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 : 271608432 : gimple_truth_valued_p (tree t, tree (*valueize)(tree) ATTRIBUTE_UNUSED)
11 : : {
12 : 271608432 : const tree type = TREE_TYPE (t);
13 : 271608432 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
14 : 271608432 : {
15 : 271608432 : tree captures[1] ATTRIBUTE_UNUSED = { t };
16 : 271608432 : if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1
17 : : )
18 : : {
19 : 36105386 : {
20 : 36105386 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 21, __FILE__, __LINE__, false);
21 : 36105386 : return true;
22 : : }
23 : : }
24 : : }
25 : 235503046 : switch (TREE_CODE (t))
26 : : {
27 : 232323627 : case SSA_NAME:
28 : 232323627 : if (gimple *_d1 = get_def (valueize, t))
29 : : {
30 : 91212962 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
31 : 105155340 : switch (gimple_assign_rhs_code (_a1))
32 : : {
33 : 2590 : case LT_EXPR:
34 : 2590 : {
35 : 2590 : tree _p0 = gimple_assign_rhs1 (_a1);
36 : 2590 : _p0 = do_valueize (valueize, _p0);
37 : 2590 : tree _p1 = gimple_assign_rhs2 (_a1);
38 : 2590 : _p1 = do_valueize (valueize, _p1);
39 : 2590 : {
40 : 2590 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
41 : 2590 : {
42 : 2590 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
43 : 2590 : return true;
44 : : }
45 : : }
46 : 214 : break;
47 : : }
48 : 214 : case LE_EXPR:
49 : 214 : {
50 : 214 : tree _p0 = gimple_assign_rhs1 (_a1);
51 : 214 : _p0 = do_valueize (valueize, _p0);
52 : 214 : tree _p1 = gimple_assign_rhs2 (_a1);
53 : 214 : _p1 = do_valueize (valueize, _p1);
54 : 214 : {
55 : 214 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
56 : 214 : {
57 : 214 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
58 : 214 : return true;
59 : : }
60 : : }
61 : 3259 : break;
62 : : }
63 : 3259 : case EQ_EXPR:
64 : 3259 : {
65 : 3259 : tree _p0 = gimple_assign_rhs1 (_a1);
66 : 3259 : _p0 = do_valueize (valueize, _p0);
67 : 3259 : tree _p1 = gimple_assign_rhs2 (_a1);
68 : 3259 : _p1 = do_valueize (valueize, _p1);
69 : 3259 : if (tree_swap_operands_p (_p0, _p1))
70 : : std::swap (_p0, _p1);
71 : 3259 : {
72 : 3259 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
73 : 3259 : {
74 : 3259 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
75 : 3259 : return true;
76 : : }
77 : : }
78 : 3259 : break;
79 : : }
80 : 12021 : case NE_EXPR:
81 : 12021 : {
82 : 12021 : tree _p0 = gimple_assign_rhs1 (_a1);
83 : 12021 : _p0 = do_valueize (valueize, _p0);
84 : 12021 : tree _p1 = gimple_assign_rhs2 (_a1);
85 : 12021 : _p1 = do_valueize (valueize, _p1);
86 : 12021 : if (tree_swap_operands_p (_p0, _p1))
87 : : std::swap (_p0, _p1);
88 : 12021 : {
89 : 12021 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
90 : 12021 : {
91 : 12021 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
92 : 12021 : return true;
93 : : }
94 : : }
95 : 12021 : break;
96 : : }
97 : 549 : case GE_EXPR:
98 : 549 : {
99 : 549 : tree _p0 = gimple_assign_rhs1 (_a1);
100 : 549 : _p0 = do_valueize (valueize, _p0);
101 : 549 : tree _p1 = gimple_assign_rhs2 (_a1);
102 : 549 : _p1 = do_valueize (valueize, _p1);
103 : 549 : {
104 : 549 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
105 : 549 : {
106 : 549 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
107 : 549 : return true;
108 : : }
109 : : }
110 : 2477 : break;
111 : : }
112 : 2477 : case GT_EXPR:
113 : 2477 : {
114 : 2477 : tree _p0 = gimple_assign_rhs1 (_a1);
115 : 2477 : _p0 = do_valueize (valueize, _p0);
116 : 2477 : tree _p1 = gimple_assign_rhs2 (_a1);
117 : 2477 : _p1 = do_valueize (valueize, _p1);
118 : 2477 : {
119 : 2477 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
120 : 2477 : {
121 : 2477 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
122 : 2477 : return true;
123 : : }
124 : : }
125 : 16 : break;
126 : : }
127 : 16 : case UNORDERED_EXPR:
128 : 16 : {
129 : 16 : tree _p0 = gimple_assign_rhs1 (_a1);
130 : 16 : _p0 = do_valueize (valueize, _p0);
131 : 16 : tree _p1 = gimple_assign_rhs2 (_a1);
132 : 16 : _p1 = do_valueize (valueize, _p1);
133 : 16 : if (tree_swap_operands_p (_p0, _p1))
134 : : std::swap (_p0, _p1);
135 : 16 : {
136 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
137 : 16 : {
138 : 16 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
139 : 16 : return true;
140 : : }
141 : : }
142 : 16 : break;
143 : : }
144 : 16 : case ORDERED_EXPR:
145 : 16 : {
146 : 16 : tree _p0 = gimple_assign_rhs1 (_a1);
147 : 16 : _p0 = do_valueize (valueize, _p0);
148 : 16 : tree _p1 = gimple_assign_rhs2 (_a1);
149 : 16 : _p1 = do_valueize (valueize, _p1);
150 : 16 : if (tree_swap_operands_p (_p0, _p1))
151 : : std::swap (_p0, _p1);
152 : 16 : {
153 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
154 : 16 : {
155 : 16 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
156 : 16 : return true;
157 : : }
158 : : }
159 : 16 : break;
160 : : }
161 : 43 : case UNLT_EXPR:
162 : 43 : {
163 : 43 : tree _p0 = gimple_assign_rhs1 (_a1);
164 : 43 : _p0 = do_valueize (valueize, _p0);
165 : 43 : tree _p1 = gimple_assign_rhs2 (_a1);
166 : 43 : _p1 = do_valueize (valueize, _p1);
167 : 43 : {
168 : 43 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
169 : 43 : {
170 : 43 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
171 : 43 : return true;
172 : : }
173 : : }
174 : 43 : break;
175 : : }
176 : 43 : case UNLE_EXPR:
177 : 43 : {
178 : 43 : tree _p0 = gimple_assign_rhs1 (_a1);
179 : 43 : _p0 = do_valueize (valueize, _p0);
180 : 43 : tree _p1 = gimple_assign_rhs2 (_a1);
181 : 43 : _p1 = do_valueize (valueize, _p1);
182 : 43 : {
183 : 43 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
184 : 43 : {
185 : 43 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
186 : 43 : return true;
187 : : }
188 : : }
189 : 37 : break;
190 : : }
191 : 37 : case UNGT_EXPR:
192 : 37 : {
193 : 37 : tree _p0 = gimple_assign_rhs1 (_a1);
194 : 37 : _p0 = do_valueize (valueize, _p0);
195 : 37 : tree _p1 = gimple_assign_rhs2 (_a1);
196 : 37 : _p1 = do_valueize (valueize, _p1);
197 : 37 : {
198 : 37 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
199 : 37 : {
200 : 37 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
201 : 37 : return true;
202 : : }
203 : : }
204 : 37 : break;
205 : : }
206 : 37 : case UNGE_EXPR:
207 : 37 : {
208 : 37 : tree _p0 = gimple_assign_rhs1 (_a1);
209 : 37 : _p0 = do_valueize (valueize, _p0);
210 : 37 : tree _p1 = gimple_assign_rhs2 (_a1);
211 : 37 : _p1 = do_valueize (valueize, _p1);
212 : 37 : {
213 : 37 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
214 : 37 : {
215 : 37 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
216 : 37 : return true;
217 : : }
218 : : }
219 : 40 : break;
220 : : }
221 : 40 : case UNEQ_EXPR:
222 : 40 : {
223 : 40 : tree _p0 = gimple_assign_rhs1 (_a1);
224 : 40 : _p0 = do_valueize (valueize, _p0);
225 : 40 : tree _p1 = gimple_assign_rhs2 (_a1);
226 : 40 : _p1 = do_valueize (valueize, _p1);
227 : 40 : if (tree_swap_operands_p (_p0, _p1))
228 : : std::swap (_p0, _p1);
229 : 40 : {
230 : 40 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
231 : 40 : {
232 : 40 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
233 : 40 : return true;
234 : : }
235 : : }
236 : 40 : break;
237 : : }
238 : 0 : case LTGT_EXPR:
239 : 0 : {
240 : 0 : tree _p0 = gimple_assign_rhs1 (_a1);
241 : 0 : _p0 = do_valueize (valueize, _p0);
242 : 0 : tree _p1 = gimple_assign_rhs2 (_a1);
243 : 0 : _p1 = do_valueize (valueize, _p1);
244 : 0 : if (tree_swap_operands_p (_p0, _p1))
245 : : std::swap (_p0, _p1);
246 : 0 : {
247 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
248 : 0 : {
249 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
250 : 0 : return true;
251 : : }
252 : : }
253 : 0 : break;
254 : : }
255 : 0 : case TRUTH_AND_EXPR:
256 : 0 : {
257 : 0 : tree _p0 = gimple_assign_rhs1 (_a1);
258 : 0 : _p0 = do_valueize (valueize, _p0);
259 : 0 : tree _p1 = gimple_assign_rhs2 (_a1);
260 : 0 : _p1 = do_valueize (valueize, _p1);
261 : 0 : if (tree_swap_operands_p (_p0, _p1))
262 : : std::swap (_p0, _p1);
263 : 0 : {
264 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
265 : 0 : {
266 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
267 : 0 : return true;
268 : : }
269 : : }
270 : 0 : break;
271 : : }
272 : 0 : case TRUTH_ANDIF_EXPR:
273 : 0 : {
274 : 0 : tree _p0 = gimple_assign_rhs1 (_a1);
275 : 0 : _p0 = do_valueize (valueize, _p0);
276 : 0 : tree _p1 = gimple_assign_rhs2 (_a1);
277 : 0 : _p1 = do_valueize (valueize, _p1);
278 : 0 : {
279 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
280 : 0 : {
281 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
282 : 0 : return true;
283 : : }
284 : : }
285 : 0 : break;
286 : : }
287 : 0 : case TRUTH_OR_EXPR:
288 : 0 : {
289 : 0 : tree _p0 = gimple_assign_rhs1 (_a1);
290 : 0 : _p0 = do_valueize (valueize, _p0);
291 : 0 : tree _p1 = gimple_assign_rhs2 (_a1);
292 : 0 : _p1 = do_valueize (valueize, _p1);
293 : 0 : if (tree_swap_operands_p (_p0, _p1))
294 : : std::swap (_p0, _p1);
295 : 0 : {
296 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
297 : 0 : {
298 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
299 : 0 : return true;
300 : : }
301 : : }
302 : 0 : break;
303 : : }
304 : 0 : case TRUTH_ORIF_EXPR:
305 : 0 : {
306 : 0 : tree _p0 = gimple_assign_rhs1 (_a1);
307 : 0 : _p0 = do_valueize (valueize, _p0);
308 : 0 : tree _p1 = gimple_assign_rhs2 (_a1);
309 : 0 : _p1 = do_valueize (valueize, _p1);
310 : 0 : {
311 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
312 : 0 : {
313 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
314 : 0 : return true;
315 : : }
316 : : }
317 : 0 : break;
318 : : }
319 : 0 : case TRUTH_XOR_EXPR:
320 : 0 : {
321 : 0 : tree _p0 = gimple_assign_rhs1 (_a1);
322 : 0 : _p0 = do_valueize (valueize, _p0);
323 : 0 : tree _p1 = gimple_assign_rhs2 (_a1);
324 : 0 : _p1 = do_valueize (valueize, _p1);
325 : 0 : if (tree_swap_operands_p (_p0, _p1))
326 : : std::swap (_p0, _p1);
327 : 0 : {
328 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
329 : 0 : {
330 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 22, __FILE__, __LINE__, false);
331 : 0 : return true;
332 : : }
333 : : }
334 : 0 : break;
335 : : }
336 : 0 : case TRUTH_NOT_EXPR:
337 : 0 : {
338 : 0 : tree _p0 = gimple_assign_rhs1 (_a1);
339 : 0 : _p0 = do_valueize (valueize, _p0);
340 : 0 : {
341 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
342 : 0 : {
343 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 23, __FILE__, __LINE__, false);
344 : 0 : return true;
345 : : }
346 : : }
347 : : break;
348 : : }
349 : : default:;
350 : : }
351 : : }
352 : : break;
353 : : default:;
354 : : }
355 : : return false;
356 : : }
357 : :
358 : : bool
359 : 5940099 : gimple_unsigned_integer_sat_mul (tree t, tree *res_ops, tree (*valueize)(tree) ATTRIBUTE_UNUSED)
360 : : {
361 : 5940099 : const tree type = TREE_TYPE (t);
362 : 5940099 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
363 : 5940099 : switch (TREE_CODE (t))
364 : : {
365 : 5940099 : case SSA_NAME:
366 : 5940099 : if (gimple *_d1 = get_def (valueize, t))
367 : : {
368 : 5940099 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
369 : 2616681 : switch (gimple_assign_rhs_code (_a1))
370 : : {
371 : 2426559 : CASE_CONVERT:
372 : 2426559 : {
373 : 2426559 : tree _p0 = gimple_assign_rhs1 (_a1);
374 : 2426559 : _p0 = do_valueize (valueize, _p0);
375 : 2426559 : switch (TREE_CODE (_p0))
376 : : {
377 : 2224405 : case SSA_NAME:
378 : 2224405 : if (gimple *_d2 = get_def (valueize, _p0))
379 : : {
380 : 2224405 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
381 : 2074862 : switch (gimple_assign_rhs_code (_a2))
382 : : {
383 : 9519 : case MIN_EXPR:
384 : 9519 : {
385 : 9519 : tree _q20 = gimple_assign_rhs1 (_a2);
386 : 9519 : _q20 = do_valueize (valueize, _q20);
387 : 9519 : tree _q21 = gimple_assign_rhs2 (_a2);
388 : 9519 : _q21 = do_valueize (valueize, _q21);
389 : 9519 : if (tree_swap_operands_p (_q20, _q21))
390 : 0 : std::swap (_q20, _q21);
391 : 9519 : {
392 : 9519 : tree _q20_pops[2];
393 : 9519 : if (gimple_usmul_widen_mult (_q20, _q20_pops, valueize))
394 : : {
395 : 0 : tree _q30 = _q20_pops[0];
396 : 0 : tree _q31 = _q20_pops[1];
397 : 0 : switch (TREE_CODE (_q21))
398 : : {
399 : 0 : case INTEGER_CST:
400 : 0 : {
401 : 0 : {
402 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q20, _q21 };
403 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
404 : : )
405 : : {
406 : 0 : if (types_match (type, captures[0], captures[1])
407 : : )
408 : : {
409 : 0 : {
410 : 0 : unsigned prec = TYPE_PRECISION (type);
411 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
412 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
413 : 0 : bool c2_is_max_p = wi::eq_p (wi::to_wide (captures[3]), max);
414 : 0 : if (c2_is_max_p
415 : : )
416 : : {
417 : 0 : {
418 : 0 : res_ops[0] = captures[0];
419 : 0 : res_ops[1] = captures[1];
420 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 89, __FILE__, __LINE__, false);
421 : 0 : return true;
422 : : }
423 : : }
424 : 0 : }
425 : : }
426 : : }
427 : : }
428 : 0 : break;
429 : : }
430 : : default:;
431 : : }
432 : : }
433 : : }
434 : 9519 : break;
435 : : }
436 : 337 : case COND_EXPR:
437 : 337 : {
438 : 337 : tree _q20 = gimple_assign_rhs1 (_a2);
439 : 337 : _q20 = do_valueize (valueize, _q20);
440 : 337 : tree _q21 = gimple_assign_rhs2 (_a2);
441 : 337 : _q21 = do_valueize (valueize, _q21);
442 : 337 : tree _q22 = gimple_assign_rhs3 (_a2);
443 : 337 : _q22 = do_valueize (valueize, _q22);
444 : 337 : switch (TREE_CODE (_q20))
445 : : {
446 : 337 : case SSA_NAME:
447 : 337 : if (gimple *_d3 = get_def (valueize, _q20))
448 : : {
449 : 337 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
450 : 348 : switch (gimple_assign_rhs_code (_a3))
451 : : {
452 : 11 : case EQ_EXPR:
453 : 11 : {
454 : 11 : tree _q30 = gimple_assign_rhs1 (_a3);
455 : 11 : _q30 = do_valueize (valueize, _q30);
456 : 11 : tree _q31 = gimple_assign_rhs2 (_a3);
457 : 11 : _q31 = do_valueize (valueize, _q31);
458 : 11 : if (tree_swap_operands_p (_q30, _q31))
459 : 0 : std::swap (_q30, _q31);
460 : 11 : switch (TREE_CODE (_q30))
461 : : {
462 : 11 : case SSA_NAME:
463 : 11 : if (gimple *_d4 = get_def (valueize, _q30))
464 : : {
465 : 11 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
466 : 0 : switch (gimple_assign_rhs_code (_a4))
467 : : {
468 : 0 : case RSHIFT_EXPR:
469 : 0 : {
470 : 0 : tree _q40 = gimple_assign_rhs1 (_a4);
471 : 0 : _q40 = do_valueize (valueize, _q40);
472 : 0 : tree _q41 = gimple_assign_rhs2 (_a4);
473 : 0 : _q41 = do_valueize (valueize, _q41);
474 : 0 : switch (TREE_CODE (_q40))
475 : : {
476 : 0 : case SSA_NAME:
477 : 0 : if (gimple *_d5 = get_def (valueize, _q40))
478 : : {
479 : 0 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
480 : 0 : switch (gimple_assign_rhs_code (_a5))
481 : : {
482 : 0 : case MULT_EXPR:
483 : 0 : {
484 : 0 : tree _q50 = gimple_assign_rhs1 (_a5);
485 : 0 : _q50 = do_valueize (valueize, _q50);
486 : 0 : tree _q51 = gimple_assign_rhs2 (_a5);
487 : 0 : _q51 = do_valueize (valueize, _q51);
488 : 0 : if (tree_swap_operands_p (_q50, _q51))
489 : 0 : std::swap (_q50, _q51);
490 : 0 : switch (TREE_CODE (_q50))
491 : : {
492 : 0 : case SSA_NAME:
493 : 0 : if (gimple *_d6 = get_def (valueize, _q50))
494 : : {
495 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
496 : 0 : switch (gimple_assign_rhs_code (_a6))
497 : : {
498 : 0 : CASE_CONVERT:
499 : 0 : {
500 : 0 : tree _q60 = gimple_assign_rhs1 (_a6);
501 : 0 : _q60 = do_valueize (valueize, _q60);
502 : 0 : switch (TREE_CODE (_q51))
503 : : {
504 : 0 : case SSA_NAME:
505 : 0 : if (gimple *_d7 = get_def (valueize, _q51))
506 : : {
507 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
508 : 0 : switch (gimple_assign_rhs_code (_a7))
509 : : {
510 : 0 : CASE_CONVERT:
511 : 0 : {
512 : 0 : tree _q80 = gimple_assign_rhs1 (_a7);
513 : 0 : _q80 = do_valueize (valueize, _q80);
514 : 0 : switch (TREE_CODE (_q41))
515 : : {
516 : 0 : case INTEGER_CST:
517 : 0 : {
518 : 0 : if (integer_zerop (_q31))
519 : : {
520 : 0 : if ((_q21 == _q40 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q40, 0) && types_match (_q21, _q40)))
521 : : {
522 : 0 : switch (TREE_CODE (_q22))
523 : : {
524 : 0 : case INTEGER_CST:
525 : 0 : {
526 : 0 : {
527 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q60, _q80, _q40, _q41, _q22 };
528 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
529 : : )
530 : : {
531 : 0 : if (types_match (type, captures[0], captures[1])
532 : : )
533 : : {
534 : 0 : {
535 : 0 : unsigned prec = TYPE_PRECISION (type);
536 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
537 : 0 : wide_int c4 = wi::to_wide (captures[4]);
538 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
539 : 0 : bool c4_is_max_p = wi::eq_p (c4, max);
540 : 0 : unsigned c2 = tree_to_uhwi (captures[3]);
541 : 0 : bool c2_is_type_precision_p = c2 == prec;
542 : 0 : if (widen_prec > prec && c2_is_type_precision_p && c4_is_max_p
543 : : )
544 : : {
545 : 0 : {
546 : 0 : res_ops[0] = captures[0];
547 : 0 : res_ops[1] = captures[1];
548 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 90, __FILE__, __LINE__, false);
549 : 0 : return true;
550 : : }
551 : : }
552 : 0 : }
553 : : }
554 : : }
555 : : }
556 : 0 : {
557 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q80, _q60, _q40, _q41, _q22 };
558 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
559 : : )
560 : : {
561 : 0 : if (types_match (type, captures[0], captures[1])
562 : : )
563 : : {
564 : 0 : {
565 : 0 : unsigned prec = TYPE_PRECISION (type);
566 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
567 : 0 : wide_int c4 = wi::to_wide (captures[4]);
568 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
569 : 0 : bool c4_is_max_p = wi::eq_p (c4, max);
570 : 0 : unsigned c2 = tree_to_uhwi (captures[3]);
571 : 0 : bool c2_is_type_precision_p = c2 == prec;
572 : 0 : if (widen_prec > prec && c2_is_type_precision_p && c4_is_max_p
573 : : )
574 : : {
575 : 0 : {
576 : 0 : res_ops[0] = captures[0];
577 : 0 : res_ops[1] = captures[1];
578 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 90, __FILE__, __LINE__, false);
579 : 0 : return true;
580 : : }
581 : : }
582 : 0 : }
583 : : }
584 : : }
585 : : }
586 : 0 : break;
587 : : }
588 : : default:;
589 : : }
590 : : }
591 : : }
592 : : break;
593 : : }
594 : : default:;
595 : : }
596 : : break;
597 : : }
598 : : default:;
599 : : }
600 : : }
601 : : break;
602 : : default:;
603 : : }
604 : : break;
605 : : }
606 : : default:;
607 : : }
608 : : }
609 : : break;
610 : : default:;
611 : : }
612 : 5940099 : break;
613 : : }
614 : : default:;
615 : : }
616 : : }
617 : : break;
618 : : default:;
619 : : }
620 : : break;
621 : : }
622 : : default:;
623 : : }
624 : : }
625 : : break;
626 : : default:;
627 : : }
628 : 5940099 : break;
629 : : }
630 : : default:;
631 : : }
632 : : }
633 : : break;
634 : 0 : case EQ_EXPR:
635 : 0 : {
636 : 0 : tree _q30 = TREE_OPERAND (_q20, 0);
637 : 0 : if ((TREE_CODE (_q30) == SSA_NAME
638 : 0 : || is_gimple_min_invariant (_q30)))
639 : : {
640 : 0 : _q30 = do_valueize (valueize, _q30);
641 : 0 : tree _q31 = TREE_OPERAND (_q20, 1);
642 : 0 : if ((TREE_CODE (_q31) == SSA_NAME
643 : 0 : || is_gimple_min_invariant (_q31)))
644 : : {
645 : 0 : _q31 = do_valueize (valueize, _q31);
646 : 0 : if (tree_swap_operands_p (_q30, _q31))
647 : 0 : std::swap (_q30, _q31);
648 : 0 : switch (TREE_CODE (_q30))
649 : : {
650 : 0 : case SSA_NAME:
651 : 0 : if (gimple *_d3 = get_def (valueize, _q30))
652 : : {
653 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
654 : 0 : switch (gimple_assign_rhs_code (_a3))
655 : : {
656 : 0 : case RSHIFT_EXPR:
657 : 0 : {
658 : 0 : tree _q40 = gimple_assign_rhs1 (_a3);
659 : 0 : _q40 = do_valueize (valueize, _q40);
660 : 0 : tree _q41 = gimple_assign_rhs2 (_a3);
661 : 0 : _q41 = do_valueize (valueize, _q41);
662 : 0 : switch (TREE_CODE (_q40))
663 : : {
664 : 0 : case SSA_NAME:
665 : 0 : if (gimple *_d4 = get_def (valueize, _q40))
666 : : {
667 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
668 : 0 : switch (gimple_assign_rhs_code (_a4))
669 : : {
670 : 0 : case MULT_EXPR:
671 : 0 : {
672 : 0 : tree _q50 = gimple_assign_rhs1 (_a4);
673 : 0 : _q50 = do_valueize (valueize, _q50);
674 : 0 : tree _q51 = gimple_assign_rhs2 (_a4);
675 : 0 : _q51 = do_valueize (valueize, _q51);
676 : 0 : if (tree_swap_operands_p (_q50, _q51))
677 : 0 : std::swap (_q50, _q51);
678 : 0 : switch (TREE_CODE (_q50))
679 : : {
680 : 0 : case SSA_NAME:
681 : 0 : if (gimple *_d5 = get_def (valueize, _q50))
682 : : {
683 : 0 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
684 : 0 : switch (gimple_assign_rhs_code (_a5))
685 : : {
686 : 0 : CASE_CONVERT:
687 : 0 : {
688 : 0 : tree _q60 = gimple_assign_rhs1 (_a5);
689 : 0 : _q60 = do_valueize (valueize, _q60);
690 : 0 : switch (TREE_CODE (_q51))
691 : : {
692 : 0 : case SSA_NAME:
693 : 0 : if (gimple *_d6 = get_def (valueize, _q51))
694 : : {
695 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
696 : 0 : switch (gimple_assign_rhs_code (_a6))
697 : : {
698 : 0 : CASE_CONVERT:
699 : 0 : {
700 : 0 : tree _q80 = gimple_assign_rhs1 (_a6);
701 : 0 : _q80 = do_valueize (valueize, _q80);
702 : 0 : switch (TREE_CODE (_q41))
703 : : {
704 : 0 : case INTEGER_CST:
705 : 0 : {
706 : 0 : if (integer_zerop (_q31))
707 : : {
708 : 0 : if ((_q21 == _q40 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q40, 0) && types_match (_q21, _q40)))
709 : : {
710 : 0 : switch (TREE_CODE (_q22))
711 : : {
712 : 0 : case INTEGER_CST:
713 : 0 : {
714 : 0 : {
715 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q60, _q80, _q40, _q41, _q22 };
716 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
717 : : )
718 : : {
719 : 0 : if (types_match (type, captures[0], captures[1])
720 : : )
721 : : {
722 : 0 : {
723 : 0 : unsigned prec = TYPE_PRECISION (type);
724 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
725 : 0 : wide_int c4 = wi::to_wide (captures[4]);
726 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
727 : 0 : bool c4_is_max_p = wi::eq_p (c4, max);
728 : 0 : unsigned c2 = tree_to_uhwi (captures[3]);
729 : 0 : bool c2_is_type_precision_p = c2 == prec;
730 : 0 : if (widen_prec > prec && c2_is_type_precision_p && c4_is_max_p
731 : : )
732 : : {
733 : 0 : {
734 : 0 : res_ops[0] = captures[0];
735 : 0 : res_ops[1] = captures[1];
736 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 90, __FILE__, __LINE__, false);
737 : 0 : return true;
738 : : }
739 : : }
740 : 0 : }
741 : : }
742 : : }
743 : : }
744 : 0 : {
745 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q80, _q60, _q40, _q41, _q22 };
746 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
747 : : )
748 : : {
749 : 0 : if (types_match (type, captures[0], captures[1])
750 : : )
751 : : {
752 : 0 : {
753 : 0 : unsigned prec = TYPE_PRECISION (type);
754 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
755 : 0 : wide_int c4 = wi::to_wide (captures[4]);
756 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
757 : 0 : bool c4_is_max_p = wi::eq_p (c4, max);
758 : 0 : unsigned c2 = tree_to_uhwi (captures[3]);
759 : 0 : bool c2_is_type_precision_p = c2 == prec;
760 : 0 : if (widen_prec > prec && c2_is_type_precision_p && c4_is_max_p
761 : : )
762 : : {
763 : 0 : {
764 : 0 : res_ops[0] = captures[0];
765 : 0 : res_ops[1] = captures[1];
766 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 90, __FILE__, __LINE__, false);
767 : 0 : return true;
768 : : }
769 : : }
770 : 0 : }
771 : : }
772 : : }
773 : : }
774 : 0 : break;
775 : : }
776 : : default:;
777 : : }
778 : : }
779 : : }
780 : : break;
781 : : }
782 : : default:;
783 : : }
784 : : break;
785 : : }
786 : : default:;
787 : : }
788 : : }
789 : : break;
790 : : default:;
791 : : }
792 : : break;
793 : : }
794 : : default:;
795 : : }
796 : : }
797 : : break;
798 : : default:;
799 : : }
800 : 5940099 : break;
801 : : }
802 : : default:;
803 : : }
804 : : }
805 : : break;
806 : : default:;
807 : : }
808 : : break;
809 : : }
810 : : default:;
811 : : }
812 : : }
813 : : break;
814 : : default:;
815 : : }
816 : : }
817 : : }
818 : 5940099 : break;
819 : : }
820 : : default:;
821 : : }
822 : : break;
823 : : }
824 : 5618 : case BIT_IOR_EXPR:
825 : 5618 : {
826 : 5618 : tree _q20 = gimple_assign_rhs1 (_a2);
827 : 5618 : _q20 = do_valueize (valueize, _q20);
828 : 5618 : tree _q21 = gimple_assign_rhs2 (_a2);
829 : 5618 : _q21 = do_valueize (valueize, _q21);
830 : 5618 : if (tree_swap_operands_p (_q20, _q21))
831 : 0 : std::swap (_q20, _q21);
832 : 5618 : switch (TREE_CODE (_q20))
833 : : {
834 : 5618 : case SSA_NAME:
835 : 5618 : if (gimple *_d3 = get_def (valueize, _q20))
836 : : {
837 : 5618 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
838 : 5582 : switch (gimple_assign_rhs_code (_a3))
839 : : {
840 : 1444 : CASE_CONVERT:
841 : 1444 : {
842 : 1444 : tree _q30 = gimple_assign_rhs1 (_a3);
843 : 1444 : _q30 = do_valueize (valueize, _q30);
844 : 1444 : switch (TREE_CODE (_q30))
845 : : {
846 : 1442 : case SSA_NAME:
847 : 1442 : if (gimple *_d4 = get_def (valueize, _q30))
848 : : {
849 : 1442 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
850 : 1528 : switch (gimple_assign_rhs_code (_a4))
851 : : {
852 : 0 : case NEGATE_EXPR:
853 : 0 : {
854 : 0 : tree _q40 = gimple_assign_rhs1 (_a4);
855 : 0 : _q40 = do_valueize (valueize, _q40);
856 : 0 : switch (TREE_CODE (_q40))
857 : : {
858 : 0 : case SSA_NAME:
859 : 0 : if (gimple *_d5 = get_def (valueize, _q40))
860 : : {
861 : 0 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
862 : 0 : switch (gimple_assign_rhs_code (_a5))
863 : : {
864 : 0 : CASE_CONVERT:
865 : 0 : {
866 : 0 : tree _q50 = gimple_assign_rhs1 (_a5);
867 : 0 : _q50 = do_valueize (valueize, _q50);
868 : 0 : switch (TREE_CODE (_q50))
869 : : {
870 : 0 : case SSA_NAME:
871 : 0 : if (gimple *_d6 = get_def (valueize, _q50))
872 : : {
873 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
874 : 0 : switch (gimple_assign_rhs_code (_a6))
875 : : {
876 : 0 : case NE_EXPR:
877 : 0 : {
878 : 0 : tree _q60 = gimple_assign_rhs1 (_a6);
879 : 0 : _q60 = do_valueize (valueize, _q60);
880 : 0 : tree _q61 = gimple_assign_rhs2 (_a6);
881 : 0 : _q61 = do_valueize (valueize, _q61);
882 : 0 : if (tree_swap_operands_p (_q60, _q61))
883 : 0 : std::swap (_q60, _q61);
884 : 0 : switch (TREE_CODE (_q60))
885 : : {
886 : 0 : case SSA_NAME:
887 : 0 : if (gimple *_d7 = get_def (valueize, _q60))
888 : : {
889 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
890 : 0 : switch (gimple_assign_rhs_code (_a7))
891 : : {
892 : 0 : CASE_CONVERT:
893 : 0 : {
894 : 0 : tree _q70 = gimple_assign_rhs1 (_a7);
895 : 0 : _q70 = do_valueize (valueize, _q70);
896 : 0 : switch (TREE_CODE (_q70))
897 : : {
898 : 0 : case SSA_NAME:
899 : 0 : if (gimple *_d8 = get_def (valueize, _q70))
900 : : {
901 : 0 : if (gassign *_a8 = dyn_cast <gassign *> (_d8))
902 : 0 : switch (gimple_assign_rhs_code (_a8))
903 : : {
904 : 0 : case RSHIFT_EXPR:
905 : 0 : {
906 : 0 : tree _q80 = gimple_assign_rhs1 (_a8);
907 : 0 : _q80 = do_valueize (valueize, _q80);
908 : 0 : tree _q81 = gimple_assign_rhs2 (_a8);
909 : 0 : _q81 = do_valueize (valueize, _q81);
910 : 0 : switch (TREE_CODE (_q81))
911 : : {
912 : 0 : case INTEGER_CST:
913 : 0 : {
914 : 0 : if (integer_zerop (_q61))
915 : : {
916 : 0 : switch (TREE_CODE (_q21))
917 : : {
918 : 0 : case SSA_NAME:
919 : 0 : if (gimple *_d9 = get_def (valueize, _q21))
920 : : {
921 : 0 : if (gassign *_a9 = dyn_cast <gassign *> (_d9))
922 : 0 : switch (gimple_assign_rhs_code (_a9))
923 : : {
924 : 0 : CASE_CONVERT:
925 : 0 : {
926 : 0 : tree _q120 = gimple_assign_rhs1 (_a9);
927 : 0 : _q120 = do_valueize (valueize, _q120);
928 : 0 : if ((_q120 == _q80 && ! TREE_SIDE_EFFECTS (_q120)) || (operand_equal_p (_q120, _q80, 0) && types_match (_q120, _q80)))
929 : : {
930 : 0 : {
931 : 0 : tree _q120_pops[2];
932 : 0 : if (gimple_usmul_widen_mult (_q120, _q120_pops, valueize))
933 : : {
934 : 0 : tree _q140 = _q120_pops[0];
935 : 0 : tree _q141 = _q120_pops[1];
936 : 0 : {
937 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q140, _q141, _q80, _q81 };
938 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
939 : : )
940 : : {
941 : 0 : if (types_match (type, captures[0], captures[1])
942 : : )
943 : : {
944 : 0 : {
945 : 0 : unsigned prec = TYPE_PRECISION (type);
946 : 0 : bool c2_is_type_precision_p = tree_to_uhwi (captures[3]) == prec;
947 : 0 : if (c2_is_type_precision_p
948 : : )
949 : : {
950 : 0 : {
951 : 0 : res_ops[0] = captures[0];
952 : 0 : res_ops[1] = captures[1];
953 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 91, __FILE__, __LINE__, false);
954 : 0 : return true;
955 : : }
956 : : }
957 : : }
958 : : }
959 : : }
960 : : }
961 : : }
962 : : }
963 : : }
964 : : break;
965 : : }
966 : : default:;
967 : : }
968 : : }
969 : : break;
970 : : default:;
971 : : }
972 : : }
973 : : break;
974 : : }
975 : : default:;
976 : : }
977 : : break;
978 : : }
979 : : default:;
980 : : }
981 : : }
982 : : break;
983 : : default:;
984 : : }
985 : : break;
986 : : }
987 : 0 : case RSHIFT_EXPR:
988 : 0 : {
989 : 0 : tree _q70 = gimple_assign_rhs1 (_a7);
990 : 0 : _q70 = do_valueize (valueize, _q70);
991 : 0 : tree _q71 = gimple_assign_rhs2 (_a7);
992 : 0 : _q71 = do_valueize (valueize, _q71);
993 : 0 : switch (TREE_CODE (_q71))
994 : : {
995 : 0 : case INTEGER_CST:
996 : 0 : {
997 : 0 : if (integer_zerop (_q61))
998 : : {
999 : 0 : switch (TREE_CODE (_q21))
1000 : : {
1001 : 0 : case SSA_NAME:
1002 : 0 : if (gimple *_d8 = get_def (valueize, _q21))
1003 : : {
1004 : 0 : if (gassign *_a8 = dyn_cast <gassign *> (_d8))
1005 : 0 : switch (gimple_assign_rhs_code (_a8))
1006 : : {
1007 : 0 : CASE_CONVERT:
1008 : 0 : {
1009 : 0 : tree _q110 = gimple_assign_rhs1 (_a8);
1010 : 0 : _q110 = do_valueize (valueize, _q110);
1011 : 0 : if ((_q110 == _q70 && ! TREE_SIDE_EFFECTS (_q110)) || (operand_equal_p (_q110, _q70, 0) && types_match (_q110, _q70)))
1012 : : {
1013 : 0 : {
1014 : 0 : tree _q110_pops[2];
1015 : 0 : if (gimple_usmul_widen_mult (_q110, _q110_pops, valueize))
1016 : : {
1017 : 0 : tree _q130 = _q110_pops[0];
1018 : 0 : tree _q131 = _q110_pops[1];
1019 : 0 : {
1020 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q130, _q131, _q70, _q71 };
1021 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1022 : : )
1023 : : {
1024 : 0 : if (types_match (type, captures[0], captures[1])
1025 : : )
1026 : : {
1027 : 0 : {
1028 : 0 : unsigned prec = TYPE_PRECISION (type);
1029 : 0 : bool c2_is_type_precision_p = tree_to_uhwi (captures[3]) == prec;
1030 : 0 : if (c2_is_type_precision_p
1031 : : )
1032 : : {
1033 : 0 : {
1034 : 0 : res_ops[0] = captures[0];
1035 : 0 : res_ops[1] = captures[1];
1036 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 91, __FILE__, __LINE__, false);
1037 : 0 : return true;
1038 : : }
1039 : : }
1040 : : }
1041 : : }
1042 : : }
1043 : : }
1044 : : }
1045 : : }
1046 : : }
1047 : : break;
1048 : : }
1049 : : default:;
1050 : : }
1051 : : }
1052 : : break;
1053 : : default:;
1054 : : }
1055 : : }
1056 : : break;
1057 : : }
1058 : : default:;
1059 : : }
1060 : : break;
1061 : : }
1062 : : default:;
1063 : : }
1064 : : }
1065 : : break;
1066 : : default:;
1067 : : }
1068 : 5940099 : break;
1069 : : }
1070 : : default:;
1071 : : }
1072 : : }
1073 : : break;
1074 : : default:;
1075 : : }
1076 : : break;
1077 : : }
1078 : : default:;
1079 : : }
1080 : : }
1081 : : break;
1082 : : default:;
1083 : : }
1084 : : break;
1085 : : }
1086 : : default:;
1087 : : }
1088 : : }
1089 : : break;
1090 : : default:;
1091 : : }
1092 : : break;
1093 : : }
1094 : 18 : case NEGATE_EXPR:
1095 : 18 : {
1096 : 18 : tree _q30 = gimple_assign_rhs1 (_a3);
1097 : 18 : _q30 = do_valueize (valueize, _q30);
1098 : 18 : switch (TREE_CODE (_q30))
1099 : : {
1100 : 18 : case SSA_NAME:
1101 : 18 : if (gimple *_d4 = get_def (valueize, _q30))
1102 : : {
1103 : 18 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
1104 : 18 : switch (gimple_assign_rhs_code (_a4))
1105 : : {
1106 : 8 : CASE_CONVERT:
1107 : 8 : {
1108 : 8 : tree _q40 = gimple_assign_rhs1 (_a4);
1109 : 8 : _q40 = do_valueize (valueize, _q40);
1110 : 8 : switch (TREE_CODE (_q40))
1111 : : {
1112 : 8 : case SSA_NAME:
1113 : 8 : if (gimple *_d5 = get_def (valueize, _q40))
1114 : : {
1115 : 8 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
1116 : 10 : switch (gimple_assign_rhs_code (_a5))
1117 : : {
1118 : 0 : case NE_EXPR:
1119 : 0 : {
1120 : 0 : tree _q50 = gimple_assign_rhs1 (_a5);
1121 : 0 : _q50 = do_valueize (valueize, _q50);
1122 : 0 : tree _q51 = gimple_assign_rhs2 (_a5);
1123 : 0 : _q51 = do_valueize (valueize, _q51);
1124 : 0 : if (tree_swap_operands_p (_q50, _q51))
1125 : 0 : std::swap (_q50, _q51);
1126 : 0 : switch (TREE_CODE (_q50))
1127 : : {
1128 : 0 : case SSA_NAME:
1129 : 0 : if (gimple *_d6 = get_def (valueize, _q50))
1130 : : {
1131 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
1132 : 0 : switch (gimple_assign_rhs_code (_a6))
1133 : : {
1134 : 0 : CASE_CONVERT:
1135 : 0 : {
1136 : 0 : tree _q60 = gimple_assign_rhs1 (_a6);
1137 : 0 : _q60 = do_valueize (valueize, _q60);
1138 : 0 : switch (TREE_CODE (_q60))
1139 : : {
1140 : 0 : case SSA_NAME:
1141 : 0 : if (gimple *_d7 = get_def (valueize, _q60))
1142 : : {
1143 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
1144 : 0 : switch (gimple_assign_rhs_code (_a7))
1145 : : {
1146 : 0 : case RSHIFT_EXPR:
1147 : 0 : {
1148 : 0 : tree _q70 = gimple_assign_rhs1 (_a7);
1149 : 0 : _q70 = do_valueize (valueize, _q70);
1150 : 0 : tree _q71 = gimple_assign_rhs2 (_a7);
1151 : 0 : _q71 = do_valueize (valueize, _q71);
1152 : 0 : switch (TREE_CODE (_q71))
1153 : : {
1154 : 0 : case INTEGER_CST:
1155 : 0 : {
1156 : 0 : if (integer_zerop (_q51))
1157 : : {
1158 : 0 : switch (TREE_CODE (_q21))
1159 : : {
1160 : 0 : case SSA_NAME:
1161 : 0 : if (gimple *_d8 = get_def (valueize, _q21))
1162 : : {
1163 : 0 : if (gassign *_a8 = dyn_cast <gassign *> (_d8))
1164 : 0 : switch (gimple_assign_rhs_code (_a8))
1165 : : {
1166 : 0 : CASE_CONVERT:
1167 : 0 : {
1168 : 0 : tree _q110 = gimple_assign_rhs1 (_a8);
1169 : 0 : _q110 = do_valueize (valueize, _q110);
1170 : 0 : if ((_q110 == _q70 && ! TREE_SIDE_EFFECTS (_q110)) || (operand_equal_p (_q110, _q70, 0) && types_match (_q110, _q70)))
1171 : : {
1172 : 0 : {
1173 : 0 : tree _q110_pops[2];
1174 : 0 : if (gimple_usmul_widen_mult (_q110, _q110_pops, valueize))
1175 : : {
1176 : 0 : tree _q130 = _q110_pops[0];
1177 : 0 : tree _q131 = _q110_pops[1];
1178 : 0 : {
1179 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q130, _q131, _q70, _q71 };
1180 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1181 : : )
1182 : : {
1183 : 0 : if (types_match (type, captures[0], captures[1])
1184 : : )
1185 : : {
1186 : 0 : {
1187 : 0 : unsigned prec = TYPE_PRECISION (type);
1188 : 0 : bool c2_is_type_precision_p = tree_to_uhwi (captures[3]) == prec;
1189 : 0 : if (c2_is_type_precision_p
1190 : : )
1191 : : {
1192 : 0 : {
1193 : 0 : res_ops[0] = captures[0];
1194 : 0 : res_ops[1] = captures[1];
1195 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 91, __FILE__, __LINE__, false);
1196 : 0 : return true;
1197 : : }
1198 : : }
1199 : : }
1200 : : }
1201 : : }
1202 : : }
1203 : : }
1204 : : }
1205 : : }
1206 : : break;
1207 : : }
1208 : : default:;
1209 : : }
1210 : : }
1211 : : break;
1212 : : default:;
1213 : : }
1214 : : }
1215 : : break;
1216 : : }
1217 : : default:;
1218 : : }
1219 : : break;
1220 : : }
1221 : : default:;
1222 : : }
1223 : : }
1224 : : break;
1225 : : default:;
1226 : : }
1227 : : break;
1228 : : }
1229 : 0 : case RSHIFT_EXPR:
1230 : 0 : {
1231 : 0 : tree _q60 = gimple_assign_rhs1 (_a6);
1232 : 0 : _q60 = do_valueize (valueize, _q60);
1233 : 0 : tree _q61 = gimple_assign_rhs2 (_a6);
1234 : 0 : _q61 = do_valueize (valueize, _q61);
1235 : 0 : switch (TREE_CODE (_q61))
1236 : : {
1237 : 0 : case INTEGER_CST:
1238 : 0 : {
1239 : 0 : if (integer_zerop (_q51))
1240 : : {
1241 : 0 : switch (TREE_CODE (_q21))
1242 : : {
1243 : 0 : case SSA_NAME:
1244 : 0 : if (gimple *_d7 = get_def (valueize, _q21))
1245 : : {
1246 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
1247 : 0 : switch (gimple_assign_rhs_code (_a7))
1248 : : {
1249 : 0 : CASE_CONVERT:
1250 : 0 : {
1251 : 0 : tree _q100 = gimple_assign_rhs1 (_a7);
1252 : 0 : _q100 = do_valueize (valueize, _q100);
1253 : 0 : if ((_q100 == _q60 && ! TREE_SIDE_EFFECTS (_q100)) || (operand_equal_p (_q100, _q60, 0) && types_match (_q100, _q60)))
1254 : : {
1255 : 0 : {
1256 : 0 : tree _q100_pops[2];
1257 : 0 : if (gimple_usmul_widen_mult (_q100, _q100_pops, valueize))
1258 : : {
1259 : 0 : tree _q120 = _q100_pops[0];
1260 : 0 : tree _q121 = _q100_pops[1];
1261 : 0 : {
1262 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q120, _q121, _q60, _q61 };
1263 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1264 : : )
1265 : : {
1266 : 0 : if (types_match (type, captures[0], captures[1])
1267 : : )
1268 : : {
1269 : 0 : {
1270 : 0 : unsigned prec = TYPE_PRECISION (type);
1271 : 0 : bool c2_is_type_precision_p = tree_to_uhwi (captures[3]) == prec;
1272 : 0 : if (c2_is_type_precision_p
1273 : : )
1274 : : {
1275 : 0 : {
1276 : 0 : res_ops[0] = captures[0];
1277 : 0 : res_ops[1] = captures[1];
1278 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 91, __FILE__, __LINE__, false);
1279 : 0 : return true;
1280 : : }
1281 : : }
1282 : : }
1283 : : }
1284 : : }
1285 : : }
1286 : : }
1287 : : }
1288 : : }
1289 : : break;
1290 : : }
1291 : : default:;
1292 : : }
1293 : : }
1294 : : break;
1295 : : default:;
1296 : : }
1297 : : }
1298 : : break;
1299 : : }
1300 : : default:;
1301 : : }
1302 : : break;
1303 : : }
1304 : : default:;
1305 : : }
1306 : : }
1307 : : break;
1308 : : default:;
1309 : : }
1310 : 5940099 : break;
1311 : : }
1312 : : default:;
1313 : : }
1314 : : }
1315 : : break;
1316 : : default:;
1317 : : }
1318 : : break;
1319 : : }
1320 : : default:;
1321 : : }
1322 : : }
1323 : : break;
1324 : : default:;
1325 : : }
1326 : : break;
1327 : : }
1328 : : default:;
1329 : : }
1330 : : }
1331 : : break;
1332 : : default:;
1333 : : }
1334 : 5940099 : break;
1335 : : }
1336 : : default:;
1337 : : }
1338 : 784143 : else if (gphi *_a2 = dyn_cast <gphi *> (_d2))
1339 : : {
1340 : 468940 : basic_block _b2 = gimple_bb (_a2);
1341 : 468940 : tree _q21, _q22;
1342 : 468940 : gcond *_cond_2 = match_cond_with_binary_phi (_a2, &_q21, &_q22);
1343 : 468940 : if (_cond_2)
1344 : : {
1345 : 27065 : tree _cond_lhs_2 = gimple_cond_lhs (_cond_2);
1346 : 27065 : tree _cond_rhs_2 = gimple_cond_rhs (_cond_2);
1347 : 27065 : tree _q20 = build2 (gimple_cond_code (_cond_2), boolean_type_node, _cond_lhs_2, _cond_rhs_2);
1348 : 27065 : switch (TREE_CODE (_q20))
1349 : : {
1350 : 0 : case SSA_NAME:
1351 : 0 : if (gimple *_d3 = get_def (valueize, _q20))
1352 : : {
1353 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1354 : 0 : switch (gimple_assign_rhs_code (_a3))
1355 : : {
1356 : 0 : case EQ_EXPR:
1357 : 0 : {
1358 : 0 : tree _q30 = gimple_assign_rhs1 (_a3);
1359 : 0 : _q30 = do_valueize (valueize, _q30);
1360 : 0 : tree _q31 = gimple_assign_rhs2 (_a3);
1361 : 0 : _q31 = do_valueize (valueize, _q31);
1362 : 0 : if (tree_swap_operands_p (_q30, _q31))
1363 : 0 : std::swap (_q30, _q31);
1364 : 0 : switch (TREE_CODE (_q30))
1365 : : {
1366 : 0 : case SSA_NAME:
1367 : 0 : if (gimple *_d4 = get_def (valueize, _q30))
1368 : : {
1369 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
1370 : 0 : switch (gimple_assign_rhs_code (_a4))
1371 : : {
1372 : 0 : case RSHIFT_EXPR:
1373 : 0 : {
1374 : 0 : tree _q40 = gimple_assign_rhs1 (_a4);
1375 : 0 : _q40 = do_valueize (valueize, _q40);
1376 : 0 : tree _q41 = gimple_assign_rhs2 (_a4);
1377 : 0 : _q41 = do_valueize (valueize, _q41);
1378 : 0 : switch (TREE_CODE (_q40))
1379 : : {
1380 : 0 : case SSA_NAME:
1381 : 0 : if (gimple *_d5 = get_def (valueize, _q40))
1382 : : {
1383 : 0 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
1384 : 0 : switch (gimple_assign_rhs_code (_a5))
1385 : : {
1386 : 0 : case MULT_EXPR:
1387 : 0 : {
1388 : 0 : tree _q50 = gimple_assign_rhs1 (_a5);
1389 : 0 : _q50 = do_valueize (valueize, _q50);
1390 : 0 : tree _q51 = gimple_assign_rhs2 (_a5);
1391 : 0 : _q51 = do_valueize (valueize, _q51);
1392 : 0 : if (tree_swap_operands_p (_q50, _q51))
1393 : 0 : std::swap (_q50, _q51);
1394 : 0 : switch (TREE_CODE (_q50))
1395 : : {
1396 : 0 : case SSA_NAME:
1397 : 0 : if (gimple *_d6 = get_def (valueize, _q50))
1398 : : {
1399 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
1400 : 0 : switch (gimple_assign_rhs_code (_a6))
1401 : : {
1402 : 0 : CASE_CONVERT:
1403 : 0 : {
1404 : 0 : tree _q60 = gimple_assign_rhs1 (_a6);
1405 : 0 : _q60 = do_valueize (valueize, _q60);
1406 : 0 : switch (TREE_CODE (_q51))
1407 : : {
1408 : 0 : case SSA_NAME:
1409 : 0 : if (gimple *_d7 = get_def (valueize, _q51))
1410 : : {
1411 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
1412 : 0 : switch (gimple_assign_rhs_code (_a7))
1413 : : {
1414 : 0 : CASE_CONVERT:
1415 : 0 : {
1416 : 0 : tree _q80 = gimple_assign_rhs1 (_a7);
1417 : 0 : _q80 = do_valueize (valueize, _q80);
1418 : 0 : switch (TREE_CODE (_q41))
1419 : : {
1420 : 0 : case INTEGER_CST:
1421 : 0 : {
1422 : 0 : if (integer_zerop (_q31))
1423 : : {
1424 : 0 : if ((_q21 == _q40 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q40, 0) && types_match (_q21, _q40)))
1425 : : {
1426 : 0 : switch (TREE_CODE (_q22))
1427 : : {
1428 : 0 : case INTEGER_CST:
1429 : 0 : {
1430 : 0 : {
1431 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q60, _q80, _q40, _q41, _q22 };
1432 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1433 : : )
1434 : : {
1435 : 0 : if (types_match (type, captures[0], captures[1])
1436 : : )
1437 : : {
1438 : 0 : {
1439 : 0 : unsigned prec = TYPE_PRECISION (type);
1440 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
1441 : 0 : wide_int c4 = wi::to_wide (captures[4]);
1442 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
1443 : 0 : bool c4_is_max_p = wi::eq_p (c4, max);
1444 : 0 : unsigned c2 = tree_to_uhwi (captures[3]);
1445 : 0 : bool c2_is_type_precision_p = c2 == prec;
1446 : 0 : if (widen_prec > prec && c2_is_type_precision_p && c4_is_max_p
1447 : : )
1448 : : {
1449 : 0 : {
1450 : 0 : res_ops[0] = captures[0];
1451 : 0 : res_ops[1] = captures[1];
1452 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 90, __FILE__, __LINE__, false);
1453 : 0 : return true;
1454 : : }
1455 : : }
1456 : 0 : }
1457 : : }
1458 : : }
1459 : : }
1460 : 0 : {
1461 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q80, _q60, _q40, _q41, _q22 };
1462 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1463 : : )
1464 : : {
1465 : 0 : if (types_match (type, captures[0], captures[1])
1466 : : )
1467 : : {
1468 : 0 : {
1469 : 0 : unsigned prec = TYPE_PRECISION (type);
1470 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
1471 : 0 : wide_int c4 = wi::to_wide (captures[4]);
1472 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
1473 : 0 : bool c4_is_max_p = wi::eq_p (c4, max);
1474 : 0 : unsigned c2 = tree_to_uhwi (captures[3]);
1475 : 0 : bool c2_is_type_precision_p = c2 == prec;
1476 : 0 : if (widen_prec > prec && c2_is_type_precision_p && c4_is_max_p
1477 : : )
1478 : : {
1479 : 0 : {
1480 : 0 : res_ops[0] = captures[0];
1481 : 0 : res_ops[1] = captures[1];
1482 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 90, __FILE__, __LINE__, false);
1483 : 0 : return true;
1484 : : }
1485 : : }
1486 : 0 : }
1487 : : }
1488 : : }
1489 : : }
1490 : 0 : break;
1491 : : }
1492 : : default:;
1493 : : }
1494 : : }
1495 : : }
1496 : : break;
1497 : : }
1498 : : default:;
1499 : : }
1500 : : break;
1501 : : }
1502 : : default:;
1503 : : }
1504 : : }
1505 : : break;
1506 : : default:;
1507 : : }
1508 : : break;
1509 : : }
1510 : : default:;
1511 : : }
1512 : : }
1513 : : break;
1514 : : default:;
1515 : : }
1516 : 468940 : break;
1517 : : }
1518 : : default:;
1519 : : }
1520 : : }
1521 : : break;
1522 : : default:;
1523 : : }
1524 : : break;
1525 : : }
1526 : : default:;
1527 : : }
1528 : : }
1529 : : break;
1530 : : default:;
1531 : : }
1532 : 468940 : break;
1533 : : }
1534 : : default:;
1535 : : }
1536 : : }
1537 : : break;
1538 : 7220 : case EQ_EXPR:
1539 : 7220 : {
1540 : 7220 : tree _q30 = TREE_OPERAND (_q20, 0);
1541 : 7220 : if ((TREE_CODE (_q30) == SSA_NAME
1542 : 7220 : || is_gimple_min_invariant (_q30)))
1543 : : {
1544 : 7220 : _q30 = do_valueize (valueize, _q30);
1545 : 7220 : tree _q31 = TREE_OPERAND (_q20, 1);
1546 : 7220 : if ((TREE_CODE (_q31) == SSA_NAME
1547 : 7220 : || is_gimple_min_invariant (_q31)))
1548 : : {
1549 : 7220 : _q31 = do_valueize (valueize, _q31);
1550 : 7220 : if (tree_swap_operands_p (_q30, _q31))
1551 : 0 : std::swap (_q30, _q31);
1552 : 7220 : switch (TREE_CODE (_q30))
1553 : : {
1554 : 7220 : case SSA_NAME:
1555 : 7220 : if (gimple *_d3 = get_def (valueize, _q30))
1556 : : {
1557 : 7220 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1558 : 11740 : switch (gimple_assign_rhs_code (_a3))
1559 : : {
1560 : 14 : case RSHIFT_EXPR:
1561 : 14 : {
1562 : 14 : tree _q40 = gimple_assign_rhs1 (_a3);
1563 : 14 : _q40 = do_valueize (valueize, _q40);
1564 : 14 : tree _q41 = gimple_assign_rhs2 (_a3);
1565 : 14 : _q41 = do_valueize (valueize, _q41);
1566 : 14 : switch (TREE_CODE (_q40))
1567 : : {
1568 : 14 : case SSA_NAME:
1569 : 14 : if (gimple *_d4 = get_def (valueize, _q40))
1570 : : {
1571 : 14 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
1572 : 14 : switch (gimple_assign_rhs_code (_a4))
1573 : : {
1574 : 0 : case MULT_EXPR:
1575 : 0 : {
1576 : 0 : tree _q50 = gimple_assign_rhs1 (_a4);
1577 : 0 : _q50 = do_valueize (valueize, _q50);
1578 : 0 : tree _q51 = gimple_assign_rhs2 (_a4);
1579 : 0 : _q51 = do_valueize (valueize, _q51);
1580 : 0 : if (tree_swap_operands_p (_q50, _q51))
1581 : 0 : std::swap (_q50, _q51);
1582 : 0 : switch (TREE_CODE (_q50))
1583 : : {
1584 : 0 : case SSA_NAME:
1585 : 0 : if (gimple *_d5 = get_def (valueize, _q50))
1586 : : {
1587 : 0 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
1588 : 0 : switch (gimple_assign_rhs_code (_a5))
1589 : : {
1590 : 0 : CASE_CONVERT:
1591 : 0 : {
1592 : 0 : tree _q60 = gimple_assign_rhs1 (_a5);
1593 : 0 : _q60 = do_valueize (valueize, _q60);
1594 : 0 : switch (TREE_CODE (_q51))
1595 : : {
1596 : 0 : case SSA_NAME:
1597 : 0 : if (gimple *_d6 = get_def (valueize, _q51))
1598 : : {
1599 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
1600 : 0 : switch (gimple_assign_rhs_code (_a6))
1601 : : {
1602 : 0 : CASE_CONVERT:
1603 : 0 : {
1604 : 0 : tree _q80 = gimple_assign_rhs1 (_a6);
1605 : 0 : _q80 = do_valueize (valueize, _q80);
1606 : 0 : switch (TREE_CODE (_q41))
1607 : : {
1608 : 0 : case INTEGER_CST:
1609 : 0 : {
1610 : 0 : if (integer_zerop (_q31))
1611 : : {
1612 : 0 : if ((_q21 == _q40 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q40, 0) && types_match (_q21, _q40)))
1613 : : {
1614 : 0 : switch (TREE_CODE (_q22))
1615 : : {
1616 : 0 : case INTEGER_CST:
1617 : 0 : {
1618 : 0 : {
1619 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q60, _q80, _q40, _q41, _q22 };
1620 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1621 : : )
1622 : : {
1623 : 0 : if (types_match (type, captures[0], captures[1])
1624 : : )
1625 : : {
1626 : 0 : {
1627 : 0 : unsigned prec = TYPE_PRECISION (type);
1628 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
1629 : 0 : wide_int c4 = wi::to_wide (captures[4]);
1630 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
1631 : 0 : bool c4_is_max_p = wi::eq_p (c4, max);
1632 : 0 : unsigned c2 = tree_to_uhwi (captures[3]);
1633 : 0 : bool c2_is_type_precision_p = c2 == prec;
1634 : 0 : if (widen_prec > prec && c2_is_type_precision_p && c4_is_max_p
1635 : : )
1636 : : {
1637 : 0 : {
1638 : 0 : res_ops[0] = captures[0];
1639 : 0 : res_ops[1] = captures[1];
1640 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 90, __FILE__, __LINE__, false);
1641 : 0 : return true;
1642 : : }
1643 : : }
1644 : 0 : }
1645 : : }
1646 : : }
1647 : : }
1648 : 0 : {
1649 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q80, _q60, _q40, _q41, _q22 };
1650 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1651 : : )
1652 : : {
1653 : 0 : if (types_match (type, captures[0], captures[1])
1654 : : )
1655 : : {
1656 : 0 : {
1657 : 0 : unsigned prec = TYPE_PRECISION (type);
1658 : 0 : unsigned widen_prec = TYPE_PRECISION (TREE_TYPE (captures[2]));
1659 : 0 : wide_int c4 = wi::to_wide (captures[4]);
1660 : 0 : wide_int max = wi::mask (prec, false, widen_prec);
1661 : 0 : bool c4_is_max_p = wi::eq_p (c4, max);
1662 : 0 : unsigned c2 = tree_to_uhwi (captures[3]);
1663 : 0 : bool c2_is_type_precision_p = c2 == prec;
1664 : 0 : if (widen_prec > prec && c2_is_type_precision_p && c4_is_max_p
1665 : : )
1666 : : {
1667 : 0 : {
1668 : 0 : res_ops[0] = captures[0];
1669 : 0 : res_ops[1] = captures[1];
1670 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 90, __FILE__, __LINE__, false);
1671 : 0 : return true;
1672 : : }
1673 : : }
1674 : 0 : }
1675 : : }
1676 : : }
1677 : : }
1678 : 0 : break;
1679 : : }
1680 : : default:;
1681 : : }
1682 : : }
1683 : : }
1684 : : break;
1685 : : }
1686 : : default:;
1687 : : }
1688 : : break;
1689 : : }
1690 : : default:;
1691 : : }
1692 : : }
1693 : : break;
1694 : : default:;
1695 : : }
1696 : : break;
1697 : : }
1698 : : default:;
1699 : : }
1700 : : }
1701 : : break;
1702 : : default:;
1703 : : }
1704 : 468940 : break;
1705 : : }
1706 : : default:;
1707 : : }
1708 : : }
1709 : : break;
1710 : : default:;
1711 : : }
1712 : : break;
1713 : : }
1714 : : default:;
1715 : : }
1716 : : }
1717 : : break;
1718 : : default:;
1719 : : }
1720 : : }
1721 : : }
1722 : 468940 : break;
1723 : : }
1724 : : default:;
1725 : : }
1726 : : }
1727 : : }
1728 : : }
1729 : : break;
1730 : : default:;
1731 : : }
1732 : : break;
1733 : : }
1734 : 0 : case COND_EXPR:
1735 : 0 : {
1736 : 0 : tree _p0 = gimple_assign_rhs1 (_a1);
1737 : 0 : _p0 = do_valueize (valueize, _p0);
1738 : 0 : tree _p1 = gimple_assign_rhs2 (_a1);
1739 : 0 : _p1 = do_valueize (valueize, _p1);
1740 : 0 : tree _p2 = gimple_assign_rhs3 (_a1);
1741 : 0 : _p2 = do_valueize (valueize, _p2);
1742 : 0 : switch (TREE_CODE (_p0))
1743 : : {
1744 : 0 : case SSA_NAME:
1745 : 0 : if (gimple *_d2 = get_def (valueize, _p0))
1746 : : {
1747 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
1748 : 0 : switch (gimple_assign_rhs_code (_a2))
1749 : : {
1750 : 0 : case NE_EXPR:
1751 : 0 : {
1752 : 0 : tree _q20 = gimple_assign_rhs1 (_a2);
1753 : 0 : _q20 = do_valueize (valueize, _q20);
1754 : 0 : tree _q21 = gimple_assign_rhs2 (_a2);
1755 : 0 : _q21 = do_valueize (valueize, _q21);
1756 : 0 : if (tree_swap_operands_p (_q20, _q21))
1757 : 0 : std::swap (_q20, _q21);
1758 : 0 : switch (TREE_CODE (_q20))
1759 : : {
1760 : 0 : case SSA_NAME:
1761 : 0 : if (gimple *_d3 = get_def (valueize, _q20))
1762 : : {
1763 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
1764 : 0 : switch (gimple_assign_rhs_code (_a3))
1765 : : {
1766 : 0 : case IMAGPART_EXPR:
1767 : 0 : {
1768 : 0 : tree _q30 = TREE_OPERAND (gimple_assign_rhs1 (_a3), 0);
1769 : 0 : if ((TREE_CODE (_q30) == SSA_NAME
1770 : 0 : || is_gimple_min_invariant (_q30)))
1771 : : {
1772 : 0 : _q30 = do_valueize (valueize, _q30);
1773 : 0 : switch (TREE_CODE (_q30))
1774 : : {
1775 : 0 : case SSA_NAME:
1776 : 0 : if (gimple *_d4 = get_def (valueize, _q30))
1777 : : {
1778 : 0 : if (gcall *_c4 = dyn_cast <gcall *> (_d4))
1779 : 0 : switch (gimple_call_combined_fn (_c4))
1780 : : {
1781 : 0 : case CFN_MUL_OVERFLOW:
1782 : 0 : if (gimple_call_num_args (_c4) == 2)
1783 : : {
1784 : 0 : tree _q40 = gimple_call_arg (_c4, 0);
1785 : 0 : _q40 = do_valueize (valueize, _q40);
1786 : 0 : tree _q41 = gimple_call_arg (_c4, 1);
1787 : 0 : _q41 = do_valueize (valueize, _q41);
1788 : 0 : if (tree_swap_operands_p (_q40, _q41))
1789 : 0 : std::swap (_q40, _q41);
1790 : 0 : if (integer_zerop (_q21))
1791 : : {
1792 : 0 : if (integer_minus_onep (_p1))
1793 : : {
1794 : 0 : switch (TREE_CODE (_p2))
1795 : : {
1796 : 0 : case SSA_NAME:
1797 : 0 : if (gimple *_d5 = get_def (valueize, _p2))
1798 : : {
1799 : 0 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
1800 : 0 : switch (gimple_assign_rhs_code (_a5))
1801 : : {
1802 : 0 : case REALPART_EXPR:
1803 : 0 : {
1804 : 0 : tree _q90 = TREE_OPERAND (gimple_assign_rhs1 (_a5), 0);
1805 : 0 : if ((TREE_CODE (_q90) == SSA_NAME
1806 : 0 : || is_gimple_min_invariant (_q90)))
1807 : : {
1808 : 0 : _q90 = do_valueize (valueize, _q90);
1809 : 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
1810 : : {
1811 : 0 : {
1812 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q30 };
1813 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1814 : : )
1815 : : {
1816 : 0 : if (types_match (type, captures[0], captures[1])
1817 : : )
1818 : : {
1819 : 0 : {
1820 : 0 : res_ops[0] = captures[0];
1821 : 0 : res_ops[1] = captures[1];
1822 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 92, __FILE__, __LINE__, false);
1823 : 0 : return true;
1824 : : }
1825 : : }
1826 : : }
1827 : : }
1828 : 0 : {
1829 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q30 };
1830 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1831 : : )
1832 : : {
1833 : 0 : if (types_match (type, captures[0], captures[1])
1834 : : )
1835 : : {
1836 : 0 : {
1837 : 0 : res_ops[0] = captures[0];
1838 : 0 : res_ops[1] = captures[1];
1839 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 92, __FILE__, __LINE__, false);
1840 : 0 : return true;
1841 : : }
1842 : : }
1843 : : }
1844 : : }
1845 : : }
1846 : : }
1847 : : break;
1848 : : }
1849 : : default:;
1850 : : }
1851 : : }
1852 : : break;
1853 : : default:;
1854 : : }
1855 : : }
1856 : : }
1857 : : }
1858 : : break;
1859 : : default:;
1860 : : }
1861 : : }
1862 : : break;
1863 : : default:;
1864 : : }
1865 : : }
1866 : : break;
1867 : : }
1868 : : default:;
1869 : : }
1870 : : }
1871 : : break;
1872 : : default:;
1873 : : }
1874 : 5940099 : break;
1875 : : }
1876 : : default:;
1877 : : }
1878 : : }
1879 : : break;
1880 : 0 : case NE_EXPR:
1881 : 0 : {
1882 : 0 : tree _q20 = TREE_OPERAND (_p0, 0);
1883 : 0 : if ((TREE_CODE (_q20) == SSA_NAME
1884 : 0 : || is_gimple_min_invariant (_q20)))
1885 : : {
1886 : 0 : _q20 = do_valueize (valueize, _q20);
1887 : 0 : tree _q21 = TREE_OPERAND (_p0, 1);
1888 : 0 : if ((TREE_CODE (_q21) == SSA_NAME
1889 : 0 : || is_gimple_min_invariant (_q21)))
1890 : : {
1891 : 0 : _q21 = do_valueize (valueize, _q21);
1892 : 0 : if (tree_swap_operands_p (_q20, _q21))
1893 : 0 : std::swap (_q20, _q21);
1894 : 0 : switch (TREE_CODE (_q20))
1895 : : {
1896 : 0 : case SSA_NAME:
1897 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
1898 : : {
1899 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
1900 : 0 : switch (gimple_assign_rhs_code (_a2))
1901 : : {
1902 : 0 : case IMAGPART_EXPR:
1903 : 0 : {
1904 : 0 : tree _q30 = TREE_OPERAND (gimple_assign_rhs1 (_a2), 0);
1905 : 0 : if ((TREE_CODE (_q30) == SSA_NAME
1906 : 0 : || is_gimple_min_invariant (_q30)))
1907 : : {
1908 : 0 : _q30 = do_valueize (valueize, _q30);
1909 : 0 : switch (TREE_CODE (_q30))
1910 : : {
1911 : 0 : case SSA_NAME:
1912 : 0 : if (gimple *_d3 = get_def (valueize, _q30))
1913 : : {
1914 : 0 : if (gcall *_c3 = dyn_cast <gcall *> (_d3))
1915 : 0 : switch (gimple_call_combined_fn (_c3))
1916 : : {
1917 : 0 : case CFN_MUL_OVERFLOW:
1918 : 0 : if (gimple_call_num_args (_c3) == 2)
1919 : : {
1920 : 0 : tree _q40 = gimple_call_arg (_c3, 0);
1921 : 0 : _q40 = do_valueize (valueize, _q40);
1922 : 0 : tree _q41 = gimple_call_arg (_c3, 1);
1923 : 0 : _q41 = do_valueize (valueize, _q41);
1924 : 0 : if (tree_swap_operands_p (_q40, _q41))
1925 : 0 : std::swap (_q40, _q41);
1926 : 0 : if (integer_zerop (_q21))
1927 : : {
1928 : 0 : if (integer_minus_onep (_p1))
1929 : : {
1930 : 0 : switch (TREE_CODE (_p2))
1931 : : {
1932 : 0 : case SSA_NAME:
1933 : 0 : if (gimple *_d4 = get_def (valueize, _p2))
1934 : : {
1935 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
1936 : 0 : switch (gimple_assign_rhs_code (_a4))
1937 : : {
1938 : 0 : case REALPART_EXPR:
1939 : 0 : {
1940 : 0 : tree _q90 = TREE_OPERAND (gimple_assign_rhs1 (_a4), 0);
1941 : 0 : if ((TREE_CODE (_q90) == SSA_NAME
1942 : 0 : || is_gimple_min_invariant (_q90)))
1943 : : {
1944 : 0 : _q90 = do_valueize (valueize, _q90);
1945 : 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
1946 : : {
1947 : 0 : {
1948 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q30 };
1949 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1950 : : )
1951 : : {
1952 : 0 : if (types_match (type, captures[0], captures[1])
1953 : : )
1954 : : {
1955 : 0 : {
1956 : 0 : res_ops[0] = captures[0];
1957 : 0 : res_ops[1] = captures[1];
1958 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 92, __FILE__, __LINE__, false);
1959 : 0 : return true;
1960 : : }
1961 : : }
1962 : : }
1963 : : }
1964 : 0 : {
1965 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q30 };
1966 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
1967 : : )
1968 : : {
1969 : 0 : if (types_match (type, captures[0], captures[1])
1970 : : )
1971 : : {
1972 : 0 : {
1973 : 0 : res_ops[0] = captures[0];
1974 : 0 : res_ops[1] = captures[1];
1975 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 92, __FILE__, __LINE__, false);
1976 : 0 : return true;
1977 : : }
1978 : : }
1979 : : }
1980 : : }
1981 : : }
1982 : : }
1983 : : break;
1984 : : }
1985 : : default:;
1986 : : }
1987 : : }
1988 : : break;
1989 : : default:;
1990 : : }
1991 : : }
1992 : : }
1993 : : }
1994 : : break;
1995 : : default:;
1996 : : }
1997 : : }
1998 : : break;
1999 : : default:;
2000 : : }
2001 : : }
2002 : : break;
2003 : : }
2004 : : default:;
2005 : : }
2006 : : }
2007 : : break;
2008 : : default:;
2009 : : }
2010 : : }
2011 : : }
2012 : 5940099 : break;
2013 : : }
2014 : : default:;
2015 : : }
2016 : : break;
2017 : : }
2018 : 190122 : case BIT_IOR_EXPR:
2019 : 190122 : {
2020 : 190122 : tree _p0 = gimple_assign_rhs1 (_a1);
2021 : 190122 : _p0 = do_valueize (valueize, _p0);
2022 : 190122 : tree _p1 = gimple_assign_rhs2 (_a1);
2023 : 190122 : _p1 = do_valueize (valueize, _p1);
2024 : 190122 : if (tree_swap_operands_p (_p0, _p1))
2025 : 2 : std::swap (_p0, _p1);
2026 : 190122 : switch (TREE_CODE (_p0))
2027 : : {
2028 : 190122 : case SSA_NAME:
2029 : 190122 : if (gimple *_d2 = get_def (valueize, _p0))
2030 : : {
2031 : 190122 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
2032 : 204797 : switch (gimple_assign_rhs_code (_a2))
2033 : : {
2034 : 10793 : CASE_CONVERT:
2035 : 10793 : {
2036 : 10793 : tree _q20 = gimple_assign_rhs1 (_a2);
2037 : 10793 : _q20 = do_valueize (valueize, _q20);
2038 : 10793 : switch (TREE_CODE (_q20))
2039 : : {
2040 : 10791 : case SSA_NAME:
2041 : 10791 : if (gimple *_d3 = get_def (valueize, _q20))
2042 : : {
2043 : 10791 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2044 : 6915 : switch (gimple_assign_rhs_code (_a3))
2045 : : {
2046 : 2 : case NEGATE_EXPR:
2047 : 2 : {
2048 : 2 : tree _q30 = gimple_assign_rhs1 (_a3);
2049 : 2 : _q30 = do_valueize (valueize, _q30);
2050 : 2 : switch (TREE_CODE (_q30))
2051 : : {
2052 : 2 : case SSA_NAME:
2053 : 2 : if (gimple *_d4 = get_def (valueize, _q30))
2054 : : {
2055 : 2 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
2056 : 0 : switch (gimple_assign_rhs_code (_a4))
2057 : : {
2058 : 0 : CASE_CONVERT:
2059 : 0 : {
2060 : 0 : tree _q40 = gimple_assign_rhs1 (_a4);
2061 : 0 : _q40 = do_valueize (valueize, _q40);
2062 : 0 : switch (TREE_CODE (_q40))
2063 : : {
2064 : 0 : case SSA_NAME:
2065 : 0 : if (gimple *_d5 = get_def (valueize, _q40))
2066 : : {
2067 : 0 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
2068 : 0 : switch (gimple_assign_rhs_code (_a5))
2069 : : {
2070 : 0 : case NE_EXPR:
2071 : 0 : {
2072 : 0 : tree _q50 = gimple_assign_rhs1 (_a5);
2073 : 0 : _q50 = do_valueize (valueize, _q50);
2074 : 0 : tree _q51 = gimple_assign_rhs2 (_a5);
2075 : 0 : _q51 = do_valueize (valueize, _q51);
2076 : 0 : if (tree_swap_operands_p (_q50, _q51))
2077 : 0 : std::swap (_q50, _q51);
2078 : 0 : switch (TREE_CODE (_q50))
2079 : : {
2080 : 0 : case SSA_NAME:
2081 : 0 : if (gimple *_d6 = get_def (valueize, _q50))
2082 : : {
2083 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
2084 : 0 : switch (gimple_assign_rhs_code (_a6))
2085 : : {
2086 : 0 : CASE_CONVERT:
2087 : 0 : {
2088 : 0 : tree _q60 = gimple_assign_rhs1 (_a6);
2089 : 0 : _q60 = do_valueize (valueize, _q60);
2090 : 0 : switch (TREE_CODE (_q60))
2091 : : {
2092 : 0 : case SSA_NAME:
2093 : 0 : if (gimple *_d7 = get_def (valueize, _q60))
2094 : : {
2095 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
2096 : 0 : switch (gimple_assign_rhs_code (_a7))
2097 : : {
2098 : 0 : case RSHIFT_EXPR:
2099 : 0 : {
2100 : 0 : tree _q70 = gimple_assign_rhs1 (_a7);
2101 : 0 : _q70 = do_valueize (valueize, _q70);
2102 : 0 : tree _q71 = gimple_assign_rhs2 (_a7);
2103 : 0 : _q71 = do_valueize (valueize, _q71);
2104 : 0 : switch (TREE_CODE (_q71))
2105 : : {
2106 : 0 : case INTEGER_CST:
2107 : 0 : {
2108 : 0 : if (integer_zerop (_q51))
2109 : : {
2110 : 0 : switch (TREE_CODE (_p1))
2111 : : {
2112 : 0 : case SSA_NAME:
2113 : 0 : if (gimple *_d8 = get_def (valueize, _p1))
2114 : : {
2115 : 0 : if (gassign *_a8 = dyn_cast <gassign *> (_d8))
2116 : 0 : switch (gimple_assign_rhs_code (_a8))
2117 : : {
2118 : 0 : CASE_CONVERT:
2119 : 0 : {
2120 : 0 : tree _q110 = gimple_assign_rhs1 (_a8);
2121 : 0 : _q110 = do_valueize (valueize, _q110);
2122 : 0 : if ((_q110 == _q70 && ! TREE_SIDE_EFFECTS (_q110)) || (operand_equal_p (_q110, _q70, 0) && types_match (_q110, _q70)))
2123 : : {
2124 : 0 : {
2125 : 0 : tree _q110_pops[2];
2126 : 0 : if (gimple_usmul_widen_mult (_q110, _q110_pops, valueize))
2127 : : {
2128 : 0 : tree _q130 = _q110_pops[0];
2129 : 0 : tree _q131 = _q110_pops[1];
2130 : 0 : {
2131 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q130, _q131, _q70, _q71 };
2132 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
2133 : : )
2134 : : {
2135 : 0 : if (types_match (type, captures[0], captures[1])
2136 : : )
2137 : : {
2138 : 0 : {
2139 : 0 : unsigned prec = TYPE_PRECISION (type);
2140 : 0 : bool c2_is_type_precision_p = tree_to_uhwi (captures[3]) == prec;
2141 : 0 : if (c2_is_type_precision_p
2142 : : )
2143 : : {
2144 : 0 : {
2145 : 0 : res_ops[0] = captures[0];
2146 : 0 : res_ops[1] = captures[1];
2147 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 91, __FILE__, __LINE__, false);
2148 : 0 : return true;
2149 : : }
2150 : : }
2151 : : }
2152 : : }
2153 : : }
2154 : : }
2155 : : }
2156 : : }
2157 : : }
2158 : : break;
2159 : : }
2160 : : default:;
2161 : : }
2162 : : }
2163 : : break;
2164 : : default:;
2165 : : }
2166 : : }
2167 : : break;
2168 : : }
2169 : : default:;
2170 : : }
2171 : : break;
2172 : : }
2173 : : default:;
2174 : : }
2175 : : }
2176 : : break;
2177 : : default:;
2178 : : }
2179 : : break;
2180 : : }
2181 : 0 : case RSHIFT_EXPR:
2182 : 0 : {
2183 : 0 : tree _q60 = gimple_assign_rhs1 (_a6);
2184 : 0 : _q60 = do_valueize (valueize, _q60);
2185 : 0 : tree _q61 = gimple_assign_rhs2 (_a6);
2186 : 0 : _q61 = do_valueize (valueize, _q61);
2187 : 0 : switch (TREE_CODE (_q61))
2188 : : {
2189 : 0 : case INTEGER_CST:
2190 : 0 : {
2191 : 0 : if (integer_zerop (_q51))
2192 : : {
2193 : 0 : switch (TREE_CODE (_p1))
2194 : : {
2195 : 0 : case SSA_NAME:
2196 : 0 : if (gimple *_d7 = get_def (valueize, _p1))
2197 : : {
2198 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
2199 : 0 : switch (gimple_assign_rhs_code (_a7))
2200 : : {
2201 : 0 : CASE_CONVERT:
2202 : 0 : {
2203 : 0 : tree _q100 = gimple_assign_rhs1 (_a7);
2204 : 0 : _q100 = do_valueize (valueize, _q100);
2205 : 0 : if ((_q100 == _q60 && ! TREE_SIDE_EFFECTS (_q100)) || (operand_equal_p (_q100, _q60, 0) && types_match (_q100, _q60)))
2206 : : {
2207 : 0 : {
2208 : 0 : tree _q100_pops[2];
2209 : 0 : if (gimple_usmul_widen_mult (_q100, _q100_pops, valueize))
2210 : : {
2211 : 0 : tree _q120 = _q100_pops[0];
2212 : 0 : tree _q121 = _q100_pops[1];
2213 : 0 : {
2214 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q120, _q121, _q60, _q61 };
2215 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
2216 : : )
2217 : : {
2218 : 0 : if (types_match (type, captures[0], captures[1])
2219 : : )
2220 : : {
2221 : 0 : {
2222 : 0 : unsigned prec = TYPE_PRECISION (type);
2223 : 0 : bool c2_is_type_precision_p = tree_to_uhwi (captures[3]) == prec;
2224 : 0 : if (c2_is_type_precision_p
2225 : : )
2226 : : {
2227 : 0 : {
2228 : 0 : res_ops[0] = captures[0];
2229 : 0 : res_ops[1] = captures[1];
2230 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 91, __FILE__, __LINE__, false);
2231 : 0 : return true;
2232 : : }
2233 : : }
2234 : : }
2235 : : }
2236 : : }
2237 : : }
2238 : : }
2239 : : }
2240 : : }
2241 : : break;
2242 : : }
2243 : : default:;
2244 : : }
2245 : : }
2246 : : break;
2247 : : default:;
2248 : : }
2249 : : }
2250 : : break;
2251 : : }
2252 : : default:;
2253 : : }
2254 : : break;
2255 : : }
2256 : : default:;
2257 : : }
2258 : : }
2259 : : break;
2260 : : default:;
2261 : : }
2262 : 5940099 : break;
2263 : : }
2264 : : default:;
2265 : : }
2266 : : }
2267 : : break;
2268 : : default:;
2269 : : }
2270 : : break;
2271 : : }
2272 : : default:;
2273 : : }
2274 : : }
2275 : : break;
2276 : : default:;
2277 : : }
2278 : : break;
2279 : : }
2280 : : default:;
2281 : : }
2282 : : }
2283 : : break;
2284 : : default:;
2285 : : }
2286 : : break;
2287 : : }
2288 : 158 : case NEGATE_EXPR:
2289 : 158 : {
2290 : 158 : tree _q20 = gimple_assign_rhs1 (_a2);
2291 : 158 : _q20 = do_valueize (valueize, _q20);
2292 : 158 : switch (TREE_CODE (_q20))
2293 : : {
2294 : 158 : case SSA_NAME:
2295 : 158 : if (gimple *_d3 = get_def (valueize, _q20))
2296 : : {
2297 : 158 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2298 : 167 : switch (gimple_assign_rhs_code (_a3))
2299 : : {
2300 : 44 : CASE_CONVERT:
2301 : 44 : {
2302 : 44 : tree _q30 = gimple_assign_rhs1 (_a3);
2303 : 44 : _q30 = do_valueize (valueize, _q30);
2304 : 44 : switch (TREE_CODE (_q30))
2305 : : {
2306 : 44 : case SSA_NAME:
2307 : 44 : if (gimple *_d4 = get_def (valueize, _q30))
2308 : : {
2309 : 44 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
2310 : 41 : switch (gimple_assign_rhs_code (_a4))
2311 : : {
2312 : 8 : case NE_EXPR:
2313 : 8 : {
2314 : 8 : tree _q40 = gimple_assign_rhs1 (_a4);
2315 : 8 : _q40 = do_valueize (valueize, _q40);
2316 : 8 : tree _q41 = gimple_assign_rhs2 (_a4);
2317 : 8 : _q41 = do_valueize (valueize, _q41);
2318 : 8 : if (tree_swap_operands_p (_q40, _q41))
2319 : 0 : std::swap (_q40, _q41);
2320 : 8 : switch (TREE_CODE (_q40))
2321 : : {
2322 : 8 : case SSA_NAME:
2323 : 8 : if (gimple *_d5 = get_def (valueize, _q40))
2324 : : {
2325 : 8 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
2326 : 14 : switch (gimple_assign_rhs_code (_a5))
2327 : : {
2328 : 0 : CASE_CONVERT:
2329 : 0 : {
2330 : 0 : tree _q50 = gimple_assign_rhs1 (_a5);
2331 : 0 : _q50 = do_valueize (valueize, _q50);
2332 : 0 : switch (TREE_CODE (_q50))
2333 : : {
2334 : 0 : case SSA_NAME:
2335 : 0 : if (gimple *_d6 = get_def (valueize, _q50))
2336 : : {
2337 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
2338 : 0 : switch (gimple_assign_rhs_code (_a6))
2339 : : {
2340 : 0 : case RSHIFT_EXPR:
2341 : 0 : {
2342 : 0 : tree _q60 = gimple_assign_rhs1 (_a6);
2343 : 0 : _q60 = do_valueize (valueize, _q60);
2344 : 0 : tree _q61 = gimple_assign_rhs2 (_a6);
2345 : 0 : _q61 = do_valueize (valueize, _q61);
2346 : 0 : switch (TREE_CODE (_q61))
2347 : : {
2348 : 0 : case INTEGER_CST:
2349 : 0 : {
2350 : 0 : if (integer_zerop (_q41))
2351 : : {
2352 : 0 : switch (TREE_CODE (_p1))
2353 : : {
2354 : 0 : case SSA_NAME:
2355 : 0 : if (gimple *_d7 = get_def (valueize, _p1))
2356 : : {
2357 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
2358 : 0 : switch (gimple_assign_rhs_code (_a7))
2359 : : {
2360 : 0 : CASE_CONVERT:
2361 : 0 : {
2362 : 0 : tree _q100 = gimple_assign_rhs1 (_a7);
2363 : 0 : _q100 = do_valueize (valueize, _q100);
2364 : 0 : if ((_q100 == _q60 && ! TREE_SIDE_EFFECTS (_q100)) || (operand_equal_p (_q100, _q60, 0) && types_match (_q100, _q60)))
2365 : : {
2366 : 0 : {
2367 : 0 : tree _q100_pops[2];
2368 : 0 : if (gimple_usmul_widen_mult (_q100, _q100_pops, valueize))
2369 : : {
2370 : 0 : tree _q120 = _q100_pops[0];
2371 : 0 : tree _q121 = _q100_pops[1];
2372 : 0 : {
2373 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q120, _q121, _q60, _q61 };
2374 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
2375 : : )
2376 : : {
2377 : 0 : if (types_match (type, captures[0], captures[1])
2378 : : )
2379 : : {
2380 : 0 : {
2381 : 0 : unsigned prec = TYPE_PRECISION (type);
2382 : 0 : bool c2_is_type_precision_p = tree_to_uhwi (captures[3]) == prec;
2383 : 0 : if (c2_is_type_precision_p
2384 : : )
2385 : : {
2386 : 0 : {
2387 : 0 : res_ops[0] = captures[0];
2388 : 0 : res_ops[1] = captures[1];
2389 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 91, __FILE__, __LINE__, false);
2390 : 0 : return true;
2391 : : }
2392 : : }
2393 : : }
2394 : : }
2395 : : }
2396 : : }
2397 : : }
2398 : : }
2399 : : }
2400 : : break;
2401 : : }
2402 : : default:;
2403 : : }
2404 : : }
2405 : : break;
2406 : : default:;
2407 : : }
2408 : : }
2409 : : break;
2410 : : }
2411 : : default:;
2412 : : }
2413 : : break;
2414 : : }
2415 : : default:;
2416 : : }
2417 : : }
2418 : : break;
2419 : : default:;
2420 : : }
2421 : : break;
2422 : : }
2423 : 0 : case RSHIFT_EXPR:
2424 : 0 : {
2425 : 0 : tree _q50 = gimple_assign_rhs1 (_a5);
2426 : 0 : _q50 = do_valueize (valueize, _q50);
2427 : 0 : tree _q51 = gimple_assign_rhs2 (_a5);
2428 : 0 : _q51 = do_valueize (valueize, _q51);
2429 : 0 : switch (TREE_CODE (_q51))
2430 : : {
2431 : 0 : case INTEGER_CST:
2432 : 0 : {
2433 : 0 : if (integer_zerop (_q41))
2434 : : {
2435 : 0 : switch (TREE_CODE (_p1))
2436 : : {
2437 : 0 : case SSA_NAME:
2438 : 0 : if (gimple *_d6 = get_def (valueize, _p1))
2439 : : {
2440 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
2441 : 0 : switch (gimple_assign_rhs_code (_a6))
2442 : : {
2443 : 0 : CASE_CONVERT:
2444 : 0 : {
2445 : 0 : tree _q90 = gimple_assign_rhs1 (_a6);
2446 : 0 : _q90 = do_valueize (valueize, _q90);
2447 : 0 : if ((_q90 == _q50 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q50, 0) && types_match (_q90, _q50)))
2448 : : {
2449 : 0 : {
2450 : 0 : tree _q90_pops[2];
2451 : 0 : if (gimple_usmul_widen_mult (_q90, _q90_pops, valueize))
2452 : : {
2453 : 0 : tree _q110 = _q90_pops[0];
2454 : 0 : tree _q111 = _q90_pops[1];
2455 : 0 : {
2456 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q110, _q111, _q50, _q51 };
2457 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
2458 : : )
2459 : : {
2460 : 0 : if (types_match (type, captures[0], captures[1])
2461 : : )
2462 : : {
2463 : 0 : {
2464 : 0 : unsigned prec = TYPE_PRECISION (type);
2465 : 0 : bool c2_is_type_precision_p = tree_to_uhwi (captures[3]) == prec;
2466 : 0 : if (c2_is_type_precision_p
2467 : : )
2468 : : {
2469 : 0 : {
2470 : 0 : res_ops[0] = captures[0];
2471 : 0 : res_ops[1] = captures[1];
2472 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 91, __FILE__, __LINE__, false);
2473 : 0 : return true;
2474 : : }
2475 : : }
2476 : : }
2477 : : }
2478 : : }
2479 : : }
2480 : : }
2481 : : }
2482 : : }
2483 : : break;
2484 : : }
2485 : : default:;
2486 : : }
2487 : : }
2488 : : break;
2489 : : default:;
2490 : : }
2491 : : }
2492 : : break;
2493 : : }
2494 : : default:;
2495 : : }
2496 : : break;
2497 : : }
2498 : : default:;
2499 : : }
2500 : : }
2501 : : break;
2502 : : default:;
2503 : : }
2504 : 5940099 : break;
2505 : : }
2506 : : default:;
2507 : : }
2508 : : }
2509 : : break;
2510 : : default:;
2511 : : }
2512 : : break;
2513 : : }
2514 : : default:;
2515 : : }
2516 : : }
2517 : : break;
2518 : : default:;
2519 : : }
2520 : : break;
2521 : : }
2522 : : default:;
2523 : : }
2524 : : }
2525 : : break;
2526 : : default:;
2527 : : }
2528 : 5940099 : break;
2529 : : }
2530 : : default:;
2531 : : }
2532 : 3323418 : else if (gphi *_a1 = dyn_cast <gphi *> (_d1))
2533 : : {
2534 : 3323418 : basic_block _b1 = gimple_bb (_a1);
2535 : 3323418 : tree _p1, _p2;
2536 : 3323418 : gcond *_cond_1 = match_cond_with_binary_phi (_a1, &_p1, &_p2);
2537 : 3323418 : if (_cond_1)
2538 : : {
2539 : 713951 : tree _cond_lhs_1 = gimple_cond_lhs (_cond_1);
2540 : 713951 : tree _cond_rhs_1 = gimple_cond_rhs (_cond_1);
2541 : 713951 : tree _p0 = build2 (gimple_cond_code (_cond_1), boolean_type_node, _cond_lhs_1, _cond_rhs_1);
2542 : 713951 : switch (TREE_CODE (_p0))
2543 : : {
2544 : 0 : case SSA_NAME:
2545 : 0 : if (gimple *_d2 = get_def (valueize, _p0))
2546 : : {
2547 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
2548 : 0 : switch (gimple_assign_rhs_code (_a2))
2549 : : {
2550 : 0 : case NE_EXPR:
2551 : 0 : {
2552 : 0 : tree _q20 = gimple_assign_rhs1 (_a2);
2553 : 0 : _q20 = do_valueize (valueize, _q20);
2554 : 0 : tree _q21 = gimple_assign_rhs2 (_a2);
2555 : 0 : _q21 = do_valueize (valueize, _q21);
2556 : 0 : if (tree_swap_operands_p (_q20, _q21))
2557 : 0 : std::swap (_q20, _q21);
2558 : 0 : switch (TREE_CODE (_q20))
2559 : : {
2560 : 0 : case SSA_NAME:
2561 : 0 : if (gimple *_d3 = get_def (valueize, _q20))
2562 : : {
2563 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
2564 : 0 : switch (gimple_assign_rhs_code (_a3))
2565 : : {
2566 : 0 : case IMAGPART_EXPR:
2567 : 0 : {
2568 : 0 : tree _q30 = TREE_OPERAND (gimple_assign_rhs1 (_a3), 0);
2569 : 0 : if ((TREE_CODE (_q30) == SSA_NAME
2570 : 0 : || is_gimple_min_invariant (_q30)))
2571 : : {
2572 : 0 : _q30 = do_valueize (valueize, _q30);
2573 : 0 : switch (TREE_CODE (_q30))
2574 : : {
2575 : 0 : case SSA_NAME:
2576 : 0 : if (gimple *_d4 = get_def (valueize, _q30))
2577 : : {
2578 : 0 : if (gcall *_c4 = dyn_cast <gcall *> (_d4))
2579 : 0 : switch (gimple_call_combined_fn (_c4))
2580 : : {
2581 : 0 : case CFN_MUL_OVERFLOW:
2582 : 0 : if (gimple_call_num_args (_c4) == 2)
2583 : : {
2584 : 0 : tree _q40 = gimple_call_arg (_c4, 0);
2585 : 0 : _q40 = do_valueize (valueize, _q40);
2586 : 0 : tree _q41 = gimple_call_arg (_c4, 1);
2587 : 0 : _q41 = do_valueize (valueize, _q41);
2588 : 0 : if (tree_swap_operands_p (_q40, _q41))
2589 : 0 : std::swap (_q40, _q41);
2590 : 0 : if (integer_zerop (_q21))
2591 : : {
2592 : 0 : if (integer_minus_onep (_p1))
2593 : : {
2594 : 0 : switch (TREE_CODE (_p2))
2595 : : {
2596 : 0 : case SSA_NAME:
2597 : 0 : if (gimple *_d5 = get_def (valueize, _p2))
2598 : : {
2599 : 0 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
2600 : 0 : switch (gimple_assign_rhs_code (_a5))
2601 : : {
2602 : 0 : case REALPART_EXPR:
2603 : 0 : {
2604 : 0 : tree _q90 = TREE_OPERAND (gimple_assign_rhs1 (_a5), 0);
2605 : 0 : if ((TREE_CODE (_q90) == SSA_NAME
2606 : 0 : || is_gimple_min_invariant (_q90)))
2607 : : {
2608 : 0 : _q90 = do_valueize (valueize, _q90);
2609 : 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
2610 : : {
2611 : 0 : {
2612 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q30 };
2613 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
2614 : : )
2615 : : {
2616 : 0 : if (types_match (type, captures[0], captures[1])
2617 : : )
2618 : : {
2619 : 0 : {
2620 : 0 : res_ops[0] = captures[0];
2621 : 0 : res_ops[1] = captures[1];
2622 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 92, __FILE__, __LINE__, false);
2623 : 0 : return true;
2624 : : }
2625 : : }
2626 : : }
2627 : : }
2628 : 0 : {
2629 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q30 };
2630 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
2631 : : )
2632 : : {
2633 : 0 : if (types_match (type, captures[0], captures[1])
2634 : : )
2635 : : {
2636 : 0 : {
2637 : 0 : res_ops[0] = captures[0];
2638 : 0 : res_ops[1] = captures[1];
2639 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 92, __FILE__, __LINE__, false);
2640 : 0 : return true;
2641 : : }
2642 : : }
2643 : : }
2644 : : }
2645 : : }
2646 : : }
2647 : : break;
2648 : : }
2649 : : default:;
2650 : : }
2651 : : }
2652 : : break;
2653 : : default:;
2654 : : }
2655 : : }
2656 : : }
2657 : : }
2658 : : break;
2659 : : default:;
2660 : : }
2661 : : }
2662 : : break;
2663 : : default:;
2664 : : }
2665 : : }
2666 : : break;
2667 : : }
2668 : : default:;
2669 : : }
2670 : : }
2671 : : break;
2672 : : default:;
2673 : : }
2674 : 3323418 : break;
2675 : : }
2676 : : default:;
2677 : : }
2678 : : }
2679 : : break;
2680 : 251059 : case NE_EXPR:
2681 : 251059 : {
2682 : 251059 : tree _q20 = TREE_OPERAND (_p0, 0);
2683 : 251059 : if ((TREE_CODE (_q20) == SSA_NAME
2684 : 251059 : || is_gimple_min_invariant (_q20)))
2685 : : {
2686 : 251059 : _q20 = do_valueize (valueize, _q20);
2687 : 251059 : tree _q21 = TREE_OPERAND (_p0, 1);
2688 : 251059 : if ((TREE_CODE (_q21) == SSA_NAME
2689 : 251059 : || is_gimple_min_invariant (_q21)))
2690 : : {
2691 : 251059 : _q21 = do_valueize (valueize, _q21);
2692 : 251059 : if (tree_swap_operands_p (_q20, _q21))
2693 : 0 : std::swap (_q20, _q21);
2694 : 251059 : switch (TREE_CODE (_q20))
2695 : : {
2696 : 250804 : case SSA_NAME:
2697 : 250804 : if (gimple *_d2 = get_def (valueize, _q20))
2698 : : {
2699 : 250804 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
2700 : 328829 : switch (gimple_assign_rhs_code (_a2))
2701 : : {
2702 : 33761 : case IMAGPART_EXPR:
2703 : 33761 : {
2704 : 33761 : tree _q30 = TREE_OPERAND (gimple_assign_rhs1 (_a2), 0);
2705 : 33761 : if ((TREE_CODE (_q30) == SSA_NAME
2706 : 33761 : || is_gimple_min_invariant (_q30)))
2707 : : {
2708 : 33761 : _q30 = do_valueize (valueize, _q30);
2709 : 33761 : switch (TREE_CODE (_q30))
2710 : : {
2711 : 33761 : case SSA_NAME:
2712 : 33761 : if (gimple *_d3 = get_def (valueize, _q30))
2713 : : {
2714 : 33761 : if (gcall *_c3 = dyn_cast <gcall *> (_d3))
2715 : 33749 : switch (gimple_call_combined_fn (_c3))
2716 : : {
2717 : 11513 : case CFN_MUL_OVERFLOW:
2718 : 11513 : if (gimple_call_num_args (_c3) == 2)
2719 : : {
2720 : 11513 : tree _q40 = gimple_call_arg (_c3, 0);
2721 : 11513 : _q40 = do_valueize (valueize, _q40);
2722 : 11513 : tree _q41 = gimple_call_arg (_c3, 1);
2723 : 11513 : _q41 = do_valueize (valueize, _q41);
2724 : 11513 : if (tree_swap_operands_p (_q40, _q41))
2725 : 0 : std::swap (_q40, _q41);
2726 : 11513 : if (integer_zerop (_q21))
2727 : : {
2728 : 11513 : if (integer_minus_onep (_p1))
2729 : : {
2730 : 10 : switch (TREE_CODE (_p2))
2731 : : {
2732 : 10 : case SSA_NAME:
2733 : 10 : if (gimple *_d4 = get_def (valueize, _p2))
2734 : : {
2735 : 10 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
2736 : 4 : switch (gimple_assign_rhs_code (_a4))
2737 : : {
2738 : 0 : case REALPART_EXPR:
2739 : 0 : {
2740 : 0 : tree _q90 = TREE_OPERAND (gimple_assign_rhs1 (_a4), 0);
2741 : 0 : if ((TREE_CODE (_q90) == SSA_NAME
2742 : 0 : || is_gimple_min_invariant (_q90)))
2743 : : {
2744 : 0 : _q90 = do_valueize (valueize, _q90);
2745 : 0 : if ((_q90 == _q30 && ! TREE_SIDE_EFFECTS (_q90)) || (operand_equal_p (_q90, _q30, 0) && types_match (_q90, _q30)))
2746 : : {
2747 : 0 : {
2748 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q40, _q41, _q30 };
2749 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
2750 : : )
2751 : : {
2752 : 0 : if (types_match (type, captures[0], captures[1])
2753 : : )
2754 : : {
2755 : 0 : {
2756 : 0 : res_ops[0] = captures[0];
2757 : 0 : res_ops[1] = captures[1];
2758 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 92, __FILE__, __LINE__, false);
2759 : 0 : return true;
2760 : : }
2761 : : }
2762 : : }
2763 : : }
2764 : 0 : {
2765 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q41, _q40, _q30 };
2766 : 0 : if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)
2767 : : )
2768 : : {
2769 : 0 : if (types_match (type, captures[0], captures[1])
2770 : : )
2771 : : {
2772 : 0 : {
2773 : 0 : res_ops[0] = captures[0];
2774 : 0 : res_ops[1] = captures[1];
2775 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 92, __FILE__, __LINE__, false);
2776 : 0 : return true;
2777 : : }
2778 : : }
2779 : : }
2780 : : }
2781 : : }
2782 : : }
2783 : : break;
2784 : : }
2785 : : default:;
2786 : : }
2787 : : }
2788 : : break;
2789 : : default:;
2790 : : }
2791 : : }
2792 : : }
2793 : : }
2794 : : break;
2795 : : default:;
2796 : : }
2797 : : }
2798 : : break;
2799 : : default:;
2800 : : }
2801 : : }
2802 : : break;
2803 : : }
2804 : : default:;
2805 : : }
2806 : : }
2807 : : break;
2808 : : default:;
2809 : : }
2810 : : }
2811 : : }
2812 : 3323418 : break;
2813 : : }
2814 : : default:;
2815 : : }
2816 : : }
2817 : : }
2818 : : }
2819 : : break;
2820 : : default:;
2821 : : }
2822 : : return false;
2823 : : }
2824 : :
2825 : : bool
2826 : 6920 : gimple_simplify_80 (gimple_match_op *res_op, gimple_seq *seq,
2827 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2828 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2829 : : {
2830 : 6920 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2831 : 6920 : if (VECTOR_TYPE_P (type)
2832 : 6920 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
2833 : : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[3])))
2834 : 20760 : && (TYPE_MODE (TREE_TYPE (type))
2835 : 6920 : == TYPE_MODE (TREE_TYPE (TREE_TYPE (captures[3]))))
2836 : : )
2837 : : {
2838 : 6920 : gimple_seq *lseq = seq;
2839 : 6920 : if (lseq
2840 : 1742 : && (!single_use (captures[1])))
2841 : 5371 : lseq = NULL;
2842 : 6920 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail716;
2843 : 6920 : {
2844 : 6920 : res_op->set_op (MINUS_EXPR, type, 2);
2845 : 6920 : res_op->ops[0] = captures[0];
2846 : 6920 : {
2847 : 6920 : tree _r1;
2848 : 6920 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
2849 : 6920 : {
2850 : 6920 : tree _o2[3], _r2;
2851 : 6920 : _o2[0] = captures[2];
2852 : 6920 : {
2853 : 6920 : tree _o3[1], _r3;
2854 : 6920 : _o3[0] = captures[3];
2855 : 6920 : gimple_match_op tem_op (res_op->cond.any_else (), NEGATE_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
2856 : 6920 : tem_op.resimplify (lseq, valueize);
2857 : 6920 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
2858 : 6920 : if (!_r3) goto next_after_fail716;
2859 : 6920 : _o2[1] = _r3;
2860 : : }
2861 : 6920 : _o2[2] = captures[4];
2862 : 6920 : tem_op.set_op (VEC_COND_EXPR, TREE_TYPE (_o2[1]), 3);
2863 : 6920 : tem_op.ops[0] = _o2[0];
2864 : 6920 : tem_op.ops[1] = _o2[1];
2865 : 6920 : tem_op.ops[2] = _o2[2];
2866 : 6920 : tem_op.resimplify (lseq, valueize);
2867 : : }
2868 : 6920 : if (type != tem_op.type
2869 : 6920 : && !useless_type_conversion_p (type, tem_op.type))
2870 : : {
2871 : 1049 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2872 : 1049 : if (!_r1) goto next_after_fail716;
2873 : 76 : tem_op.set_op (VIEW_CONVERT_EXPR, type, 1);
2874 : 76 : tem_op.ops[0] = _r1;
2875 : 76 : tem_op.resimplify (lseq, valueize);
2876 : : }
2877 : 5947 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2878 : 5947 : if (!_r1) goto next_after_fail716;
2879 : 1549 : res_op->ops[1] = _r1;
2880 : : }
2881 : 1549 : res_op->resimplify (lseq, valueize);
2882 : 1549 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 209, __FILE__, __LINE__, true);
2883 : 1549 : return true;
2884 : : }
2885 : : next_after_fail716:;
2886 : : }
2887 : : return false;
2888 : : }
2889 : :
2890 : : bool
2891 : 0 : gimple_simplify_86 (gimple_match_op *res_op, gimple_seq *seq,
2892 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2893 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
2894 : : const enum tree_code ARG_UNUSED (log1),
2895 : : const enum tree_code ARG_UNUSED (log2),
2896 : : const combined_fn ARG_UNUSED (popcount))
2897 : : {
2898 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2899 : 0 : gimple_seq *lseq = seq;
2900 : 0 : if (lseq
2901 : 0 : && (!single_use (captures[0])
2902 : 0 : || !single_use (captures[1])
2903 : 0 : || !single_use (captures[3])
2904 : 0 : || !single_use (captures[4])
2905 : 0 : || !single_use (captures[6])))
2906 : 0 : lseq = NULL;
2907 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail723;
2908 : 0 : {
2909 : 0 : res_op->set_op (popcount, type, 1);
2910 : 0 : {
2911 : 0 : tree _o1[2], _r1;
2912 : 0 : _o1[0] = captures[2];
2913 : 0 : _o1[1] = captures[5];
2914 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), log2, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2915 : 0 : tem_op.resimplify (lseq, valueize);
2916 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2917 : 0 : if (!_r1) goto next_after_fail723;
2918 : 0 : res_op->ops[0] = _r1;
2919 : : }
2920 : 0 : res_op->resimplify (lseq, valueize);
2921 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 216, __FILE__, __LINE__, true);
2922 : : return true;
2923 : : }
2924 : : next_after_fail723:;
2925 : : return false;
2926 : : }
2927 : :
2928 : : bool
2929 : 90 : gimple_simplify_89 (gimple_match_op *res_op, gimple_seq *seq,
2930 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2931 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2932 : : {
2933 : 90 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2934 : 90 : if (fold_before_rtl_expansion_p ()
2935 : 6 : && VECTOR_TYPE_P (type)
2936 : 96 : && direct_internal_fn_supported_p (IFN_AVG_CEIL, type, OPTIMIZE_FOR_BOTH)
2937 : : )
2938 : : {
2939 : 6 : gimple_seq *lseq = seq;
2940 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail726;
2941 : 6 : {
2942 : 6 : res_op->set_op (CFN_AVG_CEIL, type, 2);
2943 : 6 : res_op->ops[0] = captures[0];
2944 : 6 : res_op->ops[1] = captures[2];
2945 : 6 : res_op->resimplify (lseq, valueize);
2946 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 219, __FILE__, __LINE__, true);
2947 : 6 : return true;
2948 : : }
2949 : 0 : next_after_fail726:;
2950 : : }
2951 : : return false;
2952 : : }
2953 : :
2954 : : bool
2955 : 0 : gimple_simplify_91 (gimple_match_op *res_op, gimple_seq *seq,
2956 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2957 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2958 : : {
2959 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2960 : 0 : if (INTEGRAL_TYPE_P (type)
2961 : : )
2962 : : {
2963 : 0 : gimple_seq *lseq = seq;
2964 : 0 : if (lseq
2965 : 0 : && (!single_use (captures[0])
2966 : 0 : || !single_use (captures[2])
2967 : 0 : || !single_use (captures[3])))
2968 : 0 : lseq = NULL;
2969 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail728;
2970 : 0 : {
2971 : 0 : res_op->set_op (MINUS_EXPR, type, 2);
2972 : 0 : res_op->ops[0] = captures[1];
2973 : 0 : {
2974 : 0 : tree _o1[2], _r1;
2975 : 0 : _o1[0] = captures[4];
2976 : 0 : _o1[1] = captures[1];
2977 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
2978 : 0 : tem_op.resimplify (lseq, valueize);
2979 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
2980 : 0 : if (!_r1) goto next_after_fail728;
2981 : 0 : res_op->ops[1] = _r1;
2982 : : }
2983 : 0 : res_op->resimplify (lseq, valueize);
2984 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 221, __FILE__, __LINE__, true);
2985 : 0 : return true;
2986 : : }
2987 : : next_after_fail728:;
2988 : : }
2989 : : return false;
2990 : : }
2991 : :
2992 : : bool
2993 : 10 : gimple_simplify_95 (gimple_match_op *res_op, gimple_seq *seq,
2994 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
2995 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
2996 : : {
2997 : 10 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
2998 : 10 : if (!TYPE_OVERFLOW_SANITIZED (type) && !TYPE_OVERFLOW_TRAPS (type)
2999 : 10 : && !TYPE_SATURATING (type) && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (captures[0]))
3000 : 10 : && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (captures[0]))
3001 : 20 : && !TYPE_SATURATING (TREE_TYPE (captures[0]))
3002 : : )
3003 : : {
3004 : 10 : gimple_seq *lseq = seq;
3005 : 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail732;
3006 : 10 : {
3007 : 10 : res_op->set_op (BIT_NOT_EXPR, type, 1);
3008 : 10 : {
3009 : 10 : tree _r1;
3010 : 10 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
3011 : 10 : {
3012 : 10 : tree _o2[2], _r2;
3013 : 10 : _o2[0] = captures[1];
3014 : 10 : _o2[1] = captures[2];
3015 : 10 : tem_op.set_op (BIT_XOR_EXPR, TREE_TYPE (_o2[0]), 2);
3016 : 10 : tem_op.ops[0] = _o2[0];
3017 : 10 : tem_op.ops[1] = _o2[1];
3018 : 10 : tem_op.resimplify (lseq, valueize);
3019 : : }
3020 : 10 : if (type != tem_op.type
3021 : 10 : && !useless_type_conversion_p (type, tem_op.type))
3022 : : {
3023 : 7 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3024 : 9 : if (!_r1) goto next_after_fail732;
3025 : 4 : tem_op.set_op (NOP_EXPR, type, 1);
3026 : 4 : tem_op.ops[0] = _r1;
3027 : 4 : tem_op.resimplify (lseq, valueize);
3028 : : }
3029 : 7 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3030 : 7 : if (!_r1) goto next_after_fail732;
3031 : 5 : res_op->ops[0] = _r1;
3032 : : }
3033 : 5 : res_op->resimplify (lseq, valueize);
3034 : 5 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 225, __FILE__, __LINE__, true);
3035 : 5 : return true;
3036 : : }
3037 : : next_after_fail732:;
3038 : : }
3039 : : return false;
3040 : : }
3041 : :
3042 : : bool
3043 : 38594 : gimple_simplify_100 (gimple_match_op *res_op, gimple_seq *seq,
3044 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3045 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3046 : : {
3047 : 38594 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3048 : 38594 : if (!TYPE_SATURATING (type)
3049 : : )
3050 : : {
3051 : 38594 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
3052 : 75237 : && !FIXED_POINT_TYPE_P (type)
3053 : : )
3054 : : {
3055 : 36643 : gimple_seq *lseq = seq;
3056 : 36643 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail737;
3057 : 36643 : {
3058 : 36643 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3059 : 36643 : res_op->ops[0] = captures[1];
3060 : 36643 : res_op->resimplify (lseq, valueize);
3061 : 36643 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 229, __FILE__, __LINE__, true);
3062 : 36643 : return true;
3063 : : }
3064 : 0 : next_after_fail737:;
3065 : : }
3066 : : }
3067 : : return false;
3068 : : }
3069 : :
3070 : : bool
3071 : 1871 : gimple_simplify_101 (gimple_match_op *res_op, gimple_seq *seq,
3072 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3073 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3074 : : {
3075 : 1871 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3076 : 1871 : if (!TYPE_SATURATING (type)
3077 : : )
3078 : : {
3079 : 1871 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
3080 : 3521 : && !FIXED_POINT_TYPE_P (type)
3081 : : )
3082 : : {
3083 : 4 : if (!ANY_INTEGRAL_TYPE_P (type)
3084 : 1650 : || TYPE_OVERFLOW_WRAPS (type)
3085 : : )
3086 : : {
3087 : 39 : gimple_seq *lseq = seq;
3088 : 39 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail738;
3089 : 39 : {
3090 : 39 : res_op->set_op (NEGATE_EXPR, type, 1);
3091 : 39 : {
3092 : 39 : tree _o1[1], _r1;
3093 : 39 : _o1[0] = captures[1];
3094 : 39 : if (type != TREE_TYPE (_o1[0]) /* XXX */
3095 : 39 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
3096 : : {
3097 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, type, _o1[0]);
3098 : 2 : tem_op.resimplify (lseq, valueize);
3099 : 2 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3100 : 2 : if (!_r1) goto next_after_fail738;
3101 : : }
3102 : : else
3103 : : _r1 = _o1[0];
3104 : 38 : res_op->ops[0] = _r1;
3105 : : }
3106 : 38 : res_op->resimplify (lseq, valueize);
3107 : 38 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 230, __FILE__, __LINE__, true);
3108 : 38 : return true;
3109 : : }
3110 : : next_after_fail738:;
3111 : : }
3112 : : else
3113 : : {
3114 : 1611 : gimple_seq *lseq = seq;
3115 : 1611 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail739;
3116 : 1611 : {
3117 : 1611 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3118 : 1611 : {
3119 : 1611 : tree _o1[1], _r1;
3120 : 1611 : _o1[0] = captures[1];
3121 : 1611 : (*res_op).set_op (NEGATE_EXPR, TREE_TYPE (_o1[0]), 1);
3122 : 1611 : (*res_op).ops[0] = _o1[0];
3123 : 1611 : (*res_op).resimplify (lseq, valueize);
3124 : : }
3125 : 1611 : if (type != res_op->type
3126 : 1611 : && !useless_type_conversion_p (type, res_op->type))
3127 : : {
3128 : 2 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail739;
3129 : 1 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
3130 : 1 : res_op->resimplify (lseq, valueize);
3131 : : }
3132 : 1610 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 231, __FILE__, __LINE__, true);
3133 : 1610 : return true;
3134 : : }
3135 : : next_after_fail739:;
3136 : : }
3137 : : }
3138 : : }
3139 : : return false;
3140 : : }
3141 : :
3142 : : bool
3143 : 9 : gimple_simplify_106 (gimple_match_op *res_op, gimple_seq *seq,
3144 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3145 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3146 : : {
3147 : 9 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3148 : 9 : if (!TYPE_SATURATING (type)
3149 : : )
3150 : : {
3151 : 9 : if ((!FLOAT_TYPE_P (type) || flag_associative_math)
3152 : 18 : && !FIXED_POINT_TYPE_P (type)
3153 : : )
3154 : : {
3155 : 18 : if (!TYPE_OVERFLOW_TRAPS (type)
3156 : 9 : && TREE_CODE (type) != COMPLEX_TYPE
3157 : 9 : && tree_nop_conversion_p (type, TREE_TYPE (captures[0]))
3158 : : )
3159 : : {
3160 : 0 : gimple_seq *lseq = seq;
3161 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail747;
3162 : 0 : {
3163 : 0 : res_op->set_op (BIT_NOT_EXPR, type, 1);
3164 : 0 : {
3165 : 0 : tree _o1[1], _r1;
3166 : 0 : _o1[0] = captures[0];
3167 : 0 : if (type != TREE_TYPE (_o1[0]) /* XXX */
3168 : 0 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
3169 : : {
3170 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
3171 : 0 : tem_op.resimplify (lseq, valueize);
3172 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3173 : 0 : if (!_r1) goto next_after_fail747;
3174 : : }
3175 : : else
3176 : : _r1 = _o1[0];
3177 : 0 : res_op->ops[0] = _r1;
3178 : : }
3179 : 0 : res_op->resimplify (lseq, valueize);
3180 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 239, __FILE__, __LINE__, true);
3181 : 0 : return true;
3182 : : }
3183 : : next_after_fail747:;
3184 : : }
3185 : : }
3186 : : }
3187 : : return false;
3188 : : }
3189 : :
3190 : : bool
3191 : 18 : gimple_simplify_110 (gimple_match_op *res_op, gimple_seq *seq,
3192 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3193 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3194 : : {
3195 : 18 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3196 : 18 : if (INTEGRAL_TYPE_P (type)
3197 : : && (
3198 : : 1
3199 : : || !TREE_SIDE_EFFECTS (captures[1]))
3200 : : )
3201 : : {
3202 : 18 : gimple_seq *lseq = seq;
3203 : 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail753;
3204 : 18 : {
3205 : 18 : res_op->set_op (COND_EXPR, type, 3);
3206 : 18 : {
3207 : 18 : tree _o1[1], _r1;
3208 : 18 : _o1[0] = captures[2];
3209 : 18 : if (boolean_type_node != TREE_TYPE (_o1[0]) /* XXX */
3210 : 18 : && !useless_type_conversion_p (boolean_type_node, TREE_TYPE (_o1[0])))
3211 : : {
3212 : 18 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, boolean_type_node, _o1[0]);
3213 : 18 : tem_op.resimplify (lseq, valueize);
3214 : 18 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3215 : 18 : if (!_r1) goto next_after_fail753;
3216 : : }
3217 : : else
3218 : : _r1 = _o1[0];
3219 : 18 : res_op->ops[0] = _r1;
3220 : : }
3221 : 18 : res_op->ops[1] = captures[1];
3222 : 18 : res_op->ops[2] = captures[0];
3223 : 18 : res_op->resimplify (lseq, valueize);
3224 : 18 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 245, __FILE__, __LINE__, true);
3225 : 18 : return true;
3226 : : }
3227 : : next_after_fail753:;
3228 : : }
3229 : : return false;
3230 : : }
3231 : :
3232 : : bool
3233 : 72 : gimple_simplify_111 (gimple_match_op *res_op, gimple_seq *seq,
3234 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3235 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3236 : : {
3237 : 72 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3238 : 72 : if (VECTOR_TYPE_P (type)
3239 : 72 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
3240 : : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[3])))
3241 : 216 : && (TYPE_MODE (TREE_TYPE (type))
3242 : 72 : == TYPE_MODE (TREE_TYPE (TREE_TYPE (captures[3]))))
3243 : : )
3244 : : {
3245 : 72 : gimple_seq *lseq = seq;
3246 : 72 : if (lseq
3247 : 0 : && (!single_use (captures[1])))
3248 : 72 : lseq = NULL;
3249 : 72 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail754;
3250 : 72 : {
3251 : 72 : res_op->set_op (PLUS_EXPR, type, 2);
3252 : 72 : res_op->ops[0] = captures[0];
3253 : 72 : {
3254 : 72 : tree _r1;
3255 : 72 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
3256 : 72 : {
3257 : 72 : tree _o2[3], _r2;
3258 : 72 : _o2[0] = captures[2];
3259 : 72 : {
3260 : 72 : tree _o3[1], _r3;
3261 : 72 : _o3[0] = captures[3];
3262 : 72 : gimple_match_op tem_op (res_op->cond.any_else (), NEGATE_EXPR, TREE_TYPE (_o3[0]), _o3[0]);
3263 : 72 : tem_op.resimplify (lseq, valueize);
3264 : 72 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
3265 : 72 : if (!_r3) goto next_after_fail754;
3266 : 72 : _o2[1] = _r3;
3267 : : }
3268 : 72 : _o2[2] = captures[4];
3269 : 72 : tem_op.set_op (VEC_COND_EXPR, TREE_TYPE (_o2[1]), 3);
3270 : 72 : tem_op.ops[0] = _o2[0];
3271 : 72 : tem_op.ops[1] = _o2[1];
3272 : 72 : tem_op.ops[2] = _o2[2];
3273 : 72 : tem_op.resimplify (lseq, valueize);
3274 : : }
3275 : 72 : if (type != tem_op.type
3276 : 72 : && !useless_type_conversion_p (type, tem_op.type))
3277 : : {
3278 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3279 : 0 : if (!_r1) goto next_after_fail754;
3280 : 0 : tem_op.set_op (VIEW_CONVERT_EXPR, type, 1);
3281 : 0 : tem_op.ops[0] = _r1;
3282 : 0 : tem_op.resimplify (lseq, valueize);
3283 : : }
3284 : 72 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3285 : 72 : if (!_r1) goto next_after_fail754;
3286 : 0 : res_op->ops[1] = _r1;
3287 : : }
3288 : 0 : res_op->resimplify (lseq, valueize);
3289 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 246, __FILE__, __LINE__, true);
3290 : 0 : return true;
3291 : : }
3292 : : next_after_fail754:;
3293 : : }
3294 : : return false;
3295 : : }
3296 : :
3297 : : bool
3298 : 41867 : gimple_simplify_115 (gimple_match_op *res_op, gimple_seq *seq,
3299 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3300 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3301 : : const enum tree_code ARG_UNUSED (bitop),
3302 : : const enum tree_code ARG_UNUSED (cmp))
3303 : : {
3304 : 41867 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3305 : 83087 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
3306 : 33703 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
3307 : 73843 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[2]))
3308 : : )
3309 : : {
3310 : 16839 : gimple_seq *lseq = seq;
3311 : 16839 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail758;
3312 : 16839 : {
3313 : 16839 : res_op->set_op (cmp, type, 2);
3314 : 16839 : {
3315 : 16839 : tree _o1[2], _r1;
3316 : 16839 : _o1[0] = captures[0];
3317 : 16839 : {
3318 : 16839 : tree _o2[1], _r2;
3319 : 16839 : _o2[0] = captures[2];
3320 : 16839 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (_o2[0]) /* XXX */
3321 : 16839 : && !useless_type_conversion_p (TREE_TYPE (_o1[0]), TREE_TYPE (_o2[0])))
3322 : : {
3323 : 539 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
3324 : 539 : tem_op.resimplify (lseq, valueize);
3325 : 539 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
3326 : 539 : if (!_r2) goto next_after_fail758;
3327 : : }
3328 : : else
3329 : : _r2 = _o2[0];
3330 : 16333 : _o1[1] = _r2;
3331 : : }
3332 : 16333 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3333 : 16333 : tem_op.resimplify (lseq, valueize);
3334 : 16333 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3335 : 16333 : if (!_r1) goto next_after_fail758;
3336 : 4570 : res_op->ops[0] = _r1;
3337 : : }
3338 : 4570 : res_op->ops[1] = captures[1];
3339 : 4570 : res_op->resimplify (lseq, valueize);
3340 : 4570 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 250, __FILE__, __LINE__, true);
3341 : 4570 : return true;
3342 : : }
3343 : : next_after_fail758:;
3344 : : }
3345 : : return false;
3346 : : }
3347 : :
3348 : : bool
3349 : 2 : gimple_simplify_121 (gimple_match_op *res_op, gimple_seq *seq,
3350 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3351 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3352 : : {
3353 : 2 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3354 : 2 : gimple_seq *lseq = seq;
3355 : 2 : if (lseq
3356 : 1 : && (!single_use (captures[1])))
3357 : 1 : lseq = NULL;
3358 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail764;
3359 : 2 : {
3360 : 2 : res_op->set_op (BIT_IOR_EXPR, type, 2);
3361 : 2 : res_op->ops[0] = captures[0];
3362 : 2 : {
3363 : 2 : tree _o1[1], _r1;
3364 : 2 : _o1[0] = captures[2];
3365 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
3366 : 2 : tem_op.resimplify (lseq, valueize);
3367 : 2 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3368 : 2 : if (!_r1) goto next_after_fail764;
3369 : 1 : res_op->ops[1] = _r1;
3370 : : }
3371 : 1 : res_op->resimplify (lseq, valueize);
3372 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 255, __FILE__, __LINE__, true);
3373 : : return true;
3374 : : }
3375 : : next_after_fail764:;
3376 : : return false;
3377 : : }
3378 : :
3379 : : bool
3380 : 300 : gimple_simplify_125 (gimple_match_op *res_op, gimple_seq *seq,
3381 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3382 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3383 : : const enum tree_code ARG_UNUSED (op))
3384 : : {
3385 : 300 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3386 : 300 : gimple_seq *lseq = seq;
3387 : 300 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail768;
3388 : 300 : {
3389 : 300 : tree tem;
3390 : 300 : tem = captures[0];
3391 : 300 : res_op->set_value (tem);
3392 : 300 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 257, __FILE__, __LINE__, true);
3393 : : return true;
3394 : : }
3395 : 0 : next_after_fail768:;
3396 : 0 : return false;
3397 : : }
3398 : :
3399 : : bool
3400 : 0 : gimple_simplify_129 (gimple_match_op *res_op, gimple_seq *seq,
3401 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3402 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3403 : : {
3404 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3405 : 0 : gimple_seq *lseq = seq;
3406 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail772;
3407 : 0 : {
3408 : 0 : res_op->set_op (BIT_IOR_EXPR, type, 2);
3409 : 0 : res_op->ops[0] = captures[0];
3410 : 0 : res_op->ops[1] = captures[3];
3411 : 0 : res_op->resimplify (lseq, valueize);
3412 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 261, __FILE__, __LINE__, true);
3413 : : return true;
3414 : : }
3415 : 0 : next_after_fail772:;
3416 : 0 : return false;
3417 : : }
3418 : :
3419 : : bool
3420 : 11110 : gimple_simplify_133 (gimple_match_op *res_op, gimple_seq *seq,
3421 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3422 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3423 : : const enum tree_code ARG_UNUSED (bitop))
3424 : : {
3425 : 11110 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3426 : 11110 : gimple_seq *lseq = seq;
3427 : 11110 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail776;
3428 : 11110 : {
3429 : 11110 : tree tem;
3430 : 11110 : tem = captures[0];
3431 : 11110 : res_op->set_value (tem);
3432 : 11110 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 263, __FILE__, __LINE__, true);
3433 : : return true;
3434 : : }
3435 : 0 : next_after_fail776:;
3436 : 0 : return false;
3437 : : }
3438 : :
3439 : : bool
3440 : 0 : gimple_simplify_136 (gimple_match_op *res_op, gimple_seq *seq,
3441 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3442 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3443 : : {
3444 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3445 : 0 : gimple_seq *lseq = seq;
3446 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail779;
3447 : 0 : {
3448 : 0 : tree tem;
3449 : 0 : tem = captures[0];
3450 : 0 : res_op->set_value (tem);
3451 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 264, __FILE__, __LINE__, true);
3452 : : return true;
3453 : : }
3454 : 0 : next_after_fail779:;
3455 : 0 : return false;
3456 : : }
3457 : :
3458 : : bool
3459 : 520 : gimple_simplify_139 (gimple_match_op *res_op, gimple_seq *seq,
3460 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3461 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3462 : : const enum tree_code ARG_UNUSED (op))
3463 : : {
3464 : 520 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3465 : 520 : gimple_seq *lseq = seq;
3466 : 520 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail782;
3467 : 520 : {
3468 : 520 : tree tem;
3469 : 520 : tem = captures[0];
3470 : 520 : res_op->set_value (tem);
3471 : 520 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 258, __FILE__, __LINE__, true);
3472 : : return true;
3473 : : }
3474 : 0 : next_after_fail782:;
3475 : 0 : return false;
3476 : : }
3477 : :
3478 : : bool
3479 : 47 : gimple_simplify_142 (gimple_match_op *res_op, gimple_seq *seq,
3480 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3481 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3482 : : const enum tree_code ARG_UNUSED (op))
3483 : : {
3484 : 47 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3485 : 47 : if (tree_nop_conversion_p (type, TREE_TYPE (captures[3]))
3486 : 47 : && tree_nop_conversion_p (type, TREE_TYPE (captures[6]))
3487 : : )
3488 : : {
3489 : 47 : if (single_use (captures[4]) && single_use (captures[5])
3490 : : )
3491 : : {
3492 : 23 : gimple_seq *lseq = seq;
3493 : 23 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail786;
3494 : 23 : {
3495 : 23 : res_op->set_op (op, type, 2);
3496 : 23 : res_op->ops[0] = captures[0];
3497 : 23 : {
3498 : 23 : tree _o1[1], _r1;
3499 : 23 : _o1[0] = captures[6];
3500 : 23 : if (type != TREE_TYPE (_o1[0]) /* XXX */
3501 : 23 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
3502 : : {
3503 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
3504 : 0 : tem_op.resimplify (lseq, valueize);
3505 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3506 : 0 : if (!_r1) goto next_after_fail786;
3507 : : }
3508 : : else
3509 : : _r1 = _o1[0];
3510 : 23 : res_op->ops[1] = _r1;
3511 : : }
3512 : 23 : res_op->resimplify (lseq, valueize);
3513 : 23 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 269, __FILE__, __LINE__, true);
3514 : 23 : return true;
3515 : : }
3516 : : next_after_fail786:;
3517 : : }
3518 : : else
3519 : : {
3520 : 24 : if (single_use (captures[0]) && single_use (captures[1])
3521 : : )
3522 : : {
3523 : 6 : gimple_seq *lseq = seq;
3524 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail787;
3525 : 6 : {
3526 : 6 : res_op->set_op (op, type, 2);
3527 : 6 : {
3528 : 6 : tree _o1[1], _r1;
3529 : 6 : _o1[0] = captures[3];
3530 : 6 : if (type != TREE_TYPE (_o1[0]) /* XXX */
3531 : 6 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
3532 : : {
3533 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
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_fail787;
3537 : : }
3538 : : else
3539 : : _r1 = _o1[0];
3540 : 6 : res_op->ops[0] = _r1;
3541 : : }
3542 : 6 : res_op->ops[1] = captures[4];
3543 : 6 : res_op->resimplify (lseq, valueize);
3544 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 270, __FILE__, __LINE__, true);
3545 : 6 : return true;
3546 : : }
3547 : : next_after_fail787:;
3548 : : }
3549 : : }
3550 : : }
3551 : : return false;
3552 : : }
3553 : :
3554 : : bool
3555 : 1319636 : gimple_simplify_146 (gimple_match_op *res_op, gimple_seq *seq,
3556 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3557 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3558 : : const enum tree_code ARG_UNUSED (bitop),
3559 : : const enum tree_code ARG_UNUSED (rbitop))
3560 : : {
3561 : 1319636 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3562 : 1319636 : {
3563 : 1319636 : bool wascmp;
3564 : 1319636 : if (bitwise_inverted_equal_p (captures[2], captures[0], wascmp)
3565 : 1319636 : && (!wascmp || element_precision (type) == 1)
3566 : : )
3567 : : {
3568 : 2963 : gimple_seq *lseq = seq;
3569 : 2963 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail793;
3570 : 2963 : {
3571 : 2963 : res_op->set_op (bitop, type, 2);
3572 : 2963 : res_op->ops[0] = captures[2];
3573 : 2963 : res_op->ops[1] = captures[1];
3574 : 2963 : res_op->resimplify (lseq, valueize);
3575 : 2963 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 272, __FILE__, __LINE__, true);
3576 : 2963 : return true;
3577 : : }
3578 : 0 : next_after_fail793:;
3579 : : }
3580 : : }
3581 : 1316673 : return false;
3582 : : }
3583 : :
3584 : : bool
3585 : 92 : gimple_simplify_149 (gimple_match_op *res_op, gimple_seq *seq,
3586 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3587 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3588 : : const enum tree_code ARG_UNUSED (op))
3589 : : {
3590 : 92 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3591 : 92 : if (bitwise_equal_p (captures[4], captures[7])
3592 : : )
3593 : : {
3594 : 0 : gimple_seq *lseq = seq;
3595 : 0 : if (lseq
3596 : 0 : && (!single_use (captures[0])
3597 : 0 : || !single_use (captures[1])
3598 : 0 : || !single_use (captures[2])
3599 : 0 : || !single_use (captures[3])))
3600 : 0 : lseq = NULL;
3601 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail796;
3602 : 0 : {
3603 : 0 : res_op->set_op (NOP_EXPR, type, 1);
3604 : 0 : {
3605 : 0 : tree _o1[2], _r1;
3606 : 0 : {
3607 : 0 : tree _o2[2], _r2;
3608 : 0 : _o2[0] = captures[5];
3609 : 0 : {
3610 : 0 : tree _o3[1], _r3;
3611 : 0 : _o3[0] = captures[6];
3612 : 0 : if (TREE_TYPE (_o2[0]) != TREE_TYPE (_o3[0]) /* XXX */
3613 : 0 : && !useless_type_conversion_p (TREE_TYPE (_o2[0]), TREE_TYPE (_o3[0])))
3614 : : {
3615 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (_o2[0]), _o3[0]);
3616 : 0 : tem_op.resimplify (lseq, valueize);
3617 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
3618 : 0 : if (!_r3) goto next_after_fail796;
3619 : : }
3620 : : else
3621 : : _r3 = _o3[0];
3622 : 0 : _o2[1] = _r3;
3623 : : }
3624 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
3625 : 0 : tem_op.resimplify (lseq, valueize);
3626 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
3627 : 0 : if (!_r2) goto next_after_fail796;
3628 : 0 : _o1[0] = _r2;
3629 : : }
3630 : 0 : {
3631 : 0 : tree _o2[1], _r2;
3632 : 0 : _o2[0] = captures[4];
3633 : 0 : if (TREE_TYPE (_o1[0]) != TREE_TYPE (_o2[0]) /* XXX */
3634 : 0 : && !useless_type_conversion_p (TREE_TYPE (_o1[0]), TREE_TYPE (_o2[0])))
3635 : : {
3636 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (_o1[0]), _o2[0]);
3637 : 0 : tem_op.resimplify (lseq, valueize);
3638 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
3639 : 0 : if (!_r2) goto next_after_fail796;
3640 : : }
3641 : : else
3642 : : _r2 = _o2[0];
3643 : 0 : _o1[1] = _r2;
3644 : : }
3645 : 0 : (*res_op).set_op (BIT_IOR_EXPR, TREE_TYPE (_o1[0]), 2);
3646 : 0 : (*res_op).ops[0] = _o1[0];
3647 : 0 : (*res_op).ops[1] = _o1[1];
3648 : 0 : (*res_op).resimplify (lseq, valueize);
3649 : : }
3650 : 0 : if (type != res_op->type
3651 : 0 : && !useless_type_conversion_p (type, res_op->type))
3652 : : {
3653 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail796;
3654 : 0 : res_op->set_op (NOP_EXPR, type, 1);
3655 : 0 : res_op->resimplify (lseq, valueize);
3656 : : }
3657 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 275, __FILE__, __LINE__, true);
3658 : 0 : return true;
3659 : : }
3660 : : next_after_fail796:;
3661 : : }
3662 : : return false;
3663 : : }
3664 : :
3665 : : bool
3666 : 970 : gimple_simplify_156 (gimple_match_op *res_op, gimple_seq *seq,
3667 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3668 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3669 : : const enum tree_code ARG_UNUSED (cmp),
3670 : : const enum tree_code ARG_UNUSED (icmp))
3671 : : {
3672 : 970 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3673 : 970 : if (INTEGRAL_TYPE_P (type)
3674 : 970 : && invert_tree_comparison (cmp, HONOR_NANS (captures[1])) == icmp
3675 : 970 : && canonicalize_math_after_vectorization_p ()
3676 : : )
3677 : : {
3678 : 208 : gimple_seq *lseq = seq;
3679 : 208 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail804;
3680 : 208 : {
3681 : 208 : res_op->set_op (BIT_AND_EXPR, type, 2);
3682 : 208 : {
3683 : 208 : tree _o1[3], _r1;
3684 : 208 : _o1[0] = captures[0];
3685 : 208 : _o1[1] = captures[3];
3686 : 208 : _o1[2] = captures[5];
3687 : 208 : gimple_match_op tem_op (res_op->cond.any_else (), COND_EXPR, TREE_TYPE (_o1[1]), _o1[0], _o1[1], _o1[2]);
3688 : 208 : tem_op.resimplify (lseq, valueize);
3689 : 208 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3690 : 208 : if (!_r1) goto next_after_fail804;
3691 : 96 : res_op->ops[0] = _r1;
3692 : : }
3693 : 96 : res_op->ops[1] = build_one_cst (type);
3694 : 96 : res_op->resimplify (lseq, valueize);
3695 : 96 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 278, __FILE__, __LINE__, true);
3696 : 96 : return true;
3697 : : }
3698 : : next_after_fail804:;
3699 : : }
3700 : : return false;
3701 : : }
3702 : :
3703 : : bool
3704 : 438 : gimple_simplify_158 (gimple_match_op *res_op, gimple_seq *seq,
3705 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3706 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3707 : : {
3708 : 438 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3709 : 438 : gimple_seq *lseq = seq;
3710 : 438 : if (lseq
3711 : 188 : && (!single_use (captures[0])
3712 : 110 : || !single_use (captures[3])))
3713 : 337 : lseq = NULL;
3714 : 438 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail809;
3715 : 438 : {
3716 : 438 : res_op->set_op (BIT_XOR_EXPR, type, 2);
3717 : 438 : {
3718 : 438 : tree _o1[2], _r1;
3719 : 438 : {
3720 : 438 : tree _o2[2], _r2;
3721 : 438 : _o2[0] = captures[1];
3722 : 438 : _o2[1] = captures[4];
3723 : 438 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
3724 : 438 : tem_op.resimplify (lseq, valueize);
3725 : 438 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
3726 : 438 : if (!_r2) goto next_after_fail809;
3727 : 101 : _o1[0] = _r2;
3728 : : }
3729 : 101 : _o1[1] = captures[2];
3730 : 101 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
3731 : 101 : tem_op.resimplify (lseq, valueize);
3732 : 101 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
3733 : 101 : if (!_r1) goto next_after_fail809;
3734 : 101 : res_op->ops[0] = _r1;
3735 : : }
3736 : 101 : res_op->ops[1] = captures[1];
3737 : 101 : res_op->resimplify (lseq, valueize);
3738 : 101 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 283, __FILE__, __LINE__, true);
3739 : : return true;
3740 : : }
3741 : : next_after_fail809:;
3742 : : return false;
3743 : : }
3744 : :
3745 : : bool
3746 : 79934 : gimple_simplify_164 (gimple_match_op *res_op, gimple_seq *seq,
3747 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3748 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3749 : : const enum tree_code ARG_UNUSED (code2),
3750 : : const enum tree_code ARG_UNUSED (code1))
3751 : : {
3752 : 79934 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3753 : 79934 : if ((TREE_CODE (captures[2]) == INTEGER_CST
3754 : 37343 : && TREE_CODE (captures[4]) == INTEGER_CST)
3755 : 95760 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
3756 : 1757 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
3757 : 56997 : && operand_equal_p (captures[2], captures[4]))
3758 : : )
3759 : : {
3760 : 21532 : {
3761 : 21532 : int cmp = 0;
3762 : 21532 : if (TREE_CODE (captures[2]) == INTEGER_CST
3763 : 21517 : && TREE_CODE (captures[4]) == INTEGER_CST)
3764 : 21517 : cmp = tree_int_cst_compare (captures[2], captures[4]);
3765 : 21532 : if ((code1 == LT_EXPR || code1 == LE_EXPR)
3766 : 18259 : && (code2 == LT_EXPR || code2 == LE_EXPR)
3767 : : )
3768 : : {
3769 : 130 : if ((cmp < 0) || (cmp == 0 && code1 == LT_EXPR)
3770 : : )
3771 : : {
3772 : 50 : gimple_seq *lseq = seq;
3773 : 50 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail827;
3774 : 50 : {
3775 : 50 : tree tem;
3776 : 50 : tem = captures[3];
3777 : 50 : res_op->set_value (tem);
3778 : 50 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 294, __FILE__, __LINE__, true);
3779 : 50 : return true;
3780 : : }
3781 : 0 : next_after_fail827:;
3782 : 0 : }
3783 : : else
3784 : : {
3785 : 80 : gimple_seq *lseq = seq;
3786 : 80 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail828;
3787 : 80 : {
3788 : 80 : tree tem;
3789 : 80 : tem = captures[0];
3790 : 80 : res_op->set_value (tem);
3791 : 80 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 295, __FILE__, __LINE__, true);
3792 : 80 : return true;
3793 : : }
3794 : 0 : next_after_fail828:;
3795 : : }
3796 : : }
3797 : : else
3798 : : {
3799 : 21402 : if ((code1 == GT_EXPR || code1 == GE_EXPR)
3800 : 3273 : && (code2 == GT_EXPR || code2 == GE_EXPR)
3801 : : )
3802 : : {
3803 : 31 : if ((cmp > 0) || (cmp == 0 && code1 == GT_EXPR)
3804 : : )
3805 : : {
3806 : 20 : gimple_seq *lseq = seq;
3807 : 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail829;
3808 : 20 : {
3809 : 20 : tree tem;
3810 : 20 : tem = captures[3];
3811 : 20 : res_op->set_value (tem);
3812 : 20 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 296, __FILE__, __LINE__, true);
3813 : 20 : return true;
3814 : : }
3815 : 0 : next_after_fail829:;
3816 : 0 : }
3817 : : else
3818 : : {
3819 : 11 : gimple_seq *lseq = seq;
3820 : 11 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail830;
3821 : 11 : {
3822 : 11 : tree tem;
3823 : 11 : tem = captures[0];
3824 : 11 : res_op->set_value (tem);
3825 : 11 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 297, __FILE__, __LINE__, true);
3826 : 11 : return true;
3827 : : }
3828 : 0 : next_after_fail830:;
3829 : : }
3830 : : }
3831 : : else
3832 : : {
3833 : 21371 : if (cmp == 0
3834 : 12 : && ((code1 == LT_EXPR && code2 == GT_EXPR)
3835 : 8 : || (code1 == GT_EXPR && code2 == LT_EXPR))
3836 : : )
3837 : : {
3838 : 12 : gimple_seq *lseq = seq;
3839 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail831;
3840 : 12 : {
3841 : 12 : res_op->set_op (NE_EXPR, type, 2);
3842 : 12 : res_op->ops[0] = captures[1];
3843 : 12 : res_op->ops[1] = captures[4];
3844 : 12 : res_op->resimplify (lseq, valueize);
3845 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 298, __FILE__, __LINE__, true);
3846 : 12 : return true;
3847 : : }
3848 : 0 : next_after_fail831:;
3849 : 0 : }
3850 : : else
3851 : : {
3852 : 21359 : if (cmp >= 0
3853 : 3242 : && (code1 == LT_EXPR || code1 == LE_EXPR)
3854 : 8 : && (code2 == GT_EXPR || code2 == GE_EXPR)
3855 : : )
3856 : : {
3857 : 8 : gimple_seq *lseq = seq;
3858 : 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail832;
3859 : 8 : {
3860 : 8 : tree tem;
3861 : 8 : tem = constant_boolean_node (true, type);
3862 : 8 : res_op->set_value (tem);
3863 : 8 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 299, __FILE__, __LINE__, true);
3864 : 8 : return true;
3865 : : }
3866 : 0 : next_after_fail832:;
3867 : 0 : }
3868 : : else
3869 : : {
3870 : 3234 : if (cmp <= 0
3871 : 18117 : && (code1 == GT_EXPR || code1 == GE_EXPR)
3872 : 0 : && (code2 == LT_EXPR || code2 == LE_EXPR)
3873 : : )
3874 : : {
3875 : 0 : gimple_seq *lseq = seq;
3876 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail833;
3877 : 0 : {
3878 : 0 : tree tem;
3879 : 0 : tem = constant_boolean_node (true, type);
3880 : 0 : res_op->set_value (tem);
3881 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 300, __FILE__, __LINE__, true);
3882 : 0 : return true;
3883 : : }
3884 : 0 : next_after_fail833:;
3885 : : }
3886 : : }
3887 : : }
3888 : : }
3889 : : }
3890 : : }
3891 : : }
3892 : : return false;
3893 : : }
3894 : :
3895 : : bool
3896 : 14 : gimple_simplify_173 (gimple_match_op *res_op, gimple_seq *seq,
3897 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3898 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3899 : : {
3900 : 14 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3901 : 14 : gimple_seq *lseq = seq;
3902 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail855;
3903 : 14 : {
3904 : 14 : tree tem;
3905 : 14 : tem = constant_boolean_node (true, type);
3906 : 14 : res_op->set_value (tem);
3907 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 303, __FILE__, __LINE__, true);
3908 : : return true;
3909 : : }
3910 : 0 : next_after_fail855:;
3911 : 0 : return false;
3912 : : }
3913 : :
3914 : : bool
3915 : 12 : gimple_simplify_174 (gimple_match_op *res_op, gimple_seq *seq,
3916 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3917 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
3918 : : const enum tree_code ARG_UNUSED (eqne))
3919 : : {
3920 : 12 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3921 : 12 : if (eqne == EQ_EXPR
3922 : : )
3923 : : {
3924 : 6 : gimple_seq *lseq = seq;
3925 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail856;
3926 : 6 : {
3927 : 6 : tree tem;
3928 : 6 : tem = captures[0];
3929 : 6 : res_op->set_value (tem);
3930 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 304, __FILE__, __LINE__, true);
3931 : 6 : return true;
3932 : : }
3933 : 0 : next_after_fail856:;
3934 : : }
3935 : : else
3936 : : {
3937 : 6 : if (eqne == NE_EXPR
3938 : : )
3939 : : {
3940 : 6 : gimple_seq *lseq = seq;
3941 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail857;
3942 : 6 : {
3943 : 6 : tree tem;
3944 : 6 : tem = constant_boolean_node (true, type);
3945 : 6 : res_op->set_value (tem);
3946 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 305, __FILE__, __LINE__, true);
3947 : 6 : return true;
3948 : : }
3949 : 0 : next_after_fail857:;
3950 : : }
3951 : : }
3952 : : return false;
3953 : : }
3954 : :
3955 : : bool
3956 : 45 : gimple_simplify_175 (gimple_match_op *res_op, gimple_seq *seq,
3957 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3958 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3959 : : {
3960 : 45 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3961 : 45 : gimple_seq *lseq = seq;
3962 : 45 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail858;
3963 : 45 : {
3964 : 45 : tree tem;
3965 : 45 : tem = captures[0];
3966 : 45 : res_op->set_value (tem);
3967 : 45 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 306, __FILE__, __LINE__, true);
3968 : : return true;
3969 : : }
3970 : 0 : next_after_fail858:;
3971 : 0 : return false;
3972 : : }
3973 : :
3974 : : bool
3975 : 0 : gimple_simplify_178 (gimple_match_op *res_op, gimple_seq *seq,
3976 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3977 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3978 : : {
3979 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
3980 : 0 : gimple_seq *lseq = seq;
3981 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail861;
3982 : 0 : {
3983 : 0 : res_op->set_op (NE_EXPR, type, 2);
3984 : 0 : res_op->ops[0] = captures[2];
3985 : 0 : res_op->ops[1] = captures[3];
3986 : 0 : res_op->resimplify (lseq, valueize);
3987 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 307, __FILE__, __LINE__, true);
3988 : : return true;
3989 : : }
3990 : 0 : next_after_fail861:;
3991 : 0 : return false;
3992 : : }
3993 : :
3994 : : bool
3995 : 0 : gimple_simplify_181 (gimple_match_op *res_op, gimple_seq *seq,
3996 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
3997 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
3998 : : {
3999 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4000 : 0 : gimple_seq *lseq = seq;
4001 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail864;
4002 : 0 : {
4003 : 0 : res_op->set_op (EQ_EXPR, type, 2);
4004 : 0 : res_op->ops[0] = captures[0];
4005 : 0 : res_op->ops[1] = captures[1];
4006 : 0 : res_op->resimplify (lseq, valueize);
4007 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 309, __FILE__, __LINE__, true);
4008 : : return true;
4009 : : }
4010 : 0 : next_after_fail864:;
4011 : 0 : return false;
4012 : : }
4013 : :
4014 : : bool
4015 : 173223 : gimple_simplify_185 (gimple_match_op *res_op, gimple_seq *seq,
4016 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4017 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4018 : : const enum tree_code ARG_UNUSED (logic),
4019 : : const enum tree_code ARG_UNUSED (op),
4020 : : const enum tree_code ARG_UNUSED (ext))
4021 : : {
4022 : 173223 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4023 : 346446 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
4024 : 323261 : && TREE_CODE (captures[1]) != INTEGER_CST
4025 : : )
4026 : : {
4027 : 110872 : gimple_seq *lseq = seq;
4028 : 110872 : if (lseq
4029 : 5059 : && (!single_use (captures[0])
4030 : 5049 : || !single_use (captures[3])))
4031 : 105823 : lseq = NULL;
4032 : 110872 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail868;
4033 : 110872 : {
4034 : 110872 : res_op->set_op (op, type, 2);
4035 : 110872 : res_op->ops[0] = captures[1];
4036 : 110872 : {
4037 : 110872 : tree _o1[2], _r1;
4038 : 110872 : _o1[0] = captures[2];
4039 : 110872 : _o1[1] = captures[4];
4040 : 110872 : gimple_match_op tem_op (res_op->cond.any_else (), ext, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4041 : 110872 : tem_op.resimplify (lseq, valueize);
4042 : 110872 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4043 : 110872 : if (!_r1) goto next_after_fail868;
4044 : 5051 : res_op->ops[1] = _r1;
4045 : : }
4046 : 5051 : res_op->resimplify (lseq, valueize);
4047 : 5051 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 311, __FILE__, __LINE__, true);
4048 : 5051 : return true;
4049 : : }
4050 : : next_after_fail868:;
4051 : : }
4052 : : return false;
4053 : : }
4054 : :
4055 : : bool
4056 : 0 : gimple_simplify_192 (gimple_match_op *res_op, gimple_seq *seq,
4057 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4058 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
4059 : : {
4060 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4061 : 0 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
4062 : : )
4063 : : {
4064 : 0 : gimple_seq *lseq = seq;
4065 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail876;
4066 : 0 : {
4067 : 0 : res_op->set_op (NEGATE_EXPR, type, 1);
4068 : 0 : {
4069 : 0 : tree _o1[1], _r1;
4070 : 0 : _o1[0] = captures[0];
4071 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
4072 : 0 : tem_op.resimplify (lseq, valueize);
4073 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4074 : 0 : if (!_r1) goto next_after_fail876;
4075 : 0 : res_op->ops[0] = _r1;
4076 : : }
4077 : 0 : res_op->resimplify (lseq, valueize);
4078 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 316, __FILE__, __LINE__, true);
4079 : 0 : return true;
4080 : : }
4081 : : next_after_fail876:;
4082 : : }
4083 : : return false;
4084 : : }
4085 : :
4086 : : bool
4087 : 0 : gimple_simplify_197 (gimple_match_op *res_op, gimple_seq *seq,
4088 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4089 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
4090 : : {
4091 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4092 : 0 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
4093 : : )
4094 : : {
4095 : 0 : gimple_seq *lseq = seq;
4096 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail881;
4097 : 0 : {
4098 : 0 : res_op->set_op (NEGATE_EXPR, type, 1);
4099 : 0 : {
4100 : 0 : tree _o1[1], _r1;
4101 : 0 : _o1[0] = captures[0];
4102 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
4103 : 0 : tem_op.resimplify (lseq, valueize);
4104 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4105 : 0 : if (!_r1) goto next_after_fail881;
4106 : 0 : res_op->ops[0] = _r1;
4107 : : }
4108 : 0 : res_op->resimplify (lseq, valueize);
4109 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 316, __FILE__, __LINE__, true);
4110 : 0 : return true;
4111 : : }
4112 : : next_after_fail881:;
4113 : : }
4114 : : return false;
4115 : : }
4116 : :
4117 : : bool
4118 : 0 : gimple_simplify_203 (gimple_match_op *res_op, gimple_seq *seq,
4119 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4120 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
4121 : : {
4122 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4123 : 0 : if (!tree_expr_maybe_nan_p (captures[0]) && !HONOR_SIGNED_ZEROS (type)
4124 : : )
4125 : : {
4126 : 0 : gimple_seq *lseq = seq;
4127 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail887;
4128 : 0 : {
4129 : 0 : res_op->set_op (NOP_EXPR, type, 1);
4130 : 0 : {
4131 : 0 : tree _o1[1], _r1;
4132 : 0 : _o1[0] = captures[0];
4133 : 0 : (*res_op).set_op (ABS_EXPR, TREE_TYPE (_o1[0]), 1);
4134 : 0 : (*res_op).ops[0] = _o1[0];
4135 : 0 : (*res_op).resimplify (lseq, valueize);
4136 : : }
4137 : 0 : if (type != res_op->type
4138 : 0 : && !useless_type_conversion_p (type, res_op->type))
4139 : : {
4140 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail887;
4141 : 0 : res_op->set_op (NOP_EXPR, type, 1);
4142 : 0 : res_op->resimplify (lseq, valueize);
4143 : : }
4144 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 317, __FILE__, __LINE__, true);
4145 : 0 : return true;
4146 : : }
4147 : : next_after_fail887:;
4148 : : }
4149 : : return false;
4150 : : }
4151 : :
4152 : : bool
4153 : 214194 : gimple_simplify_209 (gimple_match_op *res_op, gimple_seq *seq,
4154 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4155 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4156 : : const enum tree_code ARG_UNUSED (op))
4157 : : {
4158 : 214194 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4159 : 214194 : gimple_seq *lseq = seq;
4160 : 214194 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail893;
4161 : 214194 : {
4162 : 214194 : tree tem;
4163 : 214194 : tem = captures[0];
4164 : 214194 : res_op->set_value (tem);
4165 : 214194 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 320, __FILE__, __LINE__, true);
4166 : : return true;
4167 : : }
4168 : 0 : next_after_fail893:;
4169 : 0 : return false;
4170 : : }
4171 : :
4172 : : bool
4173 : 4 : gimple_simplify_213 (gimple_match_op *res_op, gimple_seq *seq,
4174 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4175 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
4176 : : {
4177 : 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4178 : 4 : if (INTEGRAL_TYPE_P (type)
4179 : 4 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
4180 : 8 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
4181 : : )
4182 : : {
4183 : 4 : if (TYPE_UNSIGNED (type)
4184 : : )
4185 : : {
4186 : 2 : gimple_seq *lseq = seq;
4187 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail898;
4188 : 2 : {
4189 : 2 : res_op->set_op (ABSU_EXPR, type, 1);
4190 : 2 : res_op->ops[0] = captures[0];
4191 : 2 : res_op->resimplify (lseq, valueize);
4192 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 322, __FILE__, __LINE__, true);
4193 : 2 : return true;
4194 : : }
4195 : 0 : next_after_fail898:;
4196 : : }
4197 : : else
4198 : : {
4199 : 2 : gimple_seq *lseq = seq;
4200 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail899;
4201 : 2 : {
4202 : 2 : res_op->set_op (ABS_EXPR, type, 1);
4203 : 2 : res_op->ops[0] = captures[0];
4204 : 2 : res_op->resimplify (lseq, valueize);
4205 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 323, __FILE__, __LINE__, true);
4206 : 2 : return true;
4207 : : }
4208 : 0 : next_after_fail899:;
4209 : : }
4210 : : }
4211 : : return false;
4212 : : }
4213 : :
4214 : : bool
4215 : 7540 : gimple_simplify_220 (gimple_match_op *res_op, gimple_seq *seq,
4216 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4217 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
4218 : : {
4219 : 7540 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4220 : 7540 : {
4221 : 7540 : poly_widest_int factor;
4222 : 7540 : if (multiple_p (wi::to_poly_widest (captures[2]), wi::to_widest (captures[1]), &factor)
4223 : : )
4224 : : {
4225 : 1197 : gimple_seq *lseq = seq;
4226 : 1197 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail906;
4227 : 1197 : {
4228 : 1197 : res_op->set_op (MULT_EXPR, type, 2);
4229 : 1197 : {
4230 : 1197 : tree _o1[1], _r1;
4231 : 1197 : _o1[0] = captures[0];
4232 : 1197 : if (type != TREE_TYPE (_o1[0]) /* XXX */
4233 : 1197 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
4234 : : {
4235 : 1175 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
4236 : 1175 : tem_op.resimplify (lseq, valueize);
4237 : 1175 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4238 : 1175 : if (!_r1) goto next_after_fail906;
4239 : : }
4240 : : else
4241 : : _r1 = _o1[0];
4242 : 970 : res_op->ops[0] = _r1;
4243 : : }
4244 : 970 : res_op->ops[1] = wide_int_to_tree (type, factor);
4245 : 970 : res_op->resimplify (lseq, valueize);
4246 : 970 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 329, __FILE__, __LINE__, true);
4247 : 970 : return true;
4248 : : }
4249 : 6570 : next_after_fail906:;
4250 : : }
4251 : 7540 : }
4252 : 6570 : return false;
4253 : : }
4254 : :
4255 : : bool
4256 : 35 : gimple_simplify_225 (gimple_match_op *res_op, gimple_seq *seq,
4257 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4258 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4259 : : const combined_fn ARG_UNUSED (LDEXP))
4260 : : {
4261 : 35 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4262 : 35 : if (flag_unsafe_math_optimizations
4263 : : )
4264 : : {
4265 : 24 : {
4266 : 24 : HOST_WIDE_INT tmp = 0;
4267 : 24 : if (real_isinteger (&TREE_REAL_CST (captures[0]), &tmp)
4268 : 24 : && tmp > 0 && pow2p_hwi (tmp)
4269 : : )
4270 : : {
4271 : 24 : gimple_seq *lseq = seq;
4272 : 24 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail912;
4273 : 24 : {
4274 : 24 : res_op->set_op (LDEXP, type, 2);
4275 : 24 : res_op->ops[0] = captures[1];
4276 : 24 : {
4277 : 24 : tree _o1[2], _r1;
4278 : 24 : _o1[0] = build_int_cst (integer_type_node,
4279 : 48 : exact_log2 (tmp));
4280 : 24 : _o1[1] = captures[2];
4281 : 24 : gimple_match_op tem_op (res_op->cond.any_else (), PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4282 : 24 : tem_op.resimplify (lseq, valueize);
4283 : 24 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4284 : 24 : if (!_r1) goto next_after_fail912;
4285 : 12 : res_op->ops[1] = _r1;
4286 : : }
4287 : 12 : res_op->resimplify (lseq, valueize);
4288 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 335, __FILE__, __LINE__, true);
4289 : 12 : return true;
4290 : : }
4291 : 12 : next_after_fail912:;
4292 : : }
4293 : : }
4294 : : }
4295 : : return false;
4296 : : }
4297 : :
4298 : : bool
4299 : 1922 : gimple_simplify_231 (gimple_match_op *res_op, gimple_seq *seq,
4300 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4301 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4302 : : const enum tree_code ARG_UNUSED (cmp),
4303 : : const enum tree_code ARG_UNUSED (mod))
4304 : : {
4305 : 1922 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4306 : 1922 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[0]))
4307 : : )
4308 : : {
4309 : 1898 : {
4310 : 1898 : tree utype = unsigned_type_for (TREE_TYPE (captures[0]));
4311 : 1898 : gimple_seq *lseq = seq;
4312 : 1898 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail918;
4313 : 1898 : {
4314 : 1898 : res_op->set_op (cmp, type, 2);
4315 : 1898 : {
4316 : 1898 : tree _o1[2], _r1;
4317 : 1898 : {
4318 : 1898 : tree _o2[1], _r2;
4319 : 1898 : _o2[0] = captures[0];
4320 : 1898 : if (utype != TREE_TYPE (_o2[0]) /* XXX */
4321 : 1898 : && !useless_type_conversion_p (utype, TREE_TYPE (_o2[0])))
4322 : : {
4323 : 1898 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o2[0]);
4324 : 1898 : tem_op.resimplify (lseq, valueize);
4325 : 1898 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
4326 : 1898 : if (!_r2) goto next_after_fail918;
4327 : : }
4328 : : else
4329 : : _r2 = _o2[0];
4330 : 730 : _o1[0] = _r2;
4331 : : }
4332 : 730 : {
4333 : 730 : tree _o2[1], _r2;
4334 : 730 : _o2[0] = captures[1];
4335 : 730 : if (utype != TREE_TYPE (_o2[0]) /* XXX */
4336 : 730 : && !useless_type_conversion_p (utype, TREE_TYPE (_o2[0])))
4337 : : {
4338 : 730 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o2[0]);
4339 : 730 : tem_op.resimplify (lseq, valueize);
4340 : 730 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
4341 : 730 : if (!_r2) goto next_after_fail918;
4342 : : }
4343 : : else
4344 : : _r2 = _o2[0];
4345 : 730 : _o1[1] = _r2;
4346 : : }
4347 : 730 : gimple_match_op tem_op (res_op->cond.any_else (), mod, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
4348 : 730 : tem_op.resimplify (lseq, valueize);
4349 : 730 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4350 : 730 : if (!_r1) goto next_after_fail918;
4351 : 730 : res_op->ops[0] = _r1;
4352 : : }
4353 : 730 : {
4354 : 730 : tree _o1[1], _r1;
4355 : 730 : _o1[0] = captures[2];
4356 : 730 : if (utype != TREE_TYPE (_o1[0]) /* XXX */
4357 : 730 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
4358 : : {
4359 : 730 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o1[0]);
4360 : 730 : tem_op.resimplify (lseq, valueize);
4361 : 730 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4362 : 730 : if (!_r1) goto next_after_fail918;
4363 : : }
4364 : : else
4365 : : _r1 = _o1[0];
4366 : 730 : res_op->ops[1] = _r1;
4367 : : }
4368 : 730 : res_op->resimplify (lseq, valueize);
4369 : 730 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 341, __FILE__, __LINE__, true);
4370 : 730 : return true;
4371 : : }
4372 : : next_after_fail918:;
4373 : : }
4374 : : }
4375 : : return false;
4376 : : }
4377 : :
4378 : : bool
4379 : 62731 : gimple_simplify_243 (gimple_match_op *res_op, gimple_seq *seq,
4380 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4381 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4382 : : const enum tree_code ARG_UNUSED (op))
4383 : : {
4384 : 62731 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4385 : 62731 : if (tree_nop_conversion_p (TREE_TYPE (captures[1]), TREE_TYPE (captures[2]))
4386 : 62731 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
4387 : 125462 : && (CONSTANT_CLASS_P (captures[3]) || (single_use (captures[1]) && single_use (captures[0])))
4388 : : )
4389 : : {
4390 : 16086 : gimple_seq *lseq = seq;
4391 : 16086 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail946;
4392 : 16086 : {
4393 : 16086 : res_op->set_op (op, type, 2);
4394 : 16086 : res_op->ops[0] = captures[3];
4395 : 16086 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[3]));
4396 : 16086 : res_op->resimplify (lseq, valueize);
4397 : 16086 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 368, __FILE__, __LINE__, true);
4398 : 16086 : return true;
4399 : : }
4400 : 0 : next_after_fail946:;
4401 : : }
4402 : : return false;
4403 : : }
4404 : :
4405 : : bool
4406 : 11 : gimple_simplify_247 (gimple_match_op *res_op, gimple_seq *seq,
4407 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4408 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4409 : : const enum tree_code ARG_UNUSED (op))
4410 : : {
4411 : 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4412 : 11 : if (tree_nop_conversion_p (TREE_TYPE (captures[1]), TREE_TYPE (captures[2]))
4413 : 11 : && tree_nop_conversion_p (TREE_TYPE (captures[0]), TREE_TYPE (captures[2]))
4414 : 22 : && (CONSTANT_CLASS_P (captures[3]) || (single_use (captures[1]) && single_use (captures[0])))
4415 : : )
4416 : : {
4417 : 9 : gimple_seq *lseq = seq;
4418 : 9 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail950;
4419 : 9 : {
4420 : 9 : res_op->set_op (op, type, 2);
4421 : 9 : res_op->ops[0] = captures[3];
4422 : 9 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[3]));
4423 : 9 : res_op->resimplify (lseq, valueize);
4424 : 9 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 368, __FILE__, __LINE__, true);
4425 : 9 : return true;
4426 : : }
4427 : 0 : next_after_fail950:;
4428 : : }
4429 : : return false;
4430 : : }
4431 : :
4432 : : bool
4433 : 332774273 : gimple_simplify_252 (gimple_match_op *res_op, gimple_seq *seq,
4434 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4435 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4436 : : const enum tree_code ARG_UNUSED (cmp))
4437 : : {
4438 : 332774273 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4439 : 665552008 : if (wi::bit_and_not (get_known_nonzero_bits (captures[1]),
4440 : 998322819 : get_nonzero_bits (captures[0])) != 0
4441 : : )
4442 : : {
4443 : 13752 : gimple_seq *lseq = seq;
4444 : 13752 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail955;
4445 : 13752 : {
4446 : 13752 : tree tem;
4447 : 13752 : tem = constant_boolean_node (cmp == NE_EXPR, type);
4448 : 13752 : res_op->set_value (tem);
4449 : 13752 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 376, __FILE__, __LINE__, true);
4450 : 13752 : return true;
4451 : : }
4452 : 0 : next_after_fail955:;
4453 : : }
4454 : : return false;
4455 : : }
4456 : :
4457 : : bool
4458 : 1466 : gimple_simplify_256 (gimple_match_op *res_op, gimple_seq *seq,
4459 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4460 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4461 : : const enum tree_code ARG_UNUSED (cmp))
4462 : : {
4463 : 1466 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4464 : 1466 : if (wi::gt_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
4465 : 1466 : TYPE_SIGN (TREE_TYPE (captures[0])))
4466 : : )
4467 : : {
4468 : 2 : gimple_seq *lseq = seq;
4469 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail960;
4470 : 2 : {
4471 : 2 : tree tem;
4472 : 2 : tem = constant_boolean_node (cmp == NE_EXPR, type);
4473 : 2 : res_op->set_value (tem);
4474 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 381, __FILE__, __LINE__, true);
4475 : 2 : return true;
4476 : : }
4477 : 0 : next_after_fail960:;
4478 : : }
4479 : : else
4480 : : {
4481 : 1464 : if (wi::lt_p (wi::to_wide (captures[1]), wi::to_wide (captures[2]),
4482 : 1464 : TYPE_SIGN (TREE_TYPE (captures[0])))
4483 : : )
4484 : : {
4485 : 1464 : gimple_seq *lseq = seq;
4486 : 1464 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail961;
4487 : 1464 : {
4488 : 1464 : res_op->set_op (cmp, type, 2);
4489 : 1464 : res_op->ops[0] = captures[0];
4490 : 1464 : res_op->ops[1] = captures[2];
4491 : 1464 : res_op->resimplify (lseq, valueize);
4492 : 1464 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 382, __FILE__, __LINE__, true);
4493 : 1464 : return true;
4494 : : }
4495 : 0 : next_after_fail961:;
4496 : : }
4497 : : }
4498 : : return false;
4499 : : }
4500 : :
4501 : : bool
4502 : 592 : gimple_simplify_261 (gimple_match_op *res_op, gimple_seq *seq,
4503 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4504 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4505 : : const enum tree_code ARG_UNUSED (cmp),
4506 : : const enum tree_code ARG_UNUSED (icmp))
4507 : : {
4508 : 592 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4509 : 592 : if (tree_int_cst_sgn (captures[0]) > 0
4510 : : )
4511 : : {
4512 : 592 : {
4513 : 592 : int c1 = wi::clz (wi::to_wide (captures[0]));
4514 : 592 : int c2 = wi::clz (wi::to_wide (captures[2]));
4515 : 592 : if (c1 > c2
4516 : : )
4517 : : {
4518 : 0 : gimple_seq *lseq = seq;
4519 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail968;
4520 : 0 : {
4521 : 0 : tree tem;
4522 : 0 : tem = constant_boolean_node (cmp == NE_EXPR ? false : true, type);
4523 : 0 : res_op->set_value (tem);
4524 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 389, __FILE__, __LINE__, true);
4525 : 0 : return true;
4526 : : }
4527 : 0 : next_after_fail968:;
4528 : : }
4529 : : else
4530 : : {
4531 : 592 : gimple_seq *lseq = seq;
4532 : 592 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail969;
4533 : 592 : {
4534 : 592 : res_op->set_op (icmp, type, 2);
4535 : 592 : res_op->ops[0] = captures[1];
4536 : 592 : res_op->ops[1] = build_int_cst (TREE_TYPE (captures[1]), c2 - c1);
4537 : 592 : res_op->resimplify (lseq, valueize);
4538 : 592 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 390, __FILE__, __LINE__, true);
4539 : 592 : return true;
4540 : : }
4541 : 0 : next_after_fail969:;
4542 : : }
4543 : : }
4544 : : }
4545 : : return false;
4546 : : }
4547 : :
4548 : : bool
4549 : 16 : gimple_simplify_265 (gimple_match_op *res_op, gimple_seq *seq,
4550 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4551 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4552 : : const enum tree_code ARG_UNUSED (rotate),
4553 : : const enum tree_code ARG_UNUSED (invrot),
4554 : : const enum tree_code ARG_UNUSED (cmp))
4555 : : {
4556 : 16 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4557 : 16 : gimple_seq *lseq = seq;
4558 : 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail980;
4559 : 16 : {
4560 : 16 : res_op->set_op (cmp, type, 2);
4561 : 16 : res_op->ops[0] = captures[0];
4562 : 16 : res_op->ops[1] = const_binop (invrot, TREE_TYPE (captures[0]), captures[2], captures[1]);
4563 : 16 : res_op->resimplify (lseq, valueize);
4564 : 16 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 401, __FILE__, __LINE__, true);
4565 : : return true;
4566 : : }
4567 : 0 : next_after_fail980:;
4568 : 0 : return false;
4569 : : }
4570 : :
4571 : : bool
4572 : 35 : gimple_simplify_268 (gimple_match_op *res_op, gimple_seq *seq,
4573 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4574 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4575 : : const enum tree_code ARG_UNUSED (cmp),
4576 : : const combined_fn ARG_UNUSED (bswap))
4577 : : {
4578 : 35 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4579 : 35 : {
4580 : 35 : tree ctype = TREE_TYPE (captures[0]);
4581 : 35 : gimple_seq *lseq = seq;
4582 : 35 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail983;
4583 : 35 : {
4584 : 35 : res_op->set_op (cmp, type, 2);
4585 : 35 : {
4586 : 35 : tree _o1[1], _r1;
4587 : 35 : _o1[0] = captures[1];
4588 : 35 : if (ctype != TREE_TYPE (_o1[0]) /* XXX */
4589 : 35 : && !useless_type_conversion_p (ctype, TREE_TYPE (_o1[0])))
4590 : : {
4591 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, ctype, _o1[0]);
4592 : 0 : tem_op.resimplify (lseq, valueize);
4593 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4594 : 0 : if (!_r1) goto next_after_fail983;
4595 : : }
4596 : : else
4597 : : _r1 = _o1[0];
4598 : 35 : res_op->ops[0] = _r1;
4599 : : }
4600 : 35 : {
4601 : 35 : tree _o1[1], _r1;
4602 : 35 : _o1[0] = captures[2];
4603 : 35 : if (ctype != TREE_TYPE (_o1[0]) /* XXX */
4604 : 35 : && !useless_type_conversion_p (ctype, TREE_TYPE (_o1[0])))
4605 : : {
4606 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, ctype, _o1[0]);
4607 : 0 : tem_op.resimplify (lseq, valueize);
4608 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4609 : 0 : if (!_r1) goto next_after_fail983;
4610 : : }
4611 : : else
4612 : : _r1 = _o1[0];
4613 : 35 : res_op->ops[1] = _r1;
4614 : : }
4615 : 35 : res_op->resimplify (lseq, valueize);
4616 : 35 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 404, __FILE__, __LINE__, true);
4617 : : return true;
4618 : : }
4619 : : next_after_fail983:;
4620 : : }
4621 : : return false;
4622 : : }
4623 : :
4624 : : bool
4625 : 47651 : gimple_simplify_274 (gimple_match_op *res_op, gimple_seq *seq,
4626 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4627 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4628 : : const enum tree_code ARG_UNUSED (cmp),
4629 : : const enum tree_code ARG_UNUSED (scmp))
4630 : : {
4631 : 47651 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4632 : 47651 : if (integer_zerop (captures[2])
4633 : : )
4634 : : {
4635 : 0 : gimple_seq *lseq = seq;
4636 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail990;
4637 : 0 : {
4638 : 0 : res_op->set_op (cmp, type, 2);
4639 : 0 : res_op->ops[0] = captures[2];
4640 : 0 : res_op->ops[1] = captures[3];
4641 : 0 : res_op->resimplify (lseq, valueize);
4642 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 410, __FILE__, __LINE__, true);
4643 : 0 : return true;
4644 : : }
4645 : 0 : next_after_fail990:;
4646 : : }
4647 : : else
4648 : : {
4649 : 95302 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
4650 : 95302 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
4651 : 99574 : && single_use (captures[0])
4652 : : )
4653 : : {
4654 : 740 : if (tree_int_cst_sgn (captures[2]) < 0
4655 : : )
4656 : : {
4657 : 3 : gimple_seq *lseq = seq;
4658 : 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail991;
4659 : 3 : {
4660 : 3 : res_op->set_op (scmp, type, 2);
4661 : 3 : res_op->ops[0] = captures[1];
4662 : 3 : res_op->ops[1] = captures[3];
4663 : 3 : res_op->resimplify (lseq, valueize);
4664 : 3 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 411, __FILE__, __LINE__, true);
4665 : 3 : return true;
4666 : : }
4667 : 0 : next_after_fail991:;
4668 : : }
4669 : : else
4670 : : {
4671 : 737 : gimple_seq *lseq = seq;
4672 : 737 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail992;
4673 : 737 : {
4674 : 737 : res_op->set_op (cmp, type, 2);
4675 : 737 : res_op->ops[0] = captures[1];
4676 : 737 : res_op->ops[1] = captures[3];
4677 : 737 : res_op->resimplify (lseq, valueize);
4678 : 737 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 412, __FILE__, __LINE__, true);
4679 : 737 : return true;
4680 : : }
4681 : 0 : next_after_fail992:;
4682 : : }
4683 : : }
4684 : : }
4685 : : return false;
4686 : : }
4687 : :
4688 : : bool
4689 : 23 : gimple_simplify_278 (gimple_match_op *res_op, gimple_seq *seq,
4690 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4691 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4692 : : const enum tree_code ARG_UNUSED (cmp))
4693 : : {
4694 : 23 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4695 : 23 : if (single_use (captures[1]) && single_use (captures[3])
4696 : : )
4697 : : {
4698 : 2 : {
4699 : 2 : tree otype = TREE_TYPE (captures[0]);
4700 : 2 : gimple_seq *lseq = seq;
4701 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail999;
4702 : 2 : {
4703 : 2 : res_op->set_op (cmp, type, 2);
4704 : 2 : {
4705 : 2 : tree _o1[1], _r1;
4706 : 2 : _o1[0] = captures[4];
4707 : 2 : if (otype != TREE_TYPE (_o1[0]) /* XXX */
4708 : 2 : && !useless_type_conversion_p (otype, TREE_TYPE (_o1[0])))
4709 : : {
4710 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, otype, _o1[0]);
4711 : 2 : tem_op.resimplify (lseq, valueize);
4712 : 2 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4713 : 2 : if (!_r1) goto next_after_fail999;
4714 : : }
4715 : : else
4716 : : _r1 = _o1[0];
4717 : 1 : res_op->ops[0] = _r1;
4718 : : }
4719 : 1 : {
4720 : 1 : tree _o1[1], _r1;
4721 : 1 : _o1[0] = captures[2];
4722 : 1 : if (otype != TREE_TYPE (_o1[0]) /* XXX */
4723 : 1 : && !useless_type_conversion_p (otype, TREE_TYPE (_o1[0])))
4724 : : {
4725 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, otype, _o1[0]);
4726 : 1 : tem_op.resimplify (lseq, valueize);
4727 : 1 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
4728 : 1 : if (!_r1) goto next_after_fail999;
4729 : : }
4730 : : else
4731 : : _r1 = _o1[0];
4732 : 1 : res_op->ops[1] = _r1;
4733 : : }
4734 : 1 : res_op->resimplify (lseq, valueize);
4735 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 419, __FILE__, __LINE__, true);
4736 : 1 : return true;
4737 : : }
4738 : : next_after_fail999:;
4739 : : }
4740 : : }
4741 : : return false;
4742 : : }
4743 : :
4744 : : bool
4745 : 1082 : gimple_simplify_284 (gimple_match_op *res_op, gimple_seq *seq,
4746 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
4747 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
4748 : : const combined_fn ARG_UNUSED (sq),
4749 : : const enum tree_code ARG_UNUSED (cmp))
4750 : : {
4751 : 1082 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
4752 : 1082 : if (flag_unsafe_math_optimizations && ! flag_errno_math
4753 : : )
4754 : : {
4755 : 211 : if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (captures[1]))
4756 : : )
4757 : : {
4758 : 0 : if (cmp == EQ_EXPR || cmp == LT_EXPR || cmp == LE_EXPR
4759 : : )
4760 : : {
4761 : 0 : gimple_seq *lseq = seq;
4762 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1019;
4763 : 0 : {
4764 : 0 : tree tem;
4765 : 0 : tem = constant_boolean_node (false, type);
4766 : 0 : res_op->set_value (tem);
4767 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 438, __FILE__, __LINE__, true);
4768 : 0 : return true;
4769 : : }
4770 : 0 : next_after_fail1019:;
4771 : 0 : }
4772 : : else
4773 : : {
4774 : 0 : if (cmp == NE_EXPR || !HONOR_NANS (captures[0])
4775 : : )
4776 : : {
4777 : 0 : gimple_seq *lseq = seq;
4778 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1020;
4779 : 0 : {
4780 : 0 : tree tem;
4781 : 0 : tem = constant_boolean_node (true, type);
4782 : 0 : res_op->set_value (tem);
4783 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 439, __FILE__, __LINE__, true);
4784 : 0 : return true;
4785 : : }
4786 : 0 : next_after_fail1020:;
4787 : : }
4788 : : else
4789 : : {
4790 : 0 : gimple_seq *lseq = seq;
4791 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1021;
4792 : 0 : {
4793 : 0 : res_op->set_op (GE_EXPR, type, 2);
4794 : 0 : res_op->ops[0] = captures[0];
4795 : 0 : res_op->ops[1] = build_real (TREE_TYPE (captures[0]), dconst0);
4796 : 0 : res_op->resimplify (lseq, valueize);
4797 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 440, __FILE__, __LINE__, true);
4798 : 0 : return true;
4799 : : }
4800 : 0 : next_after_fail1021:;
4801 : : }
4802 : : }
4803 : : }
4804 : : else
4805 : : {
4806 : 211 : if (real_equal (TREE_REAL_CST_PTR (captures[1]), &dconst0)
4807 : : )
4808 : : {
4809 : 180 : if (cmp == LT_EXPR
4810 : : )
4811 : : {
4812 : 18 : gimple_seq *lseq = seq;
4813 : 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1022;
4814 : 18 : {
4815 : 18 : tree tem;
4816 : 18 : tem = constant_boolean_node (false, type);
4817 : 18 : res_op->set_value (tem);
4818 : 18 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 441, __FILE__, __LINE__, true);
4819 : 18 : return true;
4820 : : }
4821 : 0 : next_after_fail1022:;
4822 : : }
4823 : : else
4824 : : {
4825 : 162 : if (cmp == GE_EXPR && !HONOR_NANS (captures[0])
4826 : : )
4827 : : {
4828 : 18 : gimple_seq *lseq = seq;
4829 : 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1023;
4830 : 18 : {
4831 : 18 : tree tem;
4832 : 18 : tem = constant_boolean_node (true, type);
4833 : 18 : res_op->set_value (tem);
4834 : 18 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 442, __FILE__, __LINE__, true);
4835 : 18 : return true;
4836 : : }
4837 : 0 : next_after_fail1023:;
4838 : : }
4839 : : else
4840 : : {
4841 : 144 : if (cmp == LE_EXPR
4842 : : )
4843 : : {
4844 : 36 : gimple_seq *lseq = seq;
4845 : 36 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1024;
4846 : 36 : {
4847 : 36 : res_op->set_op (EQ_EXPR, type, 2);
4848 : 36 : res_op->ops[0] = captures[0];
4849 : 36 : res_op->ops[1] = captures[1];
4850 : 36 : res_op->resimplify (lseq, valueize);
4851 : 36 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 443, __FILE__, __LINE__, true);
4852 : 36 : return true;
4853 : : }
4854 : 0 : next_after_fail1024:;
4855 : : }
4856 : : else
4857 : : {
4858 : 108 : gimple_seq *lseq = seq;
4859 : 108 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1025;
4860 : 108 : {
4861 : 108 : res_op->set_op (cmp, type, 2);
4862 : 108 : res_op->ops[0] = captures[0];
4863 : 108 : res_op->ops[1] = captures[1];
4864 : 108 : res_op->resimplify (lseq, valueize);
4865 : 108 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 444, __FILE__, __LINE__, true);
4866 : 108 : return true;
4867 : : }
4868 : 0 : next_after_fail1025:;
4869 : : }
4870 : : }
4871 : : }
4872 : : }
4873 : : else
4874 : : {
4875 : 31 : if ((cmp == LT_EXPR
4876 : : || cmp == LE_EXPR
4877 : : || cmp == GT_EXPR
4878 : 31 : || cmp == GE_EXPR)
4879 : 31 : && !REAL_VALUE_ISNAN (TREE_REAL_CST (captures[1]))
4880 : 62 : && !HONOR_SIGN_DEPENDENT_ROUNDING (TREE_TYPE (captures[0]))
4881 : : )
4882 : : {
4883 : 31 : {
4884 : 31 : REAL_VALUE_TYPE c2;
4885 : 31 : enum tree_code ncmp = cmp;
4886 : 31 : const real_format *fmt
4887 : 31 : = REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (captures[0])));
4888 : 62 : real_arithmetic (&c2, MULT_EXPR,
4889 : 31 : &TREE_REAL_CST (captures[1]), &TREE_REAL_CST (captures[1]));
4890 : 31 : real_convert (&c2, fmt, &c2);
4891 : 31 : if (!REAL_VALUE_ISINF (c2))
4892 : : {
4893 : 17 : tree c3 = fold_const_call (CFN_SQRT, TREE_TYPE (captures[0]),
4894 : 17 : build_real (TREE_TYPE (captures[0]), c2));
4895 : 17 : if (c3 == NULL_TREE || TREE_CODE (c3) != REAL_CST)
4896 : : ncmp = ERROR_MARK;
4897 : 17 : else if ((cmp == LT_EXPR || cmp == GE_EXPR)
4898 : 17 : && real_less (&TREE_REAL_CST (c3), &TREE_REAL_CST (captures[1])))
4899 : 0 : ncmp = cmp == LT_EXPR ? LE_EXPR : GT_EXPR;
4900 : 17 : else if ((cmp == LE_EXPR || cmp == GT_EXPR)
4901 : 20 : && real_less (&TREE_REAL_CST (captures[1]), &TREE_REAL_CST (c3)))
4902 : 0 : ncmp = cmp == LE_EXPR ? LT_EXPR : GE_EXPR;
4903 : : else
4904 : : {
4905 : 17 : REAL_VALUE_TYPE c2alt, tow;
4906 : 17 : if (cmp == LT_EXPR || cmp == GE_EXPR)
4907 : 14 : tow = dconst0;
4908 : : else
4909 : 3 : tow = dconstinf;
4910 : 17 : real_nextafter (&c2alt, fmt, &c2, &tow);
4911 : 17 : real_convert (&c2alt, fmt, &c2alt);
4912 : 17 : if (REAL_VALUE_ISINF (c2alt))
4913 : : ncmp = ERROR_MARK;
4914 : : else
4915 : : {
4916 : 17 : c3 = fold_const_call (CFN_SQRT, TREE_TYPE (captures[0]),
4917 : 17 : build_real (TREE_TYPE (captures[0]), c2alt));
4918 : 17 : if (c3 == NULL_TREE || TREE_CODE (c3) != REAL_CST)
4919 : : ncmp = ERROR_MARK;
4920 : 17 : else if (real_equal (&TREE_REAL_CST (c3),
4921 : 17 : &TREE_REAL_CST (captures[1])))
4922 : 17 : c2 = c2alt;
4923 : : }
4924 : : }
4925 : : }
4926 : 31 : if (cmp == GT_EXPR || cmp == GE_EXPR
4927 : : )
4928 : : {
4929 : 3 : if (REAL_VALUE_ISINF (c2)
4930 : : )
4931 : : {
4932 : 0 : if (HONOR_INFINITIES (captures[0])
4933 : : )
4934 : : {
4935 : 0 : gimple_seq *lseq = seq;
4936 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1026;
4937 : 0 : {
4938 : 0 : res_op->set_op (EQ_EXPR, type, 2);
4939 : 0 : res_op->ops[0] = captures[0];
4940 : 0 : res_op->ops[1] = build_real (TREE_TYPE (captures[0]), c2);
4941 : 0 : res_op->resimplify (lseq, valueize);
4942 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 445, __FILE__, __LINE__, true);
4943 : 3 : return true;
4944 : : }
4945 : 0 : next_after_fail1026:;
4946 : : }
4947 : : else
4948 : : {
4949 : 0 : gimple_seq *lseq = seq;
4950 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1027;
4951 : 0 : {
4952 : 0 : tree tem;
4953 : 0 : tem = constant_boolean_node (false, type);
4954 : 0 : res_op->set_value (tem);
4955 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 446, __FILE__, __LINE__, true);
4956 : 0 : return true;
4957 : : }
4958 : 0 : next_after_fail1027:;
4959 : : }
4960 : : }
4961 : : else
4962 : : {
4963 : 3 : if (ncmp != ERROR_MARK
4964 : : )
4965 : : {
4966 : 3 : if (ncmp == GE_EXPR
4967 : : )
4968 : : {
4969 : 0 : gimple_seq *lseq = seq;
4970 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1028;
4971 : 0 : {
4972 : 0 : res_op->set_op (GE_EXPR, type, 2);
4973 : 0 : res_op->ops[0] = captures[0];
4974 : 0 : res_op->ops[1] = build_real (TREE_TYPE (captures[0]), c2);
4975 : 0 : res_op->resimplify (lseq, valueize);
4976 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 447, __FILE__, __LINE__, true);
4977 : 0 : return true;
4978 : : }
4979 : 0 : next_after_fail1028:;
4980 : : }
4981 : : else
4982 : : {
4983 : 3 : gimple_seq *lseq = seq;
4984 : 3 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1029;
4985 : 3 : {
4986 : 3 : res_op->set_op (GT_EXPR, type, 2);
4987 : 3 : res_op->ops[0] = captures[0];
4988 : 3 : res_op->ops[1] = build_real (TREE_TYPE (captures[0]), c2);
4989 : 3 : res_op->resimplify (lseq, valueize);
4990 : 3 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 448, __FILE__, __LINE__, true);
4991 : 3 : return true;
4992 : : }
4993 : 0 : next_after_fail1029:;
4994 : : }
4995 : : }
4996 : : }
4997 : : }
4998 : : else
4999 : : {
5000 : 28 : if (REAL_VALUE_ISINF (c2)
5001 : : )
5002 : : {
5003 : 14 : if (! HONOR_NANS (captures[0]) && ! HONOR_INFINITIES (captures[0])
5004 : : )
5005 : : {
5006 : 0 : gimple_seq *lseq = seq;
5007 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1030;
5008 : 0 : {
5009 : 0 : tree tem;
5010 : 0 : tem = constant_boolean_node (true, type);
5011 : 0 : res_op->set_value (tem);
5012 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 449, __FILE__, __LINE__, true);
5013 : 0 : return true;
5014 : : }
5015 : 0 : next_after_fail1030:;
5016 : : }
5017 : : else
5018 : : {
5019 : 14 : if (! HONOR_NANS (captures[0])
5020 : : )
5021 : : {
5022 : 0 : gimple_seq *lseq = seq;
5023 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1031;
5024 : 0 : {
5025 : 0 : res_op->set_op (NE_EXPR, type, 2);
5026 : 0 : res_op->ops[0] = captures[0];
5027 : 0 : res_op->ops[1] = build_real (TREE_TYPE (captures[0]), c2);
5028 : 0 : res_op->resimplify (lseq, valueize);
5029 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 450, __FILE__, __LINE__, true);
5030 : 0 : return true;
5031 : : }
5032 : 0 : next_after_fail1031:;
5033 : : }
5034 : : else
5035 : : {
5036 : 14 : if (! HONOR_INFINITIES (captures[0])
5037 : : )
5038 : : {
5039 : 0 : gimple_seq *lseq = seq;
5040 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1032;
5041 : 0 : {
5042 : 0 : res_op->set_op (GE_EXPR, type, 2);
5043 : 0 : res_op->ops[0] = captures[0];
5044 : 0 : res_op->ops[1] = build_real (TREE_TYPE (captures[0]), dconst0);
5045 : 0 : res_op->resimplify (lseq, valueize);
5046 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 451, __FILE__, __LINE__, true);
5047 : 0 : return true;
5048 : : }
5049 : 0 : next_after_fail1032:;
5050 : : }
5051 : : else
5052 : : {
5053 : : if (0
5054 : : )
5055 : : {
5056 : : gimple_seq *lseq = seq;
5057 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1033;
5058 : : {
5059 : : res_op->set_op (TRUTH_ANDIF_EXPR, type, 2);
5060 : : {
5061 : : tree _o1[2], _r1;
5062 : : _o1[0] = captures[0];
5063 : : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
5064 : : gimple_match_op tem_op (res_op->cond.any_else (), GE_EXPR, type, _o1[0], _o1[1]);
5065 : : tem_op.resimplify (lseq, valueize);
5066 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5067 : : if (!_r1) goto next_after_fail1033;
5068 : : res_op->ops[0] = _r1;
5069 : : }
5070 : : {
5071 : : tree _o1[2], _r1;
5072 : : _o1[0] = captures[0];
5073 : : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
5074 : : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o1[0], _o1[1]);
5075 : : tem_op.resimplify (lseq, valueize);
5076 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5077 : : if (!_r1) goto next_after_fail1033;
5078 : : res_op->ops[1] = _r1;
5079 : : }
5080 : : res_op->resimplify (lseq, valueize);
5081 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 452, __FILE__, __LINE__, true);
5082 : : return true;
5083 : : }
5084 : : next_after_fail1033:;
5085 : : }
5086 : : }
5087 : : }
5088 : : }
5089 : : }
5090 : : else
5091 : : {
5092 : 14 : if (ncmp != ERROR_MARK && ! HONOR_NANS (captures[0])
5093 : : )
5094 : : {
5095 : 0 : if (ncmp == LT_EXPR
5096 : : )
5097 : : {
5098 : 0 : gimple_seq *lseq = seq;
5099 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1034;
5100 : 0 : {
5101 : 0 : res_op->set_op (LT_EXPR, type, 2);
5102 : 0 : res_op->ops[0] = captures[0];
5103 : 0 : res_op->ops[1] = build_real (TREE_TYPE (captures[0]), c2);
5104 : 0 : res_op->resimplify (lseq, valueize);
5105 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 453, __FILE__, __LINE__, true);
5106 : 0 : return true;
5107 : : }
5108 : 0 : next_after_fail1034:;
5109 : : }
5110 : : else
5111 : : {
5112 : 0 : gimple_seq *lseq = seq;
5113 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1035;
5114 : 0 : {
5115 : 0 : res_op->set_op (LE_EXPR, type, 2);
5116 : 0 : res_op->ops[0] = captures[0];
5117 : 0 : res_op->ops[1] = build_real (TREE_TYPE (captures[0]), c2);
5118 : 0 : res_op->resimplify (lseq, valueize);
5119 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 454, __FILE__, __LINE__, true);
5120 : 0 : return true;
5121 : : }
5122 : 0 : next_after_fail1035:;
5123 : : }
5124 : : }
5125 : : else
5126 : : {
5127 : : if (ncmp != ERROR_MARK &&
5128 : :
5129 : : )
5130 : : {
5131 : : if (ncmp == LT_EXPR
5132 : : )
5133 : : {
5134 : : gimple_seq *lseq = seq;
5135 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1036;
5136 : : {
5137 : : res_op->set_op (TRUTH_ANDIF_EXPR, type, 2);
5138 : : {
5139 : : tree _o1[2], _r1;
5140 : : _o1[0] = captures[0];
5141 : : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
5142 : : gimple_match_op tem_op (res_op->cond.any_else (), GE_EXPR, type, _o1[0], _o1[1]);
5143 : : tem_op.resimplify (lseq, valueize);
5144 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5145 : : if (!_r1) goto next_after_fail1036;
5146 : : res_op->ops[0] = _r1;
5147 : : }
5148 : : {
5149 : : tree _o1[2], _r1;
5150 : : _o1[0] = captures[0];
5151 : : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
5152 : : gimple_match_op tem_op (res_op->cond.any_else (), LT_EXPR, type, _o1[0], _o1[1]);
5153 : : tem_op.resimplify (lseq, valueize);
5154 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5155 : : if (!_r1) goto next_after_fail1036;
5156 : : res_op->ops[1] = _r1;
5157 : : }
5158 : : res_op->resimplify (lseq, valueize);
5159 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 455, __FILE__, __LINE__, true);
5160 : : return true;
5161 : : }
5162 : : next_after_fail1036:;
5163 : : }
5164 : : else
5165 : : {
5166 : : gimple_seq *lseq = seq;
5167 : : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1037;
5168 : : {
5169 : : res_op->set_op (TRUTH_ANDIF_EXPR, type, 2);
5170 : : {
5171 : : tree _o1[2], _r1;
5172 : : _o1[0] = captures[0];
5173 : : _o1[1] = build_real (TREE_TYPE (captures[0]), dconst0);
5174 : : gimple_match_op tem_op (res_op->cond.any_else (), GE_EXPR, type, _o1[0], _o1[1]);
5175 : : tem_op.resimplify (lseq, valueize);
5176 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5177 : : if (!_r1) goto next_after_fail1037;
5178 : : res_op->ops[0] = _r1;
5179 : : }
5180 : : {
5181 : : tree _o1[2], _r1;
5182 : : _o1[0] = captures[0];
5183 : : _o1[1] = build_real (TREE_TYPE (captures[0]), c2);
5184 : : gimple_match_op tem_op (res_op->cond.any_else (), LE_EXPR, type, _o1[0], _o1[1]);
5185 : : tem_op.resimplify (lseq, valueize);
5186 : : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5187 : : if (!_r1) goto next_after_fail1037;
5188 : : res_op->ops[1] = _r1;
5189 : : }
5190 : : res_op->resimplify (lseq, valueize);
5191 : : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 456, __FILE__, __LINE__, true);
5192 : : return true;
5193 : : }
5194 : : next_after_fail1037:;
5195 : : }
5196 : : }
5197 : : }
5198 : : }
5199 : : }
5200 : : }
5201 : : }
5202 : : }
5203 : : }
5204 : : }
5205 : : return false;
5206 : : }
5207 : :
5208 : : bool
5209 : 12937 : gimple_simplify_317 (gimple_match_op *res_op, gimple_seq *seq,
5210 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5211 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5212 : : const enum tree_code ARG_UNUSED (cmp),
5213 : : const enum tree_code ARG_UNUSED (rcmp))
5214 : : {
5215 : 12937 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5216 : 25874 : if (!TREE_OVERFLOW (captures[0]) && !TREE_OVERFLOW (captures[2])
5217 : 25874 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
5218 : : )
5219 : : {
5220 : 5092 : {
5221 : 5092 : tree res = int_const_binop (MINUS_EXPR, captures[0], captures[2]);
5222 : 5092 : if (TREE_OVERFLOW (res)
5223 : : )
5224 : : {
5225 : 55 : if (cmp == NE_EXPR
5226 : : )
5227 : : {
5228 : 0 : gimple_seq *lseq = seq;
5229 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1113;
5230 : 0 : {
5231 : 0 : tree tem;
5232 : 0 : tem = constant_boolean_node (true, type);
5233 : 0 : res_op->set_value (tem);
5234 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 515, __FILE__, __LINE__, true);
5235 : 0 : return true;
5236 : : }
5237 : 0 : next_after_fail1113:;
5238 : : }
5239 : : else
5240 : : {
5241 : 55 : if (cmp == EQ_EXPR
5242 : : )
5243 : : {
5244 : 1 : gimple_seq *lseq = seq;
5245 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1114;
5246 : 1 : {
5247 : 1 : tree tem;
5248 : 1 : tem = constant_boolean_node (false, type);
5249 : 1 : res_op->set_value (tem);
5250 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 516, __FILE__, __LINE__, true);
5251 : 1 : return true;
5252 : : }
5253 : 0 : next_after_fail1114:;
5254 : : }
5255 : : else
5256 : : {
5257 : 54 : gimple_seq *lseq = seq;
5258 : 54 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1115;
5259 : 54 : {
5260 : 54 : tree tem;
5261 : 54 : bool less = cmp == LE_EXPR || cmp == LT_EXPR;
5262 : 54 : bool ovf_high = wi::lt_p (wi::to_wide (captures[0]), 0,
5263 : 54 : TYPE_SIGN (TREE_TYPE (captures[0]))); tem =
5264 : 54 : constant_boolean_node (less == ovf_high, type);
5265 : 54 : res_op->set_value (tem);
5266 : 54 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 517, __FILE__, __LINE__, true);
5267 : 54 : return true;
5268 : : }
5269 : 0 : next_after_fail1115:;
5270 : : }
5271 : : }
5272 : : }
5273 : : else
5274 : : {
5275 : 5037 : gimple_seq *lseq = seq;
5276 : 5037 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1116;
5277 : 5037 : {
5278 : 5037 : res_op->set_op (rcmp, type, 2);
5279 : 5037 : res_op->ops[0] = captures[1];
5280 : 5037 : res_op->ops[1] = res;
5281 : 5037 : res_op->resimplify (lseq, valueize);
5282 : 5037 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 518, __FILE__, __LINE__, true);
5283 : 5037 : return true;
5284 : : }
5285 : 0 : next_after_fail1116:;
5286 : : }
5287 : : }
5288 : : }
5289 : : else
5290 : : {
5291 : 7845 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
5292 : : )
5293 : : {
5294 : 6593 : if (cmp == EQ_EXPR || cmp == NE_EXPR
5295 : : )
5296 : : {
5297 : 2823 : gimple_seq *lseq = seq;
5298 : 2823 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1117;
5299 : 2823 : {
5300 : 2823 : res_op->set_op (cmp, type, 2);
5301 : 2823 : res_op->ops[0] = captures[1];
5302 : 2823 : {
5303 : 2823 : tree _o1[2], _r1;
5304 : 2823 : _o1[0] = captures[0];
5305 : 2823 : _o1[1] = captures[2];
5306 : 2823 : gimple_match_op tem_op (res_op->cond.any_else (), MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
5307 : 2823 : tem_op.resimplify (lseq, valueize);
5308 : 2823 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5309 : 2823 : if (!_r1) goto next_after_fail1117;
5310 : 2823 : res_op->ops[1] = _r1;
5311 : : }
5312 : 2823 : res_op->resimplify (lseq, valueize);
5313 : 2823 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 519, __FILE__, __LINE__, true);
5314 : 2823 : return true;
5315 : : }
5316 : : next_after_fail1117:;
5317 : : }
5318 : : else
5319 : : {
5320 : 3770 : if (cmp == LE_EXPR || cmp == GT_EXPR
5321 : : )
5322 : : {
5323 : 3770 : gimple_seq *lseq = seq;
5324 : 3770 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1118;
5325 : 3770 : {
5326 : 3770 : res_op->set_op (cmp, type, 2);
5327 : 3770 : {
5328 : 3770 : tree _o1[2], _r1;
5329 : 3770 : _o1[0] = captures[1];
5330 : 3770 : {
5331 : 3770 : tree _o2[2], _r2;
5332 : 3770 : _o2[0] = captures[2];
5333 : 3770 : _o2[1] = captures[0];
5334 : 3770 : gimple_match_op tem_op (res_op->cond.any_else (), MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
5335 : 3770 : tem_op.resimplify (lseq, valueize);
5336 : 3770 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
5337 : 3770 : if (!_r2) goto next_after_fail1118;
5338 : 3770 : _o1[1] = _r2;
5339 : : }
5340 : 3770 : gimple_match_op tem_op (res_op->cond.any_else (), PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
5341 : 3770 : tem_op.resimplify (lseq, valueize);
5342 : 3770 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5343 : 3770 : if (!_r1) goto next_after_fail1118;
5344 : 1672 : res_op->ops[0] = _r1;
5345 : : }
5346 : 1672 : res_op->ops[1] = captures[2];
5347 : 1672 : res_op->resimplify (lseq, valueize);
5348 : 1672 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 520, __FILE__, __LINE__, true);
5349 : 1672 : return true;
5350 : : }
5351 : : next_after_fail1118:;
5352 : : }
5353 : : else
5354 : : {
5355 : 0 : if (cmp == LT_EXPR || cmp == GE_EXPR
5356 : : )
5357 : : {
5358 : 0 : gimple_seq *lseq = seq;
5359 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1119;
5360 : 0 : {
5361 : 0 : res_op->set_op (cmp, type, 2);
5362 : 0 : {
5363 : 0 : tree _o1[2], _r1;
5364 : 0 : _o1[0] = captures[1];
5365 : 0 : {
5366 : 0 : tree _o2[2], _r2;
5367 : 0 : _o2[0] = captures[2];
5368 : 0 : {
5369 : 0 : tree _o3[2], _r3;
5370 : 0 : _o3[0] = captures[0];
5371 : 0 : _o3[1] = build_one_cst (TREE_TYPE (captures[1]));
5372 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), PLUS_EXPR, TREE_TYPE (_o3[0]), _o3[0], _o3[1]);
5373 : 0 : tem_op.resimplify (lseq, valueize);
5374 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
5375 : 0 : if (!_r3) goto next_after_fail1119;
5376 : 0 : _o2[1] = _r3;
5377 : : }
5378 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), MINUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
5379 : 0 : tem_op.resimplify (lseq, valueize);
5380 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
5381 : 0 : if (!_r2) goto next_after_fail1119;
5382 : 0 : _o1[1] = _r2;
5383 : : }
5384 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), PLUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
5385 : 0 : tem_op.resimplify (lseq, valueize);
5386 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5387 : 0 : if (!_r1) goto next_after_fail1119;
5388 : 0 : res_op->ops[0] = _r1;
5389 : : }
5390 : 0 : res_op->ops[1] = captures[2];
5391 : 0 : res_op->resimplify (lseq, valueize);
5392 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 521, __FILE__, __LINE__, true);
5393 : 0 : return true;
5394 : : }
5395 : : next_after_fail1119:;
5396 : : }
5397 : : }
5398 : : }
5399 : : }
5400 : : else
5401 : : {
5402 : 1252 : if (!TYPE_UNSIGNED (TREE_TYPE (captures[1]))
5403 : 1252 : && TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
5404 : : )
5405 : : {
5406 : 1252 : if (cmp == EQ_EXPR || cmp == NE_EXPR
5407 : : )
5408 : : {
5409 : 221 : gimple_seq *lseq = seq;
5410 : 221 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1120;
5411 : 221 : {
5412 : 221 : res_op->set_op (cmp, type, 2);
5413 : 221 : res_op->ops[0] = captures[1];
5414 : 221 : {
5415 : 221 : tree _o1[2], _r1;
5416 : 221 : _o1[0] = captures[0];
5417 : 221 : _o1[1] = captures[2];
5418 : 221 : gimple_match_op tem_op (res_op->cond.any_else (), MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
5419 : 221 : tem_op.resimplify (lseq, valueize);
5420 : 221 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5421 : 221 : if (!_r1) goto next_after_fail1120;
5422 : 221 : res_op->ops[1] = _r1;
5423 : : }
5424 : 221 : res_op->resimplify (lseq, valueize);
5425 : 221 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 522, __FILE__, __LINE__, true);
5426 : 221 : return true;
5427 : : }
5428 : : next_after_fail1120:;
5429 : : }
5430 : : else
5431 : : {
5432 : 1031 : gimple_seq *lseq = seq;
5433 : 1031 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1121;
5434 : 1031 : {
5435 : 1031 : res_op->set_op (rcmp, type, 2);
5436 : 1031 : {
5437 : 1031 : tree _o1[2], _r1;
5438 : 1031 : _o1[0] = captures[1];
5439 : 1031 : {
5440 : 1031 : tree _o2[2], _r2;
5441 : 1031 : _o2[0] = captures[0];
5442 : 1031 : _o2[1] = build_one_cst (TREE_TYPE (captures[1]));
5443 : 1031 : gimple_match_op tem_op (res_op->cond.any_else (), PLUS_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
5444 : 1031 : tem_op.resimplify (lseq, valueize);
5445 : 1031 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
5446 : 1031 : if (!_r2) goto next_after_fail1121;
5447 : 1031 : _o1[1] = _r2;
5448 : : }
5449 : 1031 : gimple_match_op tem_op (res_op->cond.any_else (), MINUS_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
5450 : 1031 : tem_op.resimplify (lseq, valueize);
5451 : 1031 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5452 : 1031 : if (!_r1) goto next_after_fail1121;
5453 : 338 : res_op->ops[0] = _r1;
5454 : : }
5455 : 338 : {
5456 : 338 : tree _o1[1], _r1;
5457 : 338 : _o1[0] = captures[2];
5458 : 338 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
5459 : 338 : tem_op.resimplify (lseq, valueize);
5460 : 338 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5461 : 338 : if (!_r1) goto next_after_fail1121;
5462 : 338 : res_op->ops[1] = _r1;
5463 : : }
5464 : 338 : res_op->resimplify (lseq, valueize);
5465 : 338 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 523, __FILE__, __LINE__, true);
5466 : 338 : return true;
5467 : : }
5468 : : next_after_fail1121:;
5469 : : }
5470 : : }
5471 : : }
5472 : : }
5473 : : return false;
5474 : : }
5475 : :
5476 : : bool
5477 : 25553 : gimple_simplify_353 (gimple_match_op *res_op, gimple_seq *seq,
5478 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5479 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5480 : : const enum tree_code ARG_UNUSED (mod))
5481 : : {
5482 : 25553 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5483 : 25553 : if (!integer_zerop (captures[1])
5484 : : )
5485 : : {
5486 : 25168 : gimple_seq *lseq = seq;
5487 : 25168 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1171;
5488 : 25168 : {
5489 : 25168 : tree tem;
5490 : 25168 : tem = captures[0];
5491 : 25168 : res_op->set_value (tem);
5492 : 25168 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 571, __FILE__, __LINE__, true);
5493 : 25168 : return true;
5494 : : }
5495 : 0 : next_after_fail1171:;
5496 : : }
5497 : : return false;
5498 : : }
5499 : :
5500 : : bool
5501 : 426 : gimple_simplify_356 (gimple_match_op *res_op, gimple_seq *seq,
5502 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5503 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5504 : : const enum tree_code ARG_UNUSED (mod))
5505 : : {
5506 : 426 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5507 : 426 : if (!integer_zerop (captures[0])
5508 : : )
5509 : : {
5510 : 41 : gimple_seq *lseq = seq;
5511 : 41 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1174;
5512 : 41 : {
5513 : 41 : tree tem;
5514 : 41 : tem = build_zero_cst (type);
5515 : 41 : res_op->set_value (tem);
5516 : 41 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 574, __FILE__, __LINE__, true);
5517 : 41 : return true;
5518 : : }
5519 : 0 : next_after_fail1174:;
5520 : : }
5521 : : return false;
5522 : : }
5523 : :
5524 : : bool
5525 : 8 : gimple_simplify_362 (gimple_match_op *res_op, gimple_seq *seq,
5526 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5527 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5528 : : const combined_fn ARG_UNUSED (SQRT))
5529 : : {
5530 : 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5531 : 8 : if (flag_unsafe_math_optimizations
5532 : : )
5533 : : {
5534 : 8 : gimple_seq *lseq = seq;
5535 : 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1182;
5536 : 8 : {
5537 : 8 : res_op->set_op (SQRT, type, 1);
5538 : 8 : res_op->ops[0] = captures[0];
5539 : 8 : res_op->resimplify (lseq, valueize);
5540 : 8 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 582, __FILE__, __LINE__, true);
5541 : 8 : return true;
5542 : : }
5543 : 0 : next_after_fail1182:;
5544 : : }
5545 : : return false;
5546 : : }
5547 : :
5548 : : bool
5549 : 0 : gimple_simplify_367 (gimple_match_op *res_op, gimple_seq *seq,
5550 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5551 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5552 : : const combined_fn ARG_UNUSED (COS),
5553 : : const combined_fn ARG_UNUSED (SIN),
5554 : : const combined_fn ARG_UNUSED (TAN))
5555 : : {
5556 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5557 : 0 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
5558 : : )
5559 : : {
5560 : 0 : gimple_seq *lseq = seq;
5561 : 0 : if (lseq
5562 : 0 : && (!single_use (captures[0])
5563 : 0 : || !single_use (captures[2])))
5564 : 0 : lseq = NULL;
5565 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1187;
5566 : 0 : {
5567 : 0 : res_op->set_op (RDIV_EXPR, type, 2);
5568 : 0 : res_op->ops[0] = build_one_cst (type);
5569 : 0 : {
5570 : 0 : tree _o1[1], _r1;
5571 : 0 : _o1[0] = captures[1];
5572 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), TAN, TREE_TYPE (_o1[0]), _o1[0]);
5573 : 0 : tem_op.resimplify (lseq, valueize);
5574 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
5575 : 0 : if (!_r1) goto next_after_fail1187;
5576 : 0 : res_op->ops[1] = _r1;
5577 : : }
5578 : 0 : res_op->resimplify (lseq, valueize);
5579 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 587, __FILE__, __LINE__, true);
5580 : 0 : return true;
5581 : : }
5582 : : next_after_fail1187:;
5583 : : }
5584 : : return false;
5585 : : }
5586 : :
5587 : : bool
5588 : 7 : gimple_simplify_372 (gimple_match_op *res_op, gimple_seq *seq,
5589 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5590 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
5591 : : {
5592 : 7 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5593 : 7 : if (ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_UNDEFINED (type)
5594 : : )
5595 : : {
5596 : 0 : gimple_seq *lseq = seq;
5597 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1192;
5598 : 0 : {
5599 : 0 : res_op->set_op (MAX_EXPR, type, 2);
5600 : 0 : res_op->ops[0] = captures[2];
5601 : 0 : res_op->ops[1] = captures[1];
5602 : 0 : res_op->resimplify (lseq, valueize);
5603 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 592, __FILE__, __LINE__, true);
5604 : 0 : return true;
5605 : : }
5606 : 0 : next_after_fail1192:;
5607 : : }
5608 : : return false;
5609 : : }
5610 : :
5611 : : bool
5612 : 3 : gimple_simplify_376 (gimple_match_op *res_op, gimple_seq *seq,
5613 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5614 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5615 : : const enum tree_code ARG_UNUSED (op))
5616 : : {
5617 : 3 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5618 : 3 : if (bitwise_equal_p (captures[0], captures[2])
5619 : 3 : && tree_expr_nonzero_p (captures[3])
5620 : 5 : && expr_no_side_effects_p (captures[2])
5621 : : )
5622 : : {
5623 : 2 : gimple_seq *lseq = seq;
5624 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1196;
5625 : 2 : {
5626 : 2 : tree tem;
5627 : 2 : tem = captures[1];
5628 : 2 : res_op->set_value (tem);
5629 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 595, __FILE__, __LINE__, true);
5630 : 2 : return true;
5631 : : }
5632 : 0 : next_after_fail1196:;
5633 : : }
5634 : : return false;
5635 : : }
5636 : :
5637 : : bool
5638 : 20 : gimple_simplify_380 (gimple_match_op *res_op, gimple_seq *seq,
5639 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5640 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
5641 : : {
5642 : 20 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5643 : 20 : gimple_seq *lseq = seq;
5644 : 20 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1200;
5645 : 20 : {
5646 : 20 : tree tem;
5647 : 20 : tem = captures[2];
5648 : 20 : res_op->set_value (tem);
5649 : 20 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 599, __FILE__, __LINE__, true);
5650 : : return true;
5651 : : }
5652 : 0 : next_after_fail1200:;
5653 : 0 : return false;
5654 : : }
5655 : :
5656 : : bool
5657 : 1 : gimple_simplify_383 (gimple_match_op *res_op, gimple_seq *seq,
5658 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5659 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5660 : : const enum tree_code ARG_UNUSED (op))
5661 : : {
5662 : 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5663 : 1 : gimple_seq *lseq = seq;
5664 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1203;
5665 : 1 : {
5666 : 1 : tree tem;
5667 : 1 : tem = captures[2];
5668 : 1 : res_op->set_value (tem);
5669 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 602, __FILE__, __LINE__, true);
5670 : : return true;
5671 : : }
5672 : 0 : next_after_fail1203:;
5673 : 0 : return false;
5674 : : }
5675 : :
5676 : : bool
5677 : 70949 : gimple_simplify_390 (gimple_match_op *res_op, gimple_seq *seq,
5678 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5679 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5680 : : const enum tree_code ARG_UNUSED (cmp))
5681 : : {
5682 : 70949 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5683 : 70949 : if (!HONOR_SIGNED_ZEROS (type)
5684 : 70949 : && (
5685 : 29679 : (INTEGRAL_TYPE_P (type)
5686 : 27496 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[1]))
5687 : 27496 : && types_match (TREE_TYPE (captures[2]), TREE_TYPE (captures[3]))
5688 : 27496 : && TYPE_PRECISION (TREE_TYPE (captures[1])) <= TYPE_PRECISION (type)
5689 : 27496 : && TYPE_PRECISION (TREE_TYPE (captures[3])) <= TYPE_PRECISION (type))
5690 : 2183 : || (types_match (type, TREE_TYPE (captures[1]))
5691 : 2183 : && types_match (type, TREE_TYPE (captures[3]))))
5692 : : )
5693 : : {
5694 : 29679 : if (cmp == EQ_EXPR
5695 : : )
5696 : : {
5697 : 120 : if (VECTOR_TYPE_P (type)
5698 : : )
5699 : : {
5700 : 0 : gimple_seq *lseq = seq;
5701 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1246;
5702 : 0 : {
5703 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
5704 : 0 : res_op->ops[0] = captures[2];
5705 : 0 : res_op->resimplify (lseq, valueize);
5706 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 609, __FILE__, __LINE__, true);
5707 : 0 : return true;
5708 : : }
5709 : 0 : next_after_fail1246:;
5710 : : }
5711 : : else
5712 : : {
5713 : 120 : gimple_seq *lseq = seq;
5714 : 120 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1247;
5715 : 120 : {
5716 : 120 : res_op->set_op (NOP_EXPR, type, 1);
5717 : 120 : res_op->ops[0] = captures[2];
5718 : 120 : res_op->resimplify (lseq, valueize);
5719 : 120 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 610, __FILE__, __LINE__, true);
5720 : 120 : return true;
5721 : : }
5722 : 0 : next_after_fail1247:;
5723 : : }
5724 : : }
5725 : : else
5726 : : {
5727 : : if (cmp == NE_EXPR
5728 : : )
5729 : : {
5730 : 2029 : if (VECTOR_TYPE_P (type)
5731 : : )
5732 : : {
5733 : 0 : gimple_seq *lseq = seq;
5734 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1248;
5735 : 0 : {
5736 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
5737 : 0 : res_op->ops[0] = captures[0];
5738 : 0 : res_op->resimplify (lseq, valueize);
5739 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 611, __FILE__, __LINE__, true);
5740 : 0 : return true;
5741 : : }
5742 : 0 : next_after_fail1248:;
5743 : : }
5744 : : else
5745 : : {
5746 : 2029 : gimple_seq *lseq = seq;
5747 : 2029 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1249;
5748 : 2029 : {
5749 : 2029 : res_op->set_op (NOP_EXPR, type, 1);
5750 : 2029 : res_op->ops[0] = captures[0];
5751 : 2029 : res_op->resimplify (lseq, valueize);
5752 : 2029 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 612, __FILE__, __LINE__, true);
5753 : 2029 : return true;
5754 : : }
5755 : 0 : next_after_fail1249:;
5756 : : }
5757 : : }
5758 : : else
5759 : : {
5760 : : if (cmp == LE_EXPR || cmp == UNLE_EXPR || cmp == LT_EXPR || cmp == UNLT_EXPR
5761 : : )
5762 : : {
5763 : 10073 : if (!HONOR_NANS (type)
5764 : : )
5765 : : {
5766 : 10061 : if (VECTOR_TYPE_P (type)
5767 : : )
5768 : : {
5769 : 0 : gimple_seq *lseq = seq;
5770 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1250;
5771 : 0 : {
5772 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
5773 : 0 : {
5774 : 0 : tree _o1[2], _r1;
5775 : 0 : _o1[0] = captures[0];
5776 : 0 : _o1[1] = captures[2];
5777 : 0 : (*res_op).set_op (MIN_EXPR, TREE_TYPE (_o1[0]), 2);
5778 : 0 : (*res_op).ops[0] = _o1[0];
5779 : 0 : (*res_op).ops[1] = _o1[1];
5780 : 0 : (*res_op).resimplify (lseq, valueize);
5781 : : }
5782 : 0 : if (type != res_op->type
5783 : 0 : && !useless_type_conversion_p (type, res_op->type))
5784 : : {
5785 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1250;
5786 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
5787 : 0 : res_op->resimplify (lseq, valueize);
5788 : : }
5789 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 613, __FILE__, __LINE__, true);
5790 : 0 : return true;
5791 : : }
5792 : : next_after_fail1250:;
5793 : : }
5794 : : else
5795 : : {
5796 : 10061 : gimple_seq *lseq = seq;
5797 : 10061 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1251;
5798 : 10061 : {
5799 : 10061 : res_op->set_op (NOP_EXPR, type, 1);
5800 : 10061 : {
5801 : 10061 : tree _o1[2], _r1;
5802 : 10061 : _o1[0] = captures[0];
5803 : 10061 : _o1[1] = captures[2];
5804 : 10061 : (*res_op).set_op (MIN_EXPR, TREE_TYPE (_o1[0]), 2);
5805 : 10061 : (*res_op).ops[0] = _o1[0];
5806 : 10061 : (*res_op).ops[1] = _o1[1];
5807 : 10061 : (*res_op).resimplify (lseq, valueize);
5808 : : }
5809 : 10061 : if (type != res_op->type
5810 : 10061 : && !useless_type_conversion_p (type, res_op->type))
5811 : : {
5812 : 46 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1251;
5813 : 46 : res_op->set_op (NOP_EXPR, type, 1);
5814 : 46 : res_op->resimplify (lseq, valueize);
5815 : : }
5816 : 10061 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 614, __FILE__, __LINE__, true);
5817 : 10061 : return true;
5818 : : }
5819 : : next_after_fail1251:;
5820 : : }
5821 : : }
5822 : : }
5823 : : else
5824 : : {
5825 : : if (cmp == GE_EXPR || cmp == UNGE_EXPR || cmp == GT_EXPR || cmp == UNGT_EXPR
5826 : : )
5827 : : {
5828 : 17457 : if (!HONOR_NANS (type)
5829 : : )
5830 : : {
5831 : 17457 : if (VECTOR_TYPE_P (type)
5832 : : )
5833 : : {
5834 : 0 : gimple_seq *lseq = seq;
5835 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1252;
5836 : 0 : {
5837 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
5838 : 0 : {
5839 : 0 : tree _o1[2], _r1;
5840 : 0 : _o1[0] = captures[0];
5841 : 0 : _o1[1] = captures[2];
5842 : 0 : (*res_op).set_op (MAX_EXPR, TREE_TYPE (_o1[0]), 2);
5843 : 0 : (*res_op).ops[0] = _o1[0];
5844 : 0 : (*res_op).ops[1] = _o1[1];
5845 : 0 : (*res_op).resimplify (lseq, valueize);
5846 : : }
5847 : 0 : if (type != res_op->type
5848 : 0 : && !useless_type_conversion_p (type, res_op->type))
5849 : : {
5850 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1252;
5851 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
5852 : 0 : res_op->resimplify (lseq, valueize);
5853 : : }
5854 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 615, __FILE__, __LINE__, true);
5855 : 0 : return true;
5856 : : }
5857 : : next_after_fail1252:;
5858 : : }
5859 : : else
5860 : : {
5861 : 17457 : gimple_seq *lseq = seq;
5862 : 17457 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1253;
5863 : 17457 : {
5864 : 17457 : res_op->set_op (NOP_EXPR, type, 1);
5865 : 17457 : {
5866 : 17457 : tree _o1[2], _r1;
5867 : 17457 : _o1[0] = captures[0];
5868 : 17457 : _o1[1] = captures[2];
5869 : 17457 : (*res_op).set_op (MAX_EXPR, TREE_TYPE (_o1[0]), 2);
5870 : 17457 : (*res_op).ops[0] = _o1[0];
5871 : 17457 : (*res_op).ops[1] = _o1[1];
5872 : 17457 : (*res_op).resimplify (lseq, valueize);
5873 : : }
5874 : 17457 : if (type != res_op->type
5875 : 17457 : && !useless_type_conversion_p (type, res_op->type))
5876 : : {
5877 : 50 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1253;
5878 : 50 : res_op->set_op (NOP_EXPR, type, 1);
5879 : 50 : res_op->resimplify (lseq, valueize);
5880 : : }
5881 : 17457 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 616, __FILE__, __LINE__, true);
5882 : 17457 : return true;
5883 : : }
5884 : : next_after_fail1253:;
5885 : : }
5886 : : }
5887 : : }
5888 : : else
5889 : : {
5890 : : if (cmp == UNEQ_EXPR
5891 : : )
5892 : : {
5893 : 0 : if (!HONOR_NANS (type)
5894 : : )
5895 : : {
5896 : 0 : if (VECTOR_TYPE_P (type)
5897 : : )
5898 : : {
5899 : 0 : gimple_seq *lseq = seq;
5900 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1254;
5901 : 0 : {
5902 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
5903 : 0 : res_op->ops[0] = captures[2];
5904 : 0 : res_op->resimplify (lseq, valueize);
5905 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 617, __FILE__, __LINE__, true);
5906 : 0 : return true;
5907 : : }
5908 : 0 : next_after_fail1254:;
5909 : : }
5910 : : else
5911 : : {
5912 : 0 : gimple_seq *lseq = seq;
5913 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1255;
5914 : 0 : {
5915 : 0 : res_op->set_op (NOP_EXPR, type, 1);
5916 : 0 : res_op->ops[0] = captures[2];
5917 : 0 : res_op->resimplify (lseq, valueize);
5918 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 618, __FILE__, __LINE__, true);
5919 : 0 : return true;
5920 : : }
5921 : 0 : next_after_fail1255:;
5922 : : }
5923 : : }
5924 : : }
5925 : : else
5926 : : {
5927 : : if (cmp == LTGT_EXPR
5928 : : )
5929 : : {
5930 : 0 : if (!HONOR_NANS (type)
5931 : : )
5932 : : {
5933 : 0 : if (VECTOR_TYPE_P (type)
5934 : : )
5935 : : {
5936 : 0 : gimple_seq *lseq = seq;
5937 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1256;
5938 : 0 : {
5939 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
5940 : 0 : res_op->ops[0] = captures[0];
5941 : 0 : res_op->resimplify (lseq, valueize);
5942 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 619, __FILE__, __LINE__, true);
5943 : 0 : return true;
5944 : : }
5945 : 0 : next_after_fail1256:;
5946 : : }
5947 : : else
5948 : : {
5949 : 0 : gimple_seq *lseq = seq;
5950 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1257;
5951 : 0 : {
5952 : 0 : res_op->set_op (NOP_EXPR, type, 1);
5953 : 0 : res_op->ops[0] = captures[0];
5954 : 0 : res_op->resimplify (lseq, valueize);
5955 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 620, __FILE__, __LINE__, true);
5956 : 0 : return true;
5957 : : }
5958 : 0 : next_after_fail1257:;
5959 : : }
5960 : : }
5961 : : }
5962 : : }
5963 : : }
5964 : : }
5965 : : }
5966 : : }
5967 : : }
5968 : : return false;
5969 : : }
5970 : :
5971 : : bool
5972 : 0 : gimple_simplify_407 (gimple_match_op *res_op, gimple_seq *seq,
5973 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5974 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
5975 : : {
5976 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
5977 : 0 : if (wi::eq_p (wi::bit_not (wi::to_wide (captures[1])), wi::to_wide (captures[3]))
5978 : : )
5979 : : {
5980 : 0 : gimple_seq *lseq = seq;
5981 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1278;
5982 : 0 : {
5983 : 0 : tree tem;
5984 : 0 : tem = captures[2];
5985 : 0 : res_op->set_value (tem);
5986 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 635, __FILE__, __LINE__, true);
5987 : 0 : return true;
5988 : : }
5989 : 0 : next_after_fail1278:;
5990 : : }
5991 : : return false;
5992 : : }
5993 : :
5994 : : bool
5995 : 2705 : gimple_simplify_413 (gimple_match_op *res_op, gimple_seq *seq,
5996 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
5997 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
5998 : : const enum tree_code ARG_UNUSED (cmp))
5999 : : {
6000 : 2705 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6001 : 2705 : if (!HONOR_SIGNED_ZEROS (type)
6002 : 2705 : && bitwise_equal_p (captures[0], captures[1])
6003 : : )
6004 : : {
6005 : 1 : gimple_seq *lseq = seq;
6006 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1286;
6007 : 1 : {
6008 : 1 : tree tem;
6009 : 1 : tem = captures[2];
6010 : 1 : res_op->set_value (tem);
6011 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 641, __FILE__, __LINE__, true);
6012 : 1 : return true;
6013 : : }
6014 : 0 : next_after_fail1286:;
6015 : : }
6016 : : return false;
6017 : : }
6018 : :
6019 : : bool
6020 : 0 : gimple_simplify_417 (gimple_match_op *res_op, gimple_seq *seq,
6021 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6022 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6023 : : const enum tree_code ARG_UNUSED (cmp))
6024 : : {
6025 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6026 : 0 : if (!HONOR_SIGNED_ZEROS (type)
6027 : 0 : && bitwise_equal_p (captures[0], captures[1])
6028 : : )
6029 : : {
6030 : 0 : gimple_seq *lseq = seq;
6031 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1290;
6032 : 0 : {
6033 : 0 : tree tem;
6034 : 0 : tem = captures[2];
6035 : 0 : res_op->set_value (tem);
6036 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 641, __FILE__, __LINE__, true);
6037 : 0 : return true;
6038 : : }
6039 : 0 : next_after_fail1290:;
6040 : : }
6041 : : return false;
6042 : : }
6043 : :
6044 : : bool
6045 : 1166 : gimple_simplify_424 (gimple_match_op *res_op, gimple_seq *seq,
6046 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6047 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
6048 : : {
6049 : 1166 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6050 : 1166 : if (!POINTER_TYPE_P (type) && integer_pow2p (captures[2])
6051 : : )
6052 : : {
6053 : 14 : {
6054 : 14 : int shift = (wi::exact_log2 (wi::to_wide (captures[2]))
6055 : 14 : - wi::exact_log2 (wi::to_wide (captures[1])));
6056 : 14 : if (shift > 0
6057 : : )
6058 : : {
6059 : 0 : gimple_seq *lseq = seq;
6060 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1297;
6061 : 0 : {
6062 : 0 : res_op->set_op (BIT_AND_EXPR, type, 2);
6063 : 0 : {
6064 : 0 : tree _o1[2], _r1;
6065 : 0 : {
6066 : 0 : tree _o2[1], _r2;
6067 : 0 : _o2[0] = captures[0];
6068 : 0 : if (type != TREE_TYPE (_o2[0]) /* XXX */
6069 : 0 : && !useless_type_conversion_p (type, TREE_TYPE (_o2[0])))
6070 : : {
6071 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o2[0]);
6072 : 0 : tem_op.resimplify (lseq, valueize);
6073 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
6074 : 0 : if (!_r2) goto next_after_fail1297;
6075 : : }
6076 : : else
6077 : : _r2 = _o2[0];
6078 : 0 : _o1[0] = _r2;
6079 : : }
6080 : 0 : _o1[1] = build_int_cst (integer_type_node, shift);
6081 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), LSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6082 : 0 : tem_op.resimplify (lseq, valueize);
6083 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6084 : 0 : if (!_r1) goto next_after_fail1297;
6085 : 0 : res_op->ops[0] = _r1;
6086 : : }
6087 : 0 : res_op->ops[1] = captures[2];
6088 : 0 : res_op->resimplify (lseq, valueize);
6089 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 649, __FILE__, __LINE__, true);
6090 : 0 : return true;
6091 : : }
6092 : : next_after_fail1297:;
6093 : : }
6094 : : else
6095 : : {
6096 : 14 : gimple_seq *lseq = seq;
6097 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1298;
6098 : 14 : {
6099 : 14 : res_op->set_op (BIT_AND_EXPR, type, 2);
6100 : 14 : {
6101 : 14 : tree _r1;
6102 : 14 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
6103 : 14 : {
6104 : 14 : tree _o2[2], _r2;
6105 : 14 : _o2[0] = captures[0];
6106 : 14 : _o2[1] = build_int_cst (integer_type_node, -shift);
6107 : 14 : tem_op.set_op (RSHIFT_EXPR, TREE_TYPE (_o2[0]), 2);
6108 : 14 : tem_op.ops[0] = _o2[0];
6109 : 14 : tem_op.ops[1] = _o2[1];
6110 : 14 : tem_op.resimplify (lseq, valueize);
6111 : : }
6112 : 14 : if (type != tem_op.type
6113 : 14 : && !useless_type_conversion_p (type, tem_op.type))
6114 : : {
6115 : 14 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6116 : 28 : if (!_r1) goto next_after_fail1298;
6117 : 14 : tem_op.set_op (NOP_EXPR, type, 1);
6118 : 14 : tem_op.ops[0] = _r1;
6119 : 14 : tem_op.resimplify (lseq, valueize);
6120 : : }
6121 : 14 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6122 : 14 : if (!_r1) goto next_after_fail1298;
6123 : 0 : res_op->ops[0] = _r1;
6124 : : }
6125 : 0 : res_op->ops[1] = captures[2];
6126 : 0 : res_op->resimplify (lseq, valueize);
6127 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 650, __FILE__, __LINE__, true);
6128 : 0 : return true;
6129 : : }
6130 : : next_after_fail1298:;
6131 : : }
6132 : : }
6133 : : }
6134 : : return false;
6135 : : }
6136 : :
6137 : : bool
6138 : 24 : gimple_simplify_437 (gimple_match_op *res_op, gimple_seq *seq,
6139 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6140 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6141 : : const enum tree_code ARG_UNUSED (cmp))
6142 : : {
6143 : 24 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6144 : 24 : if (!HONOR_SIGNED_ZEROS (TREE_TYPE (captures[1]))
6145 : 24 : && !TYPE_UNSIGNED (TREE_TYPE (captures[1]))
6146 : 48 : && element_precision (captures[1])
6147 : 24 : <= element_precision (captures[0])
6148 : 48 : && bitwise_equal_p (captures[1], captures[2])
6149 : : )
6150 : : {
6151 : 48 : if ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
6152 : 22 : && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[2])))
6153 : 28 : || TYPE_UNSIGNED (TREE_TYPE (captures[2]))
6154 : : )
6155 : : {
6156 : 22 : {
6157 : 22 : tree stype = signed_type_for (TREE_TYPE (captures[2]));
6158 : 22 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
6159 : 22 : if (types_match (captures[0], stype)
6160 : : )
6161 : : {
6162 : 22 : gimple_seq *lseq = seq;
6163 : 22 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1323;
6164 : 22 : {
6165 : 22 : res_op->set_op (NOP_EXPR, type, 1);
6166 : 22 : {
6167 : 22 : tree _o1[1], _r1;
6168 : 22 : {
6169 : 22 : tree _o2[1], _r2;
6170 : 22 : _o2[0] = captures[0];
6171 : 22 : gimple_match_op tem_op (res_op->cond.any_else (), ABSU_EXPR, utype, _o2[0]);
6172 : 22 : tem_op.resimplify (lseq, valueize);
6173 : 22 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
6174 : 22 : if (!_r2) goto next_after_fail1323;
6175 : 22 : _o1[0] = _r2;
6176 : : }
6177 : 22 : (*res_op).set_op (NEGATE_EXPR, TREE_TYPE (_o1[0]), 1);
6178 : 22 : (*res_op).ops[0] = _o1[0];
6179 : 22 : (*res_op).resimplify (lseq, valueize);
6180 : : }
6181 : 22 : if (type != res_op->type
6182 : 22 : && !useless_type_conversion_p (type, res_op->type))
6183 : : {
6184 : 20 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1323;
6185 : 20 : res_op->set_op (NOP_EXPR, type, 1);
6186 : 20 : res_op->resimplify (lseq, valueize);
6187 : : }
6188 : 22 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 659, __FILE__, __LINE__, true);
6189 : 22 : return true;
6190 : : }
6191 : : next_after_fail1323:;
6192 : : }
6193 : : else
6194 : : {
6195 : 0 : gimple_seq *lseq = seq;
6196 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1324;
6197 : 0 : {
6198 : 0 : res_op->set_op (NOP_EXPR, type, 1);
6199 : 0 : {
6200 : 0 : tree _o1[1], _r1;
6201 : 0 : {
6202 : 0 : tree _o2[1], _r2;
6203 : 0 : {
6204 : 0 : tree _o3[1], _r3;
6205 : 0 : _o3[0] = captures[2];
6206 : 0 : if (stype != TREE_TYPE (_o3[0]) /* XXX */
6207 : 0 : && !useless_type_conversion_p (stype, TREE_TYPE (_o3[0])))
6208 : : {
6209 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, stype, _o3[0]);
6210 : 0 : tem_op.resimplify (lseq, valueize);
6211 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
6212 : 0 : if (!_r3) goto next_after_fail1324;
6213 : : }
6214 : : else
6215 : : _r3 = _o3[0];
6216 : 0 : _o2[0] = _r3;
6217 : : }
6218 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ABSU_EXPR, utype, _o2[0]);
6219 : 0 : tem_op.resimplify (lseq, valueize);
6220 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
6221 : 0 : if (!_r2) goto next_after_fail1324;
6222 : 0 : _o1[0] = _r2;
6223 : : }
6224 : 0 : (*res_op).set_op (NEGATE_EXPR, TREE_TYPE (_o1[0]), 1);
6225 : 0 : (*res_op).ops[0] = _o1[0];
6226 : 0 : (*res_op).resimplify (lseq, valueize);
6227 : : }
6228 : 0 : if (type != res_op->type
6229 : 0 : && !useless_type_conversion_p (type, res_op->type))
6230 : : {
6231 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1324;
6232 : 0 : res_op->set_op (NOP_EXPR, type, 1);
6233 : 0 : res_op->resimplify (lseq, valueize);
6234 : : }
6235 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 660, __FILE__, __LINE__, true);
6236 : 0 : return true;
6237 : : }
6238 : : next_after_fail1324:;
6239 : : }
6240 : : }
6241 : : }
6242 : : else
6243 : : {
6244 : 2 : gimple_seq *lseq = seq;
6245 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1325;
6246 : 2 : {
6247 : 2 : res_op->set_op (NOP_EXPR, type, 1);
6248 : 2 : {
6249 : 2 : tree _o1[1], _r1;
6250 : 2 : {
6251 : 2 : tree _o2[1], _r2;
6252 : 2 : _o2[0] = captures[2];
6253 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), ABS_EXPR, TREE_TYPE (_o2[0]), _o2[0]);
6254 : 2 : tem_op.resimplify (lseq, valueize);
6255 : 2 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
6256 : 2 : if (!_r2) goto next_after_fail1325;
6257 : 2 : _o1[0] = _r2;
6258 : : }
6259 : 2 : (*res_op).set_op (NEGATE_EXPR, TREE_TYPE (_o1[0]), 1);
6260 : 2 : (*res_op).ops[0] = _o1[0];
6261 : 2 : (*res_op).resimplify (lseq, valueize);
6262 : : }
6263 : 2 : if (type != res_op->type
6264 : 2 : && !useless_type_conversion_p (type, res_op->type))
6265 : : {
6266 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1325;
6267 : 0 : res_op->set_op (NOP_EXPR, type, 1);
6268 : 0 : res_op->resimplify (lseq, valueize);
6269 : : }
6270 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 661, __FILE__, __LINE__, true);
6271 : 2 : return true;
6272 : : }
6273 : : next_after_fail1325:;
6274 : : }
6275 : : }
6276 : : return false;
6277 : : }
6278 : :
6279 : : bool
6280 : 0 : gimple_simplify_449 (gimple_match_op *res_op, gimple_seq *seq,
6281 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6282 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
6283 : : {
6284 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6285 : 0 : {
6286 : 0 : int val;
6287 : 0 : internal_fn ifn = IFN_LAST;
6288 : 0 : if (TREE_CODE (TREE_TYPE (captures[2])) == BITINT_TYPE)
6289 : : ifn = IFN_CLZ;
6290 : 0 : else if (direct_internal_fn_supported_p (IFN_CLZ, TREE_TYPE (captures[2]),
6291 : : OPTIMIZE_FOR_BOTH))
6292 : : ifn = IFN_CLZ;
6293 : : if (ifn == IFN_CLZ
6294 : : )
6295 : : {
6296 : 0 : gimple_seq *lseq = seq;
6297 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1345;
6298 : 0 : {
6299 : 0 : res_op->set_op (CFN_CLZ, type, 2);
6300 : 0 : res_op->ops[0] = captures[2];
6301 : 0 : res_op->ops[1] = captures[3];
6302 : 0 : res_op->resimplify (lseq, valueize);
6303 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 671, __FILE__, __LINE__, true);
6304 : 0 : return true;
6305 : : }
6306 : 0 : next_after_fail1345:;
6307 : : }
6308 : : }
6309 : : return false;
6310 : : }
6311 : :
6312 : : bool
6313 : 1840 : gimple_simplify_455 (gimple_match_op *res_op, gimple_seq *seq,
6314 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6315 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6316 : : const enum tree_code ARG_UNUSED (op),
6317 : : const enum tree_code ARG_UNUSED (neg_op))
6318 : : {
6319 : 1840 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6320 : 1840 : if (flag_unsafe_math_optimizations
6321 : : )
6322 : : {
6323 : 0 : if (!HONOR_SIGNED_ZEROS (captures[1]) && !HONOR_INFINITIES (captures[1])
6324 : : )
6325 : : {
6326 : 0 : if (real_less (&dconst0, TREE_REAL_CST_PTR (captures[0]))
6327 : : )
6328 : : {
6329 : 0 : gimple_seq *lseq = seq;
6330 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1351;
6331 : 0 : {
6332 : 0 : res_op->set_op (op, type, 2);
6333 : 0 : res_op->ops[0] = captures[1];
6334 : 0 : res_op->ops[1] = captures[2];
6335 : 0 : res_op->resimplify (lseq, valueize);
6336 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 674, __FILE__, __LINE__, true);
6337 : 0 : return true;
6338 : : }
6339 : 0 : next_after_fail1351:;
6340 : : }
6341 : : else
6342 : : {
6343 : 0 : if (real_less (TREE_REAL_CST_PTR (captures[0]), &dconst0)
6344 : : )
6345 : : {
6346 : 0 : gimple_seq *lseq = seq;
6347 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1352;
6348 : 0 : {
6349 : 0 : res_op->set_op (neg_op, type, 2);
6350 : 0 : res_op->ops[0] = captures[1];
6351 : 0 : res_op->ops[1] = captures[2];
6352 : 0 : res_op->resimplify (lseq, valueize);
6353 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 675, __FILE__, __LINE__, true);
6354 : 0 : return true;
6355 : : }
6356 : 0 : next_after_fail1352:;
6357 : : }
6358 : : }
6359 : : }
6360 : : }
6361 : : return false;
6362 : : }
6363 : :
6364 : : bool
6365 : 3665 : gimple_simplify_465 (gimple_match_op *res_op, gimple_seq *seq,
6366 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6367 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6368 : : const enum tree_code ARG_UNUSED (cmp),
6369 : : const enum tree_code ARG_UNUSED (bitop))
6370 : : {
6371 : 3665 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6372 : 3665 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6373 : : )
6374 : : {
6375 : 3665 : if (bitop == BIT_AND_EXPR || tree_expr_nonnegative_p (captures[1])
6376 : : )
6377 : : {
6378 : 3663 : gimple_seq *lseq = seq;
6379 : 3663 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1363;
6380 : 3663 : {
6381 : 3663 : tree tem;
6382 : 3663 : tem = constant_boolean_node (cmp == GE_EXPR || cmp == LE_EXPR, type);
6383 : 3663 : res_op->set_value (tem);
6384 : 3663 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 686, __FILE__, __LINE__, true);
6385 : 3663 : return true;
6386 : : }
6387 : 0 : next_after_fail1363:;
6388 : : }
6389 : : else
6390 : : {
6391 : 2 : if (TREE_CODE (captures[1]) == INTEGER_CST && wi::neg_p (wi::to_wide (captures[1]))
6392 : : )
6393 : : {
6394 : 2 : gimple_seq *lseq = seq;
6395 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1364;
6396 : 2 : {
6397 : 2 : tree tem;
6398 : 2 : tem = constant_boolean_node (cmp == LT_EXPR, type);
6399 : 2 : res_op->set_value (tem);
6400 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 687, __FILE__, __LINE__, true);
6401 : 2 : return true;
6402 : : }
6403 : 0 : next_after_fail1364:;
6404 : : }
6405 : : }
6406 : : }
6407 : : return false;
6408 : : }
6409 : :
6410 : : bool
6411 : 292 : gimple_simplify_474 (gimple_match_op *res_op, gimple_seq *seq,
6412 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6413 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6414 : : const enum tree_code ARG_UNUSED (cmp),
6415 : : const enum tree_code ARG_UNUSED (out))
6416 : : {
6417 : 292 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6418 : 292 : if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1]))
6419 : 198 : && types_match (TREE_TYPE (captures[3]), TREE_TYPE (captures[0]))
6420 : 198 : && tree_nop_conversion_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[3]))
6421 : 292 : && wi::to_wide (captures[4]) != 0
6422 : 192 : && single_use (captures[1])
6423 : : )
6424 : : {
6425 : 192 : {
6426 : 192 : unsigned int prec = TYPE_PRECISION (TREE_TYPE (captures[3]));
6427 : 192 : signop sign = TYPE_SIGN (TREE_TYPE (captures[3]));
6428 : 192 : gimple_seq *lseq = seq;
6429 : 192 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1405;
6430 : 192 : {
6431 : 192 : res_op->set_op (out, type, 2);
6432 : 192 : res_op->ops[0] = captures[3];
6433 : 192 : res_op->ops[1] = wide_int_to_tree (TREE_TYPE (captures[3]),
6434 : 192 : wi::max_value (prec, sign)
6435 : 576 : - wi::to_wide (captures[4]));
6436 : 192 : res_op->resimplify (lseq, valueize);
6437 : 192 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 691, __FILE__, __LINE__, true);
6438 : 192 : return true;
6439 : : }
6440 : 0 : next_after_fail1405:;
6441 : : }
6442 : : }
6443 : : return false;
6444 : : }
6445 : :
6446 : : bool
6447 : 988 : gimple_simplify_479 (gimple_match_op *res_op, gimple_seq *seq,
6448 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6449 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6450 : : const enum tree_code ARG_UNUSED (cmp),
6451 : : const enum tree_code ARG_UNUSED (out))
6452 : : {
6453 : 988 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6454 : 988 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2])) && !VECTOR_TYPE_P (TREE_TYPE (captures[2]))
6455 : : )
6456 : : {
6457 : 964 : {
6458 : 964 : tree t = TREE_TYPE (captures[2]), cpx = build_complex_type (t);
6459 : 964 : gimple_seq *lseq = seq;
6460 : 964 : if (lseq
6461 : 352 : && (!single_use (captures[0])))
6462 : 934 : lseq = NULL;
6463 : 964 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1410;
6464 : 964 : {
6465 : 964 : res_op->set_op (out, type, 2);
6466 : 964 : {
6467 : 964 : tree _o1[1], _r1;
6468 : 964 : {
6469 : 964 : tree _o2[2], _r2;
6470 : 964 : _o2[0] = captures[2];
6471 : 964 : _o2[1] = captures[1];
6472 : 964 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_MUL_OVERFLOW, cpx, _o2[0], _o2[1]);
6473 : 964 : tem_op.resimplify (lseq, valueize);
6474 : 964 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
6475 : 964 : if (!_r2) goto next_after_fail1410;
6476 : 30 : _o1[0] = _r2;
6477 : : }
6478 : 30 : gimple_match_op tem_op (res_op->cond.any_else (), IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
6479 : 30 : tem_op.resimplify (lseq, valueize);
6480 : 30 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6481 : 30 : if (!_r1) goto next_after_fail1410;
6482 : 30 : res_op->ops[0] = _r1;
6483 : : }
6484 : 30 : res_op->ops[1] = build_zero_cst (t);
6485 : 30 : res_op->resimplify (lseq, valueize);
6486 : 30 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 716, __FILE__, __LINE__, true);
6487 : 30 : return true;
6488 : : }
6489 : : next_after_fail1410:;
6490 : : }
6491 : : }
6492 : : return false;
6493 : : }
6494 : :
6495 : : bool
6496 : 352339 : gimple_simplify_484 (gimple_match_op *res_op, gimple_seq *seq,
6497 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6498 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6499 : : const enum tree_code ARG_UNUSED (cmp),
6500 : : const enum tree_code ARG_UNUSED (icmp))
6501 : : {
6502 : 352339 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6503 : 696297 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6504 : 352339 : && TYPE_UNSIGNED (TREE_TYPE (captures[0]))
6505 : 215799 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > 1
6506 : 920477 : && (wi::to_wide (captures[2])
6507 : 999736 : == wi::max_value (TYPE_PRECISION (TREE_TYPE (captures[0])), SIGNED) - 1)
6508 : : )
6509 : : {
6510 : 25 : {
6511 : 25 : tree stype = signed_type_for (TREE_TYPE (captures[0]));
6512 : 25 : gimple_seq *lseq = seq;
6513 : 25 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1422;
6514 : 25 : {
6515 : 25 : res_op->set_op (icmp, type, 2);
6516 : 25 : {
6517 : 25 : tree _o1[1], _r1;
6518 : 25 : _o1[0] = captures[0];
6519 : 25 : if (stype != TREE_TYPE (_o1[0]) /* XXX */
6520 : 25 : && !useless_type_conversion_p (stype, TREE_TYPE (_o1[0])))
6521 : : {
6522 : 25 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, stype, _o1[0]);
6523 : 25 : tem_op.resimplify (lseq, valueize);
6524 : 25 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6525 : 25 : if (!_r1) goto next_after_fail1422;
6526 : : }
6527 : : else
6528 : : _r1 = _o1[0];
6529 : 23 : res_op->ops[0] = _r1;
6530 : : }
6531 : 23 : res_op->ops[1] = build_int_cst (stype, 0);
6532 : 23 : res_op->resimplify (lseq, valueize);
6533 : 23 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 728, __FILE__, __LINE__, true);
6534 : 23 : return true;
6535 : : }
6536 : : next_after_fail1422:;
6537 : : }
6538 : : }
6539 : : return false;
6540 : : }
6541 : :
6542 : : bool
6543 : 8 : gimple_simplify_488 (gimple_match_op *res_op, gimple_seq *seq,
6544 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6545 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6546 : : const enum tree_code ARG_UNUSED (cmp),
6547 : : const enum tree_code ARG_UNUSED (out))
6548 : : {
6549 : 8 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6550 : 8 : if (TYPE_UNSIGNED (TREE_TYPE (captures[1]))
6551 : 8 : && types_match (TREE_TYPE (captures[1]), TREE_TYPE (captures[2]))
6552 : : )
6553 : : {
6554 : 8 : gimple_seq *lseq = seq;
6555 : 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1426;
6556 : 8 : {
6557 : 8 : res_op->set_op (out, type, 2);
6558 : 8 : {
6559 : 8 : tree _o1[1], _r1;
6560 : 8 : _o1[0] = captures[0];
6561 : 8 : gimple_match_op tem_op (res_op->cond.any_else (), IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), _o1[0]);
6562 : 8 : tem_op.resimplify (lseq, valueize);
6563 : 8 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6564 : 8 : if (!_r1) goto next_after_fail1426;
6565 : 4 : res_op->ops[0] = _r1;
6566 : : }
6567 : 4 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[1]));
6568 : 4 : res_op->resimplify (lseq, valueize);
6569 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 714, __FILE__, __LINE__, true);
6570 : 4 : return true;
6571 : : }
6572 : : next_after_fail1426:;
6573 : : }
6574 : : return false;
6575 : : }
6576 : :
6577 : : bool
6578 : 971 : gimple_simplify_494 (gimple_match_op *res_op, gimple_seq *seq,
6579 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6580 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
6581 : : {
6582 : 971 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6583 : 1942 : if (INTEGRAL_TYPE_P (type)
6584 : 971 : && !TYPE_UNSIGNED (type)
6585 : 884 : && !TYPE_OVERFLOW_TRAPS (type)
6586 : 884 : && tree_nop_conversion_p (type, TREE_TYPE (captures[1]))
6587 : 2826 : && (expr_not_equal_to (captures[0], wi::to_wide (TYPE_MIN_VALUE (type)))
6588 : 1851 : || expr_not_equal_to (captures[1], wi::minus_one (TYPE_PRECISION
6589 : : (TREE_TYPE (captures[1])))))
6590 : : )
6591 : : {
6592 : 18 : gimple_seq *lseq = seq;
6593 : 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1436;
6594 : 18 : {
6595 : 18 : res_op->set_op (TRUNC_MOD_EXPR, type, 2);
6596 : 18 : res_op->ops[0] = captures[0];
6597 : 18 : {
6598 : 18 : tree _o1[1], _r1;
6599 : 18 : _o1[0] = captures[1];
6600 : 18 : if (type != TREE_TYPE (_o1[0]) /* XXX */
6601 : 18 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
6602 : : {
6603 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type, _o1[0]);
6604 : 0 : tem_op.resimplify (lseq, valueize);
6605 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6606 : 0 : if (!_r1) goto next_after_fail1436;
6607 : : }
6608 : : else
6609 : : _r1 = _o1[0];
6610 : 18 : res_op->ops[1] = _r1;
6611 : : }
6612 : 18 : res_op->resimplify (lseq, valueize);
6613 : 18 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 738, __FILE__, __LINE__, true);
6614 : 18 : return true;
6615 : : }
6616 : : next_after_fail1436:;
6617 : : }
6618 : : return false;
6619 : : }
6620 : :
6621 : : bool
6622 : 25569 : gimple_simplify_499 (gimple_match_op *res_op, gimple_seq *seq,
6623 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6624 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6625 : : const enum tree_code ARG_UNUSED (shiftrotate))
6626 : : {
6627 : 25569 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6628 : 25569 : gimple_seq *lseq = seq;
6629 : 25569 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1441;
6630 : 25569 : {
6631 : 25569 : tree tem;
6632 : 25569 : tem = captures[0];
6633 : 25569 : res_op->set_value (tem);
6634 : 25569 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 743, __FILE__, __LINE__, true);
6635 : : return true;
6636 : : }
6637 : 0 : next_after_fail1441:;
6638 : 0 : return false;
6639 : : }
6640 : :
6641 : : bool
6642 : 160 : gimple_simplify_502 (gimple_match_op *res_op, gimple_seq *seq,
6643 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6644 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6645 : : const enum tree_code ARG_UNUSED (shiftrotate))
6646 : : {
6647 : 160 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6648 : 160 : {
6649 : 160 : tree tem = uniform_vector_p (captures[1]);
6650 : 160 : if (tem
6651 : : )
6652 : : {
6653 : 0 : gimple_seq *lseq = seq;
6654 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1444;
6655 : 0 : {
6656 : 0 : res_op->set_op (shiftrotate, type, 2);
6657 : 0 : res_op->ops[0] = captures[0];
6658 : 0 : res_op->ops[1] = tem;
6659 : 0 : res_op->resimplify (lseq, valueize);
6660 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 745, __FILE__, __LINE__, true);
6661 : 0 : return true;
6662 : : }
6663 : 0 : next_after_fail1444:;
6664 : : }
6665 : : }
6666 : : return false;
6667 : : }
6668 : :
6669 : : bool
6670 : 108662 : gimple_simplify_507 (gimple_match_op *res_op, gimple_seq *seq,
6671 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6672 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
6673 : : {
6674 : 108662 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6675 : 217324 : if (VECTOR_TYPE_P (type)
6676 : 5054 : && direct_internal_fn_supported_p (IFN_AVG_FLOOR, type, OPTIMIZE_FOR_BOTH)
6677 : 108662 : && wi::clz (get_nonzero_bits (captures[1])) > 0
6678 : 113716 : && wi::clz (get_nonzero_bits (captures[2])) > 0
6679 : : )
6680 : : {
6681 : 0 : gimple_seq *lseq = seq;
6682 : 0 : if (lseq
6683 : 0 : && (!single_use (captures[0])))
6684 : 0 : lseq = NULL;
6685 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1452;
6686 : 0 : {
6687 : 0 : res_op->set_op (CFN_AVG_FLOOR, type, 2);
6688 : 0 : res_op->ops[0] = captures[1];
6689 : 0 : res_op->ops[1] = captures[2];
6690 : 0 : res_op->resimplify (lseq, valueize);
6691 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 752, __FILE__, __LINE__, true);
6692 : 0 : return true;
6693 : : }
6694 : 0 : next_after_fail1452:;
6695 : : }
6696 : : return false;
6697 : : }
6698 : :
6699 : : bool
6700 : 102 : gimple_simplify_509 (gimple_match_op *res_op, gimple_seq *seq,
6701 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6702 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6703 : : const combined_fn ARG_UNUSED (bswap))
6704 : : {
6705 : 102 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6706 : 102 : if (BITS_PER_UNIT == 8
6707 : : && CHAR_TYPE_SIZE == 8
6708 : 102 : && tree_fits_uhwi_p (captures[2])
6709 : : )
6710 : : {
6711 : 102 : {
6712 : 102 : unsigned HOST_WIDE_INT prec = TYPE_PRECISION (TREE_TYPE (captures[0]));
6713 : 102 : unsigned HOST_WIDE_INT bits = tree_to_uhwi (captures[2]);
6714 : 102 : tree st = TYPE_PRECISION (type) > prec ? TREE_TYPE (captures[0]) : type;
6715 : 102 : if (TYPE_PRECISION (type) > prec
6716 : 2 : && !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
6717 : 0 : && TYPE_UNSIGNED (type)
6718 : 102 : && bits < prec && bits + 8 >= prec
6719 : : )
6720 : : {
6721 : 0 : {
6722 : 0 : tree nst = build_int_cst (integer_type_node, prec - 8);
6723 : 0 : gimple_seq *lseq = seq;
6724 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1455;
6725 : 0 : {
6726 : 0 : res_op->set_op (RSHIFT_EXPR, type, 2);
6727 : 0 : {
6728 : 0 : tree _r1;
6729 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
6730 : 0 : {
6731 : 0 : tree _o2[2], _r2;
6732 : 0 : {
6733 : 0 : tree _o3[1], _r3;
6734 : 0 : _o3[0] = captures[1];
6735 : 0 : if (st != TREE_TYPE (_o3[0]) /* XXX */
6736 : 0 : && !useless_type_conversion_p (st, TREE_TYPE (_o3[0])))
6737 : : {
6738 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, st, _o3[0]);
6739 : 0 : tem_op.resimplify (lseq, valueize);
6740 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
6741 : 0 : if (!_r3) goto next_after_fail1455;
6742 : : }
6743 : : else
6744 : : _r3 = _o3[0];
6745 : 0 : _o2[0] = _r3;
6746 : : }
6747 : 0 : _o2[1] = nst;
6748 : 0 : tem_op.set_op (LSHIFT_EXPR, st, 2);
6749 : 0 : tem_op.ops[0] = _o2[0];
6750 : 0 : tem_op.ops[1] = _o2[1];
6751 : 0 : tem_op.resimplify (lseq, valueize);
6752 : : }
6753 : 0 : if (type != tem_op.type
6754 : 0 : && !useless_type_conversion_p (type, tem_op.type))
6755 : : {
6756 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6757 : 0 : if (!_r1) goto next_after_fail1455;
6758 : 0 : tem_op.set_op (NOP_EXPR, type, 1);
6759 : 0 : tem_op.ops[0] = _r1;
6760 : 0 : tem_op.resimplify (lseq, valueize);
6761 : : }
6762 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6763 : 0 : if (!_r1) goto next_after_fail1455;
6764 : 0 : res_op->ops[0] = _r1;
6765 : : }
6766 : 0 : res_op->ops[1] = captures[2];
6767 : 0 : res_op->resimplify (lseq, valueize);
6768 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 755, __FILE__, __LINE__, true);
6769 : 0 : return true;
6770 : : }
6771 : : next_after_fail1455:;
6772 : : }
6773 : : }
6774 : : else
6775 : : {
6776 : 102 : if (bits + 8 == prec
6777 : : )
6778 : : {
6779 : 0 : if (TYPE_UNSIGNED (st)
6780 : : )
6781 : : {
6782 : 0 : gimple_seq *lseq = seq;
6783 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1456;
6784 : 0 : {
6785 : 0 : res_op->set_op (NOP_EXPR, type, 1);
6786 : 0 : {
6787 : 0 : tree _o1[1], _r1;
6788 : 0 : _o1[0] = captures[1];
6789 : 0 : (*res_op).set_op (NOP_EXPR, unsigned_char_type_node, 1);
6790 : 0 : (*res_op).ops[0] = _o1[0];
6791 : 0 : (*res_op).resimplify (lseq, valueize);
6792 : : }
6793 : 0 : if (type != res_op->type
6794 : 0 : && !useless_type_conversion_p (type, res_op->type))
6795 : : {
6796 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1456;
6797 : 0 : res_op->set_op (NOP_EXPR, type, 1);
6798 : 0 : res_op->resimplify (lseq, valueize);
6799 : : }
6800 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 756, __FILE__, __LINE__, true);
6801 : 0 : return true;
6802 : : }
6803 : : next_after_fail1456:;
6804 : : }
6805 : : else
6806 : : {
6807 : 0 : gimple_seq *lseq = seq;
6808 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1457;
6809 : 0 : {
6810 : 0 : res_op->set_op (NOP_EXPR, type, 1);
6811 : 0 : {
6812 : 0 : tree _o1[1], _r1;
6813 : 0 : _o1[0] = captures[1];
6814 : 0 : (*res_op).set_op (NOP_EXPR, signed_char_type_node, 1);
6815 : 0 : (*res_op).ops[0] = _o1[0];
6816 : 0 : (*res_op).resimplify (lseq, valueize);
6817 : : }
6818 : 0 : if (type != res_op->type
6819 : 0 : && !useless_type_conversion_p (type, res_op->type))
6820 : : {
6821 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1457;
6822 : 0 : res_op->set_op (NOP_EXPR, type, 1);
6823 : 0 : res_op->resimplify (lseq, valueize);
6824 : : }
6825 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 757, __FILE__, __LINE__, true);
6826 : 0 : return true;
6827 : : }
6828 : : next_after_fail1457:;
6829 : : }
6830 : : }
6831 : : else
6832 : : {
6833 : 102 : if (bits < prec && bits + 8 > prec
6834 : : )
6835 : : {
6836 : 2 : {
6837 : 2 : tree nst = build_int_cst (integer_type_node, bits & 7);
6838 : 2 : tree bt = TYPE_UNSIGNED (st) ? unsigned_char_type_node
6839 : 2 : : signed_char_type_node;
6840 : 2 : gimple_seq *lseq = seq;
6841 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1458;
6842 : 2 : {
6843 : 2 : res_op->set_op (NOP_EXPR, type, 1);
6844 : 2 : {
6845 : 2 : tree _o1[2], _r1;
6846 : 2 : {
6847 : 2 : tree _o2[1], _r2;
6848 : 2 : _o2[0] = captures[1];
6849 : 2 : if (bt != TREE_TYPE (_o2[0]) /* XXX */
6850 : 2 : && !useless_type_conversion_p (bt, TREE_TYPE (_o2[0])))
6851 : : {
6852 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, bt, _o2[0]);
6853 : 2 : tem_op.resimplify (lseq, valueize);
6854 : 2 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
6855 : 2 : if (!_r2) goto next_after_fail1458;
6856 : : }
6857 : : else
6858 : : _r2 = _o2[0];
6859 : 1 : _o1[0] = _r2;
6860 : : }
6861 : 1 : _o1[1] = nst;
6862 : 1 : (*res_op).set_op (RSHIFT_EXPR, bt, 2);
6863 : 1 : (*res_op).ops[0] = _o1[0];
6864 : 1 : (*res_op).ops[1] = _o1[1];
6865 : 1 : (*res_op).resimplify (lseq, valueize);
6866 : : }
6867 : 1 : if (type != res_op->type
6868 : 1 : && !useless_type_conversion_p (type, res_op->type))
6869 : : {
6870 : 1 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1458;
6871 : 1 : res_op->set_op (NOP_EXPR, type, 1);
6872 : 1 : res_op->resimplify (lseq, valueize);
6873 : : }
6874 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 758, __FILE__, __LINE__, true);
6875 : 1 : return true;
6876 : : }
6877 : : next_after_fail1458:;
6878 : : }
6879 : : }
6880 : : }
6881 : : }
6882 : : }
6883 : : }
6884 : : return false;
6885 : : }
6886 : :
6887 : : bool
6888 : 6854 : gimple_simplify_529 (gimple_match_op *res_op, gimple_seq *seq,
6889 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6890 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
6891 : : const combined_fn ARG_UNUSED (pows),
6892 : : const combined_fn ARG_UNUSED (exps),
6893 : : const combined_fn ARG_UNUSED (logs),
6894 : : const combined_fn ARG_UNUSED (exp2s),
6895 : : const combined_fn ARG_UNUSED (log2s))
6896 : : {
6897 : 6854 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6898 : 6854 : if (flag_unsafe_math_optimizations
6899 : : )
6900 : : {
6901 : 122 : if (real_compare (GT_EXPR, TREE_REAL_CST_PTR (captures[0]), &dconst0)
6902 : 109 : && real_isfinite (TREE_REAL_CST_PTR (captures[0]))
6903 : 122 : && canonicalize_math_after_vectorization_p ()
6904 : : )
6905 : : {
6906 : 12 : {
6907 : 12 : const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (captures[0]);
6908 : 12 : bool use_exp2 = false;
6909 : 12 : if (targetm.libc_has_function (function_c99_misc, TREE_TYPE (captures[0]))
6910 : 12 : && value->cl == rvc_normal)
6911 : : {
6912 : 12 : REAL_VALUE_TYPE frac_rvt = *value;
6913 : 12 : SET_REAL_EXP (&frac_rvt, 1);
6914 : 12 : if (real_equal (&frac_rvt, &dconst1))
6915 : 8 : use_exp2 = true;
6916 : : }
6917 : 4 : if (!use_exp2
6918 : : )
6919 : : {
6920 : 4 : if (optimize_pow_to_exp (captures[0], captures[1])
6921 : : )
6922 : : {
6923 : 0 : gimple_seq *lseq = seq;
6924 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1492;
6925 : 0 : {
6926 : 0 : res_op->set_op (exps, type, 1);
6927 : 0 : {
6928 : 0 : tree _o1[2], _r1;
6929 : 0 : {
6930 : 0 : tree _o2[1], _r2;
6931 : 0 : _o2[0] = captures[0];
6932 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), logs, TREE_TYPE (_o2[0]), _o2[0]);
6933 : 0 : tem_op.resimplify (lseq, valueize);
6934 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
6935 : 0 : if (!_r2) goto next_after_fail1492;
6936 : 0 : _o1[0] = _r2;
6937 : : }
6938 : 0 : _o1[1] = captures[1];
6939 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6940 : 0 : tem_op.resimplify (lseq, valueize);
6941 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6942 : 0 : if (!_r1) goto next_after_fail1492;
6943 : 0 : res_op->ops[0] = _r1;
6944 : : }
6945 : 0 : res_op->resimplify (lseq, valueize);
6946 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 780, __FILE__, __LINE__, true);
6947 : 0 : return true;
6948 : : }
6949 : : next_after_fail1492:;
6950 : : }
6951 : : }
6952 : : else
6953 : : {
6954 : 8 : gimple_seq *lseq = seq;
6955 : 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1493;
6956 : 8 : {
6957 : 8 : res_op->set_op (exp2s, type, 1);
6958 : 8 : {
6959 : 8 : tree _o1[2], _r1;
6960 : 8 : {
6961 : 8 : tree _o2[1], _r2;
6962 : 8 : _o2[0] = captures[0];
6963 : 8 : gimple_match_op tem_op (res_op->cond.any_else (), log2s, TREE_TYPE (_o2[0]), _o2[0]);
6964 : 8 : tem_op.resimplify (lseq, valueize);
6965 : 8 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
6966 : 8 : if (!_r2) goto next_after_fail1493;
6967 : 8 : _o1[0] = _r2;
6968 : : }
6969 : 8 : _o1[1] = captures[1];
6970 : 8 : gimple_match_op tem_op (res_op->cond.any_else (), MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
6971 : 8 : tem_op.resimplify (lseq, valueize);
6972 : 8 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
6973 : 8 : if (!_r1) goto next_after_fail1493;
6974 : 8 : res_op->ops[0] = _r1;
6975 : : }
6976 : 8 : res_op->resimplify (lseq, valueize);
6977 : 8 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 781, __FILE__, __LINE__, true);
6978 : 8 : return true;
6979 : : }
6980 : : next_after_fail1493:;
6981 : : }
6982 : : }
6983 : : }
6984 : : }
6985 : : return false;
6986 : : }
6987 : :
6988 : : bool
6989 : 4 : gimple_simplify_544 (gimple_match_op *res_op, gimple_seq *seq,
6990 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
6991 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
6992 : : {
6993 : 4 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
6994 : 8 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
6995 : 8 : && TYPE_PRECISION (TREE_TYPE (captures[0])) == 1
6996 : : )
6997 : : {
6998 : 4 : gimple_seq *lseq = seq;
6999 : 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1509;
7000 : 4 : {
7001 : 4 : res_op->set_op (BIT_AND_EXPR, type, 2);
7002 : 4 : res_op->ops[0] = captures[0];
7003 : 4 : res_op->ops[1] = captures[1];
7004 : 4 : res_op->resimplify (lseq, valueize);
7005 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 797, __FILE__, __LINE__, true);
7006 : 4 : return true;
7007 : : }
7008 : 0 : next_after_fail1509:;
7009 : : }
7010 : : return false;
7011 : : }
7012 : :
7013 : : bool
7014 : 210205 : gimple_simplify_548 (gimple_match_op *res_op, gimple_seq *seq,
7015 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7016 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
7017 : : {
7018 : 210205 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7019 : 210205 : {
7020 : 210205 : bool wascmp;
7021 : 210205 : if (bitwise_inverted_equal_p (captures[0], captures[1], wascmp)
7022 : 210205 : && (!wascmp || element_precision (type) == 1)
7023 : : )
7024 : : {
7025 : 31 : gimple_seq *lseq = seq;
7026 : 31 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1513;
7027 : 31 : {
7028 : 31 : res_op->set_op (BIT_AND_EXPR, type, 2);
7029 : 31 : res_op->ops[0] = captures[0];
7030 : 31 : res_op->ops[1] = captures[2];
7031 : 31 : res_op->resimplify (lseq, valueize);
7032 : 31 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 801, __FILE__, __LINE__, true);
7033 : 31 : return true;
7034 : : }
7035 : 0 : next_after_fail1513:;
7036 : : }
7037 : : }
7038 : 210174 : return false;
7039 : : }
7040 : :
7041 : : bool
7042 : 11059 : gimple_simplify_552 (gimple_match_op *res_op, gimple_seq *seq,
7043 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7044 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7045 : : const enum tree_code ARG_UNUSED (bitop),
7046 : : const enum tree_code ARG_UNUSED (op))
7047 : : {
7048 : 11059 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7049 : 11059 : {
7050 : 11059 : tree pmop[2];
7051 : 11059 : tree utype = fold_bit_and_mask (TREE_TYPE (captures[1]), captures[5], op, captures[1], ERROR_MARK,
7052 : : NULL_TREE, NULL_TREE, captures[2], bitop, captures[3],
7053 : : captures[4], pmop);
7054 : 11059 : if (utype
7055 : : )
7056 : : {
7057 : 8847 : gimple_seq *lseq = seq;
7058 : 8847 : if (lseq
7059 : 3161 : && (!single_use (captures[0])
7060 : 2619 : || !single_use (captures[2])))
7061 : 8760 : lseq = NULL;
7062 : 8847 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1517;
7063 : 8847 : {
7064 : 8847 : res_op->set_op (NOP_EXPR, type, 1);
7065 : 8847 : {
7066 : 8847 : tree _o1[2], _r1;
7067 : 8847 : {
7068 : 8847 : tree _o2[2], _r2;
7069 : 8847 : {
7070 : 8847 : tree _o3[1], _r3;
7071 : 8847 : _o3[0] = pmop[0];
7072 : 8847 : if (utype != TREE_TYPE (_o3[0]) /* XXX */
7073 : 8847 : && !useless_type_conversion_p (utype, TREE_TYPE (_o3[0])))
7074 : : {
7075 : 114 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o3[0]);
7076 : 114 : tem_op.resimplify (lseq, valueize);
7077 : 114 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
7078 : 114 : if (!_r3) goto next_after_fail1517;
7079 : : }
7080 : : else
7081 : : _r3 = _o3[0];
7082 : 8736 : _o2[0] = _r3;
7083 : : }
7084 : 8736 : {
7085 : 8736 : tree _o3[1], _r3;
7086 : 8736 : _o3[0] = pmop[1];
7087 : 8736 : if (utype != TREE_TYPE (_o3[0]) /* XXX */
7088 : 8736 : && !useless_type_conversion_p (utype, TREE_TYPE (_o3[0])))
7089 : : {
7090 : 3 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o3[0]);
7091 : 3 : tem_op.resimplify (lseq, valueize);
7092 : 3 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
7093 : 3 : if (!_r3) goto next_after_fail1517;
7094 : : }
7095 : : else
7096 : : _r3 = _o3[0];
7097 : 8736 : _o2[1] = _r3;
7098 : : }
7099 : 8736 : gimple_match_op tem_op (res_op->cond.any_else (), op, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
7100 : 8736 : tem_op.resimplify (lseq, valueize);
7101 : 8736 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
7102 : 8736 : if (!_r2) goto next_after_fail1517;
7103 : 87 : _o1[0] = _r2;
7104 : : }
7105 : 87 : {
7106 : 87 : tree _o2[1], _r2;
7107 : 87 : _o2[0] = captures[5];
7108 : 87 : if (utype != TREE_TYPE (_o2[0]) /* XXX */
7109 : 87 : && !useless_type_conversion_p (utype, TREE_TYPE (_o2[0])))
7110 : : {
7111 : 3 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, utype, _o2[0]);
7112 : 3 : tem_op.resimplify (lseq, valueize);
7113 : 3 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
7114 : 3 : if (!_r2) goto next_after_fail1517;
7115 : : }
7116 : : else
7117 : : _r2 = _o2[0];
7118 : 87 : _o1[1] = _r2;
7119 : : }
7120 : 87 : (*res_op).set_op (BIT_AND_EXPR, TREE_TYPE (_o1[0]), 2);
7121 : 87 : (*res_op).ops[0] = _o1[0];
7122 : 87 : (*res_op).ops[1] = _o1[1];
7123 : 87 : (*res_op).resimplify (lseq, valueize);
7124 : : }
7125 : 87 : if (type != res_op->type
7126 : 87 : && !useless_type_conversion_p (type, res_op->type))
7127 : : {
7128 : 3 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1517;
7129 : 3 : res_op->set_op (NOP_EXPR, type, 1);
7130 : 3 : res_op->resimplify (lseq, valueize);
7131 : : }
7132 : 87 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 804, __FILE__, __LINE__, true);
7133 : 87 : return true;
7134 : : }
7135 : 10972 : next_after_fail1517:;
7136 : : }
7137 : : }
7138 : 10972 : return false;
7139 : : }
7140 : :
7141 : : bool
7142 : 191849 : gimple_simplify_572 (gimple_match_op *res_op, gimple_seq *seq,
7143 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7144 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7145 : : const enum tree_code ARG_UNUSED (code2),
7146 : : const enum tree_code ARG_UNUSED (code1))
7147 : : {
7148 : 191849 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7149 : 191849 : if ((TREE_CODE (captures[2]) == INTEGER_CST
7150 : 51071 : && TREE_CODE (captures[5]) == INTEGER_CST)
7151 : 204078 : || ((INTEGRAL_TYPE_P (TREE_TYPE (captures[2]))
7152 : 32561 : || (VECTOR_TYPE_P (TREE_TYPE (captures[2]))
7153 : 1115 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, code2))
7154 : 31446 : || POINTER_TYPE_P (TREE_TYPE (captures[2])))
7155 : 148192 : && bitwise_equal_p (captures[2], captures[5]))
7156 : : )
7157 : : {
7158 : 38844 : {
7159 : 38844 : bool one_before = false;
7160 : 38844 : bool one_after = false;
7161 : 38844 : int cmp = 0;
7162 : 38844 : bool allbits = true;
7163 : 38844 : if (TREE_CODE (captures[2]) == INTEGER_CST
7164 : 38842 : && TREE_CODE (captures[5]) == INTEGER_CST)
7165 : : {
7166 : 38842 : allbits = TYPE_PRECISION (TREE_TYPE (captures[2])) <= TYPE_PRECISION (TREE_TYPE (captures[5]));
7167 : 38842 : auto t1 = wi::to_wide (fold_convert (TREE_TYPE (captures[5]), captures[2]));
7168 : 38842 : auto t2 = wi::to_wide (captures[5]);
7169 : 38842 : cmp = wi::cmp (t1, t2, TYPE_SIGN (TREE_TYPE (captures[5])));
7170 : 38842 : if (cmp < 0
7171 : 38842 : && t1 == t2 - 1)
7172 : : one_before = true;
7173 : 38842 : if (cmp > 0
7174 : 38842 : && t1 == t2 + 1)
7175 : : one_after = true;
7176 : : }
7177 : 38844 : bool val;
7178 : 38844 : switch (code2)
7179 : : {
7180 : 0 : case EQ_EXPR: val = (cmp == 0); break;
7181 : 36408 : case NE_EXPR: val = (cmp != 0); break;
7182 : 51 : case LT_EXPR: val = (cmp < 0); break;
7183 : 1655 : case GT_EXPR: val = (cmp > 0); break;
7184 : 582 : case LE_EXPR: val = (cmp <= 0); break;
7185 : 148 : case GE_EXPR: val = (cmp >= 0); break;
7186 : 0 : default: gcc_unreachable ();
7187 : : }
7188 : 38844 : if (code1 == EQ_EXPR && val
7189 : : )
7190 : : {
7191 : 19 : gimple_seq *lseq = seq;
7192 : 19 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1550;
7193 : 19 : {
7194 : 19 : tree tem;
7195 : 19 : tem = captures[0];
7196 : 19 : res_op->set_value (tem);
7197 : 19 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 826, __FILE__, __LINE__, true);
7198 : 19 : return true;
7199 : : }
7200 : 0 : next_after_fail1550:;
7201 : : }
7202 : : else
7203 : : {
7204 : 38825 : if (code1 == EQ_EXPR && !val
7205 : : )
7206 : : {
7207 : 1 : gimple_seq *lseq = seq;
7208 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1551;
7209 : 1 : {
7210 : 1 : tree tem;
7211 : 1 : tem = constant_boolean_node (false, type);
7212 : 1 : res_op->set_value (tem);
7213 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 827, __FILE__, __LINE__, true);
7214 : 1 : return true;
7215 : : }
7216 : 0 : next_after_fail1551:;
7217 : : }
7218 : : else
7219 : : {
7220 : 38824 : if (code1 == NE_EXPR && !val && allbits
7221 : : )
7222 : : {
7223 : 103 : gimple_seq *lseq = seq;
7224 : 103 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1552;
7225 : 103 : {
7226 : 103 : tree tem;
7227 : 103 : tem = captures[3];
7228 : 103 : res_op->set_value (tem);
7229 : 103 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 828, __FILE__, __LINE__, true);
7230 : 103 : return true;
7231 : : }
7232 : 0 : next_after_fail1552:;
7233 : 0 : }
7234 : : else
7235 : : {
7236 : 38721 : if ((code1 == NE_EXPR
7237 : 38721 : && code2 == GE_EXPR
7238 : 147 : && cmp == 0
7239 : 147 : && allbits)
7240 : 38726 : && ((VECTOR_BOOLEAN_TYPE_P (type)
7241 : 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
7242 : 5 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
7243 : : )
7244 : : {
7245 : 5 : gimple_seq *lseq = seq;
7246 : 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1553;
7247 : 5 : {
7248 : 5 : res_op->set_op (GT_EXPR, type, 2);
7249 : 5 : res_op->ops[0] = captures[4];
7250 : 5 : {
7251 : 5 : tree _o1[1], _r1;
7252 : 5 : _o1[0] = captures[2];
7253 : 5 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0]) /* XXX */
7254 : 5 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
7255 : : {
7256 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
7257 : 0 : tem_op.resimplify (lseq, valueize);
7258 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
7259 : 0 : if (!_r1) goto next_after_fail1553;
7260 : : }
7261 : : else
7262 : : _r1 = _o1[0];
7263 : 5 : res_op->ops[1] = _r1;
7264 : : }
7265 : 5 : res_op->resimplify (lseq, valueize);
7266 : 5 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 829, __FILE__, __LINE__, true);
7267 : 5 : return true;
7268 : : }
7269 : : next_after_fail1553:;
7270 : : }
7271 : : else
7272 : : {
7273 : 38716 : if ((code1 == NE_EXPR
7274 : 38716 : && code2 == LE_EXPR
7275 : 540 : && cmp == 0
7276 : 540 : && allbits)
7277 : 38726 : && ((VECTOR_BOOLEAN_TYPE_P (type)
7278 : 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
7279 : 10 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
7280 : : )
7281 : : {
7282 : 10 : gimple_seq *lseq = seq;
7283 : 10 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1554;
7284 : 10 : {
7285 : 10 : res_op->set_op (LT_EXPR, type, 2);
7286 : 10 : res_op->ops[0] = captures[4];
7287 : 10 : {
7288 : 10 : tree _o1[1], _r1;
7289 : 10 : _o1[0] = captures[2];
7290 : 10 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0]) /* XXX */
7291 : 10 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
7292 : : {
7293 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
7294 : 0 : tem_op.resimplify (lseq, valueize);
7295 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
7296 : 0 : if (!_r1) goto next_after_fail1554;
7297 : : }
7298 : : else
7299 : : _r1 = _o1[0];
7300 : 10 : res_op->ops[1] = _r1;
7301 : : }
7302 : 10 : res_op->resimplify (lseq, valueize);
7303 : 10 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 830, __FILE__, __LINE__, true);
7304 : 10 : return true;
7305 : : }
7306 : : next_after_fail1554:;
7307 : : }
7308 : : else
7309 : : {
7310 : 38706 : if ((code1 == NE_EXPR
7311 : 38706 : && code2 == GT_EXPR
7312 : : && one_after
7313 : 1609 : && allbits)
7314 : 38751 : && ((VECTOR_BOOLEAN_TYPE_P (type)
7315 : 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, GT_EXPR))
7316 : 45 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
7317 : : )
7318 : : {
7319 : 45 : gimple_seq *lseq = seq;
7320 : 45 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1555;
7321 : 45 : {
7322 : 45 : res_op->set_op (GT_EXPR, type, 2);
7323 : 45 : res_op->ops[0] = captures[4];
7324 : 45 : {
7325 : 45 : tree _o1[1], _r1;
7326 : 45 : _o1[0] = captures[2];
7327 : 45 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0]) /* XXX */
7328 : 45 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
7329 : : {
7330 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
7331 : 0 : tem_op.resimplify (lseq, valueize);
7332 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
7333 : 0 : if (!_r1) goto next_after_fail1555;
7334 : : }
7335 : : else
7336 : : _r1 = _o1[0];
7337 : 45 : res_op->ops[1] = _r1;
7338 : : }
7339 : 45 : res_op->resimplify (lseq, valueize);
7340 : 45 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 831, __FILE__, __LINE__, true);
7341 : 45 : return true;
7342 : : }
7343 : : next_after_fail1555:;
7344 : : }
7345 : : else
7346 : : {
7347 : 38661 : if ((code1 == NE_EXPR
7348 : 38661 : && code2 == LT_EXPR
7349 : : && one_before
7350 : 17 : && allbits)
7351 : 38661 : && ((VECTOR_BOOLEAN_TYPE_P (type)
7352 : 0 : && expand_vec_cmp_expr_p (TREE_TYPE (captures[2]), type, LT_EXPR))
7353 : 0 : || !VECTOR_TYPE_P (TREE_TYPE (captures[2])))
7354 : : )
7355 : : {
7356 : 0 : gimple_seq *lseq = seq;
7357 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1556;
7358 : 0 : {
7359 : 0 : res_op->set_op (LT_EXPR, type, 2);
7360 : 0 : res_op->ops[0] = captures[4];
7361 : 0 : {
7362 : 0 : tree _o1[1], _r1;
7363 : 0 : _o1[0] = captures[2];
7364 : 0 : if (TREE_TYPE (res_op->ops[0]) != TREE_TYPE (_o1[0]) /* XXX */
7365 : 0 : && !useless_type_conversion_p (TREE_TYPE (res_op->ops[0]), TREE_TYPE (_o1[0])))
7366 : : {
7367 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, TREE_TYPE (res_op->ops[0]), _o1[0]);
7368 : 0 : tem_op.resimplify (lseq, valueize);
7369 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
7370 : 0 : if (!_r1) goto next_after_fail1556;
7371 : : }
7372 : : else
7373 : : _r1 = _o1[0];
7374 : 0 : res_op->ops[1] = _r1;
7375 : : }
7376 : 0 : res_op->resimplify (lseq, valueize);
7377 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 832, __FILE__, __LINE__, true);
7378 : 0 : return true;
7379 : : }
7380 : : next_after_fail1556:;
7381 : : }
7382 : : }
7383 : : }
7384 : : }
7385 : : }
7386 : : }
7387 : : }
7388 : : }
7389 : : }
7390 : : return false;
7391 : : }
7392 : :
7393 : : bool
7394 : 58 : gimple_simplify_601 (gimple_match_op *res_op, gimple_seq *seq,
7395 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7396 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
7397 : : {
7398 : 58 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7399 : 58 : gimple_seq *lseq = seq;
7400 : 58 : if (lseq
7401 : 15 : && (!single_use (captures[0])))
7402 : 43 : lseq = NULL;
7403 : 58 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1612;
7404 : 58 : {
7405 : 58 : res_op->set_op (BIT_AND_EXPR, type, 2);
7406 : 58 : res_op->ops[0] = captures[1];
7407 : 58 : {
7408 : 58 : tree _o1[1], _r1;
7409 : 58 : _o1[0] = captures[2];
7410 : 58 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_NOT_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
7411 : 58 : tem_op.resimplify (lseq, valueize);
7412 : 58 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
7413 : 58 : if (!_r1) goto next_after_fail1612;
7414 : 15 : res_op->ops[1] = _r1;
7415 : : }
7416 : 15 : res_op->resimplify (lseq, valueize);
7417 : 15 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 855, __FILE__, __LINE__, true);
7418 : : return true;
7419 : : }
7420 : : next_after_fail1612:;
7421 : : return false;
7422 : : }
7423 : :
7424 : : bool
7425 : 1464 : gimple_simplify_606 (gimple_match_op *res_op, gimple_seq *seq,
7426 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7427 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
7428 : : {
7429 : 1464 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7430 : 1464 : if (element_precision (type) <= element_precision (TREE_TYPE (captures[0]))
7431 : 1464 : || !TYPE_UNSIGNED (TREE_TYPE (captures[0]))
7432 : : )
7433 : : {
7434 : 1301 : gimple_seq *lseq = seq;
7435 : 1301 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1617;
7436 : 1301 : {
7437 : 1301 : res_op->set_op (NOP_EXPR, type, 1);
7438 : 1301 : {
7439 : 1301 : tree _o1[2], _r1;
7440 : 1301 : _o1[0] = captures[0];
7441 : 1301 : _o1[1] = build_each_one_cst (TREE_TYPE (captures[0]));
7442 : 1301 : (*res_op).set_op (MINUS_EXPR, TREE_TYPE (_o1[0]), 2);
7443 : 1301 : (*res_op).ops[0] = _o1[0];
7444 : 1301 : (*res_op).ops[1] = _o1[1];
7445 : 1301 : (*res_op).resimplify (lseq, valueize);
7446 : : }
7447 : 1301 : if (type != res_op->type
7448 : 1301 : && !useless_type_conversion_p (type, res_op->type))
7449 : : {
7450 : 100 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1617;
7451 : 19 : res_op->set_op (NOP_EXPR, type, 1);
7452 : 19 : res_op->resimplify (lseq, valueize);
7453 : : }
7454 : 1220 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 860, __FILE__, __LINE__, true);
7455 : 1220 : return true;
7456 : : }
7457 : : next_after_fail1617:;
7458 : : }
7459 : : return false;
7460 : : }
7461 : :
7462 : : bool
7463 : 250723 : gimple_simplify_613 (gimple_match_op *res_op, gimple_seq *seq,
7464 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7465 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7466 : : const enum tree_code ARG_UNUSED (cmp),
7467 : : const enum tree_code ARG_UNUSED (icmp),
7468 : : const enum tree_code ARG_UNUSED (ncmp))
7469 : : {
7470 : 250723 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7471 : 250723 : if (VECTOR_TYPE_P (type)
7472 : 250723 : || (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1)
7473 : : )
7474 : : {
7475 : 250723 : {
7476 : 250723 : enum tree_code ic = invert_tree_comparison
7477 : 250723 : (cmp, HONOR_NANS (captures[0]));
7478 : 250723 : if (ic == icmp
7479 : : )
7480 : : {
7481 : 218459 : gimple_seq *lseq = seq;
7482 : 218459 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1624;
7483 : 218459 : {
7484 : 218459 : res_op->set_op (icmp, type, 2);
7485 : 218459 : res_op->ops[0] = captures[0];
7486 : 218459 : res_op->ops[1] = captures[1];
7487 : 218459 : res_op->resimplify (lseq, valueize);
7488 : 218459 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 865, __FILE__, __LINE__, true);
7489 : 218459 : return true;
7490 : : }
7491 : 0 : next_after_fail1624:;
7492 : : }
7493 : : else
7494 : : {
7495 : 32264 : if (ic == ncmp
7496 : : )
7497 : : {
7498 : 94 : gimple_seq *lseq = seq;
7499 : 94 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1625;
7500 : 94 : {
7501 : 94 : res_op->set_op (ncmp, type, 2);
7502 : 94 : res_op->ops[0] = captures[0];
7503 : 94 : res_op->ops[1] = captures[1];
7504 : 94 : res_op->resimplify (lseq, valueize);
7505 : 94 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 866, __FILE__, __LINE__, true);
7506 : 94 : return true;
7507 : : }
7508 : 0 : next_after_fail1625:;
7509 : : }
7510 : : }
7511 : : }
7512 : : }
7513 : : return false;
7514 : : }
7515 : :
7516 : : bool
7517 : 0 : gimple_simplify_621 (gimple_match_op *res_op, gimple_seq *seq,
7518 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7519 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7520 : : const enum tree_code ARG_UNUSED (minmax),
7521 : : const enum tree_code ARG_UNUSED (cmp))
7522 : : {
7523 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7524 : 0 : {
7525 : 0 : poly_int64 off0, off1;
7526 : 0 : tree base0, base1;
7527 : 0 : int equal = address_compare (cmp, TREE_TYPE (captures[0]), captures[1], captures[3], base0, base1,
7528 : : off0, off1,
7529 : :
7530 : : );
7531 : 0 : if (equal == 1
7532 : : )
7533 : : {
7534 : 0 : if (minmax == MIN_EXPR
7535 : : )
7536 : : {
7537 : 0 : if (known_le (off0, off1)
7538 : : )
7539 : : {
7540 : 0 : gimple_seq *lseq = seq;
7541 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1639;
7542 : 0 : {
7543 : 0 : tree tem;
7544 : 0 : tem = captures[0];
7545 : 0 : res_op->set_value (tem);
7546 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 871, __FILE__, __LINE__, true);
7547 : 0 : return true;
7548 : : }
7549 : 0 : next_after_fail1639:;
7550 : : }
7551 : : else
7552 : : {
7553 : 0 : if (known_gt (off0, off1)
7554 : : )
7555 : : {
7556 : 0 : gimple_seq *lseq = seq;
7557 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1640;
7558 : 0 : {
7559 : 0 : tree tem;
7560 : 0 : tem = captures[2];
7561 : 0 : res_op->set_value (tem);
7562 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 872, __FILE__, __LINE__, true);
7563 : 0 : return true;
7564 : : }
7565 : 0 : next_after_fail1640:;
7566 : : }
7567 : : }
7568 : : }
7569 : : else
7570 : : {
7571 : 0 : if (known_ge (off0, off1)
7572 : : )
7573 : : {
7574 : 0 : gimple_seq *lseq = seq;
7575 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1641;
7576 : 0 : {
7577 : 0 : tree tem;
7578 : 0 : tem = captures[0];
7579 : 0 : res_op->set_value (tem);
7580 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 873, __FILE__, __LINE__, true);
7581 : 0 : return true;
7582 : : }
7583 : 0 : next_after_fail1641:;
7584 : : }
7585 : : else
7586 : : {
7587 : 0 : if (known_lt (off0, off1)
7588 : : )
7589 : : {
7590 : 0 : gimple_seq *lseq = seq;
7591 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1642;
7592 : 0 : {
7593 : 0 : tree tem;
7594 : 0 : tem = captures[2];
7595 : 0 : res_op->set_value (tem);
7596 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 874, __FILE__, __LINE__, true);
7597 : 0 : return true;
7598 : : }
7599 : 0 : next_after_fail1642:;
7600 : : }
7601 : : }
7602 : : }
7603 : : }
7604 : : }
7605 : 0 : return false;
7606 : : }
7607 : :
7608 : : bool
7609 : 9410 : gimple_simplify_639 (gimple_match_op *res_op, gimple_seq *seq,
7610 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7611 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7612 : : const enum tree_code ARG_UNUSED (cmp),
7613 : : const enum tree_code ARG_UNUSED (minmax),
7614 : : const enum tree_code ARG_UNUSED (MINMAX))
7615 : : {
7616 : 9410 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7617 : 9410 : if (VECTOR_INTEGER_TYPE_P (type)
7618 : 9469 : && target_supports_op_p (type, MINMAX, optab_vector)
7619 : : )
7620 : : {
7621 : 59 : gimple_seq *lseq = seq;
7622 : 59 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1666;
7623 : 59 : {
7624 : 59 : res_op->set_op (minmax, type, 2);
7625 : 59 : res_op->ops[0] = captures[0];
7626 : 59 : res_op->ops[1] = captures[1];
7627 : 59 : res_op->resimplify (lseq, valueize);
7628 : 59 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 894, __FILE__, __LINE__, true);
7629 : 59 : return true;
7630 : : }
7631 : 0 : next_after_fail1666:;
7632 : : }
7633 : : return false;
7634 : : }
7635 : :
7636 : : bool
7637 : 0 : gimple_simplify_645 (gimple_match_op *res_op, gimple_seq *seq,
7638 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7639 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7640 : : const enum tree_code ARG_UNUSED (cmp))
7641 : : {
7642 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7643 : 0 : gimple_seq *lseq = seq;
7644 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1672;
7645 : 0 : {
7646 : 0 : tree tem;
7647 : 0 : tem = captures[0];
7648 : 0 : res_op->set_value (tem);
7649 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 648, __FILE__, __LINE__, true);
7650 : : return true;
7651 : : }
7652 : 0 : next_after_fail1672:;
7653 : 0 : return false;
7654 : : }
7655 : :
7656 : : bool
7657 : 0 : gimple_simplify_652 (gimple_match_op *res_op, gimple_seq *seq,
7658 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7659 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7660 : : const combined_fn ARG_UNUSED (cond_len_op))
7661 : : {
7662 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7663 : 0 : {
7664 : 0 : tree op_type = TREE_TYPE (captures[3]);
7665 : 0 : if (element_precision (type) == element_precision (op_type)
7666 : : )
7667 : : {
7668 : 0 : gimple_seq *lseq = seq;
7669 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1679;
7670 : 0 : {
7671 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
7672 : 0 : {
7673 : 0 : tree _o1[6], _r1;
7674 : 0 : _o1[0] = captures[0];
7675 : 0 : _o1[1] = captures[1];
7676 : 0 : _o1[2] = captures[2];
7677 : 0 : {
7678 : 0 : tree _o2[1], _r2;
7679 : 0 : _o2[0] = captures[6];
7680 : 0 : if (op_type != TREE_TYPE (_o2[0]) /* XXX */
7681 : 0 : && !useless_type_conversion_p (op_type, TREE_TYPE (_o2[0])))
7682 : : {
7683 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, op_type, _o2[0]);
7684 : 0 : tem_op.resimplify (lseq, valueize);
7685 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
7686 : 0 : if (!_r2) goto next_after_fail1679;
7687 : : }
7688 : : else
7689 : : _r2 = _o2[0];
7690 : 0 : _o1[3] = _r2;
7691 : : }
7692 : 0 : _o1[4] = captures[4];
7693 : 0 : _o1[5] = captures[5];
7694 : 0 : (*res_op).set_op (cond_len_op, TREE_TYPE (_o1[1]), 6);
7695 : 0 : (*res_op).ops[0] = _o1[0];
7696 : 0 : (*res_op).ops[1] = _o1[1];
7697 : 0 : (*res_op).ops[2] = _o1[2];
7698 : 0 : (*res_op).ops[3] = _o1[3];
7699 : 0 : (*res_op).ops[4] = _o1[4];
7700 : 0 : (*res_op).ops[5] = _o1[5];
7701 : 0 : (*res_op).resimplify (lseq, valueize);
7702 : : }
7703 : 0 : if (type != res_op->type
7704 : 0 : && !useless_type_conversion_p (type, res_op->type))
7705 : : {
7706 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail1679;
7707 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
7708 : 0 : res_op->resimplify (lseq, valueize);
7709 : : }
7710 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 902, __FILE__, __LINE__, true);
7711 : 0 : return true;
7712 : : }
7713 : : next_after_fail1679:;
7714 : : }
7715 : : }
7716 : : return false;
7717 : : }
7718 : :
7719 : : bool
7720 : 35 : gimple_simplify_660 (gimple_match_op *res_op, gimple_seq *seq,
7721 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7722 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7723 : : const enum tree_code ARG_UNUSED (cmp))
7724 : : {
7725 : 35 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7726 : 35 : gimple_seq *lseq = seq;
7727 : 35 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1687;
7728 : 35 : {
7729 : 35 : tree tem;
7730 : 35 : tem = constant_boolean_node (true, type);
7731 : 35 : res_op->set_value (tem);
7732 : 35 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 910, __FILE__, __LINE__, true);
7733 : : return true;
7734 : : }
7735 : 0 : next_after_fail1687:;
7736 : 0 : return false;
7737 : : }
7738 : :
7739 : : bool
7740 : 17348 : gimple_simplify_661 (gimple_match_op *res_op, gimple_seq *seq,
7741 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7742 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7743 : : const combined_fn ARG_UNUSED (ovf))
7744 : : {
7745 : 17348 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7746 : 34696 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
7747 : 17226 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7748 : 17226 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
7749 : 32845 : && (!TYPE_UNSIGNED (TREE_TYPE (captures[0])) || TYPE_UNSIGNED (TREE_TYPE (captures[1])))
7750 : : )
7751 : : {
7752 : 14521 : gimple_seq *lseq = seq;
7753 : 14521 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1688;
7754 : 14521 : {
7755 : 14521 : res_op->set_op (ovf, type, 2);
7756 : 14521 : res_op->ops[0] = captures[1];
7757 : 14521 : res_op->ops[1] = captures[2];
7758 : 14521 : res_op->resimplify (lseq, valueize);
7759 : 14521 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 911, __FILE__, __LINE__, true);
7760 : 14521 : return true;
7761 : : }
7762 : 0 : next_after_fail1688:;
7763 : : }
7764 : : return false;
7765 : : }
7766 : :
7767 : : bool
7768 : 688 : gimple_simplify_670 (gimple_match_op *res_op, gimple_seq *seq,
7769 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7770 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7771 : : const combined_fn ARG_UNUSED (fns))
7772 : : {
7773 : 688 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7774 : 688 : gimple_seq *lseq = seq;
7775 : 688 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1697;
7776 : 688 : {
7777 : 688 : tree tem;
7778 : 688 : tem = captures[0];
7779 : 688 : res_op->set_value (tem);
7780 : 688 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 920, __FILE__, __LINE__, true);
7781 : : return true;
7782 : : }
7783 : 0 : next_after_fail1697:;
7784 : 0 : return false;
7785 : : }
7786 : :
7787 : : bool
7788 : 75 : gimple_simplify_675 (gimple_match_op *res_op, gimple_seq *seq,
7789 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7790 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
7791 : : {
7792 : 75 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7793 : 75 : gimple_seq *lseq = seq;
7794 : 75 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1702;
7795 : 75 : {
7796 : 75 : tree tem;
7797 : 75 : tem = captures[0];
7798 : 75 : res_op->set_value (tem);
7799 : 75 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 925, __FILE__, __LINE__, true);
7800 : : return true;
7801 : : }
7802 : 0 : next_after_fail1702:;
7803 : 0 : return false;
7804 : : }
7805 : :
7806 : : bool
7807 : 6480 : gimple_simplify_680 (gimple_match_op *res_op, gimple_seq *seq,
7808 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7809 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7810 : : const combined_fn ARG_UNUSED (ifn),
7811 : : const combined_fn ARG_UNUSED (lfn),
7812 : : const combined_fn ARG_UNUSED (llfn))
7813 : : {
7814 : 6480 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7815 : 6480 : if (canonicalize_math_p ()
7816 : : )
7817 : : {
7818 : 4993 : if (TYPE_PRECISION (integer_type_node)
7819 : 4993 : == TYPE_PRECISION (long_integer_type_node)
7820 : : )
7821 : : {
7822 : 12 : gimple_seq *lseq = seq;
7823 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1707;
7824 : 12 : {
7825 : 12 : res_op->set_op (lfn, type, 1);
7826 : 12 : res_op->ops[0] = captures[0];
7827 : 12 : res_op->resimplify (lseq, valueize);
7828 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 930, __FILE__, __LINE__, true);
7829 : 12 : return true;
7830 : : }
7831 : 0 : next_after_fail1707:;
7832 : : }
7833 : : }
7834 : : return false;
7835 : : }
7836 : :
7837 : : bool
7838 : 1 : gimple_simplify_690 (gimple_match_op *res_op, gimple_seq *seq,
7839 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7840 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures))
7841 : : {
7842 : 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7843 : 1 : if (canonicalize_math_after_vectorization_p ()
7844 : : )
7845 : : {
7846 : 1 : gimple_seq *lseq = seq;
7847 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1717;
7848 : 1 : {
7849 : 1 : res_op->set_op (CFN_FMA, type, 3);
7850 : 1 : res_op->ops[0] = captures[0];
7851 : 1 : res_op->ops[1] = captures[1];
7852 : 1 : res_op->ops[2] = captures[2];
7853 : 1 : res_op->resimplify (lseq, valueize);
7854 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 940, __FILE__, __LINE__, true);
7855 : 1 : return true;
7856 : : }
7857 : 0 : next_after_fail1717:;
7858 : : }
7859 : : return false;
7860 : : }
7861 : :
7862 : : bool
7863 : 1777 : gimple_simplify_698 (gimple_match_op *res_op, gimple_seq *seq,
7864 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
7865 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
7866 : : const combined_fn ARG_UNUSED (CTZ))
7867 : : {
7868 : 1777 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
7869 : 3554 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
7870 : 1777 : && INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
7871 : 3554 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
7872 : : )
7873 : : {
7874 : 422 : {
7875 : 422 : combined_fn cfn = CFN_LAST;
7876 : 422 : tree type0 = TREE_TYPE (captures[1]);
7877 : 422 : if (TREE_CODE (type0) == BITINT_TYPE)
7878 : : {
7879 : 12 : if (TYPE_PRECISION (type0) > MAX_FIXED_MODE_SIZE)
7880 : : cfn = CFN_CTZ;
7881 : : else
7882 : 0 : type0
7883 : 0 : = build_nonstandard_integer_type (TYPE_PRECISION (type0),
7884 : : 1);
7885 : : }
7886 : 422 : type0 = unsigned_type_for (type0);
7887 : 422 : if (cfn == CFN_LAST
7888 : 422 : && direct_internal_fn_supported_p (IFN_CTZ, type0,
7889 : : OPTIMIZE_FOR_BOTH))
7890 : : cfn = CFN_CTZ;
7891 : 396 : if (cfn == CFN_LAST
7892 : 390 : && TYPE_PRECISION (TREE_TYPE (captures[0])) > BITS_PER_WORD
7893 : 396 : && !direct_internal_fn_supported_p (IFN_CTZ,
7894 : 0 : TREE_TYPE (captures[0]),
7895 : : OPTIMIZE_FOR_BOTH))
7896 : : {
7897 : 0 : if (TYPE_PRECISION (type0)
7898 : 0 : == TYPE_PRECISION (unsigned_type_node))
7899 : : cfn = CFN_BUILT_IN_CTZ;
7900 : 0 : else if (TYPE_PRECISION (type0)
7901 : 0 : == TYPE_PRECISION (long_long_unsigned_type_node))
7902 : 422 : cfn = CFN_BUILT_IN_CTZLL;
7903 : : }
7904 : 422 : if (sanitize_flags_p (SANITIZE_BUILTIN)
7905 : 422 : && (!cfun
7906 : 0 : || (cfun->curr_properties & PROP_ssa) == 0))
7907 : : cfn = CFN_LAST;
7908 : 422 : if (cfn == CFN_CTZ
7909 : : )
7910 : : {
7911 : 32 : gimple_seq *lseq = seq;
7912 : 32 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1725;
7913 : 32 : {
7914 : 32 : res_op->set_op (CFN_CTZ, type, 1);
7915 : 32 : {
7916 : 32 : tree _o1[1], _r1;
7917 : 32 : _o1[0] = captures[1];
7918 : 32 : if (type0 != TREE_TYPE (_o1[0]) /* XXX */
7919 : 32 : && !useless_type_conversion_p (type0, TREE_TYPE (_o1[0])))
7920 : : {
7921 : 11 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type0, _o1[0]);
7922 : 11 : tem_op.resimplify (lseq, valueize);
7923 : 11 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
7924 : 11 : if (!_r1) goto next_after_fail1725;
7925 : : }
7926 : : else
7927 : : _r1 = _o1[0];
7928 : 27 : res_op->ops[0] = _r1;
7929 : : }
7930 : 27 : res_op->resimplify (lseq, valueize);
7931 : 27 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 945, __FILE__, __LINE__, true);
7932 : 27 : return true;
7933 : : }
7934 : : next_after_fail1725:;
7935 : : }
7936 : : else
7937 : : {
7938 : 390 : if (cfn == CFN_BUILT_IN_CTZ
7939 : : )
7940 : : {
7941 : 0 : gimple_seq *lseq = seq;
7942 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1726;
7943 : 0 : {
7944 : 0 : res_op->set_op (CFN_BUILT_IN_CTZ, type, 1);
7945 : 0 : {
7946 : 0 : tree _o1[1], _r1;
7947 : 0 : _o1[0] = captures[1];
7948 : 0 : if (type0 != TREE_TYPE (_o1[0]) /* XXX */
7949 : 0 : && !useless_type_conversion_p (type0, TREE_TYPE (_o1[0])))
7950 : : {
7951 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type0, _o1[0]);
7952 : 0 : tem_op.resimplify (lseq, valueize);
7953 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
7954 : 0 : if (!_r1) goto next_after_fail1726;
7955 : : }
7956 : : else
7957 : : _r1 = _o1[0];
7958 : 0 : res_op->ops[0] = _r1;
7959 : : }
7960 : 0 : res_op->resimplify (lseq, valueize);
7961 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 946, __FILE__, __LINE__, true);
7962 : 0 : return true;
7963 : : }
7964 : : next_after_fail1726:;
7965 : : }
7966 : : else
7967 : : {
7968 : 390 : if (cfn == CFN_BUILT_IN_CTZLL
7969 : : )
7970 : : {
7971 : 0 : gimple_seq *lseq = seq;
7972 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1727;
7973 : 0 : {
7974 : 0 : res_op->set_op (CFN_BUILT_IN_CTZLL, type, 1);
7975 : 0 : {
7976 : 0 : tree _o1[1], _r1;
7977 : 0 : _o1[0] = captures[1];
7978 : 0 : if (type0 != TREE_TYPE (_o1[0]) /* XXX */
7979 : 0 : && !useless_type_conversion_p (type0, TREE_TYPE (_o1[0])))
7980 : : {
7981 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), NOP_EXPR, type0, _o1[0]);
7982 : 0 : tem_op.resimplify (lseq, valueize);
7983 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
7984 : 0 : if (!_r1) goto next_after_fail1727;
7985 : : }
7986 : : else
7987 : : _r1 = _o1[0];
7988 : 0 : res_op->ops[0] = _r1;
7989 : : }
7990 : 0 : res_op->resimplify (lseq, valueize);
7991 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 947, __FILE__, __LINE__, true);
7992 : 0 : return true;
7993 : : }
7994 : : next_after_fail1727:;
7995 : : }
7996 : : }
7997 : : }
7998 : : }
7999 : : }
8000 : : return false;
8001 : : }
8002 : :
8003 : : bool
8004 : 10494 : gimple_simplify_717 (gimple_match_op *res_op, gimple_seq *seq,
8005 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
8006 : : const tree ARG_UNUSED (type), tree *ARG_UNUSED (captures),
8007 : : const enum tree_code ARG_UNUSED (plusminus),
8008 : : const enum tree_code ARG_UNUSED (minusplus))
8009 : : {
8010 : 10494 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8011 : 10494 : if (!VECTOR_INTEGER_TYPE_P (type)
8012 : : && !FLOAT_WORDS_BIG_ENDIAN
8013 : 18029 : && (operand_equal_p (captures[0], captures[2], 0)
8014 : 4783 : ? operand_equal_p (captures[1], captures[3], 0)
8015 : 4004 : : operand_equal_p (captures[0], captures[3], 0) && operand_equal_p (captures[1], captures[2], 0))
8016 : : )
8017 : : {
8018 : 4723 : {
8019 : 4723 : vec_perm_builder builder;
8020 : 4723 : if (tree_to_vec_perm_builder (&builder, captures[4])
8021 : : )
8022 : : {
8023 : 4723 : {
8024 : 4723 : poly_uint64 nelts = TYPE_VECTOR_SUBPARTS (type);
8025 : 4723 : vec_perm_indices sel (builder, 2, nelts);
8026 : 4723 : machine_mode vec_mode = TYPE_MODE (type);
8027 : 4723 : machine_mode wide_mode;
8028 : 4723 : scalar_mode wide_elt_mode;
8029 : 4723 : poly_uint64 wide_nunits;
8030 : 4723 : scalar_mode inner_mode = GET_MODE_INNER (vec_mode);
8031 : 4723 : if (VECTOR_MODE_P (vec_mode)
8032 : 4707 : && sel.series_p (0, 2, 0, 2)
8033 : 4443 : && sel.series_p (1, 2, nelts + 1, 2)
8034 : 7602 : && GET_MODE_2XWIDER_MODE (inner_mode).exists (&wide_elt_mode)
8035 : 4416 : && multiple_p (GET_MODE_NUNITS (vec_mode), 2, &wide_nunits)
8036 : 9139 : && related_vector_mode (vec_mode, wide_elt_mode,
8037 : 3186 : wide_nunits).exists (&wide_mode)
8038 : : )
8039 : : {
8040 : 1537 : {
8041 : 1537 : tree stype
8042 : 1537 : = lang_hooks.types.type_for_mode (GET_MODE_INNER (wide_mode),
8043 : 1537 : TYPE_UNSIGNED (type));
8044 : 1537 : tree ntype = build_vector_type_for_mode (stype, wide_mode);
8045 : 6148 : const struct real_format *fmt_old = FLOAT_MODE_FORMAT (vec_mode);
8046 : 6148 : const struct real_format *fmt_new = FLOAT_MODE_FORMAT (wide_mode);
8047 : 1537 : if (TYPE_MODE (stype) != BLKmode
8048 : 1537 : && VECTOR_TYPE_P (ntype)
8049 : 1537 : && fmt_old != NULL
8050 : 3074 : && fmt_new != NULL
8051 : : )
8052 : : {
8053 : 1537 : {
8054 : 1537 : if (known_eq (GET_MODE_NUNITS (wide_mode), 1)
8055 : 1537 : && !target_supports_op_p (ntype, NEGATE_EXPR, optab_vector))
8056 : : ntype = stype;
8057 : 1537 : if (fmt_new->signbit_rw
8058 : 1537 : == fmt_old->signbit_rw + GET_MODE_UNIT_BITSIZE (vec_mode)
8059 : 1537 : && fmt_new->signbit_rw == fmt_new->signbit_ro
8060 : 1537 : && targetm.can_change_mode_class (TYPE_MODE (ntype),
8061 : 1537 : TYPE_MODE (type), ALL_REGS)
8062 : 1537 : && ((optimize_vectors_before_lowering_p ()
8063 : 0 : && VECTOR_TYPE_P (ntype))
8064 : 0 : || target_supports_op_p (ntype, NEGATE_EXPR, optab_vector))
8065 : : )
8066 : : {
8067 : 0 : if (plusminus == PLUS_EXPR
8068 : : )
8069 : : {
8070 : 0 : gimple_seq *lseq = seq;
8071 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1753;
8072 : 0 : {
8073 : 0 : res_op->set_op (PLUS_EXPR, type, 2);
8074 : 0 : {
8075 : 0 : tree _r1;
8076 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
8077 : 0 : {
8078 : 0 : tree _o2[1], _r2;
8079 : 0 : {
8080 : 0 : tree _o3[1], _r3;
8081 : 0 : _o3[0] = captures[3];
8082 : 0 : if (ntype != TREE_TYPE (_o3[0]) /* XXX */
8083 : 0 : && !useless_type_conversion_p (ntype, TREE_TYPE (_o3[0])))
8084 : : {
8085 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, ntype, _o3[0]);
8086 : 0 : tem_op.resimplify (lseq, valueize);
8087 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
8088 : 0 : if (!_r3) goto next_after_fail1753;
8089 : : }
8090 : : else
8091 : : _r3 = _o3[0];
8092 : 0 : _o2[0] = _r3;
8093 : : }
8094 : 0 : tem_op.set_op (NEGATE_EXPR, TREE_TYPE (_o2[0]), 1);
8095 : 0 : tem_op.ops[0] = _o2[0];
8096 : 0 : tem_op.resimplify (lseq, valueize);
8097 : : }
8098 : 0 : if (type != tem_op.type
8099 : 0 : && !useless_type_conversion_p (type, tem_op.type))
8100 : : {
8101 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
8102 : 0 : if (!_r1) goto next_after_fail1753;
8103 : 0 : tem_op.set_op (VIEW_CONVERT_EXPR, type, 1);
8104 : 0 : tem_op.ops[0] = _r1;
8105 : 0 : tem_op.resimplify (lseq, valueize);
8106 : : }
8107 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
8108 : 0 : if (!_r1) goto next_after_fail1753;
8109 : 0 : res_op->ops[0] = _r1;
8110 : : }
8111 : 0 : res_op->ops[1] = captures[2];
8112 : 0 : res_op->resimplify (lseq, valueize);
8113 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 969, __FILE__, __LINE__, true);
8114 : 0 : return true;
8115 : : }
8116 : 4723 : next_after_fail1753:;
8117 : : }
8118 : : else
8119 : : {
8120 : 0 : gimple_seq *lseq = seq;
8121 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1754;
8122 : 0 : {
8123 : 0 : res_op->set_op (MINUS_EXPR, type, 2);
8124 : 0 : res_op->ops[0] = captures[0];
8125 : 0 : {
8126 : 0 : tree _r1;
8127 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
8128 : 0 : {
8129 : 0 : tree _o2[1], _r2;
8130 : 0 : {
8131 : 0 : tree _o3[1], _r3;
8132 : 0 : _o3[0] = captures[1];
8133 : 0 : if (ntype != TREE_TYPE (_o3[0]) /* XXX */
8134 : 0 : && !useless_type_conversion_p (ntype, TREE_TYPE (_o3[0])))
8135 : : {
8136 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, ntype, _o3[0]);
8137 : 0 : tem_op.resimplify (lseq, valueize);
8138 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
8139 : 0 : if (!_r3) goto next_after_fail1754;
8140 : : }
8141 : : else
8142 : : _r3 = _o3[0];
8143 : 0 : _o2[0] = _r3;
8144 : : }
8145 : 0 : tem_op.set_op (NEGATE_EXPR, TREE_TYPE (_o2[0]), 1);
8146 : 0 : tem_op.ops[0] = _o2[0];
8147 : 0 : tem_op.resimplify (lseq, valueize);
8148 : : }
8149 : 0 : if (type != tem_op.type
8150 : 0 : && !useless_type_conversion_p (type, tem_op.type))
8151 : : {
8152 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
8153 : 0 : if (!_r1) goto next_after_fail1754;
8154 : 0 : tem_op.set_op (VIEW_CONVERT_EXPR, type, 1);
8155 : 0 : tem_op.ops[0] = _r1;
8156 : 0 : tem_op.resimplify (lseq, valueize);
8157 : : }
8158 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
8159 : 0 : if (!_r1) goto next_after_fail1754;
8160 : 0 : res_op->ops[1] = _r1;
8161 : : }
8162 : 0 : res_op->resimplify (lseq, valueize);
8163 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 970, __FILE__, __LINE__, true);
8164 : 0 : return true;
8165 : : }
8166 : 4723 : next_after_fail1754:;
8167 : : }
8168 : : }
8169 : : }
8170 : : }
8171 : : }
8172 : : }
8173 : 4723 : }
8174 : : }
8175 : 4723 : }
8176 : : }
8177 : : return false;
8178 : : }
8179 : :
8180 : : bool
8181 : 1396 : gimple_simplify_CFN_BUILT_IN_COSHL (gimple_match_op *res_op, gimple_seq *seq,
8182 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
8183 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
8184 : : {
8185 : 1396 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8186 : 1396 : switch (TREE_CODE (_p0))
8187 : : {
8188 : 1328 : case SSA_NAME:
8189 : 1328 : if (gimple *_d1 = get_def (valueize, _p0))
8190 : : {
8191 : 645 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
8192 : 312 : switch (gimple_assign_rhs_code (_a1))
8193 : : {
8194 : 14 : case NEGATE_EXPR:
8195 : 14 : {
8196 : 14 : tree _q20 = gimple_assign_rhs1 (_a1);
8197 : 14 : _q20 = do_valueize (valueize, _q20);
8198 : 14 : {
8199 : 14 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8200 : 14 : const combined_fn coss = CFN_BUILT_IN_COSHL;
8201 : 14 : gimple_seq *lseq = seq;
8202 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1796;
8203 : 14 : {
8204 : 14 : res_op->set_op (coss, type, 1);
8205 : 14 : res_op->ops[0] = captures[0];
8206 : 14 : res_op->resimplify (lseq, valueize);
8207 : 14 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 993, __FILE__, __LINE__, true);
8208 : 14 : return true;
8209 : : }
8210 : 0 : next_after_fail1796:;
8211 : : }
8212 : 0 : break;
8213 : : }
8214 : 0 : case ABS_EXPR:
8215 : 0 : {
8216 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
8217 : 0 : _q20 = do_valueize (valueize, _q20);
8218 : 0 : {
8219 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8220 : 0 : const combined_fn coss = CFN_BUILT_IN_COSHL;
8221 : 0 : gimple_seq *lseq = seq;
8222 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1797;
8223 : 0 : {
8224 : 0 : res_op->set_op (coss, type, 1);
8225 : 0 : res_op->ops[0] = captures[0];
8226 : 0 : res_op->resimplify (lseq, valueize);
8227 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 993, __FILE__, __LINE__, true);
8228 : 0 : return true;
8229 : : }
8230 : 0 : next_after_fail1797:;
8231 : : }
8232 : 0 : break;
8233 : : }
8234 : : default:;
8235 : : }
8236 : 377 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
8237 : 16 : switch (gimple_call_combined_fn (_c1))
8238 : : {
8239 : 0 : case CFN_BUILT_IN_COPYSIGN:
8240 : 0 : if (gimple_call_num_args (_c1) == 2)
8241 : : {
8242 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
8243 : 0 : _q20 = do_valueize (valueize, _q20);
8244 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
8245 : 0 : _q21 = do_valueize (valueize, _q21);
8246 : 0 : {
8247 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8248 : 0 : if (gimple_simplify_523 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGN, CFN_BUILT_IN_COSHL))
8249 : 0 : return true;
8250 : : }
8251 : : }
8252 : : break;
8253 : 0 : case CFN_BUILT_IN_COPYSIGNF:
8254 : 0 : if (gimple_call_num_args (_c1) == 2)
8255 : : {
8256 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
8257 : 0 : _q20 = do_valueize (valueize, _q20);
8258 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
8259 : 0 : _q21 = do_valueize (valueize, _q21);
8260 : 0 : {
8261 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8262 : 0 : if (gimple_simplify_523 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNF, CFN_BUILT_IN_COSHL))
8263 : 0 : return true;
8264 : : }
8265 : : }
8266 : : break;
8267 : 0 : case CFN_BUILT_IN_COPYSIGNL:
8268 : 0 : if (gimple_call_num_args (_c1) == 2)
8269 : : {
8270 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
8271 : 0 : _q20 = do_valueize (valueize, _q20);
8272 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
8273 : 0 : _q21 = do_valueize (valueize, _q21);
8274 : 0 : {
8275 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8276 : 0 : if (gimple_simplify_523 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COPYSIGNL, CFN_BUILT_IN_COSHL))
8277 : 0 : return true;
8278 : : }
8279 : : }
8280 : : break;
8281 : 16 : case CFN_BUILT_IN_ATANHL:
8282 : 16 : if (gimple_call_num_args (_c1) == 1)
8283 : : {
8284 : 16 : tree _q20 = gimple_call_arg (_c1, 0);
8285 : 16 : _q20 = do_valueize (valueize, _q20);
8286 : 16 : {
8287 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
8288 : 16 : if (gimple_simplify_525 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_COSHL, CFN_BUILT_IN_ATANHL, CFN_BUILT_IN_SQRTL))
8289 : 1 : return true;
8290 : : }
8291 : : }
8292 : : break;
8293 : 0 : case CFN_COPYSIGN:
8294 : 0 : if (gimple_call_num_args (_c1) == 2)
8295 : : {
8296 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
8297 : 0 : _q20 = do_valueize (valueize, _q20);
8298 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
8299 : 0 : _q21 = do_valueize (valueize, _q21);
8300 : 0 : {
8301 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
8302 : 0 : if (gimple_simplify_523 (res_op, seq, valueize, type, captures, CFN_COPYSIGN, CFN_BUILT_IN_COSHL))
8303 : 0 : return true;
8304 : : }
8305 : : }
8306 : : break;
8307 : : default:;
8308 : : }
8309 : : }
8310 : : break;
8311 : : default:;
8312 : : }
8313 : : return false;
8314 : : }
8315 : :
8316 : : bool
8317 : 3248463 : gimple_simplify_VIEW_CONVERT_EXPR (gimple_match_op *res_op, gimple_seq *seq,
8318 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
8319 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
8320 : : {
8321 : 3248463 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8322 : 3248463 : {
8323 : 3248463 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8324 : 3248463 : if ((
8325 : : 1
8326 : 3248463 : && useless_type_conversion_p (type, TREE_TYPE (captures[0])))
8327 : : || (
8328 : :
8329 : : && type == TREE_TYPE (captures[0]))
8330 : : )
8331 : : {
8332 : 210584 : gimple_seq *lseq = seq;
8333 : 210584 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1845;
8334 : 210584 : {
8335 : 210584 : tree tem;
8336 : 210584 : tem = captures[0];
8337 : 210584 : res_op->set_value (tem);
8338 : 210584 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 982, __FILE__, __LINE__, true);
8339 : 210584 : return true;
8340 : : }
8341 : 0 : next_after_fail1845:;
8342 : : }
8343 : : }
8344 : 3037879 : switch (TREE_CODE (_p0))
8345 : : {
8346 : 2809297 : case SSA_NAME:
8347 : 2809297 : if (gimple *_d1 = get_def (valueize, _p0))
8348 : : {
8349 : 2166030 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
8350 : 1513869 : switch (gimple_assign_rhs_code (_a1))
8351 : : {
8352 : 18704 : case VIEW_CONVERT_EXPR:
8353 : 18704 : {
8354 : 18704 : tree _q20 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 0);
8355 : 18704 : if ((TREE_CODE (_q20) == SSA_NAME
8356 : 18704 : || is_gimple_min_invariant (_q20)))
8357 : : {
8358 : 18700 : _q20 = do_valueize (valueize, _q20);
8359 : 18700 : {
8360 : 18700 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8361 : 18700 : gimple_seq *lseq = seq;
8362 : 18700 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1846;
8363 : 18700 : {
8364 : 18700 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
8365 : 18700 : res_op->ops[0] = captures[0];
8366 : 18700 : res_op->resimplify (lseq, valueize);
8367 : 18700 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1018, __FILE__, __LINE__, true);
8368 : 18700 : return true;
8369 : : }
8370 : 0 : next_after_fail1846:;
8371 : : }
8372 : : }
8373 : : break;
8374 : : }
8375 : 11911 : case BIT_FIELD_REF:
8376 : 11911 : {
8377 : 11911 : tree _q20 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 0);
8378 : 11911 : if ((TREE_CODE (_q20) == SSA_NAME
8379 : 11911 : || is_gimple_min_invariant (_q20)))
8380 : : {
8381 : 11886 : _q20 = do_valueize (valueize, _q20);
8382 : 11886 : tree _q21 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 1);
8383 : 11886 : if ((TREE_CODE (_q21) == SSA_NAME
8384 : 11886 : || is_gimple_min_invariant (_q21)))
8385 : : {
8386 : 11886 : _q21 = do_valueize (valueize, _q21);
8387 : 11886 : tree _q22 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 2);
8388 : 11886 : if ((TREE_CODE (_q22) == SSA_NAME
8389 : 11886 : || is_gimple_min_invariant (_q22)))
8390 : : {
8391 : 11886 : _q22 = do_valueize (valueize, _q22);
8392 : 11886 : {
8393 : 11886 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
8394 : 11886 : if (is_gimple_reg_type (type)
8395 : 11886 : && (!INTEGRAL_TYPE_P (type)
8396 : 337 : || !INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
8397 : 111 : || (type_has_mode_precision_p (type)
8398 : 32 : && type_has_mode_precision_p (TREE_TYPE (captures[0]))))
8399 : : )
8400 : : {
8401 : 11792 : gimple_seq *lseq = seq;
8402 : 11792 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1847;
8403 : 11792 : {
8404 : 11792 : res_op->set_op (BIT_FIELD_REF, type, 3);
8405 : 11792 : res_op->ops[0] = captures[1];
8406 : 11792 : res_op->ops[1] = captures[2];
8407 : 11792 : res_op->ops[2] = captures[3];
8408 : 11792 : res_op->resimplify (lseq, valueize);
8409 : 11792 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1019, __FILE__, __LINE__, true);
8410 : 11792 : return true;
8411 : : }
8412 : 0 : next_after_fail1847:;
8413 : : }
8414 : : }
8415 : : }
8416 : : }
8417 : : }
8418 : : break;
8419 : : }
8420 : : default:;
8421 : : }
8422 : : }
8423 : : break;
8424 : 3007387 : default:;
8425 : : }
8426 : 3007387 : {
8427 : 3007387 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8428 : 1773179 : if ((INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
8429 : 1238550 : && (INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0])))
8430 : 3944218 : && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (captures[0]))
8431 : : )
8432 : : {
8433 : 447364 : gimple_seq *lseq = seq;
8434 : 447364 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1848;
8435 : 447364 : {
8436 : 447364 : res_op->set_op (NOP_EXPR, type, 1);
8437 : 447364 : res_op->ops[0] = captures[0];
8438 : 447364 : res_op->resimplify (lseq, valueize);
8439 : 447364 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1020, __FILE__, __LINE__, true);
8440 : 447364 : return true;
8441 : : }
8442 : 0 : next_after_fail1848:;
8443 : : }
8444 : : }
8445 : 2560023 : switch (TREE_CODE (_p0))
8446 : : {
8447 : 2557459 : case SSA_NAME:
8448 : 2557459 : if (gimple *_d1 = get_def (valueize, _p0))
8449 : : {
8450 : 1965547 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
8451 : 1222725 : switch (gimple_assign_rhs_code (_a1))
8452 : : {
8453 : 7577 : CASE_CONVERT:
8454 : 7577 : {
8455 : 7577 : tree _q20 = gimple_assign_rhs1 (_a1);
8456 : 7577 : _q20 = do_valueize (valueize, _q20);
8457 : 7577 : {
8458 : 7577 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
8459 : 7577 : {
8460 : 7577 : bool extended_bitint = false;
8461 : 7577 : if (BITINT_TYPE_P (TREE_TYPE (captures[0])))
8462 : : {
8463 : 48 : struct bitint_info info;
8464 : 48 : extended_bitint
8465 : 48 : = targetm.c.bitint_type_info (TYPE_PRECISION (TREE_TYPE (captures[0])),
8466 : : &info);
8467 : 48 : extended_bitint = extended_bitint && info.extended;
8468 : : }
8469 : 15154 : if ((INTEGRAL_TYPE_P (TREE_TYPE (captures[0])) || POINTER_TYPE_P (TREE_TYPE (captures[0])))
8470 : 2266 : && (INTEGRAL_TYPE_P (TREE_TYPE (captures[1])) || POINTER_TYPE_P (TREE_TYPE (captures[1])))
8471 : 2266 : && !extended_bitint
8472 : 2266 : && TYPE_SIZE (TREE_TYPE (captures[0])) == TYPE_SIZE (TREE_TYPE (captures[1]))
8473 : 7800 : && (TYPE_PRECISION (TREE_TYPE (captures[0])) == TYPE_PRECISION (TREE_TYPE (captures[1]))
8474 : 84 : || (TYPE_PRECISION (TREE_TYPE (captures[0])) > TYPE_PRECISION (TREE_TYPE (captures[1]))
8475 : 1 : && TYPE_UNSIGNED (TREE_TYPE (captures[1]))))
8476 : : )
8477 : : {
8478 : 140 : gimple_seq *lseq = seq;
8479 : 140 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1849;
8480 : 140 : {
8481 : 140 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
8482 : 140 : res_op->ops[0] = captures[1];
8483 : 140 : res_op->resimplify (lseq, valueize);
8484 : 140 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1021, __FILE__, __LINE__, true);
8485 : 140 : return true;
8486 : : }
8487 : 0 : next_after_fail1849:;
8488 : : }
8489 : : }
8490 : : }
8491 : 7437 : break;
8492 : : }
8493 : 22534 : case CONSTRUCTOR:
8494 : 22534 : {
8495 : 22534 : {
8496 : 22534 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
8497 : 22534 : {
8498 : 22534 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
8499 : 22534 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
8500 : 22534 : if (CONSTRUCTOR_NELTS (ctor) == 0
8501 : : )
8502 : : {
8503 : 0 : gimple_seq *lseq = seq;
8504 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1850;
8505 : 0 : {
8506 : 0 : tree tem;
8507 : 0 : tem = build_zero_cst (type);
8508 : 0 : res_op->set_value (tem);
8509 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1022, __FILE__, __LINE__, true);
8510 : 0 : return true;
8511 : : }
8512 : 0 : next_after_fail1850:;
8513 : : }
8514 : : else
8515 : : {
8516 : 22534 : if (CONSTRUCTOR_NELTS (ctor) == 1
8517 : 560 : && VECTOR_TYPE_P (TREE_TYPE (ctor))
8518 : 23094 : && operand_equal_p (TYPE_SIZE (type),
8519 : 560 : TYPE_SIZE (TREE_TYPE
8520 : : (CONSTRUCTOR_ELT (ctor, 0)->value)))
8521 : : )
8522 : : {
8523 : 285 : gimple_seq *lseq = seq;
8524 : 285 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1851;
8525 : 285 : {
8526 : 285 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
8527 : 285 : res_op->ops[0] = CONSTRUCTOR_ELT (ctor, 0)->value;
8528 : 285 : res_op->resimplify (lseq, valueize);
8529 : 285 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1023, __FILE__, __LINE__, true);
8530 : 285 : return true;
8531 : : }
8532 : 0 : next_after_fail1851:;
8533 : : }
8534 : : }
8535 : : }
8536 : : }
8537 : : break;
8538 : : }
8539 : 9970 : case VEC_COND_EXPR:
8540 : 9970 : {
8541 : 9970 : tree _q20 = gimple_assign_rhs1 (_a1);
8542 : 9970 : _q20 = do_valueize (valueize, _q20);
8543 : 9970 : tree _q21 = gimple_assign_rhs2 (_a1);
8544 : 9970 : _q21 = do_valueize (valueize, _q21);
8545 : 9970 : tree _q22 = gimple_assign_rhs3 (_a1);
8546 : 9970 : _q22 = do_valueize (valueize, _q22);
8547 : 9970 : {
8548 : 9970 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22 };
8549 : 9677 : if (VECTOR_TYPE_P (type) && VECTOR_TYPE_P (TREE_TYPE (captures[2]))
8550 : 12466 : && known_eq (TYPE_VECTOR_SUBPARTS (type),
8551 : : TYPE_VECTOR_SUBPARTS (TREE_TYPE (captures[2])))
8552 : 15262 : && tree_nop_conversion_p (TREE_TYPE (type), TREE_TYPE (TREE_TYPE (captures[2])))
8553 : : )
8554 : : {
8555 : 2796 : gimple_seq *lseq = seq;
8556 : 2796 : if (lseq
8557 : 493 : && (!single_use (captures[0])))
8558 : 2350 : lseq = NULL;
8559 : 2796 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1852;
8560 : 2796 : {
8561 : 2796 : res_op->set_op (VEC_COND_EXPR, type, 3);
8562 : 2796 : res_op->ops[0] = captures[1];
8563 : 2796 : {
8564 : 2796 : tree _o1[1], _r1;
8565 : 2796 : _o1[0] = captures[2];
8566 : 2796 : if (type != TREE_TYPE (_o1[0]) /* XXX */
8567 : 2796 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
8568 : : {
8569 : 2796 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, type, _o1[0]);
8570 : 2796 : tem_op.resimplify (NULL, valueize);
8571 : 2796 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
8572 : 2796 : if (!_r1) goto next_after_fail1852;
8573 : : }
8574 : : else
8575 : : _r1 = _o1[0];
8576 : 2533 : res_op->ops[1] = _r1;
8577 : : }
8578 : 2533 : {
8579 : 2533 : tree _o1[1], _r1;
8580 : 2533 : _o1[0] = captures[3];
8581 : 2533 : if (type != TREE_TYPE (_o1[0]) /* XXX */
8582 : 2533 : && !useless_type_conversion_p (type, TREE_TYPE (_o1[0])))
8583 : : {
8584 : 2533 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, type, _o1[0]);
8585 : 2533 : tem_op.resimplify (NULL, valueize);
8586 : 2533 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
8587 : 2533 : if (!_r1) goto next_after_fail1852;
8588 : : }
8589 : : else
8590 : : _r1 = _o1[0];
8591 : 2446 : res_op->ops[2] = _r1;
8592 : : }
8593 : 2446 : res_op->resimplify (lseq, valueize);
8594 : 2446 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1024, __FILE__, __LINE__, true);
8595 : 2446 : return true;
8596 : : }
8597 : 7524 : next_after_fail1852:;
8598 : : }
8599 : : }
8600 : 7524 : break;
8601 : : }
8602 : : default:;
8603 : : }
8604 : : }
8605 : : break;
8606 : : default:;
8607 : : }
8608 : : return false;
8609 : : }
8610 : :
8611 : : bool
8612 : 2763 : gimple_simplify_CFN_BUILT_IN_BSWAP16 (gimple_match_op *res_op, gimple_seq *seq,
8613 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
8614 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
8615 : : {
8616 : 2763 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8617 : 2763 : switch (TREE_CODE (_p0))
8618 : : {
8619 : 2713 : case SSA_NAME:
8620 : 2713 : if (gimple *_d1 = get_def (valueize, _p0))
8621 : : {
8622 : 1411 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
8623 : 1450 : switch (gimple_assign_rhs_code (_a1))
8624 : : {
8625 : 2 : case BIT_NOT_EXPR:
8626 : 2 : {
8627 : 2 : tree _q20 = gimple_assign_rhs1 (_a1);
8628 : 2 : _q20 = do_valueize (valueize, _q20);
8629 : 2 : switch (TREE_CODE (_q20))
8630 : : {
8631 : 2 : case SSA_NAME:
8632 : 2 : if (gimple *_d2 = get_def (valueize, _q20))
8633 : : {
8634 : 2 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
8635 : 0 : switch (gimple_call_combined_fn (_c2))
8636 : : {
8637 : 0 : case CFN_BUILT_IN_BSWAP16:
8638 : 0 : if (gimple_call_num_args (_c2) == 1)
8639 : : {
8640 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
8641 : 0 : _q30 = do_valueize (valueize, _q30);
8642 : 0 : {
8643 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q30 };
8644 : 0 : if (gimple_simplify_636 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP16))
8645 : 0 : return true;
8646 : : }
8647 : : }
8648 : : break;
8649 : : default:;
8650 : : }
8651 : : }
8652 : : break;
8653 : : default:;
8654 : : }
8655 : : break;
8656 : : }
8657 : 0 : case BIT_XOR_EXPR:
8658 : 0 : {
8659 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
8660 : 0 : _q20 = do_valueize (valueize, _q20);
8661 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
8662 : 0 : _q21 = do_valueize (valueize, _q21);
8663 : 0 : if (tree_swap_operands_p (_q20, _q21))
8664 : 0 : std::swap (_q20, _q21);
8665 : 0 : switch (TREE_CODE (_q20))
8666 : : {
8667 : 0 : case SSA_NAME:
8668 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
8669 : : {
8670 : 0 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
8671 : 0 : switch (gimple_call_combined_fn (_c2))
8672 : : {
8673 : 0 : case CFN_BUILT_IN_BSWAP16:
8674 : 0 : if (gimple_call_num_args (_c2) == 1)
8675 : : {
8676 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
8677 : 0 : _q30 = do_valueize (valueize, _q30);
8678 : 0 : {
8679 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
8680 : 0 : if (gimple_simplify_637 (res_op, seq, valueize, type, captures, BIT_XOR_EXPR, CFN_BUILT_IN_BSWAP16))
8681 : 0 : return true;
8682 : : }
8683 : : }
8684 : : break;
8685 : : default:;
8686 : : }
8687 : : }
8688 : : break;
8689 : 0 : default:;
8690 : : }
8691 : 0 : switch (TREE_CODE (_q21))
8692 : : {
8693 : 0 : case SSA_NAME:
8694 : 0 : if (gimple *_d2 = get_def (valueize, _q21))
8695 : : {
8696 : 0 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
8697 : 0 : switch (gimple_call_combined_fn (_c2))
8698 : : {
8699 : 0 : case CFN_BUILT_IN_BSWAP16:
8700 : 0 : if (gimple_call_num_args (_c2) == 1)
8701 : : {
8702 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
8703 : 0 : _q40 = do_valueize (valueize, _q40);
8704 : 0 : {
8705 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
8706 : 0 : if (gimple_simplify_637 (res_op, seq, valueize, type, captures, BIT_XOR_EXPR, CFN_BUILT_IN_BSWAP16))
8707 : 0 : return true;
8708 : : }
8709 : : }
8710 : : break;
8711 : : default:;
8712 : : }
8713 : : }
8714 : : break;
8715 : : default:;
8716 : : }
8717 : 2763 : break;
8718 : : }
8719 : 22 : case BIT_IOR_EXPR:
8720 : 22 : {
8721 : 22 : tree _q20 = gimple_assign_rhs1 (_a1);
8722 : 22 : _q20 = do_valueize (valueize, _q20);
8723 : 22 : tree _q21 = gimple_assign_rhs2 (_a1);
8724 : 22 : _q21 = do_valueize (valueize, _q21);
8725 : 22 : if (tree_swap_operands_p (_q20, _q21))
8726 : 0 : std::swap (_q20, _q21);
8727 : 22 : switch (TREE_CODE (_q20))
8728 : : {
8729 : 22 : case SSA_NAME:
8730 : 22 : if (gimple *_d2 = get_def (valueize, _q20))
8731 : : {
8732 : 22 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
8733 : 0 : switch (gimple_call_combined_fn (_c2))
8734 : : {
8735 : 0 : case CFN_BUILT_IN_BSWAP16:
8736 : 0 : if (gimple_call_num_args (_c2) == 1)
8737 : : {
8738 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
8739 : 0 : _q30 = do_valueize (valueize, _q30);
8740 : 0 : {
8741 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
8742 : 0 : if (gimple_simplify_637 (res_op, seq, valueize, type, captures, BIT_IOR_EXPR, CFN_BUILT_IN_BSWAP16))
8743 : 0 : return true;
8744 : : }
8745 : : }
8746 : : break;
8747 : : default:;
8748 : : }
8749 : : }
8750 : : break;
8751 : 22 : default:;
8752 : : }
8753 : 22 : switch (TREE_CODE (_q21))
8754 : : {
8755 : 0 : case SSA_NAME:
8756 : 0 : if (gimple *_d2 = get_def (valueize, _q21))
8757 : : {
8758 : 0 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
8759 : 0 : switch (gimple_call_combined_fn (_c2))
8760 : : {
8761 : 0 : case CFN_BUILT_IN_BSWAP16:
8762 : 0 : if (gimple_call_num_args (_c2) == 1)
8763 : : {
8764 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
8765 : 0 : _q40 = do_valueize (valueize, _q40);
8766 : 0 : {
8767 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
8768 : 0 : if (gimple_simplify_637 (res_op, seq, valueize, type, captures, BIT_IOR_EXPR, CFN_BUILT_IN_BSWAP16))
8769 : 0 : return true;
8770 : : }
8771 : : }
8772 : : break;
8773 : : default:;
8774 : : }
8775 : : }
8776 : : break;
8777 : : default:;
8778 : : }
8779 : 2763 : break;
8780 : : }
8781 : 22 : case BIT_AND_EXPR:
8782 : 22 : {
8783 : 22 : tree _q20 = gimple_assign_rhs1 (_a1);
8784 : 22 : _q20 = do_valueize (valueize, _q20);
8785 : 22 : tree _q21 = gimple_assign_rhs2 (_a1);
8786 : 22 : _q21 = do_valueize (valueize, _q21);
8787 : 22 : if (tree_swap_operands_p (_q20, _q21))
8788 : 0 : std::swap (_q20, _q21);
8789 : 22 : switch (TREE_CODE (_q20))
8790 : : {
8791 : 22 : case SSA_NAME:
8792 : 22 : if (gimple *_d2 = get_def (valueize, _q20))
8793 : : {
8794 : 22 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
8795 : 0 : switch (gimple_call_combined_fn (_c2))
8796 : : {
8797 : 0 : case CFN_BUILT_IN_BSWAP16:
8798 : 0 : if (gimple_call_num_args (_c2) == 1)
8799 : : {
8800 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
8801 : 0 : _q30 = do_valueize (valueize, _q30);
8802 : 0 : {
8803 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q21 };
8804 : 0 : if (gimple_simplify_637 (res_op, seq, valueize, type, captures, BIT_AND_EXPR, CFN_BUILT_IN_BSWAP16))
8805 : 0 : return true;
8806 : : }
8807 : : }
8808 : : break;
8809 : : default:;
8810 : : }
8811 : : }
8812 : : break;
8813 : 22 : default:;
8814 : : }
8815 : 22 : switch (TREE_CODE (_q21))
8816 : : {
8817 : 0 : case SSA_NAME:
8818 : 0 : if (gimple *_d2 = get_def (valueize, _q21))
8819 : : {
8820 : 0 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
8821 : 0 : switch (gimple_call_combined_fn (_c2))
8822 : : {
8823 : 0 : case CFN_BUILT_IN_BSWAP16:
8824 : 0 : if (gimple_call_num_args (_c2) == 1)
8825 : : {
8826 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
8827 : 0 : _q40 = do_valueize (valueize, _q40);
8828 : 0 : {
8829 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
8830 : 0 : if (gimple_simplify_637 (res_op, seq, valueize, type, captures, BIT_AND_EXPR, CFN_BUILT_IN_BSWAP16))
8831 : 0 : return true;
8832 : : }
8833 : : }
8834 : : break;
8835 : : default:;
8836 : : }
8837 : : }
8838 : : break;
8839 : : default:;
8840 : : }
8841 : 2763 : break;
8842 : : }
8843 : : default:;
8844 : : }
8845 : 217 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
8846 : 4 : switch (gimple_call_combined_fn (_c1))
8847 : : {
8848 : 4 : case CFN_BUILT_IN_BSWAP16:
8849 : 4 : if (gimple_call_num_args (_c1) == 1)
8850 : : {
8851 : 4 : tree _q20 = gimple_call_arg (_c1, 0);
8852 : 4 : _q20 = do_valueize (valueize, _q20);
8853 : 4 : {
8854 : 4 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8855 : 4 : if (gimple_simplify_635 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP16))
8856 : 4 : return true;
8857 : : }
8858 : : }
8859 : : break;
8860 : : default:;
8861 : : }
8862 : : }
8863 : : break;
8864 : : default:;
8865 : : }
8866 : : return false;
8867 : : }
8868 : :
8869 : : bool
8870 : 4366 : gimple_simplify_CFN_BUILT_IN_LOGF (gimple_match_op *res_op, gimple_seq *seq,
8871 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
8872 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
8873 : : {
8874 : 4366 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
8875 : 4366 : switch (TREE_CODE (_p0))
8876 : : {
8877 : 3939 : case SSA_NAME:
8878 : 3939 : if (gimple *_d1 = get_def (valueize, _p0))
8879 : : {
8880 : 2133 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
8881 : 1793 : switch (gimple_assign_rhs_code (_a1))
8882 : : {
8883 : 40 : case RDIV_EXPR:
8884 : 40 : {
8885 : 40 : tree _q20 = gimple_assign_rhs1 (_a1);
8886 : 40 : _q20 = do_valueize (valueize, _q20);
8887 : 40 : tree _q21 = gimple_assign_rhs2 (_a1);
8888 : 40 : _q21 = do_valueize (valueize, _q21);
8889 : 40 : switch (TREE_CODE (_q20))
8890 : : {
8891 : 4 : case REAL_CST:
8892 : 4 : {
8893 : 4 : {
8894 : 4 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8895 : 4 : if (gimple_simplify_664 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_LOGF))
8896 : 2 : return true;
8897 : : }
8898 : 2 : break;
8899 : : }
8900 : 38 : default:;
8901 : : }
8902 : 38 : if (real_onep (_q20))
8903 : : {
8904 : 1 : {
8905 : 1 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
8906 : 1 : if (gimple_simplify_663 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_LOGF))
8907 : 0 : return true;
8908 : : }
8909 : : }
8910 : : break;
8911 : : }
8912 : : default:;
8913 : : }
8914 : 559 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
8915 : 91 : switch (gimple_call_combined_fn (_c1))
8916 : : {
8917 : 14 : case CFN_BUILT_IN_SQRTF:
8918 : 14 : if (gimple_call_num_args (_c1) == 1)
8919 : : {
8920 : 14 : tree _q20 = gimple_call_arg (_c1, 0);
8921 : 14 : _q20 = do_valueize (valueize, _q20);
8922 : 14 : {
8923 : 14 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8924 : 14 : if (flag_unsafe_math_optimizations
8925 : : )
8926 : : {
8927 : 14 : if (SCALAR_FLOAT_TYPE_P (type)
8928 : : )
8929 : : {
8930 : 14 : {
8931 : 14 : tree x;
8932 : 14 : switch (CFN_BUILT_IN_SQRTF)
8933 : : {
8934 : 14 : CASE_CFN_SQRT:
8935 : 14 : x = build_real (type, dconsthalf);
8936 : 14 : break;
8937 : : CASE_CFN_CBRT:
8938 : : x = build_real_truncate (type, dconst_third ());
8939 : : break;
8940 : : default:
8941 : : gcc_unreachable ();
8942 : : }
8943 : 14 : gimple_seq *lseq = seq;
8944 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1914;
8945 : 14 : {
8946 : 14 : res_op->set_op (MULT_EXPR, type, 2);
8947 : 14 : res_op->ops[0] = x;
8948 : 14 : {
8949 : 14 : tree _o1[1], _r1;
8950 : 14 : _o1[0] = captures[0];
8951 : 14 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_BUILT_IN_LOGF, TREE_TYPE (_o1[0]), _o1[0]);
8952 : 14 : tem_op.resimplify (lseq, valueize);
8953 : 14 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
8954 : 14 : if (!_r1) goto next_after_fail1914;
8955 : 7 : res_op->ops[1] = _r1;
8956 : : }
8957 : 7 : res_op->resimplify (lseq, valueize);
8958 : 7 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1036, __FILE__, __LINE__, true);
8959 : 7 : return true;
8960 : : }
8961 : : next_after_fail1914:;
8962 : : }
8963 : : }
8964 : : }
8965 : : }
8966 : : }
8967 : : break;
8968 : 12 : case CFN_BUILT_IN_EXP10F:
8969 : 12 : if (gimple_call_num_args (_c1) == 1)
8970 : : {
8971 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
8972 : 12 : _q20 = do_valueize (valueize, _q20);
8973 : 12 : {
8974 : 12 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
8975 : 12 : if (flag_unsafe_math_optimizations
8976 : : )
8977 : : {
8978 : 12 : if (SCALAR_FLOAT_TYPE_P (type)
8979 : : )
8980 : : {
8981 : 12 : {
8982 : 12 : tree x;
8983 : 12 : switch (CFN_BUILT_IN_EXP10F)
8984 : : {
8985 : : CASE_CFN_EXP:
8986 : : x = build_real_truncate (type, dconst_e ());
8987 : : break;
8988 : : CASE_CFN_EXP2:
8989 : : x = build_real (type, dconst2);
8990 : : break;
8991 : 12 : CASE_CFN_EXP10:
8992 : 12 : CASE_CFN_POW10:
8993 : 12 : {
8994 : 12 : REAL_VALUE_TYPE dconst10;
8995 : 12 : real_from_integer (&dconst10, VOIDmode, 10, SIGNED);
8996 : 12 : x = build_real (type, dconst10);
8997 : : }
8998 : 12 : break;
8999 : : default:
9000 : : gcc_unreachable ();
9001 : : }
9002 : 12 : gimple_seq *lseq = seq;
9003 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1915;
9004 : 12 : {
9005 : 12 : res_op->set_op (MULT_EXPR, type, 2);
9006 : 12 : {
9007 : 12 : tree _o1[1], _r1;
9008 : 12 : _o1[0] = x;
9009 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_BUILT_IN_LOGF, TREE_TYPE (_o1[0]), _o1[0]);
9010 : 12 : tem_op.resimplify (lseq, valueize);
9011 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9012 : 12 : if (!_r1) goto next_after_fail1915;
9013 : 12 : res_op->ops[0] = _r1;
9014 : : }
9015 : 12 : res_op->ops[1] = captures[0];
9016 : 12 : res_op->resimplify (lseq, valueize);
9017 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1037, __FILE__, __LINE__, true);
9018 : 12 : return true;
9019 : : }
9020 : : next_after_fail1915:;
9021 : : }
9022 : : }
9023 : : }
9024 : : }
9025 : : }
9026 : : break;
9027 : 7 : case CFN_BUILT_IN_EXPF:
9028 : 7 : if (gimple_call_num_args (_c1) == 1)
9029 : : {
9030 : 7 : tree _q20 = gimple_call_arg (_c1, 0);
9031 : 7 : _q20 = do_valueize (valueize, _q20);
9032 : 7 : {
9033 : 7 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9034 : 7 : if (flag_unsafe_math_optimizations
9035 : : )
9036 : : {
9037 : 7 : gimple_seq *lseq = seq;
9038 : 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1916;
9039 : 7 : {
9040 : 7 : tree tem;
9041 : 7 : tem = captures[0];
9042 : 7 : res_op->set_value (tem);
9043 : 7 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1038, __FILE__, __LINE__, true);
9044 : 7 : return true;
9045 : : }
9046 : 0 : next_after_fail1916:;
9047 : : }
9048 : : }
9049 : : }
9050 : : break;
9051 : 14 : case CFN_BUILT_IN_POWF:
9052 : 14 : if (gimple_call_num_args (_c1) == 2)
9053 : : {
9054 : 14 : tree _q20 = gimple_call_arg (_c1, 0);
9055 : 14 : _q20 = do_valueize (valueize, _q20);
9056 : 14 : tree _q21 = gimple_call_arg (_c1, 1);
9057 : 14 : _q21 = do_valueize (valueize, _q21);
9058 : 14 : {
9059 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9060 : 14 : if (gimple_simplify_665 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_LOGF, CFN_BUILT_IN_POWF))
9061 : 7 : return true;
9062 : : }
9063 : : }
9064 : : break;
9065 : 12 : case CFN_BUILT_IN_POW10F:
9066 : 12 : if (gimple_call_num_args (_c1) == 1)
9067 : : {
9068 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
9069 : 12 : _q20 = do_valueize (valueize, _q20);
9070 : 12 : {
9071 : 12 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9072 : 12 : if (flag_unsafe_math_optimizations
9073 : : )
9074 : : {
9075 : 12 : if (SCALAR_FLOAT_TYPE_P (type)
9076 : : )
9077 : : {
9078 : 12 : {
9079 : 12 : tree x;
9080 : 12 : switch (CFN_BUILT_IN_POW10F)
9081 : : {
9082 : : CASE_CFN_EXP:
9083 : : x = build_real_truncate (type, dconst_e ());
9084 : : break;
9085 : : CASE_CFN_EXP2:
9086 : : x = build_real (type, dconst2);
9087 : : break;
9088 : 12 : CASE_CFN_EXP10:
9089 : 12 : CASE_CFN_POW10:
9090 : 12 : {
9091 : 12 : REAL_VALUE_TYPE dconst10;
9092 : 12 : real_from_integer (&dconst10, VOIDmode, 10, SIGNED);
9093 : 12 : x = build_real (type, dconst10);
9094 : : }
9095 : 12 : break;
9096 : : default:
9097 : : gcc_unreachable ();
9098 : : }
9099 : 12 : gimple_seq *lseq = seq;
9100 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1917;
9101 : 12 : {
9102 : 12 : res_op->set_op (MULT_EXPR, type, 2);
9103 : 12 : {
9104 : 12 : tree _o1[1], _r1;
9105 : 12 : _o1[0] = x;
9106 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_BUILT_IN_LOGF, TREE_TYPE (_o1[0]), _o1[0]);
9107 : 12 : tem_op.resimplify (lseq, valueize);
9108 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9109 : 12 : if (!_r1) goto next_after_fail1917;
9110 : 12 : res_op->ops[0] = _r1;
9111 : : }
9112 : 12 : res_op->ops[1] = captures[0];
9113 : 12 : res_op->resimplify (lseq, valueize);
9114 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1037, __FILE__, __LINE__, true);
9115 : 12 : return true;
9116 : : }
9117 : : next_after_fail1917:;
9118 : : }
9119 : : }
9120 : : }
9121 : : }
9122 : : }
9123 : : break;
9124 : 12 : case CFN_BUILT_IN_CBRTF:
9125 : 12 : if (gimple_call_num_args (_c1) == 1)
9126 : : {
9127 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
9128 : 12 : _q20 = do_valueize (valueize, _q20);
9129 : 12 : {
9130 : 12 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9131 : 12 : if (flag_unsafe_math_optimizations
9132 : : )
9133 : : {
9134 : 12 : if (SCALAR_FLOAT_TYPE_P (type)
9135 : : )
9136 : : {
9137 : 12 : {
9138 : 12 : tree x;
9139 : 12 : switch (CFN_BUILT_IN_CBRTF)
9140 : : {
9141 : : CASE_CFN_SQRT:
9142 : : x = build_real (type, dconsthalf);
9143 : : break;
9144 : 12 : CASE_CFN_CBRT:
9145 : 12 : x = build_real_truncate (type, dconst_third ());
9146 : 12 : break;
9147 : : default:
9148 : : gcc_unreachable ();
9149 : : }
9150 : 12 : gimple_seq *lseq = seq;
9151 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1918;
9152 : 12 : {
9153 : 12 : res_op->set_op (MULT_EXPR, type, 2);
9154 : 12 : res_op->ops[0] = x;
9155 : 12 : {
9156 : 12 : tree _o1[1], _r1;
9157 : 12 : _o1[0] = captures[0];
9158 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_BUILT_IN_LOGF, TREE_TYPE (_o1[0]), _o1[0]);
9159 : 12 : tem_op.resimplify (lseq, valueize);
9160 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9161 : 12 : if (!_r1) goto next_after_fail1918;
9162 : 6 : res_op->ops[1] = _r1;
9163 : : }
9164 : 6 : res_op->resimplify (lseq, valueize);
9165 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1036, __FILE__, __LINE__, true);
9166 : 6 : return true;
9167 : : }
9168 : : next_after_fail1918:;
9169 : : }
9170 : : }
9171 : : }
9172 : : }
9173 : : }
9174 : : break;
9175 : 12 : case CFN_BUILT_IN_EXP2F:
9176 : 12 : if (gimple_call_num_args (_c1) == 1)
9177 : : {
9178 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
9179 : 12 : _q20 = do_valueize (valueize, _q20);
9180 : 12 : {
9181 : 12 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9182 : 12 : if (flag_unsafe_math_optimizations
9183 : : )
9184 : : {
9185 : 12 : if (SCALAR_FLOAT_TYPE_P (type)
9186 : : )
9187 : : {
9188 : 12 : {
9189 : 12 : tree x;
9190 : 12 : switch (CFN_BUILT_IN_EXP2F)
9191 : : {
9192 : : CASE_CFN_EXP:
9193 : : x = build_real_truncate (type, dconst_e ());
9194 : : break;
9195 : 12 : CASE_CFN_EXP2:
9196 : 12 : x = build_real (type, dconst2);
9197 : 12 : break;
9198 : : CASE_CFN_EXP10:
9199 : : CASE_CFN_POW10:
9200 : : {
9201 : : REAL_VALUE_TYPE dconst10;
9202 : : real_from_integer (&dconst10, VOIDmode, 10, SIGNED);
9203 : : x = build_real (type, dconst10);
9204 : : }
9205 : : break;
9206 : : default:
9207 : : gcc_unreachable ();
9208 : : }
9209 : 12 : gimple_seq *lseq = seq;
9210 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1919;
9211 : 12 : {
9212 : 12 : res_op->set_op (MULT_EXPR, type, 2);
9213 : 12 : {
9214 : 12 : tree _o1[1], _r1;
9215 : 12 : _o1[0] = x;
9216 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_BUILT_IN_LOGF, TREE_TYPE (_o1[0]), _o1[0]);
9217 : 12 : tem_op.resimplify (lseq, valueize);
9218 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9219 : 12 : if (!_r1) goto next_after_fail1919;
9220 : 12 : res_op->ops[0] = _r1;
9221 : : }
9222 : 12 : res_op->ops[1] = captures[0];
9223 : 12 : res_op->resimplify (lseq, valueize);
9224 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1037, __FILE__, __LINE__, true);
9225 : 12 : return true;
9226 : : }
9227 : : next_after_fail1919:;
9228 : : }
9229 : : }
9230 : : }
9231 : : }
9232 : : }
9233 : : break;
9234 : : default:;
9235 : : }
9236 : : }
9237 : : break;
9238 : : default:;
9239 : : }
9240 : : return false;
9241 : : }
9242 : :
9243 : : bool
9244 : 0 : gimple_simplify_CFN_LOG2 (gimple_match_op *res_op, gimple_seq *seq,
9245 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
9246 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
9247 : : {
9248 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9249 : 0 : switch (TREE_CODE (_p0))
9250 : : {
9251 : 0 : case SSA_NAME:
9252 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
9253 : : {
9254 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
9255 : 0 : switch (gimple_assign_rhs_code (_a1))
9256 : : {
9257 : 0 : case RDIV_EXPR:
9258 : 0 : {
9259 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
9260 : 0 : _q20 = do_valueize (valueize, _q20);
9261 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
9262 : 0 : _q21 = do_valueize (valueize, _q21);
9263 : 0 : switch (TREE_CODE (_q20))
9264 : : {
9265 : 0 : case REAL_CST:
9266 : 0 : {
9267 : 0 : {
9268 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9269 : 0 : if (gimple_simplify_664 (res_op, seq, valueize, type, captures, CFN_LOG2))
9270 : 0 : return true;
9271 : : }
9272 : 0 : break;
9273 : : }
9274 : 0 : default:;
9275 : : }
9276 : 0 : if (real_onep (_q20))
9277 : : {
9278 : 0 : {
9279 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
9280 : 0 : if (gimple_simplify_663 (res_op, seq, valueize, type, captures, CFN_LOG2))
9281 : 0 : return true;
9282 : : }
9283 : : }
9284 : : break;
9285 : : }
9286 : : default:;
9287 : : }
9288 : 0 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
9289 : 0 : switch (gimple_call_combined_fn (_c1))
9290 : : {
9291 : 0 : case CFN_EXP:
9292 : 0 : if (gimple_call_num_args (_c1) == 1)
9293 : : {
9294 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
9295 : 0 : _q20 = do_valueize (valueize, _q20);
9296 : 0 : {
9297 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9298 : 0 : if (flag_unsafe_math_optimizations
9299 : : )
9300 : : {
9301 : 0 : if (SCALAR_FLOAT_TYPE_P (type)
9302 : : )
9303 : : {
9304 : 0 : {
9305 : 0 : tree x;
9306 : 0 : switch (CFN_EXP)
9307 : : {
9308 : 0 : CASE_CFN_EXP:
9309 : 0 : x = build_real_truncate (type, dconst_e ());
9310 : 0 : break;
9311 : : CASE_CFN_EXP2:
9312 : : x = build_real (type, dconst2);
9313 : : break;
9314 : : CASE_CFN_EXP10:
9315 : : CASE_CFN_POW10:
9316 : : {
9317 : : REAL_VALUE_TYPE dconst10;
9318 : : real_from_integer (&dconst10, VOIDmode, 10, SIGNED);
9319 : : x = build_real (type, dconst10);
9320 : : }
9321 : : break;
9322 : : default:
9323 : : gcc_unreachable ();
9324 : : }
9325 : 0 : gimple_seq *lseq = seq;
9326 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1954;
9327 : 0 : {
9328 : 0 : res_op->set_op (MULT_EXPR, type, 2);
9329 : 0 : {
9330 : 0 : tree _o1[1], _r1;
9331 : 0 : _o1[0] = x;
9332 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_LOG2, TREE_TYPE (_o1[0]), _o1[0]);
9333 : 0 : tem_op.resimplify (lseq, valueize);
9334 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9335 : 0 : if (!_r1) goto next_after_fail1954;
9336 : 0 : res_op->ops[0] = _r1;
9337 : : }
9338 : 0 : res_op->ops[1] = captures[0];
9339 : 0 : res_op->resimplify (lseq, valueize);
9340 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1037, __FILE__, __LINE__, true);
9341 : 0 : return true;
9342 : : }
9343 : : next_after_fail1954:;
9344 : : }
9345 : : }
9346 : : }
9347 : : }
9348 : : }
9349 : : break;
9350 : 0 : case CFN_POW:
9351 : 0 : if (gimple_call_num_args (_c1) == 2)
9352 : : {
9353 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
9354 : 0 : _q20 = do_valueize (valueize, _q20);
9355 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
9356 : 0 : _q21 = do_valueize (valueize, _q21);
9357 : 0 : {
9358 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9359 : 0 : if (gimple_simplify_665 (res_op, seq, valueize, type, captures, CFN_LOG2, CFN_POW))
9360 : 0 : return true;
9361 : : }
9362 : : }
9363 : : break;
9364 : 0 : case CFN_EXP2:
9365 : 0 : if (gimple_call_num_args (_c1) == 1)
9366 : : {
9367 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
9368 : 0 : _q20 = do_valueize (valueize, _q20);
9369 : 0 : {
9370 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9371 : 0 : if (flag_unsafe_math_optimizations
9372 : : )
9373 : : {
9374 : 0 : gimple_seq *lseq = seq;
9375 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1955;
9376 : 0 : {
9377 : 0 : tree tem;
9378 : 0 : tem = captures[0];
9379 : 0 : res_op->set_value (tem);
9380 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1038, __FILE__, __LINE__, true);
9381 : 0 : return true;
9382 : : }
9383 : 0 : next_after_fail1955:;
9384 : : }
9385 : : }
9386 : : }
9387 : : break;
9388 : 0 : case CFN_SQRT:
9389 : 0 : if (gimple_call_num_args (_c1) == 1)
9390 : : {
9391 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
9392 : 0 : _q20 = do_valueize (valueize, _q20);
9393 : 0 : {
9394 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9395 : 0 : if (flag_unsafe_math_optimizations
9396 : : )
9397 : : {
9398 : 0 : if (SCALAR_FLOAT_TYPE_P (type)
9399 : : )
9400 : : {
9401 : 0 : {
9402 : 0 : tree x;
9403 : 0 : switch (CFN_SQRT)
9404 : : {
9405 : 0 : CASE_CFN_SQRT:
9406 : 0 : x = build_real (type, dconsthalf);
9407 : 0 : break;
9408 : : CASE_CFN_CBRT:
9409 : : x = build_real_truncate (type, dconst_third ());
9410 : : break;
9411 : : default:
9412 : : gcc_unreachable ();
9413 : : }
9414 : 0 : gimple_seq *lseq = seq;
9415 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1956;
9416 : 0 : {
9417 : 0 : res_op->set_op (MULT_EXPR, type, 2);
9418 : 0 : res_op->ops[0] = x;
9419 : 0 : {
9420 : 0 : tree _o1[1], _r1;
9421 : 0 : _o1[0] = captures[0];
9422 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_LOG2, TREE_TYPE (_o1[0]), _o1[0]);
9423 : 0 : tem_op.resimplify (lseq, valueize);
9424 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9425 : 0 : if (!_r1) goto next_after_fail1956;
9426 : 0 : res_op->ops[1] = _r1;
9427 : : }
9428 : 0 : res_op->resimplify (lseq, valueize);
9429 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1036, __FILE__, __LINE__, true);
9430 : 0 : return true;
9431 : : }
9432 : : next_after_fail1956:;
9433 : : }
9434 : : }
9435 : : }
9436 : : }
9437 : : }
9438 : : break;
9439 : 0 : case CFN_EXP10:
9440 : 0 : if (gimple_call_num_args (_c1) == 1)
9441 : : {
9442 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
9443 : 0 : _q20 = do_valueize (valueize, _q20);
9444 : 0 : {
9445 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9446 : 0 : if (flag_unsafe_math_optimizations
9447 : : )
9448 : : {
9449 : 0 : if (SCALAR_FLOAT_TYPE_P (type)
9450 : : )
9451 : : {
9452 : 0 : {
9453 : 0 : tree x;
9454 : 0 : switch (CFN_EXP10)
9455 : : {
9456 : : CASE_CFN_EXP:
9457 : : x = build_real_truncate (type, dconst_e ());
9458 : : break;
9459 : : CASE_CFN_EXP2:
9460 : : x = build_real (type, dconst2);
9461 : : break;
9462 : 0 : CASE_CFN_EXP10:
9463 : 0 : CASE_CFN_POW10:
9464 : 0 : {
9465 : 0 : REAL_VALUE_TYPE dconst10;
9466 : 0 : real_from_integer (&dconst10, VOIDmode, 10, SIGNED);
9467 : 0 : x = build_real (type, dconst10);
9468 : : }
9469 : 0 : break;
9470 : : default:
9471 : : gcc_unreachable ();
9472 : : }
9473 : 0 : gimple_seq *lseq = seq;
9474 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1957;
9475 : 0 : {
9476 : 0 : res_op->set_op (MULT_EXPR, type, 2);
9477 : 0 : {
9478 : 0 : tree _o1[1], _r1;
9479 : 0 : _o1[0] = x;
9480 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_LOG2, TREE_TYPE (_o1[0]), _o1[0]);
9481 : 0 : tem_op.resimplify (lseq, valueize);
9482 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9483 : 0 : if (!_r1) goto next_after_fail1957;
9484 : 0 : res_op->ops[0] = _r1;
9485 : : }
9486 : 0 : res_op->ops[1] = captures[0];
9487 : 0 : res_op->resimplify (lseq, valueize);
9488 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1037, __FILE__, __LINE__, true);
9489 : 0 : return true;
9490 : : }
9491 : : next_after_fail1957:;
9492 : : }
9493 : : }
9494 : : }
9495 : : }
9496 : : }
9497 : : break;
9498 : : default:;
9499 : : }
9500 : : }
9501 : : break;
9502 : : default:;
9503 : : }
9504 : : return false;
9505 : : }
9506 : :
9507 : : bool
9508 : 5857 : gimple_simplify_CFN_BUILT_IN_EXPF (gimple_match_op *res_op, gimple_seq *seq,
9509 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
9510 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
9511 : : {
9512 : 5857 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9513 : 5857 : switch (TREE_CODE (_p0))
9514 : : {
9515 : 5673 : case SSA_NAME:
9516 : 5673 : if (gimple *_d1 = get_def (valueize, _p0))
9517 : : {
9518 : 3187 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
9519 : 131 : switch (gimple_call_combined_fn (_c1))
9520 : : {
9521 : 7 : case CFN_BUILT_IN_LOGF:
9522 : 7 : if (gimple_call_num_args (_c1) == 1)
9523 : : {
9524 : 7 : tree _q20 = gimple_call_arg (_c1, 0);
9525 : 7 : _q20 = do_valueize (valueize, _q20);
9526 : 7 : {
9527 : 7 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9528 : 7 : if (flag_unsafe_math_optimizations
9529 : : )
9530 : : {
9531 : 7 : gimple_seq *lseq = seq;
9532 : 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1980;
9533 : 7 : {
9534 : 7 : tree tem;
9535 : 7 : tem = captures[0];
9536 : 7 : res_op->set_value (tem);
9537 : 7 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1039, __FILE__, __LINE__, true);
9538 : 7 : return true;
9539 : : }
9540 : 0 : next_after_fail1980:;
9541 : : }
9542 : : }
9543 : : }
9544 : : break;
9545 : : default:;
9546 : : }
9547 : : }
9548 : : break;
9549 : : default:;
9550 : : }
9551 : : return false;
9552 : : }
9553 : :
9554 : : bool
9555 : 0 : gimple_simplify_CFN_EXP (gimple_match_op *res_op, gimple_seq *seq,
9556 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
9557 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
9558 : : {
9559 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9560 : 0 : switch (TREE_CODE (_p0))
9561 : : {
9562 : 0 : case SSA_NAME:
9563 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
9564 : : {
9565 : 0 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
9566 : 0 : switch (gimple_call_combined_fn (_c1))
9567 : : {
9568 : 0 : case CFN_LOG:
9569 : 0 : if (gimple_call_num_args (_c1) == 1)
9570 : : {
9571 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
9572 : 0 : _q20 = do_valueize (valueize, _q20);
9573 : 0 : {
9574 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9575 : 0 : if (flag_unsafe_math_optimizations
9576 : : )
9577 : : {
9578 : 0 : gimple_seq *lseq = seq;
9579 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1983;
9580 : 0 : {
9581 : 0 : tree tem;
9582 : 0 : tem = captures[0];
9583 : 0 : res_op->set_value (tem);
9584 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1039, __FILE__, __LINE__, true);
9585 : 0 : return true;
9586 : : }
9587 : 0 : next_after_fail1983:;
9588 : : }
9589 : : }
9590 : : }
9591 : : break;
9592 : : default:;
9593 : : }
9594 : : }
9595 : : break;
9596 : : default:;
9597 : : }
9598 : : return false;
9599 : : }
9600 : :
9601 : : bool
9602 : 1275 : gimple_simplify_CFN_BUILT_IN_EXP2L (gimple_match_op *res_op, gimple_seq *seq,
9603 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
9604 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
9605 : : {
9606 : 1275 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9607 : 1275 : switch (TREE_CODE (_p0))
9608 : : {
9609 : 346 : case SSA_NAME:
9610 : 346 : if (gimple *_d1 = get_def (valueize, _p0))
9611 : : {
9612 : 245 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
9613 : 6 : switch (gimple_call_combined_fn (_c1))
9614 : : {
9615 : 6 : case CFN_BUILT_IN_LOG2L:
9616 : 6 : if (gimple_call_num_args (_c1) == 1)
9617 : : {
9618 : 6 : tree _q20 = gimple_call_arg (_c1, 0);
9619 : 6 : _q20 = do_valueize (valueize, _q20);
9620 : 6 : {
9621 : 6 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9622 : 6 : if (flag_unsafe_math_optimizations
9623 : : )
9624 : : {
9625 : 6 : gimple_seq *lseq = seq;
9626 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1986;
9627 : 6 : {
9628 : 6 : tree tem;
9629 : 6 : tem = captures[0];
9630 : 6 : res_op->set_value (tem);
9631 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1039, __FILE__, __LINE__, true);
9632 : 6 : return true;
9633 : : }
9634 : 0 : next_after_fail1986:;
9635 : : }
9636 : : }
9637 : : }
9638 : : break;
9639 : : default:;
9640 : : }
9641 : : }
9642 : : break;
9643 : : default:;
9644 : : }
9645 : : return false;
9646 : : }
9647 : :
9648 : : bool
9649 : 328 : gimple_simplify_CFN_BUILT_IN_EXP10L (gimple_match_op *res_op, gimple_seq *seq,
9650 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
9651 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
9652 : : {
9653 : 328 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9654 : 328 : switch (TREE_CODE (_p0))
9655 : : {
9656 : 274 : case SSA_NAME:
9657 : 274 : if (gimple *_d1 = get_def (valueize, _p0))
9658 : : {
9659 : 197 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
9660 : 6 : switch (gimple_call_combined_fn (_c1))
9661 : : {
9662 : 6 : case CFN_BUILT_IN_LOG10L:
9663 : 6 : if (gimple_call_num_args (_c1) == 1)
9664 : : {
9665 : 6 : tree _q20 = gimple_call_arg (_c1, 0);
9666 : 6 : _q20 = do_valueize (valueize, _q20);
9667 : 6 : {
9668 : 6 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9669 : 6 : if (flag_unsafe_math_optimizations
9670 : : )
9671 : : {
9672 : 6 : gimple_seq *lseq = seq;
9673 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail1990;
9674 : 6 : {
9675 : 6 : tree tem;
9676 : 6 : tem = captures[0];
9677 : 6 : res_op->set_value (tem);
9678 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1039, __FILE__, __LINE__, true);
9679 : 6 : return true;
9680 : : }
9681 : 0 : next_after_fail1990:;
9682 : : }
9683 : : }
9684 : : }
9685 : : break;
9686 : : default:;
9687 : : }
9688 : : }
9689 : : break;
9690 : : default:;
9691 : : }
9692 : : return false;
9693 : : }
9694 : :
9695 : : bool
9696 : 23078 : gimple_simplify_CFN_BUILT_IN_SQRT (gimple_match_op *res_op, gimple_seq *seq,
9697 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
9698 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
9699 : : {
9700 : 23078 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9701 : 23078 : switch (TREE_CODE (_p0))
9702 : : {
9703 : 22037 : case SSA_NAME:
9704 : 22037 : if (gimple *_d1 = get_def (valueize, _p0))
9705 : : {
9706 : 10606 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
9707 : 328 : switch (gimple_call_combined_fn (_c1))
9708 : : {
9709 : 14 : case CFN_BUILT_IN_EXP:
9710 : 14 : if (gimple_call_num_args (_c1) == 1)
9711 : : {
9712 : 14 : tree _q20 = gimple_call_arg (_c1, 0);
9713 : 14 : _q20 = do_valueize (valueize, _q20);
9714 : 14 : {
9715 : 14 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9716 : 14 : if (flag_unsafe_math_optimizations
9717 : : )
9718 : : {
9719 : 14 : gimple_seq *lseq = seq;
9720 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2002;
9721 : 14 : {
9722 : 14 : res_op->set_op (CFN_BUILT_IN_EXP, type, 1);
9723 : 14 : {
9724 : 14 : tree _o1[2], _r1;
9725 : 14 : _o1[0] = captures[0];
9726 : 14 : _o1[1] = build_real (type, dconsthalf);
9727 : 14 : gimple_match_op tem_op (res_op->cond.any_else (), MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9728 : 14 : tem_op.resimplify (lseq, valueize);
9729 : 14 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9730 : 14 : if (!_r1) goto next_after_fail2002;
9731 : 7 : res_op->ops[0] = _r1;
9732 : : }
9733 : 7 : res_op->resimplify (lseq, valueize);
9734 : 7 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1041, __FILE__, __LINE__, true);
9735 : 7 : return true;
9736 : : }
9737 : : next_after_fail2002:;
9738 : : }
9739 : : }
9740 : : }
9741 : : break;
9742 : 18 : case CFN_BUILT_IN_POW:
9743 : 18 : if (gimple_call_num_args (_c1) == 2)
9744 : : {
9745 : 18 : tree _q20 = gimple_call_arg (_c1, 0);
9746 : 18 : _q20 = do_valueize (valueize, _q20);
9747 : 18 : tree _q21 = gimple_call_arg (_c1, 1);
9748 : 18 : _q21 = do_valueize (valueize, _q21);
9749 : 18 : {
9750 : 18 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
9751 : 18 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
9752 : : )
9753 : : {
9754 : 18 : gimple_seq *lseq = seq;
9755 : 18 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2003;
9756 : 18 : {
9757 : 18 : res_op->set_op (CFN_BUILT_IN_POW, type, 2);
9758 : 18 : {
9759 : 18 : tree _o1[1], _r1;
9760 : 18 : _o1[0] = captures[0];
9761 : 18 : gimple_match_op tem_op (res_op->cond.any_else (), ABS_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
9762 : 18 : tem_op.resimplify (lseq, valueize);
9763 : 18 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9764 : 18 : if (!_r1) goto next_after_fail2003;
9765 : 15 : res_op->ops[0] = _r1;
9766 : : }
9767 : 15 : {
9768 : 15 : tree _o1[2], _r1;
9769 : 15 : _o1[0] = captures[1];
9770 : 15 : _o1[1] = build_real (type, dconsthalf);
9771 : 15 : gimple_match_op tem_op (res_op->cond.any_else (), MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9772 : 15 : tem_op.resimplify (lseq, valueize);
9773 : 15 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9774 : 15 : if (!_r1) goto next_after_fail2003;
9775 : 9 : res_op->ops[1] = _r1;
9776 : : }
9777 : 9 : res_op->resimplify (lseq, valueize);
9778 : 9 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1042, __FILE__, __LINE__, true);
9779 : 9 : return true;
9780 : : }
9781 : 9 : next_after_fail2003:;
9782 : : }
9783 : : }
9784 : : }
9785 : : break;
9786 : 12 : case CFN_BUILT_IN_CBRT:
9787 : 12 : if (gimple_call_num_args (_c1) == 1)
9788 : : {
9789 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
9790 : 12 : _q20 = do_valueize (valueize, _q20);
9791 : 12 : {
9792 : 12 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9793 : 12 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
9794 : : )
9795 : : {
9796 : 12 : gimple_seq *lseq = seq;
9797 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2004;
9798 : 12 : {
9799 : 12 : res_op->set_op (CFN_BUILT_IN_POW, type, 2);
9800 : 12 : res_op->ops[0] = captures[0];
9801 : 12 : res_op->ops[1] = build_real_truncate (type, dconst_sixth ());
9802 : 12 : res_op->resimplify (lseq, valueize);
9803 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1043, __FILE__, __LINE__, true);
9804 : 12 : return true;
9805 : : }
9806 : 0 : next_after_fail2004:;
9807 : : }
9808 : : }
9809 : : }
9810 : : break;
9811 : 12 : case CFN_BUILT_IN_EXP2:
9812 : 12 : if (gimple_call_num_args (_c1) == 1)
9813 : : {
9814 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
9815 : 12 : _q20 = do_valueize (valueize, _q20);
9816 : 12 : {
9817 : 12 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9818 : 12 : if (flag_unsafe_math_optimizations
9819 : : )
9820 : : {
9821 : 12 : gimple_seq *lseq = seq;
9822 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2005;
9823 : 12 : {
9824 : 12 : res_op->set_op (CFN_BUILT_IN_EXP2, type, 1);
9825 : 12 : {
9826 : 12 : tree _o1[2], _r1;
9827 : 12 : _o1[0] = captures[0];
9828 : 12 : _o1[1] = build_real (type, dconsthalf);
9829 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9830 : 12 : tem_op.resimplify (lseq, valueize);
9831 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9832 : 12 : if (!_r1) goto next_after_fail2005;
9833 : 6 : res_op->ops[0] = _r1;
9834 : : }
9835 : 6 : res_op->resimplify (lseq, valueize);
9836 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1041, __FILE__, __LINE__, true);
9837 : 6 : return true;
9838 : : }
9839 : : next_after_fail2005:;
9840 : : }
9841 : : }
9842 : : }
9843 : : break;
9844 : 62 : case CFN_BUILT_IN_SQRT:
9845 : 62 : if (gimple_call_num_args (_c1) == 1)
9846 : : {
9847 : 62 : tree _q20 = gimple_call_arg (_c1, 0);
9848 : 62 : _q20 = do_valueize (valueize, _q20);
9849 : 62 : {
9850 : 62 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9851 : 62 : if (flag_unsafe_math_optimizations && canonicalize_math_p ()
9852 : : )
9853 : : {
9854 : 12 : gimple_seq *lseq = seq;
9855 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2006;
9856 : 12 : {
9857 : 12 : res_op->set_op (CFN_BUILT_IN_POW, type, 2);
9858 : 12 : res_op->ops[0] = captures[0];
9859 : 12 : res_op->ops[1] = build_real (type, dconst_quarter ());
9860 : 12 : res_op->resimplify (lseq, valueize);
9861 : 12 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1040, __FILE__, __LINE__, true);
9862 : 12 : return true;
9863 : : }
9864 : 0 : next_after_fail2006:;
9865 : : }
9866 : : }
9867 : : }
9868 : : break;
9869 : 12 : case CFN_BUILT_IN_EXP10:
9870 : 12 : if (gimple_call_num_args (_c1) == 1)
9871 : : {
9872 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
9873 : 12 : _q20 = do_valueize (valueize, _q20);
9874 : 12 : {
9875 : 12 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9876 : 12 : if (flag_unsafe_math_optimizations
9877 : : )
9878 : : {
9879 : 12 : gimple_seq *lseq = seq;
9880 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2007;
9881 : 12 : {
9882 : 12 : res_op->set_op (CFN_BUILT_IN_EXP10, type, 1);
9883 : 12 : {
9884 : 12 : tree _o1[2], _r1;
9885 : 12 : _o1[0] = captures[0];
9886 : 12 : _o1[1] = build_real (type, dconsthalf);
9887 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9888 : 12 : tem_op.resimplify (lseq, valueize);
9889 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9890 : 12 : if (!_r1) goto next_after_fail2007;
9891 : 6 : res_op->ops[0] = _r1;
9892 : : }
9893 : 6 : res_op->resimplify (lseq, valueize);
9894 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1041, __FILE__, __LINE__, true);
9895 : 6 : return true;
9896 : : }
9897 : : next_after_fail2007:;
9898 : : }
9899 : : }
9900 : : }
9901 : : break;
9902 : 12 : case CFN_BUILT_IN_POW10:
9903 : 12 : if (gimple_call_num_args (_c1) == 1)
9904 : : {
9905 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
9906 : 12 : _q20 = do_valueize (valueize, _q20);
9907 : 12 : {
9908 : 12 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
9909 : 12 : if (flag_unsafe_math_optimizations
9910 : : )
9911 : : {
9912 : 12 : gimple_seq *lseq = seq;
9913 : 12 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2008;
9914 : 12 : {
9915 : 12 : res_op->set_op (CFN_BUILT_IN_POW10, type, 1);
9916 : 12 : {
9917 : 12 : tree _o1[2], _r1;
9918 : 12 : _o1[0] = captures[0];
9919 : 12 : _o1[1] = build_real (type, dconsthalf);
9920 : 12 : gimple_match_op tem_op (res_op->cond.any_else (), MULT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
9921 : 12 : tem_op.resimplify (lseq, valueize);
9922 : 12 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
9923 : 12 : if (!_r1) goto next_after_fail2008;
9924 : 6 : res_op->ops[0] = _r1;
9925 : : }
9926 : 6 : res_op->resimplify (lseq, valueize);
9927 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1041, __FILE__, __LINE__, true);
9928 : 6 : return true;
9929 : : }
9930 : : next_after_fail2008:;
9931 : : }
9932 : : }
9933 : : }
9934 : : break;
9935 : : default:;
9936 : : }
9937 : : }
9938 : : break;
9939 : : default:;
9940 : : }
9941 : : return false;
9942 : : }
9943 : :
9944 : : bool
9945 : 1546 : gimple_simplify_CFN_BUILT_IN_SINHF (gimple_match_op *res_op, gimple_seq *seq,
9946 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
9947 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
9948 : : {
9949 : 1546 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9950 : 1546 : switch (TREE_CODE (_p0))
9951 : : {
9952 : 1473 : case SSA_NAME:
9953 : 1473 : if (gimple *_d1 = get_def (valueize, _p0))
9954 : : {
9955 : 839 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
9956 : 21 : switch (gimple_call_combined_fn (_c1))
9957 : : {
9958 : 21 : case CFN_BUILT_IN_ATANHF:
9959 : 21 : if (gimple_call_num_args (_c1) == 1)
9960 : : {
9961 : 21 : tree _q20 = gimple_call_arg (_c1, 0);
9962 : 21 : _q20 = do_valueize (valueize, _q20);
9963 : 21 : {
9964 : 21 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
9965 : 21 : if (gimple_simplify_668 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SINHF, CFN_BUILT_IN_ATANHF, CFN_BUILT_IN_SQRTF))
9966 : 1 : return true;
9967 : : }
9968 : : }
9969 : : break;
9970 : : default:;
9971 : : }
9972 : : }
9973 : : break;
9974 : : default:;
9975 : : }
9976 : : return false;
9977 : : }
9978 : :
9979 : : bool
9980 : 0 : gimple_simplify_CFN_BUILT_IN_TRUNCF32 (gimple_match_op *res_op, gimple_seq *seq,
9981 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
9982 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
9983 : : {
9984 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
9985 : 0 : switch (TREE_CODE (_p0))
9986 : : {
9987 : 0 : case SSA_NAME:
9988 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
9989 : : {
9990 : 0 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
9991 : 0 : switch (gimple_call_combined_fn (_c1))
9992 : : {
9993 : 0 : case CFN_BUILT_IN_TRUNCF32:
9994 : 0 : if (gimple_call_num_args (_c1) == 1)
9995 : : {
9996 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
9997 : 0 : _q20 = do_valueize (valueize, _q20);
9998 : 0 : {
9999 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10000 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_TRUNCF32))
10001 : 0 : return true;
10002 : : }
10003 : : }
10004 : : break;
10005 : : default:;
10006 : : }
10007 : : }
10008 : : break;
10009 : 0 : default:;
10010 : : }
10011 : 0 : if (integer_valued_real_p (_p0))
10012 : : {
10013 : 0 : {
10014 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10015 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_TRUNCF32))
10016 : 0 : return true;
10017 : : }
10018 : : }
10019 : : return false;
10020 : : }
10021 : :
10022 : : bool
10023 : 207 : gimple_simplify_CFN_TRUNC (gimple_match_op *res_op, gimple_seq *seq,
10024 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10025 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10026 : : {
10027 : 207 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10028 : 207 : switch (TREE_CODE (_p0))
10029 : : {
10030 : 207 : case SSA_NAME:
10031 : 207 : if (gimple *_d1 = get_def (valueize, _p0))
10032 : : {
10033 : 120 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10034 : 0 : switch (gimple_call_combined_fn (_c1))
10035 : : {
10036 : 0 : case CFN_TRUNC:
10037 : 0 : if (gimple_call_num_args (_c1) == 1)
10038 : : {
10039 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10040 : 0 : _q20 = do_valueize (valueize, _q20);
10041 : 0 : {
10042 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10043 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_TRUNC))
10044 : 0 : return true;
10045 : : }
10046 : : }
10047 : : break;
10048 : : default:;
10049 : : }
10050 : : }
10051 : : break;
10052 : 207 : default:;
10053 : : }
10054 : 207 : if (integer_valued_real_p (_p0))
10055 : : {
10056 : 0 : {
10057 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10058 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_TRUNC))
10059 : 0 : return true;
10060 : : }
10061 : : }
10062 : : return false;
10063 : : }
10064 : :
10065 : : bool
10066 : 138 : gimple_simplify_CFN_BUILT_IN_FLOORF128 (gimple_match_op *res_op, gimple_seq *seq,
10067 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10068 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10069 : : {
10070 : 138 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10071 : 138 : switch (TREE_CODE (_p0))
10072 : : {
10073 : 136 : case SSA_NAME:
10074 : 136 : if (gimple *_d1 = get_def (valueize, _p0))
10075 : : {
10076 : 94 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10077 : 0 : switch (gimple_call_combined_fn (_c1))
10078 : : {
10079 : 0 : case CFN_BUILT_IN_FLOORF128:
10080 : 0 : if (gimple_call_num_args (_c1) == 1)
10081 : : {
10082 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10083 : 0 : _q20 = do_valueize (valueize, _q20);
10084 : 0 : {
10085 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10086 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FLOORF128))
10087 : 0 : return true;
10088 : : }
10089 : : }
10090 : : break;
10091 : : default:;
10092 : : }
10093 : : }
10094 : : break;
10095 : 138 : default:;
10096 : : }
10097 : 138 : if (integer_valued_real_p (_p0))
10098 : : {
10099 : 0 : {
10100 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10101 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FLOORF128))
10102 : 0 : return true;
10103 : : }
10104 : : }
10105 : 138 : if (tree_expr_nonnegative_p (_p0))
10106 : : {
10107 : 0 : {
10108 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10109 : 0 : if (gimple_simplify_673 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FLOORF128, CFN_BUILT_IN_TRUNCF128))
10110 : 0 : return true;
10111 : : }
10112 : : }
10113 : : return false;
10114 : : }
10115 : :
10116 : : bool
10117 : 149 : gimple_simplify_CFN_BUILT_IN_CEILF16 (gimple_match_op *res_op, gimple_seq *seq,
10118 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10119 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10120 : : {
10121 : 149 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10122 : 149 : switch (TREE_CODE (_p0))
10123 : : {
10124 : 147 : case SSA_NAME:
10125 : 147 : if (gimple *_d1 = get_def (valueize, _p0))
10126 : : {
10127 : 100 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10128 : 0 : switch (gimple_call_combined_fn (_c1))
10129 : : {
10130 : 0 : case CFN_BUILT_IN_CEILF16:
10131 : 0 : if (gimple_call_num_args (_c1) == 1)
10132 : : {
10133 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10134 : 0 : _q20 = do_valueize (valueize, _q20);
10135 : 0 : {
10136 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10137 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_CEILF16))
10138 : 0 : return true;
10139 : : }
10140 : : }
10141 : : break;
10142 : : default:;
10143 : : }
10144 : : }
10145 : : break;
10146 : 149 : default:;
10147 : : }
10148 : 149 : if (integer_valued_real_p (_p0))
10149 : : {
10150 : 0 : {
10151 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10152 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_CEILF16))
10153 : 0 : return true;
10154 : : }
10155 : : }
10156 : : return false;
10157 : : }
10158 : :
10159 : : bool
10160 : 0 : gimple_simplify_CFN_BUILT_IN_CEILF128X (gimple_match_op *res_op, gimple_seq *seq,
10161 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10162 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10163 : : {
10164 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10165 : 0 : switch (TREE_CODE (_p0))
10166 : : {
10167 : 0 : case SSA_NAME:
10168 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
10169 : : {
10170 : 0 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10171 : 0 : switch (gimple_call_combined_fn (_c1))
10172 : : {
10173 : 0 : case CFN_BUILT_IN_CEILF128X:
10174 : 0 : if (gimple_call_num_args (_c1) == 1)
10175 : : {
10176 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10177 : 0 : _q20 = do_valueize (valueize, _q20);
10178 : 0 : {
10179 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10180 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_CEILF128X))
10181 : 0 : return true;
10182 : : }
10183 : : }
10184 : : break;
10185 : : default:;
10186 : : }
10187 : : }
10188 : : break;
10189 : 0 : default:;
10190 : : }
10191 : 0 : if (integer_valued_real_p (_p0))
10192 : : {
10193 : 0 : {
10194 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10195 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_CEILF128X))
10196 : 0 : return true;
10197 : : }
10198 : : }
10199 : : return false;
10200 : : }
10201 : :
10202 : : bool
10203 : 0 : gimple_simplify_CFN_BUILT_IN_ROUNDF32X (gimple_match_op *res_op, gimple_seq *seq,
10204 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10205 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10206 : : {
10207 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10208 : 0 : switch (TREE_CODE (_p0))
10209 : : {
10210 : 0 : case SSA_NAME:
10211 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
10212 : : {
10213 : 0 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10214 : 0 : switch (gimple_call_combined_fn (_c1))
10215 : : {
10216 : 0 : case CFN_BUILT_IN_ROUNDF32X:
10217 : 0 : if (gimple_call_num_args (_c1) == 1)
10218 : : {
10219 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10220 : 0 : _q20 = do_valueize (valueize, _q20);
10221 : 0 : {
10222 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10223 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ROUNDF32X))
10224 : 0 : return true;
10225 : : }
10226 : : }
10227 : : break;
10228 : : default:;
10229 : : }
10230 : : }
10231 : : break;
10232 : 0 : default:;
10233 : : }
10234 : 0 : if (integer_valued_real_p (_p0))
10235 : : {
10236 : 0 : {
10237 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10238 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ROUNDF32X))
10239 : 0 : return true;
10240 : : }
10241 : : }
10242 : : return false;
10243 : : }
10244 : :
10245 : : bool
10246 : 281 : gimple_simplify_CFN_BUILT_IN_NEARBYINTF16 (gimple_match_op *res_op, gimple_seq *seq,
10247 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10248 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10249 : : {
10250 : 281 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10251 : 281 : switch (TREE_CODE (_p0))
10252 : : {
10253 : 279 : case SSA_NAME:
10254 : 279 : if (gimple *_d1 = get_def (valueize, _p0))
10255 : : {
10256 : 154 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10257 : 0 : switch (gimple_call_combined_fn (_c1))
10258 : : {
10259 : 0 : case CFN_BUILT_IN_NEARBYINTF16:
10260 : 0 : if (gimple_call_num_args (_c1) == 1)
10261 : : {
10262 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10263 : 0 : _q20 = do_valueize (valueize, _q20);
10264 : 0 : {
10265 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10266 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_NEARBYINTF16))
10267 : 0 : return true;
10268 : : }
10269 : : }
10270 : : break;
10271 : : default:;
10272 : : }
10273 : : }
10274 : : break;
10275 : 281 : default:;
10276 : : }
10277 : 281 : if (integer_valued_real_p (_p0))
10278 : : {
10279 : 0 : {
10280 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10281 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_NEARBYINTF16))
10282 : 0 : return true;
10283 : : }
10284 : : }
10285 : : return false;
10286 : : }
10287 : :
10288 : : bool
10289 : 0 : gimple_simplify_CFN_BUILT_IN_NEARBYINTF128X (gimple_match_op *res_op, gimple_seq *seq,
10290 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10291 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10292 : : {
10293 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10294 : 0 : switch (TREE_CODE (_p0))
10295 : : {
10296 : 0 : case SSA_NAME:
10297 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
10298 : : {
10299 : 0 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10300 : 0 : switch (gimple_call_combined_fn (_c1))
10301 : : {
10302 : 0 : case CFN_BUILT_IN_NEARBYINTF128X:
10303 : 0 : if (gimple_call_num_args (_c1) == 1)
10304 : : {
10305 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10306 : 0 : _q20 = do_valueize (valueize, _q20);
10307 : 0 : {
10308 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10309 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_NEARBYINTF128X))
10310 : 0 : return true;
10311 : : }
10312 : : }
10313 : : break;
10314 : : default:;
10315 : : }
10316 : : }
10317 : : break;
10318 : 0 : default:;
10319 : : }
10320 : 0 : if (integer_valued_real_p (_p0))
10321 : : {
10322 : 0 : {
10323 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10324 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_NEARBYINTF128X))
10325 : 0 : return true;
10326 : : }
10327 : : }
10328 : : return false;
10329 : : }
10330 : :
10331 : : bool
10332 : 0 : gimple_simplify_CFN_BUILT_IN_RINTF32X (gimple_match_op *res_op, gimple_seq *seq,
10333 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10334 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10335 : : {
10336 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10337 : 0 : switch (TREE_CODE (_p0))
10338 : : {
10339 : 0 : case SSA_NAME:
10340 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
10341 : : {
10342 : 0 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10343 : 0 : switch (gimple_call_combined_fn (_c1))
10344 : : {
10345 : 0 : case CFN_BUILT_IN_RINTF32X:
10346 : 0 : if (gimple_call_num_args (_c1) == 1)
10347 : : {
10348 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10349 : 0 : _q20 = do_valueize (valueize, _q20);
10350 : 0 : {
10351 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10352 : 0 : if (gimple_simplify_669 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_RINTF32X))
10353 : 0 : return true;
10354 : : }
10355 : : }
10356 : : break;
10357 : : default:;
10358 : : }
10359 : : }
10360 : : break;
10361 : 0 : default:;
10362 : : }
10363 : 0 : if (integer_valued_real_p (_p0))
10364 : : {
10365 : 0 : {
10366 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10367 : 0 : if (gimple_simplify_670 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_RINTF32X))
10368 : 0 : return true;
10369 : : }
10370 : : }
10371 : : return false;
10372 : : }
10373 : :
10374 : : bool
10375 : 1 : gimple_simplify_CFN_BUILT_IN_IFLOORL (gimple_match_op *res_op, gimple_seq *seq,
10376 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10377 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10378 : : {
10379 : 1 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10380 : 1 : switch (TREE_CODE (_p0))
10381 : : {
10382 : 0 : case SSA_NAME:
10383 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
10384 : : {
10385 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10386 : 0 : switch (gimple_assign_rhs_code (_a1))
10387 : : {
10388 : 0 : CASE_CONVERT:
10389 : 0 : {
10390 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
10391 : 0 : _q20 = do_valueize (valueize, _q20);
10392 : 0 : if (gimple_double_value_p (_q20, valueize))
10393 : : {
10394 : 0 : {
10395 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10396 : 0 : if (gimple_simplify_676 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IFLOORL, CFN_BUILT_IN_IFLOOR))
10397 : 0 : return true;
10398 : : }
10399 : : }
10400 : 0 : if (gimple_float_value_p (_q20, valueize))
10401 : : {
10402 : 0 : {
10403 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10404 : 0 : if (gimple_simplify_677 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IFLOORL, CFN_BUILT_IN_IFLOORF))
10405 : 0 : return true;
10406 : : }
10407 : : }
10408 : : break;
10409 : : }
10410 : : default:;
10411 : : }
10412 : : }
10413 : : break;
10414 : 1 : default:;
10415 : : }
10416 : 1 : if (tree_expr_nonnegative_p (_p0))
10417 : : {
10418 : 0 : {
10419 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10420 : 0 : if (gimple_simplify_678 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IFLOORL))
10421 : 0 : return true;
10422 : : }
10423 : : }
10424 : 1 : if (integer_valued_real_p (_p0))
10425 : : {
10426 : 0 : {
10427 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10428 : 0 : if (gimple_simplify_679 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IFLOORL))
10429 : 0 : return true;
10430 : : }
10431 : : }
10432 : 1 : {
10433 : 1 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10434 : 1 : if (gimple_simplify_680 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IFLOORL, CFN_BUILT_IN_LFLOORL, CFN_BUILT_IN_LLFLOORL))
10435 : 0 : return true;
10436 : : }
10437 : 1 : return false;
10438 : : }
10439 : :
10440 : : bool
10441 : 117 : gimple_simplify_CFN_BUILT_IN_IROUNDL (gimple_match_op *res_op, gimple_seq *seq,
10442 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10443 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10444 : : {
10445 : 117 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10446 : 117 : switch (TREE_CODE (_p0))
10447 : : {
10448 : 115 : case SSA_NAME:
10449 : 115 : if (gimple *_d1 = get_def (valueize, _p0))
10450 : : {
10451 : 77 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10452 : 132 : switch (gimple_assign_rhs_code (_a1))
10453 : : {
10454 : 0 : CASE_CONVERT:
10455 : 0 : {
10456 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
10457 : 0 : _q20 = do_valueize (valueize, _q20);
10458 : 0 : if (gimple_double_value_p (_q20, valueize))
10459 : : {
10460 : 0 : {
10461 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10462 : 0 : if (gimple_simplify_676 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IROUNDL, CFN_BUILT_IN_IROUND))
10463 : 0 : return true;
10464 : : }
10465 : : }
10466 : 0 : if (gimple_float_value_p (_q20, valueize))
10467 : : {
10468 : 0 : {
10469 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10470 : 0 : if (gimple_simplify_677 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IROUNDL, CFN_BUILT_IN_IROUNDF))
10471 : 0 : return true;
10472 : : }
10473 : : }
10474 : : break;
10475 : : }
10476 : : default:;
10477 : : }
10478 : : }
10479 : : break;
10480 : 117 : default:;
10481 : : }
10482 : 117 : if (integer_valued_real_p (_p0))
10483 : : {
10484 : 0 : {
10485 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10486 : 0 : if (gimple_simplify_679 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IROUNDL))
10487 : 0 : return true;
10488 : : }
10489 : : }
10490 : 117 : {
10491 : 117 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10492 : 117 : if (gimple_simplify_680 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_IROUNDL, CFN_BUILT_IN_LROUNDL, CFN_BUILT_IN_LLROUNDL))
10493 : 4 : return true;
10494 : : }
10495 : 113 : return false;
10496 : : }
10497 : :
10498 : : bool
10499 : 181 : gimple_simplify_CFN_BUILT_IN_ICEIL (gimple_match_op *res_op, gimple_seq *seq,
10500 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10501 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10502 : : {
10503 : 181 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10504 : 181 : switch (TREE_CODE (_p0))
10505 : : {
10506 : 180 : case SSA_NAME:
10507 : 180 : if (gimple *_d1 = get_def (valueize, _p0))
10508 : : {
10509 : 92 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10510 : 184 : switch (gimple_assign_rhs_code (_a1))
10511 : : {
10512 : 0 : CASE_CONVERT:
10513 : 0 : {
10514 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
10515 : 0 : _q20 = do_valueize (valueize, _q20);
10516 : 0 : if (gimple_float_value_p (_q20, valueize))
10517 : : {
10518 : 0 : {
10519 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10520 : 0 : if (gimple_simplify_677 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ICEIL, CFN_BUILT_IN_ICEILF))
10521 : 0 : return true;
10522 : : }
10523 : : }
10524 : : break;
10525 : : }
10526 : : default:;
10527 : : }
10528 : : }
10529 : : break;
10530 : 181 : default:;
10531 : : }
10532 : 181 : if (integer_valued_real_p (_p0))
10533 : : {
10534 : 0 : {
10535 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10536 : 0 : if (gimple_simplify_679 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ICEIL))
10537 : 0 : return true;
10538 : : }
10539 : : }
10540 : 181 : {
10541 : 181 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10542 : 181 : if (gimple_simplify_680 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_ICEIL, CFN_BUILT_IN_LCEIL, CFN_BUILT_IN_LLCEIL))
10543 : 0 : return true;
10544 : : }
10545 : 181 : return false;
10546 : : }
10547 : :
10548 : : bool
10549 : 3347 : gimple_simplify_CFN_BUILT_IN_LRINT (gimple_match_op *res_op, gimple_seq *seq,
10550 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10551 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10552 : : {
10553 : 3347 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10554 : 3347 : switch (TREE_CODE (_p0))
10555 : : {
10556 : 3109 : case SSA_NAME:
10557 : 3109 : if (gimple *_d1 = get_def (valueize, _p0))
10558 : : {
10559 : 1959 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10560 : 2276 : switch (gimple_assign_rhs_code (_a1))
10561 : : {
10562 : 260 : CASE_CONVERT:
10563 : 260 : {
10564 : 260 : tree _q20 = gimple_assign_rhs1 (_a1);
10565 : 260 : _q20 = do_valueize (valueize, _q20);
10566 : 260 : if (gimple_float_value_p (_q20, valueize))
10567 : : {
10568 : 194 : {
10569 : 194 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10570 : 194 : if (gimple_simplify_677 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_LRINT, CFN_BUILT_IN_LRINTF))
10571 : 194 : return true;
10572 : : }
10573 : : }
10574 : : break;
10575 : : }
10576 : : default:;
10577 : : }
10578 : : }
10579 : : break;
10580 : 3153 : default:;
10581 : : }
10582 : 3153 : if (integer_valued_real_p (_p0))
10583 : : {
10584 : 56 : {
10585 : 56 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10586 : 56 : if (gimple_simplify_682 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_LRINT))
10587 : 20 : return true;
10588 : : }
10589 : : }
10590 : : return false;
10591 : : }
10592 : :
10593 : : bool
10594 : 0 : gimple_simplify_CFN_LLFLOOR (gimple_match_op *res_op, gimple_seq *seq,
10595 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10596 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10597 : : {
10598 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10599 : 0 : if (tree_expr_nonnegative_p (_p0))
10600 : : {
10601 : 0 : {
10602 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10603 : 0 : if (gimple_simplify_678 (res_op, seq, valueize, type, captures, CFN_LLFLOOR))
10604 : 0 : return true;
10605 : : }
10606 : : }
10607 : 0 : if (integer_valued_real_p (_p0))
10608 : : {
10609 : 0 : {
10610 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10611 : 0 : if (gimple_simplify_679 (res_op, seq, valueize, type, captures, CFN_LLFLOOR))
10612 : 0 : return true;
10613 : : }
10614 : : }
10615 : 0 : {
10616 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10617 : 0 : if (gimple_simplify_681 (res_op, seq, valueize, type, captures, CFN_IFLOOR, CFN_LFLOOR, CFN_LLFLOOR))
10618 : 0 : return true;
10619 : : }
10620 : 0 : return false;
10621 : : }
10622 : :
10623 : : bool
10624 : 0 : gimple_simplify_CFN_LLROUND (gimple_match_op *res_op, gimple_seq *seq,
10625 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10626 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10627 : : {
10628 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10629 : 0 : if (integer_valued_real_p (_p0))
10630 : : {
10631 : 0 : {
10632 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10633 : 0 : if (gimple_simplify_679 (res_op, seq, valueize, type, captures, CFN_LLROUND))
10634 : 0 : return true;
10635 : : }
10636 : : }
10637 : 0 : {
10638 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10639 : 0 : if (gimple_simplify_681 (res_op, seq, valueize, type, captures, CFN_IROUND, CFN_LROUND, CFN_LLROUND))
10640 : 0 : return true;
10641 : : }
10642 : 0 : return false;
10643 : : }
10644 : :
10645 : : bool
10646 : 995 : gimple_simplify_CFN_BUILT_IN_CPROJF (gimple_match_op *res_op, gimple_seq *seq,
10647 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10648 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10649 : : {
10650 : 995 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10651 : 995 : {
10652 : 995 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10653 : 995 : if (!HONOR_INFINITIES (type)
10654 : : )
10655 : : {
10656 : 21 : gimple_seq *lseq = seq;
10657 : 21 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2045;
10658 : 21 : {
10659 : 21 : tree tem;
10660 : 21 : tem = captures[0];
10661 : 21 : res_op->set_value (tem);
10662 : 21 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1049, __FILE__, __LINE__, true);
10663 : 21 : return true;
10664 : : }
10665 : 0 : next_after_fail2045:;
10666 : : }
10667 : : }
10668 : 974 : switch (TREE_CODE (_p0))
10669 : : {
10670 : 917 : case SSA_NAME:
10671 : 917 : if (gimple *_d1 = get_def (valueize, _p0))
10672 : : {
10673 : 542 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10674 : 736 : switch (gimple_assign_rhs_code (_a1))
10675 : : {
10676 : 336 : case COMPLEX_EXPR:
10677 : 336 : {
10678 : 336 : tree _q20 = gimple_assign_rhs1 (_a1);
10679 : 336 : _q20 = do_valueize (valueize, _q20);
10680 : 336 : tree _q21 = gimple_assign_rhs2 (_a1);
10681 : 336 : _q21 = do_valueize (valueize, _q21);
10682 : 336 : switch (TREE_CODE (_q20))
10683 : : {
10684 : 56 : case REAL_CST:
10685 : 56 : {
10686 : 56 : if (tree_expr_nonnegative_p (_q21))
10687 : : {
10688 : 56 : {
10689 : 56 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10690 : 56 : if (real_isinf (TREE_REAL_CST_PTR (captures[0]))
10691 : : )
10692 : : {
10693 : 56 : gimple_seq *lseq = seq;
10694 : 56 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2046;
10695 : 56 : {
10696 : 56 : tree tem;
10697 : 56 : tem = build_complex_inf (type, false);
10698 : 56 : res_op->set_value (tem);
10699 : 56 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1050, __FILE__, __LINE__, true);
10700 : 56 : return true;
10701 : : }
10702 : 0 : next_after_fail2046:;
10703 : : }
10704 : : }
10705 : : }
10706 : : break;
10707 : : }
10708 : 280 : default:;
10709 : : }
10710 : 280 : switch (TREE_CODE (_q21))
10711 : : {
10712 : 224 : case REAL_CST:
10713 : 224 : {
10714 : 224 : {
10715 : 224 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
10716 : 224 : if (real_isinf (TREE_REAL_CST_PTR (captures[1]))
10717 : : )
10718 : : {
10719 : 224 : gimple_seq *lseq = seq;
10720 : 224 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2047;
10721 : 224 : {
10722 : 224 : tree tem;
10723 : 224 : tem = build_complex_inf (type, TREE_REAL_CST_PTR (captures[1])->sign);
10724 : 224 : res_op->set_value (tem);
10725 : 224 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1051, __FILE__, __LINE__, true);
10726 : 224 : return true;
10727 : : }
10728 : 0 : next_after_fail2047:;
10729 : : }
10730 : : }
10731 : 0 : break;
10732 : : }
10733 : : default:;
10734 : : }
10735 : : break;
10736 : : }
10737 : : default:;
10738 : : }
10739 : : }
10740 : : break;
10741 : : default:;
10742 : : }
10743 : : return false;
10744 : : }
10745 : :
10746 : : bool
10747 : 5514 : gimple_simplify_CFN_BUILT_IN_POPCOUNT (gimple_match_op *res_op, gimple_seq *seq,
10748 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10749 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10750 : : {
10751 : 5514 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10752 : 5514 : switch (TREE_CODE (_p0))
10753 : : {
10754 : 5407 : case SSA_NAME:
10755 : 5407 : if (gimple *_d1 = get_def (valueize, _p0))
10756 : : {
10757 : 3072 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10758 : 2310 : switch (gimple_assign_rhs_code (_a1))
10759 : : {
10760 : 1648 : CASE_CONVERT:
10761 : 1648 : {
10762 : 1648 : tree _q20 = gimple_assign_rhs1 (_a1);
10763 : 1648 : _q20 = do_valueize (valueize, _q20);
10764 : 1648 : switch (TREE_CODE (_q20))
10765 : : {
10766 : 1648 : case SSA_NAME:
10767 : 1648 : if (gimple *_d2 = get_def (valueize, _q20))
10768 : : {
10769 : 1617 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10770 : 2308 : switch (gimple_assign_rhs_code (_a2))
10771 : : {
10772 : 0 : case LROTATE_EXPR:
10773 : 0 : {
10774 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
10775 : 0 : _q30 = do_valueize (valueize, _q30);
10776 : 0 : tree _q31 = gimple_assign_rhs2 (_a2);
10777 : 0 : _q31 = do_valueize (valueize, _q31);
10778 : 0 : {
10779 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
10780 : 0 : if (gimple_simplify_700 (res_op, seq, valueize, type, captures, LROTATE_EXPR, CFN_BUILT_IN_POPCOUNT))
10781 : 0 : return true;
10782 : : }
10783 : 0 : break;
10784 : : }
10785 : 0 : case RROTATE_EXPR:
10786 : 0 : {
10787 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
10788 : 0 : _q30 = do_valueize (valueize, _q30);
10789 : 0 : tree _q31 = gimple_assign_rhs2 (_a2);
10790 : 0 : _q31 = do_valueize (valueize, _q31);
10791 : 0 : {
10792 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
10793 : 0 : if (gimple_simplify_700 (res_op, seq, valueize, type, captures, RROTATE_EXPR, CFN_BUILT_IN_POPCOUNT))
10794 : 0 : return true;
10795 : : }
10796 : 0 : break;
10797 : : }
10798 : : default:;
10799 : : }
10800 : 268 : else if (gcall *_c2 = dyn_cast <gcall *> (_d2))
10801 : 16 : switch (gimple_call_combined_fn (_c2))
10802 : : {
10803 : 0 : case CFN_BUILT_IN_BSWAP128:
10804 : 0 : if (gimple_call_num_args (_c2) == 1)
10805 : : {
10806 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
10807 : 0 : _q30 = do_valueize (valueize, _q30);
10808 : 0 : {
10809 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
10810 : 0 : if (gimple_simplify_699 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP128, CFN_BUILT_IN_POPCOUNT))
10811 : 0 : return true;
10812 : : }
10813 : : }
10814 : : break;
10815 : 16 : case CFN_BUILT_IN_BSWAP16:
10816 : 16 : if (gimple_call_num_args (_c2) == 1)
10817 : : {
10818 : 16 : tree _q30 = gimple_call_arg (_c2, 0);
10819 : 16 : _q30 = do_valueize (valueize, _q30);
10820 : 16 : {
10821 : 16 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
10822 : 16 : if (gimple_simplify_699 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP16, CFN_BUILT_IN_POPCOUNT))
10823 : 8 : return true;
10824 : : }
10825 : : }
10826 : : break;
10827 : 0 : case CFN_BUILT_IN_BSWAP32:
10828 : 0 : if (gimple_call_num_args (_c2) == 1)
10829 : : {
10830 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
10831 : 0 : _q30 = do_valueize (valueize, _q30);
10832 : 0 : {
10833 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
10834 : 0 : if (gimple_simplify_699 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP32, CFN_BUILT_IN_POPCOUNT))
10835 : 0 : return true;
10836 : : }
10837 : : }
10838 : : break;
10839 : 0 : case CFN_BUILT_IN_BSWAP64:
10840 : 0 : if (gimple_call_num_args (_c2) == 1)
10841 : : {
10842 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
10843 : 0 : _q30 = do_valueize (valueize, _q30);
10844 : 0 : {
10845 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
10846 : 0 : if (gimple_simplify_699 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP64, CFN_BUILT_IN_POPCOUNT))
10847 : 0 : return true;
10848 : : }
10849 : : }
10850 : : break;
10851 : : default:;
10852 : : }
10853 : : }
10854 : : break;
10855 : 1640 : default:;
10856 : : }
10857 : 1640 : {
10858 : 1640 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
10859 : 1640 : if (gimple_simplify_701 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_POPCOUNT))
10860 : 18 : return true;
10861 : : }
10862 : 1622 : break;
10863 : : }
10864 : 0 : case LROTATE_EXPR:
10865 : 0 : {
10866 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
10867 : 0 : _q20 = do_valueize (valueize, _q20);
10868 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
10869 : 0 : _q21 = do_valueize (valueize, _q21);
10870 : 0 : {
10871 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
10872 : 0 : if (gimple_simplify_703 (res_op, seq, valueize, type, captures, LROTATE_EXPR, CFN_BUILT_IN_POPCOUNT))
10873 : 0 : return true;
10874 : : }
10875 : 0 : break;
10876 : : }
10877 : 2 : case RROTATE_EXPR:
10878 : 2 : {
10879 : 2 : tree _q20 = gimple_assign_rhs1 (_a1);
10880 : 2 : _q20 = do_valueize (valueize, _q20);
10881 : 2 : tree _q21 = gimple_assign_rhs2 (_a1);
10882 : 2 : _q21 = do_valueize (valueize, _q21);
10883 : 2 : {
10884 : 2 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
10885 : 2 : if (gimple_simplify_703 (res_op, seq, valueize, type, captures, RROTATE_EXPR, CFN_BUILT_IN_POPCOUNT))
10886 : 2 : return true;
10887 : : }
10888 : 0 : break;
10889 : : }
10890 : : default:;
10891 : : }
10892 : 994 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
10893 : 48 : switch (gimple_call_combined_fn (_c1))
10894 : : {
10895 : 0 : case CFN_BUILT_IN_BSWAP128:
10896 : 0 : if (gimple_call_num_args (_c1) == 1)
10897 : : {
10898 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10899 : 0 : _q20 = do_valueize (valueize, _q20);
10900 : 0 : {
10901 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q20 };
10902 : 0 : if (gimple_simplify_702 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP128, CFN_BUILT_IN_POPCOUNT))
10903 : 0 : return true;
10904 : : }
10905 : : }
10906 : : break;
10907 : 0 : case CFN_BUILT_IN_BSWAP16:
10908 : 0 : if (gimple_call_num_args (_c1) == 1)
10909 : : {
10910 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10911 : 0 : _q20 = do_valueize (valueize, _q20);
10912 : 0 : {
10913 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q20 };
10914 : 0 : if (gimple_simplify_702 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP16, CFN_BUILT_IN_POPCOUNT))
10915 : 0 : return true;
10916 : : }
10917 : : }
10918 : : break;
10919 : 4 : case CFN_BUILT_IN_BSWAP32:
10920 : 4 : if (gimple_call_num_args (_c1) == 1)
10921 : : {
10922 : 4 : tree _q20 = gimple_call_arg (_c1, 0);
10923 : 4 : _q20 = do_valueize (valueize, _q20);
10924 : 4 : {
10925 : 4 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q20 };
10926 : 4 : if (gimple_simplify_702 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP32, CFN_BUILT_IN_POPCOUNT))
10927 : 4 : return true;
10928 : : }
10929 : : }
10930 : : break;
10931 : 0 : case CFN_BUILT_IN_BSWAP64:
10932 : 0 : if (gimple_call_num_args (_c1) == 1)
10933 : : {
10934 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
10935 : 0 : _q20 = do_valueize (valueize, _q20);
10936 : 0 : {
10937 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q20 };
10938 : 0 : if (gimple_simplify_702 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP64, CFN_BUILT_IN_POPCOUNT))
10939 : 0 : return true;
10940 : : }
10941 : : }
10942 : : break;
10943 : : default:;
10944 : : }
10945 : : }
10946 : : break;
10947 : 5482 : default:;
10948 : : }
10949 : 5482 : {
10950 : 5482 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
10951 : 5482 : if (gimple_simplify_704 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_POPCOUNT))
10952 : 8 : return true;
10953 : : }
10954 : 5474 : return false;
10955 : : }
10956 : :
10957 : : bool
10958 : 0 : gimple_simplify_CFN_BUILT_IN_PARITYIMAX (gimple_match_op *res_op, gimple_seq *seq,
10959 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
10960 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0)
10961 : : {
10962 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
10963 : 0 : switch (TREE_CODE (_p0))
10964 : : {
10965 : 0 : case SSA_NAME:
10966 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
10967 : : {
10968 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
10969 : 0 : switch (gimple_assign_rhs_code (_a1))
10970 : : {
10971 : 0 : case BIT_NOT_EXPR:
10972 : 0 : {
10973 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
10974 : 0 : _q20 = do_valueize (valueize, _q20);
10975 : 0 : {
10976 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
10977 : 0 : if (gimple_simplify_705 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_PARITYIMAX))
10978 : 0 : return true;
10979 : : }
10980 : 0 : break;
10981 : : }
10982 : 0 : CASE_CONVERT:
10983 : 0 : {
10984 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
10985 : 0 : _q20 = do_valueize (valueize, _q20);
10986 : 0 : switch (TREE_CODE (_q20))
10987 : : {
10988 : 0 : case SSA_NAME:
10989 : 0 : if (gimple *_d2 = get_def (valueize, _q20))
10990 : : {
10991 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
10992 : 0 : switch (gimple_assign_rhs_code (_a2))
10993 : : {
10994 : 0 : case LROTATE_EXPR:
10995 : 0 : {
10996 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
10997 : 0 : _q30 = do_valueize (valueize, _q30);
10998 : 0 : tree _q31 = gimple_assign_rhs2 (_a2);
10999 : 0 : _q31 = do_valueize (valueize, _q31);
11000 : 0 : {
11001 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
11002 : 0 : if (gimple_simplify_707 (res_op, seq, valueize, type, captures, LROTATE_EXPR, CFN_BUILT_IN_PARITYIMAX))
11003 : 0 : return true;
11004 : : }
11005 : 0 : break;
11006 : : }
11007 : 0 : case RROTATE_EXPR:
11008 : 0 : {
11009 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
11010 : 0 : _q30 = do_valueize (valueize, _q30);
11011 : 0 : tree _q31 = gimple_assign_rhs2 (_a2);
11012 : 0 : _q31 = do_valueize (valueize, _q31);
11013 : 0 : {
11014 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
11015 : 0 : if (gimple_simplify_707 (res_op, seq, valueize, type, captures, RROTATE_EXPR, CFN_BUILT_IN_PARITYIMAX))
11016 : 0 : return true;
11017 : : }
11018 : 0 : break;
11019 : : }
11020 : : default:;
11021 : : }
11022 : 0 : else if (gcall *_c2 = dyn_cast <gcall *> (_d2))
11023 : 0 : switch (gimple_call_combined_fn (_c2))
11024 : : {
11025 : 0 : case CFN_BUILT_IN_BSWAP128:
11026 : 0 : if (gimple_call_num_args (_c2) == 1)
11027 : : {
11028 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
11029 : 0 : _q30 = do_valueize (valueize, _q30);
11030 : 0 : {
11031 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
11032 : 0 : if (gimple_simplify_706 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP128, CFN_BUILT_IN_PARITYIMAX))
11033 : 0 : return true;
11034 : : }
11035 : : }
11036 : : break;
11037 : 0 : case CFN_BUILT_IN_BSWAP16:
11038 : 0 : if (gimple_call_num_args (_c2) == 1)
11039 : : {
11040 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
11041 : 0 : _q30 = do_valueize (valueize, _q30);
11042 : 0 : {
11043 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
11044 : 0 : if (gimple_simplify_706 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP16, CFN_BUILT_IN_PARITYIMAX))
11045 : 0 : return true;
11046 : : }
11047 : : }
11048 : : break;
11049 : 0 : case CFN_BUILT_IN_BSWAP32:
11050 : 0 : if (gimple_call_num_args (_c2) == 1)
11051 : : {
11052 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
11053 : 0 : _q30 = do_valueize (valueize, _q30);
11054 : 0 : {
11055 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
11056 : 0 : if (gimple_simplify_706 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP32, CFN_BUILT_IN_PARITYIMAX))
11057 : 0 : return true;
11058 : : }
11059 : : }
11060 : : break;
11061 : 0 : case CFN_BUILT_IN_BSWAP64:
11062 : 0 : if (gimple_call_num_args (_c2) == 1)
11063 : : {
11064 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
11065 : 0 : _q30 = do_valueize (valueize, _q30);
11066 : 0 : {
11067 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q30 };
11068 : 0 : if (gimple_simplify_706 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP64, CFN_BUILT_IN_PARITYIMAX))
11069 : 0 : return true;
11070 : : }
11071 : : }
11072 : : break;
11073 : : default:;
11074 : : }
11075 : : }
11076 : : break;
11077 : 0 : default:;
11078 : : }
11079 : 0 : {
11080 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
11081 : 0 : if (gimple_simplify_708 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_PARITYIMAX))
11082 : 0 : return true;
11083 : : }
11084 : 0 : break;
11085 : : }
11086 : 0 : case LROTATE_EXPR:
11087 : 0 : {
11088 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
11089 : 0 : _q20 = do_valueize (valueize, _q20);
11090 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
11091 : 0 : _q21 = do_valueize (valueize, _q21);
11092 : 0 : {
11093 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
11094 : 0 : if (gimple_simplify_710 (res_op, seq, valueize, type, captures, LROTATE_EXPR, CFN_BUILT_IN_PARITYIMAX))
11095 : 0 : return true;
11096 : : }
11097 : 0 : break;
11098 : : }
11099 : 0 : case RROTATE_EXPR:
11100 : 0 : {
11101 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
11102 : 0 : _q20 = do_valueize (valueize, _q20);
11103 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
11104 : 0 : _q21 = do_valueize (valueize, _q21);
11105 : 0 : {
11106 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
11107 : 0 : if (gimple_simplify_710 (res_op, seq, valueize, type, captures, RROTATE_EXPR, CFN_BUILT_IN_PARITYIMAX))
11108 : 0 : return true;
11109 : : }
11110 : 0 : break;
11111 : : }
11112 : : default:;
11113 : : }
11114 : 0 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
11115 : 0 : switch (gimple_call_combined_fn (_c1))
11116 : : {
11117 : 0 : case CFN_BUILT_IN_BSWAP128:
11118 : 0 : if (gimple_call_num_args (_c1) == 1)
11119 : : {
11120 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
11121 : 0 : _q20 = do_valueize (valueize, _q20);
11122 : 0 : {
11123 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q20 };
11124 : 0 : if (gimple_simplify_709 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP128, CFN_BUILT_IN_PARITYIMAX))
11125 : 0 : return true;
11126 : : }
11127 : : }
11128 : : break;
11129 : 0 : case CFN_BUILT_IN_BSWAP16:
11130 : 0 : if (gimple_call_num_args (_c1) == 1)
11131 : : {
11132 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
11133 : 0 : _q20 = do_valueize (valueize, _q20);
11134 : 0 : {
11135 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q20 };
11136 : 0 : if (gimple_simplify_709 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP16, CFN_BUILT_IN_PARITYIMAX))
11137 : 0 : return true;
11138 : : }
11139 : : }
11140 : : break;
11141 : 0 : case CFN_BUILT_IN_BSWAP32:
11142 : 0 : if (gimple_call_num_args (_c1) == 1)
11143 : : {
11144 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
11145 : 0 : _q20 = do_valueize (valueize, _q20);
11146 : 0 : {
11147 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q20 };
11148 : 0 : if (gimple_simplify_709 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP32, CFN_BUILT_IN_PARITYIMAX))
11149 : 0 : return true;
11150 : : }
11151 : : }
11152 : : break;
11153 : 0 : case CFN_BUILT_IN_BSWAP64:
11154 : 0 : if (gimple_call_num_args (_c1) == 1)
11155 : : {
11156 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
11157 : 0 : _q20 = do_valueize (valueize, _q20);
11158 : 0 : {
11159 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q20 };
11160 : 0 : if (gimple_simplify_709 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP64, CFN_BUILT_IN_PARITYIMAX))
11161 : 0 : return true;
11162 : : }
11163 : : }
11164 : : break;
11165 : : default:;
11166 : : }
11167 : : }
11168 : : break;
11169 : 0 : default:;
11170 : : }
11171 : 0 : {
11172 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
11173 : 0 : if (gimple_simplify_704 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_PARITYIMAX))
11174 : 0 : return true;
11175 : : }
11176 : 0 : return false;
11177 : : }
11178 : :
11179 : : bool
11180 : 80038307 : gimple_simplify_EQ_EXPR (gimple_match_op *res_op, gimple_seq *seq,
11181 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
11182 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
11183 : : {
11184 : 80038307 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
11185 : 80038307 : switch (TREE_CODE (_p1))
11186 : : {
11187 : 13149807 : case SSA_NAME:
11188 : 13149807 : if (gimple *_d1 = get_def (valueize, _p1))
11189 : : {
11190 : 4382292 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11191 : 6454951 : switch (gimple_assign_rhs_code (_a1))
11192 : : {
11193 : 534 : case NEGATE_EXPR:
11194 : 534 : {
11195 : 534 : tree _q30 = gimple_assign_rhs1 (_a1);
11196 : 534 : _q30 = do_valueize (valueize, _q30);
11197 : 534 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
11198 : : {
11199 : 107 : {
11200 : 107 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
11201 : 107 : if (gimple_simplify_230 (res_op, seq, valueize, type, captures, EQ_EXPR))
11202 : 0 : return true;
11203 : : }
11204 : : }
11205 : : break;
11206 : : }
11207 : : default:;
11208 : : }
11209 : : }
11210 : : break;
11211 : 80038307 : default:;
11212 : : }
11213 : 80038307 : switch (TREE_CODE (_p0))
11214 : : {
11215 : 79192908 : case SSA_NAME:
11216 : 79192908 : if (gimple *_d1 = get_def (valueize, _p0))
11217 : : {
11218 : 27048691 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11219 : 33217748 : switch (gimple_assign_rhs_code (_a1))
11220 : : {
11221 : 6547 : case NEGATE_EXPR:
11222 : 6547 : {
11223 : 6547 : tree _q20 = gimple_assign_rhs1 (_a1);
11224 : 6547 : _q20 = do_valueize (valueize, _q20);
11225 : 6547 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
11226 : : {
11227 : 150 : {
11228 : 150 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
11229 : 150 : if (gimple_simplify_230 (res_op, seq, valueize, type, captures, EQ_EXPR))
11230 : 21 : return true;
11231 : : }
11232 : : }
11233 : : break;
11234 : : }
11235 : 0 : case CEIL_MOD_EXPR:
11236 : 0 : {
11237 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
11238 : 0 : _q20 = do_valueize (valueize, _q20);
11239 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
11240 : 0 : _q21 = do_valueize (valueize, _q21);
11241 : 0 : if (integer_pow2p (_q21))
11242 : : {
11243 : 0 : if (integer_zerop (_p1))
11244 : : {
11245 : 0 : {
11246 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
11247 : 0 : if (gimple_simplify_231 (res_op, seq, valueize, type, captures, EQ_EXPR, CEIL_MOD_EXPR))
11248 : 0 : return true;
11249 : : }
11250 : : }
11251 : : }
11252 : : break;
11253 : : }
11254 : 402 : case FLOOR_MOD_EXPR:
11255 : 402 : {
11256 : 402 : tree _q20 = gimple_assign_rhs1 (_a1);
11257 : 402 : _q20 = do_valueize (valueize, _q20);
11258 : 402 : tree _q21 = gimple_assign_rhs2 (_a1);
11259 : 402 : _q21 = do_valueize (valueize, _q21);
11260 : 402 : if (integer_pow2p (_q21))
11261 : : {
11262 : 4 : if (integer_zerop (_p1))
11263 : : {
11264 : 2 : {
11265 : 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
11266 : 2 : if (gimple_simplify_231 (res_op, seq, valueize, type, captures, EQ_EXPR, FLOOR_MOD_EXPR))
11267 : 0 : return true;
11268 : : }
11269 : : }
11270 : : }
11271 : : break;
11272 : : }
11273 : 0 : case ROUND_MOD_EXPR:
11274 : 0 : {
11275 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
11276 : 0 : _q20 = do_valueize (valueize, _q20);
11277 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
11278 : 0 : _q21 = do_valueize (valueize, _q21);
11279 : 0 : if (integer_pow2p (_q21))
11280 : : {
11281 : 0 : if (integer_zerop (_p1))
11282 : : {
11283 : 0 : {
11284 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
11285 : 0 : if (gimple_simplify_231 (res_op, seq, valueize, type, captures, EQ_EXPR, ROUND_MOD_EXPR))
11286 : 0 : return true;
11287 : : }
11288 : : }
11289 : : }
11290 : : break;
11291 : : }
11292 : 58327 : case TRUNC_MOD_EXPR:
11293 : 58327 : {
11294 : 58327 : tree _q20 = gimple_assign_rhs1 (_a1);
11295 : 58327 : _q20 = do_valueize (valueize, _q20);
11296 : 58327 : tree _q21 = gimple_assign_rhs2 (_a1);
11297 : 58327 : _q21 = do_valueize (valueize, _q21);
11298 : 58327 : if (integer_pow2p (_q21))
11299 : : {
11300 : 3796 : if (integer_zerop (_p1))
11301 : : {
11302 : 499 : {
11303 : 499 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
11304 : 499 : if (gimple_simplify_231 (res_op, seq, valueize, type, captures, EQ_EXPR, TRUNC_MOD_EXPR))
11305 : 145 : return true;
11306 : : }
11307 : : }
11308 : : }
11309 : : break;
11310 : : }
11311 : : default:;
11312 : : }
11313 : : }
11314 : : break;
11315 : 80038141 : default:;
11316 : : }
11317 : 80038141 : {
11318 : 80038141 : tree _p0_pops[1];
11319 : 80038141 : if (gimple_nop_convert (_p0, _p0_pops, valueize))
11320 : : {
11321 : 460267 : tree _q20 = _p0_pops[0];
11322 : 460267 : switch (TREE_CODE (_q20))
11323 : : {
11324 : 447290 : case SSA_NAME:
11325 : 447290 : if (gimple *_d1 = get_def (valueize, _q20))
11326 : : {
11327 : 442377 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11328 : 455034 : switch (gimple_assign_rhs_code (_a1))
11329 : : {
11330 : 119 : case LSHIFT_EXPR:
11331 : 119 : {
11332 : 119 : tree _q30 = gimple_assign_rhs1 (_a1);
11333 : 119 : _q30 = do_valueize (valueize, _q30);
11334 : 119 : tree _q31 = gimple_assign_rhs2 (_a1);
11335 : 119 : _q31 = do_valueize (valueize, _q31);
11336 : 119 : {
11337 : 119 : tree _p1_pops[1];
11338 : 119 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
11339 : : {
11340 : 0 : tree _q60 = _p1_pops[0];
11341 : 0 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
11342 : : {
11343 : 0 : {
11344 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
11345 : 0 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures))
11346 : 0 : return true;
11347 : : }
11348 : : }
11349 : : }
11350 : : }
11351 : 119 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
11352 : : {
11353 : 0 : {
11354 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
11355 : 0 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures))
11356 : 0 : return true;
11357 : : }
11358 : : }
11359 : : break;
11360 : : }
11361 : : default:;
11362 : : }
11363 : : }
11364 : : break;
11365 : 460267 : default:;
11366 : : }
11367 : 460267 : switch (TREE_CODE (_p1))
11368 : : {
11369 : 111403 : case SSA_NAME:
11370 : 111403 : if (gimple *_d1 = get_def (valueize, _p1))
11371 : : {
11372 : 105721 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11373 : 116700 : switch (gimple_assign_rhs_code (_a1))
11374 : : {
11375 : 3 : case LSHIFT_EXPR:
11376 : 3 : {
11377 : 3 : tree _q40 = gimple_assign_rhs1 (_a1);
11378 : 3 : _q40 = do_valueize (valueize, _q40);
11379 : 3 : tree _q41 = gimple_assign_rhs2 (_a1);
11380 : 3 : _q41 = do_valueize (valueize, _q41);
11381 : 3 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
11382 : : {
11383 : 0 : {
11384 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
11385 : 0 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures))
11386 : 0 : return true;
11387 : : }
11388 : : }
11389 : : break;
11390 : : }
11391 : : default:;
11392 : : }
11393 : : }
11394 : : break;
11395 : 460267 : default:;
11396 : : }
11397 : 460267 : {
11398 : 460267 : tree _p1_pops[1];
11399 : 460267 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
11400 : : {
11401 : 31142 : tree _q40 = _p1_pops[0];
11402 : 31142 : switch (TREE_CODE (_q40))
11403 : : {
11404 : 13590 : case SSA_NAME:
11405 : 13590 : if (gimple *_d1 = get_def (valueize, _q40))
11406 : : {
11407 : 13488 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11408 : 19559 : switch (gimple_assign_rhs_code (_a1))
11409 : : {
11410 : 0 : case LSHIFT_EXPR:
11411 : 0 : {
11412 : 0 : tree _q50 = gimple_assign_rhs1 (_a1);
11413 : 0 : _q50 = do_valueize (valueize, _q50);
11414 : 0 : tree _q51 = gimple_assign_rhs2 (_a1);
11415 : 0 : _q51 = do_valueize (valueize, _q51);
11416 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11417 : : {
11418 : 0 : {
11419 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q20 };
11420 : 0 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures))
11421 : 0 : return true;
11422 : : }
11423 : : }
11424 : : break;
11425 : : }
11426 : : default:;
11427 : : }
11428 : : }
11429 : : break;
11430 : : default:;
11431 : : }
11432 : : }
11433 : : }
11434 : 460267 : switch (TREE_CODE (_q20))
11435 : : {
11436 : 447290 : case SSA_NAME:
11437 : 447290 : if (gimple *_d1 = get_def (valueize, _q20))
11438 : : {
11439 : 442377 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11440 : 455034 : switch (gimple_assign_rhs_code (_a1))
11441 : : {
11442 : 38480 : case PLUS_EXPR:
11443 : 38480 : {
11444 : 38480 : tree _q30 = gimple_assign_rhs1 (_a1);
11445 : 38480 : _q30 = do_valueize (valueize, _q30);
11446 : 38480 : tree _q31 = gimple_assign_rhs2 (_a1);
11447 : 38480 : _q31 = do_valueize (valueize, _q31);
11448 : 38480 : if (tree_swap_operands_p (_q30, _q31))
11449 : 210 : std::swap (_q30, _q31);
11450 : 38480 : switch (TREE_CODE (_q31))
11451 : : {
11452 : 11389 : case SSA_NAME:
11453 : 11389 : if (gimple *_d2 = get_def (valueize, _q31))
11454 : : {
11455 : 11314 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11456 : 11291 : switch (gimple_assign_rhs_code (_a2))
11457 : : {
11458 : 1966 : CASE_CONVERT:
11459 : 1966 : {
11460 : 1966 : tree _q50 = gimple_assign_rhs1 (_a2);
11461 : 1966 : _q50 = do_valueize (valueize, _q50);
11462 : 1966 : switch (TREE_CODE (_p1))
11463 : : {
11464 : 621 : case SSA_NAME:
11465 : 621 : if (gimple *_d3 = get_def (valueize, _p1))
11466 : : {
11467 : 586 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
11468 : 565 : switch (gimple_assign_rhs_code (_a3))
11469 : : {
11470 : 285 : CASE_CONVERT:
11471 : 285 : {
11472 : 285 : tree _q70 = gimple_assign_rhs1 (_a3);
11473 : 285 : _q70 = do_valueize (valueize, _q70);
11474 : 285 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
11475 : : {
11476 : 0 : {
11477 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
11478 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
11479 : 0 : return true;
11480 : : }
11481 : : }
11482 : : break;
11483 : : }
11484 : : default:;
11485 : : }
11486 : : }
11487 : : break;
11488 : : default:;
11489 : : }
11490 : : break;
11491 : : }
11492 : : default:;
11493 : : }
11494 : : }
11495 : : break;
11496 : 38480 : default:;
11497 : : }
11498 : 38480 : switch (TREE_CODE (_q30))
11499 : : {
11500 : 38480 : case SSA_NAME:
11501 : 38480 : if (gimple *_d2 = get_def (valueize, _q30))
11502 : : {
11503 : 35620 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11504 : 33657 : switch (gimple_assign_rhs_code (_a2))
11505 : : {
11506 : 21468 : CASE_CONVERT:
11507 : 21468 : {
11508 : 21468 : tree _q40 = gimple_assign_rhs1 (_a2);
11509 : 21468 : _q40 = do_valueize (valueize, _q40);
11510 : 21468 : switch (TREE_CODE (_p1))
11511 : : {
11512 : 13936 : case SSA_NAME:
11513 : 13936 : if (gimple *_d3 = get_def (valueize, _p1))
11514 : : {
11515 : 13183 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
11516 : 23426 : switch (gimple_assign_rhs_code (_a3))
11517 : : {
11518 : 132 : CASE_CONVERT:
11519 : 132 : {
11520 : 132 : tree _q70 = gimple_assign_rhs1 (_a3);
11521 : 132 : _q70 = do_valueize (valueize, _q70);
11522 : 132 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
11523 : : {
11524 : 0 : {
11525 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
11526 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
11527 : 0 : return true;
11528 : : }
11529 : : }
11530 : : break;
11531 : : }
11532 : : default:;
11533 : : }
11534 : : }
11535 : : break;
11536 : 21468 : default:;
11537 : : }
11538 : 21468 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
11539 : : {
11540 : 49 : {
11541 : 49 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q40 };
11542 : 49 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
11543 : 12 : return true;
11544 : : }
11545 : : }
11546 : : break;
11547 : : }
11548 : : default:;
11549 : : }
11550 : : }
11551 : : break;
11552 : 38468 : default:;
11553 : : }
11554 : 38468 : switch (TREE_CODE (_q31))
11555 : : {
11556 : 11387 : case SSA_NAME:
11557 : 11387 : if (gimple *_d2 = get_def (valueize, _q31))
11558 : : {
11559 : 11312 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11560 : 11289 : switch (gimple_assign_rhs_code (_a2))
11561 : : {
11562 : 1964 : CASE_CONVERT:
11563 : 1964 : {
11564 : 1964 : tree _q50 = gimple_assign_rhs1 (_a2);
11565 : 1964 : _q50 = do_valueize (valueize, _q50);
11566 : 1964 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
11567 : : {
11568 : 80 : {
11569 : 80 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50 };
11570 : 80 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
11571 : 0 : return true;
11572 : : }
11573 : : }
11574 : : break;
11575 : : }
11576 : : default:;
11577 : : }
11578 : : }
11579 : : break;
11580 : 38468 : default:;
11581 : : }
11582 : 38468 : switch (TREE_CODE (_p1))
11583 : : {
11584 : 19441 : case SSA_NAME:
11585 : 19441 : if (gimple *_d2 = get_def (valueize, _p1))
11586 : : {
11587 : 16230 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11588 : 24888 : switch (gimple_assign_rhs_code (_a2))
11589 : : {
11590 : 731 : CASE_CONVERT:
11591 : 731 : {
11592 : 731 : tree _q60 = gimple_assign_rhs1 (_a2);
11593 : 731 : _q60 = do_valueize (valueize, _q60);
11594 : 731 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
11595 : : {
11596 : 0 : {
11597 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
11598 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
11599 : 0 : return true;
11600 : : }
11601 : : }
11602 : 731 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
11603 : : {
11604 : 0 : {
11605 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
11606 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
11607 : 0 : return true;
11608 : : }
11609 : : }
11610 : : break;
11611 : : }
11612 : : default:;
11613 : : }
11614 : : }
11615 : : break;
11616 : 38468 : default:;
11617 : : }
11618 : 38468 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
11619 : : {
11620 : 0 : {
11621 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
11622 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
11623 : 0 : return true;
11624 : : }
11625 : : }
11626 : 38468 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
11627 : : {
11628 : 0 : {
11629 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q31, _q30 };
11630 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
11631 : 0 : return true;
11632 : : }
11633 : : }
11634 : 80038129 : break;
11635 : : }
11636 : : default:;
11637 : : }
11638 : : }
11639 : : break;
11640 : : default:;
11641 : : }
11642 : : }
11643 : : }
11644 : 80038129 : {
11645 : 80038129 : tree _p1_pops[1];
11646 : 80038129 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
11647 : : {
11648 : 169727 : tree _q30 = _p1_pops[0];
11649 : 169727 : switch (TREE_CODE (_q30))
11650 : : {
11651 : 145925 : case SSA_NAME:
11652 : 145925 : if (gimple *_d1 = get_def (valueize, _q30))
11653 : : {
11654 : 143404 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11655 : 187995 : switch (gimple_assign_rhs_code (_a1))
11656 : : {
11657 : 129 : case LSHIFT_EXPR:
11658 : 129 : {
11659 : 129 : tree _q40 = gimple_assign_rhs1 (_a1);
11660 : 129 : _q40 = do_valueize (valueize, _q40);
11661 : 129 : tree _q41 = gimple_assign_rhs2 (_a1);
11662 : 129 : _q41 = do_valueize (valueize, _q41);
11663 : 129 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
11664 : : {
11665 : 0 : {
11666 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _p0 };
11667 : 0 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures))
11668 : 0 : return true;
11669 : : }
11670 : : }
11671 : : break;
11672 : : }
11673 : : default:;
11674 : : }
11675 : : }
11676 : : break;
11677 : : default:;
11678 : : }
11679 : : }
11680 : : }
11681 : 80038129 : switch (TREE_CODE (_p0))
11682 : : {
11683 : 79192730 : case SSA_NAME:
11684 : 79192730 : if (gimple *_d1 = get_def (valueize, _p0))
11685 : : {
11686 : 27048513 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11687 : 33217570 : switch (gimple_assign_rhs_code (_a1))
11688 : : {
11689 : 4326 : case LSHIFT_EXPR:
11690 : 4326 : {
11691 : 4326 : tree _q20 = gimple_assign_rhs1 (_a1);
11692 : 4326 : _q20 = do_valueize (valueize, _q20);
11693 : 4326 : tree _q21 = gimple_assign_rhs2 (_a1);
11694 : 4326 : _q21 = do_valueize (valueize, _q21);
11695 : 4326 : {
11696 : 4326 : tree _p1_pops[1];
11697 : 4326 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
11698 : : {
11699 : 32 : tree _q50 = _p1_pops[0];
11700 : 32 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11701 : : {
11702 : 9 : {
11703 : 9 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11704 : 9 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures))
11705 : 3 : return true;
11706 : : }
11707 : : }
11708 : : }
11709 : : }
11710 : 4323 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
11711 : : {
11712 : 32 : {
11713 : 32 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11714 : 32 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures))
11715 : 4 : return true;
11716 : : }
11717 : : }
11718 : 4319 : if (gimple_zero_one_valued_p (_q20, valueize))
11719 : : {
11720 : 483 : switch (TREE_CODE (_q21))
11721 : : {
11722 : 73 : case INTEGER_CST:
11723 : 73 : {
11724 : 73 : if (integer_zerop (_p1))
11725 : : {
11726 : 40 : {
11727 : 40 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
11728 : 40 : if (tree_fits_shwi_p (captures[1])
11729 : 40 : && tree_to_shwi (captures[1]) > 0
11730 : 80 : && tree_to_shwi (captures[1]) < TYPE_PRECISION (TREE_TYPE (captures[0]))
11731 : : )
11732 : : {
11733 : 40 : gimple_seq *lseq = seq;
11734 : 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2391;
11735 : 40 : {
11736 : 40 : res_op->set_op (EQ_EXPR, type, 2);
11737 : 40 : res_op->ops[0] = captures[0];
11738 : 40 : res_op->ops[1] = captures[2];
11739 : 40 : res_op->resimplify (lseq, valueize);
11740 : 40 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1148, __FILE__, __LINE__, true);
11741 : 40 : return true;
11742 : : }
11743 : 0 : next_after_fail2391:;
11744 : : }
11745 : : }
11746 : : }
11747 : : break;
11748 : : }
11749 : : default:;
11750 : : }
11751 : : }
11752 : : break;
11753 : : }
11754 : : default:;
11755 : : }
11756 : : }
11757 : : break;
11758 : 80038082 : default:;
11759 : : }
11760 : 80038082 : switch (TREE_CODE (_p1))
11761 : : {
11762 : 13149767 : case SSA_NAME:
11763 : 13149767 : if (gimple *_d1 = get_def (valueize, _p1))
11764 : : {
11765 : 4382263 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11766 : 6454924 : switch (gimple_assign_rhs_code (_a1))
11767 : : {
11768 : 773 : case LSHIFT_EXPR:
11769 : 773 : {
11770 : 773 : tree _q30 = gimple_assign_rhs1 (_a1);
11771 : 773 : _q30 = do_valueize (valueize, _q30);
11772 : 773 : tree _q31 = gimple_assign_rhs2 (_a1);
11773 : 773 : _q31 = do_valueize (valueize, _q31);
11774 : 773 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
11775 : : {
11776 : 5 : {
11777 : 5 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
11778 : 5 : if (gimple_simplify_232 (res_op, seq, valueize, type, captures))
11779 : 1 : return true;
11780 : : }
11781 : : }
11782 : : break;
11783 : : }
11784 : : default:;
11785 : : }
11786 : : }
11787 : : break;
11788 : 80038081 : default:;
11789 : : }
11790 : 80038081 : switch (TREE_CODE (_p0))
11791 : : {
11792 : 79192682 : case SSA_NAME:
11793 : 79192682 : if (gimple *_d1 = get_def (valueize, _p0))
11794 : : {
11795 : 27048466 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
11796 : 33217523 : switch (gimple_assign_rhs_code (_a1))
11797 : : {
11798 : 25428 : case VIEW_CONVERT_EXPR:
11799 : 25428 : {
11800 : 25428 : tree _q20 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 0);
11801 : 25428 : if ((TREE_CODE (_q20) == SSA_NAME
11802 : 25428 : || is_gimple_min_invariant (_q20)))
11803 : : {
11804 : 24815 : _q20 = do_valueize (valueize, _q20);
11805 : 24815 : if (gimple_zero_one_valued_p (_q20, valueize))
11806 : : {
11807 : 3265 : if (integer_zerop (_p1))
11808 : : {
11809 : 568 : {
11810 : 568 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q20 };
11811 : 568 : if (gimple_simplify_236 (res_op, seq, valueize, type, captures, EQ_EXPR))
11812 : 568 : return true;
11813 : : }
11814 : : }
11815 : : }
11816 : : }
11817 : : break;
11818 : : }
11819 : 1252321 : case BIT_AND_EXPR:
11820 : 1252321 : {
11821 : 1252321 : tree _q20 = gimple_assign_rhs1 (_a1);
11822 : 1252321 : _q20 = do_valueize (valueize, _q20);
11823 : 1252321 : tree _q21 = gimple_assign_rhs2 (_a1);
11824 : 1252321 : _q21 = do_valueize (valueize, _q21);
11825 : 1252321 : if (tree_swap_operands_p (_q20, _q21))
11826 : 6777 : std::swap (_q20, _q21);
11827 : 1252321 : if (gimple_truth_valued_p (_q20, valueize))
11828 : : {
11829 : 483 : if (gimple_truth_valued_p (_q21, valueize))
11830 : : {
11831 : 447 : switch (TREE_CODE (_p1))
11832 : : {
11833 : 10 : case SSA_NAME:
11834 : 10 : if (gimple *_d2 = get_def (valueize, _p1))
11835 : : {
11836 : 10 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11837 : 10 : switch (gimple_assign_rhs_code (_a2))
11838 : : {
11839 : 2 : case BIT_XOR_EXPR:
11840 : 2 : {
11841 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
11842 : 2 : _q50 = do_valueize (valueize, _q50);
11843 : 2 : tree _q51 = gimple_assign_rhs2 (_a2);
11844 : 2 : _q51 = do_valueize (valueize, _q51);
11845 : 2 : if (tree_swap_operands_p (_q50, _q51))
11846 : 0 : std::swap (_q50, _q51);
11847 : 2 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11848 : : {
11849 : 2 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11850 : : {
11851 : 2 : {
11852 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11853 : 2 : gimple_seq *lseq = seq;
11854 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2392;
11855 : 2 : {
11856 : 2 : res_op->set_op (BIT_NOT_EXPR, type, 1);
11857 : 2 : {
11858 : 2 : tree _o1[2], _r1;
11859 : 2 : _o1[0] = captures[0];
11860 : 2 : _o1[1] = captures[1];
11861 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11862 : 2 : tem_op.resimplify (lseq, valueize);
11863 : 2 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
11864 : 2 : if (!_r1) goto next_after_fail2392;
11865 : 1 : res_op->ops[0] = _r1;
11866 : : }
11867 : 1 : res_op->resimplify (lseq, valueize);
11868 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1057, __FILE__, __LINE__, true);
11869 : 1 : return true;
11870 : : }
11871 : 1 : next_after_fail2392:;
11872 : : }
11873 : : }
11874 : : }
11875 : 1 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11876 : : {
11877 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11878 : : {
11879 : 0 : {
11880 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
11881 : 0 : gimple_seq *lseq = seq;
11882 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2393;
11883 : 0 : {
11884 : 0 : res_op->set_op (BIT_NOT_EXPR, type, 1);
11885 : 0 : {
11886 : 0 : tree _o1[2], _r1;
11887 : 0 : _o1[0] = captures[0];
11888 : 0 : _o1[1] = captures[1];
11889 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11890 : 0 : tem_op.resimplify (lseq, valueize);
11891 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
11892 : 0 : if (!_r1) goto next_after_fail2393;
11893 : 0 : res_op->ops[0] = _r1;
11894 : : }
11895 : 0 : res_op->resimplify (lseq, valueize);
11896 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1057, __FILE__, __LINE__, true);
11897 : 0 : return true;
11898 : : }
11899 : 0 : next_after_fail2393:;
11900 : : }
11901 : : }
11902 : : }
11903 : 80017801 : break;
11904 : : }
11905 : : default:;
11906 : : }
11907 : : }
11908 : : break;
11909 : : default:;
11910 : : }
11911 : : }
11912 : : }
11913 : 80017801 : break;
11914 : : }
11915 : 1232 : case BIT_XOR_EXPR:
11916 : 1232 : {
11917 : 1232 : tree _q20 = gimple_assign_rhs1 (_a1);
11918 : 1232 : _q20 = do_valueize (valueize, _q20);
11919 : 1232 : tree _q21 = gimple_assign_rhs2 (_a1);
11920 : 1232 : _q21 = do_valueize (valueize, _q21);
11921 : 1232 : if (tree_swap_operands_p (_q20, _q21))
11922 : 161 : std::swap (_q20, _q21);
11923 : 1232 : switch (TREE_CODE (_p1))
11924 : : {
11925 : 495 : case SSA_NAME:
11926 : 495 : if (gimple *_d2 = get_def (valueize, _p1))
11927 : : {
11928 : 488 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
11929 : 596 : switch (gimple_assign_rhs_code (_a2))
11930 : : {
11931 : 1 : case BIT_AND_EXPR:
11932 : 1 : {
11933 : 1 : tree _q50 = gimple_assign_rhs1 (_a2);
11934 : 1 : _q50 = do_valueize (valueize, _q50);
11935 : 1 : tree _q51 = gimple_assign_rhs2 (_a2);
11936 : 1 : _q51 = do_valueize (valueize, _q51);
11937 : 1 : if (tree_swap_operands_p (_q50, _q51))
11938 : 0 : std::swap (_q50, _q51);
11939 : 1 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
11940 : : {
11941 : 1 : if (gimple_truth_valued_p (_q50, valueize))
11942 : : {
11943 : 1 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
11944 : : {
11945 : 1 : if (gimple_truth_valued_p (_q51, valueize))
11946 : : {
11947 : 1 : {
11948 : 1 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11949 : 1 : gimple_seq *lseq = seq;
11950 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2394;
11951 : 1 : {
11952 : 1 : res_op->set_op (BIT_NOT_EXPR, type, 1);
11953 : 1 : {
11954 : 1 : tree _o1[2], _r1;
11955 : 1 : _o1[0] = captures[0];
11956 : 1 : _o1[1] = captures[1];
11957 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11958 : 1 : tem_op.resimplify (lseq, valueize);
11959 : 1 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
11960 : 1 : if (!_r1) goto next_after_fail2394;
11961 : 1 : res_op->ops[0] = _r1;
11962 : : }
11963 : 1 : res_op->resimplify (lseq, valueize);
11964 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1057, __FILE__, __LINE__, true);
11965 : 1 : return true;
11966 : : }
11967 : 0 : next_after_fail2394:;
11968 : : }
11969 : : }
11970 : : }
11971 : : }
11972 : : }
11973 : 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
11974 : : {
11975 : 0 : if (gimple_truth_valued_p (_q50, valueize))
11976 : : {
11977 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
11978 : : {
11979 : 0 : if (gimple_truth_valued_p (_q51, valueize))
11980 : : {
11981 : 0 : {
11982 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
11983 : 0 : gimple_seq *lseq = seq;
11984 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2395;
11985 : 0 : {
11986 : 0 : res_op->set_op (BIT_NOT_EXPR, type, 1);
11987 : 0 : {
11988 : 0 : tree _o1[2], _r1;
11989 : 0 : _o1[0] = captures[0];
11990 : 0 : _o1[1] = captures[1];
11991 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
11992 : 0 : tem_op.resimplify (lseq, valueize);
11993 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
11994 : 0 : if (!_r1) goto next_after_fail2395;
11995 : 0 : res_op->ops[0] = _r1;
11996 : : }
11997 : 0 : res_op->resimplify (lseq, valueize);
11998 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1057, __FILE__, __LINE__, true);
11999 : 0 : return true;
12000 : : }
12001 : 0 : next_after_fail2395:;
12002 : : }
12003 : : }
12004 : : }
12005 : : }
12006 : : }
12007 : 80017801 : break;
12008 : : }
12009 : : default:;
12010 : : }
12011 : : }
12012 : : break;
12013 : : default:;
12014 : : }
12015 : 80017801 : break;
12016 : : }
12017 : 2537 : case BIT_NOT_EXPR:
12018 : 2537 : {
12019 : 2537 : tree _q20 = gimple_assign_rhs1 (_a1);
12020 : 2537 : _q20 = do_valueize (valueize, _q20);
12021 : 2537 : if (gimple_truth_valued_p (_q20, valueize))
12022 : : {
12023 : 1809 : if (gimple_truth_valued_p (_p1, valueize))
12024 : : {
12025 : 1742 : {
12026 : 1742 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
12027 : 1742 : if (gimple_simplify_235 (res_op, seq, valueize, type, captures))
12028 : 1742 : return true;
12029 : : }
12030 : : }
12031 : : }
12032 : : break;
12033 : : }
12034 : 90683 : case MULT_EXPR:
12035 : 90683 : {
12036 : 90683 : tree _q20 = gimple_assign_rhs1 (_a1);
12037 : 90683 : _q20 = do_valueize (valueize, _q20);
12038 : 90683 : tree _q21 = gimple_assign_rhs2 (_a1);
12039 : 90683 : _q21 = do_valueize (valueize, _q21);
12040 : 90683 : if (tree_swap_operands_p (_q20, _q21))
12041 : 461 : std::swap (_q20, _q21);
12042 : 90683 : switch (TREE_CODE (_p1))
12043 : : {
12044 : 49838 : case SSA_NAME:
12045 : 49838 : if (gimple *_d2 = get_def (valueize, _p1))
12046 : : {
12047 : 48593 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12048 : 45993 : switch (gimple_assign_rhs_code (_a2))
12049 : : {
12050 : 772 : case MULT_EXPR:
12051 : 772 : {
12052 : 772 : tree _q50 = gimple_assign_rhs1 (_a2);
12053 : 772 : _q50 = do_valueize (valueize, _q50);
12054 : 772 : tree _q51 = gimple_assign_rhs2 (_a2);
12055 : 772 : _q51 = do_valueize (valueize, _q51);
12056 : 772 : if (tree_swap_operands_p (_q50, _q51))
12057 : 11 : std::swap (_q50, _q51);
12058 : 772 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
12059 : : {
12060 : 602 : {
12061 : 602 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
12062 : 602 : if (gimple_simplify_237 (res_op, seq, valueize, type, captures, EQ_EXPR))
12063 : 34 : return true;
12064 : : }
12065 : : }
12066 : 738 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
12067 : : {
12068 : 0 : {
12069 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
12070 : 0 : if (gimple_simplify_237 (res_op, seq, valueize, type, captures, EQ_EXPR))
12071 : 0 : return true;
12072 : : }
12073 : : }
12074 : 738 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
12075 : : {
12076 : 0 : {
12077 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
12078 : 0 : if (gimple_simplify_237 (res_op, seq, valueize, type, captures, EQ_EXPR))
12079 : 0 : return true;
12080 : : }
12081 : : }
12082 : 738 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
12083 : : {
12084 : 99 : {
12085 : 99 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
12086 : 99 : if (gimple_simplify_237 (res_op, seq, valueize, type, captures, EQ_EXPR))
12087 : 4 : return true;
12088 : : }
12089 : : }
12090 : 90645 : break;
12091 : : }
12092 : : default:;
12093 : : }
12094 : : }
12095 : : break;
12096 : 90645 : default:;
12097 : : }
12098 : 90645 : switch (TREE_CODE (_q21))
12099 : : {
12100 : 73966 : case INTEGER_CST:
12101 : 73966 : {
12102 : 73966 : switch (TREE_CODE (_p1))
12103 : : {
12104 : 47138 : case SSA_NAME:
12105 : 47138 : if (gimple *_d2 = get_def (valueize, _p1))
12106 : : {
12107 : 45996 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12108 : 44548 : switch (gimple_assign_rhs_code (_a2))
12109 : : {
12110 : 603 : case MULT_EXPR:
12111 : 603 : {
12112 : 603 : tree _q50 = gimple_assign_rhs1 (_a2);
12113 : 603 : _q50 = do_valueize (valueize, _q50);
12114 : 603 : tree _q51 = gimple_assign_rhs2 (_a2);
12115 : 603 : _q51 = do_valueize (valueize, _q51);
12116 : 603 : if (tree_swap_operands_p (_q50, _q51))
12117 : 0 : std::swap (_q50, _q51);
12118 : 603 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
12119 : : {
12120 : 455 : {
12121 : 455 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
12122 : 455 : if (gimple_simplify_238 (res_op, seq, valueize, type, captures, EQ_EXPR))
12123 : 14 : return true;
12124 : : }
12125 : : }
12126 : 80017801 : break;
12127 : : }
12128 : : default:;
12129 : : }
12130 : : }
12131 : : break;
12132 : : default:;
12133 : : }
12134 : : break;
12135 : : }
12136 : : default:;
12137 : : }
12138 : 80017801 : break;
12139 : : }
12140 : 780419 : CASE_CONVERT:
12141 : 780419 : {
12142 : 780419 : tree _q20 = gimple_assign_rhs1 (_a1);
12143 : 780419 : _q20 = do_valueize (valueize, _q20);
12144 : 780419 : switch (TREE_CODE (_q20))
12145 : : {
12146 : 767442 : case SSA_NAME:
12147 : 767442 : if (gimple *_d2 = get_def (valueize, _q20))
12148 : : {
12149 : 755878 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12150 : 889127 : switch (gimple_assign_rhs_code (_a2))
12151 : : {
12152 : 86133 : case EXACT_DIV_EXPR:
12153 : 86133 : {
12154 : 86133 : tree _q30 = gimple_assign_rhs1 (_a2);
12155 : 86133 : _q30 = do_valueize (valueize, _q30);
12156 : 86133 : tree _q31 = gimple_assign_rhs2 (_a2);
12157 : 86133 : _q31 = do_valueize (valueize, _q31);
12158 : 86133 : switch (TREE_CODE (_q31))
12159 : : {
12160 : 86133 : case INTEGER_CST:
12161 : 86133 : {
12162 : 86133 : switch (TREE_CODE (_p1))
12163 : : {
12164 : 1722 : case SSA_NAME:
12165 : 1722 : if (gimple *_d3 = get_def (valueize, _p1))
12166 : : {
12167 : 1615 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
12168 : 1564 : switch (gimple_assign_rhs_code (_a3))
12169 : : {
12170 : 168 : CASE_CONVERT:
12171 : 168 : {
12172 : 168 : tree _q60 = gimple_assign_rhs1 (_a3);
12173 : 168 : _q60 = do_valueize (valueize, _q60);
12174 : 168 : switch (TREE_CODE (_q60))
12175 : : {
12176 : 168 : case SSA_NAME:
12177 : 168 : if (gimple *_d4 = get_def (valueize, _q60))
12178 : : {
12179 : 168 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
12180 : 168 : switch (gimple_assign_rhs_code (_a4))
12181 : : {
12182 : 168 : case EXACT_DIV_EXPR:
12183 : 168 : {
12184 : 168 : tree _q70 = gimple_assign_rhs1 (_a4);
12185 : 168 : _q70 = do_valueize (valueize, _q70);
12186 : 168 : tree _q71 = gimple_assign_rhs2 (_a4);
12187 : 168 : _q71 = do_valueize (valueize, _q71);
12188 : 168 : if ((_q71 == _q31 && ! TREE_SIDE_EFFECTS (_q71)) || (operand_equal_p (_q71, _q31, 0) && types_match (_q71, _q31)))
12189 : : {
12190 : 168 : {
12191 : 168 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q70 };
12192 : 168 : if (gimple_simplify_239 (res_op, seq, valueize, type, captures, EQ_EXPR))
12193 : 168 : return true;
12194 : : }
12195 : : }
12196 : : break;
12197 : : }
12198 : : default:;
12199 : : }
12200 : : }
12201 : : break;
12202 : : default:;
12203 : : }
12204 : : break;
12205 : : }
12206 : : default:;
12207 : : }
12208 : : }
12209 : : break;
12210 : : default:;
12211 : : }
12212 : : break;
12213 : : }
12214 : : default:;
12215 : : }
12216 : : break;
12217 : : }
12218 : : default:;
12219 : : }
12220 : : }
12221 : : break;
12222 : 780251 : default:;
12223 : : }
12224 : 780251 : switch (TREE_CODE (_p1))
12225 : : {
12226 : 185209 : case SSA_NAME:
12227 : 185209 : if (gimple *_d2 = get_def (valueize, _p1))
12228 : : {
12229 : 176072 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12230 : 188531 : switch (gimple_assign_rhs_code (_a2))
12231 : : {
12232 : 32824 : case PLUS_EXPR:
12233 : 32824 : {
12234 : 32824 : tree _q40 = gimple_assign_rhs1 (_a2);
12235 : 32824 : _q40 = do_valueize (valueize, _q40);
12236 : 32824 : tree _q41 = gimple_assign_rhs2 (_a2);
12237 : 32824 : _q41 = do_valueize (valueize, _q41);
12238 : 32824 : if (tree_swap_operands_p (_q40, _q41))
12239 : 35 : std::swap (_q40, _q41);
12240 : 32824 : switch (TREE_CODE (_q41))
12241 : : {
12242 : 552 : case SSA_NAME:
12243 : 552 : if (gimple *_d3 = get_def (valueize, _q41))
12244 : : {
12245 : 530 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
12246 : 448 : switch (gimple_assign_rhs_code (_a3))
12247 : : {
12248 : 196 : CASE_CONVERT:
12249 : 196 : {
12250 : 196 : tree _q60 = gimple_assign_rhs1 (_a3);
12251 : 196 : _q60 = do_valueize (valueize, _q60);
12252 : 196 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
12253 : : {
12254 : 3 : {
12255 : 3 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
12256 : 3 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12257 : 0 : return true;
12258 : : }
12259 : : }
12260 : : break;
12261 : : }
12262 : : default:;
12263 : : }
12264 : : }
12265 : : break;
12266 : 32824 : default:;
12267 : : }
12268 : 32824 : switch (TREE_CODE (_q40))
12269 : : {
12270 : 32824 : case SSA_NAME:
12271 : 32824 : if (gimple *_d3 = get_def (valueize, _q40))
12272 : : {
12273 : 29950 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
12274 : 33768 : switch (gimple_assign_rhs_code (_a3))
12275 : : {
12276 : 1596 : CASE_CONVERT:
12277 : 1596 : {
12278 : 1596 : tree _q50 = gimple_assign_rhs1 (_a3);
12279 : 1596 : _q50 = do_valueize (valueize, _q50);
12280 : 1596 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
12281 : : {
12282 : 8 : {
12283 : 8 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
12284 : 8 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12285 : 7 : return true;
12286 : : }
12287 : : }
12288 : : break;
12289 : : }
12290 : : default:;
12291 : : }
12292 : : }
12293 : : break;
12294 : 32817 : default:;
12295 : : }
12296 : 32817 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
12297 : : {
12298 : 0 : {
12299 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q40, _q20 };
12300 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12301 : 0 : return true;
12302 : : }
12303 : : }
12304 : 32817 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
12305 : : {
12306 : 0 : {
12307 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q41, _q20 };
12308 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12309 : 0 : return true;
12310 : : }
12311 : : }
12312 : 780244 : break;
12313 : : }
12314 : : default:;
12315 : : }
12316 : : }
12317 : : break;
12318 : 780244 : default:;
12319 : : }
12320 : 780244 : {
12321 : 780244 : tree _p1_pops[1];
12322 : 780244 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
12323 : : {
12324 : 31434 : tree _q40 = _p1_pops[0];
12325 : 31434 : switch (TREE_CODE (_q40))
12326 : : {
12327 : 13882 : case SSA_NAME:
12328 : 13882 : if (gimple *_d2 = get_def (valueize, _q40))
12329 : : {
12330 : 13765 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12331 : 19654 : switch (gimple_assign_rhs_code (_a2))
12332 : : {
12333 : 844 : case PLUS_EXPR:
12334 : 844 : {
12335 : 844 : tree _q50 = gimple_assign_rhs1 (_a2);
12336 : 844 : _q50 = do_valueize (valueize, _q50);
12337 : 844 : tree _q51 = gimple_assign_rhs2 (_a2);
12338 : 844 : _q51 = do_valueize (valueize, _q51);
12339 : 844 : if (tree_swap_operands_p (_q50, _q51))
12340 : 13 : std::swap (_q50, _q51);
12341 : 844 : switch (TREE_CODE (_q51))
12342 : : {
12343 : 657 : case SSA_NAME:
12344 : 657 : if (gimple *_d3 = get_def (valueize, _q51))
12345 : : {
12346 : 643 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
12347 : 635 : switch (gimple_assign_rhs_code (_a3))
12348 : : {
12349 : 309 : CASE_CONVERT:
12350 : 309 : {
12351 : 309 : tree _q70 = gimple_assign_rhs1 (_a3);
12352 : 309 : _q70 = do_valueize (valueize, _q70);
12353 : 309 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
12354 : : {
12355 : 0 : {
12356 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
12357 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
12358 : 0 : return true;
12359 : : }
12360 : : }
12361 : : break;
12362 : : }
12363 : : default:;
12364 : : }
12365 : : }
12366 : : break;
12367 : 844 : default:;
12368 : : }
12369 : 844 : switch (TREE_CODE (_q50))
12370 : : {
12371 : 844 : case SSA_NAME:
12372 : 844 : if (gimple *_d3 = get_def (valueize, _q50))
12373 : : {
12374 : 775 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
12375 : 763 : switch (gimple_assign_rhs_code (_a3))
12376 : : {
12377 : 66 : CASE_CONVERT:
12378 : 66 : {
12379 : 66 : tree _q60 = gimple_assign_rhs1 (_a3);
12380 : 66 : _q60 = do_valueize (valueize, _q60);
12381 : 66 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
12382 : : {
12383 : 0 : {
12384 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
12385 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
12386 : 0 : return true;
12387 : : }
12388 : : }
12389 : : break;
12390 : : }
12391 : : default:;
12392 : : }
12393 : : }
12394 : : break;
12395 : 844 : default:;
12396 : : }
12397 : 844 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
12398 : : {
12399 : 0 : {
12400 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q50, _q20 };
12401 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
12402 : 0 : return true;
12403 : : }
12404 : : }
12405 : 844 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
12406 : : {
12407 : 0 : {
12408 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q51, _q20 };
12409 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
12410 : 0 : return true;
12411 : : }
12412 : : }
12413 : 780244 : break;
12414 : : }
12415 : : default:;
12416 : : }
12417 : : }
12418 : : break;
12419 : : default:;
12420 : : }
12421 : : }
12422 : : }
12423 : 780244 : break;
12424 : : }
12425 : 48042 : case EXACT_DIV_EXPR:
12426 : 48042 : {
12427 : 48042 : tree _q20 = gimple_assign_rhs1 (_a1);
12428 : 48042 : _q20 = do_valueize (valueize, _q20);
12429 : 48042 : tree _q21 = gimple_assign_rhs2 (_a1);
12430 : 48042 : _q21 = do_valueize (valueize, _q21);
12431 : 48042 : switch (TREE_CODE (_q21))
12432 : : {
12433 : 48042 : case INTEGER_CST:
12434 : 48042 : {
12435 : 48042 : switch (TREE_CODE (_p1))
12436 : : {
12437 : 22139 : case SSA_NAME:
12438 : 22139 : if (gimple *_d2 = get_def (valueize, _p1))
12439 : : {
12440 : 19989 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12441 : 14130 : switch (gimple_assign_rhs_code (_a2))
12442 : : {
12443 : 16 : case EXACT_DIV_EXPR:
12444 : 16 : {
12445 : 16 : tree _q50 = gimple_assign_rhs1 (_a2);
12446 : 16 : _q50 = do_valueize (valueize, _q50);
12447 : 16 : tree _q51 = gimple_assign_rhs2 (_a2);
12448 : 16 : _q51 = do_valueize (valueize, _q51);
12449 : 16 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
12450 : : {
12451 : 16 : {
12452 : 16 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
12453 : 16 : if (gimple_simplify_239 (res_op, seq, valueize, type, captures, EQ_EXPR))
12454 : 16 : return true;
12455 : : }
12456 : : }
12457 : : break;
12458 : : }
12459 : : default:;
12460 : : }
12461 : : }
12462 : : break;
12463 : : default:;
12464 : : }
12465 : : break;
12466 : : }
12467 : : default:;
12468 : : }
12469 : : break;
12470 : : }
12471 : 12999 : case TRUNC_DIV_EXPR:
12472 : 12999 : {
12473 : 12999 : tree _q20 = gimple_assign_rhs1 (_a1);
12474 : 12999 : _q20 = do_valueize (valueize, _q20);
12475 : 12999 : tree _q21 = gimple_assign_rhs2 (_a1);
12476 : 12999 : _q21 = do_valueize (valueize, _q21);
12477 : 12999 : switch (TREE_CODE (_q21))
12478 : : {
12479 : 9722 : case INTEGER_CST:
12480 : 9722 : {
12481 : 9722 : switch (TREE_CODE (_p1))
12482 : : {
12483 : 4928 : case INTEGER_CST:
12484 : 4928 : {
12485 : 4928 : {
12486 : 4928 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
12487 : 4928 : if (gimple_simplify_241 (res_op, seq, valueize, type, captures, EQ_EXPR))
12488 : 240 : return true;
12489 : : }
12490 : 4688 : break;
12491 : : }
12492 : : default:;
12493 : : }
12494 : : break;
12495 : : }
12496 : : default:;
12497 : : }
12498 : : break;
12499 : : }
12500 : 876210 : case PLUS_EXPR:
12501 : 876210 : {
12502 : 876210 : tree _q20 = gimple_assign_rhs1 (_a1);
12503 : 876210 : _q20 = do_valueize (valueize, _q20);
12504 : 876210 : tree _q21 = gimple_assign_rhs2 (_a1);
12505 : 876210 : _q21 = do_valueize (valueize, _q21);
12506 : 876210 : if (tree_swap_operands_p (_q20, _q21))
12507 : 7144 : std::swap (_q20, _q21);
12508 : 876210 : switch (TREE_CODE (_p1))
12509 : : {
12510 : 274793 : case SSA_NAME:
12511 : 274793 : if (gimple *_d2 = get_def (valueize, _p1))
12512 : : {
12513 : 252138 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12514 : 335258 : switch (gimple_assign_rhs_code (_a2))
12515 : : {
12516 : 69752 : case PLUS_EXPR:
12517 : 69752 : {
12518 : 69752 : tree _q50 = gimple_assign_rhs1 (_a2);
12519 : 69752 : _q50 = do_valueize (valueize, _q50);
12520 : 69752 : tree _q51 = gimple_assign_rhs2 (_a2);
12521 : 69752 : _q51 = do_valueize (valueize, _q51);
12522 : 69752 : if (tree_swap_operands_p (_q50, _q51))
12523 : 250 : std::swap (_q50, _q51);
12524 : 69752 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
12525 : : {
12526 : 10054 : {
12527 : 10054 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
12528 : 20108 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
12529 : 19878 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
12530 : 8498 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
12531 : : )
12532 : : {
12533 : 9824 : gimple_seq *lseq = seq;
12534 : 9824 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2396;
12535 : 9824 : {
12536 : 9824 : res_op->set_op (EQ_EXPR, type, 2);
12537 : 9824 : res_op->ops[0] = captures[0];
12538 : 9824 : res_op->ops[1] = captures[2];
12539 : 9824 : res_op->resimplify (lseq, valueize);
12540 : 9824 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1093, __FILE__, __LINE__, true);
12541 : 9824 : return true;
12542 : : }
12543 : 0 : next_after_fail2396:;
12544 : : }
12545 : : }
12546 : : }
12547 : 59928 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
12548 : : {
12549 : 16 : {
12550 : 16 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
12551 : 32 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
12552 : 32 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
12553 : 10 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
12554 : : )
12555 : : {
12556 : 16 : gimple_seq *lseq = seq;
12557 : 16 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2397;
12558 : 16 : {
12559 : 16 : res_op->set_op (EQ_EXPR, type, 2);
12560 : 16 : res_op->ops[0] = captures[0];
12561 : 16 : res_op->ops[1] = captures[2];
12562 : 16 : res_op->resimplify (lseq, valueize);
12563 : 16 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1093, __FILE__, __LINE__, true);
12564 : 16 : return true;
12565 : : }
12566 : 0 : next_after_fail2397:;
12567 : : }
12568 : : }
12569 : : }
12570 : 59912 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
12571 : : {
12572 : 1 : {
12573 : 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q50 };
12574 : 2 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
12575 : 2 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
12576 : 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
12577 : : )
12578 : : {
12579 : 1 : gimple_seq *lseq = seq;
12580 : 1 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2398;
12581 : 1 : {
12582 : 1 : res_op->set_op (EQ_EXPR, type, 2);
12583 : 1 : res_op->ops[0] = captures[0];
12584 : 1 : res_op->ops[1] = captures[2];
12585 : 1 : res_op->resimplify (lseq, valueize);
12586 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1093, __FILE__, __LINE__, true);
12587 : 1 : return true;
12588 : : }
12589 : 0 : next_after_fail2398:;
12590 : : }
12591 : : }
12592 : : }
12593 : 59911 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
12594 : : {
12595 : 172 : {
12596 : 172 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q20, _q51 };
12597 : 344 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
12598 : 212 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
12599 : 36 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
12600 : : )
12601 : : {
12602 : 40 : gimple_seq *lseq = seq;
12603 : 40 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2399;
12604 : 40 : {
12605 : 40 : res_op->set_op (EQ_EXPR, type, 2);
12606 : 40 : res_op->ops[0] = captures[0];
12607 : 40 : res_op->ops[1] = captures[2];
12608 : 40 : res_op->resimplify (lseq, valueize);
12609 : 40 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1093, __FILE__, __LINE__, true);
12610 : 40 : return true;
12611 : : }
12612 : 0 : next_after_fail2399:;
12613 : : }
12614 : : }
12615 : : }
12616 : 866329 : break;
12617 : : }
12618 : : default:;
12619 : : }
12620 : : }
12621 : : break;
12622 : 866329 : default:;
12623 : : }
12624 : 866329 : switch (TREE_CODE (_q21))
12625 : : {
12626 : 124362 : case SSA_NAME:
12627 : 124362 : if (gimple *_d2 = get_def (valueize, _q21))
12628 : : {
12629 : 121910 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12630 : 108023 : switch (gimple_assign_rhs_code (_a2))
12631 : : {
12632 : 45056 : CASE_CONVERT:
12633 : 45056 : {
12634 : 45056 : tree _q40 = gimple_assign_rhs1 (_a2);
12635 : 45056 : _q40 = do_valueize (valueize, _q40);
12636 : 45056 : switch (TREE_CODE (_p1))
12637 : : {
12638 : 3668 : case SSA_NAME:
12639 : 3668 : if (gimple *_d3 = get_def (valueize, _p1))
12640 : : {
12641 : 3212 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
12642 : 2843 : switch (gimple_assign_rhs_code (_a3))
12643 : : {
12644 : 384 : CASE_CONVERT:
12645 : 384 : {
12646 : 384 : tree _q60 = gimple_assign_rhs1 (_a3);
12647 : 384 : _q60 = do_valueize (valueize, _q60);
12648 : 384 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
12649 : : {
12650 : 17 : {
12651 : 17 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
12652 : 17 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12653 : 13 : return true;
12654 : : }
12655 : : }
12656 : : break;
12657 : : }
12658 : : default:;
12659 : : }
12660 : : }
12661 : : break;
12662 : : default:;
12663 : : }
12664 : : break;
12665 : : }
12666 : : default:;
12667 : : }
12668 : : }
12669 : : break;
12670 : 866316 : default:;
12671 : : }
12672 : 866316 : switch (TREE_CODE (_q20))
12673 : : {
12674 : 866316 : case SSA_NAME:
12675 : 866316 : if (gimple *_d2 = get_def (valueize, _q20))
12676 : : {
12677 : 846465 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12678 : 698593 : switch (gimple_assign_rhs_code (_a2))
12679 : : {
12680 : 78285 : CASE_CONVERT:
12681 : 78285 : {
12682 : 78285 : tree _q30 = gimple_assign_rhs1 (_a2);
12683 : 78285 : _q30 = do_valueize (valueize, _q30);
12684 : 78285 : switch (TREE_CODE (_p1))
12685 : : {
12686 : 38349 : case SSA_NAME:
12687 : 38349 : if (gimple *_d3 = get_def (valueize, _p1))
12688 : : {
12689 : 26322 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
12690 : 25257 : switch (gimple_assign_rhs_code (_a3))
12691 : : {
12692 : 2023 : CASE_CONVERT:
12693 : 2023 : {
12694 : 2023 : tree _q60 = gimple_assign_rhs1 (_a3);
12695 : 2023 : _q60 = do_valueize (valueize, _q60);
12696 : 2023 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
12697 : : {
12698 : 26 : {
12699 : 26 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
12700 : 26 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12701 : 13 : return true;
12702 : : }
12703 : : }
12704 : : break;
12705 : : }
12706 : : default:;
12707 : : }
12708 : : }
12709 : : break;
12710 : 78272 : default:;
12711 : : }
12712 : 78272 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
12713 : : {
12714 : 0 : {
12715 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q30 };
12716 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12717 : 0 : return true;
12718 : : }
12719 : : }
12720 : : break;
12721 : : }
12722 : : default:;
12723 : : }
12724 : : }
12725 : : break;
12726 : 866303 : default:;
12727 : : }
12728 : 866303 : switch (TREE_CODE (_q21))
12729 : : {
12730 : 124349 : case SSA_NAME:
12731 : 124349 : if (gimple *_d2 = get_def (valueize, _q21))
12732 : : {
12733 : 121897 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12734 : 108010 : switch (gimple_assign_rhs_code (_a2))
12735 : : {
12736 : 45043 : CASE_CONVERT:
12737 : 45043 : {
12738 : 45043 : tree _q40 = gimple_assign_rhs1 (_a2);
12739 : 45043 : _q40 = do_valueize (valueize, _q40);
12740 : 45043 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
12741 : : {
12742 : 0 : {
12743 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40 };
12744 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12745 : 0 : return true;
12746 : : }
12747 : : }
12748 : : break;
12749 : : }
12750 : : default:;
12751 : : }
12752 : : }
12753 : : break;
12754 : 866303 : default:;
12755 : : }
12756 : 866303 : switch (TREE_CODE (_p1))
12757 : : {
12758 : 264886 : case SSA_NAME:
12759 : 264886 : if (gimple *_d2 = get_def (valueize, _p1))
12760 : : {
12761 : 242231 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12762 : 325351 : switch (gimple_assign_rhs_code (_a2))
12763 : : {
12764 : 18748 : CASE_CONVERT:
12765 : 18748 : {
12766 : 18748 : tree _q50 = gimple_assign_rhs1 (_a2);
12767 : 18748 : _q50 = do_valueize (valueize, _q50);
12768 : 18748 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
12769 : : {
12770 : 0 : {
12771 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
12772 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12773 : 0 : return true;
12774 : : }
12775 : : }
12776 : 18748 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
12777 : : {
12778 : 0 : {
12779 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
12780 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12781 : 0 : return true;
12782 : : }
12783 : : }
12784 : : break;
12785 : : }
12786 : : default:;
12787 : : }
12788 : : }
12789 : : break;
12790 : 866303 : default:;
12791 : : }
12792 : 866303 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
12793 : : {
12794 : 56398 : {
12795 : 56398 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
12796 : 56398 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12797 : 4216 : return true;
12798 : : }
12799 : : }
12800 : 862087 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
12801 : : {
12802 : 215 : {
12803 : 215 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q21, _q20 };
12804 : 215 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
12805 : 178 : return true;
12806 : : }
12807 : : }
12808 : 80017801 : break;
12809 : : }
12810 : 142281 : case POINTER_PLUS_EXPR:
12811 : 142281 : {
12812 : 142281 : tree _q20 = gimple_assign_rhs1 (_a1);
12813 : 142281 : _q20 = do_valueize (valueize, _q20);
12814 : 142281 : tree _q21 = gimple_assign_rhs2 (_a1);
12815 : 142281 : _q21 = do_valueize (valueize, _q21);
12816 : 142281 : switch (TREE_CODE (_p1))
12817 : : {
12818 : 107026 : case SSA_NAME:
12819 : 107026 : if (gimple *_d2 = get_def (valueize, _p1))
12820 : : {
12821 : 105368 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12822 : 129978 : switch (gimple_assign_rhs_code (_a2))
12823 : : {
12824 : 10380 : case POINTER_PLUS_EXPR:
12825 : 10380 : {
12826 : 10380 : tree _q50 = gimple_assign_rhs1 (_a2);
12827 : 10380 : _q50 = do_valueize (valueize, _q50);
12828 : 10380 : tree _q51 = gimple_assign_rhs2 (_a2);
12829 : 10380 : _q51 = do_valueize (valueize, _q51);
12830 : 10380 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
12831 : : {
12832 : 1575 : {
12833 : 1575 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
12834 : 1575 : if (gimple_simplify_242 (res_op, seq, valueize, type, captures, EQ_EXPR))
12835 : 1575 : return true;
12836 : : }
12837 : : }
12838 : : break;
12839 : : }
12840 : : default:;
12841 : : }
12842 : : }
12843 : : break;
12844 : 140706 : default:;
12845 : : }
12846 : 140706 : switch (TREE_CODE (_q20))
12847 : : {
12848 : 135102 : case SSA_NAME:
12849 : 135102 : if (gimple *_d2 = get_def (valueize, _q20))
12850 : : {
12851 : 130778 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12852 : 158187 : switch (gimple_assign_rhs_code (_a2))
12853 : : {
12854 : 4114 : CASE_CONVERT:
12855 : 4114 : {
12856 : 4114 : tree _q30 = gimple_assign_rhs1 (_a2);
12857 : 4114 : _q30 = do_valueize (valueize, _q30);
12858 : 4114 : switch (TREE_CODE (_p1))
12859 : : {
12860 : 545 : case SSA_NAME:
12861 : 545 : if (gimple *_d3 = get_def (valueize, _p1))
12862 : : {
12863 : 545 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
12864 : 359 : switch (gimple_assign_rhs_code (_a3))
12865 : : {
12866 : 37 : CASE_CONVERT:
12867 : 37 : {
12868 : 37 : tree _q60 = gimple_assign_rhs1 (_a3);
12869 : 37 : _q60 = do_valueize (valueize, _q60);
12870 : 37 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
12871 : : {
12872 : 0 : {
12873 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
12874 : 0 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, EQ_EXPR))
12875 : 0 : return true;
12876 : : }
12877 : : }
12878 : : break;
12879 : : }
12880 : : default:;
12881 : : }
12882 : : }
12883 : : break;
12884 : 4114 : default:;
12885 : : }
12886 : 4114 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
12887 : : {
12888 : 0 : {
12889 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q30, _q21 };
12890 : 0 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, EQ_EXPR))
12891 : 0 : return true;
12892 : : }
12893 : : }
12894 : : break;
12895 : : }
12896 : : default:;
12897 : : }
12898 : : }
12899 : : break;
12900 : 140706 : default:;
12901 : : }
12902 : 140706 : switch (TREE_CODE (_p1))
12903 : : {
12904 : 105451 : case SSA_NAME:
12905 : 105451 : if (gimple *_d2 = get_def (valueize, _p1))
12906 : : {
12907 : 103793 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12908 : 128403 : switch (gimple_assign_rhs_code (_a2))
12909 : : {
12910 : 830 : CASE_CONVERT:
12911 : 830 : {
12912 : 830 : tree _q50 = gimple_assign_rhs1 (_a2);
12913 : 830 : _q50 = do_valueize (valueize, _q50);
12914 : 830 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
12915 : : {
12916 : 0 : {
12917 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
12918 : 0 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, EQ_EXPR))
12919 : 0 : return true;
12920 : : }
12921 : : }
12922 : : break;
12923 : : }
12924 : : default:;
12925 : : }
12926 : : }
12927 : : break;
12928 : 140706 : default:;
12929 : : }
12930 : 140706 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
12931 : : {
12932 : 2713 : {
12933 : 2713 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21 };
12934 : 2713 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, EQ_EXPR))
12935 : 945 : return true;
12936 : : }
12937 : : }
12938 : : break;
12939 : : }
12940 : 249330 : case MINUS_EXPR:
12941 : 249330 : {
12942 : 249330 : tree _q20 = gimple_assign_rhs1 (_a1);
12943 : 249330 : _q20 = do_valueize (valueize, _q20);
12944 : 249330 : tree _q21 = gimple_assign_rhs2 (_a1);
12945 : 249330 : _q21 = do_valueize (valueize, _q21);
12946 : 249330 : switch (TREE_CODE (_p1))
12947 : : {
12948 : 50800 : case SSA_NAME:
12949 : 50800 : if (gimple *_d2 = get_def (valueize, _p1))
12950 : : {
12951 : 48790 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
12952 : 52351 : switch (gimple_assign_rhs_code (_a2))
12953 : : {
12954 : 1164 : case MINUS_EXPR:
12955 : 1164 : {
12956 : 1164 : tree _q50 = gimple_assign_rhs1 (_a2);
12957 : 1164 : _q50 = do_valueize (valueize, _q50);
12958 : 1164 : tree _q51 = gimple_assign_rhs2 (_a2);
12959 : 1164 : _q51 = do_valueize (valueize, _q51);
12960 : 1164 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
12961 : : {
12962 : 272 : {
12963 : 272 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
12964 : 544 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
12965 : 499 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[0]))
12966 : 204 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[0])))
12967 : : )
12968 : : {
12969 : 227 : gimple_seq *lseq = seq;
12970 : 227 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2400;
12971 : 227 : {
12972 : 227 : res_op->set_op (EQ_EXPR, type, 2);
12973 : 227 : res_op->ops[0] = captures[0];
12974 : 227 : res_op->ops[1] = captures[2];
12975 : 227 : res_op->resimplify (lseq, valueize);
12976 : 227 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1094, __FILE__, __LINE__, true);
12977 : 227 : return true;
12978 : : }
12979 : 0 : next_after_fail2400:;
12980 : : }
12981 : : }
12982 : : }
12983 : 937 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
12984 : : {
12985 : 45 : {
12986 : 45 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q51 };
12987 : 90 : if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
12988 : 45 : && (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1]))
12989 : 0 : || TYPE_OVERFLOW_WRAPS (TREE_TYPE (captures[1])))
12990 : : )
12991 : : {
12992 : 0 : gimple_seq *lseq = seq;
12993 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2401;
12994 : 0 : {
12995 : 0 : res_op->set_op (EQ_EXPR, type, 2);
12996 : 0 : res_op->ops[0] = captures[2];
12997 : 0 : res_op->ops[1] = captures[1];
12998 : 0 : res_op->resimplify (lseq, valueize);
12999 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1095, __FILE__, __LINE__, true);
13000 : 0 : return true;
13001 : : }
13002 : 0 : next_after_fail2401:;
13003 : : }
13004 : : }
13005 : : }
13006 : : break;
13007 : : }
13008 : : default:;
13009 : : }
13010 : : }
13011 : : break;
13012 : 249103 : default:;
13013 : : }
13014 : 249103 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
13015 : : {
13016 : 147 : {
13017 : 147 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p0, _q21 };
13018 : 147 : if (gimple_simplify_244 (res_op, seq, valueize, type, captures, EQ_EXPR))
13019 : 51 : return true;
13020 : : }
13021 : : }
13022 : : break;
13023 : : }
13024 : 115480 : case POINTER_DIFF_EXPR:
13025 : 115480 : {
13026 : 115480 : tree _q20 = gimple_assign_rhs1 (_a1);
13027 : 115480 : _q20 = do_valueize (valueize, _q20);
13028 : 115480 : tree _q21 = gimple_assign_rhs2 (_a1);
13029 : 115480 : _q21 = do_valueize (valueize, _q21);
13030 : 115480 : switch (TREE_CODE (_p1))
13031 : : {
13032 : 31664 : case SSA_NAME:
13033 : 31664 : if (gimple *_d2 = get_def (valueize, _p1))
13034 : : {
13035 : 31620 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13036 : 31231 : switch (gimple_assign_rhs_code (_a2))
13037 : : {
13038 : 3628 : case POINTER_DIFF_EXPR:
13039 : 3628 : {
13040 : 3628 : tree _q50 = gimple_assign_rhs1 (_a2);
13041 : 3628 : _q50 = do_valueize (valueize, _q50);
13042 : 3628 : tree _q51 = gimple_assign_rhs2 (_a2);
13043 : 3628 : _q51 = do_valueize (valueize, _q51);
13044 : 3628 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
13045 : : {
13046 : 386 : {
13047 : 386 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q50 };
13048 : 386 : if (gimple_simplify_245 (res_op, seq, valueize, type, captures, EQ_EXPR))
13049 : 386 : return true;
13050 : : }
13051 : : }
13052 : 3242 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
13053 : : {
13054 : 0 : {
13055 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q51 };
13056 : 0 : if (gimple_simplify_246 (res_op, seq, valueize, type, captures, EQ_EXPR))
13057 : 0 : return true;
13058 : : }
13059 : : }
13060 : : break;
13061 : : }
13062 : : default:;
13063 : : }
13064 : : }
13065 : : break;
13066 : : default:;
13067 : : }
13068 : : break;
13069 : : }
13070 : : default:;
13071 : : }
13072 : : }
13073 : : break;
13074 : 80017801 : default:;
13075 : : }
13076 : 80017801 : {
13077 : 80017801 : tree _p0_pops[1];
13078 : 80017801 : if (gimple_logical_inverted_value (_p0, _p0_pops, valueize))
13079 : : {
13080 : 772 : tree _q20 = _p0_pops[0];
13081 : 772 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
13082 : : {
13083 : 0 : if (gimple_truth_valued_p (_p1, valueize))
13084 : : {
13085 : 0 : {
13086 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
13087 : 0 : if (gimple_simplify_234 (res_op, seq, valueize, type, captures, EQ_EXPR))
13088 : 0 : return true;
13089 : : }
13090 : : }
13091 : : }
13092 : : }
13093 : : }
13094 : 80017801 : if (gimple_truth_valued_p (_p0, valueize))
13095 : : {
13096 : 270372 : switch (TREE_CODE (_p1))
13097 : : {
13098 : 162636 : case SSA_NAME:
13099 : 162636 : if (gimple *_d1 = get_def (valueize, _p1))
13100 : : {
13101 : 73351 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13102 : 96707 : switch (gimple_assign_rhs_code (_a1))
13103 : : {
13104 : 75 : case BIT_NOT_EXPR:
13105 : 75 : {
13106 : 75 : tree _q30 = gimple_assign_rhs1 (_a1);
13107 : 75 : _q30 = do_valueize (valueize, _q30);
13108 : 75 : if (gimple_truth_valued_p (_q30, valueize))
13109 : : {
13110 : 75 : {
13111 : 75 : tree captures[3] ATTRIBUTE_UNUSED = { _p1, _q30, _p0 };
13112 : 75 : if (gimple_simplify_235 (res_op, seq, valueize, type, captures))
13113 : 75 : return true;
13114 : : }
13115 : : }
13116 : : break;
13117 : : }
13118 : : default:;
13119 : : }
13120 : : }
13121 : : break;
13122 : 270297 : default:;
13123 : : }
13124 : 270297 : {
13125 : 270297 : tree _p1_pops[1];
13126 : 270297 : if (gimple_logical_inverted_value (_p1, _p1_pops, valueize))
13127 : : {
13128 : 235 : tree _q30 = _p1_pops[0];
13129 : 235 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
13130 : : {
13131 : 0 : {
13132 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
13133 : 0 : if (gimple_simplify_234 (res_op, seq, valueize, type, captures, EQ_EXPR))
13134 : 0 : return true;
13135 : : }
13136 : : }
13137 : : }
13138 : : }
13139 : : }
13140 : 80017726 : switch (TREE_CODE (_p1))
13141 : : {
13142 : 13135385 : case SSA_NAME:
13143 : 13135385 : if (gimple *_d1 = get_def (valueize, _p1))
13144 : : {
13145 : 4368317 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13146 : 6441451 : switch (gimple_assign_rhs_code (_a1))
13147 : : {
13148 : 185079 : case PLUS_EXPR:
13149 : 185079 : {
13150 : 185079 : tree _q30 = gimple_assign_rhs1 (_a1);
13151 : 185079 : _q30 = do_valueize (valueize, _q30);
13152 : 185079 : tree _q31 = gimple_assign_rhs2 (_a1);
13153 : 185079 : _q31 = do_valueize (valueize, _q31);
13154 : 185079 : if (tree_swap_operands_p (_q30, _q31))
13155 : 2212 : std::swap (_q30, _q31);
13156 : 185079 : switch (TREE_CODE (_q31))
13157 : : {
13158 : 25757 : case SSA_NAME:
13159 : 25757 : if (gimple *_d2 = get_def (valueize, _q31))
13160 : : {
13161 : 24004 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13162 : 22886 : switch (gimple_assign_rhs_code (_a2))
13163 : : {
13164 : 3925 : CASE_CONVERT:
13165 : 3925 : {
13166 : 3925 : tree _q50 = gimple_assign_rhs1 (_a2);
13167 : 3925 : _q50 = do_valueize (valueize, _q50);
13168 : 3925 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
13169 : : {
13170 : 0 : {
13171 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
13172 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
13173 : 0 : return true;
13174 : : }
13175 : : }
13176 : : break;
13177 : : }
13178 : : default:;
13179 : : }
13180 : : }
13181 : : break;
13182 : 185079 : default:;
13183 : : }
13184 : 185079 : switch (TREE_CODE (_q30))
13185 : : {
13186 : 185079 : case SSA_NAME:
13187 : 185079 : if (gimple *_d2 = get_def (valueize, _q30))
13188 : : {
13189 : 173327 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13190 : 142013 : switch (gimple_assign_rhs_code (_a2))
13191 : : {
13192 : 57385 : CASE_CONVERT:
13193 : 57385 : {
13194 : 57385 : tree _q40 = gimple_assign_rhs1 (_a2);
13195 : 57385 : _q40 = do_valueize (valueize, _q40);
13196 : 57385 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
13197 : : {
13198 : 0 : {
13199 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
13200 : 0 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
13201 : 0 : return true;
13202 : : }
13203 : : }
13204 : : break;
13205 : : }
13206 : : default:;
13207 : : }
13208 : : }
13209 : : break;
13210 : 185079 : default:;
13211 : : }
13212 : 185079 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
13213 : : {
13214 : 15 : {
13215 : 15 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q30, _p0 };
13216 : 15 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
13217 : 15 : return true;
13218 : : }
13219 : : }
13220 : 185064 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
13221 : : {
13222 : 130 : {
13223 : 130 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q31, _p0 };
13224 : 130 : if (gimple_simplify_240 (res_op, seq, valueize, type, captures, EQ_EXPR))
13225 : 36 : return true;
13226 : : }
13227 : : }
13228 : 80017675 : break;
13229 : : }
13230 : : default:;
13231 : : }
13232 : : }
13233 : : break;
13234 : 80017675 : default:;
13235 : : }
13236 : 80017675 : {
13237 : 80017675 : tree _p1_pops[1];
13238 : 80017675 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
13239 : : {
13240 : 169530 : tree _q30 = _p1_pops[0];
13241 : 169530 : switch (TREE_CODE (_q30))
13242 : : {
13243 : 145728 : case SSA_NAME:
13244 : 145728 : if (gimple *_d1 = get_def (valueize, _q30))
13245 : : {
13246 : 143209 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13247 : 187821 : switch (gimple_assign_rhs_code (_a1))
13248 : : {
13249 : 47827 : case PLUS_EXPR:
13250 : 47827 : {
13251 : 47827 : tree _q40 = gimple_assign_rhs1 (_a1);
13252 : 47827 : _q40 = do_valueize (valueize, _q40);
13253 : 47827 : tree _q41 = gimple_assign_rhs2 (_a1);
13254 : 47827 : _q41 = do_valueize (valueize, _q41);
13255 : 47827 : if (tree_swap_operands_p (_q40, _q41))
13256 : 125 : std::swap (_q40, _q41);
13257 : 47827 : switch (TREE_CODE (_q41))
13258 : : {
13259 : 2696 : case SSA_NAME:
13260 : 2696 : if (gimple *_d2 = get_def (valueize, _q41))
13261 : : {
13262 : 2639 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13263 : 2600 : switch (gimple_assign_rhs_code (_a2))
13264 : : {
13265 : 1048 : CASE_CONVERT:
13266 : 1048 : {
13267 : 1048 : tree _q60 = gimple_assign_rhs1 (_a2);
13268 : 1048 : _q60 = do_valueize (valueize, _q60);
13269 : 1048 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
13270 : : {
13271 : 76 : {
13272 : 76 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
13273 : 76 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
13274 : 3 : return true;
13275 : : }
13276 : : }
13277 : : break;
13278 : : }
13279 : : default:;
13280 : : }
13281 : : }
13282 : : break;
13283 : 47824 : default:;
13284 : : }
13285 : 47824 : switch (TREE_CODE (_q40))
13286 : : {
13287 : 47824 : case SSA_NAME:
13288 : 47824 : if (gimple *_d2 = get_def (valueize, _q40))
13289 : : {
13290 : 42442 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13291 : 39965 : switch (gimple_assign_rhs_code (_a2))
13292 : : {
13293 : 36610 : CASE_CONVERT:
13294 : 36610 : {
13295 : 36610 : tree _q50 = gimple_assign_rhs1 (_a2);
13296 : 36610 : _q50 = do_valueize (valueize, _q50);
13297 : 36610 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
13298 : : {
13299 : 110 : {
13300 : 110 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
13301 : 110 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
13302 : 14 : return true;
13303 : : }
13304 : : }
13305 : : break;
13306 : : }
13307 : : default:;
13308 : : }
13309 : : }
13310 : : break;
13311 : 47810 : default:;
13312 : : }
13313 : 47810 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
13314 : : {
13315 : 0 : {
13316 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q40, _p0 };
13317 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
13318 : 0 : return true;
13319 : : }
13320 : : }
13321 : 47810 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
13322 : : {
13323 : 0 : {
13324 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _q41, _p0 };
13325 : 0 : if (gimple_simplify_233 (res_op, seq, valueize, type, captures, EQ_EXPR))
13326 : 0 : return true;
13327 : : }
13328 : : }
13329 : 80017658 : break;
13330 : : }
13331 : : default:;
13332 : : }
13333 : : }
13334 : : break;
13335 : : default:;
13336 : : }
13337 : : }
13338 : : }
13339 : 80017658 : switch (TREE_CODE (_p0))
13340 : : {
13341 : 79172259 : case SSA_NAME:
13342 : 79172259 : if (gimple *_d1 = get_def (valueize, _p0))
13343 : : {
13344 : 27028043 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13345 : 33196499 : switch (gimple_assign_rhs_code (_a1))
13346 : : {
13347 : 780240 : CASE_CONVERT:
13348 : 780240 : {
13349 : 780240 : tree _q20 = gimple_assign_rhs1 (_a1);
13350 : 780240 : _q20 = do_valueize (valueize, _q20);
13351 : 780240 : switch (TREE_CODE (_p1))
13352 : : {
13353 : 185198 : case SSA_NAME:
13354 : 185198 : if (gimple *_d2 = get_def (valueize, _p1))
13355 : : {
13356 : 176061 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13357 : 188520 : switch (gimple_assign_rhs_code (_a2))
13358 : : {
13359 : 422 : case POINTER_PLUS_EXPR:
13360 : 422 : {
13361 : 422 : tree _q40 = gimple_assign_rhs1 (_a2);
13362 : 422 : _q40 = do_valueize (valueize, _q40);
13363 : 422 : tree _q41 = gimple_assign_rhs2 (_a2);
13364 : 422 : _q41 = do_valueize (valueize, _q41);
13365 : 422 : switch (TREE_CODE (_q40))
13366 : : {
13367 : 402 : case SSA_NAME:
13368 : 402 : if (gimple *_d3 = get_def (valueize, _q40))
13369 : : {
13370 : 341 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
13371 : 318 : switch (gimple_assign_rhs_code (_a3))
13372 : : {
13373 : 77 : CASE_CONVERT:
13374 : 77 : {
13375 : 77 : tree _q50 = gimple_assign_rhs1 (_a3);
13376 : 77 : _q50 = do_valueize (valueize, _q50);
13377 : 77 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
13378 : : {
13379 : 0 : {
13380 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
13381 : 0 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, EQ_EXPR))
13382 : 0 : return true;
13383 : : }
13384 : : }
13385 : : break;
13386 : : }
13387 : : default:;
13388 : : }
13389 : : }
13390 : : break;
13391 : 422 : default:;
13392 : : }
13393 : 422 : if ((_q40 == _q20 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _q20, 0) && types_match (_q40, _q20)))
13394 : : {
13395 : 0 : {
13396 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _q20, _q41 };
13397 : 0 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, EQ_EXPR))
13398 : 0 : return true;
13399 : : }
13400 : : }
13401 : : break;
13402 : : }
13403 : : default:;
13404 : : }
13405 : : }
13406 : : break;
13407 : 780240 : default:;
13408 : : }
13409 : 780240 : {
13410 : 780240 : tree _p1_pops[1];
13411 : 780240 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
13412 : : {
13413 : 31434 : tree _q40 = _p1_pops[0];
13414 : 31434 : switch (TREE_CODE (_q40))
13415 : : {
13416 : 13882 : case SSA_NAME:
13417 : 13882 : if (gimple *_d2 = get_def (valueize, _q40))
13418 : : {
13419 : 13765 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13420 : 19654 : switch (gimple_assign_rhs_code (_a2))
13421 : : {
13422 : 0 : case POINTER_PLUS_EXPR:
13423 : 0 : {
13424 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
13425 : 0 : _q50 = do_valueize (valueize, _q50);
13426 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
13427 : 0 : _q51 = do_valueize (valueize, _q51);
13428 : 0 : switch (TREE_CODE (_q50))
13429 : : {
13430 : 0 : case SSA_NAME:
13431 : 0 : if (gimple *_d3 = get_def (valueize, _q50))
13432 : : {
13433 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
13434 : 0 : switch (gimple_assign_rhs_code (_a3))
13435 : : {
13436 : 0 : CASE_CONVERT:
13437 : 0 : {
13438 : 0 : tree _q60 = gimple_assign_rhs1 (_a3);
13439 : 0 : _q60 = do_valueize (valueize, _q60);
13440 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
13441 : : {
13442 : 0 : {
13443 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
13444 : 0 : if (gimple_simplify_247 (res_op, seq, valueize, type, captures, EQ_EXPR))
13445 : 0 : return true;
13446 : : }
13447 : : }
13448 : : break;
13449 : : }
13450 : : default:;
13451 : : }
13452 : : }
13453 : : break;
13454 : 0 : default:;
13455 : : }
13456 : 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
13457 : : {
13458 : 0 : {
13459 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q40, _q20, _q51 };
13460 : 0 : if (gimple_simplify_247 (res_op, seq, valueize, type, captures, EQ_EXPR))
13461 : 0 : return true;
13462 : : }
13463 : : }
13464 : : break;
13465 : : }
13466 : : default:;
13467 : : }
13468 : : }
13469 : : break;
13470 : : default:;
13471 : : }
13472 : : }
13473 : : }
13474 : 780240 : break;
13475 : : }
13476 : : default:;
13477 : : }
13478 : : }
13479 : : break;
13480 : 80017658 : default:;
13481 : : }
13482 : 80017658 : {
13483 : 80017658 : tree _p0_pops[1];
13484 : 80017658 : if (gimple_nop_convert (_p0, _p0_pops, valueize))
13485 : : {
13486 : 460080 : tree _q20 = _p0_pops[0];
13487 : 460080 : switch (TREE_CODE (_q20))
13488 : : {
13489 : 447104 : case SSA_NAME:
13490 : 447104 : if (gimple *_d1 = get_def (valueize, _q20))
13491 : : {
13492 : 442191 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13493 : 454851 : switch (gimple_assign_rhs_code (_a1))
13494 : : {
13495 : 33 : case POINTER_PLUS_EXPR:
13496 : 33 : {
13497 : 33 : tree _q30 = gimple_assign_rhs1 (_a1);
13498 : 33 : _q30 = do_valueize (valueize, _q30);
13499 : 33 : tree _q31 = gimple_assign_rhs2 (_a1);
13500 : 33 : _q31 = do_valueize (valueize, _q31);
13501 : 33 : switch (TREE_CODE (_q30))
13502 : : {
13503 : 33 : case SSA_NAME:
13504 : 33 : if (gimple *_d2 = get_def (valueize, _q30))
13505 : : {
13506 : 33 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13507 : 18 : switch (gimple_assign_rhs_code (_a2))
13508 : : {
13509 : 18 : CASE_CONVERT:
13510 : 18 : {
13511 : 18 : tree _q40 = gimple_assign_rhs1 (_a2);
13512 : 18 : _q40 = do_valueize (valueize, _q40);
13513 : 18 : switch (TREE_CODE (_p1))
13514 : : {
13515 : 0 : case SSA_NAME:
13516 : 0 : if (gimple *_d3 = get_def (valueize, _p1))
13517 : : {
13518 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
13519 : 0 : switch (gimple_assign_rhs_code (_a3))
13520 : : {
13521 : 0 : CASE_CONVERT:
13522 : 0 : {
13523 : 0 : tree _q70 = gimple_assign_rhs1 (_a3);
13524 : 0 : _q70 = do_valueize (valueize, _q70);
13525 : 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
13526 : : {
13527 : 0 : {
13528 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
13529 : 0 : if (gimple_simplify_247 (res_op, seq, valueize, type, captures, EQ_EXPR))
13530 : 0 : return true;
13531 : : }
13532 : : }
13533 : : break;
13534 : : }
13535 : : default:;
13536 : : }
13537 : : }
13538 : : break;
13539 : 18 : default:;
13540 : : }
13541 : 18 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
13542 : : {
13543 : 0 : {
13544 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q40, _q31 };
13545 : 0 : if (gimple_simplify_247 (res_op, seq, valueize, type, captures, EQ_EXPR))
13546 : 0 : return true;
13547 : : }
13548 : : }
13549 : : break;
13550 : : }
13551 : : default:;
13552 : : }
13553 : : }
13554 : : break;
13555 : 33 : default:;
13556 : : }
13557 : 33 : switch (TREE_CODE (_p1))
13558 : : {
13559 : 6 : case SSA_NAME:
13560 : 6 : if (gimple *_d2 = get_def (valueize, _p1))
13561 : : {
13562 : 6 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13563 : 6 : switch (gimple_assign_rhs_code (_a2))
13564 : : {
13565 : 2 : CASE_CONVERT:
13566 : 2 : {
13567 : 2 : tree _q60 = gimple_assign_rhs1 (_a2);
13568 : 2 : _q60 = do_valueize (valueize, _q60);
13569 : 2 : if ((_q60 == _q30 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q30, 0) && types_match (_q60, _q30)))
13570 : : {
13571 : 2 : {
13572 : 2 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
13573 : 2 : if (gimple_simplify_247 (res_op, seq, valueize, type, captures, EQ_EXPR))
13574 : 1 : return true;
13575 : : }
13576 : : }
13577 : : break;
13578 : : }
13579 : : default:;
13580 : : }
13581 : : }
13582 : : break;
13583 : 32 : default:;
13584 : : }
13585 : 32 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
13586 : : {
13587 : 0 : {
13588 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31 };
13589 : 0 : if (gimple_simplify_247 (res_op, seq, valueize, type, captures, EQ_EXPR))
13590 : 0 : return true;
13591 : : }
13592 : : }
13593 : : break;
13594 : : }
13595 : : default:;
13596 : : }
13597 : : }
13598 : : break;
13599 : : default:;
13600 : : }
13601 : : }
13602 : : }
13603 : 80017657 : switch (TREE_CODE (_p1))
13604 : : {
13605 : 13135316 : case SSA_NAME:
13606 : 13135316 : if (gimple *_d1 = get_def (valueize, _p1))
13607 : : {
13608 : 4368248 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13609 : 6441382 : switch (gimple_assign_rhs_code (_a1))
13610 : : {
13611 : 119497 : case POINTER_PLUS_EXPR:
13612 : 119497 : {
13613 : 119497 : tree _q30 = gimple_assign_rhs1 (_a1);
13614 : 119497 : _q30 = do_valueize (valueize, _q30);
13615 : 119497 : tree _q31 = gimple_assign_rhs2 (_a1);
13616 : 119497 : _q31 = do_valueize (valueize, _q31);
13617 : 119497 : switch (TREE_CODE (_q30))
13618 : : {
13619 : 119020 : case SSA_NAME:
13620 : 119020 : if (gimple *_d2 = get_def (valueize, _q30))
13621 : : {
13622 : 113898 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13623 : 121865 : switch (gimple_assign_rhs_code (_a2))
13624 : : {
13625 : 240 : CASE_CONVERT:
13626 : 240 : {
13627 : 240 : tree _q40 = gimple_assign_rhs1 (_a2);
13628 : 240 : _q40 = do_valueize (valueize, _q40);
13629 : 240 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
13630 : : {
13631 : 0 : {
13632 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
13633 : 0 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, EQ_EXPR))
13634 : 0 : return true;
13635 : : }
13636 : : }
13637 : : break;
13638 : : }
13639 : : default:;
13640 : : }
13641 : : }
13642 : : break;
13643 : 119497 : default:;
13644 : : }
13645 : 119497 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
13646 : : {
13647 : 4472 : {
13648 : 4472 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _p1, _p0, _q31 };
13649 : 4472 : if (gimple_simplify_243 (res_op, seq, valueize, type, captures, EQ_EXPR))
13650 : 1437 : return true;
13651 : : }
13652 : : }
13653 : : break;
13654 : : }
13655 : : default:;
13656 : : }
13657 : : }
13658 : : break;
13659 : 80016220 : default:;
13660 : : }
13661 : 80016220 : {
13662 : 80016220 : tree _p1_pops[1];
13663 : 80016220 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
13664 : : {
13665 : 169512 : tree _q30 = _p1_pops[0];
13666 : 169512 : switch (TREE_CODE (_q30))
13667 : : {
13668 : 145710 : case SSA_NAME:
13669 : 145710 : if (gimple *_d1 = get_def (valueize, _q30))
13670 : : {
13671 : 143191 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13672 : 187804 : switch (gimple_assign_rhs_code (_a1))
13673 : : {
13674 : 22 : case POINTER_PLUS_EXPR:
13675 : 22 : {
13676 : 22 : tree _q40 = gimple_assign_rhs1 (_a1);
13677 : 22 : _q40 = do_valueize (valueize, _q40);
13678 : 22 : tree _q41 = gimple_assign_rhs2 (_a1);
13679 : 22 : _q41 = do_valueize (valueize, _q41);
13680 : 22 : switch (TREE_CODE (_q40))
13681 : : {
13682 : 22 : case SSA_NAME:
13683 : 22 : if (gimple *_d2 = get_def (valueize, _q40))
13684 : : {
13685 : 20 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13686 : 40 : switch (gimple_assign_rhs_code (_a2))
13687 : : {
13688 : 0 : CASE_CONVERT:
13689 : 0 : {
13690 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
13691 : 0 : _q50 = do_valueize (valueize, _q50);
13692 : 0 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
13693 : : {
13694 : 0 : {
13695 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
13696 : 0 : if (gimple_simplify_247 (res_op, seq, valueize, type, captures, EQ_EXPR))
13697 : 0 : return true;
13698 : : }
13699 : : }
13700 : : break;
13701 : : }
13702 : : default:;
13703 : : }
13704 : : }
13705 : : break;
13706 : 22 : default:;
13707 : : }
13708 : 22 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
13709 : : {
13710 : 0 : {
13711 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q30, _p0, _q41 };
13712 : 0 : if (gimple_simplify_247 (res_op, seq, valueize, type, captures, EQ_EXPR))
13713 : 0 : return true;
13714 : : }
13715 : : }
13716 : : break;
13717 : : }
13718 : : default:;
13719 : : }
13720 : : }
13721 : : break;
13722 : : default:;
13723 : : }
13724 : : }
13725 : : }
13726 : 80016220 : switch (TREE_CODE (_p0))
13727 : : {
13728 : 79170821 : case SSA_NAME:
13729 : 79170821 : if (gimple *_d1 = get_def (valueize, _p0))
13730 : : {
13731 : 27026679 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13732 : 33195402 : switch (gimple_assign_rhs_code (_a1))
13733 : : {
13734 : 139615 : case POINTER_PLUS_EXPR:
13735 : 139615 : {
13736 : 139615 : tree _q20 = gimple_assign_rhs1 (_a1);
13737 : 139615 : _q20 = do_valueize (valueize, _q20);
13738 : 139615 : tree _q21 = gimple_assign_rhs2 (_a1);
13739 : 139615 : _q21 = do_valueize (valueize, _q21);
13740 : 139615 : switch (TREE_CODE (_p1))
13741 : : {
13742 : 104892 : case SSA_NAME:
13743 : 104892 : if (gimple *_d2 = get_def (valueize, _p1))
13744 : : {
13745 : 103240 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13746 : 127829 : switch (gimple_assign_rhs_code (_a2))
13747 : : {
13748 : 515 : case ADDR_EXPR:
13749 : 515 : {
13750 : 515 : {
13751 : 515 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
13752 : 515 : if (gimple_simplify_248 (res_op, seq, valueize, type, captures, EQ_EXPR))
13753 : 113 : return true;
13754 : : }
13755 : 402 : break;
13756 : : }
13757 : : default:;
13758 : : }
13759 : : }
13760 : : break;
13761 : 28148 : case ADDR_EXPR:
13762 : 28148 : {
13763 : 28148 : {
13764 : 28148 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
13765 : 28148 : if (gimple_simplify_248 (res_op, seq, valueize, type, captures, EQ_EXPR))
13766 : 301 : return true;
13767 : : }
13768 : 27847 : break;
13769 : : }
13770 : 139201 : default:;
13771 : : }
13772 : 139201 : switch (TREE_CODE (_q20))
13773 : : {
13774 : 134439 : case SSA_NAME:
13775 : 134439 : if (gimple *_d2 = get_def (valueize, _q20))
13776 : : {
13777 : 130121 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13778 : 157639 : switch (gimple_assign_rhs_code (_a2))
13779 : : {
13780 : 146 : case ADDR_EXPR:
13781 : 146 : {
13782 : 146 : switch (TREE_CODE (_p1))
13783 : : {
13784 : 146 : case SSA_NAME:
13785 : 146 : if (gimple *_d3 = get_def (valueize, _p1))
13786 : : {
13787 : 146 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
13788 : 172 : switch (gimple_assign_rhs_code (_a3))
13789 : : {
13790 : 72 : case POINTER_PLUS_EXPR:
13791 : 72 : {
13792 : 72 : tree _q50 = gimple_assign_rhs1 (_a3);
13793 : 72 : _q50 = do_valueize (valueize, _q50);
13794 : 72 : tree _q51 = gimple_assign_rhs2 (_a3);
13795 : 72 : _q51 = do_valueize (valueize, _q51);
13796 : 72 : switch (TREE_CODE (_q50))
13797 : : {
13798 : 72 : case SSA_NAME:
13799 : 72 : if (gimple *_d4 = get_def (valueize, _q50))
13800 : : {
13801 : 40 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
13802 : 16 : switch (gimple_assign_rhs_code (_a4))
13803 : : {
13804 : 8 : case ADDR_EXPR:
13805 : 8 : {
13806 : 8 : {
13807 : 8 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
13808 : 8 : if (gimple_simplify_249 (res_op, seq, valueize, type, captures, EQ_EXPR))
13809 : 4 : return true;
13810 : : }
13811 : 4 : break;
13812 : : }
13813 : : default:;
13814 : : }
13815 : : }
13816 : : break;
13817 : 0 : case ADDR_EXPR:
13818 : 0 : {
13819 : 0 : {
13820 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
13821 : 0 : if (gimple_simplify_249 (res_op, seq, valueize, type, captures, EQ_EXPR))
13822 : 0 : return true;
13823 : : }
13824 : 0 : break;
13825 : : }
13826 : : default:;
13827 : : }
13828 : : break;
13829 : : }
13830 : : default:;
13831 : : }
13832 : : }
13833 : : break;
13834 : : default:;
13835 : : }
13836 : : break;
13837 : : }
13838 : : default:;
13839 : : }
13840 : : }
13841 : : break;
13842 : 4762 : case ADDR_EXPR:
13843 : 4762 : {
13844 : 4762 : switch (TREE_CODE (_p1))
13845 : : {
13846 : 4750 : case SSA_NAME:
13847 : 4750 : if (gimple *_d2 = get_def (valueize, _p1))
13848 : : {
13849 : 4623 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13850 : 8213 : switch (gimple_assign_rhs_code (_a2))
13851 : : {
13852 : 83 : case POINTER_PLUS_EXPR:
13853 : 83 : {
13854 : 83 : tree _q50 = gimple_assign_rhs1 (_a2);
13855 : 83 : _q50 = do_valueize (valueize, _q50);
13856 : 83 : tree _q51 = gimple_assign_rhs2 (_a2);
13857 : 83 : _q51 = do_valueize (valueize, _q51);
13858 : 83 : switch (TREE_CODE (_q50))
13859 : : {
13860 : 79 : case SSA_NAME:
13861 : 79 : if (gimple *_d3 = get_def (valueize, _q50))
13862 : : {
13863 : 79 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
13864 : 98 : switch (gimple_assign_rhs_code (_a3))
13865 : : {
13866 : 0 : case ADDR_EXPR:
13867 : 0 : {
13868 : 0 : {
13869 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
13870 : 0 : if (gimple_simplify_249 (res_op, seq, valueize, type, captures, EQ_EXPR))
13871 : 0 : return true;
13872 : : }
13873 : 0 : break;
13874 : : }
13875 : : default:;
13876 : : }
13877 : : }
13878 : : break;
13879 : 4 : case ADDR_EXPR:
13880 : 4 : {
13881 : 4 : {
13882 : 4 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q50, _q51 };
13883 : 4 : if (gimple_simplify_249 (res_op, seq, valueize, type, captures, EQ_EXPR))
13884 : 4 : return true;
13885 : : }
13886 : 0 : break;
13887 : : }
13888 : : default:;
13889 : : }
13890 : : break;
13891 : : }
13892 : : default:;
13893 : : }
13894 : : }
13895 : : break;
13896 : : default:;
13897 : : }
13898 : : break;
13899 : : }
13900 : : default:;
13901 : : }
13902 : : break;
13903 : : }
13904 : 145980 : case ADDR_EXPR:
13905 : 145980 : {
13906 : 145980 : switch (TREE_CODE (_p1))
13907 : : {
13908 : 126871 : case SSA_NAME:
13909 : 126871 : if (gimple *_d2 = get_def (valueize, _p1))
13910 : : {
13911 : 123441 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
13912 : 210194 : switch (gimple_assign_rhs_code (_a2))
13913 : : {
13914 : 114 : case POINTER_PLUS_EXPR:
13915 : 114 : {
13916 : 114 : tree _q30 = gimple_assign_rhs1 (_a2);
13917 : 114 : _q30 = do_valueize (valueize, _q30);
13918 : 114 : tree _q31 = gimple_assign_rhs2 (_a2);
13919 : 114 : _q31 = do_valueize (valueize, _q31);
13920 : 114 : {
13921 : 114 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
13922 : 114 : if (gimple_simplify_248 (res_op, seq, valueize, type, captures, EQ_EXPR))
13923 : 80 : return true;
13924 : : }
13925 : 34 : break;
13926 : : }
13927 : : default:;
13928 : : }
13929 : : }
13930 : : break;
13931 : : default:;
13932 : : }
13933 : : break;
13934 : : }
13935 : : default:;
13936 : : }
13937 : : }
13938 : : break;
13939 : 90110 : case ADDR_EXPR:
13940 : 90110 : {
13941 : 90110 : switch (TREE_CODE (_p1))
13942 : : {
13943 : 0 : case SSA_NAME:
13944 : 0 : if (gimple *_d1 = get_def (valueize, _p1))
13945 : : {
13946 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13947 : 0 : switch (gimple_assign_rhs_code (_a1))
13948 : : {
13949 : 0 : case POINTER_PLUS_EXPR:
13950 : 0 : {
13951 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
13952 : 0 : _q30 = do_valueize (valueize, _q30);
13953 : 0 : tree _q31 = gimple_assign_rhs2 (_a1);
13954 : 0 : _q31 = do_valueize (valueize, _q31);
13955 : 0 : {
13956 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _p0 };
13957 : 0 : if (gimple_simplify_248 (res_op, seq, valueize, type, captures, EQ_EXPR))
13958 : 0 : return true;
13959 : : }
13960 : 0 : break;
13961 : : }
13962 : : default:;
13963 : : }
13964 : : }
13965 : : break;
13966 : : default:;
13967 : : }
13968 : : break;
13969 : : }
13970 : 80015718 : default:;
13971 : : }
13972 : 80015718 : switch (TREE_CODE (_p1))
13973 : : {
13974 : 13133678 : case SSA_NAME:
13975 : 13133678 : if (gimple *_d1 = get_def (valueize, _p1))
13976 : : {
13977 : 4366610 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
13978 : 6439631 : switch (gimple_assign_rhs_code (_a1))
13979 : : {
13980 : 31570 : case MINUS_EXPR:
13981 : 31570 : {
13982 : 31570 : tree _q30 = gimple_assign_rhs1 (_a1);
13983 : 31570 : _q30 = do_valueize (valueize, _q30);
13984 : 31570 : tree _q31 = gimple_assign_rhs2 (_a1);
13985 : 31570 : _q31 = do_valueize (valueize, _q31);
13986 : 31570 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
13987 : : {
13988 : 54 : {
13989 : 54 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q31 };
13990 : 54 : if (gimple_simplify_244 (res_op, seq, valueize, type, captures, EQ_EXPR))
13991 : 14 : return true;
13992 : : }
13993 : : }
13994 : : break;
13995 : : }
13996 : : default:;
13997 : : }
13998 : : }
13999 : : break;
14000 : 80015704 : default:;
14001 : : }
14002 : 80015704 : switch (TREE_CODE (_p0))
14003 : : {
14004 : 79170305 : case SSA_NAME:
14005 : 79170305 : if (gimple *_d1 = get_def (valueize, _p0))
14006 : : {
14007 : 27026163 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14008 : 33194801 : switch (gimple_assign_rhs_code (_a1))
14009 : : {
14010 : 12759 : case TRUNC_DIV_EXPR:
14011 : 12759 : {
14012 : 12759 : tree _q20 = gimple_assign_rhs1 (_a1);
14013 : 12759 : _q20 = do_valueize (valueize, _q20);
14014 : 12759 : tree _q21 = gimple_assign_rhs2 (_a1);
14015 : 12759 : _q21 = do_valueize (valueize, _q21);
14016 : 12759 : if (integer_zerop (_p1))
14017 : : {
14018 : 2598 : {
14019 : 2598 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14020 : 2598 : if (gimple_simplify_250 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR))
14021 : 131 : return true;
14022 : : }
14023 : : }
14024 : : break;
14025 : : }
14026 : 780239 : CASE_CONVERT:
14027 : 780239 : {
14028 : 780239 : tree _q20 = gimple_assign_rhs1 (_a1);
14029 : 780239 : _q20 = do_valueize (valueize, _q20);
14030 : 780239 : switch (TREE_CODE (_p1))
14031 : : {
14032 : 185197 : case SSA_NAME:
14033 : 185197 : if (gimple *_d2 = get_def (valueize, _p1))
14034 : : {
14035 : 176060 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14036 : 188519 : switch (gimple_assign_rhs_code (_a2))
14037 : : {
14038 : 39769 : CASE_CONVERT:
14039 : 39769 : {
14040 : 39769 : tree _q40 = gimple_assign_rhs1 (_a2);
14041 : 39769 : _q40 = do_valueize (valueize, _q40);
14042 : 39769 : switch (TREE_CODE (_q40))
14043 : : {
14044 : 22217 : case SSA_NAME:
14045 : 22217 : if (gimple *_d3 = get_def (valueize, _q40))
14046 : : {
14047 : 21999 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14048 : 30661 : switch (gimple_assign_rhs_code (_a3))
14049 : : {
14050 : 50 : case MINUS_EXPR:
14051 : 50 : {
14052 : 50 : tree _q50 = gimple_assign_rhs1 (_a3);
14053 : 50 : _q50 = do_valueize (valueize, _q50);
14054 : 50 : tree _q51 = gimple_assign_rhs2 (_a3);
14055 : 50 : _q51 = do_valueize (valueize, _q51);
14056 : 50 : switch (TREE_CODE (_q50))
14057 : : {
14058 : 16 : case INTEGER_CST:
14059 : 16 : {
14060 : 16 : switch (TREE_CODE (_q51))
14061 : : {
14062 : 16 : case SSA_NAME:
14063 : 16 : if (gimple *_d4 = get_def (valueize, _q51))
14064 : : {
14065 : 12 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
14066 : 12 : switch (gimple_assign_rhs_code (_a4))
14067 : : {
14068 : 12 : CASE_CONVERT:
14069 : 12 : {
14070 : 12 : tree _q70 = gimple_assign_rhs1 (_a4);
14071 : 12 : _q70 = do_valueize (valueize, _q70);
14072 : 12 : if ((_q70 == _q20 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q20, 0) && types_match (_q70, _q20)))
14073 : : {
14074 : 0 : {
14075 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
14076 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14077 : 0 : return true;
14078 : : }
14079 : : }
14080 : : break;
14081 : : }
14082 : : default:;
14083 : : }
14084 : : }
14085 : : break;
14086 : : default:;
14087 : : }
14088 : : break;
14089 : : }
14090 : : default:;
14091 : : }
14092 : : break;
14093 : : }
14094 : : default:;
14095 : : }
14096 : : }
14097 : : break;
14098 : : default:;
14099 : : }
14100 : : break;
14101 : : }
14102 : : default:;
14103 : : }
14104 : : }
14105 : : break;
14106 : 780239 : default:;
14107 : : }
14108 : 780239 : switch (TREE_CODE (_q20))
14109 : : {
14110 : 767263 : case SSA_NAME:
14111 : 767263 : if (gimple *_d2 = get_def (valueize, _q20))
14112 : : {
14113 : 755699 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14114 : 888955 : switch (gimple_assign_rhs_code (_a2))
14115 : : {
14116 : 8946 : case MINUS_EXPR:
14117 : 8946 : {
14118 : 8946 : tree _q30 = gimple_assign_rhs1 (_a2);
14119 : 8946 : _q30 = do_valueize (valueize, _q30);
14120 : 8946 : tree _q31 = gimple_assign_rhs2 (_a2);
14121 : 8946 : _q31 = do_valueize (valueize, _q31);
14122 : 8946 : switch (TREE_CODE (_q30))
14123 : : {
14124 : 528 : case INTEGER_CST:
14125 : 528 : {
14126 : 528 : switch (TREE_CODE (_q31))
14127 : : {
14128 : 528 : case SSA_NAME:
14129 : 528 : if (gimple *_d3 = get_def (valueize, _q31))
14130 : : {
14131 : 519 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14132 : 186 : switch (gimple_assign_rhs_code (_a3))
14133 : : {
14134 : 107 : CASE_CONVERT:
14135 : 107 : {
14136 : 107 : tree _q50 = gimple_assign_rhs1 (_a3);
14137 : 107 : _q50 = do_valueize (valueize, _q50);
14138 : 107 : switch (TREE_CODE (_p1))
14139 : : {
14140 : 51 : case SSA_NAME:
14141 : 51 : if (gimple *_d4 = get_def (valueize, _p1))
14142 : : {
14143 : 44 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
14144 : 18 : switch (gimple_assign_rhs_code (_a4))
14145 : : {
14146 : 4 : CASE_CONVERT:
14147 : 4 : {
14148 : 4 : tree _q70 = gimple_assign_rhs1 (_a4);
14149 : 4 : _q70 = do_valueize (valueize, _q70);
14150 : 4 : if ((_q70 == _q50 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q50, 0) && types_match (_q70, _q50)))
14151 : : {
14152 : 0 : {
14153 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
14154 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14155 : 0 : return true;
14156 : : }
14157 : : }
14158 : : break;
14159 : : }
14160 : : default:;
14161 : : }
14162 : : }
14163 : : break;
14164 : 107 : default:;
14165 : : }
14166 : 107 : if ((_p1 == _q50 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q50, 0) && types_match (_p1, _q50)))
14167 : : {
14168 : 0 : {
14169 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
14170 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14171 : 0 : return true;
14172 : : }
14173 : : }
14174 : : break;
14175 : : }
14176 : : default:;
14177 : : }
14178 : : }
14179 : : break;
14180 : 528 : default:;
14181 : : }
14182 : 528 : switch (TREE_CODE (_p1))
14183 : : {
14184 : 93 : case SSA_NAME:
14185 : 93 : if (gimple *_d3 = get_def (valueize, _p1))
14186 : : {
14187 : 79 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14188 : 29 : switch (gimple_assign_rhs_code (_a3))
14189 : : {
14190 : 4 : CASE_CONVERT:
14191 : 4 : {
14192 : 4 : tree _q60 = gimple_assign_rhs1 (_a3);
14193 : 4 : _q60 = do_valueize (valueize, _q60);
14194 : 4 : if ((_q60 == _q31 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q31, 0) && types_match (_q60, _q31)))
14195 : : {
14196 : 0 : {
14197 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
14198 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14199 : 0 : return true;
14200 : : }
14201 : : }
14202 : : break;
14203 : : }
14204 : : default:;
14205 : : }
14206 : : }
14207 : : break;
14208 : 528 : default:;
14209 : : }
14210 : 528 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q31, 0) && types_match (_p1, _q31)))
14211 : : {
14212 : 0 : {
14213 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q30 };
14214 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14215 : 0 : return true;
14216 : : }
14217 : : }
14218 : : break;
14219 : : }
14220 : : default:;
14221 : : }
14222 : : break;
14223 : : }
14224 : : default:;
14225 : : }
14226 : : }
14227 : : break;
14228 : 780239 : default:;
14229 : : }
14230 : 780239 : switch (TREE_CODE (_p1))
14231 : : {
14232 : 185197 : case SSA_NAME:
14233 : 185197 : if (gimple *_d2 = get_def (valueize, _p1))
14234 : : {
14235 : 176060 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14236 : 188519 : switch (gimple_assign_rhs_code (_a2))
14237 : : {
14238 : 39769 : CASE_CONVERT:
14239 : 39769 : {
14240 : 39769 : tree _q40 = gimple_assign_rhs1 (_a2);
14241 : 39769 : _q40 = do_valueize (valueize, _q40);
14242 : 39769 : switch (TREE_CODE (_q40))
14243 : : {
14244 : 22217 : case SSA_NAME:
14245 : 22217 : if (gimple *_d3 = get_def (valueize, _q40))
14246 : : {
14247 : 21999 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14248 : 30661 : switch (gimple_assign_rhs_code (_a3))
14249 : : {
14250 : 50 : case MINUS_EXPR:
14251 : 50 : {
14252 : 50 : tree _q50 = gimple_assign_rhs1 (_a3);
14253 : 50 : _q50 = do_valueize (valueize, _q50);
14254 : 50 : tree _q51 = gimple_assign_rhs2 (_a3);
14255 : 50 : _q51 = do_valueize (valueize, _q51);
14256 : 50 : switch (TREE_CODE (_q50))
14257 : : {
14258 : 16 : case INTEGER_CST:
14259 : 16 : {
14260 : 16 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
14261 : : {
14262 : 0 : {
14263 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
14264 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14265 : 0 : return true;
14266 : : }
14267 : : }
14268 : : break;
14269 : : }
14270 : : default:;
14271 : : }
14272 : : break;
14273 : : }
14274 : : default:;
14275 : : }
14276 : : }
14277 : : break;
14278 : : default:;
14279 : : }
14280 : : break;
14281 : : }
14282 : 748 : case MINUS_EXPR:
14283 : 748 : {
14284 : 748 : tree _q40 = gimple_assign_rhs1 (_a2);
14285 : 748 : _q40 = do_valueize (valueize, _q40);
14286 : 748 : tree _q41 = gimple_assign_rhs2 (_a2);
14287 : 748 : _q41 = do_valueize (valueize, _q41);
14288 : 748 : switch (TREE_CODE (_q40))
14289 : : {
14290 : 117 : case INTEGER_CST:
14291 : 117 : {
14292 : 117 : switch (TREE_CODE (_q41))
14293 : : {
14294 : 117 : case SSA_NAME:
14295 : 117 : if (gimple *_d3 = get_def (valueize, _q41))
14296 : : {
14297 : 97 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14298 : 25 : switch (gimple_assign_rhs_code (_a3))
14299 : : {
14300 : 11 : CASE_CONVERT:
14301 : 11 : {
14302 : 11 : tree _q60 = gimple_assign_rhs1 (_a3);
14303 : 11 : _q60 = do_valueize (valueize, _q60);
14304 : 11 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
14305 : : {
14306 : 0 : {
14307 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
14308 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14309 : 0 : return true;
14310 : : }
14311 : : }
14312 : : break;
14313 : : }
14314 : : default:;
14315 : : }
14316 : : }
14317 : : break;
14318 : 117 : default:;
14319 : : }
14320 : 117 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
14321 : : {
14322 : 0 : {
14323 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
14324 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14325 : 0 : return true;
14326 : : }
14327 : : }
14328 : : break;
14329 : : }
14330 : : default:;
14331 : : }
14332 : : break;
14333 : : }
14334 : : default:;
14335 : : }
14336 : : }
14337 : : break;
14338 : : default:;
14339 : : }
14340 : : break;
14341 : : }
14342 : 249052 : case MINUS_EXPR:
14343 : 249052 : {
14344 : 249052 : tree _q20 = gimple_assign_rhs1 (_a1);
14345 : 249052 : _q20 = do_valueize (valueize, _q20);
14346 : 249052 : tree _q21 = gimple_assign_rhs2 (_a1);
14347 : 249052 : _q21 = do_valueize (valueize, _q21);
14348 : 249052 : switch (TREE_CODE (_q20))
14349 : : {
14350 : 8231 : case INTEGER_CST:
14351 : 8231 : {
14352 : 8231 : switch (TREE_CODE (_q21))
14353 : : {
14354 : 8231 : case SSA_NAME:
14355 : 8231 : if (gimple *_d2 = get_def (valueize, _q21))
14356 : : {
14357 : 5689 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14358 : 4645 : switch (gimple_assign_rhs_code (_a2))
14359 : : {
14360 : 3381 : CASE_CONVERT:
14361 : 3381 : {
14362 : 3381 : tree _q40 = gimple_assign_rhs1 (_a2);
14363 : 3381 : _q40 = do_valueize (valueize, _q40);
14364 : 3381 : switch (TREE_CODE (_p1))
14365 : : {
14366 : 705 : case SSA_NAME:
14367 : 705 : if (gimple *_d3 = get_def (valueize, _p1))
14368 : : {
14369 : 702 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14370 : 730 : switch (gimple_assign_rhs_code (_a3))
14371 : : {
14372 : 2 : CASE_CONVERT:
14373 : 2 : {
14374 : 2 : tree _q60 = gimple_assign_rhs1 (_a3);
14375 : 2 : _q60 = do_valueize (valueize, _q60);
14376 : 2 : if ((_q60 == _q40 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q40, 0) && types_match (_q60, _q40)))
14377 : : {
14378 : 0 : {
14379 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
14380 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14381 : 0 : return true;
14382 : : }
14383 : : }
14384 : : break;
14385 : : }
14386 : : default:;
14387 : : }
14388 : : }
14389 : : break;
14390 : 3381 : default:;
14391 : : }
14392 : 3381 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
14393 : : {
14394 : 0 : {
14395 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q40, _q20 };
14396 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14397 : 0 : return true;
14398 : : }
14399 : : }
14400 : : break;
14401 : : }
14402 : : default:;
14403 : : }
14404 : : }
14405 : : break;
14406 : 8231 : default:;
14407 : : }
14408 : 8231 : switch (TREE_CODE (_p1))
14409 : : {
14410 : 1737 : case SSA_NAME:
14411 : 1737 : if (gimple *_d2 = get_def (valueize, _p1))
14412 : : {
14413 : 1617 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14414 : 1080 : switch (gimple_assign_rhs_code (_a2))
14415 : : {
14416 : 10 : CASE_CONVERT:
14417 : 10 : {
14418 : 10 : tree _q50 = gimple_assign_rhs1 (_a2);
14419 : 10 : _q50 = do_valueize (valueize, _q50);
14420 : 10 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
14421 : : {
14422 : 0 : {
14423 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14424 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14425 : 0 : return true;
14426 : : }
14427 : : }
14428 : : break;
14429 : : }
14430 : : default:;
14431 : : }
14432 : : }
14433 : : break;
14434 : 8231 : default:;
14435 : : }
14436 : 8231 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
14437 : : {
14438 : 0 : {
14439 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14440 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14441 : 0 : return true;
14442 : : }
14443 : : }
14444 : : break;
14445 : : }
14446 : : default:;
14447 : : }
14448 : : break;
14449 : : }
14450 : : default:;
14451 : : }
14452 : : }
14453 : : break;
14454 : 80015573 : default:;
14455 : : }
14456 : 80015573 : switch (TREE_CODE (_p1))
14457 : : {
14458 : 13133664 : case SSA_NAME:
14459 : 13133664 : if (gimple *_d1 = get_def (valueize, _p1))
14460 : : {
14461 : 4366596 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14462 : 6439617 : switch (gimple_assign_rhs_code (_a1))
14463 : : {
14464 : 222693 : CASE_CONVERT:
14465 : 222693 : {
14466 : 222693 : tree _q30 = gimple_assign_rhs1 (_a1);
14467 : 222693 : _q30 = do_valueize (valueize, _q30);
14468 : 222693 : switch (TREE_CODE (_q30))
14469 : : {
14470 : 198891 : case SSA_NAME:
14471 : 198891 : if (gimple *_d2 = get_def (valueize, _q30))
14472 : : {
14473 : 193812 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14474 : 251383 : switch (gimple_assign_rhs_code (_a2))
14475 : : {
14476 : 5435 : case MINUS_EXPR:
14477 : 5435 : {
14478 : 5435 : tree _q40 = gimple_assign_rhs1 (_a2);
14479 : 5435 : _q40 = do_valueize (valueize, _q40);
14480 : 5435 : tree _q41 = gimple_assign_rhs2 (_a2);
14481 : 5435 : _q41 = do_valueize (valueize, _q41);
14482 : 5435 : switch (TREE_CODE (_q40))
14483 : : {
14484 : 111 : case INTEGER_CST:
14485 : 111 : {
14486 : 111 : switch (TREE_CODE (_q41))
14487 : : {
14488 : 111 : case SSA_NAME:
14489 : 111 : if (gimple *_d3 = get_def (valueize, _q41))
14490 : : {
14491 : 99 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
14492 : 54 : switch (gimple_assign_rhs_code (_a3))
14493 : : {
14494 : 46 : CASE_CONVERT:
14495 : 46 : {
14496 : 46 : tree _q60 = gimple_assign_rhs1 (_a3);
14497 : 46 : _q60 = do_valueize (valueize, _q60);
14498 : 46 : if ((_q60 == _p0 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _p0, 0) && types_match (_q60, _p0)))
14499 : : {
14500 : 0 : {
14501 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
14502 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14503 : 0 : return true;
14504 : : }
14505 : : }
14506 : : break;
14507 : : }
14508 : : default:;
14509 : : }
14510 : : }
14511 : : break;
14512 : 111 : default:;
14513 : : }
14514 : 111 : if ((_q41 == _p0 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _p0, 0) && types_match (_q41, _p0)))
14515 : : {
14516 : 0 : {
14517 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
14518 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14519 : 0 : return true;
14520 : : }
14521 : : }
14522 : : break;
14523 : : }
14524 : : default:;
14525 : : }
14526 : : break;
14527 : : }
14528 : : default:;
14529 : : }
14530 : : }
14531 : : break;
14532 : : default:;
14533 : : }
14534 : : break;
14535 : : }
14536 : 31556 : case MINUS_EXPR:
14537 : 31556 : {
14538 : 31556 : tree _q30 = gimple_assign_rhs1 (_a1);
14539 : 31556 : _q30 = do_valueize (valueize, _q30);
14540 : 31556 : tree _q31 = gimple_assign_rhs2 (_a1);
14541 : 31556 : _q31 = do_valueize (valueize, _q31);
14542 : 31556 : switch (TREE_CODE (_q30))
14543 : : {
14544 : 707 : case INTEGER_CST:
14545 : 707 : {
14546 : 707 : switch (TREE_CODE (_q31))
14547 : : {
14548 : 707 : case SSA_NAME:
14549 : 707 : if (gimple *_d2 = get_def (valueize, _q31))
14550 : : {
14551 : 624 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14552 : 329 : switch (gimple_assign_rhs_code (_a2))
14553 : : {
14554 : 289 : CASE_CONVERT:
14555 : 289 : {
14556 : 289 : tree _q50 = gimple_assign_rhs1 (_a2);
14557 : 289 : _q50 = do_valueize (valueize, _q50);
14558 : 289 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
14559 : : {
14560 : 0 : {
14561 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
14562 : 0 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14563 : 0 : return true;
14564 : : }
14565 : : }
14566 : : break;
14567 : : }
14568 : : default:;
14569 : : }
14570 : : }
14571 : : break;
14572 : 707 : default:;
14573 : : }
14574 : 707 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
14575 : : {
14576 : 17 : {
14577 : 17 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
14578 : 17 : if (gimple_simplify_251 (res_op, seq, valueize, type, captures, EQ_EXPR))
14579 : 15 : return true;
14580 : : }
14581 : : }
14582 : : break;
14583 : : }
14584 : : default:;
14585 : : }
14586 : : break;
14587 : : }
14588 : : default:;
14589 : : }
14590 : : }
14591 : : break;
14592 : 80015558 : default:;
14593 : : }
14594 : 80015558 : switch (TREE_CODE (_p0))
14595 : : {
14596 : 79170159 : case SSA_NAME:
14597 : 79170159 : if (gimple *_d1 = get_def (valueize, _p0))
14598 : : {
14599 : 27026024 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
14600 : 33194662 : switch (gimple_assign_rhs_code (_a1))
14601 : : {
14602 : 1243 : case LT_EXPR:
14603 : 1243 : {
14604 : 1243 : tree _q20 = gimple_assign_rhs1 (_a1);
14605 : 1243 : _q20 = do_valueize (valueize, _q20);
14606 : 1243 : tree _q21 = gimple_assign_rhs2 (_a1);
14607 : 1243 : _q21 = do_valueize (valueize, _q21);
14608 : 1243 : switch (TREE_CODE (_p1))
14609 : : {
14610 : 348 : case SSA_NAME:
14611 : 348 : if (gimple *_d2 = get_def (valueize, _p1))
14612 : : {
14613 : 344 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14614 : 310 : switch (gimple_assign_rhs_code (_a2))
14615 : : {
14616 : 40 : case GT_EXPR:
14617 : 40 : {
14618 : 40 : tree _q50 = gimple_assign_rhs1 (_a2);
14619 : 40 : _q50 = do_valueize (valueize, _q50);
14620 : 40 : tree _q51 = gimple_assign_rhs2 (_a2);
14621 : 40 : _q51 = do_valueize (valueize, _q51);
14622 : 40 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14623 : : {
14624 : 16 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14625 : : {
14626 : 16 : {
14627 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14628 : 16 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, GT_EXPR, EQ_EXPR))
14629 : 16 : return true;
14630 : : }
14631 : : }
14632 : : }
14633 : : break;
14634 : : }
14635 : 16 : case EQ_EXPR:
14636 : 16 : {
14637 : 16 : tree _q50 = gimple_assign_rhs1 (_a2);
14638 : 16 : _q50 = do_valueize (valueize, _q50);
14639 : 16 : tree _q51 = gimple_assign_rhs2 (_a2);
14640 : 16 : _q51 = do_valueize (valueize, _q51);
14641 : 16 : if (tree_swap_operands_p (_q50, _q51))
14642 : 0 : std::swap (_q50, _q51);
14643 : 16 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14644 : : {
14645 : 16 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14646 : : {
14647 : 16 : {
14648 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14649 : 16 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, EQ_EXPR, GT_EXPR))
14650 : 16 : return true;
14651 : : }
14652 : : }
14653 : : }
14654 : 80009681 : break;
14655 : : }
14656 : 27 : case NE_EXPR:
14657 : 27 : {
14658 : 27 : tree _q50 = gimple_assign_rhs1 (_a2);
14659 : 27 : _q50 = do_valueize (valueize, _q50);
14660 : 27 : tree _q51 = gimple_assign_rhs2 (_a2);
14661 : 27 : _q51 = do_valueize (valueize, _q51);
14662 : 27 : if (tree_swap_operands_p (_q50, _q51))
14663 : 0 : std::swap (_q50, _q51);
14664 : 27 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14665 : : {
14666 : 16 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14667 : : {
14668 : 16 : {
14669 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14670 : 16 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, NE_EXPR, LE_EXPR))
14671 : 16 : return true;
14672 : : }
14673 : : }
14674 : : }
14675 : 80009681 : break;
14676 : : }
14677 : : default:;
14678 : : }
14679 : : }
14680 : : break;
14681 : : default:;
14682 : : }
14683 : : break;
14684 : : }
14685 : 783 : case LE_EXPR:
14686 : 783 : {
14687 : 783 : tree _q20 = gimple_assign_rhs1 (_a1);
14688 : 783 : _q20 = do_valueize (valueize, _q20);
14689 : 783 : tree _q21 = gimple_assign_rhs2 (_a1);
14690 : 783 : _q21 = do_valueize (valueize, _q21);
14691 : 783 : switch (TREE_CODE (_p1))
14692 : : {
14693 : 414 : case SSA_NAME:
14694 : 414 : if (gimple *_d2 = get_def (valueize, _p1))
14695 : : {
14696 : 414 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14697 : 391 : switch (gimple_assign_rhs_code (_a2))
14698 : : {
14699 : 48 : case GE_EXPR:
14700 : 48 : {
14701 : 48 : tree _q50 = gimple_assign_rhs1 (_a2);
14702 : 48 : _q50 = do_valueize (valueize, _q50);
14703 : 48 : tree _q51 = gimple_assign_rhs2 (_a2);
14704 : 48 : _q51 = do_valueize (valueize, _q51);
14705 : 48 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14706 : : {
14707 : 16 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14708 : : {
14709 : 16 : {
14710 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14711 : 16 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, GE_EXPR, EQ_EXPR))
14712 : 16 : return true;
14713 : : }
14714 : : }
14715 : : }
14716 : : break;
14717 : : }
14718 : 16 : case EQ_EXPR:
14719 : 16 : {
14720 : 16 : tree _q50 = gimple_assign_rhs1 (_a2);
14721 : 16 : _q50 = do_valueize (valueize, _q50);
14722 : 16 : tree _q51 = gimple_assign_rhs2 (_a2);
14723 : 16 : _q51 = do_valueize (valueize, _q51);
14724 : 16 : if (tree_swap_operands_p (_q50, _q51))
14725 : 0 : std::swap (_q50, _q51);
14726 : 16 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14727 : : {
14728 : 16 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14729 : : {
14730 : 16 : {
14731 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14732 : 16 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, EQ_EXPR, GE_EXPR))
14733 : 16 : return true;
14734 : : }
14735 : : }
14736 : : }
14737 : 80009681 : break;
14738 : : }
14739 : 16 : case NE_EXPR:
14740 : 16 : {
14741 : 16 : tree _q50 = gimple_assign_rhs1 (_a2);
14742 : 16 : _q50 = do_valueize (valueize, _q50);
14743 : 16 : tree _q51 = gimple_assign_rhs2 (_a2);
14744 : 16 : _q51 = do_valueize (valueize, _q51);
14745 : 16 : if (tree_swap_operands_p (_q50, _q51))
14746 : 0 : std::swap (_q50, _q51);
14747 : 16 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14748 : : {
14749 : 16 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14750 : : {
14751 : 16 : {
14752 : 16 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14753 : 16 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, NE_EXPR, LT_EXPR))
14754 : 16 : return true;
14755 : : }
14756 : : }
14757 : : }
14758 : 80009681 : break;
14759 : : }
14760 : : default:;
14761 : : }
14762 : : }
14763 : : break;
14764 : : default:;
14765 : : }
14766 : : break;
14767 : : }
14768 : 2296 : case GT_EXPR:
14769 : 2296 : {
14770 : 2296 : tree _q20 = gimple_assign_rhs1 (_a1);
14771 : 2296 : _q20 = do_valueize (valueize, _q20);
14772 : 2296 : tree _q21 = gimple_assign_rhs2 (_a1);
14773 : 2296 : _q21 = do_valueize (valueize, _q21);
14774 : 2296 : switch (TREE_CODE (_p1))
14775 : : {
14776 : 1019 : case SSA_NAME:
14777 : 1019 : if (gimple *_d2 = get_def (valueize, _p1))
14778 : : {
14779 : 1011 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14780 : 944 : switch (gimple_assign_rhs_code (_a2))
14781 : : {
14782 : 288 : case GT_EXPR:
14783 : 288 : {
14784 : 288 : tree _q50 = gimple_assign_rhs1 (_a2);
14785 : 288 : _q50 = do_valueize (valueize, _q50);
14786 : 288 : tree _q51 = gimple_assign_rhs2 (_a2);
14787 : 288 : _q51 = do_valueize (valueize, _q51);
14788 : 288 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
14789 : : {
14790 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
14791 : : {
14792 : 0 : {
14793 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14794 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, GT_EXPR, EQ_EXPR))
14795 : 0 : return true;
14796 : : }
14797 : 0 : {
14798 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14799 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, GT_EXPR, EQ_EXPR))
14800 : 0 : return true;
14801 : : }
14802 : : }
14803 : : }
14804 : : break;
14805 : : }
14806 : 217 : case EQ_EXPR:
14807 : 217 : {
14808 : 217 : tree _q50 = gimple_assign_rhs1 (_a2);
14809 : 217 : _q50 = do_valueize (valueize, _q50);
14810 : 217 : tree _q51 = gimple_assign_rhs2 (_a2);
14811 : 217 : _q51 = do_valueize (valueize, _q51);
14812 : 217 : if (tree_swap_operands_p (_q50, _q51))
14813 : 3 : std::swap (_q50, _q51);
14814 : 217 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
14815 : : {
14816 : 3 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
14817 : : {
14818 : 3 : {
14819 : 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14820 : 3 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, EQ_EXPR, GT_EXPR))
14821 : 3 : return true;
14822 : : }
14823 : : }
14824 : : }
14825 : 80009681 : break;
14826 : : }
14827 : 117 : case NE_EXPR:
14828 : 117 : {
14829 : 117 : tree _q50 = gimple_assign_rhs1 (_a2);
14830 : 117 : _q50 = do_valueize (valueize, _q50);
14831 : 117 : tree _q51 = gimple_assign_rhs2 (_a2);
14832 : 117 : _q51 = do_valueize (valueize, _q51);
14833 : 117 : if (tree_swap_operands_p (_q50, _q51))
14834 : 3 : std::swap (_q50, _q51);
14835 : 117 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
14836 : : {
14837 : 3 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
14838 : : {
14839 : 3 : {
14840 : 3 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14841 : 3 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, NE_EXPR, LE_EXPR))
14842 : 3 : return true;
14843 : : }
14844 : : }
14845 : : }
14846 : 80009681 : break;
14847 : : }
14848 : 164 : case LT_EXPR:
14849 : 164 : {
14850 : 164 : tree _q50 = gimple_assign_rhs1 (_a2);
14851 : 164 : _q50 = do_valueize (valueize, _q50);
14852 : 164 : tree _q51 = gimple_assign_rhs2 (_a2);
14853 : 164 : _q51 = do_valueize (valueize, _q51);
14854 : 164 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14855 : : {
14856 : 20 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14857 : : {
14858 : 20 : {
14859 : 20 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14860 : 20 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, GT_EXPR, EQ_EXPR))
14861 : 20 : return true;
14862 : : }
14863 : : }
14864 : : }
14865 : : break;
14866 : : }
14867 : : default:;
14868 : : }
14869 : : }
14870 : : break;
14871 : : default:;
14872 : : }
14873 : : break;
14874 : : }
14875 : 1432 : case GE_EXPR:
14876 : 1432 : {
14877 : 1432 : tree _q20 = gimple_assign_rhs1 (_a1);
14878 : 1432 : _q20 = do_valueize (valueize, _q20);
14879 : 1432 : tree _q21 = gimple_assign_rhs2 (_a1);
14880 : 1432 : _q21 = do_valueize (valueize, _q21);
14881 : 1432 : switch (TREE_CODE (_p1))
14882 : : {
14883 : 1129 : case SSA_NAME:
14884 : 1129 : if (gimple *_d2 = get_def (valueize, _p1))
14885 : : {
14886 : 1113 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14887 : 1034 : switch (gimple_assign_rhs_code (_a2))
14888 : : {
14889 : 104 : case GE_EXPR:
14890 : 104 : {
14891 : 104 : tree _q50 = gimple_assign_rhs1 (_a2);
14892 : 104 : _q50 = do_valueize (valueize, _q50);
14893 : 104 : tree _q51 = gimple_assign_rhs2 (_a2);
14894 : 104 : _q51 = do_valueize (valueize, _q51);
14895 : 104 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
14896 : : {
14897 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
14898 : : {
14899 : 0 : {
14900 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14901 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, GE_EXPR, EQ_EXPR))
14902 : 0 : return true;
14903 : : }
14904 : 0 : {
14905 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14906 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, GE_EXPR, EQ_EXPR))
14907 : 0 : return true;
14908 : : }
14909 : : }
14910 : : }
14911 : : break;
14912 : : }
14913 : 379 : case EQ_EXPR:
14914 : 379 : {
14915 : 379 : tree _q50 = gimple_assign_rhs1 (_a2);
14916 : 379 : _q50 = do_valueize (valueize, _q50);
14917 : 379 : tree _q51 = gimple_assign_rhs2 (_a2);
14918 : 379 : _q51 = do_valueize (valueize, _q51);
14919 : 379 : if (tree_swap_operands_p (_q50, _q51))
14920 : 20 : std::swap (_q50, _q51);
14921 : 379 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
14922 : : {
14923 : 20 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
14924 : : {
14925 : 20 : {
14926 : 20 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14927 : 20 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, EQ_EXPR, GE_EXPR))
14928 : 20 : return true;
14929 : : }
14930 : : }
14931 : : }
14932 : 80009681 : break;
14933 : : }
14934 : 209 : case NE_EXPR:
14935 : 209 : {
14936 : 209 : tree _q50 = gimple_assign_rhs1 (_a2);
14937 : 209 : _q50 = do_valueize (valueize, _q50);
14938 : 209 : tree _q51 = gimple_assign_rhs2 (_a2);
14939 : 209 : _q51 = do_valueize (valueize, _q51);
14940 : 209 : if (tree_swap_operands_p (_q50, _q51))
14941 : 20 : std::swap (_q50, _q51);
14942 : 209 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
14943 : : {
14944 : 20 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
14945 : : {
14946 : 20 : {
14947 : 20 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
14948 : 20 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, NE_EXPR, LT_EXPR))
14949 : 20 : return true;
14950 : : }
14951 : : }
14952 : : }
14953 : 80009681 : break;
14954 : : }
14955 : 59 : case LE_EXPR:
14956 : 59 : {
14957 : 59 : tree _q50 = gimple_assign_rhs1 (_a2);
14958 : 59 : _q50 = do_valueize (valueize, _q50);
14959 : 59 : tree _q51 = gimple_assign_rhs2 (_a2);
14960 : 59 : _q51 = do_valueize (valueize, _q51);
14961 : 59 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
14962 : : {
14963 : 14 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
14964 : : {
14965 : 14 : {
14966 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
14967 : 14 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, GE_EXPR, EQ_EXPR))
14968 : 14 : return true;
14969 : : }
14970 : : }
14971 : : }
14972 : : break;
14973 : : }
14974 : : default:;
14975 : : }
14976 : : }
14977 : : break;
14978 : : default:;
14979 : : }
14980 : : break;
14981 : : }
14982 : 17914 : case EQ_EXPR:
14983 : 17914 : {
14984 : 17914 : tree _q20 = gimple_assign_rhs1 (_a1);
14985 : 17914 : _q20 = do_valueize (valueize, _q20);
14986 : 17914 : tree _q21 = gimple_assign_rhs2 (_a1);
14987 : 17914 : _q21 = do_valueize (valueize, _q21);
14988 : 17914 : if (tree_swap_operands_p (_q20, _q21))
14989 : 553 : std::swap (_q20, _q21);
14990 : 17914 : switch (TREE_CODE (_p1))
14991 : : {
14992 : 15924 : case SSA_NAME:
14993 : 15924 : if (gimple *_d2 = get_def (valueize, _p1))
14994 : : {
14995 : 15724 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
14996 : 11738 : switch (gimple_assign_rhs_code (_a2))
14997 : : {
14998 : 0 : case LT_EXPR:
14999 : 0 : {
15000 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
15001 : 0 : _q50 = do_valueize (valueize, _q50);
15002 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
15003 : 0 : _q51 = do_valueize (valueize, _q51);
15004 : 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
15005 : : {
15006 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
15007 : : {
15008 : 0 : {
15009 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15010 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, EQ_EXPR, GT_EXPR))
15011 : 0 : return true;
15012 : : }
15013 : : }
15014 : : }
15015 : : break;
15016 : : }
15017 : 0 : case LE_EXPR:
15018 : 0 : {
15019 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
15020 : 0 : _q50 = do_valueize (valueize, _q50);
15021 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
15022 : 0 : _q51 = do_valueize (valueize, _q51);
15023 : 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
15024 : : {
15025 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
15026 : : {
15027 : 0 : {
15028 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15029 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, EQ_EXPR, GE_EXPR))
15030 : 0 : return true;
15031 : : }
15032 : : }
15033 : : }
15034 : : break;
15035 : : }
15036 : 318 : case GT_EXPR:
15037 : 318 : {
15038 : 318 : tree _q50 = gimple_assign_rhs1 (_a2);
15039 : 318 : _q50 = do_valueize (valueize, _q50);
15040 : 318 : tree _q51 = gimple_assign_rhs2 (_a2);
15041 : 318 : _q51 = do_valueize (valueize, _q51);
15042 : 318 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
15043 : : {
15044 : 17 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
15045 : : {
15046 : 17 : {
15047 : 17 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15048 : 17 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, EQ_EXPR, GT_EXPR))
15049 : 17 : return true;
15050 : : }
15051 : : }
15052 : : }
15053 : : break;
15054 : : }
15055 : 536 : case GE_EXPR:
15056 : 536 : {
15057 : 536 : tree _q50 = gimple_assign_rhs1 (_a2);
15058 : 536 : _q50 = do_valueize (valueize, _q50);
15059 : 536 : tree _q51 = gimple_assign_rhs2 (_a2);
15060 : 536 : _q51 = do_valueize (valueize, _q51);
15061 : 536 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
15062 : : {
15063 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
15064 : : {
15065 : 0 : {
15066 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15067 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, EQ_EXPR, GE_EXPR))
15068 : 0 : return true;
15069 : : }
15070 : : }
15071 : : }
15072 : : break;
15073 : : }
15074 : : default:;
15075 : : }
15076 : : }
15077 : : break;
15078 : : default:;
15079 : : }
15080 : 80009681 : break;
15081 : : }
15082 : 18495 : case NE_EXPR:
15083 : 18495 : {
15084 : 18495 : tree _q20 = gimple_assign_rhs1 (_a1);
15085 : 18495 : _q20 = do_valueize (valueize, _q20);
15086 : 18495 : tree _q21 = gimple_assign_rhs2 (_a1);
15087 : 18495 : _q21 = do_valueize (valueize, _q21);
15088 : 18495 : if (tree_swap_operands_p (_q20, _q21))
15089 : 45 : std::swap (_q20, _q21);
15090 : 18495 : switch (TREE_CODE (_p1))
15091 : : {
15092 : 1034 : case SSA_NAME:
15093 : 1034 : if (gimple *_d2 = get_def (valueize, _p1))
15094 : : {
15095 : 1011 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15096 : 994 : switch (gimple_assign_rhs_code (_a2))
15097 : : {
15098 : 0 : case LT_EXPR:
15099 : 0 : {
15100 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
15101 : 0 : _q50 = do_valueize (valueize, _q50);
15102 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
15103 : 0 : _q51 = do_valueize (valueize, _q51);
15104 : 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
15105 : : {
15106 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
15107 : : {
15108 : 0 : {
15109 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15110 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, NE_EXPR, LE_EXPR))
15111 : 0 : return true;
15112 : : }
15113 : : }
15114 : : }
15115 : : break;
15116 : : }
15117 : 0 : case LE_EXPR:
15118 : 0 : {
15119 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
15120 : 0 : _q50 = do_valueize (valueize, _q50);
15121 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
15122 : 0 : _q51 = do_valueize (valueize, _q51);
15123 : 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
15124 : : {
15125 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
15126 : : {
15127 : 0 : {
15128 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15129 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, NE_EXPR, LT_EXPR))
15130 : 0 : return true;
15131 : : }
15132 : : }
15133 : : }
15134 : : break;
15135 : : }
15136 : 68 : case GT_EXPR:
15137 : 68 : {
15138 : 68 : tree _q50 = gimple_assign_rhs1 (_a2);
15139 : 68 : _q50 = do_valueize (valueize, _q50);
15140 : 68 : tree _q51 = gimple_assign_rhs2 (_a2);
15141 : 68 : _q51 = do_valueize (valueize, _q51);
15142 : 68 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
15143 : : {
15144 : 17 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
15145 : : {
15146 : 17 : {
15147 : 17 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15148 : 17 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LT_EXPR, NE_EXPR, LE_EXPR))
15149 : 17 : return true;
15150 : : }
15151 : : }
15152 : : }
15153 : : break;
15154 : : }
15155 : 6 : case GE_EXPR:
15156 : 6 : {
15157 : 6 : tree _q50 = gimple_assign_rhs1 (_a2);
15158 : 6 : _q50 = do_valueize (valueize, _q50);
15159 : 6 : tree _q51 = gimple_assign_rhs2 (_a2);
15160 : 6 : _q51 = do_valueize (valueize, _q51);
15161 : 6 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
15162 : : {
15163 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
15164 : : {
15165 : 0 : {
15166 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15167 : 0 : if (gimple_simplify_253 (res_op, seq, valueize, type, captures, LE_EXPR, NE_EXPR, LT_EXPR))
15168 : 0 : return true;
15169 : : }
15170 : : }
15171 : : }
15172 : : break;
15173 : : }
15174 : : default:;
15175 : : }
15176 : : }
15177 : : break;
15178 : : default:;
15179 : : }
15180 : 80009681 : break;
15181 : : }
15182 : 63227 : case MIN_EXPR:
15183 : 63227 : {
15184 : 63227 : tree _q20 = gimple_assign_rhs1 (_a1);
15185 : 63227 : _q20 = do_valueize (valueize, _q20);
15186 : 63227 : tree _q21 = gimple_assign_rhs2 (_a1);
15187 : 63227 : _q21 = do_valueize (valueize, _q21);
15188 : 63227 : if (tree_swap_operands_p (_q20, _q21))
15189 : 8861 : std::swap (_q20, _q21);
15190 : 63227 : switch (TREE_CODE (_p1))
15191 : : {
15192 : 4930 : case SSA_NAME:
15193 : 4930 : if (gimple *_d2 = get_def (valueize, _p1))
15194 : : {
15195 : 4916 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15196 : 5178 : switch (gimple_assign_rhs_code (_a2))
15197 : : {
15198 : 0 : case MAX_EXPR:
15199 : 0 : {
15200 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
15201 : 0 : _q50 = do_valueize (valueize, _q50);
15202 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
15203 : 0 : _q51 = do_valueize (valueize, _q51);
15204 : 0 : if (tree_swap_operands_p (_q50, _q51))
15205 : 0 : std::swap (_q50, _q51);
15206 : 0 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
15207 : : {
15208 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
15209 : : {
15210 : 0 : {
15211 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15212 : 0 : if (!HONOR_NANS (captures[0])
15213 : : )
15214 : : {
15215 : 0 : gimple_seq *lseq = seq;
15216 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2402;
15217 : 0 : {
15218 : 0 : res_op->set_op (EQ_EXPR, type, 2);
15219 : 0 : res_op->ops[0] = captures[0];
15220 : 0 : res_op->ops[1] = captures[1];
15221 : 0 : res_op->resimplify (lseq, valueize);
15222 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1059, __FILE__, __LINE__, true);
15223 : 0 : return true;
15224 : : }
15225 : 0 : next_after_fail2402:;
15226 : : }
15227 : : }
15228 : : }
15229 : : }
15230 : 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
15231 : : {
15232 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
15233 : : {
15234 : 0 : {
15235 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
15236 : 0 : if (!HONOR_NANS (captures[0])
15237 : : )
15238 : : {
15239 : 0 : gimple_seq *lseq = seq;
15240 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2403;
15241 : 0 : {
15242 : 0 : res_op->set_op (EQ_EXPR, type, 2);
15243 : 0 : res_op->ops[0] = captures[0];
15244 : 0 : res_op->ops[1] = captures[1];
15245 : 0 : res_op->resimplify (lseq, valueize);
15246 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1059, __FILE__, __LINE__, true);
15247 : 0 : return true;
15248 : : }
15249 : 0 : next_after_fail2403:;
15250 : : }
15251 : : }
15252 : : }
15253 : : }
15254 : 63227 : break;
15255 : : }
15256 : : default:;
15257 : : }
15258 : : }
15259 : : break;
15260 : 63227 : default:;
15261 : : }
15262 : 63227 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
15263 : : {
15264 : 44 : {
15265 : 44 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15266 : 44 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, MIN_EXPR, EQ_EXPR, LE_EXPR))
15267 : 44 : return true;
15268 : : }
15269 : : }
15270 : 63183 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
15271 : : {
15272 : 210 : {
15273 : 210 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
15274 : 210 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, MIN_EXPR, EQ_EXPR, LE_EXPR))
15275 : 210 : return true;
15276 : : }
15277 : : }
15278 : 80009681 : break;
15279 : : }
15280 : 6829 : case MAX_EXPR:
15281 : 6829 : {
15282 : 6829 : tree _q20 = gimple_assign_rhs1 (_a1);
15283 : 6829 : _q20 = do_valueize (valueize, _q20);
15284 : 6829 : tree _q21 = gimple_assign_rhs2 (_a1);
15285 : 6829 : _q21 = do_valueize (valueize, _q21);
15286 : 6829 : if (tree_swap_operands_p (_q20, _q21))
15287 : 84 : std::swap (_q20, _q21);
15288 : 6829 : switch (TREE_CODE (_p1))
15289 : : {
15290 : 447 : case SSA_NAME:
15291 : 447 : if (gimple *_d2 = get_def (valueize, _p1))
15292 : : {
15293 : 423 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15294 : 531 : switch (gimple_assign_rhs_code (_a2))
15295 : : {
15296 : 2 : case MIN_EXPR:
15297 : 2 : {
15298 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
15299 : 2 : _q50 = do_valueize (valueize, _q50);
15300 : 2 : tree _q51 = gimple_assign_rhs2 (_a2);
15301 : 2 : _q51 = do_valueize (valueize, _q51);
15302 : 2 : if (tree_swap_operands_p (_q50, _q51))
15303 : 0 : std::swap (_q50, _q51);
15304 : 2 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
15305 : : {
15306 : 2 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
15307 : : {
15308 : 2 : {
15309 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15310 : 2 : if (!HONOR_NANS (captures[0])
15311 : : )
15312 : : {
15313 : 2 : gimple_seq *lseq = seq;
15314 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2404;
15315 : 2 : {
15316 : 2 : res_op->set_op (EQ_EXPR, type, 2);
15317 : 2 : res_op->ops[0] = captures[0];
15318 : 2 : res_op->ops[1] = captures[1];
15319 : 2 : res_op->resimplify (lseq, valueize);
15320 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1059, __FILE__, __LINE__, true);
15321 : 2 : return true;
15322 : : }
15323 : 0 : next_after_fail2404:;
15324 : : }
15325 : : }
15326 : : }
15327 : : }
15328 : 0 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
15329 : : {
15330 : 0 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
15331 : : {
15332 : 0 : {
15333 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15334 : 0 : if (!HONOR_NANS (captures[0])
15335 : : )
15336 : : {
15337 : 0 : gimple_seq *lseq = seq;
15338 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2405;
15339 : 0 : {
15340 : 0 : res_op->set_op (EQ_EXPR, type, 2);
15341 : 0 : res_op->ops[0] = captures[0];
15342 : 0 : res_op->ops[1] = captures[1];
15343 : 0 : res_op->resimplify (lseq, valueize);
15344 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1059, __FILE__, __LINE__, true);
15345 : 0 : return true;
15346 : : }
15347 : 0 : next_after_fail2405:;
15348 : : }
15349 : : }
15350 : : }
15351 : : }
15352 : 6827 : break;
15353 : : }
15354 : : default:;
15355 : : }
15356 : : }
15357 : : break;
15358 : 6827 : default:;
15359 : : }
15360 : 6827 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
15361 : : {
15362 : 0 : {
15363 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15364 : 0 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, MAX_EXPR, EQ_EXPR, GE_EXPR))
15365 : 0 : return true;
15366 : : }
15367 : : }
15368 : 6827 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
15369 : : {
15370 : 5416 : {
15371 : 5416 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
15372 : 5416 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, MAX_EXPR, EQ_EXPR, GE_EXPR))
15373 : 5411 : return true;
15374 : : }
15375 : : }
15376 : 80009681 : break;
15377 : : }
15378 : : default:;
15379 : : }
15380 : : }
15381 : : break;
15382 : 80009681 : default:;
15383 : : }
15384 : 80009681 : if (gimple_with_possible_nonzero_bits (_p0, valueize))
15385 : : {
15386 : 78468127 : if (gimple_with_known_nonzero_bits (_p1, valueize))
15387 : : {
15388 : 66836497 : {
15389 : 66836497 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
15390 : 66836497 : if (gimple_simplify_252 (res_op, seq, valueize, type, captures, EQ_EXPR))
15391 : 8971 : return true;
15392 : : }
15393 : : }
15394 : : }
15395 : 80000710 : if (gimple_with_known_nonzero_bits (_p0, valueize))
15396 : : {
15397 : 58080172 : if (gimple_with_possible_nonzero_bits (_p1, valueize))
15398 : : {
15399 : 58080172 : {
15400 : 58080172 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
15401 : 58080172 : if (gimple_simplify_252 (res_op, seq, valueize, type, captures, EQ_EXPR))
15402 : 900 : return true;
15403 : : }
15404 : : }
15405 : : }
15406 : 79999810 : switch (TREE_CODE (_p1))
15407 : : {
15408 : 13133277 : case SSA_NAME:
15409 : 13133277 : if (gimple *_d1 = get_def (valueize, _p1))
15410 : : {
15411 : 4366284 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
15412 : 6439272 : switch (gimple_assign_rhs_code (_a1))
15413 : : {
15414 : 1247 : case MIN_EXPR:
15415 : 1247 : {
15416 : 1247 : tree _q30 = gimple_assign_rhs1 (_a1);
15417 : 1247 : _q30 = do_valueize (valueize, _q30);
15418 : 1247 : tree _q31 = gimple_assign_rhs2 (_a1);
15419 : 1247 : _q31 = do_valueize (valueize, _q31);
15420 : 1247 : if (tree_swap_operands_p (_q30, _q31))
15421 : 213 : std::swap (_q30, _q31);
15422 : 1247 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
15423 : : {
15424 : 37 : {
15425 : 37 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
15426 : 37 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, MIN_EXPR, EQ_EXPR, LE_EXPR))
15427 : 37 : return true;
15428 : : }
15429 : : }
15430 : 1210 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
15431 : : {
15432 : 20 : {
15433 : 20 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
15434 : 20 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, MIN_EXPR, EQ_EXPR, LE_EXPR))
15435 : 20 : return true;
15436 : : }
15437 : : }
15438 : 79999739 : break;
15439 : : }
15440 : 464 : case MAX_EXPR:
15441 : 464 : {
15442 : 464 : tree _q30 = gimple_assign_rhs1 (_a1);
15443 : 464 : _q30 = do_valueize (valueize, _q30);
15444 : 464 : tree _q31 = gimple_assign_rhs2 (_a1);
15445 : 464 : _q31 = do_valueize (valueize, _q31);
15446 : 464 : if (tree_swap_operands_p (_q30, _q31))
15447 : 4 : std::swap (_q30, _q31);
15448 : 464 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
15449 : : {
15450 : 0 : {
15451 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
15452 : 0 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, MAX_EXPR, EQ_EXPR, GE_EXPR))
15453 : 0 : return true;
15454 : : }
15455 : : }
15456 : 464 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
15457 : : {
15458 : 14 : {
15459 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
15460 : 14 : if (gimple_simplify_254 (res_op, seq, valueize, type, captures, MAX_EXPR, EQ_EXPR, GE_EXPR))
15461 : 14 : return true;
15462 : : }
15463 : : }
15464 : 79999739 : break;
15465 : : }
15466 : : default:;
15467 : : }
15468 : : }
15469 : : break;
15470 : 79999739 : default:;
15471 : : }
15472 : 79999739 : switch (TREE_CODE (_p0))
15473 : : {
15474 : 79154340 : case SSA_NAME:
15475 : 79154340 : if (gimple *_d1 = get_def (valueize, _p0))
15476 : : {
15477 : 27018214 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
15478 : 33187245 : switch (gimple_assign_rhs_code (_a1))
15479 : : {
15480 : 62973 : case MIN_EXPR:
15481 : 62973 : {
15482 : 62973 : tree _q20 = gimple_assign_rhs1 (_a1);
15483 : 62973 : _q20 = do_valueize (valueize, _q20);
15484 : 62973 : tree _q21 = gimple_assign_rhs2 (_a1);
15485 : 62973 : _q21 = do_valueize (valueize, _q21);
15486 : 62973 : if (tree_swap_operands_p (_q20, _q21))
15487 : 8822 : std::swap (_q20, _q21);
15488 : 62973 : switch (TREE_CODE (_q21))
15489 : : {
15490 : 5160 : case INTEGER_CST:
15491 : 5160 : {
15492 : 5160 : switch (TREE_CODE (_p1))
15493 : : {
15494 : 4946 : case INTEGER_CST:
15495 : 4946 : {
15496 : 4946 : {
15497 : 4946 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
15498 : 4946 : if (gimple_simplify_255 (res_op, seq, valueize, type, captures, EQ_EXPR))
15499 : 4946 : return true;
15500 : : }
15501 : 0 : break;
15502 : : }
15503 : : default:;
15504 : : }
15505 : : break;
15506 : : }
15507 : : default:;
15508 : : }
15509 : 79993721 : break;
15510 : : }
15511 : 1416 : case MAX_EXPR:
15512 : 1416 : {
15513 : 1416 : tree _q20 = gimple_assign_rhs1 (_a1);
15514 : 1416 : _q20 = do_valueize (valueize, _q20);
15515 : 1416 : tree _q21 = gimple_assign_rhs2 (_a1);
15516 : 1416 : _q21 = do_valueize (valueize, _q21);
15517 : 1416 : if (tree_swap_operands_p (_q20, _q21))
15518 : 84 : std::swap (_q20, _q21);
15519 : 1416 : switch (TREE_CODE (_q21))
15520 : : {
15521 : 632 : case INTEGER_CST:
15522 : 632 : {
15523 : 632 : switch (TREE_CODE (_p1))
15524 : : {
15525 : 203 : case INTEGER_CST:
15526 : 203 : {
15527 : 203 : {
15528 : 203 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
15529 : 203 : if (gimple_simplify_256 (res_op, seq, valueize, type, captures, EQ_EXPR))
15530 : 203 : return true;
15531 : : }
15532 : 0 : break;
15533 : : }
15534 : : default:;
15535 : : }
15536 : : break;
15537 : : }
15538 : 1213 : default:;
15539 : : }
15540 : 1213 : if (integer_zerop (_p1))
15541 : : {
15542 : 120 : {
15543 : 120 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
15544 : 120 : if (gimple_simplify_257 (res_op, seq, valueize, type, captures, EQ_EXPR))
15545 : 30 : return true;
15546 : : }
15547 : : }
15548 : 79993721 : break;
15549 : : }
15550 : 1252302 : case BIT_AND_EXPR:
15551 : 1252302 : {
15552 : 1252302 : tree _q20 = gimple_assign_rhs1 (_a1);
15553 : 1252302 : _q20 = do_valueize (valueize, _q20);
15554 : 1252302 : tree _q21 = gimple_assign_rhs2 (_a1);
15555 : 1252302 : _q21 = do_valueize (valueize, _q21);
15556 : 1252302 : if (tree_swap_operands_p (_q20, _q21))
15557 : 6776 : std::swap (_q20, _q21);
15558 : 1252302 : switch (TREE_CODE (_q20))
15559 : : {
15560 : 1252302 : case SSA_NAME:
15561 : 1252302 : if (gimple *_d2 = get_def (valueize, _q20))
15562 : : {
15563 : 1203046 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15564 : 1716477 : switch (gimple_assign_rhs_code (_a2))
15565 : : {
15566 : 1750 : case LSHIFT_EXPR:
15567 : 1750 : {
15568 : 1750 : tree _q30 = gimple_assign_rhs1 (_a2);
15569 : 1750 : _q30 = do_valueize (valueize, _q30);
15570 : 1750 : tree _q31 = gimple_assign_rhs2 (_a2);
15571 : 1750 : _q31 = do_valueize (valueize, _q31);
15572 : 1750 : if (integer_pow2p (_q30))
15573 : : {
15574 : 1197 : if (integer_pow2p (_q21))
15575 : : {
15576 : 1 : if (integer_zerop (_p1))
15577 : : {
15578 : 1 : {
15579 : 1 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
15580 : 1 : if (gimple_simplify_258 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR))
15581 : 1 : return true;
15582 : : }
15583 : : }
15584 : : }
15585 : : }
15586 : 1749 : switch (TREE_CODE (_q31))
15587 : : {
15588 : 501 : case INTEGER_CST:
15589 : 501 : {
15590 : 501 : switch (TREE_CODE (_q21))
15591 : : {
15592 : 501 : case INTEGER_CST:
15593 : 501 : {
15594 : 501 : switch (TREE_CODE (_p1))
15595 : : {
15596 : 501 : case INTEGER_CST:
15597 : 501 : {
15598 : 501 : {
15599 : 501 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
15600 : 501 : if (gimple_simplify_259 (res_op, seq, valueize, type, captures, EQ_EXPR))
15601 : 15 : return true;
15602 : : }
15603 : 486 : break;
15604 : : }
15605 : : default:;
15606 : : }
15607 : : break;
15608 : : }
15609 : : default:;
15610 : : }
15611 : : break;
15612 : : }
15613 : 1734 : default:;
15614 : : }
15615 : 1734 : if (integer_onep (_q30))
15616 : : {
15617 : 1206 : if (integer_pow2p (_q21))
15618 : : {
15619 : 0 : if (integer_zerop (_p1))
15620 : : {
15621 : 0 : {
15622 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _q21 };
15623 : 0 : if (gimple_simplify_260 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR))
15624 : 0 : return true;
15625 : : }
15626 : : }
15627 : : }
15628 : : }
15629 : : break;
15630 : : }
15631 : 27994 : case RSHIFT_EXPR:
15632 : 27994 : {
15633 : 27994 : tree _q30 = gimple_assign_rhs1 (_a2);
15634 : 27994 : _q30 = do_valueize (valueize, _q30);
15635 : 27994 : tree _q31 = gimple_assign_rhs2 (_a2);
15636 : 27994 : _q31 = do_valueize (valueize, _q31);
15637 : 27994 : if (integer_pow2p (_q30))
15638 : : {
15639 : 10 : if (integer_pow2p (_q21))
15640 : : {
15641 : 10 : if (integer_zerop (_p1))
15642 : : {
15643 : 10 : {
15644 : 10 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _q31, _q21 };
15645 : 10 : if (gimple_simplify_261 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR))
15646 : 10 : return true;
15647 : : }
15648 : : }
15649 : : }
15650 : : }
15651 : 27984 : switch (TREE_CODE (_q31))
15652 : : {
15653 : 8532 : case INTEGER_CST:
15654 : 8532 : {
15655 : 8532 : switch (TREE_CODE (_q21))
15656 : : {
15657 : 8506 : case INTEGER_CST:
15658 : 8506 : {
15659 : 8506 : switch (TREE_CODE (_p1))
15660 : : {
15661 : 8506 : case INTEGER_CST:
15662 : 8506 : {
15663 : 8506 : {
15664 : 8506 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _q21, _p1 };
15665 : 8506 : if (gimple_simplify_262 (res_op, seq, valueize, type, captures, EQ_EXPR))
15666 : 755 : return true;
15667 : : }
15668 : 7751 : break;
15669 : : }
15670 : : default:;
15671 : : }
15672 : : break;
15673 : : }
15674 : : default:;
15675 : : }
15676 : : break;
15677 : : }
15678 : : default:;
15679 : : }
15680 : : break;
15681 : : }
15682 : : default:;
15683 : : }
15684 : : }
15685 : : break;
15686 : 1251521 : default:;
15687 : : }
15688 : 1251521 : {
15689 : 1251521 : tree _q20_pops[1];
15690 : 1251521 : if (gimple_nop_convert (_q20, _q20_pops, valueize))
15691 : : {
15692 : 17608 : tree _q30 = _q20_pops[0];
15693 : 17608 : switch (TREE_CODE (_q30))
15694 : : {
15695 : 17486 : case SSA_NAME:
15696 : 17486 : if (gimple *_d2 = get_def (valueize, _q30))
15697 : : {
15698 : 17132 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15699 : 16484 : switch (gimple_assign_rhs_code (_a2))
15700 : : {
15701 : 2963 : case LSHIFT_EXPR:
15702 : 2963 : {
15703 : 2963 : tree _q40 = gimple_assign_rhs1 (_a2);
15704 : 2963 : _q40 = do_valueize (valueize, _q40);
15705 : 2963 : tree _q41 = gimple_assign_rhs2 (_a2);
15706 : 2963 : _q41 = do_valueize (valueize, _q41);
15707 : 2963 : if (integer_onep (_q40))
15708 : : {
15709 : 2963 : if (integer_pow2p (_q21))
15710 : : {
15711 : 2 : if (integer_zerop (_p1))
15712 : : {
15713 : 2 : {
15714 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q41, _q21 };
15715 : 2 : if (gimple_simplify_260 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR))
15716 : 2 : return true;
15717 : : }
15718 : : }
15719 : : }
15720 : : }
15721 : : break;
15722 : : }
15723 : : default:;
15724 : : }
15725 : : }
15726 : : break;
15727 : : default:;
15728 : : }
15729 : : }
15730 : : }
15731 : 1251519 : break;
15732 : : }
15733 : 4277 : case LSHIFT_EXPR:
15734 : 4277 : {
15735 : 4277 : tree _q20 = gimple_assign_rhs1 (_a1);
15736 : 4277 : _q20 = do_valueize (valueize, _q20);
15737 : 4277 : tree _q21 = gimple_assign_rhs2 (_a1);
15738 : 4277 : _q21 = do_valueize (valueize, _q21);
15739 : 4277 : switch (TREE_CODE (_q20))
15740 : : {
15741 : 487 : case INTEGER_CST:
15742 : 487 : {
15743 : 487 : switch (TREE_CODE (_p1))
15744 : : {
15745 : 116 : case INTEGER_CST:
15746 : 116 : {
15747 : 116 : {
15748 : 116 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
15749 : 116 : if (gimple_simplify_263 (res_op, seq, valueize, type, captures, EQ_EXPR))
15750 : 44 : return true;
15751 : : }
15752 : 72 : break;
15753 : : }
15754 : : default:;
15755 : : }
15756 : : break;
15757 : : }
15758 : : default:;
15759 : : }
15760 : : break;
15761 : : }
15762 : 0 : case LROTATE_EXPR:
15763 : 0 : {
15764 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
15765 : 0 : _q20 = do_valueize (valueize, _q20);
15766 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
15767 : 0 : _q21 = do_valueize (valueize, _q21);
15768 : 0 : switch (TREE_CODE (_p1))
15769 : : {
15770 : 0 : case SSA_NAME:
15771 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
15772 : : {
15773 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15774 : 0 : switch (gimple_assign_rhs_code (_a2))
15775 : : {
15776 : 0 : case LROTATE_EXPR:
15777 : 0 : {
15778 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
15779 : 0 : _q50 = do_valueize (valueize, _q50);
15780 : 0 : tree _q51 = gimple_assign_rhs2 (_a2);
15781 : 0 : _q51 = do_valueize (valueize, _q51);
15782 : 0 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
15783 : : {
15784 : 0 : {
15785 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
15786 : 0 : if (gimple_simplify_264 (res_op, seq, valueize, type, captures, LROTATE_EXPR, RROTATE_EXPR, EQ_EXPR))
15787 : 0 : return true;
15788 : : }
15789 : : }
15790 : : break;
15791 : : }
15792 : : default:;
15793 : : }
15794 : : }
15795 : : break;
15796 : 0 : default:;
15797 : : }
15798 : 0 : switch (TREE_CODE (_q21))
15799 : : {
15800 : 0 : case INTEGER_CST:
15801 : 0 : {
15802 : 0 : switch (TREE_CODE (_p1))
15803 : : {
15804 : 0 : case INTEGER_CST:
15805 : 0 : {
15806 : 0 : {
15807 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
15808 : 0 : if (gimple_simplify_265 (res_op, seq, valueize, type, captures, LROTATE_EXPR, RROTATE_EXPR, EQ_EXPR))
15809 : 0 : return true;
15810 : : }
15811 : 0 : break;
15812 : : }
15813 : : default:;
15814 : : }
15815 : : break;
15816 : : }
15817 : 0 : default:;
15818 : : }
15819 : 0 : switch (TREE_CODE (_p1))
15820 : : {
15821 : 0 : case INTEGER_CST:
15822 : 0 : {
15823 : 0 : {
15824 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
15825 : 0 : if (gimple_simplify_266 (res_op, seq, valueize, type, captures, LROTATE_EXPR, RROTATE_EXPR, EQ_EXPR))
15826 : 0 : return true;
15827 : : }
15828 : 0 : break;
15829 : : }
15830 : : default:;
15831 : : }
15832 : : break;
15833 : : }
15834 : 44 : case RROTATE_EXPR:
15835 : 44 : {
15836 : 44 : tree _q20 = gimple_assign_rhs1 (_a1);
15837 : 44 : _q20 = do_valueize (valueize, _q20);
15838 : 44 : tree _q21 = gimple_assign_rhs2 (_a1);
15839 : 44 : _q21 = do_valueize (valueize, _q21);
15840 : 44 : switch (TREE_CODE (_p1))
15841 : : {
15842 : 38 : case SSA_NAME:
15843 : 38 : if (gimple *_d2 = get_def (valueize, _p1))
15844 : : {
15845 : 38 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15846 : 74 : switch (gimple_assign_rhs_code (_a2))
15847 : : {
15848 : 2 : case RROTATE_EXPR:
15849 : 2 : {
15850 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
15851 : 2 : _q50 = do_valueize (valueize, _q50);
15852 : 2 : tree _q51 = gimple_assign_rhs2 (_a2);
15853 : 2 : _q51 = do_valueize (valueize, _q51);
15854 : 2 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
15855 : : {
15856 : 2 : {
15857 : 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
15858 : 2 : if (gimple_simplify_264 (res_op, seq, valueize, type, captures, RROTATE_EXPR, LROTATE_EXPR, EQ_EXPR))
15859 : 2 : return true;
15860 : : }
15861 : : }
15862 : : break;
15863 : : }
15864 : : default:;
15865 : : }
15866 : : }
15867 : : break;
15868 : 42 : default:;
15869 : : }
15870 : 42 : switch (TREE_CODE (_q21))
15871 : : {
15872 : 42 : case INTEGER_CST:
15873 : 42 : {
15874 : 42 : switch (TREE_CODE (_p1))
15875 : : {
15876 : 6 : case INTEGER_CST:
15877 : 6 : {
15878 : 6 : {
15879 : 6 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
15880 : 6 : if (gimple_simplify_265 (res_op, seq, valueize, type, captures, RROTATE_EXPR, LROTATE_EXPR, EQ_EXPR))
15881 : 6 : return true;
15882 : : }
15883 : 0 : break;
15884 : : }
15885 : : default:;
15886 : : }
15887 : : break;
15888 : : }
15889 : 36 : default:;
15890 : : }
15891 : 36 : switch (TREE_CODE (_p1))
15892 : : {
15893 : 0 : case INTEGER_CST:
15894 : 0 : {
15895 : 0 : {
15896 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
15897 : 0 : if (gimple_simplify_266 (res_op, seq, valueize, type, captures, RROTATE_EXPR, LROTATE_EXPR, EQ_EXPR))
15898 : 0 : return true;
15899 : : }
15900 : 0 : break;
15901 : : }
15902 : : default:;
15903 : : }
15904 : : break;
15905 : : }
15906 : 90577 : case MULT_EXPR:
15907 : 90577 : {
15908 : 90577 : tree _q20 = gimple_assign_rhs1 (_a1);
15909 : 90577 : _q20 = do_valueize (valueize, _q20);
15910 : 90577 : tree _q21 = gimple_assign_rhs2 (_a1);
15911 : 90577 : _q21 = do_valueize (valueize, _q21);
15912 : 90577 : if (tree_swap_operands_p (_q20, _q21))
15913 : 460 : std::swap (_q20, _q21);
15914 : 90577 : switch (TREE_CODE (_q20))
15915 : : {
15916 : 90417 : case SSA_NAME:
15917 : 90417 : if (gimple *_d2 = get_def (valueize, _q20))
15918 : : {
15919 : 90011 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15920 : 92840 : switch (gimple_assign_rhs_code (_a2))
15921 : : {
15922 : 517 : case TRUNC_DIV_EXPR:
15923 : 517 : {
15924 : 517 : tree _q30 = gimple_assign_rhs1 (_a2);
15925 : 517 : _q30 = do_valueize (valueize, _q30);
15926 : 517 : tree _q31 = gimple_assign_rhs2 (_a2);
15927 : 517 : _q31 = do_valueize (valueize, _q31);
15928 : 517 : if ((_q21 == _q31 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q31, 0) && types_match (_q21, _q31)))
15929 : : {
15930 : 21 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
15931 : : {
15932 : 17 : {
15933 : 17 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q31 };
15934 : 17 : if (gimple_simplify_267 (res_op, seq, valueize, type, captures))
15935 : 4 : return true;
15936 : : }
15937 : : }
15938 : : }
15939 : : break;
15940 : : }
15941 : : default:;
15942 : : }
15943 : : }
15944 : : break;
15945 : 90573 : default:;
15946 : : }
15947 : 90573 : switch (TREE_CODE (_q21))
15948 : : {
15949 : 6554 : case SSA_NAME:
15950 : 6554 : if (gimple *_d2 = get_def (valueize, _q21))
15951 : : {
15952 : 6460 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
15953 : 5780 : switch (gimple_assign_rhs_code (_a2))
15954 : : {
15955 : 6 : case TRUNC_DIV_EXPR:
15956 : 6 : {
15957 : 6 : tree _q40 = gimple_assign_rhs1 (_a2);
15958 : 6 : _q40 = do_valueize (valueize, _q40);
15959 : 6 : tree _q41 = gimple_assign_rhs2 (_a2);
15960 : 6 : _q41 = do_valueize (valueize, _q41);
15961 : 6 : if ((_q41 == _q20 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q20, 0) && types_match (_q41, _q20)))
15962 : : {
15963 : 3 : if ((_p1 == _q40 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q40, 0) && types_match (_p1, _q40)))
15964 : : {
15965 : 0 : {
15966 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q21, _q40, _q20 };
15967 : 0 : if (gimple_simplify_267 (res_op, seq, valueize, type, captures))
15968 : 0 : return true;
15969 : : }
15970 : : }
15971 : : }
15972 : : break;
15973 : : }
15974 : : default:;
15975 : : }
15976 : : }
15977 : : break;
15978 : : default:;
15979 : : }
15980 : 79993721 : break;
15981 : : }
15982 : : default:;
15983 : : }
15984 : : }
15985 : : break;
15986 : 79993721 : default:;
15987 : : }
15988 : 79993721 : switch (TREE_CODE (_p1))
15989 : : {
15990 : 13133200 : case SSA_NAME:
15991 : 13133200 : if (gimple *_d1 = get_def (valueize, _p1))
15992 : : {
15993 : 4366207 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
15994 : 6439199 : switch (gimple_assign_rhs_code (_a1))
15995 : : {
15996 : 110992 : case MULT_EXPR:
15997 : 110992 : {
15998 : 110992 : tree _q30 = gimple_assign_rhs1 (_a1);
15999 : 110992 : _q30 = do_valueize (valueize, _q30);
16000 : 110992 : tree _q31 = gimple_assign_rhs2 (_a1);
16001 : 110992 : _q31 = do_valueize (valueize, _q31);
16002 : 110992 : if (tree_swap_operands_p (_q30, _q31))
16003 : 102 : std::swap (_q30, _q31);
16004 : 110992 : switch (TREE_CODE (_q30))
16005 : : {
16006 : 110992 : case SSA_NAME:
16007 : 110992 : if (gimple *_d2 = get_def (valueize, _q30))
16008 : : {
16009 : 110209 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16010 : 110928 : switch (gimple_assign_rhs_code (_a2))
16011 : : {
16012 : 82 : case TRUNC_DIV_EXPR:
16013 : 82 : {
16014 : 82 : tree _q40 = gimple_assign_rhs1 (_a2);
16015 : 82 : _q40 = do_valueize (valueize, _q40);
16016 : 82 : tree _q41 = gimple_assign_rhs2 (_a2);
16017 : 82 : _q41 = do_valueize (valueize, _q41);
16018 : 82 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
16019 : : {
16020 : 48 : if ((_q31 == _q41 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _q41, 0) && types_match (_q31, _q41)))
16021 : : {
16022 : 48 : {
16023 : 48 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q41 };
16024 : 48 : if (gimple_simplify_267 (res_op, seq, valueize, type, captures))
16025 : 0 : return true;
16026 : : }
16027 : : }
16028 : : }
16029 : : break;
16030 : : }
16031 : : default:;
16032 : : }
16033 : : }
16034 : : break;
16035 : 110992 : default:;
16036 : : }
16037 : 110992 : switch (TREE_CODE (_q31))
16038 : : {
16039 : 5335 : case SSA_NAME:
16040 : 5335 : if (gimple *_d2 = get_def (valueize, _q31))
16041 : : {
16042 : 5300 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16043 : 5036 : switch (gimple_assign_rhs_code (_a2))
16044 : : {
16045 : 43 : case TRUNC_DIV_EXPR:
16046 : 43 : {
16047 : 43 : tree _q50 = gimple_assign_rhs1 (_a2);
16048 : 43 : _q50 = do_valueize (valueize, _q50);
16049 : 43 : tree _q51 = gimple_assign_rhs2 (_a2);
16050 : 43 : _q51 = do_valueize (valueize, _q51);
16051 : 43 : if ((_q50 == _p0 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _p0, 0) && types_match (_q50, _p0)))
16052 : : {
16053 : 43 : if ((_q51 == _q30 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q30, 0) && types_match (_q51, _q30)))
16054 : : {
16055 : 43 : {
16056 : 43 : tree captures[3] ATTRIBUTE_UNUSED = { _q31, _p0, _q30 };
16057 : 43 : if (gimple_simplify_267 (res_op, seq, valueize, type, captures))
16058 : 2 : return true;
16059 : : }
16060 : : }
16061 : : }
16062 : : break;
16063 : : }
16064 : : default:;
16065 : : }
16066 : : }
16067 : : break;
16068 : : default:;
16069 : : }
16070 : 79993719 : break;
16071 : : }
16072 : : default:;
16073 : : }
16074 : : }
16075 : : break;
16076 : 79993719 : default:;
16077 : : }
16078 : 79993719 : switch (TREE_CODE (_p0))
16079 : : {
16080 : 79148320 : case SSA_NAME:
16081 : 79148320 : if (gimple *_d1 = get_def (valueize, _p0))
16082 : : {
16083 : 27012194 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16084 : 33181223 : switch (gimple_assign_rhs_code (_a1))
16085 : : {
16086 : 196 : case VEC_COND_EXPR:
16087 : 196 : {
16088 : 196 : tree _q20 = gimple_assign_rhs1 (_a1);
16089 : 196 : _q20 = do_valueize (valueize, _q20);
16090 : 196 : tree _q21 = gimple_assign_rhs2 (_a1);
16091 : 196 : _q21 = do_valueize (valueize, _q21);
16092 : 196 : tree _q22 = gimple_assign_rhs3 (_a1);
16093 : 196 : _q22 = do_valueize (valueize, _q22);
16094 : 196 : switch (TREE_CODE (_p1))
16095 : : {
16096 : 147 : case SSA_NAME:
16097 : 147 : if (gimple *_d2 = get_def (valueize, _p1))
16098 : : {
16099 : 147 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16100 : 200 : switch (gimple_assign_rhs_code (_a2))
16101 : : {
16102 : 94 : case VEC_COND_EXPR:
16103 : 94 : {
16104 : 94 : tree _q60 = gimple_assign_rhs1 (_a2);
16105 : 94 : _q60 = do_valueize (valueize, _q60);
16106 : 94 : tree _q61 = gimple_assign_rhs2 (_a2);
16107 : 94 : _q61 = do_valueize (valueize, _q61);
16108 : 94 : tree _q62 = gimple_assign_rhs3 (_a2);
16109 : 94 : _q62 = do_valueize (valueize, _q62);
16110 : 94 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
16111 : : {
16112 : 0 : {
16113 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
16114 : 0 : if (VECTOR_TYPE_P (type)
16115 : 0 : && (TREE_CODE_CLASS (EQ_EXPR) != tcc_comparison
16116 : 0 : || types_match (type, TREE_TYPE (captures[2]))
16117 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
16118 : : || (optimize_vectors_before_lowering_p ()
16119 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
16120 : : )
16121 : : {
16122 : 0 : gimple_seq *lseq = seq;
16123 : 0 : if (lseq
16124 : 0 : && (!single_use (captures[0])
16125 : 0 : || !single_use (captures[4])))
16126 : 0 : lseq = NULL;
16127 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2406;
16128 : 0 : {
16129 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
16130 : 0 : res_op->ops[0] = captures[1];
16131 : 0 : {
16132 : 0 : tree _o1[2], _r1;
16133 : 0 : _o1[0] = captures[2];
16134 : 0 : _o1[1] = captures[5];
16135 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), EQ_EXPR, type, _o1[0], _o1[1]);
16136 : 0 : tem_op.resimplify (NULL, valueize);
16137 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16138 : 0 : if (!_r1) goto next_after_fail2406;
16139 : 0 : res_op->ops[1] = _r1;
16140 : : }
16141 : 0 : {
16142 : 0 : tree _o1[2], _r1;
16143 : 0 : _o1[0] = captures[3];
16144 : 0 : _o1[1] = captures[6];
16145 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), EQ_EXPR, type, _o1[0], _o1[1]);
16146 : 0 : tem_op.resimplify (NULL, valueize);
16147 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16148 : 0 : if (!_r1) goto next_after_fail2406;
16149 : 0 : res_op->ops[2] = _r1;
16150 : : }
16151 : 0 : res_op->resimplify (lseq, valueize);
16152 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
16153 : 0 : return true;
16154 : : }
16155 : 0 : next_after_fail2406:;
16156 : : }
16157 : : }
16158 : : }
16159 : : break;
16160 : : }
16161 : : default:;
16162 : : }
16163 : : }
16164 : : break;
16165 : 196 : default:;
16166 : : }
16167 : 196 : {
16168 : 196 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
16169 : 196 : if (VECTOR_TYPE_P (type)
16170 : 196 : && (TREE_CODE_CLASS (EQ_EXPR) != tcc_comparison
16171 : 196 : || types_match (type, TREE_TYPE (captures[2]))
16172 : 196 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
16173 : : || (optimize_vectors_before_lowering_p ()
16174 : 86 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
16175 : : )
16176 : : {
16177 : 196 : gimple_seq *lseq = seq;
16178 : 196 : if (lseq
16179 : 70 : && (!single_use (captures[0])))
16180 : 134 : lseq = NULL;
16181 : 196 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2407;
16182 : 196 : {
16183 : 196 : res_op->set_op (VEC_COND_EXPR, type, 3);
16184 : 196 : res_op->ops[0] = captures[1];
16185 : 196 : {
16186 : 196 : tree _o1[2], _r1;
16187 : 196 : _o1[0] = captures[2];
16188 : 196 : _o1[1] = captures[4];
16189 : 196 : gimple_match_op tem_op (res_op->cond.any_else (), EQ_EXPR, type, _o1[0], _o1[1]);
16190 : 196 : tem_op.resimplify (NULL, valueize);
16191 : 196 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16192 : 196 : if (!_r1) goto next_after_fail2407;
16193 : 57 : res_op->ops[1] = _r1;
16194 : : }
16195 : 57 : {
16196 : 57 : tree _o1[2], _r1;
16197 : 57 : _o1[0] = captures[3];
16198 : 57 : _o1[1] = captures[4];
16199 : 57 : gimple_match_op tem_op (res_op->cond.any_else (), EQ_EXPR, type, _o1[0], _o1[1]);
16200 : 57 : tem_op.resimplify (NULL, valueize);
16201 : 57 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16202 : 57 : if (!_r1) goto next_after_fail2407;
16203 : 46 : res_op->ops[2] = _r1;
16204 : : }
16205 : 46 : res_op->resimplify (lseq, valueize);
16206 : 46 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
16207 : 46 : return true;
16208 : : }
16209 : 150 : next_after_fail2407:;
16210 : : }
16211 : : }
16212 : 150 : break;
16213 : : }
16214 : : default:;
16215 : : }
16216 : 8463938 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
16217 : 4825445 : switch (gimple_call_combined_fn (_c1))
16218 : : {
16219 : 0 : case CFN_BUILT_IN_BSWAP128:
16220 : 0 : if (gimple_call_num_args (_c1) == 1)
16221 : : {
16222 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
16223 : 0 : _q20 = do_valueize (valueize, _q20);
16224 : 0 : switch (TREE_CODE (_p1))
16225 : : {
16226 : 0 : case SSA_NAME:
16227 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
16228 : : {
16229 : 0 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
16230 : 0 : switch (gimple_call_combined_fn (_c2))
16231 : : {
16232 : 0 : case CFN_BUILT_IN_BSWAP128:
16233 : 0 : if (gimple_call_num_args (_c2) == 1)
16234 : : {
16235 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
16236 : 0 : _q40 = do_valueize (valueize, _q40);
16237 : 0 : {
16238 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
16239 : 0 : if (gimple_simplify_268 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_BSWAP128))
16240 : 0 : return true;
16241 : : }
16242 : : }
16243 : : break;
16244 : : default:;
16245 : : }
16246 : : }
16247 : : break;
16248 : 0 : case INTEGER_CST:
16249 : 0 : {
16250 : 0 : {
16251 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
16252 : 0 : if (gimple_simplify_269 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_BSWAP128))
16253 : 0 : return true;
16254 : : }
16255 : 0 : break;
16256 : : }
16257 : : default:;
16258 : : }
16259 : : }
16260 : : break;
16261 : 51 : case CFN_BUILT_IN_BSWAP16:
16262 : 51 : if (gimple_call_num_args (_c1) == 1)
16263 : : {
16264 : 51 : tree _q20 = gimple_call_arg (_c1, 0);
16265 : 51 : _q20 = do_valueize (valueize, _q20);
16266 : 51 : switch (TREE_CODE (_p1))
16267 : : {
16268 : 21 : case SSA_NAME:
16269 : 21 : if (gimple *_d2 = get_def (valueize, _p1))
16270 : : {
16271 : 21 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
16272 : 21 : switch (gimple_call_combined_fn (_c2))
16273 : : {
16274 : 21 : case CFN_BUILT_IN_BSWAP16:
16275 : 21 : if (gimple_call_num_args (_c2) == 1)
16276 : : {
16277 : 21 : tree _q40 = gimple_call_arg (_c2, 0);
16278 : 21 : _q40 = do_valueize (valueize, _q40);
16279 : 21 : {
16280 : 21 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
16281 : 21 : if (gimple_simplify_268 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_BSWAP16))
16282 : 21 : return true;
16283 : : }
16284 : : }
16285 : : break;
16286 : : default:;
16287 : : }
16288 : : }
16289 : : break;
16290 : 30 : case INTEGER_CST:
16291 : 30 : {
16292 : 30 : {
16293 : 30 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
16294 : 30 : if (gimple_simplify_269 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_BSWAP16))
16295 : 30 : return true;
16296 : : }
16297 : 0 : break;
16298 : : }
16299 : : default:;
16300 : : }
16301 : : }
16302 : : break;
16303 : 73 : case CFN_BUILT_IN_BSWAP32:
16304 : 73 : if (gimple_call_num_args (_c1) == 1)
16305 : : {
16306 : 73 : tree _q20 = gimple_call_arg (_c1, 0);
16307 : 73 : _q20 = do_valueize (valueize, _q20);
16308 : 73 : switch (TREE_CODE (_p1))
16309 : : {
16310 : 14 : case SSA_NAME:
16311 : 14 : if (gimple *_d2 = get_def (valueize, _p1))
16312 : : {
16313 : 14 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
16314 : 14 : switch (gimple_call_combined_fn (_c2))
16315 : : {
16316 : 14 : case CFN_BUILT_IN_BSWAP32:
16317 : 14 : if (gimple_call_num_args (_c2) == 1)
16318 : : {
16319 : 14 : tree _q40 = gimple_call_arg (_c2, 0);
16320 : 14 : _q40 = do_valueize (valueize, _q40);
16321 : 14 : {
16322 : 14 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
16323 : 14 : if (gimple_simplify_268 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_BSWAP32))
16324 : 14 : return true;
16325 : : }
16326 : : }
16327 : : break;
16328 : : default:;
16329 : : }
16330 : : }
16331 : : break;
16332 : 59 : case INTEGER_CST:
16333 : 59 : {
16334 : 59 : {
16335 : 59 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
16336 : 59 : if (gimple_simplify_269 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_BSWAP32))
16337 : 59 : return true;
16338 : : }
16339 : 0 : break;
16340 : : }
16341 : : default:;
16342 : : }
16343 : : }
16344 : : break;
16345 : 24 : case CFN_BUILT_IN_BSWAP64:
16346 : 24 : if (gimple_call_num_args (_c1) == 1)
16347 : : {
16348 : 24 : tree _q20 = gimple_call_arg (_c1, 0);
16349 : 24 : _q20 = do_valueize (valueize, _q20);
16350 : 24 : switch (TREE_CODE (_p1))
16351 : : {
16352 : 0 : case SSA_NAME:
16353 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
16354 : : {
16355 : 0 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
16356 : 0 : switch (gimple_call_combined_fn (_c2))
16357 : : {
16358 : 0 : case CFN_BUILT_IN_BSWAP64:
16359 : 0 : if (gimple_call_num_args (_c2) == 1)
16360 : : {
16361 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
16362 : 0 : _q40 = do_valueize (valueize, _q40);
16363 : 0 : {
16364 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
16365 : 0 : if (gimple_simplify_268 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_BSWAP64))
16366 : 0 : return true;
16367 : : }
16368 : : }
16369 : : break;
16370 : : default:;
16371 : : }
16372 : : }
16373 : : break;
16374 : 24 : case INTEGER_CST:
16375 : 24 : {
16376 : 24 : {
16377 : 24 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
16378 : 24 : if (gimple_simplify_269 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_BSWAP64))
16379 : 24 : return true;
16380 : : }
16381 : 0 : break;
16382 : : }
16383 : : default:;
16384 : : }
16385 : : }
16386 : : break;
16387 : : default:;
16388 : : }
16389 : : }
16390 : : break;
16391 : 79993525 : default:;
16392 : : }
16393 : 79993525 : switch (TREE_CODE (_p1))
16394 : : {
16395 : 13133163 : case SSA_NAME:
16396 : 13133163 : if (gimple *_d1 = get_def (valueize, _p1))
16397 : : {
16398 : 4366170 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16399 : 6439197 : switch (gimple_assign_rhs_code (_a1))
16400 : : {
16401 : 271 : case VEC_COND_EXPR:
16402 : 271 : {
16403 : 271 : tree _q30 = gimple_assign_rhs1 (_a1);
16404 : 271 : _q30 = do_valueize (valueize, _q30);
16405 : 271 : tree _q31 = gimple_assign_rhs2 (_a1);
16406 : 271 : _q31 = do_valueize (valueize, _q31);
16407 : 271 : tree _q32 = gimple_assign_rhs3 (_a1);
16408 : 271 : _q32 = do_valueize (valueize, _q32);
16409 : 271 : {
16410 : 271 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
16411 : 271 : if (VECTOR_TYPE_P (type)
16412 : 271 : && (TREE_CODE_CLASS (EQ_EXPR) != tcc_comparison
16413 : 271 : || types_match (type, TREE_TYPE (captures[3]))
16414 : 271 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
16415 : : || (optimize_vectors_before_lowering_p ()
16416 : 222 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
16417 : : )
16418 : : {
16419 : 271 : gimple_seq *lseq = seq;
16420 : 271 : if (lseq
16421 : 43 : && (!single_use (captures[1])))
16422 : 228 : lseq = NULL;
16423 : 271 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2408;
16424 : 271 : {
16425 : 271 : res_op->set_op (VEC_COND_EXPR, type, 3);
16426 : 271 : res_op->ops[0] = captures[2];
16427 : 271 : {
16428 : 271 : tree _o1[2], _r1;
16429 : 271 : _o1[0] = captures[0];
16430 : 271 : _o1[1] = captures[3];
16431 : 271 : gimple_match_op tem_op (res_op->cond.any_else (), EQ_EXPR, type, _o1[0], _o1[1]);
16432 : 271 : tem_op.resimplify (NULL, valueize);
16433 : 271 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16434 : 271 : if (!_r1) goto next_after_fail2408;
16435 : 20 : res_op->ops[1] = _r1;
16436 : : }
16437 : 20 : {
16438 : 20 : tree _o1[2], _r1;
16439 : 20 : _o1[0] = captures[0];
16440 : 20 : _o1[1] = captures[4];
16441 : 20 : gimple_match_op tem_op (res_op->cond.any_else (), EQ_EXPR, type, _o1[0], _o1[1]);
16442 : 20 : tem_op.resimplify (NULL, valueize);
16443 : 20 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
16444 : 20 : if (!_r1) goto next_after_fail2408;
16445 : 0 : res_op->ops[2] = _r1;
16446 : : }
16447 : 0 : res_op->resimplify (lseq, valueize);
16448 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
16449 : 0 : return true;
16450 : : }
16451 : 271 : next_after_fail2408:;
16452 : : }
16453 : : }
16454 : 271 : break;
16455 : : }
16456 : : default:;
16457 : : }
16458 : : }
16459 : : break;
16460 : 79993525 : default:;
16461 : : }
16462 : 79993525 : switch (TREE_CODE (_p0))
16463 : : {
16464 : 79148126 : case SSA_NAME:
16465 : 79148126 : if (gimple *_d1 = get_def (valueize, _p0))
16466 : : {
16467 : 27012000 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
16468 : 33181177 : switch (gimple_assign_rhs_code (_a1))
16469 : : {
16470 : 12954 : case COND_EXPR:
16471 : 12954 : {
16472 : 12954 : tree _q20 = gimple_assign_rhs1 (_a1);
16473 : 12954 : _q20 = do_valueize (valueize, _q20);
16474 : 12954 : tree _q21 = gimple_assign_rhs2 (_a1);
16475 : 12954 : _q21 = do_valueize (valueize, _q21);
16476 : 12954 : tree _q22 = gimple_assign_rhs3 (_a1);
16477 : 12954 : _q22 = do_valueize (valueize, _q22);
16478 : 12954 : switch (TREE_CODE (_p1))
16479 : : {
16480 : 12274 : case SSA_NAME:
16481 : 12274 : if (gimple *_d2 = get_def (valueize, _p1))
16482 : : {
16483 : 12272 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16484 : 12353 : switch (gimple_assign_rhs_code (_a2))
16485 : : {
16486 : 62 : case COND_EXPR:
16487 : 62 : {
16488 : 62 : tree _q60 = gimple_assign_rhs1 (_a2);
16489 : 62 : _q60 = do_valueize (valueize, _q60);
16490 : 62 : tree _q61 = gimple_assign_rhs2 (_a2);
16491 : 62 : _q61 = do_valueize (valueize, _q61);
16492 : 62 : tree _q62 = gimple_assign_rhs3 (_a2);
16493 : 62 : _q62 = do_valueize (valueize, _q62);
16494 : 62 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
16495 : : {
16496 : 2 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
16497 : : {
16498 : 2 : {
16499 : 2 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
16500 : 2 : const enum tree_code eqne = EQ_EXPR;
16501 : 2 : if (!HONOR_NANS (captures[1])
16502 : 2 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
16503 : 4 : && types_match (type, TREE_TYPE (captures[0]))
16504 : : )
16505 : : {
16506 : 2 : gimple_seq *lseq = seq;
16507 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2409;
16508 : 2 : {
16509 : 2 : res_op->set_op (COND_EXPR, type, 3);
16510 : 2 : {
16511 : 2 : tree _o1[2], _r1;
16512 : 2 : {
16513 : 2 : tree _o2[2], _r2;
16514 : 2 : _o2[0] = captures[0];
16515 : 2 : if (COMPARISON_CLASS_P (_o2[0]))
16516 : : {
16517 : 0 : if (!seq) return false;
16518 : 0 : _o2[0] = gimple_build (seq, TREE_CODE (_o2[0]), TREE_TYPE (_o2[0]), TREE_OPERAND (_o2[0], 0), TREE_OPERAND (_o2[0], 1));
16519 : : }
16520 : 2 : _o2[1] = captures[3];
16521 : 2 : if (COMPARISON_CLASS_P (_o2[1]))
16522 : : {
16523 : 0 : if (!seq) return false;
16524 : 0 : _o2[1] = gimple_build (seq, TREE_CODE (_o2[1]), TREE_TYPE (_o2[1]), TREE_OPERAND (_o2[1], 0), TREE_OPERAND (_o2[1], 1));
16525 : : }
16526 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
16527 : 2 : tem_op.resimplify (lseq, valueize);
16528 : 2 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
16529 : 2 : if (!_r2) goto next_after_fail2409;
16530 : 1 : _o1[0] = _r2;
16531 : : }
16532 : 1 : {
16533 : 1 : tree _o2[2], _r2;
16534 : 1 : _o2[0] = captures[1];
16535 : 1 : _o2[1] = captures[2];
16536 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o2[0], _o2[1]);
16537 : 1 : tem_op.resimplify (lseq, valueize);
16538 : 1 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
16539 : 1 : if (!_r2) goto next_after_fail2409;
16540 : 1 : _o1[1] = _r2;
16541 : : }
16542 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
16543 : 1 : tem_op.resimplify (lseq, valueize);
16544 : 1 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
16545 : 1 : if (!_r1) goto next_after_fail2409;
16546 : 1 : res_op->ops[0] = _r1;
16547 : : }
16548 : 1 : res_op->ops[1] = constant_boolean_node (eqne == NE_EXPR, type);
16549 : 1 : res_op->ops[2] = constant_boolean_node (eqne != NE_EXPR, type);
16550 : 1 : res_op->resimplify (lseq, valueize);
16551 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1149, __FILE__, __LINE__, true);
16552 : 1 : return true;
16553 : : }
16554 : 1 : next_after_fail2409:;
16555 : : }
16556 : : }
16557 : : }
16558 : : }
16559 : 61 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
16560 : : {
16561 : 28 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
16562 : : {
16563 : 28 : {
16564 : 28 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
16565 : 28 : const enum tree_code eqne = EQ_EXPR;
16566 : 28 : if (!HONOR_NANS (captures[1])
16567 : 2 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
16568 : 30 : && types_match (type, TREE_TYPE (captures[0]))
16569 : : )
16570 : : {
16571 : 2 : gimple_seq *lseq = seq;
16572 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2410;
16573 : 2 : {
16574 : 2 : res_op->set_op (COND_EXPR, type, 3);
16575 : 2 : {
16576 : 2 : tree _o1[2], _r1;
16577 : 2 : {
16578 : 2 : tree _o2[2], _r2;
16579 : 2 : _o2[0] = captures[0];
16580 : 2 : if (COMPARISON_CLASS_P (_o2[0]))
16581 : : {
16582 : 0 : if (!seq) return false;
16583 : 0 : _o2[0] = gimple_build (seq, TREE_CODE (_o2[0]), TREE_TYPE (_o2[0]), TREE_OPERAND (_o2[0], 0), TREE_OPERAND (_o2[0], 1));
16584 : : }
16585 : 2 : _o2[1] = captures[3];
16586 : 2 : if (COMPARISON_CLASS_P (_o2[1]))
16587 : : {
16588 : 0 : if (!seq) return false;
16589 : 0 : _o2[1] = gimple_build (seq, TREE_CODE (_o2[1]), TREE_TYPE (_o2[1]), TREE_OPERAND (_o2[1], 0), TREE_OPERAND (_o2[1], 1));
16590 : : }
16591 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
16592 : 2 : tem_op.resimplify (lseq, valueize);
16593 : 2 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
16594 : 2 : if (!_r2) goto next_after_fail2410;
16595 : 1 : _o1[0] = _r2;
16596 : : }
16597 : 1 : {
16598 : 1 : tree _o2[2], _r2;
16599 : 1 : _o2[0] = captures[1];
16600 : 1 : _o2[1] = captures[2];
16601 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), EQ_EXPR, type, _o2[0], _o2[1]);
16602 : 1 : tem_op.resimplify (lseq, valueize);
16603 : 1 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
16604 : 1 : if (!_r2) goto next_after_fail2410;
16605 : 1 : _o1[1] = _r2;
16606 : : }
16607 : 1 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
16608 : 1 : tem_op.resimplify (lseq, valueize);
16609 : 1 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
16610 : 1 : if (!_r1) goto next_after_fail2410;
16611 : 1 : res_op->ops[0] = _r1;
16612 : : }
16613 : 1 : res_op->ops[1] = constant_boolean_node (eqne != NE_EXPR, type);
16614 : 1 : res_op->ops[2] = constant_boolean_node (eqne == NE_EXPR, type);
16615 : 1 : res_op->resimplify (lseq, valueize);
16616 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1150, __FILE__, __LINE__, true);
16617 : 1 : return true;
16618 : : }
16619 : 27 : next_after_fail2410:;
16620 : : }
16621 : : }
16622 : : }
16623 : : }
16624 : : break;
16625 : : }
16626 : : default:;
16627 : : }
16628 : : }
16629 : : break;
16630 : : default:;
16631 : : }
16632 : : break;
16633 : : }
16634 : 150 : case VEC_COND_EXPR:
16635 : 150 : {
16636 : 150 : tree _q20 = gimple_assign_rhs1 (_a1);
16637 : 150 : _q20 = do_valueize (valueize, _q20);
16638 : 150 : tree _q21 = gimple_assign_rhs2 (_a1);
16639 : 150 : _q21 = do_valueize (valueize, _q21);
16640 : 150 : tree _q22 = gimple_assign_rhs3 (_a1);
16641 : 150 : _q22 = do_valueize (valueize, _q22);
16642 : 150 : switch (TREE_CODE (_p1))
16643 : : {
16644 : 147 : case SSA_NAME:
16645 : 147 : if (gimple *_d2 = get_def (valueize, _p1))
16646 : : {
16647 : 147 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
16648 : 200 : switch (gimple_assign_rhs_code (_a2))
16649 : : {
16650 : 94 : case VEC_COND_EXPR:
16651 : 94 : {
16652 : 94 : tree _q60 = gimple_assign_rhs1 (_a2);
16653 : 94 : _q60 = do_valueize (valueize, _q60);
16654 : 94 : tree _q61 = gimple_assign_rhs2 (_a2);
16655 : 94 : _q61 = do_valueize (valueize, _q61);
16656 : 94 : tree _q62 = gimple_assign_rhs3 (_a2);
16657 : 94 : _q62 = do_valueize (valueize, _q62);
16658 : 94 : if ((_q61 == _q21 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q21, 0) && types_match (_q61, _q21)))
16659 : : {
16660 : 14 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
16661 : : {
16662 : 14 : {
16663 : 14 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
16664 : 14 : const enum tree_code eqne = EQ_EXPR;
16665 : 14 : if (!HONOR_NANS (captures[1])
16666 : 14 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
16667 : 28 : && types_match (type, TREE_TYPE (captures[0]))
16668 : : )
16669 : : {
16670 : 14 : gimple_seq *lseq = seq;
16671 : 14 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2411;
16672 : 14 : {
16673 : 14 : res_op->set_op (VEC_COND_EXPR, type, 3);
16674 : 14 : {
16675 : 14 : tree _o1[2], _r1;
16676 : 14 : {
16677 : 14 : tree _o2[2], _r2;
16678 : 14 : _o2[0] = captures[0];
16679 : 14 : _o2[1] = captures[3];
16680 : 14 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
16681 : 14 : tem_op.resimplify (lseq, valueize);
16682 : 14 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
16683 : 14 : if (!_r2) goto next_after_fail2411;
16684 : 4 : _o1[0] = _r2;
16685 : : }
16686 : 4 : {
16687 : 4 : tree _o2[2], _r2;
16688 : 4 : _o2[0] = captures[1];
16689 : 4 : _o2[1] = captures[2];
16690 : 4 : gimple_match_op tem_op (res_op->cond.any_else (), NE_EXPR, type, _o2[0], _o2[1]);
16691 : 4 : tem_op.resimplify (lseq, valueize);
16692 : 4 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
16693 : 4 : if (!_r2) goto next_after_fail2411;
16694 : 4 : _o1[1] = _r2;
16695 : : }
16696 : 4 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
16697 : 4 : tem_op.resimplify (lseq, valueize);
16698 : 4 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
16699 : 4 : if (!_r1) goto next_after_fail2411;
16700 : 4 : res_op->ops[0] = _r1;
16701 : : }
16702 : 4 : res_op->ops[1] = constant_boolean_node (eqne == NE_EXPR, type);
16703 : 4 : res_op->ops[2] = constant_boolean_node (eqne != NE_EXPR, type);
16704 : 4 : res_op->resimplify (lseq, valueize);
16705 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1149, __FILE__, __LINE__, true);
16706 : 4 : return true;
16707 : : }
16708 : 10 : next_after_fail2411:;
16709 : : }
16710 : : }
16711 : : }
16712 : : }
16713 : 90 : if ((_q61 == _q22 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q22, 0) && types_match (_q61, _q22)))
16714 : : {
16715 : 80 : if ((_q62 == _q21 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q21, 0) && types_match (_q62, _q21)))
16716 : : {
16717 : 80 : {
16718 : 80 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _q60 };
16719 : 80 : const enum tree_code eqne = EQ_EXPR;
16720 : 80 : if (!HONOR_NANS (captures[1])
16721 : 6 : && types_match (TREE_TYPE (captures[0]), TREE_TYPE (captures[3]))
16722 : 86 : && types_match (type, TREE_TYPE (captures[0]))
16723 : : )
16724 : : {
16725 : 6 : gimple_seq *lseq = seq;
16726 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2412;
16727 : 6 : {
16728 : 6 : res_op->set_op (VEC_COND_EXPR, type, 3);
16729 : 6 : {
16730 : 6 : tree _o1[2], _r1;
16731 : 6 : {
16732 : 6 : tree _o2[2], _r2;
16733 : 6 : _o2[0] = captures[0];
16734 : 6 : _o2[1] = captures[3];
16735 : 6 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_XOR_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
16736 : 6 : tem_op.resimplify (lseq, valueize);
16737 : 6 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
16738 : 6 : if (!_r2) goto next_after_fail2412;
16739 : 3 : _o1[0] = _r2;
16740 : : }
16741 : 3 : {
16742 : 3 : tree _o2[2], _r2;
16743 : 3 : _o2[0] = captures[1];
16744 : 3 : _o2[1] = captures[2];
16745 : 3 : gimple_match_op tem_op (res_op->cond.any_else (), EQ_EXPR, type, _o2[0], _o2[1]);
16746 : 3 : tem_op.resimplify (lseq, valueize);
16747 : 3 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
16748 : 3 : if (!_r2) goto next_after_fail2412;
16749 : 3 : _o1[1] = _r2;
16750 : : }
16751 : 3 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_IOR_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
16752 : 3 : tem_op.resimplify (lseq, valueize);
16753 : 3 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
16754 : 3 : if (!_r1) goto next_after_fail2412;
16755 : 3 : res_op->ops[0] = _r1;
16756 : : }
16757 : 3 : res_op->ops[1] = constant_boolean_node (eqne != NE_EXPR, type);
16758 : 3 : res_op->ops[2] = constant_boolean_node (eqne == NE_EXPR, type);
16759 : 3 : res_op->resimplify (lseq, valueize);
16760 : 3 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1150, __FILE__, __LINE__, true);
16761 : 3 : return true;
16762 : : }
16763 : 77 : next_after_fail2412:;
16764 : : }
16765 : : }
16766 : : }
16767 : : }
16768 : : break;
16769 : : }
16770 : : default:;
16771 : : }
16772 : : }
16773 : : break;
16774 : : default:;
16775 : : }
16776 : : break;
16777 : : }
16778 : 1195 : case LT_EXPR:
16779 : 1195 : {
16780 : 1195 : tree _q20 = gimple_assign_rhs1 (_a1);
16781 : 1195 : _q20 = do_valueize (valueize, _q20);
16782 : 1195 : tree _q21 = gimple_assign_rhs2 (_a1);
16783 : 1195 : _q21 = do_valueize (valueize, _q21);
16784 : 1195 : if (integer_truep (_p1))
16785 : : {
16786 : 93 : {
16787 : 93 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16788 : 93 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, LT_EXPR, GE_EXPR, UNGE_EXPR))
16789 : 93 : return true;
16790 : : }
16791 : : }
16792 : 1102 : if (integer_zerop (_p1))
16793 : : {
16794 : 802 : {
16795 : 802 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16796 : 802 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, LT_EXPR, GE_EXPR, UNGE_EXPR))
16797 : 229 : return true;
16798 : : }
16799 : : }
16800 : : break;
16801 : : }
16802 : 735 : case LE_EXPR:
16803 : 735 : {
16804 : 735 : tree _q20 = gimple_assign_rhs1 (_a1);
16805 : 735 : _q20 = do_valueize (valueize, _q20);
16806 : 735 : tree _q21 = gimple_assign_rhs2 (_a1);
16807 : 735 : _q21 = do_valueize (valueize, _q21);
16808 : 735 : if (integer_truep (_p1))
16809 : : {
16810 : 141 : {
16811 : 141 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16812 : 141 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, LE_EXPR, GT_EXPR, UNGT_EXPR))
16813 : 141 : return true;
16814 : : }
16815 : : }
16816 : 594 : if (integer_zerop (_p1))
16817 : : {
16818 : 228 : {
16819 : 228 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16820 : 228 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, LE_EXPR, GT_EXPR, UNGT_EXPR))
16821 : 180 : return true;
16822 : : }
16823 : : }
16824 : : break;
16825 : : }
16826 : 17897 : case EQ_EXPR:
16827 : 17897 : {
16828 : 17897 : tree _q20 = gimple_assign_rhs1 (_a1);
16829 : 17897 : _q20 = do_valueize (valueize, _q20);
16830 : 17897 : tree _q21 = gimple_assign_rhs2 (_a1);
16831 : 17897 : _q21 = do_valueize (valueize, _q21);
16832 : 17897 : if (tree_swap_operands_p (_q20, _q21))
16833 : 536 : std::swap (_q20, _q21);
16834 : 17897 : if (integer_truep (_p1))
16835 : : {
16836 : 395 : {
16837 : 395 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16838 : 395 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR, NE_EXPR))
16839 : 395 : return true;
16840 : : }
16841 : : }
16842 : 17502 : if (integer_zerop (_p1))
16843 : : {
16844 : 1595 : {
16845 : 1595 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16846 : 1595 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR, NE_EXPR))
16847 : 1303 : return true;
16848 : : }
16849 : : }
16850 : 79955266 : break;
16851 : : }
16852 : 18478 : case NE_EXPR:
16853 : 18478 : {
16854 : 18478 : tree _q20 = gimple_assign_rhs1 (_a1);
16855 : 18478 : _q20 = do_valueize (valueize, _q20);
16856 : 18478 : tree _q21 = gimple_assign_rhs2 (_a1);
16857 : 18478 : _q21 = do_valueize (valueize, _q21);
16858 : 18478 : if (tree_swap_operands_p (_q20, _q21))
16859 : 28 : std::swap (_q20, _q21);
16860 : 18478 : if (integer_truep (_p1))
16861 : : {
16862 : 529 : {
16863 : 529 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16864 : 529 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR, EQ_EXPR))
16865 : 529 : return true;
16866 : : }
16867 : : }
16868 : 17949 : if (integer_zerop (_p1))
16869 : : {
16870 : 16932 : {
16871 : 16932 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16872 : 16932 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR, EQ_EXPR))
16873 : 16464 : return true;
16874 : : }
16875 : : }
16876 : 79955266 : break;
16877 : : }
16878 : 1378 : case GE_EXPR:
16879 : 1378 : {
16880 : 1378 : tree _q20 = gimple_assign_rhs1 (_a1);
16881 : 1378 : _q20 = do_valueize (valueize, _q20);
16882 : 1378 : tree _q21 = gimple_assign_rhs2 (_a1);
16883 : 1378 : _q21 = do_valueize (valueize, _q21);
16884 : 1378 : if (integer_truep (_p1))
16885 : : {
16886 : 168 : {
16887 : 168 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16888 : 168 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, GE_EXPR, LT_EXPR, UNLT_EXPR))
16889 : 168 : return true;
16890 : : }
16891 : : }
16892 : 1210 : if (integer_zerop (_p1))
16893 : : {
16894 : 135 : {
16895 : 135 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16896 : 135 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, GE_EXPR, LT_EXPR, UNLT_EXPR))
16897 : 103 : return true;
16898 : : }
16899 : : }
16900 : : break;
16901 : : }
16902 : 2270 : case GT_EXPR:
16903 : 2270 : {
16904 : 2270 : tree _q20 = gimple_assign_rhs1 (_a1);
16905 : 2270 : _q20 = do_valueize (valueize, _q20);
16906 : 2270 : tree _q21 = gimple_assign_rhs2 (_a1);
16907 : 2270 : _q21 = do_valueize (valueize, _q21);
16908 : 2270 : if (integer_truep (_p1))
16909 : : {
16910 : 100 : {
16911 : 100 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16912 : 100 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, GT_EXPR, LE_EXPR, UNLE_EXPR))
16913 : 100 : return true;
16914 : : }
16915 : : }
16916 : 2170 : if (integer_zerop (_p1))
16917 : : {
16918 : 1177 : {
16919 : 1177 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16920 : 1177 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, GT_EXPR, LE_EXPR, UNLE_EXPR))
16921 : 178 : return true;
16922 : : }
16923 : : }
16924 : : break;
16925 : : }
16926 : 3 : case UNORDERED_EXPR:
16927 : 3 : {
16928 : 3 : tree _q20 = gimple_assign_rhs1 (_a1);
16929 : 3 : _q20 = do_valueize (valueize, _q20);
16930 : 3 : tree _q21 = gimple_assign_rhs2 (_a1);
16931 : 3 : _q21 = do_valueize (valueize, _q21);
16932 : 3 : if (tree_swap_operands_p (_q20, _q21))
16933 : 0 : std::swap (_q20, _q21);
16934 : 3 : if (integer_truep (_p1))
16935 : : {
16936 : 0 : {
16937 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16938 : 0 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR))
16939 : 0 : return true;
16940 : : }
16941 : : }
16942 : 3 : if (integer_zerop (_p1))
16943 : : {
16944 : 3 : {
16945 : 3 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16946 : 3 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, UNORDERED_EXPR, ORDERED_EXPR, ORDERED_EXPR))
16947 : 3 : return true;
16948 : : }
16949 : : }
16950 : 79955266 : break;
16951 : : }
16952 : 0 : case ORDERED_EXPR:
16953 : 0 : {
16954 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
16955 : 0 : _q20 = do_valueize (valueize, _q20);
16956 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
16957 : 0 : _q21 = do_valueize (valueize, _q21);
16958 : 0 : if (tree_swap_operands_p (_q20, _q21))
16959 : 0 : std::swap (_q20, _q21);
16960 : 0 : if (integer_truep (_p1))
16961 : : {
16962 : 0 : {
16963 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16964 : 0 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR))
16965 : 0 : return true;
16966 : : }
16967 : : }
16968 : 0 : if (integer_zerop (_p1))
16969 : : {
16970 : 0 : {
16971 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16972 : 0 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, ORDERED_EXPR, UNORDERED_EXPR, UNORDERED_EXPR))
16973 : 0 : return true;
16974 : : }
16975 : : }
16976 : 79955266 : break;
16977 : : }
16978 : 0 : case UNLT_EXPR:
16979 : 0 : {
16980 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
16981 : 0 : _q20 = do_valueize (valueize, _q20);
16982 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
16983 : 0 : _q21 = do_valueize (valueize, _q21);
16984 : 0 : if (integer_truep (_p1))
16985 : : {
16986 : 0 : {
16987 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16988 : 0 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, UNLT_EXPR, GE_EXPR, GE_EXPR))
16989 : 0 : return true;
16990 : : }
16991 : : }
16992 : 0 : if (integer_zerop (_p1))
16993 : : {
16994 : 0 : {
16995 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
16996 : 0 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, UNLT_EXPR, GE_EXPR, GE_EXPR))
16997 : 0 : return true;
16998 : : }
16999 : : }
17000 : : break;
17001 : : }
17002 : 0 : case UNLE_EXPR:
17003 : 0 : {
17004 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
17005 : 0 : _q20 = do_valueize (valueize, _q20);
17006 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
17007 : 0 : _q21 = do_valueize (valueize, _q21);
17008 : 0 : if (integer_truep (_p1))
17009 : : {
17010 : 0 : {
17011 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17012 : 0 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, UNLE_EXPR, GT_EXPR, GT_EXPR))
17013 : 0 : return true;
17014 : : }
17015 : : }
17016 : 0 : if (integer_zerop (_p1))
17017 : : {
17018 : 0 : {
17019 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17020 : 0 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, UNLE_EXPR, GT_EXPR, GT_EXPR))
17021 : 0 : return true;
17022 : : }
17023 : : }
17024 : : break;
17025 : : }
17026 : 0 : case UNGT_EXPR:
17027 : 0 : {
17028 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
17029 : 0 : _q20 = do_valueize (valueize, _q20);
17030 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
17031 : 0 : _q21 = do_valueize (valueize, _q21);
17032 : 0 : if (integer_truep (_p1))
17033 : : {
17034 : 0 : {
17035 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17036 : 0 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, UNGT_EXPR, LE_EXPR, LE_EXPR))
17037 : 0 : return true;
17038 : : }
17039 : : }
17040 : 0 : if (integer_zerop (_p1))
17041 : : {
17042 : 0 : {
17043 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17044 : 0 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, UNGT_EXPR, LE_EXPR, LE_EXPR))
17045 : 0 : return true;
17046 : : }
17047 : : }
17048 : : break;
17049 : : }
17050 : 0 : case UNGE_EXPR:
17051 : 0 : {
17052 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
17053 : 0 : _q20 = do_valueize (valueize, _q20);
17054 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
17055 : 0 : _q21 = do_valueize (valueize, _q21);
17056 : 0 : if (integer_truep (_p1))
17057 : : {
17058 : 0 : {
17059 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17060 : 0 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, UNGE_EXPR, LT_EXPR, LT_EXPR))
17061 : 0 : return true;
17062 : : }
17063 : : }
17064 : 0 : if (integer_zerop (_p1))
17065 : : {
17066 : 0 : {
17067 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17068 : 0 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, UNGE_EXPR, LT_EXPR, LT_EXPR))
17069 : 0 : return true;
17070 : : }
17071 : : }
17072 : : break;
17073 : : }
17074 : 0 : case UNEQ_EXPR:
17075 : 0 : {
17076 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
17077 : 0 : _q20 = do_valueize (valueize, _q20);
17078 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
17079 : 0 : _q21 = do_valueize (valueize, _q21);
17080 : 0 : if (tree_swap_operands_p (_q20, _q21))
17081 : 0 : std::swap (_q20, _q21);
17082 : 0 : if (integer_truep (_p1))
17083 : : {
17084 : 0 : {
17085 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17086 : 0 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR))
17087 : 0 : return true;
17088 : : }
17089 : : }
17090 : 0 : if (integer_zerop (_p1))
17091 : : {
17092 : 0 : {
17093 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17094 : 0 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, UNEQ_EXPR, LTGT_EXPR, LTGT_EXPR))
17095 : 0 : return true;
17096 : : }
17097 : : }
17098 : 79955266 : break;
17099 : : }
17100 : 0 : case LTGT_EXPR:
17101 : 0 : {
17102 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
17103 : 0 : _q20 = do_valueize (valueize, _q20);
17104 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
17105 : 0 : _q21 = do_valueize (valueize, _q21);
17106 : 0 : if (tree_swap_operands_p (_q20, _q21))
17107 : 0 : std::swap (_q20, _q21);
17108 : 0 : if (integer_truep (_p1))
17109 : : {
17110 : 0 : {
17111 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17112 : 0 : if (gimple_simplify_270 (res_op, seq, valueize, type, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR))
17113 : 0 : return true;
17114 : : }
17115 : : }
17116 : 0 : if (integer_zerop (_p1))
17117 : : {
17118 : 0 : {
17119 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17120 : 0 : if (gimple_simplify_271 (res_op, seq, valueize, type, captures, LTGT_EXPR, UNEQ_EXPR, UNEQ_EXPR))
17121 : 0 : return true;
17122 : : }
17123 : : }
17124 : 79955266 : break;
17125 : : }
17126 : 248916 : case MINUS_EXPR:
17127 : 248916 : {
17128 : 248916 : tree _q20 = gimple_assign_rhs1 (_a1);
17129 : 248916 : _q20 = do_valueize (valueize, _q20);
17130 : 248916 : tree _q21 = gimple_assign_rhs2 (_a1);
17131 : 248916 : _q21 = do_valueize (valueize, _q21);
17132 : 248916 : if (integer_zerop (_p1))
17133 : : {
17134 : 97567 : {
17135 : 97567 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17136 : 97567 : if (gimple_simplify_272 (res_op, seq, valueize, type, captures, EQ_EXPR))
17137 : 12603 : return true;
17138 : : }
17139 : : }
17140 : : break;
17141 : : }
17142 : 115094 : case POINTER_DIFF_EXPR:
17143 : 115094 : {
17144 : 115094 : tree _q20 = gimple_assign_rhs1 (_a1);
17145 : 115094 : _q20 = do_valueize (valueize, _q20);
17146 : 115094 : tree _q21 = gimple_assign_rhs2 (_a1);
17147 : 115094 : _q21 = do_valueize (valueize, _q21);
17148 : 115094 : if (integer_zerop (_p1))
17149 : : {
17150 : 10106 : {
17151 : 10106 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
17152 : 10106 : if (gimple_simplify_273 (res_op, seq, valueize, type, captures, EQ_EXPR))
17153 : 3987 : return true;
17154 : : }
17155 : : }
17156 : : break;
17157 : : }
17158 : 90573 : case MULT_EXPR:
17159 : 90573 : {
17160 : 90573 : tree _q20 = gimple_assign_rhs1 (_a1);
17161 : 90573 : _q20 = do_valueize (valueize, _q20);
17162 : 90573 : tree _q21 = gimple_assign_rhs2 (_a1);
17163 : 90573 : _q21 = do_valueize (valueize, _q21);
17164 : 90573 : if (tree_swap_operands_p (_q20, _q21))
17165 : 460 : std::swap (_q20, _q21);
17166 : 90573 : switch (TREE_CODE (_q21))
17167 : : {
17168 : 73900 : case INTEGER_CST:
17169 : 73900 : {
17170 : 73900 : switch (TREE_CODE (_p1))
17171 : : {
17172 : 26776 : case INTEGER_CST:
17173 : 26776 : {
17174 : 26776 : {
17175 : 26776 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
17176 : 26776 : if (gimple_simplify_275 (res_op, seq, valueize, type, captures, EQ_EXPR))
17177 : 1774 : return true;
17178 : : }
17179 : 25002 : break;
17180 : : }
17181 : 72126 : default:;
17182 : : }
17183 : 72126 : if (integer_zerop (_p1))
17184 : : {
17185 : 17066 : {
17186 : 17066 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
17187 : 17066 : if (gimple_simplify_274 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
17188 : 0 : return true;
17189 : : }
17190 : : }
17191 : : break;
17192 : : }
17193 : : default:;
17194 : : }
17195 : 79955266 : break;
17196 : : }
17197 : : default:;
17198 : : }
17199 : : }
17200 : : break;
17201 : 79955266 : default:;
17202 : : }
17203 : 79955266 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
17204 : : {
17205 : 56622 : {
17206 : 56622 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
17207 : 56622 : if (gimple_simplify_276 (res_op, seq, valueize, type, captures, EQ_EXPR))
17208 : 32882 : return true;
17209 : : }
17210 : : }
17211 : 79922384 : switch (TREE_CODE (_p0))
17212 : : {
17213 : 79094207 : case SSA_NAME:
17214 : 79094207 : if (gimple *_d1 = get_def (valueize, _p0))
17215 : : {
17216 : 26959917 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
17217 : 33127037 : switch (gimple_assign_rhs_code (_a1))
17218 : : {
17219 : 778539 : CASE_CONVERT:
17220 : 778539 : {
17221 : 778539 : tree _q20 = gimple_assign_rhs1 (_a1);
17222 : 778539 : _q20 = do_valueize (valueize, _q20);
17223 : 778539 : switch (TREE_CODE (_p1))
17224 : : {
17225 : 184466 : case SSA_NAME:
17226 : 184466 : if (gimple *_d2 = get_def (valueize, _p1))
17227 : : {
17228 : 175329 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17229 : 187788 : switch (gimple_assign_rhs_code (_a2))
17230 : : {
17231 : 39048 : CASE_CONVERT:
17232 : 39048 : {
17233 : 39048 : tree _q40 = gimple_assign_rhs1 (_a2);
17234 : 39048 : _q40 = do_valueize (valueize, _q40);
17235 : 39048 : {
17236 : 39048 : tree _q40_pops[1];
17237 : 39048 : if (gimple_maybe_bit_not (_q40, _q40_pops, valueize))
17238 : : {
17239 : 745 : tree _q50 = _q40_pops[0];
17240 : 745 : {
17241 : 745 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q50 };
17242 : 745 : if (gimple_simplify_277 (res_op, seq, valueize, type, captures, EQ_EXPR))
17243 : 3 : return true;
17244 : : }
17245 : : }
17246 : : }
17247 : 39045 : break;
17248 : : }
17249 : : default:;
17250 : : }
17251 : : }
17252 : : break;
17253 : 778536 : default:;
17254 : : }
17255 : 778536 : {
17256 : 778536 : tree _q20_pops[1];
17257 : 778536 : if (gimple_maybe_bit_not (_q20, _q20_pops, valueize))
17258 : : {
17259 : 27036 : tree _q30 = _q20_pops[0];
17260 : 27036 : switch (TREE_CODE (_p1))
17261 : : {
17262 : 2703 : case SSA_NAME:
17263 : 2703 : if (gimple *_d2 = get_def (valueize, _p1))
17264 : : {
17265 : 2663 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17266 : 3661 : switch (gimple_assign_rhs_code (_a2))
17267 : : {
17268 : 551 : CASE_CONVERT:
17269 : 551 : {
17270 : 551 : tree _q50 = gimple_assign_rhs1 (_a2);
17271 : 551 : _q50 = do_valueize (valueize, _q50);
17272 : 551 : {
17273 : 551 : tree captures[2] ATTRIBUTE_UNUSED = { _q50, _q30 };
17274 : 551 : if (gimple_simplify_277 (res_op, seq, valueize, type, captures, EQ_EXPR))
17275 : 0 : return true;
17276 : : }
17277 : 551 : break;
17278 : : }
17279 : : default:;
17280 : : }
17281 : : }
17282 : : break;
17283 : : default:;
17284 : : }
17285 : : }
17286 : : }
17287 : 778536 : break;
17288 : : }
17289 : : default:;
17290 : : }
17291 : : }
17292 : : break;
17293 : 79922381 : default:;
17294 : : }
17295 : 79922381 : {
17296 : 79922381 : tree _p1_pops[1];
17297 : 79922381 : if (gimple_maybe_bit_not (_p1, _p1_pops, valueize))
17298 : : {
17299 : 60686389 : tree _q30 = _p1_pops[0];
17300 : 60686389 : {
17301 : 60686389 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
17302 : 60686389 : if (gimple_simplify_277 (res_op, seq, valueize, type, captures, EQ_EXPR))
17303 : 28 : return true;
17304 : : }
17305 : : }
17306 : : }
17307 : 79922353 : switch (TREE_CODE (_p0))
17308 : : {
17309 : 79094176 : case SSA_NAME:
17310 : 79094176 : if (gimple *_d1 = get_def (valueize, _p0))
17311 : : {
17312 : 26959886 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
17313 : 33127006 : switch (gimple_assign_rhs_code (_a1))
17314 : : {
17315 : 793 : case BIT_NOT_EXPR:
17316 : 793 : {
17317 : 793 : tree _q20 = gimple_assign_rhs1 (_a1);
17318 : 793 : _q20 = do_valueize (valueize, _q20);
17319 : 793 : switch (TREE_CODE (_p1))
17320 : : {
17321 : 104 : case SSA_NAME:
17322 : 104 : if (gimple *_d2 = get_def (valueize, _p1))
17323 : : {
17324 : 93 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17325 : 91 : switch (gimple_assign_rhs_code (_a2))
17326 : : {
17327 : 2 : case BIT_NOT_EXPR:
17328 : 2 : {
17329 : 2 : tree _q40 = gimple_assign_rhs1 (_a2);
17330 : 2 : _q40 = do_valueize (valueize, _q40);
17331 : 2 : {
17332 : 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _p1, _q40 };
17333 : 2 : if (gimple_simplify_280 (res_op, seq, valueize, type, captures, EQ_EXPR))
17334 : 2 : return true;
17335 : : }
17336 : 0 : break;
17337 : : }
17338 : : default:;
17339 : : }
17340 : : }
17341 : : break;
17342 : 791 : default:;
17343 : : }
17344 : 791 : {
17345 : 791 : tree _p1_pops[1];
17346 : 791 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
17347 : : {
17348 : 4 : tree _q40 = _p1_pops[0];
17349 : 4 : switch (TREE_CODE (_q40))
17350 : : {
17351 : 4 : case SSA_NAME:
17352 : 4 : if (gimple *_d2 = get_def (valueize, _q40))
17353 : : {
17354 : 4 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17355 : 6 : switch (gimple_assign_rhs_code (_a2))
17356 : : {
17357 : 2 : case BIT_NOT_EXPR:
17358 : 2 : {
17359 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
17360 : 2 : _q50 = do_valueize (valueize, _q50);
17361 : 2 : {
17362 : 2 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q40, _q50 };
17363 : 2 : if (gimple_simplify_280 (res_op, seq, valueize, type, captures, EQ_EXPR))
17364 : 2 : return true;
17365 : : }
17366 : 0 : break;
17367 : : }
17368 : : default:;
17369 : : }
17370 : : }
17371 : : break;
17372 : : default:;
17373 : : }
17374 : : }
17375 : : }
17376 : 789 : if (CONSTANT_CLASS_P (_p1))
17377 : : {
17378 : 689 : {
17379 : 689 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
17380 : 689 : if (gimple_simplify_279 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
17381 : 82 : return true;
17382 : : }
17383 : : }
17384 : : break;
17385 : : }
17386 : : default:;
17387 : : }
17388 : : }
17389 : : break;
17390 : 79922267 : default:;
17391 : : }
17392 : 79922267 : {
17393 : 79922267 : tree _p0_pops[1];
17394 : 79922267 : if (gimple_maybe_bit_not (_p0, _p0_pops, valueize))
17395 : : {
17396 : 23177 : tree _q20 = _p0_pops[0];
17397 : 23177 : {
17398 : 23177 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _q20 };
17399 : 23177 : if (gimple_simplify_277 (res_op, seq, valueize, type, captures, EQ_EXPR))
17400 : 0 : return true;
17401 : : }
17402 : : }
17403 : : }
17404 : 79922267 : {
17405 : 79922267 : tree _p0_pops[1];
17406 : 79922267 : if (gimple_nop_convert (_p0, _p0_pops, valueize))
17407 : : {
17408 : 459375 : tree _q20 = _p0_pops[0];
17409 : 459375 : switch (TREE_CODE (_q20))
17410 : : {
17411 : 446737 : case SSA_NAME:
17412 : 446737 : if (gimple *_d1 = get_def (valueize, _q20))
17413 : : {
17414 : 441824 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
17415 : 454400 : switch (gimple_assign_rhs_code (_a1))
17416 : : {
17417 : 16 : case BIT_NOT_EXPR:
17418 : 16 : {
17419 : 16 : tree _q30 = gimple_assign_rhs1 (_a1);
17420 : 16 : _q30 = do_valueize (valueize, _q30);
17421 : 16 : switch (TREE_CODE (_p1))
17422 : : {
17423 : 16 : case SSA_NAME:
17424 : 16 : if (gimple *_d2 = get_def (valueize, _p1))
17425 : : {
17426 : 16 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17427 : 16 : switch (gimple_assign_rhs_code (_a2))
17428 : : {
17429 : 16 : case BIT_NOT_EXPR:
17430 : 16 : {
17431 : 16 : tree _q50 = gimple_assign_rhs1 (_a2);
17432 : 16 : _q50 = do_valueize (valueize, _q50);
17433 : 16 : {
17434 : 16 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _p1, _q50 };
17435 : 16 : if (gimple_simplify_278 (res_op, seq, valueize, type, captures, EQ_EXPR))
17436 : 0 : return true;
17437 : : }
17438 : 16 : break;
17439 : : }
17440 : : default:;
17441 : : }
17442 : : }
17443 : : break;
17444 : 16 : default:;
17445 : : }
17446 : 16 : {
17447 : 16 : tree _p1_pops[1];
17448 : 16 : if (gimple_nop_convert (_p1, _p1_pops, valueize))
17449 : : {
17450 : 0 : tree _q50 = _p1_pops[0];
17451 : 0 : switch (TREE_CODE (_q50))
17452 : : {
17453 : 0 : case SSA_NAME:
17454 : 0 : if (gimple *_d2 = get_def (valueize, _q50))
17455 : : {
17456 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17457 : 0 : switch (gimple_assign_rhs_code (_a2))
17458 : : {
17459 : 0 : case BIT_NOT_EXPR:
17460 : 0 : {
17461 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
17462 : 0 : _q60 = do_valueize (valueize, _q60);
17463 : 0 : {
17464 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q50, _q60 };
17465 : 0 : if (gimple_simplify_278 (res_op, seq, valueize, type, captures, EQ_EXPR))
17466 : 0 : return true;
17467 : : }
17468 : 0 : break;
17469 : : }
17470 : : default:;
17471 : : }
17472 : : }
17473 : : break;
17474 : : default:;
17475 : : }
17476 : : }
17477 : : }
17478 : 16 : if (CONSTANT_CLASS_P (_p1))
17479 : : {
17480 : 0 : {
17481 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
17482 : 0 : if (gimple_simplify_279 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
17483 : 0 : return true;
17484 : : }
17485 : : }
17486 : : break;
17487 : : }
17488 : : default:;
17489 : : }
17490 : : }
17491 : : break;
17492 : : default:;
17493 : : }
17494 : : }
17495 : : }
17496 : 79922267 : switch (TREE_CODE (_p1))
17497 : : {
17498 : 388553 : case REAL_CST:
17499 : 388553 : {
17500 : 388553 : {
17501 : 388553 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
17502 : 388553 : if (gimple_simplify_281 (res_op, seq, valueize, type, captures, EQ_EXPR))
17503 : 91 : return true;
17504 : : }
17505 : 388462 : break;
17506 : : }
17507 : 79922176 : default:;
17508 : : }
17509 : 79922176 : switch (TREE_CODE (_p0))
17510 : : {
17511 : 79093999 : case SSA_NAME:
17512 : 79093999 : if (gimple *_d1 = get_def (valueize, _p0))
17513 : : {
17514 : 26959726 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
17515 : 33126902 : switch (gimple_assign_rhs_code (_a1))
17516 : : {
17517 : 861791 : case PLUS_EXPR:
17518 : 861791 : {
17519 : 861791 : tree _q20 = gimple_assign_rhs1 (_a1);
17520 : 861791 : _q20 = do_valueize (valueize, _q20);
17521 : 861791 : tree _q21 = gimple_assign_rhs2 (_a1);
17522 : 861791 : _q21 = do_valueize (valueize, _q21);
17523 : 861791 : if (tree_swap_operands_p (_q20, _q21))
17524 : 7093 : std::swap (_q20, _q21);
17525 : 861791 : switch (TREE_CODE (_q21))
17526 : : {
17527 : 2350 : case REAL_CST:
17528 : 2350 : {
17529 : 2350 : switch (TREE_CODE (_p1))
17530 : : {
17531 : 2095 : case REAL_CST:
17532 : 2095 : {
17533 : 2095 : {
17534 : 2095 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
17535 : 2095 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, PLUS_EXPR, EQ_EXPR))
17536 : 0 : return true;
17537 : : }
17538 : 2095 : break;
17539 : : }
17540 : : default:;
17541 : : }
17542 : : break;
17543 : : }
17544 : : default:;
17545 : : }
17546 : 78985746 : break;
17547 : : }
17548 : 236313 : case MINUS_EXPR:
17549 : 236313 : {
17550 : 236313 : tree _q20 = gimple_assign_rhs1 (_a1);
17551 : 236313 : _q20 = do_valueize (valueize, _q20);
17552 : 236313 : tree _q21 = gimple_assign_rhs2 (_a1);
17553 : 236313 : _q21 = do_valueize (valueize, _q21);
17554 : 236313 : switch (TREE_CODE (_q21))
17555 : : {
17556 : 176 : case REAL_CST:
17557 : 176 : {
17558 : 176 : switch (TREE_CODE (_p1))
17559 : : {
17560 : 176 : case REAL_CST:
17561 : 176 : {
17562 : 176 : {
17563 : 176 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
17564 : 176 : if (gimple_simplify_282 (res_op, seq, valueize, type, captures, MINUS_EXPR, EQ_EXPR))
17565 : 0 : return true;
17566 : : }
17567 : 176 : break;
17568 : : }
17569 : : default:;
17570 : : }
17571 : : break;
17572 : : }
17573 : 236313 : default:;
17574 : : }
17575 : 236313 : switch (TREE_CODE (_q20))
17576 : : {
17577 : 1336 : case REAL_CST:
17578 : 1336 : {
17579 : 1336 : switch (TREE_CODE (_p1))
17580 : : {
17581 : 1336 : case REAL_CST:
17582 : 1336 : {
17583 : 1336 : {
17584 : 1336 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
17585 : 1336 : if (gimple_simplify_283 (res_op, seq, valueize, type, captures, EQ_EXPR))
17586 : 0 : return true;
17587 : : }
17588 : 1336 : break;
17589 : : }
17590 : : default:;
17591 : : }
17592 : : break;
17593 : : }
17594 : : default:;
17595 : : }
17596 : : break;
17597 : : }
17598 : 3474 : case FLOAT_EXPR:
17599 : 3474 : {
17600 : 3474 : tree _q20 = gimple_assign_rhs1 (_a1);
17601 : 3474 : _q20 = do_valueize (valueize, _q20);
17602 : 3474 : switch (TREE_CODE (_p1))
17603 : : {
17604 : 2851 : case SSA_NAME:
17605 : 2851 : if (gimple *_d2 = get_def (valueize, _p1))
17606 : : {
17607 : 2741 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17608 : 4839 : switch (gimple_assign_rhs_code (_a2))
17609 : : {
17610 : 108 : case FLOAT_EXPR:
17611 : 108 : {
17612 : 108 : tree _q40 = gimple_assign_rhs1 (_a2);
17613 : 108 : _q40 = do_valueize (valueize, _q40);
17614 : 108 : {
17615 : 108 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
17616 : 108 : if (gimple_simplify_286 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
17617 : 0 : return true;
17618 : : }
17619 : 108 : break;
17620 : : }
17621 : : default:;
17622 : : }
17623 : : }
17624 : : break;
17625 : 623 : case REAL_CST:
17626 : 623 : {
17627 : 623 : {
17628 : 623 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
17629 : 623 : if (gimple_simplify_287 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
17630 : 104 : return true;
17631 : : }
17632 : 519 : break;
17633 : : }
17634 : : default:;
17635 : : }
17636 : : break;
17637 : : }
17638 : 48018 : case EXACT_DIV_EXPR:
17639 : 48018 : {
17640 : 48018 : tree _q20 = gimple_assign_rhs1 (_a1);
17641 : 48018 : _q20 = do_valueize (valueize, _q20);
17642 : 48018 : tree _q21 = gimple_assign_rhs2 (_a1);
17643 : 48018 : _q21 = do_valueize (valueize, _q21);
17644 : 48018 : switch (TREE_CODE (_p1))
17645 : : {
17646 : 25903 : case INTEGER_CST:
17647 : 25903 : {
17648 : 25903 : {
17649 : 25903 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
17650 : 25903 : if (gimple_simplify_288 (res_op, seq, valueize, type, captures, EQ_EXPR))
17651 : 25903 : return true;
17652 : : }
17653 : 0 : break;
17654 : : }
17655 : : default:;
17656 : : }
17657 : : break;
17658 : : }
17659 : 6518 : case NEGATE_EXPR:
17660 : 6518 : {
17661 : 6518 : tree _q20 = gimple_assign_rhs1 (_a1);
17662 : 6518 : _q20 = do_valueize (valueize, _q20);
17663 : 6518 : switch (TREE_CODE (_p1))
17664 : : {
17665 : 1120 : case SSA_NAME:
17666 : 1120 : if (gimple *_d2 = get_def (valueize, _p1))
17667 : : {
17668 : 1072 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17669 : 991 : switch (gimple_assign_rhs_code (_a2))
17670 : : {
17671 : 40 : case NEGATE_EXPR:
17672 : 40 : {
17673 : 40 : tree _q40 = gimple_assign_rhs1 (_a2);
17674 : 40 : _q40 = do_valueize (valueize, _q40);
17675 : 40 : {
17676 : 40 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
17677 : 40 : if (gimple_simplify_289 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
17678 : 40 : return true;
17679 : : }
17680 : 0 : break;
17681 : : }
17682 : : default:;
17683 : : }
17684 : : }
17685 : : break;
17686 : 6478 : default:;
17687 : : }
17688 : 6478 : if (CONSTANT_CLASS_P (_p1))
17689 : : {
17690 : 5398 : {
17691 : 5398 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
17692 : 5398 : if (gimple_simplify_290 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
17693 : 5398 : return true;
17694 : : }
17695 : : }
17696 : : break;
17697 : : }
17698 : 7520 : case ABS_EXPR:
17699 : 7520 : {
17700 : 7520 : tree _q20 = gimple_assign_rhs1 (_a1);
17701 : 7520 : _q20 = do_valueize (valueize, _q20);
17702 : 7520 : if (zerop (_p1))
17703 : : {
17704 : 4349 : {
17705 : 4349 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
17706 : 4349 : const enum tree_code eqne = EQ_EXPR;
17707 : 4349 : gimple_seq *lseq = seq;
17708 : 4349 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2413;
17709 : 4349 : {
17710 : 4349 : res_op->set_op (eqne, type, 2);
17711 : 4349 : res_op->ops[0] = captures[0];
17712 : 4349 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[0]));
17713 : 4349 : res_op->resimplify (lseq, valueize);
17714 : 4349 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1151, __FILE__, __LINE__, true);
17715 : 4349 : return true;
17716 : : }
17717 : 0 : next_after_fail2413:;
17718 : : }
17719 : : }
17720 : : break;
17721 : : }
17722 : 6 : case ABSU_EXPR:
17723 : 6 : {
17724 : 6 : tree _q20 = gimple_assign_rhs1 (_a1);
17725 : 6 : _q20 = do_valueize (valueize, _q20);
17726 : 6 : if (zerop (_p1))
17727 : : {
17728 : 2 : {
17729 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
17730 : 2 : const enum tree_code eqne = EQ_EXPR;
17731 : 2 : gimple_seq *lseq = seq;
17732 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2414;
17733 : 2 : {
17734 : 2 : res_op->set_op (eqne, type, 2);
17735 : 2 : res_op->ops[0] = captures[0];
17736 : 2 : res_op->ops[1] = build_zero_cst (TREE_TYPE (captures[0]));
17737 : 2 : res_op->resimplify (lseq, valueize);
17738 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1151, __FILE__, __LINE__, true);
17739 : 2 : return true;
17740 : : }
17741 : 0 : next_after_fail2414:;
17742 : : }
17743 : : }
17744 : : break;
17745 : : }
17746 : 778536 : CASE_CONVERT:
17747 : 778536 : {
17748 : 778536 : tree _q20 = gimple_assign_rhs1 (_a1);
17749 : 778536 : _q20 = do_valueize (valueize, _q20);
17750 : 778536 : switch (TREE_CODE (_p1))
17751 : : {
17752 : 184463 : case SSA_NAME:
17753 : 184463 : if (gimple *_d2 = get_def (valueize, _p1))
17754 : : {
17755 : 175326 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17756 : 187785 : switch (gimple_assign_rhs_code (_a2))
17757 : : {
17758 : 39045 : CASE_CONVERT:
17759 : 39045 : {
17760 : 39045 : tree _q40 = gimple_assign_rhs1 (_a2);
17761 : 39045 : _q40 = do_valueize (valueize, _q40);
17762 : 39045 : {
17763 : 39045 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
17764 : 39045 : if (gimple_simplify_291 (res_op, seq, valueize, type, captures, EQ_EXPR))
17765 : 4830 : return true;
17766 : : }
17767 : 34215 : break;
17768 : : }
17769 : : default:;
17770 : : }
17771 : : }
17772 : : break;
17773 : 773706 : default:;
17774 : : }
17775 : 773706 : {
17776 : 773706 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _p1 };
17777 : 773706 : if (gimple_simplify_292 (res_op, seq, valueize, type, captures, EQ_EXPR))
17778 : 67153 : return true;
17779 : : }
17780 : 706553 : switch (TREE_CODE (_q20))
17781 : : {
17782 : 693915 : case SSA_NAME:
17783 : 693915 : if (gimple *_d2 = get_def (valueize, _q20))
17784 : : {
17785 : 684848 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
17786 : 810656 : switch (gimple_assign_rhs_code (_a2))
17787 : : {
17788 : 1121 : case BIT_IOR_EXPR:
17789 : 1121 : {
17790 : 1121 : tree _q30 = gimple_assign_rhs1 (_a2);
17791 : 1121 : _q30 = do_valueize (valueize, _q30);
17792 : 1121 : tree _q31 = gimple_assign_rhs2 (_a2);
17793 : 1121 : _q31 = do_valueize (valueize, _q31);
17794 : 1121 : if (tree_swap_operands_p (_q30, _q31))
17795 : 23 : std::swap (_q30, _q31);
17796 : 1121 : switch (TREE_CODE (_q31))
17797 : : {
17798 : 216 : case INTEGER_CST:
17799 : 216 : {
17800 : 216 : switch (TREE_CODE (_p1))
17801 : : {
17802 : 56 : case INTEGER_CST:
17803 : 56 : {
17804 : 56 : {
17805 : 56 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
17806 : 56 : if (gimple_simplify_293 (res_op, seq, valueize, type, captures, EQ_EXPR))
17807 : 0 : return true;
17808 : : }
17809 : 56 : break;
17810 : : }
17811 : : default:;
17812 : : }
17813 : : break;
17814 : : }
17815 : : default:;
17816 : : }
17817 : 78985746 : break;
17818 : : }
17819 : : default:;
17820 : : }
17821 : : }
17822 : : break;
17823 : : default:;
17824 : : }
17825 : : break;
17826 : : }
17827 : 115525 : case BIT_IOR_EXPR:
17828 : 115525 : {
17829 : 115525 : tree _q20 = gimple_assign_rhs1 (_a1);
17830 : 115525 : _q20 = do_valueize (valueize, _q20);
17831 : 115525 : tree _q21 = gimple_assign_rhs2 (_a1);
17832 : 115525 : _q21 = do_valueize (valueize, _q21);
17833 : 115525 : if (tree_swap_operands_p (_q20, _q21))
17834 : 7948 : std::swap (_q20, _q21);
17835 : 115525 : switch (TREE_CODE (_q21))
17836 : : {
17837 : 5673 : case INTEGER_CST:
17838 : 5673 : {
17839 : 5673 : switch (TREE_CODE (_p1))
17840 : : {
17841 : 3942 : case INTEGER_CST:
17842 : 3942 : {
17843 : 3942 : {
17844 : 3942 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
17845 : 3942 : if (gimple_simplify_293 (res_op, seq, valueize, type, captures, EQ_EXPR))
17846 : 4 : return true;
17847 : : }
17848 : 3938 : break;
17849 : : }
17850 : : default:;
17851 : : }
17852 : : break;
17853 : : }
17854 : : default:;
17855 : : }
17856 : 78985746 : break;
17857 : : }
17858 : 1219 : case BIT_XOR_EXPR:
17859 : 1219 : {
17860 : 1219 : tree _q20 = gimple_assign_rhs1 (_a1);
17861 : 1219 : _q20 = do_valueize (valueize, _q20);
17862 : 1219 : tree _q21 = gimple_assign_rhs2 (_a1);
17863 : 1219 : _q21 = do_valueize (valueize, _q21);
17864 : 1219 : if (tree_swap_operands_p (_q20, _q21))
17865 : 155 : std::swap (_q20, _q21);
17866 : 1219 : if (integer_zerop (_p1))
17867 : : {
17868 : 414 : {
17869 : 414 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
17870 : 414 : if (gimple_simplify_295 (res_op, seq, valueize, type, captures, EQ_EXPR))
17871 : 414 : return true;
17872 : : }
17873 : : }
17874 : 805 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
17875 : : {
17876 : 0 : {
17877 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
17878 : 0 : if (gimple_simplify_296 (res_op, seq, valueize, type, captures, EQ_EXPR))
17879 : 0 : return true;
17880 : : }
17881 : : }
17882 : 805 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
17883 : : {
17884 : 14 : {
17885 : 14 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
17886 : 14 : if (gimple_simplify_296 (res_op, seq, valueize, type, captures, EQ_EXPR))
17887 : 14 : return true;
17888 : : }
17889 : : }
17890 : 78985746 : break;
17891 : : }
17892 : : default:;
17893 : : }
17894 : 8458290 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
17895 : 4824684 : switch (gimple_call_combined_fn (_c1))
17896 : : {
17897 : 61 : case CFN_BUILT_IN_SQRTF:
17898 : 61 : if (gimple_call_num_args (_c1) == 1)
17899 : : {
17900 : 61 : tree _q20 = gimple_call_arg (_c1, 0);
17901 : 61 : _q20 = do_valueize (valueize, _q20);
17902 : 61 : switch (TREE_CODE (_p1))
17903 : : {
17904 : 2 : case SSA_NAME:
17905 : 2 : if (gimple *_d2 = get_def (valueize, _p1))
17906 : : {
17907 : 2 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
17908 : 2 : switch (gimple_call_combined_fn (_c2))
17909 : : {
17910 : 2 : case CFN_BUILT_IN_SQRTF:
17911 : 2 : if (gimple_call_num_args (_c2) == 1)
17912 : : {
17913 : 2 : tree _q40 = gimple_call_arg (_c2, 0);
17914 : 2 : _q40 = do_valueize (valueize, _q40);
17915 : 2 : {
17916 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
17917 : 2 : if (gimple_simplify_285 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTF, EQ_EXPR))
17918 : 2 : return true;
17919 : : }
17920 : : }
17921 : : break;
17922 : : default:;
17923 : : }
17924 : : }
17925 : : break;
17926 : 59 : case REAL_CST:
17927 : 59 : {
17928 : 59 : {
17929 : 59 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
17930 : 59 : if (gimple_simplify_284 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTF, EQ_EXPR))
17931 : 12 : return true;
17932 : : }
17933 : 47 : break;
17934 : : }
17935 : : default:;
17936 : : }
17937 : : }
17938 : : break;
17939 : 14 : case CFN_BUILT_IN_SQRTL:
17940 : 14 : if (gimple_call_num_args (_c1) == 1)
17941 : : {
17942 : 14 : tree _q20 = gimple_call_arg (_c1, 0);
17943 : 14 : _q20 = do_valueize (valueize, _q20);
17944 : 14 : switch (TREE_CODE (_p1))
17945 : : {
17946 : 2 : case SSA_NAME:
17947 : 2 : if (gimple *_d2 = get_def (valueize, _p1))
17948 : : {
17949 : 2 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
17950 : 2 : switch (gimple_call_combined_fn (_c2))
17951 : : {
17952 : 2 : case CFN_BUILT_IN_SQRTL:
17953 : 2 : if (gimple_call_num_args (_c2) == 1)
17954 : : {
17955 : 2 : tree _q40 = gimple_call_arg (_c2, 0);
17956 : 2 : _q40 = do_valueize (valueize, _q40);
17957 : 2 : {
17958 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
17959 : 2 : if (gimple_simplify_285 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTL, EQ_EXPR))
17960 : 2 : return true;
17961 : : }
17962 : : }
17963 : : break;
17964 : : default:;
17965 : : }
17966 : : }
17967 : : break;
17968 : 12 : case REAL_CST:
17969 : 12 : {
17970 : 12 : {
17971 : 12 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
17972 : 12 : if (gimple_simplify_284 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRTL, EQ_EXPR))
17973 : 12 : return true;
17974 : : }
17975 : 0 : break;
17976 : : }
17977 : : default:;
17978 : : }
17979 : : }
17980 : : break;
17981 : 187 : case CFN_BUILT_IN_SQRT:
17982 : 187 : if (gimple_call_num_args (_c1) == 1)
17983 : : {
17984 : 187 : tree _q20 = gimple_call_arg (_c1, 0);
17985 : 187 : _q20 = do_valueize (valueize, _q20);
17986 : 187 : switch (TREE_CODE (_p1))
17987 : : {
17988 : 2 : case SSA_NAME:
17989 : 2 : if (gimple *_d2 = get_def (valueize, _p1))
17990 : : {
17991 : 2 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
17992 : 2 : switch (gimple_call_combined_fn (_c2))
17993 : : {
17994 : 2 : case CFN_BUILT_IN_SQRT:
17995 : 2 : if (gimple_call_num_args (_c2) == 1)
17996 : : {
17997 : 2 : tree _q40 = gimple_call_arg (_c2, 0);
17998 : 2 : _q40 = do_valueize (valueize, _q40);
17999 : 2 : {
18000 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
18001 : 2 : if (gimple_simplify_285 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRT, EQ_EXPR))
18002 : 2 : return true;
18003 : : }
18004 : : }
18005 : : break;
18006 : : default:;
18007 : : }
18008 : : }
18009 : : break;
18010 : 185 : case REAL_CST:
18011 : 185 : {
18012 : 185 : {
18013 : 185 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
18014 : 185 : if (gimple_simplify_284 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_SQRT, EQ_EXPR))
18015 : 12 : return true;
18016 : : }
18017 : 173 : break;
18018 : : }
18019 : : default:;
18020 : : }
18021 : : }
18022 : : break;
18023 : 135 : case CFN_SQRT:
18024 : 135 : if (gimple_call_num_args (_c1) == 1)
18025 : : {
18026 : 135 : tree _q20 = gimple_call_arg (_c1, 0);
18027 : 135 : _q20 = do_valueize (valueize, _q20);
18028 : 135 : switch (TREE_CODE (_p1))
18029 : : {
18030 : 0 : case SSA_NAME:
18031 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
18032 : : {
18033 : 0 : if (gcall *_c2 = dyn_cast <gcall *> (_d2))
18034 : 0 : switch (gimple_call_combined_fn (_c2))
18035 : : {
18036 : 0 : case CFN_SQRT:
18037 : 0 : if (gimple_call_num_args (_c2) == 1)
18038 : : {
18039 : 0 : tree _q40 = gimple_call_arg (_c2, 0);
18040 : 0 : _q40 = do_valueize (valueize, _q40);
18041 : 0 : {
18042 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
18043 : 0 : if (gimple_simplify_285 (res_op, seq, valueize, type, captures, CFN_SQRT, EQ_EXPR))
18044 : 0 : return true;
18045 : : }
18046 : : }
18047 : : break;
18048 : : default:;
18049 : : }
18050 : : }
18051 : : break;
18052 : 135 : case REAL_CST:
18053 : 135 : {
18054 : 135 : {
18055 : 135 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
18056 : 135 : if (gimple_simplify_284 (res_op, seq, valueize, type, captures, CFN_SQRT, EQ_EXPR))
18057 : 0 : return true;
18058 : : }
18059 : 135 : break;
18060 : : }
18061 : : default:;
18062 : : }
18063 : : }
18064 : : break;
18065 : : default:;
18066 : : }
18067 : : }
18068 : 78985746 : {
18069 : 78985746 : switch (TREE_CODE (_p1))
18070 : : {
18071 : 13061374 : case SSA_NAME:
18072 : 13061374 : if (gimple *_d1 = get_def (valueize, _p1))
18073 : : {
18074 : 4347426 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
18075 : 6418402 : switch (gimple_assign_rhs_code (_a1))
18076 : : {
18077 : 410841 : case ADDR_EXPR:
18078 : 410841 : {
18079 : 410841 : {
18080 : 410841 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
18081 : 410841 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, EQ_EXPR))
18082 : 0 : return true;
18083 : : }
18084 : 410841 : break;
18085 : : }
18086 : : default:;
18087 : : }
18088 : : }
18089 : : break;
18090 : 5621569 : case ADDR_EXPR:
18091 : 5621569 : {
18092 : 5621569 : {
18093 : 5621569 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
18094 : 5621569 : if (gimple_simplify_294 (res_op, seq, valueize, type, captures, EQ_EXPR))
18095 : 75 : return true;
18096 : : }
18097 : 5621494 : break;
18098 : : }
18099 : : default:;
18100 : : }
18101 : : }
18102 : : break;
18103 : 79813848 : default:;
18104 : : }
18105 : 79813848 : switch (TREE_CODE (_p1))
18106 : : {
18107 : 13112583 : case SSA_NAME:
18108 : 13112583 : if (gimple *_d1 = get_def (valueize, _p1))
18109 : : {
18110 : 4347426 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
18111 : 6418402 : switch (gimple_assign_rhs_code (_a1))
18112 : : {
18113 : 382 : case BIT_XOR_EXPR:
18114 : 382 : {
18115 : 382 : tree _q30 = gimple_assign_rhs1 (_a1);
18116 : 382 : _q30 = do_valueize (valueize, _q30);
18117 : 382 : tree _q31 = gimple_assign_rhs2 (_a1);
18118 : 382 : _q31 = do_valueize (valueize, _q31);
18119 : 382 : if (tree_swap_operands_p (_q30, _q31))
18120 : 18 : std::swap (_q30, _q31);
18121 : 382 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
18122 : : {
18123 : 18 : {
18124 : 18 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
18125 : 18 : if (gimple_simplify_296 (res_op, seq, valueize, type, captures, EQ_EXPR))
18126 : 18 : return true;
18127 : : }
18128 : : }
18129 : 364 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
18130 : : {
18131 : 0 : {
18132 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
18133 : 0 : if (gimple_simplify_296 (res_op, seq, valueize, type, captures, EQ_EXPR))
18134 : 0 : return true;
18135 : : }
18136 : : }
18137 : 79813830 : break;
18138 : : }
18139 : : default:;
18140 : : }
18141 : : }
18142 : : break;
18143 : 79813830 : default:;
18144 : : }
18145 : 79813830 : switch (TREE_CODE (_p0))
18146 : : {
18147 : 78985653 : case SSA_NAME:
18148 : 78985653 : if (gimple *_d1 = get_def (valueize, _p0))
18149 : : {
18150 : 26851398 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
18151 : 33018691 : switch (gimple_assign_rhs_code (_a1))
18152 : : {
18153 : 1251506 : case BIT_AND_EXPR:
18154 : 1251506 : {
18155 : 1251506 : tree _q20 = gimple_assign_rhs1 (_a1);
18156 : 1251506 : _q20 = do_valueize (valueize, _q20);
18157 : 1251506 : tree _q21 = gimple_assign_rhs2 (_a1);
18158 : 1251506 : _q21 = do_valueize (valueize, _q21);
18159 : 1251506 : if (tree_swap_operands_p (_q20, _q21))
18160 : 6770 : std::swap (_q20, _q21);
18161 : 1251506 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
18162 : : {
18163 : 89 : {
18164 : 89 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
18165 : 89 : if (gimple_simplify_297 (res_op, seq, valueize, type, captures, EQ_EXPR))
18166 : 24 : return true;
18167 : : }
18168 : : }
18169 : 1251482 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
18170 : : {
18171 : 129010 : {
18172 : 129010 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
18173 : 129010 : if (gimple_simplify_297 (res_op, seq, valueize, type, captures, EQ_EXPR))
18174 : 0 : return true;
18175 : : }
18176 : : }
18177 : 79813806 : break;
18178 : : }
18179 : : default:;
18180 : : }
18181 : : }
18182 : : break;
18183 : 79813806 : default:;
18184 : : }
18185 : 79813806 : switch (TREE_CODE (_p1))
18186 : : {
18187 : 13112541 : case SSA_NAME:
18188 : 13112541 : if (gimple *_d1 = get_def (valueize, _p1))
18189 : : {
18190 : 4347385 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
18191 : 6418376 : switch (gimple_assign_rhs_code (_a1))
18192 : : {
18193 : 16971 : case BIT_AND_EXPR:
18194 : 16971 : {
18195 : 16971 : tree _q30 = gimple_assign_rhs1 (_a1);
18196 : 16971 : _q30 = do_valueize (valueize, _q30);
18197 : 16971 : tree _q31 = gimple_assign_rhs2 (_a1);
18198 : 16971 : _q31 = do_valueize (valueize, _q31);
18199 : 16971 : if (tree_swap_operands_p (_q30, _q31))
18200 : 192 : std::swap (_q30, _q31);
18201 : 16971 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
18202 : : {
18203 : 655 : {
18204 : 655 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q31 };
18205 : 655 : if (gimple_simplify_297 (res_op, seq, valueize, type, captures, EQ_EXPR))
18206 : 14 : return true;
18207 : : }
18208 : : }
18209 : 16957 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
18210 : : {
18211 : 18 : {
18212 : 18 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
18213 : 18 : if (gimple_simplify_297 (res_op, seq, valueize, type, captures, EQ_EXPR))
18214 : 0 : return true;
18215 : : }
18216 : : }
18217 : 79813792 : break;
18218 : : }
18219 : : default:;
18220 : : }
18221 : : }
18222 : : break;
18223 : 79813792 : default:;
18224 : : }
18225 : 79813792 : switch (TREE_CODE (_p0))
18226 : : {
18227 : 78985615 : case SSA_NAME:
18228 : 78985615 : if (gimple *_d1 = get_def (valueize, _p0))
18229 : : {
18230 : 26851360 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
18231 : 33018667 : switch (gimple_assign_rhs_code (_a1))
18232 : : {
18233 : 706553 : CASE_CONVERT:
18234 : 706553 : {
18235 : 706553 : tree _q20 = gimple_assign_rhs1 (_a1);
18236 : 706553 : _q20 = do_valueize (valueize, _q20);
18237 : 706553 : switch (TREE_CODE (_q20))
18238 : : {
18239 : 693915 : case SSA_NAME:
18240 : 693915 : if (gimple *_d2 = get_def (valueize, _q20))
18241 : : {
18242 : 684848 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18243 : 810656 : switch (gimple_assign_rhs_code (_a2))
18244 : : {
18245 : 4276 : case BIT_AND_EXPR:
18246 : 4276 : {
18247 : 4276 : tree _q30 = gimple_assign_rhs1 (_a2);
18248 : 4276 : _q30 = do_valueize (valueize, _q30);
18249 : 4276 : tree _q31 = gimple_assign_rhs2 (_a2);
18250 : 4276 : _q31 = do_valueize (valueize, _q31);
18251 : 4276 : if (tree_swap_operands_p (_q30, _q31))
18252 : 4 : std::swap (_q30, _q31);
18253 : 4276 : switch (TREE_CODE (_q30))
18254 : : {
18255 : 4276 : case SSA_NAME:
18256 : 4276 : if (gimple *_d3 = get_def (valueize, _q30))
18257 : : {
18258 : 4253 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
18259 : 7741 : switch (gimple_assign_rhs_code (_a3))
18260 : : {
18261 : 16 : CASE_CONVERT:
18262 : 16 : {
18263 : 16 : tree _q40 = gimple_assign_rhs1 (_a3);
18264 : 16 : _q40 = do_valueize (valueize, _q40);
18265 : 16 : switch (TREE_CODE (_q31))
18266 : : {
18267 : 8 : case INTEGER_CST:
18268 : 8 : {
18269 : 8 : switch (TREE_CODE (_p1))
18270 : : {
18271 : 0 : case SSA_NAME:
18272 : 0 : if (gimple *_d4 = get_def (valueize, _p1))
18273 : : {
18274 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
18275 : 0 : switch (gimple_assign_rhs_code (_a4))
18276 : : {
18277 : 0 : CASE_CONVERT:
18278 : 0 : {
18279 : 0 : tree _q70 = gimple_assign_rhs1 (_a4);
18280 : 0 : _q70 = do_valueize (valueize, _q70);
18281 : 0 : if ((_q70 == _q40 && ! TREE_SIDE_EFFECTS (_q70)) || (operand_equal_p (_q70, _q40, 0) && types_match (_q70, _q40)))
18282 : : {
18283 : 0 : {
18284 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q40, _q31 };
18285 : 0 : if (gimple_simplify_298 (res_op, seq, valueize, type, captures, EQ_EXPR))
18286 : 0 : return true;
18287 : : }
18288 : : }
18289 : : break;
18290 : : }
18291 : : default:;
18292 : : }
18293 : : }
18294 : : break;
18295 : : default:;
18296 : : }
18297 : : break;
18298 : : }
18299 : : default:;
18300 : : }
18301 : : break;
18302 : : }
18303 : : default:;
18304 : : }
18305 : : }
18306 : : break;
18307 : : default:;
18308 : : }
18309 : 706553 : break;
18310 : : }
18311 : : default:;
18312 : : }
18313 : : }
18314 : : break;
18315 : 706553 : default:;
18316 : : }
18317 : 706553 : switch (TREE_CODE (_p1))
18318 : : {
18319 : 179633 : case SSA_NAME:
18320 : 179633 : if (gimple *_d2 = get_def (valueize, _p1))
18321 : : {
18322 : 170496 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18323 : 182955 : switch (gimple_assign_rhs_code (_a2))
18324 : : {
18325 : 34215 : CASE_CONVERT:
18326 : 34215 : {
18327 : 34215 : tree _q40 = gimple_assign_rhs1 (_a2);
18328 : 34215 : _q40 = do_valueize (valueize, _q40);
18329 : 34215 : switch (TREE_CODE (_q40))
18330 : : {
18331 : 16999 : case SSA_NAME:
18332 : 16999 : if (gimple *_d3 = get_def (valueize, _q40))
18333 : : {
18334 : 16835 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
18335 : 22482 : switch (gimple_assign_rhs_code (_a3))
18336 : : {
18337 : 25 : case BIT_AND_EXPR:
18338 : 25 : {
18339 : 25 : tree _q50 = gimple_assign_rhs1 (_a3);
18340 : 25 : _q50 = do_valueize (valueize, _q50);
18341 : 25 : tree _q51 = gimple_assign_rhs2 (_a3);
18342 : 25 : _q51 = do_valueize (valueize, _q51);
18343 : 25 : if (tree_swap_operands_p (_q50, _q51))
18344 : 0 : std::swap (_q50, _q51);
18345 : 25 : switch (TREE_CODE (_q50))
18346 : : {
18347 : 25 : case SSA_NAME:
18348 : 25 : if (gimple *_d4 = get_def (valueize, _q50))
18349 : : {
18350 : 25 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
18351 : 18 : switch (gimple_assign_rhs_code (_a4))
18352 : : {
18353 : 12 : CASE_CONVERT:
18354 : 12 : {
18355 : 12 : tree _q60 = gimple_assign_rhs1 (_a4);
18356 : 12 : _q60 = do_valueize (valueize, _q60);
18357 : 12 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
18358 : : {
18359 : 0 : switch (TREE_CODE (_q51))
18360 : : {
18361 : 0 : case INTEGER_CST:
18362 : 0 : {
18363 : 0 : {
18364 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p1, _q50, _q20, _q51 };
18365 : 0 : if (gimple_simplify_298 (res_op, seq, valueize, type, captures, EQ_EXPR))
18366 : 0 : return true;
18367 : : }
18368 : 0 : break;
18369 : : }
18370 : : default:;
18371 : : }
18372 : : }
18373 : : break;
18374 : : }
18375 : : default:;
18376 : : }
18377 : : }
18378 : : break;
18379 : : default:;
18380 : : }
18381 : 79811414 : break;
18382 : : }
18383 : : default:;
18384 : : }
18385 : : }
18386 : : break;
18387 : : default:;
18388 : : }
18389 : : break;
18390 : : }
18391 : : default:;
18392 : : }
18393 : : }
18394 : : break;
18395 : : default:;
18396 : : }
18397 : : break;
18398 : : }
18399 : 115521 : case BIT_IOR_EXPR:
18400 : 115521 : {
18401 : 115521 : tree _q20 = gimple_assign_rhs1 (_a1);
18402 : 115521 : _q20 = do_valueize (valueize, _q20);
18403 : 115521 : tree _q21 = gimple_assign_rhs2 (_a1);
18404 : 115521 : _q21 = do_valueize (valueize, _q21);
18405 : 115521 : if (tree_swap_operands_p (_q20, _q21))
18406 : 7946 : std::swap (_q20, _q21);
18407 : 115521 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
18408 : : {
18409 : 2414 : {
18410 : 2414 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q21 };
18411 : 2414 : if (gimple_simplify_299 (res_op, seq, valueize, type, captures, EQ_EXPR))
18412 : 2378 : return true;
18413 : : }
18414 : : }
18415 : 113143 : if ((_p1 == _q20 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q20, 0) && types_match (_p1, _q20)))
18416 : : {
18417 : 15 : {
18418 : 15 : tree captures[2] ATTRIBUTE_UNUSED = { _q21, _q20 };
18419 : 15 : if (gimple_simplify_299 (res_op, seq, valueize, type, captures, EQ_EXPR))
18420 : 0 : return true;
18421 : : }
18422 : : }
18423 : 79811414 : break;
18424 : : }
18425 : : default:;
18426 : : }
18427 : : }
18428 : : break;
18429 : 79811414 : default:;
18430 : : }
18431 : 79811414 : switch (TREE_CODE (_p1))
18432 : : {
18433 : 13112527 : case SSA_NAME:
18434 : 13112527 : if (gimple *_d1 = get_def (valueize, _p1))
18435 : : {
18436 : 4347371 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
18437 : 6418362 : switch (gimple_assign_rhs_code (_a1))
18438 : : {
18439 : 3862 : case BIT_IOR_EXPR:
18440 : 3862 : {
18441 : 3862 : tree _q30 = gimple_assign_rhs1 (_a1);
18442 : 3862 : _q30 = do_valueize (valueize, _q30);
18443 : 3862 : tree _q31 = gimple_assign_rhs2 (_a1);
18444 : 3862 : _q31 = do_valueize (valueize, _q31);
18445 : 3862 : if (tree_swap_operands_p (_q30, _q31))
18446 : 131 : std::swap (_q30, _q31);
18447 : 3862 : if ((_q31 == _p0 && ! TREE_SIDE_EFFECTS (_q31)) || (operand_equal_p (_q31, _p0, 0) && types_match (_q31, _p0)))
18448 : : {
18449 : 61 : {
18450 : 61 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _p0 };
18451 : 61 : if (gimple_simplify_299 (res_op, seq, valueize, type, captures, EQ_EXPR))
18452 : 0 : return true;
18453 : : }
18454 : : }
18455 : 3862 : if ((_q30 == _p0 && ! TREE_SIDE_EFFECTS (_q30)) || (operand_equal_p (_q30, _p0, 0) && types_match (_q30, _p0)))
18456 : : {
18457 : 122 : {
18458 : 122 : tree captures[2] ATTRIBUTE_UNUSED = { _q31, _p0 };
18459 : 122 : if (gimple_simplify_299 (res_op, seq, valueize, type, captures, EQ_EXPR))
18460 : 0 : return true;
18461 : : }
18462 : : }
18463 : 79811414 : break;
18464 : : }
18465 : : default:;
18466 : : }
18467 : : }
18468 : : break;
18469 : 79811414 : default:;
18470 : : }
18471 : 79811414 : switch (TREE_CODE (_p0))
18472 : : {
18473 : 78983237 : case SSA_NAME:
18474 : 78983237 : if (gimple *_d1 = get_def (valueize, _p0))
18475 : : {
18476 : 26848982 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
18477 : 33016289 : switch (gimple_assign_rhs_code (_a1))
18478 : : {
18479 : 706553 : CASE_CONVERT:
18480 : 706553 : {
18481 : 706553 : tree _q20 = gimple_assign_rhs1 (_a1);
18482 : 706553 : _q20 = do_valueize (valueize, _q20);
18483 : 706553 : switch (TREE_CODE (_q20))
18484 : : {
18485 : 693915 : case SSA_NAME:
18486 : 693915 : if (gimple *_d2 = get_def (valueize, _q20))
18487 : : {
18488 : 684848 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18489 : 810656 : switch (gimple_assign_rhs_code (_a2))
18490 : : {
18491 : 25 : case BIT_XOR_EXPR:
18492 : 25 : {
18493 : 25 : tree _q30 = gimple_assign_rhs1 (_a2);
18494 : 25 : _q30 = do_valueize (valueize, _q30);
18495 : 25 : tree _q31 = gimple_assign_rhs2 (_a2);
18496 : 25 : _q31 = do_valueize (valueize, _q31);
18497 : 25 : if (tree_swap_operands_p (_q30, _q31))
18498 : 4 : std::swap (_q30, _q31);
18499 : 25 : switch (TREE_CODE (_q31))
18500 : : {
18501 : 17 : case INTEGER_CST:
18502 : 17 : {
18503 : 17 : switch (TREE_CODE (_p1))
18504 : : {
18505 : 13 : case INTEGER_CST:
18506 : 13 : {
18507 : 13 : {
18508 : 13 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _p1 };
18509 : 13 : if (gimple_simplify_300 (res_op, seq, valueize, type, captures, EQ_EXPR))
18510 : 0 : return true;
18511 : : }
18512 : 13 : break;
18513 : : }
18514 : : default:;
18515 : : }
18516 : : break;
18517 : : }
18518 : : default:;
18519 : : }
18520 : 79811405 : break;
18521 : : }
18522 : : default:;
18523 : : }
18524 : : }
18525 : : break;
18526 : : default:;
18527 : : }
18528 : : break;
18529 : : }
18530 : 791 : case BIT_XOR_EXPR:
18531 : 791 : {
18532 : 791 : tree _q20 = gimple_assign_rhs1 (_a1);
18533 : 791 : _q20 = do_valueize (valueize, _q20);
18534 : 791 : tree _q21 = gimple_assign_rhs2 (_a1);
18535 : 791 : _q21 = do_valueize (valueize, _q21);
18536 : 791 : if (tree_swap_operands_p (_q20, _q21))
18537 : 61 : std::swap (_q20, _q21);
18538 : 791 : switch (TREE_CODE (_q21))
18539 : : {
18540 : 163 : case INTEGER_CST:
18541 : 163 : {
18542 : 163 : switch (TREE_CODE (_p1))
18543 : : {
18544 : 9 : case INTEGER_CST:
18545 : 9 : {
18546 : 9 : {
18547 : 9 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
18548 : 9 : if (gimple_simplify_300 (res_op, seq, valueize, type, captures, EQ_EXPR))
18549 : 9 : return true;
18550 : : }
18551 : 0 : break;
18552 : : }
18553 : : default:;
18554 : : }
18555 : : break;
18556 : : }
18557 : : default:;
18558 : : }
18559 : 79811405 : break;
18560 : : }
18561 : : default:;
18562 : : }
18563 : : }
18564 : : break;
18565 : 79811405 : default:;
18566 : : }
18567 : 79811405 : {
18568 : 79811405 : tree _p0_pops[1];
18569 : 79811405 : if (gimple_nop_convert (_p0, _p0_pops, valueize))
18570 : : {
18571 : 425534 : tree _q20 = _p0_pops[0];
18572 : 425534 : if (integer_zerop (_p1))
18573 : : {
18574 : 162121 : {
18575 : 162121 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
18576 : 162121 : if (gimple_simplify_301 (res_op, seq, valueize, type, captures, EQ_EXPR))
18577 : 174 : return true;
18578 : : }
18579 : : }
18580 : : }
18581 : : }
18582 : 79811231 : if (integer_zerop (_p1))
18583 : : {
18584 : 40792962 : {
18585 : 40792962 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
18586 : 40792962 : if (gimple_simplify_301 (res_op, seq, valueize, type, captures, EQ_EXPR))
18587 : 51144 : return true;
18588 : : }
18589 : : }
18590 : 79760087 : switch (TREE_CODE (_p0))
18591 : : {
18592 : 78975912 : case SSA_NAME:
18593 : 78975912 : if (gimple *_d1 = get_def (valueize, _p0))
18594 : : {
18595 : 26845576 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
18596 : 33013707 : switch (gimple_assign_rhs_code (_a1))
18597 : : {
18598 : 1251482 : case BIT_AND_EXPR:
18599 : 1251482 : {
18600 : 1251482 : tree _q20 = gimple_assign_rhs1 (_a1);
18601 : 1251482 : _q20 = do_valueize (valueize, _q20);
18602 : 1251482 : tree _q21 = gimple_assign_rhs2 (_a1);
18603 : 1251482 : _q21 = do_valueize (valueize, _q21);
18604 : 1251482 : if (tree_swap_operands_p (_q20, _q21))
18605 : 6770 : std::swap (_q20, _q21);
18606 : 1251482 : switch (TREE_CODE (_p1))
18607 : : {
18608 : 18199 : case SSA_NAME:
18609 : 18199 : if (gimple *_d2 = get_def (valueize, _p1))
18610 : : {
18611 : 17660 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18612 : 21549 : switch (gimple_assign_rhs_code (_a2))
18613 : : {
18614 : 2864 : case BIT_AND_EXPR:
18615 : 2864 : {
18616 : 2864 : tree _q50 = gimple_assign_rhs1 (_a2);
18617 : 2864 : _q50 = do_valueize (valueize, _q50);
18618 : 2864 : tree _q51 = gimple_assign_rhs2 (_a2);
18619 : 2864 : _q51 = do_valueize (valueize, _q51);
18620 : 2864 : if (tree_swap_operands_p (_q50, _q51))
18621 : 0 : std::swap (_q50, _q51);
18622 : 2864 : if ((_q51 == _q21 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q21, 0) && types_match (_q51, _q21)))
18623 : : {
18624 : 1832 : {
18625 : 1832 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q50 };
18626 : 1832 : if (gimple_simplify_302 (res_op, seq, valueize, type, captures, EQ_EXPR))
18627 : 17 : return true;
18628 : : }
18629 : : }
18630 : 2847 : if ((_q50 == _q21 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q21, 0) && types_match (_q50, _q21)))
18631 : : {
18632 : 0 : {
18633 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1, _q51 };
18634 : 0 : if (gimple_simplify_302 (res_op, seq, valueize, type, captures, EQ_EXPR))
18635 : 0 : return true;
18636 : : }
18637 : : }
18638 : 2847 : if ((_q51 == _q20 && ! TREE_SIDE_EFFECTS (_q51)) || (operand_equal_p (_q51, _q20, 0) && types_match (_q51, _q20)))
18639 : : {
18640 : 0 : {
18641 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q50 };
18642 : 0 : if (gimple_simplify_302 (res_op, seq, valueize, type, captures, EQ_EXPR))
18643 : 0 : return true;
18644 : : }
18645 : : }
18646 : 2847 : if ((_q50 == _q20 && ! TREE_SIDE_EFFECTS (_q50)) || (operand_equal_p (_q50, _q20, 0) && types_match (_q50, _q20)))
18647 : : {
18648 : 0 : {
18649 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q21, _q20, _p1, _q51 };
18650 : 0 : if (gimple_simplify_302 (res_op, seq, valueize, type, captures, EQ_EXPR))
18651 : 0 : return true;
18652 : : }
18653 : : }
18654 : 1251465 : break;
18655 : : }
18656 : : default:;
18657 : : }
18658 : : }
18659 : : break;
18660 : 1251465 : default:;
18661 : : }
18662 : 1251465 : if (integer_pow2p (_q21))
18663 : : {
18664 : 437988 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
18665 : : {
18666 : 841 : {
18667 : 841 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
18668 : 841 : if (gimple_simplify_303 (res_op, seq, valueize, type, captures, EQ_EXPR, NE_EXPR))
18669 : 841 : return true;
18670 : : }
18671 : : }
18672 : : }
18673 : 1250624 : switch (TREE_CODE (_q20))
18674 : : {
18675 : 1250624 : case SSA_NAME:
18676 : 1250624 : if (gimple *_d2 = get_def (valueize, _q20))
18677 : : {
18678 : 1201410 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18679 : 1714809 : switch (gimple_assign_rhs_code (_a2))
18680 : : {
18681 : 86680 : CASE_CONVERT:
18682 : 86680 : {
18683 : 86680 : tree _q30 = gimple_assign_rhs1 (_a2);
18684 : 86680 : _q30 = do_valueize (valueize, _q30);
18685 : 86680 : if (integer_pow2p (_q21))
18686 : : {
18687 : 7983 : if (integer_zerop (_p1))
18688 : : {
18689 : 7983 : {
18690 : 7983 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _q21 };
18691 : 7983 : if (gimple_simplify_304 (res_op, seq, valueize, type, captures, EQ_EXPR, GE_EXPR))
18692 : 20 : return true;
18693 : : }
18694 : : }
18695 : : }
18696 : : break;
18697 : : }
18698 : : default:;
18699 : : }
18700 : : }
18701 : : break;
18702 : 1250604 : default:;
18703 : : }
18704 : 1250604 : if (integer_pow2p (_q21))
18705 : : {
18706 : 437127 : if (integer_zerop (_p1))
18707 : : {
18708 : 436926 : {
18709 : 436926 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q20, _q21 };
18710 : 436926 : if (gimple_simplify_305 (res_op, seq, valueize, type, captures, EQ_EXPR, GE_EXPR))
18711 : 335 : return true;
18712 : : }
18713 : : }
18714 : : }
18715 : 79742898 : break;
18716 : : }
18717 : 1100 : case GE_EXPR:
18718 : 1100 : {
18719 : 1100 : tree _q20 = gimple_assign_rhs1 (_a1);
18720 : 1100 : _q20 = do_valueize (valueize, _q20);
18721 : 1100 : tree _q21 = gimple_assign_rhs2 (_a1);
18722 : 1100 : _q21 = do_valueize (valueize, _q21);
18723 : 1100 : if (integer_zerop (_q21))
18724 : : {
18725 : 24 : switch (TREE_CODE (_p1))
18726 : : {
18727 : 24 : case SSA_NAME:
18728 : 24 : if (gimple *_d2 = get_def (valueize, _p1))
18729 : : {
18730 : 24 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18731 : 24 : switch (gimple_assign_rhs_code (_a2))
18732 : : {
18733 : 2 : case GE_EXPR:
18734 : 2 : {
18735 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
18736 : 2 : _q50 = do_valueize (valueize, _q50);
18737 : 2 : tree _q51 = gimple_assign_rhs2 (_a2);
18738 : 2 : _q51 = do_valueize (valueize, _q51);
18739 : 2 : if (integer_zerop (_q51))
18740 : : {
18741 : 2 : {
18742 : 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
18743 : 2 : if (gimple_simplify_306 (res_op, seq, valueize, type, captures, GE_EXPR, EQ_EXPR, GE_EXPR))
18744 : 1 : return true;
18745 : : }
18746 : : }
18747 : : break;
18748 : : }
18749 : 2 : case LT_EXPR:
18750 : 2 : {
18751 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
18752 : 2 : _q50 = do_valueize (valueize, _q50);
18753 : 2 : tree _q51 = gimple_assign_rhs2 (_a2);
18754 : 2 : _q51 = do_valueize (valueize, _q51);
18755 : 2 : if (integer_zerop (_q51))
18756 : : {
18757 : 2 : {
18758 : 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q50, _q51, _q20 };
18759 : 2 : if (gimple_simplify_307 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR))
18760 : 1 : return true;
18761 : : }
18762 : : }
18763 : : break;
18764 : : }
18765 : : default:;
18766 : : }
18767 : : }
18768 : : break;
18769 : : default:;
18770 : : }
18771 : : }
18772 : : break;
18773 : : }
18774 : 866 : case LT_EXPR:
18775 : 866 : {
18776 : 866 : tree _q20 = gimple_assign_rhs1 (_a1);
18777 : 866 : _q20 = do_valueize (valueize, _q20);
18778 : 866 : tree _q21 = gimple_assign_rhs2 (_a1);
18779 : 866 : _q21 = do_valueize (valueize, _q21);
18780 : 866 : if (integer_zerop (_q21))
18781 : : {
18782 : 85 : switch (TREE_CODE (_p1))
18783 : : {
18784 : 53 : case SSA_NAME:
18785 : 53 : if (gimple *_d2 = get_def (valueize, _p1))
18786 : : {
18787 : 53 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18788 : 53 : switch (gimple_assign_rhs_code (_a2))
18789 : : {
18790 : 32 : case LT_EXPR:
18791 : 32 : {
18792 : 32 : tree _q50 = gimple_assign_rhs1 (_a2);
18793 : 32 : _q50 = do_valueize (valueize, _q50);
18794 : 32 : tree _q51 = gimple_assign_rhs2 (_a2);
18795 : 32 : _q51 = do_valueize (valueize, _q51);
18796 : 32 : if (integer_zerop (_q51))
18797 : : {
18798 : 32 : {
18799 : 32 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
18800 : 32 : if (gimple_simplify_306 (res_op, seq, valueize, type, captures, LT_EXPR, EQ_EXPR, GE_EXPR))
18801 : 14 : return true;
18802 : : }
18803 : : }
18804 : : break;
18805 : : }
18806 : 2 : case GE_EXPR:
18807 : 2 : {
18808 : 2 : tree _q50 = gimple_assign_rhs1 (_a2);
18809 : 2 : _q50 = do_valueize (valueize, _q50);
18810 : 2 : tree _q51 = gimple_assign_rhs2 (_a2);
18811 : 2 : _q51 = do_valueize (valueize, _q51);
18812 : 2 : if (integer_zerop (_q51))
18813 : : {
18814 : 2 : {
18815 : 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _q50 };
18816 : 2 : if (gimple_simplify_308 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR))
18817 : 1 : return true;
18818 : : }
18819 : : }
18820 : : break;
18821 : : }
18822 : : default:;
18823 : : }
18824 : : }
18825 : : break;
18826 : : default:;
18827 : : }
18828 : : }
18829 : : break;
18830 : : }
18831 : 705595 : CASE_CONVERT:
18832 : 705595 : {
18833 : 705595 : tree _q20 = gimple_assign_rhs1 (_a1);
18834 : 705595 : _q20 = do_valueize (valueize, _q20);
18835 : 705595 : switch (TREE_CODE (_q20))
18836 : : {
18837 : 693020 : case SSA_NAME:
18838 : 693020 : if (gimple *_d2 = get_def (valueize, _q20))
18839 : : {
18840 : 683953 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18841 : 810371 : switch (gimple_assign_rhs_code (_a2))
18842 : : {
18843 : 184 : case ADDR_EXPR:
18844 : 184 : {
18845 : 184 : switch (TREE_CODE (_p1))
18846 : : {
18847 : 164 : case SSA_NAME:
18848 : 164 : if (gimple *_d3 = get_def (valueize, _p1))
18849 : : {
18850 : 157 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
18851 : 262 : switch (gimple_assign_rhs_code (_a3))
18852 : : {
18853 : 52 : CASE_CONVERT:
18854 : 52 : {
18855 : 52 : tree _q40 = gimple_assign_rhs1 (_a3);
18856 : 52 : _q40 = do_valueize (valueize, _q40);
18857 : 52 : switch (TREE_CODE (_q40))
18858 : : {
18859 : 52 : case SSA_NAME:
18860 : 52 : if (gimple *_d4 = get_def (valueize, _q40))
18861 : : {
18862 : 52 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
18863 : 104 : switch (gimple_assign_rhs_code (_a4))
18864 : : {
18865 : 52 : case ADDR_EXPR:
18866 : 52 : {
18867 : 52 : {
18868 : 52 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
18869 : 52 : if (gimple_simplify_309 (res_op, seq, valueize, type, captures, EQ_EXPR))
18870 : 0 : return true;
18871 : : }
18872 : 52 : break;
18873 : : }
18874 : : default:;
18875 : : }
18876 : : }
18877 : : break;
18878 : 0 : case ADDR_EXPR:
18879 : 0 : {
18880 : 0 : {
18881 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
18882 : 0 : if (gimple_simplify_309 (res_op, seq, valueize, type, captures, EQ_EXPR))
18883 : 0 : return true;
18884 : : }
18885 : 0 : break;
18886 : : }
18887 : : default:;
18888 : : }
18889 : : break;
18890 : : }
18891 : 0 : case ADDR_EXPR:
18892 : 0 : {
18893 : 0 : {
18894 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
18895 : 0 : if (gimple_simplify_309 (res_op, seq, valueize, type, captures, EQ_EXPR))
18896 : 0 : return true;
18897 : : }
18898 : 0 : break;
18899 : : }
18900 : : default:;
18901 : : }
18902 : : }
18903 : : break;
18904 : 0 : case ADDR_EXPR:
18905 : 0 : {
18906 : 0 : {
18907 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
18908 : 0 : if (gimple_simplify_309 (res_op, seq, valueize, type, captures, EQ_EXPR))
18909 : 0 : return true;
18910 : : }
18911 : 0 : break;
18912 : : }
18913 : : default:;
18914 : : }
18915 : : break;
18916 : : }
18917 : : default:;
18918 : : }
18919 : : }
18920 : : break;
18921 : 12575 : case ADDR_EXPR:
18922 : 12575 : {
18923 : 12575 : switch (TREE_CODE (_p1))
18924 : : {
18925 : 12548 : case SSA_NAME:
18926 : 12548 : if (gimple *_d2 = get_def (valueize, _p1))
18927 : : {
18928 : 12466 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
18929 : 19786 : switch (gimple_assign_rhs_code (_a2))
18930 : : {
18931 : 4837 : CASE_CONVERT:
18932 : 4837 : {
18933 : 4837 : tree _q40 = gimple_assign_rhs1 (_a2);
18934 : 4837 : _q40 = do_valueize (valueize, _q40);
18935 : 4837 : switch (TREE_CODE (_q40))
18936 : : {
18937 : 4637 : case SSA_NAME:
18938 : 4637 : if (gimple *_d3 = get_def (valueize, _q40))
18939 : : {
18940 : 4612 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
18941 : 9096 : switch (gimple_assign_rhs_code (_a3))
18942 : : {
18943 : 0 : case ADDR_EXPR:
18944 : 0 : {
18945 : 0 : {
18946 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
18947 : 0 : if (gimple_simplify_309 (res_op, seq, valueize, type, captures, EQ_EXPR))
18948 : 0 : return true;
18949 : : }
18950 : 0 : break;
18951 : : }
18952 : : default:;
18953 : : }
18954 : : }
18955 : : break;
18956 : 200 : case ADDR_EXPR:
18957 : 200 : {
18958 : 200 : {
18959 : 200 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
18960 : 200 : if (gimple_simplify_309 (res_op, seq, valueize, type, captures, EQ_EXPR))
18961 : 170 : return true;
18962 : : }
18963 : 30 : break;
18964 : : }
18965 : : default:;
18966 : : }
18967 : : break;
18968 : : }
18969 : 0 : case ADDR_EXPR:
18970 : 0 : {
18971 : 0 : {
18972 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
18973 : 0 : if (gimple_simplify_309 (res_op, seq, valueize, type, captures, EQ_EXPR))
18974 : 0 : return true;
18975 : : }
18976 : 0 : break;
18977 : : }
18978 : : default:;
18979 : : }
18980 : : }
18981 : : break;
18982 : 0 : case ADDR_EXPR:
18983 : 0 : {
18984 : 0 : {
18985 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
18986 : 0 : if (gimple_simplify_309 (res_op, seq, valueize, type, captures, EQ_EXPR))
18987 : 0 : return true;
18988 : : }
18989 : 0 : break;
18990 : : }
18991 : : default:;
18992 : : }
18993 : : break;
18994 : : }
18995 : : default:;
18996 : : }
18997 : : break;
18998 : : }
18999 : 143824 : case ADDR_EXPR:
19000 : 143824 : {
19001 : 143824 : switch (TREE_CODE (_p1))
19002 : : {
19003 : 124715 : case SSA_NAME:
19004 : 124715 : if (gimple *_d2 = get_def (valueize, _p1))
19005 : : {
19006 : 121285 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
19007 : 205962 : switch (gimple_assign_rhs_code (_a2))
19008 : : {
19009 : 0 : CASE_CONVERT:
19010 : 0 : {
19011 : 0 : tree _q30 = gimple_assign_rhs1 (_a2);
19012 : 0 : _q30 = do_valueize (valueize, _q30);
19013 : 0 : switch (TREE_CODE (_q30))
19014 : : {
19015 : 0 : case SSA_NAME:
19016 : 0 : if (gimple *_d3 = get_def (valueize, _q30))
19017 : : {
19018 : 0 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
19019 : 0 : switch (gimple_assign_rhs_code (_a3))
19020 : : {
19021 : 0 : case ADDR_EXPR:
19022 : 0 : {
19023 : 0 : {
19024 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
19025 : 0 : if (gimple_simplify_310 (res_op, seq, valueize, type, captures, EQ_EXPR))
19026 : 0 : return true;
19027 : : }
19028 : 0 : break;
19029 : : }
19030 : : default:;
19031 : : }
19032 : : }
19033 : : break;
19034 : 0 : case ADDR_EXPR:
19035 : 0 : {
19036 : 0 : {
19037 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
19038 : 0 : if (gimple_simplify_310 (res_op, seq, valueize, type, captures, EQ_EXPR))
19039 : 0 : return true;
19040 : : }
19041 : 0 : break;
19042 : : }
19043 : : default:;
19044 : : }
19045 : : break;
19046 : : }
19047 : 1644 : case ADDR_EXPR:
19048 : 1644 : {
19049 : 1644 : {
19050 : 1644 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
19051 : 1644 : if (gimple_simplify_310 (res_op, seq, valueize, type, captures, EQ_EXPR))
19052 : 234 : return true;
19053 : : }
19054 : 1410 : break;
19055 : : }
19056 : : default:;
19057 : : }
19058 : : }
19059 : : break;
19060 : 14237 : case ADDR_EXPR:
19061 : 14237 : {
19062 : 14237 : {
19063 : 14237 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
19064 : 14237 : if (gimple_simplify_310 (res_op, seq, valueize, type, captures, EQ_EXPR))
19065 : 23 : return true;
19066 : : }
19067 : 14214 : break;
19068 : : }
19069 : : default:;
19070 : : }
19071 : : break;
19072 : : }
19073 : : default:;
19074 : : }
19075 : : }
19076 : : break;
19077 : 28901 : case ADDR_EXPR:
19078 : 28901 : {
19079 : 28901 : switch (TREE_CODE (_p1))
19080 : : {
19081 : 0 : case SSA_NAME:
19082 : 0 : if (gimple *_d1 = get_def (valueize, _p1))
19083 : : {
19084 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
19085 : 0 : switch (gimple_assign_rhs_code (_a1))
19086 : : {
19087 : 0 : CASE_CONVERT:
19088 : 0 : {
19089 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
19090 : 0 : _q30 = do_valueize (valueize, _q30);
19091 : 0 : switch (TREE_CODE (_q30))
19092 : : {
19093 : 0 : case SSA_NAME:
19094 : 0 : if (gimple *_d2 = get_def (valueize, _q30))
19095 : : {
19096 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
19097 : 0 : switch (gimple_assign_rhs_code (_a2))
19098 : : {
19099 : 0 : case ADDR_EXPR:
19100 : 0 : {
19101 : 0 : {
19102 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
19103 : 0 : if (gimple_simplify_310 (res_op, seq, valueize, type, captures, EQ_EXPR))
19104 : 0 : return true;
19105 : : }
19106 : 0 : break;
19107 : : }
19108 : : default:;
19109 : : }
19110 : : }
19111 : : break;
19112 : 0 : case ADDR_EXPR:
19113 : 0 : {
19114 : 0 : {
19115 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _q30 };
19116 : 0 : if (gimple_simplify_310 (res_op, seq, valueize, type, captures, EQ_EXPR))
19117 : 0 : return true;
19118 : : }
19119 : 0 : break;
19120 : : }
19121 : : default:;
19122 : : }
19123 : : break;
19124 : : }
19125 : 0 : case ADDR_EXPR:
19126 : 0 : {
19127 : 0 : {
19128 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
19129 : 0 : if (gimple_simplify_310 (res_op, seq, valueize, type, captures, EQ_EXPR))
19130 : 0 : return true;
19131 : : }
19132 : 0 : break;
19133 : : }
19134 : : default:;
19135 : : }
19136 : : }
19137 : : break;
19138 : 22528 : case ADDR_EXPR:
19139 : 22528 : {
19140 : 22528 : {
19141 : 22528 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p0, _p1 };
19142 : 22528 : if (gimple_simplify_310 (res_op, seq, valueize, type, captures, EQ_EXPR))
19143 : 15532 : return true;
19144 : : }
19145 : 6996 : break;
19146 : : }
19147 : : default:;
19148 : : }
19149 : : break;
19150 : : }
19151 : 79742898 : default:;
19152 : : }
19153 : 79742898 : {
19154 : 79742898 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
19155 : 79742898 : if (gimple_simplify_311 (res_op, seq, valueize, type, captures, EQ_EXPR))
19156 : 7766 : return true;
19157 : : }
19158 : 79735132 : switch (TREE_CODE (_p0))
19159 : : {
19160 : 78966489 : case SSA_NAME:
19161 : 78966489 : if (gimple *_d1 = get_def (valueize, _p0))
19162 : : {
19163 : 26840080 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
19164 : 33008138 : switch (gimple_assign_rhs_code (_a1))
19165 : : {
19166 : 705425 : CASE_CONVERT:
19167 : 705425 : {
19168 : 705425 : tree _q20 = gimple_assign_rhs1 (_a1);
19169 : 705425 : _q20 = do_valueize (valueize, _q20);
19170 : 705425 : switch (TREE_CODE (_p1))
19171 : : {
19172 : 519162 : case INTEGER_CST:
19173 : 519162 : {
19174 : 519162 : {
19175 : 519162 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
19176 : 519162 : if (gimple_simplify_312 (res_op, seq, valueize, type, captures, EQ_EXPR))
19177 : 14278 : return true;
19178 : : }
19179 : 504884 : break;
19180 : : }
19181 : 691147 : default:;
19182 : : }
19183 : 691147 : switch (TREE_CODE (_q20))
19184 : : {
19185 : 678767 : case SSA_NAME:
19186 : 678767 : if (gimple *_d2 = get_def (valueize, _q20))
19187 : : {
19188 : 669754 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
19189 : 790082 : switch (gimple_assign_rhs_code (_a2))
19190 : : {
19191 : 1105 : case NE_EXPR:
19192 : 1105 : {
19193 : 1105 : tree _q30 = gimple_assign_rhs1 (_a2);
19194 : 1105 : _q30 = do_valueize (valueize, _q30);
19195 : 1105 : tree _q31 = gimple_assign_rhs2 (_a2);
19196 : 1105 : _q31 = do_valueize (valueize, _q31);
19197 : 1105 : if (tree_swap_operands_p (_q30, _q31))
19198 : 0 : std::swap (_q30, _q31);
19199 : 1105 : switch (TREE_CODE (_q31))
19200 : : {
19201 : 1101 : case INTEGER_CST:
19202 : 1101 : {
19203 : 1101 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
19204 : : {
19205 : 42 : {
19206 : 42 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
19207 : 42 : if (gimple_simplify_313 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR))
19208 : 34 : return true;
19209 : : }
19210 : : }
19211 : : break;
19212 : : }
19213 : : default:;
19214 : : }
19215 : 79720786 : break;
19216 : : }
19217 : 1639 : case EQ_EXPR:
19218 : 1639 : {
19219 : 1639 : tree _q30 = gimple_assign_rhs1 (_a2);
19220 : 1639 : _q30 = do_valueize (valueize, _q30);
19221 : 1639 : tree _q31 = gimple_assign_rhs2 (_a2);
19222 : 1639 : _q31 = do_valueize (valueize, _q31);
19223 : 1639 : if (tree_swap_operands_p (_q30, _q31))
19224 : 0 : std::swap (_q30, _q31);
19225 : 1639 : switch (TREE_CODE (_q31))
19226 : : {
19227 : 1602 : case INTEGER_CST:
19228 : 1602 : {
19229 : 1602 : if ((_p1 == _q30 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q30, 0) && types_match (_p1, _q30)))
19230 : : {
19231 : 41 : {
19232 : 41 : tree captures[2] ATTRIBUTE_UNUSED = { _q30, _q31 };
19233 : 41 : if (gimple_simplify_313 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
19234 : 34 : return true;
19235 : : }
19236 : : }
19237 : : break;
19238 : : }
19239 : : default:;
19240 : : }
19241 : 79720786 : break;
19242 : : }
19243 : : default:;
19244 : : }
19245 : : }
19246 : : break;
19247 : : default:;
19248 : : }
19249 : : break;
19250 : : }
19251 : : default:;
19252 : : }
19253 : : }
19254 : : break;
19255 : 79720786 : default:;
19256 : : }
19257 : 79720786 : switch (TREE_CODE (_p1))
19258 : : {
19259 : 13111828 : case SSA_NAME:
19260 : 13111828 : if (gimple *_d1 = get_def (valueize, _p1))
19261 : : {
19262 : 4346770 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
19263 : 6417512 : switch (gimple_assign_rhs_code (_a1))
19264 : : {
19265 : 216955 : CASE_CONVERT:
19266 : 216955 : {
19267 : 216955 : tree _q30 = gimple_assign_rhs1 (_a1);
19268 : 216955 : _q30 = do_valueize (valueize, _q30);
19269 : 216955 : switch (TREE_CODE (_q30))
19270 : : {
19271 : 193659 : case SSA_NAME:
19272 : 193659 : if (gimple *_d2 = get_def (valueize, _q30))
19273 : : {
19274 : 188634 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
19275 : 243190 : switch (gimple_assign_rhs_code (_a2))
19276 : : {
19277 : 390 : case NE_EXPR:
19278 : 390 : {
19279 : 390 : tree _q40 = gimple_assign_rhs1 (_a2);
19280 : 390 : _q40 = do_valueize (valueize, _q40);
19281 : 390 : tree _q41 = gimple_assign_rhs2 (_a2);
19282 : 390 : _q41 = do_valueize (valueize, _q41);
19283 : 390 : if (tree_swap_operands_p (_q40, _q41))
19284 : 14 : std::swap (_q40, _q41);
19285 : 390 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
19286 : : {
19287 : 81 : switch (TREE_CODE (_q41))
19288 : : {
19289 : 1 : case INTEGER_CST:
19290 : 1 : {
19291 : 1 : {
19292 : 1 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
19293 : 1 : if (gimple_simplify_313 (res_op, seq, valueize, type, captures, NE_EXPR, EQ_EXPR))
19294 : 0 : return true;
19295 : : }
19296 : 1 : break;
19297 : : }
19298 : : default:;
19299 : : }
19300 : : }
19301 : 79720783 : break;
19302 : : }
19303 : 161 : case EQ_EXPR:
19304 : 161 : {
19305 : 161 : tree _q40 = gimple_assign_rhs1 (_a2);
19306 : 161 : _q40 = do_valueize (valueize, _q40);
19307 : 161 : tree _q41 = gimple_assign_rhs2 (_a2);
19308 : 161 : _q41 = do_valueize (valueize, _q41);
19309 : 161 : if (tree_swap_operands_p (_q40, _q41))
19310 : 0 : std::swap (_q40, _q41);
19311 : 161 : if ((_q40 == _p0 && ! TREE_SIDE_EFFECTS (_q40)) || (operand_equal_p (_q40, _p0, 0) && types_match (_q40, _p0)))
19312 : : {
19313 : 3 : switch (TREE_CODE (_q41))
19314 : : {
19315 : 3 : case INTEGER_CST:
19316 : 3 : {
19317 : 3 : {
19318 : 3 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q41 };
19319 : 3 : if (gimple_simplify_313 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
19320 : 3 : return true;
19321 : : }
19322 : 0 : break;
19323 : : }
19324 : : default:;
19325 : : }
19326 : : }
19327 : 79720783 : break;
19328 : : }
19329 : : default:;
19330 : : }
19331 : : }
19332 : : break;
19333 : : default:;
19334 : : }
19335 : : break;
19336 : : }
19337 : : default:;
19338 : : }
19339 : : }
19340 : : break;
19341 : 79720783 : default:;
19342 : : }
19343 : 79720783 : if (integer_onep (_p1))
19344 : : {
19345 : 4629571 : {
19346 : 4629571 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
19347 : 4629571 : if (TREE_CODE (TREE_TYPE (captures[0])) == BOOLEAN_TYPE
19348 : 4629571 : && types_match (type, TREE_TYPE (captures[0]))
19349 : : )
19350 : : {
19351 : 67251 : gimple_seq *lseq = seq;
19352 : 67251 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2415;
19353 : 67251 : {
19354 : 67251 : tree tem;
19355 : 67251 : tem = captures[0];
19356 : 67251 : res_op->set_value (tem);
19357 : 67251 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1152, __FILE__, __LINE__, true);
19358 : 67251 : return true;
19359 : : }
19360 : 0 : next_after_fail2415:;
19361 : : }
19362 : : }
19363 : : }
19364 : 79653532 : switch (TREE_CODE (_p0))
19365 : : {
19366 : 78885964 : case SSA_NAME:
19367 : 78885964 : if (gimple *_d1 = get_def (valueize, _p0))
19368 : : {
19369 : 26803999 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
19370 : 32974199 : switch (gimple_assign_rhs_code (_a1))
19371 : : {
19372 : 12952 : case COND_EXPR:
19373 : 12952 : {
19374 : 12952 : tree _q20 = gimple_assign_rhs1 (_a1);
19375 : 12952 : _q20 = do_valueize (valueize, _q20);
19376 : 12952 : tree _q21 = gimple_assign_rhs2 (_a1);
19377 : 12952 : _q21 = do_valueize (valueize, _q21);
19378 : 12952 : tree _q22 = gimple_assign_rhs3 (_a1);
19379 : 12952 : _q22 = do_valueize (valueize, _q22);
19380 : 12952 : {
19381 : 12952 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1 };
19382 : 12952 : if (gimple_simplify_314 (res_op, seq, valueize, type, captures, EQ_EXPR))
19383 : 398 : return true;
19384 : : }
19385 : 12554 : break;
19386 : : }
19387 : : default:;
19388 : : }
19389 : : }
19390 : : break;
19391 : 79653134 : default:;
19392 : : }
19393 : 79653134 : switch (TREE_CODE (_p1))
19394 : : {
19395 : 13111825 : case SSA_NAME:
19396 : 13111825 : if (gimple *_d1 = get_def (valueize, _p1))
19397 : : {
19398 : 4346767 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
19399 : 6417509 : switch (gimple_assign_rhs_code (_a1))
19400 : : {
19401 : 10827 : case COND_EXPR:
19402 : 10827 : {
19403 : 10827 : tree _q30 = gimple_assign_rhs1 (_a1);
19404 : 10827 : _q30 = do_valueize (valueize, _q30);
19405 : 10827 : tree _q31 = gimple_assign_rhs2 (_a1);
19406 : 10827 : _q31 = do_valueize (valueize, _q31);
19407 : 10827 : tree _q32 = gimple_assign_rhs3 (_a1);
19408 : 10827 : _q32 = do_valueize (valueize, _q32);
19409 : 10827 : {
19410 : 10827 : tree captures[4] ATTRIBUTE_UNUSED = { _q30, _q31, _q32, _p0 };
19411 : 10827 : if (gimple_simplify_314 (res_op, seq, valueize, type, captures, EQ_EXPR))
19412 : 0 : return true;
19413 : : }
19414 : 10827 : break;
19415 : : }
19416 : : default:;
19417 : : }
19418 : : }
19419 : : break;
19420 : 79653134 : default:;
19421 : : }
19422 : 79653134 : switch (TREE_CODE (_p0))
19423 : : {
19424 : 78885566 : case SSA_NAME:
19425 : 78885566 : if (gimple *_d1 = get_def (valueize, _p0))
19426 : : {
19427 : 26803601 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
19428 : 32973801 : switch (gimple_assign_rhs_code (_a1))
19429 : : {
19430 : 1249934 : case BIT_AND_EXPR:
19431 : 1249934 : {
19432 : 1249934 : tree _q20 = gimple_assign_rhs1 (_a1);
19433 : 1249934 : _q20 = do_valueize (valueize, _q20);
19434 : 1249934 : tree _q21 = gimple_assign_rhs2 (_a1);
19435 : 1249934 : _q21 = do_valueize (valueize, _q21);
19436 : 1249934 : if (tree_swap_operands_p (_q20, _q21))
19437 : 6770 : std::swap (_q20, _q21);
19438 : 1249934 : switch (TREE_CODE (_q21))
19439 : : {
19440 : 2237 : case VECTOR_CST:
19441 : 2237 : {
19442 : 2237 : if (integer_zerop (_p1))
19443 : : {
19444 : 2206 : {
19445 : 2206 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
19446 : 2206 : const enum tree_code cmp = EQ_EXPR;
19447 : 2206 : const enum tree_code icmp = LE_EXPR;
19448 : 2206 : {
19449 : 2206 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
19450 : 2206 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
19451 : : )
19452 : : {
19453 : 9 : {
19454 : 9 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
19455 : 9 : ? optab_vector : optab_default;
19456 : 9 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
19457 : 9 : if (target_supports_op_p (utype, icmp, optab)
19458 : 9 : || (optimize_vectors_before_lowering_p ()
19459 : 6 : && (!target_supports_op_p (type, cmp, optab)
19460 : 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
19461 : : )
19462 : : {
19463 : 6 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
19464 : : )
19465 : : {
19466 : 4 : gimple_seq *lseq = seq;
19467 : 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2416;
19468 : 4 : {
19469 : 4 : res_op->set_op (icmp, type, 2);
19470 : 4 : res_op->ops[0] = captures[1];
19471 : 4 : res_op->ops[1] = csts;
19472 : 4 : res_op->resimplify (lseq, valueize);
19473 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1153, __FILE__, __LINE__, true);
19474 : 4 : return true;
19475 : : }
19476 : 0 : next_after_fail2416:;
19477 : : }
19478 : : else
19479 : : {
19480 : 2 : gimple_seq *lseq = seq;
19481 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2417;
19482 : 2 : {
19483 : 2 : res_op->set_op (icmp, type, 2);
19484 : 2 : {
19485 : 2 : tree _o1[1], _r1;
19486 : 2 : _o1[0] = captures[1];
19487 : 2 : if (utype != TREE_TYPE (_o1[0]) /* XXX */
19488 : 2 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
19489 : : {
19490 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, utype, _o1[0]);
19491 : 2 : tem_op.resimplify (lseq, valueize);
19492 : 2 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
19493 : 2 : if (!_r1) goto next_after_fail2417;
19494 : : }
19495 : : else
19496 : : _r1 = _o1[0];
19497 : 0 : res_op->ops[0] = _r1;
19498 : : }
19499 : 0 : res_op->ops[1] = csts;
19500 : 0 : res_op->resimplify (lseq, valueize);
19501 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1154, __FILE__, __LINE__, true);
19502 : 0 : return true;
19503 : : }
19504 : 2202 : next_after_fail2417:;
19505 : : }
19506 : : }
19507 : : }
19508 : : }
19509 : : }
19510 : : }
19511 : : }
19512 : : break;
19513 : : }
19514 : 1176554 : case INTEGER_CST:
19515 : 1176554 : {
19516 : 1176554 : if (integer_zerop (_p1))
19517 : : {
19518 : 661428 : {
19519 : 661428 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
19520 : 661428 : const enum tree_code cmp = EQ_EXPR;
19521 : 661428 : const enum tree_code icmp = LE_EXPR;
19522 : 661428 : {
19523 : 661428 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
19524 : 661428 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
19525 : : )
19526 : : {
19527 : 325 : {
19528 : 325 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
19529 : 325 : ? optab_vector : optab_default;
19530 : 325 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
19531 : 325 : if (target_supports_op_p (utype, icmp, optab)
19532 : 325 : || (optimize_vectors_before_lowering_p ()
19533 : 321 : && (!target_supports_op_p (type, cmp, optab)
19534 : 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
19535 : : )
19536 : : {
19537 : 321 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
19538 : : )
19539 : : {
19540 : 315 : gimple_seq *lseq = seq;
19541 : 315 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2418;
19542 : 315 : {
19543 : 315 : res_op->set_op (icmp, type, 2);
19544 : 315 : res_op->ops[0] = captures[1];
19545 : 315 : res_op->ops[1] = csts;
19546 : 315 : res_op->resimplify (lseq, valueize);
19547 : 315 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1153, __FILE__, __LINE__, true);
19548 : 315 : return true;
19549 : : }
19550 : 0 : next_after_fail2418:;
19551 : : }
19552 : : else
19553 : : {
19554 : 6 : gimple_seq *lseq = seq;
19555 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2419;
19556 : 6 : {
19557 : 6 : res_op->set_op (icmp, type, 2);
19558 : 6 : {
19559 : 6 : tree _o1[1], _r1;
19560 : 6 : _o1[0] = captures[1];
19561 : 6 : if (utype != TREE_TYPE (_o1[0]) /* XXX */
19562 : 6 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
19563 : : {
19564 : 6 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, utype, _o1[0]);
19565 : 6 : tem_op.resimplify (lseq, valueize);
19566 : 6 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
19567 : 6 : if (!_r1) goto next_after_fail2419;
19568 : : }
19569 : : else
19570 : : _r1 = _o1[0];
19571 : 6 : res_op->ops[0] = _r1;
19572 : : }
19573 : 6 : res_op->ops[1] = csts;
19574 : 6 : res_op->resimplify (lseq, valueize);
19575 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1154, __FILE__, __LINE__, true);
19576 : 6 : return true;
19577 : : }
19578 : 661107 : next_after_fail2419:;
19579 : : }
19580 : : }
19581 : : }
19582 : : }
19583 : : }
19584 : : }
19585 : : }
19586 : : break;
19587 : : }
19588 : 1249609 : default:;
19589 : : }
19590 : 1249609 : switch (TREE_CODE (_q20))
19591 : : {
19592 : 0 : case VECTOR_CST:
19593 : 0 : {
19594 : 0 : if (integer_zerop (_p1))
19595 : : {
19596 : 0 : {
19597 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
19598 : 0 : const enum tree_code cmp = EQ_EXPR;
19599 : 0 : const enum tree_code icmp = LE_EXPR;
19600 : 0 : {
19601 : 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
19602 : 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
19603 : : )
19604 : : {
19605 : 0 : {
19606 : 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
19607 : 0 : ? optab_vector : optab_default;
19608 : 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
19609 : 0 : if (target_supports_op_p (utype, icmp, optab)
19610 : 0 : || (optimize_vectors_before_lowering_p ()
19611 : 0 : && (!target_supports_op_p (type, cmp, optab)
19612 : 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
19613 : : )
19614 : : {
19615 : 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
19616 : : )
19617 : : {
19618 : 0 : gimple_seq *lseq = seq;
19619 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2420;
19620 : 0 : {
19621 : 0 : res_op->set_op (icmp, type, 2);
19622 : 0 : res_op->ops[0] = captures[1];
19623 : 0 : res_op->ops[1] = csts;
19624 : 0 : res_op->resimplify (lseq, valueize);
19625 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1153, __FILE__, __LINE__, true);
19626 : 0 : return true;
19627 : : }
19628 : 0 : next_after_fail2420:;
19629 : : }
19630 : : else
19631 : : {
19632 : 0 : gimple_seq *lseq = seq;
19633 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2421;
19634 : 0 : {
19635 : 0 : res_op->set_op (icmp, type, 2);
19636 : 0 : {
19637 : 0 : tree _o1[1], _r1;
19638 : 0 : _o1[0] = captures[1];
19639 : 0 : if (utype != TREE_TYPE (_o1[0]) /* XXX */
19640 : 0 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
19641 : : {
19642 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, utype, _o1[0]);
19643 : 0 : tem_op.resimplify (lseq, valueize);
19644 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
19645 : 0 : if (!_r1) goto next_after_fail2421;
19646 : : }
19647 : : else
19648 : : _r1 = _o1[0];
19649 : 0 : res_op->ops[0] = _r1;
19650 : : }
19651 : 0 : res_op->ops[1] = csts;
19652 : 0 : res_op->resimplify (lseq, valueize);
19653 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1154, __FILE__, __LINE__, true);
19654 : 0 : return true;
19655 : : }
19656 : 0 : next_after_fail2421:;
19657 : : }
19658 : : }
19659 : : }
19660 : : }
19661 : : }
19662 : : }
19663 : : }
19664 : : break;
19665 : : }
19666 : 0 : case INTEGER_CST:
19667 : 0 : {
19668 : 0 : if (integer_zerop (_p1))
19669 : : {
19670 : 0 : {
19671 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
19672 : 0 : const enum tree_code cmp = EQ_EXPR;
19673 : 0 : const enum tree_code icmp = LE_EXPR;
19674 : 0 : {
19675 : 0 : tree csts = bitmask_inv_cst_vector_p (captures[2]);
19676 : 0 : if (csts && (VECTOR_TYPE_P (TREE_TYPE (captures[2])) || single_use (captures[0]))
19677 : : )
19678 : : {
19679 : 0 : {
19680 : 0 : auto optab = VECTOR_TYPE_P (TREE_TYPE (captures[2]))
19681 : 0 : ? optab_vector : optab_default;
19682 : 0 : tree utype = unsigned_type_for (TREE_TYPE (captures[2]));
19683 : 0 : if (target_supports_op_p (utype, icmp, optab)
19684 : 0 : || (optimize_vectors_before_lowering_p ()
19685 : 0 : && (!target_supports_op_p (type, cmp, optab)
19686 : 0 : || !target_supports_op_p (type, BIT_AND_EXPR, optab)))
19687 : : )
19688 : : {
19689 : 0 : if (TYPE_UNSIGNED (TREE_TYPE (captures[2]))
19690 : : )
19691 : : {
19692 : 0 : gimple_seq *lseq = seq;
19693 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2422;
19694 : 0 : {
19695 : 0 : res_op->set_op (icmp, type, 2);
19696 : 0 : res_op->ops[0] = captures[1];
19697 : 0 : res_op->ops[1] = csts;
19698 : 0 : res_op->resimplify (lseq, valueize);
19699 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1153, __FILE__, __LINE__, true);
19700 : 0 : return true;
19701 : : }
19702 : 0 : next_after_fail2422:;
19703 : : }
19704 : : else
19705 : : {
19706 : 0 : gimple_seq *lseq = seq;
19707 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2423;
19708 : 0 : {
19709 : 0 : res_op->set_op (icmp, type, 2);
19710 : 0 : {
19711 : 0 : tree _o1[1], _r1;
19712 : 0 : _o1[0] = captures[1];
19713 : 0 : if (utype != TREE_TYPE (_o1[0]) /* XXX */
19714 : 0 : && !useless_type_conversion_p (utype, TREE_TYPE (_o1[0])))
19715 : : {
19716 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, utype, _o1[0]);
19717 : 0 : tem_op.resimplify (lseq, valueize);
19718 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
19719 : 0 : if (!_r1) goto next_after_fail2423;
19720 : : }
19721 : : else
19722 : : _r1 = _o1[0];
19723 : 0 : res_op->ops[0] = _r1;
19724 : : }
19725 : 0 : res_op->ops[1] = csts;
19726 : 0 : res_op->resimplify (lseq, valueize);
19727 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1154, __FILE__, __LINE__, true);
19728 : 0 : return true;
19729 : : }
19730 : 0 : next_after_fail2423:;
19731 : : }
19732 : : }
19733 : : }
19734 : : }
19735 : : }
19736 : : }
19737 : : }
19738 : : break;
19739 : : }
19740 : : default:;
19741 : : }
19742 : 80038307 : break;
19743 : : }
19744 : 46959 : case RSHIFT_EXPR:
19745 : 46959 : {
19746 : 46959 : tree _q20 = gimple_assign_rhs1 (_a1);
19747 : 46959 : _q20 = do_valueize (valueize, _q20);
19748 : 46959 : tree _q21 = gimple_assign_rhs2 (_a1);
19749 : 46959 : _q21 = do_valueize (valueize, _q21);
19750 : 46959 : switch (TREE_CODE (_q20))
19751 : : {
19752 : 46358 : case SSA_NAME:
19753 : 46358 : if (gimple *_d2 = get_def (valueize, _q20))
19754 : : {
19755 : 45636 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
19756 : 34637 : switch (gimple_assign_rhs_code (_a2))
19757 : : {
19758 : 589 : case MULT_EXPR:
19759 : 589 : {
19760 : 589 : tree _q30 = gimple_assign_rhs1 (_a2);
19761 : 589 : _q30 = do_valueize (valueize, _q30);
19762 : 589 : tree _q31 = gimple_assign_rhs2 (_a2);
19763 : 589 : _q31 = do_valueize (valueize, _q31);
19764 : 589 : if (tree_swap_operands_p (_q30, _q31))
19765 : 0 : std::swap (_q30, _q31);
19766 : 589 : switch (TREE_CODE (_q30))
19767 : : {
19768 : 589 : case SSA_NAME:
19769 : 589 : if (gimple *_d3 = get_def (valueize, _q30))
19770 : : {
19771 : 589 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
19772 : 544 : switch (gimple_assign_rhs_code (_a3))
19773 : : {
19774 : 538 : CASE_CONVERT:
19775 : 538 : {
19776 : 538 : tree _q40 = gimple_assign_rhs1 (_a3);
19777 : 538 : _q40 = do_valueize (valueize, _q40);
19778 : 538 : switch (TREE_CODE (_q31))
19779 : : {
19780 : 0 : case SSA_NAME:
19781 : 0 : if (gimple *_d4 = get_def (valueize, _q31))
19782 : : {
19783 : 0 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
19784 : 0 : switch (gimple_assign_rhs_code (_a4))
19785 : : {
19786 : 0 : CASE_CONVERT:
19787 : 0 : {
19788 : 0 : tree _q60 = gimple_assign_rhs1 (_a4);
19789 : 0 : _q60 = do_valueize (valueize, _q60);
19790 : 0 : switch (TREE_CODE (_q21))
19791 : : {
19792 : 0 : case INTEGER_CST:
19793 : 0 : {
19794 : 0 : if (integer_zerop (_p1))
19795 : : {
19796 : 0 : {
19797 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q30, _q40, _q60, _q21 };
19798 : 0 : if (gimple_simplify_315 (res_op, seq, valueize, type, captures, EQ_EXPR))
19799 : 0 : return true;
19800 : : }
19801 : : }
19802 : : break;
19803 : : }
19804 : : default:;
19805 : : }
19806 : : break;
19807 : : }
19808 : : default:;
19809 : : }
19810 : : }
19811 : : break;
19812 : : default:;
19813 : : }
19814 : : break;
19815 : : }
19816 : : default:;
19817 : : }
19818 : : }
19819 : : break;
19820 : : default:;
19821 : : }
19822 : 80038307 : break;
19823 : : }
19824 : : default:;
19825 : : }
19826 : : }
19827 : : break;
19828 : : default:;
19829 : : }
19830 : : break;
19831 : : }
19832 : 860426 : case PLUS_EXPR:
19833 : 860426 : {
19834 : 860426 : tree _q20 = gimple_assign_rhs1 (_a1);
19835 : 860426 : _q20 = do_valueize (valueize, _q20);
19836 : 860426 : tree _q21 = gimple_assign_rhs2 (_a1);
19837 : 860426 : _q21 = do_valueize (valueize, _q21);
19838 : 860426 : if (tree_swap_operands_p (_q20, _q21))
19839 : 7093 : std::swap (_q20, _q21);
19840 : 860426 : switch (TREE_CODE (_q21))
19841 : : {
19842 : 733524 : case INTEGER_CST:
19843 : 733524 : {
19844 : 733524 : switch (TREE_CODE (_p1))
19845 : : {
19846 : 491147 : case INTEGER_CST:
19847 : 491147 : {
19848 : 491147 : {
19849 : 491147 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
19850 : 491147 : if (gimple_simplify_316 (res_op, seq, valueize, type, captures, PLUS_EXPR, MINUS_EXPR, EQ_EXPR))
19851 : 39394 : return true;
19852 : : }
19853 : 451753 : break;
19854 : : }
19855 : : default:;
19856 : : }
19857 : : break;
19858 : : }
19859 : : default:;
19860 : : }
19861 : 80038307 : break;
19862 : : }
19863 : 236245 : case MINUS_EXPR:
19864 : 236245 : {
19865 : 236245 : tree _q20 = gimple_assign_rhs1 (_a1);
19866 : 236245 : _q20 = do_valueize (valueize, _q20);
19867 : 236245 : tree _q21 = gimple_assign_rhs2 (_a1);
19868 : 236245 : _q21 = do_valueize (valueize, _q21);
19869 : 236245 : switch (TREE_CODE (_q21))
19870 : : {
19871 : 22119 : case INTEGER_CST:
19872 : 22119 : {
19873 : 22119 : switch (TREE_CODE (_p1))
19874 : : {
19875 : 21682 : case INTEGER_CST:
19876 : 21682 : {
19877 : 21682 : {
19878 : 21682 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
19879 : 21682 : if (gimple_simplify_316 (res_op, seq, valueize, type, captures, MINUS_EXPR, PLUS_EXPR, EQ_EXPR))
19880 : 24 : return true;
19881 : : }
19882 : 21658 : break;
19883 : : }
19884 : : default:;
19885 : : }
19886 : : break;
19887 : : }
19888 : 236221 : default:;
19889 : : }
19890 : 236221 : switch (TREE_CODE (_q20))
19891 : : {
19892 : 2979 : case INTEGER_CST:
19893 : 2979 : {
19894 : 2979 : switch (TREE_CODE (_p1))
19895 : : {
19896 : 1242 : case INTEGER_CST:
19897 : 1242 : {
19898 : 1242 : {
19899 : 1242 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
19900 : 1242 : if (gimple_simplify_317 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR))
19901 : 1242 : return true;
19902 : : }
19903 : 0 : break;
19904 : : }
19905 : : default:;
19906 : : }
19907 : : break;
19908 : : }
19909 : : default:;
19910 : : }
19911 : : break;
19912 : : }
19913 : : default:;
19914 : : }
19915 : 8453018 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
19916 : 4821440 : switch (gimple_call_combined_fn (_c1))
19917 : : {
19918 : 839 : case CFN_BUILT_IN_CLZ:
19919 : 839 : if (gimple_call_num_args (_c1) == 1)
19920 : : {
19921 : 839 : tree _q20 = gimple_call_arg (_c1, 0);
19922 : 839 : _q20 = do_valueize (valueize, _q20);
19923 : 839 : switch (TREE_CODE (_p1))
19924 : : {
19925 : 839 : case INTEGER_CST:
19926 : 839 : {
19927 : 839 : {
19928 : 839 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
19929 : 839 : if (gimple_simplify_318 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR, CFN_BUILT_IN_CLZ))
19930 : 8 : return true;
19931 : : }
19932 : 831 : break;
19933 : : }
19934 : : default:;
19935 : : }
19936 : : }
19937 : : break;
19938 : 12 : case CFN_BUILT_IN_CTZ:
19939 : 12 : if (gimple_call_num_args (_c1) == 1)
19940 : : {
19941 : 12 : tree _q20 = gimple_call_arg (_c1, 0);
19942 : 12 : _q20 = do_valueize (valueize, _q20);
19943 : 12 : switch (TREE_CODE (_p1))
19944 : : {
19945 : 12 : case INTEGER_CST:
19946 : 12 : {
19947 : 12 : {
19948 : 12 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
19949 : 12 : if (gimple_simplify_320 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_CTZ))
19950 : 6 : return true;
19951 : : }
19952 : 6 : break;
19953 : : }
19954 : : default:;
19955 : : }
19956 : : }
19957 : : break;
19958 : 0 : case CFN_BUILT_IN_FFS:
19959 : 0 : if (gimple_call_num_args (_c1) == 1)
19960 : : {
19961 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
19962 : 0 : _q20 = do_valueize (valueize, _q20);
19963 : 0 : switch (TREE_CODE (_p1))
19964 : : {
19965 : 0 : case INTEGER_CST:
19966 : 0 : {
19967 : 0 : {
19968 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
19969 : 0 : if (gimple_simplify_323 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_FFS))
19970 : 0 : return true;
19971 : : }
19972 : 0 : break;
19973 : : }
19974 : : default:;
19975 : : }
19976 : : }
19977 : : break;
19978 : 830 : case CFN_REDUC_IOR:
19979 : 830 : if (gimple_call_num_args (_c1) == 1)
19980 : : {
19981 : 830 : tree _q20 = gimple_call_arg (_c1, 0);
19982 : 830 : _q20 = do_valueize (valueize, _q20);
19983 : 830 : if (integer_zerop (_p1))
19984 : : {
19985 : 830 : {
19986 : 830 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
19987 : 830 : if (gimple_simplify_324 (res_op, seq, valueize, type, captures, EQ_EXPR))
19988 : 5 : return true;
19989 : : }
19990 : : }
19991 : : }
19992 : : break;
19993 : 0 : case CFN_BUILT_IN_FFSIMAX:
19994 : 0 : if (gimple_call_num_args (_c1) == 1)
19995 : : {
19996 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
19997 : 0 : _q20 = do_valueize (valueize, _q20);
19998 : 0 : switch (TREE_CODE (_p1))
19999 : : {
20000 : 0 : case INTEGER_CST:
20001 : 0 : {
20002 : 0 : {
20003 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20004 : 0 : if (gimple_simplify_323 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_FFSIMAX))
20005 : 0 : return true;
20006 : : }
20007 : 0 : break;
20008 : : }
20009 : : default:;
20010 : : }
20011 : : }
20012 : : break;
20013 : 542 : case CFN_BUILT_IN_POPCOUNT:
20014 : 542 : if (gimple_call_num_args (_c1) == 1)
20015 : : {
20016 : 542 : tree _q20 = gimple_call_arg (_c1, 0);
20017 : 542 : _q20 = do_valueize (valueize, _q20);
20018 : 542 : if (integer_zerop (_p1))
20019 : : {
20020 : 0 : {
20021 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
20022 : 0 : if (gimple_simplify_322 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNT))
20023 : 0 : return true;
20024 : : }
20025 : : }
20026 : : }
20027 : : break;
20028 : 181 : case CFN_BUILT_IN_CLZL:
20029 : 181 : if (gimple_call_num_args (_c1) == 1)
20030 : : {
20031 : 181 : tree _q20 = gimple_call_arg (_c1, 0);
20032 : 181 : _q20 = do_valueize (valueize, _q20);
20033 : 181 : switch (TREE_CODE (_p1))
20034 : : {
20035 : 178 : case INTEGER_CST:
20036 : 178 : {
20037 : 178 : {
20038 : 178 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20039 : 178 : if (gimple_simplify_318 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR, CFN_BUILT_IN_CLZL))
20040 : 6 : return true;
20041 : : }
20042 : 172 : break;
20043 : : }
20044 : : default:;
20045 : : }
20046 : : }
20047 : : break;
20048 : 14 : case CFN_BUILT_IN_CTZL:
20049 : 14 : if (gimple_call_num_args (_c1) == 1)
20050 : : {
20051 : 14 : tree _q20 = gimple_call_arg (_c1, 0);
20052 : 14 : _q20 = do_valueize (valueize, _q20);
20053 : 14 : switch (TREE_CODE (_p1))
20054 : : {
20055 : 14 : case INTEGER_CST:
20056 : 14 : {
20057 : 14 : {
20058 : 14 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20059 : 14 : if (gimple_simplify_320 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_CTZL))
20060 : 8 : return true;
20061 : : }
20062 : 6 : break;
20063 : : }
20064 : : default:;
20065 : : }
20066 : : }
20067 : : break;
20068 : 0 : case CFN_BUILT_IN_FFSL:
20069 : 0 : if (gimple_call_num_args (_c1) == 1)
20070 : : {
20071 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20072 : 0 : _q20 = do_valueize (valueize, _q20);
20073 : 0 : switch (TREE_CODE (_p1))
20074 : : {
20075 : 0 : case INTEGER_CST:
20076 : 0 : {
20077 : 0 : {
20078 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20079 : 0 : if (gimple_simplify_323 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_FFSL))
20080 : 0 : return true;
20081 : : }
20082 : 0 : break;
20083 : : }
20084 : : default:;
20085 : : }
20086 : : }
20087 : : break;
20088 : 100 : case CFN_BUILT_IN_POPCOUNTLL:
20089 : 100 : if (gimple_call_num_args (_c1) == 1)
20090 : : {
20091 : 100 : tree _q20 = gimple_call_arg (_c1, 0);
20092 : 100 : _q20 = do_valueize (valueize, _q20);
20093 : 100 : if (integer_zerop (_p1))
20094 : : {
20095 : 0 : {
20096 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
20097 : 0 : if (gimple_simplify_322 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTLL))
20098 : 0 : return true;
20099 : : }
20100 : : }
20101 : : }
20102 : : break;
20103 : 0 : case CFN_BUILT_IN_CTZIMAX:
20104 : 0 : if (gimple_call_num_args (_c1) == 1)
20105 : : {
20106 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20107 : 0 : _q20 = do_valueize (valueize, _q20);
20108 : 0 : switch (TREE_CODE (_p1))
20109 : : {
20110 : 0 : case INTEGER_CST:
20111 : 0 : {
20112 : 0 : {
20113 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20114 : 0 : if (gimple_simplify_320 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_CTZIMAX))
20115 : 0 : return true;
20116 : : }
20117 : 0 : break;
20118 : : }
20119 : : default:;
20120 : : }
20121 : : }
20122 : : break;
20123 : 0 : case CFN_POPCOUNT:
20124 : 0 : if (gimple_call_num_args (_c1) == 1)
20125 : : {
20126 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20127 : 0 : _q20 = do_valueize (valueize, _q20);
20128 : 0 : if (integer_zerop (_p1))
20129 : : {
20130 : 0 : {
20131 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
20132 : 0 : if (gimple_simplify_322 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR, CFN_POPCOUNT))
20133 : 0 : return true;
20134 : : }
20135 : : }
20136 : : }
20137 : : break;
20138 : 0 : case CFN_CLZ:
20139 : 0 : if (gimple_call_num_args (_c1) == 1)
20140 : : {
20141 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20142 : 0 : _q20 = do_valueize (valueize, _q20);
20143 : 0 : switch (TREE_CODE (_p1))
20144 : : {
20145 : 0 : case INTEGER_CST:
20146 : 0 : {
20147 : 0 : {
20148 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20149 : 0 : if (gimple_simplify_318 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR, CFN_CLZ))
20150 : 0 : return true;
20151 : : }
20152 : 0 : break;
20153 : : }
20154 : : default:;
20155 : : }
20156 : : }
20157 : 0 : if (gimple_call_num_args (_c1) == 2)
20158 : : {
20159 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20160 : 0 : _q20 = do_valueize (valueize, _q20);
20161 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
20162 : 0 : _q21 = do_valueize (valueize, _q21);
20163 : 0 : switch (TREE_CODE (_p1))
20164 : : {
20165 : 0 : case INTEGER_CST:
20166 : 0 : {
20167 : 0 : {
20168 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
20169 : 0 : if (gimple_simplify_319 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR))
20170 : 0 : return true;
20171 : : }
20172 : 0 : break;
20173 : : }
20174 : : default:;
20175 : : }
20176 : : }
20177 : : break;
20178 : 6 : case CFN_CTZ:
20179 : 6 : if (gimple_call_num_args (_c1) == 1)
20180 : : {
20181 : 6 : tree _q20 = gimple_call_arg (_c1, 0);
20182 : 6 : _q20 = do_valueize (valueize, _q20);
20183 : 6 : switch (TREE_CODE (_p1))
20184 : : {
20185 : 6 : case INTEGER_CST:
20186 : 6 : {
20187 : 6 : {
20188 : 6 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20189 : 6 : if (gimple_simplify_320 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_CTZ))
20190 : 2 : return true;
20191 : : }
20192 : 4 : break;
20193 : : }
20194 : : default:;
20195 : : }
20196 : : }
20197 : 4 : if (gimple_call_num_args (_c1) == 2)
20198 : : {
20199 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20200 : 0 : _q20 = do_valueize (valueize, _q20);
20201 : 0 : tree _q21 = gimple_call_arg (_c1, 1);
20202 : 0 : _q21 = do_valueize (valueize, _q21);
20203 : 0 : switch (TREE_CODE (_p1))
20204 : : {
20205 : 0 : case INTEGER_CST:
20206 : 0 : {
20207 : 0 : {
20208 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
20209 : 0 : if (gimple_simplify_321 (res_op, seq, valueize, type, captures, EQ_EXPR))
20210 : 0 : return true;
20211 : : }
20212 : 0 : break;
20213 : : }
20214 : : default:;
20215 : : }
20216 : : }
20217 : : break;
20218 : 0 : case CFN_FFS:
20219 : 0 : if (gimple_call_num_args (_c1) == 1)
20220 : : {
20221 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20222 : 0 : _q20 = do_valueize (valueize, _q20);
20223 : 0 : switch (TREE_CODE (_p1))
20224 : : {
20225 : 0 : case INTEGER_CST:
20226 : 0 : {
20227 : 0 : {
20228 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20229 : 0 : if (gimple_simplify_323 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_FFS))
20230 : 0 : return true;
20231 : : }
20232 : 0 : break;
20233 : : }
20234 : : default:;
20235 : : }
20236 : : }
20237 : : break;
20238 : 0 : case CFN_BUILT_IN_POPCOUNTIMAX:
20239 : 0 : if (gimple_call_num_args (_c1) == 1)
20240 : : {
20241 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20242 : 0 : _q20 = do_valueize (valueize, _q20);
20243 : 0 : if (integer_zerop (_p1))
20244 : : {
20245 : 0 : {
20246 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
20247 : 0 : if (gimple_simplify_322 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTIMAX))
20248 : 0 : return true;
20249 : : }
20250 : : }
20251 : : }
20252 : : break;
20253 : 0 : case CFN_BUILT_IN_CLZIMAX:
20254 : 0 : if (gimple_call_num_args (_c1) == 1)
20255 : : {
20256 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20257 : 0 : _q20 = do_valueize (valueize, _q20);
20258 : 0 : switch (TREE_CODE (_p1))
20259 : : {
20260 : 0 : case INTEGER_CST:
20261 : 0 : {
20262 : 0 : {
20263 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20264 : 0 : if (gimple_simplify_318 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR, CFN_BUILT_IN_CLZIMAX))
20265 : 0 : return true;
20266 : : }
20267 : 0 : break;
20268 : : }
20269 : : default:;
20270 : : }
20271 : : }
20272 : : break;
20273 : 35 : case CFN_BUILT_IN_POPCOUNTL:
20274 : 35 : if (gimple_call_num_args (_c1) == 1)
20275 : : {
20276 : 35 : tree _q20 = gimple_call_arg (_c1, 0);
20277 : 35 : _q20 = do_valueize (valueize, _q20);
20278 : 35 : if (integer_zerop (_p1))
20279 : : {
20280 : 0 : {
20281 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _q20 };
20282 : 0 : if (gimple_simplify_322 (res_op, seq, valueize, type, captures, EQ_EXPR, EQ_EXPR, CFN_BUILT_IN_POPCOUNTL))
20283 : 0 : return true;
20284 : : }
20285 : : }
20286 : : }
20287 : : break;
20288 : 488 : case CFN_BUILT_IN_CLZLL:
20289 : 488 : if (gimple_call_num_args (_c1) == 1)
20290 : : {
20291 : 488 : tree _q20 = gimple_call_arg (_c1, 0);
20292 : 488 : _q20 = do_valueize (valueize, _q20);
20293 : 488 : switch (TREE_CODE (_p1))
20294 : : {
20295 : 488 : case INTEGER_CST:
20296 : 488 : {
20297 : 488 : {
20298 : 488 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20299 : 488 : if (gimple_simplify_318 (res_op, seq, valueize, type, captures, EQ_EXPR, LT_EXPR, CFN_BUILT_IN_CLZLL))
20300 : 20 : return true;
20301 : : }
20302 : 468 : break;
20303 : : }
20304 : : default:;
20305 : : }
20306 : : }
20307 : : break;
20308 : 0 : case CFN_BUILT_IN_CTZLL:
20309 : 0 : if (gimple_call_num_args (_c1) == 1)
20310 : : {
20311 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20312 : 0 : _q20 = do_valueize (valueize, _q20);
20313 : 0 : switch (TREE_CODE (_p1))
20314 : : {
20315 : 0 : case INTEGER_CST:
20316 : 0 : {
20317 : 0 : {
20318 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20319 : 0 : if (gimple_simplify_320 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_CTZLL))
20320 : 0 : return true;
20321 : : }
20322 : 0 : break;
20323 : : }
20324 : : default:;
20325 : : }
20326 : : }
20327 : : break;
20328 : 0 : case CFN_BUILT_IN_FFSLL:
20329 : 0 : if (gimple_call_num_args (_c1) == 1)
20330 : : {
20331 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
20332 : 0 : _q20 = do_valueize (valueize, _q20);
20333 : 0 : switch (TREE_CODE (_p1))
20334 : : {
20335 : 0 : case INTEGER_CST:
20336 : 0 : {
20337 : 0 : {
20338 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
20339 : 0 : if (gimple_simplify_323 (res_op, seq, valueize, type, captures, EQ_EXPR, CFN_BUILT_IN_FFSLL))
20340 : 0 : return true;
20341 : : }
20342 : 0 : break;
20343 : : }
20344 : : default:;
20345 : : }
20346 : : }
20347 : : break;
20348 : : default:;
20349 : : }
20350 : : }
20351 : : break;
20352 : : default:;
20353 : : }
20354 : : return false;
20355 : : }
20356 : :
20357 : : bool
20358 : 2235 : gimple_simplify_CEIL_MOD_EXPR (gimple_match_op *res_op, gimple_seq *seq,
20359 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
20360 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
20361 : : {
20362 : 2235 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
20363 : 2235 : if (integer_zerop (_p0))
20364 : : {
20365 : 0 : {
20366 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
20367 : 0 : if (gimple_simplify_353 (res_op, seq, valueize, type, captures, CEIL_MOD_EXPR))
20368 : 0 : return true;
20369 : : }
20370 : : }
20371 : 2235 : if (integer_onep (_p1))
20372 : : {
20373 : 0 : {
20374 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
20375 : 0 : if (gimple_simplify_354 (res_op, seq, valueize, type, captures, CEIL_MOD_EXPR))
20376 : 0 : return true;
20377 : : }
20378 : : }
20379 : 2235 : if (integer_minus_onep (_p1))
20380 : : {
20381 : 0 : {
20382 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
20383 : 0 : if (gimple_simplify_355 (res_op, seq, valueize, type, captures, CEIL_MOD_EXPR))
20384 : 0 : return true;
20385 : : }
20386 : : }
20387 : 2235 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
20388 : : {
20389 : 0 : {
20390 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
20391 : 0 : if (gimple_simplify_356 (res_op, seq, valueize, type, captures, CEIL_MOD_EXPR))
20392 : 0 : return true;
20393 : : }
20394 : : }
20395 : 2235 : switch (TREE_CODE (_p0))
20396 : : {
20397 : 2059 : case SSA_NAME:
20398 : 2059 : if (gimple *_d1 = get_def (valueize, _p0))
20399 : : {
20400 : 1696 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
20401 : 1024 : switch (gimple_assign_rhs_code (_a1))
20402 : : {
20403 : 0 : case CEIL_MOD_EXPR:
20404 : 0 : {
20405 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
20406 : 0 : _q20 = do_valueize (valueize, _q20);
20407 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
20408 : 0 : _q21 = do_valueize (valueize, _q21);
20409 : 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
20410 : : {
20411 : 0 : {
20412 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
20413 : 0 : if (gimple_simplify_357 (res_op, seq, valueize, type, captures, CEIL_MOD_EXPR))
20414 : 0 : return true;
20415 : : }
20416 : : }
20417 : : break;
20418 : : }
20419 : 0 : case MULT_EXPR:
20420 : 0 : {
20421 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
20422 : 0 : _q20 = do_valueize (valueize, _q20);
20423 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
20424 : 0 : _q21 = do_valueize (valueize, _q21);
20425 : 0 : if (tree_swap_operands_p (_q20, _q21))
20426 : 0 : std::swap (_q20, _q21);
20427 : 0 : switch (TREE_CODE (_q21))
20428 : : {
20429 : 0 : case INTEGER_CST:
20430 : 0 : {
20431 : 0 : switch (TREE_CODE (_p1))
20432 : : {
20433 : 0 : case INTEGER_CST:
20434 : 0 : {
20435 : 0 : {
20436 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
20437 : 0 : if (gimple_simplify_358 (res_op, seq, valueize, type, captures, CEIL_MOD_EXPR))
20438 : 0 : return true;
20439 : : }
20440 : 0 : break;
20441 : : }
20442 : : default:;
20443 : : }
20444 : : break;
20445 : : }
20446 : : default:;
20447 : : }
20448 : 2235 : break;
20449 : : }
20450 : 0 : case VEC_COND_EXPR:
20451 : 0 : {
20452 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
20453 : 0 : _q20 = do_valueize (valueize, _q20);
20454 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
20455 : 0 : _q21 = do_valueize (valueize, _q21);
20456 : 0 : tree _q22 = gimple_assign_rhs3 (_a1);
20457 : 0 : _q22 = do_valueize (valueize, _q22);
20458 : 0 : switch (TREE_CODE (_p1))
20459 : : {
20460 : 0 : case SSA_NAME:
20461 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
20462 : : {
20463 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
20464 : 0 : switch (gimple_assign_rhs_code (_a2))
20465 : : {
20466 : 0 : case VEC_COND_EXPR:
20467 : 0 : {
20468 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
20469 : 0 : _q60 = do_valueize (valueize, _q60);
20470 : 0 : tree _q61 = gimple_assign_rhs2 (_a2);
20471 : 0 : _q61 = do_valueize (valueize, _q61);
20472 : 0 : tree _q62 = gimple_assign_rhs3 (_a2);
20473 : 0 : _q62 = do_valueize (valueize, _q62);
20474 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
20475 : : {
20476 : 0 : {
20477 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
20478 : 0 : if (VECTOR_TYPE_P (type)
20479 : 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
20480 : : || types_match (type, TREE_TYPE (captures[2]))
20481 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
20482 : : || (optimize_vectors_before_lowering_p ()
20483 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
20484 : : )
20485 : : {
20486 : 0 : gimple_seq *lseq = seq;
20487 : 0 : if (lseq
20488 : 0 : && (!single_use (captures[0])
20489 : 0 : || !single_use (captures[4])))
20490 : 0 : lseq = NULL;
20491 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2576;
20492 : 0 : {
20493 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
20494 : 0 : res_op->ops[0] = captures[1];
20495 : 0 : {
20496 : 0 : tree _o1[2], _r1;
20497 : 0 : _o1[0] = captures[2];
20498 : 0 : _o1[1] = captures[5];
20499 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CEIL_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20500 : 0 : tem_op.resimplify (NULL, valueize);
20501 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20502 : 0 : if (!_r1) goto next_after_fail2576;
20503 : 0 : res_op->ops[1] = _r1;
20504 : : }
20505 : 0 : {
20506 : 0 : tree _o1[2], _r1;
20507 : 0 : _o1[0] = captures[3];
20508 : 0 : _o1[1] = captures[6];
20509 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CEIL_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20510 : 0 : tem_op.resimplify (NULL, valueize);
20511 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20512 : 0 : if (!_r1) goto next_after_fail2576;
20513 : 0 : res_op->ops[2] = _r1;
20514 : : }
20515 : 0 : res_op->resimplify (lseq, valueize);
20516 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
20517 : 0 : return true;
20518 : : }
20519 : 0 : next_after_fail2576:;
20520 : : }
20521 : : }
20522 : : }
20523 : : break;
20524 : : }
20525 : : default:;
20526 : : }
20527 : : }
20528 : : break;
20529 : 0 : default:;
20530 : : }
20531 : 0 : {
20532 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
20533 : 0 : if (VECTOR_TYPE_P (type)
20534 : 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
20535 : : || types_match (type, TREE_TYPE (captures[2]))
20536 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
20537 : : || (optimize_vectors_before_lowering_p ()
20538 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
20539 : : )
20540 : : {
20541 : 0 : gimple_seq *lseq = seq;
20542 : 0 : if (lseq
20543 : 0 : && (!single_use (captures[0])))
20544 : 0 : lseq = NULL;
20545 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2577;
20546 : 0 : {
20547 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
20548 : 0 : res_op->ops[0] = captures[1];
20549 : 0 : {
20550 : 0 : tree _o1[2], _r1;
20551 : 0 : _o1[0] = captures[2];
20552 : 0 : _o1[1] = captures[4];
20553 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CEIL_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20554 : 0 : tem_op.resimplify (NULL, valueize);
20555 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20556 : 0 : if (!_r1) goto next_after_fail2577;
20557 : 0 : res_op->ops[1] = _r1;
20558 : : }
20559 : 0 : {
20560 : 0 : tree _o1[2], _r1;
20561 : 0 : _o1[0] = captures[3];
20562 : 0 : _o1[1] = captures[4];
20563 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CEIL_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20564 : 0 : tem_op.resimplify (NULL, valueize);
20565 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20566 : 0 : if (!_r1) goto next_after_fail2577;
20567 : 0 : res_op->ops[2] = _r1;
20568 : : }
20569 : 0 : res_op->resimplify (lseq, valueize);
20570 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
20571 : 0 : return true;
20572 : : }
20573 : 0 : next_after_fail2577:;
20574 : : }
20575 : : }
20576 : 0 : break;
20577 : : }
20578 : : default:;
20579 : : }
20580 : : }
20581 : : break;
20582 : 2235 : default:;
20583 : : }
20584 : 2235 : switch (TREE_CODE (_p1))
20585 : : {
20586 : 1696 : case SSA_NAME:
20587 : 1696 : if (gimple *_d1 = get_def (valueize, _p1))
20588 : : {
20589 : 1420 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
20590 : 1372 : switch (gimple_assign_rhs_code (_a1))
20591 : : {
20592 : 0 : case VEC_COND_EXPR:
20593 : 0 : {
20594 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
20595 : 0 : _q30 = do_valueize (valueize, _q30);
20596 : 0 : tree _q31 = gimple_assign_rhs2 (_a1);
20597 : 0 : _q31 = do_valueize (valueize, _q31);
20598 : 0 : tree _q32 = gimple_assign_rhs3 (_a1);
20599 : 0 : _q32 = do_valueize (valueize, _q32);
20600 : 0 : {
20601 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
20602 : 0 : if (VECTOR_TYPE_P (type)
20603 : 0 : && (TREE_CODE_CLASS (CEIL_MOD_EXPR) != tcc_comparison
20604 : : || types_match (type, TREE_TYPE (captures[3]))
20605 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
20606 : : || (optimize_vectors_before_lowering_p ()
20607 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
20608 : : )
20609 : : {
20610 : 0 : gimple_seq *lseq = seq;
20611 : 0 : if (lseq
20612 : 0 : && (!single_use (captures[1])))
20613 : 0 : lseq = NULL;
20614 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2578;
20615 : 0 : {
20616 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
20617 : 0 : res_op->ops[0] = captures[2];
20618 : 0 : {
20619 : 0 : tree _o1[2], _r1;
20620 : 0 : _o1[0] = captures[0];
20621 : 0 : _o1[1] = captures[3];
20622 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CEIL_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20623 : 0 : tem_op.resimplify (NULL, valueize);
20624 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20625 : 0 : if (!_r1) goto next_after_fail2578;
20626 : 0 : res_op->ops[1] = _r1;
20627 : : }
20628 : 0 : {
20629 : 0 : tree _o1[2], _r1;
20630 : 0 : _o1[0] = captures[0];
20631 : 0 : _o1[1] = captures[4];
20632 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CEIL_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20633 : 0 : tem_op.resimplify (NULL, valueize);
20634 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20635 : 0 : if (!_r1) goto next_after_fail2578;
20636 : 0 : res_op->ops[2] = _r1;
20637 : : }
20638 : 0 : res_op->resimplify (lseq, valueize);
20639 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
20640 : 0 : return true;
20641 : : }
20642 : 0 : next_after_fail2578:;
20643 : : }
20644 : : }
20645 : 0 : break;
20646 : : }
20647 : : default:;
20648 : : }
20649 : : }
20650 : : break;
20651 : : default:;
20652 : : }
20653 : : return false;
20654 : : }
20655 : :
20656 : : bool
20657 : 354 : gimple_simplify_ROUND_MOD_EXPR (gimple_match_op *res_op, gimple_seq *seq,
20658 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
20659 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
20660 : : {
20661 : 354 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
20662 : 354 : if (integer_zerop (_p0))
20663 : : {
20664 : 0 : {
20665 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
20666 : 0 : if (gimple_simplify_353 (res_op, seq, valueize, type, captures, ROUND_MOD_EXPR))
20667 : 0 : return true;
20668 : : }
20669 : : }
20670 : 354 : if (integer_onep (_p1))
20671 : : {
20672 : 0 : {
20673 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
20674 : 0 : if (gimple_simplify_354 (res_op, seq, valueize, type, captures, ROUND_MOD_EXPR))
20675 : 0 : return true;
20676 : : }
20677 : : }
20678 : 354 : if (integer_minus_onep (_p1))
20679 : : {
20680 : 0 : {
20681 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
20682 : 0 : if (gimple_simplify_355 (res_op, seq, valueize, type, captures, ROUND_MOD_EXPR))
20683 : 0 : return true;
20684 : : }
20685 : : }
20686 : 354 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
20687 : : {
20688 : 0 : {
20689 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
20690 : 0 : if (gimple_simplify_356 (res_op, seq, valueize, type, captures, ROUND_MOD_EXPR))
20691 : 0 : return true;
20692 : : }
20693 : : }
20694 : 354 : switch (TREE_CODE (_p0))
20695 : : {
20696 : 354 : case SSA_NAME:
20697 : 354 : if (gimple *_d1 = get_def (valueize, _p0))
20698 : : {
20699 : 276 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
20700 : 480 : switch (gimple_assign_rhs_code (_a1))
20701 : : {
20702 : 0 : case ROUND_MOD_EXPR:
20703 : 0 : {
20704 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
20705 : 0 : _q20 = do_valueize (valueize, _q20);
20706 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
20707 : 0 : _q21 = do_valueize (valueize, _q21);
20708 : 0 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
20709 : : {
20710 : 0 : {
20711 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
20712 : 0 : if (gimple_simplify_357 (res_op, seq, valueize, type, captures, ROUND_MOD_EXPR))
20713 : 0 : return true;
20714 : : }
20715 : : }
20716 : : break;
20717 : : }
20718 : 0 : case MULT_EXPR:
20719 : 0 : {
20720 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
20721 : 0 : _q20 = do_valueize (valueize, _q20);
20722 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
20723 : 0 : _q21 = do_valueize (valueize, _q21);
20724 : 0 : if (tree_swap_operands_p (_q20, _q21))
20725 : 0 : std::swap (_q20, _q21);
20726 : 0 : switch (TREE_CODE (_q21))
20727 : : {
20728 : 0 : case INTEGER_CST:
20729 : 0 : {
20730 : 0 : switch (TREE_CODE (_p1))
20731 : : {
20732 : 0 : case INTEGER_CST:
20733 : 0 : {
20734 : 0 : {
20735 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
20736 : 0 : if (gimple_simplify_358 (res_op, seq, valueize, type, captures, ROUND_MOD_EXPR))
20737 : 0 : return true;
20738 : : }
20739 : 0 : break;
20740 : : }
20741 : : default:;
20742 : : }
20743 : : break;
20744 : : }
20745 : : default:;
20746 : : }
20747 : 354 : break;
20748 : : }
20749 : 0 : case VEC_COND_EXPR:
20750 : 0 : {
20751 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
20752 : 0 : _q20 = do_valueize (valueize, _q20);
20753 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
20754 : 0 : _q21 = do_valueize (valueize, _q21);
20755 : 0 : tree _q22 = gimple_assign_rhs3 (_a1);
20756 : 0 : _q22 = do_valueize (valueize, _q22);
20757 : 0 : switch (TREE_CODE (_p1))
20758 : : {
20759 : 0 : case SSA_NAME:
20760 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
20761 : : {
20762 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
20763 : 0 : switch (gimple_assign_rhs_code (_a2))
20764 : : {
20765 : 0 : case VEC_COND_EXPR:
20766 : 0 : {
20767 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
20768 : 0 : _q60 = do_valueize (valueize, _q60);
20769 : 0 : tree _q61 = gimple_assign_rhs2 (_a2);
20770 : 0 : _q61 = do_valueize (valueize, _q61);
20771 : 0 : tree _q62 = gimple_assign_rhs3 (_a2);
20772 : 0 : _q62 = do_valueize (valueize, _q62);
20773 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
20774 : : {
20775 : 0 : {
20776 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
20777 : 0 : if (VECTOR_TYPE_P (type)
20778 : 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
20779 : : || types_match (type, TREE_TYPE (captures[2]))
20780 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
20781 : : || (optimize_vectors_before_lowering_p ()
20782 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
20783 : : )
20784 : : {
20785 : 0 : gimple_seq *lseq = seq;
20786 : 0 : if (lseq
20787 : 0 : && (!single_use (captures[0])
20788 : 0 : || !single_use (captures[4])))
20789 : 0 : lseq = NULL;
20790 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2579;
20791 : 0 : {
20792 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
20793 : 0 : res_op->ops[0] = captures[1];
20794 : 0 : {
20795 : 0 : tree _o1[2], _r1;
20796 : 0 : _o1[0] = captures[2];
20797 : 0 : _o1[1] = captures[5];
20798 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ROUND_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20799 : 0 : tem_op.resimplify (NULL, valueize);
20800 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20801 : 0 : if (!_r1) goto next_after_fail2579;
20802 : 0 : res_op->ops[1] = _r1;
20803 : : }
20804 : 0 : {
20805 : 0 : tree _o1[2], _r1;
20806 : 0 : _o1[0] = captures[3];
20807 : 0 : _o1[1] = captures[6];
20808 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ROUND_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20809 : 0 : tem_op.resimplify (NULL, valueize);
20810 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20811 : 0 : if (!_r1) goto next_after_fail2579;
20812 : 0 : res_op->ops[2] = _r1;
20813 : : }
20814 : 0 : res_op->resimplify (lseq, valueize);
20815 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
20816 : 0 : return true;
20817 : : }
20818 : 0 : next_after_fail2579:;
20819 : : }
20820 : : }
20821 : : }
20822 : : break;
20823 : : }
20824 : : default:;
20825 : : }
20826 : : }
20827 : : break;
20828 : 0 : default:;
20829 : : }
20830 : 0 : {
20831 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
20832 : 0 : if (VECTOR_TYPE_P (type)
20833 : 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
20834 : : || types_match (type, TREE_TYPE (captures[2]))
20835 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
20836 : : || (optimize_vectors_before_lowering_p ()
20837 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
20838 : : )
20839 : : {
20840 : 0 : gimple_seq *lseq = seq;
20841 : 0 : if (lseq
20842 : 0 : && (!single_use (captures[0])))
20843 : 0 : lseq = NULL;
20844 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2580;
20845 : 0 : {
20846 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
20847 : 0 : res_op->ops[0] = captures[1];
20848 : 0 : {
20849 : 0 : tree _o1[2], _r1;
20850 : 0 : _o1[0] = captures[2];
20851 : 0 : _o1[1] = captures[4];
20852 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ROUND_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20853 : 0 : tem_op.resimplify (NULL, valueize);
20854 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20855 : 0 : if (!_r1) goto next_after_fail2580;
20856 : 0 : res_op->ops[1] = _r1;
20857 : : }
20858 : 0 : {
20859 : 0 : tree _o1[2], _r1;
20860 : 0 : _o1[0] = captures[3];
20861 : 0 : _o1[1] = captures[4];
20862 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ROUND_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20863 : 0 : tem_op.resimplify (NULL, valueize);
20864 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20865 : 0 : if (!_r1) goto next_after_fail2580;
20866 : 0 : res_op->ops[2] = _r1;
20867 : : }
20868 : 0 : res_op->resimplify (lseq, valueize);
20869 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
20870 : 0 : return true;
20871 : : }
20872 : 0 : next_after_fail2580:;
20873 : : }
20874 : : }
20875 : 0 : break;
20876 : : }
20877 : : default:;
20878 : : }
20879 : : }
20880 : : break;
20881 : 354 : default:;
20882 : : }
20883 : 354 : switch (TREE_CODE (_p1))
20884 : : {
20885 : 0 : case SSA_NAME:
20886 : 0 : if (gimple *_d1 = get_def (valueize, _p1))
20887 : : {
20888 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
20889 : 0 : switch (gimple_assign_rhs_code (_a1))
20890 : : {
20891 : 0 : case VEC_COND_EXPR:
20892 : 0 : {
20893 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
20894 : 0 : _q30 = do_valueize (valueize, _q30);
20895 : 0 : tree _q31 = gimple_assign_rhs2 (_a1);
20896 : 0 : _q31 = do_valueize (valueize, _q31);
20897 : 0 : tree _q32 = gimple_assign_rhs3 (_a1);
20898 : 0 : _q32 = do_valueize (valueize, _q32);
20899 : 0 : {
20900 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
20901 : 0 : if (VECTOR_TYPE_P (type)
20902 : 0 : && (TREE_CODE_CLASS (ROUND_MOD_EXPR) != tcc_comparison
20903 : : || types_match (type, TREE_TYPE (captures[3]))
20904 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
20905 : : || (optimize_vectors_before_lowering_p ()
20906 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
20907 : : )
20908 : : {
20909 : 0 : gimple_seq *lseq = seq;
20910 : 0 : if (lseq
20911 : 0 : && (!single_use (captures[1])))
20912 : 0 : lseq = NULL;
20913 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2581;
20914 : 0 : {
20915 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
20916 : 0 : res_op->ops[0] = captures[2];
20917 : 0 : {
20918 : 0 : tree _o1[2], _r1;
20919 : 0 : _o1[0] = captures[0];
20920 : 0 : _o1[1] = captures[3];
20921 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ROUND_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20922 : 0 : tem_op.resimplify (NULL, valueize);
20923 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20924 : 0 : if (!_r1) goto next_after_fail2581;
20925 : 0 : res_op->ops[1] = _r1;
20926 : : }
20927 : 0 : {
20928 : 0 : tree _o1[2], _r1;
20929 : 0 : _o1[0] = captures[0];
20930 : 0 : _o1[1] = captures[4];
20931 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ROUND_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
20932 : 0 : tem_op.resimplify (NULL, valueize);
20933 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
20934 : 0 : if (!_r1) goto next_after_fail2581;
20935 : 0 : res_op->ops[2] = _r1;
20936 : : }
20937 : 0 : res_op->resimplify (lseq, valueize);
20938 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
20939 : 0 : return true;
20940 : : }
20941 : 0 : next_after_fail2581:;
20942 : : }
20943 : : }
20944 : 0 : break;
20945 : : }
20946 : : default:;
20947 : : }
20948 : : }
20949 : : break;
20950 : : default:;
20951 : : }
20952 : : return false;
20953 : : }
20954 : :
20955 : : bool
20956 : 1765609 : gimple_simplify_TRUNC_MOD_EXPR (gimple_match_op *res_op, gimple_seq *seq,
20957 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
20958 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
20959 : : {
20960 : 1765609 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
20961 : 1765609 : if (integer_zerop (_p0))
20962 : : {
20963 : 25544 : {
20964 : 25544 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
20965 : 25544 : if (gimple_simplify_353 (res_op, seq, valueize, type, captures, TRUNC_MOD_EXPR))
20966 : 25159 : return true;
20967 : : }
20968 : : }
20969 : 1740450 : if (integer_onep (_p1))
20970 : : {
20971 : 2234 : {
20972 : 2234 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
20973 : 2234 : if (gimple_simplify_354 (res_op, seq, valueize, type, captures, TRUNC_MOD_EXPR))
20974 : 2234 : return true;
20975 : : }
20976 : : }
20977 : 1738216 : if (integer_minus_onep (_p1))
20978 : : {
20979 : 310 : {
20980 : 310 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
20981 : 310 : if (gimple_simplify_355 (res_op, seq, valueize, type, captures, TRUNC_MOD_EXPR))
20982 : 30 : return true;
20983 : : }
20984 : : }
20985 : 1738186 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
20986 : : {
20987 : 426 : {
20988 : 426 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
20989 : 426 : if (gimple_simplify_356 (res_op, seq, valueize, type, captures, TRUNC_MOD_EXPR))
20990 : 41 : return true;
20991 : : }
20992 : : }
20993 : 1738145 : switch (TREE_CODE (_p0))
20994 : : {
20995 : 1620582 : case SSA_NAME:
20996 : 1620582 : if (gimple *_d1 = get_def (valueize, _p0))
20997 : : {
20998 : 794372 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
20999 : 698873 : switch (gimple_assign_rhs_code (_a1))
21000 : : {
21001 : 5029 : case TRUNC_MOD_EXPR:
21002 : 5029 : {
21003 : 5029 : tree _q20 = gimple_assign_rhs1 (_a1);
21004 : 5029 : _q20 = do_valueize (valueize, _q20);
21005 : 5029 : tree _q21 = gimple_assign_rhs2 (_a1);
21006 : 5029 : _q21 = do_valueize (valueize, _q21);
21007 : 5029 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _q21, 0) && types_match (_p1, _q21)))
21008 : : {
21009 : 83 : {
21010 : 83 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
21011 : 83 : if (gimple_simplify_357 (res_op, seq, valueize, type, captures, TRUNC_MOD_EXPR))
21012 : 83 : return true;
21013 : : }
21014 : : }
21015 : : break;
21016 : : }
21017 : 30237 : case MULT_EXPR:
21018 : 30237 : {
21019 : 30237 : tree _q20 = gimple_assign_rhs1 (_a1);
21020 : 30237 : _q20 = do_valueize (valueize, _q20);
21021 : 30237 : tree _q21 = gimple_assign_rhs2 (_a1);
21022 : 30237 : _q21 = do_valueize (valueize, _q21);
21023 : 30237 : if (tree_swap_operands_p (_q20, _q21))
21024 : 566 : std::swap (_q20, _q21);
21025 : 30237 : switch (TREE_CODE (_q21))
21026 : : {
21027 : 15991 : case INTEGER_CST:
21028 : 15991 : {
21029 : 15991 : switch (TREE_CODE (_p1))
21030 : : {
21031 : 10585 : case INTEGER_CST:
21032 : 10585 : {
21033 : 10585 : {
21034 : 10585 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
21035 : 10585 : if (gimple_simplify_358 (res_op, seq, valueize, type, captures, TRUNC_MOD_EXPR))
21036 : 34 : return true;
21037 : : }
21038 : 10551 : break;
21039 : : }
21040 : : default:;
21041 : : }
21042 : : break;
21043 : : }
21044 : : default:;
21045 : : }
21046 : 1738028 : break;
21047 : : }
21048 : : default:;
21049 : : }
21050 : : }
21051 : : break;
21052 : 1738028 : default:;
21053 : : }
21054 : 1738028 : switch (TREE_CODE (_p1))
21055 : : {
21056 : 1040451 : case SSA_NAME:
21057 : 1040451 : if (gimple *_d1 = get_def (valueize, _p1))
21058 : : {
21059 : 816098 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
21060 : 1238505 : switch (gimple_assign_rhs_code (_a1))
21061 : : {
21062 : 147240 : CASE_CONVERT:
21063 : 147240 : {
21064 : 147240 : tree _q30 = gimple_assign_rhs1 (_a1);
21065 : 147240 : _q30 = do_valueize (valueize, _q30);
21066 : 147240 : switch (TREE_CODE (_q30))
21067 : : {
21068 : 147240 : case SSA_NAME:
21069 : 147240 : if (gimple *_d2 = get_def (valueize, _q30))
21070 : : {
21071 : 146305 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
21072 : 102617 : switch (gimple_assign_rhs_code (_a2))
21073 : : {
21074 : 2 : case NEGATE_EXPR:
21075 : 2 : {
21076 : 2 : tree _q40 = gimple_assign_rhs1 (_a2);
21077 : 2 : _q40 = do_valueize (valueize, _q40);
21078 : 2 : {
21079 : 2 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q40 };
21080 : 2 : if (gimple_simplify_494 (res_op, seq, valueize, type, captures))
21081 : 0 : return true;
21082 : : }
21083 : 2 : break;
21084 : : }
21085 : : default:;
21086 : : }
21087 : : }
21088 : : break;
21089 : 147240 : default:;
21090 : : }
21091 : 147240 : {
21092 : 147240 : tree _q30_pops[1];
21093 : 147240 : if (gimple_power_of_two_cand (_q30, _q30_pops, valueize))
21094 : : {
21095 : 108 : tree _q40 = _q30_pops[0];
21096 : 108 : {
21097 : 108 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q30, _q40 };
21098 : 108 : if (gimple_simplify_359 (res_op, seq, valueize, type, captures, TRUNC_MOD_EXPR))
21099 : 0 : return true;
21100 : : }
21101 : : }
21102 : : }
21103 : 147240 : break;
21104 : : }
21105 : 969 : case NEGATE_EXPR:
21106 : 969 : {
21107 : 969 : tree _q30 = gimple_assign_rhs1 (_a1);
21108 : 969 : _q30 = do_valueize (valueize, _q30);
21109 : 969 : {
21110 : 969 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _q30 };
21111 : 969 : if (gimple_simplify_494 (res_op, seq, valueize, type, captures))
21112 : 18 : return true;
21113 : : }
21114 : 951 : break;
21115 : : }
21116 : : default:;
21117 : : }
21118 : : }
21119 : : break;
21120 : 683907 : case INTEGER_CST:
21121 : 683907 : {
21122 : 683907 : {
21123 : 683907 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
21124 : 683907 : if (TYPE_SIGN (type) == SIGNED
21125 : 393505 : && !TREE_OVERFLOW (captures[1])
21126 : 684484 : && wi::neg_p (wi::to_wide (captures[1]))
21127 : 923 : && !TYPE_OVERFLOW_TRAPS (type)
21128 : 684830 : && !sign_bit_p (captures[1], captures[1])
21129 : : )
21130 : : {
21131 : 346 : gimple_seq *lseq = seq;
21132 : 346 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2582;
21133 : 346 : {
21134 : 346 : res_op->set_op (TRUNC_MOD_EXPR, type, 2);
21135 : 346 : res_op->ops[0] = captures[0];
21136 : 346 : {
21137 : 346 : tree _o1[1], _r1;
21138 : 346 : _o1[0] = captures[1];
21139 : 346 : gimple_match_op tem_op (res_op->cond.any_else (), NEGATE_EXPR, TREE_TYPE (_o1[0]), _o1[0]);
21140 : 346 : tem_op.resimplify (lseq, valueize);
21141 : 346 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
21142 : 346 : if (!_r1) goto next_after_fail2582;
21143 : 346 : res_op->ops[1] = _r1;
21144 : : }
21145 : 346 : res_op->resimplify (lseq, valueize);
21146 : 346 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1175, __FILE__, __LINE__, true);
21147 : 346 : return true;
21148 : : }
21149 : 683561 : next_after_fail2582:;
21150 : : }
21151 : : }
21152 : 683561 : break;
21153 : : }
21154 : 1737664 : default:;
21155 : : }
21156 : 1737664 : {
21157 : 1737664 : tree _p1_pops[1];
21158 : 1737664 : if (gimple_power_of_two_cand (_p1, _p1_pops, valueize))
21159 : : {
21160 : 683668 : tree _q30 = _p1_pops[0];
21161 : 683668 : {
21162 : 683668 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q30 };
21163 : 683668 : if (gimple_simplify_359 (res_op, seq, valueize, type, captures, TRUNC_MOD_EXPR))
21164 : 1409 : return true;
21165 : : }
21166 : : }
21167 : : }
21168 : 1736255 : switch (TREE_CODE (_p0))
21169 : : {
21170 : 1618692 : case SSA_NAME:
21171 : 1618692 : if (gimple *_d1 = get_def (valueize, _p0))
21172 : : {
21173 : 793214 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
21174 : 697499 : switch (gimple_assign_rhs_code (_a1))
21175 : : {
21176 : 4 : case VEC_COND_EXPR:
21177 : 4 : {
21178 : 4 : tree _q20 = gimple_assign_rhs1 (_a1);
21179 : 4 : _q20 = do_valueize (valueize, _q20);
21180 : 4 : tree _q21 = gimple_assign_rhs2 (_a1);
21181 : 4 : _q21 = do_valueize (valueize, _q21);
21182 : 4 : tree _q22 = gimple_assign_rhs3 (_a1);
21183 : 4 : _q22 = do_valueize (valueize, _q22);
21184 : 4 : switch (TREE_CODE (_p1))
21185 : : {
21186 : 0 : case SSA_NAME:
21187 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
21188 : : {
21189 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
21190 : 0 : switch (gimple_assign_rhs_code (_a2))
21191 : : {
21192 : 0 : case VEC_COND_EXPR:
21193 : 0 : {
21194 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
21195 : 0 : _q60 = do_valueize (valueize, _q60);
21196 : 0 : tree _q61 = gimple_assign_rhs2 (_a2);
21197 : 0 : _q61 = do_valueize (valueize, _q61);
21198 : 0 : tree _q62 = gimple_assign_rhs3 (_a2);
21199 : 0 : _q62 = do_valueize (valueize, _q62);
21200 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
21201 : : {
21202 : 0 : {
21203 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
21204 : 0 : if (VECTOR_TYPE_P (type)
21205 : 0 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
21206 : : || types_match (type, TREE_TYPE (captures[2]))
21207 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
21208 : : || (optimize_vectors_before_lowering_p ()
21209 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
21210 : : )
21211 : : {
21212 : 0 : gimple_seq *lseq = seq;
21213 : 0 : if (lseq
21214 : 0 : && (!single_use (captures[0])
21215 : 0 : || !single_use (captures[4])))
21216 : 0 : lseq = NULL;
21217 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2583;
21218 : 0 : {
21219 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
21220 : 0 : res_op->ops[0] = captures[1];
21221 : 0 : {
21222 : 0 : tree _o1[2], _r1;
21223 : 0 : _o1[0] = captures[2];
21224 : 0 : _o1[1] = captures[5];
21225 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
21226 : 0 : tem_op.resimplify (NULL, valueize);
21227 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
21228 : 0 : if (!_r1) goto next_after_fail2583;
21229 : 0 : res_op->ops[1] = _r1;
21230 : : }
21231 : 0 : {
21232 : 0 : tree _o1[2], _r1;
21233 : 0 : _o1[0] = captures[3];
21234 : 0 : _o1[1] = captures[6];
21235 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
21236 : 0 : tem_op.resimplify (NULL, valueize);
21237 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
21238 : 0 : if (!_r1) goto next_after_fail2583;
21239 : 0 : res_op->ops[2] = _r1;
21240 : : }
21241 : 0 : res_op->resimplify (lseq, valueize);
21242 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
21243 : 0 : return true;
21244 : : }
21245 : 0 : next_after_fail2583:;
21246 : : }
21247 : : }
21248 : : }
21249 : : break;
21250 : : }
21251 : : default:;
21252 : : }
21253 : : }
21254 : : break;
21255 : 4 : default:;
21256 : : }
21257 : 4 : {
21258 : 4 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
21259 : 4 : if (VECTOR_TYPE_P (type)
21260 : 4 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
21261 : : || types_match (type, TREE_TYPE (captures[2]))
21262 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
21263 : : || (optimize_vectors_before_lowering_p ()
21264 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
21265 : : )
21266 : : {
21267 : 4 : gimple_seq *lseq = seq;
21268 : 4 : if (lseq
21269 : 3 : && (!single_use (captures[0])))
21270 : 1 : lseq = NULL;
21271 : 4 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2584;
21272 : 4 : {
21273 : 4 : res_op->set_op (VEC_COND_EXPR, type, 3);
21274 : 4 : res_op->ops[0] = captures[1];
21275 : 4 : {
21276 : 4 : tree _o1[2], _r1;
21277 : 4 : _o1[0] = captures[2];
21278 : 4 : _o1[1] = captures[4];
21279 : 4 : gimple_match_op tem_op (res_op->cond.any_else (), TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
21280 : 4 : tem_op.resimplify (NULL, valueize);
21281 : 4 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
21282 : 4 : if (!_r1) goto next_after_fail2584;
21283 : 4 : res_op->ops[1] = _r1;
21284 : : }
21285 : 4 : {
21286 : 4 : tree _o1[2], _r1;
21287 : 4 : _o1[0] = captures[3];
21288 : 4 : _o1[1] = captures[4];
21289 : 4 : gimple_match_op tem_op (res_op->cond.any_else (), TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
21290 : 4 : tem_op.resimplify (NULL, valueize);
21291 : 4 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
21292 : 4 : if (!_r1) goto next_after_fail2584;
21293 : 4 : res_op->ops[2] = _r1;
21294 : : }
21295 : 4 : res_op->resimplify (lseq, valueize);
21296 : 4 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
21297 : 4 : return true;
21298 : : }
21299 : 0 : next_after_fail2584:;
21300 : : }
21301 : : }
21302 : 0 : break;
21303 : : }
21304 : : default:;
21305 : : }
21306 : : }
21307 : : break;
21308 : 1736251 : default:;
21309 : : }
21310 : 1736251 : switch (TREE_CODE (_p1))
21311 : : {
21312 : 1040413 : case SSA_NAME:
21313 : 1040413 : if (gimple *_d1 = get_def (valueize, _p1))
21314 : : {
21315 : 816060 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
21316 : 1238467 : switch (gimple_assign_rhs_code (_a1))
21317 : : {
21318 : 23 : case VEC_COND_EXPR:
21319 : 23 : {
21320 : 23 : tree _q30 = gimple_assign_rhs1 (_a1);
21321 : 23 : _q30 = do_valueize (valueize, _q30);
21322 : 23 : tree _q31 = gimple_assign_rhs2 (_a1);
21323 : 23 : _q31 = do_valueize (valueize, _q31);
21324 : 23 : tree _q32 = gimple_assign_rhs3 (_a1);
21325 : 23 : _q32 = do_valueize (valueize, _q32);
21326 : 23 : {
21327 : 23 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
21328 : 23 : if (VECTOR_TYPE_P (type)
21329 : 23 : && (TREE_CODE_CLASS (TRUNC_MOD_EXPR) != tcc_comparison
21330 : : || types_match (type, TREE_TYPE (captures[3]))
21331 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
21332 : : || (optimize_vectors_before_lowering_p ()
21333 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
21334 : : )
21335 : : {
21336 : 23 : gimple_seq *lseq = seq;
21337 : 23 : if (lseq
21338 : 11 : && (!single_use (captures[1])))
21339 : 12 : lseq = NULL;
21340 : 23 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2585;
21341 : 23 : {
21342 : 23 : res_op->set_op (VEC_COND_EXPR, type, 3);
21343 : 23 : res_op->ops[0] = captures[2];
21344 : 23 : {
21345 : 23 : tree _o1[2], _r1;
21346 : 23 : _o1[0] = captures[0];
21347 : 23 : _o1[1] = captures[3];
21348 : 23 : gimple_match_op tem_op (res_op->cond.any_else (), TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
21349 : 23 : tem_op.resimplify (NULL, valueize);
21350 : 23 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
21351 : 23 : if (!_r1) goto next_after_fail2585;
21352 : 23 : res_op->ops[1] = _r1;
21353 : : }
21354 : 23 : {
21355 : 23 : tree _o1[2], _r1;
21356 : 23 : _o1[0] = captures[0];
21357 : 23 : _o1[1] = captures[4];
21358 : 23 : gimple_match_op tem_op (res_op->cond.any_else (), TRUNC_MOD_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
21359 : 23 : tem_op.resimplify (NULL, valueize);
21360 : 23 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
21361 : 23 : if (!_r1) goto next_after_fail2585;
21362 : 0 : res_op->ops[2] = _r1;
21363 : : }
21364 : 0 : res_op->resimplify (lseq, valueize);
21365 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
21366 : 0 : return true;
21367 : : }
21368 : 23 : next_after_fail2585:;
21369 : : }
21370 : : }
21371 : 23 : break;
21372 : : }
21373 : : default:;
21374 : : }
21375 : : }
21376 : : break;
21377 : : default:;
21378 : : }
21379 : : return false;
21380 : : }
21381 : :
21382 : : bool
21383 : 3832248 : gimple_simplify_RSHIFT_EXPR (gimple_match_op *res_op, gimple_seq *seq,
21384 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
21385 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
21386 : : {
21387 : 3832248 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
21388 : 3832248 : switch (TREE_CODE (_p1))
21389 : : {
21390 : 336949 : case SSA_NAME:
21391 : 336949 : if (gimple *_d1 = get_def (valueize, _p1))
21392 : : {
21393 : 226849 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
21394 : 203484 : switch (gimple_assign_rhs_code (_a1))
21395 : : {
21396 : 251 : case TRUNC_MOD_EXPR:
21397 : 251 : {
21398 : 251 : tree _q30 = gimple_assign_rhs1 (_a1);
21399 : 251 : _q30 = do_valueize (valueize, _q30);
21400 : 251 : tree _q31 = gimple_assign_rhs2 (_a1);
21401 : 251 : _q31 = do_valueize (valueize, _q31);
21402 : 251 : {
21403 : 251 : tree _q31_pops[1];
21404 : 251 : if (gimple_power_of_two_cand (_q31, _q31_pops, valueize))
21405 : : {
21406 : 233 : tree _q50 = _q31_pops[0];
21407 : 233 : {
21408 : 233 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
21409 : 233 : if (gimple_simplify_495 (res_op, seq, valueize, type, captures, RSHIFT_EXPR, TRUNC_MOD_EXPR))
21410 : 108 : return true;
21411 : : }
21412 : : }
21413 : : }
21414 : 143 : break;
21415 : : }
21416 : 0 : case FLOOR_MOD_EXPR:
21417 : 0 : {
21418 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
21419 : 0 : _q30 = do_valueize (valueize, _q30);
21420 : 0 : tree _q31 = gimple_assign_rhs2 (_a1);
21421 : 0 : _q31 = do_valueize (valueize, _q31);
21422 : 0 : {
21423 : 0 : tree _q31_pops[1];
21424 : 0 : if (gimple_power_of_two_cand (_q31, _q31_pops, valueize))
21425 : : {
21426 : 0 : tree _q50 = _q31_pops[0];
21427 : 0 : {
21428 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q30, _q31, _q50 };
21429 : 0 : if (gimple_simplify_495 (res_op, seq, valueize, type, captures, RSHIFT_EXPR, FLOOR_MOD_EXPR))
21430 : 0 : return true;
21431 : : }
21432 : : }
21433 : : }
21434 : 0 : break;
21435 : : }
21436 : : default:;
21437 : : }
21438 : : }
21439 : : break;
21440 : 3832140 : default:;
21441 : : }
21442 : 3832140 : switch (TREE_CODE (_p0))
21443 : : {
21444 : 3703381 : case SSA_NAME:
21445 : 3703381 : if (gimple *_d1 = get_def (valueize, _p0))
21446 : : {
21447 : 2293915 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
21448 : 1967989 : switch (gimple_assign_rhs_code (_a1))
21449 : : {
21450 : 400860 : case PLUS_EXPR:
21451 : 400860 : {
21452 : 400860 : tree _q20 = gimple_assign_rhs1 (_a1);
21453 : 400860 : _q20 = do_valueize (valueize, _q20);
21454 : 400860 : tree _q21 = gimple_assign_rhs2 (_a1);
21455 : 400860 : _q21 = do_valueize (valueize, _q21);
21456 : 400860 : if (tree_swap_operands_p (_q20, _q21))
21457 : 12480 : std::swap (_q20, _q21);
21458 : 400860 : switch (TREE_CODE (_q21))
21459 : : {
21460 : 214370 : case INTEGER_CST:
21461 : 214370 : {
21462 : 214370 : switch (TREE_CODE (_p1))
21463 : : {
21464 : 212487 : case INTEGER_CST:
21465 : 212487 : {
21466 : 212487 : {
21467 : 212487 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _p1 };
21468 : 212487 : {
21469 : 212487 : wide_int c = wi::to_wide (captures[2]);
21470 : 212487 : wide_int n = wi::to_wide (captures[3]);
21471 : 212487 : bool shift = RSHIFT_EXPR == RSHIFT_EXPR;
21472 : 212487 : int_range_max vr0, vr1, vr3;
21473 : 212487 : if (INTEGRAL_TYPE_P (type)
21474 : 424974 : && get_range_query (cfun)->range_of_expr (vr0, captures[1])
21475 : : )
21476 : : {
21477 : 424974 : if ((shift ? wi::ctz (
21478 : 212487 : c
21479 : 212487 : ) >= n.to_shwi ()
21480 : : : wi::multiple_of_p (
21481 : : c
21482 : : , n, TYPE_SIGN (type)))
21483 : 33350 : && get_range_query (cfun)->range_of_expr (vr1, captures[2])
21484 : 16675 : && range_op_handler (PLUS_EXPR).overflow_free_p (vr0, vr1)
21485 : 16148 : && get_range_query (cfun)->range_of_expr (vr3, captures[0])
21486 : 8074 : && !vr3.undefined_p ()
21487 : 220561 : && (TYPE_UNSIGNED (type)
21488 : 7194 : || (vr0.nonnegative_p () && vr3.nonnegative_p ())
21489 : 6740 : || (vr0.nonpositive_p () && vr3.nonpositive_p ()))
21490 : : )
21491 : : {
21492 : 1336 : gimple_seq *lseq = seq;
21493 : 1336 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2594;
21494 : 1336 : {
21495 : 1336 : res_op->set_op (PLUS_EXPR, type, 2);
21496 : 1336 : {
21497 : 1336 : tree _o1[2], _r1;
21498 : 1336 : _o1[0] = captures[1];
21499 : 1336 : _o1[1] = captures[3];
21500 : 1336 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
21501 : 1336 : tem_op.resimplify (lseq, valueize);
21502 : 1336 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
21503 : 1336 : if (!_r1) goto next_after_fail2594;
21504 : 555 : res_op->ops[0] = _r1;
21505 : : }
21506 : 555 : res_op->ops[1] = wide_int_to_tree (type,
21507 : 555 : (shift ? wi::rshift (
21508 : : c
21509 : 555 : , n, TYPE_SIGN (type))
21510 : : : wi::div_trunc (
21511 : : c
21512 : : , n, TYPE_SIGN (type)))
21513 : : );
21514 : 555 : res_op->resimplify (lseq, valueize);
21515 : 555 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1160, __FILE__, __LINE__, true);
21516 : 555 : return true;
21517 : : }
21518 : 211511 : next_after_fail2594:;
21519 : : }
21520 : : else
21521 : : {
21522 : 211136 : if (!vr0.undefined_p () && TYPE_UNSIGNED (type) && c.sign_mask () < 0
21523 : 61345 : &&
21524 : 61345 : (shift ? wi::ctz (
21525 : 272496 : -c
21526 : 61345 : ) >= n.to_shwi ()
21527 : : : wi::multiple_of_p (
21528 : : -c
21529 : : , n, TYPE_SIGN (type)))
21530 : 430229 : && wi::geu_p (vr0.lower_bound (), -c)
21531 : : )
21532 : : {
21533 : 856 : gimple_seq *lseq = seq;
21534 : 856 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2595;
21535 : 856 : {
21536 : 856 : res_op->set_op (PLUS_EXPR, type, 2);
21537 : 856 : {
21538 : 856 : tree _o1[2], _r1;
21539 : 856 : _o1[0] = captures[1];
21540 : 856 : _o1[1] = captures[3];
21541 : 856 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
21542 : 856 : tem_op.resimplify (lseq, valueize);
21543 : 856 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
21544 : 856 : if (!_r1) goto next_after_fail2595;
21545 : 421 : res_op->ops[0] = _r1;
21546 : : }
21547 : 421 : res_op->ops[1] = wide_int_to_tree (type, -
21548 : 421 : (shift ? wi::rshift (
21549 : 421 : -c
21550 : 421 : , n, TYPE_SIGN (type))
21551 : : : wi::div_trunc (
21552 : : -c
21553 : 421 : , n, TYPE_SIGN (type)))
21554 : : );
21555 : 421 : res_op->resimplify (lseq, valueize);
21556 : 421 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1161, __FILE__, __LINE__, true);
21557 : 421 : return true;
21558 : : }
21559 : 211511 : next_after_fail2595:;
21560 : : }
21561 : : }
21562 : : }
21563 : 212487 : }
21564 : : }
21565 : 211511 : break;
21566 : : }
21567 : : default:;
21568 : : }
21569 : : break;
21570 : : }
21571 : : default:;
21572 : : }
21573 : 3831164 : break;
21574 : : }
21575 : : default:;
21576 : : }
21577 : : }
21578 : : break;
21579 : 3831164 : default:;
21580 : : }
21581 : 3831164 : if (uniform_integer_cst_p (_p1))
21582 : : {
21583 : 3485092 : {
21584 : 3485092 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
21585 : 3485092 : if (gimple_simplify_496 (res_op, seq, valueize, type, captures, RSHIFT_EXPR))
21586 : 91 : return true;
21587 : : }
21588 : : }
21589 : 3831073 : switch (TREE_CODE (_p0))
21590 : : {
21591 : 3702322 : case SSA_NAME:
21592 : 3702322 : if (gimple *_d1 = get_def (valueize, _p0))
21593 : : {
21594 : 2292887 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
21595 : 1966909 : switch (gimple_assign_rhs_code (_a1))
21596 : : {
21597 : 2644 : case NEGATE_EXPR:
21598 : 2644 : {
21599 : 2644 : tree _q20 = gimple_assign_rhs1 (_a1);
21600 : 2644 : _q20 = do_valueize (valueize, _q20);
21601 : 2644 : switch (TREE_CODE (_p1))
21602 : : {
21603 : 2543 : case INTEGER_CST:
21604 : 2543 : {
21605 : 2543 : {
21606 : 2543 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
21607 : 2543 : if (!TYPE_UNSIGNED (type)
21608 : 2543 : && TYPE_OVERFLOW_UNDEFINED (type)
21609 : : )
21610 : : {
21611 : 750 : {
21612 : 750 : tree stype = TREE_TYPE (captures[2]);
21613 : 750 : tree bt = truth_type_for (type);
21614 : 750 : tree zeros = build_zero_cst (type);
21615 : 750 : tree INTEGER_CST = NULL_TREE;
21616 : 750 : if (INTEGRAL_TYPE_P (type)
21617 : : && canonicalize_math_after_vectorization_p ()
21618 : 968 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
21619 : : )
21620 : : {
21621 : 84 : gimple_seq *lseq = seq;
21622 : 84 : if (lseq
21623 : 42 : && (!single_use (captures[0])))
21624 : 42 : lseq = NULL;
21625 : 84 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2596;
21626 : 84 : {
21627 : 84 : res_op->set_op (NEGATE_EXPR, type, 1);
21628 : 84 : {
21629 : 84 : tree _r1;
21630 : 84 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
21631 : 84 : {
21632 : 84 : tree _o2[2], _r2;
21633 : 84 : _o2[0] = captures[1];
21634 : 84 : _o2[1] = zeros;
21635 : 84 : tem_op.set_op (GT_EXPR, boolean_type_node, 2);
21636 : 84 : tem_op.ops[0] = _o2[0];
21637 : 84 : tem_op.ops[1] = _o2[1];
21638 : 84 : tem_op.resimplify (lseq, valueize);
21639 : : }
21640 : 84 : if (type != tem_op.type
21641 : 84 : && !useless_type_conversion_p (type, tem_op.type))
21642 : : {
21643 : 84 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
21644 : 84 : if (!_r1) goto next_after_fail2596;
21645 : 42 : tem_op.set_op (NOP_EXPR, type, 1);
21646 : 42 : tem_op.ops[0] = _r1;
21647 : 42 : tem_op.resimplify (lseq, valueize);
21648 : : }
21649 : 42 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
21650 : 42 : if (!_r1) goto next_after_fail2596;
21651 : 42 : res_op->ops[0] = _r1;
21652 : : }
21653 : 42 : res_op->resimplify (lseq, valueize);
21654 : 42 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1180, __FILE__, __LINE__, true);
21655 : 42 : return true;
21656 : : }
21657 : 2499 : next_after_fail2596:;
21658 : : }
21659 : : else
21660 : : {
21661 : 116 : if (VECTOR_INTEGER_TYPE_P (type)
21662 : 116 : && TYPE_MODE (bt) == TYPE_MODE (type)
21663 : 116 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
21664 : 116 : && (INTEGER_CST = uniform_integer_cst_p (captures[2])) != NULL
21665 : 782 : && wi::eq_p (wi::to_wide (INTEGER_CST), element_precision (type) - 1)
21666 : : )
21667 : : {
21668 : 7 : gimple_seq *lseq = seq;
21669 : 7 : if (lseq
21670 : 2 : && (!single_use (captures[0])))
21671 : 5 : lseq = NULL;
21672 : 7 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2597;
21673 : 7 : {
21674 : 7 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
21675 : 7 : {
21676 : 7 : tree _o1[2], _r1;
21677 : 7 : _o1[0] = captures[1];
21678 : 7 : _o1[1] = zeros;
21679 : 7 : (*res_op).set_op (GT_EXPR, bt, 2);
21680 : 7 : (*res_op).ops[0] = _o1[0];
21681 : 7 : (*res_op).ops[1] = _o1[1];
21682 : 7 : (*res_op).resimplify (lseq, valueize);
21683 : : }
21684 : 7 : if (type != res_op->type
21685 : 7 : && !useless_type_conversion_p (type, res_op->type))
21686 : : {
21687 : 7 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail2597;
21688 : 2 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
21689 : 2 : res_op->resimplify (lseq, valueize);
21690 : : }
21691 : 2 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1181, __FILE__, __LINE__, true);
21692 : 2 : return true;
21693 : : }
21694 : 2499 : next_after_fail2597:;
21695 : : }
21696 : : }
21697 : : }
21698 : : }
21699 : : }
21700 : 2499 : break;
21701 : : }
21702 : 0 : case VECTOR_CST:
21703 : 0 : {
21704 : 0 : {
21705 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
21706 : 0 : if (!TYPE_UNSIGNED (type)
21707 : 0 : && TYPE_OVERFLOW_UNDEFINED (type)
21708 : : )
21709 : : {
21710 : 0 : {
21711 : 0 : tree stype = TREE_TYPE (captures[2]);
21712 : 0 : tree bt = truth_type_for (type);
21713 : 0 : tree zeros = build_zero_cst (type);
21714 : 0 : tree VECTOR_CST = NULL_TREE;
21715 : 0 : if (INTEGRAL_TYPE_P (type)
21716 : : && canonicalize_math_after_vectorization_p ()
21717 : 0 : && wi::eq_p (wi::to_wide (captures[2]), TYPE_PRECISION (type) - 1)
21718 : : )
21719 : : {
21720 : 0 : gimple_seq *lseq = seq;
21721 : 0 : if (lseq
21722 : 0 : && (!single_use (captures[0])))
21723 : 0 : lseq = NULL;
21724 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2598;
21725 : 0 : {
21726 : 0 : res_op->set_op (NEGATE_EXPR, type, 1);
21727 : 0 : {
21728 : 0 : tree _r1;
21729 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), ERROR_MARK, error_mark_node, 1);
21730 : 0 : {
21731 : 0 : tree _o2[2], _r2;
21732 : 0 : _o2[0] = captures[1];
21733 : 0 : _o2[1] = zeros;
21734 : 0 : tem_op.set_op (GT_EXPR, boolean_type_node, 2);
21735 : 0 : tem_op.ops[0] = _o2[0];
21736 : 0 : tem_op.ops[1] = _o2[1];
21737 : 0 : tem_op.resimplify (lseq, valueize);
21738 : : }
21739 : 0 : if (type != tem_op.type
21740 : 0 : && !useless_type_conversion_p (type, tem_op.type))
21741 : : {
21742 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
21743 : 0 : if (!_r1) goto next_after_fail2598;
21744 : 0 : tem_op.set_op (NOP_EXPR, type, 1);
21745 : 0 : tem_op.ops[0] = _r1;
21746 : 0 : tem_op.resimplify (lseq, valueize);
21747 : : }
21748 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
21749 : 0 : if (!_r1) goto next_after_fail2598;
21750 : 0 : res_op->ops[0] = _r1;
21751 : : }
21752 : 0 : res_op->resimplify (lseq, valueize);
21753 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1180, __FILE__, __LINE__, true);
21754 : 0 : return true;
21755 : : }
21756 : 0 : next_after_fail2598:;
21757 : : }
21758 : : else
21759 : : {
21760 : 0 : if (VECTOR_INTEGER_TYPE_P (type)
21761 : 0 : && TYPE_MODE (bt) == TYPE_MODE (type)
21762 : 0 : && expand_vec_cmp_expr_p (type, bt, GT_EXPR)
21763 : 0 : && (VECTOR_CST = uniform_integer_cst_p (captures[2])) != NULL
21764 : 0 : && wi::eq_p (wi::to_wide (VECTOR_CST), element_precision (type) - 1)
21765 : : )
21766 : : {
21767 : 0 : gimple_seq *lseq = seq;
21768 : 0 : if (lseq
21769 : 0 : && (!single_use (captures[0])))
21770 : 0 : lseq = NULL;
21771 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2599;
21772 : 0 : {
21773 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
21774 : 0 : {
21775 : 0 : tree _o1[2], _r1;
21776 : 0 : _o1[0] = captures[1];
21777 : 0 : _o1[1] = zeros;
21778 : 0 : (*res_op).set_op (GT_EXPR, bt, 2);
21779 : 0 : (*res_op).ops[0] = _o1[0];
21780 : 0 : (*res_op).ops[1] = _o1[1];
21781 : 0 : (*res_op).resimplify (lseq, valueize);
21782 : : }
21783 : 0 : if (type != res_op->type
21784 : 0 : && !useless_type_conversion_p (type, res_op->type))
21785 : : {
21786 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail2599;
21787 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
21788 : 0 : res_op->resimplify (lseq, valueize);
21789 : : }
21790 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1181, __FILE__, __LINE__, true);
21791 : 0 : return true;
21792 : : }
21793 : 0 : next_after_fail2599:;
21794 : : }
21795 : : }
21796 : : }
21797 : : }
21798 : : }
21799 : 0 : break;
21800 : : }
21801 : : default:;
21802 : : }
21803 : : break;
21804 : : }
21805 : 399884 : case PLUS_EXPR:
21806 : 399884 : {
21807 : 399884 : tree _q20 = gimple_assign_rhs1 (_a1);
21808 : 399884 : _q20 = do_valueize (valueize, _q20);
21809 : 399884 : tree _q21 = gimple_assign_rhs2 (_a1);
21810 : 399884 : _q21 = do_valueize (valueize, _q21);
21811 : 399884 : if (tree_swap_operands_p (_q20, _q21))
21812 : 12458 : std::swap (_q20, _q21);
21813 : 399884 : if (integer_onep (_p1))
21814 : : {
21815 : 54331 : {
21816 : 54331 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q21 };
21817 : 54331 : if (gimple_simplify_507 (res_op, seq, valueize, type, captures))
21818 : 0 : return true;
21819 : : }
21820 : 54331 : {
21821 : 54331 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q21, _q20 };
21822 : 54331 : if (gimple_simplify_507 (res_op, seq, valueize, type, captures))
21823 : 0 : return true;
21824 : : }
21825 : : }
21826 : 3830348 : break;
21827 : : }
21828 : 20358 : case LSHIFT_EXPR:
21829 : 20358 : {
21830 : 20358 : tree _q20 = gimple_assign_rhs1 (_a1);
21831 : 20358 : _q20 = do_valueize (valueize, _q20);
21832 : 20358 : tree _q21 = gimple_assign_rhs2 (_a1);
21833 : 20358 : _q21 = do_valueize (valueize, _q21);
21834 : 20358 : switch (TREE_CODE (_q21))
21835 : : {
21836 : 12335 : case INTEGER_CST:
21837 : 12335 : {
21838 : 12335 : if ((_p1 == _q21 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q21, 0))
21839 : : {
21840 : 3709 : {
21841 : 3709 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _q21 };
21842 : 3709 : if (gimple_simplify_508 (res_op, seq, valueize, type, captures))
21843 : 681 : return true;
21844 : : }
21845 : : }
21846 : : break;
21847 : : }
21848 : : default:;
21849 : : }
21850 : : break;
21851 : : }
21852 : : default:;
21853 : : }
21854 : : }
21855 : : break;
21856 : 3830348 : default:;
21857 : : }
21858 : 3830348 : {
21859 : 3830348 : tree _p0_pops[1];
21860 : 3830348 : if (gimple_nop_convert (_p0, _p0_pops, valueize))
21861 : : {
21862 : 137113 : tree _q20 = _p0_pops[0];
21863 : 137113 : switch (TREE_CODE (_q20))
21864 : : {
21865 : 137005 : case SSA_NAME:
21866 : 137005 : if (gimple *_d1 = get_def (valueize, _q20))
21867 : : {
21868 : 132035 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
21869 : 88158 : switch (gimple_assign_rhs_code (_a1))
21870 : : {
21871 : 459 : case LSHIFT_EXPR:
21872 : 459 : {
21873 : 459 : tree _q30 = gimple_assign_rhs1 (_a1);
21874 : 459 : _q30 = do_valueize (valueize, _q30);
21875 : 459 : tree _q31 = gimple_assign_rhs2 (_a1);
21876 : 459 : _q31 = do_valueize (valueize, _q31);
21877 : 459 : switch (TREE_CODE (_q31))
21878 : : {
21879 : 18 : case INTEGER_CST:
21880 : 18 : {
21881 : 18 : if ((_p1 == _q31 && ! TREE_SIDE_EFFECTS (_p1)) || operand_equal_p (_p1, _q31, 0))
21882 : : {
21883 : 13 : {
21884 : 13 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p1, _q31 };
21885 : 13 : if (gimple_simplify_508 (res_op, seq, valueize, type, captures))
21886 : 4 : return true;
21887 : : }
21888 : : }
21889 : : break;
21890 : : }
21891 : : default:;
21892 : : }
21893 : : break;
21894 : : }
21895 : : default:;
21896 : : }
21897 : : }
21898 : : break;
21899 : : default:;
21900 : : }
21901 : : }
21902 : : }
21903 : 3830344 : if (integer_all_onesp (_p0))
21904 : : {
21905 : 8009 : {
21906 : 8009 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
21907 : 8009 : if (!TYPE_UNSIGNED (type)
21908 : : )
21909 : : {
21910 : 39 : gimple_seq *lseq = seq;
21911 : 39 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2600;
21912 : 39 : {
21913 : 39 : tree tem;
21914 : 39 : tem = captures[0];
21915 : 39 : res_op->set_value (tem);
21916 : 39 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1182, __FILE__, __LINE__, true);
21917 : 39 : return true;
21918 : : }
21919 : 0 : next_after_fail2600:;
21920 : : }
21921 : : }
21922 : : }
21923 : 3830305 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
21924 : : {
21925 : 15 : {
21926 : 15 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
21927 : 15 : gimple_seq *lseq = seq;
21928 : 15 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2601;
21929 : 15 : {
21930 : 15 : tree tem;
21931 : 15 : tem = build_zero_cst (type);
21932 : 15 : res_op->set_value (tem);
21933 : 15 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1183, __FILE__, __LINE__, true);
21934 : 15 : return true;
21935 : : }
21936 : 0 : next_after_fail2601:;
21937 : : }
21938 : : }
21939 : 3830290 : if (integer_zerop (_p1))
21940 : : {
21941 : 15033 : {
21942 : 15033 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
21943 : 15033 : if (gimple_simplify_499 (res_op, seq, valueize, type, captures, RSHIFT_EXPR))
21944 : 15033 : return true;
21945 : : }
21946 : : }
21947 : 3815257 : if (integer_zerop (_p0))
21948 : : {
21949 : 1992 : {
21950 : 1992 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
21951 : 1992 : if (gimple_simplify_500 (res_op, seq, valueize, type, captures, RSHIFT_EXPR))
21952 : 1992 : return true;
21953 : : }
21954 : : }
21955 : 3813265 : switch (TREE_CODE (_p1))
21956 : : {
21957 : 334807 : case SSA_NAME:
21958 : 334807 : if (gimple *_d1 = get_def (valueize, _p1))
21959 : : {
21960 : 225902 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
21961 : 202704 : switch (gimple_assign_rhs_code (_a1))
21962 : : {
21963 : 97 : case CONSTRUCTOR:
21964 : 97 : {
21965 : 97 : {
21966 : 97 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
21967 : 97 : if (gimple_simplify_502 (res_op, seq, valueize, type, captures, RSHIFT_EXPR))
21968 : 0 : return true;
21969 : : }
21970 : 97 : break;
21971 : : }
21972 : : default:;
21973 : : }
21974 : : }
21975 : 334807 : {
21976 : 334807 : {
21977 : 334807 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
21978 : 334807 : if (gimple_simplify_503 (res_op, seq, valueize, type, captures, RSHIFT_EXPR))
21979 : 6 : return true;
21980 : : }
21981 : : }
21982 : 334801 : break;
21983 : 3054 : case VECTOR_CST:
21984 : 3054 : {
21985 : 3054 : {
21986 : 3054 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
21987 : 3054 : if (gimple_simplify_501 (res_op, seq, valueize, type, captures, RSHIFT_EXPR))
21988 : 320 : return true;
21989 : : }
21990 : 2734 : break;
21991 : : }
21992 : 3812939 : default:;
21993 : : }
21994 : 3812939 : switch (TREE_CODE (_p0))
21995 : : {
21996 : 3686226 : case SSA_NAME:
21997 : 3686226 : if (gimple *_d1 = get_def (valueize, _p0))
21998 : : {
21999 : 2280368 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
22000 : 1955214 : switch (gimple_assign_rhs_code (_a1))
22001 : : {
22002 : 23921 : case RSHIFT_EXPR:
22003 : 23921 : {
22004 : 23921 : tree _q20 = gimple_assign_rhs1 (_a1);
22005 : 23921 : _q20 = do_valueize (valueize, _q20);
22006 : 23921 : tree _q21 = gimple_assign_rhs2 (_a1);
22007 : 23921 : _q21 = do_valueize (valueize, _q21);
22008 : 23921 : switch (TREE_CODE (_q21))
22009 : : {
22010 : 20520 : case INTEGER_CST:
22011 : 20520 : {
22012 : 20520 : switch (TREE_CODE (_p1))
22013 : : {
22014 : 19869 : case INTEGER_CST:
22015 : 19869 : {
22016 : 19869 : {
22017 : 19869 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
22018 : 19869 : if (gimple_simplify_504 (res_op, seq, valueize, type, captures, RSHIFT_EXPR))
22019 : 19869 : return true;
22020 : : }
22021 : 0 : break;
22022 : : }
22023 : : default:;
22024 : : }
22025 : : break;
22026 : : }
22027 : : default:;
22028 : : }
22029 : : break;
22030 : : }
22031 : 268309 : CASE_CONVERT:
22032 : 268309 : {
22033 : 268309 : tree _q20 = gimple_assign_rhs1 (_a1);
22034 : 268309 : _q20 = do_valueize (valueize, _q20);
22035 : 268309 : switch (TREE_CODE (_q20))
22036 : : {
22037 : 268201 : case SSA_NAME:
22038 : 268201 : if (gimple *_d2 = get_def (valueize, _q20))
22039 : : {
22040 : 257711 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
22041 : 231566 : switch (gimple_assign_rhs_code (_a2))
22042 : : {
22043 : 6003 : case BIT_AND_EXPR:
22044 : 6003 : {
22045 : 6003 : tree _q30 = gimple_assign_rhs1 (_a2);
22046 : 6003 : _q30 = do_valueize (valueize, _q30);
22047 : 6003 : tree _q31 = gimple_assign_rhs2 (_a2);
22048 : 6003 : _q31 = do_valueize (valueize, _q31);
22049 : 6003 : if (tree_swap_operands_p (_q30, _q31))
22050 : 109 : std::swap (_q30, _q31);
22051 : 6003 : switch (TREE_CODE (_q31))
22052 : : {
22053 : 4975 : case INTEGER_CST:
22054 : 4975 : {
22055 : 4975 : switch (TREE_CODE (_p1))
22056 : : {
22057 : 1134 : case INTEGER_CST:
22058 : 1134 : {
22059 : 1134 : {
22060 : 1134 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
22061 : 1134 : if (gimple_simplify_505 (res_op, seq, valueize, type, captures, BIT_AND_EXPR, RSHIFT_EXPR))
22062 : 0 : return true;
22063 : : }
22064 : 1134 : break;
22065 : : }
22066 : : default:;
22067 : : }
22068 : : break;
22069 : : }
22070 : : default:;
22071 : : }
22072 : 3791934 : break;
22073 : : }
22074 : 428 : case BIT_XOR_EXPR:
22075 : 428 : {
22076 : 428 : tree _q30 = gimple_assign_rhs1 (_a2);
22077 : 428 : _q30 = do_valueize (valueize, _q30);
22078 : 428 : tree _q31 = gimple_assign_rhs2 (_a2);
22079 : 428 : _q31 = do_valueize (valueize, _q31);
22080 : 428 : if (tree_swap_operands_p (_q30, _q31))
22081 : 16 : std::swap (_q30, _q31);
22082 : 428 : switch (TREE_CODE (_q31))
22083 : : {
22084 : 53 : case INTEGER_CST:
22085 : 53 : {
22086 : 53 : switch (TREE_CODE (_p1))
22087 : : {
22088 : 53 : case INTEGER_CST:
22089 : 53 : {
22090 : 53 : {
22091 : 53 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
22092 : 53 : if (gimple_simplify_505 (res_op, seq, valueize, type, captures, BIT_XOR_EXPR, RSHIFT_EXPR))
22093 : 1 : return true;
22094 : : }
22095 : 52 : break;
22096 : : }
22097 : : default:;
22098 : : }
22099 : : break;
22100 : : }
22101 : : default:;
22102 : : }
22103 : 3791934 : break;
22104 : : }
22105 : 1140 : case BIT_IOR_EXPR:
22106 : 1140 : {
22107 : 1140 : tree _q30 = gimple_assign_rhs1 (_a2);
22108 : 1140 : _q30 = do_valueize (valueize, _q30);
22109 : 1140 : tree _q31 = gimple_assign_rhs2 (_a2);
22110 : 1140 : _q31 = do_valueize (valueize, _q31);
22111 : 1140 : if (tree_swap_operands_p (_q30, _q31))
22112 : 108 : std::swap (_q30, _q31);
22113 : 1140 : switch (TREE_CODE (_q31))
22114 : : {
22115 : 93 : case INTEGER_CST:
22116 : 93 : {
22117 : 93 : switch (TREE_CODE (_p1))
22118 : : {
22119 : 45 : case INTEGER_CST:
22120 : 45 : {
22121 : 45 : {
22122 : 45 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q30, _q31, _p1 };
22123 : 45 : if (gimple_simplify_505 (res_op, seq, valueize, type, captures, BIT_IOR_EXPR, RSHIFT_EXPR))
22124 : 3 : return true;
22125 : : }
22126 : 42 : break;
22127 : : }
22128 : : default:;
22129 : : }
22130 : : break;
22131 : : }
22132 : : default:;
22133 : : }
22134 : 3791934 : break;
22135 : : }
22136 : : default:;
22137 : : }
22138 : 115370 : else if (gcall *_c2 = dyn_cast <gcall *> (_d2))
22139 : 5509 : switch (gimple_call_combined_fn (_c2))
22140 : : {
22141 : 0 : case CFN_BUILT_IN_BSWAP128:
22142 : 0 : if (gimple_call_num_args (_c2) == 1)
22143 : : {
22144 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
22145 : 0 : _q30 = do_valueize (valueize, _q30);
22146 : 0 : switch (TREE_CODE (_p1))
22147 : : {
22148 : 0 : case INTEGER_CST:
22149 : 0 : {
22150 : 0 : {
22151 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
22152 : 0 : if (gimple_simplify_509 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP128))
22153 : 0 : return true;
22154 : : }
22155 : 0 : break;
22156 : : }
22157 : : default:;
22158 : : }
22159 : : }
22160 : : break;
22161 : 17 : case CFN_BUILT_IN_BSWAP16:
22162 : 17 : if (gimple_call_num_args (_c2) == 1)
22163 : : {
22164 : 17 : tree _q30 = gimple_call_arg (_c2, 0);
22165 : 17 : _q30 = do_valueize (valueize, _q30);
22166 : 17 : switch (TREE_CODE (_p1))
22167 : : {
22168 : 2 : case INTEGER_CST:
22169 : 2 : {
22170 : 2 : {
22171 : 2 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
22172 : 2 : if (gimple_simplify_509 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP16))
22173 : 1 : return true;
22174 : : }
22175 : 1 : break;
22176 : : }
22177 : : default:;
22178 : : }
22179 : : }
22180 : : break;
22181 : 0 : case CFN_BUILT_IN_BSWAP32:
22182 : 0 : if (gimple_call_num_args (_c2) == 1)
22183 : : {
22184 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
22185 : 0 : _q30 = do_valueize (valueize, _q30);
22186 : 0 : switch (TREE_CODE (_p1))
22187 : : {
22188 : 0 : case INTEGER_CST:
22189 : 0 : {
22190 : 0 : {
22191 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
22192 : 0 : if (gimple_simplify_509 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP32))
22193 : 0 : return true;
22194 : : }
22195 : 0 : break;
22196 : : }
22197 : : default:;
22198 : : }
22199 : : }
22200 : : break;
22201 : 0 : case CFN_BUILT_IN_BSWAP64:
22202 : 0 : if (gimple_call_num_args (_c2) == 1)
22203 : : {
22204 : 0 : tree _q30 = gimple_call_arg (_c2, 0);
22205 : 0 : _q30 = do_valueize (valueize, _q30);
22206 : 0 : switch (TREE_CODE (_p1))
22207 : : {
22208 : 0 : case INTEGER_CST:
22209 : 0 : {
22210 : 0 : {
22211 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q30, _p1 };
22212 : 0 : if (gimple_simplify_509 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP64))
22213 : 0 : return true;
22214 : : }
22215 : 0 : break;
22216 : : }
22217 : : default:;
22218 : : }
22219 : : }
22220 : : break;
22221 : : default:;
22222 : : }
22223 : : }
22224 : : break;
22225 : : default:;
22226 : : }
22227 : : break;
22228 : : }
22229 : 36977 : case BIT_AND_EXPR:
22230 : 36977 : {
22231 : 36977 : tree _q20 = gimple_assign_rhs1 (_a1);
22232 : 36977 : _q20 = do_valueize (valueize, _q20);
22233 : 36977 : tree _q21 = gimple_assign_rhs2 (_a1);
22234 : 36977 : _q21 = do_valueize (valueize, _q21);
22235 : 36977 : if (tree_swap_operands_p (_q20, _q21))
22236 : 1062 : std::swap (_q20, _q21);
22237 : 36977 : switch (TREE_CODE (_q21))
22238 : : {
22239 : 22356 : case INTEGER_CST:
22240 : 22356 : {
22241 : 22356 : switch (TREE_CODE (_p1))
22242 : : {
22243 : 21254 : case INTEGER_CST:
22244 : 21254 : {
22245 : 21254 : {
22246 : 21254 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
22247 : 21254 : if (gimple_simplify_506 (res_op, seq, valueize, type, captures, BIT_AND_EXPR, RSHIFT_EXPR))
22248 : 684 : return true;
22249 : : }
22250 : 20570 : break;
22251 : : }
22252 : : default:;
22253 : : }
22254 : : break;
22255 : : }
22256 : : default:;
22257 : : }
22258 : 3791934 : break;
22259 : : }
22260 : 21479 : case BIT_XOR_EXPR:
22261 : 21479 : {
22262 : 21479 : tree _q20 = gimple_assign_rhs1 (_a1);
22263 : 21479 : _q20 = do_valueize (valueize, _q20);
22264 : 21479 : tree _q21 = gimple_assign_rhs2 (_a1);
22265 : 21479 : _q21 = do_valueize (valueize, _q21);
22266 : 21479 : if (tree_swap_operands_p (_q20, _q21))
22267 : 1610 : std::swap (_q20, _q21);
22268 : 21479 : switch (TREE_CODE (_q21))
22269 : : {
22270 : 1668 : case INTEGER_CST:
22271 : 1668 : {
22272 : 1668 : switch (TREE_CODE (_p1))
22273 : : {
22274 : 1580 : case INTEGER_CST:
22275 : 1580 : {
22276 : 1580 : {
22277 : 1580 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
22278 : 1580 : if (gimple_simplify_506 (res_op, seq, valueize, type, captures, BIT_XOR_EXPR, RSHIFT_EXPR))
22279 : 87 : return true;
22280 : : }
22281 : 1493 : break;
22282 : : }
22283 : : default:;
22284 : : }
22285 : : break;
22286 : : }
22287 : : default:;
22288 : : }
22289 : 3791934 : break;
22290 : : }
22291 : 134718 : case BIT_IOR_EXPR:
22292 : 134718 : {
22293 : 134718 : tree _q20 = gimple_assign_rhs1 (_a1);
22294 : 134718 : _q20 = do_valueize (valueize, _q20);
22295 : 134718 : tree _q21 = gimple_assign_rhs2 (_a1);
22296 : 134718 : _q21 = do_valueize (valueize, _q21);
22297 : 134718 : if (tree_swap_operands_p (_q20, _q21))
22298 : 9188 : std::swap (_q20, _q21);
22299 : 134718 : switch (TREE_CODE (_q21))
22300 : : {
22301 : 2246 : case INTEGER_CST:
22302 : 2246 : {
22303 : 2246 : switch (TREE_CODE (_p1))
22304 : : {
22305 : 990 : case INTEGER_CST:
22306 : 990 : {
22307 : 990 : {
22308 : 990 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p0, _q20, _q21, _p1 };
22309 : 990 : if (gimple_simplify_506 (res_op, seq, valueize, type, captures, BIT_IOR_EXPR, RSHIFT_EXPR))
22310 : 67 : return true;
22311 : : }
22312 : 923 : break;
22313 : : }
22314 : : default:;
22315 : : }
22316 : : break;
22317 : : }
22318 : : default:;
22319 : : }
22320 : 3791934 : break;
22321 : : }
22322 : 341 : case VEC_COND_EXPR:
22323 : 341 : {
22324 : 341 : tree _q20 = gimple_assign_rhs1 (_a1);
22325 : 341 : _q20 = do_valueize (valueize, _q20);
22326 : 341 : tree _q21 = gimple_assign_rhs2 (_a1);
22327 : 341 : _q21 = do_valueize (valueize, _q21);
22328 : 341 : tree _q22 = gimple_assign_rhs3 (_a1);
22329 : 341 : _q22 = do_valueize (valueize, _q22);
22330 : 341 : switch (TREE_CODE (_p1))
22331 : : {
22332 : 24 : case SSA_NAME:
22333 : 24 : if (gimple *_d2 = get_def (valueize, _p1))
22334 : : {
22335 : 24 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
22336 : 24 : switch (gimple_assign_rhs_code (_a2))
22337 : : {
22338 : 0 : case VEC_COND_EXPR:
22339 : 0 : {
22340 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
22341 : 0 : _q60 = do_valueize (valueize, _q60);
22342 : 0 : tree _q61 = gimple_assign_rhs2 (_a2);
22343 : 0 : _q61 = do_valueize (valueize, _q61);
22344 : 0 : tree _q62 = gimple_assign_rhs3 (_a2);
22345 : 0 : _q62 = do_valueize (valueize, _q62);
22346 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
22347 : : {
22348 : 0 : {
22349 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
22350 : 0 : if (VECTOR_TYPE_P (type)
22351 : 0 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
22352 : : || types_match (type, TREE_TYPE (captures[2]))
22353 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
22354 : : || (optimize_vectors_before_lowering_p ()
22355 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
22356 : : )
22357 : : {
22358 : 0 : gimple_seq *lseq = seq;
22359 : 0 : if (lseq
22360 : 0 : && (!single_use (captures[0])
22361 : 0 : || !single_use (captures[4])))
22362 : 0 : lseq = NULL;
22363 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2602;
22364 : 0 : {
22365 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
22366 : 0 : res_op->ops[0] = captures[1];
22367 : 0 : {
22368 : 0 : tree _o1[2], _r1;
22369 : 0 : _o1[0] = captures[2];
22370 : 0 : _o1[1] = captures[5];
22371 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
22372 : 0 : tem_op.resimplify (NULL, valueize);
22373 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
22374 : 0 : if (!_r1) goto next_after_fail2602;
22375 : 0 : res_op->ops[1] = _r1;
22376 : : }
22377 : 0 : {
22378 : 0 : tree _o1[2], _r1;
22379 : 0 : _o1[0] = captures[3];
22380 : 0 : _o1[1] = captures[6];
22381 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
22382 : 0 : tem_op.resimplify (NULL, valueize);
22383 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
22384 : 0 : if (!_r1) goto next_after_fail2602;
22385 : 0 : res_op->ops[2] = _r1;
22386 : : }
22387 : 0 : res_op->resimplify (lseq, valueize);
22388 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
22389 : 0 : return true;
22390 : : }
22391 : 0 : next_after_fail2602:;
22392 : : }
22393 : : }
22394 : : }
22395 : : break;
22396 : : }
22397 : : default:;
22398 : : }
22399 : : }
22400 : : break;
22401 : 341 : default:;
22402 : : }
22403 : 341 : {
22404 : 341 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
22405 : 341 : if (VECTOR_TYPE_P (type)
22406 : 341 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
22407 : : || types_match (type, TREE_TYPE (captures[2]))
22408 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
22409 : : || (optimize_vectors_before_lowering_p ()
22410 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
22411 : : )
22412 : : {
22413 : 341 : gimple_seq *lseq = seq;
22414 : 341 : if (lseq
22415 : 29 : && (!single_use (captures[0])))
22416 : 312 : lseq = NULL;
22417 : 341 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2603;
22418 : 341 : {
22419 : 341 : res_op->set_op (VEC_COND_EXPR, type, 3);
22420 : 341 : res_op->ops[0] = captures[1];
22421 : 341 : {
22422 : 341 : tree _o1[2], _r1;
22423 : 341 : _o1[0] = captures[2];
22424 : 341 : _o1[1] = captures[4];
22425 : 341 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
22426 : 341 : tem_op.resimplify (NULL, valueize);
22427 : 341 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
22428 : 341 : if (!_r1) goto next_after_fail2603;
22429 : 293 : res_op->ops[1] = _r1;
22430 : : }
22431 : 293 : {
22432 : 293 : tree _o1[2], _r1;
22433 : 293 : _o1[0] = captures[3];
22434 : 293 : _o1[1] = captures[4];
22435 : 293 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
22436 : 293 : tem_op.resimplify (NULL, valueize);
22437 : 293 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
22438 : 293 : if (!_r1) goto next_after_fail2603;
22439 : 293 : res_op->ops[2] = _r1;
22440 : : }
22441 : 293 : res_op->resimplify (lseq, valueize);
22442 : 293 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
22443 : 293 : return true;
22444 : : }
22445 : 48 : next_after_fail2603:;
22446 : : }
22447 : : }
22448 : 48 : break;
22449 : : }
22450 : : default:;
22451 : : }
22452 : 659025 : else if (gcall *_c1 = dyn_cast <gcall *> (_d1))
22453 : 23568 : switch (gimple_call_combined_fn (_c1))
22454 : : {
22455 : 0 : case CFN_BUILT_IN_BSWAP128:
22456 : 0 : if (gimple_call_num_args (_c1) == 1)
22457 : : {
22458 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
22459 : 0 : _q20 = do_valueize (valueize, _q20);
22460 : 0 : switch (TREE_CODE (_p1))
22461 : : {
22462 : 0 : case INTEGER_CST:
22463 : 0 : {
22464 : 0 : {
22465 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
22466 : 0 : if (gimple_simplify_509 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP128))
22467 : 0 : return true;
22468 : : }
22469 : 0 : break;
22470 : : }
22471 : : default:;
22472 : : }
22473 : : }
22474 : : break;
22475 : 0 : case CFN_BUILT_IN_BSWAP16:
22476 : 0 : if (gimple_call_num_args (_c1) == 1)
22477 : : {
22478 : 0 : tree _q20 = gimple_call_arg (_c1, 0);
22479 : 0 : _q20 = do_valueize (valueize, _q20);
22480 : 0 : switch (TREE_CODE (_p1))
22481 : : {
22482 : 0 : case INTEGER_CST:
22483 : 0 : {
22484 : 0 : {
22485 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
22486 : 0 : if (gimple_simplify_509 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP16))
22487 : 0 : return true;
22488 : : }
22489 : 0 : break;
22490 : : }
22491 : : default:;
22492 : : }
22493 : : }
22494 : : break;
22495 : 79 : case CFN_BUILT_IN_BSWAP32:
22496 : 79 : if (gimple_call_num_args (_c1) == 1)
22497 : : {
22498 : 79 : tree _q20 = gimple_call_arg (_c1, 0);
22499 : 79 : _q20 = do_valueize (valueize, _q20);
22500 : 79 : switch (TREE_CODE (_p1))
22501 : : {
22502 : 64 : case INTEGER_CST:
22503 : 64 : {
22504 : 64 : {
22505 : 64 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
22506 : 64 : if (gimple_simplify_509 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP32))
22507 : 0 : return true;
22508 : : }
22509 : 64 : break;
22510 : : }
22511 : : default:;
22512 : : }
22513 : : }
22514 : : break;
22515 : 51 : case CFN_BUILT_IN_BSWAP64:
22516 : 51 : if (gimple_call_num_args (_c1) == 1)
22517 : : {
22518 : 51 : tree _q20 = gimple_call_arg (_c1, 0);
22519 : 51 : _q20 = do_valueize (valueize, _q20);
22520 : 51 : switch (TREE_CODE (_p1))
22521 : : {
22522 : 36 : case INTEGER_CST:
22523 : 36 : {
22524 : 36 : {
22525 : 36 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _p1 };
22526 : 36 : if (gimple_simplify_509 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_BSWAP64))
22527 : 0 : return true;
22528 : : }
22529 : 36 : break;
22530 : : }
22531 : : default:;
22532 : : }
22533 : : }
22534 : : break;
22535 : : default:;
22536 : : }
22537 : : }
22538 : : break;
22539 : 3791934 : default:;
22540 : : }
22541 : 3791934 : if (integer_onep (_p0))
22542 : : {
22543 : 211 : {
22544 : 211 : tree captures[1] ATTRIBUTE_UNUSED = { _p1 };
22545 : 211 : if (INTEGRAL_TYPE_P (type)
22546 : : )
22547 : : {
22548 : 187 : gimple_seq *lseq = seq;
22549 : 187 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2604;
22550 : 187 : {
22551 : 187 : res_op->set_op (NOP_EXPR, type, 1);
22552 : 187 : {
22553 : 187 : tree _o1[2], _r1;
22554 : 187 : _o1[0] = captures[0];
22555 : 187 : _o1[1] = build_zero_cst (TREE_TYPE (captures[0]));
22556 : 187 : (*res_op).set_op (EQ_EXPR, boolean_type_node, 2);
22557 : 187 : (*res_op).ops[0] = _o1[0];
22558 : 187 : (*res_op).ops[1] = _o1[1];
22559 : 187 : (*res_op).resimplify (lseq, valueize);
22560 : : }
22561 : 187 : if (type != res_op->type
22562 : 187 : && !useless_type_conversion_p (type, res_op->type))
22563 : : {
22564 : 187 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail2604;
22565 : 108 : res_op->set_op (NOP_EXPR, type, 1);
22566 : 108 : res_op->resimplify (lseq, valueize);
22567 : : }
22568 : 108 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1184, __FILE__, __LINE__, true);
22569 : 108 : return true;
22570 : : }
22571 : : next_after_fail2604:;
22572 : : }
22573 : : }
22574 : : }
22575 : 3791826 : switch (TREE_CODE (_p1))
22576 : : {
22577 : 334700 : case SSA_NAME:
22578 : 334700 : if (gimple *_d1 = get_def (valueize, _p1))
22579 : : {
22580 : 225873 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
22581 : 202681 : switch (gimple_assign_rhs_code (_a1))
22582 : : {
22583 : 159 : case VEC_COND_EXPR:
22584 : 159 : {
22585 : 159 : tree _q30 = gimple_assign_rhs1 (_a1);
22586 : 159 : _q30 = do_valueize (valueize, _q30);
22587 : 159 : tree _q31 = gimple_assign_rhs2 (_a1);
22588 : 159 : _q31 = do_valueize (valueize, _q31);
22589 : 159 : tree _q32 = gimple_assign_rhs3 (_a1);
22590 : 159 : _q32 = do_valueize (valueize, _q32);
22591 : 159 : {
22592 : 159 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
22593 : 159 : if (VECTOR_TYPE_P (type)
22594 : 159 : && (TREE_CODE_CLASS (RSHIFT_EXPR) != tcc_comparison
22595 : : || types_match (type, TREE_TYPE (captures[3]))
22596 : : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
22597 : : || (optimize_vectors_before_lowering_p ()
22598 : : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
22599 : : )
22600 : : {
22601 : 159 : gimple_seq *lseq = seq;
22602 : 159 : if (lseq
22603 : 69 : && (!single_use (captures[1])))
22604 : 90 : lseq = NULL;
22605 : 159 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2605;
22606 : 159 : {
22607 : 159 : res_op->set_op (VEC_COND_EXPR, type, 3);
22608 : 159 : res_op->ops[0] = captures[2];
22609 : 159 : {
22610 : 159 : tree _o1[2], _r1;
22611 : 159 : _o1[0] = captures[0];
22612 : 159 : _o1[1] = captures[3];
22613 : 159 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
22614 : 159 : tem_op.resimplify (NULL, valueize);
22615 : 159 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
22616 : 159 : if (!_r1) goto next_after_fail2605;
22617 : 0 : res_op->ops[1] = _r1;
22618 : : }
22619 : 0 : {
22620 : 0 : tree _o1[2], _r1;
22621 : 0 : _o1[0] = captures[0];
22622 : 0 : _o1[1] = captures[4];
22623 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
22624 : 0 : tem_op.resimplify (NULL, valueize);
22625 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
22626 : 0 : if (!_r1) goto next_after_fail2605;
22627 : 0 : res_op->ops[2] = _r1;
22628 : : }
22629 : 0 : res_op->resimplify (lseq, valueize);
22630 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
22631 : 0 : return true;
22632 : : }
22633 : 159 : next_after_fail2605:;
22634 : : }
22635 : : }
22636 : 159 : break;
22637 : : }
22638 : : default:;
22639 : : }
22640 : : }
22641 : : break;
22642 : 3791826 : default:;
22643 : : }
22644 : 3791826 : switch (TREE_CODE (_p0))
22645 : : {
22646 : 3665221 : case SSA_NAME:
22647 : 3665221 : if (gimple *_d1 = get_def (valueize, _p0))
22648 : : {
22649 : 2259363 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
22650 : 1934209 : switch (gimple_assign_rhs_code (_a1))
22651 : : {
22652 : 195563 : case MULT_EXPR:
22653 : 195563 : {
22654 : 195563 : tree _q20 = gimple_assign_rhs1 (_a1);
22655 : 195563 : _q20 = do_valueize (valueize, _q20);
22656 : 195563 : tree _q21 = gimple_assign_rhs2 (_a1);
22657 : 195563 : _q21 = do_valueize (valueize, _q21);
22658 : 195563 : if (tree_swap_operands_p (_q20, _q21))
22659 : 4988 : std::swap (_q20, _q21);
22660 : 195563 : switch (TREE_CODE (_q20))
22661 : : {
22662 : 195563 : case SSA_NAME:
22663 : 195563 : if (gimple *_d2 = get_def (valueize, _q20))
22664 : : {
22665 : 188523 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
22666 : 183162 : switch (gimple_assign_rhs_code (_a2))
22667 : : {
22668 : 59545 : case BIT_AND_EXPR:
22669 : 59545 : {
22670 : 59545 : tree _q30 = gimple_assign_rhs1 (_a2);
22671 : 59545 : _q30 = do_valueize (valueize, _q30);
22672 : 59545 : tree _q31 = gimple_assign_rhs2 (_a2);
22673 : 59545 : _q31 = do_valueize (valueize, _q31);
22674 : 59545 : if (tree_swap_operands_p (_q30, _q31))
22675 : 132 : std::swap (_q30, _q31);
22676 : 59545 : switch (TREE_CODE (_q30))
22677 : : {
22678 : 59545 : case SSA_NAME:
22679 : 59545 : if (gimple *_d3 = get_def (valueize, _q30))
22680 : : {
22681 : 59280 : if (gassign *_a3 = dyn_cast <gassign *> (_d3))
22682 : 85276 : switch (gimple_assign_rhs_code (_a3))
22683 : : {
22684 : 7303 : case PLUS_EXPR:
22685 : 7303 : {
22686 : 7303 : tree _q40 = gimple_assign_rhs1 (_a3);
22687 : 7303 : _q40 = do_valueize (valueize, _q40);
22688 : 7303 : tree _q41 = gimple_assign_rhs2 (_a3);
22689 : 7303 : _q41 = do_valueize (valueize, _q41);
22690 : 7303 : if (tree_swap_operands_p (_q40, _q41))
22691 : 465 : std::swap (_q40, _q41);
22692 : 7303 : switch (TREE_CODE (_q40))
22693 : : {
22694 : 7303 : case SSA_NAME:
22695 : 7303 : if (gimple *_d4 = get_def (valueize, _q40))
22696 : : {
22697 : 7295 : if (gassign *_a4 = dyn_cast <gassign *> (_d4))
22698 : 10522 : switch (gimple_assign_rhs_code (_a4))
22699 : : {
22700 : 1063 : case RSHIFT_EXPR:
22701 : 1063 : {
22702 : 1063 : tree _q50 = gimple_assign_rhs1 (_a4);
22703 : 1063 : _q50 = do_valueize (valueize, _q50);
22704 : 1063 : tree _q51 = gimple_assign_rhs2 (_a4);
22705 : 1063 : _q51 = do_valueize (valueize, _q51);
22706 : 1063 : switch (TREE_CODE (_q51))
22707 : : {
22708 : 1063 : case INTEGER_CST:
22709 : 1063 : {
22710 : 1063 : if ((_q41 == _q50 && ! TREE_SIDE_EFFECTS (_q41)) || (operand_equal_p (_q41, _q50, 0) && types_match (_q41, _q50)))
22711 : : {
22712 : 259 : switch (TREE_CODE (_q41))
22713 : : {
22714 : 259 : case SSA_NAME:
22715 : 259 : if (gimple *_d5 = get_def (valueize, _q41))
22716 : : {
22717 : 216 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
22718 : 220 : switch (gimple_assign_rhs_code (_a5))
22719 : : {
22720 : 212 : case PLUS_EXPR:
22721 : 212 : {
22722 : 212 : tree _q90 = gimple_assign_rhs1 (_a5);
22723 : 212 : _q90 = do_valueize (valueize, _q90);
22724 : 212 : tree _q91 = gimple_assign_rhs2 (_a5);
22725 : 212 : _q91 = do_valueize (valueize, _q91);
22726 : 212 : if (tree_swap_operands_p (_q90, _q91))
22727 : 14 : std::swap (_q90, _q91);
22728 : 212 : switch (TREE_CODE (_q90))
22729 : : {
22730 : 212 : case SSA_NAME:
22731 : 212 : if (gimple *_d6 = get_def (valueize, _q90))
22732 : : {
22733 : 212 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
22734 : 212 : switch (gimple_assign_rhs_code (_a6))
22735 : : {
22736 : 212 : case BIT_AND_EXPR:
22737 : 212 : {
22738 : 212 : tree _q100 = gimple_assign_rhs1 (_a6);
22739 : 212 : _q100 = do_valueize (valueize, _q100);
22740 : 212 : tree _q101 = gimple_assign_rhs2 (_a6);
22741 : 212 : _q101 = do_valueize (valueize, _q101);
22742 : 212 : if (tree_swap_operands_p (_q100, _q101))
22743 : 0 : std::swap (_q100, _q101);
22744 : 212 : switch (TREE_CODE (_q101))
22745 : : {
22746 : 212 : case INTEGER_CST:
22747 : 212 : {
22748 : 212 : switch (TREE_CODE (_q91))
22749 : : {
22750 : 212 : case SSA_NAME:
22751 : 212 : if (gimple *_d7 = get_def (valueize, _q91))
22752 : : {
22753 : 212 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
22754 : 212 : switch (gimple_assign_rhs_code (_a7))
22755 : : {
22756 : 212 : case BIT_AND_EXPR:
22757 : 212 : {
22758 : 212 : tree _q130 = gimple_assign_rhs1 (_a7);
22759 : 212 : _q130 = do_valueize (valueize, _q130);
22760 : 212 : tree _q131 = gimple_assign_rhs2 (_a7);
22761 : 212 : _q131 = do_valueize (valueize, _q131);
22762 : 212 : if (tree_swap_operands_p (_q130, _q131))
22763 : 0 : std::swap (_q130, _q131);
22764 : 212 : switch (TREE_CODE (_q130))
22765 : : {
22766 : 212 : case SSA_NAME:
22767 : 212 : if (gimple *_d8 = get_def (valueize, _q130))
22768 : : {
22769 : 212 : if (gassign *_a8 = dyn_cast <gassign *> (_d8))
22770 : 212 : switch (gimple_assign_rhs_code (_a8))
22771 : : {
22772 : 212 : case RSHIFT_EXPR:
22773 : 212 : {
22774 : 212 : tree _q140 = gimple_assign_rhs1 (_a8);
22775 : 212 : _q140 = do_valueize (valueize, _q140);
22776 : 212 : tree _q141 = gimple_assign_rhs2 (_a8);
22777 : 212 : _q141 = do_valueize (valueize, _q141);
22778 : 212 : if ((_q140 == _q100 && ! TREE_SIDE_EFFECTS (_q140)) || (operand_equal_p (_q140, _q100, 0) && types_match (_q140, _q100)))
22779 : : {
22780 : 212 : switch (TREE_CODE (_q140))
22781 : : {
22782 : 212 : case SSA_NAME:
22783 : 212 : if (gimple *_d9 = get_def (valueize, _q140))
22784 : : {
22785 : 212 : if (gassign *_a9 = dyn_cast <gassign *> (_d9))
22786 : 172 : switch (gimple_assign_rhs_code (_a9))
22787 : : {
22788 : 172 : case MINUS_EXPR:
22789 : 172 : {
22790 : 172 : tree _q160 = gimple_assign_rhs1 (_a9);
22791 : 172 : _q160 = do_valueize (valueize, _q160);
22792 : 172 : tree _q161 = gimple_assign_rhs2 (_a9);
22793 : 172 : _q161 = do_valueize (valueize, _q161);
22794 : 172 : switch (TREE_CODE (_q161))
22795 : : {
22796 : 172 : case SSA_NAME:
22797 : 172 : if (gimple *_d10 = get_def (valueize, _q161))
22798 : : {
22799 : 172 : if (gassign *_a10 = dyn_cast <gassign *> (_d10))
22800 : 172 : switch (gimple_assign_rhs_code (_a10))
22801 : : {
22802 : 172 : case BIT_AND_EXPR:
22803 : 172 : {
22804 : 172 : tree _q180 = gimple_assign_rhs1 (_a10);
22805 : 172 : _q180 = do_valueize (valueize, _q180);
22806 : 172 : tree _q181 = gimple_assign_rhs2 (_a10);
22807 : 172 : _q181 = do_valueize (valueize, _q181);
22808 : 172 : if (tree_swap_operands_p (_q180, _q181))
22809 : 0 : std::swap (_q180, _q181);
22810 : 172 : switch (TREE_CODE (_q180))
22811 : : {
22812 : 172 : case SSA_NAME:
22813 : 172 : if (gimple *_d11 = get_def (valueize, _q180))
22814 : : {
22815 : 172 : if (gassign *_a11 = dyn_cast <gassign *> (_d11))
22816 : 172 : switch (gimple_assign_rhs_code (_a11))
22817 : : {
22818 : 172 : case RSHIFT_EXPR:
22819 : 172 : {
22820 : 172 : tree _q190 = gimple_assign_rhs1 (_a11);
22821 : 172 : _q190 = do_valueize (valueize, _q190);
22822 : 172 : tree _q191 = gimple_assign_rhs2 (_a11);
22823 : 172 : _q191 = do_valueize (valueize, _q191);
22824 : 172 : if ((_q190 == _q160 && ! TREE_SIDE_EFFECTS (_q190)) || (operand_equal_p (_q190, _q160, 0) && types_match (_q190, _q160)))
22825 : : {
22826 : 172 : switch (TREE_CODE (_q191))
22827 : : {
22828 : 172 : case INTEGER_CST:
22829 : 172 : {
22830 : 172 : switch (TREE_CODE (_q181))
22831 : : {
22832 : 172 : case INTEGER_CST:
22833 : 172 : {
22834 : 172 : switch (TREE_CODE (_q141))
22835 : : {
22836 : 172 : case INTEGER_CST:
22837 : 172 : {
22838 : 172 : switch (TREE_CODE (_q131))
22839 : : {
22840 : 172 : case INTEGER_CST:
22841 : 172 : {
22842 : 172 : switch (TREE_CODE (_q31))
22843 : : {
22844 : 172 : case INTEGER_CST:
22845 : 172 : {
22846 : 172 : switch (TREE_CODE (_q21))
22847 : : {
22848 : 172 : case INTEGER_CST:
22849 : 172 : {
22850 : 172 : switch (TREE_CODE (_p1))
22851 : : {
22852 : 172 : case INTEGER_CST:
22853 : 172 : {
22854 : 172 : {
22855 : 172 : tree captures[12] ATTRIBUTE_UNUSED = { _q50, _q51, _q100, _q101, _q160, _q191, _q181, _q141, _q131, _q31, _q21, _p1 };
22856 : 172 : if (gimple_simplify_510 (res_op, seq, valueize, type, captures))
22857 : 0 : return true;
22858 : : }
22859 : 172 : break;
22860 : : }
22861 : : default:;
22862 : : }
22863 : : break;
22864 : : }
22865 : : default:;
22866 : : }
22867 : : break;
22868 : : }
22869 : : default:;
22870 : : }
22871 : : break;
22872 : : }
22873 : : default:;
22874 : : }
22875 : : break;
22876 : : }
22877 : : default:;
22878 : : }
22879 : : break;
22880 : : }
22881 : : default:;
22882 : : }
22883 : : break;
22884 : : }
22885 : : default:;
22886 : : }
22887 : : }
22888 : : break;
22889 : : }
22890 : : default:;
22891 : : }
22892 : : }
22893 : : break;
22894 : : default:;
22895 : : }
22896 : 212 : break;
22897 : : }
22898 : : default:;
22899 : : }
22900 : : }
22901 : : break;
22902 : : default:;
22903 : : }
22904 : : break;
22905 : : }
22906 : : default:;
22907 : : }
22908 : : }
22909 : : break;
22910 : : default:;
22911 : : }
22912 : : }
22913 : : break;
22914 : : }
22915 : : default:;
22916 : : }
22917 : : }
22918 : : break;
22919 : : default:;
22920 : : }
22921 : 212 : break;
22922 : : }
22923 : : default:;
22924 : : }
22925 : : }
22926 : : break;
22927 : : default:;
22928 : : }
22929 : : break;
22930 : : }
22931 : 212 : default:;
22932 : : }
22933 : 212 : switch (TREE_CODE (_q100))
22934 : : {
22935 : 212 : case SSA_NAME:
22936 : 212 : if (gimple *_d7 = get_def (valueize, _q100))
22937 : : {
22938 : 212 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
22939 : 172 : switch (gimple_assign_rhs_code (_a7))
22940 : : {
22941 : 0 : case RSHIFT_EXPR:
22942 : 0 : {
22943 : 0 : tree _q110 = gimple_assign_rhs1 (_a7);
22944 : 0 : _q110 = do_valueize (valueize, _q110);
22945 : 0 : tree _q111 = gimple_assign_rhs2 (_a7);
22946 : 0 : _q111 = do_valueize (valueize, _q111);
22947 : 0 : switch (TREE_CODE (_q110))
22948 : : {
22949 : 0 : case SSA_NAME:
22950 : 0 : if (gimple *_d8 = get_def (valueize, _q110))
22951 : : {
22952 : 0 : if (gassign *_a8 = dyn_cast <gassign *> (_d8))
22953 : 0 : switch (gimple_assign_rhs_code (_a8))
22954 : : {
22955 : 0 : case MINUS_EXPR:
22956 : 0 : {
22957 : 0 : tree _q120 = gimple_assign_rhs1 (_a8);
22958 : 0 : _q120 = do_valueize (valueize, _q120);
22959 : 0 : tree _q121 = gimple_assign_rhs2 (_a8);
22960 : 0 : _q121 = do_valueize (valueize, _q121);
22961 : 0 : switch (TREE_CODE (_q121))
22962 : : {
22963 : 0 : case SSA_NAME:
22964 : 0 : if (gimple *_d9 = get_def (valueize, _q121))
22965 : : {
22966 : 0 : if (gassign *_a9 = dyn_cast <gassign *> (_d9))
22967 : 0 : switch (gimple_assign_rhs_code (_a9))
22968 : : {
22969 : 0 : case BIT_AND_EXPR:
22970 : 0 : {
22971 : 0 : tree _q140 = gimple_assign_rhs1 (_a9);
22972 : 0 : _q140 = do_valueize (valueize, _q140);
22973 : 0 : tree _q141 = gimple_assign_rhs2 (_a9);
22974 : 0 : _q141 = do_valueize (valueize, _q141);
22975 : 0 : if (tree_swap_operands_p (_q140, _q141))
22976 : 0 : std::swap (_q140, _q141);
22977 : 0 : switch (TREE_CODE (_q140))
22978 : : {
22979 : 0 : case SSA_NAME:
22980 : 0 : if (gimple *_d10 = get_def (valueize, _q140))
22981 : : {
22982 : 0 : if (gassign *_a10 = dyn_cast <gassign *> (_d10))
22983 : 0 : switch (gimple_assign_rhs_code (_a10))
22984 : : {
22985 : 0 : case RSHIFT_EXPR:
22986 : 0 : {
22987 : 0 : tree _q150 = gimple_assign_rhs1 (_a10);
22988 : 0 : _q150 = do_valueize (valueize, _q150);
22989 : 0 : tree _q151 = gimple_assign_rhs2 (_a10);
22990 : 0 : _q151 = do_valueize (valueize, _q151);
22991 : 0 : if ((_q150 == _q120 && ! TREE_SIDE_EFFECTS (_q150)) || (operand_equal_p (_q150, _q120, 0) && types_match (_q150, _q120)))
22992 : : {
22993 : 0 : switch (TREE_CODE (_q151))
22994 : : {
22995 : 0 : case INTEGER_CST:
22996 : 0 : {
22997 : 0 : switch (TREE_CODE (_q141))
22998 : : {
22999 : 0 : case INTEGER_CST:
23000 : 0 : {
23001 : 0 : switch (TREE_CODE (_q111))
23002 : : {
23003 : 0 : case INTEGER_CST:
23004 : 0 : {
23005 : 0 : switch (TREE_CODE (_q101))
23006 : : {
23007 : 0 : case INTEGER_CST:
23008 : 0 : {
23009 : 0 : switch (TREE_CODE (_q91))
23010 : : {
23011 : 0 : case SSA_NAME:
23012 : 0 : if (gimple *_d11 = get_def (valueize, _q91))
23013 : : {
23014 : 0 : if (gassign *_a11 = dyn_cast <gassign *> (_d11))
23015 : 0 : switch (gimple_assign_rhs_code (_a11))
23016 : : {
23017 : 0 : case BIT_AND_EXPR:
23018 : 0 : {
23019 : 0 : tree _q210 = gimple_assign_rhs1 (_a11);
23020 : 0 : _q210 = do_valueize (valueize, _q210);
23021 : 0 : tree _q211 = gimple_assign_rhs2 (_a11);
23022 : 0 : _q211 = do_valueize (valueize, _q211);
23023 : 0 : if (tree_swap_operands_p (_q210, _q211))
23024 : 0 : std::swap (_q210, _q211);
23025 : 0 : if ((_q210 == _q110 && ! TREE_SIDE_EFFECTS (_q210)) || (operand_equal_p (_q210, _q110, 0) && types_match (_q210, _q110)))
23026 : : {
23027 : 0 : switch (TREE_CODE (_q211))
23028 : : {
23029 : 0 : case INTEGER_CST:
23030 : 0 : {
23031 : 0 : switch (TREE_CODE (_q31))
23032 : : {
23033 : 0 : case INTEGER_CST:
23034 : 0 : {
23035 : 0 : switch (TREE_CODE (_q21))
23036 : : {
23037 : 0 : case INTEGER_CST:
23038 : 0 : {
23039 : 0 : switch (TREE_CODE (_p1))
23040 : : {
23041 : 0 : case INTEGER_CST:
23042 : 0 : {
23043 : 0 : {
23044 : 0 : tree captures[12] ATTRIBUTE_UNUSED = { _q50, _q51, _q110, _q211, _q120, _q151, _q141, _q111, _q101, _q31, _q21, _p1 };
23045 : 0 : if (gimple_simplify_510 (res_op, seq, valueize, type, captures))
23046 : 0 : return true;
23047 : : }
23048 : 0 : break;
23049 : : }
23050 : : default:;
23051 : : }
23052 : : break;
23053 : : }
23054 : : default:;
23055 : : }
23056 : : break;
23057 : : }
23058 : : default:;
23059 : : }
23060 : : break;
23061 : : }
23062 : : default:;
23063 : : }
23064 : : }
23065 : 3832248 : break;
23066 : : }
23067 : : default:;
23068 : : }
23069 : : }
23070 : : break;
23071 : : default:;
23072 : : }
23073 : : break;
23074 : : }
23075 : : default:;
23076 : : }
23077 : : break;
23078 : : }
23079 : : default:;
23080 : : }
23081 : : break;
23082 : : }
23083 : : default:;
23084 : : }
23085 : : break;
23086 : : }
23087 : : default:;
23088 : : }
23089 : : }
23090 : : break;
23091 : : }
23092 : : default:;
23093 : : }
23094 : : }
23095 : : break;
23096 : : default:;
23097 : : }
23098 : 3832248 : break;
23099 : : }
23100 : : default:;
23101 : : }
23102 : : }
23103 : : break;
23104 : : default:;
23105 : : }
23106 : : break;
23107 : : }
23108 : : default:;
23109 : : }
23110 : : }
23111 : : break;
23112 : : default:;
23113 : : }
23114 : : break;
23115 : : }
23116 : : default:;
23117 : : }
23118 : : }
23119 : : break;
23120 : : default:;
23121 : : }
23122 : 3832248 : break;
23123 : : }
23124 : : default:;
23125 : : }
23126 : : }
23127 : : break;
23128 : : default:;
23129 : : }
23130 : 3832248 : break;
23131 : : }
23132 : : default:;
23133 : : }
23134 : : }
23135 : : break;
23136 : : default:;
23137 : : }
23138 : : }
23139 : : break;
23140 : : }
23141 : : default:;
23142 : : }
23143 : : break;
23144 : : }
23145 : 1908 : case PLUS_EXPR:
23146 : 1908 : {
23147 : 1908 : tree _q50 = gimple_assign_rhs1 (_a4);
23148 : 1908 : _q50 = do_valueize (valueize, _q50);
23149 : 1908 : tree _q51 = gimple_assign_rhs2 (_a4);
23150 : 1908 : _q51 = do_valueize (valueize, _q51);
23151 : 1908 : if (tree_swap_operands_p (_q50, _q51))
23152 : 30 : std::swap (_q50, _q51);
23153 : 1908 : switch (TREE_CODE (_q50))
23154 : : {
23155 : 1908 : case SSA_NAME:
23156 : 1908 : if (gimple *_d5 = get_def (valueize, _q50))
23157 : : {
23158 : 1908 : if (gassign *_a5 = dyn_cast <gassign *> (_d5))
23159 : 1932 : switch (gimple_assign_rhs_code (_a5))
23160 : : {
23161 : 0 : case BIT_AND_EXPR:
23162 : 0 : {
23163 : 0 : tree _q60 = gimple_assign_rhs1 (_a5);
23164 : 0 : _q60 = do_valueize (valueize, _q60);
23165 : 0 : tree _q61 = gimple_assign_rhs2 (_a5);
23166 : 0 : _q61 = do_valueize (valueize, _q61);
23167 : 0 : if (tree_swap_operands_p (_q60, _q61))
23168 : 0 : std::swap (_q60, _q61);
23169 : 0 : switch (TREE_CODE (_q61))
23170 : : {
23171 : 0 : case INTEGER_CST:
23172 : 0 : {
23173 : 0 : switch (TREE_CODE (_q51))
23174 : : {
23175 : 0 : case SSA_NAME:
23176 : 0 : if (gimple *_d6 = get_def (valueize, _q51))
23177 : : {
23178 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
23179 : 0 : switch (gimple_assign_rhs_code (_a6))
23180 : : {
23181 : 0 : case BIT_AND_EXPR:
23182 : 0 : {
23183 : 0 : tree _q90 = gimple_assign_rhs1 (_a6);
23184 : 0 : _q90 = do_valueize (valueize, _q90);
23185 : 0 : tree _q91 = gimple_assign_rhs2 (_a6);
23186 : 0 : _q91 = do_valueize (valueize, _q91);
23187 : 0 : if (tree_swap_operands_p (_q90, _q91))
23188 : 0 : std::swap (_q90, _q91);
23189 : 0 : switch (TREE_CODE (_q90))
23190 : : {
23191 : 0 : case SSA_NAME:
23192 : 0 : if (gimple *_d7 = get_def (valueize, _q90))
23193 : : {
23194 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
23195 : 0 : switch (gimple_assign_rhs_code (_a7))
23196 : : {
23197 : 0 : case RSHIFT_EXPR:
23198 : 0 : {
23199 : 0 : tree _q100 = gimple_assign_rhs1 (_a7);
23200 : 0 : _q100 = do_valueize (valueize, _q100);
23201 : 0 : tree _q101 = gimple_assign_rhs2 (_a7);
23202 : 0 : _q101 = do_valueize (valueize, _q101);
23203 : 0 : if ((_q100 == _q60 && ! TREE_SIDE_EFFECTS (_q100)) || (operand_equal_p (_q100, _q60, 0) && types_match (_q100, _q60)))
23204 : : {
23205 : 0 : switch (TREE_CODE (_q100))
23206 : : {
23207 : 0 : case SSA_NAME:
23208 : 0 : if (gimple *_d8 = get_def (valueize, _q100))
23209 : : {
23210 : 0 : if (gassign *_a8 = dyn_cast <gassign *> (_d8))
23211 : 0 : switch (gimple_assign_rhs_code (_a8))
23212 : : {
23213 : 0 : case MINUS_EXPR:
23214 : 0 : {
23215 : 0 : tree _q120 = gimple_assign_rhs1 (_a8);
23216 : 0 : _q120 = do_valueize (valueize, _q120);
23217 : 0 : tree _q121 = gimple_assign_rhs2 (_a8);
23218 : 0 : _q121 = do_valueize (valueize, _q121);
23219 : 0 : switch (TREE_CODE (_q121))
23220 : : {
23221 : 0 : case SSA_NAME:
23222 : 0 : if (gimple *_d9 = get_def (valueize, _q121))
23223 : : {
23224 : 0 : if (gassign *_a9 = dyn_cast <gassign *> (_d9))
23225 : 0 : switch (gimple_assign_rhs_code (_a9))
23226 : : {
23227 : 0 : case BIT_AND_EXPR:
23228 : 0 : {
23229 : 0 : tree _q140 = gimple_assign_rhs1 (_a9);
23230 : 0 : _q140 = do_valueize (valueize, _q140);
23231 : 0 : tree _q141 = gimple_assign_rhs2 (_a9);
23232 : 0 : _q141 = do_valueize (valueize, _q141);
23233 : 0 : if (tree_swap_operands_p (_q140, _q141))
23234 : 0 : std::swap (_q140, _q141);
23235 : 0 : switch (TREE_CODE (_q140))
23236 : : {
23237 : 0 : case SSA_NAME:
23238 : 0 : if (gimple *_d10 = get_def (valueize, _q140))
23239 : : {
23240 : 0 : if (gassign *_a10 = dyn_cast <gassign *> (_d10))
23241 : 0 : switch (gimple_assign_rhs_code (_a10))
23242 : : {
23243 : 0 : case RSHIFT_EXPR:
23244 : 0 : {
23245 : 0 : tree _q150 = gimple_assign_rhs1 (_a10);
23246 : 0 : _q150 = do_valueize (valueize, _q150);
23247 : 0 : tree _q151 = gimple_assign_rhs2 (_a10);
23248 : 0 : _q151 = do_valueize (valueize, _q151);
23249 : 0 : if ((_q150 == _q120 && ! TREE_SIDE_EFFECTS (_q150)) || (operand_equal_p (_q150, _q120, 0) && types_match (_q150, _q120)))
23250 : : {
23251 : 0 : switch (TREE_CODE (_q151))
23252 : : {
23253 : 0 : case INTEGER_CST:
23254 : 0 : {
23255 : 0 : switch (TREE_CODE (_q141))
23256 : : {
23257 : 0 : case INTEGER_CST:
23258 : 0 : {
23259 : 0 : switch (TREE_CODE (_q101))
23260 : : {
23261 : 0 : case INTEGER_CST:
23262 : 0 : {
23263 : 0 : switch (TREE_CODE (_q91))
23264 : : {
23265 : 0 : case INTEGER_CST:
23266 : 0 : {
23267 : 0 : switch (TREE_CODE (_q41))
23268 : : {
23269 : 0 : case SSA_NAME:
23270 : 0 : if (gimple *_d11 = get_def (valueize, _q41))
23271 : : {
23272 : 0 : if (gassign *_a11 = dyn_cast <gassign *> (_d11))
23273 : 0 : switch (gimple_assign_rhs_code (_a11))
23274 : : {
23275 : 0 : case RSHIFT_EXPR:
23276 : 0 : {
23277 : 0 : tree _q210 = gimple_assign_rhs1 (_a11);
23278 : 0 : _q210 = do_valueize (valueize, _q210);
23279 : 0 : tree _q211 = gimple_assign_rhs2 (_a11);
23280 : 0 : _q211 = do_valueize (valueize, _q211);
23281 : 0 : if ((_q210 == _q40 && ! TREE_SIDE_EFFECTS (_q210)) || (operand_equal_p (_q210, _q40, 0) && types_match (_q210, _q40)))
23282 : : {
23283 : 0 : switch (TREE_CODE (_q211))
23284 : : {
23285 : 0 : case INTEGER_CST:
23286 : 0 : {
23287 : 0 : switch (TREE_CODE (_q31))
23288 : : {
23289 : 0 : case INTEGER_CST:
23290 : 0 : {
23291 : 0 : switch (TREE_CODE (_q21))
23292 : : {
23293 : 0 : case INTEGER_CST:
23294 : 0 : {
23295 : 0 : switch (TREE_CODE (_p1))
23296 : : {
23297 : 0 : case INTEGER_CST:
23298 : 0 : {
23299 : 0 : {
23300 : 0 : tree captures[12] ATTRIBUTE_UNUSED = { _q40, _q211, _q60, _q61, _q120, _q151, _q141, _q101, _q91, _q31, _q21, _p1 };
23301 : 0 : if (gimple_simplify_510 (res_op, seq, valueize, type, captures))
23302 : 0 : return true;
23303 : : }
23304 : 0 : break;
23305 : : }
23306 : : default:;
23307 : : }
23308 : : break;
23309 : : }
23310 : : default:;
23311 : : }
23312 : : break;
23313 : : }
23314 : : default:;
23315 : : }
23316 : : break;
23317 : : }
23318 : : default:;
23319 : : }
23320 : : }
23321 : : break;
23322 : : }
23323 : : default:;
23324 : : }
23325 : : }
23326 : : break;
23327 : : default:;
23328 : : }
23329 : : break;
23330 : : }
23331 : : default:;
23332 : : }
23333 : : break;
23334 : : }
23335 : : default:;
23336 : : }
23337 : : break;
23338 : : }
23339 : : default:;
23340 : : }
23341 : : break;
23342 : : }
23343 : : default:;
23344 : : }
23345 : : }
23346 : : break;
23347 : : }
23348 : : default:;
23349 : : }
23350 : : }
23351 : : break;
23352 : : default:;
23353 : : }
23354 : 0 : break;
23355 : : }
23356 : : default:;
23357 : : }
23358 : : }
23359 : : break;
23360 : : default:;
23361 : : }
23362 : : break;
23363 : : }
23364 : : default:;
23365 : : }
23366 : : }
23367 : : break;
23368 : : default:;
23369 : : }
23370 : : }
23371 : : break;
23372 : : }
23373 : : default:;
23374 : : }
23375 : : }
23376 : : break;
23377 : : default:;
23378 : : }
23379 : 0 : break;
23380 : : }
23381 : : default:;
23382 : : }
23383 : : }
23384 : : break;
23385 : : default:;
23386 : : }
23387 : : break;
23388 : : }
23389 : 0 : default:;
23390 : : }
23391 : 0 : switch (TREE_CODE (_q60))
23392 : : {
23393 : 0 : case SSA_NAME:
23394 : 0 : if (gimple *_d6 = get_def (valueize, _q60))
23395 : : {
23396 : 0 : if (gassign *_a6 = dyn_cast <gassign *> (_d6))
23397 : 0 : switch (gimple_assign_rhs_code (_a6))
23398 : : {
23399 : 0 : case RSHIFT_EXPR:
23400 : 0 : {
23401 : 0 : tree _q70 = gimple_assign_rhs1 (_a6);
23402 : 0 : _q70 = do_valueize (valueize, _q70);
23403 : 0 : tree _q71 = gimple_assign_rhs2 (_a6);
23404 : 0 : _q71 = do_valueize (valueize, _q71);
23405 : 0 : switch (TREE_CODE (_q70))
23406 : : {
23407 : 0 : case SSA_NAME:
23408 : 0 : if (gimple *_d7 = get_def (valueize, _q70))
23409 : : {
23410 : 0 : if (gassign *_a7 = dyn_cast <gassign *> (_d7))
23411 : 0 : switch (gimple_assign_rhs_code (_a7))
23412 : : {
23413 : 0 : case MINUS_EXPR:
23414 : 0 : {
23415 : 0 : tree _q80 = gimple_assign_rhs1 (_a7);
23416 : 0 : _q80 = do_valueize (valueize, _q80);
23417 : 0 : tree _q81 = gimple_assign_rhs2 (_a7);
23418 : 0 : _q81 = do_valueize (valueize, _q81);
23419 : 0 : switch (TREE_CODE (_q81))
23420 : : {
23421 : 0 : case SSA_NAME:
23422 : 0 : if (gimple *_d8 = get_def (valueize, _q81))
23423 : : {
23424 : 0 : if (gassign *_a8 = dyn_cast <gassign *> (_d8))
23425 : 0 : switch (gimple_assign_rhs_code (_a8))
23426 : : {
23427 : 0 : case BIT_AND_EXPR:
23428 : 0 : {
23429 : 0 : tree _q100 = gimple_assign_rhs1 (_a8);
23430 : 0 : _q100 = do_valueize (valueize, _q100);
23431 : 0 : tree _q101 = gimple_assign_rhs2 (_a8);
23432 : 0 : _q101 = do_valueize (valueize, _q101);
23433 : 0 : if (tree_swap_operands_p (_q100, _q101))
23434 : 0 : std::swap (_q100, _q101);
23435 : 0 : switch (TREE_CODE (_q100))
23436 : : {
23437 : 0 : case SSA_NAME:
23438 : 0 : if (gimple *_d9 = get_def (valueize, _q100))
23439 : : {
23440 : 0 : if (gassign *_a9 = dyn_cast <gassign *> (_d9))
23441 : 0 : switch (gimple_assign_rhs_code (_a9))
23442 : : {
23443 : 0 : case RSHIFT_EXPR:
23444 : 0 : {
23445 : 0 : tree _q110 = gimple_assign_rhs1 (_a9);
23446 : 0 : _q110 = do_valueize (valueize, _q110);
23447 : 0 : tree _q111 = gimple_assign_rhs2 (_a9);
23448 : 0 : _q111 = do_valueize (valueize, _q111);
23449 : 0 : if ((_q110 == _q80 && ! TREE_SIDE_EFFECTS (_q110)) || (operand_equal_p (_q110, _q80, 0) && types_match (_q110, _q80)))
23450 : : {
23451 : 0 : switch (TREE_CODE (_q111))
23452 : : {
23453 : 0 : case INTEGER_CST:
23454 : 0 : {
23455 : 0 : switch (TREE_CODE (_q101))
23456 : : {
23457 : 0 : case INTEGER_CST:
23458 : 0 : {
23459 : 0 : switch (TREE_CODE (_q71))
23460 : : {
23461 : 0 : case INTEGER_CST:
23462 : 0 : {
23463 : 0 : switch (TREE_CODE (_q61))
23464 : : {
23465 : 0 : case INTEGER_CST:
23466 : 0 : {
23467 : 0 : switch (TREE_CODE (_q51))
23468 : : {
23469 : 0 : case SSA_NAME:
23470 : 0 : if (gimple *_d10 = get_def (valueize, _q51))
23471 : : {
23472 : 0 : if (gassign *_a10 = dyn_cast <gassign *> (_d10))
23473 : 0 : switch (gimple_assign_rhs_code (_a10))
23474 : : {
23475 : 0 : case BIT_AND_EXPR:
23476 : 0 : {
23477 : 0 : tree _q170 = gimple_assign_rhs1 (_a10);
23478 : 0 : _q170 = do_valueize (valueize, _q170);
23479 : 0 : tree _q171 = gimple_assign_rhs2 (_a10);
23480 : 0 : _q171 = do_valueize (valueize, _q171);
23481 : 0 : if (tree_swap_operands_p (_q170, _q171))
23482 : 0 : std::swap (_q170, _q171);
23483 : 0 : if ((_q170 == _q70 && ! TREE_SIDE_EFFECTS (_q170)) || (operand_equal_p (_q170, _q70, 0) && types_match (_q170, _q70)))
23484 : : {
23485 : 0 : switch (TREE_CODE (_q171))
23486 : : {
23487 : 0 : case INTEGER_CST:
23488 : 0 : {
23489 : 0 : switch (TREE_CODE (_q41))
23490 : : {
23491 : 0 : case SSA_NAME:
23492 : 0 : if (gimple *_d11 = get_def (valueize, _q41))
23493 : : {
23494 : 0 : if (gassign *_a11 = dyn_cast <gassign *> (_d11))
23495 : 0 : switch (gimple_assign_rhs_code (_a11))
23496 : : {
23497 : 0 : case RSHIFT_EXPR:
23498 : 0 : {
23499 : 0 : tree _q200 = gimple_assign_rhs1 (_a11);
23500 : 0 : _q200 = do_valueize (valueize, _q200);
23501 : 0 : tree _q201 = gimple_assign_rhs2 (_a11);
23502 : 0 : _q201 = do_valueize (valueize, _q201);
23503 : 0 : if ((_q200 == _q40 && ! TREE_SIDE_EFFECTS (_q200)) || (operand_equal_p (_q200, _q40, 0) && types_match (_q200, _q40)))
23504 : : {
23505 : 0 : switch (TREE_CODE (_q201))
23506 : : {
23507 : 0 : case INTEGER_CST:
23508 : 0 : {
23509 : 0 : switch (TREE_CODE (_q31))
23510 : : {
23511 : 0 : case INTEGER_CST:
23512 : 0 : {
23513 : 0 : switch (TREE_CODE (_q21))
23514 : : {
23515 : 0 : case INTEGER_CST:
23516 : 0 : {
23517 : 0 : switch (TREE_CODE (_p1))
23518 : : {
23519 : 0 : case INTEGER_CST:
23520 : 0 : {
23521 : 0 : {
23522 : 0 : tree captures[12] ATTRIBUTE_UNUSED = { _q40, _q201, _q70, _q171, _q80, _q111, _q101, _q71, _q61, _q31, _q21, _p1 };
23523 : 0 : if (gimple_simplify_510 (res_op, seq, valueize, type, captures))
23524 : 0 : return true;
23525 : : }
23526 : 0 : break;
23527 : : }
23528 : : default:;
23529 : : }
23530 : : break;
23531 : : }
23532 : : default:;
23533 : : }
23534 : : break;
23535 : : }
23536 : : default:;
23537 : : }
23538 : : break;
23539 : : }
23540 : : default:;
23541 : : }
23542 : : }
23543 : : break;
23544 : : }
23545 : : default:;
23546 : : }
23547 : : }
23548 : : break;
23549 : : default:;
23550 : : }
23551 : : break;
23552 : : }
23553 : : default:;
23554 : : }
23555 : : }
23556 : 3832248 : break;
23557 : : }
23558 : : default:;
23559 : : }
23560 : : }
23561 : : break;
23562 : : default:;
23563 : : }
23564 : : break;
23565 : : }
23566 : : default:;
23567 : : }
23568 : : break;
23569 : : }
23570 : : default:;
23571 : : }
23572 : : break;
23573 : : }
23574 : : default:;
23575 : : }
23576 : : break;
23577 : : }
23578 : : default:;
23579 : : }
23580 : : }
23581 : : break;
23582 : : }
23583 : : default:;
23584 : : }
23585 : : }
23586 : : break;
23587 : : default:;
23588 : : }
23589 : 3832248 : break;
23590 : : }
23591 : : default:;
23592 : : }
23593 : : }
23594 : : break;
23595 : : default:;
23596 : : }
23597 : : break;
23598 : : }
23599 : : default:;
23600 : : }
23601 : : }
23602 : : break;
23603 : : default:;
23604 : : }
23605 : : break;
23606 : : }
23607 : : default:;
23608 : : }
23609 : : }
23610 : : break;
23611 : : default:;
23612 : : }
23613 : 3832248 : break;
23614 : : }
23615 : : default:;
23616 : : }
23617 : : }
23618 : : break;
23619 : : default:;
23620 : : }
23621 : 3832248 : break;
23622 : : }
23623 : : default:;
23624 : : }
23625 : : }
23626 : : break;
23627 : : default:;
23628 : : }
23629 : 3832248 : break;
23630 : : }
23631 : : default:;
23632 : : }
23633 : : }
23634 : : break;
23635 : : default:;
23636 : : }
23637 : 3832248 : break;
23638 : : }
23639 : : default:;
23640 : : }
23641 : : }
23642 : : break;
23643 : : default:;
23644 : : }
23645 : 3832248 : break;
23646 : : }
23647 : 554 : case VEC_PERM_EXPR:
23648 : 554 : {
23649 : 554 : tree _q20 = gimple_assign_rhs1 (_a1);
23650 : 554 : _q20 = do_valueize (valueize, _q20);
23651 : 554 : tree _q21 = gimple_assign_rhs2 (_a1);
23652 : 554 : _q21 = do_valueize (valueize, _q21);
23653 : 554 : tree _q22 = gimple_assign_rhs3 (_a1);
23654 : 554 : _q22 = do_valueize (valueize, _q22);
23655 : 554 : if ((_q21 == _q20 && ! TREE_SIDE_EFFECTS (_q21)) || (operand_equal_p (_q21, _q20, 0) && types_match (_q21, _q20)))
23656 : : {
23657 : 152 : switch (TREE_CODE (_p1))
23658 : : {
23659 : 56 : case SSA_NAME:
23660 : 56 : if (gimple *_d2 = get_def (valueize, _p1))
23661 : : {
23662 : 49 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
23663 : 37 : switch (gimple_assign_rhs_code (_a2))
23664 : : {
23665 : 2 : case VEC_PERM_EXPR:
23666 : 2 : {
23667 : 2 : tree _q60 = gimple_assign_rhs1 (_a2);
23668 : 2 : _q60 = do_valueize (valueize, _q60);
23669 : 2 : tree _q61 = gimple_assign_rhs2 (_a2);
23670 : 2 : _q61 = do_valueize (valueize, _q61);
23671 : 2 : tree _q62 = gimple_assign_rhs3 (_a2);
23672 : 2 : _q62 = do_valueize (valueize, _q62);
23673 : 2 : if ((_q61 == _q60 && ! TREE_SIDE_EFFECTS (_q61)) || (operand_equal_p (_q61, _q60, 0) && types_match (_q61, _q60)))
23674 : : {
23675 : 2 : if ((_q62 == _q22 && ! TREE_SIDE_EFFECTS (_q62)) || (operand_equal_p (_q62, _q22, 0) && types_match (_q62, _q22)))
23676 : : {
23677 : 2 : {
23678 : 2 : tree captures[4] ATTRIBUTE_UNUSED = { _q20, _q22, _q60 };
23679 : 2 : if (VECTOR_INTEGER_TYPE_P (type)
23680 : : )
23681 : : {
23682 : 2 : gimple_seq *lseq = seq;
23683 : 2 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2606;
23684 : 2 : {
23685 : 2 : res_op->set_op (VEC_PERM_EXPR, type, 3);
23686 : 2 : {
23687 : 2 : tree _o1[2], _r1;
23688 : 2 : _o1[0] = captures[0];
23689 : 2 : _o1[1] = captures[2];
23690 : 2 : gimple_match_op tem_op (res_op->cond.any_else (), RSHIFT_EXPR, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
23691 : 2 : tem_op.resimplify (lseq, valueize);
23692 : 2 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
23693 : 2 : if (!_r1) goto next_after_fail2606;
23694 : 1 : captures[3] = _r1;
23695 : : }
23696 : 1 : res_op->ops[0] = captures[3];
23697 : 1 : res_op->ops[1] = captures[3];
23698 : 1 : res_op->ops[2] = captures[1];
23699 : 1 : res_op->resimplify (lseq, valueize);
23700 : 1 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1064, __FILE__, __LINE__, true);
23701 : 1 : return true;
23702 : : }
23703 : : next_after_fail2606:;
23704 : : }
23705 : : }
23706 : : }
23707 : : }
23708 : : break;
23709 : : }
23710 : : default:;
23711 : : }
23712 : : }
23713 : : break;
23714 : : default:;
23715 : : }
23716 : : }
23717 : : break;
23718 : : }
23719 : : default:;
23720 : : }
23721 : : }
23722 : : break;
23723 : : default:;
23724 : : }
23725 : : return false;
23726 : : }
23727 : :
23728 : : bool
23729 : 0 : gimple_simplify_CFN_FMIN (gimple_match_op *res_op, gimple_seq *seq,
23730 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
23731 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
23732 : : {
23733 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
23734 : 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
23735 : : {
23736 : 0 : {
23737 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
23738 : 0 : if (gimple_simplify_627 (res_op, seq, valueize, type, captures, CFN_FMIN))
23739 : 0 : return true;
23740 : : }
23741 : : }
23742 : 0 : switch (TREE_CODE (_p1))
23743 : : {
23744 : 0 : case REAL_CST:
23745 : 0 : {
23746 : 0 : {
23747 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
23748 : 0 : if (gimple_simplify_628 (res_op, seq, valueize, type, captures, CFN_FMIN))
23749 : 0 : return true;
23750 : : }
23751 : 0 : break;
23752 : : }
23753 : 0 : default:;
23754 : : }
23755 : 0 : switch (TREE_CODE (_p0))
23756 : : {
23757 : 0 : case REAL_CST:
23758 : 0 : {
23759 : 0 : {
23760 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
23761 : 0 : if (gimple_simplify_628 (res_op, seq, valueize, type, captures, CFN_FMIN))
23762 : 0 : return true;
23763 : : }
23764 : 0 : break;
23765 : : }
23766 : 0 : default:;
23767 : : }
23768 : 0 : {
23769 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
23770 : 0 : if (gimple_simplify_629 (res_op, seq, valueize, type, captures, CFN_FMIN))
23771 : 0 : return true;
23772 : : }
23773 : 0 : switch (TREE_CODE (_p0))
23774 : : {
23775 : 0 : case SSA_NAME:
23776 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
23777 : : {
23778 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
23779 : 0 : switch (gimple_assign_rhs_code (_a1))
23780 : : {
23781 : 0 : case NEGATE_EXPR:
23782 : 0 : {
23783 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
23784 : 0 : _q20 = do_valueize (valueize, _q20);
23785 : 0 : switch (TREE_CODE (_p1))
23786 : : {
23787 : 0 : case SSA_NAME:
23788 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
23789 : : {
23790 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
23791 : 0 : switch (gimple_assign_rhs_code (_a2))
23792 : : {
23793 : 0 : case NEGATE_EXPR:
23794 : 0 : {
23795 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
23796 : 0 : _q40 = do_valueize (valueize, _q40);
23797 : 0 : {
23798 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
23799 : 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
23800 : 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
23801 : 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
23802 : : )
23803 : : {
23804 : 0 : gimple_seq *lseq = seq;
23805 : 0 : if (lseq
23806 : 0 : && (!single_use (captures[0])
23807 : 0 : || !single_use (captures[2])))
23808 : 0 : lseq = NULL;
23809 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2799;
23810 : 0 : {
23811 : 0 : res_op->set_op (NEGATE_EXPR, type, 1);
23812 : 0 : {
23813 : 0 : tree _o1[2], _r1;
23814 : 0 : _o1[0] = captures[1];
23815 : 0 : _o1[1] = captures[3];
23816 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_FMAX, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
23817 : 0 : tem_op.resimplify (lseq, valueize);
23818 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
23819 : 0 : if (!_r1) goto next_after_fail2799;
23820 : 0 : res_op->ops[0] = _r1;
23821 : : }
23822 : 0 : res_op->resimplify (lseq, valueize);
23823 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1219, __FILE__, __LINE__, true);
23824 : 0 : return true;
23825 : : }
23826 : 0 : next_after_fail2799:;
23827 : : }
23828 : : }
23829 : 0 : break;
23830 : : }
23831 : : default:;
23832 : : }
23833 : : }
23834 : : break;
23835 : : default:;
23836 : : }
23837 : : break;
23838 : : }
23839 : : default:;
23840 : : }
23841 : : }
23842 : : break;
23843 : : default:;
23844 : : }
23845 : : return false;
23846 : : }
23847 : :
23848 : : bool
23849 : 11 : gimple_simplify_CFN_BUILT_IN_FMAXF16 (gimple_match_op *res_op, gimple_seq *seq,
23850 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
23851 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
23852 : : {
23853 : 11 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
23854 : 11 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
23855 : : {
23856 : 0 : {
23857 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
23858 : 0 : if (gimple_simplify_627 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF16))
23859 : 0 : return true;
23860 : : }
23861 : : }
23862 : 11 : switch (TREE_CODE (_p1))
23863 : : {
23864 : 0 : case REAL_CST:
23865 : 0 : {
23866 : 0 : {
23867 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
23868 : 0 : if (gimple_simplify_628 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF16))
23869 : 0 : return true;
23870 : : }
23871 : 0 : break;
23872 : : }
23873 : 11 : default:;
23874 : : }
23875 : 11 : switch (TREE_CODE (_p0))
23876 : : {
23877 : 0 : case REAL_CST:
23878 : 0 : {
23879 : 0 : {
23880 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
23881 : 0 : if (gimple_simplify_628 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF16))
23882 : 0 : return true;
23883 : : }
23884 : 0 : break;
23885 : : }
23886 : 11 : default:;
23887 : : }
23888 : 11 : {
23889 : 11 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
23890 : 11 : if (gimple_simplify_630 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF16))
23891 : 11 : return true;
23892 : : }
23893 : 0 : switch (TREE_CODE (_p0))
23894 : : {
23895 : 0 : case SSA_NAME:
23896 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
23897 : : {
23898 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
23899 : 0 : switch (gimple_assign_rhs_code (_a1))
23900 : : {
23901 : 0 : case NEGATE_EXPR:
23902 : 0 : {
23903 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
23904 : 0 : _q20 = do_valueize (valueize, _q20);
23905 : 0 : switch (TREE_CODE (_p1))
23906 : : {
23907 : 0 : case SSA_NAME:
23908 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
23909 : : {
23910 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
23911 : 0 : switch (gimple_assign_rhs_code (_a2))
23912 : : {
23913 : 0 : case NEGATE_EXPR:
23914 : 0 : {
23915 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
23916 : 0 : _q40 = do_valueize (valueize, _q40);
23917 : 0 : {
23918 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
23919 : 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
23920 : 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
23921 : 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
23922 : : )
23923 : : {
23924 : 0 : gimple_seq *lseq = seq;
23925 : 0 : if (lseq
23926 : 0 : && (!single_use (captures[0])
23927 : 0 : || !single_use (captures[2])))
23928 : 0 : lseq = NULL;
23929 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2803;
23930 : 0 : {
23931 : 0 : res_op->set_op (NEGATE_EXPR, type, 1);
23932 : 0 : {
23933 : 0 : tree _o1[2], _r1;
23934 : 0 : _o1[0] = captures[1];
23935 : 0 : _o1[1] = captures[3];
23936 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_BUILT_IN_FMINF16, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
23937 : 0 : tem_op.resimplify (lseq, valueize);
23938 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
23939 : 0 : if (!_r1) goto next_after_fail2803;
23940 : 0 : res_op->ops[0] = _r1;
23941 : : }
23942 : 0 : res_op->resimplify (lseq, valueize);
23943 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1219, __FILE__, __LINE__, true);
23944 : 0 : return true;
23945 : : }
23946 : 0 : next_after_fail2803:;
23947 : : }
23948 : : }
23949 : 0 : break;
23950 : : }
23951 : : default:;
23952 : : }
23953 : : }
23954 : : break;
23955 : : default:;
23956 : : }
23957 : : break;
23958 : : }
23959 : : default:;
23960 : : }
23961 : : }
23962 : : break;
23963 : : default:;
23964 : : }
23965 : : return false;
23966 : : }
23967 : :
23968 : : bool
23969 : 0 : gimple_simplify_CFN_BUILT_IN_FMAXF32X (gimple_match_op *res_op, gimple_seq *seq,
23970 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
23971 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
23972 : : {
23973 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
23974 : 0 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
23975 : : {
23976 : 0 : {
23977 : 0 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
23978 : 0 : if (gimple_simplify_627 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF32X))
23979 : 0 : return true;
23980 : : }
23981 : : }
23982 : 0 : switch (TREE_CODE (_p1))
23983 : : {
23984 : 0 : case REAL_CST:
23985 : 0 : {
23986 : 0 : {
23987 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
23988 : 0 : if (gimple_simplify_628 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF32X))
23989 : 0 : return true;
23990 : : }
23991 : 0 : break;
23992 : : }
23993 : 0 : default:;
23994 : : }
23995 : 0 : switch (TREE_CODE (_p0))
23996 : : {
23997 : 0 : case REAL_CST:
23998 : 0 : {
23999 : 0 : {
24000 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p1, _p0 };
24001 : 0 : if (gimple_simplify_628 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF32X))
24002 : 0 : return true;
24003 : : }
24004 : 0 : break;
24005 : : }
24006 : 0 : default:;
24007 : : }
24008 : 0 : {
24009 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
24010 : 0 : if (gimple_simplify_630 (res_op, seq, valueize, type, captures, CFN_BUILT_IN_FMAXF32X))
24011 : 0 : return true;
24012 : : }
24013 : 0 : switch (TREE_CODE (_p0))
24014 : : {
24015 : 0 : case SSA_NAME:
24016 : 0 : if (gimple *_d1 = get_def (valueize, _p0))
24017 : : {
24018 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24019 : 0 : switch (gimple_assign_rhs_code (_a1))
24020 : : {
24021 : 0 : case NEGATE_EXPR:
24022 : 0 : {
24023 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
24024 : 0 : _q20 = do_valueize (valueize, _q20);
24025 : 0 : switch (TREE_CODE (_p1))
24026 : : {
24027 : 0 : case SSA_NAME:
24028 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
24029 : : {
24030 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
24031 : 0 : switch (gimple_assign_rhs_code (_a2))
24032 : : {
24033 : 0 : case NEGATE_EXPR:
24034 : 0 : {
24035 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
24036 : 0 : _q40 = do_valueize (valueize, _q40);
24037 : 0 : {
24038 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _q20, _p1, _q40 };
24039 : 0 : if (FLOAT_TYPE_P (TREE_TYPE (captures[1]))
24040 : 0 : || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
24041 : 0 : && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (captures[1])))
24042 : : )
24043 : : {
24044 : 0 : gimple_seq *lseq = seq;
24045 : 0 : if (lseq
24046 : 0 : && (!single_use (captures[0])
24047 : 0 : || !single_use (captures[2])))
24048 : 0 : lseq = NULL;
24049 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2807;
24050 : 0 : {
24051 : 0 : res_op->set_op (NEGATE_EXPR, type, 1);
24052 : 0 : {
24053 : 0 : tree _o1[2], _r1;
24054 : 0 : _o1[0] = captures[1];
24055 : 0 : _o1[1] = captures[3];
24056 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), CFN_BUILT_IN_FMINF32X, TREE_TYPE (_o1[0]), _o1[0], _o1[1]);
24057 : 0 : tem_op.resimplify (lseq, valueize);
24058 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, lseq);
24059 : 0 : if (!_r1) goto next_after_fail2807;
24060 : 0 : res_op->ops[0] = _r1;
24061 : : }
24062 : 0 : res_op->resimplify (lseq, valueize);
24063 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1219, __FILE__, __LINE__, true);
24064 : 0 : return true;
24065 : : }
24066 : 0 : next_after_fail2807:;
24067 : : }
24068 : : }
24069 : 0 : break;
24070 : : }
24071 : : default:;
24072 : : }
24073 : : }
24074 : : break;
24075 : : default:;
24076 : : }
24077 : : break;
24078 : : }
24079 : : default:;
24080 : : }
24081 : : }
24082 : : break;
24083 : : default:;
24084 : : }
24085 : : return false;
24086 : : }
24087 : :
24088 : : bool
24089 : 96988 : gimple_simplify_RROTATE_EXPR (gimple_match_op *res_op, gimple_seq *seq,
24090 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
24091 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
24092 : : {
24093 : 96988 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
24094 : 96988 : if (integer_all_onesp (_p0))
24095 : : {
24096 : 4 : {
24097 : 4 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
24098 : 4 : if (gimple_simplify_631 (res_op, seq, valueize, type, captures, RROTATE_EXPR))
24099 : 4 : return true;
24100 : : }
24101 : : }
24102 : 96984 : if (integer_zerop (_p1))
24103 : : {
24104 : 26 : {
24105 : 26 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
24106 : 26 : if (gimple_simplify_499 (res_op, seq, valueize, type, captures, RROTATE_EXPR))
24107 : 26 : return true;
24108 : : }
24109 : : }
24110 : 96958 : if (integer_zerop (_p0))
24111 : : {
24112 : 0 : {
24113 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
24114 : 0 : if (gimple_simplify_500 (res_op, seq, valueize, type, captures, RROTATE_EXPR))
24115 : 0 : return true;
24116 : : }
24117 : : }
24118 : 96958 : switch (TREE_CODE (_p1))
24119 : : {
24120 : 18073 : case SSA_NAME:
24121 : 18073 : if (gimple *_d1 = get_def (valueize, _p1))
24122 : : {
24123 : 16870 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24124 : 13538 : switch (gimple_assign_rhs_code (_a1))
24125 : : {
24126 : 0 : case CONSTRUCTOR:
24127 : 0 : {
24128 : 0 : {
24129 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
24130 : 0 : if (gimple_simplify_502 (res_op, seq, valueize, type, captures, RROTATE_EXPR))
24131 : 0 : return true;
24132 : : }
24133 : 0 : break;
24134 : : }
24135 : 100 : case MINUS_EXPR:
24136 : 100 : {
24137 : 100 : tree _q30 = gimple_assign_rhs1 (_a1);
24138 : 100 : _q30 = do_valueize (valueize, _q30);
24139 : 100 : tree _q31 = gimple_assign_rhs2 (_a1);
24140 : 100 : _q31 = do_valueize (valueize, _q31);
24141 : 100 : switch (TREE_CODE (_q30))
24142 : : {
24143 : 100 : case INTEGER_CST:
24144 : 100 : {
24145 : 100 : {
24146 : 100 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31 };
24147 : 100 : if (gimple_simplify_632 (res_op, seq, valueize, type, captures, RROTATE_EXPR, LROTATE_EXPR))
24148 : 7 : return true;
24149 : : }
24150 : 93 : break;
24151 : : }
24152 : : default:;
24153 : : }
24154 : : break;
24155 : : }
24156 : : default:;
24157 : : }
24158 : : }
24159 : : break;
24160 : 0 : case VECTOR_CST:
24161 : 0 : {
24162 : 0 : {
24163 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
24164 : 0 : if (gimple_simplify_501 (res_op, seq, valueize, type, captures, RROTATE_EXPR))
24165 : 0 : return true;
24166 : : }
24167 : 0 : break;
24168 : : }
24169 : 96951 : default:;
24170 : : }
24171 : 96951 : switch (TREE_CODE (_p0))
24172 : : {
24173 : 94279 : case SSA_NAME:
24174 : 94279 : if (gimple *_d1 = get_def (valueize, _p0))
24175 : : {
24176 : 75439 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24177 : 49876 : switch (gimple_assign_rhs_code (_a1))
24178 : : {
24179 : 30 : case RROTATE_EXPR:
24180 : 30 : {
24181 : 30 : tree _q20 = gimple_assign_rhs1 (_a1);
24182 : 30 : _q20 = do_valueize (valueize, _q20);
24183 : 30 : tree _q21 = gimple_assign_rhs2 (_a1);
24184 : 30 : _q21 = do_valueize (valueize, _q21);
24185 : 30 : switch (TREE_CODE (_q21))
24186 : : {
24187 : 30 : case INTEGER_CST:
24188 : 30 : {
24189 : 30 : switch (TREE_CODE (_p1))
24190 : : {
24191 : 30 : case INTEGER_CST:
24192 : 30 : {
24193 : 30 : {
24194 : 30 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _q21, _p1 };
24195 : 30 : if (gimple_simplify_504 (res_op, seq, valueize, type, captures, RROTATE_EXPR))
24196 : 30 : return true;
24197 : : }
24198 : 0 : break;
24199 : : }
24200 : : default:;
24201 : : }
24202 : : break;
24203 : : }
24204 : : default:;
24205 : : }
24206 : : break;
24207 : : }
24208 : : default:;
24209 : : }
24210 : : }
24211 : : break;
24212 : : default:;
24213 : : }
24214 : : return false;
24215 : : }
24216 : :
24217 : : bool
24218 : 31554 : gimple_simplify_UNLT_EXPR (gimple_match_op *res_op, gimple_seq *seq,
24219 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
24220 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
24221 : : {
24222 : 31554 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
24223 : 31554 : switch (TREE_CODE (_p0))
24224 : : {
24225 : 31122 : case SSA_NAME:
24226 : 31122 : if (gimple *_d1 = get_def (valueize, _p0))
24227 : : {
24228 : 17132 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24229 : 21950 : switch (gimple_assign_rhs_code (_a1))
24230 : : {
24231 : 0 : case VEC_COND_EXPR:
24232 : 0 : {
24233 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
24234 : 0 : _q20 = do_valueize (valueize, _q20);
24235 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
24236 : 0 : _q21 = do_valueize (valueize, _q21);
24237 : 0 : tree _q22 = gimple_assign_rhs3 (_a1);
24238 : 0 : _q22 = do_valueize (valueize, _q22);
24239 : 0 : switch (TREE_CODE (_p1))
24240 : : {
24241 : 0 : case SSA_NAME:
24242 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
24243 : : {
24244 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
24245 : 0 : switch (gimple_assign_rhs_code (_a2))
24246 : : {
24247 : 0 : case VEC_COND_EXPR:
24248 : 0 : {
24249 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
24250 : 0 : _q60 = do_valueize (valueize, _q60);
24251 : 0 : tree _q61 = gimple_assign_rhs2 (_a2);
24252 : 0 : _q61 = do_valueize (valueize, _q61);
24253 : 0 : tree _q62 = gimple_assign_rhs3 (_a2);
24254 : 0 : _q62 = do_valueize (valueize, _q62);
24255 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
24256 : : {
24257 : 0 : {
24258 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
24259 : 0 : if (VECTOR_TYPE_P (type)
24260 : 0 : && (TREE_CODE_CLASS (UNLT_EXPR) != tcc_comparison
24261 : 0 : || types_match (type, TREE_TYPE (captures[2]))
24262 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
24263 : : || (optimize_vectors_before_lowering_p ()
24264 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
24265 : : )
24266 : : {
24267 : 0 : gimple_seq *lseq = seq;
24268 : 0 : if (lseq
24269 : 0 : && (!single_use (captures[0])
24270 : 0 : || !single_use (captures[4])))
24271 : 0 : lseq = NULL;
24272 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2823;
24273 : 0 : {
24274 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
24275 : 0 : res_op->ops[0] = captures[1];
24276 : 0 : {
24277 : 0 : tree _o1[2], _r1;
24278 : 0 : _o1[0] = captures[2];
24279 : 0 : _o1[1] = captures[5];
24280 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNLT_EXPR, type, _o1[0], _o1[1]);
24281 : 0 : tem_op.resimplify (NULL, valueize);
24282 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24283 : 0 : if (!_r1) goto next_after_fail2823;
24284 : 0 : res_op->ops[1] = _r1;
24285 : : }
24286 : 0 : {
24287 : 0 : tree _o1[2], _r1;
24288 : 0 : _o1[0] = captures[3];
24289 : 0 : _o1[1] = captures[6];
24290 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNLT_EXPR, type, _o1[0], _o1[1]);
24291 : 0 : tem_op.resimplify (NULL, valueize);
24292 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24293 : 0 : if (!_r1) goto next_after_fail2823;
24294 : 0 : res_op->ops[2] = _r1;
24295 : : }
24296 : 0 : res_op->resimplify (lseq, valueize);
24297 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
24298 : 0 : return true;
24299 : : }
24300 : 0 : next_after_fail2823:;
24301 : : }
24302 : : }
24303 : : }
24304 : : break;
24305 : : }
24306 : : default:;
24307 : : }
24308 : : }
24309 : : break;
24310 : 0 : default:;
24311 : : }
24312 : 0 : {
24313 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
24314 : 0 : if (VECTOR_TYPE_P (type)
24315 : 0 : && (TREE_CODE_CLASS (UNLT_EXPR) != tcc_comparison
24316 : 0 : || types_match (type, TREE_TYPE (captures[2]))
24317 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
24318 : : || (optimize_vectors_before_lowering_p ()
24319 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
24320 : : )
24321 : : {
24322 : 0 : gimple_seq *lseq = seq;
24323 : 0 : if (lseq
24324 : 0 : && (!single_use (captures[0])))
24325 : 0 : lseq = NULL;
24326 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2824;
24327 : 0 : {
24328 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
24329 : 0 : res_op->ops[0] = captures[1];
24330 : 0 : {
24331 : 0 : tree _o1[2], _r1;
24332 : 0 : _o1[0] = captures[2];
24333 : 0 : _o1[1] = captures[4];
24334 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNLT_EXPR, type, _o1[0], _o1[1]);
24335 : 0 : tem_op.resimplify (NULL, valueize);
24336 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24337 : 0 : if (!_r1) goto next_after_fail2824;
24338 : 0 : res_op->ops[1] = _r1;
24339 : : }
24340 : 0 : {
24341 : 0 : tree _o1[2], _r1;
24342 : 0 : _o1[0] = captures[3];
24343 : 0 : _o1[1] = captures[4];
24344 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNLT_EXPR, type, _o1[0], _o1[1]);
24345 : 0 : tem_op.resimplify (NULL, valueize);
24346 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24347 : 0 : if (!_r1) goto next_after_fail2824;
24348 : 0 : res_op->ops[2] = _r1;
24349 : : }
24350 : 0 : res_op->resimplify (lseq, valueize);
24351 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
24352 : 0 : return true;
24353 : : }
24354 : 0 : next_after_fail2824:;
24355 : : }
24356 : : }
24357 : 0 : break;
24358 : : }
24359 : : default:;
24360 : : }
24361 : : }
24362 : : break;
24363 : 31554 : default:;
24364 : : }
24365 : 31554 : switch (TREE_CODE (_p1))
24366 : : {
24367 : 13322 : case SSA_NAME:
24368 : 13322 : if (gimple *_d1 = get_def (valueize, _p1))
24369 : : {
24370 : 8120 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24371 : 11564 : switch (gimple_assign_rhs_code (_a1))
24372 : : {
24373 : 0 : case VEC_COND_EXPR:
24374 : 0 : {
24375 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
24376 : 0 : _q30 = do_valueize (valueize, _q30);
24377 : 0 : tree _q31 = gimple_assign_rhs2 (_a1);
24378 : 0 : _q31 = do_valueize (valueize, _q31);
24379 : 0 : tree _q32 = gimple_assign_rhs3 (_a1);
24380 : 0 : _q32 = do_valueize (valueize, _q32);
24381 : 0 : {
24382 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
24383 : 0 : if (VECTOR_TYPE_P (type)
24384 : 0 : && (TREE_CODE_CLASS (UNLT_EXPR) != tcc_comparison
24385 : 0 : || types_match (type, TREE_TYPE (captures[3]))
24386 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
24387 : : || (optimize_vectors_before_lowering_p ()
24388 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
24389 : : )
24390 : : {
24391 : 0 : gimple_seq *lseq = seq;
24392 : 0 : if (lseq
24393 : 0 : && (!single_use (captures[1])))
24394 : 0 : lseq = NULL;
24395 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2825;
24396 : 0 : {
24397 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
24398 : 0 : res_op->ops[0] = captures[2];
24399 : 0 : {
24400 : 0 : tree _o1[2], _r1;
24401 : 0 : _o1[0] = captures[0];
24402 : 0 : _o1[1] = captures[3];
24403 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNLT_EXPR, type, _o1[0], _o1[1]);
24404 : 0 : tem_op.resimplify (NULL, valueize);
24405 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24406 : 0 : if (!_r1) goto next_after_fail2825;
24407 : 0 : res_op->ops[1] = _r1;
24408 : : }
24409 : 0 : {
24410 : 0 : tree _o1[2], _r1;
24411 : 0 : _o1[0] = captures[0];
24412 : 0 : _o1[1] = captures[4];
24413 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNLT_EXPR, type, _o1[0], _o1[1]);
24414 : 0 : tem_op.resimplify (NULL, valueize);
24415 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24416 : 0 : if (!_r1) goto next_after_fail2825;
24417 : 0 : res_op->ops[2] = _r1;
24418 : : }
24419 : 0 : res_op->resimplify (lseq, valueize);
24420 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
24421 : 0 : return true;
24422 : : }
24423 : 0 : next_after_fail2825:;
24424 : : }
24425 : : }
24426 : 0 : break;
24427 : : }
24428 : : default:;
24429 : : }
24430 : : }
24431 : : break;
24432 : 31554 : default:;
24433 : : }
24434 : 31554 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
24435 : : {
24436 : 7 : {
24437 : 7 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
24438 : 7 : if (gimple_simplify_659 (res_op, seq, valueize, type, captures, UNLT_EXPR))
24439 : 7 : return true;
24440 : : }
24441 : : }
24442 : 31547 : switch (TREE_CODE (_p0))
24443 : : {
24444 : 31115 : case SSA_NAME:
24445 : 31115 : if (gimple *_d1 = get_def (valueize, _p0))
24446 : : {
24447 : 17131 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24448 : 21950 : switch (gimple_assign_rhs_code (_a1))
24449 : : {
24450 : 701 : case FLOAT_EXPR:
24451 : 701 : {
24452 : 701 : tree _q20 = gimple_assign_rhs1 (_a1);
24453 : 701 : _q20 = do_valueize (valueize, _q20);
24454 : 701 : switch (TREE_CODE (_p1))
24455 : : {
24456 : 0 : case SSA_NAME:
24457 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
24458 : : {
24459 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
24460 : 0 : switch (gimple_assign_rhs_code (_a2))
24461 : : {
24462 : 0 : case FLOAT_EXPR:
24463 : 0 : {
24464 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
24465 : 0 : _q40 = do_valueize (valueize, _q40);
24466 : 0 : {
24467 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
24468 : 0 : if (gimple_simplify_286 (res_op, seq, valueize, type, captures, UNLT_EXPR, LT_EXPR))
24469 : 0 : return true;
24470 : : }
24471 : 0 : break;
24472 : : }
24473 : : default:;
24474 : : }
24475 : : }
24476 : : break;
24477 : : default:;
24478 : : }
24479 : : break;
24480 : : }
24481 : 30 : case NEGATE_EXPR:
24482 : 30 : {
24483 : 30 : tree _q20 = gimple_assign_rhs1 (_a1);
24484 : 30 : _q20 = do_valueize (valueize, _q20);
24485 : 30 : switch (TREE_CODE (_p1))
24486 : : {
24487 : 30 : case SSA_NAME:
24488 : 30 : if (gimple *_d2 = get_def (valueize, _p1))
24489 : : {
24490 : 30 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
24491 : 30 : switch (gimple_assign_rhs_code (_a2))
24492 : : {
24493 : 30 : case NEGATE_EXPR:
24494 : 30 : {
24495 : 30 : tree _q40 = gimple_assign_rhs1 (_a2);
24496 : 30 : _q40 = do_valueize (valueize, _q40);
24497 : 30 : {
24498 : 30 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
24499 : 30 : if (gimple_simplify_289 (res_op, seq, valueize, type, captures, UNLT_EXPR, UNGT_EXPR))
24500 : 30 : return true;
24501 : : }
24502 : 0 : break;
24503 : : }
24504 : : default:;
24505 : : }
24506 : : }
24507 : : break;
24508 : 0 : default:;
24509 : : }
24510 : 0 : if (CONSTANT_CLASS_P (_p1))
24511 : : {
24512 : 0 : {
24513 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
24514 : 0 : if (gimple_simplify_290 (res_op, seq, valueize, type, captures, UNLT_EXPR, UNGT_EXPR))
24515 : 0 : return true;
24516 : : }
24517 : : }
24518 : : break;
24519 : : }
24520 : : default:;
24521 : : }
24522 : : }
24523 : : break;
24524 : 31517 : default:;
24525 : : }
24526 : 31517 : switch (TREE_CODE (_p1))
24527 : : {
24528 : 17924 : case REAL_CST:
24529 : 17924 : {
24530 : 17924 : {
24531 : 17924 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
24532 : 17924 : if (gimple_simplify_658 (res_op, seq, valueize, type, captures, UNLT_EXPR))
24533 : 0 : return true;
24534 : : }
24535 : 17924 : break;
24536 : : }
24537 : : default:;
24538 : : }
24539 : : return false;
24540 : : }
24541 : :
24542 : : bool
24543 : 12041 : gimple_simplify_UNEQ_EXPR (gimple_match_op *res_op, gimple_seq *seq,
24544 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
24545 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1)
24546 : : {
24547 : 12041 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
24548 : 12041 : switch (TREE_CODE (_p0))
24549 : : {
24550 : 11806 : case SSA_NAME:
24551 : 11806 : if (gimple *_d1 = get_def (valueize, _p0))
24552 : : {
24553 : 7127 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24554 : 9098 : switch (gimple_assign_rhs_code (_a1))
24555 : : {
24556 : 0 : case VEC_COND_EXPR:
24557 : 0 : {
24558 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
24559 : 0 : _q20 = do_valueize (valueize, _q20);
24560 : 0 : tree _q21 = gimple_assign_rhs2 (_a1);
24561 : 0 : _q21 = do_valueize (valueize, _q21);
24562 : 0 : tree _q22 = gimple_assign_rhs3 (_a1);
24563 : 0 : _q22 = do_valueize (valueize, _q22);
24564 : 0 : switch (TREE_CODE (_p1))
24565 : : {
24566 : 0 : case SSA_NAME:
24567 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
24568 : : {
24569 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
24570 : 0 : switch (gimple_assign_rhs_code (_a2))
24571 : : {
24572 : 0 : case VEC_COND_EXPR:
24573 : 0 : {
24574 : 0 : tree _q60 = gimple_assign_rhs1 (_a2);
24575 : 0 : _q60 = do_valueize (valueize, _q60);
24576 : 0 : tree _q61 = gimple_assign_rhs2 (_a2);
24577 : 0 : _q61 = do_valueize (valueize, _q61);
24578 : 0 : tree _q62 = gimple_assign_rhs3 (_a2);
24579 : 0 : _q62 = do_valueize (valueize, _q62);
24580 : 0 : if ((_q60 == _q20 && ! TREE_SIDE_EFFECTS (_q60)) || (operand_equal_p (_q60, _q20, 0) && types_match (_q60, _q20)))
24581 : : {
24582 : 0 : {
24583 : 0 : tree captures[7] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _q61, _q62 };
24584 : 0 : if (VECTOR_TYPE_P (type)
24585 : 0 : && (TREE_CODE_CLASS (UNEQ_EXPR) != tcc_comparison
24586 : 0 : || types_match (type, TREE_TYPE (captures[2]))
24587 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
24588 : : || (optimize_vectors_before_lowering_p ()
24589 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
24590 : : )
24591 : : {
24592 : 0 : gimple_seq *lseq = seq;
24593 : 0 : if (lseq
24594 : 0 : && (!single_use (captures[0])
24595 : 0 : || !single_use (captures[4])))
24596 : 0 : lseq = NULL;
24597 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2835;
24598 : 0 : {
24599 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
24600 : 0 : res_op->ops[0] = captures[1];
24601 : 0 : {
24602 : 0 : tree _o1[2], _r1;
24603 : 0 : _o1[0] = captures[2];
24604 : 0 : _o1[1] = captures[5];
24605 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNEQ_EXPR, type, _o1[0], _o1[1]);
24606 : 0 : tem_op.resimplify (NULL, valueize);
24607 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24608 : 0 : if (!_r1) goto next_after_fail2835;
24609 : 0 : res_op->ops[1] = _r1;
24610 : : }
24611 : 0 : {
24612 : 0 : tree _o1[2], _r1;
24613 : 0 : _o1[0] = captures[3];
24614 : 0 : _o1[1] = captures[6];
24615 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNEQ_EXPR, type, _o1[0], _o1[1]);
24616 : 0 : tem_op.resimplify (NULL, valueize);
24617 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24618 : 0 : if (!_r1) goto next_after_fail2835;
24619 : 0 : res_op->ops[2] = _r1;
24620 : : }
24621 : 0 : res_op->resimplify (lseq, valueize);
24622 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1060, __FILE__, __LINE__, true);
24623 : 0 : return true;
24624 : : }
24625 : 0 : next_after_fail2835:;
24626 : : }
24627 : : }
24628 : : }
24629 : : break;
24630 : : }
24631 : : default:;
24632 : : }
24633 : : }
24634 : : break;
24635 : 0 : default:;
24636 : : }
24637 : 0 : {
24638 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1 };
24639 : 0 : if (VECTOR_TYPE_P (type)
24640 : 0 : && (TREE_CODE_CLASS (UNEQ_EXPR) != tcc_comparison
24641 : 0 : || types_match (type, TREE_TYPE (captures[2]))
24642 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[1]))
24643 : : || (optimize_vectors_before_lowering_p ()
24644 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[2]), TREE_TYPE (captures[1]))))
24645 : : )
24646 : : {
24647 : 0 : gimple_seq *lseq = seq;
24648 : 0 : if (lseq
24649 : 0 : && (!single_use (captures[0])))
24650 : 0 : lseq = NULL;
24651 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2836;
24652 : 0 : {
24653 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
24654 : 0 : res_op->ops[0] = captures[1];
24655 : 0 : {
24656 : 0 : tree _o1[2], _r1;
24657 : 0 : _o1[0] = captures[2];
24658 : 0 : _o1[1] = captures[4];
24659 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNEQ_EXPR, type, _o1[0], _o1[1]);
24660 : 0 : tem_op.resimplify (NULL, valueize);
24661 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24662 : 0 : if (!_r1) goto next_after_fail2836;
24663 : 0 : res_op->ops[1] = _r1;
24664 : : }
24665 : 0 : {
24666 : 0 : tree _o1[2], _r1;
24667 : 0 : _o1[0] = captures[3];
24668 : 0 : _o1[1] = captures[4];
24669 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNEQ_EXPR, type, _o1[0], _o1[1]);
24670 : 0 : tem_op.resimplify (NULL, valueize);
24671 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24672 : 0 : if (!_r1) goto next_after_fail2836;
24673 : 0 : res_op->ops[2] = _r1;
24674 : : }
24675 : 0 : res_op->resimplify (lseq, valueize);
24676 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1062, __FILE__, __LINE__, true);
24677 : 0 : return true;
24678 : : }
24679 : 0 : next_after_fail2836:;
24680 : : }
24681 : : }
24682 : 0 : break;
24683 : : }
24684 : : default:;
24685 : : }
24686 : : }
24687 : : break;
24688 : 12041 : default:;
24689 : : }
24690 : 12041 : switch (TREE_CODE (_p1))
24691 : : {
24692 : 11317 : case SSA_NAME:
24693 : 11317 : if (gimple *_d1 = get_def (valueize, _p1))
24694 : : {
24695 : 6845 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24696 : 8674 : switch (gimple_assign_rhs_code (_a1))
24697 : : {
24698 : 0 : case VEC_COND_EXPR:
24699 : 0 : {
24700 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
24701 : 0 : _q30 = do_valueize (valueize, _q30);
24702 : 0 : tree _q31 = gimple_assign_rhs2 (_a1);
24703 : 0 : _q31 = do_valueize (valueize, _q31);
24704 : 0 : tree _q32 = gimple_assign_rhs3 (_a1);
24705 : 0 : _q32 = do_valueize (valueize, _q32);
24706 : 0 : {
24707 : 0 : tree captures[5] ATTRIBUTE_UNUSED = { _p0, _p1, _q30, _q31, _q32 };
24708 : 0 : if (VECTOR_TYPE_P (type)
24709 : 0 : && (TREE_CODE_CLASS (UNEQ_EXPR) != tcc_comparison
24710 : 0 : || types_match (type, TREE_TYPE (captures[3]))
24711 : 0 : || expand_vec_cond_expr_p (type, TREE_TYPE (captures[2]))
24712 : : || (optimize_vectors_before_lowering_p ()
24713 : 0 : && !expand_vec_cond_expr_p (TREE_TYPE (captures[3]), TREE_TYPE (captures[2]))))
24714 : : )
24715 : : {
24716 : 0 : gimple_seq *lseq = seq;
24717 : 0 : if (lseq
24718 : 0 : && (!single_use (captures[1])))
24719 : 0 : lseq = NULL;
24720 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail2837;
24721 : 0 : {
24722 : 0 : res_op->set_op (VEC_COND_EXPR, type, 3);
24723 : 0 : res_op->ops[0] = captures[2];
24724 : 0 : {
24725 : 0 : tree _o1[2], _r1;
24726 : 0 : _o1[0] = captures[0];
24727 : 0 : _o1[1] = captures[3];
24728 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNEQ_EXPR, type, _o1[0], _o1[1]);
24729 : 0 : tem_op.resimplify (NULL, valueize);
24730 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24731 : 0 : if (!_r1) goto next_after_fail2837;
24732 : 0 : res_op->ops[1] = _r1;
24733 : : }
24734 : 0 : {
24735 : 0 : tree _o1[2], _r1;
24736 : 0 : _o1[0] = captures[0];
24737 : 0 : _o1[1] = captures[4];
24738 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), UNEQ_EXPR, type, _o1[0], _o1[1]);
24739 : 0 : tem_op.resimplify (NULL, valueize);
24740 : 0 : _r1 = maybe_push_res_to_seq (&tem_op, NULL);
24741 : 0 : if (!_r1) goto next_after_fail2837;
24742 : 0 : res_op->ops[2] = _r1;
24743 : : }
24744 : 0 : res_op->resimplify (lseq, valueize);
24745 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1063, __FILE__, __LINE__, true);
24746 : 0 : return true;
24747 : : }
24748 : 0 : next_after_fail2837:;
24749 : : }
24750 : : }
24751 : 0 : break;
24752 : : }
24753 : : default:;
24754 : : }
24755 : : }
24756 : : break;
24757 : 12041 : default:;
24758 : : }
24759 : 12041 : if ((_p1 == _p0 && ! TREE_SIDE_EFFECTS (_p1)) || (operand_equal_p (_p1, _p0, 0) && types_match (_p1, _p0)))
24760 : : {
24761 : 5 : {
24762 : 5 : tree captures[1] ATTRIBUTE_UNUSED = { _p0 };
24763 : 5 : if (gimple_simplify_660 (res_op, seq, valueize, type, captures, UNEQ_EXPR))
24764 : 5 : return true;
24765 : : }
24766 : : }
24767 : 12036 : switch (TREE_CODE (_p0))
24768 : : {
24769 : 11801 : case SSA_NAME:
24770 : 11801 : if (gimple *_d1 = get_def (valueize, _p0))
24771 : : {
24772 : 7127 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24773 : 9098 : switch (gimple_assign_rhs_code (_a1))
24774 : : {
24775 : 0 : case FLOAT_EXPR:
24776 : 0 : {
24777 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
24778 : 0 : _q20 = do_valueize (valueize, _q20);
24779 : 0 : switch (TREE_CODE (_p1))
24780 : : {
24781 : 0 : case SSA_NAME:
24782 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
24783 : : {
24784 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
24785 : 0 : switch (gimple_assign_rhs_code (_a2))
24786 : : {
24787 : 0 : case FLOAT_EXPR:
24788 : 0 : {
24789 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
24790 : 0 : _q40 = do_valueize (valueize, _q40);
24791 : 0 : {
24792 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _q20, _q40 };
24793 : 0 : if (gimple_simplify_286 (res_op, seq, valueize, type, captures, UNEQ_EXPR, EQ_EXPR))
24794 : 0 : return true;
24795 : : }
24796 : 0 : break;
24797 : : }
24798 : : default:;
24799 : : }
24800 : : }
24801 : : break;
24802 : : default:;
24803 : : }
24804 : : break;
24805 : : }
24806 : 0 : case NEGATE_EXPR:
24807 : 0 : {
24808 : 0 : tree _q20 = gimple_assign_rhs1 (_a1);
24809 : 0 : _q20 = do_valueize (valueize, _q20);
24810 : 0 : switch (TREE_CODE (_p1))
24811 : : {
24812 : 0 : case SSA_NAME:
24813 : 0 : if (gimple *_d2 = get_def (valueize, _p1))
24814 : : {
24815 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
24816 : 0 : switch (gimple_assign_rhs_code (_a2))
24817 : : {
24818 : 0 : case NEGATE_EXPR:
24819 : 0 : {
24820 : 0 : tree _q40 = gimple_assign_rhs1 (_a2);
24821 : 0 : _q40 = do_valueize (valueize, _q40);
24822 : 0 : {
24823 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _q40 };
24824 : 0 : if (gimple_simplify_289 (res_op, seq, valueize, type, captures, UNEQ_EXPR, UNEQ_EXPR))
24825 : 0 : return true;
24826 : : }
24827 : 0 : break;
24828 : : }
24829 : : default:;
24830 : : }
24831 : : }
24832 : : break;
24833 : 0 : default:;
24834 : : }
24835 : 0 : if (CONSTANT_CLASS_P (_p1))
24836 : : {
24837 : 0 : {
24838 : 0 : tree captures[2] ATTRIBUTE_UNUSED = { _q20, _p1 };
24839 : 0 : if (gimple_simplify_290 (res_op, seq, valueize, type, captures, UNEQ_EXPR, UNEQ_EXPR))
24840 : 0 : return true;
24841 : : }
24842 : : }
24843 : : break;
24844 : : }
24845 : : default:;
24846 : : }
24847 : : }
24848 : : break;
24849 : 12036 : default:;
24850 : : }
24851 : 12036 : switch (TREE_CODE (_p1))
24852 : : {
24853 : 487 : case REAL_CST:
24854 : 487 : {
24855 : 487 : {
24856 : 487 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
24857 : 487 : if (gimple_simplify_658 (res_op, seq, valueize, type, captures, UNEQ_EXPR))
24858 : 0 : return true;
24859 : : }
24860 : 487 : break;
24861 : : }
24862 : : default:;
24863 : : }
24864 : : return false;
24865 : : }
24866 : :
24867 : : bool
24868 : 1097820 : gimple_simplify_BIT_FIELD_REF (gimple_match_op *res_op, gimple_seq *seq,
24869 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
24870 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
24871 : : {
24872 : 1097820 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
24873 : 1097820 : switch (TREE_CODE (_p0))
24874 : : {
24875 : 1097754 : case SSA_NAME:
24876 : 1097754 : if (gimple *_d1 = get_def (valueize, _p0))
24877 : : {
24878 : 743751 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
24879 : 952169 : switch (gimple_assign_rhs_code (_a1))
24880 : : {
24881 : 419 : case BIT_FIELD_REF:
24882 : 419 : {
24883 : 419 : tree _q20 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 0);
24884 : 419 : if ((TREE_CODE (_q20) == SSA_NAME
24885 : 419 : || is_gimple_min_invariant (_q20)))
24886 : : {
24887 : 381 : _q20 = do_valueize (valueize, _q20);
24888 : 381 : tree _q21 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 1);
24889 : 381 : if ((TREE_CODE (_q21) == SSA_NAME
24890 : 381 : || is_gimple_min_invariant (_q21)))
24891 : : {
24892 : 381 : _q21 = do_valueize (valueize, _q21);
24893 : 381 : tree _q22 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 2);
24894 : 381 : if ((TREE_CODE (_q22) == SSA_NAME
24895 : 381 : || is_gimple_min_invariant (_q22)))
24896 : : {
24897 : 381 : _q22 = do_valueize (valueize, _q22);
24898 : 381 : {
24899 : 381 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1, _p2 };
24900 : 381 : gimple_seq *lseq = seq;
24901 : 381 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3051;
24902 : 381 : {
24903 : 381 : res_op->set_op (BIT_FIELD_REF, type, 3);
24904 : 381 : res_op->ops[0] = captures[0];
24905 : 381 : res_op->ops[1] = captures[3];
24906 : 381 : res_op->ops[2] = const_binop (PLUS_EXPR, bitsizetype, captures[2], captures[4]);
24907 : 381 : res_op->resimplify (lseq, valueize);
24908 : 381 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1275, __FILE__, __LINE__, true);
24909 : 381 : return true;
24910 : : }
24911 : 0 : next_after_fail3051:;
24912 : : }
24913 : : }
24914 : : }
24915 : : }
24916 : : break;
24917 : : }
24918 : 61198 : case VIEW_CONVERT_EXPR:
24919 : 61198 : {
24920 : 61198 : tree _q20 = TREE_OPERAND (gimple_assign_rhs1 (_a1), 0);
24921 : 61198 : if ((TREE_CODE (_q20) == SSA_NAME
24922 : 61198 : || is_gimple_min_invariant (_q20)))
24923 : : {
24924 : 61181 : _q20 = do_valueize (valueize, _q20);
24925 : 61181 : {
24926 : 61181 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _p2 };
24927 : 122362 : if (! INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
24928 : 61218 : || type_has_mode_precision_p (TREE_TYPE (captures[0]))
24929 : : )
24930 : : {
24931 : 61157 : gimple_seq *lseq = seq;
24932 : 61157 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3052;
24933 : 61157 : {
24934 : 61157 : res_op->set_op (BIT_FIELD_REF, type, 3);
24935 : 61157 : res_op->ops[0] = captures[0];
24936 : 61157 : res_op->ops[1] = captures[1];
24937 : 61157 : res_op->ops[2] = captures[2];
24938 : 61157 : res_op->resimplify (lseq, valueize);
24939 : 61157 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1276, __FILE__, __LINE__, true);
24940 : 61157 : return true;
24941 : : }
24942 : 0 : next_after_fail3052:;
24943 : : }
24944 : : }
24945 : : }
24946 : : break;
24947 : : }
24948 : : default:;
24949 : : }
24950 : : }
24951 : : break;
24952 : 1036282 : default:;
24953 : : }
24954 : 1036282 : if (integer_zerop (_p2))
24955 : : {
24956 : 397372 : {
24957 : 397372 : tree captures[2] ATTRIBUTE_UNUSED = { _p0, _p1 };
24958 : 397372 : if (tree_int_cst_equal (captures[1], TYPE_SIZE (TREE_TYPE (captures[0])))
24959 : : )
24960 : : {
24961 : 1830 : gimple_seq *lseq = seq;
24962 : 1830 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3053;
24963 : 1830 : {
24964 : 1830 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
24965 : 1830 : res_op->ops[0] = captures[0];
24966 : 1830 : res_op->resimplify (lseq, valueize);
24967 : 1830 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1277, __FILE__, __LINE__, true);
24968 : 1830 : return true;
24969 : : }
24970 : 0 : next_after_fail3053:;
24971 : : }
24972 : : }
24973 : : }
24974 : 1034452 : {
24975 : 1034452 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
24976 : 1034452 : if (TREE_CODE (TREE_TYPE (captures[0])) == COMPLEX_TYPE
24977 : 1034452 : && tree_int_cst_equal (captures[1], TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))))
24978 : : )
24979 : : {
24980 : 201 : if (integer_zerop (captures[2])
24981 : : )
24982 : : {
24983 : 102 : gimple_seq *lseq = seq;
24984 : 102 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3054;
24985 : 102 : {
24986 : 102 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
24987 : 102 : {
24988 : 102 : tree _o1[1], _r1;
24989 : 102 : _o1[0] = captures[0];
24990 : 102 : (*res_op).set_op (REALPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), 1);
24991 : 102 : (*res_op).ops[0] = _o1[0];
24992 : 102 : (*res_op).resimplify (lseq, valueize);
24993 : : }
24994 : 102 : if (type != res_op->type
24995 : 102 : && !useless_type_conversion_p (type, res_op->type))
24996 : : {
24997 : 4 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail3054;
24998 : 2 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
24999 : 2 : res_op->resimplify (lseq, valueize);
25000 : : }
25001 : 100 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1278, __FILE__, __LINE__, true);
25002 : 100 : return true;
25003 : : }
25004 : 1032284 : next_after_fail3054:;
25005 : : }
25006 : : else
25007 : : {
25008 : 99 : if (tree_int_cst_equal (captures[2], TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0]))))
25009 : : )
25010 : : {
25011 : 97 : gimple_seq *lseq = seq;
25012 : 97 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3055;
25013 : 97 : {
25014 : 97 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25015 : 97 : {
25016 : 97 : tree _o1[1], _r1;
25017 : 97 : _o1[0] = captures[0];
25018 : 97 : (*res_op).set_op (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (_o1[0])), 1);
25019 : 97 : (*res_op).ops[0] = _o1[0];
25020 : 97 : (*res_op).resimplify (lseq, valueize);
25021 : : }
25022 : 97 : if (type != res_op->type
25023 : 97 : && !useless_type_conversion_p (type, res_op->type))
25024 : : {
25025 : 4 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail3055;
25026 : 2 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25027 : 2 : res_op->resimplify (lseq, valueize);
25028 : : }
25029 : 95 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1279, __FILE__, __LINE__, true);
25030 : 95 : return true;
25031 : : }
25032 : 1032284 : next_after_fail3055:;
25033 : : }
25034 : : }
25035 : : }
25036 : : else
25037 : : {
25038 : 2068394 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[0]))
25039 : 36234 : && INTEGRAL_TYPE_P (type)
25040 : 34266 : && (!
25041 : : 1
25042 : 34266 : || is_gimple_reg (captures[0]))
25043 : 1068517 : && ((compare_tree_int (captures[1], TYPE_PRECISION (TREE_TYPE (captures[0]))) == 0
25044 : 0 : && integer_zerop (captures[2]))
25045 : : || (BYTES_BIG_ENDIAN == WORDS_BIG_ENDIAN
25046 : : && canonicalize_math_after_vectorization_p ()
25047 : 6483 : && TYPE_PRECISION (TREE_TYPE (captures[0])) % BITS_PER_UNIT == 0
25048 : 6483 : && TYPE_PRECISION (type) % BITS_PER_UNIT == 0
25049 : 6165 : && compare_tree_int (captures[2], (BYTES_BIG_ENDIAN
25050 : : ? (TYPE_PRECISION (TREE_TYPE (captures[0]))
25051 : : - TYPE_PRECISION (type))
25052 : : : 0)) == 0))
25053 : : )
25054 : : {
25055 : 1973 : gimple_seq *lseq = seq;
25056 : 1973 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3056;
25057 : 1973 : {
25058 : 1973 : res_op->set_op (NOP_EXPR, type, 1);
25059 : 1973 : res_op->ops[0] = captures[0];
25060 : 1973 : res_op->resimplify (lseq, valueize);
25061 : 1973 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1280, __FILE__, __LINE__, true);
25062 : 1973 : return true;
25063 : : }
25064 : 0 : next_after_fail3056:;
25065 : : }
25066 : : }
25067 : : }
25068 : 1032284 : switch (TREE_CODE (_p0))
25069 : : {
25070 : 1032218 : case SSA_NAME:
25071 : 1032218 : if (gimple *_d1 = get_def (valueize, _p0))
25072 : : {
25073 : 679410 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
25074 : 826592 : switch (gimple_assign_rhs_code (_a1))
25075 : : {
25076 : 24774 : case CONSTRUCTOR:
25077 : 24774 : {
25078 : 24774 : {
25079 : 24774 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _p2 };
25080 : 24774 : if (VECTOR_TYPE_P (TREE_TYPE (captures[0]))
25081 : 24774 : && tree_fits_uhwi_p (TYPE_SIZE (type))
25082 : 49548 : && ((tree_to_uhwi (TYPE_SIZE (type))
25083 : 24774 : == tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))))
25084 : 7086 : || (VECTOR_TYPE_P (type)
25085 : 4458 : && (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type)))
25086 : 4458 : == tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (captures[0])))))))
25087 : : )
25088 : : {
25089 : 20951 : {
25090 : 20951 : tree ctor = (TREE_CODE (captures[0]) == SSA_NAME
25091 : 20951 : ? gimple_assign_rhs1 (SSA_NAME_DEF_STMT (captures[0])) : captures[0]);
25092 : 20951 : tree eltype = TREE_TYPE (TREE_TYPE (ctor));
25093 : 20951 : unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
25094 : 20951 : unsigned HOST_WIDE_INT n = tree_to_uhwi (captures[1]);
25095 : 20951 : unsigned HOST_WIDE_INT idx = tree_to_uhwi (captures[2]);
25096 : 20951 : if (n != 0
25097 : 20951 : && (idx % width) == 0
25098 : 20951 : && (n % width) == 0
25099 : 41902 : && known_le ((idx + n) / width,
25100 : : TYPE_VECTOR_SUBPARTS (TREE_TYPE (ctor)))
25101 : : )
25102 : : {
25103 : 20951 : {
25104 : 20951 : idx = idx / width;
25105 : 20951 : n = n / width;
25106 : 20951 : poly_uint64 k = 1;
25107 : 20951 : if (CONSTRUCTOR_NELTS (ctor) != 0)
25108 : : {
25109 : 20951 : tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (ctor, 0)->value);
25110 : 20951 : if (TREE_CODE (cons_elem) == VECTOR_TYPE)
25111 : 4423 : k = TYPE_VECTOR_SUBPARTS (cons_elem);
25112 : : }
25113 : 20951 : unsigned HOST_WIDE_INT elt, count, const_k;
25114 : 20951 : if (multiple_p (idx, k, &elt) && multiple_p (n, k, &count)
25115 : : )
25116 : : {
25117 : 17708 : if (CONSTRUCTOR_NELTS (ctor) == 0
25118 : : )
25119 : : {
25120 : 0 : gimple_seq *lseq = seq;
25121 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3057;
25122 : 0 : {
25123 : 0 : tree tem;
25124 : 0 : tem = build_zero_cst (type);
25125 : 0 : res_op->set_value (tem);
25126 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1281, __FILE__, __LINE__, true);
25127 : 18756 : return true;
25128 : : }
25129 : 0 : next_after_fail3057:;
25130 : : }
25131 : : else
25132 : : {
25133 : 17708 : if (count == 1
25134 : : )
25135 : : {
25136 : 15507 : if (elt < CONSTRUCTOR_NELTS (ctor)
25137 : : )
25138 : : {
25139 : 15313 : gimple_seq *lseq = seq;
25140 : 15313 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3058;
25141 : 15313 : {
25142 : 15313 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25143 : 15313 : res_op->ops[0] = CONSTRUCTOR_ELT (ctor, elt)->value;
25144 : 15313 : res_op->resimplify (lseq, valueize);
25145 : 15313 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1282, __FILE__, __LINE__, true);
25146 : 15313 : return true;
25147 : : }
25148 : 0 : next_after_fail3058:;
25149 : : }
25150 : : else
25151 : : {
25152 : 194 : gimple_seq *lseq = seq;
25153 : 194 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3059;
25154 : 194 : {
25155 : 194 : tree tem;
25156 : 194 : tem = build_zero_cst (type);
25157 : 194 : res_op->set_value (tem);
25158 : 194 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1283, __FILE__, __LINE__, true);
25159 : 194 : return true;
25160 : : }
25161 : 0 : next_after_fail3059:;
25162 : : }
25163 : : }
25164 : : else
25165 : : {
25166 : 2201 : if (single_use (captures[0])
25167 : : )
25168 : : {
25169 : 366 : {
25170 : 366 : vec<constructor_elt, va_gc> *vals;
25171 : 366 : vec_alloc (vals, count);
25172 : 366 : bool constant_p = true;
25173 : 366 : tree res;
25174 : 2099 : for (unsigned i = 0;
25175 : 2099 : i < count && elt + i < CONSTRUCTOR_NELTS (ctor); ++i)
25176 : : {
25177 : 1733 : tree e = CONSTRUCTOR_ELT (ctor, elt + i)->value;
25178 : 1733 : CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE, e);
25179 : 1733 : if (!CONSTANT_CLASS_P (e))
25180 : 1257 : constant_p = false;
25181 : : }
25182 : 366 : tree evtype = (types_match (TREE_TYPE (type),
25183 : 366 : TREE_TYPE (TREE_TYPE (ctor)))
25184 : 366 : ? type
25185 : 1 : : build_vector_type (TREE_TYPE (TREE_TYPE (ctor)),
25186 : 1 : count * k));
25187 : 366 : res = (constant_p ? build_vector_from_ctor (evtype, vals)
25188 : : : (
25189 : : 1
25190 : : ? NULL_TREE : build_constructor (evtype, vals)));
25191 : 6 : if (res
25192 : : )
25193 : : {
25194 : 6 : gimple_seq *lseq = seq;
25195 : 6 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3060;
25196 : 6 : {
25197 : 6 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25198 : 6 : res_op->ops[0] = res;
25199 : 6 : res_op->resimplify (lseq, valueize);
25200 : 6 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1284, __FILE__, __LINE__, true);
25201 : 6 : return true;
25202 : : }
25203 : 0 : next_after_fail3060:;
25204 : : }
25205 : : }
25206 : : }
25207 : : }
25208 : : }
25209 : : }
25210 : : else
25211 : : {
25212 : 3243 : if (k.is_constant (&const_k)
25213 : 3243 : && idx + n <= (idx / const_k + 1) * const_k
25214 : : )
25215 : : {
25216 : 3243 : if (CONSTRUCTOR_NELTS (ctor) <= idx / const_k
25217 : : )
25218 : : {
25219 : 0 : gimple_seq *lseq = seq;
25220 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3061;
25221 : 0 : {
25222 : 0 : tree tem;
25223 : 0 : tem = build_zero_cst (type);
25224 : 0 : res_op->set_value (tem);
25225 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1285, __FILE__, __LINE__, true);
25226 : 0 : return true;
25227 : : }
25228 : 0 : next_after_fail3061:;
25229 : : }
25230 : : else
25231 : : {
25232 : 3243 : if (n == const_k
25233 : : )
25234 : : {
25235 : 0 : gimple_seq *lseq = seq;
25236 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3062;
25237 : 0 : {
25238 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25239 : 0 : res_op->ops[0] = CONSTRUCTOR_ELT (ctor, idx / const_k)->value;
25240 : 0 : res_op->resimplify (lseq, valueize);
25241 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1286, __FILE__, __LINE__, true);
25242 : 0 : return true;
25243 : : }
25244 : 0 : next_after_fail3062:;
25245 : : }
25246 : : else
25247 : : {
25248 : 3243 : gimple_seq *lseq = seq;
25249 : 3243 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3063;
25250 : 3243 : {
25251 : 3243 : res_op->set_op (BIT_FIELD_REF, type, 3);
25252 : 3243 : res_op->ops[0] = CONSTRUCTOR_ELT (ctor, idx / const_k)->value;
25253 : 3243 : res_op->ops[1] = captures[1];
25254 : 3243 : res_op->ops[2] = bitsize_int ((idx % const_k) * width);
25255 : 3243 : res_op->resimplify (lseq, valueize);
25256 : 3243 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1287, __FILE__, __LINE__, true);
25257 : 3243 : return true;
25258 : : }
25259 : 0 : next_after_fail3063:;
25260 : : }
25261 : : }
25262 : : }
25263 : : }
25264 : : }
25265 : : }
25266 : : }
25267 : : }
25268 : : }
25269 : 6018 : break;
25270 : : }
25271 : 41037 : case VEC_PERM_EXPR:
25272 : 41037 : {
25273 : 41037 : tree _q20 = gimple_assign_rhs1 (_a1);
25274 : 41037 : _q20 = do_valueize (valueize, _q20);
25275 : 41037 : tree _q21 = gimple_assign_rhs2 (_a1);
25276 : 41037 : _q21 = do_valueize (valueize, _q21);
25277 : 41037 : tree _q22 = gimple_assign_rhs3 (_a1);
25278 : 41037 : _q22 = do_valueize (valueize, _q22);
25279 : 41037 : switch (TREE_CODE (_q22))
25280 : : {
25281 : 41037 : case VECTOR_CST:
25282 : 41037 : {
25283 : 41037 : {
25284 : 41037 : tree captures[6] ATTRIBUTE_UNUSED = { _p0, _q20, _q21, _q22, _p1, _p2 };
25285 : 41037 : {
25286 : 41037 : tree elem_type = TREE_TYPE (TREE_TYPE (captures[0]));
25287 : 41037 : poly_uint64 elem_size = tree_to_poly_uint64 (TYPE_SIZE (elem_type));
25288 : 41037 : poly_uint64 size = tree_to_poly_uint64 (TYPE_SIZE (type));
25289 : 41037 : unsigned HOST_WIDE_INT nelts, idx;
25290 : 41037 : unsigned HOST_WIDE_INT nelts_op = 0;
25291 : 41037 : if (constant_multiple_p (tree_to_poly_uint64 (captures[5]), elem_size, &idx)
25292 : 41037 : && VECTOR_CST_NELTS (captures[3]).is_constant (&nelts)
25293 : 41037 : && (known_eq (size, elem_size)
25294 : 28175 : || (constant_multiple_p (size, elem_size, &nelts_op)
25295 : 28175 : && pow2p_hwi (nelts_op)))
25296 : : )
25297 : : {
25298 : 41037 : {
25299 : 41037 : bool ok = true;
25300 : 41037 : if (known_eq (size, elem_size))
25301 : 12862 : idx = TREE_INT_CST_LOW (VECTOR_CST_ELT (captures[3], idx)) % (2 * nelts);
25302 : : else
25303 : : {
25304 : 28175 : unsigned start
25305 : 28175 : = TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx)) % (2 * nelts);
25306 : 28175 : unsigned end
25307 : 28175 : = (TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + nelts_op - 1))
25308 : 28175 : % (2 * nelts));
25309 : 28175 : if ((start < nelts) != (end < nelts))
25310 : : ok = false;
25311 : : else
25312 : 723 : for (unsigned HOST_WIDE_INT i = 1; i != nelts_op; i++)
25313 : : {
25314 : 551 : if ((TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + i))
25315 : 551 : % (2 * nelts) - 1)
25316 : 551 : != (TREE_INT_CST_LOW (vector_cst_elt (captures[3], idx + i - 1))
25317 : 551 : % (2 * nelts)))
25318 : : {
25319 : : ok = false;
25320 : : break;
25321 : : }
25322 : : }
25323 : 28175 : if (start % nelts_op)
25324 : : ok = false;
25325 : 14821 : idx = start;
25326 : : }
25327 : 27683 : if (ok
25328 : : )
25329 : : {
25330 : 13023 : if (idx < nelts
25331 : : )
25332 : : {
25333 : 10589 : gimple_seq *lseq = seq;
25334 : 10589 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3064;
25335 : 10589 : {
25336 : 10589 : res_op->set_op (BIT_FIELD_REF, type, 3);
25337 : 10589 : res_op->ops[0] = captures[1];
25338 : 10589 : res_op->ops[1] = captures[4];
25339 : 10589 : res_op->ops[2] = bitsize_int (idx * elem_size);
25340 : 10589 : res_op->resimplify (lseq, valueize);
25341 : 10589 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1288, __FILE__, __LINE__, true);
25342 : 13023 : return true;
25343 : : }
25344 : 0 : next_after_fail3064:;
25345 : : }
25346 : : else
25347 : : {
25348 : 2434 : gimple_seq *lseq = seq;
25349 : 2434 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3065;
25350 : 2434 : {
25351 : 2434 : res_op->set_op (BIT_FIELD_REF, type, 3);
25352 : 2434 : res_op->ops[0] = captures[2];
25353 : 2434 : res_op->ops[1] = captures[4];
25354 : 2434 : res_op->ops[2] = bitsize_int ((idx - nelts) * elem_size);
25355 : 2434 : res_op->resimplify (lseq, valueize);
25356 : 2434 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1289, __FILE__, __LINE__, true);
25357 : 2434 : return true;
25358 : : }
25359 : 0 : next_after_fail3065:;
25360 : : }
25361 : : }
25362 : : }
25363 : : }
25364 : : }
25365 : : }
25366 : 28014 : break;
25367 : : }
25368 : : default:;
25369 : : }
25370 : : break;
25371 : : }
25372 : 1406 : case BIT_INSERT_EXPR:
25373 : 1406 : {
25374 : 1406 : tree _q20 = gimple_assign_rhs1 (_a1);
25375 : 1406 : _q20 = do_valueize (valueize, _q20);
25376 : 1406 : tree _q21 = gimple_assign_rhs2 (_a1);
25377 : 1406 : _q21 = do_valueize (valueize, _q21);
25378 : 1406 : tree _q22 = gimple_assign_rhs3 (_a1);
25379 : 1406 : _q22 = do_valueize (valueize, _q22);
25380 : 1406 : {
25381 : 1406 : tree captures[5] ATTRIBUTE_UNUSED = { _q20, _q21, _q22, _p1, _p2 };
25382 : 1406 : {
25383 : 1406 : unsigned HOST_WIDE_INT isize;
25384 : 1406 : if (INTEGRAL_TYPE_P (TREE_TYPE (captures[1])))
25385 : 1316 : isize = TYPE_PRECISION (TREE_TYPE (captures[1]));
25386 : : else
25387 : 90 : isize = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (captures[1])));
25388 : 2812 : if ((!INTEGRAL_TYPE_P (TREE_TYPE (captures[1]))
25389 : 1316 : || type_has_mode_precision_p (TREE_TYPE (captures[1])))
25390 : 1370 : && wi::leu_p (wi::to_wide (captures[2]), wi::to_wide (captures[4]))
25391 : 2098 : && wi::leu_p (wi::to_wide (captures[4]) + wi::to_wide (captures[3]),
25392 : 2098 : wi::to_wide (captures[2]) + isize)
25393 : : )
25394 : : {
25395 : 275 : gimple_seq *lseq = seq;
25396 : 275 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3066;
25397 : 275 : {
25398 : 275 : res_op->set_op (BIT_FIELD_REF, type, 3);
25399 : 275 : res_op->ops[0] = captures[1];
25400 : 275 : res_op->ops[1] = captures[3];
25401 : 275 : res_op->ops[2] = wide_int_to_tree (bitsizetype,
25402 : 275 : wi::to_wide (captures[4])
25403 : 550 : - wi::to_wide (captures[2]));
25404 : 275 : res_op->resimplify (lseq, valueize);
25405 : 275 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1290, __FILE__, __LINE__, true);
25406 : 1344 : return true;
25407 : : }
25408 : 0 : next_after_fail3066:;
25409 : : }
25410 : : else
25411 : : {
25412 : 1131 : if (wi::eq_p (wi::to_wide (captures[2]), wi::to_wide (captures[4]))
25413 : 1131 : && compare_tree_int (captures[3], isize) == 0
25414 : : )
25415 : : {
25416 : 5 : gimple_seq *lseq = seq;
25417 : 5 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3067;
25418 : 5 : {
25419 : 5 : res_op->set_op (NOP_EXPR, type, 1);
25420 : 5 : res_op->ops[0] = captures[1];
25421 : 5 : res_op->resimplify (lseq, valueize);
25422 : 5 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1291, __FILE__, __LINE__, true);
25423 : 5 : return true;
25424 : : }
25425 : 0 : next_after_fail3067:;
25426 : : }
25427 : : else
25428 : : {
25429 : 1126 : if (wi::geu_p (wi::to_wide (captures[2]),
25430 : 2252 : wi::to_wide (captures[4]) + wi::to_wide (captures[3]))
25431 : 1273 : || wi::geu_p (wi::to_wide (captures[4]),
25432 : 1273 : wi::to_wide (captures[2]) + isize)
25433 : : )
25434 : : {
25435 : 1064 : gimple_seq *lseq = seq;
25436 : 1064 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3068;
25437 : 1064 : {
25438 : 1064 : res_op->set_op (BIT_FIELD_REF, type, 3);
25439 : 1064 : res_op->ops[0] = captures[0];
25440 : 1064 : res_op->ops[1] = captures[3];
25441 : 1064 : res_op->ops[2] = captures[4];
25442 : 1064 : res_op->resimplify (lseq, valueize);
25443 : 1064 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1292, __FILE__, __LINE__, true);
25444 : 1064 : return true;
25445 : : }
25446 : 0 : next_after_fail3068:;
25447 : : }
25448 : : }
25449 : : }
25450 : : }
25451 : : }
25452 : 62 : break;
25453 : : }
25454 : : default:;
25455 : : }
25456 : : }
25457 : : break;
25458 : : default:;
25459 : : }
25460 : : return false;
25461 : : }
25462 : :
25463 : : bool
25464 : 1329 : gimple_simplify_CFN_FNMS (gimple_match_op *res_op, gimple_seq *seq,
25465 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
25466 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2)
25467 : : {
25468 : 1329 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
25469 : 1329 : switch (TREE_CODE (_p0))
25470 : : {
25471 : 1329 : case SSA_NAME:
25472 : 1329 : if (gimple *_d1 = get_def (valueize, _p0))
25473 : : {
25474 : 1310 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
25475 : 2141 : switch (gimple_assign_rhs_code (_a1))
25476 : : {
25477 : 16 : case NEGATE_EXPR:
25478 : 16 : {
25479 : 16 : tree _q20 = gimple_assign_rhs1 (_a1);
25480 : 16 : _q20 = do_valueize (valueize, _q20);
25481 : 16 : {
25482 : 16 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _p2 };
25483 : 16 : if (gimple_simplify_692 (res_op, seq, valueize, type, captures))
25484 : 16 : return true;
25485 : : }
25486 : 0 : switch (TREE_CODE (_p2))
25487 : : {
25488 : 0 : case SSA_NAME:
25489 : 0 : if (gimple *_d2 = get_def (valueize, _p2))
25490 : : {
25491 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
25492 : 0 : switch (gimple_assign_rhs_code (_a2))
25493 : : {
25494 : 0 : case NEGATE_EXPR:
25495 : 0 : {
25496 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
25497 : 0 : _q50 = do_valueize (valueize, _q50);
25498 : 0 : {
25499 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q20, _p1, _q50 };
25500 : 0 : if (gimple_simplify_693 (res_op, seq, valueize, type, captures))
25501 : 0 : return true;
25502 : : }
25503 : 0 : break;
25504 : : }
25505 : : default:;
25506 : : }
25507 : : }
25508 : : break;
25509 : : default:;
25510 : : }
25511 : : break;
25512 : : }
25513 : : default:;
25514 : : }
25515 : : }
25516 : : break;
25517 : 1313 : default:;
25518 : : }
25519 : 1313 : switch (TREE_CODE (_p1))
25520 : : {
25521 : 1313 : case SSA_NAME:
25522 : 1313 : if (gimple *_d1 = get_def (valueize, _p1))
25523 : : {
25524 : 1290 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
25525 : 2118 : switch (gimple_assign_rhs_code (_a1))
25526 : : {
25527 : 0 : case NEGATE_EXPR:
25528 : 0 : {
25529 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
25530 : 0 : _q30 = do_valueize (valueize, _q30);
25531 : 0 : {
25532 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _p2 };
25533 : 0 : if (gimple_simplify_692 (res_op, seq, valueize, type, captures))
25534 : 0 : return true;
25535 : : }
25536 : 0 : break;
25537 : : }
25538 : : default:;
25539 : : }
25540 : : }
25541 : : break;
25542 : 1313 : default:;
25543 : : }
25544 : 1313 : switch (TREE_CODE (_p2))
25545 : : {
25546 : 1313 : case SSA_NAME:
25547 : 1313 : if (gimple *_d1 = get_def (valueize, _p2))
25548 : : {
25549 : 1299 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
25550 : 2100 : switch (gimple_assign_rhs_code (_a1))
25551 : : {
25552 : 8 : case NEGATE_EXPR:
25553 : 8 : {
25554 : 8 : tree _q40 = gimple_assign_rhs1 (_a1);
25555 : 8 : _q40 = do_valueize (valueize, _q40);
25556 : 8 : {
25557 : 8 : tree captures[3] ATTRIBUTE_UNUSED = { _p0, _p1, _q40 };
25558 : 8 : if (canonicalize_math_after_vectorization_p ()
25559 : : )
25560 : : {
25561 : 8 : gimple_seq *lseq = seq;
25562 : 8 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3072;
25563 : 8 : {
25564 : 8 : res_op->set_op (CFN_FNMA, type, 3);
25565 : 8 : res_op->ops[0] = captures[0];
25566 : 8 : res_op->ops[1] = captures[1];
25567 : 8 : res_op->ops[2] = captures[2];
25568 : 8 : res_op->resimplify (lseq, valueize);
25569 : 8 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1296, __FILE__, __LINE__, true);
25570 : 8 : return true;
25571 : : }
25572 : 0 : next_after_fail3072:;
25573 : : }
25574 : : }
25575 : 0 : break;
25576 : : }
25577 : : default:;
25578 : : }
25579 : : }
25580 : : break;
25581 : 1305 : default:;
25582 : : }
25583 : 1305 : switch (TREE_CODE (_p1))
25584 : : {
25585 : 1305 : case SSA_NAME:
25586 : 1305 : if (gimple *_d1 = get_def (valueize, _p1))
25587 : : {
25588 : 1282 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
25589 : 2118 : switch (gimple_assign_rhs_code (_a1))
25590 : : {
25591 : 0 : case NEGATE_EXPR:
25592 : 0 : {
25593 : 0 : tree _q30 = gimple_assign_rhs1 (_a1);
25594 : 0 : _q30 = do_valueize (valueize, _q30);
25595 : 0 : switch (TREE_CODE (_p2))
25596 : : {
25597 : 0 : case SSA_NAME:
25598 : 0 : if (gimple *_d2 = get_def (valueize, _p2))
25599 : : {
25600 : 0 : if (gassign *_a2 = dyn_cast <gassign *> (_d2))
25601 : 0 : switch (gimple_assign_rhs_code (_a2))
25602 : : {
25603 : 0 : case NEGATE_EXPR:
25604 : 0 : {
25605 : 0 : tree _q50 = gimple_assign_rhs1 (_a2);
25606 : 0 : _q50 = do_valueize (valueize, _q50);
25607 : 0 : {
25608 : 0 : tree captures[3] ATTRIBUTE_UNUSED = { _q30, _p0, _q50 };
25609 : 0 : if (gimple_simplify_693 (res_op, seq, valueize, type, captures))
25610 : 0 : return true;
25611 : : }
25612 : 0 : break;
25613 : : }
25614 : : default:;
25615 : : }
25616 : : }
25617 : : break;
25618 : : default:;
25619 : : }
25620 : : break;
25621 : : }
25622 : : default:;
25623 : : }
25624 : : }
25625 : : break;
25626 : : default:;
25627 : : }
25628 : : return false;
25629 : : }
25630 : :
25631 : : bool
25632 : 7194535 : gimple_simplify (gimple_match_op *res_op, gimple_seq *seq,
25633 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
25634 : : code_helper code, const tree type, tree _p0, tree _p1, tree _p2)
25635 : : {
25636 : 7194535 : switch (code.get_rep())
25637 : : {
25638 : 1283447 : case COND_EXPR:
25639 : 1283447 : return gimple_simplify_COND_EXPR (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25640 : 197778 : case VEC_COND_EXPR:
25641 : 197778 : return gimple_simplify_VEC_COND_EXPR (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25642 : 1097820 : case BIT_FIELD_REF:
25643 : 1097820 : return gimple_simplify_BIT_FIELD_REF (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25644 : 14314 : case BIT_INSERT_EXPR:
25645 : 14314 : return gimple_simplify_BIT_INSERT_EXPR (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25646 : 2540 : case -CFN_BUILT_IN_FMAF:
25647 : 2540 : return gimple_simplify_CFN_BUILT_IN_FMAF (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25648 : 3066 : case -CFN_BUILT_IN_FMA:
25649 : 3066 : return gimple_simplify_CFN_BUILT_IN_FMA (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25650 : 1012 : case -CFN_BUILT_IN_FMAL:
25651 : 1012 : return gimple_simplify_CFN_BUILT_IN_FMAL (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25652 : 19486 : case -CFN_FMA:
25653 : 19486 : return gimple_simplify_CFN_FMA (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25654 : 2777 : case -CFN_FMS:
25655 : 2777 : return gimple_simplify_CFN_FMS (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25656 : 4292 : case -CFN_FNMA:
25657 : 4292 : return gimple_simplify_CFN_FNMA (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25658 : 1329 : case -CFN_FNMS:
25659 : 1329 : return gimple_simplify_CFN_FNMS (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25660 : 0 : case -CFN_VCOND_MASK_LEN:
25661 : 0 : return gimple_simplify_CFN_VCOND_MASK_LEN (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25662 : 773204 : case VEC_PERM_EXPR:
25663 : 773204 : return gimple_simplify_VEC_PERM_EXPR (res_op, seq, valueize, code, type, _p0, _p1, _p2);
25664 : : default:;
25665 : : }
25666 : : return false;
25667 : : }
25668 : :
25669 : : bool
25670 : 903 : gimple_simplify_CFN_COND_MUL (gimple_match_op *res_op, gimple_seq *seq,
25671 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
25672 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2, tree _p3)
25673 : : {
25674 : 903 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
25675 : 903 : switch (TREE_CODE (_p2))
25676 : : {
25677 : 869 : case SSA_NAME:
25678 : 869 : if (gimple *_d1 = get_def (valueize, _p2))
25679 : : {
25680 : 377 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
25681 : 28 : switch (gimple_call_combined_fn (_c1))
25682 : : {
25683 : 0 : case CFN_COPYSIGN:
25684 : 0 : if (gimple_call_num_args (_c1) == 2)
25685 : : {
25686 : 0 : tree _q40 = gimple_call_arg (_c1, 0);
25687 : 0 : _q40 = do_valueize (valueize, _q40);
25688 : 0 : tree _q41 = gimple_call_arg (_c1, 1);
25689 : 0 : _q41 = do_valueize (valueize, _q41);
25690 : 0 : if (real_onep (_q40))
25691 : : {
25692 : 0 : {
25693 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p1, _q41, _p3 };
25694 : 0 : {
25695 : 0 : tree signs = sign_mask_for (type);
25696 : 0 : if (signs
25697 : : )
25698 : : {
25699 : 0 : {
25700 : 0 : tree inttype = TREE_TYPE (signs);
25701 : 0 : gimple_seq *lseq = seq;
25702 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3086;
25703 : 0 : {
25704 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25705 : 0 : {
25706 : 0 : tree _o1[4], _r1;
25707 : 0 : _o1[0] = captures[0];
25708 : 0 : {
25709 : 0 : tree _o2[1], _r2;
25710 : 0 : _o2[0] = captures[1];
25711 : 0 : if (inttype != TREE_TYPE (_o2[0]) /* XXX */
25712 : 0 : && !useless_type_conversion_p (inttype, TREE_TYPE (_o2[0])))
25713 : : {
25714 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, inttype, _o2[0]);
25715 : 0 : tem_op.resimplify (lseq, valueize);
25716 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
25717 : 0 : if (!_r2) goto next_after_fail3086;
25718 : : }
25719 : : else
25720 : : _r2 = _o2[0];
25721 : 0 : _o1[1] = _r2;
25722 : : }
25723 : 0 : {
25724 : 0 : tree _o2[2], _r2;
25725 : 0 : {
25726 : 0 : tree _o3[1], _r3;
25727 : 0 : _o3[0] = captures[2];
25728 : 0 : if (inttype != TREE_TYPE (_o3[0]) /* XXX */
25729 : 0 : && !useless_type_conversion_p (inttype, TREE_TYPE (_o3[0])))
25730 : : {
25731 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, inttype, _o3[0]);
25732 : 0 : tem_op.resimplify (lseq, valueize);
25733 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
25734 : 0 : if (!_r3) goto next_after_fail3086;
25735 : : }
25736 : : else
25737 : : _r3 = _o3[0];
25738 : 0 : _o2[0] = _r3;
25739 : : }
25740 : 0 : _o2[1] = signs;
25741 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
25742 : 0 : tem_op.resimplify (lseq, valueize);
25743 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
25744 : 0 : if (!_r2) goto next_after_fail3086;
25745 : 0 : _o1[2] = _r2;
25746 : : }
25747 : 0 : {
25748 : 0 : tree _o2[1], _r2;
25749 : 0 : _o2[0] = captures[3];
25750 : 0 : if (inttype != TREE_TYPE (_o2[0]) /* XXX */
25751 : 0 : && !useless_type_conversion_p (inttype, TREE_TYPE (_o2[0])))
25752 : : {
25753 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, inttype, _o2[0]);
25754 : 0 : tem_op.resimplify (lseq, valueize);
25755 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
25756 : 0 : if (!_r2) goto next_after_fail3086;
25757 : : }
25758 : : else
25759 : : _r2 = _o2[0];
25760 : 0 : _o1[3] = _r2;
25761 : : }
25762 : 0 : (*res_op).set_op (CFN_COND_XOR, inttype, 4);
25763 : 0 : (*res_op).ops[0] = _o1[0];
25764 : 0 : (*res_op).ops[1] = _o1[1];
25765 : 0 : (*res_op).ops[2] = _o1[2];
25766 : 0 : (*res_op).ops[3] = _o1[3];
25767 : 0 : (*res_op).resimplify (lseq, valueize);
25768 : : }
25769 : 0 : if (type != res_op->type
25770 : 0 : && !useless_type_conversion_p (type, res_op->type))
25771 : : {
25772 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail3086;
25773 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25774 : 0 : res_op->resimplify (lseq, valueize);
25775 : : }
25776 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1309, __FILE__, __LINE__, true);
25777 : 0 : return true;
25778 : : }
25779 : 0 : next_after_fail3086:;
25780 : : }
25781 : : }
25782 : : }
25783 : : }
25784 : : }
25785 : : }
25786 : : break;
25787 : : default:;
25788 : : }
25789 : : }
25790 : : break;
25791 : 903 : default:;
25792 : : }
25793 : 903 : switch (TREE_CODE (_p1))
25794 : : {
25795 : 903 : case SSA_NAME:
25796 : 903 : if (gimple *_d1 = get_def (valueize, _p1))
25797 : : {
25798 : 398 : if (gcall *_c1 = dyn_cast <gcall *> (_d1))
25799 : 31 : switch (gimple_call_combined_fn (_c1))
25800 : : {
25801 : 0 : case CFN_COPYSIGN:
25802 : 0 : if (gimple_call_num_args (_c1) == 2)
25803 : : {
25804 : 0 : tree _q30 = gimple_call_arg (_c1, 0);
25805 : 0 : _q30 = do_valueize (valueize, _q30);
25806 : 0 : tree _q31 = gimple_call_arg (_c1, 1);
25807 : 0 : _q31 = do_valueize (valueize, _q31);
25808 : 0 : if (real_onep (_q30))
25809 : : {
25810 : 0 : {
25811 : 0 : tree captures[4] ATTRIBUTE_UNUSED = { _p0, _p2, _q31, _p3 };
25812 : 0 : {
25813 : 0 : tree signs = sign_mask_for (type);
25814 : 0 : if (signs
25815 : : )
25816 : : {
25817 : 0 : {
25818 : 0 : tree inttype = TREE_TYPE (signs);
25819 : 0 : gimple_seq *lseq = seq;
25820 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3087;
25821 : 0 : {
25822 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25823 : 0 : {
25824 : 0 : tree _o1[4], _r1;
25825 : 0 : _o1[0] = captures[0];
25826 : 0 : {
25827 : 0 : tree _o2[1], _r2;
25828 : 0 : _o2[0] = captures[1];
25829 : 0 : if (inttype != TREE_TYPE (_o2[0]) /* XXX */
25830 : 0 : && !useless_type_conversion_p (inttype, TREE_TYPE (_o2[0])))
25831 : : {
25832 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, inttype, _o2[0]);
25833 : 0 : tem_op.resimplify (lseq, valueize);
25834 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
25835 : 0 : if (!_r2) goto next_after_fail3087;
25836 : : }
25837 : : else
25838 : : _r2 = _o2[0];
25839 : 0 : _o1[1] = _r2;
25840 : : }
25841 : 0 : {
25842 : 0 : tree _o2[2], _r2;
25843 : 0 : {
25844 : 0 : tree _o3[1], _r3;
25845 : 0 : _o3[0] = captures[2];
25846 : 0 : if (inttype != TREE_TYPE (_o3[0]) /* XXX */
25847 : 0 : && !useless_type_conversion_p (inttype, TREE_TYPE (_o3[0])))
25848 : : {
25849 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, inttype, _o3[0]);
25850 : 0 : tem_op.resimplify (lseq, valueize);
25851 : 0 : _r3 = maybe_push_res_to_seq (&tem_op, lseq);
25852 : 0 : if (!_r3) goto next_after_fail3087;
25853 : : }
25854 : : else
25855 : : _r3 = _o3[0];
25856 : 0 : _o2[0] = _r3;
25857 : : }
25858 : 0 : _o2[1] = signs;
25859 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), BIT_AND_EXPR, TREE_TYPE (_o2[0]), _o2[0], _o2[1]);
25860 : 0 : tem_op.resimplify (lseq, valueize);
25861 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
25862 : 0 : if (!_r2) goto next_after_fail3087;
25863 : 0 : _o1[2] = _r2;
25864 : : }
25865 : 0 : {
25866 : 0 : tree _o2[1], _r2;
25867 : 0 : _o2[0] = captures[3];
25868 : 0 : if (inttype != TREE_TYPE (_o2[0]) /* XXX */
25869 : 0 : && !useless_type_conversion_p (inttype, TREE_TYPE (_o2[0])))
25870 : : {
25871 : 0 : gimple_match_op tem_op (res_op->cond.any_else (), VIEW_CONVERT_EXPR, inttype, _o2[0]);
25872 : 0 : tem_op.resimplify (lseq, valueize);
25873 : 0 : _r2 = maybe_push_res_to_seq (&tem_op, lseq);
25874 : 0 : if (!_r2) goto next_after_fail3087;
25875 : : }
25876 : : else
25877 : : _r2 = _o2[0];
25878 : 0 : _o1[3] = _r2;
25879 : : }
25880 : 0 : (*res_op).set_op (CFN_COND_XOR, inttype, 4);
25881 : 0 : (*res_op).ops[0] = _o1[0];
25882 : 0 : (*res_op).ops[1] = _o1[1];
25883 : 0 : (*res_op).ops[2] = _o1[2];
25884 : 0 : (*res_op).ops[3] = _o1[3];
25885 : 0 : (*res_op).resimplify (lseq, valueize);
25886 : : }
25887 : 0 : if (type != res_op->type
25888 : 0 : && !useless_type_conversion_p (type, res_op->type))
25889 : : {
25890 : 0 : if (!(res_op->ops[0] = maybe_push_res_to_seq (res_op, lseq))) goto next_after_fail3087;
25891 : 0 : res_op->set_op (VIEW_CONVERT_EXPR, type, 1);
25892 : 0 : res_op->resimplify (lseq, valueize);
25893 : : }
25894 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1309, __FILE__, __LINE__, true);
25895 : 0 : return true;
25896 : : }
25897 : 0 : next_after_fail3087:;
25898 : : }
25899 : : }
25900 : : }
25901 : : }
25902 : : }
25903 : : }
25904 : : break;
25905 : : default:;
25906 : : }
25907 : : }
25908 : : break;
25909 : : default:;
25910 : : }
25911 : : return false;
25912 : : }
25913 : :
25914 : : bool
25915 : 24696 : gimple_simplify (gimple_match_op *res_op, gimple_seq *seq,
25916 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
25917 : : code_helper code, const tree type, tree _p0, tree _p1, tree _p2, tree _p3, tree _p4)
25918 : : {
25919 : 24696 : switch (code.get_rep())
25920 : : {
25921 : 0 : case -CFN_VCOND_MASK_LEN:
25922 : 0 : return gimple_simplify_CFN_VCOND_MASK_LEN (res_op, seq, valueize, code, type, _p0, _p1, _p2, _p3, _p4);
25923 : : default:;
25924 : : }
25925 : : return false;
25926 : : }
25927 : :
25928 : : bool
25929 : 0 : gimple_simplify_CFN_COND_LEN_ADD (gimple_match_op *res_op, gimple_seq *seq,
25930 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
25931 : : code_helper ARG_UNUSED (code), tree ARG_UNUSED (type), tree _p0, tree _p1, tree _p2, tree _p3, tree _p4, tree _p5)
25932 : : {
25933 : 0 : const bool debug_dump = dump_file && (dump_flags & TDF_FOLDING);
25934 : 0 : if (integer_truep (_p0))
25935 : : {
25936 : 0 : switch (TREE_CODE (_p2))
25937 : : {
25938 : 0 : case SSA_NAME:
25939 : 0 : if (gimple *_d1 = get_def (valueize, _p2))
25940 : : {
25941 : 0 : if (gassign *_a1 = dyn_cast <gassign *> (_d1))
25942 : 0 : switch (gimple_assign_rhs_code (_a1))
25943 : : {
25944 : 0 : case VEC_COND_EXPR:
25945 : 0 : {
25946 : 0 : tree _q40 = gimple_assign_rhs1 (_a1);
25947 : 0 : _q40 = do_valueize (valueize, _q40);
25948 : 0 : tree _q41 = gimple_assign_rhs2 (_a1);
25949 : 0 : _q41 = do_valueize (valueize, _q41);
25950 : 0 : tree _q42 = gimple_assign_rhs3 (_a1);
25951 : 0 : _q42 = do_valueize (valueize, _q42);
25952 : 0 : if (zerop (_q42))
25953 : : {
25954 : 0 : if ((_p3 == _p1 && ! TREE_SIDE_EFFECTS (_p3)) || (operand_equal_p (_p3, _p1, 0) && types_match (_p3, _p1)))
25955 : : {
25956 : 0 : {
25957 : 0 : tree captures[6] ATTRIBUTE_UNUSED = { _p1, _q40, _q41, _q42, _p4, _p5 };
25958 : 0 : if (ANY_INTEGRAL_TYPE_P (type)
25959 : 0 : || (FLOAT_TYPE_P (type)
25960 : 0 : && fold_real_zero_addition_p (type, NULL_TREE, captures[3], 0))
25961 : : )
25962 : : {
25963 : 0 : gimple_seq *lseq = seq;
25964 : 0 : if (UNLIKELY (!dbg_cnt (match))) goto next_after_fail3161;
25965 : 0 : {
25966 : 0 : res_op->set_op (CFN_COND_LEN_ADD, type, 6);
25967 : 0 : res_op->ops[0] = captures[1];
25968 : 0 : res_op->ops[1] = captures[0];
25969 : 0 : res_op->ops[2] = captures[2];
25970 : 0 : res_op->ops[3] = captures[0];
25971 : 0 : res_op->ops[4] = captures[4];
25972 : 0 : res_op->ops[5] = captures[5];
25973 : 0 : res_op->resimplify (lseq, valueize);
25974 : 0 : if (UNLIKELY (debug_dump)) gimple_dump_logs ("match.pd", 1315, __FILE__, __LINE__, true);
25975 : 0 : return true;
25976 : : }
25977 : 0 : next_after_fail3161:;
25978 : : }
25979 : : }
25980 : : }
25981 : : }
25982 : : break;
25983 : : }
25984 : : default:;
25985 : : }
25986 : : }
25987 : : break;
25988 : : default:;
25989 : : }
25990 : : }
25991 : : return false;
25992 : : }
25993 : :
25994 : : bool
25995 : 607639 : gimple_simplify (gimple_match_op *res_op, gimple_seq *seq,
25996 : : tree (*valueize)(tree) ATTRIBUTE_UNUSED,
25997 : : code_helper code, const tree type, tree _p0, tree _p1, tree _p2, tree _p3, tree _p4, tree _p5)
25998 : : {
25999 : 607639 : switch (code.get_rep())
26000 : : {
26001 : 0 : case -CFN_COND_LEN_ADD:
26002 : 0 : return gimple_simplify_CFN_COND_LEN_ADD (res_op, seq, valueize, code, type, _p0, _p1, _p2, _p3, _p4, _p5);
26003 : : default:;
26004 : : }
26005 : : return false;
26006 : : }
26007 : :
26008 : : bool
26009 : 81835 : gimple_simplify (gimple_match_op*, gimple_seq*,
26010 : : tree (*)(tree), code_helper,
26011 : : const tree, tree, tree, tree, tree, tree, tree, tree)
26012 : : {
26013 : 81835 : return false;
26014 : : }
26015 : : void
26016 : 5320 : gimple_dump_logs (const char *file1, int line1_id, const char *file2, int line2, bool simplify)
26017 : : {
26018 : 5320 : static int dbg_line_numbers[1316] = {
26019 : : /* 0 */ 161, 164, 173, 175, 178, 181, 183, 189, 197, 195,
26020 : : /* 10 */ 199, 201, 205, 961, 959, 2151, 2162, 2143, 2149, 2154,
26021 : : /* 20 */ 2159, 2388, 2392, 2394, 2396, 2398, 2400, 2402, 2404, 2431,
26022 : : /* 30 */ 2447, 2455, 2437, 3006, 3008, 3010, 3014, 3024, 3026, 3030,
26023 : : /* 40 */ 3241, 3251, 3262, 3267, 3272, 3305, 3310, 3276, 3280, 3284,
26024 : : /* 50 */ 3334, 3288, 3316, 3322, 3328, 3292, 3351, 3355, 3380, 3386,
26025 : : /* 60 */ 3408, 3392, 3421, 3360, 3364, 3374, 3368, 3425, 3440, 3467,
26026 : : /* 70 */ 3502, 3479, 3520, 3527, 3579, 3536, 3607, 3554, 3545, 3570,
26027 : : /* 80 */ 3564, 3590, 3620, 3629, 3638, 3647, 3657, 3691, 3701, 3704,
26028 : : /* 90 */ 3736, 3761, 3724, 6001, 6252, 6263, 6241, 6270, 6302, 6277,
26029 : : /* 100 */ 6289, 6309, 9300, 9321, 9345, 11498, 11501, 11506, 11721, 11728,
26030 : : /* 110 */ 11747, 11772, 11840, 11797, 11810, 11824, 11854, 11859, 2110, 9120,
26031 : : /* 120 */ 228, 1336, 1340, 1498, 1513, 1518, 1565, 1566, 1570, 1571,
26032 : : /* 130 */ 1629, 1634, 1727, 1851, 1941, 1861, 2005, 1871, 1876, 1999,
26033 : : /* 140 */ 1884, 2051, 1993, 2012, 2018, 2644, 2025, 2039, 2085, 2302,
26034 : : /* 150 */ 2369, 2380, 2383, 2415, 2521, 2553, 4794, 4807, 4817, 3083,
26035 : : /* 160 */ 3085, 5092, 4831, 4843, 7307, 7309, 7374, 7382, 10571, 10577,
26036 : : /* 170 */ 10973, 10975, 254, 281, 282, 493, 1330, 4758, 1810, 1815,
26037 : : /* 180 */ 1834, 1889, 1952, 4308, 4246, 4351, 4352, 4356, 4357, 4367,
26038 : : /* 190 */ 4371, 4375, 4390, 4393, 4397, 4323, 4326, 4331, 4464, 4478,
26039 : : /* 200 */ 4484, 4490, 4672, 4673, 4699, 4718, 4737, 5080, 5900, 7238,
26040 : : /* 210 */ 7323, 7325, 8748, 8823, 10426, 10474, 10488, 11525, 11947, 12013,
26041 : : /* 220 */ 943, 949, 1478, 1487, 1970, 1961, 1908, 2670, 4259, 4299,
26042 : : /* 230 */ 4304, 4305, 4313, 4314, 4317, 4334, 4409, 4412, 4416, 4498,
26043 : : /* 240 */ 4520, 4558, 4569, 4608, 4623, 5086, 7248, 8828, 10484, 11529,
26044 : : /* 250 */ 1464, 1473, 1503, 1508, 1550, 1535, 1542, 1592, 2047, 1597,
26045 : : /* 260 */ 1604, 1624, 1841, 1751, 1846, 1856, 1866, 1980, 2067, 2077,
26046 : : /* 270 */ 2079, 2321, 2329, 2334, 2339, 2355, 2345, 2346, 2504, 2533,
26047 : : /* 280 */ 2535, 2540, 2542, 2663, 3832, 3847, 3865, 4065, 4066, 4067,
26048 : : /* 290 */ 4075, 4083, 4092, 4101, 4133, 4134, 4139, 4140, 4145, 4150,
26049 : : /* 300 */ 4154, 4209, 4223, 3837, 3856, 3858, 3842, 6910, 6922, 6916,
26050 : : /* 310 */ 7911, 9697, 319, 320, 1300, 1295, 447, 455, 461, 467,
26051 : : /* 320 */ 499, 1275, 2135, 2136, 2173, 2679, 5239, 5585, 5886, 5893,
26052 : : /* 330 */ 5943, 5946, 5996, 8741, 9155, 8985, 8992, 9149, 9194, 9199,
26053 : : /* 340 */ 329, 906, 1347, 2925, 2420, 2658, 2473, 2697, 2707, 2746,
26054 : : /* 350 */ 2752, 2755, 2760, 2776, 2778, 2779, 2782, 2784, 2785, 2787,
26055 : : /* 360 */ 2789, 2791, 2793, 2795, 2797, 2811, 2812, 2846, 2931, 2956,
26056 : : /* 370 */ 2872, 2899, 2939, 2944, 2969, 2976, 3042, 4181, 5022, 5030,
26057 : : /* 380 */ 5033, 5039, 5042, 5069, 5377, 5378, 5412, 5416, 5545, 5385,
26058 : : /* 390 */ 5386, 5430, 5433, 5434, 5439, 5442, 5445, 5446, 5398, 5401,
26059 : : /* 400 */ 5618, 5622, 5627, 5911, 6063, 6067, 7334, 7350, 7352, 7364,
26060 : : /* 410 */ 7394, 7400, 7401, 7416, 7417, 7421, 7439, 7444, 7476, 7484,
26061 : : /* 420 */ 7494, 7503, 7507, 7513, 7520, 7536, 7540, 7544, 7551, 7552,
26062 : : /* 430 */ 7557, 7558, 7565, 7566, 7568, 7569, 7585, 7596, 7608, 7612,
26063 : : /* 440 */ 7614, 7619, 7622, 7625, 7633, 7695, 7696, 7700, 7701, 7708,
26064 : : /* 450 */ 7712, 7716, 7719, 7725, 7726, 7730, 7733, 7740, 7760, 7763,
26065 : : /* 460 */ 7766, 7769, 7818, 7821, 7825, 7832, 7838, 7846, 7855, 7856,
26066 : : /* 470 */ 7954, 7964, 8003, 8009, 8025, 8038, 8040, 8042, 8068, 8110,
26067 : : /* 480 */ 8089, 8090, 8097, 8099, 8115, 8121, 8126, 8135, 8141, 8147,
26068 : : /* 490 */ 8152, 8157, 8189, 8252, 8171, 8181, 8290, 8292, 8294, 8296,
26069 : : /* 500 */ 8298, 8300, 8304, 8306, 8329, 8352, 8464, 8471, 8472, 8480,
26070 : : /* 510 */ 8481, 8551, 8661, 9741, 9743, 9831, 9833, 9834, 9840, 9856,
26071 : : /* 520 */ 9858, 9860, 9878, 9879, 10211, 10214, 10228, 10237, 10301, 10302,
26072 : : /* 530 */ 10356, 10358, 10434, 10843, 10845, 10847, 11280, 1363, 7330, 7341,
26073 : : /* 540 */ 7343, 7451, 473, 1248, 1252, 1269, 9105, 9110, 9115, 533,
26074 : : /* 550 */ 534, 545, 550, 557, 566, 574, 583, 629, 632, 841,
26075 : : /* 560 */ 994, 1012, 1022, 1029, 1039, 1044, 1053, 1061, 1086, 1107,
26076 : : /* 570 */ 594, 871, 875, 880, 886, 890, 898, 986, 745, 755,
26077 : : /* 580 */ 757, 759, 8735, 9160, 9182, 9165, 9170, 9175, 9189, 9223,
26078 : : /* 590 */ 9228, 816, 5098, 3793, 5122, 5165, 5178, 5110, 5129, 5136,
26079 : : /* 600 */ 5142, 5148, 5154, 6481, 6656, 6658, 6660, 6760, 6763, 6787,
26080 : : /* 610 */ 6788, 6791, 6792, 6796, 6797, 6801, 6802, 6806, 6807, 6811,
26081 : : /* 620 */ 6812, 6937, 6939, 6953, 6957, 6980, 6986, 6580, 6581, 6870,
26082 : : /* 630 */ 6874, 6882, 6889, 6894, 7019, 7025, 7034, 7035, 7044, 7050,
26083 : : /* 640 */ 7057, 7113, 7118, 7179, 7182, 7126, 7131, 7189, 7192, 8235,
26084 : : /* 650 */ 8237, 7148, 7149, 7150, 7200, 8205, 8206, 8220, 8221, 7169,
26085 : : /* 660 */ 7170, 7171, 7212, 7213, 8266, 8271, 9714, 9715, 10631, 10639,
26086 : : /* 670 */ 10667, 10679, 10706, 10718, 828, 831, 1356, 1372, 1702, 2720,
26087 : : /* 680 */ 2723, 2820, 2832, 2914, 2858, 2885, 2997, 3000, 5060, 5052,
26088 : : /* 690 */ 7272, 8591, 7868, 7871, 7897, 7898, 8377, 8379, 8381, 8383,
26089 : : /* 700 */ 8387, 8389, 8391, 8393, 8397, 8402, 8409, 8414, 8434, 8436,
26090 : : /* 710 */ 8438, 8440, 8604, 8612, 8622, 8630, 8640, 8762, 8764, 9755,
26091 : : /* 720 */ 9774, 9814, 10279, 10281, 10282, 10337, 10340, 10342, 2736, 7262,
26092 : : /* 730 */ 7941, 8836, 8841, 10864, 10866, 10868, 10870, 10874, 932, 968,
26093 : : /* 740 */ 1320, 5226, 5198, 5268, 5271, 5279, 5293, 5346, 5348, 5349,
26094 : : /* 750 */ 5350, 5557, 2254, 5249, 5258, 6117, 6120, 6121, 6129, 10799,
26095 : : /* 760 */ 10817, 2313, 4192, 4197, 4964, 9371, 9385, 9401, 9412, 9580,
26096 : : /* 770 */ 9582, 9613, 9648, 11891, 1212, 9053, 9074, 1221, 8797, 8803,
26097 : : /* 780 */ 8955, 8956, 9100, 9527, 1235, 1239, 9095, 9278, 2180, 2194,
26098 : : /* 790 */ 2608, 4284, 2219, 2242, 2243, 10154, 1446, 1530, 1578, 1523,
26099 : : /* 800 */ 1555, 1586, 1619, 1660, 1671, 1682, 1694, 2565, 1766, 1923,
26100 : : /* 810 */ 1931, 1936, 2059, 2410, 2685, 3237, 5516, 5534, 5535, 6088,
26101 : : /* 820 */ 6094, 6142, 3802, 3804, 3814, 3816, 3923, 3924, 3925, 3933,
26102 : : /* 830 */ 3941, 3950, 3959, 3993, 3994, 3999, 4000, 4005, 4010, 4014,
26103 : : /* 840 */ 3822, 3827, 3872, 6491, 6500, 6501, 6907, 6919, 7466, 6913,
26104 : : /* 850 */ 7914, 9683, 9685, 10469, 1609, 1614, 2623, 1782, 2628, 5596,
26105 : : /* 860 */ 2603, 2634, 2638, 5610, 5007, 7299, 7301, 4850, 4854, 4864,
26106 : : /* 870 */ 4882, 4947, 4949, 4951, 4953, 5002, 9705, 4868, 4875, 4860,
26107 : : /* 880 */ 4974, 4983, 4986, 5185, 5318, 5328, 8690, 8693, 8712, 6039,
26108 : : /* 890 */ 6051, 6054, 6058, 6361, 6824, 6833, 11038, 11045, 11073, 11079,
26109 : : /* 900 */ 11087, 11093, 11102, 11108, 11116, 11122, 11168, 11176, 8496, 7459,
26110 : : /* 910 */ 7455, 8671, 8678, 8813, 8818, 8919, 9016, 9033, 9065, 9085,
26111 : : /* 920 */ 9090, 9341, 9318, 9297, 9126, 9130, 9421, 9431, 9438, 9447,
26112 : : /* 930 */ 9465, 9472, 9453, 9720, 9726, 10144, 10150, 10147, 10158, 10164,
26113 : : /* 940 */ 10172, 10178, 10186, 10192, 10246, 10408, 10410, 10412, 10449, 10464,
26114 : : /* 950 */ 10527, 10529, 10531, 10730, 10733, 10538, 10552, 10565, 10620, 10622,
26115 : : /* 960 */ 10624, 10831, 10918, 10920, 10922, 11056, 11063, 11249, 11264, 11355,
26116 : : /* 970 */ 11356, 12000, 219, 2091, 2101, 6174, 2119, 1162, 2576, 3218,
26117 : : /* 980 */ 5638, 5640, 5650, 5767, 5778, 5791, 5814, 5824, 5833, 5845,
26118 : : /* 990 */ 5871, 6182, 6588, 1169, 1263, 2189, 2225, 2231, 4271, 7225,
26119 : : /* 1000 */ 4279, 10168, 10182, 10196, 1281, 1288, 9079, 9273, 1779, 1793,
26120 : : /* 1010 */ 1800, 1822, 1829, 2425, 2651, 2096, 2114, 2123, 5655, 5665,
26121 : : /* 1020 */ 5674, 5701, 5711, 5717, 6191, 5858, 5726, 5723, 6009, 6017,
26122 : : /* 1030 */ 6025, 6029, 6012, 6020, 6033, 6045, 8912, 8887, 8848, 8852,
26123 : : /* 1040 */ 9236, 9001, 9252, 9240, 9244, 9005, 9256, 9248, 9287, 9478,
26124 : : /* 1050 */ 9485, 9491, 11271, 237, 1735, 1740, 2489, 2616, 4169, 4929,
26125 : : /* 1060 */ 6209, 6218, 6229, 6238, 11906, 727, 4449, 4777, 5958, 5964,
26126 : : /* 1070 */ 5966, 3090, 242, 3111, 3115, 3146, 3154, 3127, 3141, 260,
26127 : : /* 1080 */ 297, 1482, 1788, 1896, 1903, 1913, 1918, 2200, 3162, 3174,
26128 : : /* 1090 */ 3168, 3180, 2211, 2841, 2866, 2893, 2877, 2904, 4532, 4504,
26129 : : /* 1100 */ 4579, 4588, 4631, 4642, 5971, 5982, 11872, 11873, 12022, 1707,
26130 : : /* 1110 */ 1712, 1773, 7904, 11227, 11231, 247, 300, 2850, 3187, 3194,
26131 : : /* 1120 */ 3201, 3207, 4541, 3212, 4597, 4645, 4654, 5974, 304, 373,
26132 : : /* 1130 */ 341, 350, 358, 432, 646, 686, 1003, 1200, 1205, 1303,
26133 : : /* 1140 */ 1306, 1438, 2479, 5987, 8770, 8776, 8967, 9217, 2596, 6395,
26134 : : /* 1150 */ 6403, 7971, 8528, 8571, 8572, 2586, 8522, 1195, 609, 612,
26135 : : /* 1160 */ 1138, 1143, 5880, 736, 765, 771, 777, 785, 790, 795,
26136 : : /* 1170 */ 859, 863, 8782, 8788, 8446, 917, 1393, 5214, 1382, 1385,
26137 : : /* 1180 */ 1417, 1428, 5191, 5263, 5356, 1176, 9260, 9009, 9268, 9264,
26138 : : /* 1190 */ 9505, 9508, 9511, 9516, 9522, 1182, 9206, 1228, 8975, 9212,
26139 : : /* 1200 */ 9534, 9537, 9540, 1187, 1190, 1452, 1641, 1717, 1745, 1759,
26140 : : /* 1210 */ 2360, 5362, 5363, 7908, 11879, 4889, 4893, 4921, 4922, 4995,
26141 : : /* 1220 */ 4900, 4904, 4912, 4913, 5300, 6006, 8504, 8506, 8513, 8515,
26142 : : /* 1230 */ 7463, 9135, 12028, 6160, 6162, 6429, 6434, 6440, 6441, 6447,
26143 : : /* 1240 */ 6452, 6457, 6463, 6465, 6472, 6998, 7001, 7004, 7007, 7063,
26144 : : /* 1250 */ 7066, 7075, 7079, 7084, 7092, 8319, 8320, 6328, 6332, 6336,
26145 : : /* 1260 */ 6340, 6166, 6168, 6368, 6372, 6376, 6380, 6414, 6416, 6847,
26146 : : /* 1270 */ 6861, 10943, 10949, 11003, 11010, 9886, 9892, 9897, 9906, 9908,
26147 : : /* 1280 */ 9928, 9973, 9976, 9977, 10009, 10015, 10017, 10018, 10074, 10075,
26148 : : /* 1290 */ 10096, 10101, 10106, 10136, 10161, 10175, 10189, 11379, 11381, 11416,
26149 : : /* 1300 */ 11490, 11493, 11578, 11513, 11519, 11647, 11649, 11711, 11713, 483,
26150 : : /* 1310 */ 11137, 10958, 10964, 11020, 11027, 11152
26151 : : };
26152 : :
26153 : 10126 : fprintf (dump_file, "%s %s:%d, %s:%d\n",
26154 : : simplify ? "Applying pattern" : "Matching expression", file1, dbg_line_numbers[line1_id], file2, line2);
26155 : 5320 : }
26156 : :
26157 : : #pragma GCC diagnostic pop
|
