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-restrict.h"
34 #include "fold-const.h"
37 #include "stor-layout.h"
39 #include "gimple-fold.h"
41 #include "gimple-iterator.h"
42 #include "tree-into-ssa.h"
44 #include "tree-object-size.h"
46 #include "tree-ssa-propagate.h"
47 #include "ipa-utils.h"
48 #include "tree-ssa-address.h"
49 #include "langhooks.h"
50 #include "gimplify-me.h"
54 #include "gimple-match.h"
55 #include "gomp-constants.h"
56 #include "optabs-query.h"
57 #include "omp-general.h"
59 #include "fold-const-call.h"
60 #include "stringpool.h"
63 #include "diagnostic-core.h"
66 #include "tree-vector-builder.h"
67 #include "tree-ssa-strlen.h"
70 enum strlen_range_kind
{
71 /* Compute the exact constant string length. */
73 /* Compute the maximum constant string length. */
75 /* Compute a range of string lengths bounded by object sizes. When
76 the length of a string cannot be determined, consider as the upper
77 bound the size of the enclosing object the string may be a member
78 or element of. Also determine the size of the largest character
79 array the string may refer to. */
81 /* Determine the integer value of the argument (not string length). */
86 get_range_strlen (tree
, bitmap
*, strlen_range_kind
, c_strlen_data
*, unsigned);
88 /* Return true when DECL can be referenced from current unit.
89 FROM_DECL (if non-null) specify constructor of variable DECL was taken from.
90 We can get declarations that are not possible to reference for various
93 1) When analyzing C++ virtual tables.
94 C++ virtual tables do have known constructors even
95 when they are keyed to other compilation unit.
96 Those tables can contain pointers to methods and vars
97 in other units. Those methods have both STATIC and EXTERNAL
99 2) In WHOPR mode devirtualization might lead to reference
100 to method that was partitioned elsehwere.
101 In this case we have static VAR_DECL or FUNCTION_DECL
102 that has no corresponding callgraph/varpool node
104 3) COMDAT functions referred by external vtables that
105 we devirtualize only during final compilation stage.
106 At this time we already decided that we will not output
107 the function body and thus we can't reference the symbol
111 can_refer_decl_in_current_unit_p (tree decl
, tree from_decl
)
114 struct cgraph_node
*node
;
117 if (DECL_ABSTRACT_P (decl
))
120 /* We are concerned only about static/external vars and functions. */
121 if ((!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
122 || !VAR_OR_FUNCTION_DECL_P (decl
))
125 /* Static objects can be referred only if they are defined and not optimized
127 if (!TREE_PUBLIC (decl
))
129 if (DECL_EXTERNAL (decl
))
131 /* Before we start optimizing unreachable code we can be sure all
132 static objects are defined. */
133 if (symtab
->function_flags_ready
)
135 snode
= symtab_node::get (decl
);
136 if (!snode
|| !snode
->definition
)
138 node
= dyn_cast
<cgraph_node
*> (snode
);
139 return !node
|| !node
->inlined_to
;
142 /* We will later output the initializer, so we can refer to it.
143 So we are concerned only when DECL comes from initializer of
144 external var or var that has been optimized out. */
146 || !VAR_P (from_decl
)
147 || (!DECL_EXTERNAL (from_decl
)
148 && (vnode
= varpool_node::get (from_decl
)) != NULL
149 && vnode
->definition
)
151 && (vnode
= varpool_node::get (from_decl
)) != NULL
152 && vnode
->in_other_partition
))
154 /* We are folding reference from external vtable. The vtable may reffer
155 to a symbol keyed to other compilation unit. The other compilation
156 unit may be in separate DSO and the symbol may be hidden. */
157 if (DECL_VISIBILITY_SPECIFIED (decl
)
158 && DECL_EXTERNAL (decl
)
159 && DECL_VISIBILITY (decl
) != VISIBILITY_DEFAULT
160 && (!(snode
= symtab_node::get (decl
)) || !snode
->in_other_partition
))
162 /* When function is public, we always can introduce new reference.
163 Exception are the COMDAT functions where introducing a direct
164 reference imply need to include function body in the curren tunit. */
165 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
167 /* We have COMDAT. We are going to check if we still have definition
168 or if the definition is going to be output in other partition.
169 Bypass this when gimplifying; all needed functions will be produced.
171 As observed in PR20991 for already optimized out comdat virtual functions
172 it may be tempting to not necessarily give up because the copy will be
173 output elsewhere when corresponding vtable is output.
174 This is however not possible - ABI specify that COMDATs are output in
175 units where they are used and when the other unit was compiled with LTO
176 it is possible that vtable was kept public while the function itself
178 if (!symtab
->function_flags_ready
)
181 snode
= symtab_node::get (decl
);
183 || ((!snode
->definition
|| DECL_EXTERNAL (decl
))
184 && (!snode
->in_other_partition
185 || (!snode
->forced_by_abi
&& !snode
->force_output
))))
187 node
= dyn_cast
<cgraph_node
*> (snode
);
188 return !node
|| !node
->inlined_to
;
191 /* Create a temporary for TYPE for a statement STMT. If the current function
192 is in SSA form, a SSA name is created. Otherwise a temporary register
196 create_tmp_reg_or_ssa_name (tree type
, gimple
*stmt
)
198 if (gimple_in_ssa_p (cfun
))
199 return make_ssa_name (type
, stmt
);
201 return create_tmp_reg (type
);
204 /* CVAL is value taken from DECL_INITIAL of variable. Try to transform it into
205 acceptable form for is_gimple_min_invariant.
206 FROM_DECL (if non-NULL) specify variable whose constructor contains CVAL. */
209 canonicalize_constructor_val (tree cval
, tree from_decl
)
211 if (CONSTANT_CLASS_P (cval
))
214 tree orig_cval
= cval
;
216 if (TREE_CODE (cval
) == POINTER_PLUS_EXPR
217 && TREE_CODE (TREE_OPERAND (cval
, 1)) == INTEGER_CST
)
219 tree ptr
= TREE_OPERAND (cval
, 0);
220 if (is_gimple_min_invariant (ptr
))
221 cval
= build1_loc (EXPR_LOCATION (cval
),
222 ADDR_EXPR
, TREE_TYPE (ptr
),
223 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (ptr
)),
225 fold_convert (ptr_type_node
,
226 TREE_OPERAND (cval
, 1))));
228 if (TREE_CODE (cval
) == ADDR_EXPR
)
230 tree base
= NULL_TREE
;
231 if (TREE_CODE (TREE_OPERAND (cval
, 0)) == COMPOUND_LITERAL_EXPR
)
233 base
= COMPOUND_LITERAL_EXPR_DECL (TREE_OPERAND (cval
, 0));
235 TREE_OPERAND (cval
, 0) = base
;
238 base
= get_base_address (TREE_OPERAND (cval
, 0));
242 if (VAR_OR_FUNCTION_DECL_P (base
)
243 && !can_refer_decl_in_current_unit_p (base
, from_decl
))
245 if (TREE_TYPE (base
) == error_mark_node
)
248 /* ??? We should be able to assert that TREE_ADDRESSABLE is set,
249 but since the use can be in a debug stmt we can't. */
251 else if (TREE_CODE (base
) == FUNCTION_DECL
)
253 /* Make sure we create a cgraph node for functions we'll reference.
254 They can be non-existent if the reference comes from an entry
255 of an external vtable for example. */
256 cgraph_node::get_create (base
);
258 /* Fixup types in global initializers. */
259 if (TREE_TYPE (TREE_TYPE (cval
)) != TREE_TYPE (TREE_OPERAND (cval
, 0)))
260 cval
= build_fold_addr_expr (TREE_OPERAND (cval
, 0));
262 if (!useless_type_conversion_p (TREE_TYPE (orig_cval
), TREE_TYPE (cval
)))
263 cval
= fold_convert (TREE_TYPE (orig_cval
), cval
);
266 /* In CONSTRUCTORs we may see unfolded constants like (int (*) ()) 0. */
267 if (TREE_CODE (cval
) == INTEGER_CST
)
269 if (TREE_OVERFLOW_P (cval
))
270 cval
= drop_tree_overflow (cval
);
271 if (!useless_type_conversion_p (TREE_TYPE (orig_cval
), TREE_TYPE (cval
)))
272 cval
= fold_convert (TREE_TYPE (orig_cval
), cval
);
278 /* If SYM is a constant variable with known value, return the value.
279 NULL_TREE is returned otherwise. */
282 get_symbol_constant_value (tree sym
)
284 tree val
= ctor_for_folding (sym
);
285 if (val
!= error_mark_node
)
289 val
= canonicalize_constructor_val (unshare_expr (val
), sym
);
290 if (val
&& is_gimple_min_invariant (val
))
295 /* Variables declared 'const' without an initializer
296 have zero as the initializer if they may not be
297 overridden at link or run time. */
299 && is_gimple_reg_type (TREE_TYPE (sym
)))
300 return build_zero_cst (TREE_TYPE (sym
));
308 /* Subroutine of fold_stmt. We perform constant folding of the
309 memory reference tree EXPR. */
312 maybe_fold_reference (tree expr
)
314 tree result
= NULL_TREE
;
316 if ((TREE_CODE (expr
) == VIEW_CONVERT_EXPR
317 || TREE_CODE (expr
) == REALPART_EXPR
318 || TREE_CODE (expr
) == IMAGPART_EXPR
)
319 && CONSTANT_CLASS_P (TREE_OPERAND (expr
, 0)))
320 result
= fold_unary_loc (EXPR_LOCATION (expr
),
323 TREE_OPERAND (expr
, 0));
324 else if (TREE_CODE (expr
) == BIT_FIELD_REF
325 && CONSTANT_CLASS_P (TREE_OPERAND (expr
, 0)))
326 result
= fold_ternary_loc (EXPR_LOCATION (expr
),
329 TREE_OPERAND (expr
, 0),
330 TREE_OPERAND (expr
, 1),
331 TREE_OPERAND (expr
, 2));
333 result
= fold_const_aggregate_ref (expr
);
335 if (result
&& is_gimple_min_invariant (result
))
341 /* Return true if EXPR is an acceptable right-hand-side for a
342 GIMPLE assignment. We validate the entire tree, not just
343 the root node, thus catching expressions that embed complex
344 operands that are not permitted in GIMPLE. This function
345 is needed because the folding routines in fold-const.c
346 may return such expressions in some cases, e.g., an array
347 access with an embedded index addition. It may make more
348 sense to have folding routines that are sensitive to the
349 constraints on GIMPLE operands, rather than abandoning any
350 any attempt to fold if the usual folding turns out to be too
354 valid_gimple_rhs_p (tree expr
)
356 enum tree_code code
= TREE_CODE (expr
);
358 switch (TREE_CODE_CLASS (code
))
360 case tcc_declaration
:
361 if (!is_gimple_variable (expr
))
366 /* All constants are ok. */
370 /* GENERIC allows comparisons with non-boolean types, reject
371 those for GIMPLE. Let vector-typed comparisons pass - rules
372 for GENERIC and GIMPLE are the same here. */
373 if (!(INTEGRAL_TYPE_P (TREE_TYPE (expr
))
374 && (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
375 || TYPE_PRECISION (TREE_TYPE (expr
)) == 1))
376 && ! VECTOR_TYPE_P (TREE_TYPE (expr
)))
381 if (!is_gimple_val (TREE_OPERAND (expr
, 0))
382 || !is_gimple_val (TREE_OPERAND (expr
, 1)))
387 if (!is_gimple_val (TREE_OPERAND (expr
, 0)))
397 if (is_gimple_min_invariant (expr
))
399 t
= TREE_OPERAND (expr
, 0);
400 while (handled_component_p (t
))
402 /* ??? More checks needed, see the GIMPLE verifier. */
403 if ((TREE_CODE (t
) == ARRAY_REF
404 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
405 && !is_gimple_val (TREE_OPERAND (t
, 1)))
407 t
= TREE_OPERAND (t
, 0);
409 if (!is_gimple_id (t
))
415 if (get_gimple_rhs_class (code
) == GIMPLE_TERNARY_RHS
)
417 if ((code
== COND_EXPR
418 ? !is_gimple_condexpr (TREE_OPERAND (expr
, 0))
419 : !is_gimple_val (TREE_OPERAND (expr
, 0)))
420 || !is_gimple_val (TREE_OPERAND (expr
, 1))
421 || !is_gimple_val (TREE_OPERAND (expr
, 2)))
432 case tcc_exceptional
:
433 if (code
== CONSTRUCTOR
)
437 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (expr
), i
, elt
)
438 if (!is_gimple_val (elt
))
442 if (code
!= SSA_NAME
)
447 if (code
== BIT_FIELD_REF
)
448 return is_gimple_val (TREE_OPERAND (expr
, 0));
459 /* Attempt to fold an assignment statement pointed-to by SI. Returns a
460 replacement rhs for the statement or NULL_TREE if no simplification
461 could be made. It is assumed that the operands have been previously
465 fold_gimple_assign (gimple_stmt_iterator
*si
)
467 gimple
*stmt
= gsi_stmt (*si
);
468 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
469 location_t loc
= gimple_location (stmt
);
471 tree result
= NULL_TREE
;
473 switch (get_gimple_rhs_class (subcode
))
475 case GIMPLE_SINGLE_RHS
:
477 tree rhs
= gimple_assign_rhs1 (stmt
);
479 if (TREE_CLOBBER_P (rhs
))
482 if (REFERENCE_CLASS_P (rhs
))
483 return maybe_fold_reference (rhs
);
485 else if (TREE_CODE (rhs
) == OBJ_TYPE_REF
)
487 tree val
= OBJ_TYPE_REF_EXPR (rhs
);
488 if (is_gimple_min_invariant (val
))
490 else if (flag_devirtualize
&& virtual_method_call_p (rhs
))
493 vec
<cgraph_node
*>targets
494 = possible_polymorphic_call_targets (rhs
, stmt
, &final
);
495 if (final
&& targets
.length () <= 1 && dbg_cnt (devirt
))
497 if (dump_enabled_p ())
499 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
,
500 "resolving virtual function address "
501 "reference to function %s\n",
502 targets
.length () == 1
503 ? targets
[0]->name ()
506 if (targets
.length () == 1)
508 val
= fold_convert (TREE_TYPE (val
),
509 build_fold_addr_expr_loc
510 (loc
, targets
[0]->decl
));
511 STRIP_USELESS_TYPE_CONVERSION (val
);
514 /* We cannot use __builtin_unreachable here because it
515 cannot have address taken. */
516 val
= build_int_cst (TREE_TYPE (val
), 0);
522 else if (TREE_CODE (rhs
) == ADDR_EXPR
)
524 tree ref
= TREE_OPERAND (rhs
, 0);
525 if (TREE_CODE (ref
) == MEM_REF
526 && integer_zerop (TREE_OPERAND (ref
, 1)))
528 result
= TREE_OPERAND (ref
, 0);
529 if (!useless_type_conversion_p (TREE_TYPE (rhs
),
531 result
= build1 (NOP_EXPR
, TREE_TYPE (rhs
), result
);
536 else if (TREE_CODE (rhs
) == CONSTRUCTOR
537 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
)
539 /* Fold a constant vector CONSTRUCTOR to VECTOR_CST. */
543 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
544 if (! CONSTANT_CLASS_P (val
))
547 return build_vector_from_ctor (TREE_TYPE (rhs
),
548 CONSTRUCTOR_ELTS (rhs
));
551 else if (DECL_P (rhs
)
552 && is_gimple_reg_type (TREE_TYPE (rhs
)))
553 return get_symbol_constant_value (rhs
);
557 case GIMPLE_UNARY_RHS
:
560 case GIMPLE_BINARY_RHS
:
563 case GIMPLE_TERNARY_RHS
:
564 result
= fold_ternary_loc (loc
, subcode
,
565 TREE_TYPE (gimple_assign_lhs (stmt
)),
566 gimple_assign_rhs1 (stmt
),
567 gimple_assign_rhs2 (stmt
),
568 gimple_assign_rhs3 (stmt
));
572 STRIP_USELESS_TYPE_CONVERSION (result
);
573 if (valid_gimple_rhs_p (result
))
578 case GIMPLE_INVALID_RHS
:
586 /* Replace a statement at *SI_P with a sequence of statements in STMTS,
587 adjusting the replacement stmts location and virtual operands.
588 If the statement has a lhs the last stmt in the sequence is expected
589 to assign to that lhs. */
592 gsi_replace_with_seq_vops (gimple_stmt_iterator
*si_p
, gimple_seq stmts
)
594 gimple
*stmt
= gsi_stmt (*si_p
);
596 if (gimple_has_location (stmt
))
597 annotate_all_with_location (stmts
, gimple_location (stmt
));
599 /* First iterate over the replacement statements backward, assigning
600 virtual operands to their defining statements. */
601 gimple
*laststore
= NULL
;
602 for (gimple_stmt_iterator i
= gsi_last (stmts
);
603 !gsi_end_p (i
); gsi_prev (&i
))
605 gimple
*new_stmt
= gsi_stmt (i
);
606 if ((gimple_assign_single_p (new_stmt
)
607 && !is_gimple_reg (gimple_assign_lhs (new_stmt
)))
608 || (is_gimple_call (new_stmt
)
609 && (gimple_call_flags (new_stmt
)
610 & (ECF_NOVOPS
| ECF_PURE
| ECF_CONST
| ECF_NORETURN
)) == 0))
614 vdef
= gimple_vdef (stmt
);
616 vdef
= make_ssa_name (gimple_vop (cfun
), new_stmt
);
617 gimple_set_vdef (new_stmt
, vdef
);
618 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
619 SSA_NAME_DEF_STMT (vdef
) = new_stmt
;
620 laststore
= new_stmt
;
624 /* Second iterate over the statements forward, assigning virtual
625 operands to their uses. */
626 tree reaching_vuse
= gimple_vuse (stmt
);
627 for (gimple_stmt_iterator i
= gsi_start (stmts
);
628 !gsi_end_p (i
); gsi_next (&i
))
630 gimple
*new_stmt
= gsi_stmt (i
);
631 /* If the new statement possibly has a VUSE, update it with exact SSA
632 name we know will reach this one. */
633 if (gimple_has_mem_ops (new_stmt
))
634 gimple_set_vuse (new_stmt
, reaching_vuse
);
635 gimple_set_modified (new_stmt
, true);
636 if (gimple_vdef (new_stmt
))
637 reaching_vuse
= gimple_vdef (new_stmt
);
640 /* If the new sequence does not do a store release the virtual
641 definition of the original statement. */
643 && reaching_vuse
== gimple_vuse (stmt
))
645 tree vdef
= gimple_vdef (stmt
);
647 && TREE_CODE (vdef
) == SSA_NAME
)
649 unlink_stmt_vdef (stmt
);
650 release_ssa_name (vdef
);
654 /* Finally replace the original statement with the sequence. */
655 gsi_replace_with_seq (si_p
, stmts
, false);
658 /* Helper function for update_gimple_call and
659 gimplify_and_update_call_from_tree. A GIMPLE_CALL STMT is being replaced
660 with GIMPLE_CALL NEW_STMT. */
663 finish_update_gimple_call (gimple_stmt_iterator
*si_p
, gimple
*new_stmt
,
666 tree lhs
= gimple_call_lhs (stmt
);
667 gimple_call_set_lhs (new_stmt
, lhs
);
668 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
669 SSA_NAME_DEF_STMT (lhs
) = new_stmt
;
670 gimple_move_vops (new_stmt
, stmt
);
671 gimple_set_location (new_stmt
, gimple_location (stmt
));
672 if (gimple_block (new_stmt
) == NULL_TREE
)
673 gimple_set_block (new_stmt
, gimple_block (stmt
));
674 gsi_replace (si_p
, new_stmt
, false);
677 /* Update a GIMPLE_CALL statement at iterator *SI_P to call to FN
678 with number of arguments NARGS, where the arguments in GIMPLE form
679 follow NARGS argument. */
682 update_gimple_call (gimple_stmt_iterator
*si_p
, tree fn
, int nargs
, ...)
685 gcall
*new_stmt
, *stmt
= as_a
<gcall
*> (gsi_stmt (*si_p
));
687 gcc_assert (is_gimple_call (stmt
));
688 va_start (ap
, nargs
);
689 new_stmt
= gimple_build_call_valist (fn
, nargs
, ap
);
690 finish_update_gimple_call (si_p
, new_stmt
, stmt
);
695 /* Return true if EXPR is a CALL_EXPR suitable for representation
696 as a single GIMPLE_CALL statement. If the arguments require
697 further gimplification, return false. */
700 valid_gimple_call_p (tree expr
)
704 if (TREE_CODE (expr
) != CALL_EXPR
)
707 nargs
= call_expr_nargs (expr
);
708 for (i
= 0; i
< nargs
; i
++)
710 tree arg
= CALL_EXPR_ARG (expr
, i
);
711 if (is_gimple_reg_type (TREE_TYPE (arg
)))
713 if (!is_gimple_val (arg
))
717 if (!is_gimple_lvalue (arg
))
724 /* Convert EXPR into a GIMPLE value suitable for substitution on the
725 RHS of an assignment. Insert the necessary statements before
726 iterator *SI_P. The statement at *SI_P, which must be a GIMPLE_CALL
727 is replaced. If the call is expected to produces a result, then it
728 is replaced by an assignment of the new RHS to the result variable.
729 If the result is to be ignored, then the call is replaced by a
730 GIMPLE_NOP. A proper VDEF chain is retained by making the first
731 VUSE and the last VDEF of the whole sequence be the same as the replaced
732 statement and using new SSA names for stores in between. */
735 gimplify_and_update_call_from_tree (gimple_stmt_iterator
*si_p
, tree expr
)
738 gimple
*stmt
, *new_stmt
;
739 gimple_stmt_iterator i
;
740 gimple_seq stmts
= NULL
;
742 stmt
= gsi_stmt (*si_p
);
744 gcc_assert (is_gimple_call (stmt
));
746 if (valid_gimple_call_p (expr
))
748 /* The call has simplified to another call. */
749 tree fn
= CALL_EXPR_FN (expr
);
751 unsigned nargs
= call_expr_nargs (expr
);
752 vec
<tree
> args
= vNULL
;
758 args
.safe_grow_cleared (nargs
, true);
760 for (i
= 0; i
< nargs
; i
++)
761 args
[i
] = CALL_EXPR_ARG (expr
, i
);
764 new_stmt
= gimple_build_call_vec (fn
, args
);
765 finish_update_gimple_call (si_p
, new_stmt
, stmt
);
770 lhs
= gimple_call_lhs (stmt
);
771 if (lhs
== NULL_TREE
)
773 push_gimplify_context (gimple_in_ssa_p (cfun
));
774 gimplify_and_add (expr
, &stmts
);
775 pop_gimplify_context (NULL
);
777 /* We can end up with folding a memcpy of an empty class assignment
778 which gets optimized away by C++ gimplification. */
779 if (gimple_seq_empty_p (stmts
))
781 if (gimple_in_ssa_p (cfun
))
783 unlink_stmt_vdef (stmt
);
786 gsi_replace (si_p
, gimple_build_nop (), false);
792 tree tmp
= force_gimple_operand (expr
, &stmts
, false, NULL_TREE
);
793 new_stmt
= gimple_build_assign (lhs
, tmp
);
794 i
= gsi_last (stmts
);
795 gsi_insert_after_without_update (&i
, new_stmt
,
796 GSI_CONTINUE_LINKING
);
799 gsi_replace_with_seq_vops (si_p
, stmts
);
803 /* Replace the call at *GSI with the gimple value VAL. */
806 replace_call_with_value (gimple_stmt_iterator
*gsi
, tree val
)
808 gimple
*stmt
= gsi_stmt (*gsi
);
809 tree lhs
= gimple_call_lhs (stmt
);
813 if (!useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (val
)))
814 val
= fold_convert (TREE_TYPE (lhs
), val
);
815 repl
= gimple_build_assign (lhs
, val
);
818 repl
= gimple_build_nop ();
819 tree vdef
= gimple_vdef (stmt
);
820 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
822 unlink_stmt_vdef (stmt
);
823 release_ssa_name (vdef
);
825 gsi_replace (gsi
, repl
, false);
828 /* Replace the call at *GSI with the new call REPL and fold that
832 replace_call_with_call_and_fold (gimple_stmt_iterator
*gsi
, gimple
*repl
)
834 gimple
*stmt
= gsi_stmt (*gsi
);
835 gimple_call_set_lhs (repl
, gimple_call_lhs (stmt
));
836 gimple_set_location (repl
, gimple_location (stmt
));
837 gimple_move_vops (repl
, stmt
);
838 gsi_replace (gsi
, repl
, false);
842 /* Return true if VAR is a VAR_DECL or a component thereof. */
845 var_decl_component_p (tree var
)
848 while (handled_component_p (inner
))
849 inner
= TREE_OPERAND (inner
, 0);
850 return (DECL_P (inner
)
851 || (TREE_CODE (inner
) == MEM_REF
852 && TREE_CODE (TREE_OPERAND (inner
, 0)) == ADDR_EXPR
));
855 /* Return TRUE if the SIZE argument, representing the size of an
856 object, is in a range of values of which exactly zero is valid. */
859 size_must_be_zero_p (tree size
)
861 if (integer_zerop (size
))
864 if (TREE_CODE (size
) != SSA_NAME
|| !INTEGRAL_TYPE_P (TREE_TYPE (size
)))
867 tree type
= TREE_TYPE (size
);
868 int prec
= TYPE_PRECISION (type
);
870 /* Compute the value of SSIZE_MAX, the largest positive value that
871 can be stored in ssize_t, the signed counterpart of size_t. */
872 wide_int ssize_max
= wi::lshift (wi::one (prec
), prec
- 1) - 1;
873 value_range
valid_range (build_int_cst (type
, 0),
874 wide_int_to_tree (type
, ssize_max
));
877 get_range_query (cfun
)->range_of_expr (vr
, size
);
879 get_global_range_query ()->range_of_expr (vr
, size
);
880 if (vr
.undefined_p ())
881 vr
.set_varying (TREE_TYPE (size
));
882 vr
.intersect (&valid_range
);
886 /* Fold function call to builtin mem{{,p}cpy,move}. Try to detect and
887 diagnose (otherwise undefined) overlapping copies without preventing
888 folding. When folded, GCC guarantees that overlapping memcpy has
889 the same semantics as memmove. Call to the library memcpy need not
890 provide the same guarantee. Return false if no simplification can
894 gimple_fold_builtin_memory_op (gimple_stmt_iterator
*gsi
,
895 tree dest
, tree src
, enum built_in_function code
)
897 gimple
*stmt
= gsi_stmt (*gsi
);
898 tree lhs
= gimple_call_lhs (stmt
);
899 tree len
= gimple_call_arg (stmt
, 2);
900 location_t loc
= gimple_location (stmt
);
902 /* If the LEN parameter is a constant zero or in range where
903 the only valid value is zero, return DEST. */
904 if (size_must_be_zero_p (len
))
907 if (gimple_call_lhs (stmt
))
908 repl
= gimple_build_assign (gimple_call_lhs (stmt
), dest
);
910 repl
= gimple_build_nop ();
911 tree vdef
= gimple_vdef (stmt
);
912 if (vdef
&& TREE_CODE (vdef
) == SSA_NAME
)
914 unlink_stmt_vdef (stmt
);
915 release_ssa_name (vdef
);
917 gsi_replace (gsi
, repl
, false);
921 /* If SRC and DEST are the same (and not volatile), return
922 DEST{,+LEN,+LEN-1}. */
923 if (operand_equal_p (src
, dest
, 0))
925 /* Avoid diagnosing exact overlap in calls to __builtin_memcpy.
926 It's safe and may even be emitted by GCC itself (see bug
928 unlink_stmt_vdef (stmt
);
929 if (gimple_vdef (stmt
) && TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
930 release_ssa_name (gimple_vdef (stmt
));
933 gsi_replace (gsi
, gimple_build_nop (), false);
940 /* We cannot (easily) change the type of the copy if it is a storage
941 order barrier, i.e. is equivalent to a VIEW_CONVERT_EXPR that can
942 modify the storage order of objects (see storage_order_barrier_p). */
944 = POINTER_TYPE_P (TREE_TYPE (src
))
945 ? TREE_TYPE (TREE_TYPE (src
)) : NULL_TREE
;
947 = POINTER_TYPE_P (TREE_TYPE (dest
))
948 ? TREE_TYPE (TREE_TYPE (dest
)) : NULL_TREE
;
949 tree destvar
, srcvar
, srcoff
;
950 unsigned int src_align
, dest_align
;
951 unsigned HOST_WIDE_INT tmp_len
;
954 /* Build accesses at offset zero with a ref-all character type. */
956 = build_int_cst (build_pointer_type_for_mode (char_type_node
,
959 /* If we can perform the copy efficiently with first doing all loads
960 and then all stores inline it that way. Currently efficiently
961 means that we can load all the memory into a single integer
962 register which is what MOVE_MAX gives us. */
963 src_align
= get_pointer_alignment (src
);
964 dest_align
= get_pointer_alignment (dest
);
965 if (tree_fits_uhwi_p (len
)
966 && compare_tree_int (len
, MOVE_MAX
) <= 0
967 /* FIXME: Don't transform copies from strings with known length.
968 Until GCC 9 this prevented a case in gcc.dg/strlenopt-8.c
969 from being handled, and the case was XFAILed for that reason.
970 Now that it is handled and the XFAIL removed, as soon as other
971 strlenopt tests that rely on it for passing are adjusted, this
972 hack can be removed. */
973 && !c_strlen (src
, 1)
974 && !((tmp_str
= getbyterep (src
, &tmp_len
)) != NULL
975 && memchr (tmp_str
, 0, tmp_len
) == NULL
)
977 && AGGREGATE_TYPE_P (srctype
)
978 && TYPE_REVERSE_STORAGE_ORDER (srctype
))
980 && AGGREGATE_TYPE_P (desttype
)
981 && TYPE_REVERSE_STORAGE_ORDER (desttype
)))
983 unsigned ilen
= tree_to_uhwi (len
);
984 if (pow2p_hwi (ilen
))
986 /* Detect out-of-bounds accesses without issuing warnings.
987 Avoid folding out-of-bounds copies but to avoid false
988 positives for unreachable code defer warning until after
989 DCE has worked its magic.
990 -Wrestrict is still diagnosed. */
991 if (int warning
= check_bounds_or_overlap (as_a
<gcall
*>(stmt
),
994 if (warning
!= OPT_Wrestrict
)
997 scalar_int_mode mode
;
998 tree type
= lang_hooks
.types
.type_for_size (ilen
* 8, 1);
1000 && is_a
<scalar_int_mode
> (TYPE_MODE (type
), &mode
)
1001 && GET_MODE_SIZE (mode
) * BITS_PER_UNIT
== ilen
* 8
1002 /* If the destination pointer is not aligned we must be able
1003 to emit an unaligned store. */
1004 && (dest_align
>= GET_MODE_ALIGNMENT (mode
)
1005 || !targetm
.slow_unaligned_access (mode
, dest_align
)
1006 || (optab_handler (movmisalign_optab
, mode
)
1007 != CODE_FOR_nothing
)))
1009 tree srctype
= type
;
1010 tree desttype
= type
;
1011 if (src_align
< GET_MODE_ALIGNMENT (mode
))
1012 srctype
= build_aligned_type (type
, src_align
);
1013 tree srcmem
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1014 tree tem
= fold_const_aggregate_ref (srcmem
);
1017 else if (src_align
< GET_MODE_ALIGNMENT (mode
)
1018 && targetm
.slow_unaligned_access (mode
, src_align
)
1019 && (optab_handler (movmisalign_optab
, mode
)
1020 == CODE_FOR_nothing
))
1025 if (is_gimple_reg_type (TREE_TYPE (srcmem
)))
1027 new_stmt
= gimple_build_assign (NULL_TREE
, srcmem
);
1029 = create_tmp_reg_or_ssa_name (TREE_TYPE (srcmem
),
1031 gimple_assign_set_lhs (new_stmt
, srcmem
);
1032 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
1033 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1035 if (dest_align
< GET_MODE_ALIGNMENT (mode
))
1036 desttype
= build_aligned_type (type
, dest_align
);
1038 = gimple_build_assign (fold_build2 (MEM_REF
, desttype
,
1041 gimple_move_vops (new_stmt
, stmt
);
1044 gsi_replace (gsi
, new_stmt
, false);
1047 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1054 if (code
== BUILT_IN_MEMMOVE
)
1056 /* Both DEST and SRC must be pointer types.
1057 ??? This is what old code did. Is the testing for pointer types
1060 If either SRC is readonly or length is 1, we can use memcpy. */
1061 if (!dest_align
|| !src_align
)
1063 if (readonly_data_expr (src
)
1064 || (tree_fits_uhwi_p (len
)
1065 && (MIN (src_align
, dest_align
) / BITS_PER_UNIT
1066 >= tree_to_uhwi (len
))))
1068 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1071 gimple_call_set_fndecl (stmt
, fn
);
1072 gimple_call_set_arg (stmt
, 0, dest
);
1073 gimple_call_set_arg (stmt
, 1, src
);
1078 /* If *src and *dest can't overlap, optimize into memcpy as well. */
1079 if (TREE_CODE (src
) == ADDR_EXPR
1080 && TREE_CODE (dest
) == ADDR_EXPR
)
1082 tree src_base
, dest_base
, fn
;
1083 poly_int64 src_offset
= 0, dest_offset
= 0;
1084 poly_uint64 maxsize
;
1086 srcvar
= TREE_OPERAND (src
, 0);
1087 src_base
= get_addr_base_and_unit_offset (srcvar
, &src_offset
);
1088 if (src_base
== NULL
)
1090 destvar
= TREE_OPERAND (dest
, 0);
1091 dest_base
= get_addr_base_and_unit_offset (destvar
,
1093 if (dest_base
== NULL
)
1094 dest_base
= destvar
;
1095 if (!poly_int_tree_p (len
, &maxsize
))
1097 if (SSA_VAR_P (src_base
)
1098 && SSA_VAR_P (dest_base
))
1100 if (operand_equal_p (src_base
, dest_base
, 0)
1101 && ranges_maybe_overlap_p (src_offset
, maxsize
,
1102 dest_offset
, maxsize
))
1105 else if (TREE_CODE (src_base
) == MEM_REF
1106 && TREE_CODE (dest_base
) == MEM_REF
)
1108 if (! operand_equal_p (TREE_OPERAND (src_base
, 0),
1109 TREE_OPERAND (dest_base
, 0), 0))
1111 poly_offset_int full_src_offset
1112 = mem_ref_offset (src_base
) + src_offset
;
1113 poly_offset_int full_dest_offset
1114 = mem_ref_offset (dest_base
) + dest_offset
;
1115 if (ranges_maybe_overlap_p (full_src_offset
, maxsize
,
1116 full_dest_offset
, maxsize
))
1122 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1125 gimple_call_set_fndecl (stmt
, fn
);
1126 gimple_call_set_arg (stmt
, 0, dest
);
1127 gimple_call_set_arg (stmt
, 1, src
);
1132 /* If the destination and source do not alias optimize into
1134 if ((is_gimple_min_invariant (dest
)
1135 || TREE_CODE (dest
) == SSA_NAME
)
1136 && (is_gimple_min_invariant (src
)
1137 || TREE_CODE (src
) == SSA_NAME
))
1140 ao_ref_init_from_ptr_and_size (&destr
, dest
, len
);
1141 ao_ref_init_from_ptr_and_size (&srcr
, src
, len
);
1142 if (!refs_may_alias_p_1 (&destr
, &srcr
, false))
1145 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
1148 gimple_call_set_fndecl (stmt
, fn
);
1149 gimple_call_set_arg (stmt
, 0, dest
);
1150 gimple_call_set_arg (stmt
, 1, src
);
1159 if (!tree_fits_shwi_p (len
))
1162 || (AGGREGATE_TYPE_P (srctype
)
1163 && TYPE_REVERSE_STORAGE_ORDER (srctype
)))
1166 || (AGGREGATE_TYPE_P (desttype
)
1167 && TYPE_REVERSE_STORAGE_ORDER (desttype
)))
1169 /* In the following try to find a type that is most natural to be
1170 used for the memcpy source and destination and that allows
1171 the most optimization when memcpy is turned into a plain assignment
1172 using that type. In theory we could always use a char[len] type
1173 but that only gains us that the destination and source possibly
1174 no longer will have their address taken. */
1175 if (TREE_CODE (srctype
) == ARRAY_TYPE
1176 && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
))
1177 srctype
= TREE_TYPE (srctype
);
1178 if (TREE_CODE (desttype
) == ARRAY_TYPE
1179 && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
))
1180 desttype
= TREE_TYPE (desttype
);
1181 if (TREE_ADDRESSABLE (srctype
)
1182 || TREE_ADDRESSABLE (desttype
))
1185 /* Make sure we are not copying using a floating-point mode or
1186 a type whose size possibly does not match its precision. */
1187 if (FLOAT_MODE_P (TYPE_MODE (desttype
))
1188 || TREE_CODE (desttype
) == BOOLEAN_TYPE
1189 || TREE_CODE (desttype
) == ENUMERAL_TYPE
)
1190 desttype
= bitwise_type_for_mode (TYPE_MODE (desttype
));
1191 if (FLOAT_MODE_P (TYPE_MODE (srctype
))
1192 || TREE_CODE (srctype
) == BOOLEAN_TYPE
1193 || TREE_CODE (srctype
) == ENUMERAL_TYPE
)
1194 srctype
= bitwise_type_for_mode (TYPE_MODE (srctype
));
1202 src_align
= get_pointer_alignment (src
);
1203 dest_align
= get_pointer_alignment (dest
);
1205 /* Choose between src and destination type for the access based
1206 on alignment, whether the access constitutes a register access
1207 and whether it may actually expose a declaration for SSA rewrite
1208 or SRA decomposition. Also try to expose a string constant, we
1209 might be able to concatenate several of them later into a single
1211 destvar
= NULL_TREE
;
1213 if (TREE_CODE (dest
) == ADDR_EXPR
1214 && var_decl_component_p (TREE_OPERAND (dest
, 0))
1215 && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype
), len
)
1216 && dest_align
>= TYPE_ALIGN (desttype
)
1217 && (is_gimple_reg_type (desttype
)
1218 || src_align
>= TYPE_ALIGN (desttype
)))
1219 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
1220 else if (TREE_CODE (src
) == ADDR_EXPR
1221 && var_decl_component_p (TREE_OPERAND (src
, 0))
1222 && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype
), len
)
1223 && src_align
>= TYPE_ALIGN (srctype
)
1224 && (is_gimple_reg_type (srctype
)
1225 || dest_align
>= TYPE_ALIGN (srctype
)))
1226 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1227 /* FIXME: Don't transform copies from strings with known original length.
1228 As soon as strlenopt tests that rely on it for passing are adjusted,
1229 this hack can be removed. */
1230 else if (gimple_call_alloca_for_var_p (stmt
)
1231 && (srcvar
= string_constant (src
, &srcoff
, NULL
, NULL
))
1232 && integer_zerop (srcoff
)
1233 && tree_int_cst_equal (TYPE_SIZE_UNIT (TREE_TYPE (srcvar
)), len
)
1234 && dest_align
>= TYPE_ALIGN (TREE_TYPE (srcvar
)))
1235 srctype
= TREE_TYPE (srcvar
);
1239 /* Now that we chose an access type express the other side in
1240 terms of it if the target allows that with respect to alignment
1242 if (srcvar
== NULL_TREE
)
1244 if (src_align
>= TYPE_ALIGN (desttype
))
1245 srcvar
= fold_build2 (MEM_REF
, desttype
, src
, off0
);
1248 if (STRICT_ALIGNMENT
)
1250 srctype
= build_aligned_type (TYPE_MAIN_VARIANT (desttype
),
1252 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1255 else if (destvar
== NULL_TREE
)
1257 if (dest_align
>= TYPE_ALIGN (srctype
))
1258 destvar
= fold_build2 (MEM_REF
, srctype
, dest
, off0
);
1261 if (STRICT_ALIGNMENT
)
1263 desttype
= build_aligned_type (TYPE_MAIN_VARIANT (srctype
),
1265 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
1269 /* Same as above, detect out-of-bounds accesses without issuing
1270 warnings. Avoid folding out-of-bounds copies but to avoid
1271 false positives for unreachable code defer warning until
1272 after DCE has worked its magic.
1273 -Wrestrict is still diagnosed. */
1274 if (int warning
= check_bounds_or_overlap (as_a
<gcall
*>(stmt
),
1275 dest
, src
, len
, len
,
1277 if (warning
!= OPT_Wrestrict
)
1281 if (is_gimple_reg_type (TREE_TYPE (srcvar
)))
1283 tree tem
= fold_const_aggregate_ref (srcvar
);
1286 if (! is_gimple_min_invariant (srcvar
))
1288 new_stmt
= gimple_build_assign (NULL_TREE
, srcvar
);
1289 srcvar
= create_tmp_reg_or_ssa_name (TREE_TYPE (srcvar
),
1291 gimple_assign_set_lhs (new_stmt
, srcvar
);
1292 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
1293 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1295 new_stmt
= gimple_build_assign (destvar
, srcvar
);
1296 goto set_vop_and_replace
;
1299 /* We get an aggregate copy. If the source is a STRING_CST, then
1300 directly use its type to perform the copy. */
1301 if (TREE_CODE (srcvar
) == STRING_CST
)
1304 /* Or else, use an unsigned char[] type to perform the copy in order
1305 to preserve padding and to avoid any issues with TREE_ADDRESSABLE
1306 types or float modes behavior on copying. */
1309 desttype
= build_array_type_nelts (unsigned_char_type_node
,
1310 tree_to_uhwi (len
));
1312 if (src_align
> TYPE_ALIGN (srctype
))
1313 srctype
= build_aligned_type (srctype
, src_align
);
1314 srcvar
= fold_build2 (MEM_REF
, srctype
, src
, off0
);
1317 if (dest_align
> TYPE_ALIGN (desttype
))
1318 desttype
= build_aligned_type (desttype
, dest_align
);
1319 destvar
= fold_build2 (MEM_REF
, desttype
, dest
, off0
);
1320 new_stmt
= gimple_build_assign (destvar
, srcvar
);
1322 set_vop_and_replace
:
1323 gimple_move_vops (new_stmt
, stmt
);
1326 gsi_replace (gsi
, new_stmt
, false);
1329 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1333 gimple_seq stmts
= NULL
;
1334 if (code
== BUILT_IN_MEMCPY
|| code
== BUILT_IN_MEMMOVE
)
1336 else if (code
== BUILT_IN_MEMPCPY
)
1338 len
= gimple_convert_to_ptrofftype (&stmts
, loc
, len
);
1339 dest
= gimple_build (&stmts
, loc
, POINTER_PLUS_EXPR
,
1340 TREE_TYPE (dest
), dest
, len
);
1345 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
1346 gimple
*repl
= gimple_build_assign (lhs
, dest
);
1347 gsi_replace (gsi
, repl
, false);
1351 /* Transform a call to built-in bcmp(a, b, len) at *GSI into one
1352 to built-in memcmp (a, b, len). */
1355 gimple_fold_builtin_bcmp (gimple_stmt_iterator
*gsi
)
1357 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCMP
);
1362 /* Transform bcmp (a, b, len) into memcmp (a, b, len). */
1364 gimple
*stmt
= gsi_stmt (*gsi
);
1365 tree a
= gimple_call_arg (stmt
, 0);
1366 tree b
= gimple_call_arg (stmt
, 1);
1367 tree len
= gimple_call_arg (stmt
, 2);
1369 gimple
*repl
= gimple_build_call (fn
, 3, a
, b
, len
);
1370 replace_call_with_call_and_fold (gsi
, repl
);
1375 /* Transform a call to built-in bcopy (src, dest, len) at *GSI into one
1376 to built-in memmove (dest, src, len). */
1379 gimple_fold_builtin_bcopy (gimple_stmt_iterator
*gsi
)
1381 tree fn
= builtin_decl_implicit (BUILT_IN_MEMMOVE
);
1386 /* bcopy has been removed from POSIX in Issue 7 but Issue 6 specifies
1387 it's quivalent to memmove (not memcpy). Transform bcopy (src, dest,
1388 len) into memmove (dest, src, len). */
1390 gimple
*stmt
= gsi_stmt (*gsi
);
1391 tree src
= gimple_call_arg (stmt
, 0);
1392 tree dest
= gimple_call_arg (stmt
, 1);
1393 tree len
= gimple_call_arg (stmt
, 2);
1395 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
1396 gimple_call_set_fntype (as_a
<gcall
*> (stmt
), TREE_TYPE (fn
));
1397 replace_call_with_call_and_fold (gsi
, repl
);
1402 /* Transform a call to built-in bzero (dest, len) at *GSI into one
1403 to built-in memset (dest, 0, len). */
1406 gimple_fold_builtin_bzero (gimple_stmt_iterator
*gsi
)
1408 tree fn
= builtin_decl_implicit (BUILT_IN_MEMSET
);
1413 /* Transform bzero (dest, len) into memset (dest, 0, len). */
1415 gimple
*stmt
= gsi_stmt (*gsi
);
1416 tree dest
= gimple_call_arg (stmt
, 0);
1417 tree len
= gimple_call_arg (stmt
, 1);
1419 gimple_seq seq
= NULL
;
1420 gimple
*repl
= gimple_build_call (fn
, 3, dest
, integer_zero_node
, len
);
1421 gimple_seq_add_stmt_without_update (&seq
, repl
);
1422 gsi_replace_with_seq_vops (gsi
, seq
);
1428 /* Fold function call to builtin memset or bzero at *GSI setting the
1429 memory of size LEN to VAL. Return whether a simplification was made. */
1432 gimple_fold_builtin_memset (gimple_stmt_iterator
*gsi
, tree c
, tree len
)
1434 gimple
*stmt
= gsi_stmt (*gsi
);
1436 unsigned HOST_WIDE_INT length
, cval
;
1438 /* If the LEN parameter is zero, return DEST. */
1439 if (integer_zerop (len
))
1441 replace_call_with_value (gsi
, gimple_call_arg (stmt
, 0));
1445 if (! tree_fits_uhwi_p (len
))
1448 if (TREE_CODE (c
) != INTEGER_CST
)
1451 tree dest
= gimple_call_arg (stmt
, 0);
1453 if (TREE_CODE (var
) != ADDR_EXPR
)
1456 var
= TREE_OPERAND (var
, 0);
1457 if (TREE_THIS_VOLATILE (var
))
1460 etype
= TREE_TYPE (var
);
1461 if (TREE_CODE (etype
) == ARRAY_TYPE
)
1462 etype
= TREE_TYPE (etype
);
1464 if (!INTEGRAL_TYPE_P (etype
)
1465 && !POINTER_TYPE_P (etype
))
1468 if (! var_decl_component_p (var
))
1471 length
= tree_to_uhwi (len
);
1472 if (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (etype
)) != length
1473 || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (etype
))
1474 != GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (etype
)))
1475 || get_pointer_alignment (dest
) / BITS_PER_UNIT
< length
)
1478 if (length
> HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
)
1481 if (!type_has_mode_precision_p (etype
))
1482 etype
= lang_hooks
.types
.type_for_mode (SCALAR_INT_TYPE_MODE (etype
),
1483 TYPE_UNSIGNED (etype
));
1485 if (integer_zerop (c
))
1489 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8 || HOST_BITS_PER_WIDE_INT
> 64)
1492 cval
= TREE_INT_CST_LOW (c
);
1496 cval
|= (cval
<< 31) << 1;
1499 var
= fold_build2 (MEM_REF
, etype
, dest
, build_int_cst (ptr_type_node
, 0));
1500 gimple
*store
= gimple_build_assign (var
, build_int_cst_type (etype
, cval
));
1501 gimple_move_vops (store
, stmt
);
1502 gsi_insert_before (gsi
, store
, GSI_SAME_STMT
);
1503 if (gimple_call_lhs (stmt
))
1505 gimple
*asgn
= gimple_build_assign (gimple_call_lhs (stmt
), dest
);
1506 gsi_replace (gsi
, asgn
, false);
1510 gimple_stmt_iterator gsi2
= *gsi
;
1512 gsi_remove (&gsi2
, true);
1518 /* Helper of get_range_strlen for ARG that is not an SSA_NAME. */
1521 get_range_strlen_tree (tree arg
, bitmap
*visited
, strlen_range_kind rkind
,
1522 c_strlen_data
*pdata
, unsigned eltsize
)
1524 gcc_assert (TREE_CODE (arg
) != SSA_NAME
);
1526 /* The length computed by this invocation of the function. */
1527 tree val
= NULL_TREE
;
1529 /* True if VAL is an optimistic (tight) bound determined from
1530 the size of the character array in which the string may be
1531 stored. In that case, the computed VAL is used to set
1533 bool tight_bound
= false;
1535 /* We can end up with &(*iftmp_1)[0] here as well, so handle it. */
1536 if (TREE_CODE (arg
) == ADDR_EXPR
1537 && TREE_CODE (TREE_OPERAND (arg
, 0)) == ARRAY_REF
)
1539 tree op
= TREE_OPERAND (arg
, 0);
1540 if (integer_zerop (TREE_OPERAND (op
, 1)))
1542 tree aop0
= TREE_OPERAND (op
, 0);
1543 if (TREE_CODE (aop0
) == INDIRECT_REF
1544 && TREE_CODE (TREE_OPERAND (aop0
, 0)) == SSA_NAME
)
1545 return get_range_strlen (TREE_OPERAND (aop0
, 0), visited
, rkind
,
1548 else if (TREE_CODE (TREE_OPERAND (op
, 0)) == COMPONENT_REF
1549 && rkind
== SRK_LENRANGE
)
1551 /* Fail if an array is the last member of a struct object
1552 since it could be treated as a (fake) flexible array
1554 tree idx
= TREE_OPERAND (op
, 1);
1556 arg
= TREE_OPERAND (op
, 0);
1557 tree optype
= TREE_TYPE (arg
);
1558 if (tree dom
= TYPE_DOMAIN (optype
))
1559 if (tree bound
= TYPE_MAX_VALUE (dom
))
1560 if (TREE_CODE (bound
) == INTEGER_CST
1561 && TREE_CODE (idx
) == INTEGER_CST
1562 && tree_int_cst_lt (bound
, idx
))
1567 if (rkind
== SRK_INT_VALUE
)
1569 /* We are computing the maximum value (not string length). */
1571 if (TREE_CODE (val
) != INTEGER_CST
1572 || tree_int_cst_sgn (val
) < 0)
1577 c_strlen_data lendata
= { };
1578 val
= c_strlen (arg
, 1, &lendata
, eltsize
);
1580 if (!val
&& lendata
.decl
)
1582 /* ARG refers to an unterminated const character array.
1583 DATA.DECL with size DATA.LEN. */
1584 val
= lendata
.minlen
;
1585 pdata
->decl
= lendata
.decl
;
1589 /* Set if VAL represents the maximum length based on array size (set
1590 when exact length cannot be determined). */
1591 bool maxbound
= false;
1593 if (!val
&& rkind
== SRK_LENRANGE
)
1595 if (TREE_CODE (arg
) == ADDR_EXPR
)
1596 return get_range_strlen (TREE_OPERAND (arg
, 0), visited
, rkind
,
1599 if (TREE_CODE (arg
) == ARRAY_REF
)
1601 tree optype
= TREE_TYPE (TREE_OPERAND (arg
, 0));
1603 /* Determine the "innermost" array type. */
1604 while (TREE_CODE (optype
) == ARRAY_TYPE
1605 && TREE_CODE (TREE_TYPE (optype
)) == ARRAY_TYPE
)
1606 optype
= TREE_TYPE (optype
);
1608 /* Avoid arrays of pointers. */
1609 tree eltype
= TREE_TYPE (optype
);
1610 if (TREE_CODE (optype
) != ARRAY_TYPE
1611 || !INTEGRAL_TYPE_P (eltype
))
1614 /* Fail when the array bound is unknown or zero. */
1615 val
= TYPE_SIZE_UNIT (optype
);
1617 || TREE_CODE (val
) != INTEGER_CST
1618 || integer_zerop (val
))
1621 val
= fold_build2 (MINUS_EXPR
, TREE_TYPE (val
), val
,
1624 /* Set the minimum size to zero since the string in
1625 the array could have zero length. */
1626 pdata
->minlen
= ssize_int (0);
1630 else if (TREE_CODE (arg
) == COMPONENT_REF
1631 && (TREE_CODE (TREE_TYPE (TREE_OPERAND (arg
, 1)))
1634 /* Use the type of the member array to determine the upper
1635 bound on the length of the array. This may be overly
1636 optimistic if the array itself isn't NUL-terminated and
1637 the caller relies on the subsequent member to contain
1638 the NUL but that would only be considered valid if
1639 the array were the last member of a struct. */
1641 tree fld
= TREE_OPERAND (arg
, 1);
1643 tree optype
= TREE_TYPE (fld
);
1645 /* Determine the "innermost" array type. */
1646 while (TREE_CODE (optype
) == ARRAY_TYPE
1647 && TREE_CODE (TREE_TYPE (optype
)) == ARRAY_TYPE
)
1648 optype
= TREE_TYPE (optype
);
1650 /* Fail when the array bound is unknown or zero. */
1651 val
= TYPE_SIZE_UNIT (optype
);
1653 || TREE_CODE (val
) != INTEGER_CST
1654 || integer_zerop (val
))
1656 val
= fold_build2 (MINUS_EXPR
, TREE_TYPE (val
), val
,
1659 /* Set the minimum size to zero since the string in
1660 the array could have zero length. */
1661 pdata
->minlen
= ssize_int (0);
1663 /* The array size determined above is an optimistic bound
1664 on the length. If the array isn't nul-terminated the
1665 length computed by the library function would be greater.
1666 Even though using strlen to cross the subobject boundary
1667 is undefined, avoid drawing conclusions from the member
1668 type about the length here. */
1671 else if (TREE_CODE (arg
) == MEM_REF
1672 && TREE_CODE (TREE_TYPE (arg
)) == ARRAY_TYPE
1673 && TREE_CODE (TREE_TYPE (TREE_TYPE (arg
))) == INTEGER_TYPE
1674 && TREE_CODE (TREE_OPERAND (arg
, 0)) == ADDR_EXPR
)
1676 /* Handle a MEM_REF into a DECL accessing an array of integers,
1677 being conservative about references to extern structures with
1678 flexible array members that can be initialized to arbitrary
1679 numbers of elements as an extension (static structs are okay).
1680 FIXME: Make this less conservative -- see
1681 component_ref_size in tree.c. */
1682 tree ref
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
1683 if ((TREE_CODE (ref
) == PARM_DECL
|| VAR_P (ref
))
1684 && (decl_binds_to_current_def_p (ref
)
1685 || !array_at_struct_end_p (arg
)))
1687 /* Fail if the offset is out of bounds. Such accesses
1688 should be diagnosed at some point. */
1689 val
= DECL_SIZE_UNIT (ref
);
1691 || TREE_CODE (val
) != INTEGER_CST
1692 || integer_zerop (val
))
1695 poly_offset_int psiz
= wi::to_offset (val
);
1696 poly_offset_int poff
= mem_ref_offset (arg
);
1697 if (known_le (psiz
, poff
))
1700 pdata
->minlen
= ssize_int (0);
1702 /* Subtract the offset and one for the terminating nul. */
1705 val
= wide_int_to_tree (TREE_TYPE (val
), psiz
);
1706 /* Since VAL reflects the size of a declared object
1707 rather the type of the access it is not a tight bound. */
1710 else if (TREE_CODE (arg
) == PARM_DECL
|| VAR_P (arg
))
1712 /* Avoid handling pointers to arrays. GCC might misuse
1713 a pointer to an array of one bound to point to an array
1714 object of a greater bound. */
1715 tree argtype
= TREE_TYPE (arg
);
1716 if (TREE_CODE (argtype
) == ARRAY_TYPE
)
1718 val
= TYPE_SIZE_UNIT (argtype
);
1720 || TREE_CODE (val
) != INTEGER_CST
1721 || integer_zerop (val
))
1723 val
= wide_int_to_tree (TREE_TYPE (val
),
1724 wi::sub (wi::to_wide (val
), 1));
1726 /* Set the minimum size to zero since the string in
1727 the array could have zero length. */
1728 pdata
->minlen
= ssize_int (0);
1737 /* Adjust the lower bound on the string length as necessary. */
1739 || (rkind
!= SRK_STRLEN
1740 && TREE_CODE (pdata
->minlen
) == INTEGER_CST
1741 && TREE_CODE (val
) == INTEGER_CST
1742 && tree_int_cst_lt (val
, pdata
->minlen
)))
1743 pdata
->minlen
= val
;
1745 if (pdata
->maxbound
&& TREE_CODE (pdata
->maxbound
) == INTEGER_CST
)
1747 /* Adjust the tighter (more optimistic) string length bound
1748 if necessary and proceed to adjust the more conservative
1750 if (TREE_CODE (val
) == INTEGER_CST
)
1752 if (tree_int_cst_lt (pdata
->maxbound
, val
))
1753 pdata
->maxbound
= val
;
1756 pdata
->maxbound
= val
;
1758 else if (pdata
->maxbound
|| maxbound
)
1759 /* Set PDATA->MAXBOUND only if it either isn't INTEGER_CST or
1760 if VAL corresponds to the maximum length determined based
1761 on the type of the object. */
1762 pdata
->maxbound
= val
;
1766 /* VAL computed above represents an optimistically tight bound
1767 on the length of the string based on the referenced object's
1768 or subobject's type. Determine the conservative upper bound
1769 based on the enclosing object's size if possible. */
1770 if (rkind
== SRK_LENRANGE
)
1773 tree base
= get_addr_base_and_unit_offset (arg
, &offset
);
1776 /* When the call above fails due to a non-constant offset
1777 assume the offset is zero and use the size of the whole
1778 enclosing object instead. */
1779 base
= get_base_address (arg
);
1782 /* If the base object is a pointer no upper bound on the length
1783 can be determined. Otherwise the maximum length is equal to
1784 the size of the enclosing object minus the offset of
1785 the referenced subobject minus 1 (for the terminating nul). */
1786 tree type
= TREE_TYPE (base
);
1787 if (TREE_CODE (type
) == POINTER_TYPE
1788 || (TREE_CODE (base
) != PARM_DECL
&& !VAR_P (base
))
1789 || !(val
= DECL_SIZE_UNIT (base
)))
1790 val
= build_all_ones_cst (size_type_node
);
1793 val
= DECL_SIZE_UNIT (base
);
1794 val
= fold_build2 (MINUS_EXPR
, TREE_TYPE (val
), val
,
1795 size_int (offset
+ 1));
1804 /* Adjust the more conservative bound if possible/necessary
1805 and fail otherwise. */
1806 if (rkind
!= SRK_STRLEN
)
1808 if (TREE_CODE (pdata
->maxlen
) != INTEGER_CST
1809 || TREE_CODE (val
) != INTEGER_CST
)
1812 if (tree_int_cst_lt (pdata
->maxlen
, val
))
1813 pdata
->maxlen
= val
;
1816 else if (simple_cst_equal (val
, pdata
->maxlen
) != 1)
1818 /* Fail if the length of this ARG is different from that
1819 previously determined from another ARG. */
1824 pdata
->maxlen
= val
;
1825 return rkind
== SRK_LENRANGE
|| !integer_all_onesp (val
);
1828 /* For an ARG referencing one or more strings, try to obtain the range
1829 of their lengths, or the size of the largest array ARG referes to if
1830 the range of lengths cannot be determined, and store all in *PDATA.
1831 For an integer ARG (when RKIND == SRK_INT_VALUE), try to determine
1832 the maximum constant value.
1833 If ARG is an SSA_NAME, follow its use-def chains. When RKIND ==
1834 SRK_STRLEN, then if PDATA->MAXLEN is not equal to the determined
1835 length or if we are unable to determine the length, return false.
1836 VISITED is a bitmap of visited variables.
1837 RKIND determines the kind of value or range to obtain (see
1839 Set PDATA->DECL if ARG refers to an unterminated constant array.
1840 On input, set ELTSIZE to 1 for normal single byte character strings,
1841 and either 2 or 4 for wide characer strings (the size of wchar_t).
1842 Return true if *PDATA was successfully populated and false otherwise. */
1845 get_range_strlen (tree arg
, bitmap
*visited
,
1846 strlen_range_kind rkind
,
1847 c_strlen_data
*pdata
, unsigned eltsize
)
1850 if (TREE_CODE (arg
) != SSA_NAME
)
1851 return get_range_strlen_tree (arg
, visited
, rkind
, pdata
, eltsize
);
1853 /* If ARG is registered for SSA update we cannot look at its defining
1855 if (name_registered_for_update_p (arg
))
1858 /* If we were already here, break the infinite cycle. */
1860 *visited
= BITMAP_ALLOC (NULL
);
1861 if (!bitmap_set_bit (*visited
, SSA_NAME_VERSION (arg
)))
1865 gimple
*def_stmt
= SSA_NAME_DEF_STMT (var
);
1867 switch (gimple_code (def_stmt
))
1870 /* The RHS of the statement defining VAR must either have a
1871 constant length or come from another SSA_NAME with a constant
1873 if (gimple_assign_single_p (def_stmt
)
1874 || gimple_assign_unary_nop_p (def_stmt
))
1876 tree rhs
= gimple_assign_rhs1 (def_stmt
);
1877 return get_range_strlen (rhs
, visited
, rkind
, pdata
, eltsize
);
1879 else if (gimple_assign_rhs_code (def_stmt
) == COND_EXPR
)
1881 tree ops
[2] = { gimple_assign_rhs2 (def_stmt
),
1882 gimple_assign_rhs3 (def_stmt
) };
1884 for (unsigned int i
= 0; i
< 2; i
++)
1885 if (!get_range_strlen (ops
[i
], visited
, rkind
, pdata
, eltsize
))
1887 if (rkind
!= SRK_LENRANGE
)
1889 /* Set the upper bound to the maximum to prevent
1890 it from being adjusted in the next iteration but
1891 leave MINLEN and the more conservative MAXBOUND
1892 determined so far alone (or leave them null if
1893 they haven't been set yet). That the MINLEN is
1894 in fact zero can be determined from MAXLEN being
1895 unbounded but the discovered minimum is used for
1897 pdata
->maxlen
= build_all_ones_cst (size_type_node
);
1904 /* Unless RKIND == SRK_LENRANGE, all arguments of the PHI node
1905 must have a constant length. */
1906 for (unsigned i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1908 tree arg
= gimple_phi_arg (def_stmt
, i
)->def
;
1910 /* If this PHI has itself as an argument, we cannot
1911 determine the string length of this argument. However,
1912 if we can find a constant string length for the other
1913 PHI args then we can still be sure that this is a
1914 constant string length. So be optimistic and just
1915 continue with the next argument. */
1916 if (arg
== gimple_phi_result (def_stmt
))
1919 if (!get_range_strlen (arg
, visited
, rkind
, pdata
, eltsize
))
1921 if (rkind
!= SRK_LENRANGE
)
1923 /* Set the upper bound to the maximum to prevent
1924 it from being adjusted in the next iteration but
1925 leave MINLEN and the more conservative MAXBOUND
1926 determined so far alone (or leave them null if
1927 they haven't been set yet). That the MINLEN is
1928 in fact zero can be determined from MAXLEN being
1929 unbounded but the discovered minimum is used for
1931 pdata
->maxlen
= build_all_ones_cst (size_type_node
);
1941 /* Try to obtain the range of the lengths of the string(s) referenced
1942 by ARG, or the size of the largest array ARG refers to if the range
1943 of lengths cannot be determined, and store all in *PDATA which must
1944 be zero-initialized on input except PDATA->MAXBOUND may be set to
1945 a non-null tree node other than INTEGER_CST to request to have it
1946 set to the length of the longest string in a PHI. ELTSIZE is
1947 the expected size of the string element in bytes: 1 for char and
1948 some power of 2 for wide characters.
1949 Return true if the range [PDATA->MINLEN, PDATA->MAXLEN] is suitable
1950 for optimization. Returning false means that a nonzero PDATA->MINLEN
1951 doesn't reflect the true lower bound of the range when PDATA->MAXLEN
1952 is -1 (in that case, the actual range is indeterminate, i.e.,
1953 [0, PTRDIFF_MAX - 2]. */
1956 get_range_strlen (tree arg
, c_strlen_data
*pdata
, unsigned eltsize
)
1958 bitmap visited
= NULL
;
1959 tree maxbound
= pdata
->maxbound
;
1961 if (!get_range_strlen (arg
, &visited
, SRK_LENRANGE
, pdata
, eltsize
))
1963 /* On failure extend the length range to an impossible maximum
1964 (a valid MAXLEN must be less than PTRDIFF_MAX - 1). Other
1965 members can stay unchanged regardless. */
1966 pdata
->minlen
= ssize_int (0);
1967 pdata
->maxlen
= build_all_ones_cst (size_type_node
);
1969 else if (!pdata
->minlen
)
1970 pdata
->minlen
= ssize_int (0);
1972 /* If it's unchanged from it initial non-null value, set the conservative
1973 MAXBOUND to SIZE_MAX. Otherwise leave it null (if it is null). */
1974 if (maxbound
&& pdata
->maxbound
== maxbound
)
1975 pdata
->maxbound
= build_all_ones_cst (size_type_node
);
1978 BITMAP_FREE (visited
);
1980 return !integer_all_onesp (pdata
->maxlen
);
1983 /* Return the maximum value for ARG given RKIND (see strlen_range_kind).
1984 For ARG of pointer types, NONSTR indicates if the caller is prepared
1985 to handle unterminated strings. For integer ARG and when RKIND ==
1986 SRK_INT_VALUE, NONSTR must be null.
1988 If an unterminated array is discovered and our caller handles
1989 unterminated arrays, then bubble up the offending DECL and
1990 return the maximum size. Otherwise return NULL. */
1993 get_maxval_strlen (tree arg
, strlen_range_kind rkind
, tree
*nonstr
= NULL
)
1995 /* A non-null NONSTR is meaningless when determining the maximum
1996 value of an integer ARG. */
1997 gcc_assert (rkind
!= SRK_INT_VALUE
|| nonstr
== NULL
);
1998 /* ARG must have an integral type when RKIND says so. */
1999 gcc_assert (rkind
!= SRK_INT_VALUE
|| INTEGRAL_TYPE_P (TREE_TYPE (arg
)));
2001 bitmap visited
= NULL
;
2003 /* Reset DATA.MAXLEN if the call fails or when DATA.MAXLEN
2005 c_strlen_data lendata
= { };
2006 if (!get_range_strlen (arg
, &visited
, rkind
, &lendata
, /* eltsize = */1))
2007 lendata
.maxlen
= NULL_TREE
;
2008 else if (lendata
.maxlen
&& integer_all_onesp (lendata
.maxlen
))
2009 lendata
.maxlen
= NULL_TREE
;
2012 BITMAP_FREE (visited
);
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
;
2028 /* Fold function call to builtin strcpy with arguments DEST and SRC.
2029 If LEN is not NULL, it represents the length of the string to be
2030 copied. Return NULL_TREE if no simplification can be made. */
2033 gimple_fold_builtin_strcpy (gimple_stmt_iterator
*gsi
,
2034 tree dest
, tree src
)
2036 gimple
*stmt
= gsi_stmt (*gsi
);
2037 location_t loc
= gimple_location (stmt
);
2040 /* If SRC and DEST are the same (and not volatile), return DEST. */
2041 if (operand_equal_p (src
, dest
, 0))
2043 /* Issue -Wrestrict unless the pointers are null (those do
2044 not point to objects and so do not indicate an overlap;
2045 such calls could be the result of sanitization and jump
2047 if (!integer_zerop (dest
) && !warning_suppressed_p (stmt
, OPT_Wrestrict
))
2049 tree func
= gimple_call_fndecl (stmt
);
2051 warning_at (loc
, OPT_Wrestrict
,
2052 "%qD source argument is the same as destination",
2056 replace_call_with_value (gsi
, dest
);
2060 if (optimize_function_for_size_p (cfun
))
2063 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
2067 /* Set to non-null if ARG refers to an unterminated array. */
2069 tree len
= get_maxval_strlen (src
, SRK_STRLEN
, &nonstr
);
2073 /* Avoid folding calls with unterminated arrays. */
2074 if (!warning_suppressed_p (stmt
, OPT_Wstringop_overread
))
2075 warn_string_no_nul (loc
, NULL_TREE
, "strcpy", src
, nonstr
);
2076 suppress_warning (stmt
, OPT_Wstringop_overread
);
2083 len
= fold_convert_loc (loc
, size_type_node
, len
);
2084 len
= size_binop_loc (loc
, PLUS_EXPR
, len
, build_int_cst (size_type_node
, 1));
2085 len
= force_gimple_operand_gsi (gsi
, len
, true,
2086 NULL_TREE
, true, GSI_SAME_STMT
);
2087 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2088 replace_call_with_call_and_fold (gsi
, repl
);
2092 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
2093 If SLEN is not NULL, it represents the length of the source string.
2094 Return NULL_TREE if no simplification can be made. */
2097 gimple_fold_builtin_strncpy (gimple_stmt_iterator
*gsi
,
2098 tree dest
, tree src
, tree len
)
2100 gimple
*stmt
= gsi_stmt (*gsi
);
2101 location_t loc
= gimple_location (stmt
);
2102 bool nonstring
= get_attr_nonstring_decl (dest
) != NULL_TREE
;
2104 /* If the LEN parameter is zero, return DEST. */
2105 if (integer_zerop (len
))
2107 /* Avoid warning if the destination refers to an array/pointer
2108 decorate with attribute nonstring. */
2111 tree fndecl
= gimple_call_fndecl (stmt
);
2113 /* Warn about the lack of nul termination: the result is not
2114 a (nul-terminated) string. */
2115 tree slen
= get_maxval_strlen (src
, SRK_STRLEN
);
2116 if (slen
&& !integer_zerop (slen
))
2117 warning_at (loc
, OPT_Wstringop_truncation
,
2118 "%G%qD destination unchanged after copying no bytes "
2119 "from a string of length %E",
2120 stmt
, fndecl
, slen
);
2122 warning_at (loc
, OPT_Wstringop_truncation
,
2123 "%G%qD destination unchanged after copying no bytes",
2127 replace_call_with_value (gsi
, dest
);
2131 /* We can't compare slen with len as constants below if len is not a
2133 if (TREE_CODE (len
) != INTEGER_CST
)
2136 /* Now, we must be passed a constant src ptr parameter. */
2137 tree slen
= get_maxval_strlen (src
, SRK_STRLEN
);
2138 if (!slen
|| TREE_CODE (slen
) != INTEGER_CST
)
2141 /* The size of the source string including the terminating nul. */
2142 tree ssize
= size_binop_loc (loc
, PLUS_EXPR
, slen
, ssize_int (1));
2144 /* We do not support simplification of this case, though we do
2145 support it when expanding trees into RTL. */
2146 /* FIXME: generate a call to __builtin_memset. */
2147 if (tree_int_cst_lt (ssize
, len
))
2150 /* Diagnose truncation that leaves the copy unterminated. */
2151 maybe_diag_stxncpy_trunc (*gsi
, src
, len
);
2153 /* OK transform into builtin memcpy. */
2154 tree fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
2158 len
= fold_convert_loc (loc
, size_type_node
, len
);
2159 len
= force_gimple_operand_gsi (gsi
, len
, true,
2160 NULL_TREE
, true, GSI_SAME_STMT
);
2161 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2162 replace_call_with_call_and_fold (gsi
, repl
);
2167 /* Fold function call to builtin strchr or strrchr.
2168 If both arguments are constant, evaluate and fold the result,
2169 otherwise simplify str(r)chr (str, 0) into str + strlen (str).
2170 In general strlen is significantly faster than strchr
2171 due to being a simpler operation. */
2173 gimple_fold_builtin_strchr (gimple_stmt_iterator
*gsi
, bool is_strrchr
)
2175 gimple
*stmt
= gsi_stmt (*gsi
);
2176 tree str
= gimple_call_arg (stmt
, 0);
2177 tree c
= gimple_call_arg (stmt
, 1);
2178 location_t loc
= gimple_location (stmt
);
2182 if (!gimple_call_lhs (stmt
))
2185 /* Avoid folding if the first argument is not a nul-terminated array.
2186 Defer warning until later. */
2187 if (!check_nul_terminated_array (NULL_TREE
, str
))
2190 if ((p
= c_getstr (str
)) && target_char_cst_p (c
, &ch
))
2192 const char *p1
= is_strrchr
? strrchr (p
, ch
) : strchr (p
, ch
);
2196 replace_call_with_value (gsi
, integer_zero_node
);
2200 tree len
= build_int_cst (size_type_node
, p1
- p
);
2201 gimple_seq stmts
= NULL
;
2202 gimple
*new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
2203 POINTER_PLUS_EXPR
, str
, len
);
2204 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
2205 gsi_replace_with_seq_vops (gsi
, stmts
);
2209 if (!integer_zerop (c
))
2212 /* Transform strrchr (s, 0) to strchr (s, 0) when optimizing for size. */
2213 if (is_strrchr
&& optimize_function_for_size_p (cfun
))
2215 tree strchr_fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
2219 gimple
*repl
= gimple_build_call (strchr_fn
, 2, str
, c
);
2220 replace_call_with_call_and_fold (gsi
, repl
);
2228 tree strlen_fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
2233 /* Create newstr = strlen (str). */
2234 gimple_seq stmts
= NULL
;
2235 gimple
*new_stmt
= gimple_build_call (strlen_fn
, 1, str
);
2236 gimple_set_location (new_stmt
, loc
);
2237 len
= create_tmp_reg_or_ssa_name (size_type_node
);
2238 gimple_call_set_lhs (new_stmt
, len
);
2239 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
2241 /* Create (str p+ strlen (str)). */
2242 new_stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
2243 POINTER_PLUS_EXPR
, str
, len
);
2244 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
2245 gsi_replace_with_seq_vops (gsi
, stmts
);
2246 /* gsi now points at the assignment to the lhs, get a
2247 stmt iterator to the strlen.
2248 ??? We can't use gsi_for_stmt as that doesn't work when the
2249 CFG isn't built yet. */
2250 gimple_stmt_iterator gsi2
= *gsi
;
2256 /* Fold function call to builtin strstr.
2257 If both arguments are constant, evaluate and fold the result,
2258 additionally fold strstr (x, "") into x and strstr (x, "c")
2259 into strchr (x, 'c'). */
2261 gimple_fold_builtin_strstr (gimple_stmt_iterator
*gsi
)
2263 gimple
*stmt
= gsi_stmt (*gsi
);
2264 if (!gimple_call_lhs (stmt
))
2267 tree haystack
= gimple_call_arg (stmt
, 0);
2268 tree needle
= gimple_call_arg (stmt
, 1);
2270 /* Avoid folding if either argument is not a nul-terminated array.
2271 Defer warning until later. */
2272 if (!check_nul_terminated_array (NULL_TREE
, haystack
)
2273 || !check_nul_terminated_array (NULL_TREE
, needle
))
2276 const char *q
= c_getstr (needle
);
2280 if (const char *p
= c_getstr (haystack
))
2282 const char *r
= strstr (p
, q
);
2286 replace_call_with_value (gsi
, integer_zero_node
);
2290 tree len
= build_int_cst (size_type_node
, r
- p
);
2291 gimple_seq stmts
= NULL
;
2293 = gimple_build_assign (gimple_call_lhs (stmt
), POINTER_PLUS_EXPR
,
2295 gimple_seq_add_stmt_without_update (&stmts
, new_stmt
);
2296 gsi_replace_with_seq_vops (gsi
, stmts
);
2300 /* For strstr (x, "") return x. */
2303 replace_call_with_value (gsi
, haystack
);
2307 /* Transform strstr (x, "c") into strchr (x, 'c'). */
2310 tree strchr_fn
= builtin_decl_implicit (BUILT_IN_STRCHR
);
2313 tree c
= build_int_cst (integer_type_node
, q
[0]);
2314 gimple
*repl
= gimple_build_call (strchr_fn
, 2, haystack
, c
);
2315 replace_call_with_call_and_fold (gsi
, repl
);
2323 /* Simplify a call to the strcat builtin. DST and SRC are the arguments
2326 Return NULL_TREE if no simplification was possible, otherwise return the
2327 simplified form of the call as a tree.
2329 The simplified form may be a constant or other expression which
2330 computes the same value, but in a more efficient manner (including
2331 calls to other builtin functions).
2333 The call may contain arguments which need to be evaluated, but
2334 which are not useful to determine the result of the call. In
2335 this case we return a chain of COMPOUND_EXPRs. The LHS of each
2336 COMPOUND_EXPR will be an argument which must be evaluated.
2337 COMPOUND_EXPRs are chained through their RHS. The RHS of the last
2338 COMPOUND_EXPR in the chain will contain the tree for the simplified
2339 form of the builtin function call. */
2342 gimple_fold_builtin_strcat (gimple_stmt_iterator
*gsi
, tree dst
, tree src
)
2344 gimple
*stmt
= gsi_stmt (*gsi
);
2345 location_t loc
= gimple_location (stmt
);
2347 const char *p
= c_getstr (src
);
2349 /* If the string length is zero, return the dst parameter. */
2350 if (p
&& *p
== '\0')
2352 replace_call_with_value (gsi
, dst
);
2356 if (!optimize_bb_for_speed_p (gimple_bb (stmt
)))
2359 /* See if we can store by pieces into (dst + strlen(dst)). */
2361 tree strlen_fn
= builtin_decl_implicit (BUILT_IN_STRLEN
);
2362 tree memcpy_fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
2364 if (!strlen_fn
|| !memcpy_fn
)
2367 /* If the length of the source string isn't computable don't
2368 split strcat into strlen and memcpy. */
2369 tree len
= get_maxval_strlen (src
, SRK_STRLEN
);
2373 /* Create strlen (dst). */
2374 gimple_seq stmts
= NULL
, stmts2
;
2375 gimple
*repl
= gimple_build_call (strlen_fn
, 1, dst
);
2376 gimple_set_location (repl
, loc
);
2377 newdst
= create_tmp_reg_or_ssa_name (size_type_node
);
2378 gimple_call_set_lhs (repl
, newdst
);
2379 gimple_seq_add_stmt_without_update (&stmts
, repl
);
2381 /* Create (dst p+ strlen (dst)). */
2382 newdst
= fold_build_pointer_plus_loc (loc
, dst
, newdst
);
2383 newdst
= force_gimple_operand (newdst
, &stmts2
, true, NULL_TREE
);
2384 gimple_seq_add_seq_without_update (&stmts
, stmts2
);
2386 len
= fold_convert_loc (loc
, size_type_node
, len
);
2387 len
= size_binop_loc (loc
, PLUS_EXPR
, len
,
2388 build_int_cst (size_type_node
, 1));
2389 len
= force_gimple_operand (len
, &stmts2
, true, NULL_TREE
);
2390 gimple_seq_add_seq_without_update (&stmts
, stmts2
);
2392 repl
= gimple_build_call (memcpy_fn
, 3, newdst
, src
, len
);
2393 gimple_seq_add_stmt_without_update (&stmts
, repl
);
2394 if (gimple_call_lhs (stmt
))
2396 repl
= gimple_build_assign (gimple_call_lhs (stmt
), dst
);
2397 gimple_seq_add_stmt_without_update (&stmts
, repl
);
2398 gsi_replace_with_seq_vops (gsi
, stmts
);
2399 /* gsi now points at the assignment to the lhs, get a
2400 stmt iterator to the memcpy call.
2401 ??? We can't use gsi_for_stmt as that doesn't work when the
2402 CFG isn't built yet. */
2403 gimple_stmt_iterator gsi2
= *gsi
;
2409 gsi_replace_with_seq_vops (gsi
, stmts
);
2415 /* Fold a call to the __strcat_chk builtin FNDECL. DEST, SRC, and SIZE
2416 are the arguments to the call. */
2419 gimple_fold_builtin_strcat_chk (gimple_stmt_iterator
*gsi
)
2421 gimple
*stmt
= gsi_stmt (*gsi
);
2422 tree dest
= gimple_call_arg (stmt
, 0);
2423 tree src
= gimple_call_arg (stmt
, 1);
2424 tree size
= gimple_call_arg (stmt
, 2);
2430 /* If the SRC parameter is "", return DEST. */
2431 if (p
&& *p
== '\0')
2433 replace_call_with_value (gsi
, dest
);
2437 if (! tree_fits_uhwi_p (size
) || ! integer_all_onesp (size
))
2440 /* If __builtin_strcat_chk is used, assume strcat is available. */
2441 fn
= builtin_decl_explicit (BUILT_IN_STRCAT
);
2445 gimple
*repl
= gimple_build_call (fn
, 2, dest
, src
);
2446 replace_call_with_call_and_fold (gsi
, repl
);
2450 /* Simplify a call to the strncat builtin. */
2453 gimple_fold_builtin_strncat (gimple_stmt_iterator
*gsi
)
2455 gimple
*stmt
= gsi_stmt (*gsi
);
2456 tree dst
= gimple_call_arg (stmt
, 0);
2457 tree src
= gimple_call_arg (stmt
, 1);
2458 tree len
= gimple_call_arg (stmt
, 2);
2460 const char *p
= c_getstr (src
);
2462 /* If the requested length is zero, or the src parameter string
2463 length is zero, return the dst parameter. */
2464 if (integer_zerop (len
) || (p
&& *p
== '\0'))
2466 replace_call_with_value (gsi
, dst
);
2470 if (TREE_CODE (len
) != INTEGER_CST
|| !p
)
2473 unsigned srclen
= strlen (p
);
2475 int cmpsrc
= compare_tree_int (len
, srclen
);
2477 /* Return early if the requested len is less than the string length.
2478 Warnings will be issued elsewhere later. */
2482 unsigned HOST_WIDE_INT dstsize
;
2484 bool nowarn
= warning_suppressed_p (stmt
, OPT_Wstringop_overflow_
);
2486 if (!nowarn
&& compute_builtin_object_size (dst
, 1, &dstsize
))
2488 int cmpdst
= compare_tree_int (len
, dstsize
);
2492 tree fndecl
= gimple_call_fndecl (stmt
);
2494 /* Strncat copies (at most) LEN bytes and always appends
2495 the terminating NUL so the specified bound should never
2496 be equal to (or greater than) the size of the destination.
2497 If it is, the copy could overflow. */
2498 location_t loc
= gimple_location (stmt
);
2499 nowarn
= warning_at (loc
, OPT_Wstringop_overflow_
,
2501 ? G_("%G%qD specified bound %E equals "
2503 : G_("%G%qD specified bound %E exceeds "
2504 "destination size %wu"),
2505 stmt
, fndecl
, len
, dstsize
);
2507 suppress_warning (stmt
, OPT_Wstringop_overflow_
);
2511 if (!nowarn
&& cmpsrc
== 0)
2513 tree fndecl
= gimple_call_fndecl (stmt
);
2514 location_t loc
= gimple_location (stmt
);
2516 /* To avoid possible overflow the specified bound should also
2517 not be equal to the length of the source, even when the size
2518 of the destination is unknown (it's not an uncommon mistake
2519 to specify as the bound to strncpy the length of the source). */
2520 if (warning_at (loc
, OPT_Wstringop_overflow_
,
2521 "%G%qD specified bound %E equals source length",
2523 suppress_warning (stmt
, OPT_Wstringop_overflow_
);
2526 tree fn
= builtin_decl_implicit (BUILT_IN_STRCAT
);
2528 /* If the replacement _DECL isn't initialized, don't do the
2533 /* Otherwise, emit a call to strcat. */
2534 gcall
*repl
= gimple_build_call (fn
, 2, dst
, src
);
2535 replace_call_with_call_and_fold (gsi
, repl
);
2539 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
2543 gimple_fold_builtin_strncat_chk (gimple_stmt_iterator
*gsi
)
2545 gimple
*stmt
= gsi_stmt (*gsi
);
2546 tree dest
= gimple_call_arg (stmt
, 0);
2547 tree src
= gimple_call_arg (stmt
, 1);
2548 tree len
= gimple_call_arg (stmt
, 2);
2549 tree size
= gimple_call_arg (stmt
, 3);
2554 /* If the SRC parameter is "" or if LEN is 0, return DEST. */
2555 if ((p
&& *p
== '\0')
2556 || integer_zerop (len
))
2558 replace_call_with_value (gsi
, dest
);
2562 if (! tree_fits_uhwi_p (size
))
2565 if (! integer_all_onesp (size
))
2567 tree src_len
= c_strlen (src
, 1);
2569 && tree_fits_uhwi_p (src_len
)
2570 && tree_fits_uhwi_p (len
)
2571 && ! tree_int_cst_lt (len
, src_len
))
2573 /* If LEN >= strlen (SRC), optimize into __strcat_chk. */
2574 fn
= builtin_decl_explicit (BUILT_IN_STRCAT_CHK
);
2578 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, size
);
2579 replace_call_with_call_and_fold (gsi
, repl
);
2585 /* If __builtin_strncat_chk is used, assume strncat is available. */
2586 fn
= builtin_decl_explicit (BUILT_IN_STRNCAT
);
2590 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
2591 replace_call_with_call_and_fold (gsi
, repl
);
2595 /* Build and append gimple statements to STMTS that would load a first
2596 character of a memory location identified by STR. LOC is location
2597 of the statement. */
2600 gimple_load_first_char (location_t loc
, tree str
, gimple_seq
*stmts
)
2604 tree cst_uchar_node
= build_type_variant (unsigned_char_type_node
, 1, 0);
2605 tree cst_uchar_ptr_node
2606 = build_pointer_type_for_mode (cst_uchar_node
, ptr_mode
, true);
2607 tree off0
= build_int_cst (cst_uchar_ptr_node
, 0);
2609 tree temp
= fold_build2_loc (loc
, MEM_REF
, cst_uchar_node
, str
, off0
);
2610 gassign
*stmt
= gimple_build_assign (NULL_TREE
, temp
);
2611 var
= create_tmp_reg_or_ssa_name (cst_uchar_node
, stmt
);
2613 gimple_assign_set_lhs (stmt
, var
);
2614 gimple_seq_add_stmt_without_update (stmts
, stmt
);
2619 /* Fold a call to the str{n}{case}cmp builtin pointed by GSI iterator. */
2622 gimple_fold_builtin_string_compare (gimple_stmt_iterator
*gsi
)
2624 gimple
*stmt
= gsi_stmt (*gsi
);
2625 tree callee
= gimple_call_fndecl (stmt
);
2626 enum built_in_function fcode
= DECL_FUNCTION_CODE (callee
);
2628 tree type
= integer_type_node
;
2629 tree str1
= gimple_call_arg (stmt
, 0);
2630 tree str2
= gimple_call_arg (stmt
, 1);
2631 tree lhs
= gimple_call_lhs (stmt
);
2633 tree bound_node
= NULL_TREE
;
2634 unsigned HOST_WIDE_INT bound
= HOST_WIDE_INT_M1U
;
2636 /* Handle strncmp and strncasecmp functions. */
2637 if (gimple_call_num_args (stmt
) == 3)
2639 bound_node
= gimple_call_arg (stmt
, 2);
2640 if (tree_fits_uhwi_p (bound_node
))
2641 bound
= tree_to_uhwi (bound_node
);
2644 /* If the BOUND parameter is zero, return zero. */
2647 replace_call_with_value (gsi
, integer_zero_node
);
2651 /* If ARG1 and ARG2 are the same (and not volatile), return zero. */
2652 if (operand_equal_p (str1
, str2
, 0))
2654 replace_call_with_value (gsi
, integer_zero_node
);
2658 /* Initially set to the number of characters, including the terminating
2659 nul if each array has one. LENx == strnlen (Sx, LENx) implies that
2660 the array Sx is not terminated by a nul.
2661 For nul-terminated strings then adjusted to their length so that
2662 LENx == NULPOSx holds. */
2663 unsigned HOST_WIDE_INT len1
= HOST_WIDE_INT_MAX
, len2
= len1
;
2664 const char *p1
= getbyterep (str1
, &len1
);
2665 const char *p2
= getbyterep (str2
, &len2
);
2667 /* The position of the terminating nul character if one exists, otherwise
2668 a value greater than LENx. */
2669 unsigned HOST_WIDE_INT nulpos1
= HOST_WIDE_INT_MAX
, nulpos2
= nulpos1
;
2673 size_t n
= strnlen (p1
, len1
);
2680 size_t n
= strnlen (p2
, len2
);
2685 /* For known strings, return an immediate value. */
2689 bool known_result
= false;
2693 case BUILT_IN_STRCMP
:
2694 case BUILT_IN_STRCMP_EQ
:
2695 if (len1
!= nulpos1
|| len2
!= nulpos2
)
2698 r
= strcmp (p1
, p2
);
2699 known_result
= true;
2702 case BUILT_IN_STRNCMP
:
2703 case BUILT_IN_STRNCMP_EQ
:
2705 if (bound
== HOST_WIDE_INT_M1U
)
2708 /* Reduce the bound to be no more than the length
2709 of the shorter of the two strings, or the sizes
2710 of the unterminated arrays. */
2711 unsigned HOST_WIDE_INT n
= bound
;
2713 if (len1
== nulpos1
&& len1
< n
)
2715 if (len2
== nulpos2
&& len2
< n
)
2718 if (MIN (nulpos1
, nulpos2
) + 1 < n
)
2721 r
= strncmp (p1
, p2
, n
);
2722 known_result
= true;
2725 /* Only handleable situation is where the string are equal (result 0),
2726 which is already handled by operand_equal_p case. */
2727 case BUILT_IN_STRCASECMP
:
2729 case BUILT_IN_STRNCASECMP
:
2731 if (bound
== HOST_WIDE_INT_M1U
)
2733 r
= strncmp (p1
, p2
, bound
);
2735 known_result
= true;
2744 replace_call_with_value (gsi
, build_cmp_result (type
, r
));
2749 bool nonzero_bound
= (bound
>= 1 && bound
< HOST_WIDE_INT_M1U
)
2750 || fcode
== BUILT_IN_STRCMP
2751 || fcode
== BUILT_IN_STRCMP_EQ
2752 || fcode
== BUILT_IN_STRCASECMP
;
2754 location_t loc
= gimple_location (stmt
);
2756 /* If the second arg is "", return *(const unsigned char*)arg1. */
2757 if (p2
&& *p2
== '\0' && nonzero_bound
)
2759 gimple_seq stmts
= NULL
;
2760 tree var
= gimple_load_first_char (loc
, str1
, &stmts
);
2763 stmt
= gimple_build_assign (lhs
, NOP_EXPR
, var
);
2764 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2767 gsi_replace_with_seq_vops (gsi
, stmts
);
2771 /* If the first arg is "", return -*(const unsigned char*)arg2. */
2772 if (p1
&& *p1
== '\0' && nonzero_bound
)
2774 gimple_seq stmts
= NULL
;
2775 tree var
= gimple_load_first_char (loc
, str2
, &stmts
);
2779 tree c
= create_tmp_reg_or_ssa_name (integer_type_node
);
2780 stmt
= gimple_build_assign (c
, NOP_EXPR
, var
);
2781 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2783 stmt
= gimple_build_assign (lhs
, NEGATE_EXPR
, c
);
2784 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2787 gsi_replace_with_seq_vops (gsi
, stmts
);
2791 /* If BOUND is one, return an expression corresponding to
2792 (*(const unsigned char*)arg2 - *(const unsigned char*)arg1). */
2793 if (fcode
== BUILT_IN_STRNCMP
&& bound
== 1)
2795 gimple_seq stmts
= NULL
;
2796 tree temp1
= gimple_load_first_char (loc
, str1
, &stmts
);
2797 tree temp2
= gimple_load_first_char (loc
, str2
, &stmts
);
2801 tree c1
= create_tmp_reg_or_ssa_name (integer_type_node
);
2802 gassign
*convert1
= gimple_build_assign (c1
, NOP_EXPR
, temp1
);
2803 gimple_seq_add_stmt_without_update (&stmts
, convert1
);
2805 tree c2
= create_tmp_reg_or_ssa_name (integer_type_node
);
2806 gassign
*convert2
= gimple_build_assign (c2
, NOP_EXPR
, temp2
);
2807 gimple_seq_add_stmt_without_update (&stmts
, convert2
);
2809 stmt
= gimple_build_assign (lhs
, MINUS_EXPR
, c1
, c2
);
2810 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2813 gsi_replace_with_seq_vops (gsi
, stmts
);
2817 /* If BOUND is greater than the length of one constant string,
2818 and the other argument is also a nul-terminated string, replace
2819 strncmp with strcmp. */
2820 if (fcode
== BUILT_IN_STRNCMP
2821 && bound
> 0 && bound
< HOST_WIDE_INT_M1U
2822 && ((p2
&& len2
< bound
&& len2
== nulpos2
)
2823 || (p1
&& len1
< bound
&& len1
== nulpos1
)))
2825 tree fn
= builtin_decl_implicit (BUILT_IN_STRCMP
);
2828 gimple
*repl
= gimple_build_call (fn
, 2, str1
, str2
);
2829 replace_call_with_call_and_fold (gsi
, repl
);
2836 /* Fold a call to the memchr pointed by GSI iterator. */
2839 gimple_fold_builtin_memchr (gimple_stmt_iterator
*gsi
)
2841 gimple
*stmt
= gsi_stmt (*gsi
);
2842 tree lhs
= gimple_call_lhs (stmt
);
2843 tree arg1
= gimple_call_arg (stmt
, 0);
2844 tree arg2
= gimple_call_arg (stmt
, 1);
2845 tree len
= gimple_call_arg (stmt
, 2);
2847 /* If the LEN parameter is zero, return zero. */
2848 if (integer_zerop (len
))
2850 replace_call_with_value (gsi
, build_int_cst (ptr_type_node
, 0));
2855 if (TREE_CODE (arg2
) != INTEGER_CST
2856 || !tree_fits_uhwi_p (len
)
2857 || !target_char_cst_p (arg2
, &c
))
2860 unsigned HOST_WIDE_INT length
= tree_to_uhwi (len
);
2861 unsigned HOST_WIDE_INT string_length
;
2862 const char *p1
= getbyterep (arg1
, &string_length
);
2866 const char *r
= (const char *)memchr (p1
, c
, MIN (length
, string_length
));
2869 tree mem_size
, offset_node
;
2870 byte_representation (arg1
, &offset_node
, &mem_size
, NULL
);
2871 unsigned HOST_WIDE_INT offset
= (offset_node
== NULL_TREE
)
2872 ? 0 : tree_to_uhwi (offset_node
);
2873 /* MEM_SIZE is the size of the array the string literal
2875 unsigned HOST_WIDE_INT string_size
= tree_to_uhwi (mem_size
) - offset
;
2876 gcc_checking_assert (string_length
<= string_size
);
2877 if (length
<= string_size
)
2879 replace_call_with_value (gsi
, build_int_cst (ptr_type_node
, 0));
2885 unsigned HOST_WIDE_INT offset
= r
- p1
;
2886 gimple_seq stmts
= NULL
;
2887 if (lhs
!= NULL_TREE
)
2889 tree offset_cst
= build_int_cst (sizetype
, offset
);
2890 gassign
*stmt
= gimple_build_assign (lhs
, POINTER_PLUS_EXPR
,
2892 gimple_seq_add_stmt_without_update (&stmts
, stmt
);
2895 gimple_seq_add_stmt_without_update (&stmts
,
2896 gimple_build_nop ());
2898 gsi_replace_with_seq_vops (gsi
, stmts
);
2906 /* Fold a call to the fputs builtin. ARG0 and ARG1 are the arguments
2907 to the call. IGNORE is true if the value returned
2908 by the builtin will be ignored. UNLOCKED is true is true if this
2909 actually a call to fputs_unlocked. If LEN in non-NULL, it represents
2910 the known length of the string. Return NULL_TREE if no simplification
2914 gimple_fold_builtin_fputs (gimple_stmt_iterator
*gsi
,
2915 tree arg0
, tree arg1
,
2918 gimple
*stmt
= gsi_stmt (*gsi
);
2920 /* If we're using an unlocked function, assume the other unlocked
2921 functions exist explicitly. */
2922 tree
const fn_fputc
= (unlocked
2923 ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED
)
2924 : builtin_decl_implicit (BUILT_IN_FPUTC
));
2925 tree
const fn_fwrite
= (unlocked
2926 ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED
)
2927 : builtin_decl_implicit (BUILT_IN_FWRITE
));
2929 /* If the return value is used, don't do the transformation. */
2930 if (gimple_call_lhs (stmt
))
2933 /* Get the length of the string passed to fputs. If the length
2934 can't be determined, punt. */
2935 tree len
= get_maxval_strlen (arg0
, SRK_STRLEN
);
2937 || TREE_CODE (len
) != INTEGER_CST
)
2940 switch (compare_tree_int (len
, 1))
2942 case -1: /* length is 0, delete the call entirely . */
2943 replace_call_with_value (gsi
, integer_zero_node
);
2946 case 0: /* length is 1, call fputc. */
2948 const char *p
= c_getstr (arg0
);
2954 gimple
*repl
= gimple_build_call (fn_fputc
, 2,
2956 (integer_type_node
, p
[0]), arg1
);
2957 replace_call_with_call_and_fold (gsi
, repl
);
2962 case 1: /* length is greater than 1, call fwrite. */
2964 /* If optimizing for size keep fputs. */
2965 if (optimize_function_for_size_p (cfun
))
2967 /* New argument list transforming fputs(string, stream) to
2968 fwrite(string, 1, len, stream). */
2972 gimple
*repl
= gimple_build_call (fn_fwrite
, 4, arg0
,
2973 size_one_node
, len
, arg1
);
2974 replace_call_with_call_and_fold (gsi
, repl
);
2983 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
2984 DEST, SRC, LEN, and SIZE are the arguments to the call.
2985 IGNORE is true, if return value can be ignored. FCODE is the BUILT_IN_*
2986 code of the builtin. If MAXLEN is not NULL, it is maximum length
2987 passed as third argument. */
2990 gimple_fold_builtin_memory_chk (gimple_stmt_iterator
*gsi
,
2991 tree dest
, tree src
, tree len
, tree size
,
2992 enum built_in_function fcode
)
2994 gimple
*stmt
= gsi_stmt (*gsi
);
2995 location_t loc
= gimple_location (stmt
);
2996 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
2999 /* If SRC and DEST are the same (and not volatile), return DEST
3000 (resp. DEST+LEN for __mempcpy_chk). */
3001 if (fcode
!= BUILT_IN_MEMSET_CHK
&& operand_equal_p (src
, dest
, 0))
3003 if (fcode
!= BUILT_IN_MEMPCPY_CHK
)
3005 replace_call_with_value (gsi
, dest
);
3010 gimple_seq stmts
= NULL
;
3011 len
= gimple_convert_to_ptrofftype (&stmts
, loc
, len
);
3012 tree temp
= gimple_build (&stmts
, loc
, POINTER_PLUS_EXPR
,
3013 TREE_TYPE (dest
), dest
, len
);
3014 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
3015 replace_call_with_value (gsi
, temp
);
3020 if (! tree_fits_uhwi_p (size
))
3023 tree maxlen
= get_maxval_strlen (len
, SRK_INT_VALUE
);
3024 if (! integer_all_onesp (size
))
3026 if (! tree_fits_uhwi_p (len
))
3028 /* If LEN is not constant, try MAXLEN too.
3029 For MAXLEN only allow optimizing into non-_ocs function
3030 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
3031 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
3033 if (fcode
== BUILT_IN_MEMPCPY_CHK
&& ignore
)
3035 /* (void) __mempcpy_chk () can be optimized into
3036 (void) __memcpy_chk (). */
3037 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
3041 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
3042 replace_call_with_call_and_fold (gsi
, repl
);
3051 if (tree_int_cst_lt (size
, maxlen
))
3056 /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
3057 mem{cpy,pcpy,move,set} is available. */
3060 case BUILT_IN_MEMCPY_CHK
:
3061 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY
);
3063 case BUILT_IN_MEMPCPY_CHK
:
3064 fn
= builtin_decl_explicit (BUILT_IN_MEMPCPY
);
3066 case BUILT_IN_MEMMOVE_CHK
:
3067 fn
= builtin_decl_explicit (BUILT_IN_MEMMOVE
);
3069 case BUILT_IN_MEMSET_CHK
:
3070 fn
= builtin_decl_explicit (BUILT_IN_MEMSET
);
3079 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
3080 replace_call_with_call_and_fold (gsi
, repl
);
3084 /* Fold a call to the __st[rp]cpy_chk builtin.
3085 DEST, SRC, and SIZE are the arguments to the call.
3086 IGNORE is true if return value can be ignored. FCODE is the BUILT_IN_*
3087 code of the builtin. If MAXLEN is not NULL, it is maximum length of
3088 strings passed as second argument. */
3091 gimple_fold_builtin_stxcpy_chk (gimple_stmt_iterator
*gsi
,
3093 tree src
, tree size
,
3094 enum built_in_function fcode
)
3096 gimple
*stmt
= gsi_stmt (*gsi
);
3097 location_t loc
= gimple_location (stmt
);
3098 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
3101 /* If SRC and DEST are the same (and not volatile), return DEST. */
3102 if (fcode
== BUILT_IN_STRCPY_CHK
&& operand_equal_p (src
, dest
, 0))
3104 /* Issue -Wrestrict unless the pointers are null (those do
3105 not point to objects and so do not indicate an overlap;
3106 such calls could be the result of sanitization and jump
3108 if (!integer_zerop (dest
)
3109 && !warning_suppressed_p (stmt
, OPT_Wrestrict
))
3111 tree func
= gimple_call_fndecl (stmt
);
3113 warning_at (loc
, OPT_Wrestrict
,
3114 "%qD source argument is the same as destination",
3118 replace_call_with_value (gsi
, dest
);
3122 if (! tree_fits_uhwi_p (size
))
3125 tree maxlen
= get_maxval_strlen (src
, SRK_STRLENMAX
);
3126 if (! integer_all_onesp (size
))
3128 len
= c_strlen (src
, 1);
3129 if (! len
|| ! tree_fits_uhwi_p (len
))
3131 /* If LEN is not constant, try MAXLEN too.
3132 For MAXLEN only allow optimizing into non-_ocs function
3133 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
3134 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
3136 if (fcode
== BUILT_IN_STPCPY_CHK
)
3141 /* If return value of __stpcpy_chk is ignored,
3142 optimize into __strcpy_chk. */
3143 fn
= builtin_decl_explicit (BUILT_IN_STRCPY_CHK
);
3147 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, size
);
3148 replace_call_with_call_and_fold (gsi
, repl
);
3152 if (! len
|| TREE_SIDE_EFFECTS (len
))
3155 /* If c_strlen returned something, but not a constant,
3156 transform __strcpy_chk into __memcpy_chk. */
3157 fn
= builtin_decl_explicit (BUILT_IN_MEMCPY_CHK
);
3161 gimple_seq stmts
= NULL
;
3162 len
= force_gimple_operand (len
, &stmts
, true, NULL_TREE
);
3163 len
= gimple_convert (&stmts
, loc
, size_type_node
, len
);
3164 len
= gimple_build (&stmts
, loc
, PLUS_EXPR
, size_type_node
, len
,
3165 build_int_cst (size_type_node
, 1));
3166 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
3167 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
3168 replace_call_with_call_and_fold (gsi
, repl
);
3175 if (! tree_int_cst_lt (maxlen
, size
))
3179 /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available. */
3180 fn
= builtin_decl_explicit (fcode
== BUILT_IN_STPCPY_CHK
3181 ? BUILT_IN_STPCPY
: BUILT_IN_STRCPY
);
3185 gimple
*repl
= gimple_build_call (fn
, 2, dest
, src
);
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 gimple
*stmt
= gsi_stmt (*gsi
);
3202 bool ignore
= gimple_call_lhs (stmt
) == NULL_TREE
;
3205 if (fcode
== BUILT_IN_STPNCPY_CHK
&& ignore
)
3207 /* If return value of __stpncpy_chk is ignored,
3208 optimize into __strncpy_chk. */
3209 fn
= builtin_decl_explicit (BUILT_IN_STRNCPY_CHK
);
3212 gimple
*repl
= gimple_build_call (fn
, 4, dest
, src
, len
, size
);
3213 replace_call_with_call_and_fold (gsi
, repl
);
3218 if (! tree_fits_uhwi_p (size
))
3221 tree maxlen
= get_maxval_strlen (len
, SRK_INT_VALUE
);
3222 if (! integer_all_onesp (size
))
3224 if (! tree_fits_uhwi_p (len
))
3226 /* If LEN is not constant, try MAXLEN too.
3227 For MAXLEN only allow optimizing into non-_ocs function
3228 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
3229 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
3235 if (tree_int_cst_lt (size
, maxlen
))
3239 /* If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available. */
3240 fn
= builtin_decl_explicit (fcode
== BUILT_IN_STPNCPY_CHK
3241 ? BUILT_IN_STPNCPY
: BUILT_IN_STRNCPY
);
3245 gimple
*repl
= gimple_build_call (fn
, 3, dest
, src
, len
);
3246 replace_call_with_call_and_fold (gsi
, repl
);
3250 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
3251 Return NULL_TREE if no simplification can be made. */
3254 gimple_fold_builtin_stpcpy (gimple_stmt_iterator
*gsi
)
3256 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3257 location_t loc
= gimple_location (stmt
);
3258 tree dest
= gimple_call_arg (stmt
, 0);
3259 tree src
= gimple_call_arg (stmt
, 1);
3262 /* If the result is unused, replace stpcpy with strcpy. */
3263 if (gimple_call_lhs (stmt
) == NULL_TREE
)
3265 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3268 gimple_call_set_fndecl (stmt
, fn
);
3273 /* Set to non-null if ARG refers to an unterminated array. */
3274 c_strlen_data data
= { };
3275 /* The size of the unterminated array if SRC referes to one. */
3277 /* True if the size is exact/constant, false if it's the lower bound
3280 tree len
= c_strlen (src
, 1, &data
, 1);
3282 || TREE_CODE (len
) != INTEGER_CST
)
3284 data
.decl
= unterminated_array (src
, &size
, &exact
);
3291 /* Avoid folding calls with unterminated arrays. */
3292 if (!warning_suppressed_p (stmt
, OPT_Wstringop_overread
))
3293 warn_string_no_nul (loc
, NULL_TREE
, "stpcpy", src
, data
.decl
, size
,
3295 suppress_warning (stmt
, OPT_Wstringop_overread
);
3299 if (optimize_function_for_size_p (cfun
)
3300 /* If length is zero it's small enough. */
3301 && !integer_zerop (len
))
3304 /* If the source has a known length replace stpcpy with memcpy. */
3305 fn
= builtin_decl_implicit (BUILT_IN_MEMCPY
);
3309 gimple_seq stmts
= NULL
;
3310 tree tem
= gimple_convert (&stmts
, loc
, size_type_node
, len
);
3311 lenp1
= gimple_build (&stmts
, loc
, PLUS_EXPR
, size_type_node
,
3312 tem
, build_int_cst (size_type_node
, 1));
3313 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
3314 gcall
*repl
= gimple_build_call (fn
, 3, dest
, src
, lenp1
);
3315 gimple_move_vops (repl
, stmt
);
3316 gsi_insert_before (gsi
, repl
, GSI_SAME_STMT
);
3317 /* Replace the result with dest + len. */
3319 tem
= gimple_convert (&stmts
, loc
, sizetype
, len
);
3320 gsi_insert_seq_before (gsi
, stmts
, GSI_SAME_STMT
);
3321 gassign
*ret
= gimple_build_assign (gimple_call_lhs (stmt
),
3322 POINTER_PLUS_EXPR
, dest
, tem
);
3323 gsi_replace (gsi
, ret
, false);
3324 /* Finally fold the memcpy call. */
3325 gimple_stmt_iterator gsi2
= *gsi
;
3331 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS. Return
3332 NULL_TREE if a normal call should be emitted rather than expanding
3333 the function inline. FCODE is either BUILT_IN_SNPRINTF_CHK or
3334 BUILT_IN_VSNPRINTF_CHK. If MAXLEN is not NULL, it is maximum length
3335 passed as second argument. */
3338 gimple_fold_builtin_snprintf_chk (gimple_stmt_iterator
*gsi
,
3339 enum built_in_function fcode
)
3341 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3342 tree dest
, size
, len
, fn
, fmt
, flag
;
3343 const char *fmt_str
;
3345 /* Verify the required arguments in the original call. */
3346 if (gimple_call_num_args (stmt
) < 5)
3349 dest
= gimple_call_arg (stmt
, 0);
3350 len
= gimple_call_arg (stmt
, 1);
3351 flag
= gimple_call_arg (stmt
, 2);
3352 size
= gimple_call_arg (stmt
, 3);
3353 fmt
= gimple_call_arg (stmt
, 4);
3355 if (! tree_fits_uhwi_p (size
))
3358 if (! integer_all_onesp (size
))
3360 tree maxlen
= get_maxval_strlen (len
, SRK_INT_VALUE
);
3361 if (! tree_fits_uhwi_p (len
))
3363 /* If LEN is not constant, try MAXLEN too.
3364 For MAXLEN only allow optimizing into non-_ocs function
3365 if SIZE is >= MAXLEN, never convert to __ocs_fail (). */
3366 if (maxlen
== NULL_TREE
|| ! tree_fits_uhwi_p (maxlen
))
3372 if (tree_int_cst_lt (size
, maxlen
))
3376 if (!init_target_chars ())
3379 /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
3380 or if format doesn't contain % chars or is "%s". */
3381 if (! integer_zerop (flag
))
3383 fmt_str
= c_getstr (fmt
);
3384 if (fmt_str
== NULL
)
3386 if (strchr (fmt_str
, target_percent
) != NULL
3387 && strcmp (fmt_str
, target_percent_s
))
3391 /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
3393 fn
= builtin_decl_explicit (fcode
== BUILT_IN_VSNPRINTF_CHK
3394 ? BUILT_IN_VSNPRINTF
: BUILT_IN_SNPRINTF
);
3398 /* Replace the called function and the first 5 argument by 3 retaining
3399 trailing varargs. */
3400 gimple_call_set_fndecl (stmt
, fn
);
3401 gimple_call_set_fntype (stmt
, TREE_TYPE (fn
));
3402 gimple_call_set_arg (stmt
, 0, dest
);
3403 gimple_call_set_arg (stmt
, 1, len
);
3404 gimple_call_set_arg (stmt
, 2, fmt
);
3405 for (unsigned i
= 3; i
< gimple_call_num_args (stmt
) - 2; ++i
)
3406 gimple_call_set_arg (stmt
, i
, gimple_call_arg (stmt
, i
+ 2));
3407 gimple_set_num_ops (stmt
, gimple_num_ops (stmt
) - 2);
3412 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
3413 Return NULL_TREE if a normal call should be emitted rather than
3414 expanding the function inline. FCODE is either BUILT_IN_SPRINTF_CHK
3415 or BUILT_IN_VSPRINTF_CHK. */
3418 gimple_fold_builtin_sprintf_chk (gimple_stmt_iterator
*gsi
,
3419 enum built_in_function fcode
)
3421 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3422 tree dest
, size
, len
, fn
, fmt
, flag
;
3423 const char *fmt_str
;
3424 unsigned nargs
= gimple_call_num_args (stmt
);
3426 /* Verify the required arguments in the original call. */
3429 dest
= gimple_call_arg (stmt
, 0);
3430 flag
= gimple_call_arg (stmt
, 1);
3431 size
= gimple_call_arg (stmt
, 2);
3432 fmt
= gimple_call_arg (stmt
, 3);
3434 if (! tree_fits_uhwi_p (size
))
3439 if (!init_target_chars ())
3442 /* Check whether the format is a literal string constant. */
3443 fmt_str
= c_getstr (fmt
);
3444 if (fmt_str
!= NULL
)
3446 /* If the format doesn't contain % args or %%, we know the size. */
3447 if (strchr (fmt_str
, target_percent
) == 0)
3449 if (fcode
!= BUILT_IN_SPRINTF_CHK
|| nargs
== 4)
3450 len
= build_int_cstu (size_type_node
, strlen (fmt_str
));
3452 /* If the format is "%s" and first ... argument is a string literal,
3453 we know the size too. */
3454 else if (fcode
== BUILT_IN_SPRINTF_CHK
3455 && strcmp (fmt_str
, target_percent_s
) == 0)
3461 arg
= gimple_call_arg (stmt
, 4);
3462 if (POINTER_TYPE_P (TREE_TYPE (arg
)))
3464 len
= c_strlen (arg
, 1);
3465 if (! len
|| ! tree_fits_uhwi_p (len
))
3472 if (! integer_all_onesp (size
))
3474 if (! len
|| ! tree_int_cst_lt (len
, size
))
3478 /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
3479 or if format doesn't contain % chars or is "%s". */
3480 if (! integer_zerop (flag
))
3482 if (fmt_str
== NULL
)
3484 if (strchr (fmt_str
, target_percent
) != NULL
3485 && strcmp (fmt_str
, target_percent_s
))
3489 /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available. */
3490 fn
= builtin_decl_explicit (fcode
== BUILT_IN_VSPRINTF_CHK
3491 ? BUILT_IN_VSPRINTF
: BUILT_IN_SPRINTF
);
3495 /* Replace the called function and the first 4 argument by 2 retaining
3496 trailing varargs. */
3497 gimple_call_set_fndecl (stmt
, fn
);
3498 gimple_call_set_fntype (stmt
, TREE_TYPE (fn
));
3499 gimple_call_set_arg (stmt
, 0, dest
);
3500 gimple_call_set_arg (stmt
, 1, fmt
);
3501 for (unsigned i
= 2; i
< gimple_call_num_args (stmt
) - 2; ++i
)
3502 gimple_call_set_arg (stmt
, i
, gimple_call_arg (stmt
, i
+ 2));
3503 gimple_set_num_ops (stmt
, gimple_num_ops (stmt
) - 2);
3508 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
3509 ORIG may be null if this is a 2-argument call. We don't attempt to
3510 simplify calls with more than 3 arguments.
3512 Return true if simplification was possible, otherwise false. */
3515 gimple_fold_builtin_sprintf (gimple_stmt_iterator
*gsi
)
3517 gimple
*stmt
= gsi_stmt (*gsi
);
3519 /* Verify the required arguments in the original call. We deal with two
3520 types of sprintf() calls: 'sprintf (str, fmt)' and
3521 'sprintf (dest, "%s", orig)'. */
3522 if (gimple_call_num_args (stmt
) > 3)
3525 tree orig
= NULL_TREE
;
3526 if (gimple_call_num_args (stmt
) == 3)
3527 orig
= gimple_call_arg (stmt
, 2);
3529 /* Check whether the format is a literal string constant. */
3530 tree fmt
= gimple_call_arg (stmt
, 1);
3531 const char *fmt_str
= c_getstr (fmt
);
3532 if (fmt_str
== NULL
)
3535 tree dest
= gimple_call_arg (stmt
, 0);
3537 if (!init_target_chars ())
3540 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3544 /* If the format doesn't contain % args or %%, use strcpy. */
3545 if (strchr (fmt_str
, target_percent
) == NULL
)
3547 /* Don't optimize sprintf (buf, "abc", ptr++). */
3551 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
3552 'format' is known to contain no % formats. */
3553 gimple_seq stmts
= NULL
;
3554 gimple
*repl
= gimple_build_call (fn
, 2, dest
, fmt
);
3556 /* Propagate the NO_WARNING bit to avoid issuing the same
3557 warning more than once. */
3558 copy_warning (repl
, stmt
);
3560 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3561 if (tree lhs
= gimple_call_lhs (stmt
))
3563 repl
= gimple_build_assign (lhs
, build_int_cst (TREE_TYPE (lhs
),
3565 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3566 gsi_replace_with_seq_vops (gsi
, stmts
);
3567 /* gsi now points at the assignment to the lhs, get a
3568 stmt iterator to the memcpy call.
3569 ??? We can't use gsi_for_stmt as that doesn't work when the
3570 CFG isn't built yet. */
3571 gimple_stmt_iterator gsi2
= *gsi
;
3577 gsi_replace_with_seq_vops (gsi
, stmts
);
3583 /* If the format is "%s", use strcpy if the result isn't used. */
3584 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
3586 /* Don't crash on sprintf (str1, "%s"). */
3590 /* Don't fold calls with source arguments of invalid (nonpointer)
3592 if (!POINTER_TYPE_P (TREE_TYPE (orig
)))
3595 tree orig_len
= NULL_TREE
;
3596 if (gimple_call_lhs (stmt
))
3598 orig_len
= get_maxval_strlen (orig
, SRK_STRLEN
);
3603 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */
3604 gimple_seq stmts
= NULL
;
3605 gimple
*repl
= gimple_build_call (fn
, 2, dest
, orig
);
3607 /* Propagate the NO_WARNING bit to avoid issuing the same
3608 warning more than once. */
3609 copy_warning (repl
, stmt
);
3611 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3612 if (tree lhs
= gimple_call_lhs (stmt
))
3614 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
3615 TREE_TYPE (orig_len
)))
3616 orig_len
= fold_convert (TREE_TYPE (lhs
), orig_len
);
3617 repl
= gimple_build_assign (lhs
, orig_len
);
3618 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3619 gsi_replace_with_seq_vops (gsi
, stmts
);
3620 /* gsi now points at the assignment to the lhs, get a
3621 stmt iterator to the memcpy call.
3622 ??? We can't use gsi_for_stmt as that doesn't work when the
3623 CFG isn't built yet. */
3624 gimple_stmt_iterator gsi2
= *gsi
;
3630 gsi_replace_with_seq_vops (gsi
, stmts
);
3638 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
3639 FMT, and ORIG. ORIG may be null if this is a 3-argument call. We don't
3640 attempt to simplify calls with more than 4 arguments.
3642 Return true if simplification was possible, otherwise false. */
3645 gimple_fold_builtin_snprintf (gimple_stmt_iterator
*gsi
)
3647 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3648 tree dest
= gimple_call_arg (stmt
, 0);
3649 tree destsize
= gimple_call_arg (stmt
, 1);
3650 tree fmt
= gimple_call_arg (stmt
, 2);
3651 tree orig
= NULL_TREE
;
3652 const char *fmt_str
= NULL
;
3654 if (gimple_call_num_args (stmt
) > 4)
3657 if (gimple_call_num_args (stmt
) == 4)
3658 orig
= gimple_call_arg (stmt
, 3);
3660 if (!tree_fits_uhwi_p (destsize
))
3662 unsigned HOST_WIDE_INT destlen
= tree_to_uhwi (destsize
);
3664 /* Check whether the format is a literal string constant. */
3665 fmt_str
= c_getstr (fmt
);
3666 if (fmt_str
== NULL
)
3669 if (!init_target_chars ())
3672 /* If the format doesn't contain % args or %%, use strcpy. */
3673 if (strchr (fmt_str
, target_percent
) == NULL
)
3675 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3679 /* Don't optimize snprintf (buf, 4, "abc", ptr++). */
3683 /* We could expand this as
3684 memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
3686 memcpy (str, fmt_with_nul_at_cstm1, cst);
3687 but in the former case that might increase code size
3688 and in the latter case grow .rodata section too much.
3690 size_t len
= strlen (fmt_str
);
3694 gimple_seq stmts
= NULL
;
3695 gimple
*repl
= gimple_build_call (fn
, 2, dest
, fmt
);
3696 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3697 if (tree lhs
= gimple_call_lhs (stmt
))
3699 repl
= gimple_build_assign (lhs
,
3700 build_int_cst (TREE_TYPE (lhs
), len
));
3701 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3702 gsi_replace_with_seq_vops (gsi
, stmts
);
3703 /* gsi now points at the assignment to the lhs, get a
3704 stmt iterator to the memcpy call.
3705 ??? We can't use gsi_for_stmt as that doesn't work when the
3706 CFG isn't built yet. */
3707 gimple_stmt_iterator gsi2
= *gsi
;
3713 gsi_replace_with_seq_vops (gsi
, stmts
);
3719 /* If the format is "%s", use strcpy if the result isn't used. */
3720 else if (fmt_str
&& strcmp (fmt_str
, target_percent_s
) == 0)
3722 tree fn
= builtin_decl_implicit (BUILT_IN_STRCPY
);
3726 /* Don't crash on snprintf (str1, cst, "%s"). */
3730 tree orig_len
= get_maxval_strlen (orig
, SRK_STRLEN
);
3731 if (!orig_len
|| TREE_CODE (orig_len
) != INTEGER_CST
)
3734 /* We could expand this as
3735 memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
3737 memcpy (str1, str2_with_nul_at_cstm1, cst);
3738 but in the former case that might increase code size
3739 and in the latter case grow .rodata section too much.
3741 if (compare_tree_int (orig_len
, destlen
) >= 0)
3744 /* Convert snprintf (str1, cst, "%s", str2) into
3745 strcpy (str1, str2) if strlen (str2) < cst. */
3746 gimple_seq stmts
= NULL
;
3747 gimple
*repl
= gimple_build_call (fn
, 2, dest
, orig
);
3748 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3749 if (tree lhs
= gimple_call_lhs (stmt
))
3751 if (!useless_type_conversion_p (TREE_TYPE (lhs
),
3752 TREE_TYPE (orig_len
)))
3753 orig_len
= fold_convert (TREE_TYPE (lhs
), orig_len
);
3754 repl
= gimple_build_assign (lhs
, orig_len
);
3755 gimple_seq_add_stmt_without_update (&stmts
, repl
);
3756 gsi_replace_with_seq_vops (gsi
, stmts
);
3757 /* gsi now points at the assignment to the lhs, get a
3758 stmt iterator to the memcpy call.
3759 ??? We can't use gsi_for_stmt as that doesn't work when the
3760 CFG isn't built yet. */
3761 gimple_stmt_iterator gsi2
= *gsi
;
3767 gsi_replace_with_seq_vops (gsi
, stmts
);
3775 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
3776 FP, FMT, and ARG are the arguments to the call. We don't fold calls with
3777 more than 3 arguments, and ARG may be null in the 2-argument case.
3779 Return NULL_TREE if no simplification was possible, otherwise return the
3780 simplified form of the call as a tree. FCODE is the BUILT_IN_*
3781 code of the function to be simplified. */
3784 gimple_fold_builtin_fprintf (gimple_stmt_iterator
*gsi
,
3785 tree fp
, tree fmt
, tree arg
,
3786 enum built_in_function fcode
)
3788 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3789 tree fn_fputc
, fn_fputs
;
3790 const char *fmt_str
= NULL
;
3792 /* If the return value is used, don't do the transformation. */
3793 if (gimple_call_lhs (stmt
) != NULL_TREE
)
3796 /* Check whether the format is a literal string constant. */
3797 fmt_str
= c_getstr (fmt
);
3798 if (fmt_str
== NULL
)
3801 if (fcode
== BUILT_IN_FPRINTF_UNLOCKED
)
3803 /* If we're using an unlocked function, assume the other
3804 unlocked functions exist explicitly. */
3805 fn_fputc
= builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED
);
3806 fn_fputs
= builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED
);
3810 fn_fputc
= builtin_decl_implicit (BUILT_IN_FPUTC
);
3811 fn_fputs
= builtin_decl_implicit (BUILT_IN_FPUTS
);
3814 if (!init_target_chars ())
3817 /* If the format doesn't contain % args or %%, use strcpy. */
3818 if (strchr (fmt_str
, target_percent
) == NULL
)
3820 if (fcode
!= BUILT_IN_VFPRINTF
&& fcode
!= BUILT_IN_VFPRINTF_CHK
3824 /* If the format specifier was "", fprintf does nothing. */
3825 if (fmt_str
[0] == '\0')
3827 replace_call_with_value (gsi
, NULL_TREE
);
3831 /* When "string" doesn't contain %, replace all cases of
3832 fprintf (fp, string) with fputs (string, fp). The fputs
3833 builtin will take care of special cases like length == 1. */
3836 gcall
*repl
= gimple_build_call (fn_fputs
, 2, fmt
, fp
);
3837 replace_call_with_call_and_fold (gsi
, repl
);
3842 /* The other optimizations can be done only on the non-va_list variants. */
3843 else if (fcode
== BUILT_IN_VFPRINTF
|| fcode
== BUILT_IN_VFPRINTF_CHK
)
3846 /* If the format specifier was "%s", call __builtin_fputs (arg, fp). */
3847 else if (strcmp (fmt_str
, target_percent_s
) == 0)
3849 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
3853 gcall
*repl
= gimple_build_call (fn_fputs
, 2, arg
, fp
);
3854 replace_call_with_call_and_fold (gsi
, repl
);
3859 /* If the format specifier was "%c", call __builtin_fputc (arg, fp). */
3860 else if (strcmp (fmt_str
, target_percent_c
) == 0)
3863 || ! useless_type_conversion_p (integer_type_node
, TREE_TYPE (arg
)))
3867 gcall
*repl
= gimple_build_call (fn_fputc
, 2, arg
, fp
);
3868 replace_call_with_call_and_fold (gsi
, repl
);
3876 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
3877 FMT and ARG are the arguments to the call; we don't fold cases with
3878 more than 2 arguments, and ARG may be null if this is a 1-argument case.
3880 Return NULL_TREE if no simplification was possible, otherwise return the
3881 simplified form of the call as a tree. FCODE is the BUILT_IN_*
3882 code of the function to be simplified. */
3885 gimple_fold_builtin_printf (gimple_stmt_iterator
*gsi
, tree fmt
,
3886 tree arg
, enum built_in_function fcode
)
3888 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
3889 tree fn_putchar
, fn_puts
, newarg
;
3890 const char *fmt_str
= NULL
;
3892 /* If the return value is used, don't do the transformation. */
3893 if (gimple_call_lhs (stmt
) != NULL_TREE
)
3896 /* Check whether the format is a literal string constant. */
3897 fmt_str
= c_getstr (fmt
);
3898 if (fmt_str
== NULL
)
3901 if (fcode
== BUILT_IN_PRINTF_UNLOCKED
)
3903 /* If we're using an unlocked function, assume the other
3904 unlocked functions exist explicitly. */
3905 fn_putchar
= builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED
);
3906 fn_puts
= builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED
);
3910 fn_putchar
= builtin_decl_implicit (BUILT_IN_PUTCHAR
);
3911 fn_puts
= builtin_decl_implicit (BUILT_IN_PUTS
);
3914 if (!init_target_chars ())
3917 if (strcmp (fmt_str
, target_percent_s
) == 0
3918 || strchr (fmt_str
, target_percent
) == NULL
)
3922 if (strcmp (fmt_str
, target_percent_s
) == 0)
3924 if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
3927 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
3930 str
= c_getstr (arg
);
3936 /* The format specifier doesn't contain any '%' characters. */
3937 if (fcode
!= BUILT_IN_VPRINTF
&& fcode
!= BUILT_IN_VPRINTF_CHK
3943 /* If the string was "", printf does nothing. */
3946 replace_call_with_value (gsi
, NULL_TREE
);
3950 /* If the string has length of 1, call putchar. */
3953 /* Given printf("c"), (where c is any one character,)
3954 convert "c"[0] to an int and pass that to the replacement
3956 newarg
= build_int_cst (integer_type_node
, str
[0]);
3959 gcall
*repl
= gimple_build_call (fn_putchar
, 1, newarg
);
3960 replace_call_with_call_and_fold (gsi
, repl
);
3966 /* If the string was "string\n", call puts("string"). */
3967 size_t len
= strlen (str
);
3968 if ((unsigned char)str
[len
- 1] == target_newline
3969 && (size_t) (int) len
== len
3974 /* Create a NUL-terminated string that's one char shorter
3975 than the original, stripping off the trailing '\n'. */
3976 newstr
= xstrdup (str
);
3977 newstr
[len
- 1] = '\0';
3978 newarg
= build_string_literal (len
, newstr
);
3982 gcall
*repl
= gimple_build_call (fn_puts
, 1, newarg
);
3983 replace_call_with_call_and_fold (gsi
, repl
);
3988 /* We'd like to arrange to call fputs(string,stdout) here,
3989 but we need stdout and don't have a way to get it yet. */
3994 /* The other optimizations can be done only on the non-va_list variants. */
3995 else if (fcode
== BUILT_IN_VPRINTF
|| fcode
== BUILT_IN_VPRINTF_CHK
)
3998 /* If the format specifier was "%s\n", call __builtin_puts(arg). */
3999 else if (strcmp (fmt_str
, target_percent_s_newline
) == 0)
4001 if (!arg
|| ! POINTER_TYPE_P (TREE_TYPE (arg
)))
4005 gcall
*repl
= gimple_build_call (fn_puts
, 1, arg
);
4006 replace_call_with_call_and_fold (gsi
, repl
);
4011 /* If the format specifier was "%c", call __builtin_putchar(arg). */
4012 else if (strcmp (fmt_str
, target_percent_c
) == 0)
4014 if (!arg
|| ! useless_type_conversion_p (integer_type_node
,
4019 gcall
*repl
= gimple_build_call (fn_putchar
, 1, arg
);
4020 replace_call_with_call_and_fold (gsi
, repl
);
4030 /* Fold a call to __builtin_strlen with known length LEN. */
4033 gimple_fold_builtin_strlen (gimple_stmt_iterator
*gsi
)
4035 gimple
*stmt
= gsi_stmt (*gsi
);
4036 tree arg
= gimple_call_arg (stmt
, 0);
4041 c_strlen_data lendata
= { };
4042 if (get_range_strlen (arg
, &lendata
, /* eltsize = */ 1)
4044 && lendata
.minlen
&& TREE_CODE (lendata
.minlen
) == INTEGER_CST
4045 && lendata
.maxlen
&& TREE_CODE (lendata
.maxlen
) == INTEGER_CST
)
4047 /* The range of lengths refers to either a single constant
4048 string or to the longest and shortest constant string
4049 referenced by the argument of the strlen() call, or to
4050 the strings that can possibly be stored in the arrays
4051 the argument refers to. */
4052 minlen
= wi::to_wide (lendata
.minlen
);
4053 maxlen
= wi::to_wide (lendata
.maxlen
);
4057 unsigned prec
= TYPE_PRECISION (sizetype
);
4059 minlen
= wi::shwi (0, prec
);
4060 maxlen
= wi::to_wide (max_object_size (), prec
) - 2;
4063 if (minlen
== maxlen
)
4065 /* Fold the strlen call to a constant. */
4066 tree type
= TREE_TYPE (lendata
.minlen
);
4067 tree len
= force_gimple_operand_gsi (gsi
,
4068 wide_int_to_tree (type
, minlen
),
4069 true, NULL
, true, GSI_SAME_STMT
);
4070 replace_call_with_value (gsi
, len
);
4074 /* Set the strlen() range to [0, MAXLEN]. */
4075 if (tree lhs
= gimple_call_lhs (stmt
))
4076 set_strlen_range (lhs
, minlen
, maxlen
);
4081 /* Fold a call to __builtin_acc_on_device. */
4084 gimple_fold_builtin_acc_on_device (gimple_stmt_iterator
*gsi
, tree arg0
)
4086 /* Defer folding until we know which compiler we're in. */
4087 if (symtab
->state
!= EXPANSION
)
4090 unsigned val_host
= GOMP_DEVICE_HOST
;
4091 unsigned val_dev
= GOMP_DEVICE_NONE
;
4093 #ifdef ACCEL_COMPILER
4094 val_host
= GOMP_DEVICE_NOT_HOST
;
4095 val_dev
= ACCEL_COMPILER_acc_device
;
4098 location_t loc
= gimple_location (gsi_stmt (*gsi
));
4100 tree host_eq
= make_ssa_name (boolean_type_node
);
4101 gimple
*host_ass
= gimple_build_assign
4102 (host_eq
, EQ_EXPR
, arg0
, build_int_cst (TREE_TYPE (arg0
), val_host
));
4103 gimple_set_location (host_ass
, loc
);
4104 gsi_insert_before (gsi
, host_ass
, GSI_SAME_STMT
);
4106 tree dev_eq
= make_ssa_name (boolean_type_node
);
4107 gimple
*dev_ass
= gimple_build_assign
4108 (dev_eq
, EQ_EXPR
, arg0
, build_int_cst (TREE_TYPE (arg0
), val_dev
));
4109 gimple_set_location (dev_ass
, loc
);
4110 gsi_insert_before (gsi
, dev_ass
, GSI_SAME_STMT
);
4112 tree result
= make_ssa_name (boolean_type_node
);
4113 gimple
*result_ass
= gimple_build_assign
4114 (result
, BIT_IOR_EXPR
, host_eq
, dev_eq
);
4115 gimple_set_location (result_ass
, loc
);
4116 gsi_insert_before (gsi
, result_ass
, GSI_SAME_STMT
);
4118 replace_call_with_value (gsi
, result
);
4123 /* Fold realloc (0, n) -> malloc (n). */
4126 gimple_fold_builtin_realloc (gimple_stmt_iterator
*gsi
)
4128 gimple
*stmt
= gsi_stmt (*gsi
);
4129 tree arg
= gimple_call_arg (stmt
, 0);
4130 tree size
= gimple_call_arg (stmt
, 1);
4132 if (operand_equal_p (arg
, null_pointer_node
, 0))
4134 tree fn_malloc
= builtin_decl_implicit (BUILT_IN_MALLOC
);
4137 gcall
*repl
= gimple_build_call (fn_malloc
, 1, size
);
4138 replace_call_with_call_and_fold (gsi
, repl
);
4145 /* Number of bytes into which any type but aggregate or vector types
4147 static constexpr size_t clear_padding_unit
4148 = MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
;
4149 /* Buffer size on which __builtin_clear_padding folding code works. */
4150 static const size_t clear_padding_buf_size
= 32 * clear_padding_unit
;
4152 /* Data passed through __builtin_clear_padding folding. */
4153 struct clear_padding_struct
{
4155 /* 0 during __builtin_clear_padding folding, nonzero during
4156 clear_type_padding_in_mask. In that case, instead of clearing the
4157 non-padding bits in union_ptr array clear the padding bits in there. */
4161 gimple_stmt_iterator
*gsi
;
4162 /* Alignment of buf->base + 0. */
4164 /* Offset from buf->base. Should be always a multiple of UNITS_PER_WORD. */
4166 /* Number of padding bytes before buf->off that don't have padding clear
4167 code emitted yet. */
4168 HOST_WIDE_INT padding_bytes
;
4169 /* The size of the whole object. Never emit code to touch
4170 buf->base + buf->sz or following bytes. */
4172 /* Number of bytes recorded in buf->buf. */
4174 /* When inside union, instead of emitting code we and bits inside of
4175 the union_ptr array. */
4176 unsigned char *union_ptr
;
4177 /* Set bits mean padding bits that need to be cleared by the builtin. */
4178 unsigned char buf
[clear_padding_buf_size
+ clear_padding_unit
];
4181 /* Emit code to clear padding requested in BUF->buf - set bits
4182 in there stand for padding that should be cleared. FULL is true
4183 if everything from the buffer should be flushed, otherwise
4184 it can leave up to 2 * clear_padding_unit bytes for further
4188 clear_padding_flush (clear_padding_struct
*buf
, bool full
)
4190 gcc_assert ((clear_padding_unit
% UNITS_PER_WORD
) == 0);
4191 if (!full
&& buf
->size
< 2 * clear_padding_unit
)
4193 gcc_assert ((buf
->off
% UNITS_PER_WORD
) == 0);
4194 size_t end
= buf
->size
;
4196 end
= ((end
- clear_padding_unit
- 1) / clear_padding_unit
4197 * clear_padding_unit
);
4198 size_t padding_bytes
= buf
->padding_bytes
;
4201 if (buf
->clear_in_mask
)
4203 /* During clear_type_padding_in_mask, clear the padding
4204 bits set in buf->buf in the buf->union_ptr mask. */
4205 for (size_t i
= 0; i
< end
; i
++)
4207 if (buf
->buf
[i
] == (unsigned char) ~0)
4211 memset (&buf
->union_ptr
[buf
->off
+ i
- padding_bytes
],
4214 buf
->union_ptr
[buf
->off
+ i
] &= ~buf
->buf
[i
];
4219 memset (&buf
->union_ptr
[buf
->off
+ end
- padding_bytes
],
4223 buf
->padding_bytes
= 0;
4227 memmove (buf
->buf
, buf
->buf
+ end
, buf
->size
- end
);
4230 buf
->padding_bytes
= padding_bytes
;
4234 /* Inside of a union, instead of emitting any code, instead
4235 clear all bits in the union_ptr buffer that are clear
4236 in buf. Whole padding bytes don't clear anything. */
4237 for (size_t i
= 0; i
< end
; i
++)
4239 if (buf
->buf
[i
] == (unsigned char) ~0)
4244 buf
->union_ptr
[buf
->off
+ i
] &= buf
->buf
[i
];
4251 buf
->padding_bytes
= 0;
4255 memmove (buf
->buf
, buf
->buf
+ end
, buf
->size
- end
);
4258 buf
->padding_bytes
= padding_bytes
;
4262 size_t wordsize
= UNITS_PER_WORD
;
4263 for (size_t i
= 0; i
< end
; i
+= wordsize
)
4265 size_t nonzero_first
= wordsize
;
4266 size_t nonzero_last
= 0;
4267 size_t zero_first
= wordsize
;
4268 size_t zero_last
= 0;
4269 bool all_ones
= true, bytes_only
= true;
4270 if ((unsigned HOST_WIDE_INT
) (buf
->off
+ i
+ wordsize
)
4271 > (unsigned HOST_WIDE_INT
) buf
->sz
)
4273 gcc_assert (wordsize
> 1);
4278 for (size_t j
= i
; j
< i
+ wordsize
&& j
< end
; j
++)
4282 if (nonzero_first
== wordsize
)
4284 nonzero_first
= j
- i
;
4285 nonzero_last
= j
- i
;
4287 if (nonzero_last
!= j
- i
)
4289 nonzero_last
= j
+ 1 - i
;
4293 if (zero_first
== wordsize
)
4295 zero_last
= j
+ 1 - i
;
4297 if (buf
->buf
[j
] != 0 && buf
->buf
[j
] != (unsigned char) ~0)
4303 size_t padding_end
= i
;
4306 if (nonzero_first
== 0
4307 && nonzero_last
== wordsize
4310 /* All bits are padding and we had some padding
4311 before too. Just extend it. */
4312 padding_bytes
+= wordsize
;
4315 if (all_ones
&& nonzero_first
== 0)
4317 padding_bytes
+= nonzero_last
;
4318 padding_end
+= nonzero_last
;
4319 nonzero_first
= wordsize
;
4322 else if (bytes_only
&& nonzero_first
== 0)
4324 gcc_assert (zero_first
&& zero_first
!= wordsize
);
4325 padding_bytes
+= zero_first
;
4326 padding_end
+= zero_first
;
4329 if (padding_bytes
== 1)
4331 atype
= char_type_node
;
4332 src
= build_zero_cst (char_type_node
);
4336 atype
= build_array_type_nelts (char_type_node
, padding_bytes
);
4337 src
= build_constructor (atype
, NULL
);
4339 tree dst
= build2_loc (buf
->loc
, MEM_REF
, atype
, buf
->base
,
4340 build_int_cst (buf
->alias_type
,
4341 buf
->off
+ padding_end
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
);
4347 buf
->padding_bytes
= 0;
4349 if (nonzero_first
== wordsize
)
4350 /* All bits in a word are 0, there are no padding bits. */
4352 if (all_ones
&& nonzero_last
== wordsize
)
4354 /* All bits between nonzero_first and end of word are padding
4355 bits, start counting padding_bytes. */
4356 padding_bytes
= nonzero_last
- nonzero_first
;
4361 /* If bitfields aren't involved in this word, prefer storing
4362 individual bytes or groups of them over performing a RMW
4363 operation on the whole word. */
4364 gcc_assert (i
+ zero_last
<= end
);
4365 for (size_t j
= padding_end
; j
< i
+ zero_last
; j
++)
4370 for (k
= j
; k
< i
+ zero_last
; k
++)
4371 if (buf
->buf
[k
] == 0)
4373 HOST_WIDE_INT off
= buf
->off
+ j
;
4377 atype
= char_type_node
;
4378 src
= build_zero_cst (char_type_node
);
4382 atype
= build_array_type_nelts (char_type_node
, k
- j
);
4383 src
= build_constructor (atype
, NULL
);
4385 tree dst
= build2_loc (buf
->loc
, MEM_REF
, atype
,
4387 build_int_cst (buf
->alias_type
, off
));
4388 gimple
*g
= gimple_build_assign (dst
, src
);
4389 gimple_set_location (g
, buf
->loc
);
4390 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4394 if (nonzero_last
== wordsize
)
4395 padding_bytes
= nonzero_last
- zero_last
;
4398 for (size_t eltsz
= 1; eltsz
<= wordsize
; eltsz
<<= 1)
4400 if (nonzero_last
- nonzero_first
<= eltsz
4401 && ((nonzero_first
& ~(eltsz
- 1))
4402 == ((nonzero_last
- 1) & ~(eltsz
- 1))))
4406 type
= char_type_node
;
4408 type
= lang_hooks
.types
.type_for_size (eltsz
* BITS_PER_UNIT
,
4410 size_t start
= nonzero_first
& ~(eltsz
- 1);
4411 HOST_WIDE_INT off
= buf
->off
+ i
+ start
;
4413 if (eltsz
> 1 && buf
->align
< TYPE_ALIGN (type
))
4414 atype
= build_aligned_type (type
, buf
->align
);
4415 tree dst
= build2_loc (buf
->loc
, MEM_REF
, atype
, buf
->base
,
4416 build_int_cst (buf
->alias_type
, off
));
4420 && nonzero_first
== start
4421 && nonzero_last
== start
+ eltsz
)
4422 src
= build_zero_cst (type
);
4425 src
= make_ssa_name (type
);
4426 g
= gimple_build_assign (src
, unshare_expr (dst
));
4427 gimple_set_location (g
, buf
->loc
);
4428 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4429 tree mask
= native_interpret_expr (type
,
4430 buf
->buf
+ i
+ start
,
4432 gcc_assert (mask
&& TREE_CODE (mask
) == INTEGER_CST
);
4433 mask
= fold_build1 (BIT_NOT_EXPR
, type
, mask
);
4434 tree src_masked
= make_ssa_name (type
);
4435 g
= gimple_build_assign (src_masked
, BIT_AND_EXPR
,
4437 gimple_set_location (g
, buf
->loc
);
4438 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4441 g
= gimple_build_assign (dst
, src
);
4442 gimple_set_location (g
, buf
->loc
);
4443 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4453 if (padding_bytes
== 1)
4455 atype
= char_type_node
;
4456 src
= build_zero_cst (char_type_node
);
4460 atype
= build_array_type_nelts (char_type_node
, padding_bytes
);
4461 src
= build_constructor (atype
, NULL
);
4463 tree dst
= build2_loc (buf
->loc
, MEM_REF
, atype
, buf
->base
,
4464 build_int_cst (buf
->alias_type
,
4467 gimple
*g
= gimple_build_assign (dst
, src
);
4468 gimple_set_location (g
, buf
->loc
);
4469 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4471 size_t end_rem
= end
% UNITS_PER_WORD
;
4472 buf
->off
+= end
- end_rem
;
4473 buf
->size
= end_rem
;
4474 memset (buf
->buf
, 0, buf
->size
);
4475 buf
->padding_bytes
= 0;
4479 memmove (buf
->buf
, buf
->buf
+ end
, buf
->size
- end
);
4482 buf
->padding_bytes
= padding_bytes
;
4486 /* Append PADDING_BYTES padding bytes. */
4489 clear_padding_add_padding (clear_padding_struct
*buf
,
4490 HOST_WIDE_INT padding_bytes
)
4492 if (padding_bytes
== 0)
4494 if ((unsigned HOST_WIDE_INT
) padding_bytes
+ buf
->size
4495 > (unsigned HOST_WIDE_INT
) clear_padding_buf_size
)
4496 clear_padding_flush (buf
, false);
4497 if ((unsigned HOST_WIDE_INT
) padding_bytes
+ buf
->size
4498 > (unsigned HOST_WIDE_INT
) clear_padding_buf_size
)
4500 memset (buf
->buf
+ buf
->size
, ~0, clear_padding_buf_size
- buf
->size
);
4501 padding_bytes
-= clear_padding_buf_size
- buf
->size
;
4502 buf
->size
= clear_padding_buf_size
;
4503 clear_padding_flush (buf
, false);
4504 gcc_assert (buf
->padding_bytes
);
4505 /* At this point buf->buf[0] through buf->buf[buf->size - 1]
4506 is guaranteed to be all ones. */
4507 padding_bytes
+= buf
->size
;
4508 buf
->size
= padding_bytes
% UNITS_PER_WORD
;
4509 memset (buf
->buf
, ~0, buf
->size
);
4510 buf
->off
+= padding_bytes
- buf
->size
;
4511 buf
->padding_bytes
+= padding_bytes
- buf
->size
;
4515 memset (buf
->buf
+ buf
->size
, ~0, padding_bytes
);
4516 buf
->size
+= padding_bytes
;
4520 static void clear_padding_type (clear_padding_struct
*, tree
, HOST_WIDE_INT
);
4522 /* Clear padding bits of union type TYPE. */
4525 clear_padding_union (clear_padding_struct
*buf
, tree type
, HOST_WIDE_INT sz
)
4527 clear_padding_struct
*union_buf
;
4528 HOST_WIDE_INT start_off
= 0, next_off
= 0;
4529 size_t start_size
= 0;
4532 start_off
= buf
->off
+ buf
->size
;
4533 next_off
= start_off
+ sz
;
4534 start_size
= start_off
% UNITS_PER_WORD
;
4535 start_off
-= start_size
;
4536 clear_padding_flush (buf
, true);
4541 if (sz
+ buf
->size
> clear_padding_buf_size
)
4542 clear_padding_flush (buf
, false);
4543 union_buf
= XALLOCA (clear_padding_struct
);
4544 union_buf
->loc
= buf
->loc
;
4545 union_buf
->clear_in_mask
= buf
->clear_in_mask
;
4546 union_buf
->base
= NULL_TREE
;
4547 union_buf
->alias_type
= NULL_TREE
;
4548 union_buf
->gsi
= NULL
;
4549 union_buf
->align
= 0;
4551 union_buf
->padding_bytes
= 0;
4553 union_buf
->size
= 0;
4554 if (sz
+ buf
->size
<= clear_padding_buf_size
)
4555 union_buf
->union_ptr
= buf
->buf
+ buf
->size
;
4557 union_buf
->union_ptr
= XNEWVEC (unsigned char, sz
);
4558 memset (union_buf
->union_ptr
, ~0, sz
);
4561 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
4562 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_PADDING_P (field
))
4564 if (DECL_SIZE_UNIT (field
) == NULL_TREE
)
4566 if (TREE_TYPE (field
) == error_mark_node
)
4568 gcc_assert (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
4569 && !COMPLETE_TYPE_P (TREE_TYPE (field
)));
4570 if (!buf
->clear_in_mask
)
4571 error_at (buf
->loc
, "flexible array member %qD does not have "
4572 "well defined padding bits for %qs",
4573 field
, "__builtin_clear_padding");
4576 HOST_WIDE_INT fldsz
= tree_to_shwi (DECL_SIZE_UNIT (field
));
4577 gcc_assert (union_buf
->size
== 0);
4578 union_buf
->off
= start_off
;
4579 union_buf
->size
= start_size
;
4580 memset (union_buf
->buf
, ~0, start_size
);
4581 clear_padding_type (union_buf
, TREE_TYPE (field
), fldsz
);
4582 clear_padding_add_padding (union_buf
, sz
- fldsz
);
4583 clear_padding_flush (union_buf
, true);
4586 if (buf
== union_buf
)
4588 buf
->off
= next_off
;
4589 buf
->size
= next_off
% UNITS_PER_WORD
;
4590 buf
->off
-= buf
->size
;
4591 memset (buf
->buf
, ~0, buf
->size
);
4593 else if (sz
+ buf
->size
<= clear_padding_buf_size
)
4597 unsigned char *union_ptr
= union_buf
->union_ptr
;
4600 clear_padding_flush (buf
, false);
4601 HOST_WIDE_INT this_sz
4602 = MIN ((unsigned HOST_WIDE_INT
) sz
,
4603 clear_padding_buf_size
- buf
->size
);
4604 memcpy (buf
->buf
+ buf
->size
, union_ptr
, this_sz
);
4605 buf
->size
+= this_sz
;
4606 union_ptr
+= this_sz
;
4609 XDELETE (union_buf
->union_ptr
);
4613 /* The only known floating point formats with padding bits are the
4614 IEEE extended ones. */
4617 clear_padding_real_needs_padding_p (tree type
)
4619 const struct real_format
*fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
4621 && fmt
->signbit_ro
== fmt
->signbit_rw
4622 && (fmt
->signbit_ro
== 79 || fmt
->signbit_ro
== 95));
4625 /* Return true if TYPE might contain any padding bits. */
4628 clear_padding_type_may_have_padding_p (tree type
)
4630 switch (TREE_CODE (type
))
4638 return clear_padding_type_may_have_padding_p (TREE_TYPE (type
));
4640 return clear_padding_real_needs_padding_p (type
);
4646 /* Emit a runtime loop:
4647 for (; buf.base != end; buf.base += sz)
4648 __builtin_clear_padding (buf.base); */
4651 clear_padding_emit_loop (clear_padding_struct
*buf
, tree type
, tree end
)
4653 tree l1
= create_artificial_label (buf
->loc
);
4654 tree l2
= create_artificial_label (buf
->loc
);
4655 tree l3
= create_artificial_label (buf
->loc
);
4656 gimple
*g
= gimple_build_goto (l2
);
4657 gimple_set_location (g
, buf
->loc
);
4658 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4659 g
= gimple_build_label (l1
);
4660 gimple_set_location (g
, buf
->loc
);
4661 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4662 clear_padding_type (buf
, type
, buf
->sz
);
4663 clear_padding_flush (buf
, true);
4664 g
= gimple_build_assign (buf
->base
, POINTER_PLUS_EXPR
, buf
->base
,
4665 size_int (buf
->sz
));
4666 gimple_set_location (g
, buf
->loc
);
4667 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4668 g
= gimple_build_label (l2
);
4669 gimple_set_location (g
, buf
->loc
);
4670 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4671 g
= gimple_build_cond (NE_EXPR
, buf
->base
, end
, l1
, l3
);
4672 gimple_set_location (g
, buf
->loc
);
4673 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4674 g
= gimple_build_label (l3
);
4675 gimple_set_location (g
, buf
->loc
);
4676 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4679 /* Clear padding bits for TYPE. Called recursively from
4680 gimple_fold_builtin_clear_padding. */
4683 clear_padding_type (clear_padding_struct
*buf
, tree type
, HOST_WIDE_INT sz
)
4685 switch (TREE_CODE (type
))
4688 HOST_WIDE_INT cur_pos
;
4690 for (tree field
= TYPE_FIELDS (type
); field
; field
= DECL_CHAIN (field
))
4691 if (TREE_CODE (field
) == FIELD_DECL
&& !DECL_PADDING_P (field
))
4693 tree ftype
= TREE_TYPE (field
);
4694 if (DECL_BIT_FIELD (field
))
4696 HOST_WIDE_INT fldsz
= TYPE_PRECISION (ftype
);
4699 HOST_WIDE_INT pos
= int_byte_position (field
);
4701 = tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
));
4702 bpos
%= BITS_PER_UNIT
;
4704 = ROUND_UP (bpos
+ fldsz
, BITS_PER_UNIT
) / BITS_PER_UNIT
;
4705 if (pos
+ end
> cur_pos
)
4707 clear_padding_add_padding (buf
, pos
+ end
- cur_pos
);
4708 cur_pos
= pos
+ end
;
4710 gcc_assert (cur_pos
> pos
4711 && ((unsigned HOST_WIDE_INT
) buf
->size
4712 >= (unsigned HOST_WIDE_INT
) cur_pos
- pos
));
4713 unsigned char *p
= buf
->buf
+ buf
->size
- (cur_pos
- pos
);
4714 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
)
4715 sorry_at (buf
->loc
, "PDP11 bit-field handling unsupported"
4716 " in %qs", "__builtin_clear_padding");
4717 else if (BYTES_BIG_ENDIAN
)
4720 if (bpos
+ fldsz
<= BITS_PER_UNIT
)
4721 *p
&= ~(((1 << fldsz
) - 1)
4722 << (BITS_PER_UNIT
- bpos
- fldsz
));
4727 *p
&= ~(((1U << BITS_PER_UNIT
) - 1) >> bpos
);
4729 fldsz
-= BITS_PER_UNIT
- bpos
;
4731 memset (p
, 0, fldsz
/ BITS_PER_UNIT
);
4732 p
+= fldsz
/ BITS_PER_UNIT
;
4733 fldsz
%= BITS_PER_UNIT
;
4735 *p
&= ((1U << BITS_PER_UNIT
) - 1) >> fldsz
;
4740 /* Little endian. */
4741 if (bpos
+ fldsz
<= BITS_PER_UNIT
)
4742 *p
&= ~(((1 << fldsz
) - 1) << bpos
);
4747 *p
&= ~(((1 << BITS_PER_UNIT
) - 1) << bpos
);
4749 fldsz
-= BITS_PER_UNIT
- bpos
;
4751 memset (p
, 0, fldsz
/ BITS_PER_UNIT
);
4752 p
+= fldsz
/ BITS_PER_UNIT
;
4753 fldsz
%= BITS_PER_UNIT
;
4755 *p
&= ~((1 << fldsz
) - 1);
4759 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
)
4761 if (ftype
== error_mark_node
)
4763 gcc_assert (TREE_CODE (ftype
) == ARRAY_TYPE
4764 && !COMPLETE_TYPE_P (ftype
));
4765 if (!buf
->clear_in_mask
)
4766 error_at (buf
->loc
, "flexible array member %qD does not "
4767 "have well defined padding bits for %qs",
4768 field
, "__builtin_clear_padding");
4770 else if (is_empty_type (TREE_TYPE (field
)))
4774 HOST_WIDE_INT pos
= int_byte_position (field
);
4775 HOST_WIDE_INT fldsz
= tree_to_shwi (DECL_SIZE_UNIT (field
));
4776 gcc_assert (pos
>= 0 && fldsz
>= 0 && pos
>= cur_pos
);
4777 clear_padding_add_padding (buf
, pos
- cur_pos
);
4779 clear_padding_type (buf
, TREE_TYPE (field
), fldsz
);
4783 gcc_assert (sz
>= cur_pos
);
4784 clear_padding_add_padding (buf
, sz
- cur_pos
);
4787 HOST_WIDE_INT nelts
, fldsz
;
4788 fldsz
= int_size_in_bytes (TREE_TYPE (type
));
4793 && sz
> 8 * UNITS_PER_WORD
4794 && buf
->union_ptr
== NULL
4795 && clear_padding_type_may_have_padding_p (TREE_TYPE (type
)))
4797 /* For sufficiently large array of more than one elements,
4798 emit a runtime loop to keep code size manageable. */
4799 tree base
= buf
->base
;
4800 unsigned int prev_align
= buf
->align
;
4801 HOST_WIDE_INT off
= buf
->off
+ buf
->size
;
4802 HOST_WIDE_INT prev_sz
= buf
->sz
;
4803 clear_padding_flush (buf
, true);
4804 tree elttype
= TREE_TYPE (type
);
4805 buf
->base
= create_tmp_var (build_pointer_type (elttype
));
4806 tree end
= make_ssa_name (TREE_TYPE (buf
->base
));
4807 gimple
*g
= gimple_build_assign (buf
->base
, POINTER_PLUS_EXPR
,
4808 base
, size_int (off
));
4809 gimple_set_location (g
, buf
->loc
);
4810 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4811 g
= gimple_build_assign (end
, POINTER_PLUS_EXPR
, buf
->base
,
4813 gimple_set_location (g
, buf
->loc
);
4814 gsi_insert_before (buf
->gsi
, g
, GSI_SAME_STMT
);
4816 buf
->align
= TYPE_ALIGN (elttype
);
4819 clear_padding_emit_loop (buf
, elttype
, end
);
4822 buf
->align
= prev_align
;
4823 buf
->size
= off
% UNITS_PER_WORD
;
4824 buf
->off
= off
- buf
->size
;
4825 memset (buf
->buf
, 0, buf
->size
);
4828 for (HOST_WIDE_INT i
= 0; i
< nelts
; i
++)
4829 clear_padding_type (buf
, TREE_TYPE (type
), fldsz
);
4832 clear_padding_union (buf
, type
, sz
);
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 if (clear_padding_real_needs_padding_p (type
))
4840 /* Use native_interpret_expr + native_encode_expr to figure out
4841 which bits are padding. */
4842 memset (buf
->buf
+ buf
->size
, ~0, sz
);
4843 tree cst
= native_interpret_expr (type
, buf
->buf
+ buf
->size
, sz
);
4844 gcc_assert (cst
&& TREE_CODE (cst
) == REAL_CST
);
4845 int len
= native_encode_expr (cst
, buf
->buf
+ buf
->size
, sz
);
4846 gcc_assert (len
> 0 && (size_t) len
== (size_t) sz
);
4847 for (size_t i
= 0; i
< (size_t) sz
; i
++)
4848 buf
->buf
[buf
->size
+ i
] ^= ~0;
4851 memset (buf
->buf
+ buf
->size
, 0, sz
);
4855 fldsz
= int_size_in_bytes (TREE_TYPE (type
));
4856 clear_padding_type (buf
, TREE_TYPE (type
), fldsz
);
4857 clear_padding_type (buf
, TREE_TYPE (type
), fldsz
);
4860 nelts
= TYPE_VECTOR_SUBPARTS (type
).to_constant ();
4861 fldsz
= int_size_in_bytes (TREE_TYPE (type
));
4862 for (HOST_WIDE_INT i
= 0; i
< nelts
; i
++)
4863 clear_padding_type (buf
, TREE_TYPE (type
), fldsz
);
4866 gcc_assert ((size_t) sz
<= clear_padding_unit
);
4867 if ((unsigned HOST_WIDE_INT
) sz
+ buf
->size
> clear_padding_buf_size
)
4868 clear_padding_flush (buf
, false);
4869 memset (buf
->buf
+ buf
->size
, ~0, sz
);
4873 gcc_assert ((size_t) sz
<= clear_padding_unit
);
4874 if ((unsigned HOST_WIDE_INT
) sz
+ buf
->size
> clear_padding_buf_size
)
4875 clear_padding_flush (buf
, false);
4876 memset (buf
->buf
+ buf
->size
, 0, sz
);
4882 /* Clear padding bits of TYPE in MASK. */
4885 clear_type_padding_in_mask (tree type
, unsigned char *mask
)
4887 clear_padding_struct buf
;
4888 buf
.loc
= UNKNOWN_LOCATION
;
4889 buf
.clear_in_mask
= true;
4890 buf
.base
= NULL_TREE
;
4891 buf
.alias_type
= NULL_TREE
;
4895 buf
.padding_bytes
= 0;
4896 buf
.sz
= int_size_in_bytes (type
);
4898 buf
.union_ptr
= mask
;
4899 clear_padding_type (&buf
, type
, buf
.sz
);
4900 clear_padding_flush (&buf
, true);
4903 /* Fold __builtin_clear_padding builtin. */
4906 gimple_fold_builtin_clear_padding (gimple_stmt_iterator
*gsi
)
4908 gimple
*stmt
= gsi_stmt (*gsi
);
4909 gcc_assert (gimple_call_num_args (stmt
) == 2);
4910 tree ptr
= gimple_call_arg (stmt
, 0);
4911 tree typearg
= gimple_call_arg (stmt
, 1);
4912 tree type
= TREE_TYPE (TREE_TYPE (typearg
));
4913 location_t loc
= gimple_location (stmt
);
4914 clear_padding_struct buf
;
4915 gimple_stmt_iterator gsiprev
= *gsi
;
4916 /* This should be folded during the lower pass. */
4917 gcc_assert (!gimple_in_ssa_p (cfun
) && cfun
->cfg
== NULL
);
4918 gcc_assert (COMPLETE_TYPE_P (type
));
4919 gsi_prev (&gsiprev
);
4922 buf
.clear_in_mask
= false;
4924 buf
.alias_type
= NULL_TREE
;
4926 buf
.align
= get_pointer_alignment (ptr
);
4927 unsigned int talign
= min_align_of_type (type
) * BITS_PER_UNIT
;
4928 buf
.align
= MAX (buf
.align
, talign
);
4930 buf
.padding_bytes
= 0;
4932 buf
.sz
= int_size_in_bytes (type
);
4933 buf
.union_ptr
= NULL
;
4934 if (buf
.sz
< 0 && int_size_in_bytes (strip_array_types (type
)) < 0)
4935 sorry_at (loc
, "%s not supported for variable length aggregates",
4936 "__builtin_clear_padding");
4937 /* The implementation currently assumes 8-bit host and target
4938 chars which is the case for all currently supported targets
4939 and hosts and is required e.g. for native_{encode,interpret}* APIs. */
4940 else if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
4941 sorry_at (loc
, "%s not supported on this target",
4942 "__builtin_clear_padding");
4943 else if (!clear_padding_type_may_have_padding_p (type
))
4945 else if (TREE_CODE (type
) == ARRAY_TYPE
&& buf
.sz
< 0)
4947 tree sz
= TYPE_SIZE_UNIT (type
);
4948 tree elttype
= type
;
4949 /* Only supports C/C++ VLAs and flattens all the VLA levels. */
4950 while (TREE_CODE (elttype
) == ARRAY_TYPE
4951 && int_size_in_bytes (elttype
) < 0)
4952 elttype
= TREE_TYPE (elttype
);
4953 HOST_WIDE_INT eltsz
= int_size_in_bytes (elttype
);
4954 gcc_assert (eltsz
>= 0);
4957 buf
.base
= create_tmp_var (build_pointer_type (elttype
));
4958 tree end
= make_ssa_name (TREE_TYPE (buf
.base
));
4959 gimple
*g
= gimple_build_assign (buf
.base
, ptr
);
4960 gimple_set_location (g
, loc
);
4961 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
4962 g
= gimple_build_assign (end
, POINTER_PLUS_EXPR
, buf
.base
, sz
);
4963 gimple_set_location (g
, loc
);
4964 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
4966 buf
.align
= TYPE_ALIGN (elttype
);
4967 buf
.alias_type
= build_pointer_type (elttype
);
4968 clear_padding_emit_loop (&buf
, elttype
, end
);
4973 if (!is_gimple_mem_ref_addr (buf
.base
))
4975 buf
.base
= make_ssa_name (TREE_TYPE (ptr
));
4976 gimple
*g
= gimple_build_assign (buf
.base
, ptr
);
4977 gimple_set_location (g
, loc
);
4978 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
4980 buf
.alias_type
= build_pointer_type (type
);
4981 clear_padding_type (&buf
, type
, buf
.sz
);
4982 clear_padding_flush (&buf
, true);
4985 gimple_stmt_iterator gsiprev2
= *gsi
;
4986 gsi_prev (&gsiprev2
);
4987 if (gsi_stmt (gsiprev
) == gsi_stmt (gsiprev2
))
4988 gsi_replace (gsi
, gimple_build_nop (), true);
4991 gsi_remove (gsi
, true);
4997 /* Fold the non-target builtin at *GSI and return whether any simplification
5001 gimple_fold_builtin (gimple_stmt_iterator
*gsi
)
5003 gcall
*stmt
= as_a
<gcall
*>(gsi_stmt (*gsi
));
5004 tree callee
= gimple_call_fndecl (stmt
);
5006 /* Give up for always_inline inline builtins until they are
5008 if (avoid_folding_inline_builtin (callee
))
5011 unsigned n
= gimple_call_num_args (stmt
);
5012 enum built_in_function fcode
= DECL_FUNCTION_CODE (callee
);
5016 return gimple_fold_builtin_bcmp (gsi
);
5017 case BUILT_IN_BCOPY
:
5018 return gimple_fold_builtin_bcopy (gsi
);
5019 case BUILT_IN_BZERO
:
5020 return gimple_fold_builtin_bzero (gsi
);
5022 case BUILT_IN_MEMSET
:
5023 return gimple_fold_builtin_memset (gsi
,
5024 gimple_call_arg (stmt
, 1),
5025 gimple_call_arg (stmt
, 2));
5026 case BUILT_IN_MEMCPY
:
5027 case BUILT_IN_MEMPCPY
:
5028 case BUILT_IN_MEMMOVE
:
5029 return gimple_fold_builtin_memory_op (gsi
, gimple_call_arg (stmt
, 0),
5030 gimple_call_arg (stmt
, 1), fcode
);
5031 case BUILT_IN_SPRINTF_CHK
:
5032 case BUILT_IN_VSPRINTF_CHK
:
5033 return gimple_fold_builtin_sprintf_chk (gsi
, fcode
);
5034 case BUILT_IN_STRCAT_CHK
:
5035 return gimple_fold_builtin_strcat_chk (gsi
);
5036 case BUILT_IN_STRNCAT_CHK
:
5037 return gimple_fold_builtin_strncat_chk (gsi
);
5038 case BUILT_IN_STRLEN
:
5039 return gimple_fold_builtin_strlen (gsi
);
5040 case BUILT_IN_STRCPY
:
5041 return gimple_fold_builtin_strcpy (gsi
,
5042 gimple_call_arg (stmt
, 0),
5043 gimple_call_arg (stmt
, 1));
5044 case BUILT_IN_STRNCPY
:
5045 return gimple_fold_builtin_strncpy (gsi
,
5046 gimple_call_arg (stmt
, 0),
5047 gimple_call_arg (stmt
, 1),
5048 gimple_call_arg (stmt
, 2));
5049 case BUILT_IN_STRCAT
:
5050 return gimple_fold_builtin_strcat (gsi
, gimple_call_arg (stmt
, 0),
5051 gimple_call_arg (stmt
, 1));
5052 case BUILT_IN_STRNCAT
:
5053 return gimple_fold_builtin_strncat (gsi
);
5054 case BUILT_IN_INDEX
:
5055 case BUILT_IN_STRCHR
:
5056 return gimple_fold_builtin_strchr (gsi
, false);
5057 case BUILT_IN_RINDEX
:
5058 case BUILT_IN_STRRCHR
:
5059 return gimple_fold_builtin_strchr (gsi
, true);
5060 case BUILT_IN_STRSTR
:
5061 return gimple_fold_builtin_strstr (gsi
);
5062 case BUILT_IN_STRCMP
:
5063 case BUILT_IN_STRCMP_EQ
:
5064 case BUILT_IN_STRCASECMP
:
5065 case BUILT_IN_STRNCMP
:
5066 case BUILT_IN_STRNCMP_EQ
:
5067 case BUILT_IN_STRNCASECMP
:
5068 return gimple_fold_builtin_string_compare (gsi
);
5069 case BUILT_IN_MEMCHR
:
5070 return gimple_fold_builtin_memchr (gsi
);
5071 case BUILT_IN_FPUTS
:
5072 return gimple_fold_builtin_fputs (gsi
, gimple_call_arg (stmt
, 0),
5073 gimple_call_arg (stmt
, 1), false);
5074 case BUILT_IN_FPUTS_UNLOCKED
:
5075 return gimple_fold_builtin_fputs (gsi
, gimple_call_arg (stmt
, 0),
5076 gimple_call_arg (stmt
, 1), true);
5077 case BUILT_IN_MEMCPY_CHK
:
5078 case BUILT_IN_MEMPCPY_CHK
:
5079 case BUILT_IN_MEMMOVE_CHK
:
5080 case BUILT_IN_MEMSET_CHK
:
5081 return gimple_fold_builtin_memory_chk (gsi
,
5082 gimple_call_arg (stmt
, 0),
5083 gimple_call_arg (stmt
, 1),
5084 gimple_call_arg (stmt
, 2),
5085 gimple_call_arg (stmt
, 3),
5087 case BUILT_IN_STPCPY
:
5088 return gimple_fold_builtin_stpcpy (gsi
);
5089 case BUILT_IN_STRCPY_CHK
:
5090 case BUILT_IN_STPCPY_CHK
:
5091 return gimple_fold_builtin_stxcpy_chk (gsi
,
5092 gimple_call_arg (stmt
, 0),
5093 gimple_call_arg (stmt
, 1),
5094 gimple_call_arg (stmt
, 2),
5096 case BUILT_IN_STRNCPY_CHK
:
5097 case BUILT_IN_STPNCPY_CHK
:
5098 return gimple_fold_builtin_stxncpy_chk (gsi
,
5099 gimple_call_arg (stmt
, 0),
5100 gimple_call_arg (stmt
, 1),
5101 gimple_call_arg (stmt
, 2),
5102 gimple_call_arg (stmt
, 3),
5104 case BUILT_IN_SNPRINTF_CHK
:
5105 case BUILT_IN_VSNPRINTF_CHK
:
5106 return gimple_fold_builtin_snprintf_chk (gsi
, fcode
);
5108 case BUILT_IN_FPRINTF
:
5109 case BUILT_IN_FPRINTF_UNLOCKED
:
5110 case BUILT_IN_VFPRINTF
:
5111 if (n
== 2 || n
== 3)
5112 return gimple_fold_builtin_fprintf (gsi
,
5113 gimple_call_arg (stmt
, 0),
5114 gimple_call_arg (stmt
, 1),
5116 ? gimple_call_arg (stmt
, 2)
5120 case BUILT_IN_FPRINTF_CHK
:
5121 case BUILT_IN_VFPRINTF_CHK
:
5122 if (n
== 3 || n
== 4)
5123 return gimple_fold_builtin_fprintf (gsi
,
5124 gimple_call_arg (stmt
, 0),
5125 gimple_call_arg (stmt
, 2),
5127 ? gimple_call_arg (stmt
, 3)
5131 case BUILT_IN_PRINTF
:
5132 case BUILT_IN_PRINTF_UNLOCKED
:
5133 case BUILT_IN_VPRINTF
:
5134 if (n
== 1 || n
== 2)
5135 return gimple_fold_builtin_printf (gsi
, gimple_call_arg (stmt
, 0),
5137 ? gimple_call_arg (stmt
, 1)
5138 : NULL_TREE
, fcode
);
5140 case BUILT_IN_PRINTF_CHK
:
5141 case BUILT_IN_VPRINTF_CHK
:
5142 if (n
== 2 || n
== 3)
5143 return gimple_fold_builtin_printf (gsi
, gimple_call_arg (stmt
, 1),
5145 ? gimple_call_arg (stmt
, 2)
5146 : NULL_TREE
, fcode
);
5148 case BUILT_IN_ACC_ON_DEVICE
:
5149 return gimple_fold_builtin_acc_on_device (gsi
,
5150 gimple_call_arg (stmt
, 0));
5151 case BUILT_IN_REALLOC
:
5152 return gimple_fold_builtin_realloc (gsi
);
5154 case BUILT_IN_CLEAR_PADDING
:
5155 return gimple_fold_builtin_clear_padding (gsi
);
5160 /* Try the generic builtin folder. */
5161 bool ignore
= (gimple_call_lhs (stmt
) == NULL
);
5162 tree result
= fold_call_stmt (stmt
, ignore
);
5166 STRIP_NOPS (result
);
5168 result
= fold_convert (gimple_call_return_type (stmt
), result
);
5169 gimplify_and_update_call_from_tree (gsi
, result
);
5176 /* Transform IFN_GOACC_DIM_SIZE and IFN_GOACC_DIM_POS internal
5177 function calls to constants, where possible. */
5180 fold_internal_goacc_dim (const gimple
*call
)
5182 int axis
= oacc_get_ifn_dim_arg (call
);
5183 int size
= oacc_get_fn_dim_size (current_function_decl
, axis
);
5184 tree result
= NULL_TREE
;
5185 tree type
= TREE_TYPE (gimple_call_lhs (call
));
5187 switch (gimple_call_internal_fn (call
))
5189 case IFN_GOACC_DIM_POS
:
5190 /* If the size is 1, we know the answer. */
5192 result
= build_int_cst (type
, 0);
5194 case IFN_GOACC_DIM_SIZE
:
5195 /* If the size is not dynamic, we know the answer. */
5197 result
= build_int_cst (type
, size
);
5206 /* Return true if stmt is __atomic_compare_exchange_N call which is suitable
5207 for conversion into ATOMIC_COMPARE_EXCHANGE if the second argument is
5208 &var where var is only addressable because of such calls. */
5211 optimize_atomic_compare_exchange_p (gimple
*stmt
)
5213 if (gimple_call_num_args (stmt
) != 6
5214 || !flag_inline_atomics
5216 || sanitize_flags_p (SANITIZE_THREAD
| SANITIZE_ADDRESS
)
5217 || !gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
)
5218 || !gimple_vdef (stmt
)
5219 || !gimple_vuse (stmt
))
5222 tree fndecl
= gimple_call_fndecl (stmt
);
5223 switch (DECL_FUNCTION_CODE (fndecl
))
5225 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1
:
5226 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2
:
5227 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4
:
5228 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8
:
5229 case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16
:
5235 tree expected
= gimple_call_arg (stmt
, 1);
5236 if (TREE_CODE (expected
) != ADDR_EXPR
5237 || !SSA_VAR_P (TREE_OPERAND (expected
, 0)))
5240 tree etype
= TREE_TYPE (TREE_OPERAND (expected
, 0));
5241 if (!is_gimple_reg_type (etype
)
5242 || !auto_var_in_fn_p (TREE_OPERAND (expected
, 0), current_function_decl
)
5243 || TREE_THIS_VOLATILE (etype
)
5244 || VECTOR_TYPE_P (etype
)
5245 || TREE_CODE (etype
) == COMPLEX_TYPE
5246 /* Don't optimize floating point expected vars, VIEW_CONVERT_EXPRs
5247 might not preserve all the bits. See PR71716. */
5248 || SCALAR_FLOAT_TYPE_P (etype
)
5249 || maybe_ne (TYPE_PRECISION (etype
),
5250 GET_MODE_BITSIZE (TYPE_MODE (etype
))))
5253 tree weak
= gimple_call_arg (stmt
, 3);
5254 if (!integer_zerop (weak
) && !integer_onep (weak
))
5257 tree parmt
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
5258 tree itype
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (parmt
)));
5259 machine_mode mode
= TYPE_MODE (itype
);
5261 if (direct_optab_handler (atomic_compare_and_swap_optab
, mode
)
5263 && optab_handler (sync_compare_and_swap_optab
, mode
) == CODE_FOR_nothing
)
5266 if (maybe_ne (int_size_in_bytes (etype
), GET_MODE_SIZE (mode
)))
5273 r = __atomic_compare_exchange_N (p, &e, d, w, s, f);
5275 _Complex uintN_t t = ATOMIC_COMPARE_EXCHANGE (p, e, d, w * 256 + N, s, f);
5276 i = IMAGPART_EXPR <t>;
5278 e = REALPART_EXPR <t>; */
5281 fold_builtin_atomic_compare_exchange (gimple_stmt_iterator
*gsi
)
5283 gimple
*stmt
= gsi_stmt (*gsi
);
5284 tree fndecl
= gimple_call_fndecl (stmt
);
5285 tree parmt
= TYPE_ARG_TYPES (TREE_TYPE (fndecl
));
5286 tree itype
= TREE_VALUE (TREE_CHAIN (TREE_CHAIN (parmt
)));
5287 tree ctype
= build_complex_type (itype
);
5288 tree expected
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
5289 bool throws
= false;
5291 gimple
*g
= gimple_build_assign (make_ssa_name (TREE_TYPE (expected
)),
5293 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
5294 gimple_stmt_iterator gsiret
= gsi_for_stmt (g
);
5295 if (!useless_type_conversion_p (itype
, TREE_TYPE (expected
)))
5297 g
= gimple_build_assign (make_ssa_name (itype
), VIEW_CONVERT_EXPR
,
5298 build1 (VIEW_CONVERT_EXPR
, itype
,
5299 gimple_assign_lhs (g
)));
5300 gsi_insert_before (gsi
, g
, GSI_SAME_STMT
);
5302 int flag
= (integer_onep (gimple_call_arg (stmt
, 3)) ? 256 : 0)
5303 + int_size_in_bytes (itype
);
5304 g
= gimple_build_call_internal (IFN_ATOMIC_COMPARE_EXCHANGE
, 6,
5305 gimple_call_arg (stmt
, 0),
5306 gimple_assign_lhs (g
),
5307 gimple_call_arg (stmt
, 2),
5308 build_int_cst (integer_type_node
, flag
),
5309 gimple_call_arg (stmt
, 4),
5310 gimple_call_arg (stmt
, 5));
5311 tree lhs
= make_ssa_name (ctype
);
5312 gimple_call_set_lhs (g
, lhs
);
5313 gimple_move_vops (g
, stmt
);
5314 tree oldlhs
= gimple_call_lhs (stmt
);
5315 if (stmt_can_throw_internal (cfun
, stmt
))
5318 e
= find_fallthru_edge (gsi_bb (*gsi
)->succs
);
5320 gimple_call_set_nothrow (as_a
<gcall
*> (g
),
5321 gimple_call_nothrow_p (as_a
<gcall
*> (stmt
)));
5322 gimple_call_set_lhs (stmt
, NULL_TREE
);
5323 gsi_replace (gsi
, g
, true);
5326 g
= gimple_build_assign (make_ssa_name (itype
), IMAGPART_EXPR
,
5327 build1 (IMAGPART_EXPR
, itype
, lhs
));
5330 gsi_insert_on_edge_immediate (e
, g
);
5331 *gsi
= gsi_for_stmt (g
);
5334 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5335 g
= gimple_build_assign (oldlhs
, NOP_EXPR
, gimple_assign_lhs (g
));
5336 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5338 g
= gimple_build_assign (make_ssa_name (itype
), REALPART_EXPR
,
5339 build1 (REALPART_EXPR
, itype
, lhs
));
5340 if (throws
&& oldlhs
== NULL_TREE
)
5342 gsi_insert_on_edge_immediate (e
, g
);
5343 *gsi
= gsi_for_stmt (g
);
5346 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5347 if (!useless_type_conversion_p (TREE_TYPE (expected
), itype
))
5349 g
= gimple_build_assign (make_ssa_name (TREE_TYPE (expected
)),
5351 build1 (VIEW_CONVERT_EXPR
, TREE_TYPE (expected
),
5352 gimple_assign_lhs (g
)));
5353 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5355 g
= gimple_build_assign (expected
, SSA_NAME
, gimple_assign_lhs (g
));
5356 gsi_insert_after (gsi
, g
, GSI_NEW_STMT
);
5360 /* Return true if ARG0 CODE ARG1 in infinite signed precision operation
5361 doesn't fit into TYPE. The test for overflow should be regardless of
5362 -fwrapv, and even for unsigned types. */
5365 arith_overflowed_p (enum tree_code code
, const_tree type
,
5366 const_tree arg0
, const_tree arg1
)
5368 widest2_int warg0
= widest2_int_cst (arg0
);
5369 widest2_int warg1
= widest2_int_cst (arg1
);
5373 case PLUS_EXPR
: wres
= wi::add (warg0
, warg1
); break;
5374 case MINUS_EXPR
: wres
= wi::sub (warg0
, warg1
); break;
5375 case MULT_EXPR
: wres
= wi::mul (warg0
, warg1
); break;
5376 default: gcc_unreachable ();
5378 signop sign
= TYPE_SIGN (type
);
5379 if (sign
== UNSIGNED
&& wi::neg_p (wres
))
5381 return wi::min_precision (wres
, sign
) > TYPE_PRECISION (type
);
5384 /* If IFN_MASK_LOAD/STORE call CALL is unconditional, return a MEM_REF
5385 for the memory it references, otherwise return null. VECTYPE is the
5386 type of the memory vector. */
5389 gimple_fold_mask_load_store_mem_ref (gcall
*call
, tree vectype
)
5391 tree ptr
= gimple_call_arg (call
, 0);
5392 tree alias_align
= gimple_call_arg (call
, 1);
5393 tree mask
= gimple_call_arg (call
, 2);
5394 if (!tree_fits_uhwi_p (alias_align
) || !integer_all_onesp (mask
))
5397 unsigned HOST_WIDE_INT align
= tree_to_uhwi (alias_align
);
5398 if (TYPE_ALIGN (vectype
) != align
)
5399 vectype
= build_aligned_type (vectype
, align
);
5400 tree offset
= build_zero_cst (TREE_TYPE (alias_align
));
5401 return fold_build2 (MEM_REF
, vectype
, ptr
, offset
);
5404 /* Try to fold IFN_MASK_LOAD call CALL. Return true on success. */
5407 gimple_fold_mask_load (gimple_stmt_iterator
*gsi
, gcall
*call
)
5409 tree lhs
= gimple_call_lhs (call
);
5413 if (tree rhs
= gimple_fold_mask_load_store_mem_ref (call
, TREE_TYPE (lhs
)))
5415 gassign
*new_stmt
= gimple_build_assign (lhs
, rhs
);
5416 gimple_set_location (new_stmt
, gimple_location (call
));
5417 gimple_move_vops (new_stmt
, call
);
5418 gsi_replace (gsi
, new_stmt
, false);
5424 /* Try to fold IFN_MASK_STORE call CALL. Return true on success. */
5427 gimple_fold_mask_store (gimple_stmt_iterator
*gsi
, gcall
*call
)
5429 tree rhs
= gimple_call_arg (call
, 3);
5430 if (tree lhs
= gimple_fold_mask_load_store_mem_ref (call
, TREE_TYPE (rhs
)))
5432 gassign
*new_stmt
= gimple_build_assign (lhs
, rhs
);
5433 gimple_set_location (new_stmt
, gimple_location (call
));
5434 gimple_move_vops (new_stmt
, call
);
5435 gsi_replace (gsi
, new_stmt
, false);
5441 /* Attempt to fold a call statement referenced by the statement iterator GSI.
5442 The statement may be replaced by another statement, e.g., if the call
5443 simplifies to a constant value. Return true if any changes were made.
5444 It is assumed that the operands have been previously folded. */
5447 gimple_fold_call (gimple_stmt_iterator
*gsi
, bool inplace
)
5449 gcall
*stmt
= as_a
<gcall
*> (gsi_stmt (*gsi
));
5451 bool changed
= false;
5453 /* Check for virtual calls that became direct calls. */
5454 callee
= gimple_call_fn (stmt
);
5455 if (callee
&& TREE_CODE (callee
) == OBJ_TYPE_REF
)
5457 if (gimple_call_addr_fndecl (OBJ_TYPE_REF_EXPR (callee
)) != NULL_TREE
)
5459 if (dump_file
&& virtual_method_call_p (callee
)
5460 && !possible_polymorphic_call_target_p
5461 (callee
, stmt
, cgraph_node::get (gimple_call_addr_fndecl
5462 (OBJ_TYPE_REF_EXPR (callee
)))))
5465 "Type inheritance inconsistent devirtualization of ");
5466 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
5467 fprintf (dump_file
, " to ");
5468 print_generic_expr (dump_file
, callee
, TDF_SLIM
);
5469 fprintf (dump_file
, "\n");
5472 gimple_call_set_fn (stmt
, OBJ_TYPE_REF_EXPR (callee
));
5475 else if (flag_devirtualize
&& !inplace
&& virtual_method_call_p (callee
))
5478 vec
<cgraph_node
*>targets
5479 = possible_polymorphic_call_targets (callee
, stmt
, &final
);
5480 if (final
&& targets
.length () <= 1 && dbg_cnt (devirt
))
5482 tree lhs
= gimple_call_lhs (stmt
);
5483 if (dump_enabled_p ())
5485 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, stmt
,
5486 "folding virtual function call to %s\n",
5487 targets
.length () == 1
5488 ? targets
[0]->name ()
5489 : "__builtin_unreachable");
5491 if (targets
.length () == 1)
5493 tree fndecl
= targets
[0]->decl
;
5494 gimple_call_set_fndecl (stmt
, fndecl
);
5496 /* If changing the call to __cxa_pure_virtual
5497 or similar noreturn function, adjust gimple_call_fntype
5499 if (gimple_call_noreturn_p (stmt
)
5500 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl
)))
5501 && TYPE_ARG_TYPES (TREE_TYPE (fndecl
))
5502 && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl
)))
5504 gimple_call_set_fntype (stmt
, TREE_TYPE (fndecl
));
5505 /* If the call becomes noreturn, remove the lhs. */
5507 && gimple_call_noreturn_p (stmt
)
5508 && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (stmt
)))
5509 || should_remove_lhs_p (lhs
)))
5511 if (TREE_CODE (lhs
) == SSA_NAME
)
5513 tree var
= create_tmp_var (TREE_TYPE (lhs
));
5514 tree def
= get_or_create_ssa_default_def (cfun
, var
);
5515 gimple
*new_stmt
= gimple_build_assign (lhs
, def
);
5516 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
5518 gimple_call_set_lhs (stmt
, NULL_TREE
);
5520 maybe_remove_unused_call_args (cfun
, stmt
);
5524 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
5525 gimple
*new_stmt
= gimple_build_call (fndecl
, 0);
5526 gimple_set_location (new_stmt
, gimple_location (stmt
));
5527 /* If the call had a SSA name as lhs morph that into
5528 an uninitialized value. */
5529 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
5531 tree var
= create_tmp_var (TREE_TYPE (lhs
));
5532 SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs
, var
);
5533 SSA_NAME_DEF_STMT (lhs
) = gimple_build_nop ();
5534 set_ssa_default_def (cfun
, var
, lhs
);
5536 gimple_move_vops (new_stmt
, stmt
);
5537 gsi_replace (gsi
, new_stmt
, false);
5544 /* Check for indirect calls that became direct calls, and then
5545 no longer require a static chain. */
5546 if (gimple_call_chain (stmt
))
5548 tree fn
= gimple_call_fndecl (stmt
);
5549 if (fn
&& !DECL_STATIC_CHAIN (fn
))
5551 gimple_call_set_chain (stmt
, NULL
);
5559 /* Check for builtins that CCP can handle using information not
5560 available in the generic fold routines. */
5561 if (gimple_call_builtin_p (stmt
, BUILT_IN_NORMAL
))
5563 if (gimple_fold_builtin (gsi
))
5566 else if (gimple_call_builtin_p (stmt
, BUILT_IN_MD
))
5568 changed
|= targetm
.gimple_fold_builtin (gsi
);
5570 else if (gimple_call_internal_p (stmt
))
5572 enum tree_code subcode
= ERROR_MARK
;
5573 tree result
= NULL_TREE
;
5574 bool cplx_result
= false;
5575 tree overflow
= NULL_TREE
;
5576 switch (gimple_call_internal_fn (stmt
))
5578 case IFN_BUILTIN_EXPECT
:
5579 result
= fold_builtin_expect (gimple_location (stmt
),
5580 gimple_call_arg (stmt
, 0),
5581 gimple_call_arg (stmt
, 1),
5582 gimple_call_arg (stmt
, 2),
5585 case IFN_UBSAN_OBJECT_SIZE
:
5587 tree offset
= gimple_call_arg (stmt
, 1);
5588 tree objsize
= gimple_call_arg (stmt
, 2);
5589 if (integer_all_onesp (objsize
)
5590 || (TREE_CODE (offset
) == INTEGER_CST
5591 && TREE_CODE (objsize
) == INTEGER_CST
5592 && tree_int_cst_le (offset
, objsize
)))
5594 replace_call_with_value (gsi
, NULL_TREE
);
5600 if (integer_zerop (gimple_call_arg (stmt
, 1)))
5602 replace_call_with_value (gsi
, NULL_TREE
);
5606 case IFN_UBSAN_BOUNDS
:
5608 tree index
= gimple_call_arg (stmt
, 1);
5609 tree bound
= gimple_call_arg (stmt
, 2);
5610 if (TREE_CODE (index
) == INTEGER_CST
5611 && TREE_CODE (bound
) == INTEGER_CST
)
5613 index
= fold_convert (TREE_TYPE (bound
), index
);
5614 if (TREE_CODE (index
) == INTEGER_CST
5615 && tree_int_cst_le (index
, bound
))
5617 replace_call_with_value (gsi
, NULL_TREE
);
5623 case IFN_GOACC_DIM_SIZE
:
5624 case IFN_GOACC_DIM_POS
:
5625 result
= fold_internal_goacc_dim (stmt
);
5627 case IFN_UBSAN_CHECK_ADD
:
5628 subcode
= PLUS_EXPR
;
5630 case IFN_UBSAN_CHECK_SUB
:
5631 subcode
= MINUS_EXPR
;
5633 case IFN_UBSAN_CHECK_MUL
:
5634 subcode
= MULT_EXPR
;
5636 case IFN_ADD_OVERFLOW
:
5637 subcode
= PLUS_EXPR
;
5640 case IFN_SUB_OVERFLOW
:
5641 subcode
= MINUS_EXPR
;
5644 case IFN_MUL_OVERFLOW
:
5645 subcode
= MULT_EXPR
;
5649 changed
|= gimple_fold_mask_load (gsi
, stmt
);
5651 case IFN_MASK_STORE
:
5652 changed
|= gimple_fold_mask_store (gsi
, stmt
);
5657 if (subcode
!= ERROR_MARK
)
5659 tree arg0
= gimple_call_arg (stmt
, 0);
5660 tree arg1
= gimple_call_arg (stmt
, 1);
5661 tree type
= TREE_TYPE (arg0
);
5664 tree lhs
= gimple_call_lhs (stmt
);
5665 if (lhs
== NULL_TREE
)
5668 type
= TREE_TYPE (TREE_TYPE (lhs
));
5670 if (type
== NULL_TREE
)
5672 /* x = y + 0; x = y - 0; x = y * 0; */
5673 else if (integer_zerop (arg1
))
5674 result
= subcode
== MULT_EXPR
? integer_zero_node
: arg0
;
5675 /* x = 0 + y; x = 0 * y; */
5676 else if (subcode
!= MINUS_EXPR
&& integer_zerop (arg0
))
5677 result
= subcode
== MULT_EXPR
? integer_zero_node
: arg1
;
5679 else if (subcode
== MINUS_EXPR
&& operand_equal_p (arg0
, arg1
, 0))
5680 result
= integer_zero_node
;
5681 /* x = y * 1; x = 1 * y; */
5682 else if (subcode
== MULT_EXPR
&& integer_onep (arg1
))
5684 else if (subcode
== MULT_EXPR
&& integer_onep (arg0
))
5686 else if (TREE_CODE (arg0
) == INTEGER_CST
5687 && TREE_CODE (arg1
) == INTEGER_CST
)
5690 result
= int_const_binop (subcode
, fold_convert (type
, arg0
),
5691 fold_convert (type
, arg1
));
5693 result
= int_const_binop (subcode
, arg0
, arg1
);
5694 if (result
&& arith_overflowed_p (subcode
, type
, arg0
, arg1
))
5697 overflow
= build_one_cst (type
);
5704 if (result
== integer_zero_node
)
5705 result
= build_zero_cst (type
);
5706 else if (cplx_result
&& TREE_TYPE (result
) != type
)
5708 if (TREE_CODE (result
) == INTEGER_CST
)
5710 if (arith_overflowed_p (PLUS_EXPR
, type
, result
,
5712 overflow
= build_one_cst (type
);
5714 else if ((!TYPE_UNSIGNED (TREE_TYPE (result
))
5715 && TYPE_UNSIGNED (type
))
5716 || (TYPE_PRECISION (type
)
5717 < (TYPE_PRECISION (TREE_TYPE (result
))
5718 + (TYPE_UNSIGNED (TREE_TYPE (result
))
5719 && !TYPE_UNSIGNED (type
)))))
5722 result
= fold_convert (type
, result
);
5729 if (TREE_CODE (result
) == INTEGER_CST
&& TREE_OVERFLOW (result
))
5730 result
= drop_tree_overflow (result
);
5733 if (overflow
== NULL_TREE
)
5734 overflow
= build_zero_cst (TREE_TYPE (result
));
5735 tree ctype
= build_complex_type (TREE_TYPE (result
));
5736 if (TREE_CODE (result
) == INTEGER_CST
5737 && TREE_CODE (overflow
) == INTEGER_CST
)
5738 result
= build_complex (ctype
, result
, overflow
);
5740 result
= build2_loc (gimple_location (stmt
), COMPLEX_EXPR
,
5741 ctype
, result
, overflow
);
5743 gimplify_and_update_call_from_tree (gsi
, result
);
5752 /* Return true whether NAME has a use on STMT. */
5755 has_use_on_stmt (tree name
, gimple
*stmt
)
5757 imm_use_iterator iter
;
5758 use_operand_p use_p
;
5759 FOR_EACH_IMM_USE_FAST (use_p
, iter
, name
)
5760 if (USE_STMT (use_p
) == stmt
)
5765 /* Worker for fold_stmt_1 dispatch to pattern based folding with
5768 Replaces *GSI with the simplification result in RCODE and OPS
5769 and the associated statements in *SEQ. Does the replacement
5770 according to INPLACE and returns true if the operation succeeded. */
5773 replace_stmt_with_simplification (gimple_stmt_iterator
*gsi
,
5774 gimple_match_op
*res_op
,
5775 gimple_seq
*seq
, bool inplace
)
5777 gimple
*stmt
= gsi_stmt (*gsi
);
5778 tree
*ops
= res_op
->ops
;
5779 unsigned int num_ops
= res_op
->num_ops
;
5781 /* Play safe and do not allow abnormals to be mentioned in
5782 newly created statements. See also maybe_push_res_to_seq.
5783 As an exception allow such uses if there was a use of the
5784 same SSA name on the old stmt. */
5785 for (unsigned int i
= 0; i
< num_ops
; ++i
)
5786 if (TREE_CODE (ops
[i
]) == SSA_NAME
5787 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops
[i
])
5788 && !has_use_on_stmt (ops
[i
], stmt
))
5791 if (num_ops
> 0 && COMPARISON_CLASS_P (ops
[0]))
5792 for (unsigned int i
= 0; i
< 2; ++i
)
5793 if (TREE_CODE (TREE_OPERAND (ops
[0], i
)) == SSA_NAME
5794 && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops
[0], i
))
5795 && !has_use_on_stmt (TREE_OPERAND (ops
[0], i
), stmt
))
5798 /* Don't insert new statements when INPLACE is true, even if we could
5799 reuse STMT for the final statement. */
5800 if (inplace
&& !gimple_seq_empty_p (*seq
))
5803 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
5805 gcc_assert (res_op
->code
.is_tree_code ());
5806 if (TREE_CODE_CLASS ((enum tree_code
) res_op
->code
) == tcc_comparison
5807 /* GIMPLE_CONDs condition may not throw. */
5808 && (!flag_exceptions
5809 || !cfun
->can_throw_non_call_exceptions
5810 || !operation_could_trap_p (res_op
->code
,
5811 FLOAT_TYPE_P (TREE_TYPE (ops
[0])),
5813 gimple_cond_set_condition (cond_stmt
, res_op
->code
, ops
[0], ops
[1]);
5814 else if (res_op
->code
== SSA_NAME
)
5815 gimple_cond_set_condition (cond_stmt
, NE_EXPR
, ops
[0],
5816 build_zero_cst (TREE_TYPE (ops
[0])));
5817 else if (res_op
->code
== INTEGER_CST
)
5819 if (integer_zerop (ops
[0]))
5820 gimple_cond_make_false (cond_stmt
);
5822 gimple_cond_make_true (cond_stmt
);
5826 tree res
= maybe_push_res_to_seq (res_op
, seq
);
5829 gimple_cond_set_condition (cond_stmt
, NE_EXPR
, res
,
5830 build_zero_cst (TREE_TYPE (res
)));
5834 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5836 fprintf (dump_file
, "gimple_simplified to ");
5837 if (!gimple_seq_empty_p (*seq
))
5838 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
5839 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
),
5842 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
5845 else if (is_gimple_assign (stmt
)
5846 && res_op
->code
.is_tree_code ())
5849 || gimple_num_ops (stmt
) > get_gimple_rhs_num_ops (res_op
->code
))
5851 maybe_build_generic_op (res_op
);
5852 gimple_assign_set_rhs_with_ops (gsi
, res_op
->code
,
5853 res_op
->op_or_null (0),
5854 res_op
->op_or_null (1),
5855 res_op
->op_or_null (2));
5856 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5858 fprintf (dump_file
, "gimple_simplified to ");
5859 if (!gimple_seq_empty_p (*seq
))
5860 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
5861 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
),
5864 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
5868 else if (res_op
->code
.is_fn_code ()
5869 && gimple_call_combined_fn (stmt
) == res_op
->code
)
5871 gcc_assert (num_ops
== gimple_call_num_args (stmt
));
5872 for (unsigned int i
= 0; i
< num_ops
; ++i
)
5873 gimple_call_set_arg (stmt
, i
, ops
[i
]);
5874 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5876 fprintf (dump_file
, "gimple_simplified to ");
5877 if (!gimple_seq_empty_p (*seq
))
5878 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
5879 print_gimple_stmt (dump_file
, gsi_stmt (*gsi
), 0, TDF_SLIM
);
5881 gsi_insert_seq_before (gsi
, *seq
, GSI_SAME_STMT
);
5886 if (gimple_has_lhs (stmt
))
5888 tree lhs
= gimple_get_lhs (stmt
);
5889 if (!maybe_push_res_to_seq (res_op
, seq
, lhs
))
5891 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
5893 fprintf (dump_file
, "gimple_simplified to ");
5894 print_gimple_seq (dump_file
, *seq
, 0, TDF_SLIM
);
5896 gsi_replace_with_seq_vops (gsi
, *seq
);
5906 /* Canonicalize MEM_REFs invariant address operand after propagation. */
5909 maybe_canonicalize_mem_ref_addr (tree
*t
, bool is_debug
= false)
5914 if (TREE_CODE (*t
) == ADDR_EXPR
)
5915 t
= &TREE_OPERAND (*t
, 0);
5917 /* The C and C++ frontends use an ARRAY_REF for indexing with their
5918 generic vector extension. The actual vector referenced is
5919 view-converted to an array type for this purpose. If the index
5920 is constant the canonical representation in the middle-end is a
5921 BIT_FIELD_REF so re-write the former to the latter here. */
5922 if (TREE_CODE (*t
) == ARRAY_REF
5923 && TREE_CODE (TREE_OPERAND (*t
, 0)) == VIEW_CONVERT_EXPR
5924 && TREE_CODE (TREE_OPERAND (*t
, 1)) == INTEGER_CST
5925 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*t
, 0), 0))))
5927 tree vtype
= TREE_TYPE (TREE_OPERAND (TREE_OPERAND (*t
, 0), 0));
5928 if (VECTOR_TYPE_P (vtype
))
5930 tree low
= array_ref_low_bound (*t
);
5931 if (TREE_CODE (low
) == INTEGER_CST
)
5933 if (tree_int_cst_le (low
, TREE_OPERAND (*t
, 1)))
5935 widest_int idx
= wi::sub (wi::to_widest (TREE_OPERAND (*t
, 1)),
5936 wi::to_widest (low
));
5937 idx
= wi::mul (idx
, wi::to_widest
5938 (TYPE_SIZE (TREE_TYPE (*t
))));
5940 = wi::add (idx
, wi::to_widest (TYPE_SIZE (TREE_TYPE (*t
))));
5941 if (wi::les_p (ext
, wi::to_widest (TYPE_SIZE (vtype
))))
5943 *t
= build3_loc (EXPR_LOCATION (*t
), BIT_FIELD_REF
,
5945 TREE_OPERAND (TREE_OPERAND (*t
, 0), 0),
5946 TYPE_SIZE (TREE_TYPE (*t
)),
5947 wide_int_to_tree (bitsizetype
, idx
));
5955 while (handled_component_p (*t
))
5956 t
= &TREE_OPERAND (*t
, 0);
5958 /* Canonicalize MEM [&foo.bar, 0] which appears after propagating
5959 of invariant addresses into a SSA name MEM_REF address. */
5960 if (TREE_CODE (*t
) == MEM_REF
5961 || TREE_CODE (*t
) == TARGET_MEM_REF
)
5963 tree addr
= TREE_OPERAND (*t
, 0);
5964 if (TREE_CODE (addr
) == ADDR_EXPR
5965 && (TREE_CODE (TREE_OPERAND (addr
, 0)) == MEM_REF
5966 || handled_component_p (TREE_OPERAND (addr
, 0))))
5970 base
= get_addr_base_and_unit_offset (TREE_OPERAND (addr
, 0),
5979 TREE_OPERAND (*t
, 0) = build_fold_addr_expr (base
);
5980 TREE_OPERAND (*t
, 1) = int_const_binop (PLUS_EXPR
,
5981 TREE_OPERAND (*t
, 1),
5982 size_int (coffset
));
5985 gcc_checking_assert (TREE_CODE (TREE_OPERAND (*t
, 0)) == DEBUG_EXPR_DECL
5986 || is_gimple_mem_ref_addr (TREE_OPERAND (*t
, 0)));
5989 /* Canonicalize back MEM_REFs to plain reference trees if the object
5990 accessed is a decl that has the same access semantics as the MEM_REF. */
5991 if (TREE_CODE (*t
) == MEM_REF
5992 && TREE_CODE (TREE_OPERAND (*t
, 0)) == ADDR_EXPR
5993 && integer_zerop (TREE_OPERAND (*t
, 1))
5994 && MR_DEPENDENCE_CLIQUE (*t
) == 0)
5996 tree decl
= TREE_OPERAND (TREE_OPERAND (*t
, 0), 0);
5997 tree alias_type
= TREE_TYPE (TREE_OPERAND (*t
, 1));
5998 if (/* Same volatile qualification. */
5999 TREE_THIS_VOLATILE (*t
) == TREE_THIS_VOLATILE (decl
)
6000 /* Same TBAA behavior with -fstrict-aliasing. */
6001 && !TYPE_REF_CAN_ALIAS_ALL (alias_type
)
6002 && (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))
6003 == TYPE_MAIN_VARIANT (TREE_TYPE (alias_type
)))
6004 /* Same alignment. */
6005 && TYPE_ALIGN (TREE_TYPE (decl
)) == TYPE_ALIGN (TREE_TYPE (*t
))
6006 /* We have to look out here to not drop a required conversion
6007 from the rhs to the lhs if *t appears on the lhs or vice-versa
6008 if it appears on the rhs. Thus require strict type
6010 && types_compatible_p (TREE_TYPE (*t
), TREE_TYPE (decl
)))
6012 *t
= TREE_OPERAND (TREE_OPERAND (*t
, 0), 0);
6017 else if (TREE_CODE (*orig_t
) == ADDR_EXPR
6018 && TREE_CODE (*t
) == MEM_REF
6019 && TREE_CODE (TREE_OPERAND (*t
, 0)) == INTEGER_CST
)
6023 base
= get_addr_base_and_unit_offset (TREE_OPERAND (*orig_t
, 0),
6027 gcc_assert (TREE_CODE (base
) == MEM_REF
);
6029 if (mem_ref_offset (base
).to_shwi (&moffset
))
6032 if (wi::to_poly_wide (TREE_OPERAND (base
, 0)).to_shwi (&moffset
))
6035 *orig_t
= build_int_cst (TREE_TYPE (*orig_t
), coffset
);
6042 /* Canonicalize TARGET_MEM_REF in particular with respect to
6043 the indexes becoming constant. */
6044 else if (TREE_CODE (*t
) == TARGET_MEM_REF
)
6046 tree tem
= maybe_fold_tmr (*t
);
6050 if (TREE_CODE (*orig_t
) == ADDR_EXPR
)
6051 recompute_tree_invariant_for_addr_expr (*orig_t
);
6059 /* Worker for both fold_stmt and fold_stmt_inplace. The INPLACE argument
6060 distinguishes both cases. */
6063 fold_stmt_1 (gimple_stmt_iterator
*gsi
, bool inplace
, tree (*valueize
) (tree
))
6065 bool changed
= false;
6066 gimple
*stmt
= gsi_stmt (*gsi
);
6067 bool nowarning
= warning_suppressed_p (stmt
, OPT_Wstrict_overflow
);
6069 fold_defer_overflow_warnings ();
6071 /* First do required canonicalization of [TARGET_]MEM_REF addresses
6073 ??? This shouldn't be done in generic folding but in the
6074 propagation helpers which also know whether an address was
6076 Also canonicalize operand order. */
6077 switch (gimple_code (stmt
))
6080 if (gimple_assign_rhs_class (stmt
) == GIMPLE_SINGLE_RHS
)
6082 tree
*rhs
= gimple_assign_rhs1_ptr (stmt
);
6083 if ((REFERENCE_CLASS_P (*rhs
)
6084 || TREE_CODE (*rhs
) == ADDR_EXPR
)
6085 && maybe_canonicalize_mem_ref_addr (rhs
))
6087 tree
*lhs
= gimple_assign_lhs_ptr (stmt
);
6088 if (REFERENCE_CLASS_P (*lhs
)
6089 && maybe_canonicalize_mem_ref_addr (lhs
))
6094 /* Canonicalize operand order. */
6095 enum tree_code code
= gimple_assign_rhs_code (stmt
);
6096 if (TREE_CODE_CLASS (code
) == tcc_comparison
6097 || commutative_tree_code (code
)
6098 || commutative_ternary_tree_code (code
))
6100 tree rhs1
= gimple_assign_rhs1 (stmt
);
6101 tree rhs2
= gimple_assign_rhs2 (stmt
);
6102 if (tree_swap_operands_p (rhs1
, rhs2
))
6104 gimple_assign_set_rhs1 (stmt
, rhs2
);
6105 gimple_assign_set_rhs2 (stmt
, rhs1
);
6106 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
6107 gimple_assign_set_rhs_code (stmt
,
6108 swap_tree_comparison (code
));
6116 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
6118 tree
*arg
= gimple_call_arg_ptr (stmt
, i
);
6119 if (REFERENCE_CLASS_P (*arg
)
6120 && maybe_canonicalize_mem_ref_addr (arg
))
6123 tree
*lhs
= gimple_call_lhs_ptr (stmt
);
6125 && REFERENCE_CLASS_P (*lhs
)
6126 && maybe_canonicalize_mem_ref_addr (lhs
))
6132 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
6133 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
6135 tree link
= gimple_asm_output_op (asm_stmt
, i
);
6136 tree op
= TREE_VALUE (link
);
6137 if (REFERENCE_CLASS_P (op
)
6138 && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link
)))
6141 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
6143 tree link
= gimple_asm_input_op (asm_stmt
, i
);
6144 tree op
= TREE_VALUE (link
);
6145 if ((REFERENCE_CLASS_P (op
)
6146 || TREE_CODE (op
) == ADDR_EXPR
)
6147 && maybe_canonicalize_mem_ref_addr (&TREE_VALUE (link
)))
6153 if (gimple_debug_bind_p (stmt
))
6155 tree
*val
= gimple_debug_bind_get_value_ptr (stmt
);
6157 && (REFERENCE_CLASS_P (*val
)
6158 || TREE_CODE (*val
) == ADDR_EXPR
)
6159 && maybe_canonicalize_mem_ref_addr (val
, true))
6165 /* Canonicalize operand order. */
6166 tree lhs
= gimple_cond_lhs (stmt
);
6167 tree rhs
= gimple_cond_rhs (stmt
);
6168 if (tree_swap_operands_p (lhs
, rhs
))
6170 gcond
*gc
= as_a
<gcond
*> (stmt
);
6171 gimple_cond_set_lhs (gc
, rhs
);
6172 gimple_cond_set_rhs (gc
, lhs
);
6173 gimple_cond_set_code (gc
,
6174 swap_tree_comparison (gimple_cond_code (gc
)));
6181 /* Dispatch to pattern-based folding. */
6183 || is_gimple_assign (stmt
)
6184 || gimple_code (stmt
) == GIMPLE_COND
)
6186 gimple_seq seq
= NULL
;
6187 gimple_match_op res_op
;
6188 if (gimple_simplify (stmt
, &res_op
, inplace
? NULL
: &seq
,
6189 valueize
, valueize
))
6191 if (replace_stmt_with_simplification (gsi
, &res_op
, &seq
, inplace
))
6194 gimple_seq_discard (seq
);
6198 stmt
= gsi_stmt (*gsi
);
6200 /* Fold the main computation performed by the statement. */
6201 switch (gimple_code (stmt
))
6205 /* Try to canonicalize for boolean-typed X the comparisons
6206 X == 0, X == 1, X != 0, and X != 1. */
6207 if (gimple_assign_rhs_code (stmt
) == EQ_EXPR
6208 || gimple_assign_rhs_code (stmt
) == NE_EXPR
)
6210 tree lhs
= gimple_assign_lhs (stmt
);
6211 tree op1
= gimple_assign_rhs1 (stmt
);
6212 tree op2
= gimple_assign_rhs2 (stmt
);
6213 tree type
= TREE_TYPE (op1
);
6215 /* Check whether the comparison operands are of the same boolean
6216 type as the result type is.
6217 Check that second operand is an integer-constant with value
6219 if (TREE_CODE (op2
) == INTEGER_CST
6220 && (integer_zerop (op2
) || integer_onep (op2
))
6221 && useless_type_conversion_p (TREE_TYPE (lhs
), type
))
6223 enum tree_code cmp_code
= gimple_assign_rhs_code (stmt
);
6224 bool is_logical_not
= false;
6226 /* X == 0 and X != 1 is a logical-not.of X
6227 X == 1 and X != 0 is X */
6228 if ((cmp_code
== EQ_EXPR
&& integer_zerop (op2
))
6229 || (cmp_code
== NE_EXPR
&& integer_onep (op2
)))
6230 is_logical_not
= true;
6232 if (is_logical_not
== false)
6233 gimple_assign_set_rhs_with_ops (gsi
, TREE_CODE (op1
), op1
);
6234 /* Only for one-bit precision typed X the transformation
6235 !X -> ~X is valied. */
6236 else if (TYPE_PRECISION (type
) == 1)
6237 gimple_assign_set_rhs_with_ops (gsi
, BIT_NOT_EXPR
, op1
);
6238 /* Otherwise we use !X -> X ^ 1. */
6240 gimple_assign_set_rhs_with_ops (gsi
, BIT_XOR_EXPR
, op1
,
6241 build_int_cst (type
, 1));
6247 unsigned old_num_ops
= gimple_num_ops (stmt
);
6248 tree lhs
= gimple_assign_lhs (stmt
);
6249 tree new_rhs
= fold_gimple_assign (gsi
);
6251 && !useless_type_conversion_p (TREE_TYPE (lhs
),
6252 TREE_TYPE (new_rhs
)))
6253 new_rhs
= fold_convert (TREE_TYPE (lhs
), new_rhs
);
6256 || get_gimple_rhs_num_ops (TREE_CODE (new_rhs
)) < old_num_ops
))
6258 gimple_assign_set_rhs_from_tree (gsi
, new_rhs
);
6265 changed
|= gimple_fold_call (gsi
, inplace
);
6269 if (gimple_debug_bind_p (stmt
))
6271 tree val
= gimple_debug_bind_get_value (stmt
);
6273 && REFERENCE_CLASS_P (val
))
6275 tree tem
= maybe_fold_reference (val
);
6278 gimple_debug_bind_set_value (stmt
, tem
);
6283 && TREE_CODE (val
) == ADDR_EXPR
)
6285 tree ref
= TREE_OPERAND (val
, 0);
6286 tree tem
= maybe_fold_reference (ref
);
6289 tem
= build_fold_addr_expr_with_type (tem
, TREE_TYPE (val
));
6290 gimple_debug_bind_set_value (stmt
, tem
);
6299 greturn
*ret_stmt
= as_a
<greturn
*> (stmt
);
6300 tree ret
= gimple_return_retval(ret_stmt
);
6302 if (ret
&& TREE_CODE (ret
) == SSA_NAME
&& valueize
)
6304 tree val
= valueize (ret
);
6305 if (val
&& val
!= ret
6306 && may_propagate_copy (ret
, val
))
6308 gimple_return_set_retval (ret_stmt
, val
);
6318 stmt
= gsi_stmt (*gsi
);
6320 fold_undefer_overflow_warnings (changed
&& !nowarning
, stmt
, 0);
6324 /* Valueziation callback that ends up not following SSA edges. */
6327 no_follow_ssa_edges (tree
)
6332 /* Valueization callback that ends up following single-use SSA edges only. */
6335 follow_single_use_edges (tree val
)
6337 if (TREE_CODE (val
) == SSA_NAME
6338 && !has_single_use (val
))
6343 /* Valueization callback that follows all SSA edges. */
6346 follow_all_ssa_edges (tree val
)
6351 /* Fold the statement pointed to by GSI. In some cases, this function may
6352 replace the whole statement with a new one. Returns true iff folding
6354 The statement pointed to by GSI should be in valid gimple form but may
6355 be in unfolded state as resulting from for example constant propagation
6356 which can produce *&x = 0. */
6359 fold_stmt (gimple_stmt_iterator
*gsi
)
6361 return fold_stmt_1 (gsi
, false, no_follow_ssa_edges
);
6365 fold_stmt (gimple_stmt_iterator
*gsi
, tree (*valueize
) (tree
))
6367 return fold_stmt_1 (gsi
, false, valueize
);
6370 /* Perform the minimal folding on statement *GSI. Only operations like
6371 *&x created by constant propagation are handled. The statement cannot
6372 be replaced with a new one. Return true if the statement was
6373 changed, false otherwise.
6374 The statement *GSI should be in valid gimple form but may
6375 be in unfolded state as resulting from for example constant propagation
6376 which can produce *&x = 0. */
6379 fold_stmt_inplace (gimple_stmt_iterator
*gsi
)
6381 gimple
*stmt
= gsi_stmt (*gsi
);
6382 bool changed
= fold_stmt_1 (gsi
, true, no_follow_ssa_edges
);
6383 gcc_assert (gsi_stmt (*gsi
) == stmt
);
6387 /* Canonicalize and possibly invert the boolean EXPR; return NULL_TREE
6388 if EXPR is null or we don't know how.
6389 If non-null, the result always has boolean type. */
6392 canonicalize_bool (tree expr
, bool invert
)
6398 if (integer_nonzerop (expr
))
6399 return boolean_false_node
;
6400 else if (integer_zerop (expr
))
6401 return boolean_true_node
;
6402 else if (TREE_CODE (expr
) == SSA_NAME
)
6403 return fold_build2 (EQ_EXPR
, boolean_type_node
, expr
,
6404 build_int_cst (TREE_TYPE (expr
), 0));
6405 else if (COMPARISON_CLASS_P (expr
))
6406 return fold_build2 (invert_tree_comparison (TREE_CODE (expr
), false),
6408 TREE_OPERAND (expr
, 0),
6409 TREE_OPERAND (expr
, 1));
6415 if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
)
6417 if (integer_nonzerop (expr
))
6418 return boolean_true_node
;
6419 else if (integer_zerop (expr
))
6420 return boolean_false_node
;
6421 else if (TREE_CODE (expr
) == SSA_NAME
)
6422 return fold_build2 (NE_EXPR
, boolean_type_node
, expr
,
6423 build_int_cst (TREE_TYPE (expr
), 0));
6424 else if (COMPARISON_CLASS_P (expr
))
6425 return fold_build2 (TREE_CODE (expr
),
6427 TREE_OPERAND (expr
, 0),
6428 TREE_OPERAND (expr
, 1));
6434 /* Check to see if a boolean expression EXPR is logically equivalent to the
6435 comparison (OP1 CODE OP2). Check for various identities involving
6439 same_bool_comparison_p (const_tree expr
, enum tree_code code
,
6440 const_tree op1
, const_tree op2
)
6444 /* The obvious case. */
6445 if (TREE_CODE (expr
) == code
6446 && operand_equal_p (TREE_OPERAND (expr
, 0), op1
, 0)
6447 && operand_equal_p (TREE_OPERAND (expr
, 1), op2
, 0))
6450 /* Check for comparing (name, name != 0) and the case where expr
6451 is an SSA_NAME with a definition matching the comparison. */
6452 if (TREE_CODE (expr
) == SSA_NAME
6453 && TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
)
6455 if (operand_equal_p (expr
, op1
, 0))
6456 return ((code
== NE_EXPR
&& integer_zerop (op2
))
6457 || (code
== EQ_EXPR
&& integer_nonzerop (op2
)));
6458 s
= SSA_NAME_DEF_STMT (expr
);
6459 if (is_gimple_assign (s
)
6460 && gimple_assign_rhs_code (s
) == code
6461 && operand_equal_p (gimple_assign_rhs1 (s
), op1
, 0)
6462 && operand_equal_p (gimple_assign_rhs2 (s
), op2
, 0))
6466 /* If op1 is of the form (name != 0) or (name == 0), and the definition
6467 of name is a comparison, recurse. */
6468 if (TREE_CODE (op1
) == SSA_NAME
6469 && TREE_CODE (TREE_TYPE (op1
)) == BOOLEAN_TYPE
)
6471 s
= SSA_NAME_DEF_STMT (op1
);
6472 if (is_gimple_assign (s
)
6473 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
)
6475 enum tree_code c
= gimple_assign_rhs_code (s
);
6476 if ((c
== NE_EXPR
&& integer_zerop (op2
))
6477 || (c
== EQ_EXPR
&& integer_nonzerop (op2
)))
6478 return same_bool_comparison_p (expr
, c
,
6479 gimple_assign_rhs1 (s
),
6480 gimple_assign_rhs2 (s
));
6481 if ((c
== EQ_EXPR
&& integer_zerop (op2
))
6482 || (c
== NE_EXPR
&& integer_nonzerop (op2
)))
6483 return same_bool_comparison_p (expr
,
6484 invert_tree_comparison (c
, false),
6485 gimple_assign_rhs1 (s
),
6486 gimple_assign_rhs2 (s
));
6492 /* Check to see if two boolean expressions OP1 and OP2 are logically
6496 same_bool_result_p (const_tree op1
, const_tree op2
)
6498 /* Simple cases first. */
6499 if (operand_equal_p (op1
, op2
, 0))
6502 /* Check the cases where at least one of the operands is a comparison.
6503 These are a bit smarter than operand_equal_p in that they apply some
6504 identifies on SSA_NAMEs. */
6505 if (COMPARISON_CLASS_P (op2
)
6506 && same_bool_comparison_p (op1
, TREE_CODE (op2
),
6507 TREE_OPERAND (op2
, 0),
6508 TREE_OPERAND (op2
, 1)))
6510 if (COMPARISON_CLASS_P (op1
)
6511 && same_bool_comparison_p (op2
, TREE_CODE (op1
),
6512 TREE_OPERAND (op1
, 0),
6513 TREE_OPERAND (op1
, 1)))
6520 /* Forward declarations for some mutually recursive functions. */
6523 and_comparisons_1 (tree type
, enum tree_code code1
, tree op1a
, tree op1b
,
6524 enum tree_code code2
, tree op2a
, tree op2b
);
6526 and_var_with_comparison (tree type
, tree var
, bool invert
,
6527 enum tree_code code2
, tree op2a
, tree op2b
);
6529 and_var_with_comparison_1 (tree type
, gimple
*stmt
,
6530 enum tree_code code2
, tree op2a
, tree op2b
);
6532 or_comparisons_1 (tree
, enum tree_code code1
, tree op1a
, tree op1b
,
6533 enum tree_code code2
, tree op2a
, tree op2b
);
6535 or_var_with_comparison (tree
, tree var
, bool invert
,
6536 enum tree_code code2
, tree op2a
, tree op2b
);
6538 or_var_with_comparison_1 (tree
, gimple
*stmt
,
6539 enum tree_code code2
, tree op2a
, tree op2b
);
6541 /* Helper function for and_comparisons_1: try to simplify the AND of the
6542 ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
6543 If INVERT is true, invert the value of the VAR before doing the AND.
6544 Return NULL_EXPR if we can't simplify this to a single expression. */
6547 and_var_with_comparison (tree type
, tree var
, bool invert
,
6548 enum tree_code code2
, tree op2a
, tree op2b
)
6551 gimple
*stmt
= SSA_NAME_DEF_STMT (var
);
6553 /* We can only deal with variables whose definitions are assignments. */
6554 if (!is_gimple_assign (stmt
))
6557 /* If we have an inverted comparison, apply DeMorgan's law and rewrite
6558 !var AND (op2a code2 op2b) => !(var OR !(op2a code2 op2b))
6559 Then we only have to consider the simpler non-inverted cases. */
6561 t
= or_var_with_comparison_1 (type
, stmt
,
6562 invert_tree_comparison (code2
, false),
6565 t
= and_var_with_comparison_1 (type
, stmt
, code2
, op2a
, op2b
);
6566 return canonicalize_bool (t
, invert
);
6569 /* Try to simplify the AND of the ssa variable defined by the assignment
6570 STMT with the comparison specified by (OP2A CODE2 OP2B).
6571 Return NULL_EXPR if we can't simplify this to a single expression. */
6574 and_var_with_comparison_1 (tree type
, gimple
*stmt
,
6575 enum tree_code code2
, tree op2a
, tree op2b
)
6577 tree var
= gimple_assign_lhs (stmt
);
6578 tree true_test_var
= NULL_TREE
;
6579 tree false_test_var
= NULL_TREE
;
6580 enum tree_code innercode
= gimple_assign_rhs_code (stmt
);
6582 /* Check for identities like (var AND (var == 0)) => false. */
6583 if (TREE_CODE (op2a
) == SSA_NAME
6584 && TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
)
6586 if ((code2
== NE_EXPR
&& integer_zerop (op2b
))
6587 || (code2
== EQ_EXPR
&& integer_nonzerop (op2b
)))
6589 true_test_var
= op2a
;
6590 if (var
== true_test_var
)
6593 else if ((code2
== EQ_EXPR
&& integer_zerop (op2b
))
6594 || (code2
== NE_EXPR
&& integer_nonzerop (op2b
)))
6596 false_test_var
= op2a
;
6597 if (var
== false_test_var
)
6598 return boolean_false_node
;
6602 /* If the definition is a comparison, recurse on it. */
6603 if (TREE_CODE_CLASS (innercode
) == tcc_comparison
)
6605 tree t
= and_comparisons_1 (type
, innercode
,
6606 gimple_assign_rhs1 (stmt
),
6607 gimple_assign_rhs2 (stmt
),
6615 /* If the definition is an AND or OR expression, we may be able to
6616 simplify by reassociating. */
6617 if (TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
6618 && (innercode
== BIT_AND_EXPR
|| innercode
== BIT_IOR_EXPR
))
6620 tree inner1
= gimple_assign_rhs1 (stmt
);
6621 tree inner2
= gimple_assign_rhs2 (stmt
);
6624 tree partial
= NULL_TREE
;
6625 bool is_and
= (innercode
== BIT_AND_EXPR
);
6627 /* Check for boolean identities that don't require recursive examination
6629 inner1 AND (inner1 AND inner2) => inner1 AND inner2 => var
6630 inner1 AND (inner1 OR inner2) => inner1
6631 !inner1 AND (inner1 AND inner2) => false
6632 !inner1 AND (inner1 OR inner2) => !inner1 AND inner2
6633 Likewise for similar cases involving inner2. */
6634 if (inner1
== true_test_var
)
6635 return (is_and
? var
: inner1
);
6636 else if (inner2
== true_test_var
)
6637 return (is_and
? var
: inner2
);
6638 else if (inner1
== false_test_var
)
6640 ? boolean_false_node
6641 : and_var_with_comparison (type
, inner2
, false, code2
, op2a
,
6643 else if (inner2
== false_test_var
)
6645 ? boolean_false_node
6646 : and_var_with_comparison (type
, inner1
, false, code2
, op2a
,
6649 /* Next, redistribute/reassociate the AND across the inner tests.
6650 Compute the first partial result, (inner1 AND (op2a code op2b)) */
6651 if (TREE_CODE (inner1
) == SSA_NAME
6652 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner1
))
6653 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
6654 && (t
= maybe_fold_and_comparisons (type
, gimple_assign_rhs_code (s
),
6655 gimple_assign_rhs1 (s
),
6656 gimple_assign_rhs2 (s
),
6657 code2
, op2a
, op2b
)))
6659 /* Handle the AND case, where we are reassociating:
6660 (inner1 AND inner2) AND (op2a code2 op2b)
6662 If the partial result t is a constant, we win. Otherwise
6663 continue on to try reassociating with the other inner test. */
6666 if (integer_onep (t
))
6668 else if (integer_zerop (t
))
6669 return boolean_false_node
;
6672 /* Handle the OR case, where we are redistributing:
6673 (inner1 OR inner2) AND (op2a code2 op2b)
6674 => (t OR (inner2 AND (op2a code2 op2b))) */
6675 else if (integer_onep (t
))
6676 return boolean_true_node
;
6678 /* Save partial result for later. */
6682 /* Compute the second partial result, (inner2 AND (op2a code op2b)) */
6683 if (TREE_CODE (inner2
) == SSA_NAME
6684 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner2
))
6685 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
6686 && (t
= maybe_fold_and_comparisons (type
, gimple_assign_rhs_code (s
),
6687 gimple_assign_rhs1 (s
),
6688 gimple_assign_rhs2 (s
),
6689 code2
, op2a
, op2b
)))
6691 /* Handle the AND case, where we are reassociating:
6692 (inner1 AND inner2) AND (op2a code2 op2b)
6693 => (inner1 AND t) */
6696 if (integer_onep (t
))
6698 else if (integer_zerop (t
))
6699 return boolean_false_node
;
6700 /* If both are the same, we can apply the identity
6702 else if (partial
&& same_bool_result_p (t
, partial
))
6706 /* Handle the OR case. where we are redistributing:
6707 (inner1 OR inner2) AND (op2a code2 op2b)
6708 => (t OR (inner1 AND (op2a code2 op2b)))
6709 => (t OR partial) */
6712 if (integer_onep (t
))
6713 return boolean_true_node
;
6716 /* We already got a simplification for the other
6717 operand to the redistributed OR expression. The
6718 interesting case is when at least one is false.
6719 Or, if both are the same, we can apply the identity
6721 if (integer_zerop (partial
))
6723 else if (integer_zerop (t
))
6725 else if (same_bool_result_p (t
, partial
))
6734 /* Try to simplify the AND of two comparisons defined by
6735 (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
6736 If this can be done without constructing an intermediate value,
6737 return the resulting tree; otherwise NULL_TREE is returned.
6738 This function is deliberately asymmetric as it recurses on SSA_DEFs
6739 in the first comparison but not the second. */
6742 and_comparisons_1 (tree type
, enum tree_code code1
, tree op1a
, tree op1b
,
6743 enum tree_code code2
, tree op2a
, tree op2b
)
6745 tree truth_type
= truth_type_for (TREE_TYPE (op1a
));
6747 /* First check for ((x CODE1 y) AND (x CODE2 y)). */
6748 if (operand_equal_p (op1a
, op2a
, 0)
6749 && operand_equal_p (op1b
, op2b
, 0))
6751 /* Result will be either NULL_TREE, or a combined comparison. */
6752 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
6753 TRUTH_ANDIF_EXPR
, code1
, code2
,
6754 truth_type
, op1a
, op1b
);
6759 /* Likewise the swapped case of the above. */
6760 if (operand_equal_p (op1a
, op2b
, 0)
6761 && operand_equal_p (op1b
, op2a
, 0))
6763 /* Result will be either NULL_TREE, or a combined comparison. */
6764 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
6765 TRUTH_ANDIF_EXPR
, code1
,
6766 swap_tree_comparison (code2
),
6767 truth_type
, op1a
, op1b
);
6772 /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
6773 NAME's definition is a truth value. See if there are any simplifications
6774 that can be done against the NAME's definition. */
6775 if (TREE_CODE (op1a
) == SSA_NAME
6776 && (code1
== NE_EXPR
|| code1
== EQ_EXPR
)
6777 && (integer_zerop (op1b
) || integer_onep (op1b
)))
6779 bool invert
= ((code1
== EQ_EXPR
&& integer_zerop (op1b
))
6780 || (code1
== NE_EXPR
&& integer_onep (op1b
)));
6781 gimple
*stmt
= SSA_NAME_DEF_STMT (op1a
);
6782 switch (gimple_code (stmt
))
6785 /* Try to simplify by copy-propagating the definition. */
6786 return and_var_with_comparison (type
, op1a
, invert
, code2
, op2a
,
6790 /* If every argument to the PHI produces the same result when
6791 ANDed with the second comparison, we win.
6792 Do not do this unless the type is bool since we need a bool
6793 result here anyway. */
6794 if (TREE_CODE (TREE_TYPE (op1a
)) == BOOLEAN_TYPE
)
6796 tree result
= NULL_TREE
;
6798 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
6800 tree arg
= gimple_phi_arg_def (stmt
, i
);
6802 /* If this PHI has itself as an argument, ignore it.
6803 If all the other args produce the same result,
6805 if (arg
== gimple_phi_result (stmt
))
6807 else if (TREE_CODE (arg
) == INTEGER_CST
)
6809 if (invert
? integer_nonzerop (arg
) : integer_zerop (arg
))
6812 result
= boolean_false_node
;
6813 else if (!integer_zerop (result
))
6817 result
= fold_build2 (code2
, boolean_type_node
,
6819 else if (!same_bool_comparison_p (result
,
6823 else if (TREE_CODE (arg
) == SSA_NAME
6824 && !SSA_NAME_IS_DEFAULT_DEF (arg
))
6827 gimple
*def_stmt
= SSA_NAME_DEF_STMT (arg
);
6828 /* In simple cases we can look through PHI nodes,
6829 but we have to be careful with loops.
6831 if (! dom_info_available_p (CDI_DOMINATORS
)
6832 || gimple_bb (def_stmt
) == gimple_bb (stmt
)
6833 || dominated_by_p (CDI_DOMINATORS
,
6834 gimple_bb (def_stmt
),
6837 temp
= and_var_with_comparison (type
, arg
, invert
, code2
,
6843 else if (!same_bool_result_p (result
, temp
))
6859 /* Helper function for maybe_fold_and_comparisons and maybe_fold_or_comparisons
6860 : try to simplify the AND/OR of the ssa variable VAR with the comparison
6861 specified by (OP2A CODE2 OP2B) from match.pd. Return NULL_EXPR if we can't
6862 simplify this to a single expression. As we are going to lower the cost
6863 of building SSA names / gimple stmts significantly, we need to allocate
6864 them ont the stack. This will cause the code to be a bit ugly. */
6867 maybe_fold_comparisons_from_match_pd (tree type
, enum tree_code code
,
6868 enum tree_code code1
,
6869 tree op1a
, tree op1b
,
6870 enum tree_code code2
, tree op2a
,
6873 /* Allocate gimple stmt1 on the stack. */
6875 = (gassign
*) XALLOCAVEC (char, gimple_size (GIMPLE_ASSIGN
, 3));
6876 gimple_init (stmt1
, GIMPLE_ASSIGN
, 3);
6877 gimple_assign_set_rhs_code (stmt1
, code1
);
6878 gimple_assign_set_rhs1 (stmt1
, op1a
);
6879 gimple_assign_set_rhs2 (stmt1
, op1b
);
6881 /* Allocate gimple stmt2 on the stack. */
6883 = (gassign
*) XALLOCAVEC (char, gimple_size (GIMPLE_ASSIGN
, 3));
6884 gimple_init (stmt2
, GIMPLE_ASSIGN
, 3);
6885 gimple_assign_set_rhs_code (stmt2
, code2
);
6886 gimple_assign_set_rhs1 (stmt2
, op2a
);
6887 gimple_assign_set_rhs2 (stmt2
, op2b
);
6889 /* Allocate SSA names(lhs1) on the stack. */
6890 tree lhs1
= (tree
)XALLOCA (tree_ssa_name
);
6891 memset (lhs1
, 0, sizeof (tree_ssa_name
));
6892 TREE_SET_CODE (lhs1
, SSA_NAME
);
6893 TREE_TYPE (lhs1
) = type
;
6894 init_ssa_name_imm_use (lhs1
);
6896 /* Allocate SSA names(lhs2) on the stack. */
6897 tree lhs2
= (tree
)XALLOCA (tree_ssa_name
);
6898 memset (lhs2
, 0, sizeof (tree_ssa_name
));
6899 TREE_SET_CODE (lhs2
, SSA_NAME
);
6900 TREE_TYPE (lhs2
) = type
;
6901 init_ssa_name_imm_use (lhs2
);
6903 gimple_assign_set_lhs (stmt1
, lhs1
);
6904 gimple_assign_set_lhs (stmt2
, lhs2
);
6906 gimple_match_op
op (gimple_match_cond::UNCOND
, code
,
6907 type
, gimple_assign_lhs (stmt1
),
6908 gimple_assign_lhs (stmt2
));
6909 if (op
.resimplify (NULL
, follow_all_ssa_edges
))
6911 if (gimple_simplified_result_is_gimple_val (&op
))
6913 tree res
= op
.ops
[0];
6915 return build2 (code1
, type
, op1a
, op1b
);
6916 else if (res
== lhs2
)
6917 return build2 (code2
, type
, op2a
, op2b
);
6921 else if (op
.code
.is_tree_code ()
6922 && TREE_CODE_CLASS ((tree_code
)op
.code
) == tcc_comparison
)
6924 tree op0
= op
.ops
[0];
6925 tree op1
= op
.ops
[1];
6926 if (op0
== lhs1
|| op0
== lhs2
|| op1
== lhs1
|| op1
== lhs2
)
6927 return NULL_TREE
; /* not simple */
6929 return build2 ((enum tree_code
)op
.code
, op
.type
, op0
, op1
);
6936 /* Try to simplify the AND of two comparisons, specified by
6937 (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
6938 If this can be simplified to a single expression (without requiring
6939 introducing more SSA variables to hold intermediate values),
6940 return the resulting tree. Otherwise return NULL_TREE.
6941 If the result expression is non-null, it has boolean type. */
6944 maybe_fold_and_comparisons (tree type
,
6945 enum tree_code code1
, tree op1a
, tree op1b
,
6946 enum tree_code code2
, tree op2a
, tree op2b
)
6948 if (tree t
= and_comparisons_1 (type
, code1
, op1a
, op1b
, code2
, op2a
, op2b
))
6951 if (tree t
= and_comparisons_1 (type
, code2
, op2a
, op2b
, code1
, op1a
, op1b
))
6954 if (tree t
= maybe_fold_comparisons_from_match_pd (type
, BIT_AND_EXPR
, code1
,
6955 op1a
, op1b
, code2
, op2a
,
6962 /* Helper function for or_comparisons_1: try to simplify the OR of the
6963 ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
6964 If INVERT is true, invert the value of VAR before doing the OR.
6965 Return NULL_EXPR if we can't simplify this to a single expression. */
6968 or_var_with_comparison (tree type
, tree var
, bool invert
,
6969 enum tree_code code2
, tree op2a
, tree op2b
)
6972 gimple
*stmt
= SSA_NAME_DEF_STMT (var
);
6974 /* We can only deal with variables whose definitions are assignments. */
6975 if (!is_gimple_assign (stmt
))
6978 /* If we have an inverted comparison, apply DeMorgan's law and rewrite
6979 !var OR (op2a code2 op2b) => !(var AND !(op2a code2 op2b))
6980 Then we only have to consider the simpler non-inverted cases. */
6982 t
= and_var_with_comparison_1 (type
, stmt
,
6983 invert_tree_comparison (code2
, false),
6986 t
= or_var_with_comparison_1 (type
, stmt
, code2
, op2a
, op2b
);
6987 return canonicalize_bool (t
, invert
);
6990 /* Try to simplify the OR of the ssa variable defined by the assignment
6991 STMT with the comparison specified by (OP2A CODE2 OP2B).
6992 Return NULL_EXPR if we can't simplify this to a single expression. */
6995 or_var_with_comparison_1 (tree type
, gimple
*stmt
,
6996 enum tree_code code2
, tree op2a
, tree op2b
)
6998 tree var
= gimple_assign_lhs (stmt
);
6999 tree true_test_var
= NULL_TREE
;
7000 tree false_test_var
= NULL_TREE
;
7001 enum tree_code innercode
= gimple_assign_rhs_code (stmt
);
7003 /* Check for identities like (var OR (var != 0)) => true . */
7004 if (TREE_CODE (op2a
) == SSA_NAME
7005 && TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
)
7007 if ((code2
== NE_EXPR
&& integer_zerop (op2b
))
7008 || (code2
== EQ_EXPR
&& integer_nonzerop (op2b
)))
7010 true_test_var
= op2a
;
7011 if (var
== true_test_var
)
7014 else if ((code2
== EQ_EXPR
&& integer_zerop (op2b
))
7015 || (code2
== NE_EXPR
&& integer_nonzerop (op2b
)))
7017 false_test_var
= op2a
;
7018 if (var
== false_test_var
)
7019 return boolean_true_node
;
7023 /* If the definition is a comparison, recurse on it. */
7024 if (TREE_CODE_CLASS (innercode
) == tcc_comparison
)
7026 tree t
= or_comparisons_1 (type
, innercode
,
7027 gimple_assign_rhs1 (stmt
),
7028 gimple_assign_rhs2 (stmt
),
7036 /* If the definition is an AND or OR expression, we may be able to
7037 simplify by reassociating. */
7038 if (TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
7039 && (innercode
== BIT_AND_EXPR
|| innercode
== BIT_IOR_EXPR
))
7041 tree inner1
= gimple_assign_rhs1 (stmt
);
7042 tree inner2
= gimple_assign_rhs2 (stmt
);
7045 tree partial
= NULL_TREE
;
7046 bool is_or
= (innercode
== BIT_IOR_EXPR
);
7048 /* Check for boolean identities that don't require recursive examination
7050 inner1 OR (inner1 OR inner2) => inner1 OR inner2 => var
7051 inner1 OR (inner1 AND inner2) => inner1
7052 !inner1 OR (inner1 OR inner2) => true
7053 !inner1 OR (inner1 AND inner2) => !inner1 OR inner2
7055 if (inner1
== true_test_var
)
7056 return (is_or
? var
: inner1
);
7057 else if (inner2
== true_test_var
)
7058 return (is_or
? var
: inner2
);
7059 else if (inner1
== false_test_var
)
7062 : or_var_with_comparison (type
, inner2
, false, code2
, op2a
,
7064 else if (inner2
== false_test_var
)
7067 : or_var_with_comparison (type
, inner1
, false, code2
, op2a
,
7070 /* Next, redistribute/reassociate the OR across the inner tests.
7071 Compute the first partial result, (inner1 OR (op2a code op2b)) */
7072 if (TREE_CODE (inner1
) == SSA_NAME
7073 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner1
))
7074 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
7075 && (t
= maybe_fold_or_comparisons (type
, gimple_assign_rhs_code (s
),
7076 gimple_assign_rhs1 (s
),
7077 gimple_assign_rhs2 (s
),
7078 code2
, op2a
, op2b
)))
7080 /* Handle the OR case, where we are reassociating:
7081 (inner1 OR inner2) OR (op2a code2 op2b)
7083 If the partial result t is a constant, we win. Otherwise
7084 continue on to try reassociating with the other inner test. */
7087 if (integer_onep (t
))
7088 return boolean_true_node
;
7089 else if (integer_zerop (t
))
7093 /* Handle the AND case, where we are redistributing:
7094 (inner1 AND inner2) OR (op2a code2 op2b)
7095 => (t AND (inner2 OR (op2a code op2b))) */
7096 else if (integer_zerop (t
))
7097 return boolean_false_node
;
7099 /* Save partial result for later. */
7103 /* Compute the second partial result, (inner2 OR (op2a code op2b)) */
7104 if (TREE_CODE (inner2
) == SSA_NAME
7105 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner2
))
7106 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
7107 && (t
= maybe_fold_or_comparisons (type
, gimple_assign_rhs_code (s
),
7108 gimple_assign_rhs1 (s
),
7109 gimple_assign_rhs2 (s
),
7110 code2
, op2a
, op2b
)))
7112 /* Handle the OR case, where we are reassociating:
7113 (inner1 OR inner2) OR (op2a code2 op2b)
7115 => (t OR partial) */
7118 if (integer_zerop (t
))
7120 else if (integer_onep (t
))
7121 return boolean_true_node
;
7122 /* If both are the same, we can apply the identity
7124 else if (partial
&& same_bool_result_p (t
, partial
))
7128 /* Handle the AND case, where we are redistributing:
7129 (inner1 AND inner2) OR (op2a code2 op2b)
7130 => (t AND (inner1 OR (op2a code2 op2b)))
7131 => (t AND partial) */
7134 if (integer_zerop (t
))
7135 return boolean_false_node
;
7138 /* We already got a simplification for the other
7139 operand to the redistributed AND expression. The
7140 interesting case is when at least one is true.
7141 Or, if both are the same, we can apply the identity
7143 if (integer_onep (partial
))
7145 else if (integer_onep (t
))
7147 else if (same_bool_result_p (t
, partial
))
7156 /* Try to simplify the OR of two comparisons defined by
7157 (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
7158 If this can be done without constructing an intermediate value,
7159 return the resulting tree; otherwise NULL_TREE is returned.
7160 This function is deliberately asymmetric as it recurses on SSA_DEFs
7161 in the first comparison but not the second. */
7164 or_comparisons_1 (tree type
, enum tree_code code1
, tree op1a
, tree op1b
,
7165 enum tree_code code2
, tree op2a
, tree op2b
)
7167 tree truth_type
= truth_type_for (TREE_TYPE (op1a
));
7169 /* First check for ((x CODE1 y) OR (x CODE2 y)). */
7170 if (operand_equal_p (op1a
, op2a
, 0)
7171 && operand_equal_p (op1b
, op2b
, 0))
7173 /* Result will be either NULL_TREE, or a combined comparison. */
7174 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
7175 TRUTH_ORIF_EXPR
, code1
, code2
,
7176 truth_type
, op1a
, op1b
);
7181 /* Likewise the swapped case of the above. */
7182 if (operand_equal_p (op1a
, op2b
, 0)
7183 && operand_equal_p (op1b
, op2a
, 0))
7185 /* Result will be either NULL_TREE, or a combined comparison. */
7186 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
7187 TRUTH_ORIF_EXPR
, code1
,
7188 swap_tree_comparison (code2
),
7189 truth_type
, op1a
, op1b
);
7194 /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
7195 NAME's definition is a truth value. See if there are any simplifications
7196 that can be done against the NAME's definition. */
7197 if (TREE_CODE (op1a
) == SSA_NAME
7198 && (code1
== NE_EXPR
|| code1
== EQ_EXPR
)
7199 && (integer_zerop (op1b
) || integer_onep (op1b
)))
7201 bool invert
= ((code1
== EQ_EXPR
&& integer_zerop (op1b
))
7202 || (code1
== NE_EXPR
&& integer_onep (op1b
)));
7203 gimple
*stmt
= SSA_NAME_DEF_STMT (op1a
);
7204 switch (gimple_code (stmt
))
7207 /* Try to simplify by copy-propagating the definition. */
7208 return or_var_with_comparison (type
, op1a
, invert
, code2
, op2a
,
7212 /* If every argument to the PHI produces the same result when
7213 ORed with the second comparison, we win.
7214 Do not do this unless the type is bool since we need a bool
7215 result here anyway. */
7216 if (TREE_CODE (TREE_TYPE (op1a
)) == BOOLEAN_TYPE
)
7218 tree result
= NULL_TREE
;
7220 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
7222 tree arg
= gimple_phi_arg_def (stmt
, i
);
7224 /* If this PHI has itself as an argument, ignore it.
7225 If all the other args produce the same result,
7227 if (arg
== gimple_phi_result (stmt
))
7229 else if (TREE_CODE (arg
) == INTEGER_CST
)
7231 if (invert
? integer_zerop (arg
) : integer_nonzerop (arg
))
7234 result
= boolean_true_node
;
7235 else if (!integer_onep (result
))
7239 result
= fold_build2 (code2
, boolean_type_node
,
7241 else if (!same_bool_comparison_p (result
,
7245 else if (TREE_CODE (arg
) == SSA_NAME
7246 && !SSA_NAME_IS_DEFAULT_DEF (arg
))
7249 gimple
*def_stmt
= SSA_NAME_DEF_STMT (arg
);
7250 /* In simple cases we can look through PHI nodes,
7251 but we have to be careful with loops.
7253 if (! dom_info_available_p (CDI_DOMINATORS
)
7254 || gimple_bb (def_stmt
) == gimple_bb (stmt
)
7255 || dominated_by_p (CDI_DOMINATORS
,
7256 gimple_bb (def_stmt
),
7259 temp
= or_var_with_comparison (type
, arg
, invert
, code2
,
7265 else if (!same_bool_result_p (result
, temp
))
7281 /* Try to simplify the OR of two comparisons, specified by
7282 (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
7283 If this can be simplified to a single expression (without requiring
7284 introducing more SSA variables to hold intermediate values),
7285 return the resulting tree. Otherwise return NULL_TREE.
7286 If the result expression is non-null, it has boolean type. */
7289 maybe_fold_or_comparisons (tree type
,
7290 enum tree_code code1
, tree op1a
, tree op1b
,
7291 enum tree_code code2
, tree op2a
, tree op2b
)
7293 if (tree t
= or_comparisons_1 (type
, code1
, op1a
, op1b
, code2
, op2a
, op2b
))
7296 if (tree t
= or_comparisons_1 (type
, code2
, op2a
, op2b
, code1
, op1a
, op1b
))
7299 if (tree t
= maybe_fold_comparisons_from_match_pd (type
, BIT_IOR_EXPR
, code1
,
7300 op1a
, op1b
, code2
, op2a
,
7307 /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
7309 Either NULL_TREE, a simplified but non-constant or a constant
7312 ??? This should go into a gimple-fold-inline.h file to be eventually
7313 privatized with the single valueize function used in the various TUs
7314 to avoid the indirect function call overhead. */
7317 gimple_fold_stmt_to_constant_1 (gimple
*stmt
, tree (*valueize
) (tree
),
7318 tree (*gvalueize
) (tree
))
7320 gimple_match_op res_op
;
7321 /* ??? The SSA propagators do not correctly deal with following SSA use-def
7322 edges if there are intermediate VARYING defs. For this reason
7323 do not follow SSA edges here even though SCCVN can technically
7324 just deal fine with that. */
7325 if (gimple_simplify (stmt
, &res_op
, NULL
, gvalueize
, valueize
))
7327 tree res
= NULL_TREE
;
7328 if (gimple_simplified_result_is_gimple_val (&res_op
))
7329 res
= res_op
.ops
[0];
7330 else if (mprts_hook
)
7331 res
= mprts_hook (&res_op
);
7334 if (dump_file
&& dump_flags
& TDF_DETAILS
)
7336 fprintf (dump_file
, "Match-and-simplified ");
7337 print_gimple_expr (dump_file
, stmt
, 0, TDF_SLIM
);
7338 fprintf (dump_file
, " to ");
7339 print_generic_expr (dump_file
, res
);
7340 fprintf (dump_file
, "\n");
7346 location_t loc
= gimple_location (stmt
);
7347 switch (gimple_code (stmt
))
7351 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
7353 switch (get_gimple_rhs_class (subcode
))
7355 case GIMPLE_SINGLE_RHS
:
7357 tree rhs
= gimple_assign_rhs1 (stmt
);
7358 enum tree_code_class kind
= TREE_CODE_CLASS (subcode
);
7360 if (TREE_CODE (rhs
) == SSA_NAME
)
7362 /* If the RHS is an SSA_NAME, return its known constant value,
7364 return (*valueize
) (rhs
);
7366 /* Handle propagating invariant addresses into address
7368 else if (TREE_CODE (rhs
) == ADDR_EXPR
7369 && !is_gimple_min_invariant (rhs
))
7371 poly_int64 offset
= 0;
7373 base
= get_addr_base_and_unit_offset_1 (TREE_OPERAND (rhs
, 0),
7377 && (CONSTANT_CLASS_P (base
)
7378 || decl_address_invariant_p (base
)))
7379 return build_invariant_address (TREE_TYPE (rhs
),
7382 else if (TREE_CODE (rhs
) == CONSTRUCTOR
7383 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
7384 && known_eq (CONSTRUCTOR_NELTS (rhs
),
7385 TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs
))))
7390 nelts
= CONSTRUCTOR_NELTS (rhs
);
7391 tree_vector_builder
vec (TREE_TYPE (rhs
), nelts
, 1);
7392 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
7394 val
= (*valueize
) (val
);
7395 if (TREE_CODE (val
) == INTEGER_CST
7396 || TREE_CODE (val
) == REAL_CST
7397 || TREE_CODE (val
) == FIXED_CST
)
7398 vec
.quick_push (val
);
7403 return vec
.build ();
7405 if (subcode
== OBJ_TYPE_REF
)
7407 tree val
= (*valueize
) (OBJ_TYPE_REF_EXPR (rhs
));
7408 /* If callee is constant, we can fold away the wrapper. */
7409 if (is_gimple_min_invariant (val
))
7413 if (kind
== tcc_reference
)
7415 if ((TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
7416 || TREE_CODE (rhs
) == REALPART_EXPR
7417 || TREE_CODE (rhs
) == IMAGPART_EXPR
)
7418 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
7420 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
7421 return fold_unary_loc (EXPR_LOCATION (rhs
),
7423 TREE_TYPE (rhs
), val
);
7425 else if (TREE_CODE (rhs
) == BIT_FIELD_REF
7426 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
7428 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
7429 return fold_ternary_loc (EXPR_LOCATION (rhs
),
7431 TREE_TYPE (rhs
), val
,
7432 TREE_OPERAND (rhs
, 1),
7433 TREE_OPERAND (rhs
, 2));
7435 else if (TREE_CODE (rhs
) == MEM_REF
7436 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
7438 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
7439 if (TREE_CODE (val
) == ADDR_EXPR
7440 && is_gimple_min_invariant (val
))
7442 tree tem
= fold_build2 (MEM_REF
, TREE_TYPE (rhs
),
7444 TREE_OPERAND (rhs
, 1));
7449 return fold_const_aggregate_ref_1 (rhs
, valueize
);
7451 else if (kind
== tcc_declaration
)
7452 return get_symbol_constant_value (rhs
);
7456 case GIMPLE_UNARY_RHS
:
7459 case GIMPLE_BINARY_RHS
:
7460 /* Translate &x + CST into an invariant form suitable for
7461 further propagation. */
7462 if (subcode
== POINTER_PLUS_EXPR
)
7464 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
7465 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
7466 if (TREE_CODE (op0
) == ADDR_EXPR
7467 && TREE_CODE (op1
) == INTEGER_CST
)
7469 tree off
= fold_convert (ptr_type_node
, op1
);
7471 (loc
, ADDR_EXPR
, TREE_TYPE (op0
),
7472 fold_build2 (MEM_REF
,
7473 TREE_TYPE (TREE_TYPE (op0
)),
7474 unshare_expr (op0
), off
));
7477 /* Canonicalize bool != 0 and bool == 0 appearing after
7478 valueization. While gimple_simplify handles this
7479 it can get confused by the ~X == 1 -> X == 0 transform
7480 which we cant reduce to a SSA name or a constant
7481 (and we have no way to tell gimple_simplify to not
7482 consider those transforms in the first place). */
7483 else if (subcode
== EQ_EXPR
7484 || subcode
== NE_EXPR
)
7486 tree lhs
= gimple_assign_lhs (stmt
);
7487 tree op0
= gimple_assign_rhs1 (stmt
);
7488 if (useless_type_conversion_p (TREE_TYPE (lhs
),
7491 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
7492 op0
= (*valueize
) (op0
);
7493 if (TREE_CODE (op0
) == INTEGER_CST
)
7494 std::swap (op0
, op1
);
7495 if (TREE_CODE (op1
) == INTEGER_CST
7496 && ((subcode
== NE_EXPR
&& integer_zerop (op1
))
7497 || (subcode
== EQ_EXPR
&& integer_onep (op1
))))
7503 case GIMPLE_TERNARY_RHS
:
7505 /* Handle ternary operators that can appear in GIMPLE form. */
7506 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
7507 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
7508 tree op2
= (*valueize
) (gimple_assign_rhs3 (stmt
));
7509 return fold_ternary_loc (loc
, subcode
,
7510 gimple_expr_type (stmt
), op0
, op1
, op2
);
7521 gcall
*call_stmt
= as_a
<gcall
*> (stmt
);
7523 if (gimple_call_internal_p (stmt
))
7525 enum tree_code subcode
= ERROR_MARK
;
7526 switch (gimple_call_internal_fn (stmt
))
7528 case IFN_UBSAN_CHECK_ADD
:
7529 subcode
= PLUS_EXPR
;
7531 case IFN_UBSAN_CHECK_SUB
:
7532 subcode
= MINUS_EXPR
;
7534 case IFN_UBSAN_CHECK_MUL
:
7535 subcode
= MULT_EXPR
;
7537 case IFN_BUILTIN_EXPECT
:
7539 tree arg0
= gimple_call_arg (stmt
, 0);
7540 tree op0
= (*valueize
) (arg0
);
7541 if (TREE_CODE (op0
) == INTEGER_CST
)
7548 tree arg0
= gimple_call_arg (stmt
, 0);
7549 tree arg1
= gimple_call_arg (stmt
, 1);
7550 tree op0
= (*valueize
) (arg0
);
7551 tree op1
= (*valueize
) (arg1
);
7553 if (TREE_CODE (op0
) != INTEGER_CST
7554 || TREE_CODE (op1
) != INTEGER_CST
)
7559 /* x * 0 = 0 * x = 0 without overflow. */
7560 if (integer_zerop (op0
) || integer_zerop (op1
))
7561 return build_zero_cst (TREE_TYPE (arg0
));
7564 /* y - y = 0 without overflow. */
7565 if (operand_equal_p (op0
, op1
, 0))
7566 return build_zero_cst (TREE_TYPE (arg0
));
7573 = fold_binary_loc (loc
, subcode
, TREE_TYPE (arg0
), op0
, op1
);
7575 && TREE_CODE (res
) == INTEGER_CST
7576 && !TREE_OVERFLOW (res
))
7581 fn
= (*valueize
) (gimple_call_fn (stmt
));
7582 if (TREE_CODE (fn
) == ADDR_EXPR
7583 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
7584 && fndecl_built_in_p (TREE_OPERAND (fn
, 0))
7585 && gimple_builtin_call_types_compatible_p (stmt
,
7586 TREE_OPERAND (fn
, 0)))
7588 tree
*args
= XALLOCAVEC (tree
, gimple_call_num_args (stmt
));
7591 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
7592 args
[i
] = (*valueize
) (gimple_call_arg (stmt
, i
));
7593 retval
= fold_builtin_call_array (loc
,
7594 gimple_call_return_type (call_stmt
),
7595 fn
, gimple_call_num_args (stmt
), args
);
7598 /* fold_call_expr wraps the result inside a NOP_EXPR. */
7599 STRIP_NOPS (retval
);
7600 retval
= fold_convert (gimple_call_return_type (call_stmt
),
7613 /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
7614 Returns NULL_TREE if folding to a constant is not possible, otherwise
7615 returns a constant according to is_gimple_min_invariant. */
7618 gimple_fold_stmt_to_constant (gimple
*stmt
, tree (*valueize
) (tree
))
7620 tree res
= gimple_fold_stmt_to_constant_1 (stmt
, valueize
);
7621 if (res
&& is_gimple_min_invariant (res
))
7627 /* The following set of functions are supposed to fold references using
7628 their constant initializers. */
7630 /* See if we can find constructor defining value of BASE.
7631 When we know the consructor with constant offset (such as
7632 base is array[40] and we do know constructor of array), then
7633 BIT_OFFSET is adjusted accordingly.
7635 As a special case, return error_mark_node when constructor
7636 is not explicitly available, but it is known to be zero
7637 such as 'static const int a;'. */
7639 get_base_constructor (tree base
, poly_int64_pod
*bit_offset
,
7640 tree (*valueize
)(tree
))
7642 poly_int64 bit_offset2
, size
, max_size
;
7645 if (TREE_CODE (base
) == MEM_REF
)
7647 poly_offset_int boff
= *bit_offset
+ mem_ref_offset (base
) * BITS_PER_UNIT
;
7648 if (!boff
.to_shwi (bit_offset
))
7652 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
7653 base
= valueize (TREE_OPERAND (base
, 0));
7654 if (!base
|| TREE_CODE (base
) != ADDR_EXPR
)
7656 base
= TREE_OPERAND (base
, 0);
7659 && TREE_CODE (base
) == SSA_NAME
)
7660 base
= valueize (base
);
7662 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
7663 DECL_INITIAL. If BASE is a nested reference into another
7664 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
7665 the inner reference. */
7666 switch (TREE_CODE (base
))
7671 tree init
= ctor_for_folding (base
);
7673 /* Our semantic is exact opposite of ctor_for_folding;
7674 NULL means unknown, while error_mark_node is 0. */
7675 if (init
== error_mark_node
)
7678 return error_mark_node
;
7682 case VIEW_CONVERT_EXPR
:
7683 return get_base_constructor (TREE_OPERAND (base
, 0),
7684 bit_offset
, valueize
);
7688 base
= get_ref_base_and_extent (base
, &bit_offset2
, &size
, &max_size
,
7690 if (!known_size_p (max_size
) || maybe_ne (size
, max_size
))
7692 *bit_offset
+= bit_offset2
;
7693 return get_base_constructor (base
, bit_offset
, valueize
);
7699 if (CONSTANT_CLASS_P (base
))
7706 /* CTOR is CONSTRUCTOR of an array type. Fold a reference of SIZE bits
7707 to the memory at bit OFFSET. When non-null, TYPE is the expected
7708 type of the reference; otherwise the type of the referenced element
7709 is used instead. When SIZE is zero, attempt to fold a reference to
7710 the entire element which OFFSET refers to. Increment *SUBOFF by
7711 the bit offset of the accessed element. */
7714 fold_array_ctor_reference (tree type
, tree ctor
,
7715 unsigned HOST_WIDE_INT offset
,
7716 unsigned HOST_WIDE_INT size
,
7718 unsigned HOST_WIDE_INT
*suboff
)
7720 offset_int low_bound
;
7721 offset_int elt_size
;
7722 offset_int access_index
;
7723 tree domain_type
= NULL_TREE
;
7724 HOST_WIDE_INT inner_offset
;
7726 /* Compute low bound and elt size. */
7727 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
7728 domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
7729 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
7731 /* Static constructors for variably sized objects make no sense. */
7732 if (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) != INTEGER_CST
)
7734 low_bound
= wi::to_offset (TYPE_MIN_VALUE (domain_type
));
7738 /* Static constructors for variably sized objects make no sense. */
7739 if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor
)))) != INTEGER_CST
)
7741 elt_size
= wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor
))));
7743 /* When TYPE is non-null, verify that it specifies a constant-sized
7744 access of a multiple of the array element size. Avoid division
7745 by zero below when ELT_SIZE is zero, such as with the result of
7746 an initializer for a zero-length array or an empty struct. */
7749 && (!TYPE_SIZE_UNIT (type
)
7750 || TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
)))
7753 /* Compute the array index we look for. */
7754 access_index
= wi::udiv_trunc (offset_int (offset
/ BITS_PER_UNIT
),
7756 access_index
+= low_bound
;
7758 /* And offset within the access. */
7759 inner_offset
= offset
% (elt_size
.to_uhwi () * BITS_PER_UNIT
);
7761 unsigned HOST_WIDE_INT elt_sz
= elt_size
.to_uhwi ();
7762 if (size
> elt_sz
* BITS_PER_UNIT
)
7764 /* native_encode_expr constraints. */
7765 if (size
> MAX_BITSIZE_MODE_ANY_MODE
7766 || size
% BITS_PER_UNIT
!= 0
7767 || inner_offset
% BITS_PER_UNIT
!= 0
7768 || elt_sz
> MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
)
7772 tree val
= get_array_ctor_element_at_index (ctor
, access_index
,
7774 if (!val
&& ctor_idx
>= CONSTRUCTOR_NELTS (ctor
))
7775 return build_zero_cst (type
);
7777 /* native-encode adjacent ctor elements. */
7778 unsigned char buf
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
7779 unsigned bufoff
= 0;
7780 offset_int index
= 0;
7781 offset_int max_index
= access_index
;
7782 constructor_elt
*elt
= CONSTRUCTOR_ELT (ctor
, ctor_idx
);
7784 val
= build_zero_cst (TREE_TYPE (TREE_TYPE (ctor
)));
7785 else if (!CONSTANT_CLASS_P (val
))
7789 else if (TREE_CODE (elt
->index
) == RANGE_EXPR
)
7791 index
= wi::to_offset (TREE_OPERAND (elt
->index
, 0));
7792 max_index
= wi::to_offset (TREE_OPERAND (elt
->index
, 1));
7795 index
= max_index
= wi::to_offset (elt
->index
);
7796 index
= wi::umax (index
, access_index
);
7799 if (bufoff
+ elt_sz
> sizeof (buf
))
7800 elt_sz
= sizeof (buf
) - bufoff
;
7801 int len
= native_encode_expr (val
, buf
+ bufoff
, elt_sz
,
7802 inner_offset
/ BITS_PER_UNIT
);
7803 if (len
!= (int) elt_sz
- inner_offset
/ BITS_PER_UNIT
)
7809 if (wi::cmpu (access_index
, index
) == 0)
7811 else if (wi::cmpu (access_index
, max_index
) > 0)
7814 if (ctor_idx
>= CONSTRUCTOR_NELTS (ctor
))
7816 val
= build_zero_cst (TREE_TYPE (TREE_TYPE (ctor
)));
7821 elt
= CONSTRUCTOR_ELT (ctor
, ctor_idx
);
7823 max_index
= access_index
;
7826 else if (TREE_CODE (elt
->index
) == RANGE_EXPR
)
7828 index
= wi::to_offset (TREE_OPERAND (elt
->index
, 0));
7829 max_index
= wi::to_offset (TREE_OPERAND (elt
->index
, 1));
7832 index
= max_index
= wi::to_offset (elt
->index
);
7833 index
= wi::umax (index
, access_index
);
7834 if (wi::cmpu (access_index
, index
) == 0)
7837 val
= build_zero_cst (TREE_TYPE (TREE_TYPE (ctor
)));
7841 while (bufoff
< size
/ BITS_PER_UNIT
);
7843 return native_interpret_expr (type
, buf
, size
/ BITS_PER_UNIT
);
7846 if (tree val
= get_array_ctor_element_at_index (ctor
, access_index
))
7848 if (!size
&& TREE_CODE (val
) != CONSTRUCTOR
)
7850 /* For the final reference to the entire accessed element
7851 (SIZE is zero), reset INNER_OFFSET, disegard TYPE (which
7852 may be null) in favor of the type of the element, and set
7853 SIZE to the size of the accessed element. */
7855 type
= TREE_TYPE (val
);
7856 size
= elt_sz
* BITS_PER_UNIT
;
7858 else if (size
&& access_index
< CONSTRUCTOR_NELTS (ctor
) - 1
7859 && TREE_CODE (val
) == CONSTRUCTOR
7860 && (elt_sz
* BITS_PER_UNIT
- inner_offset
) < size
)
7861 /* If this isn't the last element in the CTOR and a CTOR itself
7862 and it does not cover the whole object we are requesting give up
7863 since we're not set up for combining from multiple CTORs. */
7866 *suboff
+= access_index
.to_uhwi () * elt_sz
* BITS_PER_UNIT
;
7867 return fold_ctor_reference (type
, val
, inner_offset
, size
, from_decl
,
7871 /* Memory not explicitly mentioned in constructor is 0 (or
7872 the reference is out of range). */
7873 return type
? build_zero_cst (type
) : NULL_TREE
;
7876 /* CTOR is CONSTRUCTOR of an aggregate or vector. Fold a reference
7877 of SIZE bits to the memory at bit OFFSET. When non-null, TYPE
7878 is the expected type of the reference; otherwise the type of
7879 the referenced member is used instead. When SIZE is zero,
7880 attempt to fold a reference to the entire member which OFFSET
7881 refers to; in this case. Increment *SUBOFF by the bit offset
7882 of the accessed member. */
7885 fold_nonarray_ctor_reference (tree type
, tree ctor
,
7886 unsigned HOST_WIDE_INT offset
,
7887 unsigned HOST_WIDE_INT size
,
7889 unsigned HOST_WIDE_INT
*suboff
)
7891 unsigned HOST_WIDE_INT cnt
;
7894 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
,
7897 tree byte_offset
= DECL_FIELD_OFFSET (cfield
);
7898 tree field_offset
= DECL_FIELD_BIT_OFFSET (cfield
);
7899 tree field_size
= DECL_SIZE (cfield
);
7903 /* Determine the size of the flexible array member from
7904 the size of the initializer provided for it. */
7905 field_size
= TYPE_SIZE (TREE_TYPE (cval
));
7908 /* Variable sized objects in static constructors makes no sense,
7909 but field_size can be NULL for flexible array members. */
7910 gcc_assert (TREE_CODE (field_offset
) == INTEGER_CST
7911 && TREE_CODE (byte_offset
) == INTEGER_CST
7912 && (field_size
!= NULL_TREE
7913 ? TREE_CODE (field_size
) == INTEGER_CST
7914 : TREE_CODE (TREE_TYPE (cfield
)) == ARRAY_TYPE
));
7916 /* Compute bit offset of the field. */
7917 offset_int bitoffset
7918 = (wi::to_offset (field_offset
)
7919 + (wi::to_offset (byte_offset
) << LOG2_BITS_PER_UNIT
));
7920 /* Compute bit offset where the field ends. */
7921 offset_int bitoffset_end
;
7922 if (field_size
!= NULL_TREE
)
7923 bitoffset_end
= bitoffset
+ wi::to_offset (field_size
);
7927 /* Compute the bit offset of the end of the desired access.
7928 As a special case, if the size of the desired access is
7929 zero, assume the access is to the entire field (and let
7930 the caller make any necessary adjustments by storing
7931 the actual bounds of the field in FIELDBOUNDS). */
7932 offset_int access_end
= offset_int (offset
);
7936 access_end
= bitoffset_end
;
7938 /* Is there any overlap between the desired access at
7939 [OFFSET, OFFSET+SIZE) and the offset of the field within
7940 the object at [BITOFFSET, BITOFFSET_END)? */
7941 if (wi::cmps (access_end
, bitoffset
) > 0
7942 && (field_size
== NULL_TREE
7943 || wi::lts_p (offset
, bitoffset_end
)))
7945 *suboff
+= bitoffset
.to_uhwi ();
7947 if (!size
&& TREE_CODE (cval
) != CONSTRUCTOR
)
7949 /* For the final reference to the entire accessed member
7950 (SIZE is zero), reset OFFSET, disegard TYPE (which may
7951 be null) in favor of the type of the member, and set
7952 SIZE to the size of the accessed member. */
7953 offset
= bitoffset
.to_uhwi ();
7954 type
= TREE_TYPE (cval
);
7955 size
= (bitoffset_end
- bitoffset
).to_uhwi ();
7958 /* We do have overlap. Now see if the field is large enough
7959 to cover the access. Give up for accesses that extend
7960 beyond the end of the object or that span multiple fields. */
7961 if (wi::cmps (access_end
, bitoffset_end
) > 0)
7963 if (offset
< bitoffset
)
7966 offset_int inner_offset
= offset_int (offset
) - bitoffset
;
7967 return fold_ctor_reference (type
, cval
,
7968 inner_offset
.to_uhwi (), size
,
7976 return build_zero_cst (type
);
7979 /* CTOR is value initializing memory. Fold a reference of TYPE and
7980 bit size POLY_SIZE to the memory at bit POLY_OFFSET. When POLY_SIZE
7981 is zero, attempt to fold a reference to the entire subobject
7982 which OFFSET refers to. This is used when folding accesses to
7983 string members of aggregates. When non-null, set *SUBOFF to
7984 the bit offset of the accessed subobject. */
7987 fold_ctor_reference (tree type
, tree ctor
, const poly_uint64
&poly_offset
,
7988 const poly_uint64
&poly_size
, tree from_decl
,
7989 unsigned HOST_WIDE_INT
*suboff
/* = NULL */)
7993 /* We found the field with exact match. */
7995 && useless_type_conversion_p (type
, TREE_TYPE (ctor
))
7996 && known_eq (poly_offset
, 0U))
7997 return canonicalize_constructor_val (unshare_expr (ctor
), from_decl
);
7999 /* The remaining optimizations need a constant size and offset. */
8000 unsigned HOST_WIDE_INT size
, offset
;
8001 if (!poly_size
.is_constant (&size
) || !poly_offset
.is_constant (&offset
))
8004 /* We are at the end of walk, see if we can view convert the
8006 if (!AGGREGATE_TYPE_P (TREE_TYPE (ctor
)) && !offset
8007 /* VIEW_CONVERT_EXPR is defined only for matching sizes. */
8008 && !compare_tree_int (TYPE_SIZE (type
), size
)
8009 && !compare_tree_int (TYPE_SIZE (TREE_TYPE (ctor
)), size
))
8011 ret
= canonicalize_constructor_val (unshare_expr (ctor
), from_decl
);
8014 ret
= fold_unary (VIEW_CONVERT_EXPR
, type
, ret
);
8016 STRIP_USELESS_TYPE_CONVERSION (ret
);
8020 /* For constants and byte-aligned/sized reads try to go through
8021 native_encode/interpret. */
8022 if (CONSTANT_CLASS_P (ctor
)
8023 && BITS_PER_UNIT
== 8
8024 && offset
% BITS_PER_UNIT
== 0
8025 && offset
/ BITS_PER_UNIT
<= INT_MAX
8026 && size
% BITS_PER_UNIT
== 0
8027 && size
<= MAX_BITSIZE_MODE_ANY_MODE
8028 && can_native_interpret_type_p (type
))
8030 unsigned char buf
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
8031 int len
= native_encode_expr (ctor
, buf
, size
/ BITS_PER_UNIT
,
8032 offset
/ BITS_PER_UNIT
);
8034 return native_interpret_expr (type
, buf
, len
);
8036 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
8038 unsigned HOST_WIDE_INT dummy
= 0;
8043 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
8044 || TREE_CODE (TREE_TYPE (ctor
)) == VECTOR_TYPE
)
8045 ret
= fold_array_ctor_reference (type
, ctor
, offset
, size
,
8048 ret
= fold_nonarray_ctor_reference (type
, ctor
, offset
, size
,
8051 /* Fall back to native_encode_initializer. Needs to be done
8052 only in the outermost fold_ctor_reference call (because it itself
8053 recurses into CONSTRUCTORs) and doesn't update suboff. */
8054 if (ret
== NULL_TREE
8056 && BITS_PER_UNIT
== 8
8057 && offset
% BITS_PER_UNIT
== 0
8058 && offset
/ BITS_PER_UNIT
<= INT_MAX
8059 && size
% BITS_PER_UNIT
== 0
8060 && size
<= MAX_BITSIZE_MODE_ANY_MODE
8061 && can_native_interpret_type_p (type
))
8063 unsigned char buf
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
8064 int len
= native_encode_initializer (ctor
, buf
, size
/ BITS_PER_UNIT
,
8065 offset
/ BITS_PER_UNIT
);
8067 return native_interpret_expr (type
, buf
, len
);
8076 /* Return the tree representing the element referenced by T if T is an
8077 ARRAY_REF or COMPONENT_REF into constant aggregates valuezing SSA
8078 names using VALUEIZE. Return NULL_TREE otherwise. */
8081 fold_const_aggregate_ref_1 (tree t
, tree (*valueize
) (tree
))
8083 tree ctor
, idx
, base
;
8084 poly_int64 offset
, size
, max_size
;
8088 if (TREE_THIS_VOLATILE (t
))
8092 return get_symbol_constant_value (t
);
8094 tem
= fold_read_from_constant_string (t
);
8098 switch (TREE_CODE (t
))
8101 case ARRAY_RANGE_REF
:
8102 /* Constant indexes are handled well by get_base_constructor.
8103 Only special case variable offsets.
8104 FIXME: This code can't handle nested references with variable indexes
8105 (they will be handled only by iteration of ccp). Perhaps we can bring
8106 get_ref_base_and_extent here and make it use a valueize callback. */
8107 if (TREE_CODE (TREE_OPERAND (t
, 1)) == SSA_NAME
8109 && (idx
= (*valueize
) (TREE_OPERAND (t
, 1)))
8110 && poly_int_tree_p (idx
))
8112 tree low_bound
, unit_size
;
8114 /* If the resulting bit-offset is constant, track it. */
8115 if ((low_bound
= array_ref_low_bound (t
),
8116 poly_int_tree_p (low_bound
))
8117 && (unit_size
= array_ref_element_size (t
),
8118 tree_fits_uhwi_p (unit_size
)))
8120 poly_offset_int woffset
8121 = wi::sext (wi::to_poly_offset (idx
)
8122 - wi::to_poly_offset (low_bound
),
8123 TYPE_PRECISION (sizetype
));
8124 woffset
*= tree_to_uhwi (unit_size
);
8125 woffset
*= BITS_PER_UNIT
;
8126 if (woffset
.to_shwi (&offset
))
8128 base
= TREE_OPERAND (t
, 0);
8129 ctor
= get_base_constructor (base
, &offset
, valueize
);
8130 /* Empty constructor. Always fold to 0. */
8131 if (ctor
== error_mark_node
)
8132 return build_zero_cst (TREE_TYPE (t
));
8133 /* Out of bound array access. Value is undefined,
8135 if (maybe_lt (offset
, 0))
8137 /* We cannot determine ctor. */
8140 return fold_ctor_reference (TREE_TYPE (t
), ctor
, offset
,
8141 tree_to_uhwi (unit_size
)
8151 case TARGET_MEM_REF
:
8153 base
= get_ref_base_and_extent (t
, &offset
, &size
, &max_size
, &reverse
);
8154 ctor
= get_base_constructor (base
, &offset
, valueize
);
8156 /* Empty constructor. Always fold to 0. */
8157 if (ctor
== error_mark_node
)
8158 return build_zero_cst (TREE_TYPE (t
));
8159 /* We do not know precise address. */
8160 if (!known_size_p (max_size
) || maybe_ne (max_size
, size
))
8162 /* We cannot determine ctor. */
8166 /* Out of bound array access. Value is undefined, but don't fold. */
8167 if (maybe_lt (offset
, 0))
8170 tem
= fold_ctor_reference (TREE_TYPE (t
), ctor
, offset
, size
, base
);
8174 /* For bit field reads try to read the representative and
8176 if (TREE_CODE (t
) == COMPONENT_REF
8177 && DECL_BIT_FIELD (TREE_OPERAND (t
, 1))
8178 && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t
, 1)))
8180 HOST_WIDE_INT csize
, coffset
;
8181 tree field
= TREE_OPERAND (t
, 1);
8182 tree repr
= DECL_BIT_FIELD_REPRESENTATIVE (field
);
8183 if (INTEGRAL_TYPE_P (TREE_TYPE (repr
))
8184 && size
.is_constant (&csize
)
8185 && offset
.is_constant (&coffset
)
8186 && (coffset
% BITS_PER_UNIT
!= 0
8187 || csize
% BITS_PER_UNIT
!= 0)
8189 && BYTES_BIG_ENDIAN
== WORDS_BIG_ENDIAN
)
8191 poly_int64 bitoffset
;
8192 poly_uint64 field_offset
, repr_offset
;
8193 if (poly_int_tree_p (DECL_FIELD_OFFSET (field
), &field_offset
)
8194 && poly_int_tree_p (DECL_FIELD_OFFSET (repr
), &repr_offset
))
8195 bitoffset
= (field_offset
- repr_offset
) * BITS_PER_UNIT
;
8198 bitoffset
+= (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field
))
8199 - tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr
)));
8200 HOST_WIDE_INT bitoff
;
8201 int diff
= (TYPE_PRECISION (TREE_TYPE (repr
))
8202 - TYPE_PRECISION (TREE_TYPE (field
)));
8203 if (bitoffset
.is_constant (&bitoff
)
8208 size
= tree_to_uhwi (DECL_SIZE (repr
));
8210 tem
= fold_ctor_reference (TREE_TYPE (repr
), ctor
, offset
,
8212 if (tem
&& TREE_CODE (tem
) == INTEGER_CST
)
8214 if (!BYTES_BIG_ENDIAN
)
8215 tem
= wide_int_to_tree (TREE_TYPE (field
),
8216 wi::lrshift (wi::to_wide (tem
),
8219 tem
= wide_int_to_tree (TREE_TYPE (field
),
8220 wi::lrshift (wi::to_wide (tem
),
8232 tree c
= fold_const_aggregate_ref_1 (TREE_OPERAND (t
, 0), valueize
);
8233 if (c
&& TREE_CODE (c
) == COMPLEX_CST
)
8234 return fold_build1_loc (EXPR_LOCATION (t
),
8235 TREE_CODE (t
), TREE_TYPE (t
), c
);
8247 fold_const_aggregate_ref (tree t
)
8249 return fold_const_aggregate_ref_1 (t
, NULL
);
8252 /* Lookup virtual method with index TOKEN in a virtual table V
8254 Set CAN_REFER if non-NULL to false if method
8255 is not referable or if the virtual table is ill-formed (such as rewriten
8256 by non-C++ produced symbol). Otherwise just return NULL in that calse. */
8259 gimple_get_virt_method_for_vtable (HOST_WIDE_INT token
,
8261 unsigned HOST_WIDE_INT offset
,
8264 tree vtable
= v
, init
, fn
;
8265 unsigned HOST_WIDE_INT size
;
8266 unsigned HOST_WIDE_INT elt_size
, access_index
;
8272 /* First of all double check we have virtual table. */
8273 if (!VAR_P (v
) || !DECL_VIRTUAL_P (v
))
8275 /* Pass down that we lost track of the target. */
8281 init
= ctor_for_folding (v
);
8283 /* The virtual tables should always be born with constructors
8284 and we always should assume that they are avaialble for
8285 folding. At the moment we do not stream them in all cases,
8286 but it should never happen that ctor seem unreachable. */
8288 if (init
== error_mark_node
)
8290 /* Pass down that we lost track of the target. */
8295 gcc_checking_assert (TREE_CODE (TREE_TYPE (v
)) == ARRAY_TYPE
);
8296 size
= tree_to_uhwi (TYPE_SIZE (TREE_TYPE (TREE_TYPE (v
))));
8297 offset
*= BITS_PER_UNIT
;
8298 offset
+= token
* size
;
8300 /* Lookup the value in the constructor that is assumed to be array.
8301 This is equivalent to
8302 fn = fold_ctor_reference (TREE_TYPE (TREE_TYPE (v)), init,
8303 offset, size, NULL);
8304 but in a constant time. We expect that frontend produced a simple
8305 array without indexed initializers. */
8307 gcc_checking_assert (TREE_CODE (TREE_TYPE (init
)) == ARRAY_TYPE
);
8308 domain_type
= TYPE_DOMAIN (TREE_TYPE (init
));
8309 gcc_checking_assert (integer_zerop (TYPE_MIN_VALUE (domain_type
)));
8310 elt_size
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (init
))));
8312 access_index
= offset
/ BITS_PER_UNIT
/ elt_size
;
8313 gcc_checking_assert (offset
% (elt_size
* BITS_PER_UNIT
) == 0);
8315 /* The C++ FE can now produce indexed fields, and we check if the indexes
8317 if (access_index
< CONSTRUCTOR_NELTS (init
))
8319 fn
= CONSTRUCTOR_ELT (init
, access_index
)->value
;
8320 tree idx
= CONSTRUCTOR_ELT (init
, access_index
)->index
;
8321 gcc_checking_assert (!idx
|| tree_to_uhwi (idx
) == access_index
);
8327 /* For type inconsistent program we may end up looking up virtual method
8328 in virtual table that does not contain TOKEN entries. We may overrun
8329 the virtual table and pick up a constant or RTTI info pointer.
8330 In any case the call is undefined. */
8332 || (TREE_CODE (fn
) != ADDR_EXPR
&& TREE_CODE (fn
) != FDESC_EXPR
)
8333 || TREE_CODE (TREE_OPERAND (fn
, 0)) != FUNCTION_DECL
)
8334 fn
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
8337 fn
= TREE_OPERAND (fn
, 0);
8339 /* When cgraph node is missing and function is not public, we cannot
8340 devirtualize. This can happen in WHOPR when the actual method
8341 ends up in other partition, because we found devirtualization
8342 possibility too late. */
8343 if (!can_refer_decl_in_current_unit_p (fn
, vtable
))
8354 /* Make sure we create a cgraph node for functions we'll reference.
8355 They can be non-existent if the reference comes from an entry
8356 of an external vtable for example. */
8357 cgraph_node::get_create (fn
);
8362 /* Return a declaration of a function which an OBJ_TYPE_REF references. TOKEN
8363 is integer form of OBJ_TYPE_REF_TOKEN of the reference expression.
8364 KNOWN_BINFO carries the binfo describing the true type of
8365 OBJ_TYPE_REF_OBJECT(REF).
8366 Set CAN_REFER if non-NULL to false if method
8367 is not referable or if the virtual table is ill-formed (such as rewriten
8368 by non-C++ produced symbol). Otherwise just return NULL in that calse. */
8371 gimple_get_virt_method_for_binfo (HOST_WIDE_INT token
, tree known_binfo
,
8374 unsigned HOST_WIDE_INT offset
;
8377 v
= BINFO_VTABLE (known_binfo
);
8378 /* If there is no virtual methods table, leave the OBJ_TYPE_REF alone. */
8382 if (!vtable_pointer_value_to_vtable (v
, &v
, &offset
))
8388 return gimple_get_virt_method_for_vtable (token
, v
, offset
, can_refer
);
8391 /* Given a pointer value T, return a simplified version of an
8392 indirection through T, or NULL_TREE if no simplification is
8393 possible. Note that the resulting type may be different from
8394 the type pointed to in the sense that it is still compatible
8395 from the langhooks point of view. */
8398 gimple_fold_indirect_ref (tree t
)
8400 tree ptype
= TREE_TYPE (t
), type
= TREE_TYPE (ptype
);
8405 subtype
= TREE_TYPE (sub
);
8406 if (!POINTER_TYPE_P (subtype
)
8407 || TYPE_REF_CAN_ALIAS_ALL (ptype
))
8410 if (TREE_CODE (sub
) == ADDR_EXPR
)
8412 tree op
= TREE_OPERAND (sub
, 0);
8413 tree optype
= TREE_TYPE (op
);
8415 if (useless_type_conversion_p (type
, optype
))
8418 /* *(foo *)&fooarray => fooarray[0] */
8419 if (TREE_CODE (optype
) == ARRAY_TYPE
8420 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype
))) == INTEGER_CST
8421 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
8423 tree type_domain
= TYPE_DOMAIN (optype
);
8424 tree min_val
= size_zero_node
;
8425 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
8426 min_val
= TYPE_MIN_VALUE (type_domain
);
8427 if (TREE_CODE (min_val
) == INTEGER_CST
)
8428 return build4 (ARRAY_REF
, type
, op
, min_val
, NULL_TREE
, NULL_TREE
);
8430 /* *(foo *)&complexfoo => __real__ complexfoo */
8431 else if (TREE_CODE (optype
) == COMPLEX_TYPE
8432 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
8433 return fold_build1 (REALPART_EXPR
, type
, op
);
8434 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
8435 else if (TREE_CODE (optype
) == VECTOR_TYPE
8436 && useless_type_conversion_p (type
, TREE_TYPE (optype
)))
8438 tree part_width
= TYPE_SIZE (type
);
8439 tree index
= bitsize_int (0);
8440 return fold_build3 (BIT_FIELD_REF
, type
, op
, part_width
, index
);
8444 /* *(p + CST) -> ... */
8445 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
8446 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
8448 tree addr
= TREE_OPERAND (sub
, 0);
8449 tree off
= TREE_OPERAND (sub
, 1);
8453 addrtype
= TREE_TYPE (addr
);
8455 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
8456 if (TREE_CODE (addr
) == ADDR_EXPR
8457 && TREE_CODE (TREE_TYPE (addrtype
)) == VECTOR_TYPE
8458 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
)))
8459 && tree_fits_uhwi_p (off
))
8461 unsigned HOST_WIDE_INT offset
= tree_to_uhwi (off
);
8462 tree part_width
= TYPE_SIZE (type
);
8463 unsigned HOST_WIDE_INT part_widthi
8464 = tree_to_shwi (part_width
) / BITS_PER_UNIT
;
8465 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
8466 tree index
= bitsize_int (indexi
);
8467 if (known_lt (offset
/ part_widthi
,
8468 TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype
))))
8469 return fold_build3 (BIT_FIELD_REF
, type
, TREE_OPERAND (addr
, 0),
8473 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
8474 if (TREE_CODE (addr
) == ADDR_EXPR
8475 && TREE_CODE (TREE_TYPE (addrtype
)) == COMPLEX_TYPE
8476 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (addrtype
))))
8478 tree size
= TYPE_SIZE_UNIT (type
);
8479 if (tree_int_cst_equal (size
, off
))
8480 return fold_build1 (IMAGPART_EXPR
, type
, TREE_OPERAND (addr
, 0));
8483 /* *(p + CST) -> MEM_REF <p, CST>. */
8484 if (TREE_CODE (addr
) != ADDR_EXPR
8485 || DECL_P (TREE_OPERAND (addr
, 0)))
8486 return fold_build2 (MEM_REF
, type
,
8488 wide_int_to_tree (ptype
, wi::to_wide (off
)));
8491 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
8492 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
8493 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype
)))) == INTEGER_CST
8494 && useless_type_conversion_p (type
, TREE_TYPE (TREE_TYPE (subtype
))))
8497 tree min_val
= size_zero_node
;
8499 sub
= gimple_fold_indirect_ref (sub
);
8501 sub
= build1 (INDIRECT_REF
, TREE_TYPE (subtype
), osub
);
8502 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
8503 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
8504 min_val
= TYPE_MIN_VALUE (type_domain
);
8505 if (TREE_CODE (min_val
) == INTEGER_CST
)
8506 return build4 (ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
, NULL_TREE
);
8512 /* Return true if CODE is an operation that when operating on signed
8513 integer types involves undefined behavior on overflow and the
8514 operation can be expressed with unsigned arithmetic. */
8517 arith_code_with_undefined_signed_overflow (tree_code code
)
8526 case POINTER_PLUS_EXPR
:
8533 /* Rewrite STMT, an assignment with a signed integer or pointer arithmetic
8534 operation that can be transformed to unsigned arithmetic by converting
8535 its operand, carrying out the operation in the corresponding unsigned
8536 type and converting the result back to the original type.
8538 Returns a sequence of statements that replace STMT and also contain
8539 a modified form of STMT itself. */
8542 rewrite_to_defined_overflow (gimple
*stmt
)
8544 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
8546 fprintf (dump_file
, "rewriting stmt with undefined signed "
8548 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
8551 tree lhs
= gimple_assign_lhs (stmt
);
8552 tree type
= unsigned_type_for (TREE_TYPE (lhs
));
8553 gimple_seq stmts
= NULL
;
8554 if (gimple_assign_rhs_code (stmt
) == ABS_EXPR
)
8555 gimple_assign_set_rhs_code (stmt
, ABSU_EXPR
);
8557 for (unsigned i
= 1; i
< gimple_num_ops (stmt
); ++i
)
8559 tree op
= gimple_op (stmt
, i
);
8560 op
= gimple_convert (&stmts
, type
, op
);
8561 gimple_set_op (stmt
, i
, op
);
8563 gimple_assign_set_lhs (stmt
, make_ssa_name (type
, stmt
));
8564 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
)
8565 gimple_assign_set_rhs_code (stmt
, PLUS_EXPR
);
8566 gimple_set_modified (stmt
, true);
8567 gimple_seq_add_stmt (&stmts
, stmt
);
8568 gimple
*cvt
= gimple_build_assign (lhs
, NOP_EXPR
, gimple_assign_lhs (stmt
));
8569 gimple_seq_add_stmt (&stmts
, cvt
);
8575 /* The valueization hook we use for the gimple_build API simplification.
8576 This makes us match fold_buildN behavior by only combining with
8577 statements in the sequence(s) we are currently building. */
8580 gimple_build_valueize (tree op
)
8582 if (gimple_bb (SSA_NAME_DEF_STMT (op
)) == NULL
)
8587 /* Build the expression CODE OP0 of type TYPE with location LOC,
8588 simplifying it first if possible. Returns the built
8589 expression value and appends statements possibly defining it
8593 gimple_build (gimple_seq
*seq
, location_t loc
,
8594 enum tree_code code
, tree type
, tree op0
)
8596 tree res
= gimple_simplify (code
, type
, op0
, seq
, gimple_build_valueize
);
8599 res
= create_tmp_reg_or_ssa_name (type
);
8601 if (code
== REALPART_EXPR
8602 || code
== IMAGPART_EXPR
8603 || code
== VIEW_CONVERT_EXPR
)
8604 stmt
= gimple_build_assign (res
, code
, build1 (code
, type
, op0
));
8606 stmt
= gimple_build_assign (res
, code
, op0
);
8607 gimple_set_location (stmt
, loc
);
8608 gimple_seq_add_stmt_without_update (seq
, stmt
);
8613 /* Build the expression OP0 CODE OP1 of type TYPE with location LOC,
8614 simplifying it first if possible. Returns the built
8615 expression value and appends statements possibly defining it
8619 gimple_build (gimple_seq
*seq
, location_t loc
,
8620 enum tree_code code
, tree type
, tree op0
, tree op1
)
8622 tree res
= gimple_simplify (code
, type
, op0
, op1
, seq
, gimple_build_valueize
);
8625 res
= create_tmp_reg_or_ssa_name (type
);
8626 gimple
*stmt
= gimple_build_assign (res
, code
, op0
, op1
);
8627 gimple_set_location (stmt
, loc
);
8628 gimple_seq_add_stmt_without_update (seq
, stmt
);
8633 /* Build the expression (CODE OP0 OP1 OP2) of type TYPE with location LOC,
8634 simplifying it first if possible. Returns the built
8635 expression value and appends statements possibly defining it
8639 gimple_build (gimple_seq
*seq
, location_t loc
,
8640 enum tree_code code
, tree type
, tree op0
, tree op1
, tree op2
)
8642 tree res
= gimple_simplify (code
, type
, op0
, op1
, op2
,
8643 seq
, gimple_build_valueize
);
8646 res
= create_tmp_reg_or_ssa_name (type
);
8648 if (code
== BIT_FIELD_REF
)
8649 stmt
= gimple_build_assign (res
, code
,
8650 build3 (code
, type
, op0
, op1
, op2
));
8652 stmt
= gimple_build_assign (res
, code
, op0
, op1
, op2
);
8653 gimple_set_location (stmt
, loc
);
8654 gimple_seq_add_stmt_without_update (seq
, stmt
);
8659 /* Build the call FN () with a result of type TYPE (or no result if TYPE is
8660 void) with a location LOC. Returns the built expression value (or NULL_TREE
8661 if TYPE is void) and appends statements possibly defining it to SEQ. */
8664 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
, tree type
)
8666 tree res
= NULL_TREE
;
8668 if (internal_fn_p (fn
))
8669 stmt
= gimple_build_call_internal (as_internal_fn (fn
), 0);
8672 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
8673 stmt
= gimple_build_call (decl
, 0);
8675 if (!VOID_TYPE_P (type
))
8677 res
= create_tmp_reg_or_ssa_name (type
);
8678 gimple_call_set_lhs (stmt
, res
);
8680 gimple_set_location (stmt
, loc
);
8681 gimple_seq_add_stmt_without_update (seq
, stmt
);
8685 /* Build the call FN (ARG0) with a result of type TYPE
8686 (or no result if TYPE is void) with location LOC,
8687 simplifying it first if possible. Returns the built
8688 expression value (or NULL_TREE if TYPE is void) and appends
8689 statements possibly defining it to SEQ. */
8692 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
8693 tree type
, tree arg0
)
8695 tree res
= gimple_simplify (fn
, type
, arg0
, seq
, gimple_build_valueize
);
8699 if (internal_fn_p (fn
))
8700 stmt
= gimple_build_call_internal (as_internal_fn (fn
), 1, arg0
);
8703 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
8704 stmt
= gimple_build_call (decl
, 1, arg0
);
8706 if (!VOID_TYPE_P (type
))
8708 res
= create_tmp_reg_or_ssa_name (type
);
8709 gimple_call_set_lhs (stmt
, res
);
8711 gimple_set_location (stmt
, loc
);
8712 gimple_seq_add_stmt_without_update (seq
, stmt
);
8717 /* Build the call FN (ARG0, ARG1) with a result of type TYPE
8718 (or no result if TYPE is void) with location LOC,
8719 simplifying it first if possible. Returns the built
8720 expression value (or NULL_TREE if TYPE is void) and appends
8721 statements possibly defining it to SEQ. */
8724 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
8725 tree type
, tree arg0
, tree arg1
)
8727 tree res
= gimple_simplify (fn
, type
, arg0
, arg1
, seq
, gimple_build_valueize
);
8731 if (internal_fn_p (fn
))
8732 stmt
= gimple_build_call_internal (as_internal_fn (fn
), 2, arg0
, arg1
);
8735 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
8736 stmt
= gimple_build_call (decl
, 2, arg0
, arg1
);
8738 if (!VOID_TYPE_P (type
))
8740 res
= create_tmp_reg_or_ssa_name (type
);
8741 gimple_call_set_lhs (stmt
, res
);
8743 gimple_set_location (stmt
, loc
);
8744 gimple_seq_add_stmt_without_update (seq
, stmt
);
8749 /* Build the call FN (ARG0, ARG1, ARG2) with a result of type TYPE
8750 (or no result if TYPE is void) with location LOC,
8751 simplifying it first if possible. Returns the built
8752 expression value (or NULL_TREE if TYPE is void) and appends
8753 statements possibly defining it to SEQ. */
8756 gimple_build (gimple_seq
*seq
, location_t loc
, combined_fn fn
,
8757 tree type
, tree arg0
, tree arg1
, tree arg2
)
8759 tree res
= gimple_simplify (fn
, type
, arg0
, arg1
, arg2
,
8760 seq
, gimple_build_valueize
);
8764 if (internal_fn_p (fn
))
8765 stmt
= gimple_build_call_internal (as_internal_fn (fn
),
8766 3, arg0
, arg1
, arg2
);
8769 tree decl
= builtin_decl_implicit (as_builtin_fn (fn
));
8770 stmt
= gimple_build_call (decl
, 3, arg0
, arg1
, arg2
);
8772 if (!VOID_TYPE_P (type
))
8774 res
= create_tmp_reg_or_ssa_name (type
);
8775 gimple_call_set_lhs (stmt
, res
);
8777 gimple_set_location (stmt
, loc
);
8778 gimple_seq_add_stmt_without_update (seq
, stmt
);
8783 /* Build the conversion (TYPE) OP with a result of type TYPE
8784 with location LOC if such conversion is neccesary in GIMPLE,
8785 simplifying it first.
8786 Returns the built expression value and appends
8787 statements possibly defining it to SEQ. */
8790 gimple_convert (gimple_seq
*seq
, location_t loc
, tree type
, tree op
)
8792 if (useless_type_conversion_p (type
, TREE_TYPE (op
)))
8794 return gimple_build (seq
, loc
, NOP_EXPR
, type
, op
);
8797 /* Build the conversion (ptrofftype) OP with a result of a type
8798 compatible with ptrofftype with location LOC if such conversion
8799 is neccesary in GIMPLE, simplifying it first.
8800 Returns the built expression value and appends
8801 statements possibly defining it to SEQ. */
8804 gimple_convert_to_ptrofftype (gimple_seq
*seq
, location_t loc
, tree op
)
8806 if (ptrofftype_p (TREE_TYPE (op
)))
8808 return gimple_convert (seq
, loc
, sizetype
, op
);
8811 /* Build a vector of type TYPE in which each element has the value OP.
8812 Return a gimple value for the result, appending any new statements
8816 gimple_build_vector_from_val (gimple_seq
*seq
, location_t loc
, tree type
,
8819 if (!TYPE_VECTOR_SUBPARTS (type
).is_constant ()
8820 && !CONSTANT_CLASS_P (op
))
8821 return gimple_build (seq
, loc
, VEC_DUPLICATE_EXPR
, type
, op
);
8823 tree res
, vec
= build_vector_from_val (type
, op
);
8824 if (is_gimple_val (vec
))
8826 if (gimple_in_ssa_p (cfun
))
8827 res
= make_ssa_name (type
);
8829 res
= create_tmp_reg (type
);
8830 gimple
*stmt
= gimple_build_assign (res
, vec
);
8831 gimple_set_location (stmt
, loc
);
8832 gimple_seq_add_stmt_without_update (seq
, stmt
);
8836 /* Build a vector from BUILDER, handling the case in which some elements
8837 are non-constant. Return a gimple value for the result, appending any
8838 new instructions to SEQ.
8840 BUILDER must not have a stepped encoding on entry. This is because
8841 the function is not geared up to handle the arithmetic that would
8842 be needed in the variable case, and any code building a vector that
8843 is known to be constant should use BUILDER->build () directly. */
8846 gimple_build_vector (gimple_seq
*seq
, location_t loc
,
8847 tree_vector_builder
*builder
)
8849 gcc_assert (builder
->nelts_per_pattern () <= 2);
8850 unsigned int encoded_nelts
= builder
->encoded_nelts ();
8851 for (unsigned int i
= 0; i
< encoded_nelts
; ++i
)
8852 if (!CONSTANT_CLASS_P ((*builder
)[i
]))
8854 tree type
= builder
->type ();
8855 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
).to_constant ();
8856 vec
<constructor_elt
, va_gc
> *v
;
8857 vec_alloc (v
, nelts
);
8858 for (i
= 0; i
< nelts
; ++i
)
8859 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, builder
->elt (i
));
8862 if (gimple_in_ssa_p (cfun
))
8863 res
= make_ssa_name (type
);
8865 res
= create_tmp_reg (type
);
8866 gimple
*stmt
= gimple_build_assign (res
, build_constructor (type
, v
));
8867 gimple_set_location (stmt
, loc
);
8868 gimple_seq_add_stmt_without_update (seq
, stmt
);
8871 return builder
->build ();
8874 /* Emit gimple statements into &stmts that take a value given in OLD_SIZE
8875 and generate a value guaranteed to be rounded upwards to ALIGN.
8877 Return the tree node representing this size, it is of TREE_TYPE TYPE. */
8880 gimple_build_round_up (gimple_seq
*seq
, location_t loc
, tree type
,
8881 tree old_size
, unsigned HOST_WIDE_INT align
)
8883 unsigned HOST_WIDE_INT tg_mask
= align
- 1;
8884 /* tree new_size = (old_size + tg_mask) & ~tg_mask; */
8885 gcc_assert (INTEGRAL_TYPE_P (type
));
8886 tree tree_mask
= build_int_cst (type
, tg_mask
);
8887 tree oversize
= gimple_build (seq
, loc
, PLUS_EXPR
, type
, old_size
,
8890 tree mask
= build_int_cst (type
, -align
);
8891 return gimple_build (seq
, loc
, BIT_AND_EXPR
, type
, oversize
, mask
);
8894 /* Return true if the result of assignment STMT is known to be non-negative.
8895 If the return value is based on the assumption that signed overflow is
8896 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
8897 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
8900 gimple_assign_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
8903 enum tree_code code
= gimple_assign_rhs_code (stmt
);
8904 switch (get_gimple_rhs_class (code
))
8906 case GIMPLE_UNARY_RHS
:
8907 return tree_unary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt
),
8908 gimple_expr_type (stmt
),
8909 gimple_assign_rhs1 (stmt
),
8910 strict_overflow_p
, depth
);
8911 case GIMPLE_BINARY_RHS
:
8912 return tree_binary_nonnegative_warnv_p (gimple_assign_rhs_code (stmt
),
8913 gimple_expr_type (stmt
),
8914 gimple_assign_rhs1 (stmt
),
8915 gimple_assign_rhs2 (stmt
),
8916 strict_overflow_p
, depth
);
8917 case GIMPLE_TERNARY_RHS
:
8919 case GIMPLE_SINGLE_RHS
:
8920 return tree_single_nonnegative_warnv_p (gimple_assign_rhs1 (stmt
),
8921 strict_overflow_p
, depth
);
8922 case GIMPLE_INVALID_RHS
:
8928 /* Return true if return value of call STMT is known to be non-negative.
8929 If the return value is based on the assumption that signed overflow is
8930 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
8931 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
8934 gimple_call_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
8937 tree arg0
= gimple_call_num_args (stmt
) > 0 ?
8938 gimple_call_arg (stmt
, 0) : NULL_TREE
;
8939 tree arg1
= gimple_call_num_args (stmt
) > 1 ?
8940 gimple_call_arg (stmt
, 1) : NULL_TREE
;
8942 return tree_call_nonnegative_warnv_p (gimple_expr_type (stmt
),
8943 gimple_call_combined_fn (stmt
),
8946 strict_overflow_p
, depth
);
8949 /* Return true if return value of call STMT is known to be non-negative.
8950 If the return value is based on the assumption that signed overflow is
8951 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
8952 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
8955 gimple_phi_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
8958 for (unsigned i
= 0; i
< gimple_phi_num_args (stmt
); ++i
)
8960 tree arg
= gimple_phi_arg_def (stmt
, i
);
8961 if (!tree_single_nonnegative_warnv_p (arg
, strict_overflow_p
, depth
+ 1))
8967 /* Return true if STMT is known to compute a non-negative value.
8968 If the return value is based on the assumption that signed overflow is
8969 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change
8970 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
8973 gimple_stmt_nonnegative_warnv_p (gimple
*stmt
, bool *strict_overflow_p
,
8976 switch (gimple_code (stmt
))
8979 return gimple_assign_nonnegative_warnv_p (stmt
, strict_overflow_p
,
8982 return gimple_call_nonnegative_warnv_p (stmt
, strict_overflow_p
,
8985 return gimple_phi_nonnegative_warnv_p (stmt
, strict_overflow_p
,
8992 /* Return true if the floating-point value computed by assignment STMT
8993 is known to have an integer value. We also allow +Inf, -Inf and NaN
8994 to be considered integer values. Return false for signaling NaN.
8996 DEPTH is the current nesting depth of the query. */
8999 gimple_assign_integer_valued_real_p (gimple
*stmt
, int depth
)
9001 enum tree_code code
= gimple_assign_rhs_code (stmt
);
9002 switch (get_gimple_rhs_class (code
))
9004 case GIMPLE_UNARY_RHS
:
9005 return integer_valued_real_unary_p (gimple_assign_rhs_code (stmt
),
9006 gimple_assign_rhs1 (stmt
), depth
);
9007 case GIMPLE_BINARY_RHS
:
9008 return integer_valued_real_binary_p (gimple_assign_rhs_code (stmt
),
9009 gimple_assign_rhs1 (stmt
),
9010 gimple_assign_rhs2 (stmt
), depth
);
9011 case GIMPLE_TERNARY_RHS
:
9013 case GIMPLE_SINGLE_RHS
:
9014 return integer_valued_real_single_p (gimple_assign_rhs1 (stmt
), depth
);
9015 case GIMPLE_INVALID_RHS
:
9021 /* Return true if the floating-point value computed by call STMT is known
9022 to have an integer value. We also allow +Inf, -Inf and NaN to be
9023 considered integer values. Return false for signaling NaN.
9025 DEPTH is the current nesting depth of the query. */
9028 gimple_call_integer_valued_real_p (gimple
*stmt
, int depth
)
9030 tree arg0
= (gimple_call_num_args (stmt
) > 0
9031 ? gimple_call_arg (stmt
, 0)
9033 tree arg1
= (gimple_call_num_args (stmt
) > 1
9034 ? gimple_call_arg (stmt
, 1)
9036 return integer_valued_real_call_p (gimple_call_combined_fn (stmt
),
9040 /* Return true if the floating-point result of phi STMT is known to have
9041 an integer value. We also allow +Inf, -Inf and NaN to be considered
9042 integer values. Return false for signaling NaN.
9044 DEPTH is the current nesting depth of the query. */
9047 gimple_phi_integer_valued_real_p (gimple
*stmt
, int depth
)
9049 for (unsigned i
= 0; i
< gimple_phi_num_args (stmt
); ++i
)
9051 tree arg
= gimple_phi_arg_def (stmt
, i
);
9052 if (!integer_valued_real_single_p (arg
, depth
+ 1))
9058 /* Return true if the floating-point value computed by STMT is known
9059 to have an integer value. We also allow +Inf, -Inf and NaN to be
9060 considered integer values. Return false for signaling NaN.
9062 DEPTH is the current nesting depth of the query. */
9065 gimple_stmt_integer_valued_real_p (gimple
*stmt
, int depth
)
9067 switch (gimple_code (stmt
))
9070 return gimple_assign_integer_valued_real_p (stmt
, depth
);
9072 return gimple_call_integer_valued_real_p (stmt
, depth
);
9074 return gimple_phi_integer_valued_real_p (stmt
, depth
);