1 /* Statement simplification on GIMPLE.
2 Copyright (C) 2010-2018 Free Software Foundation, Inc.
3 Split out from tree-ssa-ccp.c.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3, or (at your option) any
12 GCC is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
32 #include "gimple-pretty-print.h"
33 #include "gimple-ssa-warn-restrict.h"
34 #include "fold-const.h"
37 #include "stor-layout.h"
39 #include "gimple-fold.h"
41 #include "gimple-iterator.h"
42 #include "tree-into-ssa.h"
44 #include "tree-object-size.h"
46 #include "tree-ssa-propagate.h"
47 #include "ipa-utils.h"
48 #include "tree-ssa-address.h"
49 #include "langhooks.h"
50 #include "gimplify-me.h"
54 #include "gimple-match.h"
55 #include "gomp-constants.h"
56 #include "optabs-query.h"
57 #include "omp-general.h"
59 #include "fold-const-call.h"
60 #include "stringpool.h"
63 #include "diagnostic-core.h"
66 #include "tree-vector-builder.h"
67 #include "tree-ssa-strlen.h"
69 /* Return true when DECL can be referenced from current unit.
70 FROM_DECL (if non-null) specify constructor of variable DECL was taken from.
71 We can get declarations that are not possible to reference for various
74 1) When analyzing C++ virtual tables.
75 C++ virtual tables do have known constructors even
76 when they are keyed to other compilation unit.
77 Those tables can contain pointers to methods and vars
78 in other units. Those methods have both STATIC and EXTERNAL
80 2) In WHOPR mode devirtualization might lead to reference
81 to method that was partitioned elsehwere.
82 In this case we have static VAR_DECL or FUNCTION_DECL
83 that has no corresponding callgraph/varpool node
85 3) COMDAT functions referred by external vtables that
86 we devirtualize only during final compilation stage.
87 At this time we already decided that we will not output
88 the function body and thus we can't reference the symbol
92 can_refer_decl_in_current_unit_p (tree decl
, tree from_decl
)
95 struct cgraph_node
*node
;
98 if (DECL_ABSTRACT_P (decl
))
101 /* We are concerned only about static/external vars and functions. */
102 if ((!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
103 || !VAR_OR_FUNCTION_DECL_P (decl
))
106 /* Static objects can be referred only if they was not optimized out yet. */
107 if (!TREE_PUBLIC (decl
) && !DECL_EXTERNAL (decl
))
109 /* Before we start optimizing unreachable code we can be sure all
110 static objects are defined. */
111 if (symtab
->function_flags_ready
)
113 snode
= symtab_node::get (decl
);
114 if (!snode
|| !snode
->definition
)
116 node
= dyn_cast
<cgraph_node
*> (snode
);
117 return !node
|| !node
->global
.inlined_to
;
120 /* We will later output the initializer, so we can refer to it.
121 So we are concerned only when DECL comes from initializer of
122 external var or var that has been optimized out. */
124 || !VAR_P (from_decl
)
125 || (!DECL_EXTERNAL (from_decl
)
126 && (vnode
= varpool_node::get (from_decl
)) != NULL
127 && vnode
->definition
)
129 && (vnode
= varpool_node::get (from_decl
)) != NULL
130 && vnode
->in_other_partition
))
132 /* We are folding reference from external vtable. The vtable may reffer
133 to a symbol keyed to other compilation unit. The other compilation
134 unit may be in separate DSO and the symbol may be hidden. */
135 if (DECL_VISIBILITY_SPECIFIED (decl
)
136 && DECL_EXTERNAL (decl
)
137 && DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
138 && (!(snode
= symtab_node::get (decl
)) || !snode
->in_other_partition
))
140 /* When function is public, we always can introduce new reference.
141 Exception are the COMDAT functions where introducing a direct
142 reference imply need to include function body in the curren tunit. */
143 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
145 /* We have COMDAT. We are going to check if we still have definition
146 or if the definition is going to be output in other partition.
147 Bypass this when gimplifying; all needed functions will be produced.
149 As observed in PR20991 for already optimized out comdat virtual functions
150 it may be tempting to not necessarily give up because the copy will be
151 output elsewhere when corresponding vtable is output.
152 This is however not possible - ABI specify that COMDATs are output in
153 units where they are used and when the other unit was compiled with LTO
154 it is possible that vtable was kept public while the function itself
156 if (!symtab
->function_flags_ready
)
159 snode
= symtab_node::get (decl
);
161 || ((!snode
->definition
|| DECL_EXTERNAL (decl
))
162 && (!snode
->in_other_partition
163 || (!snode
->forced_by_abi
&& !snode
->force_output
))))
165 node
= dyn_cast
<cgraph_node
*> (snode
);
166 return !node
|| !node
->global
.inlined_to
;
169 /* Create a temporary for TYPE for a statement STMT. If the current function
170 is in SSA form, a SSA name is created. Otherwise a temporary register
174 create_tmp_reg_or_ssa_name (tree type
, gimple
*stmt
)
176 if (gimple_in_ssa_p (cfun
))
177 return make_ssa_name (type
, stmt
);
179 return create_tmp_reg (type
);
182 /* CVAL is value taken from DECL_INITIAL of variable. Try to transform it into
183 acceptable form for is_gimple_min_invariant.
184 FROM_DECL (if non-NULL) specify variable whose constructor contains CVAL. */
187 canonicalize_constructor_val (tree cval
, tree from_decl
)
189 tree orig_cval
= cval
;
191 if (TREE_CODE (cval
) == POINTER_PLUS_EXPR
192 && TREE_CODE (TREE_OPERAND (cval
, 1)) == INTEGER_CST
)
194 tree ptr
= TREE_OPERAND (cval
, 0);
195 if (is_gimple_min_invariant (ptr
))
196 cval
= build1_loc (EXPR_LOCATION (cval
),
197 ADDR_EXPR
, TREE_TYPE (ptr
),
198 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (ptr
)),
200 fold_convert (ptr_type_node
,
201 TREE_OPERAND (cval
, 1))));
203 if (TREE_CODE (cval
) == ADDR_EXPR
)
205 tree base
= NULL_TREE
;
206 if (TREE_CODE (TREE_OPERAND (cval
, 0)) == COMPOUND_LITERAL_EXPR
)
208 base
= COMPOUND_LITERAL_EXPR_DECL (TREE_OPERAND (cval
, 0));
210 TREE_OPERAND (cval
, 0) = base
;
213 base
= get_base_address (TREE_OPERAND (cval
, 0));
217 if (VAR_OR_FUNCTION_DECL_P (base
)
218 && !can_refer_decl_in_current_unit_p (base
, from_decl
))
220 if (TREE_TYPE (base
) == error_mark_node
)
223 TREE_ADDRESSABLE (base
) = 1;
224 else if (TREE_CODE (base
) == FUNCTION_DECL
)
226 /* Make sure we create a cgraph node for functions we'll reference.
227 They can be non-existent if the reference comes from an entry
228 of an external vtable for example. */
229 cgraph_node::get_create (base
);
231 /* Fixup types in global initializers. */
232 if (TREE_TYPE (TREE_TYPE (cval
)) != TREE_TYPE (TREE_OPERAND (cval
, 0)))
233 cval
= build_fold_addr_expr (TREE_OPERAND (cval
, 0));
235 if (!useless_type_conversion_p (TREE_TYPE (orig_cval
), TREE_TYPE (cval
)))
236 cval
= fold_convert (TREE_TYPE (orig_cval
), cval
);
239 if (TREE_OVERFLOW_P (cval
))
240 return drop_tree_overflow (cval
);
244 /* If SYM is a constant variable with known value, return the value.
245 NULL_TREE is returned otherwise. */
248 get_symbol_constant_value (tree sym
)
250 tree val
= ctor_for_folding (sym
);
251 if (val
!= error_mark_node
)
255 val
= canonicalize_constructor_val (unshare_expr (val
), sym
);
256 if (val
&& is_gimple_min_invariant (val
))
261 /* Variables declared 'const' without an initializer
262 have zero as the initializer if they may not be
263 overridden at link or run time. */
265 && is_gimple_reg_type (TREE_TYPE (sym
)))
266 return build_zero_cst (TREE_TYPE (sym
));
274 /* Subroutine of fold_stmt. We perform several simplifications of the
275 memory reference tree EXPR and make sure to re-gimplify them properly
276 after propagation of constant addresses. IS_LHS is true if the
277 reference is supposed to be an lvalue. */
280 maybe_fold_reference (tree expr
, bool is_lhs
)
284 if ((TREE_CODE (expr
) == VIEW_CONVERT_EXPR
285 || TREE_CODE (expr
) == REALPART_EXPR
286 || TREE_CODE (expr
) == IMAGPART_EXPR
)
287 && CONSTANT_CLASS_P (TREE_OPERAND (expr
, 0)))
288 return fold_unary_loc (EXPR_LOCATION (expr
),
291 TREE_OPERAND (expr
, 0));
292 else if (TREE_CODE (expr
) == BIT_FIELD_REF
293 && CONSTANT_CLASS_P (TREE_OPERAND (expr
, 0)))
294 return fold_ternary_loc (EXPR_LOCATION (expr
),
297 TREE_OPERAND (expr
, 0),
298 TREE_OPERAND (expr
, 1),
299 TREE_OPERAND (expr
, 2));
302 && (result
= fold_const_aggregate_ref (expr
))
303 && is_gimple_min_invariant (result
))
310 /* Attempt to fold an assignment statement pointed-to by SI. Returns a
311 replacement rhs for the statement or NULL_TREE if no simplification
312 could be made. It is assumed that the operands have been previously
316 fold_gimple_assign (gimple_stmt_iterator
*si
)
318 gimple
*stmt
= gsi_stmt (*si
);
319 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
320 location_t loc
= gimple_location (stmt
);
322 tree result
= NULL_TREE
;
324 switch (get_gimple_rhs_class (subcode
))
326 case GIMPLE_SINGLE_RHS
:
328 tree rhs
= gimple_assign_rhs1 (stmt
);
330 if (TREE_CLOBBER_P (rhs
))
333 if (REFERENCE_CLASS_P (rhs
))
334 return maybe_fold_reference (rhs
, false);
336 else if (TREE_CODE (rhs
) == OBJ_TYPE_REF
)
338 tree val
= OBJ_TYPE_REF_EXPR (rhs
);
339 if (is_gimple_min_invariant (val
))
341 else if (flag_devirtualize
&& virtual_method_call_p (rhs
))
344 vec
<cgraph_node
*>targets
345 = possible_polymorphic_call_targets (rhs
, stmt
, &final
);
346 if (final
&& targets
.length () <= 1 && dbg_cnt (devirt
))
348 if (dump_enabled_p ())
350 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
,
351 "resolving virtual function address "
352 "reference to function %s\n",
353 targets
.length () == 1
354 ? targets
[0]->name ()
357 if (targets
.length () == 1)
359 val
= fold_convert (TREE_TYPE (val
),
360 build_fold_addr_expr_loc
361 (loc
, targets
[0]->decl
));
362 STRIP_USELESS_TYPE_CONVERSION (val
);
365 /* We can not use __builtin_unreachable here because it
366 can not have address taken. */
367 val
= build_int_cst (TREE_TYPE (val
), 0);
373 else if (TREE_CODE (rhs
) == ADDR_EXPR
)
375 tree ref
= TREE_OPERAND (rhs
, 0);
376 tree tem
= maybe_fold_reference (ref
, true);
378 && TREE_CODE (tem
) == MEM_REF
379 && integer_zerop (TREE_OPERAND (tem
, 1)))
380 result
= fold_convert (TREE_TYPE (rhs
), TREE_OPERAND (tem
, 0));
382 result
= fold_convert (TREE_TYPE (rhs
),
383 build_fold_addr_expr_loc (loc
, tem
));
384 else if (TREE_CODE (ref
) == MEM_REF
385 && integer_zerop (TREE_OPERAND (ref
, 1)))
386 result
= fold_convert (TREE_TYPE (rhs
), TREE_OPERAND (ref
, 0));
390 /* Strip away useless type conversions. Both the
391 NON_LVALUE_EXPR that may have been added by fold, and
392 "useless" type conversions that might now be apparent
393 due to propagation. */
394 STRIP_USELESS_TYPE_CONVERSION (result
);
396 if (result
!= rhs
&& valid_gimple_rhs_p (result
))
401 else if (TREE_CODE (rhs
) == CONSTRUCTOR
402 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
)
404 /* Fold a constant vector CONSTRUCTOR to VECTOR_CST. */
408 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
409 if (! CONSTANT_CLASS_P (val
))
412 return build_vector_from_ctor (TREE_TYPE (rhs
),
413 CONSTRUCTOR_ELTS (rhs
));
416 else if (DECL_P (rhs
))
417 return get_symbol_constant_value (rhs
);
421 case GIMPLE_UNARY_RHS
:
424 case GIMPLE_BINARY_RHS
:
427 case GIMPLE_TERNARY_RHS
:
428 result
= fold_ternary_loc (loc
, subcode
,
429 TREE_TYPE (gimple_assign_lhs (stmt
)),
430 gimple_assign_rhs1 (stmt
),
431 gimple_assign_rhs2 (stmt
),
432 gimple_assign_rhs3 (stmt
));
436 STRIP_USELESS_TYPE_CONVERSION (result
);
437 if (valid_gimple_rhs_p (result
))
442 case GIMPLE_INVALID_RHS
:
450 /* Replace a statement at *SI_P with a sequence of statements in STMTS,
451 adjusting the replacement stmts location and virtual operands.
452 If the statement has a lhs the last stmt in the sequence is expected
453 to assign to that lhs. */
456 gsi_replace_with_seq_vops (gimple_stmt_iterator
*si_p
, gimple_seq stmts
)
458 gimple
*stmt
= gsi_stmt (*si_p
);
460 if (gimple_has_location (stmt
))
461 annotate_all_with_location (stmts
, gimple_location (stmt
));
463 /* First iterate over the replacement statements backward, assigning
464 virtual operands to their defining statements. */
465 gimple
*laststore
= NULL
;
466 for (gimple_stmt_iterator i
= gsi_last (stmts
);
467 !gsi_end_p (i
); gsi_prev (&i
))
469 gimple
*new_stmt
= gsi_stmt (i
);
470 if ((gimple_assign_single_p (new_stmt
)
471 && !is_gimple_reg (gimple_assign_lhs (new_stmt
)))
472 || (is_gimple_call (new_stmt
)
473 && (gimple_call_flags (new_stmt
)
474 & (ECF_NOVOPS
| ECF_PURE
| ECF_CONST
| ECF_NORETURN
)) == 0))
478 vdef
= gimple_vdef (stmt
);
480 vdef
= make_ssa_name (gimple_vop (cfun
), new_stmt
);
481 gimple_set_vdef (new_stmt
, vdef
);
482 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
483 SSA_NAME_DEF_STMT (vdef
) = new_stmt
;
484 laststore
= new_stmt
;
488 /* Second iterate over the statements forward, assigning virtual
489 operands to their uses. */
490 tree reaching_vuse
= gimple_vuse (stmt
);
491 for (gimple_stmt_iterator i
= gsi_start (stmts
);
492 !gsi_end_p (i
); gsi_next (&i
))
494 gimple
*new_stmt
= gsi_stmt (i
);
495 /* If the new statement possibly has a VUSE, update it with exact SSA
496 name we know will reach this one. */
497 if (gimple_has_mem_ops (new_stmt
))
498 gimple_set_vuse (new_stmt
, reaching_vuse
);
499 gimple_set_modified (new_stmt
, true);
500 if (gimple_vdef (new_stmt
))
501 reaching_vuse
= gimple_vdef (new_stmt
);
504 /* If the new sequence does not do a store release the virtual
505 definition of the original statement. */
507 && reaching_vuse
== gimple_vuse (stmt
))
509 tree vdef
= gimple_vdef (stmt
);
511 && TREE_CODE (vdef
) == SSA_NAME
)
513 unlink_stmt_vdef (stmt
);
514 release_ssa_name (vdef
);
518 /* Finally replace the original statement with the sequence. */
519 gsi_replace_with_seq (si_p
, stmts
, false);
522 /* Convert EXPR into a GIMPLE value suitable for substitution on the
523 RHS of an assignment. Insert the necessary statements before
524 iterator *SI_P. The statement at *SI_P, which must be a GIMPLE_CALL
525 is replaced. If the call is expected to produces a result, then it
526 is replaced by an assignment of the new RHS to the result variable.
527 If the result is to be ignored, then the call is replaced by a
528 GIMPLE_NOP. A proper VDEF chain is retained by making the first
529 VUSE and the last VDEF of the whole sequence be the same as the replaced
530 statement and using new SSA names for stores in between. */
533 gimplify_and_update_call_from_tree (gimple_stmt_iterator
*si_p
, tree expr
)
536 gimple
*stmt
, *new_stmt
;
537 gimple_stmt_iterator i
;
538 gimple_seq stmts
= NULL
;
540 stmt
= gsi_stmt (*si_p
);
542 gcc_assert (is_gimple_call (stmt
));
544 push_gimplify_context (gimple_in_ssa_p (cfun
));
546 lhs
= gimple_call_lhs (stmt
);
547 if (lhs
== NULL_TREE
)
549 gimplify_and_add (expr
, &stmts
);
550 /* We can end up with folding a memcpy of an empty class assignment
551 which gets optimized away by C++ gimplification. */
552 if (gimple_seq_empty_p (stmts
))
554 pop_gimplify_context (NULL
);
555 if (gimple_in_ssa_p (cfun
))
557 unlink_stmt_vdef (stmt
);
560 gsi_replace (si_p
, gimple_build_nop (), false);
566 tree tmp
= force_gimple_operand (expr
, &stmts
, false, NULL_TREE
);
567 new_stmt
= gimple_build_assign (lhs
, tmp
);
568 i
= gsi_last (stmts
);
569 gsi_insert_after_without_update (&i
, new_stmt
,
570 GSI_CONTINUE_LINKING
);
573 pop_gimplify_context (NULL
);
575 gsi_replace_with_seq_vops (si_p
, stmts
);
579 /* Replace the call at *GSI with the gimple value VAL. */
582 replace_call_with_value (gimple_stmt_iterator
*gsi
, tree val
)
584 gimple
*stmt
= gsi_stmt (*gsi
);
585 tree lhs
= gimple_call_lhs (stmt
);
589 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (val
)))
590 val
= fold_convert (TREE_TYPE (lhs
), val
);
591 repl
= gimple_build_assign (lhs
, val
);
594 repl
= gimple_build_nop ();
595 tree vdef
= gimple_vdef (stmt
);
596 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
598 unlink_stmt_vdef (stmt
);
599 release_ssa_name (vdef
);
601 gsi_replace (gsi
, repl
, false);
604 /* Replace the call at *GSI with the new call REPL and fold that
608 replace_call_with_call_and_fold (gimple_stmt_iterator
*gsi
, gimple
*repl
)
610 gimple
*stmt
= gsi_stmt (*gsi
);
611 gimple_call_set_lhs (repl
, gimple_call_lhs (stmt
));
612 gimple_set_location (repl
, gimple_location (stmt
));
613 if (gimple_vdef (stmt
)
614 && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
616 gimple_set_vdef (repl
, gimple_vdef (stmt
));
617 SSA_NAME_DEF_STMT (gimple_vdef (repl
)) = repl
;
619 if (gimple_vuse (stmt
))
620 gimple_set_vuse (repl
, gimple_vuse (stmt
));
621 gsi_replace (gsi
, repl
, false);
625 /* Return true if VAR is a VAR_DECL or a component thereof. */
628 var_decl_component_p (tree var
)
631 while (handled_component_p (inner
))
632 inner
= TREE_OPERAND (inner
, 0);
633 return (DECL_P (inner
)
634 || (TREE_CODE (inner
) == MEM_REF
635 && TREE_CODE (TREE_OPERAND (inner
, 0)) == ADDR_EXPR
));
638 /* If the SIZE argument representing the size of an object is in a range
639 of values of which exactly one is valid (and that is zero), return
640 true, otherwise false. */
643 size_must_be_zero_p (tree size
)
645 if (integer_zerop (size
))
648 if (TREE_CODE (size
) != SSA_NAME
|| !INTEGRAL_TYPE_P (TREE_TYPE (size
)))
652 enum value_range_type rtype
= get_range_info (size
, &min
, &max
);
653 if (rtype
!= VR_ANTI_RANGE
)
656 tree type
= TREE_TYPE (size
);
657 int prec
= TYPE_PRECISION (type
);
659 wide_int wone
= wi::one (prec
);
661 /* Compute the value of SSIZE_MAX, the largest positive value that
662 can be stored in ssize_t, the signed counterpart of size_t. */
663 wide_int ssize_max
= wi::lshift (wi::one (prec
), prec
- 1) - 1;
665 return wi::eq_p (min
, wone
) && wi::geu_p (max
, ssize_max
);
668 /* Fold function call to builtin mem{{,p}cpy,move}. Try to detect and
669 diagnose (otherwise undefined) overlapping copies without preventing
670 folding. When folded, GCC guarantees that overlapping memcpy has
671 the same semantics as memmove. Call to the library memcpy need not
672 provide the same guarantee. Return false if no simplification can
676 gimple_fold_builtin_memory_op (gimple_stmt_iterator
*gsi
,
677 tree dest
, tree src
, int endp
)
679 gimple
*stmt
= gsi_stmt (*gsi
);
680 tree lhs
= gimple_call_lhs (stmt
);
681 tree len
= gimple_call_arg (stmt
, 2);
682 tree destvar
, srcvar
;
683 location_t loc
= gimple_location (stmt
);
685 bool nowarn
= gimple_no_warning_p (stmt
);
687 /* If the LEN parameter is a constant zero or in range where
688 the only valid value is zero, return DEST. */
689 if (size_must_be_zero_p (len
))
692 if (gimple_call_lhs (stmt
))
693 repl
= gimple_build_assign (gimple_call_lhs (stmt
), dest
);
695 repl
= gimple_build_nop ();
696 tree vdef
= gimple_vdef (stmt
);
697 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
699 unlink_stmt_vdef (stmt
);
700 release_ssa_name (vdef
);
702 gsi_replace (gsi
, repl
, false);
706 /* If SRC and DEST are the same (and not volatile), return
707 DEST{,+LEN,+LEN-1}. */
708 if (operand_equal_p (src
, dest
, 0))
710 /* Avoid diagnosing exact overlap in calls to __builtin_memcpy.
711 It's safe and may even be emitted by GCC itself (see bug
713 unlink_stmt_vdef (stmt
);
714 if (gimple_vdef (stmt
) && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
715 release_ssa_name (gimple_vdef (stmt
));
718 gsi_replace (gsi
, gimple_build_nop (), false);
725 tree srctype
, desttype
;
726 unsigned int src_align
, dest_align
;
729 /* Build accesses at offset zero with a ref-all character type. */
730 off0
= build_int_cst (build_pointer_type_for_mode (char_type_node
,
733 /* If we can perform the copy efficiently with first doing all loads
734 and then all stores inline it that way. Currently efficiently
735 means that we can load all the memory into a single integer
736 register which is what MOVE_MAX gives us. */
737 src_align
= get_pointer_alignment (src
);
738 dest_align
= get_pointer_alignment (dest
);
739 if (tree_fits_uhwi_p (len
)
740 && compare_tree_int (len
, MOVE_MAX
) <= 0
741 /* ??? Don't transform copies from strings with known length this
742 confuses the tree-ssa-strlen.c. This doesn't handle
743 the case in gcc.dg/strlenopt-8.c which is XFAILed for that
745 && !c_strlen (src
, 2))
747 unsigned ilen
= tree_to_uhwi (len
);
748 if (pow2p_hwi (ilen
))
750 /* Detect invalid bounds and overlapping copies and issue
751 either -Warray-bounds or -Wrestrict. */
753 && check_bounds_or_overlap (as_a
<gcall
*>(stmt
),
754 dest
, src
, len
, len
))
755 gimple_set_no_warning (stmt
, true);
757 scalar_int_mode mode
;
758 tree type
= lang_hooks
.types
.type_for_size (ilen
* 8, 1);
760 && is_a
<scalar_int_mode
> (TYPE_MODE (type
), &mode
)
761 && GET_MODE_SIZE (mode
) * BITS_PER_UNIT
== ilen
* 8
762 /* If the destination pointer is not aligned we must be able
763 to emit an unaligned store. */
764 && (dest_align
>= GET_MODE_ALIGNMENT (mode
)
765 || !targetm
.slow_unaligned_access (mode
, dest_align
)
766 || (optab_handler (movmisalign_optab
, mode
)
767 != CODE_FOR_nothing
)))
770 tree desttype
= type
;
771 if (src_align
< GET_MODE_ALIGNMENT (mode
))
772 srctype
= build_aligned_type (type
, src_align
);
773 tree srcmem
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
774 tree tem
= fold_const_aggregate_ref (srcmem
);
777 else if (src_align
< GET_MODE_ALIGNMENT (mode
)
778 && targetm
.slow_unaligned_access (mode
, src_align
)
779 && (optab_handler (movmisalign_optab
, mode
)
780 == CODE_FOR_nothing
))
785 if (is_gimple_reg_type (TREE_TYPE (srcmem
)))
787 new_stmt
= gimple_build_assign (NULL_TREE
, srcmem
);
789 = create_tmp_reg_or_ssa_name (TREE_TYPE (srcmem
),
791 gimple_assign_set_lhs (new_stmt
, srcmem
);
792 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
793 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
795 if (dest_align
< GET_MODE_ALIGNMENT (mode
))
796 desttype
= build_aligned_type (type
, dest_align
);
798 = gimple_build_assign (fold_build2 (MEM_REF
, desttype
,
801 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
802 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
803 if (gimple_vdef (new_stmt
)
804 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
805 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
808 gsi_replace (gsi
, new_stmt
, false);
811 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
820 /* Both DEST and SRC must be pointer types.
821 ??? This is what old code did. Is the testing for pointer types
824 If either SRC is readonly or length is 1, we can use memcpy. */
825 if (!dest_align
|| !src_align
)
827 if (readonly_data_expr (src
)
828 || (tree_fits_uhwi_p (len
)
829 && (MIN (src_align
, dest_align
) / BITS_PER_UNIT
830 >= tree_to_uhwi (len
))))
832 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
835 gimple_call_set_fndecl (stmt
, fn
);
836 gimple_call_set_arg (stmt
, 0, dest
);
837 gimple_call_set_arg (stmt
, 1, src
);
842 /* If *src and *dest can't overlap, optimize into memcpy as well. */
843 if (TREE_CODE (src
) == ADDR_EXPR
844 && TREE_CODE (dest
) == ADDR_EXPR
)
846 tree src_base
, dest_base
, fn
;
847 poly_int64 src_offset
= 0, dest_offset
= 0;
850 srcvar
= TREE_OPERAND (src
, 0);
851 src_base
= get_addr_base_and_unit_offset (srcvar
, &src_offset
);
852 if (src_base
== NULL
)
854 destvar
= TREE_OPERAND (dest
, 0);
855 dest_base
= get_addr_base_and_unit_offset (destvar
,
857 if (dest_base
== NULL
)
859 if (!poly_int_tree_p (len
, &maxsize
))
861 if (SSA_VAR_P (src_base
)
862 && SSA_VAR_P (dest_base
))
864 if (operand_equal_p (src_base
, dest_base
, 0)
865 && ranges_maybe_overlap_p (src_offset
, maxsize
,
866 dest_offset
, maxsize
))
869 else if (TREE_CODE (src_base
) == MEM_REF
870 && TREE_CODE (dest_base
) == MEM_REF
)
872 if (! operand_equal_p (TREE_OPERAND (src_base
, 0),
873 TREE_OPERAND (dest_base
, 0), 0))
875 poly_offset_int full_src_offset
876 = mem_ref_offset (src_base
) + src_offset
;
877 poly_offset_int full_dest_offset
878 = mem_ref_offset (dest_base
) + dest_offset
;
879 if (ranges_maybe_overlap_p (full_src_offset
, maxsize
,
880 full_dest_offset
, maxsize
))
886 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
889 gimple_call_set_fndecl (stmt
, fn
);
890 gimple_call_set_arg (stmt
, 0, dest
);
891 gimple_call_set_arg (stmt
, 1, src
);
896 /* If the destination and source do not alias optimize into
898 if ((is_gimple_min_invariant (dest
)
899 || TREE_CODE (dest
) == SSA_NAME
)
900 && (is_gimple_min_invariant (src
)
901 || TREE_CODE (src
) == SSA_NAME
))
904 ao_ref_init_from_ptr_and_size (&destr
, dest
, len
);
905 ao_ref_init_from_ptr_and_size (&srcr
, src
, len
);
906 if (!refs_may_alias_p_1 (&destr
, &srcr
, false))
909 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
912 gimple_call_set_fndecl (stmt
, fn
);
913 gimple_call_set_arg (stmt
, 0, dest
);
914 gimple_call_set_arg (stmt
, 1, src
);
923 if (!tree_fits_shwi_p (len
))
925 if (!POINTER_TYPE_P (TREE_TYPE (src
))
926 || !POINTER_TYPE_P (TREE_TYPE (dest
)))
928 /* In the following try to find a type that is most natural to be
929 used for the memcpy source and destination and that allows
930 the most optimization when memcpy is turned into a plain assignment
931 using that type. In theory we could always use a char[len] type
932 but that only gains us that the destination and source possibly
933 no longer will have their address taken. */
934 srctype
= TREE_TYPE (TREE_TYPE (src
));
935 if (TREE_CODE (srctype
) == ARRAY_TYPE
936 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
))
937 srctype
= TREE_TYPE (srctype
);
938 desttype
= TREE_TYPE (TREE_TYPE (dest
));
939 if (TREE_CODE (desttype
) == ARRAY_TYPE
940 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
))
941 desttype
= TREE_TYPE (desttype
);
942 if (TREE_ADDRESSABLE (srctype
)
943 || TREE_ADDRESSABLE (desttype
))
946 /* Make sure we are not copying using a floating-point mode or
947 a type whose size possibly does not match its precision. */
948 if (FLOAT_MODE_P (TYPE_MODE (desttype
))
949 || TREE_CODE (desttype
) == BOOLEAN_TYPE
950 || TREE_CODE (desttype
) == ENUMERAL_TYPE
)
951 desttype
= bitwise_type_for_mode (TYPE_MODE (desttype
));
952 if (FLOAT_MODE_P (TYPE_MODE (srctype
))
953 || TREE_CODE (srctype
) == BOOLEAN_TYPE
954 || TREE_CODE (srctype
) == ENUMERAL_TYPE
)
955 srctype
= bitwise_type_for_mode (TYPE_MODE (srctype
));
963 src_align
= get_pointer_alignment (src
);
964 dest_align
= get_pointer_alignment (dest
);
965 if (dest_align
< TYPE_ALIGN (desttype
)
966 || src_align
< TYPE_ALIGN (srctype
))
970 if (TREE_CODE (dest
) == ADDR_EXPR
971 && var_decl_component_p (TREE_OPERAND (dest
, 0))
972 && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
))
973 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
976 if (TREE_CODE (src
) == ADDR_EXPR
977 && var_decl_component_p (TREE_OPERAND (src
, 0))
978 && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
))
981 || src_align
>= TYPE_ALIGN (desttype
))
982 srcvar
= fold_build2 (MEM_REF
, destvar
? desttype
: srctype
,
984 else if (!STRICT_ALIGNMENT
)
986 srctype
= build_aligned_type (TYPE_MAIN_VARIANT (desttype
),
988 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
992 if (srcvar
== NULL_TREE
&& destvar
== NULL_TREE
)
995 if (srcvar
== NULL_TREE
)
997 if (src_align
>= TYPE_ALIGN (desttype
))
998 srcvar
= fold_build2 (MEM_REF
, desttype
, src
, off0
);
1001 if (STRICT_ALIGNMENT
)
1003 srctype
= build_aligned_type (TYPE_MAIN_VARIANT (desttype
),
1005 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1008 else if (destvar
== NULL_TREE
)
1010 if (dest_align
>= TYPE_ALIGN (srctype
))
1011 destvar
= fold_build2 (MEM_REF
, srctype
, dest
, off0
);
1014 if (STRICT_ALIGNMENT
)
1016 desttype
= build_aligned_type (TYPE_MAIN_VARIANT (srctype
),
1018 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
1022 /* Detect invalid bounds and overlapping copies and issue either
1023 -Warray-bounds or -Wrestrict. */
1025 check_bounds_or_overlap (as_a
<gcall
*>(stmt
), dest
, src
, len
, len
);
1028 if (is_gimple_reg_type (TREE_TYPE (srcvar
)))
1030 tree tem
= fold_const_aggregate_ref (srcvar
);
1033 if (! is_gimple_min_invariant (srcvar
))
1035 new_stmt
= gimple_build_assign (NULL_TREE
, srcvar
);
1036 srcvar
= create_tmp_reg_or_ssa_name (TREE_TYPE (srcvar
),
1038 gimple_assign_set_lhs (new_stmt
, srcvar
);
1039 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
1040 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1042 new_stmt
= gimple_build_assign (destvar
, srcvar
);
1043 goto set_vop_and_replace
;
1046 /* We get an aggregate copy. Use an unsigned char[] type to
1047 perform the copying to preserve padding and to avoid any issues
1048 with TREE_ADDRESSABLE types or float modes behavior on copying. */
1049 desttype
= build_array_type_nelts (unsigned_char_type_node
,
1050 tree_to_uhwi (len
));
1052 if (src_align
> TYPE_ALIGN (srctype
))
1053 srctype
= build_aligned_type (srctype
, src_align
);
1054 if (dest_align
> TYPE_ALIGN (desttype
))
1055 desttype
= build_aligned_type (desttype
, dest_align
);
1057 = gimple_build_assign (fold_build2 (MEM_REF
, desttype
, dest
, off0
),
1058 fold_build2 (MEM_REF
, srctype
, src
, off0
));
1059 set_vop_and_replace
:
1060 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
1061 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
1062 if (gimple_vdef (new_stmt
)
1063 && TREE_CODE (gimple_vdef (new_stmt
)) == SSA_NAME
)
1064 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt
)) = new_stmt
;
1067 gsi_replace (gsi
, new_stmt
, false);
1070 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1074 gimple_seq stmts
= NULL
;
1075 if (endp
== 0 || endp
== 3)
1078 len
= gimple_build (&stmts
, loc
, MINUS_EXPR
, TREE_TYPE (len
), len
,
1080 if (endp
== 2 || endp
== 1)
1082 len
= gimple_convert_to_ptrofftype (&stmts
, loc
, len
);
1083 dest
= gimple_build (&stmts
, loc
, POINTER_PLUS_EXPR
,
1084 TREE_TYPE (dest
), dest
, len
);
1087 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
1088 gimple
*repl
= gimple_build_assign (lhs
, dest
);
1089 gsi_replace (gsi
, repl
, false);
1093 /* Transform a call to built-in bcmp(a, b, len) at *GSI into one
1094 to built-in memcmp (a, b, len). */
1097 gimple_fold_builtin_bcmp (gimple_stmt_iterator
*gsi
)
1099 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
1104 /* Transform bcmp (a, b, len) into memcmp (a, b, len). */
1106 gimple
*stmt
= gsi_stmt (*gsi
);
1107 tree a
= gimple_call_arg (stmt
, 0);
1108 tree b
= gimple_call_arg (stmt
, 1);
1109 tree len
= gimple_call_arg (stmt
, 2);
1111 gimple
*repl
= gimple_build_call (fn
, 3, a
, b
, len
);
1112 replace_call_with_call_and_fold (gsi
, repl
);
1117 /* Transform a call to built-in bcopy (src, dest, len) at *GSI into one
1118 to built-in memmove (dest, src, len). */
1121 gimple_fold_builtin_bcopy (gimple_stmt_iterator
*gsi
)
1123 tree fn
= builtin_decl_implicit (BUILT_IN_MEMMOVE
);
1128 /* bcopy has been removed from POSIX in Issue 7 but Issue 6 specifies
1129 it's quivalent to memmove (not memcpy). Transform bcopy (src, dest,
1130 len) into memmove (dest, src, len). */
1132 gimple
*stmt
= gsi_stmt (*gsi
);
1133 tree src
= gimple_call_arg (stmt
, 0);
1134 tree dest
= gimple_call_arg (stmt
, 1);
1135 tree len
= gimple_call_arg (stmt
, 2);
1137 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
1138 gimple_call_set_fntype (as_a
<gcall
*> (stmt
), TREE_TYPE (fn
));
1139 replace_call_with_call_and_fold (gsi
, repl
);
1144 /* Transform a call to built-in bzero (dest, len) at *GSI into one
1145 to built-in memset (dest, 0, len). */
1148 gimple_fold_builtin_bzero (gimple_stmt_iterator
*gsi
)
1150 tree fn
= builtin_decl_implicit (BUILT_IN_MEMSET
);
1155 /* Transform bzero (dest, len) into memset (dest, 0, len). */
1157 gimple
*stmt
= gsi_stmt (*gsi
);
1158 tree dest
= gimple_call_arg (stmt
, 0);
1159 tree len
= gimple_call_arg (stmt
, 1);
1161 gimple_seq seq
= NULL
;
1162 gimple
*repl
= gimple_build_call (fn
, 3, dest
, integer_zero_node
, len
);
1163 gimple_seq_add_stmt_without_update (&seq
, repl
);
1164 gsi_replace_with_seq_vops (gsi
, seq
);
1170 /* Fold function call to builtin memset or bzero at *GSI setting the
1171 memory of size LEN to VAL. Return whether a simplification was made. */
1174 gimple_fold_builtin_memset (gimple_stmt_iterator
*gsi
, tree c
, tree len
)
1176 gimple
*stmt
= gsi_stmt (*gsi
);
1178 unsigned HOST_WIDE_INT length
, cval
;
1180 /* If the LEN parameter is zero, return DEST. */
1181 if (integer_zerop (len
))
1183 replace_call_with_value (gsi
, gimple_call_arg (stmt
, 0));
1187 if (! tree_fits_uhwi_p (len
))
1190 if (TREE_CODE (c
) != INTEGER_CST
)
1193 tree dest
= gimple_call_arg (stmt
, 0);
1195 if (TREE_CODE (var
) != ADDR_EXPR
)
1198 var
= TREE_OPERAND (var
, 0);
1199 if (TREE_THIS_VOLATILE (var
))
1202 etype
= TREE_TYPE (var
);
1203 if (TREE_CODE (etype
) == ARRAY_TYPE
)
1204 etype
= TREE_TYPE (etype
);
1206 if (!INTEGRAL_TYPE_P (etype
)
1207 && !POINTER_TYPE_P (etype
))
1210 if (! var_decl_component_p (var
))
1213 length
= tree_to_uhwi (len
);
1214 if (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (etype
)) != length
1215 || get_pointer_alignment (dest
) / BITS_PER_UNIT
< length
)
1218 if (length
> HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
)
1221 if (integer_zerop (c
))
1225 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8 || HOST_BITS_PER_WIDE_INT
> 64)
1228 cval
= TREE_INT_CST_LOW (c
);
1232 cval
|= (cval
<< 31) << 1;
1235 var
= fold_build2 (MEM_REF
, etype
, dest
, build_int_cst (ptr_type_node
, 0));
1236 gimple
*store
= gimple_build_assign (var
, build_int_cst_type (etype
, cval
));
1237 gimple_set_vuse (store
, gimple_vuse (stmt
));
1238 tree vdef
= gimple_vdef (stmt
);
1239 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
1241 gimple_set_vdef (store
, gimple_vdef (stmt
));
1242 SSA_NAME_DEF_STMT (gimple_vdef (stmt
)) = store
;
1244 gsi_insert_before (gsi
, store
, GSI_SAME_STMT
);
1245 if (gimple_call_lhs (stmt
))
1247 gimple
*asgn
= gimple_build_assign (gimple_call_lhs (stmt
), dest
);
1248 gsi_replace (gsi
, asgn
, false);
1252 gimple_stmt_iterator gsi2
= *gsi
;
1254 gsi_remove (&gsi2
, true);
1261 /* Obtain the minimum and maximum string length or minimum and maximum
1262 value of ARG in LENGTH[0] and LENGTH[1], respectively.
1263 If ARG is an SSA name variable, follow its use-def chains. When
1264 TYPE == 0, if LENGTH[1] is not equal to the length we determine or
1265 if we are unable to determine the length or value, return false.
1266 VISITED is a bitmap of visited variables.
1267 TYPE is 0 if string length should be obtained, 1 for maximum string
1268 length and 2 for maximum value ARG can have.
1269 When FUZZY is non-zero and the length of a string cannot be determined,
1270 the function instead considers as the maximum possible length the
1271 size of a character array it may refer to. If FUZZY is 2, it will handle
1272 PHIs and COND_EXPRs optimistically, if we can determine string length
1273 minimum and maximum, it will use the minimum from the ones where it
1275 Set *FLEXP to true if the range of the string lengths has been
1276 obtained from the upper bound of an array at the end of a struct.
1277 Such an array may hold a string that's longer than its upper bound
1278 due to it being used as a poor-man's flexible array member. */
1281 get_range_strlen (tree arg
, tree length
[2], bitmap
*visited
, int type
,
1282 int fuzzy
, bool *flexp
)
1284 tree var
, val
= NULL_TREE
;
1287 /* The minimum and maximum length. */
1288 tree
*const minlen
= length
;
1289 tree
*const maxlen
= length
+ 1;
1291 if (TREE_CODE (arg
) != SSA_NAME
)
1293 /* We can end up with &(*iftmp_1)[0] here as well, so handle it. */
1294 if (TREE_CODE (arg
) == ADDR_EXPR
1295 && TREE_CODE (TREE_OPERAND (arg
, 0)) == ARRAY_REF
)
1297 tree op
= TREE_OPERAND (arg
, 0);
1298 if (integer_zerop (TREE_OPERAND (op
, 1)))
1300 tree aop0
= TREE_OPERAND (op
, 0);
1301 if (TREE_CODE (aop0
) == INDIRECT_REF
1302 && TREE_CODE (TREE_OPERAND (aop0
, 0)) == SSA_NAME
)
1303 return get_range_strlen (TREE_OPERAND (aop0
, 0),
1304 length
, visited
, type
, fuzzy
, flexp
);
1306 else if (TREE_CODE (TREE_OPERAND (op
, 0)) == COMPONENT_REF
&& fuzzy
)
1308 /* Fail if an array is the last member of a struct object
1309 since it could be treated as a (fake) flexible array
1311 tree idx
= TREE_OPERAND (op
, 1);
1313 arg
= TREE_OPERAND (op
, 0);
1314 tree optype
= TREE_TYPE (arg
);
1315 if (tree dom
= TYPE_DOMAIN (optype
))
1316 if (tree bound
= TYPE_MAX_VALUE (dom
))
1317 if (TREE_CODE (bound
) == INTEGER_CST
1318 && TREE_CODE (idx
) == INTEGER_CST
1319 && tree_int_cst_lt (bound
, idx
))
1327 if (TREE_CODE (val
) != INTEGER_CST
1328 || tree_int_cst_sgn (val
) < 0)
1332 val
= c_strlen (arg
, 1);
1336 if (TREE_CODE (arg
) == ADDR_EXPR
)
1337 return get_range_strlen (TREE_OPERAND (arg
, 0), length
,
1338 visited
, type
, fuzzy
, flexp
);
1340 if (TREE_CODE (arg
) == ARRAY_REF
)
1342 tree type
= TREE_TYPE (TREE_OPERAND (arg
, 0));
1344 /* Determine the "innermost" array type. */
1345 while (TREE_CODE (type
) == ARRAY_TYPE
1346 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
)
1347 type
= TREE_TYPE (type
);
1349 /* Avoid arrays of pointers. */
1350 tree eltype
= TREE_TYPE (type
);
1351 if (TREE_CODE (type
) != ARRAY_TYPE
1352 || !INTEGRAL_TYPE_P (eltype
))
1355 val
= TYPE_SIZE_UNIT (type
);
1356 if (!val
|| integer_zerop (val
))
1359 val
= fold_build2 (MINUS_EXPR
, TREE_TYPE (val
), val
,
1361 /* Set the minimum size to zero since the string in
1362 the array could have zero length. */
1363 *minlen
= ssize_int (0);
1365 if (TREE_CODE (TREE_OPERAND (arg
, 0)) == COMPONENT_REF
1366 && type
== TREE_TYPE (TREE_OPERAND (arg
, 0))
1367 && array_at_struct_end_p (TREE_OPERAND (arg
, 0)))
1370 else if (TREE_CODE (arg
) == COMPONENT_REF
1371 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 1)))
1374 /* Use the type of the member array to determine the upper
1375 bound on the length of the array. This may be overly
1376 optimistic if the array itself isn't NUL-terminated and
1377 the caller relies on the subsequent member to contain
1378 the NUL but that would only be considered valid if
1379 the array were the last member of a struct.
1380 Set *FLEXP to true if the array whose bound is being
1381 used is at the end of a struct. */
1382 if (array_at_struct_end_p (arg
))
1385 arg
= TREE_OPERAND (arg
, 1);
1387 tree type
= TREE_TYPE (arg
);
1389 while (TREE_CODE (type
) == ARRAY_TYPE
1390 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
)
1391 type
= TREE_TYPE (type
);
1393 /* Fail when the array bound is unknown or zero. */
1394 val
= TYPE_SIZE_UNIT (type
);
1395 if (!val
|| integer_zerop (val
))
1397 val
= fold_build2 (MINUS_EXPR
, TREE_TYPE (val
), val
,
1399 /* Set the minimum size to zero since the string in
1400 the array could have zero length. */
1401 *minlen
= ssize_int (0);
1406 tree type
= TREE_TYPE (arg
);
1407 if (POINTER_TYPE_P (type
))
1408 type
= TREE_TYPE (type
);
1410 if (TREE_CODE (type
) == ARRAY_TYPE
)
1412 val
= TYPE_SIZE_UNIT (type
);
1414 || TREE_CODE (val
) != INTEGER_CST
1415 || integer_zerop (val
))
1417 val
= wide_int_to_tree (TREE_TYPE (val
),
1418 wi::sub (wi::to_wide (val
), 1));
1419 /* Set the minimum size to zero since the string in
1420 the array could have zero length. */
1421 *minlen
= ssize_int (0);
1431 && TREE_CODE (*minlen
) == INTEGER_CST
1432 && TREE_CODE (val
) == INTEGER_CST
1433 && tree_int_cst_lt (val
, *minlen
)))
1440 if (TREE_CODE (*maxlen
) != INTEGER_CST
1441 || TREE_CODE (val
) != INTEGER_CST
)
1444 if (tree_int_cst_lt (*maxlen
, val
))
1448 else if (simple_cst_equal (val
, *maxlen
) != 1)
1456 /* If ARG is registered for SSA update we cannot look at its defining
1458 if (name_registered_for_update_p (arg
))
1461 /* If we were already here, break the infinite cycle. */
1463 *visited
= BITMAP_ALLOC (NULL
);
1464 if (!bitmap_set_bit (*visited
, SSA_NAME_VERSION (arg
)))
1468 def_stmt
= SSA_NAME_DEF_STMT (var
);
1470 switch (gimple_code (def_stmt
))
1473 /* The RHS of the statement defining VAR must either have a
1474 constant length or come from another SSA_NAME with a constant
1476 if (gimple_assign_single_p (def_stmt
)
1477 || gimple_assign_unary_nop_p (def_stmt
))
1479 tree rhs
= gimple_assign_rhs1 (def_stmt
);
1480 return get_range_strlen (rhs
, length
, visited
, type
, fuzzy
, flexp
);
1482 else if (gimple_assign_rhs_code (def_stmt
) == COND_EXPR
)
1484 tree ops
[2] = { gimple_assign_rhs2 (def_stmt
),
1485 gimple_assign_rhs3 (def_stmt
) };
1487 for (unsigned int i
= 0; i
< 2; i
++)
1488 if (!get_range_strlen (ops
[i
], length
, visited
, type
, fuzzy
,
1492 *maxlen
= build_all_ones_cst (size_type_node
);
1501 /* All the arguments of the PHI node must have the same constant
1503 for (unsigned i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1505 tree arg
= gimple_phi_arg (def_stmt
, i
)->def
;
1507 /* If this PHI has itself as an argument, we cannot
1508 determine the string length of this argument. However,
1509 if we can find a constant string length for the other
1510 PHI args then we can still be sure that this is a
1511 constant string length. So be optimistic and just
1512 continue with the next argument. */
1513 if (arg
== gimple_phi_result (def_stmt
))
1516 if (!get_range_strlen (arg
, length
, visited
, type
, fuzzy
, flexp
))
1519 *maxlen
= build_all_ones_cst (size_type_node
);
1531 /* Determine the minimum and maximum value or string length that ARG
1532 refers to and store each in the first two elements of MINMAXLEN.
1533 For expressions that point to strings of unknown lengths that are
1534 character arrays, use the upper bound of the array as the maximum
1535 length. For example, given an expression like 'x ? array : "xyz"'
1536 and array declared as 'char array[8]', MINMAXLEN[0] will be set
1537 to 0 and MINMAXLEN[1] to 7, the longest string that could be
1539 Return true if the range of the string lengths has been obtained
1540 from the upper bound of an array at the end of a struct. Such
1541 an array may hold a string that's longer than its upper bound
1542 due to it being used as a poor-man's flexible array member.
1544 STRICT is true if it will handle PHIs and COND_EXPRs conservatively
1545 and false if PHIs and COND_EXPRs are to be handled optimistically,
1546 if we can determine string length minimum and maximum; it will use
1547 the minimum from the ones where it can be determined.
1548 STRICT false should be only used for warning code. */
1551 get_range_strlen (tree arg
, tree minmaxlen
[2], bool strict
)
1553 bitmap visited
= NULL
;
1555 minmaxlen
[0] = NULL_TREE
;
1556 minmaxlen
[1] = NULL_TREE
;
1558 bool flexarray
= false;
1559 if (!get_range_strlen (arg
, minmaxlen
, &visited
, 1, strict
? 1 : 2,
1562 minmaxlen
[0] = NULL_TREE
;
1563 minmaxlen
[1] = NULL_TREE
;
1567 BITMAP_FREE (visited
);
1573 get_maxval_strlen (tree arg
, int type
)
1575 bitmap visited
= NULL
;
1576 tree len
[2] = { NULL_TREE
, NULL_TREE
};
1579 if (!get_range_strlen (arg
, len
, &visited
, type
, 0, &dummy
))
1582 BITMAP_FREE (visited
);
1588 /* Fold function call to builtin strcpy with arguments DEST and SRC.
1589 If LEN is not NULL, it represents the length of the string to be
1590 copied. Return NULL_TREE if no simplification can be made. */
1593 gimple_fold_builtin_strcpy (gimple_stmt_iterator
*gsi
,
1594 tree dest
, tree src
)
1596 gimple
*stmt
= gsi_stmt (*gsi
);
1597 location_t loc
= gimple_location (stmt
);
1600 /* If SRC and DEST are the same (and not volatile), return DEST. */
1601 if (operand_equal_p (src
, dest
, 0))
1603 /* Issue -Wrestrict unless the pointers are null (those do
1604 not point to objects and so do not indicate an overlap;
1605 such calls could be the result of sanitization and jump
1607 if (!integer_zerop (dest
) && !gimple_no_warning_p (stmt
))
1609 tree func
= gimple_call_fndecl (stmt
);
1611 warning_at (loc
, OPT_Wrestrict
,
1612 "%qD source argument is the same as destination",
1616 replace_call_with_value (gsi
, dest
);
1620 if (optimize_function_for_size_p (cfun
))
1623 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1627 tree len
= get_maxval_strlen (src
, 0);
1631 len
= fold_convert_loc (loc
, size_type_node
, len
);
1632 len
= size_binop_loc (loc
, PLUS_EXPR
, len
, build_int_cst (size_type_node
, 1));
1633 len
= force_gimple_operand_gsi (gsi
, len
, true,
1634 NULL_TREE
, true, GSI_SAME_STMT
);
1635 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
1636 replace_call_with_call_and_fold (gsi
, repl
);
1640 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
1641 If SLEN is not NULL, it represents the length of the source string.
1642 Return NULL_TREE if no simplification can be made. */
1645 gimple_fold_builtin_strncpy (gimple_stmt_iterator
*gsi
,
1646 tree dest
, tree src
, tree len
)
1648 gimple
*stmt
= gsi_stmt (*gsi
);
1649 location_t loc
= gimple_location (stmt
);
1650 bool nonstring
= get_attr_nonstring_decl (dest
) != NULL_TREE
;
1652 /* If the LEN parameter is zero, return DEST. */
1653 if (integer_zerop (len
))
1655 /* Avoid warning if the destination refers to a an array/pointer
1656 decorate with attribute nonstring. */
1659 tree fndecl
= gimple_call_fndecl (stmt
);
1660 gcall
*call
= as_a
<gcall
*> (stmt
);
1662 /* Warn about the lack of nul termination: the result is not
1663 a (nul-terminated) string. */
1664 tree slen
= get_maxval_strlen (src
, 0);
1665 if (slen
&& !integer_zerop (slen
))
1666 warning_at (loc
, OPT_Wstringop_truncation
,
1667 "%G%qD destination unchanged after copying no bytes "
1668 "from a string of length %E",
1669 call
, fndecl
, slen
);
1671 warning_at (loc
, OPT_Wstringop_truncation
,
1672 "%G%qD destination unchanged after copying no bytes",
1676 replace_call_with_value (gsi
, dest
);
1680 /* We can't compare slen with len as constants below if len is not a
1682 if (TREE_CODE (len
) != INTEGER_CST
)
1685 /* Now, we must be passed a constant src ptr parameter. */
1686 tree slen
= get_maxval_strlen (src
, 0);
1687 if (!slen
|| TREE_CODE (slen
) != INTEGER_CST
)
1690 /* The size of the source string including the terminating nul. */
1691 tree ssize
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
1693 /* We do not support simplification of this case, though we do
1694 support it when expanding trees into RTL. */
1695 /* FIXME: generate a call to __builtin_memset. */
1696 if (tree_int_cst_lt (ssize
, len
))
1699 /* Diagnose truncation that leaves the copy unterminated. */
1700 maybe_diag_stxncpy_trunc (*gsi
, src
, len
);
1702 /* OK transform into builtin memcpy. */
1703 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1707 len
= fold_convert_loc (loc
, size_type_node
, len
);
1708 len
= force_gimple_operand_gsi (gsi
, len
, true,
1709 NULL_TREE
, true, GSI_SAME_STMT
);
1710 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
1711 replace_call_with_call_and_fold (gsi
, repl
);
1716 /* Fold function call to builtin strchr or strrchr.
1717 If both arguments are constant, evaluate and fold the result,
1718 otherwise simplify str(r)chr (str, 0) into str + strlen (str).
1719 In general strlen is significantly faster than strchr
1720 due to being a simpler operation. */
1722 gimple_fold_builtin_strchr (gimple_stmt_iterator
*gsi
, bool is_strrchr
)
1724 gimple
*stmt
= gsi_stmt (*gsi
);
1725 tree str
= gimple_call_arg (stmt
, 0);
1726 tree c
= gimple_call_arg (stmt
, 1);
1727 location_t loc
= gimple_location (stmt
);
1731 if (!gimple_call_lhs (stmt
))
1734 if ((p
= c_getstr (str
)) && target_char_cst_p (c
, &ch
))
1736 const char *p1
= is_strrchr
? strrchr (p
, ch
) : strchr (p
, ch
);
1740 replace_call_with_value (gsi
, integer_zero_node
);
1744 tree len
= build_int_cst (size_type_node
, p1
- p
);
1745 gimple_seq stmts
= NULL
;
1746 gimple
*new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
1747 POINTER_PLUS_EXPR
, str
, len
);
1748 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
1749 gsi_replace_with_seq_vops (gsi
, stmts
);
1753 if (!integer_zerop (c
))
1756 /* Transform strrchr (s, 0) to strchr (s, 0) when optimizing for size. */
1757 if (is_strrchr
&& optimize_function_for_size_p (cfun
))
1759 tree strchr_fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
1763 gimple
*repl
= gimple_build_call (strchr_fn
, 2, str
, c
);
1764 replace_call_with_call_and_fold (gsi
, repl
);
1772 tree strlen_fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
1777 /* Create newstr = strlen (str). */
1778 gimple_seq stmts
= NULL
;
1779 gimple
*new_stmt
= gimple_build_call (strlen_fn
, 1, str
);
1780 gimple_set_location (new_stmt
, loc
);
1781 len
= create_tmp_reg_or_ssa_name (size_type_node
);
1782 gimple_call_set_lhs (new_stmt
, len
);
1783 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
1785 /* Create (str p+ strlen (str)). */
1786 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
1787 POINTER_PLUS_EXPR
, str
, len
);
1788 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
1789 gsi_replace_with_seq_vops (gsi
, stmts
);
1790 /* gsi now points at the assignment to the lhs, get a
1791 stmt iterator to the strlen.
1792 ??? We can't use gsi_for_stmt as that doesn't work when the
1793 CFG isn't built yet. */
1794 gimple_stmt_iterator gsi2
= *gsi
;
1800 /* Fold function call to builtin strstr.
1801 If both arguments are constant, evaluate and fold the result,
1802 additionally fold strstr (x, "") into x and strstr (x, "c")
1803 into strchr (x, 'c'). */
1805 gimple_fold_builtin_strstr (gimple_stmt_iterator
*gsi
)
1807 gimple
*stmt
= gsi_stmt (*gsi
);
1808 tree haystack
= gimple_call_arg (stmt
, 0);
1809 tree needle
= gimple_call_arg (stmt
, 1);
1812 if (!gimple_call_lhs (stmt
))
1815 q
= c_getstr (needle
);
1819 if ((p
= c_getstr (haystack
)))
1821 const char *r
= strstr (p
, q
);
1825 replace_call_with_value (gsi
, integer_zero_node
);
1829 tree len
= build_int_cst (size_type_node
, r
- p
);
1830 gimple_seq stmts
= NULL
;
1832 = gimple_build_assign (gimple_call_lhs (stmt
), POINTER_PLUS_EXPR
,
1834 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
1835 gsi_replace_with_seq_vops (gsi
, stmts
);
1839 /* For strstr (x, "") return x. */
1842 replace_call_with_value (gsi
, haystack
);
1846 /* Transform strstr (x, "c") into strchr (x, 'c'). */
1849 tree strchr_fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
1852 tree c
= build_int_cst (integer_type_node
, q
[0]);
1853 gimple
*repl
= gimple_build_call (strchr_fn
, 2, haystack
, c
);
1854 replace_call_with_call_and_fold (gsi
, repl
);
1862 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
1865 Return NULL_TREE if no simplification was possible, otherwise return the
1866 simplified form of the call as a tree.
1868 The simplified form may be a constant or other expression which
1869 computes the same value, but in a more efficient manner (including
1870 calls to other builtin functions).
1872 The call may contain arguments which need to be evaluated, but
1873 which are not useful to determine the result of the call. In
1874 this case we return a chain of COMPOUND_EXPRs. The LHS of each
1875 COMPOUND_EXPR will be an argument which must be evaluated.
1876 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
1877 COMPOUND_EXPR in the chain will contain the tree for the simplified
1878 form of the builtin function call. */
1881 gimple_fold_builtin_strcat (gimple_stmt_iterator
*gsi
, tree dst
, tree src
)
1883 gimple
*stmt
= gsi_stmt (*gsi
);
1884 location_t loc
= gimple_location (stmt
);
1886 const char *p
= c_getstr (src
);
1888 /* If the string length is zero, return the dst parameter. */
1889 if (p
&& *p
== '\0')
1891 replace_call_with_value (gsi
, dst
);
1895 if (!optimize_bb_for_speed_p (gimple_bb (stmt
)))
1898 /* See if we can store by pieces into (dst + strlen(dst)). */
1900 tree strlen_fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
1901 tree memcpy_fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1903 if (!strlen_fn
|| !memcpy_fn
)
1906 /* If the length of the source string isn't computable don't
1907 split strcat into strlen and memcpy. */
1908 tree len
= get_maxval_strlen (src
, 0);
1912 /* Create strlen (dst). */
1913 gimple_seq stmts
= NULL
, stmts2
;
1914 gimple
*repl
= gimple_build_call (strlen_fn
, 1, dst
);
1915 gimple_set_location (repl
, loc
);
1916 newdst
= create_tmp_reg_or_ssa_name (size_type_node
);
1917 gimple_call_set_lhs (repl
, newdst
);
1918 gimple_seq_add_stmt_without_update (&stmts
, repl
);
1920 /* Create (dst p+ strlen (dst)). */
1921 newdst
= fold_build_pointer_plus_loc (loc
, dst
, newdst
);
1922 newdst
= force_gimple_operand (newdst
, &stmts2
, true, NULL_TREE
);
1923 gimple_seq_add_seq_without_update (&stmts
, stmts2
);
1925 len
= fold_convert_loc (loc
, size_type_node
, len
);
1926 len
= size_binop_loc (loc
, PLUS_EXPR
, len
,
1927 build_int_cst (size_type_node
, 1));
1928 len
= force_gimple_operand (len
, &stmts2
, true, NULL_TREE
);
1929 gimple_seq_add_seq_without_update (&stmts
, stmts2
);
1931 repl
= gimple_build_call (memcpy_fn
, 3, newdst
, src
, len
);
1932 gimple_seq_add_stmt_without_update (&stmts
, repl
);
1933 if (gimple_call_lhs (stmt
))
1935 repl
= gimple_build_assign (gimple_call_lhs (stmt
), dst
);
1936 gimple_seq_add_stmt_without_update (&stmts
, repl
);
1937 gsi_replace_with_seq_vops (gsi
, stmts
);
1938 /* gsi now points at the assignment to the lhs, get a
1939 stmt iterator to the memcpy call.
1940 ??? We can't use gsi_for_stmt as that doesn't work when the
1941 CFG isn't built yet. */
1942 gimple_stmt_iterator gsi2
= *gsi
;
1948 gsi_replace_with_seq_vops (gsi
, stmts
);
1954 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
1955 are the arguments to the call. */
1958 gimple_fold_builtin_strcat_chk (gimple_stmt_iterator
*gsi
)
1960 gimple
*stmt
= gsi_stmt (*gsi
);
1961 tree dest
= gimple_call_arg (stmt
, 0);
1962 tree src
= gimple_call_arg (stmt
, 1);
1963 tree size
= gimple_call_arg (stmt
, 2);
1969 /* If the SRC parameter is "", return DEST. */
1970 if (p
&& *p
== '\0')
1972 replace_call_with_value (gsi
, dest
);
1976 if (! tree_fits_uhwi_p (size
) || ! integer_all_onesp (size
))
1979 /* If __builtin_strcat_chk is used, assume strcat is available. */
1980 fn
= builtin_decl_explicit (BUILT_IN_STRCAT
);
1984 gimple
*repl
= gimple_build_call (fn
, 2, dest
, src
);
1985 replace_call_with_call_and_fold (gsi
, repl
);
1989 /* Simplify a call to the strncat builtin. */
1992 gimple_fold_builtin_strncat (gimple_stmt_iterator
*gsi
)
1994 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
1995 tree dst
= gimple_call_arg (stmt
, 0);
1996 tree src
= gimple_call_arg (stmt
, 1);
1997 tree len
= gimple_call_arg (stmt
, 2);
1999 const char *p
= c_getstr (src
);
2001 /* If the requested length is zero, or the src parameter string
2002 length is zero, return the dst parameter. */
2003 if (integer_zerop (len
) || (p
&& *p
== '\0'))
2005 replace_call_with_value (gsi
, dst
);
2009 if (TREE_CODE (len
) != INTEGER_CST
|| !p
)
2012 unsigned srclen
= strlen (p
);
2014 int cmpsrc
= compare_tree_int (len
, srclen
);
2016 /* Return early if the requested len is less than the string length.
2017 Warnings will be issued elsewhere later. */
2021 unsigned HOST_WIDE_INT dstsize
;
2023 bool nowarn
= gimple_no_warning_p (stmt
);
2025 if (!nowarn
&& compute_builtin_object_size (dst
, 1, &dstsize
))
2027 int cmpdst
= compare_tree_int (len
, dstsize
);
2031 tree fndecl
= gimple_call_fndecl (stmt
);
2033 /* Strncat copies (at most) LEN bytes and always appends
2034 the terminating NUL so the specified bound should never
2035 be equal to (or greater than) the size of the destination.
2036 If it is, the copy could overflow. */
2037 location_t loc
= gimple_location (stmt
);
2038 nowarn
= warning_at (loc
, OPT_Wstringop_overflow_
,
2040 ? G_("%G%qD specified bound %E equals "
2042 : G_("%G%qD specified bound %E exceeds "
2043 "destination size %wu"),
2044 stmt
, fndecl
, len
, dstsize
);
2046 gimple_set_no_warning (stmt
, true);
2050 if (!nowarn
&& cmpsrc
== 0)
2052 tree fndecl
= gimple_call_fndecl (stmt
);
2053 location_t loc
= gimple_location (stmt
);
2055 /* To avoid possible overflow the specified bound should also
2056 not be equal to the length of the source, even when the size
2057 of the destination is unknown (it's not an uncommon mistake
2058 to specify as the bound to strncpy the length of the source). */
2059 if (warning_at (loc
, OPT_Wstringop_overflow_
,
2060 "%G%qD specified bound %E equals source length",
2062 gimple_set_no_warning (stmt
, true);
2065 tree fn
= builtin_decl_implicit (BUILT_IN_STRCAT
);
2067 /* If the replacement _DECL isn't initialized, don't do the
2072 /* Otherwise, emit a call to strcat. */
2073 gcall
*repl
= gimple_build_call (fn
, 2, dst
, src
);
2074 replace_call_with_call_and_fold (gsi
, repl
);
2078 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
2082 gimple_fold_builtin_strncat_chk (gimple_stmt_iterator
*gsi
)
2084 gimple
*stmt
= gsi_stmt (*gsi
);
2085 tree dest
= gimple_call_arg (stmt
, 0);
2086 tree src
= gimple_call_arg (stmt
, 1);
2087 tree len
= gimple_call_arg (stmt
, 2);
2088 tree size
= gimple_call_arg (stmt
, 3);
2093 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
2094 if ((p
&& *p
== '\0')
2095 || integer_zerop (len
))
2097 replace_call_with_value (gsi
, dest
);
2101 if (! tree_fits_uhwi_p (size
))
2104 if (! integer_all_onesp (size
))
2106 tree src_len
= c_strlen (src
, 1);
2108 && tree_fits_uhwi_p (src_len
)
2109 && tree_fits_uhwi_p (len
)
2110 && ! tree_int_cst_lt (len
, src_len
))
2112 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
2113 fn
= builtin_decl_explicit (BUILT_IN_STRCAT_CHK
);
2117 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, size
);
2118 replace_call_with_call_and_fold (gsi
, repl
);
2124 /* If __builtin_strncat_chk is used, assume strncat is available. */
2125 fn
= builtin_decl_explicit (BUILT_IN_STRNCAT
);
2129 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2130 replace_call_with_call_and_fold (gsi
, repl
);
2134 /* Build and append gimple statements to STMTS that would load a first
2135 character of a memory location identified by STR. LOC is location
2136 of the statement. */
2139 gimple_load_first_char (location_t loc
, tree str
, gimple_seq
*stmts
)
2143 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
2144 tree cst_uchar_ptr_node
2145 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
2146 tree off0
= build_int_cst (cst_uchar_ptr_node
, 0);
2148 tree temp
= fold_build2_loc (loc
, MEM_REF
, cst_uchar_node
, str
, off0
);
2149 gassign
*stmt
= gimple_build_assign (NULL_TREE
, temp
);
2150 var
= create_tmp_reg_or_ssa_name (cst_uchar_node
, stmt
);
2152 gimple_assign_set_lhs (stmt
, var
);
2153 gimple_seq_add_stmt_without_update (stmts
, stmt
);
2158 /* Fold a call to the str{n}{case}cmp builtin pointed by GSI iterator.
2159 FCODE is the name of the builtin. */
2162 gimple_fold_builtin_string_compare (gimple_stmt_iterator
*gsi
)
2164 gimple
*stmt
= gsi_stmt (*gsi
);
2165 tree callee
= gimple_call_fndecl (stmt
);
2166 enum built_in_function fcode
= DECL_FUNCTION_CODE (callee
);
2168 tree type
= integer_type_node
;
2169 tree str1
= gimple_call_arg (stmt
, 0);
2170 tree str2
= gimple_call_arg (stmt
, 1);
2171 tree lhs
= gimple_call_lhs (stmt
);
2172 HOST_WIDE_INT length
= -1;
2174 /* Handle strncmp and strncasecmp functions. */
2175 if (gimple_call_num_args (stmt
) == 3)
2177 tree len
= gimple_call_arg (stmt
, 2);
2178 if (tree_fits_uhwi_p (len
))
2179 length
= tree_to_uhwi (len
);
2182 /* If the LEN parameter is zero, return zero. */
2185 replace_call_with_value (gsi
, integer_zero_node
);
2189 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
2190 if (operand_equal_p (str1
, str2
, 0))
2192 replace_call_with_value (gsi
, integer_zero_node
);
2196 const char *p1
= c_getstr (str1
);
2197 const char *p2
= c_getstr (str2
);
2199 /* For known strings, return an immediate value. */
2203 bool known_result
= false;
2207 case BUILT_IN_STRCMP
:
2208 case BUILT_IN_STRCMP_EQ
:
2210 r
= strcmp (p1
, p2
);
2211 known_result
= true;
2214 case BUILT_IN_STRNCMP
:
2215 case BUILT_IN_STRNCMP_EQ
:
2219 r
= strncmp (p1
, p2
, length
);
2220 known_result
= true;
2223 /* Only handleable situation is where the string are equal (result 0),
2224 which is already handled by operand_equal_p case. */
2225 case BUILT_IN_STRCASECMP
:
2227 case BUILT_IN_STRNCASECMP
:
2231 r
= strncmp (p1
, p2
, length
);
2233 known_result
= true;
2242 replace_call_with_value (gsi
, build_cmp_result (type
, r
));
2247 bool nonzero_length
= length
>= 1
2248 || fcode
== BUILT_IN_STRCMP
2249 || fcode
== BUILT_IN_STRCMP_EQ
2250 || fcode
== BUILT_IN_STRCASECMP
;
2252 location_t loc
= gimple_location (stmt
);
2254 /* If the second arg is "", return *(const unsigned char*)arg1. */
2255 if (p2
&& *p2
== '\0' && nonzero_length
)
2257 gimple_seq stmts
= NULL
;
2258 tree var
= gimple_load_first_char (loc
, str1
, &stmts
);
2261 stmt
= gimple_build_assign (lhs
, NOP_EXPR
, var
);
2262 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2265 gsi_replace_with_seq_vops (gsi
, stmts
);
2269 /* If the first arg is "", return -*(const unsigned char*)arg2. */
2270 if (p1
&& *p1
== '\0' && nonzero_length
)
2272 gimple_seq stmts
= NULL
;
2273 tree var
= gimple_load_first_char (loc
, str2
, &stmts
);
2277 tree c
= create_tmp_reg_or_ssa_name (integer_type_node
);
2278 stmt
= gimple_build_assign (c
, NOP_EXPR
, var
);
2279 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2281 stmt
= gimple_build_assign (lhs
, NEGATE_EXPR
, c
);
2282 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2285 gsi_replace_with_seq_vops (gsi
, stmts
);
2289 /* If len parameter is one, return an expression corresponding to
2290 (*(const unsigned char*)arg2 - *(const unsigned char*)arg1). */
2291 if (fcode
== BUILT_IN_STRNCMP
&& length
== 1)
2293 gimple_seq stmts
= NULL
;
2294 tree temp1
= gimple_load_first_char (loc
, str1
, &stmts
);
2295 tree temp2
= gimple_load_first_char (loc
, str2
, &stmts
);
2299 tree c1
= create_tmp_reg_or_ssa_name (integer_type_node
);
2300 gassign
*convert1
= gimple_build_assign (c1
, NOP_EXPR
, temp1
);
2301 gimple_seq_add_stmt_without_update (&stmts
, convert1
);
2303 tree c2
= create_tmp_reg_or_ssa_name (integer_type_node
);
2304 gassign
*convert2
= gimple_build_assign (c2
, NOP_EXPR
, temp2
);
2305 gimple_seq_add_stmt_without_update (&stmts
, convert2
);
2307 stmt
= gimple_build_assign (lhs
, MINUS_EXPR
, c1
, c2
);
2308 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2311 gsi_replace_with_seq_vops (gsi
, stmts
);
2315 /* If length is larger than the length of one constant string,
2316 replace strncmp with corresponding strcmp */
2317 if (fcode
== BUILT_IN_STRNCMP
2319 && ((p2
&& (size_t) length
> strlen (p2
))
2320 || (p1
&& (size_t) length
> strlen (p1
))))
2322 tree fn
= builtin_decl_implicit (BUILT_IN_STRCMP
);
2325 gimple
*repl
= gimple_build_call (fn
, 2, str1
, str2
);
2326 replace_call_with_call_and_fold (gsi
, repl
);
2333 /* Fold a call to the memchr pointed by GSI iterator. */
2336 gimple_fold_builtin_memchr (gimple_stmt_iterator
*gsi
)
2338 gimple
*stmt
= gsi_stmt (*gsi
);
2339 tree lhs
= gimple_call_lhs (stmt
);
2340 tree arg1
= gimple_call_arg (stmt
, 0);
2341 tree arg2
= gimple_call_arg (stmt
, 1);
2342 tree len
= gimple_call_arg (stmt
, 2);
2344 /* If the LEN parameter is zero, return zero. */
2345 if (integer_zerop (len
))
2347 replace_call_with_value (gsi
, build_int_cst (ptr_type_node
, 0));
2352 if (TREE_CODE (arg2
) != INTEGER_CST
2353 || !tree_fits_uhwi_p (len
)
2354 || !target_char_cst_p (arg2
, &c
))
2357 unsigned HOST_WIDE_INT length
= tree_to_uhwi (len
);
2358 unsigned HOST_WIDE_INT string_length
;
2359 const char *p1
= c_getstr (arg1
, &string_length
);
2363 const char *r
= (const char *)memchr (p1
, c
, MIN (length
, string_length
));
2366 if (length
<= string_length
)
2368 replace_call_with_value (gsi
, build_int_cst (ptr_type_node
, 0));
2374 unsigned HOST_WIDE_INT offset
= r
- p1
;
2375 gimple_seq stmts
= NULL
;
2376 if (lhs
!= NULL_TREE
)
2378 tree offset_cst
= build_int_cst (TREE_TYPE (len
), offset
);
2379 gassign
*stmt
= gimple_build_assign (lhs
, POINTER_PLUS_EXPR
,
2381 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2384 gimple_seq_add_stmt_without_update (&stmts
,
2385 gimple_build_nop ());
2387 gsi_replace_with_seq_vops (gsi
, stmts
);
2395 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
2396 to the call. IGNORE is true if the value returned
2397 by the builtin will be ignored. UNLOCKED is true is true if this
2398 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
2399 the known length of the string. Return NULL_TREE if no simplification
2403 gimple_fold_builtin_fputs (gimple_stmt_iterator
*gsi
,
2404 tree arg0
, tree arg1
,
2407 gimple
*stmt
= gsi_stmt (*gsi
);
2409 /* If we're using an unlocked function, assume the other unlocked
2410 functions exist explicitly. */
2411 tree
const fn_fputc
= (unlocked
2412 ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED
)
2413 : builtin_decl_implicit (BUILT_IN_FPUTC
));
2414 tree
const fn_fwrite
= (unlocked
2415 ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED
)
2416 : builtin_decl_implicit (BUILT_IN_FWRITE
));
2418 /* If the return value is used, don't do the transformation. */
2419 if (gimple_call_lhs (stmt
))
2422 /* Get the length of the string passed to fputs. If the length
2423 can't be determined, punt. */
2424 tree len
= get_maxval_strlen (arg0
, 0);
2426 || TREE_CODE (len
) != INTEGER_CST
)
2429 switch (compare_tree_int (len
, 1))
2431 case -1: /* length is 0, delete the call entirely . */
2432 replace_call_with_value (gsi
, integer_zero_node
);
2435 case 0: /* length is 1, call fputc. */
2437 const char *p
= c_getstr (arg0
);
2443 gimple
*repl
= gimple_build_call (fn_fputc
, 2,
2445 (integer_type_node
, p
[0]), arg1
);
2446 replace_call_with_call_and_fold (gsi
, repl
);
2451 case 1: /* length is greater than 1, call fwrite. */
2453 /* If optimizing for size keep fputs. */
2454 if (optimize_function_for_size_p (cfun
))
2456 /* New argument list transforming fputs(string, stream) to
2457 fwrite(string, 1, len, stream). */
2461 gimple
*repl
= gimple_build_call (fn_fwrite
, 4, arg0
,
2462 size_one_node
, len
, arg1
);
2463 replace_call_with_call_and_fold (gsi
, repl
);
2472 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
2473 DEST, SRC, LEN, and SIZE are the arguments to the call.
2474 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
2475 code of the builtin. If MAXLEN is not NULL, it is maximum length
2476 passed as third argument. */
2479 gimple_fold_builtin_memory_chk (gimple_stmt_iterator
*gsi
,
2480 tree dest
, tree src
, tree len
, tree size
,
2481 enum built_in_function fcode
)
2483 gimple
*stmt
= gsi_stmt (*gsi
);
2484 location_t loc
= gimple_location (stmt
);
2485 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
2488 /* If SRC and DEST are the same (and not volatile), return DEST
2489 (resp. DEST+LEN for __mempcpy_chk). */
2490 if (fcode
!= BUILT_IN_MEMSET_CHK
&& operand_equal_p (src
, dest
, 0))
2492 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
2494 replace_call_with_value (gsi
, dest
);
2499 gimple_seq stmts
= NULL
;
2500 len
= gimple_convert_to_ptrofftype (&stmts
, loc
, len
);
2501 tree temp
= gimple_build (&stmts
, loc
, POINTER_PLUS_EXPR
,
2502 TREE_TYPE (dest
), dest
, len
);
2503 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
2504 replace_call_with_value (gsi
, temp
);
2509 if (! tree_fits_uhwi_p (size
))
2512 tree maxlen
= get_maxval_strlen (len
, 2);
2513 if (! integer_all_onesp (size
))
2515 if (! tree_fits_uhwi_p (len
))
2517 /* If LEN is not constant, try MAXLEN too.
2518 For MAXLEN only allow optimizing into non-_ocs function
2519 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
2520 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
2522 if (fcode
== BUILT_IN_MEMPCPY_CHK
&& ignore
)
2524 /* (void) __mempcpy_chk () can be optimized into
2525 (void) __memcpy_chk (). */
2526 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
2530 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
2531 replace_call_with_call_and_fold (gsi
, repl
);
2540 if (tree_int_cst_lt (size
, maxlen
))
2545 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
2546 mem{cpy,pcpy,move,set} is available. */
2549 case BUILT_IN_MEMCPY_CHK
:
2550 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY
);
2552 case BUILT_IN_MEMPCPY_CHK
:
2553 fn
= builtin_decl_explicit (BUILT_IN_MEMPCPY
);
2555 case BUILT_IN_MEMMOVE_CHK
:
2556 fn
= builtin_decl_explicit (BUILT_IN_MEMMOVE
);
2558 case BUILT_IN_MEMSET_CHK
:
2559 fn
= builtin_decl_explicit (BUILT_IN_MEMSET
);
2568 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2569 replace_call_with_call_and_fold (gsi
, repl
);
2573 /* Fold a call to the __st[rp]cpy_chk builtin.
2574 DEST, SRC, and SIZE are the arguments to the call.
2575 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
2576 code of the builtin. If MAXLEN is not NULL, it is maximum length of
2577 strings passed as second argument. */
2580 gimple_fold_builtin_stxcpy_chk (gimple_stmt_iterator
*gsi
,
2582 tree src
, tree size
,
2583 enum built_in_function fcode
)
2585 gimple
*stmt
= gsi_stmt (*gsi
);
2586 location_t loc
= gimple_location (stmt
);
2587 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
2590 /* If SRC and DEST are the same (and not volatile), return DEST. */
2591 if (fcode
== BUILT_IN_STRCPY_CHK
&& operand_equal_p (src
, dest
, 0))
2593 /* Issue -Wrestrict unless the pointers are null (those do
2594 not point to objects and so do not indicate an overlap;
2595 such calls could be the result of sanitization and jump
2597 if (!integer_zerop (dest
) && !gimple_no_warning_p (stmt
))
2599 tree func
= gimple_call_fndecl (stmt
);
2601 warning_at (loc
, OPT_Wrestrict
,
2602 "%qD source argument is the same as destination",
2606 replace_call_with_value (gsi
, dest
);
2610 if (! tree_fits_uhwi_p (size
))
2613 tree maxlen
= get_maxval_strlen (src
, 1);
2614 if (! integer_all_onesp (size
))
2616 len
= c_strlen (src
, 1);
2617 if (! len
|| ! tree_fits_uhwi_p (len
))
2619 /* If LEN is not constant, try MAXLEN too.
2620 For MAXLEN only allow optimizing into non-_ocs function
2621 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
2622 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
2624 if (fcode
== BUILT_IN_STPCPY_CHK
)
2629 /* If return value of __stpcpy_chk is ignored,
2630 optimize into __strcpy_chk. */
2631 fn
= builtin_decl_explicit (BUILT_IN_STRCPY_CHK
);
2635 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, size
);
2636 replace_call_with_call_and_fold (gsi
, repl
);
2640 if (! len
|| TREE_SIDE_EFFECTS (len
))
2643 /* If c_strlen returned something, but not a constant,
2644 transform __strcpy_chk into __memcpy_chk. */
2645 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
2649 gimple_seq stmts
= NULL
;
2650 len
= gimple_convert (&stmts
, loc
, size_type_node
, len
);
2651 len
= gimple_build (&stmts
, loc
, PLUS_EXPR
, size_type_node
, len
,
2652 build_int_cst (size_type_node
, 1));
2653 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
2654 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
2655 replace_call_with_call_and_fold (gsi
, repl
);
2662 if (! tree_int_cst_lt (maxlen
, size
))
2666 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
2667 fn
= builtin_decl_explicit (fcode
== BUILT_IN_STPCPY_CHK
2668 ? BUILT_IN_STPCPY
: BUILT_IN_STRCPY
);
2672 gimple
*repl
= gimple_build_call (fn
, 2, dest
, src
);
2673 replace_call_with_call_and_fold (gsi
, repl
);
2677 /* Fold a call to the __st{r,p}ncpy_chk builtin. DEST, SRC, LEN, and SIZE
2678 are the arguments to the call. If MAXLEN is not NULL, it is maximum
2679 length passed as third argument. IGNORE is true if return value can be
2680 ignored. FCODE is the BUILT_IN_* code of the builtin. */
2683 gimple_fold_builtin_stxncpy_chk (gimple_stmt_iterator
*gsi
,
2684 tree dest
, tree src
,
2685 tree len
, tree size
,
2686 enum built_in_function fcode
)
2688 gimple
*stmt
= gsi_stmt (*gsi
);
2689 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
2692 if (fcode
== BUILT_IN_STPNCPY_CHK
&& ignore
)
2694 /* If return value of __stpncpy_chk is ignored,
2695 optimize into __strncpy_chk. */
2696 fn
= builtin_decl_explicit (BUILT_IN_STRNCPY_CHK
);
2699 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
2700 replace_call_with_call_and_fold (gsi
, repl
);
2705 if (! tree_fits_uhwi_p (size
))
2708 tree maxlen
= get_maxval_strlen (len
, 2);
2709 if (! integer_all_onesp (size
))
2711 if (! tree_fits_uhwi_p (len
))
2713 /* If LEN is not constant, try MAXLEN too.
2714 For MAXLEN only allow optimizing into non-_ocs function
2715 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
2716 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
2722 if (tree_int_cst_lt (size
, maxlen
))
2726 /* If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available. */
2727 fn
= builtin_decl_explicit (fcode
== BUILT_IN_STPNCPY_CHK
2728 ? BUILT_IN_STPNCPY
: BUILT_IN_STRNCPY
);
2732 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2733 replace_call_with_call_and_fold (gsi
, repl
);
2737 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
2738 Return NULL_TREE if no simplification can be made. */
2741 gimple_fold_builtin_stpcpy (gimple_stmt_iterator
*gsi
)
2743 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
2744 location_t loc
= gimple_location (stmt
);
2745 tree dest
= gimple_call_arg (stmt
, 0);
2746 tree src
= gimple_call_arg (stmt
, 1);
2747 tree fn
, len
, lenp1
;
2749 /* If the result is unused, replace stpcpy with strcpy. */
2750 if (gimple_call_lhs (stmt
) == NULL_TREE
)
2752 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
2755 gimple_call_set_fndecl (stmt
, fn
);
2760 len
= c_strlen (src
, 1);
2762 || TREE_CODE (len
) != INTEGER_CST
)
2765 if (optimize_function_for_size_p (cfun
)
2766 /* If length is zero it's small enough. */
2767 && !integer_zerop (len
))
2770 /* If the source has a known length replace stpcpy with memcpy. */
2771 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
2775 gimple_seq stmts
= NULL
;
2776 tree tem
= gimple_convert (&stmts
, loc
, size_type_node
, len
);
2777 lenp1
= gimple_build (&stmts
, loc
, PLUS_EXPR
, size_type_node
,
2778 tem
, build_int_cst (size_type_node
, 1));
2779 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
2780 gcall
*repl
= gimple_build_call (fn
, 3, dest
, src
, lenp1
);
2781 gimple_set_vuse (repl
, gimple_vuse (stmt
));
2782 gimple_set_vdef (repl
, gimple_vdef (stmt
));
2783 if (gimple_vdef (repl
)
2784 && TREE_CODE (gimple_vdef (repl
)) == SSA_NAME
)
2785 SSA_NAME_DEF_STMT (gimple_vdef (repl
)) = repl
;
2786 gsi_insert_before (gsi
, repl
, GSI_SAME_STMT
);
2787 /* Replace the result with dest + len. */
2789 tem
= gimple_convert (&stmts
, loc
, sizetype
, len
);
2790 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
2791 gassign
*ret
= gimple_build_assign (gimple_call_lhs (stmt
),
2792 POINTER_PLUS_EXPR
, dest
, tem
);
2793 gsi_replace (gsi
, ret
, false);
2794 /* Finally fold the memcpy call. */
2795 gimple_stmt_iterator gsi2
= *gsi
;
2801 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS. Return
2802 NULL_TREE if a normal call should be emitted rather than expanding
2803 the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
2804 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
2805 passed as second argument. */
2808 gimple_fold_builtin_snprintf_chk (gimple_stmt_iterator
*gsi
,
2809 enum built_in_function fcode
)
2811 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
2812 tree dest
, size
, len
, fn
, fmt
, flag
;
2813 const char *fmt_str
;
2815 /* Verify the required arguments in the original call. */
2816 if (gimple_call_num_args (stmt
) < 5)
2819 dest
= gimple_call_arg (stmt
, 0);
2820 len
= gimple_call_arg (stmt
, 1);
2821 flag
= gimple_call_arg (stmt
, 2);
2822 size
= gimple_call_arg (stmt
, 3);
2823 fmt
= gimple_call_arg (stmt
, 4);
2825 if (! tree_fits_uhwi_p (size
))
2828 if (! integer_all_onesp (size
))
2830 tree maxlen
= get_maxval_strlen (len
, 2);
2831 if (! tree_fits_uhwi_p (len
))
2833 /* If LEN is not constant, try MAXLEN too.
2834 For MAXLEN only allow optimizing into non-_ocs function
2835 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
2836 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
2842 if (tree_int_cst_lt (size
, maxlen
))
2846 if (!init_target_chars ())
2849 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
2850 or if format doesn't contain % chars or is "%s". */
2851 if (! integer_zerop (flag
))
2853 fmt_str
= c_getstr (fmt
);
2854 if (fmt_str
== NULL
)
2856 if (strchr (fmt_str
, target_percent
) != NULL
2857 && strcmp (fmt_str
, target_percent_s
))
2861 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
2863 fn
= builtin_decl_explicit (fcode
== BUILT_IN_VSNPRINTF_CHK
2864 ? BUILT_IN_VSNPRINTF
: BUILT_IN_SNPRINTF
);
2868 /* Replace the called function and the first 5 argument by 3 retaining
2869 trailing varargs. */
2870 gimple_call_set_fndecl (stmt
, fn
);
2871 gimple_call_set_fntype (stmt
, TREE_TYPE (fn
));
2872 gimple_call_set_arg (stmt
, 0, dest
);
2873 gimple_call_set_arg (stmt
, 1, len
);
2874 gimple_call_set_arg (stmt
, 2, fmt
);
2875 for (unsigned i
= 3; i
< gimple_call_num_args (stmt
) - 2; ++i
)
2876 gimple_call_set_arg (stmt
, i
, gimple_call_arg (stmt
, i
+ 2));
2877 gimple_set_num_ops (stmt
, gimple_num_ops (stmt
) - 2);
2882 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
2883 Return NULL_TREE if a normal call should be emitted rather than
2884 expanding the function inline. FCODE is either BUILT_IN_SPRINTF_CHK
2885 or BUILT_IN_VSPRINTF_CHK. */
2888 gimple_fold_builtin_sprintf_chk (gimple_stmt_iterator
*gsi
,
2889 enum built_in_function fcode
)
2891 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
2892 tree dest
, size
, len
, fn
, fmt
, flag
;
2893 const char *fmt_str
;
2894 unsigned nargs
= gimple_call_num_args (stmt
);
2896 /* Verify the required arguments in the original call. */
2899 dest
= gimple_call_arg (stmt
, 0);
2900 flag
= gimple_call_arg (stmt
, 1);
2901 size
= gimple_call_arg (stmt
, 2);
2902 fmt
= gimple_call_arg (stmt
, 3);
2904 if (! tree_fits_uhwi_p (size
))
2909 if (!init_target_chars ())
2912 /* Check whether the format is a literal string constant. */
2913 fmt_str
= c_getstr (fmt
);
2914 if (fmt_str
!= NULL
)
2916 /* If the format doesn't contain % args or %%, we know the size. */
2917 if (strchr (fmt_str
, target_percent
) == 0)
2919 if (fcode
!= BUILT_IN_SPRINTF_CHK
|| nargs
== 4)
2920 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
2922 /* If the format is "%s" and first ... argument is a string literal,
2923 we know the size too. */
2924 else if (fcode
== BUILT_IN_SPRINTF_CHK
2925 && strcmp (fmt_str
, target_percent_s
) == 0)
2931 arg
= gimple_call_arg (stmt
, 4);
2932 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
2934 len
= c_strlen (arg
, 1);
2935 if (! len
|| ! tree_fits_uhwi_p (len
))
2942 if (! integer_all_onesp (size
))
2944 if (! len
|| ! tree_int_cst_lt (len
, size
))
2948 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
2949 or if format doesn't contain % chars or is "%s". */
2950 if (! integer_zerop (flag
))
2952 if (fmt_str
== NULL
)
2954 if (strchr (fmt_str
, target_percent
) != NULL
2955 && strcmp (fmt_str
, target_percent_s
))
2959 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
2960 fn
= builtin_decl_explicit (fcode
== BUILT_IN_VSPRINTF_CHK
2961 ? BUILT_IN_VSPRINTF
: BUILT_IN_SPRINTF
);
2965 /* Replace the called function and the first 4 argument by 2 retaining
2966 trailing varargs. */
2967 gimple_call_set_fndecl (stmt
, fn
);
2968 gimple_call_set_fntype (stmt
, TREE_TYPE (fn
));
2969 gimple_call_set_arg (stmt
, 0, dest
);
2970 gimple_call_set_arg (stmt
, 1, fmt
);
2971 for (unsigned i
= 2; i
< gimple_call_num_args (stmt
) - 2; ++i
)
2972 gimple_call_set_arg (stmt
, i
, gimple_call_arg (stmt
, i
+ 2));
2973 gimple_set_num_ops (stmt
, gimple_num_ops (stmt
) - 2);
2978 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
2979 ORIG may be null if this is a 2-argument call. We don't attempt to
2980 simplify calls with more than 3 arguments.
2982 Return true if simplification was possible, otherwise false. */
2985 gimple_fold_builtin_sprintf (gimple_stmt_iterator
*gsi
)
2987 gimple
*stmt
= gsi_stmt (*gsi
);
2988 tree dest
= gimple_call_arg (stmt
, 0);
2989 tree fmt
= gimple_call_arg (stmt
, 1);
2990 tree orig
= NULL_TREE
;
2991 const char *fmt_str
= NULL
;
2993 /* Verify the required arguments in the original call. We deal with two
2994 types of sprintf() calls: 'sprintf (str, fmt)' and
2995 'sprintf (dest, "%s", orig)'. */
2996 if (gimple_call_num_args (stmt
) > 3)
2999 if (gimple_call_num_args (stmt
) == 3)
3000 orig
= gimple_call_arg (stmt
, 2);
3002 /* Check whether the format is a literal string constant. */
3003 fmt_str
= c_getstr (fmt
);
3004 if (fmt_str
== NULL
)
3007 if (!init_target_chars ())
3010 /* If the format doesn't contain % args or %%, use strcpy. */
3011 if (strchr (fmt_str
, target_percent
) == NULL
)
3013 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3018 /* Don't optimize sprintf (buf, "abc", ptr++). */
3022 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
3023 'format' is known to contain no % formats. */
3024 gimple_seq stmts
= NULL
;
3025 gimple
*repl
= gimple_build_call (fn
, 2, dest
, fmt
);
3026 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3027 if (gimple_call_lhs (stmt
))
3029 repl
= gimple_build_assign (gimple_call_lhs (stmt
),
3030 build_int_cst (integer_type_node
,
3032 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3033 gsi_replace_with_seq_vops (gsi
, stmts
);
3034 /* gsi now points at the assignment to the lhs, get a
3035 stmt iterator to the memcpy call.
3036 ??? We can't use gsi_for_stmt as that doesn't work when the
3037 CFG isn't built yet. */
3038 gimple_stmt_iterator gsi2
= *gsi
;
3044 gsi_replace_with_seq_vops (gsi
, stmts
);
3050 /* If the format is "%s", use strcpy if the result isn't used. */
3051 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
3054 fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3059 /* Don't crash on sprintf (str1, "%s"). */
3063 tree orig_len
= NULL_TREE
;
3064 if (gimple_call_lhs (stmt
))
3066 orig_len
= get_maxval_strlen (orig
, 0);
3071 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
3072 gimple_seq stmts
= NULL
;
3073 gimple
*repl
= gimple_build_call (fn
, 2, dest
, orig
);
3074 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3075 if (gimple_call_lhs (stmt
))
3077 if (!useless_type_conversion_p (integer_type_node
,
3078 TREE_TYPE (orig_len
)))
3079 orig_len
= fold_convert (integer_type_node
, orig_len
);
3080 repl
= gimple_build_assign (gimple_call_lhs (stmt
), orig_len
);
3081 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3082 gsi_replace_with_seq_vops (gsi
, stmts
);
3083 /* gsi now points at the assignment to the lhs, get a
3084 stmt iterator to the memcpy call.
3085 ??? We can't use gsi_for_stmt as that doesn't work when the
3086 CFG isn't built yet. */
3087 gimple_stmt_iterator gsi2
= *gsi
;
3093 gsi_replace_with_seq_vops (gsi
, stmts
);
3101 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
3102 FMT, and ORIG. ORIG may be null if this is a 3-argument call. We don't
3103 attempt to simplify calls with more than 4 arguments.
3105 Return true if simplification was possible, otherwise false. */
3108 gimple_fold_builtin_snprintf (gimple_stmt_iterator
*gsi
)
3110 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3111 tree dest
= gimple_call_arg (stmt
, 0);
3112 tree destsize
= gimple_call_arg (stmt
, 1);
3113 tree fmt
= gimple_call_arg (stmt
, 2);
3114 tree orig
= NULL_TREE
;
3115 const char *fmt_str
= NULL
;
3117 if (gimple_call_num_args (stmt
) > 4)
3120 if (gimple_call_num_args (stmt
) == 4)
3121 orig
= gimple_call_arg (stmt
, 3);
3123 if (!tree_fits_uhwi_p (destsize
))
3125 unsigned HOST_WIDE_INT destlen
= tree_to_uhwi (destsize
);
3127 /* Check whether the format is a literal string constant. */
3128 fmt_str
= c_getstr (fmt
);
3129 if (fmt_str
== NULL
)
3132 if (!init_target_chars ())
3135 /* If the format doesn't contain % args or %%, use strcpy. */
3136 if (strchr (fmt_str
, target_percent
) == NULL
)
3138 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3142 /* Don't optimize snprintf (buf, 4, "abc", ptr++). */
3146 /* We could expand this as
3147 memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
3149 memcpy (str, fmt_with_nul_at_cstm1, cst);
3150 but in the former case that might increase code size
3151 and in the latter case grow .rodata section too much.
3153 size_t len
= strlen (fmt_str
);
3157 gimple_seq stmts
= NULL
;
3158 gimple
*repl
= gimple_build_call (fn
, 2, dest
, fmt
);
3159 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3160 if (gimple_call_lhs (stmt
))
3162 repl
= gimple_build_assign (gimple_call_lhs (stmt
),
3163 build_int_cst (integer_type_node
, len
));
3164 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3165 gsi_replace_with_seq_vops (gsi
, stmts
);
3166 /* gsi now points at the assignment to the lhs, get a
3167 stmt iterator to the memcpy call.
3168 ??? We can't use gsi_for_stmt as that doesn't work when the
3169 CFG isn't built yet. */
3170 gimple_stmt_iterator gsi2
= *gsi
;
3176 gsi_replace_with_seq_vops (gsi
, stmts
);
3182 /* If the format is "%s", use strcpy if the result isn't used. */
3183 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
3185 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3189 /* Don't crash on snprintf (str1, cst, "%s"). */
3193 tree orig_len
= get_maxval_strlen (orig
, 0);
3194 if (!orig_len
|| TREE_CODE (orig_len
) != INTEGER_CST
)
3197 /* We could expand this as
3198 memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
3200 memcpy (str1, str2_with_nul_at_cstm1, cst);
3201 but in the former case that might increase code size
3202 and in the latter case grow .rodata section too much.
3204 if (compare_tree_int (orig_len
, destlen
) >= 0)
3207 /* Convert snprintf (str1, cst, "%s", str2) into
3208 strcpy (str1, str2) if strlen (str2) < cst. */
3209 gimple_seq stmts
= NULL
;
3210 gimple
*repl
= gimple_build_call (fn
, 2, dest
, orig
);
3211 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3212 if (gimple_call_lhs (stmt
))
3214 if (!useless_type_conversion_p (integer_type_node
,
3215 TREE_TYPE (orig_len
)))
3216 orig_len
= fold_convert (integer_type_node
, orig_len
);
3217 repl
= gimple_build_assign (gimple_call_lhs (stmt
), orig_len
);
3218 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3219 gsi_replace_with_seq_vops (gsi
, stmts
);
3220 /* gsi now points at the assignment to the lhs, get a
3221 stmt iterator to the memcpy call.
3222 ??? We can't use gsi_for_stmt as that doesn't work when the
3223 CFG isn't built yet. */
3224 gimple_stmt_iterator gsi2
= *gsi
;
3230 gsi_replace_with_seq_vops (gsi
, stmts
);
3238 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
3239 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
3240 more than 3 arguments, and ARG may be null in the 2-argument case.
3242 Return NULL_TREE if no simplification was possible, otherwise return the
3243 simplified form of the call as a tree. FCODE is the BUILT_IN_*
3244 code of the function to be simplified. */
3247 gimple_fold_builtin_fprintf (gimple_stmt_iterator
*gsi
,
3248 tree fp
, tree fmt
, tree arg
,
3249 enum built_in_function fcode
)
3251 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3252 tree fn_fputc
, fn_fputs
;
3253 const char *fmt_str
= NULL
;
3255 /* If the return value is used, don't do the transformation. */
3256 if (gimple_call_lhs (stmt
) != NULL_TREE
)
3259 /* Check whether the format is a literal string constant. */
3260 fmt_str
= c_getstr (fmt
);
3261 if (fmt_str
== NULL
)
3264 if (fcode
== BUILT_IN_FPRINTF_UNLOCKED
)
3266 /* If we're using an unlocked function, assume the other
3267 unlocked functions exist explicitly. */
3268 fn_fputc
= builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED
);
3269 fn_fputs
= builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED
);
3273 fn_fputc
= builtin_decl_implicit (BUILT_IN_FPUTC
);
3274 fn_fputs
= builtin_decl_implicit (BUILT_IN_FPUTS
);
3277 if (!init_target_chars ())
3280 /* If the format doesn't contain % args or %%, use strcpy. */
3281 if (strchr (fmt_str
, target_percent
) == NULL
)
3283 if (fcode
!= BUILT_IN_VFPRINTF
&& fcode
!= BUILT_IN_VFPRINTF_CHK
3287 /* If the format specifier was "", fprintf does nothing. */
3288 if (fmt_str
[0] == '\0')
3290 replace_call_with_value (gsi
, NULL_TREE
);
3294 /* When "string" doesn't contain %, replace all cases of
3295 fprintf (fp, string) with fputs (string, fp). The fputs
3296 builtin will take care of special cases like length == 1. */
3299 gcall
*repl
= gimple_build_call (fn_fputs
, 2, fmt
, fp
);
3300 replace_call_with_call_and_fold (gsi
, repl
);
3305 /* The other optimizations can be done only on the non-va_list variants. */
3306 else if (fcode
== BUILT_IN_VFPRINTF
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
3309 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
3310 else if (strcmp (fmt_str
, target_percent_s
) == 0)
3312 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
3316 gcall
*repl
= gimple_build_call (fn_fputs
, 2, arg
, fp
);
3317 replace_call_with_call_and_fold (gsi
, repl
);
3322 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
3323 else if (strcmp (fmt_str
, target_percent_c
) == 0)
3326 || ! useless_type_conversion_p (integer_type_node
, TREE_TYPE (arg
)))
3330 gcall
*repl
= gimple_build_call (fn_fputc
, 2, arg
, fp
);
3331 replace_call_with_call_and_fold (gsi
, repl
);
3339 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
3340 FMT and ARG are the arguments to the call; we don't fold cases with
3341 more than 2 arguments, and ARG may be null if this is a 1-argument case.
3343 Return NULL_TREE if no simplification was possible, otherwise return the
3344 simplified form of the call as a tree. FCODE is the BUILT_IN_*
3345 code of the function to be simplified. */
3348 gimple_fold_builtin_printf (gimple_stmt_iterator
*gsi
, tree fmt
,
3349 tree arg
, enum built_in_function fcode
)
3351 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3352 tree fn_putchar
, fn_puts
, newarg
;
3353 const char *fmt_str
= NULL
;
3355 /* If the return value is used, don't do the transformation. */
3356 if (gimple_call_lhs (stmt
) != NULL_TREE
)
3359 /* Check whether the format is a literal string constant. */
3360 fmt_str
= c_getstr (fmt
);
3361 if (fmt_str
== NULL
)
3364 if (fcode
== BUILT_IN_PRINTF_UNLOCKED
)
3366 /* If we're using an unlocked function, assume the other
3367 unlocked functions exist explicitly. */
3368 fn_putchar
= builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED
);
3369 fn_puts
= builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED
);
3373 fn_putchar
= builtin_decl_implicit (BUILT_IN_PUTCHAR
);
3374 fn_puts
= builtin_decl_implicit (BUILT_IN_PUTS
);
3377 if (!init_target_chars ())
3380 if (strcmp (fmt_str
, target_percent_s
) == 0
3381 || strchr (fmt_str
, target_percent
) == NULL
)
3385 if (strcmp (fmt_str
, target_percent_s
) == 0)
3387 if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
3390 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
3393 str
= c_getstr (arg
);
3399 /* The format specifier doesn't contain any '%' characters. */
3400 if (fcode
!= BUILT_IN_VPRINTF
&& fcode
!= BUILT_IN_VPRINTF_CHK
3406 /* If the string was "", printf does nothing. */
3409 replace_call_with_value (gsi
, NULL_TREE
);
3413 /* If the string has length of 1, call putchar. */
3416 /* Given printf("c"), (where c is any one character,)
3417 convert "c"[0] to an int and pass that to the replacement
3419 newarg
= build_int_cst (integer_type_node
, str
[0]);
3422 gcall
*repl
= gimple_build_call (fn_putchar
, 1, newarg
);
3423 replace_call_with_call_and_fold (gsi
, repl
);
3429 /* If the string was "string\n", call puts("string"). */
3430 size_t len
= strlen (str
);
3431 if ((unsigned char)str
[len
- 1] == target_newline
3432 && (size_t) (int) len
== len
3437 /* Create a NUL-terminated string that's one char shorter
3438 than the original, stripping off the trailing '\n'. */
3439 newstr
= xstrdup (str
);
3440 newstr
[len
- 1] = '\0';
3441 newarg
= build_string_literal (len
, newstr
);
3445 gcall
*repl
= gimple_build_call (fn_puts
, 1, newarg
);
3446 replace_call_with_call_and_fold (gsi
, repl
);
3451 /* We'd like to arrange to call fputs(string,stdout) here,
3452 but we need stdout and don't have a way to get it yet. */
3457 /* The other optimizations can be done only on the non-va_list variants. */
3458 else if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
3461 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
3462 else if (strcmp (fmt_str
, target_percent_s_newline
) == 0)
3464 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
3468 gcall
*repl
= gimple_build_call (fn_puts
, 1, arg
);
3469 replace_call_with_call_and_fold (gsi
, repl
);
3474 /* If the format specifier was "%c", call __builtin_putchar(arg). */
3475 else if (strcmp (fmt_str
, target_percent_c
) == 0)
3477 if (!arg
|| ! useless_type_conversion_p (integer_type_node
,
3482 gcall
*repl
= gimple_build_call (fn_putchar
, 1, arg
);
3483 replace_call_with_call_and_fold (gsi
, repl
);
3493 /* Fold a call to __builtin_strlen with known length LEN. */
3496 gimple_fold_builtin_strlen (gimple_stmt_iterator
*gsi
)
3498 gimple
*stmt
= gsi_stmt (*gsi
);
3504 if (!get_range_strlen (gimple_call_arg (stmt
, 0), lenrange
, true)
3505 && lenrange
[0] && TREE_CODE (lenrange
[0]) == INTEGER_CST
3506 && lenrange
[1] && TREE_CODE (lenrange
[1]) == INTEGER_CST
)
3508 /* The range of lengths refers to either a single constant
3509 string or to the longest and shortest constant string
3510 referenced by the argument of the strlen() call, or to
3511 the strings that can possibly be stored in the arrays
3512 the argument refers to. */
3513 minlen
= wi::to_wide (lenrange
[0]);
3514 maxlen
= wi::to_wide (lenrange
[1]);
3518 unsigned prec
= TYPE_PRECISION (sizetype
);
3520 minlen
= wi::shwi (0, prec
);
3521 maxlen
= wi::to_wide (max_object_size (), prec
) - 2;
3524 if (minlen
== maxlen
)
3526 lenrange
[0] = force_gimple_operand_gsi (gsi
, lenrange
[0], true, NULL
,
3527 true, GSI_SAME_STMT
);
3528 replace_call_with_value (gsi
, lenrange
[0]);
3532 if (tree lhs
= gimple_call_lhs (stmt
))
3533 if (TREE_CODE (lhs
) == SSA_NAME
3534 && INTEGRAL_TYPE_P (TREE_TYPE (lhs
)))
3535 set_range_info (lhs
, VR_RANGE
, minlen
, maxlen
);
3540 /* Fold a call to __builtin_acc_on_device. */
3543 gimple_fold_builtin_acc_on_device (gimple_stmt_iterator
*gsi
, tree arg0
)
3545 /* Defer folding until we know which compiler we're in. */
3546 if (symtab
->state
!= EXPANSION
)
3549 unsigned val_host
= GOMP_DEVICE_HOST
;
3550 unsigned val_dev
= GOMP_DEVICE_NONE
;
3552 #ifdef ACCEL_COMPILER
3553 val_host
= GOMP_DEVICE_NOT_HOST
;
3554 val_dev
= ACCEL_COMPILER_acc_device
;
3557 location_t loc
= gimple_location (gsi_stmt (*gsi
));
3559 tree host_eq
= make_ssa_name (boolean_type_node
);
3560 gimple
*host_ass
= gimple_build_assign
3561 (host_eq
, EQ_EXPR
, arg0
, build_int_cst (TREE_TYPE (arg0
), val_host
));
3562 gimple_set_location (host_ass
, loc
);
3563 gsi_insert_before (gsi
, host_ass
, GSI_SAME_STMT
);
3565 tree dev_eq
= make_ssa_name (boolean_type_node
);
3566 gimple
*dev_ass
= gimple_build_assign
3567 (dev_eq
, EQ_EXPR
, arg0
, build_int_cst (TREE_TYPE (arg0
), val_dev
));
3568 gimple_set_location (dev_ass
, loc
);
3569 gsi_insert_before (gsi
, dev_ass
, GSI_SAME_STMT
);
3571 tree result
= make_ssa_name (boolean_type_node
);
3572 gimple
*result_ass
= gimple_build_assign
3573 (result
, BIT_IOR_EXPR
, host_eq
, dev_eq
);
3574 gimple_set_location (result_ass
, loc
);
3575 gsi_insert_before (gsi
, result_ass
, GSI_SAME_STMT
);
3577 replace_call_with_value (gsi
, result
);
3582 /* Fold realloc (0, n) -> malloc (n). */
3585 gimple_fold_builtin_realloc (gimple_stmt_iterator
*gsi
)
3587 gimple
*stmt
= gsi_stmt (*gsi
);
3588 tree arg
= gimple_call_arg (stmt
, 0);
3589 tree size
= gimple_call_arg (stmt
, 1);
3591 if (operand_equal_p (arg
, null_pointer_node
, 0))
3593 tree fn_malloc
= builtin_decl_implicit (BUILT_IN_MALLOC
);
3596 gcall
*repl
= gimple_build_call (fn_malloc
, 1, size
);
3597 replace_call_with_call_and_fold (gsi
, repl
);
3604 /* Fold the non-target builtin at *GSI and return whether any simplification
3608 gimple_fold_builtin (gimple_stmt_iterator
*gsi
)
3610 gcall
*stmt
= as_a
<gcall
*>(gsi_stmt (*gsi
));
3611 tree callee
= gimple_call_fndecl (stmt
);
3613 /* Give up for always_inline inline builtins until they are
3615 if (avoid_folding_inline_builtin (callee
))
3618 unsigned n
= gimple_call_num_args (stmt
);
3619 enum built_in_function fcode
= DECL_FUNCTION_CODE (callee
);
3623 return gimple_fold_builtin_bcmp (gsi
);
3624 case BUILT_IN_BCOPY
:
3625 return gimple_fold_builtin_bcopy (gsi
);
3626 case BUILT_IN_BZERO
:
3627 return gimple_fold_builtin_bzero (gsi
);
3629 case BUILT_IN_MEMSET
:
3630 return gimple_fold_builtin_memset (gsi
,
3631 gimple_call_arg (stmt
, 1),
3632 gimple_call_arg (stmt
, 2));
3633 case BUILT_IN_MEMCPY
:
3634 return gimple_fold_builtin_memory_op (gsi
, gimple_call_arg (stmt
, 0),
3635 gimple_call_arg (stmt
, 1), 0);
3636 case BUILT_IN_MEMPCPY
:
3637 return gimple_fold_builtin_memory_op (gsi
, gimple_call_arg (stmt
, 0),
3638 gimple_call_arg (stmt
, 1), 1);
3639 case BUILT_IN_MEMMOVE
:
3640 return gimple_fold_builtin_memory_op (gsi
, gimple_call_arg (stmt
, 0),
3641 gimple_call_arg (stmt
, 1), 3);
3642 case BUILT_IN_SPRINTF_CHK
:
3643 case BUILT_IN_VSPRINTF_CHK
:
3644 return gimple_fold_builtin_sprintf_chk (gsi
, fcode
);
3645 case BUILT_IN_STRCAT_CHK
:
3646 return gimple_fold_builtin_strcat_chk (gsi
);
3647 case BUILT_IN_STRNCAT_CHK
:
3648 return gimple_fold_builtin_strncat_chk (gsi
);
3649 case BUILT_IN_STRLEN
:
3650 return gimple_fold_builtin_strlen (gsi
);
3651 case BUILT_IN_STRCPY
:
3652 return gimple_fold_builtin_strcpy (gsi
,
3653 gimple_call_arg (stmt
, 0),
3654 gimple_call_arg (stmt
, 1));
3655 case BUILT_IN_STRNCPY
:
3656 return gimple_fold_builtin_strncpy (gsi
,
3657 gimple_call_arg (stmt
, 0),
3658 gimple_call_arg (stmt
, 1),
3659 gimple_call_arg (stmt
, 2));
3660 case BUILT_IN_STRCAT
:
3661 return gimple_fold_builtin_strcat (gsi
, gimple_call_arg (stmt
, 0),
3662 gimple_call_arg (stmt
, 1));
3663 case BUILT_IN_STRNCAT
:
3664 return gimple_fold_builtin_strncat (gsi
);
3665 case BUILT_IN_INDEX
:
3666 case BUILT_IN_STRCHR
:
3667 return gimple_fold_builtin_strchr (gsi
, false);
3668 case BUILT_IN_RINDEX
:
3669 case BUILT_IN_STRRCHR
:
3670 return gimple_fold_builtin_strchr (gsi
, true);
3671 case BUILT_IN_STRSTR
:
3672 return gimple_fold_builtin_strstr (gsi
);
3673 case BUILT_IN_STRCMP
:
3674 case BUILT_IN_STRCMP_EQ
:
3675 case BUILT_IN_STRCASECMP
:
3676 case BUILT_IN_STRNCMP
:
3677 case BUILT_IN_STRNCMP_EQ
:
3678 case BUILT_IN_STRNCASECMP
:
3679 return gimple_fold_builtin_string_compare (gsi
);
3680 case BUILT_IN_MEMCHR
:
3681 return gimple_fold_builtin_memchr (gsi
);
3682 case BUILT_IN_FPUTS
:
3683 return gimple_fold_builtin_fputs (gsi
, gimple_call_arg (stmt
, 0),
3684 gimple_call_arg (stmt
, 1), false);
3685 case BUILT_IN_FPUTS_UNLOCKED
:
3686 return gimple_fold_builtin_fputs (gsi
, gimple_call_arg (stmt
, 0),
3687 gimple_call_arg (stmt
, 1), true);
3688 case BUILT_IN_MEMCPY_CHK
:
3689 case BUILT_IN_MEMPCPY_CHK
:
3690 case BUILT_IN_MEMMOVE_CHK
:
3691 case BUILT_IN_MEMSET_CHK
:
3692 return gimple_fold_builtin_memory_chk (gsi
,
3693 gimple_call_arg (stmt
, 0),
3694 gimple_call_arg (stmt
, 1),
3695 gimple_call_arg (stmt
, 2),
3696 gimple_call_arg (stmt
, 3),
3698 case BUILT_IN_STPCPY
:
3699 return gimple_fold_builtin_stpcpy (gsi
);
3700 case BUILT_IN_STRCPY_CHK
:
3701 case BUILT_IN_STPCPY_CHK
:
3702 return gimple_fold_builtin_stxcpy_chk (gsi
,
3703 gimple_call_arg (stmt
, 0),
3704 gimple_call_arg (stmt
, 1),
3705 gimple_call_arg (stmt
, 2),
3707 case BUILT_IN_STRNCPY_CHK
:
3708 case BUILT_IN_STPNCPY_CHK
:
3709 return gimple_fold_builtin_stxncpy_chk (gsi
,
3710 gimple_call_arg (stmt
, 0),
3711 gimple_call_arg (stmt
, 1),
3712 gimple_call_arg (stmt
, 2),
3713 gimple_call_arg (stmt
, 3),
3715 case BUILT_IN_SNPRINTF_CHK
:
3716 case BUILT_IN_VSNPRINTF_CHK
:
3717 return gimple_fold_builtin_snprintf_chk (gsi
, fcode
);
3719 case BUILT_IN_FPRINTF
:
3720 case BUILT_IN_FPRINTF_UNLOCKED
:
3721 case BUILT_IN_VFPRINTF
:
3722 if (n
== 2 || n
== 3)
3723 return gimple_fold_builtin_fprintf (gsi
,
3724 gimple_call_arg (stmt
, 0),
3725 gimple_call_arg (stmt
, 1),
3727 ? gimple_call_arg (stmt
, 2)
3731 case BUILT_IN_FPRINTF_CHK
:
3732 case BUILT_IN_VFPRINTF_CHK
:
3733 if (n
== 3 || n
== 4)
3734 return gimple_fold_builtin_fprintf (gsi
,
3735 gimple_call_arg (stmt
, 0),
3736 gimple_call_arg (stmt
, 2),
3738 ? gimple_call_arg (stmt
, 3)
3742 case BUILT_IN_PRINTF
:
3743 case BUILT_IN_PRINTF_UNLOCKED
:
3744 case BUILT_IN_VPRINTF
:
3745 if (n
== 1 || n
== 2)
3746 return gimple_fold_builtin_printf (gsi
, gimple_call_arg (stmt
, 0),
3748 ? gimple_call_arg (stmt
, 1)
3749 : NULL_TREE
, fcode
);
3751 case BUILT_IN_PRINTF_CHK
:
3752 case BUILT_IN_VPRINTF_CHK
:
3753 if (n
== 2 || n
== 3)
3754 return gimple_fold_builtin_printf (gsi
, gimple_call_arg (stmt
, 1),
3756 ? gimple_call_arg (stmt
, 2)
3757 : NULL_TREE
, fcode
);
3759 case BUILT_IN_ACC_ON_DEVICE
:
3760 return gimple_fold_builtin_acc_on_device (gsi
,
3761 gimple_call_arg (stmt
, 0));
3762 case BUILT_IN_REALLOC
:
3763 return gimple_fold_builtin_realloc (gsi
);
3768 /* Try the generic builtin folder. */
3769 bool ignore
= (gimple_call_lhs (stmt
) == NULL
);
3770 tree result
= fold_call_stmt (stmt
, ignore
);
3774 STRIP_NOPS (result
);
3776 result
= fold_convert (gimple_call_return_type (stmt
), result
);
3777 if (!update_call_from_tree (gsi
, result
))
3778 gimplify_and_update_call_from_tree (gsi
, result
);
3785 /* Transform IFN_GOACC_DIM_SIZE and IFN_GOACC_DIM_POS internal
3786 function calls to constants, where possible. */
3789 fold_internal_goacc_dim (const gimple
*call
)
3791 int axis
= oacc_get_ifn_dim_arg (call
);
3792 int size
= oacc_get_fn_dim_size (current_function_decl
, axis
);
3793 tree result
= NULL_TREE
;
3794 tree type
= TREE_TYPE (gimple_call_lhs (call
));
3796 switch (gimple_call_internal_fn (call
))
3798 case IFN_GOACC_DIM_POS
:
3799 /* If the size is 1, we know the answer. */
3801 result
= build_int_cst (type
, 0);
3803 case IFN_GOACC_DIM_SIZE
:
3804 /* If the size is not dynamic, we know the answer. */
3806 result
= build_int_cst (type
, size
);
3815 /* Return true if stmt is __atomic_compare_exchange_N call which is suitable
3816 for conversion into ATOMIC_COMPARE_EXCHANGE if the second argument is
3817 &var where var is only addressable because of such calls. */
3820 optimize_atomic_compare_exchange_p (gimple
*stmt
)
3822 if (gimple_call_num_args (stmt
) != 6
3823 || !flag_inline_atomics
3825 || sanitize_flags_p (SANITIZE_THREAD
| SANITIZE_ADDRESS
)
3826 || !gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
)
3827 || !gimple_vdef (stmt
)
3828 || !gimple_vuse (stmt
))
3831 tree fndecl
= gimple_call_fndecl (stmt
);
3832 switch (DECL_FUNCTION_CODE (fndecl
))
3834 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
:
3835 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2
:
3836 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4
:
3837 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8
:
3838 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16
:
3844 tree expected
= gimple_call_arg (stmt
, 1);
3845 if (TREE_CODE (expected
) != ADDR_EXPR
3846 || !SSA_VAR_P (TREE_OPERAND (expected
, 0)))
3849 tree etype
= TREE_TYPE (TREE_OPERAND (expected
, 0));
3850 if (!is_gimple_reg_type (etype
)
3851 || !auto_var_in_fn_p (TREE_OPERAND (expected
, 0), current_function_decl
)
3852 || TREE_THIS_VOLATILE (etype
)
3853 || VECTOR_TYPE_P (etype
)
3854 || TREE_CODE (etype
) == COMPLEX_TYPE
3855 /* Don't optimize floating point expected vars, VIEW_CONVERT_EXPRs
3856 might not preserve all the bits. See PR71716. */
3857 || SCALAR_FLOAT_TYPE_P (etype
)
3858 || maybe_ne (TYPE_PRECISION (etype
),
3859 GET_MODE_BITSIZE (TYPE_MODE (etype
))))
3862 tree weak
= gimple_call_arg (stmt
, 3);
3863 if (!integer_zerop (weak
) && !integer_onep (weak
))
3866 tree parmt
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
3867 tree itype
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (parmt
)));
3868 machine_mode mode
= TYPE_MODE (itype
);
3870 if (direct_optab_handler (atomic_compare_and_swap_optab
, mode
)
3872 && optab_handler (sync_compare_and_swap_optab
, mode
) == CODE_FOR_nothing
)
3875 if (maybe_ne (int_size_in_bytes (etype
), GET_MODE_SIZE (mode
)))
3882 r = __atomic_compare_exchange_N (p, &e, d, w, s, f);
3884 _Complex uintN_t t = ATOMIC_COMPARE_EXCHANGE (p, e, d, w * 256 + N, s, f);
3885 i = IMAGPART_EXPR <t>;
3887 e = REALPART_EXPR <t>; */
3890 fold_builtin_atomic_compare_exchange (gimple_stmt_iterator
*gsi
)
3892 gimple
*stmt
= gsi_stmt (*gsi
);
3893 tree fndecl
= gimple_call_fndecl (stmt
);
3894 tree parmt
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
3895 tree itype
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (parmt
)));
3896 tree ctype
= build_complex_type (itype
);
3897 tree expected
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
3898 bool throws
= false;
3900 gimple
*g
= gimple_build_assign (make_ssa_name (TREE_TYPE (expected
)),
3902 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
3903 gimple_stmt_iterator gsiret
= gsi_for_stmt (g
);
3904 if (!useless_type_conversion_p (itype
, TREE_TYPE (expected
)))
3906 g
= gimple_build_assign (make_ssa_name (itype
), VIEW_CONVERT_EXPR
,
3907 build1 (VIEW_CONVERT_EXPR
, itype
,
3908 gimple_assign_lhs (g
)));
3909 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
3911 int flag
= (integer_onep (gimple_call_arg (stmt
, 3)) ? 256 : 0)
3912 + int_size_in_bytes (itype
);
3913 g
= gimple_build_call_internal (IFN_ATOMIC_COMPARE_EXCHANGE
, 6,
3914 gimple_call_arg (stmt
, 0),
3915 gimple_assign_lhs (g
),
3916 gimple_call_arg (stmt
, 2),
3917 build_int_cst (integer_type_node
, flag
),
3918 gimple_call_arg (stmt
, 4),
3919 gimple_call_arg (stmt
, 5));
3920 tree lhs
= make_ssa_name (ctype
);
3921 gimple_call_set_lhs (g
, lhs
);
3922 gimple_set_vdef (g
, gimple_vdef (stmt
));
3923 gimple_set_vuse (g
, gimple_vuse (stmt
));
3924 SSA_NAME_DEF_STMT (gimple_vdef (g
)) = g
;
3925 tree oldlhs
= gimple_call_lhs (stmt
);
3926 if (stmt_can_throw_internal (stmt
))
3929 e
= find_fallthru_edge (gsi_bb (*gsi
)->succs
);
3931 gimple_call_set_nothrow (as_a
<gcall
*> (g
),
3932 gimple_call_nothrow_p (as_a
<gcall
*> (stmt
)));
3933 gimple_call_set_lhs (stmt
, NULL_TREE
);
3934 gsi_replace (gsi
, g
, true);
3937 g
= gimple_build_assign (make_ssa_name (itype
), IMAGPART_EXPR
,
3938 build1 (IMAGPART_EXPR
, itype
, lhs
));
3941 gsi_insert_on_edge_immediate (e
, g
);
3942 *gsi
= gsi_for_stmt (g
);
3945 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
3946 g
= gimple_build_assign (oldlhs
, NOP_EXPR
, gimple_assign_lhs (g
));
3947 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
3949 g
= gimple_build_assign (make_ssa_name (itype
), REALPART_EXPR
,
3950 build1 (REALPART_EXPR
, itype
, lhs
));
3951 if (throws
&& oldlhs
== NULL_TREE
)
3953 gsi_insert_on_edge_immediate (e
, g
);
3954 *gsi
= gsi_for_stmt (g
);
3957 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
3958 if (!useless_type_conversion_p (TREE_TYPE (expected
), itype
))
3960 g
= gimple_build_assign (make_ssa_name (TREE_TYPE (expected
)),
3962 build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (expected
),
3963 gimple_assign_lhs (g
)));
3964 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
3966 g
= gimple_build_assign (expected
, SSA_NAME
, gimple_assign_lhs (g
));
3967 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
3971 /* Return true if ARG0 CODE ARG1 in infinite signed precision operation
3972 doesn't fit into TYPE. The test for overflow should be regardless of
3973 -fwrapv, and even for unsigned types. */
3976 arith_overflowed_p (enum tree_code code
, const_tree type
,
3977 const_tree arg0
, const_tree arg1
)
3979 widest2_int warg0
= widest2_int_cst (arg0
);
3980 widest2_int warg1
= widest2_int_cst (arg1
);
3984 case PLUS_EXPR
: wres
= wi::add (warg0
, warg1
); break;
3985 case MINUS_EXPR
: wres
= wi::sub (warg0
, warg1
); break;
3986 case MULT_EXPR
: wres
= wi::mul (warg0
, warg1
); break;
3987 default: gcc_unreachable ();
3989 signop sign
= TYPE_SIGN (type
);
3990 if (sign
== UNSIGNED
&& wi::neg_p (wres
))
3992 return wi::min_precision (wres
, sign
) > TYPE_PRECISION (type
);
3995 /* Attempt to fold a call statement referenced by the statement iterator GSI.
3996 The statement may be replaced by another statement, e.g., if the call
3997 simplifies to a constant value. Return true if any changes were made.
3998 It is assumed that the operands have been previously folded. */
4001 gimple_fold_call (gimple_stmt_iterator
*gsi
, bool inplace
)
4003 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
4005 bool changed
= false;
4008 /* Fold *& in call arguments. */
4009 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
4010 if (REFERENCE_CLASS_P (gimple_call_arg (stmt
, i
)))
4012 tree tmp
= maybe_fold_reference (gimple_call_arg (stmt
, i
), false);
4015 gimple_call_set_arg (stmt
, i
, tmp
);
4020 /* Check for virtual calls that became direct calls. */
4021 callee
= gimple_call_fn (stmt
);
4022 if (callee
&& TREE_CODE (callee
) == OBJ_TYPE_REF
)
4024 if (gimple_call_addr_fndecl (OBJ_TYPE_REF_EXPR (callee
)) != NULL_TREE
)
4026 if (dump_file
&& virtual_method_call_p (callee
)
4027 && !possible_polymorphic_call_target_p
4028 (callee
, stmt
, cgraph_node::get (gimple_call_addr_fndecl
4029 (OBJ_TYPE_REF_EXPR (callee
)))))
4032 "Type inheritance inconsistent devirtualization of ");
4033 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
4034 fprintf (dump_file
, " to ");
4035 print_generic_expr (dump_file
, callee
, TDF_SLIM
);
4036 fprintf (dump_file
, "\n");
4039 gimple_call_set_fn (stmt
, OBJ_TYPE_REF_EXPR (callee
));
4042 else if (flag_devirtualize
&& !inplace
&& virtual_method_call_p (callee
))
4045 vec
<cgraph_node
*>targets
4046 = possible_polymorphic_call_targets (callee
, stmt
, &final
);
4047 if (final
&& targets
.length () <= 1 && dbg_cnt (devirt
))
4049 tree lhs
= gimple_call_lhs (stmt
);
4050 if (dump_enabled_p ())
4052 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
,
4053 "folding virtual function call to %s\n",
4054 targets
.length () == 1
4055 ? targets
[0]->name ()
4056 : "__builtin_unreachable");
4058 if (targets
.length () == 1)
4060 tree fndecl
= targets
[0]->decl
;
4061 gimple_call_set_fndecl (stmt
, fndecl
);
4063 /* If changing the call to __cxa_pure_virtual
4064 or similar noreturn function, adjust gimple_call_fntype
4066 if (gimple_call_noreturn_p (stmt
)
4067 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl
)))
4068 && TYPE_ARG_TYPES (TREE_TYPE (fndecl
))
4069 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
4071 gimple_call_set_fntype (stmt
, TREE_TYPE (fndecl
));
4072 /* If the call becomes noreturn, remove the lhs. */
4074 && gimple_call_noreturn_p (stmt
)
4075 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (stmt
)))
4076 || should_remove_lhs_p (lhs
)))
4078 if (TREE_CODE (lhs
) == SSA_NAME
)
4080 tree var
= create_tmp_var (TREE_TYPE (lhs
));
4081 tree def
= get_or_create_ssa_default_def (cfun
, var
);
4082 gimple
*new_stmt
= gimple_build_assign (lhs
, def
);
4083 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
4085 gimple_call_set_lhs (stmt
, NULL_TREE
);
4087 maybe_remove_unused_call_args (cfun
, stmt
);
4091 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
4092 gimple
*new_stmt
= gimple_build_call (fndecl
, 0);
4093 gimple_set_location (new_stmt
, gimple_location (stmt
));
4094 /* If the call had a SSA name as lhs morph that into
4095 an uninitialized value. */
4096 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
4098 tree var
= create_tmp_var (TREE_TYPE (lhs
));
4099 SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs
, var
);
4100 SSA_NAME_DEF_STMT (lhs
) = gimple_build_nop ();
4101 set_ssa_default_def (cfun
, var
, lhs
);
4103 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
4104 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
4105 gsi_replace (gsi
, new_stmt
, false);
4112 /* Check for indirect calls that became direct calls, and then
4113 no longer require a static chain. */
4114 if (gimple_call_chain (stmt
))
4116 tree fn
= gimple_call_fndecl (stmt
);
4117 if (fn
&& !DECL_STATIC_CHAIN (fn
))
4119 gimple_call_set_chain (stmt
, NULL
);
4124 tree tmp
= maybe_fold_reference (gimple_call_chain (stmt
), false);
4127 gimple_call_set_chain (stmt
, tmp
);
4136 /* Check for builtins that CCP can handle using information not
4137 available in the generic fold routines. */
4138 if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
4140 if (gimple_fold_builtin (gsi
))
4143 else if (gimple_call_builtin_p (stmt
, BUILT_IN_MD
))
4145 changed
|= targetm
.gimple_fold_builtin (gsi
);
4147 else if (gimple_call_internal_p (stmt
))
4149 enum tree_code subcode
= ERROR_MARK
;
4150 tree result
= NULL_TREE
;
4151 bool cplx_result
= false;
4152 tree overflow
= NULL_TREE
;
4153 switch (gimple_call_internal_fn (stmt
))
4155 case IFN_BUILTIN_EXPECT
:
4156 result
= fold_builtin_expect (gimple_location (stmt
),
4157 gimple_call_arg (stmt
, 0),
4158 gimple_call_arg (stmt
, 1),
4159 gimple_call_arg (stmt
, 2));
4161 case IFN_UBSAN_OBJECT_SIZE
:
4163 tree offset
= gimple_call_arg (stmt
, 1);
4164 tree objsize
= gimple_call_arg (stmt
, 2);
4165 if (integer_all_onesp (objsize
)
4166 || (TREE_CODE (offset
) == INTEGER_CST
4167 && TREE_CODE (objsize
) == INTEGER_CST
4168 && tree_int_cst_le (offset
, objsize
)))
4170 replace_call_with_value (gsi
, NULL_TREE
);
4176 if (integer_zerop (gimple_call_arg (stmt
, 1)))
4178 replace_call_with_value (gsi
, NULL_TREE
);
4182 case IFN_UBSAN_BOUNDS
:
4184 tree index
= gimple_call_arg (stmt
, 1);
4185 tree bound
= gimple_call_arg (stmt
, 2);
4186 if (TREE_CODE (index
) == INTEGER_CST
4187 && TREE_CODE (bound
) == INTEGER_CST
)
4189 index
= fold_convert (TREE_TYPE (bound
), index
);
4190 if (TREE_CODE (index
) == INTEGER_CST
4191 && tree_int_cst_le (index
, bound
))
4193 replace_call_with_value (gsi
, NULL_TREE
);
4199 case IFN_GOACC_DIM_SIZE
:
4200 case IFN_GOACC_DIM_POS
:
4201 result
= fold_internal_goacc_dim (stmt
);
4203 case IFN_UBSAN_CHECK_ADD
:
4204 subcode
= PLUS_EXPR
;
4206 case IFN_UBSAN_CHECK_SUB
:
4207 subcode
= MINUS_EXPR
;
4209 case IFN_UBSAN_CHECK_MUL
:
4210 subcode
= MULT_EXPR
;
4212 case IFN_ADD_OVERFLOW
:
4213 subcode
= PLUS_EXPR
;
4216 case IFN_SUB_OVERFLOW
:
4217 subcode
= MINUS_EXPR
;
4220 case IFN_MUL_OVERFLOW
:
4221 subcode
= MULT_EXPR
;
4227 if (subcode
!= ERROR_MARK
)
4229 tree arg0
= gimple_call_arg (stmt
, 0);
4230 tree arg1
= gimple_call_arg (stmt
, 1);
4231 tree type
= TREE_TYPE (arg0
);
4234 tree lhs
= gimple_call_lhs (stmt
);
4235 if (lhs
== NULL_TREE
)
4238 type
= TREE_TYPE (TREE_TYPE (lhs
));
4240 if (type
== NULL_TREE
)
4242 /* x = y + 0; x = y - 0; x = y * 0; */
4243 else if (integer_zerop (arg1
))
4244 result
= subcode
== MULT_EXPR
? integer_zero_node
: arg0
;
4245 /* x = 0 + y; x = 0 * y; */
4246 else if (subcode
!= MINUS_EXPR
&& integer_zerop (arg0
))
4247 result
= subcode
== MULT_EXPR
? integer_zero_node
: arg1
;
4249 else if (subcode
== MINUS_EXPR
&& operand_equal_p (arg0
, arg1
, 0))
4250 result
= integer_zero_node
;
4251 /* x = y * 1; x = 1 * y; */
4252 else if (subcode
== MULT_EXPR
&& integer_onep (arg1
))
4254 else if (subcode
== MULT_EXPR
&& integer_onep (arg0
))
4256 else if (TREE_CODE (arg0
) == INTEGER_CST
4257 && TREE_CODE (arg1
) == INTEGER_CST
)
4260 result
= int_const_binop (subcode
, fold_convert (type
, arg0
),
4261 fold_convert (type
, arg1
));
4263 result
= int_const_binop (subcode
, arg0
, arg1
);
4264 if (result
&& arith_overflowed_p (subcode
, type
, arg0
, arg1
))
4267 overflow
= build_one_cst (type
);
4274 if (result
== integer_zero_node
)
4275 result
= build_zero_cst (type
);
4276 else if (cplx_result
&& TREE_TYPE (result
) != type
)
4278 if (TREE_CODE (result
) == INTEGER_CST
)
4280 if (arith_overflowed_p (PLUS_EXPR
, type
, result
,
4282 overflow
= build_one_cst (type
);
4284 else if ((!TYPE_UNSIGNED (TREE_TYPE (result
))
4285 && TYPE_UNSIGNED (type
))
4286 || (TYPE_PRECISION (type
)
4287 < (TYPE_PRECISION (TREE_TYPE (result
))
4288 + (TYPE_UNSIGNED (TREE_TYPE (result
))
4289 && !TYPE_UNSIGNED (type
)))))
4292 result
= fold_convert (type
, result
);
4299 if (TREE_CODE (result
) == INTEGER_CST
&& TREE_OVERFLOW (result
))
4300 result
= drop_tree_overflow (result
);
4303 if (overflow
== NULL_TREE
)
4304 overflow
= build_zero_cst (TREE_TYPE (result
));
4305 tree ctype
= build_complex_type (TREE_TYPE (result
));
4306 if (TREE_CODE (result
) == INTEGER_CST
4307 && TREE_CODE (overflow
) == INTEGER_CST
)
4308 result
= build_complex (ctype
, result
, overflow
);
4310 result
= build2_loc (gimple_location (stmt
), COMPLEX_EXPR
,
4311 ctype
, result
, overflow
);
4313 if (!update_call_from_tree (gsi
, result
))
4314 gimplify_and_update_call_from_tree (gsi
, result
);
4323 /* Return true whether NAME has a use on STMT. */
4326 has_use_on_stmt (tree name
, gimple
*stmt
)
4328 imm_use_iterator iter
;
4329 use_operand_p use_p
;
4330 FOR_EACH_IMM_USE_FAST (use_p
, iter
, name
)
4331 if (USE_STMT (use_p
) == stmt
)
4336 /* Worker for fold_stmt_1 dispatch to pattern based folding with
4339 Replaces *GSI with the simplification result in RCODE and OPS
4340 and the associated statements in *SEQ. Does the replacement
4341 according to INPLACE and returns true if the operation succeeded. */
4344 replace_stmt_with_simplification (gimple_stmt_iterator
*gsi
,
4345 gimple_match_op
*res_op
,
4346 gimple_seq
*seq
, bool inplace
)
4348 gimple
*stmt
= gsi_stmt (*gsi
);
4349 tree
*ops
= res_op
->ops
;
4350 unsigned int num_ops
= res_op
->num_ops
;
4352 /* Play safe and do not allow abnormals to be mentioned in
4353 newly created statements. See also maybe_push_res_to_seq.
4354 As an exception allow such uses if there was a use of the
4355 same SSA name on the old stmt. */
4356 for (unsigned int i
= 0; i
< num_ops
; ++i
)
4357 if (TREE_CODE (ops
[i
]) == SSA_NAME
4358 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops
[i
])
4359 && !has_use_on_stmt (ops
[i
], stmt
))
4362 if (num_ops
> 0 && COMPARISON_CLASS_P (ops
[0]))
4363 for (unsigned int i
= 0; i
< 2; ++i
)
4364 if (TREE_CODE (TREE_OPERAND (ops
[0], i
)) == SSA_NAME
4365 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops
[0], i
))
4366 && !has_use_on_stmt (TREE_OPERAND (ops
[0], i
), stmt
))
4369 /* Don't insert new statements when INPLACE is true, even if we could
4370 reuse STMT for the final statement. */
4371 if (inplace
&& !gimple_seq_empty_p (*seq
))
4374 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
4376 gcc_assert (res_op
->code
.is_tree_code ());
4377 if (TREE_CODE_CLASS ((enum tree_code
) res_op
->code
) == tcc_comparison
4378 /* GIMPLE_CONDs condition may not throw. */
4379 && (!flag_exceptions
4380 || !cfun
->can_throw_non_call_exceptions
4381 || !operation_could_trap_p (res_op
->code
,
4382 FLOAT_TYPE_P (TREE_TYPE (ops
[0])),
4384 gimple_cond_set_condition (cond_stmt
, res_op
->code
, ops
[0], ops
[1]);
4385 else if (res_op
->code
== SSA_NAME
)
4386 gimple_cond_set_condition (cond_stmt
, NE_EXPR
, ops
[0],
4387 build_zero_cst (TREE_TYPE (ops
[0])));
4388 else if (res_op
->code
== INTEGER_CST
)
4390 if (integer_zerop (ops
[0]))
4391 gimple_cond_make_false (cond_stmt
);
4393 gimple_cond_make_true (cond_stmt
);
4397 tree res
= maybe_push_res_to_seq (res_op
, seq
);
4400 gimple_cond_set_condition (cond_stmt
, NE_EXPR
, res
,
4401 build_zero_cst (TREE_TYPE (res
)));
4405 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4407 fprintf (dump_file
, "gimple_simplified to ");
4408 if (!gimple_seq_empty_p (*seq
))
4409 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
4410 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
),
4413 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
4416 else if (is_gimple_assign (stmt
)
4417 && res_op
->code
.is_tree_code ())
4420 || gimple_num_ops (stmt
) > get_gimple_rhs_num_ops (res_op
->code
))
4422 maybe_build_generic_op (res_op
);
4423 gimple_assign_set_rhs_with_ops (gsi
, res_op
->code
,
4424 res_op
->op_or_null (0),
4425 res_op
->op_or_null (1),
4426 res_op
->op_or_null (2));
4427 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4429 fprintf (dump_file
, "gimple_simplified to ");
4430 if (!gimple_seq_empty_p (*seq
))
4431 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
4432 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
),
4435 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
4439 else if (res_op
->code
.is_fn_code ()
4440 && gimple_call_combined_fn (stmt
) == res_op
->code
)
4442 gcc_assert (num_ops
== gimple_call_num_args (stmt
));
4443 for (unsigned int i
= 0; i
< num_ops
; ++i
)
4444 gimple_call_set_arg (stmt
, i
, ops
[i
]);
4445 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4447 fprintf (dump_file
, "gimple_simplified to ");
4448 if (!gimple_seq_empty_p (*seq
))
4449 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
4450 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
), 0, TDF_SLIM
);
4452 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
4457 if (gimple_has_lhs (stmt
))
4459 tree lhs
= gimple_get_lhs (stmt
);
4460 if (!maybe_push_res_to_seq (res_op
, seq
, lhs
))
4462 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
4464 fprintf (dump_file
, "gimple_simplified to ");
4465 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
4467 gsi_replace_with_seq_vops (gsi
, *seq
);
4477 /* Canonicalize MEM_REFs invariant address operand after propagation. */
4480 maybe_canonicalize_mem_ref_addr (tree
*t
)
4484 if (TREE_CODE (*t
) == ADDR_EXPR
)
4485 t
= &TREE_OPERAND (*t
, 0);
4487 /* The C and C++ frontends use an ARRAY_REF for indexing with their
4488 generic vector extension. The actual vector referenced is
4489 view-converted to an array type for this purpose. If the index
4490 is constant the canonical representation in the middle-end is a
4491 BIT_FIELD_REF so re-write the former to the latter here. */
4492 if (TREE_CODE (*t
) == ARRAY_REF
4493 && TREE_CODE (TREE_OPERAND (*t
, 0)) == VIEW_CONVERT_EXPR
4494 && TREE_CODE (TREE_OPERAND (*t
, 1)) == INTEGER_CST
4495 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*t
, 0), 0))))
4497 tree vtype
= TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*t
, 0), 0));
4498 if (VECTOR_TYPE_P (vtype
))
4500 tree low
= array_ref_low_bound (*t
);
4501 if (TREE_CODE (low
) == INTEGER_CST
)
4503 if (tree_int_cst_le (low
, TREE_OPERAND (*t
, 1)))
4505 widest_int idx
= wi::sub (wi::to_widest (TREE_OPERAND (*t
, 1)),
4506 wi::to_widest (low
));
4507 idx
= wi::mul (idx
, wi::to_widest
4508 (TYPE_SIZE (TREE_TYPE (*t
))));
4510 = wi::add (idx
, wi::to_widest (TYPE_SIZE (TREE_TYPE (*t
))));
4511 if (wi::les_p (ext
, wi::to_widest (TYPE_SIZE (vtype
))))
4513 *t
= build3_loc (EXPR_LOCATION (*t
), BIT_FIELD_REF
,
4515 TREE_OPERAND (TREE_OPERAND (*t
, 0), 0),
4516 TYPE_SIZE (TREE_TYPE (*t
)),
4517 wide_int_to_tree (bitsizetype
, idx
));
4525 while (handled_component_p (*t
))
4526 t
= &TREE_OPERAND (*t
, 0);
4528 /* Canonicalize MEM [&foo.bar, 0] which appears after propagating
4529 of invariant addresses into a SSA name MEM_REF address. */
4530 if (TREE_CODE (*t
) == MEM_REF
4531 || TREE_CODE (*t
) == TARGET_MEM_REF
)
4533 tree addr
= TREE_OPERAND (*t
, 0);
4534 if (TREE_CODE (addr
) == ADDR_EXPR
4535 && (TREE_CODE (TREE_OPERAND (addr
, 0)) == MEM_REF
4536 || handled_component_p (TREE_OPERAND (addr
, 0))))
4540 base
= get_addr_base_and_unit_offset (TREE_OPERAND (addr
, 0),
4545 TREE_OPERAND (*t
, 0) = build_fold_addr_expr (base
);
4546 TREE_OPERAND (*t
, 1) = int_const_binop (PLUS_EXPR
,
4547 TREE_OPERAND (*t
, 1),
4548 size_int (coffset
));
4551 gcc_checking_assert (TREE_CODE (TREE_OPERAND (*t
, 0)) == DEBUG_EXPR_DECL
4552 || is_gimple_mem_ref_addr (TREE_OPERAND (*t
, 0)));
4555 /* Canonicalize back MEM_REFs to plain reference trees if the object
4556 accessed is a decl that has the same access semantics as the MEM_REF. */
4557 if (TREE_CODE (*t
) == MEM_REF
4558 && TREE_CODE (TREE_OPERAND (*t
, 0)) == ADDR_EXPR
4559 && integer_zerop (TREE_OPERAND (*t
, 1))
4560 && MR_DEPENDENCE_CLIQUE (*t
) == 0)
4562 tree decl
= TREE_OPERAND (TREE_OPERAND (*t
, 0), 0);
4563 tree alias_type
= TREE_TYPE (TREE_OPERAND (*t
, 1));
4564 if (/* Same volatile qualification. */
4565 TREE_THIS_VOLATILE (*t
) == TREE_THIS_VOLATILE (decl
)
4566 /* Same TBAA behavior with -fstrict-aliasing. */
4567 && !TYPE_REF_CAN_ALIAS_ALL (alias_type
)
4568 && (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))
4569 == TYPE_MAIN_VARIANT (TREE_TYPE (alias_type
)))
4570 /* Same alignment. */
4571 && TYPE_ALIGN (TREE_TYPE (decl
)) == TYPE_ALIGN (TREE_TYPE (*t
))
4572 /* We have to look out here to not drop a required conversion
4573 from the rhs to the lhs if *t appears on the lhs or vice-versa
4574 if it appears on the rhs. Thus require strict type
4576 && types_compatible_p (TREE_TYPE (*t
), TREE_TYPE (decl
)))
4578 *t
= TREE_OPERAND (TREE_OPERAND (*t
, 0), 0);
4583 /* Canonicalize TARGET_MEM_REF in particular with respect to
4584 the indexes becoming constant. */
4585 else if (TREE_CODE (*t
) == TARGET_MEM_REF
)
4587 tree tem
= maybe_fold_tmr (*t
);
4598 /* Worker for both fold_stmt and fold_stmt_inplace. The INPLACE argument
4599 distinguishes both cases. */
4602 fold_stmt_1 (gimple_stmt_iterator
*gsi
, bool inplace
, tree (*valueize
) (tree
))
4604 bool changed
= false;
4605 gimple
*stmt
= gsi_stmt (*gsi
);
4606 bool nowarning
= gimple_no_warning_p (stmt
);
4608 fold_defer_overflow_warnings ();
4610 /* First do required canonicalization of [TARGET_]MEM_REF addresses
4612 ??? This shouldn't be done in generic folding but in the
4613 propagation helpers which also know whether an address was
4615 Also canonicalize operand order. */
4616 switch (gimple_code (stmt
))
4619 if (gimple_assign_rhs_class (stmt
) == GIMPLE_SINGLE_RHS
)
4621 tree
*rhs
= gimple_assign_rhs1_ptr (stmt
);
4622 if ((REFERENCE_CLASS_P (*rhs
)
4623 || TREE_CODE (*rhs
) == ADDR_EXPR
)
4624 && maybe_canonicalize_mem_ref_addr (rhs
))
4626 tree
*lhs
= gimple_assign_lhs_ptr (stmt
);
4627 if (REFERENCE_CLASS_P (*lhs
)
4628 && maybe_canonicalize_mem_ref_addr (lhs
))
4633 /* Canonicalize operand order. */
4634 enum tree_code code
= gimple_assign_rhs_code (stmt
);
4635 if (TREE_CODE_CLASS (code
) == tcc_comparison
4636 || commutative_tree_code (code
)
4637 || commutative_ternary_tree_code (code
))
4639 tree rhs1
= gimple_assign_rhs1 (stmt
);
4640 tree rhs2
= gimple_assign_rhs2 (stmt
);
4641 if (tree_swap_operands_p (rhs1
, rhs2
))
4643 gimple_assign_set_rhs1 (stmt
, rhs2
);
4644 gimple_assign_set_rhs2 (stmt
, rhs1
);
4645 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
4646 gimple_assign_set_rhs_code (stmt
,
4647 swap_tree_comparison (code
));
4655 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
4657 tree
*arg
= gimple_call_arg_ptr (stmt
, i
);
4658 if (REFERENCE_CLASS_P (*arg
)
4659 && maybe_canonicalize_mem_ref_addr (arg
))
4662 tree
*lhs
= gimple_call_lhs_ptr (stmt
);
4664 && REFERENCE_CLASS_P (*lhs
)
4665 && maybe_canonicalize_mem_ref_addr (lhs
))
4671 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
4672 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
4674 tree link
= gimple_asm_output_op (asm_stmt
, i
);
4675 tree op
= TREE_VALUE (link
);
4676 if (REFERENCE_CLASS_P (op
)
4677 && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link
)))
4680 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
4682 tree link
= gimple_asm_input_op (asm_stmt
, i
);
4683 tree op
= TREE_VALUE (link
);
4684 if ((REFERENCE_CLASS_P (op
)
4685 || TREE_CODE (op
) == ADDR_EXPR
)
4686 && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link
)))
4692 if (gimple_debug_bind_p (stmt
))
4694 tree
*val
= gimple_debug_bind_get_value_ptr (stmt
);
4696 && (REFERENCE_CLASS_P (*val
)
4697 || TREE_CODE (*val
) == ADDR_EXPR
)
4698 && maybe_canonicalize_mem_ref_addr (val
))
4704 /* Canonicalize operand order. */
4705 tree lhs
= gimple_cond_lhs (stmt
);
4706 tree rhs
= gimple_cond_rhs (stmt
);
4707 if (tree_swap_operands_p (lhs
, rhs
))
4709 gcond
*gc
= as_a
<gcond
*> (stmt
);
4710 gimple_cond_set_lhs (gc
, rhs
);
4711 gimple_cond_set_rhs (gc
, lhs
);
4712 gimple_cond_set_code (gc
,
4713 swap_tree_comparison (gimple_cond_code (gc
)));
4720 /* Dispatch to pattern-based folding. */
4722 || is_gimple_assign (stmt
)
4723 || gimple_code (stmt
) == GIMPLE_COND
)
4725 gimple_seq seq
= NULL
;
4726 gimple_match_op res_op
;
4727 if (gimple_simplify (stmt
, &res_op
, inplace
? NULL
: &seq
,
4728 valueize
, valueize
))
4730 if (replace_stmt_with_simplification (gsi
, &res_op
, &seq
, inplace
))
4733 gimple_seq_discard (seq
);
4737 stmt
= gsi_stmt (*gsi
);
4739 /* Fold the main computation performed by the statement. */
4740 switch (gimple_code (stmt
))
4744 /* Try to canonicalize for boolean-typed X the comparisons
4745 X == 0, X == 1, X != 0, and X != 1. */
4746 if (gimple_assign_rhs_code (stmt
) == EQ_EXPR
4747 || gimple_assign_rhs_code (stmt
) == NE_EXPR
)
4749 tree lhs
= gimple_assign_lhs (stmt
);
4750 tree op1
= gimple_assign_rhs1 (stmt
);
4751 tree op2
= gimple_assign_rhs2 (stmt
);
4752 tree type
= TREE_TYPE (op1
);
4754 /* Check whether the comparison operands are of the same boolean
4755 type as the result type is.
4756 Check that second operand is an integer-constant with value
4758 if (TREE_CODE (op2
) == INTEGER_CST
4759 && (integer_zerop (op2
) || integer_onep (op2
))
4760 && useless_type_conversion_p (TREE_TYPE (lhs
), type
))
4762 enum tree_code cmp_code
= gimple_assign_rhs_code (stmt
);
4763 bool is_logical_not
= false;
4765 /* X == 0 and X != 1 is a logical-not.of X
4766 X == 1 and X != 0 is X */
4767 if ((cmp_code
== EQ_EXPR
&& integer_zerop (op2
))
4768 || (cmp_code
== NE_EXPR
&& integer_onep (op2
)))
4769 is_logical_not
= true;
4771 if (is_logical_not
== false)
4772 gimple_assign_set_rhs_with_ops (gsi
, TREE_CODE (op1
), op1
);
4773 /* Only for one-bit precision typed X the transformation
4774 !X -> ~X is valied. */
4775 else if (TYPE_PRECISION (type
) == 1)
4776 gimple_assign_set_rhs_with_ops (gsi
, BIT_NOT_EXPR
, op1
);
4777 /* Otherwise we use !X -> X ^ 1. */
4779 gimple_assign_set_rhs_with_ops (gsi
, BIT_XOR_EXPR
, op1
,
4780 build_int_cst (type
, 1));
4786 unsigned old_num_ops
= gimple_num_ops (stmt
);
4787 tree lhs
= gimple_assign_lhs (stmt
);
4788 tree new_rhs
= fold_gimple_assign (gsi
);
4790 && !useless_type_conversion_p (TREE_TYPE (lhs
),
4791 TREE_TYPE (new_rhs
)))
4792 new_rhs
= fold_convert (TREE_TYPE (lhs
), new_rhs
);
4795 || get_gimple_rhs_num_ops (TREE_CODE (new_rhs
)) < old_num_ops
))
4797 gimple_assign_set_rhs_from_tree (gsi
, new_rhs
);
4804 changed
|= gimple_fold_call (gsi
, inplace
);
4808 /* Fold *& in asm operands. */
4810 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
4812 const char **oconstraints
;
4813 const char *constraint
;
4814 bool allows_mem
, allows_reg
;
4816 noutputs
= gimple_asm_noutputs (asm_stmt
);
4817 oconstraints
= XALLOCAVEC (const char *, noutputs
);
4819 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
4821 tree link
= gimple_asm_output_op (asm_stmt
, i
);
4822 tree op
= TREE_VALUE (link
);
4824 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
4825 if (REFERENCE_CLASS_P (op
)
4826 && (op
= maybe_fold_reference (op
, true)) != NULL_TREE
)
4828 TREE_VALUE (link
) = op
;
4832 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
4834 tree link
= gimple_asm_input_op (asm_stmt
, i
);
4835 tree op
= TREE_VALUE (link
);
4837 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
4838 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
4839 oconstraints
, &allows_mem
, &allows_reg
);
4840 if (REFERENCE_CLASS_P (op
)
4841 && (op
= maybe_fold_reference (op
, !allows_reg
&& allows_mem
))
4844 TREE_VALUE (link
) = op
;
4852 if (gimple_debug_bind_p (stmt
))
4854 tree val
= gimple_debug_bind_get_value (stmt
);
4856 && REFERENCE_CLASS_P (val
))
4858 tree tem
= maybe_fold_reference (val
, false);
4861 gimple_debug_bind_set_value (stmt
, tem
);
4866 && TREE_CODE (val
) == ADDR_EXPR
)
4868 tree ref
= TREE_OPERAND (val
, 0);
4869 tree tem
= maybe_fold_reference (ref
, false);
4872 tem
= build_fold_addr_expr_with_type (tem
, TREE_TYPE (val
));
4873 gimple_debug_bind_set_value (stmt
, tem
);
4882 greturn
*ret_stmt
= as_a
<greturn
*> (stmt
);
4883 tree ret
= gimple_return_retval(ret_stmt
);
4885 if (ret
&& TREE_CODE (ret
) == SSA_NAME
&& valueize
)
4887 tree val
= valueize (ret
);
4888 if (val
&& val
!= ret
4889 && may_propagate_copy (ret
, val
))
4891 gimple_return_set_retval (ret_stmt
, val
);
4901 stmt
= gsi_stmt (*gsi
);
4903 /* Fold *& on the lhs. */
4904 if (gimple_has_lhs (stmt
))
4906 tree lhs
= gimple_get_lhs (stmt
);
4907 if (lhs
&& REFERENCE_CLASS_P (lhs
))
4909 tree new_lhs
= maybe_fold_reference (lhs
, true);
4912 gimple_set_lhs (stmt
, new_lhs
);
4918 fold_undefer_overflow_warnings (changed
&& !nowarning
, stmt
, 0);
4922 /* Valueziation callback that ends up not following SSA edges. */
4925 no_follow_ssa_edges (tree
)
4930 /* Valueization callback that ends up following single-use SSA edges only. */
4933 follow_single_use_edges (tree val
)
4935 if (TREE_CODE (val
) == SSA_NAME
4936 && !has_single_use (val
))
4941 /* Valueization callback that follows all SSA edges. */
4944 follow_all_ssa_edges (tree val
)
4949 /* Fold the statement pointed to by GSI. In some cases, this function may
4950 replace the whole statement with a new one. Returns true iff folding
4952 The statement pointed to by GSI should be in valid gimple form but may
4953 be in unfolded state as resulting from for example constant propagation
4954 which can produce *&x = 0. */
4957 fold_stmt (gimple_stmt_iterator
*gsi
)
4959 return fold_stmt_1 (gsi
, false, no_follow_ssa_edges
);
4963 fold_stmt (gimple_stmt_iterator
*gsi
, tree (*valueize
) (tree
))
4965 return fold_stmt_1 (gsi
, false, valueize
);
4968 /* Perform the minimal folding on statement *GSI. Only operations like
4969 *&x created by constant propagation are handled. The statement cannot
4970 be replaced with a new one. Return true if the statement was
4971 changed, false otherwise.
4972 The statement *GSI should be in valid gimple form but may
4973 be in unfolded state as resulting from for example constant propagation
4974 which can produce *&x = 0. */
4977 fold_stmt_inplace (gimple_stmt_iterator
*gsi
)
4979 gimple
*stmt
= gsi_stmt (*gsi
);
4980 bool changed
= fold_stmt_1 (gsi
, true, no_follow_ssa_edges
);
4981 gcc_assert (gsi_stmt (*gsi
) == stmt
);
4985 /* Canonicalize and possibly invert the boolean EXPR; return NULL_TREE
4986 if EXPR is null or we don't know how.
4987 If non-null, the result always has boolean type. */
4990 canonicalize_bool (tree expr
, bool invert
)
4996 if (integer_nonzerop (expr
))
4997 return boolean_false_node
;
4998 else if (integer_zerop (expr
))
4999 return boolean_true_node
;
5000 else if (TREE_CODE (expr
) == SSA_NAME
)
5001 return fold_build2 (EQ_EXPR
, boolean_type_node
, expr
,
5002 build_int_cst (TREE_TYPE (expr
), 0));
5003 else if (COMPARISON_CLASS_P (expr
))
5004 return fold_build2 (invert_tree_comparison (TREE_CODE (expr
), false),
5006 TREE_OPERAND (expr
, 0),
5007 TREE_OPERAND (expr
, 1));
5013 if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
)
5015 if (integer_nonzerop (expr
))
5016 return boolean_true_node
;
5017 else if (integer_zerop (expr
))
5018 return boolean_false_node
;
5019 else if (TREE_CODE (expr
) == SSA_NAME
)
5020 return fold_build2 (NE_EXPR
, boolean_type_node
, expr
,
5021 build_int_cst (TREE_TYPE (expr
), 0));
5022 else if (COMPARISON_CLASS_P (expr
))
5023 return fold_build2 (TREE_CODE (expr
),
5025 TREE_OPERAND (expr
, 0),
5026 TREE_OPERAND (expr
, 1));
5032 /* Check to see if a boolean expression EXPR is logically equivalent to the
5033 comparison (OP1 CODE OP2). Check for various identities involving
5037 same_bool_comparison_p (const_tree expr
, enum tree_code code
,
5038 const_tree op1
, const_tree op2
)
5042 /* The obvious case. */
5043 if (TREE_CODE (expr
) == code
5044 && operand_equal_p (TREE_OPERAND (expr
, 0), op1
, 0)
5045 && operand_equal_p (TREE_OPERAND (expr
, 1), op2
, 0))
5048 /* Check for comparing (name, name != 0) and the case where expr
5049 is an SSA_NAME with a definition matching the comparison. */
5050 if (TREE_CODE (expr
) == SSA_NAME
5051 && TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
)
5053 if (operand_equal_p (expr
, op1
, 0))
5054 return ((code
== NE_EXPR
&& integer_zerop (op2
))
5055 || (code
== EQ_EXPR
&& integer_nonzerop (op2
)));
5056 s
= SSA_NAME_DEF_STMT (expr
);
5057 if (is_gimple_assign (s
)
5058 && gimple_assign_rhs_code (s
) == code
5059 && operand_equal_p (gimple_assign_rhs1 (s
), op1
, 0)
5060 && operand_equal_p (gimple_assign_rhs2 (s
), op2
, 0))
5064 /* If op1 is of the form (name != 0) or (name == 0), and the definition
5065 of name is a comparison, recurse. */
5066 if (TREE_CODE (op1
) == SSA_NAME
5067 && TREE_CODE (TREE_TYPE (op1
)) == BOOLEAN_TYPE
)
5069 s
= SSA_NAME_DEF_STMT (op1
);
5070 if (is_gimple_assign (s
)
5071 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
)
5073 enum tree_code c
= gimple_assign_rhs_code (s
);
5074 if ((c
== NE_EXPR
&& integer_zerop (op2
))
5075 || (c
== EQ_EXPR
&& integer_nonzerop (op2
)))
5076 return same_bool_comparison_p (expr
, c
,
5077 gimple_assign_rhs1 (s
),
5078 gimple_assign_rhs2 (s
));
5079 if ((c
== EQ_EXPR
&& integer_zerop (op2
))
5080 || (c
== NE_EXPR
&& integer_nonzerop (op2
)))
5081 return same_bool_comparison_p (expr
,
5082 invert_tree_comparison (c
, false),
5083 gimple_assign_rhs1 (s
),
5084 gimple_assign_rhs2 (s
));
5090 /* Check to see if two boolean expressions OP1 and OP2 are logically
5094 same_bool_result_p (const_tree op1
, const_tree op2
)
5096 /* Simple cases first. */
5097 if (operand_equal_p (op1
, op2
, 0))
5100 /* Check the cases where at least one of the operands is a comparison.
5101 These are a bit smarter than operand_equal_p in that they apply some
5102 identifies on SSA_NAMEs. */
5103 if (COMPARISON_CLASS_P (op2
)
5104 && same_bool_comparison_p (op1
, TREE_CODE (op2
),
5105 TREE_OPERAND (op2
, 0),
5106 TREE_OPERAND (op2
, 1)))
5108 if (COMPARISON_CLASS_P (op1
)
5109 && same_bool_comparison_p (op2
, TREE_CODE (op1
),
5110 TREE_OPERAND (op1
, 0),
5111 TREE_OPERAND (op1
, 1)))
5118 /* Forward declarations for some mutually recursive functions. */
5121 and_comparisons_1 (enum tree_code code1
, tree op1a
, tree op1b
,
5122 enum tree_code code2
, tree op2a
, tree op2b
);
5124 and_var_with_comparison (tree var
, bool invert
,
5125 enum tree_code code2
, tree op2a
, tree op2b
);
5127 and_var_with_comparison_1 (gimple
*stmt
,
5128 enum tree_code code2
, tree op2a
, tree op2b
);
5130 or_comparisons_1 (enum tree_code code1
, tree op1a
, tree op1b
,
5131 enum tree_code code2
, tree op2a
, tree op2b
);
5133 or_var_with_comparison (tree var
, bool invert
,
5134 enum tree_code code2
, tree op2a
, tree op2b
);
5136 or_var_with_comparison_1 (gimple
*stmt
,
5137 enum tree_code code2
, tree op2a
, tree op2b
);
5139 /* Helper function for and_comparisons_1: try to simplify the AND of the
5140 ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
5141 If INVERT is true, invert the value of the VAR before doing the AND.
5142 Return NULL_EXPR if we can't simplify this to a single expression. */
5145 and_var_with_comparison (tree var
, bool invert
,
5146 enum tree_code code2
, tree op2a
, tree op2b
)
5149 gimple
*stmt
= SSA_NAME_DEF_STMT (var
);
5151 /* We can only deal with variables whose definitions are assignments. */
5152 if (!is_gimple_assign (stmt
))
5155 /* If we have an inverted comparison, apply DeMorgan's law and rewrite
5156 !var AND (op2a code2 op2b) => !(var OR !(op2a code2 op2b))
5157 Then we only have to consider the simpler non-inverted cases. */
5159 t
= or_var_with_comparison_1 (stmt
,
5160 invert_tree_comparison (code2
, false),
5163 t
= and_var_with_comparison_1 (stmt
, code2
, op2a
, op2b
);
5164 return canonicalize_bool (t
, invert
);
5167 /* Try to simplify the AND of the ssa variable defined by the assignment
5168 STMT with the comparison specified by (OP2A CODE2 OP2B).
5169 Return NULL_EXPR if we can't simplify this to a single expression. */
5172 and_var_with_comparison_1 (gimple
*stmt
,
5173 enum tree_code code2
, tree op2a
, tree op2b
)
5175 tree var
= gimple_assign_lhs (stmt
);
5176 tree true_test_var
= NULL_TREE
;
5177 tree false_test_var
= NULL_TREE
;
5178 enum tree_code innercode
= gimple_assign_rhs_code (stmt
);
5180 /* Check for identities like (var AND (var == 0)) => false. */
5181 if (TREE_CODE (op2a
) == SSA_NAME
5182 && TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
)
5184 if ((code2
== NE_EXPR
&& integer_zerop (op2b
))
5185 || (code2
== EQ_EXPR
&& integer_nonzerop (op2b
)))
5187 true_test_var
= op2a
;
5188 if (var
== true_test_var
)
5191 else if ((code2
== EQ_EXPR
&& integer_zerop (op2b
))
5192 || (code2
== NE_EXPR
&& integer_nonzerop (op2b
)))
5194 false_test_var
= op2a
;
5195 if (var
== false_test_var
)
5196 return boolean_false_node
;
5200 /* If the definition is a comparison, recurse on it. */
5201 if (TREE_CODE_CLASS (innercode
) == tcc_comparison
)
5203 tree t
= and_comparisons_1 (innercode
,
5204 gimple_assign_rhs1 (stmt
),
5205 gimple_assign_rhs2 (stmt
),
5213 /* If the definition is an AND or OR expression, we may be able to
5214 simplify by reassociating. */
5215 if (TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
5216 && (innercode
== BIT_AND_EXPR
|| innercode
== BIT_IOR_EXPR
))
5218 tree inner1
= gimple_assign_rhs1 (stmt
);
5219 tree inner2
= gimple_assign_rhs2 (stmt
);
5222 tree partial
= NULL_TREE
;
5223 bool is_and
= (innercode
== BIT_AND_EXPR
);
5225 /* Check for boolean identities that don't require recursive examination
5227 inner1 AND (inner1 AND inner2) => inner1 AND inner2 => var
5228 inner1 AND (inner1 OR inner2) => inner1
5229 !inner1 AND (inner1 AND inner2) => false
5230 !inner1 AND (inner1 OR inner2) => !inner1 AND inner2
5231 Likewise for similar cases involving inner2. */
5232 if (inner1
== true_test_var
)
5233 return (is_and
? var
: inner1
);
5234 else if (inner2
== true_test_var
)
5235 return (is_and
? var
: inner2
);
5236 else if (inner1
== false_test_var
)
5238 ? boolean_false_node
5239 : and_var_with_comparison (inner2
, false, code2
, op2a
, op2b
));
5240 else if (inner2
== false_test_var
)
5242 ? boolean_false_node
5243 : and_var_with_comparison (inner1
, false, code2
, op2a
, op2b
));
5245 /* Next, redistribute/reassociate the AND across the inner tests.
5246 Compute the first partial result, (inner1 AND (op2a code op2b)) */
5247 if (TREE_CODE (inner1
) == SSA_NAME
5248 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner1
))
5249 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
5250 && (t
= maybe_fold_and_comparisons (gimple_assign_rhs_code (s
),
5251 gimple_assign_rhs1 (s
),
5252 gimple_assign_rhs2 (s
),
5253 code2
, op2a
, op2b
)))
5255 /* Handle the AND case, where we are reassociating:
5256 (inner1 AND inner2) AND (op2a code2 op2b)
5258 If the partial result t is a constant, we win. Otherwise
5259 continue on to try reassociating with the other inner test. */
5262 if (integer_onep (t
))
5264 else if (integer_zerop (t
))
5265 return boolean_false_node
;
5268 /* Handle the OR case, where we are redistributing:
5269 (inner1 OR inner2) AND (op2a code2 op2b)
5270 => (t OR (inner2 AND (op2a code2 op2b))) */
5271 else if (integer_onep (t
))
5272 return boolean_true_node
;
5274 /* Save partial result for later. */
5278 /* Compute the second partial result, (inner2 AND (op2a code op2b)) */
5279 if (TREE_CODE (inner2
) == SSA_NAME
5280 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner2
))
5281 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
5282 && (t
= maybe_fold_and_comparisons (gimple_assign_rhs_code (s
),
5283 gimple_assign_rhs1 (s
),
5284 gimple_assign_rhs2 (s
),
5285 code2
, op2a
, op2b
)))
5287 /* Handle the AND case, where we are reassociating:
5288 (inner1 AND inner2) AND (op2a code2 op2b)
5289 => (inner1 AND t) */
5292 if (integer_onep (t
))
5294 else if (integer_zerop (t
))
5295 return boolean_false_node
;
5296 /* If both are the same, we can apply the identity
5298 else if (partial
&& same_bool_result_p (t
, partial
))
5302 /* Handle the OR case. where we are redistributing:
5303 (inner1 OR inner2) AND (op2a code2 op2b)
5304 => (t OR (inner1 AND (op2a code2 op2b)))
5305 => (t OR partial) */
5308 if (integer_onep (t
))
5309 return boolean_true_node
;
5312 /* We already got a simplification for the other
5313 operand to the redistributed OR expression. The
5314 interesting case is when at least one is false.
5315 Or, if both are the same, we can apply the identity
5317 if (integer_zerop (partial
))
5319 else if (integer_zerop (t
))
5321 else if (same_bool_result_p (t
, partial
))
5330 /* Try to simplify the AND of two comparisons defined by
5331 (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
5332 If this can be done without constructing an intermediate value,
5333 return the resulting tree; otherwise NULL_TREE is returned.
5334 This function is deliberately asymmetric as it recurses on SSA_DEFs
5335 in the first comparison but not the second. */
5338 and_comparisons_1 (enum tree_code code1
, tree op1a
, tree op1b
,
5339 enum tree_code code2
, tree op2a
, tree op2b
)
5341 tree truth_type
= truth_type_for (TREE_TYPE (op1a
));
5343 /* First check for ((x CODE1 y) AND (x CODE2 y)). */
5344 if (operand_equal_p (op1a
, op2a
, 0)
5345 && operand_equal_p (op1b
, op2b
, 0))
5347 /* Result will be either NULL_TREE, or a combined comparison. */
5348 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
5349 TRUTH_ANDIF_EXPR
, code1
, code2
,
5350 truth_type
, op1a
, op1b
);
5355 /* Likewise the swapped case of the above. */
5356 if (operand_equal_p (op1a
, op2b
, 0)
5357 && operand_equal_p (op1b
, op2a
, 0))
5359 /* Result will be either NULL_TREE, or a combined comparison. */
5360 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
5361 TRUTH_ANDIF_EXPR
, code1
,
5362 swap_tree_comparison (code2
),
5363 truth_type
, op1a
, op1b
);
5368 /* If both comparisons are of the same value against constants, we might
5369 be able to merge them. */
5370 if (operand_equal_p (op1a
, op2a
, 0)
5371 && TREE_CODE (op1b
) == INTEGER_CST
5372 && TREE_CODE (op2b
) == INTEGER_CST
)
5374 int cmp
= tree_int_cst_compare (op1b
, op2b
);
5376 /* If we have (op1a == op1b), we should either be able to
5377 return that or FALSE, depending on whether the constant op1b
5378 also satisfies the other comparison against op2b. */
5379 if (code1
== EQ_EXPR
)
5385 case EQ_EXPR
: val
= (cmp
== 0); break;
5386 case NE_EXPR
: val
= (cmp
!= 0); break;
5387 case LT_EXPR
: val
= (cmp
< 0); break;
5388 case GT_EXPR
: val
= (cmp
> 0); break;
5389 case LE_EXPR
: val
= (cmp
<= 0); break;
5390 case GE_EXPR
: val
= (cmp
>= 0); break;
5391 default: done
= false;
5396 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
5398 return boolean_false_node
;
5401 /* Likewise if the second comparison is an == comparison. */
5402 else if (code2
== EQ_EXPR
)
5408 case EQ_EXPR
: val
= (cmp
== 0); break;
5409 case NE_EXPR
: val
= (cmp
!= 0); break;
5410 case LT_EXPR
: val
= (cmp
> 0); break;
5411 case GT_EXPR
: val
= (cmp
< 0); break;
5412 case LE_EXPR
: val
= (cmp
>= 0); break;
5413 case GE_EXPR
: val
= (cmp
<= 0); break;
5414 default: done
= false;
5419 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
5421 return boolean_false_node
;
5425 /* Same business with inequality tests. */
5426 else if (code1
== NE_EXPR
)
5431 case EQ_EXPR
: val
= (cmp
!= 0); break;
5432 case NE_EXPR
: val
= (cmp
== 0); break;
5433 case LT_EXPR
: val
= (cmp
>= 0); break;
5434 case GT_EXPR
: val
= (cmp
<= 0); break;
5435 case LE_EXPR
: val
= (cmp
> 0); break;
5436 case GE_EXPR
: val
= (cmp
< 0); break;
5441 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
5443 else if (code2
== NE_EXPR
)
5448 case EQ_EXPR
: val
= (cmp
== 0); break;
5449 case NE_EXPR
: val
= (cmp
!= 0); break;
5450 case LT_EXPR
: val
= (cmp
<= 0); break;
5451 case GT_EXPR
: val
= (cmp
>= 0); break;
5452 case LE_EXPR
: val
= (cmp
< 0); break;
5453 case GE_EXPR
: val
= (cmp
> 0); break;
5458 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
5461 /* Chose the more restrictive of two < or <= comparisons. */
5462 else if ((code1
== LT_EXPR
|| code1
== LE_EXPR
)
5463 && (code2
== LT_EXPR
|| code2
== LE_EXPR
))
5465 if ((cmp
< 0) || (cmp
== 0 && code1
== LT_EXPR
))
5466 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
5468 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
5471 /* Likewise chose the more restrictive of two > or >= comparisons. */
5472 else if ((code1
== GT_EXPR
|| code1
== GE_EXPR
)
5473 && (code2
== GT_EXPR
|| code2
== GE_EXPR
))
5475 if ((cmp
> 0) || (cmp
== 0 && code1
== GT_EXPR
))
5476 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
5478 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
5481 /* Check for singleton ranges. */
5483 && ((code1
== LE_EXPR
&& code2
== GE_EXPR
)
5484 || (code1
== GE_EXPR
&& code2
== LE_EXPR
)))
5485 return fold_build2 (EQ_EXPR
, boolean_type_node
, op1a
, op2b
);
5487 /* Check for disjoint ranges. */
5489 && (code1
== LT_EXPR
|| code1
== LE_EXPR
)
5490 && (code2
== GT_EXPR
|| code2
== GE_EXPR
))
5491 return boolean_false_node
;
5493 && (code1
== GT_EXPR
|| code1
== GE_EXPR
)
5494 && (code2
== LT_EXPR
|| code2
== LE_EXPR
))
5495 return boolean_false_node
;
5498 /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
5499 NAME's definition is a truth value. See if there are any simplifications
5500 that can be done against the NAME's definition. */
5501 if (TREE_CODE (op1a
) == SSA_NAME
5502 && (code1
== NE_EXPR
|| code1
== EQ_EXPR
)
5503 && (integer_zerop (op1b
) || integer_onep (op1b
)))
5505 bool invert
= ((code1
== EQ_EXPR
&& integer_zerop (op1b
))
5506 || (code1
== NE_EXPR
&& integer_onep (op1b
)));
5507 gimple
*stmt
= SSA_NAME_DEF_STMT (op1a
);
5508 switch (gimple_code (stmt
))
5511 /* Try to simplify by copy-propagating the definition. */
5512 return and_var_with_comparison (op1a
, invert
, code2
, op2a
, op2b
);
5515 /* If every argument to the PHI produces the same result when
5516 ANDed with the second comparison, we win.
5517 Do not do this unless the type is bool since we need a bool
5518 result here anyway. */
5519 if (TREE_CODE (TREE_TYPE (op1a
)) == BOOLEAN_TYPE
)
5521 tree result
= NULL_TREE
;
5523 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
5525 tree arg
= gimple_phi_arg_def (stmt
, i
);
5527 /* If this PHI has itself as an argument, ignore it.
5528 If all the other args produce the same result,
5530 if (arg
== gimple_phi_result (stmt
))
5532 else if (TREE_CODE (arg
) == INTEGER_CST
)
5534 if (invert
? integer_nonzerop (arg
) : integer_zerop (arg
))
5537 result
= boolean_false_node
;
5538 else if (!integer_zerop (result
))
5542 result
= fold_build2 (code2
, boolean_type_node
,
5544 else if (!same_bool_comparison_p (result
,
5548 else if (TREE_CODE (arg
) == SSA_NAME
5549 && !SSA_NAME_IS_DEFAULT_DEF (arg
))
5552 gimple
*def_stmt
= SSA_NAME_DEF_STMT (arg
);
5553 /* In simple cases we can look through PHI nodes,
5554 but we have to be careful with loops.
5556 if (! dom_info_available_p (CDI_DOMINATORS
)
5557 || gimple_bb (def_stmt
) == gimple_bb (stmt
)
5558 || dominated_by_p (CDI_DOMINATORS
,
5559 gimple_bb (def_stmt
),
5562 temp
= and_var_with_comparison (arg
, invert
, code2
,
5568 else if (!same_bool_result_p (result
, temp
))
5584 /* Try to simplify the AND of two comparisons, specified by
5585 (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
5586 If this can be simplified to a single expression (without requiring
5587 introducing more SSA variables to hold intermediate values),
5588 return the resulting tree. Otherwise return NULL_TREE.
5589 If the result expression is non-null, it has boolean type. */
5592 maybe_fold_and_comparisons (enum tree_code code1
, tree op1a
, tree op1b
,
5593 enum tree_code code2
, tree op2a
, tree op2b
)
5595 tree t
= and_comparisons_1 (code1
, op1a
, op1b
, code2
, op2a
, op2b
);
5599 return and_comparisons_1 (code2
, op2a
, op2b
, code1
, op1a
, op1b
);
5602 /* Helper function for or_comparisons_1: try to simplify the OR of the
5603 ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
5604 If INVERT is true, invert the value of VAR before doing the OR.
5605 Return NULL_EXPR if we can't simplify this to a single expression. */
5608 or_var_with_comparison (tree var
, bool invert
,
5609 enum tree_code code2
, tree op2a
, tree op2b
)
5612 gimple
*stmt
= SSA_NAME_DEF_STMT (var
);
5614 /* We can only deal with variables whose definitions are assignments. */
5615 if (!is_gimple_assign (stmt
))
5618 /* If we have an inverted comparison, apply DeMorgan's law and rewrite
5619 !var OR (op2a code2 op2b) => !(var AND !(op2a code2 op2b))
5620 Then we only have to consider the simpler non-inverted cases. */
5622 t
= and_var_with_comparison_1 (stmt
,
5623 invert_tree_comparison (code2
, false),
5626 t
= or_var_with_comparison_1 (stmt
, code2
, op2a
, op2b
);
5627 return canonicalize_bool (t
, invert
);
5630 /* Try to simplify the OR of the ssa variable defined by the assignment
5631 STMT with the comparison specified by (OP2A CODE2 OP2B).
5632 Return NULL_EXPR if we can't simplify this to a single expression. */
5635 or_var_with_comparison_1 (gimple
*stmt
,
5636 enum tree_code code2
, tree op2a
, tree op2b
)
5638 tree var
= gimple_assign_lhs (stmt
);
5639 tree true_test_var
= NULL_TREE
;
5640 tree false_test_var
= NULL_TREE
;
5641 enum tree_code innercode
= gimple_assign_rhs_code (stmt
);
5643 /* Check for identities like (var OR (var != 0)) => true . */
5644 if (TREE_CODE (op2a
) == SSA_NAME
5645 && TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
)
5647 if ((code2
== NE_EXPR
&& integer_zerop (op2b
))
5648 || (code2
== EQ_EXPR
&& integer_nonzerop (op2b
)))
5650 true_test_var
= op2a
;
5651 if (var
== true_test_var
)
5654 else if ((code2
== EQ_EXPR
&& integer_zerop (op2b
))
5655 || (code2
== NE_EXPR
&& integer_nonzerop (op2b
)))
5657 false_test_var
= op2a
;
5658 if (var
== false_test_var
)
5659 return boolean_true_node
;
5663 /* If the definition is a comparison, recurse on it. */
5664 if (TREE_CODE_CLASS (innercode
) == tcc_comparison
)
5666 tree t
= or_comparisons_1 (innercode
,
5667 gimple_assign_rhs1 (stmt
),
5668 gimple_assign_rhs2 (stmt
),
5676 /* If the definition is an AND or OR expression, we may be able to
5677 simplify by reassociating. */
5678 if (TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
5679 && (innercode
== BIT_AND_EXPR
|| innercode
== BIT_IOR_EXPR
))
5681 tree inner1
= gimple_assign_rhs1 (stmt
);
5682 tree inner2
= gimple_assign_rhs2 (stmt
);
5685 tree partial
= NULL_TREE
;
5686 bool is_or
= (innercode
== BIT_IOR_EXPR
);
5688 /* Check for boolean identities that don't require recursive examination
5690 inner1 OR (inner1 OR inner2) => inner1 OR inner2 => var
5691 inner1 OR (inner1 AND inner2) => inner1
5692 !inner1 OR (inner1 OR inner2) => true
5693 !inner1 OR (inner1 AND inner2) => !inner1 OR inner2
5695 if (inner1
== true_test_var
)
5696 return (is_or
? var
: inner1
);
5697 else if (inner2
== true_test_var
)
5698 return (is_or
? var
: inner2
);
5699 else if (inner1
== false_test_var
)
5702 : or_var_with_comparison (inner2
, false, code2
, op2a
, op2b
));
5703 else if (inner2
== false_test_var
)
5706 : or_var_with_comparison (inner1
, false, code2
, op2a
, op2b
));
5708 /* Next, redistribute/reassociate the OR across the inner tests.
5709 Compute the first partial result, (inner1 OR (op2a code op2b)) */
5710 if (TREE_CODE (inner1
) == SSA_NAME
5711 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner1
))
5712 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
5713 && (t
= maybe_fold_or_comparisons (gimple_assign_rhs_code (s
),
5714 gimple_assign_rhs1 (s
),
5715 gimple_assign_rhs2 (s
),
5716 code2
, op2a
, op2b
)))
5718 /* Handle the OR case, where we are reassociating:
5719 (inner1 OR inner2) OR (op2a code2 op2b)
5721 If the partial result t is a constant, we win. Otherwise
5722 continue on to try reassociating with the other inner test. */
5725 if (integer_onep (t
))
5726 return boolean_true_node
;
5727 else if (integer_zerop (t
))
5731 /* Handle the AND case, where we are redistributing:
5732 (inner1 AND inner2) OR (op2a code2 op2b)
5733 => (t AND (inner2 OR (op2a code op2b))) */
5734 else if (integer_zerop (t
))
5735 return boolean_false_node
;
5737 /* Save partial result for later. */
5741 /* Compute the second partial result, (inner2 OR (op2a code op2b)) */
5742 if (TREE_CODE (inner2
) == SSA_NAME
5743 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner2
))
5744 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
5745 && (t
= maybe_fold_or_comparisons (gimple_assign_rhs_code (s
),
5746 gimple_assign_rhs1 (s
),
5747 gimple_assign_rhs2 (s
),
5748 code2
, op2a
, op2b
)))
5750 /* Handle the OR case, where we are reassociating:
5751 (inner1 OR inner2) OR (op2a code2 op2b)
5753 => (t OR partial) */
5756 if (integer_zerop (t
))
5758 else if (integer_onep (t
))
5759 return boolean_true_node
;
5760 /* If both are the same, we can apply the identity
5762 else if (partial
&& same_bool_result_p (t
, partial
))
5766 /* Handle the AND case, where we are redistributing:
5767 (inner1 AND inner2) OR (op2a code2 op2b)
5768 => (t AND (inner1 OR (op2a code2 op2b)))
5769 => (t AND partial) */
5772 if (integer_zerop (t
))
5773 return boolean_false_node
;
5776 /* We already got a simplification for the other
5777 operand to the redistributed AND expression. The
5778 interesting case is when at least one is true.
5779 Or, if both are the same, we can apply the identity
5781 if (integer_onep (partial
))
5783 else if (integer_onep (t
))
5785 else if (same_bool_result_p (t
, partial
))
5794 /* Try to simplify the OR of two comparisons defined by
5795 (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
5796 If this can be done without constructing an intermediate value,
5797 return the resulting tree; otherwise NULL_TREE is returned.
5798 This function is deliberately asymmetric as it recurses on SSA_DEFs
5799 in the first comparison but not the second. */
5802 or_comparisons_1 (enum tree_code code1
, tree op1a
, tree op1b
,
5803 enum tree_code code2
, tree op2a
, tree op2b
)
5805 tree truth_type
= truth_type_for (TREE_TYPE (op1a
));
5807 /* First check for ((x CODE1 y) OR (x CODE2 y)). */
5808 if (operand_equal_p (op1a
, op2a
, 0)
5809 && operand_equal_p (op1b
, op2b
, 0))
5811 /* Result will be either NULL_TREE, or a combined comparison. */
5812 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
5813 TRUTH_ORIF_EXPR
, code1
, code2
,
5814 truth_type
, op1a
, op1b
);
5819 /* Likewise the swapped case of the above. */
5820 if (operand_equal_p (op1a
, op2b
, 0)
5821 && operand_equal_p (op1b
, op2a
, 0))
5823 /* Result will be either NULL_TREE, or a combined comparison. */
5824 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
5825 TRUTH_ORIF_EXPR
, code1
,
5826 swap_tree_comparison (code2
),
5827 truth_type
, op1a
, op1b
);
5832 /* If both comparisons are of the same value against constants, we might
5833 be able to merge them. */
5834 if (operand_equal_p (op1a
, op2a
, 0)
5835 && TREE_CODE (op1b
) == INTEGER_CST
5836 && TREE_CODE (op2b
) == INTEGER_CST
)
5838 int cmp
= tree_int_cst_compare (op1b
, op2b
);
5840 /* If we have (op1a != op1b), we should either be able to
5841 return that or TRUE, depending on whether the constant op1b
5842 also satisfies the other comparison against op2b. */
5843 if (code1
== NE_EXPR
)
5849 case EQ_EXPR
: val
= (cmp
== 0); break;
5850 case NE_EXPR
: val
= (cmp
!= 0); break;
5851 case LT_EXPR
: val
= (cmp
< 0); break;
5852 case GT_EXPR
: val
= (cmp
> 0); break;
5853 case LE_EXPR
: val
= (cmp
<= 0); break;
5854 case GE_EXPR
: val
= (cmp
>= 0); break;
5855 default: done
= false;
5860 return boolean_true_node
;
5862 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
5865 /* Likewise if the second comparison is a != comparison. */
5866 else if (code2
== NE_EXPR
)
5872 case EQ_EXPR
: val
= (cmp
== 0); break;
5873 case NE_EXPR
: val
= (cmp
!= 0); break;
5874 case LT_EXPR
: val
= (cmp
> 0); break;
5875 case GT_EXPR
: val
= (cmp
< 0); break;
5876 case LE_EXPR
: val
= (cmp
>= 0); break;
5877 case GE_EXPR
: val
= (cmp
<= 0); break;
5878 default: done
= false;
5883 return boolean_true_node
;
5885 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
5889 /* See if an equality test is redundant with the other comparison. */
5890 else if (code1
== EQ_EXPR
)
5895 case EQ_EXPR
: val
= (cmp
== 0); break;
5896 case NE_EXPR
: val
= (cmp
!= 0); break;
5897 case LT_EXPR
: val
= (cmp
< 0); break;
5898 case GT_EXPR
: val
= (cmp
> 0); break;
5899 case LE_EXPR
: val
= (cmp
<= 0); break;
5900 case GE_EXPR
: val
= (cmp
>= 0); break;
5905 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
5907 else if (code2
== EQ_EXPR
)
5912 case EQ_EXPR
: val
= (cmp
== 0); break;
5913 case NE_EXPR
: val
= (cmp
!= 0); break;
5914 case LT_EXPR
: val
= (cmp
> 0); break;
5915 case GT_EXPR
: val
= (cmp
< 0); break;
5916 case LE_EXPR
: val
= (cmp
>= 0); break;
5917 case GE_EXPR
: val
= (cmp
<= 0); break;
5922 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
5925 /* Chose the less restrictive of two < or <= comparisons. */
5926 else if ((code1
== LT_EXPR
|| code1
== LE_EXPR
)
5927 && (code2
== LT_EXPR
|| code2
== LE_EXPR
))
5929 if ((cmp
< 0) || (cmp
== 0 && code1
== LT_EXPR
))
5930 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
5932 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
5935 /* Likewise chose the less restrictive of two > or >= comparisons. */
5936 else if ((code1
== GT_EXPR
|| code1
== GE_EXPR
)
5937 && (code2
== GT_EXPR
|| code2
== GE_EXPR
))
5939 if ((cmp
> 0) || (cmp
== 0 && code1
== GT_EXPR
))
5940 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
5942 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
5945 /* Check for singleton ranges. */
5947 && ((code1
== LT_EXPR
&& code2
== GT_EXPR
)
5948 || (code1
== GT_EXPR
&& code2
== LT_EXPR
)))
5949 return fold_build2 (NE_EXPR
, boolean_type_node
, op1a
, op2b
);
5951 /* Check for less/greater pairs that don't restrict the range at all. */
5953 && (code1
== LT_EXPR
|| code1
== LE_EXPR
)
5954 && (code2
== GT_EXPR
|| code2
== GE_EXPR
))
5955 return boolean_true_node
;
5957 && (code1
== GT_EXPR
|| code1
== GE_EXPR
)
5958 && (code2
== LT_EXPR
|| code2
== LE_EXPR
))
5959 return boolean_true_node
;
5962 /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
5963 NAME's definition is a truth value. See if there are any simplifications
5964 that can be done against the NAME's definition. */
5965 if (TREE_CODE (op1a
) == SSA_NAME
5966 && (code1
== NE_EXPR
|| code1
== EQ_EXPR
)
5967 && (integer_zerop (op1b
) || integer_onep (op1b
)))
5969 bool invert
= ((code1
== EQ_EXPR
&& integer_zerop (op1b
))
5970 || (code1
== NE_EXPR
&& integer_onep (op1b
)));
5971 gimple
*stmt
= SSA_NAME_DEF_STMT (op1a
);
5972 switch (gimple_code (stmt
))
5975 /* Try to simplify by copy-propagating the definition. */
5976 return or_var_with_comparison (op1a
, invert
, code2
, op2a
, op2b
);
5979 /* If every argument to the PHI produces the same result when
5980 ORed with the second comparison, we win.
5981 Do not do this unless the type is bool since we need a bool
5982 result here anyway. */
5983 if (TREE_CODE (TREE_TYPE (op1a
)) == BOOLEAN_TYPE
)
5985 tree result
= NULL_TREE
;
5987 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
5989 tree arg
= gimple_phi_arg_def (stmt
, i
);
5991 /* If this PHI has itself as an argument, ignore it.
5992 If all the other args produce the same result,
5994 if (arg
== gimple_phi_result (stmt
))
5996 else if (TREE_CODE (arg
) == INTEGER_CST
)
5998 if (invert
? integer_zerop (arg
) : integer_nonzerop (arg
))
6001 result
= boolean_true_node
;
6002 else if (!integer_onep (result
))
6006 result
= fold_build2 (code2
, boolean_type_node
,
6008 else if (!same_bool_comparison_p (result
,
6012 else if (TREE_CODE (arg
) == SSA_NAME
6013 && !SSA_NAME_IS_DEFAULT_DEF (arg
))
6016 gimple
*def_stmt
= SSA_NAME_DEF_STMT (arg
);
6017 /* In simple cases we can look through PHI nodes,
6018 but we have to be careful with loops.
6020 if (! dom_info_available_p (CDI_DOMINATORS
)
6021 || gimple_bb (def_stmt
) == gimple_bb (stmt
)
6022 || dominated_by_p (CDI_DOMINATORS
,
6023 gimple_bb (def_stmt
),
6026 temp
= or_var_with_comparison (arg
, invert
, code2
,
6032 else if (!same_bool_result_p (result
, temp
))
6048 /* Try to simplify the OR of two comparisons, specified by
6049 (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
6050 If this can be simplified to a single expression (without requiring
6051 introducing more SSA variables to hold intermediate values),
6052 return the resulting tree. Otherwise return NULL_TREE.
6053 If the result expression is non-null, it has boolean type. */
6056 maybe_fold_or_comparisons (enum tree_code code1
, tree op1a
, tree op1b
,
6057 enum tree_code code2
, tree op2a
, tree op2b
)
6059 tree t
= or_comparisons_1 (code1
, op1a
, op1b
, code2
, op2a
, op2b
);
6063 return or_comparisons_1 (code2
, op2a
, op2b
, code1
, op1a
, op1b
);
6067 /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
6069 Either NULL_TREE, a simplified but non-constant or a constant
6072 ??? This should go into a gimple-fold-inline.h file to be eventually
6073 privatized with the single valueize function used in the various TUs
6074 to avoid the indirect function call overhead. */
6077 gimple_fold_stmt_to_constant_1 (gimple
*stmt
, tree (*valueize
) (tree
),
6078 tree (*gvalueize
) (tree
))
6080 gimple_match_op res_op
;
6081 /* ??? The SSA propagators do not correctly deal with following SSA use-def
6082 edges if there are intermediate VARYING defs. For this reason
6083 do not follow SSA edges here even though SCCVN can technically
6084 just deal fine with that. */
6085 if (gimple_simplify (stmt
, &res_op
, NULL
, gvalueize
, valueize
))
6087 tree res
= NULL_TREE
;
6088 if (gimple_simplified_result_is_gimple_val (&res_op
))
6089 res
= res_op
.ops
[0];
6090 else if (mprts_hook
)
6091 res
= mprts_hook (&res_op
);
6094 if (dump_file
&& dump_flags
& TDF_DETAILS
)
6096 fprintf (dump_file
, "Match-and-simplified ");
6097 print_gimple_expr (dump_file
, stmt
, 0, TDF_SLIM
);
6098 fprintf (dump_file
, " to ");
6099 print_generic_expr (dump_file
, res
);
6100 fprintf (dump_file
, "\n");
6106 location_t loc
= gimple_location (stmt
);
6107 switch (gimple_code (stmt
))
6111 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
6113 switch (get_gimple_rhs_class (subcode
))
6115 case GIMPLE_SINGLE_RHS
:
6117 tree rhs
= gimple_assign_rhs1 (stmt
);
6118 enum tree_code_class kind
= TREE_CODE_CLASS (subcode
);
6120 if (TREE_CODE (rhs
) == SSA_NAME
)
6122 /* If the RHS is an SSA_NAME, return its known constant value,
6124 return (*valueize
) (rhs
);
6126 /* Handle propagating invariant addresses into address
6128 else if (TREE_CODE (rhs
) == ADDR_EXPR
6129 && !is_gimple_min_invariant (rhs
))
6131 poly_int64 offset
= 0;
6133 base
= get_addr_base_and_unit_offset_1 (TREE_OPERAND (rhs
, 0),
6137 && (CONSTANT_CLASS_P (base
)
6138 || decl_address_invariant_p (base
)))
6139 return build_invariant_address (TREE_TYPE (rhs
),
6142 else if (TREE_CODE (rhs
) == CONSTRUCTOR
6143 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
6144 && known_eq (CONSTRUCTOR_NELTS (rhs
),
6145 TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs
))))
6150 nelts
= CONSTRUCTOR_NELTS (rhs
);
6151 tree_vector_builder
vec (TREE_TYPE (rhs
), nelts
, 1);
6152 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
6154 val
= (*valueize
) (val
);
6155 if (TREE_CODE (val
) == INTEGER_CST
6156 || TREE_CODE (val
) == REAL_CST
6157 || TREE_CODE (val
) == FIXED_CST
)
6158 vec
.quick_push (val
);
6163 return vec
.build ();
6165 if (subcode
== OBJ_TYPE_REF
)
6167 tree val
= (*valueize
) (OBJ_TYPE_REF_EXPR (rhs
));
6168 /* If callee is constant, we can fold away the wrapper. */
6169 if (is_gimple_min_invariant (val
))
6173 if (kind
== tcc_reference
)
6175 if ((TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
6176 || TREE_CODE (rhs
) == REALPART_EXPR
6177 || TREE_CODE (rhs
) == IMAGPART_EXPR
)
6178 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
6180 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
6181 return fold_unary_loc (EXPR_LOCATION (rhs
),
6183 TREE_TYPE (rhs
), val
);
6185 else if (TREE_CODE (rhs
) == BIT_FIELD_REF
6186 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
6188 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
6189 return fold_ternary_loc (EXPR_LOCATION (rhs
),
6191 TREE_TYPE (rhs
), val
,
6192 TREE_OPERAND (rhs
, 1),
6193 TREE_OPERAND (rhs
, 2));
6195 else if (TREE_CODE (rhs
) == MEM_REF
6196 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
6198 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
6199 if (TREE_CODE (val
) == ADDR_EXPR
6200 && is_gimple_min_invariant (val
))
6202 tree tem
= fold_build2 (MEM_REF
, TREE_TYPE (rhs
),
6204 TREE_OPERAND (rhs
, 1));
6209 return fold_const_aggregate_ref_1 (rhs
, valueize
);
6211 else if (kind
== tcc_declaration
)
6212 return get_symbol_constant_value (rhs
);
6216 case GIMPLE_UNARY_RHS
:
6219 case GIMPLE_BINARY_RHS
:
6220 /* Translate &x + CST into an invariant form suitable for
6221 further propagation. */
6222 if (subcode
== POINTER_PLUS_EXPR
)
6224 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
6225 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
6226 if (TREE_CODE (op0
) == ADDR_EXPR
6227 && TREE_CODE (op1
) == INTEGER_CST
)
6229 tree off
= fold_convert (ptr_type_node
, op1
);
6230 return build_fold_addr_expr_loc
6232 fold_build2 (MEM_REF
,
6233 TREE_TYPE (TREE_TYPE (op0
)),
6234 unshare_expr (op0
), off
));
6237 /* Canonicalize bool != 0 and bool == 0 appearing after
6238 valueization. While gimple_simplify handles this
6239 it can get confused by the ~X == 1 -> X == 0 transform
6240 which we cant reduce to a SSA name or a constant
6241 (and we have no way to tell gimple_simplify to not
6242 consider those transforms in the first place). */
6243 else if (subcode
== EQ_EXPR
6244 || subcode
== NE_EXPR
)
6246 tree lhs
= gimple_assign_lhs (stmt
);
6247 tree op0
= gimple_assign_rhs1 (stmt
);
6248 if (useless_type_conversion_p (TREE_TYPE (lhs
),
6251 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
6252 op0
= (*valueize
) (op0
);
6253 if (TREE_CODE (op0
) == INTEGER_CST
)
6254 std::swap (op0
, op1
);
6255 if (TREE_CODE (op1
) == INTEGER_CST
6256 && ((subcode
== NE_EXPR
&& integer_zerop (op1
))
6257 || (subcode
== EQ_EXPR
&& integer_onep (op1
))))
6263 case GIMPLE_TERNARY_RHS
:
6265 /* Handle ternary operators that can appear in GIMPLE form. */
6266 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
6267 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
6268 tree op2
= (*valueize
) (gimple_assign_rhs3 (stmt
));
6269 return fold_ternary_loc (loc
, subcode
,
6270 gimple_expr_type (stmt
), op0
, op1
, op2
);
6281 gcall
*call_stmt
= as_a
<gcall
*> (stmt
);
6283 if (gimple_call_internal_p (stmt
))
6285 enum tree_code subcode
= ERROR_MARK
;
6286 switch (gimple_call_internal_fn (stmt
))
6288 case IFN_UBSAN_CHECK_ADD
:
6289 subcode
= PLUS_EXPR
;
6291 case IFN_UBSAN_CHECK_SUB
:
6292 subcode
= MINUS_EXPR
;
6294 case IFN_UBSAN_CHECK_MUL
:
6295 subcode
= MULT_EXPR
;
6297 case IFN_BUILTIN_EXPECT
:
6299 tree arg0
= gimple_call_arg (stmt
, 0);
6300 tree op0
= (*valueize
) (arg0
);
6301 if (TREE_CODE (op0
) == INTEGER_CST
)
6308 tree arg0
= gimple_call_arg (stmt
, 0);
6309 tree arg1
= gimple_call_arg (stmt
, 1);
6310 tree op0
= (*valueize
) (arg0
);
6311 tree op1
= (*valueize
) (arg1
);
6313 if (TREE_CODE (op0
) != INTEGER_CST
6314 || TREE_CODE (op1
) != INTEGER_CST
)
6319 /* x * 0 = 0 * x = 0 without overflow. */
6320 if (integer_zerop (op0
) || integer_zerop (op1
))
6321 return build_zero_cst (TREE_TYPE (arg0
));
6324 /* y - y = 0 without overflow. */
6325 if (operand_equal_p (op0
, op1
, 0))
6326 return build_zero_cst (TREE_TYPE (arg0
));
6333 = fold_binary_loc (loc
, subcode
, TREE_TYPE (arg0
), op0
, op1
);
6335 && TREE_CODE (res
) == INTEGER_CST
6336 && !TREE_OVERFLOW (res
))
6341 fn
= (*valueize
) (gimple_call_fn (stmt
));
6342 if (TREE_CODE (fn
) == ADDR_EXPR
6343 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
6344 && DECL_BUILT_IN (TREE_OPERAND (fn
, 0))
6345 && gimple_builtin_call_types_compatible_p (stmt
,
6346 TREE_OPERAND (fn
, 0)))
6348 tree
*args
= XALLOCAVEC (tree
, gimple_call_num_args (stmt
));
6351 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
6352 args
[i
] = (*valueize
) (gimple_call_arg (stmt
, i
));
6353 retval
= fold_builtin_call_array (loc
,
6354 gimple_call_return_type (call_stmt
),
6355 fn
, gimple_call_num_args (stmt
), args
);
6358 /* fold_call_expr wraps the result inside a NOP_EXPR. */
6359 STRIP_NOPS (retval
);
6360 retval
= fold_convert (gimple_call_return_type (call_stmt
),
6373 /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
6374 Returns NULL_TREE if folding to a constant is not possible, otherwise
6375 returns a constant according to is_gimple_min_invariant. */
6378 gimple_fold_stmt_to_constant (gimple
*stmt
, tree (*valueize
) (tree
))
6380 tree res
= gimple_fold_stmt_to_constant_1 (stmt
, valueize
);
6381 if (res
&& is_gimple_min_invariant (res
))
6387 /* The following set of functions are supposed to fold references using
6388 their constant initializers. */
6390 /* See if we can find constructor defining value of BASE.
6391 When we know the consructor with constant offset (such as
6392 base is array[40] and we do know constructor of array), then
6393 BIT_OFFSET is adjusted accordingly.
6395 As a special case, return error_mark_node when constructor
6396 is not explicitly available, but it is known to be zero
6397 such as 'static const int a;'. */
6399 get_base_constructor (tree base
, poly_int64_pod
*bit_offset
,
6400 tree (*valueize
)(tree
))
6402 poly_int64 bit_offset2
, size
, max_size
;
6405 if (TREE_CODE (base
) == MEM_REF
)
6407 poly_offset_int boff
= *bit_offset
+ mem_ref_offset (base
) * BITS_PER_UNIT
;
6408 if (!boff
.to_shwi (bit_offset
))
6412 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
6413 base
= valueize (TREE_OPERAND (base
, 0));
6414 if (!base
|| TREE_CODE (base
) != ADDR_EXPR
)
6416 base
= TREE_OPERAND (base
, 0);
6419 && TREE_CODE (base
) == SSA_NAME
)
6420 base
= valueize (base
);
6422 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
6423 DECL_INITIAL. If BASE is a nested reference into another
6424 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
6425 the inner reference. */
6426 switch (TREE_CODE (base
))
6431 tree init
= ctor_for_folding (base
);
6433 /* Our semantic is exact opposite of ctor_for_folding;
6434 NULL means unknown, while error_mark_node is 0. */
6435 if (init
== error_mark_node
)
6438 return error_mark_node
;
6442 case VIEW_CONVERT_EXPR
:
6443 return get_base_constructor (TREE_OPERAND (base
, 0),
6444 bit_offset
, valueize
);
6448 base
= get_ref_base_and_extent (base
, &bit_offset2
, &size
, &max_size
,
6450 if (!known_size_p (max_size
) || maybe_ne (size
, max_size
))
6452 *bit_offset
+= bit_offset2
;
6453 return get_base_constructor (base
, bit_offset
, valueize
);
6459 if (CONSTANT_CLASS_P (base
))
6466 /* CTOR is CONSTRUCTOR of an array type. Fold a reference of SIZE bits
6467 to the memory at bit OFFSET. When non-null, TYPE is the expected
6468 type of the reference; otherwise the type of the referenced element
6469 is used instead. When SIZE is zero, attempt to fold a reference to
6470 the entire element which OFFSET refers to. Increment *SUBOFF by
6471 the bit offset of the accessed element. */
6474 fold_array_ctor_reference (tree type
, tree ctor
,
6475 unsigned HOST_WIDE_INT offset
,
6476 unsigned HOST_WIDE_INT size
,
6478 unsigned HOST_WIDE_INT
*suboff
)
6480 offset_int low_bound
;
6481 offset_int elt_size
;
6482 offset_int access_index
;
6483 tree domain_type
= NULL_TREE
;
6484 HOST_WIDE_INT inner_offset
;
6486 /* Compute low bound and elt size. */
6487 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
6488 domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
6489 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
6491 /* Static constructors for variably sized objects makes no sense. */
6492 if (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) != INTEGER_CST
)
6494 low_bound
= wi::to_offset (TYPE_MIN_VALUE (domain_type
));
6498 /* Static constructors for variably sized objects makes no sense. */
6499 if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor
)))) != INTEGER_CST
)
6501 elt_size
= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor
))));
6503 /* When TYPE is non-null, verify that it specifies a constant-sized
6504 accessed not larger than size of array element. */
6506 && (!TYPE_SIZE_UNIT (type
)
6507 || TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
6508 || elt_size
< wi::to_offset (TYPE_SIZE_UNIT (type
))
6512 /* Compute the array index we look for. */
6513 access_index
= wi::udiv_trunc (offset_int (offset
/ BITS_PER_UNIT
),
6515 access_index
+= low_bound
;
6517 /* And offset within the access. */
6518 inner_offset
= offset
% (elt_size
.to_uhwi () * BITS_PER_UNIT
);
6520 /* See if the array field is large enough to span whole access. We do not
6521 care to fold accesses spanning multiple array indexes. */
6522 if (inner_offset
+ size
> elt_size
.to_uhwi () * BITS_PER_UNIT
)
6524 if (tree val
= get_array_ctor_element_at_index (ctor
, access_index
))
6526 if (!size
&& TREE_CODE (val
) != CONSTRUCTOR
)
6528 /* For the final reference to the entire accessed element
6529 (SIZE is zero), reset INNER_OFFSET, disegard TYPE (which
6530 may be null) in favor of the type of the element, and set
6531 SIZE to the size of the accessed element. */
6533 type
= TREE_TYPE (val
);
6534 size
= elt_size
.to_uhwi () * BITS_PER_UNIT
;
6537 *suboff
+= (access_index
* elt_size
* BITS_PER_UNIT
).to_uhwi ();
6538 return fold_ctor_reference (type
, val
, inner_offset
, size
, from_decl
,
6542 /* Memory not explicitly mentioned in constructor is 0 (or
6543 the reference is out of range). */
6544 return type
? build_zero_cst (type
) : NULL_TREE
;
6547 /* CTOR is CONSTRUCTOR of an aggregate or vector. Fold a reference
6548 of SIZE bits to the memory at bit OFFSET. When non-null, TYPE
6549 is the expected type of the reference; otherwise the type of
6550 the referenced member is used instead. When SIZE is zero,
6551 attempt to fold a reference to the entire member which OFFSET
6552 refers to; in this case. Increment *SUBOFF by the bit offset
6553 of the accessed member. */
6556 fold_nonarray_ctor_reference (tree type
, tree ctor
,
6557 unsigned HOST_WIDE_INT offset
,
6558 unsigned HOST_WIDE_INT size
,
6560 unsigned HOST_WIDE_INT
*suboff
)
6562 unsigned HOST_WIDE_INT cnt
;
6565 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
,
6568 tree byte_offset
= DECL_FIELD_OFFSET (cfield
);
6569 tree field_offset
= DECL_FIELD_BIT_OFFSET (cfield
);
6570 tree field_size
= DECL_SIZE (cfield
);
6574 /* Determine the size of the flexible array member from
6575 the size of the initializer provided for it. */
6576 field_size
= TYPE_SIZE (TREE_TYPE (cval
));
6579 /* Variable sized objects in static constructors makes no sense,
6580 but field_size can be NULL for flexible array members. */
6581 gcc_assert (TREE_CODE (field_offset
) == INTEGER_CST
6582 && TREE_CODE (byte_offset
) == INTEGER_CST
6583 && (field_size
!= NULL_TREE
6584 ? TREE_CODE (field_size
) == INTEGER_CST
6585 : TREE_CODE (TREE_TYPE (cfield
)) == ARRAY_TYPE
));
6587 /* Compute bit offset of the field. */
6588 offset_int bitoffset
6589 = (wi::to_offset (field_offset
)
6590 + (wi::to_offset (byte_offset
) << LOG2_BITS_PER_UNIT
));
6591 /* Compute bit offset where the field ends. */
6592 offset_int bitoffset_end
;
6593 if (field_size
!= NULL_TREE
)
6594 bitoffset_end
= bitoffset
+ wi::to_offset (field_size
);
6598 /* Compute the bit offset of the end of the desired access.
6599 As a special case, if the size of the desired access is
6600 zero, assume the access is to the entire field (and let
6601 the caller make any necessary adjustments by storing
6602 the actual bounds of the field in FIELDBOUNDS). */
6603 offset_int access_end
= offset_int (offset
);
6607 access_end
= bitoffset_end
;
6609 /* Is there any overlap between the desired access at
6610 [OFFSET, OFFSET+SIZE) and the offset of the field within
6611 the object at [BITOFFSET, BITOFFSET_END)? */
6612 if (wi::cmps (access_end
, bitoffset
) > 0
6613 && (field_size
== NULL_TREE
6614 || wi::lts_p (offset
, bitoffset_end
)))
6616 *suboff
+= bitoffset
.to_uhwi ();
6618 if (!size
&& TREE_CODE (cval
) != CONSTRUCTOR
)
6620 /* For the final reference to the entire accessed member
6621 (SIZE is zero), reset OFFSET, disegard TYPE (which may
6622 be null) in favor of the type of the member, and set
6623 SIZE to the size of the accessed member. */
6624 offset
= bitoffset
.to_uhwi ();
6625 type
= TREE_TYPE (cval
);
6626 size
= (bitoffset_end
- bitoffset
).to_uhwi ();
6629 /* We do have overlap. Now see if the field is large enough
6630 to cover the access. Give up for accesses that extend
6631 beyond the end of the object or that span multiple fields. */
6632 if (wi::cmps (access_end
, bitoffset_end
) > 0)
6634 if (offset
< bitoffset
)
6637 offset_int inner_offset
= offset_int (offset
) - bitoffset
;
6638 return fold_ctor_reference (type
, cval
,
6639 inner_offset
.to_uhwi (), size
,
6643 /* Memory not explicitly mentioned in constructor is 0. */
6644 return type
? build_zero_cst (type
) : NULL_TREE
;
6647 /* CTOR is value initializing memory. Fold a reference of TYPE and
6648 bit size POLY_SIZE to the memory at bit POLY_OFFSET. When SIZE
6649 is zero, attempt to fold a reference to the entire subobject
6650 which OFFSET refers to. This is used when folding accesses to
6651 string members of aggregates. When non-null, set *SUBOFF to
6652 the bit offset of the accessed subobject. */
6655 fold_ctor_reference (tree type
, tree ctor
, const poly_uint64
&poly_offset
,
6656 const poly_uint64
&poly_size
, tree from_decl
,
6657 unsigned HOST_WIDE_INT
*suboff
/* = NULL */)
6661 /* We found the field with exact match. */
6663 && useless_type_conversion_p (type
, TREE_TYPE (ctor
))
6664 && known_eq (poly_offset
, 0U))
6665 return canonicalize_constructor_val (unshare_expr (ctor
), from_decl
);
6667 /* The remaining optimizations need a constant size and offset. */
6668 unsigned HOST_WIDE_INT size
, offset
;
6669 if (!poly_size
.is_constant (&size
) || !poly_offset
.is_constant (&offset
))
6672 /* We are at the end of walk, see if we can view convert the
6674 if (!AGGREGATE_TYPE_P (TREE_TYPE (ctor
)) && !offset
6675 /* VIEW_CONVERT_EXPR is defined only for matching sizes. */
6676 && !compare_tree_int (TYPE_SIZE (type
), size
)
6677 && !compare_tree_int (TYPE_SIZE (TREE_TYPE (ctor
)), size
))
6679 ret
= canonicalize_constructor_val (unshare_expr (ctor
), from_decl
);
6682 ret
= fold_unary (VIEW_CONVERT_EXPR
, type
, ret
);
6684 STRIP_USELESS_TYPE_CONVERSION (ret
);
6688 /* For constants and byte-aligned/sized reads try to go through
6689 native_encode/interpret. */
6690 if (CONSTANT_CLASS_P (ctor
)
6691 && BITS_PER_UNIT
== 8
6692 && offset
% BITS_PER_UNIT
== 0
6693 && size
% BITS_PER_UNIT
== 0
6694 && size
<= MAX_BITSIZE_MODE_ANY_MODE
)
6696 unsigned char buf
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
6697 int len
= native_encode_expr (ctor
, buf
, size
/ BITS_PER_UNIT
,
6698 offset
/ BITS_PER_UNIT
);
6700 return native_interpret_expr (type
, buf
, len
);
6702 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
6704 unsigned HOST_WIDE_INT dummy
= 0;
6708 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
6709 || TREE_CODE (TREE_TYPE (ctor
)) == VECTOR_TYPE
)
6710 return fold_array_ctor_reference (type
, ctor
, offset
, size
,
6713 return fold_nonarray_ctor_reference (type
, ctor
, offset
, size
,
6720 /* Return the tree representing the element referenced by T if T is an
6721 ARRAY_REF or COMPONENT_REF into constant aggregates valuezing SSA
6722 names using VALUEIZE. Return NULL_TREE otherwise. */
6725 fold_const_aggregate_ref_1 (tree t
, tree (*valueize
) (tree
))
6727 tree ctor
, idx
, base
;
6728 poly_int64 offset
, size
, max_size
;
6732 if (TREE_THIS_VOLATILE (t
))
6736 return get_symbol_constant_value (t
);
6738 tem
= fold_read_from_constant_string (t
);
6742 switch (TREE_CODE (t
))
6745 case ARRAY_RANGE_REF
:
6746 /* Constant indexes are handled well by get_base_constructor.
6747 Only special case variable offsets.
6748 FIXME: This code can't handle nested references with variable indexes
6749 (they will be handled only by iteration of ccp). Perhaps we can bring
6750 get_ref_base_and_extent here and make it use a valueize callback. */
6751 if (TREE_CODE (TREE_OPERAND (t
, 1)) == SSA_NAME
6753 && (idx
= (*valueize
) (TREE_OPERAND (t
, 1)))
6754 && poly_int_tree_p (idx
))
6756 tree low_bound
, unit_size
;
6758 /* If the resulting bit-offset is constant, track it. */
6759 if ((low_bound
= array_ref_low_bound (t
),
6760 poly_int_tree_p (low_bound
))
6761 && (unit_size
= array_ref_element_size (t
),
6762 tree_fits_uhwi_p (unit_size
)))
6764 poly_offset_int woffset
6765 = wi::sext (wi::to_poly_offset (idx
)
6766 - wi::to_poly_offset (low_bound
),
6767 TYPE_PRECISION (TREE_TYPE (idx
)));
6769 if (woffset
.to_shwi (&offset
))
6771 /* TODO: This code seems wrong, multiply then check
6772 to see if it fits. */
6773 offset
*= tree_to_uhwi (unit_size
);
6774 offset
*= BITS_PER_UNIT
;
6776 base
= TREE_OPERAND (t
, 0);
6777 ctor
= get_base_constructor (base
, &offset
, valueize
);
6778 /* Empty constructor. Always fold to 0. */
6779 if (ctor
== error_mark_node
)
6780 return build_zero_cst (TREE_TYPE (t
));
6781 /* Out of bound array access. Value is undefined,
6783 if (maybe_lt (offset
, 0))
6785 /* We can not determine ctor. */
6788 return fold_ctor_reference (TREE_TYPE (t
), ctor
, offset
,
6789 tree_to_uhwi (unit_size
)
6799 case TARGET_MEM_REF
:
6801 base
= get_ref_base_and_extent (t
, &offset
, &size
, &max_size
, &reverse
);
6802 ctor
= get_base_constructor (base
, &offset
, valueize
);
6804 /* Empty constructor. Always fold to 0. */
6805 if (ctor
== error_mark_node
)
6806 return build_zero_cst (TREE_TYPE (t
));
6807 /* We do not know precise address. */
6808 if (!known_size_p (max_size
) || maybe_ne (max_size
, size
))
6810 /* We can not determine ctor. */
6814 /* Out of bound array access. Value is undefined, but don't fold. */
6815 if (maybe_lt (offset
, 0))
6818 return fold_ctor_reference (TREE_TYPE (t
), ctor
, offset
, size
,
6824 tree c
= fold_const_aggregate_ref_1 (TREE_OPERAND (t
, 0), valueize
);
6825 if (c
&& TREE_CODE (c
) == COMPLEX_CST
)
6826 return fold_build1_loc (EXPR_LOCATION (t
),
6827 TREE_CODE (t
), TREE_TYPE (t
), c
);
6839 fold_const_aggregate_ref (tree t
)
6841 return fold_const_aggregate_ref_1 (t
, NULL
);
6844 /* Lookup virtual method with index TOKEN in a virtual table V
6846 Set CAN_REFER if non-NULL to false if method
6847 is not referable or if the virtual table is ill-formed (such as rewriten
6848 by non-C++ produced symbol). Otherwise just return NULL in that calse. */
6851 gimple_get_virt_method_for_vtable (HOST_WIDE_INT token
,
6853 unsigned HOST_WIDE_INT offset
,
6856 tree vtable
= v
, init
, fn
;
6857 unsigned HOST_WIDE_INT size
;
6858 unsigned HOST_WIDE_INT elt_size
, access_index
;
6864 /* First of all double check we have virtual table. */
6865 if (!VAR_P (v
) || !DECL_VIRTUAL_P (v
))
6867 /* Pass down that we lost track of the target. */
6873 init
= ctor_for_folding (v
);
6875 /* The virtual tables should always be born with constructors
6876 and we always should assume that they are avaialble for
6877 folding. At the moment we do not stream them in all cases,
6878 but it should never happen that ctor seem unreachable. */
6880 if (init
== error_mark_node
)
6882 /* Pass down that we lost track of the target. */
6887 gcc_checking_assert (TREE_CODE (TREE_TYPE (v
)) == ARRAY_TYPE
);
6888 size
= tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (v
))));
6889 offset
*= BITS_PER_UNIT
;
6890 offset
+= token
* size
;
6892 /* Lookup the value in the constructor that is assumed to be array.
6893 This is equivalent to
6894 fn = fold_ctor_reference (TREE_TYPE (TREE_TYPE (v)), init,
6895 offset, size, NULL);
6896 but in a constant time. We expect that frontend produced a simple
6897 array without indexed initializers. */
6899 gcc_checking_assert (TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
);
6900 domain_type
= TYPE_DOMAIN (TREE_TYPE (init
));
6901 gcc_checking_assert (integer_zerop (TYPE_MIN_VALUE (domain_type
)));
6902 elt_size
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (init
))));
6904 access_index
= offset
/ BITS_PER_UNIT
/ elt_size
;
6905 gcc_checking_assert (offset
% (elt_size
* BITS_PER_UNIT
) == 0);
6907 /* This code makes an assumption that there are no
6908 indexed fileds produced by C++ FE, so we can directly index the array. */
6909 if (access_index
< CONSTRUCTOR_NELTS (init
))
6911 fn
= CONSTRUCTOR_ELT (init
, access_index
)->value
;
6912 gcc_checking_assert (!CONSTRUCTOR_ELT (init
, access_index
)->index
);
6918 /* For type inconsistent program we may end up looking up virtual method
6919 in virtual table that does not contain TOKEN entries. We may overrun
6920 the virtual table and pick up a constant or RTTI info pointer.
6921 In any case the call is undefined. */
6923 || (TREE_CODE (fn
) != ADDR_EXPR
&& TREE_CODE (fn
) != FDESC_EXPR
)
6924 || TREE_CODE (TREE_OPERAND (fn
, 0)) != FUNCTION_DECL
)
6925 fn
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
6928 fn
= TREE_OPERAND (fn
, 0);
6930 /* When cgraph node is missing and function is not public, we cannot
6931 devirtualize. This can happen in WHOPR when the actual method
6932 ends up in other partition, because we found devirtualization
6933 possibility too late. */
6934 if (!can_refer_decl_in_current_unit_p (fn
, vtable
))
6945 /* Make sure we create a cgraph node for functions we'll reference.
6946 They can be non-existent if the reference comes from an entry
6947 of an external vtable for example. */
6948 cgraph_node::get_create (fn
);
6953 /* Return a declaration of a function which an OBJ_TYPE_REF references. TOKEN
6954 is integer form of OBJ_TYPE_REF_TOKEN of the reference expression.
6955 KNOWN_BINFO carries the binfo describing the true type of
6956 OBJ_TYPE_REF_OBJECT(REF).
6957 Set CAN_REFER if non-NULL to false if method
6958 is not referable or if the virtual table is ill-formed (such as rewriten
6959 by non-C++ produced symbol). Otherwise just return NULL in that calse. */
6962 gimple_get_virt_method_for_binfo (HOST_WIDE_INT token
, tree known_binfo
,
6965 unsigned HOST_WIDE_INT offset
;
6968 v
= BINFO_VTABLE (known_binfo
);
6969 /* If there is no virtual methods table, leave the OBJ_TYPE_REF alone. */
6973 if (!vtable_pointer_value_to_vtable (v
, &v
, &offset
))
6979 return gimple_get_virt_method_for_vtable (token
, v
, offset
, can_refer
);
6982 /* Given a pointer value T, return a simplified version of an
6983 indirection through T, or NULL_TREE if no simplification is
6984 possible. Note that the resulting type may be different from
6985 the type pointed to in the sense that it is still compatible
6986 from the langhooks point of view. */
6989 gimple_fold_indirect_ref (tree t
)
6991 tree ptype
= TREE_TYPE (t
), type
= TREE_TYPE (ptype
);
6996 subtype
= TREE_TYPE (sub
);
6997 if (!POINTER_TYPE_P (subtype
)
6998 || TYPE_REF_CAN_ALIAS_ALL (ptype
))
7001 if (TREE_CODE (sub
) == ADDR_EXPR
)
7003 tree op
= TREE_OPERAND (sub
, 0);
7004 tree optype
= TREE_TYPE (op
);
7006 if (useless_type_conversion_p (type
, optype
))
7009 /* *(foo *)&fooarray => fooarray[0] */
7010 if (TREE_CODE (optype
) == ARRAY_TYPE
7011 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype
))) == INTEGER_CST
7012 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
7014 tree type_domain
= TYPE_DOMAIN (optype
);
7015 tree min_val
= size_zero_node
;
7016 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7017 min_val
= TYPE_MIN_VALUE (type_domain
);
7018 if (TREE_CODE (min_val
) == INTEGER_CST
)
7019 return build4 (ARRAY_REF
, type
, op
, min_val
, NULL_TREE
, NULL_TREE
);
7021 /* *(foo *)&complexfoo => __real__ complexfoo */
7022 else if (TREE_CODE (optype
) == COMPLEX_TYPE
7023 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
7024 return fold_build1 (REALPART_EXPR
, type
, op
);
7025 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
7026 else if (TREE_CODE (optype
) == VECTOR_TYPE
7027 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
7029 tree part_width
= TYPE_SIZE (type
);
7030 tree index
= bitsize_int (0);
7031 return fold_build3 (BIT_FIELD_REF
, type
, op
, part_width
, index
);
7035 /* *(p + CST) -> ... */
7036 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
7037 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
7039 tree addr
= TREE_OPERAND (sub
, 0);
7040 tree off
= TREE_OPERAND (sub
, 1);
7044 addrtype
= TREE_TYPE (addr
);
7046 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
7047 if (TREE_CODE (addr
) == ADDR_EXPR
7048 && TREE_CODE (TREE_TYPE (addrtype
)) == VECTOR_TYPE
7049 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
)))
7050 && tree_fits_uhwi_p (off
))
7052 unsigned HOST_WIDE_INT offset
= tree_to_uhwi (off
);
7053 tree part_width
= TYPE_SIZE (type
);
7054 unsigned HOST_WIDE_INT part_widthi
7055 = tree_to_shwi (part_width
) / BITS_PER_UNIT
;
7056 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
7057 tree index
= bitsize_int (indexi
);
7058 if (known_lt (offset
/ part_widthi
,
7059 TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype
))))
7060 return fold_build3 (BIT_FIELD_REF
, type
, TREE_OPERAND (addr
, 0),
7064 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
7065 if (TREE_CODE (addr
) == ADDR_EXPR
7066 && TREE_CODE (TREE_TYPE (addrtype
)) == COMPLEX_TYPE
7067 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
7069 tree size
= TYPE_SIZE_UNIT (type
);
7070 if (tree_int_cst_equal (size
, off
))
7071 return fold_build1 (IMAGPART_EXPR
, type
, TREE_OPERAND (addr
, 0));
7074 /* *(p + CST) -> MEM_REF <p, CST>. */
7075 if (TREE_CODE (addr
) != ADDR_EXPR
7076 || DECL_P (TREE_OPERAND (addr
, 0)))
7077 return fold_build2 (MEM_REF
, type
,
7079 wide_int_to_tree (ptype
, wi::to_wide (off
)));
7082 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
7083 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
7084 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype
)))) == INTEGER_CST
7085 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
7088 tree min_val
= size_zero_node
;
7090 sub
= gimple_fold_indirect_ref (sub
);
7092 sub
= build1 (INDIRECT_REF
, TREE_TYPE (subtype
), osub
);
7093 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
7094 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
7095 min_val
= TYPE_MIN_VALUE (type_domain
);
7096 if (TREE_CODE (min_val
) == INTEGER_CST
)
7097 return build4 (ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
, NULL_TREE
);
7103 /* Return true if CODE is an operation that when operating on signed
7104 integer types involves undefined behavior on overflow and the
7105 operation can be expressed with unsigned arithmetic. */
7108 arith_code_with_undefined_signed_overflow (tree_code code
)
7116 case POINTER_PLUS_EXPR
:
7123 /* Rewrite STMT, an assignment with a signed integer or pointer arithmetic
7124 operation that can be transformed to unsigned arithmetic by converting
7125 its operand, carrying out the operation in the corresponding unsigned
7126 type and converting the result back to the original type.
7128 Returns a sequence of statements that replace STMT and also contain
7129 a modified form of STMT itself. */
7132 rewrite_to_defined_overflow (gimple
*stmt
)
7134 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
7136 fprintf (dump_file
, "rewriting stmt with undefined signed "
7138 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
7141 tree lhs
= gimple_assign_lhs (stmt
);
7142 tree type
= unsigned_type_for (TREE_TYPE (lhs
));
7143 gimple_seq stmts
= NULL
;
7144 for (unsigned i
= 1; i
< gimple_num_ops (stmt
); ++i
)
7146 tree op
= gimple_op (stmt
, i
);
7147 op
= gimple_convert (&stmts
, type
, op
);
7148 gimple_set_op (stmt
, i
, op
);
7150 gimple_assign_set_lhs (stmt
, make_ssa_name (type
, stmt
));
7151 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
)
7152 gimple_assign_set_rhs_code (stmt
, PLUS_EXPR
);
7153 gimple_seq_add_stmt (&stmts
, stmt
);
7154 gimple
*cvt
= gimple_build_assign (lhs
, NOP_EXPR
, gimple_assign_lhs (stmt
));
7155 gimple_seq_add_stmt (&stmts
, cvt
);
7161 /* The valueization hook we use for the gimple_build API simplification.
7162 This makes us match fold_buildN behavior by only combining with
7163 statements in the sequence(s) we are currently building. */
7166 gimple_build_valueize (tree op
)
7168 if (gimple_bb (SSA_NAME_DEF_STMT (op
)) == NULL
)
7173 /* Build the expression CODE OP0 of type TYPE with location LOC,
7174 simplifying it first if possible. Returns the built
7175 expression value and appends statements possibly defining it
7179 gimple_build (gimple_seq
*seq
, location_t loc
,
7180 enum tree_code code
, tree type
, tree op0
)
7182 tree res
= gimple_simplify (code
, type
, op0
, seq
, gimple_build_valueize
);
7185 res
= create_tmp_reg_or_ssa_name (type
);
7187 if (code
== REALPART_EXPR
7188 || code
== IMAGPART_EXPR
7189 || code
== VIEW_CONVERT_EXPR
)
7190 stmt
= gimple_build_assign (res
, code
, build1 (code
, type
, op0
));
7192 stmt
= gimple_build_assign (res
, code
, op0
);
7193 gimple_set_location (stmt
, loc
);
7194 gimple_seq_add_stmt_without_update (seq
, stmt
);
7199 /* Build the expression OP0 CODE OP1 of type TYPE with location LOC,
7200 simplifying it first if possible. Returns the built
7201 expression value and appends statements possibly defining it
7205 gimple_build (gimple_seq
*seq
, location_t loc
,
7206 enum tree_code code
, tree type
, tree op0
, tree op1
)
7208 tree res
= gimple_simplify (code
, type
, op0
, op1
, seq
, gimple_build_valueize
);
7211 res
= create_tmp_reg_or_ssa_name (type
);
7212 gimple
*stmt
= gimple_build_assign (res
, code
, op0
, op1
);
7213 gimple_set_location (stmt
, loc
);
7214 gimple_seq_add_stmt_without_update (seq
, stmt
);
7219 /* Build the expression (CODE OP0 OP1 OP2) of type TYPE with location LOC,
7220 simplifying it first if possible. Returns the built
7221 expression value and appends statements possibly defining it
7225 gimple_build (gimple_seq
*seq
, location_t loc
,
7226 enum tree_code code
, tree type
, tree op0
, tree op1
, tree op2
)
7228 tree res
= gimple_simplify (code
, type
, op0
, op1
, op2
,
7229 seq
, gimple_build_valueize
);
7232 res
= create_tmp_reg_or_ssa_name (type
);
7234 if (code
== BIT_FIELD_REF
)
7235 stmt
= gimple_build_assign (res
, code
,
7236 build3 (code
, type
, op0
, op1
, op2
));
7238 stmt
= gimple_build_assign (res
, code
, op0
, op1
, op2
);
7239 gimple_set_location (stmt
, loc
);
7240 gimple_seq_add_stmt_without_update (seq
, stmt
);
7245 /* Build the call FN (ARG0) with a result of type TYPE
7246 (or no result if TYPE is void) with location LOC,
7247 simplifying it first if possible. Returns the built
7248 expression value (or NULL_TREE if TYPE is void) and appends
7249 statements possibly defining it to SEQ. */
7252 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
7253 tree type
, tree arg0
)
7255 tree res
= gimple_simplify (fn
, type
, arg0
, seq
, gimple_build_valueize
);
7259 if (internal_fn_p (fn
))
7260 stmt
= gimple_build_call_internal (as_internal_fn (fn
), 1, arg0
);
7263 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
7264 stmt
= gimple_build_call (decl
, 1, arg0
);
7266 if (!VOID_TYPE_P (type
))
7268 res
= create_tmp_reg_or_ssa_name (type
);
7269 gimple_call_set_lhs (stmt
, res
);
7271 gimple_set_location (stmt
, loc
);
7272 gimple_seq_add_stmt_without_update (seq
, stmt
);
7277 /* Build the call FN (ARG0, ARG1) with a result of type TYPE
7278 (or no result if TYPE is void) with location LOC,
7279 simplifying it first if possible. Returns the built
7280 expression value (or NULL_TREE if TYPE is void) and appends
7281 statements possibly defining it to SEQ. */
7284 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
7285 tree type
, tree arg0
, tree arg1
)
7287 tree res
= gimple_simplify (fn
, type
, arg0
, arg1
, seq
, gimple_build_valueize
);
7291 if (internal_fn_p (fn
))
7292 stmt
= gimple_build_call_internal (as_internal_fn (fn
), 2, arg0
, arg1
);
7295 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
7296 stmt
= gimple_build_call (decl
, 2, arg0
, arg1
);
7298 if (!VOID_TYPE_P (type
))
7300 res
= create_tmp_reg_or_ssa_name (type
);
7301 gimple_call_set_lhs (stmt
, res
);
7303 gimple_set_location (stmt
, loc
);
7304 gimple_seq_add_stmt_without_update (seq
, stmt
);
7309 /* Build the call FN (ARG0, ARG1, ARG2) with a result of type TYPE
7310 (or no result if TYPE is void) with location LOC,
7311 simplifying it first if possible. Returns the built
7312 expression value (or NULL_TREE if TYPE is void) and appends
7313 statements possibly defining it to SEQ. */
7316 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
7317 tree type
, tree arg0
, tree arg1
, tree arg2
)
7319 tree res
= gimple_simplify (fn
, type
, arg0
, arg1
, arg2
,
7320 seq
, gimple_build_valueize
);
7324 if (internal_fn_p (fn
))
7325 stmt
= gimple_build_call_internal (as_internal_fn (fn
),
7326 3, arg0
, arg1
, arg2
);
7329 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
7330 stmt
= gimple_build_call (decl
, 3, arg0
, arg1
, arg2
);
7332 if (!VOID_TYPE_P (type
))
7334 res
= create_tmp_reg_or_ssa_name (type
);
7335 gimple_call_set_lhs (stmt
, res
);
7337 gimple_set_location (stmt
, loc
);
7338 gimple_seq_add_stmt_without_update (seq
, stmt
);
7343 /* Build the conversion (TYPE) OP with a result of type TYPE
7344 with location LOC if such conversion is neccesary in GIMPLE,
7345 simplifying it first.
7346 Returns the built expression value and appends
7347 statements possibly defining it to SEQ. */
7350 gimple_convert (gimple_seq
*seq
, location_t loc
, tree type
, tree op
)
7352 if (useless_type_conversion_p (type
, TREE_TYPE (op
)))
7354 return gimple_build (seq
, loc
, NOP_EXPR
, type
, op
);
7357 /* Build the conversion (ptrofftype) OP with a result of a type
7358 compatible with ptrofftype with location LOC if such conversion
7359 is neccesary in GIMPLE, simplifying it first.
7360 Returns the built expression value and appends
7361 statements possibly defining it to SEQ. */
7364 gimple_convert_to_ptrofftype (gimple_seq
*seq
, location_t loc
, tree op
)
7366 if (ptrofftype_p (TREE_TYPE (op
)))
7368 return gimple_convert (seq
, loc
, sizetype
, op
);
7371 /* Build a vector of type TYPE in which each element has the value OP.
7372 Return a gimple value for the result, appending any new statements
7376 gimple_build_vector_from_val (gimple_seq
*seq
, location_t loc
, tree type
,
7379 if (!TYPE_VECTOR_SUBPARTS (type
).is_constant ()
7380 && !CONSTANT_CLASS_P (op
))
7381 return gimple_build (seq
, loc
, VEC_DUPLICATE_EXPR
, type
, op
);
7383 tree res
, vec
= build_vector_from_val (type
, op
);
7384 if (is_gimple_val (vec
))
7386 if (gimple_in_ssa_p (cfun
))
7387 res
= make_ssa_name (type
);
7389 res
= create_tmp_reg (type
);
7390 gimple
*stmt
= gimple_build_assign (res
, vec
);
7391 gimple_set_location (stmt
, loc
);
7392 gimple_seq_add_stmt_without_update (seq
, stmt
);
7396 /* Build a vector from BUILDER, handling the case in which some elements
7397 are non-constant. Return a gimple value for the result, appending any
7398 new instructions to SEQ.
7400 BUILDER must not have a stepped encoding on entry. This is because
7401 the function is not geared up to handle the arithmetic that would
7402 be needed in the variable case, and any code building a vector that
7403 is known to be constant should use BUILDER->build () directly. */
7406 gimple_build_vector (gimple_seq
*seq
, location_t loc
,
7407 tree_vector_builder
*builder
)
7409 gcc_assert (builder
->nelts_per_pattern () <= 2);
7410 unsigned int encoded_nelts
= builder
->encoded_nelts ();
7411 for (unsigned int i
= 0; i
< encoded_nelts
; ++i
)
7412 if (!TREE_CONSTANT ((*builder
)[i
]))
7414 tree type
= builder
->type ();
7415 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
).to_constant ();
7416 vec
<constructor_elt
, va_gc
> *v
;
7417 vec_alloc (v
, nelts
);
7418 for (i
= 0; i
< nelts
; ++i
)
7419 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, builder
->elt (i
));
7422 if (gimple_in_ssa_p (cfun
))
7423 res
= make_ssa_name (type
);
7425 res
= create_tmp_reg (type
);
7426 gimple
*stmt
= gimple_build_assign (res
, build_constructor (type
, v
));
7427 gimple_set_location (stmt
, loc
);
7428 gimple_seq_add_stmt_without_update (seq
, stmt
);
7431 return builder
->build ();
7434 /* Return true if the result of assignment STMT is known to be non-negative.
7435 If the return value is based on the assumption that signed overflow is
7436 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
7437 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
7440 gimple_assign_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
7443 enum tree_code code
= gimple_assign_rhs_code (stmt
);
7444 switch (get_gimple_rhs_class (code
))
7446 case GIMPLE_UNARY_RHS
:
7447 return tree_unary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt
),
7448 gimple_expr_type (stmt
),
7449 gimple_assign_rhs1 (stmt
),
7450 strict_overflow_p
, depth
);
7451 case GIMPLE_BINARY_RHS
:
7452 return tree_binary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt
),
7453 gimple_expr_type (stmt
),
7454 gimple_assign_rhs1 (stmt
),
7455 gimple_assign_rhs2 (stmt
),
7456 strict_overflow_p
, depth
);
7457 case GIMPLE_TERNARY_RHS
:
7459 case GIMPLE_SINGLE_RHS
:
7460 return tree_single_nonnegative_warnv_p (gimple_assign_rhs1 (stmt
),
7461 strict_overflow_p
, depth
);
7462 case GIMPLE_INVALID_RHS
:
7468 /* Return true if return value of call STMT is known to be non-negative.
7469 If the return value is based on the assumption that signed overflow is
7470 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
7471 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
7474 gimple_call_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
7477 tree arg0
= gimple_call_num_args (stmt
) > 0 ?
7478 gimple_call_arg (stmt
, 0) : NULL_TREE
;
7479 tree arg1
= gimple_call_num_args (stmt
) > 1 ?
7480 gimple_call_arg (stmt
, 1) : NULL_TREE
;
7482 return tree_call_nonnegative_warnv_p (gimple_expr_type (stmt
),
7483 gimple_call_combined_fn (stmt
),
7486 strict_overflow_p
, depth
);
7489 /* Return true if return value of call STMT is known to be non-negative.
7490 If the return value is based on the assumption that signed overflow is
7491 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
7492 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
7495 gimple_phi_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
7498 for (unsigned i
= 0; i
< gimple_phi_num_args (stmt
); ++i
)
7500 tree arg
= gimple_phi_arg_def (stmt
, i
);
7501 if (!tree_single_nonnegative_warnv_p (arg
, strict_overflow_p
, depth
+ 1))
7507 /* Return true if STMT is known to compute a non-negative value.
7508 If the return value is based on the assumption that signed overflow is
7509 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
7510 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
7513 gimple_stmt_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
7516 switch (gimple_code (stmt
))
7519 return gimple_assign_nonnegative_warnv_p (stmt
, strict_overflow_p
,
7522 return gimple_call_nonnegative_warnv_p (stmt
, strict_overflow_p
,
7525 return gimple_phi_nonnegative_warnv_p (stmt
, strict_overflow_p
,
7532 /* Return true if the floating-point value computed by assignment STMT
7533 is known to have an integer value. We also allow +Inf, -Inf and NaN
7534 to be considered integer values. Return false for signaling NaN.
7536 DEPTH is the current nesting depth of the query. */
7539 gimple_assign_integer_valued_real_p (gimple
*stmt
, int depth
)
7541 enum tree_code code
= gimple_assign_rhs_code (stmt
);
7542 switch (get_gimple_rhs_class (code
))
7544 case GIMPLE_UNARY_RHS
:
7545 return integer_valued_real_unary_p (gimple_assign_rhs_code (stmt
),
7546 gimple_assign_rhs1 (stmt
), depth
);
7547 case GIMPLE_BINARY_RHS
:
7548 return integer_valued_real_binary_p (gimple_assign_rhs_code (stmt
),
7549 gimple_assign_rhs1 (stmt
),
7550 gimple_assign_rhs2 (stmt
), depth
);
7551 case GIMPLE_TERNARY_RHS
:
7553 case GIMPLE_SINGLE_RHS
:
7554 return integer_valued_real_single_p (gimple_assign_rhs1 (stmt
), depth
);
7555 case GIMPLE_INVALID_RHS
:
7561 /* Return true if the floating-point value computed by call STMT is known
7562 to have an integer value. We also allow +Inf, -Inf and NaN to be
7563 considered integer values. Return false for signaling NaN.
7565 DEPTH is the current nesting depth of the query. */
7568 gimple_call_integer_valued_real_p (gimple
*stmt
, int depth
)
7570 tree arg0
= (gimple_call_num_args (stmt
) > 0
7571 ? gimple_call_arg (stmt
, 0)
7573 tree arg1
= (gimple_call_num_args (stmt
) > 1
7574 ? gimple_call_arg (stmt
, 1)
7576 return integer_valued_real_call_p (gimple_call_combined_fn (stmt
),
7580 /* Return true if the floating-point result of phi STMT is known to have
7581 an integer value. We also allow +Inf, -Inf and NaN to be considered
7582 integer values. Return false for signaling NaN.
7584 DEPTH is the current nesting depth of the query. */
7587 gimple_phi_integer_valued_real_p (gimple
*stmt
, int depth
)
7589 for (unsigned i
= 0; i
< gimple_phi_num_args (stmt
); ++i
)
7591 tree arg
= gimple_phi_arg_def (stmt
, i
);
7592 if (!integer_valued_real_single_p (arg
, depth
+ 1))
7598 /* Return true if the floating-point value computed by STMT is known
7599 to have an integer value. We also allow +Inf, -Inf and NaN to be
7600 considered integer values. Return false for signaling NaN.
7602 DEPTH is the current nesting depth of the query. */
7605 gimple_stmt_integer_valued_real_p (gimple
*stmt
, int depth
)
7607 switch (gimple_code (stmt
))
7610 return gimple_assign_integer_valued_real_p (stmt
, depth
);
7612 return gimple_call_integer_valued_real_p (stmt
, depth
);
7614 return gimple_phi_integer_valued_real_p (stmt
, depth
);