Warning: That file was not part of the compilation database. It may have many parsing errors.

1/* Preamble and helpers for the autogenerated gimple-match.c file.
2 Copyright (C) 2014-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "backend.h"
24#include "target.h"
25#include "rtl.h"
26#include "tree.h"
27#include "gimple.h"
28#include "ssa.h"
29#include "cgraph.h"
30#include "fold-const.h"
31#include "fold-const-call.h"
32#include "stor-layout.h"
33#include "gimple-fold.h"
34#include "calls.h"
35#include "tree-dfa.h"
36#include "builtins.h"
37#include "gimple-match.h"
38#include "tree-pass.h"
39#include "internal-fn.h"
40#include "case-cfn-macros.h"
41#include "gimplify.h"
42#include "optabs-tree.h"
43
44
45/* Forward declarations of the private auto-generated matchers.
46 They expect valueized operands in canonical order and do not
47 perform simplification of all-constant operands. */
48static bool gimple_simplify (code_helper *, tree *,
49 gimple_seq *, tree (*)(tree),
50 code_helper, tree, tree);
51static bool gimple_simplify (code_helper *, tree *,
52 gimple_seq *, tree (*)(tree),
53 code_helper, tree, tree, tree);
54static bool gimple_simplify (code_helper *, tree *,
55 gimple_seq *, tree (*)(tree),
56 code_helper, tree, tree, tree, tree);
57
58
59/* Return whether T is a constant that we'll dispatch to fold to
60 evaluate fully constant expressions. */
61
62static inline bool
63constant_for_folding (tree t)
64{
65 return (CONSTANT_CLASS_P (t)
66 /* The following is only interesting to string builtins. */
67 || (TREE_CODE (t) == ADDR_EXPR
68 && TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST));
69}
70
71
72/* Helper that matches and simplifies the toplevel result from
73 a gimple_simplify run (where we don't want to build
74 a stmt in case it's used in in-place folding). Replaces
75 *RES_CODE and *RES_OPS with a simplified and/or canonicalized
76 result and returns whether any change was made. */
77
78bool
79gimple_resimplify1 (gimple_seq *seq,
80 code_helper *res_code, tree type, tree *res_ops,
81 tree (*valueize)(tree))
82{
83 if (constant_for_folding (res_ops[0]))
84 {
85 tree tem = NULL_TREE;
86 if (res_code->is_tree_code ())
87 tem = const_unop (*res_code, type, res_ops[0]);
88 else
89 tem = fold_const_call (combined_fn (*res_code), type, res_ops[0]);
90 if (tem != NULL_TREE
91 && CONSTANT_CLASS_P (tem))
92 {
93 if (TREE_OVERFLOW_P (tem))
94 tem = drop_tree_overflow (tem);
95 res_ops[0] = tem;
96 res_ops[1] = NULL_TREE;
97 res_ops[2] = NULL_TREE;
98 *res_code = TREE_CODE (res_ops[0]);
99 return true;
100 }
101 }
102
103 code_helper res_code2;
104 tree res_ops2[3] = {};
105 if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
106 *res_code, type, res_ops[0]))
107 {
108 *res_code = res_code2;
109 res_ops[0] = res_ops2[0];
110 res_ops[1] = res_ops2[1];
111 res_ops[2] = res_ops2[2];
112 return true;
113 }
114
115 return false;
116}
117
118/* Helper that matches and simplifies the toplevel result from
119 a gimple_simplify run (where we don't want to build
120 a stmt in case it's used in in-place folding). Replaces
121 *RES_CODE and *RES_OPS with a simplified and/or canonicalized
122 result and returns whether any change was made. */
123
124bool
125gimple_resimplify2 (gimple_seq *seq,
126 code_helper *res_code, tree type, tree *res_ops,
127 tree (*valueize)(tree))
128{
129 if (constant_for_folding (res_ops[0]) && constant_for_folding (res_ops[1]))
130 {
131 tree tem = NULL_TREE;
132 if (res_code->is_tree_code ())
133 tem = const_binop (*res_code, type, res_ops[0], res_ops[1]);
134 else
135 tem = fold_const_call (combined_fn (*res_code), type,
136 res_ops[0], res_ops[1]);
137 if (tem != NULL_TREE
138 && CONSTANT_CLASS_P (tem))
139 {
140 if (TREE_OVERFLOW_P (tem))
141 tem = drop_tree_overflow (tem);
142 res_ops[0] = tem;
143 res_ops[1] = NULL_TREE;
144 res_ops[2] = NULL_TREE;
145 *res_code = TREE_CODE (res_ops[0]);
146 return true;
147 }
148 }
149
150 /* Canonicalize operand order. */
151 bool canonicalized = false;
152 if (res_code->is_tree_code ()
153 && (TREE_CODE_CLASS ((enum tree_code) *res_code) == tcc_comparison
154 || commutative_tree_code (*res_code))
155 && tree_swap_operands_p (res_ops[0], res_ops[1]))
156 {
157 std::swap (res_ops[0], res_ops[1]);
158 if (TREE_CODE_CLASS ((enum tree_code) *res_code) == tcc_comparison)
159 *res_code = swap_tree_comparison (*res_code);
160 canonicalized = true;
161 }
162
163 code_helper res_code2;
164 tree res_ops2[3] = {};
165 if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
166 *res_code, type, res_ops[0], res_ops[1]))
167 {
168 *res_code = res_code2;
169 res_ops[0] = res_ops2[0];
170 res_ops[1] = res_ops2[1];
171 res_ops[2] = res_ops2[2];
172 return true;
173 }
174
175 return canonicalized;
176}
177
178/* Helper that matches and simplifies the toplevel result from
179 a gimple_simplify run (where we don't want to build
180 a stmt in case it's used in in-place folding). Replaces
181 *RES_CODE and *RES_OPS with a simplified and/or canonicalized
182 result and returns whether any change was made. */
183
184bool
185gimple_resimplify3 (gimple_seq *seq,
186 code_helper *res_code, tree type, tree *res_ops,
187 tree (*valueize)(tree))
188{
189 if (constant_for_folding (res_ops[0]) && constant_for_folding (res_ops[1])
190 && constant_for_folding (res_ops[2]))
191 {
192 tree tem = NULL_TREE;
193 if (res_code->is_tree_code ())
194 tem = fold_ternary/*_to_constant*/ (*res_code, type, res_ops[0],
195 res_ops[1], res_ops[2]);
196 else
197 tem = fold_const_call (combined_fn (*res_code), type,
198 res_ops[0], res_ops[1], res_ops[2]);
199 if (tem != NULL_TREE
200 && CONSTANT_CLASS_P (tem))
201 {
202 if (TREE_OVERFLOW_P (tem))
203 tem = drop_tree_overflow (tem);
204 res_ops[0] = tem;
205 res_ops[1] = NULL_TREE;
206 res_ops[2] = NULL_TREE;
207 *res_code = TREE_CODE (res_ops[0]);
208 return true;
209 }
210 }
211
212 /* Canonicalize operand order. */
213 bool canonicalized = false;
214 if (res_code->is_tree_code ()
215 && commutative_ternary_tree_code (*res_code)
216 && tree_swap_operands_p (res_ops[0], res_ops[1]))
217 {
218 std::swap (res_ops[0], res_ops[1]);
219 canonicalized = true;
220 }
221
222 code_helper res_code2;
223 tree res_ops2[3] = {};
224 if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
225 *res_code, type,
226 res_ops[0], res_ops[1], res_ops[2]))
227 {
228 *res_code = res_code2;
229 res_ops[0] = res_ops2[0];
230 res_ops[1] = res_ops2[1];
231 res_ops[2] = res_ops2[2];
232 return true;
233 }
234
235 return canonicalized;
236}
237
238
239/* If in GIMPLE expressions with CODE go as single-rhs build
240 a GENERIC tree for that expression into *OP0. */
241
242void
243maybe_build_generic_op (enum tree_code code, tree type, tree *ops)
244{
245 switch (code)
246 {
247 case REALPART_EXPR:
248 case IMAGPART_EXPR:
249 case VIEW_CONVERT_EXPR:
250 ops[0] = build1 (code, type, ops[0]);
251 break;
252 case BIT_FIELD_REF:
253 ops[0] = build3 (code, type, ops[0], ops[1], ops[2]);
254 ops[1] = ops[2] = NULL_TREE;
255 break;
256 default:;
257 }
258}
259
260tree (*mprts_hook) (code_helper, tree, tree *);
261
262/* Try to build a call to FN with return type TYPE and the NARGS
263 arguments given in OPS. Return null if the target doesn't support
264 the function. */
265
266static gcall *
267build_call_internal (internal_fn fn, tree type, unsigned int nargs, tree *ops)
268{
269 if (direct_internal_fn_p (fn))
270 {
271 tree_pair types = direct_internal_fn_types (fn, type, ops);
272 if (!direct_internal_fn_supported_p (fn, types, OPTIMIZE_FOR_BOTH))
273 return NULL;
274 }
275 return gimple_build_call_internal (fn, nargs, ops[0], ops[1], ops[2]);
276}
277
278/* Push the exploded expression described by RCODE, TYPE and OPS
279 as a statement to SEQ if necessary and return a gimple value
280 denoting the value of the expression. If RES is not NULL
281 then the result will be always RES and even gimple values are
282 pushed to SEQ. */
283
284tree
285maybe_push_res_to_seq (code_helper rcode, tree type, tree *ops,
286 gimple_seq *seq, tree res)
287{
288 if (rcode.is_tree_code ())
289 {
290 if (!res
291 && gimple_simplified_result_is_gimple_val (rcode, ops))
292 return ops[0];
293 if (mprts_hook)
294 {
295 tree tem = mprts_hook (rcode, type, ops);
296 if (tem)
297 return tem;
298 }
299 if (!seq)
300 return NULL_TREE;
301 /* Play safe and do not allow abnormals to be mentioned in
302 newly created statements. */
303 if ((TREE_CODE (ops[0]) == SSA_NAME
304 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[0]))
305 || (ops[1]
306 && TREE_CODE (ops[1]) == SSA_NAME
307 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[1]))
308 || (ops[2]
309 && TREE_CODE (ops[2]) == SSA_NAME
310 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2]))
311 || (COMPARISON_CLASS_P (ops[0])
312 && ((TREE_CODE (TREE_OPERAND (ops[0], 0)) == SSA_NAME
313 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0],
314 0)))
315 || (TREE_CODE (TREE_OPERAND (ops[0], 1)) == SSA_NAME
316 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0],
317 1))))))
318 return NULL_TREE;
319 if (!res)
320 {
321 if (gimple_in_ssa_p (cfun))
322 res = make_ssa_name (type);
323 else
324 res = create_tmp_reg (type);
325 }
326 maybe_build_generic_op (rcode, type, ops);
327 gimple *new_stmt = gimple_build_assign (res, rcode,
328 ops[0], ops[1], ops[2]);
329 gimple_seq_add_stmt_without_update (seq, new_stmt);
330 return res;
331 }
332 else
333 {
334 if (!seq)
335 return NULL_TREE;
336 combined_fn fn = rcode;
337 /* Play safe and do not allow abnormals to be mentioned in
338 newly created statements. */
339 unsigned nargs;
340 for (nargs = 0; nargs < 3; ++nargs)
341 {
342 if (!ops[nargs])
343 break;
344 if (TREE_CODE (ops[nargs]) == SSA_NAME
345 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[nargs]))
346 return NULL_TREE;
347 }
348 gcc_assert (nargs != 0);
349 gcall *new_stmt = NULL;
350 if (internal_fn_p (fn))
351 {
352 /* Generate the given function if we can. */
353 internal_fn ifn = as_internal_fn (fn);
354 new_stmt = build_call_internal (ifn, type, nargs, ops);
355 if (!new_stmt)
356 return NULL_TREE;
357 }
358 else
359 {
360 /* Find the function we want to call. */
361 tree decl = builtin_decl_implicit (as_builtin_fn (fn));
362 if (!decl)
363 return NULL;
364
365 /* We can't and should not emit calls to non-const functions. */
366 if (!(flags_from_decl_or_type (decl) & ECF_CONST))
367 return NULL;
368
369 new_stmt = gimple_build_call (decl, nargs, ops[0], ops[1], ops[2]);
370 }
371 if (!res)
372 {
373 if (gimple_in_ssa_p (cfun))
374 res = make_ssa_name (type);
375 else
376 res = create_tmp_reg (type);
377 }
378 gimple_call_set_lhs (new_stmt, res);
379 gimple_seq_add_stmt_without_update (seq, new_stmt);
380 return res;
381 }
382}
383
384
385/* Public API overloads follow for operation being tree_code or
386 built_in_function and for one to three operands or arguments.
387 They return NULL_TREE if nothing could be simplified or
388 the resulting simplified value with parts pushed to SEQ.
389 If SEQ is NULL then if the simplification needs to create
390 new stmts it will fail. If VALUEIZE is non-NULL then all
391 SSA names will be valueized using that hook prior to
392 applying simplifications. */
393
394/* Unary ops. */
395
396tree
397gimple_simplify (enum tree_code code, tree type,
398 tree op0,
399 gimple_seq *seq, tree (*valueize)(tree))
400{
401 if (constant_for_folding (op0))
402 {
403 tree res = const_unop (code, type, op0);
404 if (res != NULL_TREE
405 && CONSTANT_CLASS_P (res))
406 return res;
407 }
408
409 code_helper rcode;
410 tree ops[3] = {};
411 if (!gimple_simplify (&rcode, ops, seq, valueize,
412 code, type, op0))
413 return NULL_TREE;
414 return maybe_push_res_to_seq (rcode, type, ops, seq);
415}
416
417/* Binary ops. */
418
419tree
420gimple_simplify (enum tree_code code, tree type,
421 tree op0, tree op1,
422 gimple_seq *seq, tree (*valueize)(tree))
423{
424 if (constant_for_folding (op0) && constant_for_folding (op1))
425 {
426 tree res = const_binop (code, type, op0, op1);
427 if (res != NULL_TREE
428 && CONSTANT_CLASS_P (res))
429 return res;
430 }
431
432 /* Canonicalize operand order both for matching and fallback stmt
433 generation. */
434 if ((commutative_tree_code (code)
435 || TREE_CODE_CLASS (code) == tcc_comparison)
436 && tree_swap_operands_p (op0, op1))
437 {
438 std::swap (op0, op1);
439 if (TREE_CODE_CLASS (code) == tcc_comparison)
440 code = swap_tree_comparison (code);
441 }
442
443 code_helper rcode;
444 tree ops[3] = {};
445 if (!gimple_simplify (&rcode, ops, seq, valueize,
446 code, type, op0, op1))
447 return NULL_TREE;
448 return maybe_push_res_to_seq (rcode, type, ops, seq);
449}
450
451/* Ternary ops. */
452
453tree
454gimple_simplify (enum tree_code code, tree type,
455 tree op0, tree op1, tree op2,
456 gimple_seq *seq, tree (*valueize)(tree))
457{
458 if (constant_for_folding (op0) && constant_for_folding (op1)
459 && constant_for_folding (op2))
460 {
461 tree res = fold_ternary/*_to_constant */ (code, type, op0, op1, op2);
462 if (res != NULL_TREE
463 && CONSTANT_CLASS_P (res))
464 return res;
465 }
466
467 /* Canonicalize operand order both for matching and fallback stmt
468 generation. */
469 if (commutative_ternary_tree_code (code)
470 && tree_swap_operands_p (op0, op1))
471 std::swap (op0, op1);
472
473 code_helper rcode;
474 tree ops[3] = {};
475 if (!gimple_simplify (&rcode, ops, seq, valueize,
476 code, type, op0, op1, op2))
477 return NULL_TREE;
478 return maybe_push_res_to_seq (rcode, type, ops, seq);
479}
480
481/* Builtin function with one argument. */
482
483tree
484gimple_simplify (enum built_in_function fn, tree type,
485 tree arg0,
486 gimple_seq *seq, tree (*valueize)(tree))
487{
488 if (constant_for_folding (arg0))
489 {
490 tree res = fold_const_call (as_combined_fn (fn), type, arg0);
491 if (res && CONSTANT_CLASS_P (res))
492 return res;
493 }
494
495 code_helper rcode;
496 tree ops[3] = {};
497 if (!gimple_simplify (&rcode, ops, seq, valueize,
498 as_combined_fn (fn), type, arg0))
499 return NULL_TREE;
500 return maybe_push_res_to_seq (rcode, type, ops, seq);
501}
502
503/* Builtin function with two arguments. */
504
505tree
506gimple_simplify (enum built_in_function fn, tree type,
507 tree arg0, tree arg1,
508 gimple_seq *seq, tree (*valueize)(tree))
509{
510 if (constant_for_folding (arg0)
511 && constant_for_folding (arg1))
512 {
513 tree res = fold_const_call (as_combined_fn (fn), type, arg0, arg1);
514 if (res && CONSTANT_CLASS_P (res))
515 return res;
516 }
517
518 code_helper rcode;
519 tree ops[3] = {};
520 if (!gimple_simplify (&rcode, ops, seq, valueize,
521 as_combined_fn (fn), type, arg0, arg1))
522 return NULL_TREE;
523 return maybe_push_res_to_seq (rcode, type, ops, seq);
524}
525
526/* Builtin function with three arguments. */
527
528tree
529gimple_simplify (enum built_in_function fn, tree type,
530 tree arg0, tree arg1, tree arg2,
531 gimple_seq *seq, tree (*valueize)(tree))
532{
533 if (constant_for_folding (arg0)
534 && constant_for_folding (arg1)
535 && constant_for_folding (arg2))
536 {
537 tree res = fold_const_call (as_combined_fn (fn), type, arg0, arg1, arg2);
538 if (res && CONSTANT_CLASS_P (res))
539 return res;
540 }
541
542 code_helper rcode;
543 tree ops[3] = {};
544 if (!gimple_simplify (&rcode, ops, seq, valueize,
545 as_combined_fn (fn), type, arg0, arg1, arg2))
546 return NULL_TREE;
547 return maybe_push_res_to_seq (rcode, type, ops, seq);
548}
549
550/* Helper for gimple_simplify valueizing OP using VALUEIZE and setting
551 VALUEIZED to true if valueization changed OP. */
552
553static inline tree
554do_valueize (tree op, tree (*valueize)(tree), bool &valueized)
555{
556 if (valueize && TREE_CODE (op) == SSA_NAME)
557 {
558 tree tem = valueize (op);
559 if (tem && tem != op)
560 {
561 op = tem;
562 valueized = true;
563 }
564 }
565 return op;
566}
567
568/* The main STMT based simplification entry. It is used by the fold_stmt
569 and the fold_stmt_to_constant APIs. */
570
571bool
572gimple_simplify (gimple *stmt,
573 code_helper *rcode, tree *ops,
574 gimple_seq *seq,
575 tree (*valueize)(tree), tree (*top_valueize)(tree))
576{
577 switch (gimple_code (stmt))
578 {
579 case GIMPLE_ASSIGN:
580 {
581 enum tree_code code = gimple_assign_rhs_code (stmt);
582 tree type = TREE_TYPE (gimple_assign_lhs (stmt));
583 switch (gimple_assign_rhs_class (stmt))
584 {
585 case GIMPLE_SINGLE_RHS:
586 if (code == REALPART_EXPR
587 || code == IMAGPART_EXPR
588 || code == VIEW_CONVERT_EXPR)
589 {
590 tree op0 = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
591 bool valueized = false;
592 op0 = do_valueize (op0, top_valueize, valueized);
593 *rcode = code;
594 ops[0] = op0;
595 return (gimple_resimplify1 (seq, rcode, type, ops, valueize)
596 || valueized);
597 }
598 else if (code == BIT_FIELD_REF)
599 {
600 tree rhs1 = gimple_assign_rhs1 (stmt);
601 tree op0 = TREE_OPERAND (rhs1, 0);
602 bool valueized = false;
603 op0 = do_valueize (op0, top_valueize, valueized);
604 *rcode = code;
605 ops[0] = op0;
606 ops[1] = TREE_OPERAND (rhs1, 1);
607 ops[2] = TREE_OPERAND (rhs1, 2);
608 return (gimple_resimplify3 (seq, rcode, type, ops, valueize)
609 || valueized);
610 }
611 else if (code == SSA_NAME
612 && top_valueize)
613 {
614 tree op0 = gimple_assign_rhs1 (stmt);
615 tree valueized = top_valueize (op0);
616 if (!valueized || op0 == valueized)
617 return false;
618 ops[0] = valueized;
619 *rcode = TREE_CODE (op0);
620 return true;
621 }
622 break;
623 case GIMPLE_UNARY_RHS:
624 {
625 tree rhs1 = gimple_assign_rhs1 (stmt);
626 bool valueized = false;
627 rhs1 = do_valueize (rhs1, top_valueize, valueized);
628 *rcode = code;
629 ops[0] = rhs1;
630 return (gimple_resimplify1 (seq, rcode, type, ops, valueize)
631 || valueized);
632 }
633 case GIMPLE_BINARY_RHS:
634 {
635 tree rhs1 = gimple_assign_rhs1 (stmt);
636 tree rhs2 = gimple_assign_rhs2 (stmt);
637 bool valueized = false;
638 rhs1 = do_valueize (rhs1, top_valueize, valueized);
639 rhs2 = do_valueize (rhs2, top_valueize, valueized);
640 *rcode = code;
641 ops[0] = rhs1;
642 ops[1] = rhs2;
643 return (gimple_resimplify2 (seq, rcode, type, ops, valueize)
644 || valueized);
645 }
646 case GIMPLE_TERNARY_RHS:
647 {
648 bool valueized = false;
649 tree rhs1 = gimple_assign_rhs1 (stmt);
650 /* If this is a [VEC_]COND_EXPR first try to simplify an
651 embedded GENERIC condition. */
652 if (code == COND_EXPR
653 || code == VEC_COND_EXPR)
654 {
655 if (COMPARISON_CLASS_P (rhs1))
656 {
657 tree lhs = TREE_OPERAND (rhs1, 0);
658 tree rhs = TREE_OPERAND (rhs1, 1);
659 lhs = do_valueize (lhs, top_valueize, valueized);
660 rhs = do_valueize (rhs, top_valueize, valueized);
661 code_helper rcode2 = TREE_CODE (rhs1);
662 tree ops2[3] = {};
663 ops2[0] = lhs;
664 ops2[1] = rhs;
665 if ((gimple_resimplify2 (seq, &rcode2, TREE_TYPE (rhs1),
666 ops2, valueize)
667 || valueized)
668 && rcode2.is_tree_code ())
669 {
670 valueized = true;
671 if (TREE_CODE_CLASS ((enum tree_code)rcode2)
672 == tcc_comparison)
673 rhs1 = build2 (rcode2, TREE_TYPE (rhs1),
674 ops2[0], ops2[1]);
675 else if (rcode2 == SSA_NAME
676 || rcode2 == INTEGER_CST
677 || rcode2 == VECTOR_CST)
678 rhs1 = ops2[0];
679 else
680 valueized = false;
681 }
682 }
683 }
684 tree rhs2 = gimple_assign_rhs2 (stmt);
685 tree rhs3 = gimple_assign_rhs3 (stmt);
686 rhs1 = do_valueize (rhs1, top_valueize, valueized);
687 rhs2 = do_valueize (rhs2, top_valueize, valueized);
688 rhs3 = do_valueize (rhs3, top_valueize, valueized);
689 *rcode = code;
690 ops[0] = rhs1;
691 ops[1] = rhs2;
692 ops[2] = rhs3;
693 return (gimple_resimplify3 (seq, rcode, type, ops, valueize)
694 || valueized);
695 }
696 default:
697 gcc_unreachable ();
698 }
699 break;
700 }
701
702 case GIMPLE_CALL:
703 /* ??? This way we can't simplify calls with side-effects. */
704 if (gimple_call_lhs (stmt) != NULL_TREE
705 && gimple_call_num_args (stmt) >= 1
706 && gimple_call_num_args (stmt) <= 3)
707 {
708 bool valueized = false;
709 if (gimple_call_internal_p (stmt))
710 *rcode = as_combined_fn (gimple_call_internal_fn (stmt));
711 else
712 {
713 tree fn = gimple_call_fn (stmt);
714 if (!fn)
715 return false;
716
717 fn = do_valueize (fn, top_valueize, valueized);
718 if (TREE_CODE (fn) != ADDR_EXPR
719 || TREE_CODE (TREE_OPERAND (fn, 0)) != FUNCTION_DECL)
720 return false;
721
722 tree decl = TREE_OPERAND (fn, 0);
723 if (DECL_BUILT_IN_CLASS (decl) != BUILT_IN_NORMAL
724 || !gimple_builtin_call_types_compatible_p (stmt, decl))
725 return false;
726
727 *rcode = as_combined_fn (DECL_FUNCTION_CODE (decl));
728 }
729
730 tree type = TREE_TYPE (gimple_call_lhs (stmt));
731 for (unsigned i = 0; i < gimple_call_num_args (stmt); ++i)
732 {
733 tree arg = gimple_call_arg (stmt, i);
734 ops[i] = do_valueize (arg, top_valueize, valueized);
735 }
736 switch (gimple_call_num_args (stmt))
737 {
738 case 1:
739 return (gimple_resimplify1 (seq, rcode, type, ops, valueize)
740 || valueized);
741 case 2:
742 return (gimple_resimplify2 (seq, rcode, type, ops, valueize)
743 || valueized);
744 case 3:
745 return (gimple_resimplify3 (seq, rcode, type, ops, valueize)
746 || valueized);
747 default:
748 gcc_unreachable ();
749 }
750 }
751 break;
752
753 case GIMPLE_COND:
754 {
755 tree lhs = gimple_cond_lhs (stmt);
756 tree rhs = gimple_cond_rhs (stmt);
757 bool valueized = false;
758 lhs = do_valueize (lhs, top_valueize, valueized);
759 rhs = do_valueize (rhs, top_valueize, valueized);
760 *rcode = gimple_cond_code (stmt);
761 ops[0] = lhs;
762 ops[1] = rhs;
763 return (gimple_resimplify2 (seq, rcode,
764 boolean_type_node, ops, valueize)
765 || valueized);
766 }
767
768 default:
769 break;
770 }
771
772 return false;
773}
774
775
776/* Helper for the autogenerated code, valueize OP. */
777
778inline tree
779do_valueize (tree (*valueize)(tree), tree op)
780{
781 if (valueize && TREE_CODE (op) == SSA_NAME)
782 {
783 tree tem = valueize (op);
784 if (tem)
785 return tem;
786 }
787 return op;
788}
789
790/* Helper for the autogenerated code, get at the definition of NAME when
791 VALUEIZE allows that. */
792
793inline gimple *
794get_def (tree (*valueize)(tree), tree name)
795{
796 if (valueize && ! valueize (name))
797 return NULL;
798 return SSA_NAME_DEF_STMT (name);
799}
800
801/* Routine to determine if the types T1 and T2 are effectively
802 the same for GIMPLE. If T1 or T2 is not a type, the test
803 applies to their TREE_TYPE. */
804
805static inline bool
806types_match (tree t1, tree t2)
807{
808 if (!TYPE_P (t1))
809 t1 = TREE_TYPE (t1);
810 if (!TYPE_P (t2))
811 t2 = TREE_TYPE (t2);
812
813 return types_compatible_p (t1, t2);
814}
815
816/* Return if T has a single use. For GIMPLE, we also allow any
817 non-SSA_NAME (ie constants) and zero uses to cope with uses
818 that aren't linked up yet. */
819
820static inline bool
821single_use (tree t)
822{
823 return TREE_CODE (t) != SSA_NAME || has_zero_uses (t) || has_single_use (t);
824}
825
826/* Return true if math operations should be canonicalized,
827 e.g. sqrt(sqrt(x)) -> pow(x, 0.25). */
828
829static inline bool
830canonicalize_math_p ()
831{
832 return !cfun || (cfun->curr_properties & PROP_gimple_opt_math) == 0;
833}
834

Warning: That file was not part of the compilation database. It may have many parsing errors.