1 /* Statement simplification on GIMPLE.
2 Copyright (C) 2010-2021 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-access.h"
34 #include "gimple-ssa-warn-restrict.h"
35 #include "fold-const.h"
38 #include "stor-layout.h"
40 #include "gimple-fold.h"
42 #include "gimple-iterator.h"
43 #include "tree-into-ssa.h"
45 #include "tree-object-size.h"
47 #include "tree-ssa-propagate.h"
48 #include "ipa-utils.h"
49 #include "tree-ssa-address.h"
50 #include "langhooks.h"
51 #include "gimplify-me.h"
55 #include "gimple-match.h"
56 #include "gomp-constants.h"
57 #include "optabs-query.h"
58 #include "omp-general.h"
60 #include "fold-const-call.h"
61 #include "stringpool.h"
64 #include "diagnostic-core.h"
67 #include "tree-vector-builder.h"
68 #include "tree-ssa-strlen.h"
72 #include "internal-fn.h"
74 enum strlen_range_kind
{
75 /* Compute the exact constant string length. */
77 /* Compute the maximum constant string length. */
79 /* Compute a range of string lengths bounded by object sizes. When
80 the length of a string cannot be determined, consider as the upper
81 bound the size of the enclosing object the string may be a member
82 or element of. Also determine the size of the largest character
83 array the string may refer to. */
85 /* Determine the integer value of the argument (not string length). */
90 get_range_strlen (tree
, bitmap
, strlen_range_kind
, c_strlen_data
*, unsigned);
92 /* Return true when DECL can be referenced from current unit.
93 FROM_DECL (if non-null) specify constructor of variable DECL was taken from.
94 We can get declarations that are not possible to reference for various
97 1) When analyzing C++ virtual tables.
98 C++ virtual tables do have known constructors even
99 when they are keyed to other compilation unit.
100 Those tables can contain pointers to methods and vars
101 in other units. Those methods have both STATIC and EXTERNAL
103 2) In WHOPR mode devirtualization might lead to reference
104 to method that was partitioned elsehwere.
105 In this case we have static VAR_DECL or FUNCTION_DECL
106 that has no corresponding callgraph/varpool node
108 3) COMDAT functions referred by external vtables that
109 we devirtualize only during final compilation stage.
110 At this time we already decided that we will not output
111 the function body and thus we can't reference the symbol
115 can_refer_decl_in_current_unit_p (tree decl
, tree from_decl
)
118 struct cgraph_node
*node
;
121 if (DECL_ABSTRACT_P (decl
))
124 /* We are concerned only about static/external vars and functions. */
125 if ((!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
126 || !VAR_OR_FUNCTION_DECL_P (decl
))
129 /* Static objects can be referred only if they are defined and not optimized
131 if (!TREE_PUBLIC (decl
))
133 if (DECL_EXTERNAL (decl
))
135 /* Before we start optimizing unreachable code we can be sure all
136 static objects are defined. */
137 if (symtab
->function_flags_ready
)
139 snode
= symtab_node::get (decl
);
140 if (!snode
|| !snode
->definition
)
142 node
= dyn_cast
<cgraph_node
*> (snode
);
143 return !node
|| !node
->inlined_to
;
146 /* We will later output the initializer, so we can refer to it.
147 So we are concerned only when DECL comes from initializer of
148 external var or var that has been optimized out. */
150 || !VAR_P (from_decl
)
151 || (!DECL_EXTERNAL (from_decl
)
152 && (vnode
= varpool_node::get (from_decl
)) != NULL
153 && vnode
->definition
)
155 && (vnode
= varpool_node::get (from_decl
)) != NULL
156 && vnode
->in_other_partition
))
158 /* We are folding reference from external vtable. The vtable may reffer
159 to a symbol keyed to other compilation unit. The other compilation
160 unit may be in separate DSO and the symbol may be hidden. */
161 if (DECL_VISIBILITY_SPECIFIED (decl
)
162 && DECL_EXTERNAL (decl
)
163 && DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
164 && (!(snode
= symtab_node::get (decl
)) || !snode
->in_other_partition
))
166 /* When function is public, we always can introduce new reference.
167 Exception are the COMDAT functions where introducing a direct
168 reference imply need to include function body in the curren tunit. */
169 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
171 /* We have COMDAT. We are going to check if we still have definition
172 or if the definition is going to be output in other partition.
173 Bypass this when gimplifying; all needed functions will be produced.
175 As observed in PR20991 for already optimized out comdat virtual functions
176 it may be tempting to not necessarily give up because the copy will be
177 output elsewhere when corresponding vtable is output.
178 This is however not possible - ABI specify that COMDATs are output in
179 units where they are used and when the other unit was compiled with LTO
180 it is possible that vtable was kept public while the function itself
182 if (!symtab
->function_flags_ready
)
185 snode
= symtab_node::get (decl
);
187 || ((!snode
->definition
|| DECL_EXTERNAL (decl
))
188 && (!snode
->in_other_partition
189 || (!snode
->forced_by_abi
&& !snode
->force_output
))))
191 node
= dyn_cast
<cgraph_node
*> (snode
);
192 return !node
|| !node
->inlined_to
;
195 /* Create a temporary for TYPE for a statement STMT. If the current function
196 is in SSA form, a SSA name is created. Otherwise a temporary register
200 create_tmp_reg_or_ssa_name (tree type
, gimple
*stmt
)
202 if (gimple_in_ssa_p (cfun
))
203 return make_ssa_name (type
, stmt
);
205 return create_tmp_reg (type
);
208 /* CVAL is value taken from DECL_INITIAL of variable. Try to transform it into
209 acceptable form for is_gimple_min_invariant.
210 FROM_DECL (if non-NULL) specify variable whose constructor contains CVAL. */
213 canonicalize_constructor_val (tree cval
, tree from_decl
)
215 if (CONSTANT_CLASS_P (cval
))
218 tree orig_cval
= cval
;
220 if (TREE_CODE (cval
) == POINTER_PLUS_EXPR
221 && TREE_CODE (TREE_OPERAND (cval
, 1)) == INTEGER_CST
)
223 tree ptr
= TREE_OPERAND (cval
, 0);
224 if (is_gimple_min_invariant (ptr
))
225 cval
= build1_loc (EXPR_LOCATION (cval
),
226 ADDR_EXPR
, TREE_TYPE (ptr
),
227 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (ptr
)),
229 fold_convert (ptr_type_node
,
230 TREE_OPERAND (cval
, 1))));
232 if (TREE_CODE (cval
) == ADDR_EXPR
)
234 tree base
= NULL_TREE
;
235 if (TREE_CODE (TREE_OPERAND (cval
, 0)) == COMPOUND_LITERAL_EXPR
)
237 base
= COMPOUND_LITERAL_EXPR_DECL (TREE_OPERAND (cval
, 0));
239 TREE_OPERAND (cval
, 0) = base
;
242 base
= get_base_address (TREE_OPERAND (cval
, 0));
246 if (VAR_OR_FUNCTION_DECL_P (base
)
247 && !can_refer_decl_in_current_unit_p (base
, from_decl
))
249 if (TREE_TYPE (base
) == error_mark_node
)
252 /* ??? We should be able to assert that TREE_ADDRESSABLE is set,
253 but since the use can be in a debug stmt we can't. */
255 else if (TREE_CODE (base
) == FUNCTION_DECL
)
257 /* Make sure we create a cgraph node for functions we'll reference.
258 They can be non-existent if the reference comes from an entry
259 of an external vtable for example. */
260 cgraph_node::get_create (base
);
262 /* Fixup types in global initializers. */
263 if (TREE_TYPE (TREE_TYPE (cval
)) != TREE_TYPE (TREE_OPERAND (cval
, 0)))
264 cval
= build_fold_addr_expr (TREE_OPERAND (cval
, 0));
266 if (!useless_type_conversion_p (TREE_TYPE (orig_cval
), TREE_TYPE (cval
)))
267 cval
= fold_convert (TREE_TYPE (orig_cval
), cval
);
270 /* In CONSTRUCTORs we may see unfolded constants like (int (*) ()) 0. */
271 if (TREE_CODE (cval
) == INTEGER_CST
)
273 if (TREE_OVERFLOW_P (cval
))
274 cval
= drop_tree_overflow (cval
);
275 if (!useless_type_conversion_p (TREE_TYPE (orig_cval
), TREE_TYPE (cval
)))
276 cval
= fold_convert (TREE_TYPE (orig_cval
), cval
);
282 /* If SYM is a constant variable with known value, return the value.
283 NULL_TREE is returned otherwise. */
286 get_symbol_constant_value (tree sym
)
288 tree val
= ctor_for_folding (sym
);
289 if (val
!= error_mark_node
)
293 val
= canonicalize_constructor_val (unshare_expr (val
), sym
);
294 if (val
&& is_gimple_min_invariant (val
))
299 /* Variables declared 'const' without an initializer
300 have zero as the initializer if they may not be
301 overridden at link or run time. */
303 && is_gimple_reg_type (TREE_TYPE (sym
)))
304 return build_zero_cst (TREE_TYPE (sym
));
312 /* Subroutine of fold_stmt. We perform constant folding of the
313 memory reference tree EXPR. */
316 maybe_fold_reference (tree expr
)
318 tree result
= NULL_TREE
;
320 if ((TREE_CODE (expr
) == VIEW_CONVERT_EXPR
321 || TREE_CODE (expr
) == REALPART_EXPR
322 || TREE_CODE (expr
) == IMAGPART_EXPR
)
323 && CONSTANT_CLASS_P (TREE_OPERAND (expr
, 0)))
324 result
= fold_unary_loc (EXPR_LOCATION (expr
),
327 TREE_OPERAND (expr
, 0));
328 else if (TREE_CODE (expr
) == BIT_FIELD_REF
329 && CONSTANT_CLASS_P (TREE_OPERAND (expr
, 0)))
330 result
= fold_ternary_loc (EXPR_LOCATION (expr
),
333 TREE_OPERAND (expr
, 0),
334 TREE_OPERAND (expr
, 1),
335 TREE_OPERAND (expr
, 2));
337 result
= fold_const_aggregate_ref (expr
);
339 if (result
&& is_gimple_min_invariant (result
))
345 /* Return true if EXPR is an acceptable right-hand-side for a
346 GIMPLE assignment. We validate the entire tree, not just
347 the root node, thus catching expressions that embed complex
348 operands that are not permitted in GIMPLE. This function
349 is needed because the folding routines in fold-const.c
350 may return such expressions in some cases, e.g., an array
351 access with an embedded index addition. It may make more
352 sense to have folding routines that are sensitive to the
353 constraints on GIMPLE operands, rather than abandoning any
354 any attempt to fold if the usual folding turns out to be too
358 valid_gimple_rhs_p (tree expr
)
360 enum tree_code code
= TREE_CODE (expr
);
362 switch (TREE_CODE_CLASS (code
))
364 case tcc_declaration
:
365 if (!is_gimple_variable (expr
))
370 /* All constants are ok. */
374 /* GENERIC allows comparisons with non-boolean types, reject
375 those for GIMPLE. Let vector-typed comparisons pass - rules
376 for GENERIC and GIMPLE are the same here. */
377 if (!(INTEGRAL_TYPE_P (TREE_TYPE (expr
))
378 && (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
379 || TYPE_PRECISION (TREE_TYPE (expr
)) == 1))
380 && ! VECTOR_TYPE_P (TREE_TYPE (expr
)))
385 if (!is_gimple_val (TREE_OPERAND (expr
, 0))
386 || !is_gimple_val (TREE_OPERAND (expr
, 1)))
391 if (!is_gimple_val (TREE_OPERAND (expr
, 0)))
401 if (is_gimple_min_invariant (expr
))
403 t
= TREE_OPERAND (expr
, 0);
404 while (handled_component_p (t
))
406 /* ??? More checks needed, see the GIMPLE verifier. */
407 if ((TREE_CODE (t
) == ARRAY_REF
408 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
409 && !is_gimple_val (TREE_OPERAND (t
, 1)))
411 t
= TREE_OPERAND (t
, 0);
413 if (!is_gimple_id (t
))
419 if (get_gimple_rhs_class (code
) == GIMPLE_TERNARY_RHS
)
421 if ((code
== COND_EXPR
422 ? !is_gimple_condexpr (TREE_OPERAND (expr
, 0))
423 : !is_gimple_val (TREE_OPERAND (expr
, 0)))
424 || !is_gimple_val (TREE_OPERAND (expr
, 1))
425 || !is_gimple_val (TREE_OPERAND (expr
, 2)))
436 case tcc_exceptional
:
437 if (code
== CONSTRUCTOR
)
441 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), i
, elt
)
442 if (!is_gimple_val (elt
))
446 if (code
!= SSA_NAME
)
451 if (code
== BIT_FIELD_REF
)
452 return is_gimple_val (TREE_OPERAND (expr
, 0));
463 /* Attempt to fold an assignment statement pointed-to by SI. Returns a
464 replacement rhs for the statement or NULL_TREE if no simplification
465 could be made. It is assumed that the operands have been previously
469 fold_gimple_assign (gimple_stmt_iterator
*si
)
471 gimple
*stmt
= gsi_stmt (*si
);
472 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
473 location_t loc
= gimple_location (stmt
);
475 tree result
= NULL_TREE
;
477 switch (get_gimple_rhs_class (subcode
))
479 case GIMPLE_SINGLE_RHS
:
481 tree rhs
= gimple_assign_rhs1 (stmt
);
483 if (TREE_CLOBBER_P (rhs
))
486 if (REFERENCE_CLASS_P (rhs
))
487 return maybe_fold_reference (rhs
);
489 else if (TREE_CODE (rhs
) == OBJ_TYPE_REF
)
491 tree val
= OBJ_TYPE_REF_EXPR (rhs
);
492 if (is_gimple_min_invariant (val
))
494 else if (flag_devirtualize
&& virtual_method_call_p (rhs
))
497 vec
<cgraph_node
*>targets
498 = possible_polymorphic_call_targets (rhs
, stmt
, &final
);
499 if (final
&& targets
.length () <= 1 && dbg_cnt (devirt
))
501 if (dump_enabled_p ())
503 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
,
504 "resolving virtual function address "
505 "reference to function %s\n",
506 targets
.length () == 1
507 ? targets
[0]->name ()
510 if (targets
.length () == 1)
512 val
= fold_convert (TREE_TYPE (val
),
513 build_fold_addr_expr_loc
514 (loc
, targets
[0]->decl
));
515 STRIP_USELESS_TYPE_CONVERSION (val
);
518 /* We cannot use __builtin_unreachable here because it
519 cannot have address taken. */
520 val
= build_int_cst (TREE_TYPE (val
), 0);
526 else if (TREE_CODE (rhs
) == ADDR_EXPR
)
528 tree ref
= TREE_OPERAND (rhs
, 0);
529 if (TREE_CODE (ref
) == MEM_REF
530 && integer_zerop (TREE_OPERAND (ref
, 1)))
532 result
= TREE_OPERAND (ref
, 0);
533 if (!useless_type_conversion_p (TREE_TYPE (rhs
),
535 result
= build1 (NOP_EXPR
, TREE_TYPE (rhs
), result
);
540 else if (TREE_CODE (rhs
) == CONSTRUCTOR
541 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
)
543 /* Fold a constant vector CONSTRUCTOR to VECTOR_CST. */
547 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
548 if (! CONSTANT_CLASS_P (val
))
551 return build_vector_from_ctor (TREE_TYPE (rhs
),
552 CONSTRUCTOR_ELTS (rhs
));
555 else if (DECL_P (rhs
)
556 && is_gimple_reg_type (TREE_TYPE (rhs
)))
557 return get_symbol_constant_value (rhs
);
561 case GIMPLE_UNARY_RHS
:
564 case GIMPLE_BINARY_RHS
:
567 case GIMPLE_TERNARY_RHS
:
568 result
= fold_ternary_loc (loc
, subcode
,
569 TREE_TYPE (gimple_assign_lhs (stmt
)),
570 gimple_assign_rhs1 (stmt
),
571 gimple_assign_rhs2 (stmt
),
572 gimple_assign_rhs3 (stmt
));
576 STRIP_USELESS_TYPE_CONVERSION (result
);
577 if (valid_gimple_rhs_p (result
))
582 case GIMPLE_INVALID_RHS
:
590 /* Replace a statement at *SI_P with a sequence of statements in STMTS,
591 adjusting the replacement stmts location and virtual operands.
592 If the statement has a lhs the last stmt in the sequence is expected
593 to assign to that lhs. */
596 gsi_replace_with_seq_vops (gimple_stmt_iterator
*si_p
, gimple_seq stmts
)
598 gimple
*stmt
= gsi_stmt (*si_p
);
600 if (gimple_has_location (stmt
))
601 annotate_all_with_location (stmts
, gimple_location (stmt
));
603 /* First iterate over the replacement statements backward, assigning
604 virtual operands to their defining statements. */
605 gimple
*laststore
= NULL
;
606 for (gimple_stmt_iterator i
= gsi_last (stmts
);
607 !gsi_end_p (i
); gsi_prev (&i
))
609 gimple
*new_stmt
= gsi_stmt (i
);
610 if ((gimple_assign_single_p (new_stmt
)
611 && !is_gimple_reg (gimple_assign_lhs (new_stmt
)))
612 || (is_gimple_call (new_stmt
)
613 && (gimple_call_flags (new_stmt
)
614 & (ECF_NOVOPS
| ECF_PURE
| ECF_CONST
| ECF_NORETURN
)) == 0))
618 vdef
= gimple_vdef (stmt
);
620 vdef
= make_ssa_name (gimple_vop (cfun
), new_stmt
);
621 gimple_set_vdef (new_stmt
, vdef
);
622 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
623 SSA_NAME_DEF_STMT (vdef
) = new_stmt
;
624 laststore
= new_stmt
;
628 /* Second iterate over the statements forward, assigning virtual
629 operands to their uses. */
630 tree reaching_vuse
= gimple_vuse (stmt
);
631 for (gimple_stmt_iterator i
= gsi_start (stmts
);
632 !gsi_end_p (i
); gsi_next (&i
))
634 gimple
*new_stmt
= gsi_stmt (i
);
635 /* If the new statement possibly has a VUSE, update it with exact SSA
636 name we know will reach this one. */
637 if (gimple_has_mem_ops (new_stmt
))
638 gimple_set_vuse (new_stmt
, reaching_vuse
);
639 gimple_set_modified (new_stmt
, true);
640 if (gimple_vdef (new_stmt
))
641 reaching_vuse
= gimple_vdef (new_stmt
);
644 /* If the new sequence does not do a store release the virtual
645 definition of the original statement. */
647 && reaching_vuse
== gimple_vuse (stmt
))
649 tree vdef
= gimple_vdef (stmt
);
651 && TREE_CODE (vdef
) == SSA_NAME
)
653 unlink_stmt_vdef (stmt
);
654 release_ssa_name (vdef
);
658 /* Finally replace the original statement with the sequence. */
659 gsi_replace_with_seq (si_p
, stmts
, false);
662 /* Helper function for update_gimple_call and
663 gimplify_and_update_call_from_tree. A GIMPLE_CALL STMT is being replaced
664 with GIMPLE_CALL NEW_STMT. */
667 finish_update_gimple_call (gimple_stmt_iterator
*si_p
, gimple
*new_stmt
,
670 tree lhs
= gimple_call_lhs (stmt
);
671 gimple_call_set_lhs (new_stmt
, lhs
);
672 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
673 SSA_NAME_DEF_STMT (lhs
) = new_stmt
;
674 gimple_move_vops (new_stmt
, stmt
);
675 gimple_set_location (new_stmt
, gimple_location (stmt
));
676 if (gimple_block (new_stmt
) == NULL_TREE
)
677 gimple_set_block (new_stmt
, gimple_block (stmt
));
678 gsi_replace (si_p
, new_stmt
, false);
681 /* Update a GIMPLE_CALL statement at iterator *SI_P to call to FN
682 with number of arguments NARGS, where the arguments in GIMPLE form
683 follow NARGS argument. */
686 update_gimple_call (gimple_stmt_iterator
*si_p
, tree fn
, int nargs
, ...)
689 gcall
*new_stmt
, *stmt
= as_a
<gcall
*> (gsi_stmt (*si_p
));
691 gcc_assert (is_gimple_call (stmt
));
692 va_start (ap
, nargs
);
693 new_stmt
= gimple_build_call_valist (fn
, nargs
, ap
);
694 finish_update_gimple_call (si_p
, new_stmt
, stmt
);
699 /* Return true if EXPR is a CALL_EXPR suitable for representation
700 as a single GIMPLE_CALL statement. If the arguments require
701 further gimplification, return false. */
704 valid_gimple_call_p (tree expr
)
708 if (TREE_CODE (expr
) != CALL_EXPR
)
711 nargs
= call_expr_nargs (expr
);
712 for (i
= 0; i
< nargs
; i
++)
714 tree arg
= CALL_EXPR_ARG (expr
, i
);
715 if (is_gimple_reg_type (TREE_TYPE (arg
)))
717 if (!is_gimple_val (arg
))
721 if (!is_gimple_lvalue (arg
))
728 /* Convert EXPR into a GIMPLE value suitable for substitution on the
729 RHS of an assignment. Insert the necessary statements before
730 iterator *SI_P. The statement at *SI_P, which must be a GIMPLE_CALL
731 is replaced. If the call is expected to produces a result, then it
732 is replaced by an assignment of the new RHS to the result variable.
733 If the result is to be ignored, then the call is replaced by a
734 GIMPLE_NOP. A proper VDEF chain is retained by making the first
735 VUSE and the last VDEF of the whole sequence be the same as the replaced
736 statement and using new SSA names for stores in between. */
739 gimplify_and_update_call_from_tree (gimple_stmt_iterator
*si_p
, tree expr
)
742 gimple
*stmt
, *new_stmt
;
743 gimple_stmt_iterator i
;
744 gimple_seq stmts
= NULL
;
746 stmt
= gsi_stmt (*si_p
);
748 gcc_assert (is_gimple_call (stmt
));
750 if (valid_gimple_call_p (expr
))
752 /* The call has simplified to another call. */
753 tree fn
= CALL_EXPR_FN (expr
);
755 unsigned nargs
= call_expr_nargs (expr
);
756 vec
<tree
> args
= vNULL
;
762 args
.safe_grow_cleared (nargs
, true);
764 for (i
= 0; i
< nargs
; i
++)
765 args
[i
] = CALL_EXPR_ARG (expr
, i
);
768 new_stmt
= gimple_build_call_vec (fn
, args
);
769 finish_update_gimple_call (si_p
, new_stmt
, stmt
);
774 lhs
= gimple_call_lhs (stmt
);
775 if (lhs
== NULL_TREE
)
777 push_gimplify_context (gimple_in_ssa_p (cfun
));
778 gimplify_and_add (expr
, &stmts
);
779 pop_gimplify_context (NULL
);
781 /* We can end up with folding a memcpy of an empty class assignment
782 which gets optimized away by C++ gimplification. */
783 if (gimple_seq_empty_p (stmts
))
785 if (gimple_in_ssa_p (cfun
))
787 unlink_stmt_vdef (stmt
);
790 gsi_replace (si_p
, gimple_build_nop (), false);
796 tree tmp
= force_gimple_operand (expr
, &stmts
, false, NULL_TREE
);
797 new_stmt
= gimple_build_assign (lhs
, tmp
);
798 i
= gsi_last (stmts
);
799 gsi_insert_after_without_update (&i
, new_stmt
,
800 GSI_CONTINUE_LINKING
);
803 gsi_replace_with_seq_vops (si_p
, stmts
);
807 /* Replace the call at *GSI with the gimple value VAL. */
810 replace_call_with_value (gimple_stmt_iterator
*gsi
, tree val
)
812 gimple
*stmt
= gsi_stmt (*gsi
);
813 tree lhs
= gimple_call_lhs (stmt
);
817 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (val
)))
818 val
= fold_convert (TREE_TYPE (lhs
), val
);
819 repl
= gimple_build_assign (lhs
, val
);
822 repl
= gimple_build_nop ();
823 tree vdef
= gimple_vdef (stmt
);
824 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
826 unlink_stmt_vdef (stmt
);
827 release_ssa_name (vdef
);
829 gsi_replace (gsi
, repl
, false);
832 /* Replace the call at *GSI with the new call REPL and fold that
836 replace_call_with_call_and_fold (gimple_stmt_iterator
*gsi
, gimple
*repl
)
838 gimple
*stmt
= gsi_stmt (*gsi
);
839 gimple_call_set_lhs (repl
, gimple_call_lhs (stmt
));
840 gimple_set_location (repl
, gimple_location (stmt
));
841 gimple_move_vops (repl
, stmt
);
842 gsi_replace (gsi
, repl
, false);
846 /* Return true if VAR is a VAR_DECL or a component thereof. */
849 var_decl_component_p (tree var
)
852 while (handled_component_p (inner
))
853 inner
= TREE_OPERAND (inner
, 0);
854 return (DECL_P (inner
)
855 || (TREE_CODE (inner
) == MEM_REF
856 && TREE_CODE (TREE_OPERAND (inner
, 0)) == ADDR_EXPR
));
859 /* Return TRUE if the SIZE argument, representing the size of an
860 object, is in a range of values of which exactly zero is valid. */
863 size_must_be_zero_p (tree size
)
865 if (integer_zerop (size
))
868 if (TREE_CODE (size
) != SSA_NAME
|| !INTEGRAL_TYPE_P (TREE_TYPE (size
)))
871 tree type
= TREE_TYPE (size
);
872 int prec
= TYPE_PRECISION (type
);
874 /* Compute the value of SSIZE_MAX, the largest positive value that
875 can be stored in ssize_t, the signed counterpart of size_t. */
876 wide_int ssize_max
= wi::lshift (wi::one (prec
), prec
- 1) - 1;
877 value_range
valid_range (build_int_cst (type
, 0),
878 wide_int_to_tree (type
, ssize_max
));
881 get_range_query (cfun
)->range_of_expr (vr
, size
);
883 get_global_range_query ()->range_of_expr (vr
, size
);
884 if (vr
.undefined_p ())
885 vr
.set_varying (TREE_TYPE (size
));
886 vr
.intersect (&valid_range
);
890 /* Fold function call to builtin mem{{,p}cpy,move}. Try to detect and
891 diagnose (otherwise undefined) overlapping copies without preventing
892 folding. When folded, GCC guarantees that overlapping memcpy has
893 the same semantics as memmove. Call to the library memcpy need not
894 provide the same guarantee. Return false if no simplification can
898 gimple_fold_builtin_memory_op (gimple_stmt_iterator
*gsi
,
899 tree dest
, tree src
, enum built_in_function code
)
901 gimple
*stmt
= gsi_stmt (*gsi
);
902 tree lhs
= gimple_call_lhs (stmt
);
903 tree len
= gimple_call_arg (stmt
, 2);
904 location_t loc
= gimple_location (stmt
);
906 /* If the LEN parameter is a constant zero or in range where
907 the only valid value is zero, return DEST. */
908 if (size_must_be_zero_p (len
))
911 if (gimple_call_lhs (stmt
))
912 repl
= gimple_build_assign (gimple_call_lhs (stmt
), dest
);
914 repl
= gimple_build_nop ();
915 tree vdef
= gimple_vdef (stmt
);
916 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
918 unlink_stmt_vdef (stmt
);
919 release_ssa_name (vdef
);
921 gsi_replace (gsi
, repl
, false);
925 /* If SRC and DEST are the same (and not volatile), return
926 DEST{,+LEN,+LEN-1}. */
927 if (operand_equal_p (src
, dest
, 0))
929 /* Avoid diagnosing exact overlap in calls to __builtin_memcpy.
930 It's safe and may even be emitted by GCC itself (see bug
932 unlink_stmt_vdef (stmt
);
933 if (gimple_vdef (stmt
) && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
934 release_ssa_name (gimple_vdef (stmt
));
937 gsi_replace (gsi
, gimple_build_nop (), false);
944 /* We cannot (easily) change the type of the copy if it is a storage
945 order barrier, i.e. is equivalent to a VIEW_CONVERT_EXPR that can
946 modify the storage order of objects (see storage_order_barrier_p). */
948 = POINTER_TYPE_P (TREE_TYPE (src
))
949 ? TREE_TYPE (TREE_TYPE (src
)) : NULL_TREE
;
951 = POINTER_TYPE_P (TREE_TYPE (dest
))
952 ? TREE_TYPE (TREE_TYPE (dest
)) : NULL_TREE
;
953 tree destvar
, srcvar
, srcoff
;
954 unsigned int src_align
, dest_align
;
955 unsigned HOST_WIDE_INT tmp_len
;
958 /* Build accesses at offset zero with a ref-all character type. */
960 = build_int_cst (build_pointer_type_for_mode (char_type_node
,
963 /* If we can perform the copy efficiently with first doing all loads and
964 then all stores inline it that way. Currently efficiently means that
965 we can load all the memory with a single set operation and that the
966 total size is less than MOVE_MAX * MOVE_RATIO. */
967 src_align
= get_pointer_alignment (src
);
968 dest_align
= get_pointer_alignment (dest
);
969 if (tree_fits_uhwi_p (len
)
972 * MOVE_RATIO (optimize_function_for_size_p (cfun
))))
974 /* FIXME: Don't transform copies from strings with known length.
975 Until GCC 9 this prevented a case in gcc.dg/strlenopt-8.c
976 from being handled, and the case was XFAILed for that reason.
977 Now that it is handled and the XFAIL removed, as soon as other
978 strlenopt tests that rely on it for passing are adjusted, this
979 hack can be removed. */
980 && !c_strlen (src
, 1)
981 && !((tmp_str
= getbyterep (src
, &tmp_len
)) != NULL
982 && memchr (tmp_str
, 0, tmp_len
) == NULL
)
984 && AGGREGATE_TYPE_P (srctype
)
985 && TYPE_REVERSE_STORAGE_ORDER (srctype
))
987 && AGGREGATE_TYPE_P (desttype
)
988 && TYPE_REVERSE_STORAGE_ORDER (desttype
)))
990 unsigned ilen
= tree_to_uhwi (len
);
991 if (pow2p_hwi (ilen
))
993 /* Detect out-of-bounds accesses without issuing warnings.
994 Avoid folding out-of-bounds copies but to avoid false
995 positives for unreachable code defer warning until after
996 DCE has worked its magic.
997 -Wrestrict is still diagnosed. */
998 if (int warning
= check_bounds_or_overlap (as_a
<gcall
*>(stmt
),
1001 if (warning
!= OPT_Wrestrict
)
1004 scalar_int_mode mode
;
1005 if (int_mode_for_size (ilen
* 8, 0).exists (&mode
)
1006 && GET_MODE_SIZE (mode
) * BITS_PER_UNIT
== ilen
* 8
1007 && have_insn_for (SET
, mode
)
1008 /* If the destination pointer is not aligned we must be able
1009 to emit an unaligned store. */
1010 && (dest_align
>= GET_MODE_ALIGNMENT (mode
)
1011 || !targetm
.slow_unaligned_access (mode
, dest_align
)
1012 || (optab_handler (movmisalign_optab
, mode
)
1013 != CODE_FOR_nothing
)))
1015 tree type
= build_nonstandard_integer_type (ilen
* 8, 1);
1016 tree srctype
= type
;
1017 tree desttype
= type
;
1018 if (src_align
< GET_MODE_ALIGNMENT (mode
))
1019 srctype
= build_aligned_type (type
, src_align
);
1020 tree srcmem
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1021 tree tem
= fold_const_aggregate_ref (srcmem
);
1024 else if (src_align
< GET_MODE_ALIGNMENT (mode
)
1025 && targetm
.slow_unaligned_access (mode
, src_align
)
1026 && (optab_handler (movmisalign_optab
, mode
)
1027 == CODE_FOR_nothing
))
1032 if (is_gimple_reg_type (TREE_TYPE (srcmem
)))
1034 new_stmt
= gimple_build_assign (NULL_TREE
, srcmem
);
1036 = create_tmp_reg_or_ssa_name (TREE_TYPE (srcmem
),
1038 gimple_assign_set_lhs (new_stmt
, srcmem
);
1039 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
1040 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1042 if (dest_align
< GET_MODE_ALIGNMENT (mode
))
1043 desttype
= build_aligned_type (type
, dest_align
);
1045 = gimple_build_assign (fold_build2 (MEM_REF
, desttype
,
1048 gimple_move_vops (new_stmt
, stmt
);
1051 gsi_replace (gsi
, new_stmt
, false);
1054 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1061 if (code
== BUILT_IN_MEMMOVE
)
1063 /* Both DEST and SRC must be pointer types.
1064 ??? This is what old code did. Is the testing for pointer types
1067 If either SRC is readonly or length is 1, we can use memcpy. */
1068 if (!dest_align
|| !src_align
)
1070 if (readonly_data_expr (src
)
1071 || (tree_fits_uhwi_p (len
)
1072 && (MIN (src_align
, dest_align
) / BITS_PER_UNIT
1073 >= tree_to_uhwi (len
))))
1075 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1078 gimple_call_set_fndecl (stmt
, fn
);
1079 gimple_call_set_arg (stmt
, 0, dest
);
1080 gimple_call_set_arg (stmt
, 1, src
);
1085 /* If *src and *dest can't overlap, optimize into memcpy as well. */
1086 if (TREE_CODE (src
) == ADDR_EXPR
1087 && TREE_CODE (dest
) == ADDR_EXPR
)
1089 tree src_base
, dest_base
, fn
;
1090 poly_int64 src_offset
= 0, dest_offset
= 0;
1091 poly_uint64 maxsize
;
1093 srcvar
= TREE_OPERAND (src
, 0);
1094 src_base
= get_addr_base_and_unit_offset (srcvar
, &src_offset
);
1095 if (src_base
== NULL
)
1097 destvar
= TREE_OPERAND (dest
, 0);
1098 dest_base
= get_addr_base_and_unit_offset (destvar
,
1100 if (dest_base
== NULL
)
1101 dest_base
= destvar
;
1102 if (!poly_int_tree_p (len
, &maxsize
))
1104 if (SSA_VAR_P (src_base
)
1105 && SSA_VAR_P (dest_base
))
1107 if (operand_equal_p (src_base
, dest_base
, 0)
1108 && ranges_maybe_overlap_p (src_offset
, maxsize
,
1109 dest_offset
, maxsize
))
1112 else if (TREE_CODE (src_base
) == MEM_REF
1113 && TREE_CODE (dest_base
) == MEM_REF
)
1115 if (! operand_equal_p (TREE_OPERAND (src_base
, 0),
1116 TREE_OPERAND (dest_base
, 0), 0))
1118 poly_offset_int full_src_offset
1119 = mem_ref_offset (src_base
) + src_offset
;
1120 poly_offset_int full_dest_offset
1121 = mem_ref_offset (dest_base
) + dest_offset
;
1122 if (ranges_maybe_overlap_p (full_src_offset
, maxsize
,
1123 full_dest_offset
, maxsize
))
1129 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1132 gimple_call_set_fndecl (stmt
, fn
);
1133 gimple_call_set_arg (stmt
, 0, dest
);
1134 gimple_call_set_arg (stmt
, 1, src
);
1139 /* If the destination and source do not alias optimize into
1141 if ((is_gimple_min_invariant (dest
)
1142 || TREE_CODE (dest
) == SSA_NAME
)
1143 && (is_gimple_min_invariant (src
)
1144 || TREE_CODE (src
) == SSA_NAME
))
1147 ao_ref_init_from_ptr_and_size (&destr
, dest
, len
);
1148 ao_ref_init_from_ptr_and_size (&srcr
, src
, len
);
1149 if (!refs_may_alias_p_1 (&destr
, &srcr
, false))
1152 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1155 gimple_call_set_fndecl (stmt
, fn
);
1156 gimple_call_set_arg (stmt
, 0, dest
);
1157 gimple_call_set_arg (stmt
, 1, src
);
1166 if (!tree_fits_shwi_p (len
))
1169 || (AGGREGATE_TYPE_P (srctype
)
1170 && TYPE_REVERSE_STORAGE_ORDER (srctype
)))
1173 || (AGGREGATE_TYPE_P (desttype
)
1174 && TYPE_REVERSE_STORAGE_ORDER (desttype
)))
1176 /* In the following try to find a type that is most natural to be
1177 used for the memcpy source and destination and that allows
1178 the most optimization when memcpy is turned into a plain assignment
1179 using that type. In theory we could always use a char[len] type
1180 but that only gains us that the destination and source possibly
1181 no longer will have their address taken. */
1182 if (TREE_CODE (srctype
) == ARRAY_TYPE
1183 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
))
1184 srctype
= TREE_TYPE (srctype
);
1185 if (TREE_CODE (desttype
) == ARRAY_TYPE
1186 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
))
1187 desttype
= TREE_TYPE (desttype
);
1188 if (TREE_ADDRESSABLE (srctype
)
1189 || TREE_ADDRESSABLE (desttype
))
1192 /* Make sure we are not copying using a floating-point mode or
1193 a type whose size possibly does not match its precision. */
1194 if (FLOAT_MODE_P (TYPE_MODE (desttype
))
1195 || TREE_CODE (desttype
) == BOOLEAN_TYPE
1196 || TREE_CODE (desttype
) == ENUMERAL_TYPE
)
1197 desttype
= bitwise_type_for_mode (TYPE_MODE (desttype
));
1198 if (FLOAT_MODE_P (TYPE_MODE (srctype
))
1199 || TREE_CODE (srctype
) == BOOLEAN_TYPE
1200 || TREE_CODE (srctype
) == ENUMERAL_TYPE
)
1201 srctype
= bitwise_type_for_mode (TYPE_MODE (srctype
));
1209 src_align
= get_pointer_alignment (src
);
1210 dest_align
= get_pointer_alignment (dest
);
1212 /* Choose between src and destination type for the access based
1213 on alignment, whether the access constitutes a register access
1214 and whether it may actually expose a declaration for SSA rewrite
1215 or SRA decomposition. Also try to expose a string constant, we
1216 might be able to concatenate several of them later into a single
1218 destvar
= NULL_TREE
;
1220 if (TREE_CODE (dest
) == ADDR_EXPR
1221 && var_decl_component_p (TREE_OPERAND (dest
, 0))
1222 && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
)
1223 && dest_align
>= TYPE_ALIGN (desttype
)
1224 && (is_gimple_reg_type (desttype
)
1225 || src_align
>= TYPE_ALIGN (desttype
)))
1226 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
1227 else if (TREE_CODE (src
) == ADDR_EXPR
1228 && var_decl_component_p (TREE_OPERAND (src
, 0))
1229 && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
)
1230 && src_align
>= TYPE_ALIGN (srctype
)
1231 && (is_gimple_reg_type (srctype
)
1232 || dest_align
>= TYPE_ALIGN (srctype
)))
1233 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1234 /* FIXME: Don't transform copies from strings with known original length.
1235 As soon as strlenopt tests that rely on it for passing are adjusted,
1236 this hack can be removed. */
1237 else if (gimple_call_alloca_for_var_p (stmt
)
1238 && (srcvar
= string_constant (src
, &srcoff
, NULL
, NULL
))
1239 && integer_zerop (srcoff
)
1240 && tree_int_cst_equal (TYPE_SIZE_UNIT (TREE_TYPE (srcvar
)), len
)
1241 && dest_align
>= TYPE_ALIGN (TREE_TYPE (srcvar
)))
1242 srctype
= TREE_TYPE (srcvar
);
1246 /* Now that we chose an access type express the other side in
1247 terms of it if the target allows that with respect to alignment
1249 if (srcvar
== NULL_TREE
)
1251 if (src_align
>= TYPE_ALIGN (desttype
))
1252 srcvar
= fold_build2 (MEM_REF
, desttype
, src
, off0
);
1255 if (STRICT_ALIGNMENT
)
1257 srctype
= build_aligned_type (TYPE_MAIN_VARIANT (desttype
),
1259 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1262 else if (destvar
== NULL_TREE
)
1264 if (dest_align
>= TYPE_ALIGN (srctype
))
1265 destvar
= fold_build2 (MEM_REF
, srctype
, dest
, off0
);
1268 if (STRICT_ALIGNMENT
)
1270 desttype
= build_aligned_type (TYPE_MAIN_VARIANT (srctype
),
1272 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
1276 /* Same as above, detect out-of-bounds accesses without issuing
1277 warnings. Avoid folding out-of-bounds copies but to avoid
1278 false positives for unreachable code defer warning until
1279 after DCE has worked its magic.
1280 -Wrestrict is still diagnosed. */
1281 if (int warning
= check_bounds_or_overlap (as_a
<gcall
*>(stmt
),
1282 dest
, src
, len
, len
,
1284 if (warning
!= OPT_Wrestrict
)
1288 if (is_gimple_reg_type (TREE_TYPE (srcvar
)))
1290 tree tem
= fold_const_aggregate_ref (srcvar
);
1293 if (! is_gimple_min_invariant (srcvar
))
1295 new_stmt
= gimple_build_assign (NULL_TREE
, srcvar
);
1296 srcvar
= create_tmp_reg_or_ssa_name (TREE_TYPE (srcvar
),
1298 gimple_assign_set_lhs (new_stmt
, srcvar
);
1299 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
1300 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1302 new_stmt
= gimple_build_assign (destvar
, srcvar
);
1303 goto set_vop_and_replace
;
1306 /* We get an aggregate copy. If the source is a STRING_CST, then
1307 directly use its type to perform the copy. */
1308 if (TREE_CODE (srcvar
) == STRING_CST
)
1311 /* Or else, use an unsigned char[] type to perform the copy in order
1312 to preserve padding and to avoid any issues with TREE_ADDRESSABLE
1313 types or float modes behavior on copying. */
1316 desttype
= build_array_type_nelts (unsigned_char_type_node
,
1317 tree_to_uhwi (len
));
1319 if (src_align
> TYPE_ALIGN (srctype
))
1320 srctype
= build_aligned_type (srctype
, src_align
);
1321 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1324 if (dest_align
> TYPE_ALIGN (desttype
))
1325 desttype
= build_aligned_type (desttype
, dest_align
);
1326 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
1327 new_stmt
= gimple_build_assign (destvar
, srcvar
);
1329 set_vop_and_replace
:
1330 gimple_move_vops (new_stmt
, stmt
);
1333 gsi_replace (gsi
, new_stmt
, false);
1336 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1340 gimple_seq stmts
= NULL
;
1341 if (code
== BUILT_IN_MEMCPY
|| code
== BUILT_IN_MEMMOVE
)
1343 else if (code
== BUILT_IN_MEMPCPY
)
1345 len
= gimple_convert_to_ptrofftype (&stmts
, loc
, len
);
1346 dest
= gimple_build (&stmts
, loc
, POINTER_PLUS_EXPR
,
1347 TREE_TYPE (dest
), dest
, len
);
1352 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
1353 gimple
*repl
= gimple_build_assign (lhs
, dest
);
1354 gsi_replace (gsi
, repl
, false);
1358 /* Transform a call to built-in bcmp(a, b, len) at *GSI into one
1359 to built-in memcmp (a, b, len). */
1362 gimple_fold_builtin_bcmp (gimple_stmt_iterator
*gsi
)
1364 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
1369 /* Transform bcmp (a, b, len) into memcmp (a, b, len). */
1371 gimple
*stmt
= gsi_stmt (*gsi
);
1372 tree a
= gimple_call_arg (stmt
, 0);
1373 tree b
= gimple_call_arg (stmt
, 1);
1374 tree len
= gimple_call_arg (stmt
, 2);
1376 gimple
*repl
= gimple_build_call (fn
, 3, a
, b
, len
);
1377 replace_call_with_call_and_fold (gsi
, repl
);
1382 /* Transform a call to built-in bcopy (src, dest, len) at *GSI into one
1383 to built-in memmove (dest, src, len). */
1386 gimple_fold_builtin_bcopy (gimple_stmt_iterator
*gsi
)
1388 tree fn
= builtin_decl_implicit (BUILT_IN_MEMMOVE
);
1393 /* bcopy has been removed from POSIX in Issue 7 but Issue 6 specifies
1394 it's quivalent to memmove (not memcpy). Transform bcopy (src, dest,
1395 len) into memmove (dest, src, len). */
1397 gimple
*stmt
= gsi_stmt (*gsi
);
1398 tree src
= gimple_call_arg (stmt
, 0);
1399 tree dest
= gimple_call_arg (stmt
, 1);
1400 tree len
= gimple_call_arg (stmt
, 2);
1402 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
1403 gimple_call_set_fntype (as_a
<gcall
*> (stmt
), TREE_TYPE (fn
));
1404 replace_call_with_call_and_fold (gsi
, repl
);
1409 /* Transform a call to built-in bzero (dest, len) at *GSI into one
1410 to built-in memset (dest, 0, len). */
1413 gimple_fold_builtin_bzero (gimple_stmt_iterator
*gsi
)
1415 tree fn
= builtin_decl_implicit (BUILT_IN_MEMSET
);
1420 /* Transform bzero (dest, len) into memset (dest, 0, len). */
1422 gimple
*stmt
= gsi_stmt (*gsi
);
1423 tree dest
= gimple_call_arg (stmt
, 0);
1424 tree len
= gimple_call_arg (stmt
, 1);
1426 gimple_seq seq
= NULL
;
1427 gimple
*repl
= gimple_build_call (fn
, 3, dest
, integer_zero_node
, len
);
1428 gimple_seq_add_stmt_without_update (&seq
, repl
);
1429 gsi_replace_with_seq_vops (gsi
, seq
);
1435 /* Fold function call to builtin memset or bzero at *GSI setting the
1436 memory of size LEN to VAL. Return whether a simplification was made. */
1439 gimple_fold_builtin_memset (gimple_stmt_iterator
*gsi
, tree c
, tree len
)
1441 gimple
*stmt
= gsi_stmt (*gsi
);
1443 unsigned HOST_WIDE_INT length
, cval
;
1445 /* If the LEN parameter is zero, return DEST. */
1446 if (integer_zerop (len
))
1448 replace_call_with_value (gsi
, gimple_call_arg (stmt
, 0));
1452 if (! tree_fits_uhwi_p (len
))
1455 if (TREE_CODE (c
) != INTEGER_CST
)
1458 tree dest
= gimple_call_arg (stmt
, 0);
1460 if (TREE_CODE (var
) != ADDR_EXPR
)
1463 var
= TREE_OPERAND (var
, 0);
1464 if (TREE_THIS_VOLATILE (var
))
1467 etype
= TREE_TYPE (var
);
1468 if (TREE_CODE (etype
) == ARRAY_TYPE
)
1469 etype
= TREE_TYPE (etype
);
1471 if (!INTEGRAL_TYPE_P (etype
)
1472 && !POINTER_TYPE_P (etype
))
1475 if (! var_decl_component_p (var
))
1478 length
= tree_to_uhwi (len
);
1479 if (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (etype
)) != length
1480 || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (etype
))
1481 != GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (etype
)))
1482 || get_pointer_alignment (dest
) / BITS_PER_UNIT
< length
)
1485 if (length
> HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
)
1488 if (!type_has_mode_precision_p (etype
))
1489 etype
= lang_hooks
.types
.type_for_mode (SCALAR_INT_TYPE_MODE (etype
),
1490 TYPE_UNSIGNED (etype
));
1492 if (integer_zerop (c
))
1496 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8 || HOST_BITS_PER_WIDE_INT
> 64)
1499 cval
= TREE_INT_CST_LOW (c
);
1503 cval
|= (cval
<< 31) << 1;
1506 var
= fold_build2 (MEM_REF
, etype
, dest
, build_int_cst (ptr_type_node
, 0));
1507 gimple
*store
= gimple_build_assign (var
, build_int_cst_type (etype
, cval
));
1508 gimple_move_vops (store
, stmt
);
1509 gimple_set_location (store
, gimple_location (stmt
));
1510 gsi_insert_before (gsi
, store
, GSI_SAME_STMT
);
1511 if (gimple_call_lhs (stmt
))
1513 gimple
*asgn
= gimple_build_assign (gimple_call_lhs (stmt
), dest
);
1514 gsi_replace (gsi
, asgn
, false);
1518 gimple_stmt_iterator gsi2
= *gsi
;
1520 gsi_remove (&gsi2
, true);
1526 /* Helper of get_range_strlen for ARG that is not an SSA_NAME. */
1529 get_range_strlen_tree (tree arg
, bitmap visited
, strlen_range_kind rkind
,
1530 c_strlen_data
*pdata
, unsigned eltsize
)
1532 gcc_assert (TREE_CODE (arg
) != SSA_NAME
);
1534 /* The length computed by this invocation of the function. */
1535 tree val
= NULL_TREE
;
1537 /* True if VAL is an optimistic (tight) bound determined from
1538 the size of the character array in which the string may be
1539 stored. In that case, the computed VAL is used to set
1541 bool tight_bound
= false;
1543 /* We can end up with &(*iftmp_1)[0] here as well, so handle it. */
1544 if (TREE_CODE (arg
) == ADDR_EXPR
1545 && TREE_CODE (TREE_OPERAND (arg
, 0)) == ARRAY_REF
)
1547 tree op
= TREE_OPERAND (arg
, 0);
1548 if (integer_zerop (TREE_OPERAND (op
, 1)))
1550 tree aop0
= TREE_OPERAND (op
, 0);
1551 if (TREE_CODE (aop0
) == INDIRECT_REF
1552 && TREE_CODE (TREE_OPERAND (aop0
, 0)) == SSA_NAME
)
1553 return get_range_strlen (TREE_OPERAND (aop0
, 0), visited
, rkind
,
1556 else if (TREE_CODE (TREE_OPERAND (op
, 0)) == COMPONENT_REF
1557 && rkind
== SRK_LENRANGE
)
1559 /* Fail if an array is the last member of a struct object
1560 since it could be treated as a (fake) flexible array
1562 tree idx
= TREE_OPERAND (op
, 1);
1564 arg
= TREE_OPERAND (op
, 0);
1565 tree optype
= TREE_TYPE (arg
);
1566 if (tree dom
= TYPE_DOMAIN (optype
))
1567 if (tree bound
= TYPE_MAX_VALUE (dom
))
1568 if (TREE_CODE (bound
) == INTEGER_CST
1569 && TREE_CODE (idx
) == INTEGER_CST
1570 && tree_int_cst_lt (bound
, idx
))
1575 if (rkind
== SRK_INT_VALUE
)
1577 /* We are computing the maximum value (not string length). */
1579 if (TREE_CODE (val
) != INTEGER_CST
1580 || tree_int_cst_sgn (val
) < 0)
1585 c_strlen_data lendata
= { };
1586 val
= c_strlen (arg
, 1, &lendata
, eltsize
);
1588 if (!val
&& lendata
.decl
)
1590 /* ARG refers to an unterminated const character array.
1591 DATA.DECL with size DATA.LEN. */
1592 val
= lendata
.minlen
;
1593 pdata
->decl
= lendata
.decl
;
1597 /* Set if VAL represents the maximum length based on array size (set
1598 when exact length cannot be determined). */
1599 bool maxbound
= false;
1601 if (!val
&& rkind
== SRK_LENRANGE
)
1603 if (TREE_CODE (arg
) == ADDR_EXPR
)
1604 return get_range_strlen (TREE_OPERAND (arg
, 0), visited
, rkind
,
1607 if (TREE_CODE (arg
) == ARRAY_REF
)
1609 tree optype
= TREE_TYPE (TREE_OPERAND (arg
, 0));
1611 /* Determine the "innermost" array type. */
1612 while (TREE_CODE (optype
) == ARRAY_TYPE
1613 && TREE_CODE (TREE_TYPE (optype
)) == ARRAY_TYPE
)
1614 optype
= TREE_TYPE (optype
);
1616 /* Avoid arrays of pointers. */
1617 tree eltype
= TREE_TYPE (optype
);
1618 if (TREE_CODE (optype
) != ARRAY_TYPE
1619 || !INTEGRAL_TYPE_P (eltype
))
1622 /* Fail when the array bound is unknown or zero. */
1623 val
= TYPE_SIZE_UNIT (optype
);
1625 || TREE_CODE (val
) != INTEGER_CST
1626 || integer_zerop (val
))
1629 val
= fold_build2 (MINUS_EXPR
, TREE_TYPE (val
), val
,
1632 /* Set the minimum size to zero since the string in
1633 the array could have zero length. */
1634 pdata
->minlen
= ssize_int (0);
1638 else if (TREE_CODE (arg
) == COMPONENT_REF
1639 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 1)))
1642 /* Use the type of the member array to determine the upper
1643 bound on the length of the array. This may be overly
1644 optimistic if the array itself isn't NUL-terminated and
1645 the caller relies on the subsequent member to contain
1646 the NUL but that would only be considered valid if
1647 the array were the last member of a struct. */
1649 tree fld
= TREE_OPERAND (arg
, 1);
1651 tree optype
= TREE_TYPE (fld
);
1653 /* Determine the "innermost" array type. */
1654 while (TREE_CODE (optype
) == ARRAY_TYPE
1655 && TREE_CODE (TREE_TYPE (optype
)) == ARRAY_TYPE
)
1656 optype
= TREE_TYPE (optype
);
1658 /* Fail when the array bound is unknown or zero. */
1659 val
= TYPE_SIZE_UNIT (optype
);
1661 || TREE_CODE (val
) != INTEGER_CST
1662 || integer_zerop (val
))
1664 val
= fold_build2 (MINUS_EXPR
, TREE_TYPE (val
), val
,
1667 /* Set the minimum size to zero since the string in
1668 the array could have zero length. */
1669 pdata
->minlen
= ssize_int (0);
1671 /* The array size determined above is an optimistic bound
1672 on the length. If the array isn't nul-terminated the
1673 length computed by the library function would be greater.
1674 Even though using strlen to cross the subobject boundary
1675 is undefined, avoid drawing conclusions from the member
1676 type about the length here. */
1679 else if (TREE_CODE (arg
) == MEM_REF
1680 && TREE_CODE (TREE_TYPE (arg
)) == ARRAY_TYPE
1681 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == INTEGER_TYPE
1682 && TREE_CODE (TREE_OPERAND (arg
, 0)) == ADDR_EXPR
)
1684 /* Handle a MEM_REF into a DECL accessing an array of integers,
1685 being conservative about references to extern structures with
1686 flexible array members that can be initialized to arbitrary
1687 numbers of elements as an extension (static structs are okay).
1688 FIXME: Make this less conservative -- see
1689 component_ref_size in tree.c. */
1690 tree ref
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
1691 if ((TREE_CODE (ref
) == PARM_DECL
|| VAR_P (ref
))
1692 && (decl_binds_to_current_def_p (ref
)
1693 || !array_at_struct_end_p (arg
)))
1695 /* Fail if the offset is out of bounds. Such accesses
1696 should be diagnosed at some point. */
1697 val
= DECL_SIZE_UNIT (ref
);
1699 || TREE_CODE (val
) != INTEGER_CST
1700 || integer_zerop (val
))
1703 poly_offset_int psiz
= wi::to_offset (val
);
1704 poly_offset_int poff
= mem_ref_offset (arg
);
1705 if (known_le (psiz
, poff
))
1708 pdata
->minlen
= ssize_int (0);
1710 /* Subtract the offset and one for the terminating nul. */
1713 val
= wide_int_to_tree (TREE_TYPE (val
), psiz
);
1714 /* Since VAL reflects the size of a declared object
1715 rather the type of the access it is not a tight bound. */
1718 else if (TREE_CODE (arg
) == PARM_DECL
|| VAR_P (arg
))
1720 /* Avoid handling pointers to arrays. GCC might misuse
1721 a pointer to an array of one bound to point to an array
1722 object of a greater bound. */
1723 tree argtype
= TREE_TYPE (arg
);
1724 if (TREE_CODE (argtype
) == ARRAY_TYPE
)
1726 val
= TYPE_SIZE_UNIT (argtype
);
1728 || TREE_CODE (val
) != INTEGER_CST
1729 || integer_zerop (val
))
1731 val
= wide_int_to_tree (TREE_TYPE (val
),
1732 wi::sub (wi::to_wide (val
), 1));
1734 /* Set the minimum size to zero since the string in
1735 the array could have zero length. */
1736 pdata
->minlen
= ssize_int (0);
1745 /* Adjust the lower bound on the string length as necessary. */
1747 || (rkind
!= SRK_STRLEN
1748 && TREE_CODE (pdata
->minlen
) == INTEGER_CST
1749 && TREE_CODE (val
) == INTEGER_CST
1750 && tree_int_cst_lt (val
, pdata
->minlen
)))
1751 pdata
->minlen
= val
;
1753 if (pdata
->maxbound
&& TREE_CODE (pdata
->maxbound
) == INTEGER_CST
)
1755 /* Adjust the tighter (more optimistic) string length bound
1756 if necessary and proceed to adjust the more conservative
1758 if (TREE_CODE (val
) == INTEGER_CST
)
1760 if (tree_int_cst_lt (pdata
->maxbound
, val
))
1761 pdata
->maxbound
= val
;
1764 pdata
->maxbound
= val
;
1766 else if (pdata
->maxbound
|| maxbound
)
1767 /* Set PDATA->MAXBOUND only if it either isn't INTEGER_CST or
1768 if VAL corresponds to the maximum length determined based
1769 on the type of the object. */
1770 pdata
->maxbound
= val
;
1774 /* VAL computed above represents an optimistically tight bound
1775 on the length of the string based on the referenced object's
1776 or subobject's type. Determine the conservative upper bound
1777 based on the enclosing object's size if possible. */
1778 if (rkind
== SRK_LENRANGE
)
1781 tree base
= get_addr_base_and_unit_offset (arg
, &offset
);
1784 /* When the call above fails due to a non-constant offset
1785 assume the offset is zero and use the size of the whole
1786 enclosing object instead. */
1787 base
= get_base_address (arg
);
1790 /* If the base object is a pointer no upper bound on the length
1791 can be determined. Otherwise the maximum length is equal to
1792 the size of the enclosing object minus the offset of
1793 the referenced subobject minus 1 (for the terminating nul). */
1794 tree type
= TREE_TYPE (base
);
1795 if (TREE_CODE (type
) == POINTER_TYPE
1796 || (TREE_CODE (base
) != PARM_DECL
&& !VAR_P (base
))
1797 || !(val
= DECL_SIZE_UNIT (base
)))
1798 val
= build_all_ones_cst (size_type_node
);
1801 val
= DECL_SIZE_UNIT (base
);
1802 val
= fold_build2 (MINUS_EXPR
, TREE_TYPE (val
), val
,
1803 size_int (offset
+ 1));
1812 /* Adjust the more conservative bound if possible/necessary
1813 and fail otherwise. */
1814 if (rkind
!= SRK_STRLEN
)
1816 if (TREE_CODE (pdata
->maxlen
) != INTEGER_CST
1817 || TREE_CODE (val
) != INTEGER_CST
)
1820 if (tree_int_cst_lt (pdata
->maxlen
, val
))
1821 pdata
->maxlen
= val
;
1824 else if (simple_cst_equal (val
, pdata
->maxlen
) != 1)
1826 /* Fail if the length of this ARG is different from that
1827 previously determined from another ARG. */
1832 pdata
->maxlen
= val
;
1833 return rkind
== SRK_LENRANGE
|| !integer_all_onesp (val
);
1836 /* For an ARG referencing one or more strings, try to obtain the range
1837 of their lengths, or the size of the largest array ARG referes to if
1838 the range of lengths cannot be determined, and store all in *PDATA.
1839 For an integer ARG (when RKIND == SRK_INT_VALUE), try to determine
1840 the maximum constant value.
1841 If ARG is an SSA_NAME, follow its use-def chains. When RKIND ==
1842 SRK_STRLEN, then if PDATA->MAXLEN is not equal to the determined
1843 length or if we are unable to determine the length, return false.
1844 VISITED is a bitmap of visited variables.
1845 RKIND determines the kind of value or range to obtain (see
1847 Set PDATA->DECL if ARG refers to an unterminated constant array.
1848 On input, set ELTSIZE to 1 for normal single byte character strings,
1849 and either 2 or 4 for wide characer strings (the size of wchar_t).
1850 Return true if *PDATA was successfully populated and false otherwise. */
1853 get_range_strlen (tree arg
, bitmap visited
,
1854 strlen_range_kind rkind
,
1855 c_strlen_data
*pdata
, unsigned eltsize
)
1858 if (TREE_CODE (arg
) != SSA_NAME
)
1859 return get_range_strlen_tree (arg
, visited
, rkind
, pdata
, eltsize
);
1861 /* If ARG is registered for SSA update we cannot look at its defining
1863 if (name_registered_for_update_p (arg
))
1866 /* If we were already here, break the infinite cycle. */
1867 if (!bitmap_set_bit (visited
, SSA_NAME_VERSION (arg
)))
1871 gimple
*def_stmt
= SSA_NAME_DEF_STMT (var
);
1873 switch (gimple_code (def_stmt
))
1876 /* The RHS of the statement defining VAR must either have a
1877 constant length or come from another SSA_NAME with a constant
1879 if (gimple_assign_single_p (def_stmt
)
1880 || gimple_assign_unary_nop_p (def_stmt
))
1882 tree rhs
= gimple_assign_rhs1 (def_stmt
);
1883 return get_range_strlen (rhs
, visited
, rkind
, pdata
, eltsize
);
1885 else if (gimple_assign_rhs_code (def_stmt
) == COND_EXPR
)
1887 tree ops
[2] = { gimple_assign_rhs2 (def_stmt
),
1888 gimple_assign_rhs3 (def_stmt
) };
1890 for (unsigned int i
= 0; i
< 2; i
++)
1891 if (!get_range_strlen (ops
[i
], visited
, rkind
, pdata
, eltsize
))
1893 if (rkind
!= SRK_LENRANGE
)
1895 /* Set the upper bound to the maximum to prevent
1896 it from being adjusted in the next iteration but
1897 leave MINLEN and the more conservative MAXBOUND
1898 determined so far alone (or leave them null if
1899 they haven't been set yet). That the MINLEN is
1900 in fact zero can be determined from MAXLEN being
1901 unbounded but the discovered minimum is used for
1903 pdata
->maxlen
= build_all_ones_cst (size_type_node
);
1910 /* Unless RKIND == SRK_LENRANGE, all arguments of the PHI node
1911 must have a constant length. */
1912 for (unsigned i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1914 tree arg
= gimple_phi_arg (def_stmt
, i
)->def
;
1916 /* If this PHI has itself as an argument, we cannot
1917 determine the string length of this argument. However,
1918 if we can find a constant string length for the other
1919 PHI args then we can still be sure that this is a
1920 constant string length. So be optimistic and just
1921 continue with the next argument. */
1922 if (arg
== gimple_phi_result (def_stmt
))
1925 if (!get_range_strlen (arg
, visited
, rkind
, pdata
, eltsize
))
1927 if (rkind
!= SRK_LENRANGE
)
1929 /* Set the upper bound to the maximum to prevent
1930 it from being adjusted in the next iteration but
1931 leave MINLEN and the more conservative MAXBOUND
1932 determined so far alone (or leave them null if
1933 they haven't been set yet). That the MINLEN is
1934 in fact zero can be determined from MAXLEN being
1935 unbounded but the discovered minimum is used for
1937 pdata
->maxlen
= build_all_ones_cst (size_type_node
);
1947 /* Try to obtain the range of the lengths of the string(s) referenced
1948 by ARG, or the size of the largest array ARG refers to if the range
1949 of lengths cannot be determined, and store all in *PDATA which must
1950 be zero-initialized on input except PDATA->MAXBOUND may be set to
1951 a non-null tree node other than INTEGER_CST to request to have it
1952 set to the length of the longest string in a PHI. ELTSIZE is
1953 the expected size of the string element in bytes: 1 for char and
1954 some power of 2 for wide characters.
1955 Return true if the range [PDATA->MINLEN, PDATA->MAXLEN] is suitable
1956 for optimization. Returning false means that a nonzero PDATA->MINLEN
1957 doesn't reflect the true lower bound of the range when PDATA->MAXLEN
1958 is -1 (in that case, the actual range is indeterminate, i.e.,
1959 [0, PTRDIFF_MAX - 2]. */
1962 get_range_strlen (tree arg
, c_strlen_data
*pdata
, unsigned eltsize
)
1964 auto_bitmap visited
;
1965 tree maxbound
= pdata
->maxbound
;
1967 if (!get_range_strlen (arg
, visited
, SRK_LENRANGE
, pdata
, eltsize
))
1969 /* On failure extend the length range to an impossible maximum
1970 (a valid MAXLEN must be less than PTRDIFF_MAX - 1). Other
1971 members can stay unchanged regardless. */
1972 pdata
->minlen
= ssize_int (0);
1973 pdata
->maxlen
= build_all_ones_cst (size_type_node
);
1975 else if (!pdata
->minlen
)
1976 pdata
->minlen
= ssize_int (0);
1978 /* If it's unchanged from it initial non-null value, set the conservative
1979 MAXBOUND to SIZE_MAX. Otherwise leave it null (if it is null). */
1980 if (maxbound
&& pdata
->maxbound
== maxbound
)
1981 pdata
->maxbound
= build_all_ones_cst (size_type_node
);
1983 return !integer_all_onesp (pdata
->maxlen
);
1986 /* Return the maximum value for ARG given RKIND (see strlen_range_kind).
1987 For ARG of pointer types, NONSTR indicates if the caller is prepared
1988 to handle unterminated strings. For integer ARG and when RKIND ==
1989 SRK_INT_VALUE, NONSTR must be null.
1991 If an unterminated array is discovered and our caller handles
1992 unterminated arrays, then bubble up the offending DECL and
1993 return the maximum size. Otherwise return NULL. */
1996 get_maxval_strlen (tree arg
, strlen_range_kind rkind
, tree
*nonstr
= NULL
)
1998 /* A non-null NONSTR is meaningless when determining the maximum
1999 value of an integer ARG. */
2000 gcc_assert (rkind
!= SRK_INT_VALUE
|| nonstr
== NULL
);
2001 /* ARG must have an integral type when RKIND says so. */
2002 gcc_assert (rkind
!= SRK_INT_VALUE
|| INTEGRAL_TYPE_P (TREE_TYPE (arg
)));
2004 auto_bitmap visited
;
2006 /* Reset DATA.MAXLEN if the call fails or when DATA.MAXLEN
2008 c_strlen_data lendata
= { };
2009 if (!get_range_strlen (arg
, visited
, rkind
, &lendata
, /* eltsize = */1))
2010 lendata
.maxlen
= NULL_TREE
;
2011 else if (lendata
.maxlen
&& integer_all_onesp (lendata
.maxlen
))
2012 lendata
.maxlen
= NULL_TREE
;
2016 /* For callers prepared to handle unterminated arrays set
2017 *NONSTR to point to the declaration of the array and return
2018 the maximum length/size. */
2019 *nonstr
= lendata
.decl
;
2020 return lendata
.maxlen
;
2023 /* Fail if the constant array isn't nul-terminated. */
2024 return lendata
.decl
? NULL_TREE
: lendata
.maxlen
;
2027 /* Return true if LEN is known to be less than or equal to (or if STRICT is
2028 true, strictly less than) the lower bound of SIZE at compile time and false
2032 known_lower (gimple
*stmt
, tree len
, tree size
, bool strict
= false)
2034 if (len
== NULL_TREE
)
2037 wide_int size_range
[2];
2038 wide_int len_range
[2];
2039 if (get_range (len
, stmt
, len_range
) && get_range (size
, stmt
, size_range
))
2042 return wi::ltu_p (len_range
[1], size_range
[0]);
2044 return wi::leu_p (len_range
[1], size_range
[0]);
2050 /* Fold function call to builtin strcpy with arguments DEST and SRC.
2051 If LEN is not NULL, it represents the length of the string to be
2052 copied. Return NULL_TREE if no simplification can be made. */
2055 gimple_fold_builtin_strcpy (gimple_stmt_iterator
*gsi
,
2056 tree dest
, tree src
)
2058 gimple
*stmt
= gsi_stmt (*gsi
);
2059 location_t loc
= gimple_location (stmt
);
2062 /* If SRC and DEST are the same (and not volatile), return DEST. */
2063 if (operand_equal_p (src
, dest
, 0))
2065 /* Issue -Wrestrict unless the pointers are null (those do
2066 not point to objects and so do not indicate an overlap;
2067 such calls could be the result of sanitization and jump
2069 if (!integer_zerop (dest
) && !warning_suppressed_p (stmt
, OPT_Wrestrict
))
2071 tree func
= gimple_call_fndecl (stmt
);
2073 warning_at (loc
, OPT_Wrestrict
,
2074 "%qD source argument is the same as destination",
2078 replace_call_with_value (gsi
, dest
);
2082 if (optimize_function_for_size_p (cfun
))
2085 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
2089 /* Set to non-null if ARG refers to an unterminated array. */
2091 tree len
= get_maxval_strlen (src
, SRK_STRLEN
, &nonstr
);
2095 /* Avoid folding calls with unterminated arrays. */
2096 if (!warning_suppressed_p (stmt
, OPT_Wstringop_overread
))
2097 warn_string_no_nul (loc
, stmt
, "strcpy", src
, nonstr
);
2098 suppress_warning (stmt
, OPT_Wstringop_overread
);
2105 len
= fold_convert_loc (loc
, size_type_node
, len
);
2106 len
= size_binop_loc (loc
, PLUS_EXPR
, len
, build_int_cst (size_type_node
, 1));
2107 len
= force_gimple_operand_gsi (gsi
, len
, true,
2108 NULL_TREE
, true, GSI_SAME_STMT
);
2109 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2110 replace_call_with_call_and_fold (gsi
, repl
);
2114 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
2115 If SLEN is not NULL, it represents the length of the source string.
2116 Return NULL_TREE if no simplification can be made. */
2119 gimple_fold_builtin_strncpy (gimple_stmt_iterator
*gsi
,
2120 tree dest
, tree src
, tree len
)
2122 gimple
*stmt
= gsi_stmt (*gsi
);
2123 location_t loc
= gimple_location (stmt
);
2124 bool nonstring
= get_attr_nonstring_decl (dest
) != NULL_TREE
;
2126 /* If the LEN parameter is zero, return DEST. */
2127 if (integer_zerop (len
))
2129 /* Avoid warning if the destination refers to an array/pointer
2130 decorate with attribute nonstring. */
2133 tree fndecl
= gimple_call_fndecl (stmt
);
2135 /* Warn about the lack of nul termination: the result is not
2136 a (nul-terminated) string. */
2137 tree slen
= get_maxval_strlen (src
, SRK_STRLEN
);
2138 if (slen
&& !integer_zerop (slen
))
2139 warning_at (loc
, OPT_Wstringop_truncation
,
2140 "%qD destination unchanged after copying no bytes "
2141 "from a string of length %E",
2144 warning_at (loc
, OPT_Wstringop_truncation
,
2145 "%qD destination unchanged after copying no bytes",
2149 replace_call_with_value (gsi
, dest
);
2153 /* We can't compare slen with len as constants below if len is not a
2155 if (TREE_CODE (len
) != INTEGER_CST
)
2158 /* Now, we must be passed a constant src ptr parameter. */
2159 tree slen
= get_maxval_strlen (src
, SRK_STRLEN
);
2160 if (!slen
|| TREE_CODE (slen
) != INTEGER_CST
)
2163 /* The size of the source string including the terminating nul. */
2164 tree ssize
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
2166 /* We do not support simplification of this case, though we do
2167 support it when expanding trees into RTL. */
2168 /* FIXME: generate a call to __builtin_memset. */
2169 if (tree_int_cst_lt (ssize
, len
))
2172 /* Diagnose truncation that leaves the copy unterminated. */
2173 maybe_diag_stxncpy_trunc (*gsi
, src
, len
);
2175 /* OK transform into builtin memcpy. */
2176 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
2180 len
= fold_convert_loc (loc
, size_type_node
, len
);
2181 len
= force_gimple_operand_gsi (gsi
, len
, true,
2182 NULL_TREE
, true, GSI_SAME_STMT
);
2183 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2184 replace_call_with_call_and_fold (gsi
, repl
);
2189 /* Fold function call to builtin strchr or strrchr.
2190 If both arguments are constant, evaluate and fold the result,
2191 otherwise simplify str(r)chr (str, 0) into str + strlen (str).
2192 In general strlen is significantly faster than strchr
2193 due to being a simpler operation. */
2195 gimple_fold_builtin_strchr (gimple_stmt_iterator
*gsi
, bool is_strrchr
)
2197 gimple
*stmt
= gsi_stmt (*gsi
);
2198 tree str
= gimple_call_arg (stmt
, 0);
2199 tree c
= gimple_call_arg (stmt
, 1);
2200 location_t loc
= gimple_location (stmt
);
2204 if (!gimple_call_lhs (stmt
))
2207 /* Avoid folding if the first argument is not a nul-terminated array.
2208 Defer warning until later. */
2209 if (!check_nul_terminated_array (NULL_TREE
, str
))
2212 if ((p
= c_getstr (str
)) && target_char_cst_p (c
, &ch
))
2214 const char *p1
= is_strrchr
? strrchr (p
, ch
) : strchr (p
, ch
);
2218 replace_call_with_value (gsi
, integer_zero_node
);
2222 tree len
= build_int_cst (size_type_node
, p1
- p
);
2223 gimple_seq stmts
= NULL
;
2224 gimple
*new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
2225 POINTER_PLUS_EXPR
, str
, len
);
2226 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
2227 gsi_replace_with_seq_vops (gsi
, stmts
);
2231 if (!integer_zerop (c
))
2234 /* Transform strrchr (s, 0) to strchr (s, 0) when optimizing for size. */
2235 if (is_strrchr
&& optimize_function_for_size_p (cfun
))
2237 tree strchr_fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
2241 gimple
*repl
= gimple_build_call (strchr_fn
, 2, str
, c
);
2242 replace_call_with_call_and_fold (gsi
, repl
);
2250 tree strlen_fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
2255 /* Create newstr = strlen (str). */
2256 gimple_seq stmts
= NULL
;
2257 gimple
*new_stmt
= gimple_build_call (strlen_fn
, 1, str
);
2258 gimple_set_location (new_stmt
, loc
);
2259 len
= create_tmp_reg_or_ssa_name (size_type_node
);
2260 gimple_call_set_lhs (new_stmt
, len
);
2261 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
2263 /* Create (str p+ strlen (str)). */
2264 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
2265 POINTER_PLUS_EXPR
, str
, len
);
2266 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
2267 gsi_replace_with_seq_vops (gsi
, stmts
);
2268 /* gsi now points at the assignment to the lhs, get a
2269 stmt iterator to the strlen.
2270 ??? We can't use gsi_for_stmt as that doesn't work when the
2271 CFG isn't built yet. */
2272 gimple_stmt_iterator gsi2
= *gsi
;
2278 /* Fold function call to builtin strstr.
2279 If both arguments are constant, evaluate and fold the result,
2280 additionally fold strstr (x, "") into x and strstr (x, "c")
2281 into strchr (x, 'c'). */
2283 gimple_fold_builtin_strstr (gimple_stmt_iterator
*gsi
)
2285 gimple
*stmt
= gsi_stmt (*gsi
);
2286 if (!gimple_call_lhs (stmt
))
2289 tree haystack
= gimple_call_arg (stmt
, 0);
2290 tree needle
= gimple_call_arg (stmt
, 1);
2292 /* Avoid folding if either argument is not a nul-terminated array.
2293 Defer warning until later. */
2294 if (!check_nul_terminated_array (NULL_TREE
, haystack
)
2295 || !check_nul_terminated_array (NULL_TREE
, needle
))
2298 const char *q
= c_getstr (needle
);
2302 if (const char *p
= c_getstr (haystack
))
2304 const char *r
= strstr (p
, q
);
2308 replace_call_with_value (gsi
, integer_zero_node
);
2312 tree len
= build_int_cst (size_type_node
, r
- p
);
2313 gimple_seq stmts
= NULL
;
2315 = gimple_build_assign (gimple_call_lhs (stmt
), POINTER_PLUS_EXPR
,
2317 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
2318 gsi_replace_with_seq_vops (gsi
, stmts
);
2322 /* For strstr (x, "") return x. */
2325 replace_call_with_value (gsi
, haystack
);
2329 /* Transform strstr (x, "c") into strchr (x, 'c'). */
2332 tree strchr_fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
2335 tree c
= build_int_cst (integer_type_node
, q
[0]);
2336 gimple
*repl
= gimple_build_call (strchr_fn
, 2, haystack
, c
);
2337 replace_call_with_call_and_fold (gsi
, repl
);
2345 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
2348 Return NULL_TREE if no simplification was possible, otherwise return the
2349 simplified form of the call as a tree.
2351 The simplified form may be a constant or other expression which
2352 computes the same value, but in a more efficient manner (including
2353 calls to other builtin functions).
2355 The call may contain arguments which need to be evaluated, but
2356 which are not useful to determine the result of the call. In
2357 this case we return a chain of COMPOUND_EXPRs. The LHS of each
2358 COMPOUND_EXPR will be an argument which must be evaluated.
2359 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
2360 COMPOUND_EXPR in the chain will contain the tree for the simplified
2361 form of the builtin function call. */
2364 gimple_fold_builtin_strcat (gimple_stmt_iterator
*gsi
, tree dst
, tree src
)
2366 gimple
*stmt
= gsi_stmt (*gsi
);
2367 location_t loc
= gimple_location (stmt
);
2369 const char *p
= c_getstr (src
);
2371 /* If the string length is zero, return the dst parameter. */
2372 if (p
&& *p
== '\0')
2374 replace_call_with_value (gsi
, dst
);
2378 if (!optimize_bb_for_speed_p (gimple_bb (stmt
)))
2381 /* See if we can store by pieces into (dst + strlen(dst)). */
2383 tree strlen_fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
2384 tree memcpy_fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
2386 if (!strlen_fn
|| !memcpy_fn
)
2389 /* If the length of the source string isn't computable don't
2390 split strcat into strlen and memcpy. */
2391 tree len
= get_maxval_strlen (src
, SRK_STRLEN
);
2395 /* Create strlen (dst). */
2396 gimple_seq stmts
= NULL
, stmts2
;
2397 gimple
*repl
= gimple_build_call (strlen_fn
, 1, dst
);
2398 gimple_set_location (repl
, loc
);
2399 newdst
= create_tmp_reg_or_ssa_name (size_type_node
);
2400 gimple_call_set_lhs (repl
, newdst
);
2401 gimple_seq_add_stmt_without_update (&stmts
, repl
);
2403 /* Create (dst p+ strlen (dst)). */
2404 newdst
= fold_build_pointer_plus_loc (loc
, dst
, newdst
);
2405 newdst
= force_gimple_operand (newdst
, &stmts2
, true, NULL_TREE
);
2406 gimple_seq_add_seq_without_update (&stmts
, stmts2
);
2408 len
= fold_convert_loc (loc
, size_type_node
, len
);
2409 len
= size_binop_loc (loc
, PLUS_EXPR
, len
,
2410 build_int_cst (size_type_node
, 1));
2411 len
= force_gimple_operand (len
, &stmts2
, true, NULL_TREE
);
2412 gimple_seq_add_seq_without_update (&stmts
, stmts2
);
2414 repl
= gimple_build_call (memcpy_fn
, 3, newdst
, src
, len
);
2415 gimple_seq_add_stmt_without_update (&stmts
, repl
);
2416 if (gimple_call_lhs (stmt
))
2418 repl
= gimple_build_assign (gimple_call_lhs (stmt
), dst
);
2419 gimple_seq_add_stmt_without_update (&stmts
, repl
);
2420 gsi_replace_with_seq_vops (gsi
, stmts
);
2421 /* gsi now points at the assignment to the lhs, get a
2422 stmt iterator to the memcpy call.
2423 ??? We can't use gsi_for_stmt as that doesn't work when the
2424 CFG isn't built yet. */
2425 gimple_stmt_iterator gsi2
= *gsi
;
2431 gsi_replace_with_seq_vops (gsi
, stmts
);
2437 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
2438 are the arguments to the call. */
2441 gimple_fold_builtin_strcat_chk (gimple_stmt_iterator
*gsi
)
2443 gimple
*stmt
= gsi_stmt (*gsi
);
2444 tree dest
= gimple_call_arg (stmt
, 0);
2445 tree src
= gimple_call_arg (stmt
, 1);
2446 tree size
= gimple_call_arg (stmt
, 2);
2452 /* If the SRC parameter is "", return DEST. */
2453 if (p
&& *p
== '\0')
2455 replace_call_with_value (gsi
, dest
);
2459 if (! tree_fits_uhwi_p (size
) || ! integer_all_onesp (size
))
2462 /* If __builtin_strcat_chk is used, assume strcat is available. */
2463 fn
= builtin_decl_explicit (BUILT_IN_STRCAT
);
2467 gimple
*repl
= gimple_build_call (fn
, 2, dest
, src
);
2468 replace_call_with_call_and_fold (gsi
, repl
);
2472 /* Simplify a call to the strncat builtin. */
2475 gimple_fold_builtin_strncat (gimple_stmt_iterator
*gsi
)
2477 gimple
*stmt
= gsi_stmt (*gsi
);
2478 tree dst
= gimple_call_arg (stmt
, 0);
2479 tree src
= gimple_call_arg (stmt
, 1);
2480 tree len
= gimple_call_arg (stmt
, 2);
2481 tree src_len
= c_strlen (src
, 1);
2483 /* If the requested length is zero, or the src parameter string
2484 length is zero, return the dst parameter. */
2485 if (integer_zerop (len
) || (src_len
&& integer_zerop (src_len
)))
2487 replace_call_with_value (gsi
, dst
);
2491 /* Return early if the requested len is less than the string length.
2492 Warnings will be issued elsewhere later. */
2493 if (!src_len
|| known_lower (stmt
, len
, src_len
, true))
2496 unsigned HOST_WIDE_INT dstsize
;
2497 bool found_dstsize
= compute_builtin_object_size (dst
, 1, &dstsize
);
2499 /* Warn on constant LEN. */
2500 if (TREE_CODE (len
) == INTEGER_CST
)
2502 bool nowarn
= warning_suppressed_p (stmt
, OPT_Wstringop_overflow_
);
2504 if (!nowarn
&& found_dstsize
)
2506 int cmpdst
= compare_tree_int (len
, dstsize
);
2510 tree fndecl
= gimple_call_fndecl (stmt
);
2512 /* Strncat copies (at most) LEN bytes and always appends
2513 the terminating NUL so the specified bound should never
2514 be equal to (or greater than) the size of the destination.
2515 If it is, the copy could overflow. */
2516 location_t loc
= gimple_location (stmt
);
2517 nowarn
= warning_at (loc
, OPT_Wstringop_overflow_
,
2519 ? G_("%qD specified bound %E equals "
2521 : G_("%qD specified bound %E exceeds "
2522 "destination size %wu"),
2523 fndecl
, len
, dstsize
);
2525 suppress_warning (stmt
, OPT_Wstringop_overflow_
);
2529 if (!nowarn
&& TREE_CODE (src_len
) == INTEGER_CST
2530 && tree_int_cst_compare (src_len
, len
) == 0)
2532 tree fndecl
= gimple_call_fndecl (stmt
);
2533 location_t loc
= gimple_location (stmt
);
2535 /* To avoid possible overflow the specified bound should also
2536 not be equal to the length of the source, even when the size
2537 of the destination is unknown (it's not an uncommon mistake
2538 to specify as the bound to strncpy the length of the source). */
2539 if (warning_at (loc
, OPT_Wstringop_overflow_
,
2540 "%qD specified bound %E equals source length",
2542 suppress_warning (stmt
, OPT_Wstringop_overflow_
);
2546 if (!known_lower (stmt
, src_len
, len
))
2549 tree fn
= builtin_decl_implicit (BUILT_IN_STRCAT
);
2551 /* If the replacement _DECL isn't initialized, don't do the
2556 /* Otherwise, emit a call to strcat. */
2557 gcall
*repl
= gimple_build_call (fn
, 2, dst
, src
);
2558 replace_call_with_call_and_fold (gsi
, repl
);
2562 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
2566 gimple_fold_builtin_strncat_chk (gimple_stmt_iterator
*gsi
)
2568 gimple
*stmt
= gsi_stmt (*gsi
);
2569 tree dest
= gimple_call_arg (stmt
, 0);
2570 tree src
= gimple_call_arg (stmt
, 1);
2571 tree len
= gimple_call_arg (stmt
, 2);
2572 tree size
= gimple_call_arg (stmt
, 3);
2577 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
2578 if ((p
&& *p
== '\0')
2579 || integer_zerop (len
))
2581 replace_call_with_value (gsi
, dest
);
2585 if (! integer_all_onesp (size
))
2587 tree src_len
= c_strlen (src
, 1);
2588 if (known_lower (stmt
, src_len
, len
))
2590 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
2591 fn
= builtin_decl_explicit (BUILT_IN_STRCAT_CHK
);
2595 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, size
);
2596 replace_call_with_call_and_fold (gsi
, repl
);
2602 /* If __builtin_strncat_chk is used, assume strncat is available. */
2603 fn
= builtin_decl_explicit (BUILT_IN_STRNCAT
);
2607 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2608 replace_call_with_call_and_fold (gsi
, repl
);
2612 /* Build and append gimple statements to STMTS that would load a first
2613 character of a memory location identified by STR. LOC is location
2614 of the statement. */
2617 gimple_load_first_char (location_t loc
, tree str
, gimple_seq
*stmts
)
2621 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
2622 tree cst_uchar_ptr_node
2623 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
2624 tree off0
= build_int_cst (cst_uchar_ptr_node
, 0);
2626 tree temp
= fold_build2_loc (loc
, MEM_REF
, cst_uchar_node
, str
, off0
);
2627 gassign
*stmt
= gimple_build_assign (NULL_TREE
, temp
);
2628 var
= create_tmp_reg_or_ssa_name (cst_uchar_node
, stmt
);
2630 gimple_assign_set_lhs (stmt
, var
);
2631 gimple_seq_add_stmt_without_update (stmts
, stmt
);
2636 /* Fold a call to the str{n}{case}cmp builtin pointed by GSI iterator. */
2639 gimple_fold_builtin_string_compare (gimple_stmt_iterator
*gsi
)
2641 gimple
*stmt
= gsi_stmt (*gsi
);
2642 tree callee
= gimple_call_fndecl (stmt
);
2643 enum built_in_function fcode
= DECL_FUNCTION_CODE (callee
);
2645 tree type
= integer_type_node
;
2646 tree str1
= gimple_call_arg (stmt
, 0);
2647 tree str2
= gimple_call_arg (stmt
, 1);
2648 tree lhs
= gimple_call_lhs (stmt
);
2650 tree bound_node
= NULL_TREE
;
2651 unsigned HOST_WIDE_INT bound
= HOST_WIDE_INT_M1U
;
2653 /* Handle strncmp and strncasecmp functions. */
2654 if (gimple_call_num_args (stmt
) == 3)
2656 bound_node
= gimple_call_arg (stmt
, 2);
2657 if (tree_fits_uhwi_p (bound_node
))
2658 bound
= tree_to_uhwi (bound_node
);
2661 /* If the BOUND parameter is zero, return zero. */
2664 replace_call_with_value (gsi
, integer_zero_node
);
2668 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
2669 if (operand_equal_p (str1
, str2
, 0))
2671 replace_call_with_value (gsi
, integer_zero_node
);
2675 /* Initially set to the number of characters, including the terminating
2676 nul if each array has one. LENx == strnlen (Sx, LENx) implies that
2677 the array Sx is not terminated by a nul.
2678 For nul-terminated strings then adjusted to their length so that
2679 LENx == NULPOSx holds. */
2680 unsigned HOST_WIDE_INT len1
= HOST_WIDE_INT_MAX
, len2
= len1
;
2681 const char *p1
= getbyterep (str1
, &len1
);
2682 const char *p2
= getbyterep (str2
, &len2
);
2684 /* The position of the terminating nul character if one exists, otherwise
2685 a value greater than LENx. */
2686 unsigned HOST_WIDE_INT nulpos1
= HOST_WIDE_INT_MAX
, nulpos2
= nulpos1
;
2690 size_t n
= strnlen (p1
, len1
);
2697 size_t n
= strnlen (p2
, len2
);
2702 /* For known strings, return an immediate value. */
2706 bool known_result
= false;
2710 case BUILT_IN_STRCMP
:
2711 case BUILT_IN_STRCMP_EQ
:
2712 if (len1
!= nulpos1
|| len2
!= nulpos2
)
2715 r
= strcmp (p1
, p2
);
2716 known_result
= true;
2719 case BUILT_IN_STRNCMP
:
2720 case BUILT_IN_STRNCMP_EQ
:
2722 if (bound
== HOST_WIDE_INT_M1U
)
2725 /* Reduce the bound to be no more than the length
2726 of the shorter of the two strings, or the sizes
2727 of the unterminated arrays. */
2728 unsigned HOST_WIDE_INT n
= bound
;
2730 if (len1
== nulpos1
&& len1
< n
)
2732 if (len2
== nulpos2
&& len2
< n
)
2735 if (MIN (nulpos1
, nulpos2
) + 1 < n
)
2738 r
= strncmp (p1
, p2
, n
);
2739 known_result
= true;
2742 /* Only handleable situation is where the string are equal (result 0),
2743 which is already handled by operand_equal_p case. */
2744 case BUILT_IN_STRCASECMP
:
2746 case BUILT_IN_STRNCASECMP
:
2748 if (bound
== HOST_WIDE_INT_M1U
)
2750 r
= strncmp (p1
, p2
, bound
);
2752 known_result
= true;
2761 replace_call_with_value (gsi
, build_cmp_result (type
, r
));
2766 bool nonzero_bound
= (bound
>= 1 && bound
< HOST_WIDE_INT_M1U
)
2767 || fcode
== BUILT_IN_STRCMP
2768 || fcode
== BUILT_IN_STRCMP_EQ
2769 || fcode
== BUILT_IN_STRCASECMP
;
2771 location_t loc
= gimple_location (stmt
);
2773 /* If the second arg is "", return *(const unsigned char*)arg1. */
2774 if (p2
&& *p2
== '\0' && nonzero_bound
)
2776 gimple_seq stmts
= NULL
;
2777 tree var
= gimple_load_first_char (loc
, str1
, &stmts
);
2780 stmt
= gimple_build_assign (lhs
, NOP_EXPR
, var
);
2781 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2784 gsi_replace_with_seq_vops (gsi
, stmts
);
2788 /* If the first arg is "", return -*(const unsigned char*)arg2. */
2789 if (p1
&& *p1
== '\0' && nonzero_bound
)
2791 gimple_seq stmts
= NULL
;
2792 tree var
= gimple_load_first_char (loc
, str2
, &stmts
);
2796 tree c
= create_tmp_reg_or_ssa_name (integer_type_node
);
2797 stmt
= gimple_build_assign (c
, NOP_EXPR
, var
);
2798 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2800 stmt
= gimple_build_assign (lhs
, NEGATE_EXPR
, c
);
2801 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2804 gsi_replace_with_seq_vops (gsi
, stmts
);
2808 /* If BOUND is one, return an expression corresponding to
2809 (*(const unsigned char*)arg2 - *(const unsigned char*)arg1). */
2810 if (fcode
== BUILT_IN_STRNCMP
&& bound
== 1)
2812 gimple_seq stmts
= NULL
;
2813 tree temp1
= gimple_load_first_char (loc
, str1
, &stmts
);
2814 tree temp2
= gimple_load_first_char (loc
, str2
, &stmts
);
2818 tree c1
= create_tmp_reg_or_ssa_name (integer_type_node
);
2819 gassign
*convert1
= gimple_build_assign (c1
, NOP_EXPR
, temp1
);
2820 gimple_seq_add_stmt_without_update (&stmts
, convert1
);
2822 tree c2
= create_tmp_reg_or_ssa_name (integer_type_node
);
2823 gassign
*convert2
= gimple_build_assign (c2
, NOP_EXPR
, temp2
);
2824 gimple_seq_add_stmt_without_update (&stmts
, convert2
);
2826 stmt
= gimple_build_assign (lhs
, MINUS_EXPR
, c1
, c2
);
2827 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2830 gsi_replace_with_seq_vops (gsi
, stmts
);
2834 /* If BOUND is greater than the length of one constant string,
2835 and the other argument is also a nul-terminated string, replace
2836 strncmp with strcmp. */
2837 if (fcode
== BUILT_IN_STRNCMP
2838 && bound
> 0 && bound
< HOST_WIDE_INT_M1U
2839 && ((p2
&& len2
< bound
&& len2
== nulpos2
)
2840 || (p1
&& len1
< bound
&& len1
== nulpos1
)))
2842 tree fn
= builtin_decl_implicit (BUILT_IN_STRCMP
);
2845 gimple
*repl
= gimple_build_call (fn
, 2, str1
, str2
);
2846 replace_call_with_call_and_fold (gsi
, repl
);
2853 /* Fold a call to the memchr pointed by GSI iterator. */
2856 gimple_fold_builtin_memchr (gimple_stmt_iterator
*gsi
)
2858 gimple
*stmt
= gsi_stmt (*gsi
);
2859 tree lhs
= gimple_call_lhs (stmt
);
2860 tree arg1
= gimple_call_arg (stmt
, 0);
2861 tree arg2
= gimple_call_arg (stmt
, 1);
2862 tree len
= gimple_call_arg (stmt
, 2);
2864 /* If the LEN parameter is zero, return zero. */
2865 if (integer_zerop (len
))
2867 replace_call_with_value (gsi
, build_int_cst (ptr_type_node
, 0));
2872 if (TREE_CODE (arg2
) != INTEGER_CST
2873 || !tree_fits_uhwi_p (len
)
2874 || !target_char_cst_p (arg2
, &c
))
2877 unsigned HOST_WIDE_INT length
= tree_to_uhwi (len
);
2878 unsigned HOST_WIDE_INT string_length
;
2879 const char *p1
= getbyterep (arg1
, &string_length
);
2883 const char *r
= (const char *)memchr (p1
, c
, MIN (length
, string_length
));
2886 tree mem_size
, offset_node
;
2887 byte_representation (arg1
, &offset_node
, &mem_size
, NULL
);
2888 unsigned HOST_WIDE_INT offset
= (offset_node
== NULL_TREE
)
2889 ? 0 : tree_to_uhwi (offset_node
);
2890 /* MEM_SIZE is the size of the array the string literal
2892 unsigned HOST_WIDE_INT string_size
= tree_to_uhwi (mem_size
) - offset
;
2893 gcc_checking_assert (string_length
<= string_size
);
2894 if (length
<= string_size
)
2896 replace_call_with_value (gsi
, build_int_cst (ptr_type_node
, 0));
2902 unsigned HOST_WIDE_INT offset
= r
- p1
;
2903 gimple_seq stmts
= NULL
;
2904 if (lhs
!= NULL_TREE
)
2906 tree offset_cst
= build_int_cst (sizetype
, offset
);
2907 gassign
*stmt
= gimple_build_assign (lhs
, POINTER_PLUS_EXPR
,
2909 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2912 gimple_seq_add_stmt_without_update (&stmts
,
2913 gimple_build_nop ());
2915 gsi_replace_with_seq_vops (gsi
, stmts
);
2923 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
2924 to the call. IGNORE is true if the value returned
2925 by the builtin will be ignored. UNLOCKED is true is true if this
2926 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
2927 the known length of the string. Return NULL_TREE if no simplification
2931 gimple_fold_builtin_fputs (gimple_stmt_iterator
*gsi
,
2932 tree arg0
, tree arg1
,
2935 gimple
*stmt
= gsi_stmt (*gsi
);
2937 /* If we're using an unlocked function, assume the other unlocked
2938 functions exist explicitly. */
2939 tree
const fn_fputc
= (unlocked
2940 ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED
)
2941 : builtin_decl_implicit (BUILT_IN_FPUTC
));
2942 tree
const fn_fwrite
= (unlocked
2943 ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED
)
2944 : builtin_decl_implicit (BUILT_IN_FWRITE
));
2946 /* If the return value is used, don't do the transformation. */
2947 if (gimple_call_lhs (stmt
))
2950 /* Get the length of the string passed to fputs. If the length
2951 can't be determined, punt. */
2952 tree len
= get_maxval_strlen (arg0
, SRK_STRLEN
);
2954 || TREE_CODE (len
) != INTEGER_CST
)
2957 switch (compare_tree_int (len
, 1))
2959 case -1: /* length is 0, delete the call entirely . */
2960 replace_call_with_value (gsi
, integer_zero_node
);
2963 case 0: /* length is 1, call fputc. */
2965 const char *p
= c_getstr (arg0
);
2971 gimple
*repl
= gimple_build_call (fn_fputc
, 2,
2973 (integer_type_node
, p
[0]), arg1
);
2974 replace_call_with_call_and_fold (gsi
, repl
);
2979 case 1: /* length is greater than 1, call fwrite. */
2981 /* If optimizing for size keep fputs. */
2982 if (optimize_function_for_size_p (cfun
))
2984 /* New argument list transforming fputs(string, stream) to
2985 fwrite(string, 1, len, stream). */
2989 gimple
*repl
= gimple_build_call (fn_fwrite
, 4, arg0
,
2990 size_one_node
, len
, arg1
);
2991 replace_call_with_call_and_fold (gsi
, repl
);
2999 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
3000 DEST, SRC, LEN, and SIZE are the arguments to the call.
3001 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
3002 code of the builtin. If MAXLEN is not NULL, it is maximum length
3003 passed as third argument. */
3006 gimple_fold_builtin_memory_chk (gimple_stmt_iterator
*gsi
,
3007 tree dest
, tree src
, tree len
, tree size
,
3008 enum built_in_function fcode
)
3010 gimple
*stmt
= gsi_stmt (*gsi
);
3011 location_t loc
= gimple_location (stmt
);
3012 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
3015 /* If SRC and DEST are the same (and not volatile), return DEST
3016 (resp. DEST+LEN for __mempcpy_chk). */
3017 if (fcode
!= BUILT_IN_MEMSET_CHK
&& operand_equal_p (src
, dest
, 0))
3019 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
3021 replace_call_with_value (gsi
, dest
);
3026 gimple_seq stmts
= NULL
;
3027 len
= gimple_convert_to_ptrofftype (&stmts
, loc
, len
);
3028 tree temp
= gimple_build (&stmts
, loc
, POINTER_PLUS_EXPR
,
3029 TREE_TYPE (dest
), dest
, len
);
3030 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
3031 replace_call_with_value (gsi
, temp
);
3036 tree maxlen
= get_maxval_strlen (len
, SRK_INT_VALUE
);
3037 if (! integer_all_onesp (size
)
3038 && !known_lower (stmt
, len
, size
)
3039 && !known_lower (stmt
, maxlen
, size
))
3041 /* MAXLEN and LEN both cannot be proved to be less than SIZE, at
3042 least try to optimize (void) __mempcpy_chk () into
3043 (void) __memcpy_chk () */
3044 if (fcode
== BUILT_IN_MEMPCPY_CHK
&& ignore
)
3046 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
3050 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
3051 replace_call_with_call_and_fold (gsi
, repl
);
3058 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
3059 mem{cpy,pcpy,move,set} is available. */
3062 case BUILT_IN_MEMCPY_CHK
:
3063 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY
);
3065 case BUILT_IN_MEMPCPY_CHK
:
3066 fn
= builtin_decl_explicit (BUILT_IN_MEMPCPY
);
3068 case BUILT_IN_MEMMOVE_CHK
:
3069 fn
= builtin_decl_explicit (BUILT_IN_MEMMOVE
);
3071 case BUILT_IN_MEMSET_CHK
:
3072 fn
= builtin_decl_explicit (BUILT_IN_MEMSET
);
3081 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
3082 replace_call_with_call_and_fold (gsi
, repl
);
3086 /* Print a message in the dump file recording transformation of FROM to TO. */
3089 dump_transformation (gcall
*from
, gcall
*to
)
3091 if (dump_enabled_p ())
3092 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, from
, "simplified %T to %T\n",
3093 gimple_call_fn (from
), gimple_call_fn (to
));
3096 /* Fold a call to the __st[rp]cpy_chk builtin.
3097 DEST, SRC, and SIZE are the arguments to the call.
3098 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
3099 code of the builtin. If MAXLEN is not NULL, it is maximum length of
3100 strings passed as second argument. */
3103 gimple_fold_builtin_stxcpy_chk (gimple_stmt_iterator
*gsi
,
3105 tree src
, tree size
,
3106 enum built_in_function fcode
)
3108 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3109 location_t loc
= gimple_location (stmt
);
3110 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
3113 /* If SRC and DEST are the same (and not volatile), return DEST. */
3114 if (fcode
== BUILT_IN_STRCPY_CHK
&& operand_equal_p (src
, dest
, 0))
3116 /* Issue -Wrestrict unless the pointers are null (those do
3117 not point to objects and so do not indicate an overlap;
3118 such calls could be the result of sanitization and jump
3120 if (!integer_zerop (dest
)
3121 && !warning_suppressed_p (stmt
, OPT_Wrestrict
))
3123 tree func
= gimple_call_fndecl (stmt
);
3125 warning_at (loc
, OPT_Wrestrict
,
3126 "%qD source argument is the same as destination",
3130 replace_call_with_value (gsi
, dest
);
3134 tree maxlen
= get_maxval_strlen (src
, SRK_STRLENMAX
);
3135 if (! integer_all_onesp (size
))
3137 len
= c_strlen (src
, 1);
3138 if (!known_lower (stmt
, len
, size
, true)
3139 && !known_lower (stmt
, maxlen
, size
, true))
3141 if (fcode
== BUILT_IN_STPCPY_CHK
)
3146 /* If return value of __stpcpy_chk is ignored,
3147 optimize into __strcpy_chk. */
3148 fn
= builtin_decl_explicit (BUILT_IN_STRCPY_CHK
);
3152 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, size
);
3153 replace_call_with_call_and_fold (gsi
, repl
);
3157 if (! len
|| TREE_SIDE_EFFECTS (len
))
3160 /* If c_strlen returned something, but not provably less than size,
3161 transform __strcpy_chk into __memcpy_chk. */
3162 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
3166 gimple_seq stmts
= NULL
;
3167 len
= force_gimple_operand (len
, &stmts
, true, NULL_TREE
);
3168 len
= gimple_convert (&stmts
, loc
, size_type_node
, len
);
3169 len
= gimple_build (&stmts
, loc
, PLUS_EXPR
, size_type_node
, len
,
3170 build_int_cst (size_type_node
, 1));
3171 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
3172 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
3173 replace_call_with_call_and_fold (gsi
, repl
);
3178 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
3179 fn
= builtin_decl_explicit (fcode
== BUILT_IN_STPCPY_CHK
&& !ignore
3180 ? BUILT_IN_STPCPY
: BUILT_IN_STRCPY
);
3184 gcall
*repl
= gimple_build_call (fn
, 2, dest
, src
);
3185 dump_transformation (stmt
, repl
);
3186 replace_call_with_call_and_fold (gsi
, repl
);
3190 /* Fold a call to the __st{r,p}ncpy_chk builtin. DEST, SRC, LEN, and SIZE
3191 are the arguments to the call. If MAXLEN is not NULL, it is maximum
3192 length passed as third argument. IGNORE is true if return value can be
3193 ignored. FCODE is the BUILT_IN_* code of the builtin. */
3196 gimple_fold_builtin_stxncpy_chk (gimple_stmt_iterator
*gsi
,
3197 tree dest
, tree src
,
3198 tree len
, tree size
,
3199 enum built_in_function fcode
)
3201 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3202 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
3205 tree maxlen
= get_maxval_strlen (len
, SRK_INT_VALUE
);
3206 if (! integer_all_onesp (size
)
3207 && !known_lower (stmt
, len
, size
) && !known_lower (stmt
, maxlen
, size
))
3209 if (fcode
== BUILT_IN_STPNCPY_CHK
&& ignore
)
3211 /* If return value of __stpncpy_chk is ignored,
3212 optimize into __strncpy_chk. */
3213 fn
= builtin_decl_explicit (BUILT_IN_STRNCPY_CHK
);
3216 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
3217 replace_call_with_call_and_fold (gsi
, repl
);
3224 /* If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available. */
3225 fn
= builtin_decl_explicit (fcode
== BUILT_IN_STPNCPY_CHK
&& !ignore
3226 ? BUILT_IN_STPNCPY
: BUILT_IN_STRNCPY
);
3230 gcall
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
3231 dump_transformation (stmt
, repl
);
3232 replace_call_with_call_and_fold (gsi
, repl
);
3236 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
3237 Return NULL_TREE if no simplification can be made. */
3240 gimple_fold_builtin_stpcpy (gimple_stmt_iterator
*gsi
)
3242 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3243 location_t loc
= gimple_location (stmt
);
3244 tree dest
= gimple_call_arg (stmt
, 0);
3245 tree src
= gimple_call_arg (stmt
, 1);
3248 /* If the result is unused, replace stpcpy with strcpy. */
3249 if (gimple_call_lhs (stmt
) == NULL_TREE
)
3251 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3254 gimple_call_set_fndecl (stmt
, fn
);
3259 /* Set to non-null if ARG refers to an unterminated array. */
3260 c_strlen_data data
= { };
3261 /* The size of the unterminated array if SRC referes to one. */
3263 /* True if the size is exact/constant, false if it's the lower bound
3266 tree len
= c_strlen (src
, 1, &data
, 1);
3268 || TREE_CODE (len
) != INTEGER_CST
)
3270 data
.decl
= unterminated_array (src
, &size
, &exact
);
3277 /* Avoid folding calls with unterminated arrays. */
3278 if (!warning_suppressed_p (stmt
, OPT_Wstringop_overread
))
3279 warn_string_no_nul (loc
, stmt
, "stpcpy", src
, data
.decl
, size
,
3281 suppress_warning (stmt
, OPT_Wstringop_overread
);
3285 if (optimize_function_for_size_p (cfun
)
3286 /* If length is zero it's small enough. */
3287 && !integer_zerop (len
))
3290 /* If the source has a known length replace stpcpy with memcpy. */
3291 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3295 gimple_seq stmts
= NULL
;
3296 tree tem
= gimple_convert (&stmts
, loc
, size_type_node
, len
);
3297 lenp1
= gimple_build (&stmts
, loc
, PLUS_EXPR
, size_type_node
,
3298 tem
, build_int_cst (size_type_node
, 1));
3299 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
3300 gcall
*repl
= gimple_build_call (fn
, 3, dest
, src
, lenp1
);
3301 gimple_move_vops (repl
, stmt
);
3302 gsi_insert_before (gsi
, repl
, GSI_SAME_STMT
);
3303 /* Replace the result with dest + len. */
3305 tem
= gimple_convert (&stmts
, loc
, sizetype
, len
);
3306 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
3307 gassign
*ret
= gimple_build_assign (gimple_call_lhs (stmt
),
3308 POINTER_PLUS_EXPR
, dest
, tem
);
3309 gsi_replace (gsi
, ret
, false);
3310 /* Finally fold the memcpy call. */
3311 gimple_stmt_iterator gsi2
= *gsi
;
3317 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS. Return
3318 NULL_TREE if a normal call should be emitted rather than expanding
3319 the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
3320 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
3321 passed as second argument. */
3324 gimple_fold_builtin_snprintf_chk (gimple_stmt_iterator
*gsi
,
3325 enum built_in_function fcode
)
3327 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3328 tree dest
, size
, len
, fn
, fmt
, flag
;
3329 const char *fmt_str
;
3331 /* Verify the required arguments in the original call. */
3332 if (gimple_call_num_args (stmt
) < 5)
3335 dest
= gimple_call_arg (stmt
, 0);
3336 len
= gimple_call_arg (stmt
, 1);
3337 flag
= gimple_call_arg (stmt
, 2);
3338 size
= gimple_call_arg (stmt
, 3);
3339 fmt
= gimple_call_arg (stmt
, 4);
3341 tree maxlen
= get_maxval_strlen (len
, SRK_INT_VALUE
);
3342 if (! integer_all_onesp (size
)
3343 && !known_lower (stmt
, len
, size
) && !known_lower (stmt
, maxlen
, size
))
3346 if (!init_target_chars ())
3349 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
3350 or if format doesn't contain % chars or is "%s". */
3351 if (! integer_zerop (flag
))
3353 fmt_str
= c_getstr (fmt
);
3354 if (fmt_str
== NULL
)
3356 if (strchr (fmt_str
, target_percent
) != NULL
3357 && strcmp (fmt_str
, target_percent_s
))
3361 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
3363 fn
= builtin_decl_explicit (fcode
== BUILT_IN_VSNPRINTF_CHK
3364 ? BUILT_IN_VSNPRINTF
: BUILT_IN_SNPRINTF
);
3368 /* Replace the called function and the first 5 argument by 3 retaining
3369 trailing varargs. */
3370 gimple_call_set_fndecl (stmt
, fn
);
3371 gimple_call_set_fntype (stmt
, TREE_TYPE (fn
));
3372 gimple_call_set_arg (stmt
, 0, dest
);
3373 gimple_call_set_arg (stmt
, 1, len
);
3374 gimple_call_set_arg (stmt
, 2, fmt
);
3375 for (unsigned i
= 3; i
< gimple_call_num_args (stmt
) - 2; ++i
)
3376 gimple_call_set_arg (stmt
, i
, gimple_call_arg (stmt
, i
+ 2));
3377 gimple_set_num_ops (stmt
, gimple_num_ops (stmt
) - 2);
3382 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
3383 Return NULL_TREE if a normal call should be emitted rather than
3384 expanding the function inline. FCODE is either BUILT_IN_SPRINTF_CHK
3385 or BUILT_IN_VSPRINTF_CHK. */
3388 gimple_fold_builtin_sprintf_chk (gimple_stmt_iterator
*gsi
,
3389 enum built_in_function fcode
)
3391 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3392 tree dest
, size
, len
, fn
, fmt
, flag
;
3393 const char *fmt_str
;
3394 unsigned nargs
= gimple_call_num_args (stmt
);
3396 /* Verify the required arguments in the original call. */
3399 dest
= gimple_call_arg (stmt
, 0);
3400 flag
= gimple_call_arg (stmt
, 1);
3401 size
= gimple_call_arg (stmt
, 2);
3402 fmt
= gimple_call_arg (stmt
, 3);
3406 if (!init_target_chars ())
3409 /* Check whether the format is a literal string constant. */
3410 fmt_str
= c_getstr (fmt
);
3411 if (fmt_str
!= NULL
)
3413 /* If the format doesn't contain % args or %%, we know the size. */
3414 if (strchr (fmt_str
, target_percent
) == 0)
3416 if (fcode
!= BUILT_IN_SPRINTF_CHK
|| nargs
== 4)
3417 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
3419 /* If the format is "%s" and first ... argument is a string literal,
3420 we know the size too. */
3421 else if (fcode
== BUILT_IN_SPRINTF_CHK
3422 && strcmp (fmt_str
, target_percent_s
) == 0)
3428 arg
= gimple_call_arg (stmt
, 4);
3429 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
3430 len
= c_strlen (arg
, 1);
3435 if (! integer_all_onesp (size
) && !known_lower (stmt
, len
, size
, true))
3438 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
3439 or if format doesn't contain % chars or is "%s". */
3440 if (! integer_zerop (flag
))
3442 if (fmt_str
== NULL
)
3444 if (strchr (fmt_str
, target_percent
) != NULL
3445 && strcmp (fmt_str
, target_percent_s
))
3449 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
3450 fn
= builtin_decl_explicit (fcode
== BUILT_IN_VSPRINTF_CHK
3451 ? BUILT_IN_VSPRINTF
: BUILT_IN_SPRINTF
);
3455 /* Replace the called function and the first 4 argument by 2 retaining
3456 trailing varargs. */
3457 gimple_call_set_fndecl (stmt
, fn
);
3458 gimple_call_set_fntype (stmt
, TREE_TYPE (fn
));
3459 gimple_call_set_arg (stmt
, 0, dest
);
3460 gimple_call_set_arg (stmt
, 1, fmt
);
3461 for (unsigned i
= 2; i
< gimple_call_num_args (stmt
) - 2; ++i
)
3462 gimple_call_set_arg (stmt
, i
, gimple_call_arg (stmt
, i
+ 2));
3463 gimple_set_num_ops (stmt
, gimple_num_ops (stmt
) - 2);
3468 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
3469 ORIG may be null if this is a 2-argument call. We don't attempt to
3470 simplify calls with more than 3 arguments.
3472 Return true if simplification was possible, otherwise false. */
3475 gimple_fold_builtin_sprintf (gimple_stmt_iterator
*gsi
)
3477 gimple
*stmt
= gsi_stmt (*gsi
);
3479 /* Verify the required arguments in the original call. We deal with two
3480 types of sprintf() calls: 'sprintf (str, fmt)' and
3481 'sprintf (dest, "%s", orig)'. */
3482 if (gimple_call_num_args (stmt
) > 3)
3485 tree orig
= NULL_TREE
;
3486 if (gimple_call_num_args (stmt
) == 3)
3487 orig
= gimple_call_arg (stmt
, 2);
3489 /* Check whether the format is a literal string constant. */
3490 tree fmt
= gimple_call_arg (stmt
, 1);
3491 const char *fmt_str
= c_getstr (fmt
);
3492 if (fmt_str
== NULL
)
3495 tree dest
= gimple_call_arg (stmt
, 0);
3497 if (!init_target_chars ())
3500 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3504 /* If the format doesn't contain % args or %%, use strcpy. */
3505 if (strchr (fmt_str
, target_percent
) == NULL
)
3507 /* Don't optimize sprintf (buf, "abc", ptr++). */
3511 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
3512 'format' is known to contain no % formats. */
3513 gimple_seq stmts
= NULL
;
3514 gimple
*repl
= gimple_build_call (fn
, 2, dest
, fmt
);
3516 /* Propagate the NO_WARNING bit to avoid issuing the same
3517 warning more than once. */
3518 copy_warning (repl
, stmt
);
3520 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3521 if (tree lhs
= gimple_call_lhs (stmt
))
3523 repl
= gimple_build_assign (lhs
, build_int_cst (TREE_TYPE (lhs
),
3525 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3526 gsi_replace_with_seq_vops (gsi
, stmts
);
3527 /* gsi now points at the assignment to the lhs, get a
3528 stmt iterator to the memcpy call.
3529 ??? We can't use gsi_for_stmt as that doesn't work when the
3530 CFG isn't built yet. */
3531 gimple_stmt_iterator gsi2
= *gsi
;
3537 gsi_replace_with_seq_vops (gsi
, stmts
);
3543 /* If the format is "%s", use strcpy if the result isn't used. */
3544 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
3546 /* Don't crash on sprintf (str1, "%s"). */
3550 /* Don't fold calls with source arguments of invalid (nonpointer)
3552 if (!POINTER_TYPE_P (TREE_TYPE (orig
)))
3555 tree orig_len
= NULL_TREE
;
3556 if (gimple_call_lhs (stmt
))
3558 orig_len
= get_maxval_strlen (orig
, SRK_STRLEN
);
3563 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
3564 gimple_seq stmts
= NULL
;
3565 gimple
*repl
= gimple_build_call (fn
, 2, dest
, orig
);
3567 /* Propagate the NO_WARNING bit to avoid issuing the same
3568 warning more than once. */
3569 copy_warning (repl
, stmt
);
3571 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3572 if (tree lhs
= gimple_call_lhs (stmt
))
3574 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
3575 TREE_TYPE (orig_len
)))
3576 orig_len
= fold_convert (TREE_TYPE (lhs
), orig_len
);
3577 repl
= gimple_build_assign (lhs
, orig_len
);
3578 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3579 gsi_replace_with_seq_vops (gsi
, stmts
);
3580 /* gsi now points at the assignment to the lhs, get a
3581 stmt iterator to the memcpy call.
3582 ??? We can't use gsi_for_stmt as that doesn't work when the
3583 CFG isn't built yet. */
3584 gimple_stmt_iterator gsi2
= *gsi
;
3590 gsi_replace_with_seq_vops (gsi
, stmts
);
3598 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
3599 FMT, and ORIG. ORIG may be null if this is a 3-argument call. We don't
3600 attempt to simplify calls with more than 4 arguments.
3602 Return true if simplification was possible, otherwise false. */
3605 gimple_fold_builtin_snprintf (gimple_stmt_iterator
*gsi
)
3607 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3608 tree dest
= gimple_call_arg (stmt
, 0);
3609 tree destsize
= gimple_call_arg (stmt
, 1);
3610 tree fmt
= gimple_call_arg (stmt
, 2);
3611 tree orig
= NULL_TREE
;
3612 const char *fmt_str
= NULL
;
3614 if (gimple_call_num_args (stmt
) > 4)
3617 if (gimple_call_num_args (stmt
) == 4)
3618 orig
= gimple_call_arg (stmt
, 3);
3620 /* Check whether the format is a literal string constant. */
3621 fmt_str
= c_getstr (fmt
);
3622 if (fmt_str
== NULL
)
3625 if (!init_target_chars ())
3628 /* If the format doesn't contain % args or %%, use strcpy. */
3629 if (strchr (fmt_str
, target_percent
) == NULL
)
3631 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3635 /* Don't optimize snprintf (buf, 4, "abc", ptr++). */
3639 tree len
= build_int_cstu (TREE_TYPE (destsize
), strlen (fmt_str
));
3641 /* We could expand this as
3642 memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
3644 memcpy (str, fmt_with_nul_at_cstm1, cst);
3645 but in the former case that might increase code size
3646 and in the latter case grow .rodata section too much.
3648 if (!known_lower (stmt
, len
, destsize
, true))
3651 gimple_seq stmts
= NULL
;
3652 gimple
*repl
= gimple_build_call (fn
, 2, dest
, fmt
);
3653 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3654 if (tree lhs
= gimple_call_lhs (stmt
))
3656 repl
= gimple_build_assign (lhs
,
3657 fold_convert (TREE_TYPE (lhs
), len
));
3658 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3659 gsi_replace_with_seq_vops (gsi
, stmts
);
3660 /* gsi now points at the assignment to the lhs, get a
3661 stmt iterator to the memcpy call.
3662 ??? We can't use gsi_for_stmt as that doesn't work when the
3663 CFG isn't built yet. */
3664 gimple_stmt_iterator gsi2
= *gsi
;
3670 gsi_replace_with_seq_vops (gsi
, stmts
);
3676 /* If the format is "%s", use strcpy if the result isn't used. */
3677 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
3679 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3683 /* Don't crash on snprintf (str1, cst, "%s"). */
3687 tree orig_len
= get_maxval_strlen (orig
, SRK_STRLEN
);
3689 /* We could expand this as
3690 memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
3692 memcpy (str1, str2_with_nul_at_cstm1, cst);
3693 but in the former case that might increase code size
3694 and in the latter case grow .rodata section too much.
3696 if (!known_lower (stmt
, orig_len
, destsize
, true))
3699 /* Convert snprintf (str1, cst, "%s", str2) into
3700 strcpy (str1, str2) if strlen (str2) < cst. */
3701 gimple_seq stmts
= NULL
;
3702 gimple
*repl
= gimple_build_call (fn
, 2, dest
, orig
);
3703 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3704 if (tree lhs
= gimple_call_lhs (stmt
))
3706 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
3707 TREE_TYPE (orig_len
)))
3708 orig_len
= fold_convert (TREE_TYPE (lhs
), orig_len
);
3709 repl
= gimple_build_assign (lhs
, orig_len
);
3710 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3711 gsi_replace_with_seq_vops (gsi
, stmts
);
3712 /* gsi now points at the assignment to the lhs, get a
3713 stmt iterator to the memcpy call.
3714 ??? We can't use gsi_for_stmt as that doesn't work when the
3715 CFG isn't built yet. */
3716 gimple_stmt_iterator gsi2
= *gsi
;
3722 gsi_replace_with_seq_vops (gsi
, stmts
);
3730 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
3731 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
3732 more than 3 arguments, and ARG may be null in the 2-argument case.
3734 Return NULL_TREE if no simplification was possible, otherwise return the
3735 simplified form of the call as a tree. FCODE is the BUILT_IN_*
3736 code of the function to be simplified. */
3739 gimple_fold_builtin_fprintf (gimple_stmt_iterator
*gsi
,
3740 tree fp
, tree fmt
, tree arg
,
3741 enum built_in_function fcode
)
3743 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3744 tree fn_fputc
, fn_fputs
;
3745 const char *fmt_str
= NULL
;
3747 /* If the return value is used, don't do the transformation. */
3748 if (gimple_call_lhs (stmt
) != NULL_TREE
)
3751 /* Check whether the format is a literal string constant. */
3752 fmt_str
= c_getstr (fmt
);
3753 if (fmt_str
== NULL
)
3756 if (fcode
== BUILT_IN_FPRINTF_UNLOCKED
)
3758 /* If we're using an unlocked function, assume the other
3759 unlocked functions exist explicitly. */
3760 fn_fputc
= builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED
);
3761 fn_fputs
= builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED
);
3765 fn_fputc
= builtin_decl_implicit (BUILT_IN_FPUTC
);
3766 fn_fputs
= builtin_decl_implicit (BUILT_IN_FPUTS
);
3769 if (!init_target_chars ())
3772 /* If the format doesn't contain % args or %%, use strcpy. */
3773 if (strchr (fmt_str
, target_percent
) == NULL
)
3775 if (fcode
!= BUILT_IN_VFPRINTF
&& fcode
!= BUILT_IN_VFPRINTF_CHK
3779 /* If the format specifier was "", fprintf does nothing. */
3780 if (fmt_str
[0] == '\0')
3782 replace_call_with_value (gsi
, NULL_TREE
);
3786 /* When "string" doesn't contain %, replace all cases of
3787 fprintf (fp, string) with fputs (string, fp). The fputs
3788 builtin will take care of special cases like length == 1. */
3791 gcall
*repl
= gimple_build_call (fn_fputs
, 2, fmt
, fp
);
3792 replace_call_with_call_and_fold (gsi
, repl
);
3797 /* The other optimizations can be done only on the non-va_list variants. */
3798 else if (fcode
== BUILT_IN_VFPRINTF
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
3801 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
3802 else if (strcmp (fmt_str
, target_percent_s
) == 0)
3804 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
3808 gcall
*repl
= gimple_build_call (fn_fputs
, 2, arg
, fp
);
3809 replace_call_with_call_and_fold (gsi
, repl
);
3814 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
3815 else if (strcmp (fmt_str
, target_percent_c
) == 0)
3818 || ! useless_type_conversion_p (integer_type_node
, TREE_TYPE (arg
)))
3822 gcall
*repl
= gimple_build_call (fn_fputc
, 2, arg
, fp
);
3823 replace_call_with_call_and_fold (gsi
, repl
);
3831 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
3832 FMT and ARG are the arguments to the call; we don't fold cases with
3833 more than 2 arguments, and ARG may be null if this is a 1-argument case.
3835 Return NULL_TREE if no simplification was possible, otherwise return the
3836 simplified form of the call as a tree. FCODE is the BUILT_IN_*
3837 code of the function to be simplified. */
3840 gimple_fold_builtin_printf (gimple_stmt_iterator
*gsi
, tree fmt
,
3841 tree arg
, enum built_in_function fcode
)
3843 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3844 tree fn_putchar
, fn_puts
, newarg
;
3845 const char *fmt_str
= NULL
;
3847 /* If the return value is used, don't do the transformation. */
3848 if (gimple_call_lhs (stmt
) != NULL_TREE
)
3851 /* Check whether the format is a literal string constant. */
3852 fmt_str
= c_getstr (fmt
);
3853 if (fmt_str
== NULL
)
3856 if (fcode
== BUILT_IN_PRINTF_UNLOCKED
)
3858 /* If we're using an unlocked function, assume the other
3859 unlocked functions exist explicitly. */
3860 fn_putchar
= builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED
);
3861 fn_puts
= builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED
);
3865 fn_putchar
= builtin_decl_implicit (BUILT_IN_PUTCHAR
);
3866 fn_puts
= builtin_decl_implicit (BUILT_IN_PUTS
);
3869 if (!init_target_chars ())
3872 if (strcmp (fmt_str
, target_percent_s
) == 0
3873 || strchr (fmt_str
, target_percent
) == NULL
)
3877 if (strcmp (fmt_str
, target_percent_s
) == 0)
3879 if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
3882 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
3885 str
= c_getstr (arg
);
3891 /* The format specifier doesn't contain any '%' characters. */
3892 if (fcode
!= BUILT_IN_VPRINTF
&& fcode
!= BUILT_IN_VPRINTF_CHK
3898 /* If the string was "", printf does nothing. */
3901 replace_call_with_value (gsi
, NULL_TREE
);
3905 /* If the string has length of 1, call putchar. */
3908 /* Given printf("c"), (where c is any one character,)
3909 convert "c"[0] to an int and pass that to the replacement
3911 newarg
= build_int_cst (integer_type_node
, str
[0]);
3914 gcall
*repl
= gimple_build_call (fn_putchar
, 1, newarg
);
3915 replace_call_with_call_and_fold (gsi
, repl
);
3921 /* If the string was "string\n", call puts("string"). */
3922 size_t len
= strlen (str
);
3923 if ((unsigned char)str
[len
- 1] == target_newline
3924 && (size_t) (int) len
== len
3929 /* Create a NUL-terminated string that's one char shorter
3930 than the original, stripping off the trailing '\n'. */
3931 newstr
= xstrdup (str
);
3932 newstr
[len
- 1] = '\0';
3933 newarg
= build_string_literal (len
, newstr
);
3937 gcall
*repl
= gimple_build_call (fn_puts
, 1, newarg
);
3938 replace_call_with_call_and_fold (gsi
, repl
);
3943 /* We'd like to arrange to call fputs(string,stdout) here,
3944 but we need stdout and don't have a way to get it yet. */
3949 /* The other optimizations can be done only on the non-va_list variants. */
3950 else if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
3953 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
3954 else if (strcmp (fmt_str
, target_percent_s_newline
) == 0)
3956 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
3960 gcall
*repl
= gimple_build_call (fn_puts
, 1, arg
);
3961 replace_call_with_call_and_fold (gsi
, repl
);
3966 /* If the format specifier was "%c", call __builtin_putchar(arg). */
3967 else if (strcmp (fmt_str
, target_percent_c
) == 0)
3969 if (!arg
|| ! useless_type_conversion_p (integer_type_node
,
3974 gcall
*repl
= gimple_build_call (fn_putchar
, 1, arg
);
3975 replace_call_with_call_and_fold (gsi
, repl
);
3985 /* Fold a call to __builtin_strlen with known length LEN. */
3988 gimple_fold_builtin_strlen (gimple_stmt_iterator
*gsi
)
3990 gimple
*stmt
= gsi_stmt (*gsi
);
3991 tree arg
= gimple_call_arg (stmt
, 0);
3996 c_strlen_data lendata
= { };
3997 if (get_range_strlen (arg
, &lendata
, /* eltsize = */ 1)
3999 && lendata
.minlen
&& TREE_CODE (lendata
.minlen
) == INTEGER_CST
4000 && lendata
.maxlen
&& TREE_CODE (lendata
.maxlen
) == INTEGER_CST
)
4002 /* The range of lengths refers to either a single constant
4003 string or to the longest and shortest constant string
4004 referenced by the argument of the strlen() call, or to
4005 the strings that can possibly be stored in the arrays
4006 the argument refers to. */
4007 minlen
= wi::to_wide (lendata
.minlen
);
4008 maxlen
= wi::to_wide (lendata
.maxlen
);
4012 unsigned prec
= TYPE_PRECISION (sizetype
);
4014 minlen
= wi::shwi (0, prec
);
4015 maxlen
= wi::to_wide (max_object_size (), prec
) - 2;
4018 if (minlen
== maxlen
)
4020 /* Fold the strlen call to a constant. */
4021 tree type
= TREE_TYPE (lendata
.minlen
);
4022 tree len
= force_gimple_operand_gsi (gsi
,
4023 wide_int_to_tree (type
, minlen
),
4024 true, NULL
, true, GSI_SAME_STMT
);
4025 replace_call_with_value (gsi
, len
);
4029 /* Set the strlen() range to [0, MAXLEN]. */
4030 if (tree lhs
= gimple_call_lhs (stmt
))
4031 set_strlen_range (lhs
, minlen
, maxlen
);
4036 /* Fold a call to __builtin_acc_on_device. */
4039 gimple_fold_builtin_acc_on_device (gimple_stmt_iterator
*gsi
, tree arg0
)
4041 /* Defer folding until we know which compiler we're in. */
4042 if (symtab
->state
!= EXPANSION
)
4045 unsigned val_host
= GOMP_DEVICE_HOST
;
4046 unsigned val_dev
= GOMP_DEVICE_NONE
;
4048 #ifdef ACCEL_COMPILER
4049 val_host
= GOMP_DEVICE_NOT_HOST
;
4050 val_dev
= ACCEL_COMPILER_acc_device
;
4053 location_t loc
= gimple_location (gsi_stmt (*gsi
));
4055 tree host_eq
= make_ssa_name (boolean_type_node
);
4056 gimple
*host_ass
= gimple_build_assign
4057 (host_eq
, EQ_EXPR
, arg0
, build_int_cst (TREE_TYPE (arg0
), val_host
));
4058 gimple_set_location (host_ass
, loc
);
4059 gsi_insert_before (gsi
, host_ass
, GSI_SAME_STMT
);
4061 tree dev_eq
= make_ssa_name (boolean_type_node
);
4062 gimple
*dev_ass
= gimple_build_assign
4063 (dev_eq
, EQ_EXPR
, arg0
, build_int_cst (TREE_TYPE (arg0
), val_dev
));
4064 gimple_set_location (dev_ass
, loc
);
4065 gsi_insert_before (gsi
, dev_ass
, GSI_SAME_STMT
);
4067 tree result
= make_ssa_name (boolean_type_node
);
4068 gimple
*result_ass
= gimple_build_assign
4069 (result
, BIT_IOR_EXPR
, host_eq
, dev_eq
);
4070 gimple_set_location (result_ass
, loc
);
4071 gsi_insert_before (gsi
, result_ass
, GSI_SAME_STMT
);
4073 replace_call_with_value (gsi
, result
);
4078 /* Fold realloc (0, n) -> malloc (n). */
4081 gimple_fold_builtin_realloc (gimple_stmt_iterator
*gsi
)
4083 gimple
*stmt
= gsi_stmt (*gsi
);
4084 tree arg
= gimple_call_arg (stmt
, 0);
4085 tree size
= gimple_call_arg (stmt
, 1);
4087 if (operand_equal_p (arg
, null_pointer_node
, 0))
4089 tree fn_malloc
= builtin_decl_implicit (BUILT_IN_MALLOC
);
4092 gcall
*repl
= gimple_build_call (fn_malloc
, 1, size
);
4093 replace_call_with_call_and_fold (gsi
, repl
);
4100 /* Number of bytes into which any type but aggregate or vector types
4102 static constexpr size_t clear_padding_unit
4103 = MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
;
4104 /* Buffer size on which __builtin_clear_padding folding code works. */
4105 static const size_t clear_padding_buf_size
= 32 * clear_padding_unit
;
4107 /* Data passed through __builtin_clear_padding folding. */
4108 struct clear_padding_struct
{
4110 /* 0 during __builtin_clear_padding folding, nonzero during
4111 clear_type_padding_in_mask. In that case, instead of clearing the
4112 non-padding bits in union_ptr array clear the padding bits in there. */
4116 gimple_stmt_iterator
*gsi
;
4117 /* Alignment of buf->base + 0. */
4119 /* Offset from buf->base. Should be always a multiple of UNITS_PER_WORD. */
4121 /* Number of padding bytes before buf->off that don't have padding clear
4122 code emitted yet. */
4123 HOST_WIDE_INT padding_bytes
;
4124 /* The size of the whole object. Never emit code to touch
4125 buf->base + buf->sz or following bytes. */
4127 /* Number of bytes recorded in buf->buf. */
4129 /* When inside union, instead of emitting code we and bits inside of
4130 the union_ptr array. */
4131 unsigned char *union_ptr
;
4132 /* Set bits mean padding bits that need to be cleared by the builtin. */
4133 unsigned char buf
[clear_padding_buf_size
+ clear_padding_unit
];
4136 /* Emit code to clear padding requested in BUF->buf - set bits
4137 in there stand for padding that should be cleared. FULL is true
4138 if everything from the buffer should be flushed, otherwise
4139 it can leave up to 2 * clear_padding_unit bytes for further
4143 clear_padding_flush (clear_padding_struct
*buf
, bool full
)
4145 gcc_assert ((clear_padding_unit
% UNITS_PER_WORD
) == 0);
4146 if (!full
&& buf
->size
< 2 * clear_padding_unit
)
4148 gcc_assert ((buf
->off
% UNITS_PER_WORD
) == 0);
4149 size_t end
= buf
->size
;
4151 end
= ((end
- clear_padding_unit
- 1) / clear_padding_unit
4152 * clear_padding_unit
);
4153 size_t padding_bytes
= buf
->padding_bytes
;
4156 if (buf
->clear_in_mask
)
4158 /* During clear_type_padding_in_mask, clear the padding
4159 bits set in buf->buf in the buf->union_ptr mask. */
4160 for (size_t i
= 0; i
< end
; i
++)
4162 if (buf
->buf
[i
] == (unsigned char) ~0)
4166 memset (&buf
->union_ptr
[buf
->off
+ i
- padding_bytes
],
4169 buf
->union_ptr
[buf
->off
+ i
] &= ~buf
->buf
[i
];
4174 memset (&buf
->union_ptr
[buf
->off
+ end
- padding_bytes
],
4178 buf
->padding_bytes
= 0;
4182 memmove (buf
->buf
, buf
->buf
+ end
, buf
->size
- end
);
4185 buf
->padding_bytes
= padding_bytes
;
4189 /* Inside of a union, instead of emitting any code, instead
4190 clear all bits in the union_ptr buffer that are clear
4191 in buf. Whole padding bytes don't clear anything. */
4192 for (size_t i
= 0; i
< end
; i
++)
4194 if (buf
->buf
[i
] == (unsigned char) ~0)
4199 buf
->union_ptr
[buf
->off
+ i
] &= buf
->buf
[i
];
4206 buf
->padding_bytes
= 0;
4210 memmove (buf
->buf
, buf
->buf
+ end
, buf
->size
- end
);
4213 buf
->padding_bytes
= padding_bytes
;
4217 size_t wordsize
= UNITS_PER_WORD
;
4218 for (size_t i
= 0; i
< end
; i
+= wordsize
)
4220 size_t nonzero_first
= wordsize
;
4221 size_t nonzero_last
= 0;
4222 size_t zero_first
= wordsize
;
4223 size_t zero_last
= 0;
4224 bool all_ones
= true, bytes_only
= true;
4225 if ((unsigned HOST_WIDE_INT
) (buf
->off
+ i
+ wordsize
)
4226 > (unsigned HOST_WIDE_INT
) buf
->sz
)
4228 gcc_assert (wordsize
> 1);
4233 for (size_t j
= i
; j
< i
+ wordsize
&& j
< end
; j
++)
4237 if (nonzero_first
== wordsize
)
4239 nonzero_first
= j
- i
;
4240 nonzero_last
= j
- i
;
4242 if (nonzero_last
!= j
- i
)
4244 nonzero_last
= j
+ 1 - i
;
4248 if (zero_first
== wordsize
)
4250 zero_last
= j
+ 1 - i
;
4252 if (buf
->buf
[j
] != 0 && buf
->buf
[j
] != (unsigned char) ~0)
4258 size_t padding_end
= i
;
4261 if (nonzero_first
== 0
4262 && nonzero_last
== wordsize
4265 /* All bits are padding and we had some padding
4266 before too. Just extend it. */
4267 padding_bytes
+= wordsize
;
4270 if (all_ones
&& nonzero_first
== 0)
4272 padding_bytes
+= nonzero_last
;
4273 padding_end
+= nonzero_last
;
4274 nonzero_first
= wordsize
;
4277 else if (bytes_only
&& nonzero_first
== 0)
4279 gcc_assert (zero_first
&& zero_first
!= wordsize
);
4280 padding_bytes
+= zero_first
;
4281 padding_end
+= zero_first
;
4284 if (padding_bytes
== 1)
4286 atype
= char_type_node
;
4287 src
= build_zero_cst (char_type_node
);
4291 atype
= build_array_type_nelts (char_type_node
, padding_bytes
);
4292 src
= build_constructor (atype
, NULL
);
4294 tree dst
= build2_loc (buf
->loc
, MEM_REF
, atype
, buf
->base
,
4295 build_int_cst (buf
->alias_type
,
4296 buf
->off
+ padding_end
4298 gimple
*g
= gimple_build_assign (dst
, src
);
4299 gimple_set_location (g
, buf
->loc
);
4300 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4302 buf
->padding_bytes
= 0;
4304 if (nonzero_first
== wordsize
)
4305 /* All bits in a word are 0, there are no padding bits. */
4307 if (all_ones
&& nonzero_last
== wordsize
)
4309 /* All bits between nonzero_first and end of word are padding
4310 bits, start counting padding_bytes. */
4311 padding_bytes
= nonzero_last
- nonzero_first
;
4316 /* If bitfields aren't involved in this word, prefer storing
4317 individual bytes or groups of them over performing a RMW
4318 operation on the whole word. */
4319 gcc_assert (i
+ zero_last
<= end
);
4320 for (size_t j
= padding_end
; j
< i
+ zero_last
; j
++)
4325 for (k
= j
; k
< i
+ zero_last
; k
++)
4326 if (buf
->buf
[k
] == 0)
4328 HOST_WIDE_INT off
= buf
->off
+ j
;
4332 atype
= char_type_node
;
4333 src
= build_zero_cst (char_type_node
);
4337 atype
= build_array_type_nelts (char_type_node
, k
- j
);
4338 src
= build_constructor (atype
, NULL
);
4340 tree dst
= build2_loc (buf
->loc
, MEM_REF
, atype
,
4342 build_int_cst (buf
->alias_type
, off
));
4343 gimple
*g
= gimple_build_assign (dst
, src
);
4344 gimple_set_location (g
, buf
->loc
);
4345 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4349 if (nonzero_last
== wordsize
)
4350 padding_bytes
= nonzero_last
- zero_last
;
4353 for (size_t eltsz
= 1; eltsz
<= wordsize
; eltsz
<<= 1)
4355 if (nonzero_last
- nonzero_first
<= eltsz
4356 && ((nonzero_first
& ~(eltsz
- 1))
4357 == ((nonzero_last
- 1) & ~(eltsz
- 1))))
4361 type
= char_type_node
;
4363 type
= lang_hooks
.types
.type_for_size (eltsz
* BITS_PER_UNIT
,
4365 size_t start
= nonzero_first
& ~(eltsz
- 1);
4366 HOST_WIDE_INT off
= buf
->off
+ i
+ start
;
4368 if (eltsz
> 1 && buf
->align
< TYPE_ALIGN (type
))
4369 atype
= build_aligned_type (type
, buf
->align
);
4370 tree dst
= build2_loc (buf
->loc
, MEM_REF
, atype
, buf
->base
,
4371 build_int_cst (buf
->alias_type
, off
));
4375 && nonzero_first
== start
4376 && nonzero_last
== start
+ eltsz
)
4377 src
= build_zero_cst (type
);
4380 src
= make_ssa_name (type
);
4381 g
= gimple_build_assign (src
, unshare_expr (dst
));
4382 gimple_set_location (g
, buf
->loc
);
4383 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4384 tree mask
= native_interpret_expr (type
,
4385 buf
->buf
+ i
+ start
,
4387 gcc_assert (mask
&& TREE_CODE (mask
) == INTEGER_CST
);
4388 mask
= fold_build1 (BIT_NOT_EXPR
, type
, mask
);
4389 tree src_masked
= make_ssa_name (type
);
4390 g
= gimple_build_assign (src_masked
, BIT_AND_EXPR
,
4392 gimple_set_location (g
, buf
->loc
);
4393 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4396 g
= gimple_build_assign (dst
, src
);
4397 gimple_set_location (g
, buf
->loc
);
4398 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4408 if (padding_bytes
== 1)
4410 atype
= char_type_node
;
4411 src
= build_zero_cst (char_type_node
);
4415 atype
= build_array_type_nelts (char_type_node
, padding_bytes
);
4416 src
= build_constructor (atype
, NULL
);
4418 tree dst
= build2_loc (buf
->loc
, MEM_REF
, atype
, buf
->base
,
4419 build_int_cst (buf
->alias_type
,
4422 gimple
*g
= gimple_build_assign (dst
, src
);
4423 gimple_set_location (g
, buf
->loc
);
4424 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4426 size_t end_rem
= end
% UNITS_PER_WORD
;
4427 buf
->off
+= end
- end_rem
;
4428 buf
->size
= end_rem
;
4429 memset (buf
->buf
, 0, buf
->size
);
4430 buf
->padding_bytes
= 0;
4434 memmove (buf
->buf
, buf
->buf
+ end
, buf
->size
- end
);
4437 buf
->padding_bytes
= padding_bytes
;
4441 /* Append PADDING_BYTES padding bytes. */
4444 clear_padding_add_padding (clear_padding_struct
*buf
,
4445 HOST_WIDE_INT padding_bytes
)
4447 if (padding_bytes
== 0)
4449 if ((unsigned HOST_WIDE_INT
) padding_bytes
+ buf
->size
4450 > (unsigned HOST_WIDE_INT
) clear_padding_buf_size
)
4451 clear_padding_flush (buf
, false);
4452 if ((unsigned HOST_WIDE_INT
) padding_bytes
+ buf
->size
4453 > (unsigned HOST_WIDE_INT
) clear_padding_buf_size
)
4455 memset (buf
->buf
+ buf
->size
, ~0, clear_padding_buf_size
- buf
->size
);
4456 padding_bytes
-= clear_padding_buf_size
- buf
->size
;
4457 buf
->size
= clear_padding_buf_size
;
4458 clear_padding_flush (buf
, false);
4459 gcc_assert (buf
->padding_bytes
);
4460 /* At this point buf->buf[0] through buf->buf[buf->size - 1]
4461 is guaranteed to be all ones. */
4462 padding_bytes
+= buf
->size
;
4463 buf
->size
= padding_bytes
% UNITS_PER_WORD
;
4464 memset (buf
->buf
, ~0, buf
->size
);
4465 buf
->off
+= padding_bytes
- buf
->size
;
4466 buf
->padding_bytes
+= padding_bytes
- buf
->size
;
4470 memset (buf
->buf
+ buf
->size
, ~0, padding_bytes
);
4471 buf
->size
+= padding_bytes
;
4475 static void clear_padding_type (clear_padding_struct
*, tree
,
4476 HOST_WIDE_INT
, bool);
4478 /* Clear padding bits of union type TYPE. */
4481 clear_padding_union (clear_padding_struct
*buf
, tree type
,
4482 HOST_WIDE_INT sz
, bool for_auto_init
)
4484 clear_padding_struct
*union_buf
;
4485 HOST_WIDE_INT start_off
= 0, next_off
= 0;
4486 size_t start_size
= 0;
4489 start_off
= buf
->off
+ buf
->size
;
4490 next_off
= start_off
+ sz
;
4491 start_size
= start_off
% UNITS_PER_WORD
;
4492 start_off
-= start_size
;
4493 clear_padding_flush (buf
, true);
4498 if (sz
+ buf
->size
> clear_padding_buf_size
)
4499 clear_padding_flush (buf
, false);
4500 union_buf
= XALLOCA (clear_padding_struct
);
4501 union_buf
->loc
= buf
->loc
;
4502 union_buf
->clear_in_mask
= buf
->clear_in_mask
;
4503 union_buf
->base
= NULL_TREE
;
4504 union_buf
->alias_type
= NULL_TREE
;
4505 union_buf
->gsi
= NULL
;
4506 union_buf
->align
= 0;
4508 union_buf
->padding_bytes
= 0;
4510 union_buf
->size
= 0;
4511 if (sz
+ buf
->size
<= clear_padding_buf_size
)
4512 union_buf
->union_ptr
= buf
->buf
+ buf
->size
;
4514 union_buf
->union_ptr
= XNEWVEC (unsigned char, sz
);
4515 memset (union_buf
->union_ptr
, ~0, sz
);
4518 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
4519 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_PADDING_P (field
))
4521 if (DECL_SIZE_UNIT (field
) == NULL_TREE
)
4523 if (TREE_TYPE (field
) == error_mark_node
)
4525 gcc_assert (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
4526 && !COMPLETE_TYPE_P (TREE_TYPE (field
)));
4527 if (!buf
->clear_in_mask
&& !for_auto_init
)
4528 error_at (buf
->loc
, "flexible array member %qD does not have "
4529 "well defined padding bits for %qs",
4530 field
, "__builtin_clear_padding");
4533 HOST_WIDE_INT fldsz
= tree_to_shwi (DECL_SIZE_UNIT (field
));
4534 gcc_assert (union_buf
->size
== 0);
4535 union_buf
->off
= start_off
;
4536 union_buf
->size
= start_size
;
4537 memset (union_buf
->buf
, ~0, start_size
);
4538 clear_padding_type (union_buf
, TREE_TYPE (field
), fldsz
, for_auto_init
);
4539 clear_padding_add_padding (union_buf
, sz
- fldsz
);
4540 clear_padding_flush (union_buf
, true);
4543 if (buf
== union_buf
)
4545 buf
->off
= next_off
;
4546 buf
->size
= next_off
% UNITS_PER_WORD
;
4547 buf
->off
-= buf
->size
;
4548 memset (buf
->buf
, ~0, buf
->size
);
4550 else if (sz
+ buf
->size
<= clear_padding_buf_size
)
4554 unsigned char *union_ptr
= union_buf
->union_ptr
;
4557 clear_padding_flush (buf
, false);
4558 HOST_WIDE_INT this_sz
4559 = MIN ((unsigned HOST_WIDE_INT
) sz
,
4560 clear_padding_buf_size
- buf
->size
);
4561 memcpy (buf
->buf
+ buf
->size
, union_ptr
, this_sz
);
4562 buf
->size
+= this_sz
;
4563 union_ptr
+= this_sz
;
4566 XDELETE (union_buf
->union_ptr
);
4570 /* The only known floating point formats with padding bits are the
4571 IEEE extended ones. */
4574 clear_padding_real_needs_padding_p (tree type
)
4576 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
4578 && fmt
->signbit_ro
== fmt
->signbit_rw
4579 && (fmt
->signbit_ro
== 79 || fmt
->signbit_ro
== 95));
4582 /* Return true if TYPE might contain any padding bits. */
4585 clear_padding_type_may_have_padding_p (tree type
)
4587 switch (TREE_CODE (type
))
4595 return clear_padding_type_may_have_padding_p (TREE_TYPE (type
));
4597 return clear_padding_real_needs_padding_p (type
);
4603 /* Emit a runtime loop:
4604 for (; buf.base != end; buf.base += sz)
4605 __builtin_clear_padding (buf.base); */
4608 clear_padding_emit_loop (clear_padding_struct
*buf
, tree type
,
4609 tree end
, bool for_auto_init
)
4611 tree l1
= create_artificial_label (buf
->loc
);
4612 tree l2
= create_artificial_label (buf
->loc
);
4613 tree l3
= create_artificial_label (buf
->loc
);
4614 gimple
*g
= gimple_build_goto (l2
);
4615 gimple_set_location (g
, buf
->loc
);
4616 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4617 g
= gimple_build_label (l1
);
4618 gimple_set_location (g
, buf
->loc
);
4619 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4620 clear_padding_type (buf
, type
, buf
->sz
, for_auto_init
);
4621 clear_padding_flush (buf
, true);
4622 g
= gimple_build_assign (buf
->base
, POINTER_PLUS_EXPR
, buf
->base
,
4623 size_int (buf
->sz
));
4624 gimple_set_location (g
, buf
->loc
);
4625 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4626 g
= gimple_build_label (l2
);
4627 gimple_set_location (g
, buf
->loc
);
4628 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4629 g
= gimple_build_cond (NE_EXPR
, buf
->base
, end
, l1
, l3
);
4630 gimple_set_location (g
, buf
->loc
);
4631 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4632 g
= gimple_build_label (l3
);
4633 gimple_set_location (g
, buf
->loc
);
4634 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4637 /* Clear padding bits for TYPE. Called recursively from
4638 gimple_fold_builtin_clear_padding. If FOR_AUTO_INIT is true,
4639 the __builtin_clear_padding is not called by the end user,
4640 instead, it's inserted by the compiler to initialize the
4641 paddings of automatic variable. Therefore, we should not
4642 emit the error messages for flexible array members to confuse
4646 clear_padding_type (clear_padding_struct
*buf
, tree type
,
4647 HOST_WIDE_INT sz
, bool for_auto_init
)
4649 switch (TREE_CODE (type
))
4652 HOST_WIDE_INT cur_pos
;
4654 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
4655 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_PADDING_P (field
))
4657 tree ftype
= TREE_TYPE (field
);
4658 if (DECL_BIT_FIELD (field
))
4660 HOST_WIDE_INT fldsz
= TYPE_PRECISION (ftype
);
4663 HOST_WIDE_INT pos
= int_byte_position (field
);
4667 = tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
));
4668 bpos
%= BITS_PER_UNIT
;
4670 = ROUND_UP (bpos
+ fldsz
, BITS_PER_UNIT
) / BITS_PER_UNIT
;
4671 if (pos
+ end
> cur_pos
)
4673 clear_padding_add_padding (buf
, pos
+ end
- cur_pos
);
4674 cur_pos
= pos
+ end
;
4676 gcc_assert (cur_pos
> pos
4677 && ((unsigned HOST_WIDE_INT
) buf
->size
4678 >= (unsigned HOST_WIDE_INT
) cur_pos
- pos
));
4679 unsigned char *p
= buf
->buf
+ buf
->size
- (cur_pos
- pos
);
4680 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
)
4681 sorry_at (buf
->loc
, "PDP11 bit-field handling unsupported"
4682 " in %qs", "__builtin_clear_padding");
4683 else if (BYTES_BIG_ENDIAN
)
4686 if (bpos
+ fldsz
<= BITS_PER_UNIT
)
4687 *p
&= ~(((1 << fldsz
) - 1)
4688 << (BITS_PER_UNIT
- bpos
- fldsz
));
4693 *p
&= ~(((1U << BITS_PER_UNIT
) - 1) >> bpos
);
4695 fldsz
-= BITS_PER_UNIT
- bpos
;
4697 memset (p
, 0, fldsz
/ BITS_PER_UNIT
);
4698 p
+= fldsz
/ BITS_PER_UNIT
;
4699 fldsz
%= BITS_PER_UNIT
;
4701 *p
&= ((1U << BITS_PER_UNIT
) - 1) >> fldsz
;
4706 /* Little endian. */
4707 if (bpos
+ fldsz
<= BITS_PER_UNIT
)
4708 *p
&= ~(((1 << fldsz
) - 1) << bpos
);
4713 *p
&= ~(((1 << BITS_PER_UNIT
) - 1) << bpos
);
4715 fldsz
-= BITS_PER_UNIT
- bpos
;
4717 memset (p
, 0, fldsz
/ BITS_PER_UNIT
);
4718 p
+= fldsz
/ BITS_PER_UNIT
;
4719 fldsz
%= BITS_PER_UNIT
;
4721 *p
&= ~((1 << fldsz
) - 1);
4725 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
)
4727 if (ftype
== error_mark_node
)
4729 gcc_assert (TREE_CODE (ftype
) == ARRAY_TYPE
4730 && !COMPLETE_TYPE_P (ftype
));
4731 if (!buf
->clear_in_mask
&& !for_auto_init
)
4732 error_at (buf
->loc
, "flexible array member %qD does not "
4733 "have well defined padding bits for %qs",
4734 field
, "__builtin_clear_padding");
4736 else if (is_empty_type (TREE_TYPE (field
)))
4740 HOST_WIDE_INT pos
= int_byte_position (field
);
4743 HOST_WIDE_INT fldsz
= tree_to_shwi (DECL_SIZE_UNIT (field
));
4744 gcc_assert (pos
>= 0 && fldsz
>= 0 && pos
>= cur_pos
);
4745 clear_padding_add_padding (buf
, pos
- cur_pos
);
4747 clear_padding_type (buf
, TREE_TYPE (field
),
4748 fldsz
, for_auto_init
);
4752 gcc_assert (sz
>= cur_pos
);
4753 clear_padding_add_padding (buf
, sz
- cur_pos
);
4756 HOST_WIDE_INT nelts
, fldsz
;
4757 fldsz
= int_size_in_bytes (TREE_TYPE (type
));
4762 && sz
> 8 * UNITS_PER_WORD
4763 && buf
->union_ptr
== NULL
4764 && clear_padding_type_may_have_padding_p (TREE_TYPE (type
)))
4766 /* For sufficiently large array of more than one elements,
4767 emit a runtime loop to keep code size manageable. */
4768 tree base
= buf
->base
;
4769 unsigned int prev_align
= buf
->align
;
4770 HOST_WIDE_INT off
= buf
->off
+ buf
->size
;
4771 HOST_WIDE_INT prev_sz
= buf
->sz
;
4772 clear_padding_flush (buf
, true);
4773 tree elttype
= TREE_TYPE (type
);
4774 buf
->base
= create_tmp_var (build_pointer_type (elttype
));
4775 tree end
= make_ssa_name (TREE_TYPE (buf
->base
));
4776 gimple
*g
= gimple_build_assign (buf
->base
, POINTER_PLUS_EXPR
,
4777 base
, size_int (off
));
4778 gimple_set_location (g
, buf
->loc
);
4779 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4780 g
= gimple_build_assign (end
, POINTER_PLUS_EXPR
, buf
->base
,
4782 gimple_set_location (g
, buf
->loc
);
4783 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4785 buf
->align
= TYPE_ALIGN (elttype
);
4788 clear_padding_emit_loop (buf
, elttype
, end
, for_auto_init
);
4791 buf
->align
= prev_align
;
4792 buf
->size
= off
% UNITS_PER_WORD
;
4793 buf
->off
= off
- buf
->size
;
4794 memset (buf
->buf
, 0, buf
->size
);
4797 for (HOST_WIDE_INT i
= 0; i
< nelts
; i
++)
4798 clear_padding_type (buf
, TREE_TYPE (type
), fldsz
, for_auto_init
);
4801 clear_padding_union (buf
, type
, sz
, for_auto_init
);
4804 gcc_assert ((size_t) sz
<= clear_padding_unit
);
4805 if ((unsigned HOST_WIDE_INT
) sz
+ buf
->size
> clear_padding_buf_size
)
4806 clear_padding_flush (buf
, false);
4807 if (clear_padding_real_needs_padding_p (type
))
4809 /* Use native_interpret_expr + native_encode_expr to figure out
4810 which bits are padding. */
4811 memset (buf
->buf
+ buf
->size
, ~0, sz
);
4812 tree cst
= native_interpret_expr (type
, buf
->buf
+ buf
->size
, sz
);
4813 gcc_assert (cst
&& TREE_CODE (cst
) == REAL_CST
);
4814 int len
= native_encode_expr (cst
, buf
->buf
+ buf
->size
, sz
);
4815 gcc_assert (len
> 0 && (size_t) len
== (size_t) sz
);
4816 for (size_t i
= 0; i
< (size_t) sz
; i
++)
4817 buf
->buf
[buf
->size
+ i
] ^= ~0;
4820 memset (buf
->buf
+ buf
->size
, 0, sz
);
4824 fldsz
= int_size_in_bytes (TREE_TYPE (type
));
4825 clear_padding_type (buf
, TREE_TYPE (type
), fldsz
, for_auto_init
);
4826 clear_padding_type (buf
, TREE_TYPE (type
), fldsz
, for_auto_init
);
4829 nelts
= TYPE_VECTOR_SUBPARTS (type
).to_constant ();
4830 fldsz
= int_size_in_bytes (TREE_TYPE (type
));
4831 for (HOST_WIDE_INT i
= 0; i
< nelts
; i
++)
4832 clear_padding_type (buf
, TREE_TYPE (type
), fldsz
, for_auto_init
);
4835 gcc_assert ((size_t) sz
<= clear_padding_unit
);
4836 if ((unsigned HOST_WIDE_INT
) sz
+ buf
->size
> clear_padding_buf_size
)
4837 clear_padding_flush (buf
, false);
4838 memset (buf
->buf
+ buf
->size
, ~0, sz
);
4842 gcc_assert ((size_t) sz
<= clear_padding_unit
);
4843 if ((unsigned HOST_WIDE_INT
) sz
+ buf
->size
> clear_padding_buf_size
)
4844 clear_padding_flush (buf
, false);
4845 memset (buf
->buf
+ buf
->size
, 0, sz
);
4851 /* Clear padding bits of TYPE in MASK. */
4854 clear_type_padding_in_mask (tree type
, unsigned char *mask
)
4856 clear_padding_struct buf
;
4857 buf
.loc
= UNKNOWN_LOCATION
;
4858 buf
.clear_in_mask
= true;
4859 buf
.base
= NULL_TREE
;
4860 buf
.alias_type
= NULL_TREE
;
4864 buf
.padding_bytes
= 0;
4865 buf
.sz
= int_size_in_bytes (type
);
4867 buf
.union_ptr
= mask
;
4868 clear_padding_type (&buf
, type
, buf
.sz
, false);
4869 clear_padding_flush (&buf
, true);
4872 /* Fold __builtin_clear_padding builtin. */
4875 gimple_fold_builtin_clear_padding (gimple_stmt_iterator
*gsi
)
4877 gimple
*stmt
= gsi_stmt (*gsi
);
4878 gcc_assert (gimple_call_num_args (stmt
) == 3);
4879 tree ptr
= gimple_call_arg (stmt
, 0);
4880 tree typearg
= gimple_call_arg (stmt
, 1);
4881 /* the 3rd argument of __builtin_clear_padding is to distinguish whether
4882 this call is made by the user or by the compiler for automatic variable
4884 bool for_auto_init
= (bool) TREE_INT_CST_LOW (gimple_call_arg (stmt
, 2));
4885 tree type
= TREE_TYPE (TREE_TYPE (typearg
));
4886 location_t loc
= gimple_location (stmt
);
4887 clear_padding_struct buf
;
4888 gimple_stmt_iterator gsiprev
= *gsi
;
4889 /* This should be folded during the lower pass. */
4890 gcc_assert (!gimple_in_ssa_p (cfun
) && cfun
->cfg
== NULL
);
4891 gcc_assert (COMPLETE_TYPE_P (type
));
4892 gsi_prev (&gsiprev
);
4895 buf
.clear_in_mask
= false;
4897 buf
.alias_type
= NULL_TREE
;
4899 buf
.align
= get_pointer_alignment (ptr
);
4900 unsigned int talign
= min_align_of_type (type
) * BITS_PER_UNIT
;
4901 buf
.align
= MAX (buf
.align
, talign
);
4903 buf
.padding_bytes
= 0;
4905 buf
.sz
= int_size_in_bytes (type
);
4906 buf
.union_ptr
= NULL
;
4907 if (buf
.sz
< 0 && int_size_in_bytes (strip_array_types (type
)) < 0)
4908 sorry_at (loc
, "%s not supported for variable length aggregates",
4909 "__builtin_clear_padding");
4910 /* The implementation currently assumes 8-bit host and target
4911 chars which is the case for all currently supported targets
4912 and hosts and is required e.g. for native_{encode,interpret}* APIs. */
4913 else if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
4914 sorry_at (loc
, "%s not supported on this target",
4915 "__builtin_clear_padding");
4916 else if (!clear_padding_type_may_have_padding_p (type
))
4918 else if (TREE_CODE (type
) == ARRAY_TYPE
&& buf
.sz
< 0)
4920 tree sz
= TYPE_SIZE_UNIT (type
);
4921 tree elttype
= type
;
4922 /* Only supports C/C++ VLAs and flattens all the VLA levels. */
4923 while (TREE_CODE (elttype
) == ARRAY_TYPE
4924 && int_size_in_bytes (elttype
) < 0)
4925 elttype
= TREE_TYPE (elttype
);
4926 HOST_WIDE_INT eltsz
= int_size_in_bytes (elttype
);
4927 gcc_assert (eltsz
>= 0);
4930 buf
.base
= create_tmp_var (build_pointer_type (elttype
));
4931 tree end
= make_ssa_name (TREE_TYPE (buf
.base
));
4932 gimple
*g
= gimple_build_assign (buf
.base
, ptr
);
4933 gimple_set_location (g
, loc
);
4934 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
4935 g
= gimple_build_assign (end
, POINTER_PLUS_EXPR
, buf
.base
, sz
);
4936 gimple_set_location (g
, loc
);
4937 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
4939 buf
.align
= TYPE_ALIGN (elttype
);
4940 buf
.alias_type
= build_pointer_type (elttype
);
4941 clear_padding_emit_loop (&buf
, elttype
, end
, for_auto_init
);
4946 if (!is_gimple_mem_ref_addr (buf
.base
))
4948 buf
.base
= make_ssa_name (TREE_TYPE (ptr
));
4949 gimple
*g
= gimple_build_assign (buf
.base
, ptr
);
4950 gimple_set_location (g
, loc
);
4951 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
4953 buf
.alias_type
= build_pointer_type (type
);
4954 clear_padding_type (&buf
, type
, buf
.sz
, for_auto_init
);
4955 clear_padding_flush (&buf
, true);
4958 gimple_stmt_iterator gsiprev2
= *gsi
;
4959 gsi_prev (&gsiprev2
);
4960 if (gsi_stmt (gsiprev
) == gsi_stmt (gsiprev2
))
4961 gsi_replace (gsi
, gimple_build_nop (), true);
4964 gsi_remove (gsi
, true);
4970 /* Fold the non-target builtin at *GSI and return whether any simplification
4974 gimple_fold_builtin (gimple_stmt_iterator
*gsi
)
4976 gcall
*stmt
= as_a
<gcall
*>(gsi_stmt (*gsi
));
4977 tree callee
= gimple_call_fndecl (stmt
);
4979 /* Give up for always_inline inline builtins until they are
4981 if (avoid_folding_inline_builtin (callee
))
4984 unsigned n
= gimple_call_num_args (stmt
);
4985 enum built_in_function fcode
= DECL_FUNCTION_CODE (callee
);
4989 return gimple_fold_builtin_bcmp (gsi
);
4990 case BUILT_IN_BCOPY
:
4991 return gimple_fold_builtin_bcopy (gsi
);
4992 case BUILT_IN_BZERO
:
4993 return gimple_fold_builtin_bzero (gsi
);
4995 case BUILT_IN_MEMSET
:
4996 return gimple_fold_builtin_memset (gsi
,
4997 gimple_call_arg (stmt
, 1),
4998 gimple_call_arg (stmt
, 2));
4999 case BUILT_IN_MEMCPY
:
5000 case BUILT_IN_MEMPCPY
:
5001 case BUILT_IN_MEMMOVE
:
5002 return gimple_fold_builtin_memory_op (gsi
, gimple_call_arg (stmt
, 0),
5003 gimple_call_arg (stmt
, 1), fcode
);
5004 case BUILT_IN_SPRINTF_CHK
:
5005 case BUILT_IN_VSPRINTF_CHK
:
5006 return gimple_fold_builtin_sprintf_chk (gsi
, fcode
);
5007 case BUILT_IN_STRCAT_CHK
:
5008 return gimple_fold_builtin_strcat_chk (gsi
);
5009 case BUILT_IN_STRNCAT_CHK
:
5010 return gimple_fold_builtin_strncat_chk (gsi
);
5011 case BUILT_IN_STRLEN
:
5012 return gimple_fold_builtin_strlen (gsi
);
5013 case BUILT_IN_STRCPY
:
5014 return gimple_fold_builtin_strcpy (gsi
,
5015 gimple_call_arg (stmt
, 0),
5016 gimple_call_arg (stmt
, 1));
5017 case BUILT_IN_STRNCPY
:
5018 return gimple_fold_builtin_strncpy (gsi
,
5019 gimple_call_arg (stmt
, 0),
5020 gimple_call_arg (stmt
, 1),
5021 gimple_call_arg (stmt
, 2));
5022 case BUILT_IN_STRCAT
:
5023 return gimple_fold_builtin_strcat (gsi
, gimple_call_arg (stmt
, 0),
5024 gimple_call_arg (stmt
, 1));
5025 case BUILT_IN_STRNCAT
:
5026 return gimple_fold_builtin_strncat (gsi
);
5027 case BUILT_IN_INDEX
:
5028 case BUILT_IN_STRCHR
:
5029 return gimple_fold_builtin_strchr (gsi
, false);
5030 case BUILT_IN_RINDEX
:
5031 case BUILT_IN_STRRCHR
:
5032 return gimple_fold_builtin_strchr (gsi
, true);
5033 case BUILT_IN_STRSTR
:
5034 return gimple_fold_builtin_strstr (gsi
);
5035 case BUILT_IN_STRCMP
:
5036 case BUILT_IN_STRCMP_EQ
:
5037 case BUILT_IN_STRCASECMP
:
5038 case BUILT_IN_STRNCMP
:
5039 case BUILT_IN_STRNCMP_EQ
:
5040 case BUILT_IN_STRNCASECMP
:
5041 return gimple_fold_builtin_string_compare (gsi
);
5042 case BUILT_IN_MEMCHR
:
5043 return gimple_fold_builtin_memchr (gsi
);
5044 case BUILT_IN_FPUTS
:
5045 return gimple_fold_builtin_fputs (gsi
, gimple_call_arg (stmt
, 0),
5046 gimple_call_arg (stmt
, 1), false);
5047 case BUILT_IN_FPUTS_UNLOCKED
:
5048 return gimple_fold_builtin_fputs (gsi
, gimple_call_arg (stmt
, 0),
5049 gimple_call_arg (stmt
, 1), true);
5050 case BUILT_IN_MEMCPY_CHK
:
5051 case BUILT_IN_MEMPCPY_CHK
:
5052 case BUILT_IN_MEMMOVE_CHK
:
5053 case BUILT_IN_MEMSET_CHK
:
5054 return gimple_fold_builtin_memory_chk (gsi
,
5055 gimple_call_arg (stmt
, 0),
5056 gimple_call_arg (stmt
, 1),
5057 gimple_call_arg (stmt
, 2),
5058 gimple_call_arg (stmt
, 3),
5060 case BUILT_IN_STPCPY
:
5061 return gimple_fold_builtin_stpcpy (gsi
);
5062 case BUILT_IN_STRCPY_CHK
:
5063 case BUILT_IN_STPCPY_CHK
:
5064 return gimple_fold_builtin_stxcpy_chk (gsi
,
5065 gimple_call_arg (stmt
, 0),
5066 gimple_call_arg (stmt
, 1),
5067 gimple_call_arg (stmt
, 2),
5069 case BUILT_IN_STRNCPY_CHK
:
5070 case BUILT_IN_STPNCPY_CHK
:
5071 return gimple_fold_builtin_stxncpy_chk (gsi
,
5072 gimple_call_arg (stmt
, 0),
5073 gimple_call_arg (stmt
, 1),
5074 gimple_call_arg (stmt
, 2),
5075 gimple_call_arg (stmt
, 3),
5077 case BUILT_IN_SNPRINTF_CHK
:
5078 case BUILT_IN_VSNPRINTF_CHK
:
5079 return gimple_fold_builtin_snprintf_chk (gsi
, fcode
);
5081 case BUILT_IN_FPRINTF
:
5082 case BUILT_IN_FPRINTF_UNLOCKED
:
5083 case BUILT_IN_VFPRINTF
:
5084 if (n
== 2 || n
== 3)
5085 return gimple_fold_builtin_fprintf (gsi
,
5086 gimple_call_arg (stmt
, 0),
5087 gimple_call_arg (stmt
, 1),
5089 ? gimple_call_arg (stmt
, 2)
5093 case BUILT_IN_FPRINTF_CHK
:
5094 case BUILT_IN_VFPRINTF_CHK
:
5095 if (n
== 3 || n
== 4)
5096 return gimple_fold_builtin_fprintf (gsi
,
5097 gimple_call_arg (stmt
, 0),
5098 gimple_call_arg (stmt
, 2),
5100 ? gimple_call_arg (stmt
, 3)
5104 case BUILT_IN_PRINTF
:
5105 case BUILT_IN_PRINTF_UNLOCKED
:
5106 case BUILT_IN_VPRINTF
:
5107 if (n
== 1 || n
== 2)
5108 return gimple_fold_builtin_printf (gsi
, gimple_call_arg (stmt
, 0),
5110 ? gimple_call_arg (stmt
, 1)
5111 : NULL_TREE
, fcode
);
5113 case BUILT_IN_PRINTF_CHK
:
5114 case BUILT_IN_VPRINTF_CHK
:
5115 if (n
== 2 || n
== 3)
5116 return gimple_fold_builtin_printf (gsi
, gimple_call_arg (stmt
, 1),
5118 ? gimple_call_arg (stmt
, 2)
5119 : NULL_TREE
, fcode
);
5121 case BUILT_IN_ACC_ON_DEVICE
:
5122 return gimple_fold_builtin_acc_on_device (gsi
,
5123 gimple_call_arg (stmt
, 0));
5124 case BUILT_IN_REALLOC
:
5125 return gimple_fold_builtin_realloc (gsi
);
5127 case BUILT_IN_CLEAR_PADDING
:
5128 return gimple_fold_builtin_clear_padding (gsi
);
5133 /* Try the generic builtin folder. */
5134 bool ignore
= (gimple_call_lhs (stmt
) == NULL
);
5135 tree result
= fold_call_stmt (stmt
, ignore
);
5139 STRIP_NOPS (result
);
5141 result
= fold_convert (gimple_call_return_type (stmt
), result
);
5142 gimplify_and_update_call_from_tree (gsi
, result
);
5149 /* Transform IFN_GOACC_DIM_SIZE and IFN_GOACC_DIM_POS internal
5150 function calls to constants, where possible. */
5153 fold_internal_goacc_dim (const gimple
*call
)
5155 int axis
= oacc_get_ifn_dim_arg (call
);
5156 int size
= oacc_get_fn_dim_size (current_function_decl
, axis
);
5157 tree result
= NULL_TREE
;
5158 tree type
= TREE_TYPE (gimple_call_lhs (call
));
5160 switch (gimple_call_internal_fn (call
))
5162 case IFN_GOACC_DIM_POS
:
5163 /* If the size is 1, we know the answer. */
5165 result
= build_int_cst (type
, 0);
5167 case IFN_GOACC_DIM_SIZE
:
5168 /* If the size is not dynamic, we know the answer. */
5170 result
= build_int_cst (type
, size
);
5179 /* Return true if stmt is __atomic_compare_exchange_N call which is suitable
5180 for conversion into ATOMIC_COMPARE_EXCHANGE if the second argument is
5181 &var where var is only addressable because of such calls. */
5184 optimize_atomic_compare_exchange_p (gimple
*stmt
)
5186 if (gimple_call_num_args (stmt
) != 6
5187 || !flag_inline_atomics
5189 || sanitize_flags_p (SANITIZE_THREAD
| SANITIZE_ADDRESS
)
5190 || !gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
)
5191 || !gimple_vdef (stmt
)
5192 || !gimple_vuse (stmt
))
5195 tree fndecl
= gimple_call_fndecl (stmt
);
5196 switch (DECL_FUNCTION_CODE (fndecl
))
5198 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
:
5199 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2
:
5200 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4
:
5201 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8
:
5202 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16
:
5208 tree expected
= gimple_call_arg (stmt
, 1);
5209 if (TREE_CODE (expected
) != ADDR_EXPR
5210 || !SSA_VAR_P (TREE_OPERAND (expected
, 0)))
5213 tree etype
= TREE_TYPE (TREE_OPERAND (expected
, 0));
5214 if (!is_gimple_reg_type (etype
)
5215 || !auto_var_in_fn_p (TREE_OPERAND (expected
, 0), current_function_decl
)
5216 || TREE_THIS_VOLATILE (etype
)
5217 || VECTOR_TYPE_P (etype
)
5218 || TREE_CODE (etype
) == COMPLEX_TYPE
5219 /* Don't optimize floating point expected vars, VIEW_CONVERT_EXPRs
5220 might not preserve all the bits. See PR71716. */
5221 || SCALAR_FLOAT_TYPE_P (etype
)
5222 || maybe_ne (TYPE_PRECISION (etype
),
5223 GET_MODE_BITSIZE (TYPE_MODE (etype
))))
5226 tree weak
= gimple_call_arg (stmt
, 3);
5227 if (!integer_zerop (weak
) && !integer_onep (weak
))
5230 tree parmt
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
5231 tree itype
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (parmt
)));
5232 machine_mode mode
= TYPE_MODE (itype
);
5234 if (direct_optab_handler (atomic_compare_and_swap_optab
, mode
)
5236 && optab_handler (sync_compare_and_swap_optab
, mode
) == CODE_FOR_nothing
)
5239 if (maybe_ne (int_size_in_bytes (etype
), GET_MODE_SIZE (mode
)))
5246 r = __atomic_compare_exchange_N (p, &e, d, w, s, f);
5248 _Complex uintN_t t = ATOMIC_COMPARE_EXCHANGE (p, e, d, w * 256 + N, s, f);
5249 i = IMAGPART_EXPR <t>;
5251 e = REALPART_EXPR <t>; */
5254 fold_builtin_atomic_compare_exchange (gimple_stmt_iterator
*gsi
)
5256 gimple
*stmt
= gsi_stmt (*gsi
);
5257 tree fndecl
= gimple_call_fndecl (stmt
);
5258 tree parmt
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
5259 tree itype
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (parmt
)));
5260 tree ctype
= build_complex_type (itype
);
5261 tree expected
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
5262 bool throws
= false;
5264 gimple
*g
= gimple_build_assign (make_ssa_name (TREE_TYPE (expected
)),
5266 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
5267 gimple_stmt_iterator gsiret
= gsi_for_stmt (g
);
5268 if (!useless_type_conversion_p (itype
, TREE_TYPE (expected
)))
5270 g
= gimple_build_assign (make_ssa_name (itype
), VIEW_CONVERT_EXPR
,
5271 build1 (VIEW_CONVERT_EXPR
, itype
,
5272 gimple_assign_lhs (g
)));
5273 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
5275 int flag
= (integer_onep (gimple_call_arg (stmt
, 3)) ? 256 : 0)
5276 + int_size_in_bytes (itype
);
5277 g
= gimple_build_call_internal (IFN_ATOMIC_COMPARE_EXCHANGE
, 6,
5278 gimple_call_arg (stmt
, 0),
5279 gimple_assign_lhs (g
),
5280 gimple_call_arg (stmt
, 2),
5281 build_int_cst (integer_type_node
, flag
),
5282 gimple_call_arg (stmt
, 4),
5283 gimple_call_arg (stmt
, 5));
5284 tree lhs
= make_ssa_name (ctype
);
5285 gimple_call_set_lhs (g
, lhs
);
5286 gimple_move_vops (g
, stmt
);
5287 tree oldlhs
= gimple_call_lhs (stmt
);
5288 if (stmt_can_throw_internal (cfun
, stmt
))
5291 e
= find_fallthru_edge (gsi_bb (*gsi
)->succs
);
5293 gimple_call_set_nothrow (as_a
<gcall
*> (g
),
5294 gimple_call_nothrow_p (as_a
<gcall
*> (stmt
)));
5295 gimple_call_set_lhs (stmt
, NULL_TREE
);
5296 gsi_replace (gsi
, g
, true);
5299 g
= gimple_build_assign (make_ssa_name (itype
), IMAGPART_EXPR
,
5300 build1 (IMAGPART_EXPR
, itype
, lhs
));
5303 gsi_insert_on_edge_immediate (e
, g
);
5304 *gsi
= gsi_for_stmt (g
);
5307 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5308 g
= gimple_build_assign (oldlhs
, NOP_EXPR
, gimple_assign_lhs (g
));
5309 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5311 g
= gimple_build_assign (make_ssa_name (itype
), REALPART_EXPR
,
5312 build1 (REALPART_EXPR
, itype
, lhs
));
5313 if (throws
&& oldlhs
== NULL_TREE
)
5315 gsi_insert_on_edge_immediate (e
, g
);
5316 *gsi
= gsi_for_stmt (g
);
5319 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5320 if (!useless_type_conversion_p (TREE_TYPE (expected
), itype
))
5322 g
= gimple_build_assign (make_ssa_name (TREE_TYPE (expected
)),
5324 build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (expected
),
5325 gimple_assign_lhs (g
)));
5326 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5328 g
= gimple_build_assign (expected
, SSA_NAME
, gimple_assign_lhs (g
));
5329 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5333 /* Return true if ARG0 CODE ARG1 in infinite signed precision operation
5334 doesn't fit into TYPE. The test for overflow should be regardless of
5335 -fwrapv, and even for unsigned types. */
5338 arith_overflowed_p (enum tree_code code
, const_tree type
,
5339 const_tree arg0
, const_tree arg1
)
5341 widest2_int warg0
= widest2_int_cst (arg0
);
5342 widest2_int warg1
= widest2_int_cst (arg1
);
5346 case PLUS_EXPR
: wres
= wi::add (warg0
, warg1
); break;
5347 case MINUS_EXPR
: wres
= wi::sub (warg0
, warg1
); break;
5348 case MULT_EXPR
: wres
= wi::mul (warg0
, warg1
); break;
5349 default: gcc_unreachable ();
5351 signop sign
= TYPE_SIGN (type
);
5352 if (sign
== UNSIGNED
&& wi::neg_p (wres
))
5354 return wi::min_precision (wres
, sign
) > TYPE_PRECISION (type
);
5357 /* If IFN_MASK_LOAD/STORE call CALL is unconditional, return a MEM_REF
5358 for the memory it references, otherwise return null. VECTYPE is the
5359 type of the memory vector. */
5362 gimple_fold_mask_load_store_mem_ref (gcall
*call
, tree vectype
)
5364 tree ptr
= gimple_call_arg (call
, 0);
5365 tree alias_align
= gimple_call_arg (call
, 1);
5366 tree mask
= gimple_call_arg (call
, 2);
5367 if (!tree_fits_uhwi_p (alias_align
) || !integer_all_onesp (mask
))
5370 unsigned HOST_WIDE_INT align
= tree_to_uhwi (alias_align
);
5371 if (TYPE_ALIGN (vectype
) != align
)
5372 vectype
= build_aligned_type (vectype
, align
);
5373 tree offset
= build_zero_cst (TREE_TYPE (alias_align
));
5374 return fold_build2 (MEM_REF
, vectype
, ptr
, offset
);
5377 /* Try to fold IFN_MASK_LOAD call CALL. Return true on success. */
5380 gimple_fold_mask_load (gimple_stmt_iterator
*gsi
, gcall
*call
)
5382 tree lhs
= gimple_call_lhs (call
);
5386 if (tree rhs
= gimple_fold_mask_load_store_mem_ref (call
, TREE_TYPE (lhs
)))
5388 gassign
*new_stmt
= gimple_build_assign (lhs
, rhs
);
5389 gimple_set_location (new_stmt
, gimple_location (call
));
5390 gimple_move_vops (new_stmt
, call
);
5391 gsi_replace (gsi
, new_stmt
, false);
5397 /* Try to fold IFN_MASK_STORE call CALL. Return true on success. */
5400 gimple_fold_mask_store (gimple_stmt_iterator
*gsi
, gcall
*call
)
5402 tree rhs
= gimple_call_arg (call
, 3);
5403 if (tree lhs
= gimple_fold_mask_load_store_mem_ref (call
, TREE_TYPE (rhs
)))
5405 gassign
*new_stmt
= gimple_build_assign (lhs
, rhs
);
5406 gimple_set_location (new_stmt
, gimple_location (call
));
5407 gimple_move_vops (new_stmt
, call
);
5408 gsi_replace (gsi
, new_stmt
, false);
5414 /* Attempt to fold a call statement referenced by the statement iterator GSI.
5415 The statement may be replaced by another statement, e.g., if the call
5416 simplifies to a constant value. Return true if any changes were made.
5417 It is assumed that the operands have been previously folded. */
5420 gimple_fold_call (gimple_stmt_iterator
*gsi
, bool inplace
)
5422 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
5424 bool changed
= false;
5426 /* Check for virtual calls that became direct calls. */
5427 callee
= gimple_call_fn (stmt
);
5428 if (callee
&& TREE_CODE (callee
) == OBJ_TYPE_REF
)
5430 if (gimple_call_addr_fndecl (OBJ_TYPE_REF_EXPR (callee
)) != NULL_TREE
)
5432 if (dump_file
&& virtual_method_call_p (callee
)
5433 && !possible_polymorphic_call_target_p
5434 (callee
, stmt
, cgraph_node::get (gimple_call_addr_fndecl
5435 (OBJ_TYPE_REF_EXPR (callee
)))))
5438 "Type inheritance inconsistent devirtualization of ");
5439 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5440 fprintf (dump_file
, " to ");
5441 print_generic_expr (dump_file
, callee
, TDF_SLIM
);
5442 fprintf (dump_file
, "\n");
5445 gimple_call_set_fn (stmt
, OBJ_TYPE_REF_EXPR (callee
));
5448 else if (flag_devirtualize
&& !inplace
&& virtual_method_call_p (callee
))
5451 vec
<cgraph_node
*>targets
5452 = possible_polymorphic_call_targets (callee
, stmt
, &final
);
5453 if (final
&& targets
.length () <= 1 && dbg_cnt (devirt
))
5455 tree lhs
= gimple_call_lhs (stmt
);
5456 if (dump_enabled_p ())
5458 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
,
5459 "folding virtual function call to %s\n",
5460 targets
.length () == 1
5461 ? targets
[0]->name ()
5462 : "__builtin_unreachable");
5464 if (targets
.length () == 1)
5466 tree fndecl
= targets
[0]->decl
;
5467 gimple_call_set_fndecl (stmt
, fndecl
);
5469 /* If changing the call to __cxa_pure_virtual
5470 or similar noreturn function, adjust gimple_call_fntype
5472 if (gimple_call_noreturn_p (stmt
)
5473 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl
)))
5474 && TYPE_ARG_TYPES (TREE_TYPE (fndecl
))
5475 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
5477 gimple_call_set_fntype (stmt
, TREE_TYPE (fndecl
));
5478 /* If the call becomes noreturn, remove the lhs. */
5480 && gimple_call_noreturn_p (stmt
)
5481 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (stmt
)))
5482 || should_remove_lhs_p (lhs
)))
5484 if (TREE_CODE (lhs
) == SSA_NAME
)
5486 tree var
= create_tmp_var (TREE_TYPE (lhs
));
5487 tree def
= get_or_create_ssa_default_def (cfun
, var
);
5488 gimple
*new_stmt
= gimple_build_assign (lhs
, def
);
5489 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
5491 gimple_call_set_lhs (stmt
, NULL_TREE
);
5493 maybe_remove_unused_call_args (cfun
, stmt
);
5497 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
5498 gimple
*new_stmt
= gimple_build_call (fndecl
, 0);
5499 gimple_set_location (new_stmt
, gimple_location (stmt
));
5500 /* If the call had a SSA name as lhs morph that into
5501 an uninitialized value. */
5502 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
5504 tree var
= create_tmp_var (TREE_TYPE (lhs
));
5505 SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs
, var
);
5506 SSA_NAME_DEF_STMT (lhs
) = gimple_build_nop ();
5507 set_ssa_default_def (cfun
, var
, lhs
);
5509 gimple_move_vops (new_stmt
, stmt
);
5510 gsi_replace (gsi
, new_stmt
, false);
5517 /* Check for indirect calls that became direct calls, and then
5518 no longer require a static chain. */
5519 if (gimple_call_chain (stmt
))
5521 tree fn
= gimple_call_fndecl (stmt
);
5522 if (fn
&& !DECL_STATIC_CHAIN (fn
))
5524 gimple_call_set_chain (stmt
, NULL
);
5532 /* Check for builtins that CCP can handle using information not
5533 available in the generic fold routines. */
5534 if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
5536 if (gimple_fold_builtin (gsi
))
5539 else if (gimple_call_builtin_p (stmt
, BUILT_IN_MD
))
5541 changed
|= targetm
.gimple_fold_builtin (gsi
);
5543 else if (gimple_call_internal_p (stmt
))
5545 enum tree_code subcode
= ERROR_MARK
;
5546 tree result
= NULL_TREE
;
5547 bool cplx_result
= false;
5548 tree overflow
= NULL_TREE
;
5549 switch (gimple_call_internal_fn (stmt
))
5551 case IFN_BUILTIN_EXPECT
:
5552 result
= fold_builtin_expect (gimple_location (stmt
),
5553 gimple_call_arg (stmt
, 0),
5554 gimple_call_arg (stmt
, 1),
5555 gimple_call_arg (stmt
, 2),
5558 case IFN_UBSAN_OBJECT_SIZE
:
5560 tree offset
= gimple_call_arg (stmt
, 1);
5561 tree objsize
= gimple_call_arg (stmt
, 2);
5562 if (integer_all_onesp (objsize
)
5563 || (TREE_CODE (offset
) == INTEGER_CST
5564 && TREE_CODE (objsize
) == INTEGER_CST
5565 && tree_int_cst_le (offset
, objsize
)))
5567 replace_call_with_value (gsi
, NULL_TREE
);
5573 if (integer_zerop (gimple_call_arg (stmt
, 1)))
5575 replace_call_with_value (gsi
, NULL_TREE
);
5579 case IFN_UBSAN_BOUNDS
:
5581 tree index
= gimple_call_arg (stmt
, 1);
5582 tree bound
= gimple_call_arg (stmt
, 2);
5583 if (TREE_CODE (index
) == INTEGER_CST
5584 && TREE_CODE (bound
) == INTEGER_CST
)
5586 index
= fold_convert (TREE_TYPE (bound
), index
);
5587 if (TREE_CODE (index
) == INTEGER_CST
5588 && tree_int_cst_le (index
, bound
))
5590 replace_call_with_value (gsi
, NULL_TREE
);
5596 case IFN_GOACC_DIM_SIZE
:
5597 case IFN_GOACC_DIM_POS
:
5598 result
= fold_internal_goacc_dim (stmt
);
5600 case IFN_UBSAN_CHECK_ADD
:
5601 subcode
= PLUS_EXPR
;
5603 case IFN_UBSAN_CHECK_SUB
:
5604 subcode
= MINUS_EXPR
;
5606 case IFN_UBSAN_CHECK_MUL
:
5607 subcode
= MULT_EXPR
;
5609 case IFN_ADD_OVERFLOW
:
5610 subcode
= PLUS_EXPR
;
5613 case IFN_SUB_OVERFLOW
:
5614 subcode
= MINUS_EXPR
;
5617 case IFN_MUL_OVERFLOW
:
5618 subcode
= MULT_EXPR
;
5622 changed
|= gimple_fold_mask_load (gsi
, stmt
);
5624 case IFN_MASK_STORE
:
5625 changed
|= gimple_fold_mask_store (gsi
, stmt
);
5630 if (subcode
!= ERROR_MARK
)
5632 tree arg0
= gimple_call_arg (stmt
, 0);
5633 tree arg1
= gimple_call_arg (stmt
, 1);
5634 tree type
= TREE_TYPE (arg0
);
5637 tree lhs
= gimple_call_lhs (stmt
);
5638 if (lhs
== NULL_TREE
)
5641 type
= TREE_TYPE (TREE_TYPE (lhs
));
5643 if (type
== NULL_TREE
)
5645 /* x = y + 0; x = y - 0; x = y * 0; */
5646 else if (integer_zerop (arg1
))
5647 result
= subcode
== MULT_EXPR
? integer_zero_node
: arg0
;
5648 /* x = 0 + y; x = 0 * y; */
5649 else if (subcode
!= MINUS_EXPR
&& integer_zerop (arg0
))
5650 result
= subcode
== MULT_EXPR
? integer_zero_node
: arg1
;
5652 else if (subcode
== MINUS_EXPR
&& operand_equal_p (arg0
, arg1
, 0))
5653 result
= integer_zero_node
;
5654 /* x = y * 1; x = 1 * y; */
5655 else if (subcode
== MULT_EXPR
&& integer_onep (arg1
))
5657 else if (subcode
== MULT_EXPR
&& integer_onep (arg0
))
5659 else if (TREE_CODE (arg0
) == INTEGER_CST
5660 && TREE_CODE (arg1
) == INTEGER_CST
)
5663 result
= int_const_binop (subcode
, fold_convert (type
, arg0
),
5664 fold_convert (type
, arg1
));
5666 result
= int_const_binop (subcode
, arg0
, arg1
);
5667 if (result
&& arith_overflowed_p (subcode
, type
, arg0
, arg1
))
5670 overflow
= build_one_cst (type
);
5677 if (result
== integer_zero_node
)
5678 result
= build_zero_cst (type
);
5679 else if (cplx_result
&& TREE_TYPE (result
) != type
)
5681 if (TREE_CODE (result
) == INTEGER_CST
)
5683 if (arith_overflowed_p (PLUS_EXPR
, type
, result
,
5685 overflow
= build_one_cst (type
);
5687 else if ((!TYPE_UNSIGNED (TREE_TYPE (result
))
5688 && TYPE_UNSIGNED (type
))
5689 || (TYPE_PRECISION (type
)
5690 < (TYPE_PRECISION (TREE_TYPE (result
))
5691 + (TYPE_UNSIGNED (TREE_TYPE (result
))
5692 && !TYPE_UNSIGNED (type
)))))
5695 result
= fold_convert (type
, result
);
5702 if (TREE_CODE (result
) == INTEGER_CST
&& TREE_OVERFLOW (result
))
5703 result
= drop_tree_overflow (result
);
5706 if (overflow
== NULL_TREE
)
5707 overflow
= build_zero_cst (TREE_TYPE (result
));
5708 tree ctype
= build_complex_type (TREE_TYPE (result
));
5709 if (TREE_CODE (result
) == INTEGER_CST
5710 && TREE_CODE (overflow
) == INTEGER_CST
)
5711 result
= build_complex (ctype
, result
, overflow
);
5713 result
= build2_loc (gimple_location (stmt
), COMPLEX_EXPR
,
5714 ctype
, result
, overflow
);
5716 gimplify_and_update_call_from_tree (gsi
, result
);
5725 /* Return true whether NAME has a use on STMT. */
5728 has_use_on_stmt (tree name
, gimple
*stmt
)
5730 imm_use_iterator iter
;
5731 use_operand_p use_p
;
5732 FOR_EACH_IMM_USE_FAST (use_p
, iter
, name
)
5733 if (USE_STMT (use_p
) == stmt
)
5738 /* Worker for fold_stmt_1 dispatch to pattern based folding with
5741 Replaces *GSI with the simplification result in RCODE and OPS
5742 and the associated statements in *SEQ. Does the replacement
5743 according to INPLACE and returns true if the operation succeeded. */
5746 replace_stmt_with_simplification (gimple_stmt_iterator
*gsi
,
5747 gimple_match_op
*res_op
,
5748 gimple_seq
*seq
, bool inplace
)
5750 gimple
*stmt
= gsi_stmt (*gsi
);
5751 tree
*ops
= res_op
->ops
;
5752 unsigned int num_ops
= res_op
->num_ops
;
5754 /* Play safe and do not allow abnormals to be mentioned in
5755 newly created statements. See also maybe_push_res_to_seq.
5756 As an exception allow such uses if there was a use of the
5757 same SSA name on the old stmt. */
5758 for (unsigned int i
= 0; i
< num_ops
; ++i
)
5759 if (TREE_CODE (ops
[i
]) == SSA_NAME
5760 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops
[i
])
5761 && !has_use_on_stmt (ops
[i
], stmt
))
5764 if (num_ops
> 0 && COMPARISON_CLASS_P (ops
[0]))
5765 for (unsigned int i
= 0; i
< 2; ++i
)
5766 if (TREE_CODE (TREE_OPERAND (ops
[0], i
)) == SSA_NAME
5767 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops
[0], i
))
5768 && !has_use_on_stmt (TREE_OPERAND (ops
[0], i
), stmt
))
5771 /* Don't insert new statements when INPLACE is true, even if we could
5772 reuse STMT for the final statement. */
5773 if (inplace
&& !gimple_seq_empty_p (*seq
))
5776 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
5778 gcc_assert (res_op
->code
.is_tree_code ());
5779 auto code
= tree_code (res_op
->code
);
5780 if (TREE_CODE_CLASS (code
) == tcc_comparison
5781 /* GIMPLE_CONDs condition may not throw. */
5782 && (!flag_exceptions
5783 || !cfun
->can_throw_non_call_exceptions
5784 || !operation_could_trap_p (code
,
5785 FLOAT_TYPE_P (TREE_TYPE (ops
[0])),
5787 gimple_cond_set_condition (cond_stmt
, code
, ops
[0], ops
[1]);
5788 else if (code
== SSA_NAME
)
5789 gimple_cond_set_condition (cond_stmt
, NE_EXPR
, ops
[0],
5790 build_zero_cst (TREE_TYPE (ops
[0])));
5791 else if (code
== INTEGER_CST
)
5793 if (integer_zerop (ops
[0]))
5794 gimple_cond_make_false (cond_stmt
);
5796 gimple_cond_make_true (cond_stmt
);
5800 tree res
= maybe_push_res_to_seq (res_op
, seq
);
5803 gimple_cond_set_condition (cond_stmt
, NE_EXPR
, res
,
5804 build_zero_cst (TREE_TYPE (res
)));
5808 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5810 fprintf (dump_file
, "gimple_simplified to ");
5811 if (!gimple_seq_empty_p (*seq
))
5812 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
5813 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
),
5816 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
5819 else if (is_gimple_assign (stmt
)
5820 && res_op
->code
.is_tree_code ())
5822 auto code
= tree_code (res_op
->code
);
5824 || gimple_num_ops (stmt
) > get_gimple_rhs_num_ops (code
))
5826 maybe_build_generic_op (res_op
);
5827 gimple_assign_set_rhs_with_ops (gsi
, code
,
5828 res_op
->op_or_null (0),
5829 res_op
->op_or_null (1),
5830 res_op
->op_or_null (2));
5831 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5833 fprintf (dump_file
, "gimple_simplified to ");
5834 if (!gimple_seq_empty_p (*seq
))
5835 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
5836 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
),
5839 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
5843 else if (res_op
->code
.is_fn_code ()
5844 && gimple_call_combined_fn (stmt
) == combined_fn (res_op
->code
))
5846 gcc_assert (num_ops
== gimple_call_num_args (stmt
));
5847 for (unsigned int i
= 0; i
< num_ops
; ++i
)
5848 gimple_call_set_arg (stmt
, i
, ops
[i
]);
5849 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5851 fprintf (dump_file
, "gimple_simplified to ");
5852 if (!gimple_seq_empty_p (*seq
))
5853 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
5854 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
), 0, TDF_SLIM
);
5856 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
5861 if (gimple_has_lhs (stmt
))
5863 tree lhs
= gimple_get_lhs (stmt
);
5864 if (!maybe_push_res_to_seq (res_op
, seq
, lhs
))
5866 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5868 fprintf (dump_file
, "gimple_simplified to ");
5869 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
5871 gsi_replace_with_seq_vops (gsi
, *seq
);
5881 /* Canonicalize MEM_REFs invariant address operand after propagation. */
5884 maybe_canonicalize_mem_ref_addr (tree
*t
, bool is_debug
= false)
5889 if (TREE_CODE (*t
) == ADDR_EXPR
)
5890 t
= &TREE_OPERAND (*t
, 0);
5892 /* The C and C++ frontends use an ARRAY_REF for indexing with their
5893 generic vector extension. The actual vector referenced is
5894 view-converted to an array type for this purpose. If the index
5895 is constant the canonical representation in the middle-end is a
5896 BIT_FIELD_REF so re-write the former to the latter here. */
5897 if (TREE_CODE (*t
) == ARRAY_REF
5898 && TREE_CODE (TREE_OPERAND (*t
, 0)) == VIEW_CONVERT_EXPR
5899 && TREE_CODE (TREE_OPERAND (*t
, 1)) == INTEGER_CST
5900 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*t
, 0), 0))))
5902 tree vtype
= TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*t
, 0), 0));
5903 if (VECTOR_TYPE_P (vtype
))
5905 tree low
= array_ref_low_bound (*t
);
5906 if (TREE_CODE (low
) == INTEGER_CST
)
5908 if (tree_int_cst_le (low
, TREE_OPERAND (*t
, 1)))
5910 widest_int idx
= wi::sub (wi::to_widest (TREE_OPERAND (*t
, 1)),
5911 wi::to_widest (low
));
5912 idx
= wi::mul (idx
, wi::to_widest
5913 (TYPE_SIZE (TREE_TYPE (*t
))));
5915 = wi::add (idx
, wi::to_widest (TYPE_SIZE (TREE_TYPE (*t
))));
5916 if (wi::les_p (ext
, wi::to_widest (TYPE_SIZE (vtype
))))
5918 *t
= build3_loc (EXPR_LOCATION (*t
), BIT_FIELD_REF
,
5920 TREE_OPERAND (TREE_OPERAND (*t
, 0), 0),
5921 TYPE_SIZE (TREE_TYPE (*t
)),
5922 wide_int_to_tree (bitsizetype
, idx
));
5930 while (handled_component_p (*t
))
5931 t
= &TREE_OPERAND (*t
, 0);
5933 /* Canonicalize MEM [&foo.bar, 0] which appears after propagating
5934 of invariant addresses into a SSA name MEM_REF address. */
5935 if (TREE_CODE (*t
) == MEM_REF
5936 || TREE_CODE (*t
) == TARGET_MEM_REF
)
5938 tree addr
= TREE_OPERAND (*t
, 0);
5939 if (TREE_CODE (addr
) == ADDR_EXPR
5940 && (TREE_CODE (TREE_OPERAND (addr
, 0)) == MEM_REF
5941 || handled_component_p (TREE_OPERAND (addr
, 0))))
5945 base
= get_addr_base_and_unit_offset (TREE_OPERAND (addr
, 0),
5954 TREE_OPERAND (*t
, 0) = build_fold_addr_expr (base
);
5955 TREE_OPERAND (*t
, 1) = int_const_binop (PLUS_EXPR
,
5956 TREE_OPERAND (*t
, 1),
5957 size_int (coffset
));
5960 gcc_checking_assert (TREE_CODE (TREE_OPERAND (*t
, 0)) == DEBUG_EXPR_DECL
5961 || is_gimple_mem_ref_addr (TREE_OPERAND (*t
, 0)));
5964 /* Canonicalize back MEM_REFs to plain reference trees if the object
5965 accessed is a decl that has the same access semantics as the MEM_REF. */
5966 if (TREE_CODE (*t
) == MEM_REF
5967 && TREE_CODE (TREE_OPERAND (*t
, 0)) == ADDR_EXPR
5968 && integer_zerop (TREE_OPERAND (*t
, 1))
5969 && MR_DEPENDENCE_CLIQUE (*t
) == 0)
5971 tree decl
= TREE_OPERAND (TREE_OPERAND (*t
, 0), 0);
5972 tree alias_type
= TREE_TYPE (TREE_OPERAND (*t
, 1));
5973 if (/* Same volatile qualification. */
5974 TREE_THIS_VOLATILE (*t
) == TREE_THIS_VOLATILE (decl
)
5975 /* Same TBAA behavior with -fstrict-aliasing. */
5976 && !TYPE_REF_CAN_ALIAS_ALL (alias_type
)
5977 && (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))
5978 == TYPE_MAIN_VARIANT (TREE_TYPE (alias_type
)))
5979 /* Same alignment. */
5980 && TYPE_ALIGN (TREE_TYPE (decl
)) == TYPE_ALIGN (TREE_TYPE (*t
))
5981 /* We have to look out here to not drop a required conversion
5982 from the rhs to the lhs if *t appears on the lhs or vice-versa
5983 if it appears on the rhs. Thus require strict type
5985 && types_compatible_p (TREE_TYPE (*t
), TREE_TYPE (decl
)))
5987 *t
= TREE_OPERAND (TREE_OPERAND (*t
, 0), 0);
5992 else if (TREE_CODE (*orig_t
) == ADDR_EXPR
5993 && TREE_CODE (*t
) == MEM_REF
5994 && TREE_CODE (TREE_OPERAND (*t
, 0)) == INTEGER_CST
)
5998 base
= get_addr_base_and_unit_offset (TREE_OPERAND (*orig_t
, 0),
6002 gcc_assert (TREE_CODE (base
) == MEM_REF
);
6004 if (mem_ref_offset (base
).to_shwi (&moffset
))
6007 if (wi::to_poly_wide (TREE_OPERAND (base
, 0)).to_shwi (&moffset
))
6010 *orig_t
= build_int_cst (TREE_TYPE (*orig_t
), coffset
);
6017 /* Canonicalize TARGET_MEM_REF in particular with respect to
6018 the indexes becoming constant. */
6019 else if (TREE_CODE (*t
) == TARGET_MEM_REF
)
6021 tree tem
= maybe_fold_tmr (*t
);
6025 if (TREE_CODE (*orig_t
) == ADDR_EXPR
)
6026 recompute_tree_invariant_for_addr_expr (*orig_t
);
6034 /* Worker for both fold_stmt and fold_stmt_inplace. The INPLACE argument
6035 distinguishes both cases. */
6038 fold_stmt_1 (gimple_stmt_iterator
*gsi
, bool inplace
, tree (*valueize
) (tree
))
6040 bool changed
= false;
6041 gimple
*stmt
= gsi_stmt (*gsi
);
6042 bool nowarning
= warning_suppressed_p (stmt
, OPT_Wstrict_overflow
);
6044 fold_defer_overflow_warnings ();
6046 /* First do required canonicalization of [TARGET_]MEM_REF addresses
6048 ??? This shouldn't be done in generic folding but in the
6049 propagation helpers which also know whether an address was
6051 Also canonicalize operand order. */
6052 switch (gimple_code (stmt
))
6055 if (gimple_assign_rhs_class (stmt
) == GIMPLE_SINGLE_RHS
)
6057 tree
*rhs
= gimple_assign_rhs1_ptr (stmt
);
6058 if ((REFERENCE_CLASS_P (*rhs
)
6059 || TREE_CODE (*rhs
) == ADDR_EXPR
)
6060 && maybe_canonicalize_mem_ref_addr (rhs
))
6062 tree
*lhs
= gimple_assign_lhs_ptr (stmt
);
6063 if (REFERENCE_CLASS_P (*lhs
)
6064 && maybe_canonicalize_mem_ref_addr (lhs
))
6066 /* Canonicalize &MEM[ssa_n, CST] to ssa_n p+ CST.
6067 This cannot be done in maybe_canonicalize_mem_ref_addr
6068 as the gimple now has two operands rather than one.
6069 The same reason why this can't be done in
6070 maybe_canonicalize_mem_ref_addr is the same reason why
6071 this can't be done inplace. */
6072 if (!inplace
&& TREE_CODE (*rhs
) == ADDR_EXPR
)
6074 tree inner
= TREE_OPERAND (*rhs
, 0);
6075 if (TREE_CODE (inner
) == MEM_REF
6076 && TREE_CODE (TREE_OPERAND (inner
, 0)) == SSA_NAME
6077 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
)
6079 tree ptr
= TREE_OPERAND (inner
, 0);
6080 tree addon
= TREE_OPERAND (inner
, 1);
6081 addon
= fold_convert (sizetype
, addon
);
6082 gimple_assign_set_rhs_with_ops (gsi
, POINTER_PLUS_EXPR
,
6085 stmt
= gsi_stmt (*gsi
);
6091 /* Canonicalize operand order. */
6092 enum tree_code code
= gimple_assign_rhs_code (stmt
);
6093 if (TREE_CODE_CLASS (code
) == tcc_comparison
6094 || commutative_tree_code (code
)
6095 || commutative_ternary_tree_code (code
))
6097 tree rhs1
= gimple_assign_rhs1 (stmt
);
6098 tree rhs2
= gimple_assign_rhs2 (stmt
);
6099 if (tree_swap_operands_p (rhs1
, rhs2
))
6101 gimple_assign_set_rhs1 (stmt
, rhs2
);
6102 gimple_assign_set_rhs2 (stmt
, rhs1
);
6103 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
6104 gimple_assign_set_rhs_code (stmt
,
6105 swap_tree_comparison (code
));
6113 gcall
*call
= as_a
<gcall
*> (stmt
);
6114 for (i
= 0; i
< gimple_call_num_args (call
); ++i
)
6116 tree
*arg
= gimple_call_arg_ptr (call
, i
);
6117 if (REFERENCE_CLASS_P (*arg
)
6118 && maybe_canonicalize_mem_ref_addr (arg
))
6121 tree
*lhs
= gimple_call_lhs_ptr (call
);
6123 && REFERENCE_CLASS_P (*lhs
)
6124 && maybe_canonicalize_mem_ref_addr (lhs
))
6128 combined_fn cfn
= gimple_call_combined_fn (call
);
6129 internal_fn ifn
= associated_internal_fn (cfn
, TREE_TYPE (*lhs
));
6130 int opno
= first_commutative_argument (ifn
);
6133 tree arg1
= gimple_call_arg (call
, opno
);
6134 tree arg2
= gimple_call_arg (call
, opno
+ 1);
6135 if (tree_swap_operands_p (arg1
, arg2
))
6137 gimple_call_set_arg (call
, opno
, arg2
);
6138 gimple_call_set_arg (call
, opno
+ 1, arg1
);
6147 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
6148 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
6150 tree link
= gimple_asm_output_op (asm_stmt
, i
);
6151 tree op
= TREE_VALUE (link
);
6152 if (REFERENCE_CLASS_P (op
)
6153 && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link
)))
6156 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
6158 tree link
= gimple_asm_input_op (asm_stmt
, i
);
6159 tree op
= TREE_VALUE (link
);
6160 if ((REFERENCE_CLASS_P (op
)
6161 || TREE_CODE (op
) == ADDR_EXPR
)
6162 && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link
)))
6168 if (gimple_debug_bind_p (stmt
))
6170 tree
*val
= gimple_debug_bind_get_value_ptr (stmt
);
6172 && (REFERENCE_CLASS_P (*val
)
6173 || TREE_CODE (*val
) == ADDR_EXPR
)
6174 && maybe_canonicalize_mem_ref_addr (val
, true))
6180 /* Canonicalize operand order. */
6181 tree lhs
= gimple_cond_lhs (stmt
);
6182 tree rhs
= gimple_cond_rhs (stmt
);
6183 if (tree_swap_operands_p (lhs
, rhs
))
6185 gcond
*gc
= as_a
<gcond
*> (stmt
);
6186 gimple_cond_set_lhs (gc
, rhs
);
6187 gimple_cond_set_rhs (gc
, lhs
);
6188 gimple_cond_set_code (gc
,
6189 swap_tree_comparison (gimple_cond_code (gc
)));
6196 /* Dispatch to pattern-based folding. */
6198 || is_gimple_assign (stmt
)
6199 || gimple_code (stmt
) == GIMPLE_COND
)
6201 gimple_seq seq
= NULL
;
6202 gimple_match_op res_op
;
6203 if (gimple_simplify (stmt
, &res_op
, inplace
? NULL
: &seq
,
6204 valueize
, valueize
))
6206 if (replace_stmt_with_simplification (gsi
, &res_op
, &seq
, inplace
))
6209 gimple_seq_discard (seq
);
6213 stmt
= gsi_stmt (*gsi
);
6215 /* Fold the main computation performed by the statement. */
6216 switch (gimple_code (stmt
))
6220 /* Try to canonicalize for boolean-typed X the comparisons
6221 X == 0, X == 1, X != 0, and X != 1. */
6222 if (gimple_assign_rhs_code (stmt
) == EQ_EXPR
6223 || gimple_assign_rhs_code (stmt
) == NE_EXPR
)
6225 tree lhs
= gimple_assign_lhs (stmt
);
6226 tree op1
= gimple_assign_rhs1 (stmt
);
6227 tree op2
= gimple_assign_rhs2 (stmt
);
6228 tree type
= TREE_TYPE (op1
);
6230 /* Check whether the comparison operands are of the same boolean
6231 type as the result type is.
6232 Check that second operand is an integer-constant with value
6234 if (TREE_CODE (op2
) == INTEGER_CST
6235 && (integer_zerop (op2
) || integer_onep (op2
))
6236 && useless_type_conversion_p (TREE_TYPE (lhs
), type
))
6238 enum tree_code cmp_code
= gimple_assign_rhs_code (stmt
);
6239 bool is_logical_not
= false;
6241 /* X == 0 and X != 1 is a logical-not.of X
6242 X == 1 and X != 0 is X */
6243 if ((cmp_code
== EQ_EXPR
&& integer_zerop (op2
))
6244 || (cmp_code
== NE_EXPR
&& integer_onep (op2
)))
6245 is_logical_not
= true;
6247 if (is_logical_not
== false)
6248 gimple_assign_set_rhs_with_ops (gsi
, TREE_CODE (op1
), op1
);
6249 /* Only for one-bit precision typed X the transformation
6250 !X -> ~X is valied. */
6251 else if (TYPE_PRECISION (type
) == 1)
6252 gimple_assign_set_rhs_with_ops (gsi
, BIT_NOT_EXPR
, op1
);
6253 /* Otherwise we use !X -> X ^ 1. */
6255 gimple_assign_set_rhs_with_ops (gsi
, BIT_XOR_EXPR
, op1
,
6256 build_int_cst (type
, 1));
6262 unsigned old_num_ops
= gimple_num_ops (stmt
);
6263 tree lhs
= gimple_assign_lhs (stmt
);
6264 tree new_rhs
= fold_gimple_assign (gsi
);
6266 && !useless_type_conversion_p (TREE_TYPE (lhs
),
6267 TREE_TYPE (new_rhs
)))
6268 new_rhs
= fold_convert (TREE_TYPE (lhs
), new_rhs
);
6271 || get_gimple_rhs_num_ops (TREE_CODE (new_rhs
)) < old_num_ops
))
6273 gimple_assign_set_rhs_from_tree (gsi
, new_rhs
);
6280 changed
|= gimple_fold_call (gsi
, inplace
);
6284 if (gimple_debug_bind_p (stmt
))
6286 tree val
= gimple_debug_bind_get_value (stmt
);
6288 && REFERENCE_CLASS_P (val
))
6290 tree tem
= maybe_fold_reference (val
);
6293 gimple_debug_bind_set_value (stmt
, tem
);
6298 && TREE_CODE (val
) == ADDR_EXPR
)
6300 tree ref
= TREE_OPERAND (val
, 0);
6301 tree tem
= maybe_fold_reference (ref
);
6304 tem
= build_fold_addr_expr_with_type (tem
, TREE_TYPE (val
));
6305 gimple_debug_bind_set_value (stmt
, tem
);
6314 greturn
*ret_stmt
= as_a
<greturn
*> (stmt
);
6315 tree ret
= gimple_return_retval(ret_stmt
);
6317 if (ret
&& TREE_CODE (ret
) == SSA_NAME
&& valueize
)
6319 tree val
= valueize (ret
);
6320 if (val
&& val
!= ret
6321 && may_propagate_copy (ret
, val
))
6323 gimple_return_set_retval (ret_stmt
, val
);
6333 stmt
= gsi_stmt (*gsi
);
6335 fold_undefer_overflow_warnings (changed
&& !nowarning
, stmt
, 0);
6339 /* Valueziation callback that ends up not following SSA edges. */
6342 no_follow_ssa_edges (tree
)
6347 /* Valueization callback that ends up following single-use SSA edges only. */
6350 follow_single_use_edges (tree val
)
6352 if (TREE_CODE (val
) == SSA_NAME
6353 && !has_single_use (val
))
6358 /* Valueization callback that follows all SSA edges. */
6361 follow_all_ssa_edges (tree val
)
6366 /* Fold the statement pointed to by GSI. In some cases, this function may
6367 replace the whole statement with a new one. Returns true iff folding
6369 The statement pointed to by GSI should be in valid gimple form but may
6370 be in unfolded state as resulting from for example constant propagation
6371 which can produce *&x = 0. */
6374 fold_stmt (gimple_stmt_iterator
*gsi
)
6376 return fold_stmt_1 (gsi
, false, no_follow_ssa_edges
);
6380 fold_stmt (gimple_stmt_iterator
*gsi
, tree (*valueize
) (tree
))
6382 return fold_stmt_1 (gsi
, false, valueize
);
6385 /* Perform the minimal folding on statement *GSI. Only operations like
6386 *&x created by constant propagation are handled. The statement cannot
6387 be replaced with a new one. Return true if the statement was
6388 changed, false otherwise.
6389 The statement *GSI should be in valid gimple form but may
6390 be in unfolded state as resulting from for example constant propagation
6391 which can produce *&x = 0. */
6394 fold_stmt_inplace (gimple_stmt_iterator
*gsi
)
6396 gimple
*stmt
= gsi_stmt (*gsi
);
6397 bool changed
= fold_stmt_1 (gsi
, true, no_follow_ssa_edges
);
6398 gcc_assert (gsi_stmt (*gsi
) == stmt
);
6402 /* Canonicalize and possibly invert the boolean EXPR; return NULL_TREE
6403 if EXPR is null or we don't know how.
6404 If non-null, the result always has boolean type. */
6407 canonicalize_bool (tree expr
, bool invert
)
6413 if (integer_nonzerop (expr
))
6414 return boolean_false_node
;
6415 else if (integer_zerop (expr
))
6416 return boolean_true_node
;
6417 else if (TREE_CODE (expr
) == SSA_NAME
)
6418 return fold_build2 (EQ_EXPR
, boolean_type_node
, expr
,
6419 build_int_cst (TREE_TYPE (expr
), 0));
6420 else if (COMPARISON_CLASS_P (expr
))
6421 return fold_build2 (invert_tree_comparison (TREE_CODE (expr
), false),
6423 TREE_OPERAND (expr
, 0),
6424 TREE_OPERAND (expr
, 1));
6430 if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
)
6432 if (integer_nonzerop (expr
))
6433 return boolean_true_node
;
6434 else if (integer_zerop (expr
))
6435 return boolean_false_node
;
6436 else if (TREE_CODE (expr
) == SSA_NAME
)
6437 return fold_build2 (NE_EXPR
, boolean_type_node
, expr
,
6438 build_int_cst (TREE_TYPE (expr
), 0));
6439 else if (COMPARISON_CLASS_P (expr
))
6440 return fold_build2 (TREE_CODE (expr
),
6442 TREE_OPERAND (expr
, 0),
6443 TREE_OPERAND (expr
, 1));
6449 /* Check to see if a boolean expression EXPR is logically equivalent to the
6450 comparison (OP1 CODE OP2). Check for various identities involving
6454 same_bool_comparison_p (const_tree expr
, enum tree_code code
,
6455 const_tree op1
, const_tree op2
)
6459 /* The obvious case. */
6460 if (TREE_CODE (expr
) == code
6461 && operand_equal_p (TREE_OPERAND (expr
, 0), op1
, 0)
6462 && operand_equal_p (TREE_OPERAND (expr
, 1), op2
, 0))
6465 /* Check for comparing (name, name != 0) and the case where expr
6466 is an SSA_NAME with a definition matching the comparison. */
6467 if (TREE_CODE (expr
) == SSA_NAME
6468 && TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
)
6470 if (operand_equal_p (expr
, op1
, 0))
6471 return ((code
== NE_EXPR
&& integer_zerop (op2
))
6472 || (code
== EQ_EXPR
&& integer_nonzerop (op2
)));
6473 s
= SSA_NAME_DEF_STMT (expr
);
6474 if (is_gimple_assign (s
)
6475 && gimple_assign_rhs_code (s
) == code
6476 && operand_equal_p (gimple_assign_rhs1 (s
), op1
, 0)
6477 && operand_equal_p (gimple_assign_rhs2 (s
), op2
, 0))
6481 /* If op1 is of the form (name != 0) or (name == 0), and the definition
6482 of name is a comparison, recurse. */
6483 if (TREE_CODE (op1
) == SSA_NAME
6484 && TREE_CODE (TREE_TYPE (op1
)) == BOOLEAN_TYPE
)
6486 s
= SSA_NAME_DEF_STMT (op1
);
6487 if (is_gimple_assign (s
)
6488 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
)
6490 enum tree_code c
= gimple_assign_rhs_code (s
);
6491 if ((c
== NE_EXPR
&& integer_zerop (op2
))
6492 || (c
== EQ_EXPR
&& integer_nonzerop (op2
)))
6493 return same_bool_comparison_p (expr
, c
,
6494 gimple_assign_rhs1 (s
),
6495 gimple_assign_rhs2 (s
));
6496 if ((c
== EQ_EXPR
&& integer_zerop (op2
))
6497 || (c
== NE_EXPR
&& integer_nonzerop (op2
)))
6498 return same_bool_comparison_p (expr
,
6499 invert_tree_comparison (c
, false),
6500 gimple_assign_rhs1 (s
),
6501 gimple_assign_rhs2 (s
));
6507 /* Check to see if two boolean expressions OP1 and OP2 are logically
6511 same_bool_result_p (const_tree op1
, const_tree op2
)
6513 /* Simple cases first. */
6514 if (operand_equal_p (op1
, op2
, 0))
6517 /* Check the cases where at least one of the operands is a comparison.
6518 These are a bit smarter than operand_equal_p in that they apply some
6519 identifies on SSA_NAMEs. */
6520 if (COMPARISON_CLASS_P (op2
)
6521 && same_bool_comparison_p (op1
, TREE_CODE (op2
),
6522 TREE_OPERAND (op2
, 0),
6523 TREE_OPERAND (op2
, 1)))
6525 if (COMPARISON_CLASS_P (op1
)
6526 && same_bool_comparison_p (op2
, TREE_CODE (op1
),
6527 TREE_OPERAND (op1
, 0),
6528 TREE_OPERAND (op1
, 1)))
6535 /* Forward declarations for some mutually recursive functions. */
6538 and_comparisons_1 (tree type
, enum tree_code code1
, tree op1a
, tree op1b
,
6539 enum tree_code code2
, tree op2a
, tree op2b
);
6541 and_var_with_comparison (tree type
, tree var
, bool invert
,
6542 enum tree_code code2
, tree op2a
, tree op2b
);
6544 and_var_with_comparison_1 (tree type
, gimple
*stmt
,
6545 enum tree_code code2
, tree op2a
, tree op2b
);
6547 or_comparisons_1 (tree
, enum tree_code code1
, tree op1a
, tree op1b
,
6548 enum tree_code code2
, tree op2a
, tree op2b
);
6550 or_var_with_comparison (tree
, tree var
, bool invert
,
6551 enum tree_code code2
, tree op2a
, tree op2b
);
6553 or_var_with_comparison_1 (tree
, gimple
*stmt
,
6554 enum tree_code code2
, tree op2a
, tree op2b
);
6556 /* Helper function for and_comparisons_1: try to simplify the AND of the
6557 ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
6558 If INVERT is true, invert the value of the VAR before doing the AND.
6559 Return NULL_EXPR if we can't simplify this to a single expression. */
6562 and_var_with_comparison (tree type
, tree var
, bool invert
,
6563 enum tree_code code2
, tree op2a
, tree op2b
)
6566 gimple
*stmt
= SSA_NAME_DEF_STMT (var
);
6568 /* We can only deal with variables whose definitions are assignments. */
6569 if (!is_gimple_assign (stmt
))
6572 /* If we have an inverted comparison, apply DeMorgan's law and rewrite
6573 !var AND (op2a code2 op2b) => !(var OR !(op2a code2 op2b))
6574 Then we only have to consider the simpler non-inverted cases. */
6576 t
= or_var_with_comparison_1 (type
, stmt
,
6577 invert_tree_comparison (code2
, false),
6580 t
= and_var_with_comparison_1 (type
, stmt
, code2
, op2a
, op2b
);
6581 return canonicalize_bool (t
, invert
);
6584 /* Try to simplify the AND of the ssa variable defined by the assignment
6585 STMT with the comparison specified by (OP2A CODE2 OP2B).
6586 Return NULL_EXPR if we can't simplify this to a single expression. */
6589 and_var_with_comparison_1 (tree type
, gimple
*stmt
,
6590 enum tree_code code2
, tree op2a
, tree op2b
)
6592 tree var
= gimple_assign_lhs (stmt
);
6593 tree true_test_var
= NULL_TREE
;
6594 tree false_test_var
= NULL_TREE
;
6595 enum tree_code innercode
= gimple_assign_rhs_code (stmt
);
6597 /* Check for identities like (var AND (var == 0)) => false. */
6598 if (TREE_CODE (op2a
) == SSA_NAME
6599 && TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
)
6601 if ((code2
== NE_EXPR
&& integer_zerop (op2b
))
6602 || (code2
== EQ_EXPR
&& integer_nonzerop (op2b
)))
6604 true_test_var
= op2a
;
6605 if (var
== true_test_var
)
6608 else if ((code2
== EQ_EXPR
&& integer_zerop (op2b
))
6609 || (code2
== NE_EXPR
&& integer_nonzerop (op2b
)))
6611 false_test_var
= op2a
;
6612 if (var
== false_test_var
)
6613 return boolean_false_node
;
6617 /* If the definition is a comparison, recurse on it. */
6618 if (TREE_CODE_CLASS (innercode
) == tcc_comparison
)
6620 tree t
= and_comparisons_1 (type
, innercode
,
6621 gimple_assign_rhs1 (stmt
),
6622 gimple_assign_rhs2 (stmt
),
6630 /* If the definition is an AND or OR expression, we may be able to
6631 simplify by reassociating. */
6632 if (TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
6633 && (innercode
== BIT_AND_EXPR
|| innercode
== BIT_IOR_EXPR
))
6635 tree inner1
= gimple_assign_rhs1 (stmt
);
6636 tree inner2
= gimple_assign_rhs2 (stmt
);
6639 tree partial
= NULL_TREE
;
6640 bool is_and
= (innercode
== BIT_AND_EXPR
);
6642 /* Check for boolean identities that don't require recursive examination
6644 inner1 AND (inner1 AND inner2) => inner1 AND inner2 => var
6645 inner1 AND (inner1 OR inner2) => inner1
6646 !inner1 AND (inner1 AND inner2) => false
6647 !inner1 AND (inner1 OR inner2) => !inner1 AND inner2
6648 Likewise for similar cases involving inner2. */
6649 if (inner1
== true_test_var
)
6650 return (is_and
? var
: inner1
);
6651 else if (inner2
== true_test_var
)
6652 return (is_and
? var
: inner2
);
6653 else if (inner1
== false_test_var
)
6655 ? boolean_false_node
6656 : and_var_with_comparison (type
, inner2
, false, code2
, op2a
,
6658 else if (inner2
== false_test_var
)
6660 ? boolean_false_node
6661 : and_var_with_comparison (type
, inner1
, false, code2
, op2a
,
6664 /* Next, redistribute/reassociate the AND across the inner tests.
6665 Compute the first partial result, (inner1 AND (op2a code op2b)) */
6666 if (TREE_CODE (inner1
) == SSA_NAME
6667 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner1
))
6668 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
6669 && (t
= maybe_fold_and_comparisons (type
, gimple_assign_rhs_code (s
),
6670 gimple_assign_rhs1 (s
),
6671 gimple_assign_rhs2 (s
),
6672 code2
, op2a
, op2b
)))
6674 /* Handle the AND case, where we are reassociating:
6675 (inner1 AND inner2) AND (op2a code2 op2b)
6677 If the partial result t is a constant, we win. Otherwise
6678 continue on to try reassociating with the other inner test. */
6681 if (integer_onep (t
))
6683 else if (integer_zerop (t
))
6684 return boolean_false_node
;
6687 /* Handle the OR case, where we are redistributing:
6688 (inner1 OR inner2) AND (op2a code2 op2b)
6689 => (t OR (inner2 AND (op2a code2 op2b))) */
6690 else if (integer_onep (t
))
6691 return boolean_true_node
;
6693 /* Save partial result for later. */
6697 /* Compute the second partial result, (inner2 AND (op2a code op2b)) */
6698 if (TREE_CODE (inner2
) == SSA_NAME
6699 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner2
))
6700 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
6701 && (t
= maybe_fold_and_comparisons (type
, gimple_assign_rhs_code (s
),
6702 gimple_assign_rhs1 (s
),
6703 gimple_assign_rhs2 (s
),
6704 code2
, op2a
, op2b
)))
6706 /* Handle the AND case, where we are reassociating:
6707 (inner1 AND inner2) AND (op2a code2 op2b)
6708 => (inner1 AND t) */
6711 if (integer_onep (t
))
6713 else if (integer_zerop (t
))
6714 return boolean_false_node
;
6715 /* If both are the same, we can apply the identity
6717 else if (partial
&& same_bool_result_p (t
, partial
))
6721 /* Handle the OR case. where we are redistributing:
6722 (inner1 OR inner2) AND (op2a code2 op2b)
6723 => (t OR (inner1 AND (op2a code2 op2b)))
6724 => (t OR partial) */
6727 if (integer_onep (t
))
6728 return boolean_true_node
;
6731 /* We already got a simplification for the other
6732 operand to the redistributed OR expression. The
6733 interesting case is when at least one is false.
6734 Or, if both are the same, we can apply the identity
6736 if (integer_zerop (partial
))
6738 else if (integer_zerop (t
))
6740 else if (same_bool_result_p (t
, partial
))
6749 /* Try to simplify the AND of two comparisons defined by
6750 (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
6751 If this can be done without constructing an intermediate value,
6752 return the resulting tree; otherwise NULL_TREE is returned.
6753 This function is deliberately asymmetric as it recurses on SSA_DEFs
6754 in the first comparison but not the second. */
6757 and_comparisons_1 (tree type
, enum tree_code code1
, tree op1a
, tree op1b
,
6758 enum tree_code code2
, tree op2a
, tree op2b
)
6760 tree truth_type
= truth_type_for (TREE_TYPE (op1a
));
6762 /* First check for ((x CODE1 y) AND (x CODE2 y)). */
6763 if (operand_equal_p (op1a
, op2a
, 0)
6764 && operand_equal_p (op1b
, op2b
, 0))
6766 /* Result will be either NULL_TREE, or a combined comparison. */
6767 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
6768 TRUTH_ANDIF_EXPR
, code1
, code2
,
6769 truth_type
, op1a
, op1b
);
6774 /* Likewise the swapped case of the above. */
6775 if (operand_equal_p (op1a
, op2b
, 0)
6776 && operand_equal_p (op1b
, op2a
, 0))
6778 /* Result will be either NULL_TREE, or a combined comparison. */
6779 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
6780 TRUTH_ANDIF_EXPR
, code1
,
6781 swap_tree_comparison (code2
),
6782 truth_type
, op1a
, op1b
);
6787 /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
6788 NAME's definition is a truth value. See if there are any simplifications
6789 that can be done against the NAME's definition. */
6790 if (TREE_CODE (op1a
) == SSA_NAME
6791 && (code1
== NE_EXPR
|| code1
== EQ_EXPR
)
6792 && (integer_zerop (op1b
) || integer_onep (op1b
)))
6794 bool invert
= ((code1
== EQ_EXPR
&& integer_zerop (op1b
))
6795 || (code1
== NE_EXPR
&& integer_onep (op1b
)));
6796 gimple
*stmt
= SSA_NAME_DEF_STMT (op1a
);
6797 switch (gimple_code (stmt
))
6800 /* Try to simplify by copy-propagating the definition. */
6801 return and_var_with_comparison (type
, op1a
, invert
, code2
, op2a
,
6805 /* If every argument to the PHI produces the same result when
6806 ANDed with the second comparison, we win.
6807 Do not do this unless the type is bool since we need a bool
6808 result here anyway. */
6809 if (TREE_CODE (TREE_TYPE (op1a
)) == BOOLEAN_TYPE
)
6811 tree result
= NULL_TREE
;
6813 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
6815 tree arg
= gimple_phi_arg_def (stmt
, i
);
6817 /* If this PHI has itself as an argument, ignore it.
6818 If all the other args produce the same result,
6820 if (arg
== gimple_phi_result (stmt
))
6822 else if (TREE_CODE (arg
) == INTEGER_CST
)
6824 if (invert
? integer_nonzerop (arg
) : integer_zerop (arg
))
6827 result
= boolean_false_node
;
6828 else if (!integer_zerop (result
))
6832 result
= fold_build2 (code2
, boolean_type_node
,
6834 else if (!same_bool_comparison_p (result
,
6838 else if (TREE_CODE (arg
) == SSA_NAME
6839 && !SSA_NAME_IS_DEFAULT_DEF (arg
))
6842 gimple
*def_stmt
= SSA_NAME_DEF_STMT (arg
);
6843 /* In simple cases we can look through PHI nodes,
6844 but we have to be careful with loops.
6846 if (! dom_info_available_p (CDI_DOMINATORS
)
6847 || gimple_bb (def_stmt
) == gimple_bb (stmt
)
6848 || dominated_by_p (CDI_DOMINATORS
,
6849 gimple_bb (def_stmt
),
6852 temp
= and_var_with_comparison (type
, arg
, invert
, code2
,
6858 else if (!same_bool_result_p (result
, temp
))
6874 /* Helper function for maybe_fold_and_comparisons and maybe_fold_or_comparisons
6875 : try to simplify the AND/OR of the ssa variable VAR with the comparison
6876 specified by (OP2A CODE2 OP2B) from match.pd. Return NULL_EXPR if we can't
6877 simplify this to a single expression. As we are going to lower the cost
6878 of building SSA names / gimple stmts significantly, we need to allocate
6879 them ont the stack. This will cause the code to be a bit ugly. */
6882 maybe_fold_comparisons_from_match_pd (tree type
, enum tree_code code
,
6883 enum tree_code code1
,
6884 tree op1a
, tree op1b
,
6885 enum tree_code code2
, tree op2a
,
6888 /* Allocate gimple stmt1 on the stack. */
6890 = (gassign
*) XALLOCAVEC (char, gimple_size (GIMPLE_ASSIGN
, 3));
6891 gimple_init (stmt1
, GIMPLE_ASSIGN
, 3);
6892 gimple_assign_set_rhs_code (stmt1
, code1
);
6893 gimple_assign_set_rhs1 (stmt1
, op1a
);
6894 gimple_assign_set_rhs2 (stmt1
, op1b
);
6896 /* Allocate gimple stmt2 on the stack. */
6898 = (gassign
*) XALLOCAVEC (char, gimple_size (GIMPLE_ASSIGN
, 3));
6899 gimple_init (stmt2
, GIMPLE_ASSIGN
, 3);
6900 gimple_assign_set_rhs_code (stmt2
, code2
);
6901 gimple_assign_set_rhs1 (stmt2
, op2a
);
6902 gimple_assign_set_rhs2 (stmt2
, op2b
);
6904 /* Allocate SSA names(lhs1) on the stack. */
6905 tree lhs1
= (tree
)XALLOCA (tree_ssa_name
);
6906 memset (lhs1
, 0, sizeof (tree_ssa_name
));
6907 TREE_SET_CODE (lhs1
, SSA_NAME
);
6908 TREE_TYPE (lhs1
) = type
;
6909 init_ssa_name_imm_use (lhs1
);
6911 /* Allocate SSA names(lhs2) on the stack. */
6912 tree lhs2
= (tree
)XALLOCA (tree_ssa_name
);
6913 memset (lhs2
, 0, sizeof (tree_ssa_name
));
6914 TREE_SET_CODE (lhs2
, SSA_NAME
);
6915 TREE_TYPE (lhs2
) = type
;
6916 init_ssa_name_imm_use (lhs2
);
6918 gimple_assign_set_lhs (stmt1
, lhs1
);
6919 gimple_assign_set_lhs (stmt2
, lhs2
);
6921 gimple_match_op
op (gimple_match_cond::UNCOND
, code
,
6922 type
, gimple_assign_lhs (stmt1
),
6923 gimple_assign_lhs (stmt2
));
6924 if (op
.resimplify (NULL
, follow_all_ssa_edges
))
6926 if (gimple_simplified_result_is_gimple_val (&op
))
6928 tree res
= op
.ops
[0];
6930 return build2 (code1
, type
, op1a
, op1b
);
6931 else if (res
== lhs2
)
6932 return build2 (code2
, type
, op2a
, op2b
);
6936 else if (op
.code
.is_tree_code ()
6937 && TREE_CODE_CLASS ((tree_code
)op
.code
) == tcc_comparison
)
6939 tree op0
= op
.ops
[0];
6940 tree op1
= op
.ops
[1];
6941 if (op0
== lhs1
|| op0
== lhs2
|| op1
== lhs1
|| op1
== lhs2
)
6942 return NULL_TREE
; /* not simple */
6944 return build2 ((enum tree_code
)op
.code
, op
.type
, op0
, op1
);
6951 /* Try to simplify the AND of two comparisons, specified by
6952 (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
6953 If this can be simplified to a single expression (without requiring
6954 introducing more SSA variables to hold intermediate values),
6955 return the resulting tree. Otherwise return NULL_TREE.
6956 If the result expression is non-null, it has boolean type. */
6959 maybe_fold_and_comparisons (tree type
,
6960 enum tree_code code1
, tree op1a
, tree op1b
,
6961 enum tree_code code2
, tree op2a
, tree op2b
)
6963 if (tree t
= and_comparisons_1 (type
, code1
, op1a
, op1b
, code2
, op2a
, op2b
))
6966 if (tree t
= and_comparisons_1 (type
, code2
, op2a
, op2b
, code1
, op1a
, op1b
))
6969 if (tree t
= maybe_fold_comparisons_from_match_pd (type
, BIT_AND_EXPR
, code1
,
6970 op1a
, op1b
, code2
, op2a
,
6977 /* Helper function for or_comparisons_1: try to simplify the OR of the
6978 ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
6979 If INVERT is true, invert the value of VAR before doing the OR.
6980 Return NULL_EXPR if we can't simplify this to a single expression. */
6983 or_var_with_comparison (tree type
, tree var
, bool invert
,
6984 enum tree_code code2
, tree op2a
, tree op2b
)
6987 gimple
*stmt
= SSA_NAME_DEF_STMT (var
);
6989 /* We can only deal with variables whose definitions are assignments. */
6990 if (!is_gimple_assign (stmt
))
6993 /* If we have an inverted comparison, apply DeMorgan's law and rewrite
6994 !var OR (op2a code2 op2b) => !(var AND !(op2a code2 op2b))
6995 Then we only have to consider the simpler non-inverted cases. */
6997 t
= and_var_with_comparison_1 (type
, stmt
,
6998 invert_tree_comparison (code2
, false),
7001 t
= or_var_with_comparison_1 (type
, stmt
, code2
, op2a
, op2b
);
7002 return canonicalize_bool (t
, invert
);
7005 /* Try to simplify the OR of the ssa variable defined by the assignment
7006 STMT with the comparison specified by (OP2A CODE2 OP2B).
7007 Return NULL_EXPR if we can't simplify this to a single expression. */
7010 or_var_with_comparison_1 (tree type
, gimple
*stmt
,
7011 enum tree_code code2
, tree op2a
, tree op2b
)
7013 tree var
= gimple_assign_lhs (stmt
);
7014 tree true_test_var
= NULL_TREE
;
7015 tree false_test_var
= NULL_TREE
;
7016 enum tree_code innercode
= gimple_assign_rhs_code (stmt
);
7018 /* Check for identities like (var OR (var != 0)) => true . */
7019 if (TREE_CODE (op2a
) == SSA_NAME
7020 && TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
)
7022 if ((code2
== NE_EXPR
&& integer_zerop (op2b
))
7023 || (code2
== EQ_EXPR
&& integer_nonzerop (op2b
)))
7025 true_test_var
= op2a
;
7026 if (var
== true_test_var
)
7029 else if ((code2
== EQ_EXPR
&& integer_zerop (op2b
))
7030 || (code2
== NE_EXPR
&& integer_nonzerop (op2b
)))
7032 false_test_var
= op2a
;
7033 if (var
== false_test_var
)
7034 return boolean_true_node
;
7038 /* If the definition is a comparison, recurse on it. */
7039 if (TREE_CODE_CLASS (innercode
) == tcc_comparison
)
7041 tree t
= or_comparisons_1 (type
, innercode
,
7042 gimple_assign_rhs1 (stmt
),
7043 gimple_assign_rhs2 (stmt
),
7051 /* If the definition is an AND or OR expression, we may be able to
7052 simplify by reassociating. */
7053 if (TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
7054 && (innercode
== BIT_AND_EXPR
|| innercode
== BIT_IOR_EXPR
))
7056 tree inner1
= gimple_assign_rhs1 (stmt
);
7057 tree inner2
= gimple_assign_rhs2 (stmt
);
7060 tree partial
= NULL_TREE
;
7061 bool is_or
= (innercode
== BIT_IOR_EXPR
);
7063 /* Check for boolean identities that don't require recursive examination
7065 inner1 OR (inner1 OR inner2) => inner1 OR inner2 => var
7066 inner1 OR (inner1 AND inner2) => inner1
7067 !inner1 OR (inner1 OR inner2) => true
7068 !inner1 OR (inner1 AND inner2) => !inner1 OR inner2
7070 if (inner1
== true_test_var
)
7071 return (is_or
? var
: inner1
);
7072 else if (inner2
== true_test_var
)
7073 return (is_or
? var
: inner2
);
7074 else if (inner1
== false_test_var
)
7077 : or_var_with_comparison (type
, inner2
, false, code2
, op2a
,
7079 else if (inner2
== false_test_var
)
7082 : or_var_with_comparison (type
, inner1
, false, code2
, op2a
,
7085 /* Next, redistribute/reassociate the OR across the inner tests.
7086 Compute the first partial result, (inner1 OR (op2a code op2b)) */
7087 if (TREE_CODE (inner1
) == SSA_NAME
7088 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner1
))
7089 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
7090 && (t
= maybe_fold_or_comparisons (type
, gimple_assign_rhs_code (s
),
7091 gimple_assign_rhs1 (s
),
7092 gimple_assign_rhs2 (s
),
7093 code2
, op2a
, op2b
)))
7095 /* Handle the OR case, where we are reassociating:
7096 (inner1 OR inner2) OR (op2a code2 op2b)
7098 If the partial result t is a constant, we win. Otherwise
7099 continue on to try reassociating with the other inner test. */
7102 if (integer_onep (t
))
7103 return boolean_true_node
;
7104 else if (integer_zerop (t
))
7108 /* Handle the AND case, where we are redistributing:
7109 (inner1 AND inner2) OR (op2a code2 op2b)
7110 => (t AND (inner2 OR (op2a code op2b))) */
7111 else if (integer_zerop (t
))
7112 return boolean_false_node
;
7114 /* Save partial result for later. */
7118 /* Compute the second partial result, (inner2 OR (op2a code op2b)) */
7119 if (TREE_CODE (inner2
) == SSA_NAME
7120 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner2
))
7121 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
7122 && (t
= maybe_fold_or_comparisons (type
, gimple_assign_rhs_code (s
),
7123 gimple_assign_rhs1 (s
),
7124 gimple_assign_rhs2 (s
),
7125 code2
, op2a
, op2b
)))
7127 /* Handle the OR case, where we are reassociating:
7128 (inner1 OR inner2) OR (op2a code2 op2b)
7130 => (t OR partial) */
7133 if (integer_zerop (t
))
7135 else if (integer_onep (t
))
7136 return boolean_true_node
;
7137 /* If both are the same, we can apply the identity
7139 else if (partial
&& same_bool_result_p (t
, partial
))
7143 /* Handle the AND case, where we are redistributing:
7144 (inner1 AND inner2) OR (op2a code2 op2b)
7145 => (t AND (inner1 OR (op2a code2 op2b)))
7146 => (t AND partial) */
7149 if (integer_zerop (t
))
7150 return boolean_false_node
;
7153 /* We already got a simplification for the other
7154 operand to the redistributed AND expression. The
7155 interesting case is when at least one is true.
7156 Or, if both are the same, we can apply the identity
7158 if (integer_onep (partial
))
7160 else if (integer_onep (t
))
7162 else if (same_bool_result_p (t
, partial
))
7171 /* Try to simplify the OR of two comparisons defined by
7172 (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
7173 If this can be done without constructing an intermediate value,
7174 return the resulting tree; otherwise NULL_TREE is returned.
7175 This function is deliberately asymmetric as it recurses on SSA_DEFs
7176 in the first comparison but not the second. */
7179 or_comparisons_1 (tree type
, enum tree_code code1
, tree op1a
, tree op1b
,
7180 enum tree_code code2
, tree op2a
, tree op2b
)
7182 tree truth_type
= truth_type_for (TREE_TYPE (op1a
));
7184 /* First check for ((x CODE1 y) OR (x CODE2 y)). */
7185 if (operand_equal_p (op1a
, op2a
, 0)
7186 && operand_equal_p (op1b
, op2b
, 0))
7188 /* Result will be either NULL_TREE, or a combined comparison. */
7189 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
7190 TRUTH_ORIF_EXPR
, code1
, code2
,
7191 truth_type
, op1a
, op1b
);
7196 /* Likewise the swapped case of the above. */
7197 if (operand_equal_p (op1a
, op2b
, 0)
7198 && operand_equal_p (op1b
, op2a
, 0))
7200 /* Result will be either NULL_TREE, or a combined comparison. */
7201 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
7202 TRUTH_ORIF_EXPR
, code1
,
7203 swap_tree_comparison (code2
),
7204 truth_type
, op1a
, op1b
);
7209 /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
7210 NAME's definition is a truth value. See if there are any simplifications
7211 that can be done against the NAME's definition. */
7212 if (TREE_CODE (op1a
) == SSA_NAME
7213 && (code1
== NE_EXPR
|| code1
== EQ_EXPR
)
7214 && (integer_zerop (op1b
) || integer_onep (op1b
)))
7216 bool invert
= ((code1
== EQ_EXPR
&& integer_zerop (op1b
))
7217 || (code1
== NE_EXPR
&& integer_onep (op1b
)));
7218 gimple
*stmt
= SSA_NAME_DEF_STMT (op1a
);
7219 switch (gimple_code (stmt
))
7222 /* Try to simplify by copy-propagating the definition. */
7223 return or_var_with_comparison (type
, op1a
, invert
, code2
, op2a
,
7227 /* If every argument to the PHI produces the same result when
7228 ORed with the second comparison, we win.
7229 Do not do this unless the type is bool since we need a bool
7230 result here anyway. */
7231 if (TREE_CODE (TREE_TYPE (op1a
)) == BOOLEAN_TYPE
)
7233 tree result
= NULL_TREE
;
7235 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
7237 tree arg
= gimple_phi_arg_def (stmt
, i
);
7239 /* If this PHI has itself as an argument, ignore it.
7240 If all the other args produce the same result,
7242 if (arg
== gimple_phi_result (stmt
))
7244 else if (TREE_CODE (arg
) == INTEGER_CST
)
7246 if (invert
? integer_zerop (arg
) : integer_nonzerop (arg
))
7249 result
= boolean_true_node
;
7250 else if (!integer_onep (result
))
7254 result
= fold_build2 (code2
, boolean_type_node
,
7256 else if (!same_bool_comparison_p (result
,
7260 else if (TREE_CODE (arg
) == SSA_NAME
7261 && !SSA_NAME_IS_DEFAULT_DEF (arg
))
7264 gimple
*def_stmt
= SSA_NAME_DEF_STMT (arg
);
7265 /* In simple cases we can look through PHI nodes,
7266 but we have to be careful with loops.
7268 if (! dom_info_available_p (CDI_DOMINATORS
)
7269 || gimple_bb (def_stmt
) == gimple_bb (stmt
)
7270 || dominated_by_p (CDI_DOMINATORS
,
7271 gimple_bb (def_stmt
),
7274 temp
= or_var_with_comparison (type
, arg
, invert
, code2
,
7280 else if (!same_bool_result_p (result
, temp
))
7296 /* Try to simplify the OR of two comparisons, specified by
7297 (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
7298 If this can be simplified to a single expression (without requiring
7299 introducing more SSA variables to hold intermediate values),
7300 return the resulting tree. Otherwise return NULL_TREE.
7301 If the result expression is non-null, it has boolean type. */
7304 maybe_fold_or_comparisons (tree type
,
7305 enum tree_code code1
, tree op1a
, tree op1b
,
7306 enum tree_code code2
, tree op2a
, tree op2b
)
7308 if (tree t
= or_comparisons_1 (type
, code1
, op1a
, op1b
, code2
, op2a
, op2b
))
7311 if (tree t
= or_comparisons_1 (type
, code2
, op2a
, op2b
, code1
, op1a
, op1b
))
7314 if (tree t
= maybe_fold_comparisons_from_match_pd (type
, BIT_IOR_EXPR
, code1
,
7315 op1a
, op1b
, code2
, op2a
,
7322 /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
7324 Either NULL_TREE, a simplified but non-constant or a constant
7327 ??? This should go into a gimple-fold-inline.h file to be eventually
7328 privatized with the single valueize function used in the various TUs
7329 to avoid the indirect function call overhead. */
7332 gimple_fold_stmt_to_constant_1 (gimple
*stmt
, tree (*valueize
) (tree
),
7333 tree (*gvalueize
) (tree
))
7335 gimple_match_op res_op
;
7336 /* ??? The SSA propagators do not correctly deal with following SSA use-def
7337 edges if there are intermediate VARYING defs. For this reason
7338 do not follow SSA edges here even though SCCVN can technically
7339 just deal fine with that. */
7340 if (gimple_simplify (stmt
, &res_op
, NULL
, gvalueize
, valueize
))
7342 tree res
= NULL_TREE
;
7343 if (gimple_simplified_result_is_gimple_val (&res_op
))
7344 res
= res_op
.ops
[0];
7345 else if (mprts_hook
)
7346 res
= mprts_hook (&res_op
);
7349 if (dump_file
&& dump_flags
& TDF_DETAILS
)
7351 fprintf (dump_file
, "Match-and-simplified ");
7352 print_gimple_expr (dump_file
, stmt
, 0, TDF_SLIM
);
7353 fprintf (dump_file
, " to ");
7354 print_generic_expr (dump_file
, res
);
7355 fprintf (dump_file
, "\n");
7361 location_t loc
= gimple_location (stmt
);
7362 switch (gimple_code (stmt
))
7366 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
7368 switch (get_gimple_rhs_class (subcode
))
7370 case GIMPLE_SINGLE_RHS
:
7372 tree rhs
= gimple_assign_rhs1 (stmt
);
7373 enum tree_code_class kind
= TREE_CODE_CLASS (subcode
);
7375 if (TREE_CODE (rhs
) == SSA_NAME
)
7377 /* If the RHS is an SSA_NAME, return its known constant value,
7379 return (*valueize
) (rhs
);
7381 /* Handle propagating invariant addresses into address
7383 else if (TREE_CODE (rhs
) == ADDR_EXPR
7384 && !is_gimple_min_invariant (rhs
))
7386 poly_int64 offset
= 0;
7388 base
= get_addr_base_and_unit_offset_1 (TREE_OPERAND (rhs
, 0),
7392 && (CONSTANT_CLASS_P (base
)
7393 || decl_address_invariant_p (base
)))
7394 return build_invariant_address (TREE_TYPE (rhs
),
7397 else if (TREE_CODE (rhs
) == CONSTRUCTOR
7398 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
7399 && known_eq (CONSTRUCTOR_NELTS (rhs
),
7400 TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs
))))
7405 nelts
= CONSTRUCTOR_NELTS (rhs
);
7406 tree_vector_builder
vec (TREE_TYPE (rhs
), nelts
, 1);
7407 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
7409 val
= (*valueize
) (val
);
7410 if (TREE_CODE (val
) == INTEGER_CST
7411 || TREE_CODE (val
) == REAL_CST
7412 || TREE_CODE (val
) == FIXED_CST
)
7413 vec
.quick_push (val
);
7418 return vec
.build ();
7420 if (subcode
== OBJ_TYPE_REF
)
7422 tree val
= (*valueize
) (OBJ_TYPE_REF_EXPR (rhs
));
7423 /* If callee is constant, we can fold away the wrapper. */
7424 if (is_gimple_min_invariant (val
))
7428 if (kind
== tcc_reference
)
7430 if ((TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
7431 || TREE_CODE (rhs
) == REALPART_EXPR
7432 || TREE_CODE (rhs
) == IMAGPART_EXPR
)
7433 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
7435 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
7436 return fold_unary_loc (EXPR_LOCATION (rhs
),
7438 TREE_TYPE (rhs
), val
);
7440 else if (TREE_CODE (rhs
) == BIT_FIELD_REF
7441 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
7443 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
7444 return fold_ternary_loc (EXPR_LOCATION (rhs
),
7446 TREE_TYPE (rhs
), val
,
7447 TREE_OPERAND (rhs
, 1),
7448 TREE_OPERAND (rhs
, 2));
7450 else if (TREE_CODE (rhs
) == MEM_REF
7451 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
7453 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
7454 if (TREE_CODE (val
) == ADDR_EXPR
7455 && is_gimple_min_invariant (val
))
7457 tree tem
= fold_build2 (MEM_REF
, TREE_TYPE (rhs
),
7459 TREE_OPERAND (rhs
, 1));
7464 return fold_const_aggregate_ref_1 (rhs
, valueize
);
7466 else if (kind
== tcc_declaration
)
7467 return get_symbol_constant_value (rhs
);
7471 case GIMPLE_UNARY_RHS
:
7474 case GIMPLE_BINARY_RHS
:
7475 /* Translate &x + CST into an invariant form suitable for
7476 further propagation. */
7477 if (subcode
== POINTER_PLUS_EXPR
)
7479 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
7480 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
7481 if (TREE_CODE (op0
) == ADDR_EXPR
7482 && TREE_CODE (op1
) == INTEGER_CST
)
7484 tree off
= fold_convert (ptr_type_node
, op1
);
7486 (loc
, ADDR_EXPR
, TREE_TYPE (op0
),
7487 fold_build2 (MEM_REF
,
7488 TREE_TYPE (TREE_TYPE (op0
)),
7489 unshare_expr (op0
), off
));
7492 /* Canonicalize bool != 0 and bool == 0 appearing after
7493 valueization. While gimple_simplify handles this
7494 it can get confused by the ~X == 1 -> X == 0 transform
7495 which we cant reduce to a SSA name or a constant
7496 (and we have no way to tell gimple_simplify to not
7497 consider those transforms in the first place). */
7498 else if (subcode
== EQ_EXPR
7499 || subcode
== NE_EXPR
)
7501 tree lhs
= gimple_assign_lhs (stmt
);
7502 tree op0
= gimple_assign_rhs1 (stmt
);
7503 if (useless_type_conversion_p (TREE_TYPE (lhs
),
7506 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
7507 op0
= (*valueize
) (op0
);
7508 if (TREE_CODE (op0
) == INTEGER_CST
)
7509 std::swap (op0
, op1
);
7510 if (TREE_CODE (op1
) == INTEGER_CST
7511 && ((subcode
== NE_EXPR
&& integer_zerop (op1
))
7512 || (subcode
== EQ_EXPR
&& integer_onep (op1
))))
7518 case GIMPLE_TERNARY_RHS
:
7520 /* Handle ternary operators that can appear in GIMPLE form. */
7521 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
7522 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
7523 tree op2
= (*valueize
) (gimple_assign_rhs3 (stmt
));
7524 return fold_ternary_loc (loc
, subcode
,
7525 TREE_TYPE (gimple_assign_lhs (stmt
)),
7537 gcall
*call_stmt
= as_a
<gcall
*> (stmt
);
7539 if (gimple_call_internal_p (stmt
))
7541 enum tree_code subcode
= ERROR_MARK
;
7542 switch (gimple_call_internal_fn (stmt
))
7544 case IFN_UBSAN_CHECK_ADD
:
7545 subcode
= PLUS_EXPR
;
7547 case IFN_UBSAN_CHECK_SUB
:
7548 subcode
= MINUS_EXPR
;
7550 case IFN_UBSAN_CHECK_MUL
:
7551 subcode
= MULT_EXPR
;
7553 case IFN_BUILTIN_EXPECT
:
7555 tree arg0
= gimple_call_arg (stmt
, 0);
7556 tree op0
= (*valueize
) (arg0
);
7557 if (TREE_CODE (op0
) == INTEGER_CST
)
7564 tree arg0
= gimple_call_arg (stmt
, 0);
7565 tree arg1
= gimple_call_arg (stmt
, 1);
7566 tree op0
= (*valueize
) (arg0
);
7567 tree op1
= (*valueize
) (arg1
);
7569 if (TREE_CODE (op0
) != INTEGER_CST
7570 || TREE_CODE (op1
) != INTEGER_CST
)
7575 /* x * 0 = 0 * x = 0 without overflow. */
7576 if (integer_zerop (op0
) || integer_zerop (op1
))
7577 return build_zero_cst (TREE_TYPE (arg0
));
7580 /* y - y = 0 without overflow. */
7581 if (operand_equal_p (op0
, op1
, 0))
7582 return build_zero_cst (TREE_TYPE (arg0
));
7589 = fold_binary_loc (loc
, subcode
, TREE_TYPE (arg0
), op0
, op1
);
7591 && TREE_CODE (res
) == INTEGER_CST
7592 && !TREE_OVERFLOW (res
))
7597 fn
= (*valueize
) (gimple_call_fn (stmt
));
7598 if (TREE_CODE (fn
) == ADDR_EXPR
7599 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
7600 && fndecl_built_in_p (TREE_OPERAND (fn
, 0))
7601 && gimple_builtin_call_types_compatible_p (stmt
,
7602 TREE_OPERAND (fn
, 0)))
7604 tree
*args
= XALLOCAVEC (tree
, gimple_call_num_args (stmt
));
7607 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
7608 args
[i
] = (*valueize
) (gimple_call_arg (stmt
, i
));
7609 retval
= fold_builtin_call_array (loc
,
7610 gimple_call_return_type (call_stmt
),
7611 fn
, gimple_call_num_args (stmt
), args
);
7614 /* fold_call_expr wraps the result inside a NOP_EXPR. */
7615 STRIP_NOPS (retval
);
7616 retval
= fold_convert (gimple_call_return_type (call_stmt
),
7629 /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
7630 Returns NULL_TREE if folding to a constant is not possible, otherwise
7631 returns a constant according to is_gimple_min_invariant. */
7634 gimple_fold_stmt_to_constant (gimple
*stmt
, tree (*valueize
) (tree
))
7636 tree res
= gimple_fold_stmt_to_constant_1 (stmt
, valueize
);
7637 if (res
&& is_gimple_min_invariant (res
))
7643 /* The following set of functions are supposed to fold references using
7644 their constant initializers. */
7646 /* See if we can find constructor defining value of BASE.
7647 When we know the consructor with constant offset (such as
7648 base is array[40] and we do know constructor of array), then
7649 BIT_OFFSET is adjusted accordingly.
7651 As a special case, return error_mark_node when constructor
7652 is not explicitly available, but it is known to be zero
7653 such as 'static const int a;'. */
7655 get_base_constructor (tree base
, poly_int64_pod
*bit_offset
,
7656 tree (*valueize
)(tree
))
7658 poly_int64 bit_offset2
, size
, max_size
;
7661 if (TREE_CODE (base
) == MEM_REF
)
7663 poly_offset_int boff
= *bit_offset
+ mem_ref_offset (base
) * BITS_PER_UNIT
;
7664 if (!boff
.to_shwi (bit_offset
))
7668 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
7669 base
= valueize (TREE_OPERAND (base
, 0));
7670 if (!base
|| TREE_CODE (base
) != ADDR_EXPR
)
7672 base
= TREE_OPERAND (base
, 0);
7675 && TREE_CODE (base
) == SSA_NAME
)
7676 base
= valueize (base
);
7678 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
7679 DECL_INITIAL. If BASE is a nested reference into another
7680 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
7681 the inner reference. */
7682 switch (TREE_CODE (base
))
7687 tree init
= ctor_for_folding (base
);
7689 /* Our semantic is exact opposite of ctor_for_folding;
7690 NULL means unknown, while error_mark_node is 0. */
7691 if (init
== error_mark_node
)
7694 return error_mark_node
;
7698 case VIEW_CONVERT_EXPR
:
7699 return get_base_constructor (TREE_OPERAND (base
, 0),
7700 bit_offset
, valueize
);
7704 base
= get_ref_base_and_extent (base
, &bit_offset2
, &size
, &max_size
,
7706 if (!known_size_p (max_size
) || maybe_ne (size
, max_size
))
7708 *bit_offset
+= bit_offset2
;
7709 return get_base_constructor (base
, bit_offset
, valueize
);
7715 if (CONSTANT_CLASS_P (base
))
7722 /* CTOR is CONSTRUCTOR of an array type. Fold a reference of SIZE bits
7723 to the memory at bit OFFSET. When non-null, TYPE is the expected
7724 type of the reference; otherwise the type of the referenced element
7725 is used instead. When SIZE is zero, attempt to fold a reference to
7726 the entire element which OFFSET refers to. Increment *SUBOFF by
7727 the bit offset of the accessed element. */
7730 fold_array_ctor_reference (tree type
, tree ctor
,
7731 unsigned HOST_WIDE_INT offset
,
7732 unsigned HOST_WIDE_INT size
,
7734 unsigned HOST_WIDE_INT
*suboff
)
7736 offset_int low_bound
;
7737 offset_int elt_size
;
7738 offset_int access_index
;
7739 tree domain_type
= NULL_TREE
;
7740 HOST_WIDE_INT inner_offset
;
7742 /* Compute low bound and elt size. */
7743 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
7744 domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
7745 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
7747 /* Static constructors for variably sized objects make no sense. */
7748 if (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) != INTEGER_CST
)
7750 low_bound
= wi::to_offset (TYPE_MIN_VALUE (domain_type
));
7754 /* Static constructors for variably sized objects make no sense. */
7755 if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor
)))) != INTEGER_CST
)
7757 elt_size
= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor
))));
7759 /* When TYPE is non-null, verify that it specifies a constant-sized
7760 access of a multiple of the array element size. Avoid division
7761 by zero below when ELT_SIZE is zero, such as with the result of
7762 an initializer for a zero-length array or an empty struct. */
7765 && (!TYPE_SIZE_UNIT (type
)
7766 || TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)))
7769 /* Compute the array index we look for. */
7770 access_index
= wi::udiv_trunc (offset_int (offset
/ BITS_PER_UNIT
),
7772 access_index
+= low_bound
;
7774 /* And offset within the access. */
7775 inner_offset
= offset
% (elt_size
.to_uhwi () * BITS_PER_UNIT
);
7777 unsigned HOST_WIDE_INT elt_sz
= elt_size
.to_uhwi ();
7778 if (size
> elt_sz
* BITS_PER_UNIT
)
7780 /* native_encode_expr constraints. */
7781 if (size
> MAX_BITSIZE_MODE_ANY_MODE
7782 || size
% BITS_PER_UNIT
!= 0
7783 || inner_offset
% BITS_PER_UNIT
!= 0
7784 || elt_sz
> MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
)
7788 tree val
= get_array_ctor_element_at_index (ctor
, access_index
,
7790 if (!val
&& ctor_idx
>= CONSTRUCTOR_NELTS (ctor
))
7791 return build_zero_cst (type
);
7793 /* native-encode adjacent ctor elements. */
7794 unsigned char buf
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
7795 unsigned bufoff
= 0;
7796 offset_int index
= 0;
7797 offset_int max_index
= access_index
;
7798 constructor_elt
*elt
= CONSTRUCTOR_ELT (ctor
, ctor_idx
);
7800 val
= build_zero_cst (TREE_TYPE (TREE_TYPE (ctor
)));
7801 else if (!CONSTANT_CLASS_P (val
))
7805 else if (TREE_CODE (elt
->index
) == RANGE_EXPR
)
7807 index
= wi::to_offset (TREE_OPERAND (elt
->index
, 0));
7808 max_index
= wi::to_offset (TREE_OPERAND (elt
->index
, 1));
7811 index
= max_index
= wi::to_offset (elt
->index
);
7812 index
= wi::umax (index
, access_index
);
7815 if (bufoff
+ elt_sz
> sizeof (buf
))
7816 elt_sz
= sizeof (buf
) - bufoff
;
7817 int len
= native_encode_expr (val
, buf
+ bufoff
, elt_sz
,
7818 inner_offset
/ BITS_PER_UNIT
);
7819 if (len
!= (int) elt_sz
- inner_offset
/ BITS_PER_UNIT
)
7825 if (wi::cmpu (access_index
, index
) == 0)
7827 else if (wi::cmpu (access_index
, max_index
) > 0)
7830 if (ctor_idx
>= CONSTRUCTOR_NELTS (ctor
))
7832 val
= build_zero_cst (TREE_TYPE (TREE_TYPE (ctor
)));
7837 elt
= CONSTRUCTOR_ELT (ctor
, ctor_idx
);
7839 max_index
= access_index
;
7842 else if (TREE_CODE (elt
->index
) == RANGE_EXPR
)
7844 index
= wi::to_offset (TREE_OPERAND (elt
->index
, 0));
7845 max_index
= wi::to_offset (TREE_OPERAND (elt
->index
, 1));
7848 index
= max_index
= wi::to_offset (elt
->index
);
7849 index
= wi::umax (index
, access_index
);
7850 if (wi::cmpu (access_index
, index
) == 0)
7853 val
= build_zero_cst (TREE_TYPE (TREE_TYPE (ctor
)));
7857 while (bufoff
< size
/ BITS_PER_UNIT
);
7859 return native_interpret_expr (type
, buf
, size
/ BITS_PER_UNIT
);
7862 if (tree val
= get_array_ctor_element_at_index (ctor
, access_index
))
7864 if (!size
&& TREE_CODE (val
) != CONSTRUCTOR
)
7866 /* For the final reference to the entire accessed element
7867 (SIZE is zero), reset INNER_OFFSET, disegard TYPE (which
7868 may be null) in favor of the type of the element, and set
7869 SIZE to the size of the accessed element. */
7871 type
= TREE_TYPE (val
);
7872 size
= elt_sz
* BITS_PER_UNIT
;
7874 else if (size
&& access_index
< CONSTRUCTOR_NELTS (ctor
) - 1
7875 && TREE_CODE (val
) == CONSTRUCTOR
7876 && (elt_sz
* BITS_PER_UNIT
- inner_offset
) < size
)
7877 /* If this isn't the last element in the CTOR and a CTOR itself
7878 and it does not cover the whole object we are requesting give up
7879 since we're not set up for combining from multiple CTORs. */
7882 *suboff
+= access_index
.to_uhwi () * elt_sz
* BITS_PER_UNIT
;
7883 return fold_ctor_reference (type
, val
, inner_offset
, size
, from_decl
,
7887 /* Memory not explicitly mentioned in constructor is 0 (or
7888 the reference is out of range). */
7889 return type
? build_zero_cst (type
) : NULL_TREE
;
7892 /* CTOR is CONSTRUCTOR of an aggregate or vector. Fold a reference
7893 of SIZE bits to the memory at bit OFFSET. When non-null, TYPE
7894 is the expected type of the reference; otherwise the type of
7895 the referenced member is used instead. When SIZE is zero,
7896 attempt to fold a reference to the entire member which OFFSET
7897 refers to; in this case. Increment *SUBOFF by the bit offset
7898 of the accessed member. */
7901 fold_nonarray_ctor_reference (tree type
, tree ctor
,
7902 unsigned HOST_WIDE_INT offset
,
7903 unsigned HOST_WIDE_INT size
,
7905 unsigned HOST_WIDE_INT
*suboff
)
7907 unsigned HOST_WIDE_INT cnt
;
7910 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
,
7913 tree byte_offset
= DECL_FIELD_OFFSET (cfield
);
7914 tree field_offset
= DECL_FIELD_BIT_OFFSET (cfield
);
7915 tree field_size
= DECL_SIZE (cfield
);
7919 /* Determine the size of the flexible array member from
7920 the size of the initializer provided for it. */
7921 field_size
= TYPE_SIZE (TREE_TYPE (cval
));
7924 /* Variable sized objects in static constructors makes no sense,
7925 but field_size can be NULL for flexible array members. */
7926 gcc_assert (TREE_CODE (field_offset
) == INTEGER_CST
7927 && TREE_CODE (byte_offset
) == INTEGER_CST
7928 && (field_size
!= NULL_TREE
7929 ? TREE_CODE (field_size
) == INTEGER_CST
7930 : TREE_CODE (TREE_TYPE (cfield
)) == ARRAY_TYPE
));
7932 /* Compute bit offset of the field. */
7933 offset_int bitoffset
7934 = (wi::to_offset (field_offset
)
7935 + (wi::to_offset (byte_offset
) << LOG2_BITS_PER_UNIT
));
7936 /* Compute bit offset where the field ends. */
7937 offset_int bitoffset_end
;
7938 if (field_size
!= NULL_TREE
)
7939 bitoffset_end
= bitoffset
+ wi::to_offset (field_size
);
7943 /* Compute the bit offset of the end of the desired access.
7944 As a special case, if the size of the desired access is
7945 zero, assume the access is to the entire field (and let
7946 the caller make any necessary adjustments by storing
7947 the actual bounds of the field in FIELDBOUNDS). */
7948 offset_int access_end
= offset_int (offset
);
7952 access_end
= bitoffset_end
;
7954 /* Is there any overlap between the desired access at
7955 [OFFSET, OFFSET+SIZE) and the offset of the field within
7956 the object at [BITOFFSET, BITOFFSET_END)? */
7957 if (wi::cmps (access_end
, bitoffset
) > 0
7958 && (field_size
== NULL_TREE
7959 || wi::lts_p (offset
, bitoffset_end
)))
7961 *suboff
+= bitoffset
.to_uhwi ();
7963 if (!size
&& TREE_CODE (cval
) != CONSTRUCTOR
)
7965 /* For the final reference to the entire accessed member
7966 (SIZE is zero), reset OFFSET, disegard TYPE (which may
7967 be null) in favor of the type of the member, and set
7968 SIZE to the size of the accessed member. */
7969 offset
= bitoffset
.to_uhwi ();
7970 type
= TREE_TYPE (cval
);
7971 size
= (bitoffset_end
- bitoffset
).to_uhwi ();
7974 /* We do have overlap. Now see if the field is large enough
7975 to cover the access. Give up for accesses that extend
7976 beyond the end of the object or that span multiple fields. */
7977 if (wi::cmps (access_end
, bitoffset_end
) > 0)
7979 if (offset
< bitoffset
)
7982 offset_int inner_offset
= offset_int (offset
) - bitoffset
;
7983 return fold_ctor_reference (type
, cval
,
7984 inner_offset
.to_uhwi (), size
,
7992 return build_zero_cst (type
);
7995 /* CTOR is value initializing memory. Fold a reference of TYPE and
7996 bit size POLY_SIZE to the memory at bit POLY_OFFSET. When POLY_SIZE
7997 is zero, attempt to fold a reference to the entire subobject
7998 which OFFSET refers to. This is used when folding accesses to
7999 string members of aggregates. When non-null, set *SUBOFF to
8000 the bit offset of the accessed subobject. */
8003 fold_ctor_reference (tree type
, tree ctor
, const poly_uint64
&poly_offset
,
8004 const poly_uint64
&poly_size
, tree from_decl
,
8005 unsigned HOST_WIDE_INT
*suboff
/* = NULL */)
8009 /* We found the field with exact match. */
8011 && useless_type_conversion_p (type
, TREE_TYPE (ctor
))
8012 && known_eq (poly_offset
, 0U))
8013 return canonicalize_constructor_val (unshare_expr (ctor
), from_decl
);
8015 /* The remaining optimizations need a constant size and offset. */
8016 unsigned HOST_WIDE_INT size
, offset
;
8017 if (!poly_size
.is_constant (&size
) || !poly_offset
.is_constant (&offset
))
8020 /* We are at the end of walk, see if we can view convert the
8022 if (!AGGREGATE_TYPE_P (TREE_TYPE (ctor
)) && !offset
8023 /* VIEW_CONVERT_EXPR is defined only for matching sizes. */
8024 && !compare_tree_int (TYPE_SIZE (type
), size
)
8025 && !compare_tree_int (TYPE_SIZE (TREE_TYPE (ctor
)), size
))
8027 ret
= canonicalize_constructor_val (unshare_expr (ctor
), from_decl
);
8030 ret
= fold_unary (VIEW_CONVERT_EXPR
, type
, ret
);
8032 STRIP_USELESS_TYPE_CONVERSION (ret
);
8036 /* For constants and byte-aligned/sized reads try to go through
8037 native_encode/interpret. */
8038 if (CONSTANT_CLASS_P (ctor
)
8039 && BITS_PER_UNIT
== 8
8040 && offset
% BITS_PER_UNIT
== 0
8041 && offset
/ BITS_PER_UNIT
<= INT_MAX
8042 && size
% BITS_PER_UNIT
== 0
8043 && size
<= MAX_BITSIZE_MODE_ANY_MODE
8044 && can_native_interpret_type_p (type
))
8046 unsigned char buf
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
8047 int len
= native_encode_expr (ctor
, buf
, size
/ BITS_PER_UNIT
,
8048 offset
/ BITS_PER_UNIT
);
8050 return native_interpret_expr (type
, buf
, len
);
8052 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
8054 unsigned HOST_WIDE_INT dummy
= 0;
8059 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
8060 || TREE_CODE (TREE_TYPE (ctor
)) == VECTOR_TYPE
)
8061 ret
= fold_array_ctor_reference (type
, ctor
, offset
, size
,
8064 ret
= fold_nonarray_ctor_reference (type
, ctor
, offset
, size
,
8067 /* Fall back to native_encode_initializer. Needs to be done
8068 only in the outermost fold_ctor_reference call (because it itself
8069 recurses into CONSTRUCTORs) and doesn't update suboff. */
8070 if (ret
== NULL_TREE
8072 && BITS_PER_UNIT
== 8
8073 && offset
% BITS_PER_UNIT
== 0
8074 && offset
/ BITS_PER_UNIT
<= INT_MAX
8075 && size
% BITS_PER_UNIT
== 0
8076 && size
<= MAX_BITSIZE_MODE_ANY_MODE
8077 && can_native_interpret_type_p (type
))
8079 unsigned char buf
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
8080 int len
= native_encode_initializer (ctor
, buf
, size
/ BITS_PER_UNIT
,
8081 offset
/ BITS_PER_UNIT
);
8083 return native_interpret_expr (type
, buf
, len
);
8092 /* Return the tree representing the element referenced by T if T is an
8093 ARRAY_REF or COMPONENT_REF into constant aggregates valuezing SSA
8094 names using VALUEIZE. Return NULL_TREE otherwise. */
8097 fold_const_aggregate_ref_1 (tree t
, tree (*valueize
) (tree
))
8099 tree ctor
, idx
, base
;
8100 poly_int64 offset
, size
, max_size
;
8104 if (TREE_THIS_VOLATILE (t
))
8108 return get_symbol_constant_value (t
);
8110 tem
= fold_read_from_constant_string (t
);
8114 switch (TREE_CODE (t
))
8117 case ARRAY_RANGE_REF
:
8118 /* Constant indexes are handled well by get_base_constructor.
8119 Only special case variable offsets.
8120 FIXME: This code can't handle nested references with variable indexes
8121 (they will be handled only by iteration of ccp). Perhaps we can bring
8122 get_ref_base_and_extent here and make it use a valueize callback. */
8123 if (TREE_CODE (TREE_OPERAND (t
, 1)) == SSA_NAME
8125 && (idx
= (*valueize
) (TREE_OPERAND (t
, 1)))
8126 && poly_int_tree_p (idx
))
8128 tree low_bound
, unit_size
;
8130 /* If the resulting bit-offset is constant, track it. */
8131 if ((low_bound
= array_ref_low_bound (t
),
8132 poly_int_tree_p (low_bound
))
8133 && (unit_size
= array_ref_element_size (t
),
8134 tree_fits_uhwi_p (unit_size
)))
8136 poly_offset_int woffset
8137 = wi::sext (wi::to_poly_offset (idx
)
8138 - wi::to_poly_offset (low_bound
),
8139 TYPE_PRECISION (sizetype
));
8140 woffset
*= tree_to_uhwi (unit_size
);
8141 woffset
*= BITS_PER_UNIT
;
8142 if (woffset
.to_shwi (&offset
))
8144 base
= TREE_OPERAND (t
, 0);
8145 ctor
= get_base_constructor (base
, &offset
, valueize
);
8146 /* Empty constructor. Always fold to 0. */
8147 if (ctor
== error_mark_node
)
8148 return build_zero_cst (TREE_TYPE (t
));
8149 /* Out of bound array access. Value is undefined,
8151 if (maybe_lt (offset
, 0))
8153 /* We cannot determine ctor. */
8156 return fold_ctor_reference (TREE_TYPE (t
), ctor
, offset
,
8157 tree_to_uhwi (unit_size
)
8167 case TARGET_MEM_REF
:
8169 base
= get_ref_base_and_extent (t
, &offset
, &size
, &max_size
, &reverse
);
8170 ctor
= get_base_constructor (base
, &offset
, valueize
);
8172 /* Empty constructor. Always fold to 0. */
8173 if (ctor
== error_mark_node
)
8174 return build_zero_cst (TREE_TYPE (t
));
8175 /* We do not know precise address. */
8176 if (!known_size_p (max_size
) || maybe_ne (max_size
, size
))
8178 /* We cannot determine ctor. */
8182 /* Out of bound array access. Value is undefined, but don't fold. */
8183 if (maybe_lt (offset
, 0))
8186 tem
= fold_ctor_reference (TREE_TYPE (t
), ctor
, offset
, size
, base
);
8190 /* For bit field reads try to read the representative and
8192 if (TREE_CODE (t
) == COMPONENT_REF
8193 && DECL_BIT_FIELD (TREE_OPERAND (t
, 1))
8194 && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t
, 1)))
8196 HOST_WIDE_INT csize
, coffset
;
8197 tree field
= TREE_OPERAND (t
, 1);
8198 tree repr
= DECL_BIT_FIELD_REPRESENTATIVE (field
);
8199 if (INTEGRAL_TYPE_P (TREE_TYPE (repr
))
8200 && size
.is_constant (&csize
)
8201 && offset
.is_constant (&coffset
)
8202 && (coffset
% BITS_PER_UNIT
!= 0
8203 || csize
% BITS_PER_UNIT
!= 0)
8205 && BYTES_BIG_ENDIAN
== WORDS_BIG_ENDIAN
)
8207 poly_int64 bitoffset
;
8208 poly_uint64 field_offset
, repr_offset
;
8209 if (poly_int_tree_p (DECL_FIELD_OFFSET (field
), &field_offset
)
8210 && poly_int_tree_p (DECL_FIELD_OFFSET (repr
), &repr_offset
))
8211 bitoffset
= (field_offset
- repr_offset
) * BITS_PER_UNIT
;
8214 bitoffset
+= (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
8215 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
8216 HOST_WIDE_INT bitoff
;
8217 int diff
= (TYPE_PRECISION (TREE_TYPE (repr
))
8218 - TYPE_PRECISION (TREE_TYPE (field
)));
8219 if (bitoffset
.is_constant (&bitoff
)
8224 size
= tree_to_uhwi (DECL_SIZE (repr
));
8226 tem
= fold_ctor_reference (TREE_TYPE (repr
), ctor
, offset
,
8228 if (tem
&& TREE_CODE (tem
) == INTEGER_CST
)
8230 if (!BYTES_BIG_ENDIAN
)
8231 tem
= wide_int_to_tree (TREE_TYPE (field
),
8232 wi::lrshift (wi::to_wide (tem
),
8235 tem
= wide_int_to_tree (TREE_TYPE (field
),
8236 wi::lrshift (wi::to_wide (tem
),
8248 tree c
= fold_const_aggregate_ref_1 (TREE_OPERAND (t
, 0), valueize
);
8249 if (c
&& TREE_CODE (c
) == COMPLEX_CST
)
8250 return fold_build1_loc (EXPR_LOCATION (t
),
8251 TREE_CODE (t
), TREE_TYPE (t
), c
);
8263 fold_const_aggregate_ref (tree t
)
8265 return fold_const_aggregate_ref_1 (t
, NULL
);
8268 /* Lookup virtual method with index TOKEN in a virtual table V
8270 Set CAN_REFER if non-NULL to false if method
8271 is not referable or if the virtual table is ill-formed (such as rewriten
8272 by non-C++ produced symbol). Otherwise just return NULL in that calse. */
8275 gimple_get_virt_method_for_vtable (HOST_WIDE_INT token
,
8277 unsigned HOST_WIDE_INT offset
,
8280 tree vtable
= v
, init
, fn
;
8281 unsigned HOST_WIDE_INT size
;
8282 unsigned HOST_WIDE_INT elt_size
, access_index
;
8288 /* First of all double check we have virtual table. */
8289 if (!VAR_P (v
) || !DECL_VIRTUAL_P (v
))
8291 /* Pass down that we lost track of the target. */
8297 init
= ctor_for_folding (v
);
8299 /* The virtual tables should always be born with constructors
8300 and we always should assume that they are avaialble for
8301 folding. At the moment we do not stream them in all cases,
8302 but it should never happen that ctor seem unreachable. */
8304 if (init
== error_mark_node
)
8306 /* Pass down that we lost track of the target. */
8311 gcc_checking_assert (TREE_CODE (TREE_TYPE (v
)) == ARRAY_TYPE
);
8312 size
= tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (v
))));
8313 offset
*= BITS_PER_UNIT
;
8314 offset
+= token
* size
;
8316 /* Lookup the value in the constructor that is assumed to be array.
8317 This is equivalent to
8318 fn = fold_ctor_reference (TREE_TYPE (TREE_TYPE (v)), init,
8319 offset, size, NULL);
8320 but in a constant time. We expect that frontend produced a simple
8321 array without indexed initializers. */
8323 gcc_checking_assert (TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
);
8324 domain_type
= TYPE_DOMAIN (TREE_TYPE (init
));
8325 gcc_checking_assert (integer_zerop (TYPE_MIN_VALUE (domain_type
)));
8326 elt_size
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (init
))));
8328 access_index
= offset
/ BITS_PER_UNIT
/ elt_size
;
8329 gcc_checking_assert (offset
% (elt_size
* BITS_PER_UNIT
) == 0);
8331 /* The C++ FE can now produce indexed fields, and we check if the indexes
8333 if (access_index
< CONSTRUCTOR_NELTS (init
))
8335 fn
= CONSTRUCTOR_ELT (init
, access_index
)->value
;
8336 tree idx
= CONSTRUCTOR_ELT (init
, access_index
)->index
;
8337 gcc_checking_assert (!idx
|| tree_to_uhwi (idx
) == access_index
);
8343 /* For type inconsistent program we may end up looking up virtual method
8344 in virtual table that does not contain TOKEN entries. We may overrun
8345 the virtual table and pick up a constant or RTTI info pointer.
8346 In any case the call is undefined. */
8348 || (TREE_CODE (fn
) != ADDR_EXPR
&& TREE_CODE (fn
) != FDESC_EXPR
)
8349 || TREE_CODE (TREE_OPERAND (fn
, 0)) != FUNCTION_DECL
)
8350 fn
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
8353 fn
= TREE_OPERAND (fn
, 0);
8355 /* When cgraph node is missing and function is not public, we cannot
8356 devirtualize. This can happen in WHOPR when the actual method
8357 ends up in other partition, because we found devirtualization
8358 possibility too late. */
8359 if (!can_refer_decl_in_current_unit_p (fn
, vtable
))
8370 /* Make sure we create a cgraph node for functions we'll reference.
8371 They can be non-existent if the reference comes from an entry
8372 of an external vtable for example. */
8373 cgraph_node::get_create (fn
);
8378 /* Return a declaration of a function which an OBJ_TYPE_REF references. TOKEN
8379 is integer form of OBJ_TYPE_REF_TOKEN of the reference expression.
8380 KNOWN_BINFO carries the binfo describing the true type of
8381 OBJ_TYPE_REF_OBJECT(REF).
8382 Set CAN_REFER if non-NULL to false if method
8383 is not referable or if the virtual table is ill-formed (such as rewriten
8384 by non-C++ produced symbol). Otherwise just return NULL in that calse. */
8387 gimple_get_virt_method_for_binfo (HOST_WIDE_INT token
, tree known_binfo
,
8390 unsigned HOST_WIDE_INT offset
;
8393 v
= BINFO_VTABLE (known_binfo
);
8394 /* If there is no virtual methods table, leave the OBJ_TYPE_REF alone. */
8398 if (!vtable_pointer_value_to_vtable (v
, &v
, &offset
))
8404 return gimple_get_virt_method_for_vtable (token
, v
, offset
, can_refer
);
8407 /* Given a pointer value T, return a simplified version of an
8408 indirection through T, or NULL_TREE if no simplification is
8409 possible. Note that the resulting type may be different from
8410 the type pointed to in the sense that it is still compatible
8411 from the langhooks point of view. */
8414 gimple_fold_indirect_ref (tree t
)
8416 tree ptype
= TREE_TYPE (t
), type
= TREE_TYPE (ptype
);
8421 subtype
= TREE_TYPE (sub
);
8422 if (!POINTER_TYPE_P (subtype
)
8423 || TYPE_REF_CAN_ALIAS_ALL (ptype
))
8426 if (TREE_CODE (sub
) == ADDR_EXPR
)
8428 tree op
= TREE_OPERAND (sub
, 0);
8429 tree optype
= TREE_TYPE (op
);
8431 if (useless_type_conversion_p (type
, optype
))
8434 /* *(foo *)&fooarray => fooarray[0] */
8435 if (TREE_CODE (optype
) == ARRAY_TYPE
8436 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype
))) == INTEGER_CST
8437 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
8439 tree type_domain
= TYPE_DOMAIN (optype
);
8440 tree min_val
= size_zero_node
;
8441 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
8442 min_val
= TYPE_MIN_VALUE (type_domain
);
8443 if (TREE_CODE (min_val
) == INTEGER_CST
)
8444 return build4 (ARRAY_REF
, type
, op
, min_val
, NULL_TREE
, NULL_TREE
);
8446 /* *(foo *)&complexfoo => __real__ complexfoo */
8447 else if (TREE_CODE (optype
) == COMPLEX_TYPE
8448 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
8449 return fold_build1 (REALPART_EXPR
, type
, op
);
8450 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
8451 else if (TREE_CODE (optype
) == VECTOR_TYPE
8452 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
8454 tree part_width
= TYPE_SIZE (type
);
8455 tree index
= bitsize_int (0);
8456 return fold_build3 (BIT_FIELD_REF
, type
, op
, part_width
, index
);
8460 /* *(p + CST) -> ... */
8461 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
8462 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
8464 tree addr
= TREE_OPERAND (sub
, 0);
8465 tree off
= TREE_OPERAND (sub
, 1);
8469 addrtype
= TREE_TYPE (addr
);
8471 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
8472 if (TREE_CODE (addr
) == ADDR_EXPR
8473 && TREE_CODE (TREE_TYPE (addrtype
)) == VECTOR_TYPE
8474 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
)))
8475 && tree_fits_uhwi_p (off
))
8477 unsigned HOST_WIDE_INT offset
= tree_to_uhwi (off
);
8478 tree part_width
= TYPE_SIZE (type
);
8479 unsigned HOST_WIDE_INT part_widthi
8480 = tree_to_shwi (part_width
) / BITS_PER_UNIT
;
8481 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
8482 tree index
= bitsize_int (indexi
);
8483 if (known_lt (offset
/ part_widthi
,
8484 TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype
))))
8485 return fold_build3 (BIT_FIELD_REF
, type
, TREE_OPERAND (addr
, 0),
8489 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
8490 if (TREE_CODE (addr
) == ADDR_EXPR
8491 && TREE_CODE (TREE_TYPE (addrtype
)) == COMPLEX_TYPE
8492 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
8494 tree size
= TYPE_SIZE_UNIT (type
);
8495 if (tree_int_cst_equal (size
, off
))
8496 return fold_build1 (IMAGPART_EXPR
, type
, TREE_OPERAND (addr
, 0));
8499 /* *(p + CST) -> MEM_REF <p, CST>. */
8500 if (TREE_CODE (addr
) != ADDR_EXPR
8501 || DECL_P (TREE_OPERAND (addr
, 0)))
8502 return fold_build2 (MEM_REF
, type
,
8504 wide_int_to_tree (ptype
, wi::to_wide (off
)));
8507 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
8508 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
8509 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype
)))) == INTEGER_CST
8510 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
8513 tree min_val
= size_zero_node
;
8515 sub
= gimple_fold_indirect_ref (sub
);
8517 sub
= build1 (INDIRECT_REF
, TREE_TYPE (subtype
), osub
);
8518 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
8519 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
8520 min_val
= TYPE_MIN_VALUE (type_domain
);
8521 if (TREE_CODE (min_val
) == INTEGER_CST
)
8522 return build4 (ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
, NULL_TREE
);
8528 /* Return true if CODE is an operation that when operating on signed
8529 integer types involves undefined behavior on overflow and the
8530 operation can be expressed with unsigned arithmetic. */
8533 arith_code_with_undefined_signed_overflow (tree_code code
)
8542 case POINTER_PLUS_EXPR
:
8549 /* Rewrite STMT, an assignment with a signed integer or pointer arithmetic
8550 operation that can be transformed to unsigned arithmetic by converting
8551 its operand, carrying out the operation in the corresponding unsigned
8552 type and converting the result back to the original type.
8554 Returns a sequence of statements that replace STMT and also contain
8555 a modified form of STMT itself. */
8558 rewrite_to_defined_overflow (gimple
*stmt
)
8560 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8562 fprintf (dump_file
, "rewriting stmt with undefined signed "
8564 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
8567 tree lhs
= gimple_assign_lhs (stmt
);
8568 tree type
= unsigned_type_for (TREE_TYPE (lhs
));
8569 gimple_seq stmts
= NULL
;
8570 if (gimple_assign_rhs_code (stmt
) == ABS_EXPR
)
8571 gimple_assign_set_rhs_code (stmt
, ABSU_EXPR
);
8573 for (unsigned i
= 1; i
< gimple_num_ops (stmt
); ++i
)
8575 tree op
= gimple_op (stmt
, i
);
8576 op
= gimple_convert (&stmts
, type
, op
);
8577 gimple_set_op (stmt
, i
, op
);
8579 gimple_assign_set_lhs (stmt
, make_ssa_name (type
, stmt
));
8580 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
)
8581 gimple_assign_set_rhs_code (stmt
, PLUS_EXPR
);
8582 gimple_set_modified (stmt
, true);
8583 gimple_seq_add_stmt (&stmts
, stmt
);
8584 gimple
*cvt
= gimple_build_assign (lhs
, NOP_EXPR
, gimple_assign_lhs (stmt
));
8585 gimple_seq_add_stmt (&stmts
, cvt
);
8591 /* The valueization hook we use for the gimple_build API simplification.
8592 This makes us match fold_buildN behavior by only combining with
8593 statements in the sequence(s) we are currently building. */
8596 gimple_build_valueize (tree op
)
8598 if (gimple_bb (SSA_NAME_DEF_STMT (op
)) == NULL
)
8603 /* Build the expression CODE OP0 of type TYPE with location LOC,
8604 simplifying it first if possible. Returns the built
8605 expression value and appends statements possibly defining it
8609 gimple_build (gimple_seq
*seq
, location_t loc
,
8610 enum tree_code code
, tree type
, tree op0
)
8612 tree res
= gimple_simplify (code
, type
, op0
, seq
, gimple_build_valueize
);
8615 res
= create_tmp_reg_or_ssa_name (type
);
8617 if (code
== REALPART_EXPR
8618 || code
== IMAGPART_EXPR
8619 || code
== VIEW_CONVERT_EXPR
)
8620 stmt
= gimple_build_assign (res
, code
, build1 (code
, type
, op0
));
8622 stmt
= gimple_build_assign (res
, code
, op0
);
8623 gimple_set_location (stmt
, loc
);
8624 gimple_seq_add_stmt_without_update (seq
, stmt
);
8629 /* Build the expression OP0 CODE OP1 of type TYPE with location LOC,
8630 simplifying it first if possible. Returns the built
8631 expression value and appends statements possibly defining it
8635 gimple_build (gimple_seq
*seq
, location_t loc
,
8636 enum tree_code code
, tree type
, tree op0
, tree op1
)
8638 tree res
= gimple_simplify (code
, type
, op0
, op1
, seq
, gimple_build_valueize
);
8641 res
= create_tmp_reg_or_ssa_name (type
);
8642 gimple
*stmt
= gimple_build_assign (res
, code
, op0
, op1
);
8643 gimple_set_location (stmt
, loc
);
8644 gimple_seq_add_stmt_without_update (seq
, stmt
);
8649 /* Build the expression (CODE OP0 OP1 OP2) of type TYPE with location LOC,
8650 simplifying it first if possible. Returns the built
8651 expression value and appends statements possibly defining it
8655 gimple_build (gimple_seq
*seq
, location_t loc
,
8656 enum tree_code code
, tree type
, tree op0
, tree op1
, tree op2
)
8658 tree res
= gimple_simplify (code
, type
, op0
, op1
, op2
,
8659 seq
, gimple_build_valueize
);
8662 res
= create_tmp_reg_or_ssa_name (type
);
8664 if (code
== BIT_FIELD_REF
)
8665 stmt
= gimple_build_assign (res
, code
,
8666 build3 (code
, type
, op0
, op1
, op2
));
8668 stmt
= gimple_build_assign (res
, code
, op0
, op1
, op2
);
8669 gimple_set_location (stmt
, loc
);
8670 gimple_seq_add_stmt_without_update (seq
, stmt
);
8675 /* Build the call FN () with a result of type TYPE (or no result if TYPE is
8676 void) with a location LOC. Returns the built expression value (or NULL_TREE
8677 if TYPE is void) and appends statements possibly defining it to SEQ. */
8680 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
, tree type
)
8682 tree res
= NULL_TREE
;
8684 if (internal_fn_p (fn
))
8685 stmt
= gimple_build_call_internal (as_internal_fn (fn
), 0);
8688 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
8689 stmt
= gimple_build_call (decl
, 0);
8691 if (!VOID_TYPE_P (type
))
8693 res
= create_tmp_reg_or_ssa_name (type
);
8694 gimple_call_set_lhs (stmt
, res
);
8696 gimple_set_location (stmt
, loc
);
8697 gimple_seq_add_stmt_without_update (seq
, stmt
);
8701 /* Build the call FN (ARG0) with a result of type TYPE
8702 (or no result if TYPE is void) with location LOC,
8703 simplifying it first if possible. Returns the built
8704 expression value (or NULL_TREE if TYPE is void) and appends
8705 statements possibly defining it to SEQ. */
8708 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
8709 tree type
, tree arg0
)
8711 tree res
= gimple_simplify (fn
, type
, arg0
, seq
, gimple_build_valueize
);
8715 if (internal_fn_p (fn
))
8716 stmt
= gimple_build_call_internal (as_internal_fn (fn
), 1, arg0
);
8719 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
8720 stmt
= gimple_build_call (decl
, 1, arg0
);
8722 if (!VOID_TYPE_P (type
))
8724 res
= create_tmp_reg_or_ssa_name (type
);
8725 gimple_call_set_lhs (stmt
, res
);
8727 gimple_set_location (stmt
, loc
);
8728 gimple_seq_add_stmt_without_update (seq
, stmt
);
8733 /* Build the call FN (ARG0, ARG1) with a result of type TYPE
8734 (or no result if TYPE is void) with location LOC,
8735 simplifying it first if possible. Returns the built
8736 expression value (or NULL_TREE if TYPE is void) and appends
8737 statements possibly defining it to SEQ. */
8740 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
8741 tree type
, tree arg0
, tree arg1
)
8743 tree res
= gimple_simplify (fn
, type
, arg0
, arg1
, seq
, gimple_build_valueize
);
8747 if (internal_fn_p (fn
))
8748 stmt
= gimple_build_call_internal (as_internal_fn (fn
), 2, arg0
, arg1
);
8751 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
8752 stmt
= gimple_build_call (decl
, 2, arg0
, arg1
);
8754 if (!VOID_TYPE_P (type
))
8756 res
= create_tmp_reg_or_ssa_name (type
);
8757 gimple_call_set_lhs (stmt
, res
);
8759 gimple_set_location (stmt
, loc
);
8760 gimple_seq_add_stmt_without_update (seq
, stmt
);
8765 /* Build the call FN (ARG0, ARG1, ARG2) with a result of type TYPE
8766 (or no result if TYPE is void) with location LOC,
8767 simplifying it first if possible. Returns the built
8768 expression value (or NULL_TREE if TYPE is void) and appends
8769 statements possibly defining it to SEQ. */
8772 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
8773 tree type
, tree arg0
, tree arg1
, tree arg2
)
8775 tree res
= gimple_simplify (fn
, type
, arg0
, arg1
, arg2
,
8776 seq
, gimple_build_valueize
);
8780 if (internal_fn_p (fn
))
8781 stmt
= gimple_build_call_internal (as_internal_fn (fn
),
8782 3, arg0
, arg1
, arg2
);
8785 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
8786 stmt
= gimple_build_call (decl
, 3, arg0
, arg1
, arg2
);
8788 if (!VOID_TYPE_P (type
))
8790 res
= create_tmp_reg_or_ssa_name (type
);
8791 gimple_call_set_lhs (stmt
, res
);
8793 gimple_set_location (stmt
, loc
);
8794 gimple_seq_add_stmt_without_update (seq
, stmt
);
8799 /* Build CODE (OP0) with a result of type TYPE (or no result if TYPE is
8800 void) with location LOC, simplifying it first if possible. Returns the
8801 built expression value (or NULL_TREE if TYPE is void) and appends
8802 statements possibly defining it to SEQ. */
8805 gimple_build (gimple_seq
*seq
, location_t loc
, code_helper code
,
8806 tree type
, tree op0
)
8808 if (code
.is_tree_code ())
8809 return gimple_build (seq
, loc
, tree_code (code
), type
, op0
);
8810 return gimple_build (seq
, loc
, combined_fn (code
), type
, op0
);
8813 /* Build CODE (OP0, OP1) with a result of type TYPE (or no result if TYPE is
8814 void) with location LOC, simplifying it first if possible. Returns the
8815 built expression value (or NULL_TREE if TYPE is void) and appends
8816 statements possibly defining it to SEQ. */
8819 gimple_build (gimple_seq
*seq
, location_t loc
, code_helper code
,
8820 tree type
, tree op0
, tree op1
)
8822 if (code
.is_tree_code ())
8823 return gimple_build (seq
, loc
, tree_code (code
), type
, op0
, op1
);
8824 return gimple_build (seq
, loc
, combined_fn (code
), type
, op0
, op1
);
8827 /* Build CODE (OP0, OP1, OP2) with a result of type TYPE (or no result if TYPE
8828 is void) with location LOC, simplifying it first if possible. Returns the
8829 built expression value (or NULL_TREE if TYPE is void) and appends statements
8830 possibly defining it to SEQ. */
8833 gimple_build (gimple_seq
*seq
, location_t loc
, code_helper code
,
8834 tree type
, tree op0
, tree op1
, tree op2
)
8836 if (code
.is_tree_code ())
8837 return gimple_build (seq
, loc
, tree_code (code
), type
, op0
, op1
, op2
);
8838 return gimple_build (seq
, loc
, combined_fn (code
), type
, op0
, op1
, op2
);
8841 /* Build the conversion (TYPE) OP with a result of type TYPE
8842 with location LOC if such conversion is neccesary in GIMPLE,
8843 simplifying it first.
8844 Returns the built expression value and appends
8845 statements possibly defining it to SEQ. */
8848 gimple_convert (gimple_seq
*seq
, location_t loc
, tree type
, tree op
)
8850 if (useless_type_conversion_p (type
, TREE_TYPE (op
)))
8852 return gimple_build (seq
, loc
, NOP_EXPR
, type
, op
);
8855 /* Build the conversion (ptrofftype) OP with a result of a type
8856 compatible with ptrofftype with location LOC if such conversion
8857 is neccesary in GIMPLE, simplifying it first.
8858 Returns the built expression value and appends
8859 statements possibly defining it to SEQ. */
8862 gimple_convert_to_ptrofftype (gimple_seq
*seq
, location_t loc
, tree op
)
8864 if (ptrofftype_p (TREE_TYPE (op
)))
8866 return gimple_convert (seq
, loc
, sizetype
, op
);
8869 /* Build a vector of type TYPE in which each element has the value OP.
8870 Return a gimple value for the result, appending any new statements
8874 gimple_build_vector_from_val (gimple_seq
*seq
, location_t loc
, tree type
,
8877 if (!TYPE_VECTOR_SUBPARTS (type
).is_constant ()
8878 && !CONSTANT_CLASS_P (op
))
8879 return gimple_build (seq
, loc
, VEC_DUPLICATE_EXPR
, type
, op
);
8881 tree res
, vec
= build_vector_from_val (type
, op
);
8882 if (is_gimple_val (vec
))
8884 if (gimple_in_ssa_p (cfun
))
8885 res
= make_ssa_name (type
);
8887 res
= create_tmp_reg (type
);
8888 gimple
*stmt
= gimple_build_assign (res
, vec
);
8889 gimple_set_location (stmt
, loc
);
8890 gimple_seq_add_stmt_without_update (seq
, stmt
);
8894 /* Build a vector from BUILDER, handling the case in which some elements
8895 are non-constant. Return a gimple value for the result, appending any
8896 new instructions to SEQ.
8898 BUILDER must not have a stepped encoding on entry. This is because
8899 the function is not geared up to handle the arithmetic that would
8900 be needed in the variable case, and any code building a vector that
8901 is known to be constant should use BUILDER->build () directly. */
8904 gimple_build_vector (gimple_seq
*seq
, location_t loc
,
8905 tree_vector_builder
*builder
)
8907 gcc_assert (builder
->nelts_per_pattern () <= 2);
8908 unsigned int encoded_nelts
= builder
->encoded_nelts ();
8909 for (unsigned int i
= 0; i
< encoded_nelts
; ++i
)
8910 if (!CONSTANT_CLASS_P ((*builder
)[i
]))
8912 tree type
= builder
->type ();
8913 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
).to_constant ();
8914 vec
<constructor_elt
, va_gc
> *v
;
8915 vec_alloc (v
, nelts
);
8916 for (i
= 0; i
< nelts
; ++i
)
8917 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, builder
->elt (i
));
8920 if (gimple_in_ssa_p (cfun
))
8921 res
= make_ssa_name (type
);
8923 res
= create_tmp_reg (type
);
8924 gimple
*stmt
= gimple_build_assign (res
, build_constructor (type
, v
));
8925 gimple_set_location (stmt
, loc
);
8926 gimple_seq_add_stmt_without_update (seq
, stmt
);
8929 return builder
->build ();
8932 /* Emit gimple statements into &stmts that take a value given in OLD_SIZE
8933 and generate a value guaranteed to be rounded upwards to ALIGN.
8935 Return the tree node representing this size, it is of TREE_TYPE TYPE. */
8938 gimple_build_round_up (gimple_seq
*seq
, location_t loc
, tree type
,
8939 tree old_size
, unsigned HOST_WIDE_INT align
)
8941 unsigned HOST_WIDE_INT tg_mask
= align
- 1;
8942 /* tree new_size = (old_size + tg_mask) & ~tg_mask; */
8943 gcc_assert (INTEGRAL_TYPE_P (type
));
8944 tree tree_mask
= build_int_cst (type
, tg_mask
);
8945 tree oversize
= gimple_build (seq
, loc
, PLUS_EXPR
, type
, old_size
,
8948 tree mask
= build_int_cst (type
, -align
);
8949 return gimple_build (seq
, loc
, BIT_AND_EXPR
, type
, oversize
, mask
);
8952 /* Return true if the result of assignment STMT is known to be non-negative.
8953 If the return value is based on the assumption that signed overflow is
8954 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
8955 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
8958 gimple_assign_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
8961 enum tree_code code
= gimple_assign_rhs_code (stmt
);
8962 tree type
= TREE_TYPE (gimple_assign_lhs (stmt
));
8963 switch (get_gimple_rhs_class (code
))
8965 case GIMPLE_UNARY_RHS
:
8966 return tree_unary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt
),
8968 gimple_assign_rhs1 (stmt
),
8969 strict_overflow_p
, depth
);
8970 case GIMPLE_BINARY_RHS
:
8971 return tree_binary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt
),
8973 gimple_assign_rhs1 (stmt
),
8974 gimple_assign_rhs2 (stmt
),
8975 strict_overflow_p
, depth
);
8976 case GIMPLE_TERNARY_RHS
:
8978 case GIMPLE_SINGLE_RHS
:
8979 return tree_single_nonnegative_warnv_p (gimple_assign_rhs1 (stmt
),
8980 strict_overflow_p
, depth
);
8981 case GIMPLE_INVALID_RHS
:
8987 /* Return true if return value of call STMT is known to be non-negative.
8988 If the return value is based on the assumption that signed overflow is
8989 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
8990 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
8993 gimple_call_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
8996 tree arg0
= gimple_call_num_args (stmt
) > 0 ?
8997 gimple_call_arg (stmt
, 0) : NULL_TREE
;
8998 tree arg1
= gimple_call_num_args (stmt
) > 1 ?
8999 gimple_call_arg (stmt
, 1) : NULL_TREE
;
9000 tree lhs
= gimple_call_lhs (stmt
);
9002 && tree_call_nonnegative_warnv_p (TREE_TYPE (lhs
),
9003 gimple_call_combined_fn (stmt
),
9005 strict_overflow_p
, depth
));
9008 /* Return true if return value of call STMT is known to be non-negative.
9009 If the return value is based on the assumption that signed overflow is
9010 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
9011 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
9014 gimple_phi_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
9017 for (unsigned i
= 0; i
< gimple_phi_num_args (stmt
); ++i
)
9019 tree arg
= gimple_phi_arg_def (stmt
, i
);
9020 if (!tree_single_nonnegative_warnv_p (arg
, strict_overflow_p
, depth
+ 1))
9026 /* Return true if STMT is known to compute a non-negative value.
9027 If the return value is based on the assumption that signed overflow is
9028 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
9029 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
9032 gimple_stmt_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
9035 switch (gimple_code (stmt
))
9038 return gimple_assign_nonnegative_warnv_p (stmt
, strict_overflow_p
,
9041 return gimple_call_nonnegative_warnv_p (stmt
, strict_overflow_p
,
9044 return gimple_phi_nonnegative_warnv_p (stmt
, strict_overflow_p
,
9051 /* Return true if the floating-point value computed by assignment STMT
9052 is known to have an integer value. We also allow +Inf, -Inf and NaN
9053 to be considered integer values. Return false for signaling NaN.
9055 DEPTH is the current nesting depth of the query. */
9058 gimple_assign_integer_valued_real_p (gimple
*stmt
, int depth
)
9060 enum tree_code code
= gimple_assign_rhs_code (stmt
);
9061 switch (get_gimple_rhs_class (code
))
9063 case GIMPLE_UNARY_RHS
:
9064 return integer_valued_real_unary_p (gimple_assign_rhs_code (stmt
),
9065 gimple_assign_rhs1 (stmt
), depth
);
9066 case GIMPLE_BINARY_RHS
:
9067 return integer_valued_real_binary_p (gimple_assign_rhs_code (stmt
),
9068 gimple_assign_rhs1 (stmt
),
9069 gimple_assign_rhs2 (stmt
), depth
);
9070 case GIMPLE_TERNARY_RHS
:
9072 case GIMPLE_SINGLE_RHS
:
9073 return integer_valued_real_single_p (gimple_assign_rhs1 (stmt
), depth
);
9074 case GIMPLE_INVALID_RHS
:
9080 /* Return true if the floating-point value computed by call STMT is known
9081 to have an integer value. We also allow +Inf, -Inf and NaN to be
9082 considered integer values. Return false for signaling NaN.
9084 DEPTH is the current nesting depth of the query. */
9087 gimple_call_integer_valued_real_p (gimple
*stmt
, int depth
)
9089 tree arg0
= (gimple_call_num_args (stmt
) > 0
9090 ? gimple_call_arg (stmt
, 0)
9092 tree arg1
= (gimple_call_num_args (stmt
) > 1
9093 ? gimple_call_arg (stmt
, 1)
9095 return integer_valued_real_call_p (gimple_call_combined_fn (stmt
),
9099 /* Return true if the floating-point result of phi STMT is known to have
9100 an integer value. We also allow +Inf, -Inf and NaN to be considered
9101 integer values. Return false for signaling NaN.
9103 DEPTH is the current nesting depth of the query. */
9106 gimple_phi_integer_valued_real_p (gimple
*stmt
, int depth
)
9108 for (unsigned i
= 0; i
< gimple_phi_num_args (stmt
); ++i
)
9110 tree arg
= gimple_phi_arg_def (stmt
, i
);
9111 if (!integer_valued_real_single_p (arg
, depth
+ 1))
9117 /* Return true if the floating-point value computed by STMT is known
9118 to have an integer value. We also allow +Inf, -Inf and NaN to be
9119 considered integer values. Return false for signaling NaN.
9121 DEPTH is the current nesting depth of the query. */
9124 gimple_stmt_integer_valued_real_p (gimple
*stmt
, int depth
)
9126 switch (gimple_code (stmt
))
9129 return gimple_assign_integer_valued_real_p (stmt
, depth
);
9131 return gimple_call_integer_valued_real_p (stmt
, depth
);
9133 return gimple_phi_integer_valued_real_p (stmt
, depth
);