1 /* Statement simplification on GIMPLE.
2 Copyright (C) 2010, 2011 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"
28 #include "tree-dump.h"
29 #include "tree-flow.h"
30 #include "tree-pass.h"
31 #include "tree-ssa-propagate.h"
33 #include "gimple-fold.h"
35 /* Return true when DECL can be referenced from current unit.
36 We can get declarations that are not possible to reference for
39 1) When analyzing C++ virtual tables.
40 C++ virtual tables do have known constructors even
41 when they are keyed to other compilation unit.
42 Those tables can contain pointers to methods and vars
43 in other units. Those methods have both STATIC and EXTERNAL
45 2) In WHOPR mode devirtualization might lead to reference
46 to method that was partitioned elsehwere.
47 In this case we have static VAR_DECL or FUNCTION_DECL
48 that has no corresponding callgraph/varpool node
50 3) COMDAT functions referred by external vtables that
51 we devirtualize only during final copmilation stage.
52 At this time we already decided that we will not output
53 the function body and thus we can't reference the symbol
57 can_refer_decl_in_current_unit_p (tree decl
)
59 struct varpool_node
*vnode
;
60 struct cgraph_node
*node
;
62 if (!TREE_STATIC (decl
) && !DECL_EXTERNAL (decl
))
64 /* External flag is set, so we deal with C++ reference
65 to static object from other file. */
66 if (DECL_EXTERNAL (decl
) && TREE_STATIC (decl
)
67 && TREE_CODE (decl
) == VAR_DECL
)
69 /* Just be sure it is not big in frontend setting
70 flags incorrectly. Those variables should never
72 gcc_checking_assert (!(vnode
= varpool_get_node (decl
))
73 || !vnode
->finalized
);
76 /* When function is public, we always can introduce new reference.
77 Exception are the COMDAT functions where introducing a direct
78 reference imply need to include function body in the curren tunit. */
79 if (TREE_PUBLIC (decl
) && !DECL_COMDAT (decl
))
81 /* We are not at ltrans stage; so don't worry about WHOPR.
82 Also when still gimplifying all referred comdat functions will be
84 ??? as observed in PR20991 for already optimized out comdat virtual functions
85 we may not neccesarily give up because the copy will be output elsewhere when
86 corresponding vtable is output. */
87 if (!flag_ltrans
&& (!DECL_COMDAT (decl
) || !cgraph_function_flags_ready
))
89 /* If we already output the function body, we are safe. */
90 if (TREE_ASM_WRITTEN (decl
))
92 if (TREE_CODE (decl
) == FUNCTION_DECL
)
94 node
= cgraph_get_node (decl
);
95 /* Check that we still have function body and that we didn't took
96 the decision to eliminate offline copy of the function yet.
97 The second is important when devirtualization happens during final
98 compilation stage when making a new reference no longer makes callee
100 if (!node
|| !node
->analyzed
|| node
->global
.inlined_to
)
103 else if (TREE_CODE (decl
) == VAR_DECL
)
105 vnode
= varpool_get_node (decl
);
106 if (!vnode
|| !vnode
->finalized
)
112 /* CVAL is value taken from DECL_INITIAL of variable. Try to transform it into
113 acceptable form for is_gimple_min_invariant. */
116 canonicalize_constructor_val (tree cval
)
119 if (TREE_CODE (cval
) == POINTER_PLUS_EXPR
120 && TREE_CODE (TREE_OPERAND (cval
, 1)) == INTEGER_CST
)
122 tree ptr
= TREE_OPERAND (cval
, 0);
123 if (is_gimple_min_invariant (ptr
))
124 cval
= build1_loc (EXPR_LOCATION (cval
),
125 ADDR_EXPR
, TREE_TYPE (ptr
),
126 fold_build2 (MEM_REF
, TREE_TYPE (TREE_TYPE (ptr
)),
128 fold_convert (ptr_type_node
,
129 TREE_OPERAND (cval
, 1))));
131 if (TREE_CODE (cval
) == ADDR_EXPR
)
133 tree base
= get_base_address (TREE_OPERAND (cval
, 0));
136 && (TREE_CODE (base
) == VAR_DECL
137 || TREE_CODE (base
) == FUNCTION_DECL
)
138 && !can_refer_decl_in_current_unit_p (base
))
140 if (cfun
&& base
&& TREE_CODE (base
) == VAR_DECL
)
141 add_referenced_var (base
);
142 /* Fixup types in global initializers. */
143 if (TREE_TYPE (TREE_TYPE (cval
)) != TREE_TYPE (TREE_OPERAND (cval
, 0)))
144 cval
= build_fold_addr_expr (TREE_OPERAND (cval
, 0));
149 /* If SYM is a constant variable with known value, return the value.
150 NULL_TREE is returned otherwise. */
153 get_symbol_constant_value (tree sym
)
155 if (const_value_known_p (sym
))
157 tree val
= DECL_INITIAL (sym
);
160 val
= canonicalize_constructor_val (val
);
161 if (val
&& is_gimple_min_invariant (val
))
166 /* Variables declared 'const' without an initializer
167 have zero as the initializer if they may not be
168 overridden at link or run time. */
170 && (INTEGRAL_TYPE_P (TREE_TYPE (sym
))
171 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (sym
))))
172 return build_zero_cst (TREE_TYPE (sym
));
180 /* Subroutine of fold_stmt. We perform several simplifications of the
181 memory reference tree EXPR and make sure to re-gimplify them properly
182 after propagation of constant addresses. IS_LHS is true if the
183 reference is supposed to be an lvalue. */
186 maybe_fold_reference (tree expr
, bool is_lhs
)
191 if ((TREE_CODE (expr
) == VIEW_CONVERT_EXPR
192 || TREE_CODE (expr
) == REALPART_EXPR
193 || TREE_CODE (expr
) == IMAGPART_EXPR
)
194 && CONSTANT_CLASS_P (TREE_OPERAND (expr
, 0)))
195 return fold_unary_loc (EXPR_LOCATION (expr
),
198 TREE_OPERAND (expr
, 0));
199 else if (TREE_CODE (expr
) == BIT_FIELD_REF
200 && CONSTANT_CLASS_P (TREE_OPERAND (expr
, 0)))
201 return fold_ternary_loc (EXPR_LOCATION (expr
),
204 TREE_OPERAND (expr
, 0),
205 TREE_OPERAND (expr
, 1),
206 TREE_OPERAND (expr
, 2));
208 while (handled_component_p (*t
))
209 t
= &TREE_OPERAND (*t
, 0);
211 /* Canonicalize MEM_REFs invariant address operand. Do this first
212 to avoid feeding non-canonical MEM_REFs elsewhere. */
213 if (TREE_CODE (*t
) == MEM_REF
214 && !is_gimple_mem_ref_addr (TREE_OPERAND (*t
, 0)))
216 bool volatile_p
= TREE_THIS_VOLATILE (*t
);
217 tree tem
= fold_binary (MEM_REF
, TREE_TYPE (*t
),
218 TREE_OPERAND (*t
, 0),
219 TREE_OPERAND (*t
, 1));
222 TREE_THIS_VOLATILE (tem
) = volatile_p
;
224 tem
= maybe_fold_reference (expr
, is_lhs
);
232 && (result
= fold_const_aggregate_ref (expr
))
233 && is_gimple_min_invariant (result
))
236 /* Fold back MEM_REFs to reference trees. */
237 if (TREE_CODE (*t
) == MEM_REF
238 && TREE_CODE (TREE_OPERAND (*t
, 0)) == ADDR_EXPR
239 && integer_zerop (TREE_OPERAND (*t
, 1))
240 && (TREE_THIS_VOLATILE (*t
)
241 == TREE_THIS_VOLATILE (TREE_OPERAND (TREE_OPERAND (*t
, 0), 0)))
242 && !TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (*t
, 1)))
243 && (TYPE_MAIN_VARIANT (TREE_TYPE (*t
))
244 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_OPERAND (*t
, 1)))))
245 /* We have to look out here to not drop a required conversion
246 from the rhs to the lhs if is_lhs, but we don't have the
247 rhs here to verify that. Thus require strict type
249 && types_compatible_p (TREE_TYPE (*t
),
250 TREE_TYPE (TREE_OPERAND
251 (TREE_OPERAND (*t
, 0), 0))))
254 *t
= TREE_OPERAND (TREE_OPERAND (*t
, 0), 0);
255 tem
= maybe_fold_reference (expr
, is_lhs
);
260 else if (TREE_CODE (*t
) == TARGET_MEM_REF
)
262 tree tem
= maybe_fold_tmr (*t
);
266 tem
= maybe_fold_reference (expr
, is_lhs
);
277 /* Attempt to fold an assignment statement pointed-to by SI. Returns a
278 replacement rhs for the statement or NULL_TREE if no simplification
279 could be made. It is assumed that the operands have been previously
283 fold_gimple_assign (gimple_stmt_iterator
*si
)
285 gimple stmt
= gsi_stmt (*si
);
286 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
287 location_t loc
= gimple_location (stmt
);
289 tree result
= NULL_TREE
;
291 switch (get_gimple_rhs_class (subcode
))
293 case GIMPLE_SINGLE_RHS
:
295 tree rhs
= gimple_assign_rhs1 (stmt
);
297 if (REFERENCE_CLASS_P (rhs
))
298 return maybe_fold_reference (rhs
, false);
300 else if (TREE_CODE (rhs
) == ADDR_EXPR
)
302 tree ref
= TREE_OPERAND (rhs
, 0);
303 tree tem
= maybe_fold_reference (ref
, true);
305 && TREE_CODE (tem
) == MEM_REF
306 && integer_zerop (TREE_OPERAND (tem
, 1)))
307 result
= fold_convert (TREE_TYPE (rhs
), TREE_OPERAND (tem
, 0));
309 result
= fold_convert (TREE_TYPE (rhs
),
310 build_fold_addr_expr_loc (loc
, tem
));
311 else if (TREE_CODE (ref
) == MEM_REF
312 && integer_zerop (TREE_OPERAND (ref
, 1)))
313 result
= fold_convert (TREE_TYPE (rhs
), TREE_OPERAND (ref
, 0));
316 else if (TREE_CODE (rhs
) == CONSTRUCTOR
317 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
318 && (CONSTRUCTOR_NELTS (rhs
)
319 == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs
))))
321 /* Fold a constant vector CONSTRUCTOR to VECTOR_CST. */
325 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
326 if (TREE_CODE (val
) != INTEGER_CST
327 && TREE_CODE (val
) != REAL_CST
328 && TREE_CODE (val
) != FIXED_CST
)
331 return build_vector_from_ctor (TREE_TYPE (rhs
),
332 CONSTRUCTOR_ELTS (rhs
));
335 else if (DECL_P (rhs
))
336 return unshare_expr (get_symbol_constant_value (rhs
));
338 /* If we couldn't fold the RHS, hand over to the generic
340 if (result
== NULL_TREE
)
343 /* Strip away useless type conversions. Both the NON_LVALUE_EXPR
344 that may have been added by fold, and "useless" type
345 conversions that might now be apparent due to propagation. */
346 STRIP_USELESS_TYPE_CONVERSION (result
);
348 if (result
!= rhs
&& valid_gimple_rhs_p (result
))
355 case GIMPLE_UNARY_RHS
:
357 tree rhs
= gimple_assign_rhs1 (stmt
);
359 result
= fold_unary_loc (loc
, subcode
, gimple_expr_type (stmt
), rhs
);
362 /* If the operation was a conversion do _not_ mark a
363 resulting constant with TREE_OVERFLOW if the original
364 constant was not. These conversions have implementation
365 defined behavior and retaining the TREE_OVERFLOW flag
366 here would confuse later passes such as VRP. */
367 if (CONVERT_EXPR_CODE_P (subcode
)
368 && TREE_CODE (result
) == INTEGER_CST
369 && TREE_CODE (rhs
) == INTEGER_CST
)
370 TREE_OVERFLOW (result
) = TREE_OVERFLOW (rhs
);
372 STRIP_USELESS_TYPE_CONVERSION (result
);
373 if (valid_gimple_rhs_p (result
))
379 case GIMPLE_BINARY_RHS
:
380 /* Try to canonicalize for boolean-typed X the comparisons
381 X == 0, X == 1, X != 0, and X != 1. */
382 if (gimple_assign_rhs_code (stmt
) == EQ_EXPR
383 || gimple_assign_rhs_code (stmt
) == NE_EXPR
)
385 tree lhs
= gimple_assign_lhs (stmt
);
386 tree op1
= gimple_assign_rhs1 (stmt
);
387 tree op2
= gimple_assign_rhs2 (stmt
);
388 tree type
= TREE_TYPE (op1
);
390 /* Check whether the comparison operands are of the same boolean
391 type as the result type is.
392 Check that second operand is an integer-constant with value
394 if (TREE_CODE (op2
) == INTEGER_CST
395 && (integer_zerop (op2
) || integer_onep (op2
))
396 && useless_type_conversion_p (TREE_TYPE (lhs
), type
))
398 enum tree_code cmp_code
= gimple_assign_rhs_code (stmt
);
399 bool is_logical_not
= false;
401 /* X == 0 and X != 1 is a logical-not.of X
402 X == 1 and X != 0 is X */
403 if ((cmp_code
== EQ_EXPR
&& integer_zerop (op2
))
404 || (cmp_code
== NE_EXPR
&& integer_onep (op2
)))
405 is_logical_not
= true;
407 if (is_logical_not
== false)
409 /* Only for one-bit precision typed X the transformation
410 !X -> ~X is valied. */
411 else if (TYPE_PRECISION (type
) == 1)
412 result
= build1_loc (gimple_location (stmt
), BIT_NOT_EXPR
,
414 /* Otherwise we use !X -> X ^ 1. */
416 result
= build2_loc (gimple_location (stmt
), BIT_XOR_EXPR
,
417 type
, op1
, build_int_cst (type
, 1));
423 result
= fold_binary_loc (loc
, subcode
,
424 TREE_TYPE (gimple_assign_lhs (stmt
)),
425 gimple_assign_rhs1 (stmt
),
426 gimple_assign_rhs2 (stmt
));
430 STRIP_USELESS_TYPE_CONVERSION (result
);
431 if (valid_gimple_rhs_p (result
))
436 case GIMPLE_TERNARY_RHS
:
437 /* Try to fold a conditional expression. */
438 if (gimple_assign_rhs_code (stmt
) == COND_EXPR
)
440 tree op0
= gimple_assign_rhs1 (stmt
);
443 location_t cond_loc
= gimple_location (stmt
);
445 if (COMPARISON_CLASS_P (op0
))
447 fold_defer_overflow_warnings ();
448 tem
= fold_binary_loc (cond_loc
,
449 TREE_CODE (op0
), TREE_TYPE (op0
),
450 TREE_OPERAND (op0
, 0),
451 TREE_OPERAND (op0
, 1));
452 /* This is actually a conditional expression, not a GIMPLE
453 conditional statement, however, the valid_gimple_rhs_p
454 test still applies. */
455 set
= (tem
&& is_gimple_condexpr (tem
)
456 && valid_gimple_rhs_p (tem
));
457 fold_undefer_overflow_warnings (set
, stmt
, 0);
459 else if (is_gimple_min_invariant (op0
))
468 result
= fold_build3_loc (cond_loc
, COND_EXPR
,
469 TREE_TYPE (gimple_assign_lhs (stmt
)), tem
,
470 gimple_assign_rhs2 (stmt
),
471 gimple_assign_rhs3 (stmt
));
475 result
= fold_ternary_loc (loc
, subcode
,
476 TREE_TYPE (gimple_assign_lhs (stmt
)),
477 gimple_assign_rhs1 (stmt
),
478 gimple_assign_rhs2 (stmt
),
479 gimple_assign_rhs3 (stmt
));
483 STRIP_USELESS_TYPE_CONVERSION (result
);
484 if (valid_gimple_rhs_p (result
))
489 case GIMPLE_INVALID_RHS
:
496 /* Attempt to fold a conditional statement. Return true if any changes were
497 made. We only attempt to fold the condition expression, and do not perform
498 any transformation that would require alteration of the cfg. It is
499 assumed that the operands have been previously folded. */
502 fold_gimple_cond (gimple stmt
)
504 tree result
= fold_binary_loc (gimple_location (stmt
),
505 gimple_cond_code (stmt
),
507 gimple_cond_lhs (stmt
),
508 gimple_cond_rhs (stmt
));
512 STRIP_USELESS_TYPE_CONVERSION (result
);
513 if (is_gimple_condexpr (result
) && valid_gimple_rhs_p (result
))
515 gimple_cond_set_condition_from_tree (stmt
, result
);
523 /* Convert EXPR into a GIMPLE value suitable for substitution on the
524 RHS of an assignment. Insert the necessary statements before
525 iterator *SI_P. The statement at *SI_P, which must be a GIMPLE_CALL
526 is replaced. If the call is expected to produces a result, then it
527 is replaced by an assignment of the new RHS to the result variable.
528 If the result is to be ignored, then the call is replaced by a
529 GIMPLE_NOP. A proper VDEF chain is retained by making the first
530 VUSE and the last VDEF of the whole sequence be the same as the replaced
531 statement and using new SSA names for stores in between. */
534 gimplify_and_update_call_from_tree (gimple_stmt_iterator
*si_p
, tree expr
)
537 tree tmp
= NULL_TREE
; /* Silence warning. */
538 gimple stmt
, new_stmt
;
539 gimple_stmt_iterator i
;
540 gimple_seq stmts
= gimple_seq_alloc();
541 struct gimplify_ctx gctx
;
543 gimple laststore
= NULL
;
546 stmt
= gsi_stmt (*si_p
);
548 gcc_assert (is_gimple_call (stmt
));
550 lhs
= gimple_call_lhs (stmt
);
551 reaching_vuse
= gimple_vuse (stmt
);
553 push_gimplify_context (&gctx
);
555 if (lhs
== NULL_TREE
)
557 gimplify_and_add (expr
, &stmts
);
558 /* We can end up with folding a memcpy of an empty class assignment
559 which gets optimized away by C++ gimplification. */
560 if (gimple_seq_empty_p (stmts
))
562 pop_gimplify_context (NULL
);
563 if (gimple_in_ssa_p (cfun
))
565 unlink_stmt_vdef (stmt
);
568 gsi_remove (si_p
, true);
573 tmp
= get_initialized_tmp_var (expr
, &stmts
, NULL
);
575 pop_gimplify_context (NULL
);
577 if (gimple_has_location (stmt
))
578 annotate_all_with_location (stmts
, gimple_location (stmt
));
580 /* The replacement can expose previously unreferenced variables. */
581 for (i
= gsi_start (stmts
); !gsi_end_p (i
); gsi_next (&i
))
585 gsi_insert_before (si_p
, last
, GSI_NEW_STMT
);
588 new_stmt
= gsi_stmt (i
);
589 if (gimple_in_ssa_p (cfun
))
591 find_new_referenced_vars (new_stmt
);
592 mark_symbols_for_renaming (new_stmt
);
594 /* If the new statement has a VUSE, update it with exact SSA name we
595 know will reach this one. */
596 if (gimple_vuse (new_stmt
))
598 /* If we've also seen a previous store create a new VDEF for
599 the latter one, and make that the new reaching VUSE. */
602 reaching_vuse
= make_ssa_name (gimple_vop (cfun
), laststore
);
603 gimple_set_vdef (laststore
, reaching_vuse
);
604 update_stmt (laststore
);
607 gimple_set_vuse (new_stmt
, reaching_vuse
);
608 gimple_set_modified (new_stmt
, true);
610 if (gimple_assign_single_p (new_stmt
)
611 && !is_gimple_reg (gimple_assign_lhs (new_stmt
)))
613 laststore
= new_stmt
;
618 if (lhs
== NULL_TREE
)
620 /* If we replace a call without LHS that has a VDEF and our new
621 sequence ends with a store we must make that store have the same
622 vdef in order not to break the sequencing. This can happen
623 for instance when folding memcpy calls into assignments. */
624 if (gimple_vdef (stmt
) && laststore
)
626 gimple_set_vdef (laststore
, gimple_vdef (stmt
));
627 if (TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
628 SSA_NAME_DEF_STMT (gimple_vdef (stmt
)) = laststore
;
629 update_stmt (laststore
);
631 else if (gimple_in_ssa_p (cfun
))
633 unlink_stmt_vdef (stmt
);
642 gsi_insert_before (si_p
, last
, GSI_NEW_STMT
);
645 if (laststore
&& is_gimple_reg (lhs
))
647 gimple_set_vdef (laststore
, gimple_vdef (stmt
));
648 update_stmt (laststore
);
649 if (TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
650 SSA_NAME_DEF_STMT (gimple_vdef (stmt
)) = laststore
;
655 reaching_vuse
= make_ssa_name (gimple_vop (cfun
), laststore
);
656 gimple_set_vdef (laststore
, reaching_vuse
);
657 update_stmt (laststore
);
660 new_stmt
= gimple_build_assign (lhs
, tmp
);
661 if (!is_gimple_reg (tmp
))
662 gimple_set_vuse (new_stmt
, reaching_vuse
);
663 if (!is_gimple_reg (lhs
))
665 gimple_set_vdef (new_stmt
, gimple_vdef (stmt
));
666 if (TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
667 SSA_NAME_DEF_STMT (gimple_vdef (stmt
)) = new_stmt
;
669 else if (reaching_vuse
== gimple_vuse (stmt
))
670 unlink_stmt_vdef (stmt
);
673 gimple_set_location (new_stmt
, gimple_location (stmt
));
674 gsi_replace (si_p
, new_stmt
, false);
677 /* Return the string length, maximum string length or maximum value of
679 If ARG is an SSA name variable, follow its use-def chains. If LENGTH
680 is not NULL and, for TYPE == 0, its value is not equal to the length
681 we determine or if we are unable to determine the length or value,
682 return false. VISITED is a bitmap of visited variables.
683 TYPE is 0 if string length should be returned, 1 for maximum string
684 length and 2 for maximum value ARG can have. */
687 get_maxval_strlen (tree arg
, tree
*length
, bitmap visited
, int type
)
692 if (TREE_CODE (arg
) != SSA_NAME
)
694 if (TREE_CODE (arg
) == COND_EXPR
)
695 return get_maxval_strlen (COND_EXPR_THEN (arg
), length
, visited
, type
)
696 && get_maxval_strlen (COND_EXPR_ELSE (arg
), length
, visited
, type
);
697 /* We can end up with &(*iftmp_1)[0] here as well, so handle it. */
698 else if (TREE_CODE (arg
) == ADDR_EXPR
699 && TREE_CODE (TREE_OPERAND (arg
, 0)) == ARRAY_REF
700 && integer_zerop (TREE_OPERAND (TREE_OPERAND (arg
, 0), 1)))
702 tree aop0
= TREE_OPERAND (TREE_OPERAND (arg
, 0), 0);
703 if (TREE_CODE (aop0
) == INDIRECT_REF
704 && TREE_CODE (TREE_OPERAND (aop0
, 0)) == SSA_NAME
)
705 return get_maxval_strlen (TREE_OPERAND (aop0
, 0),
706 length
, visited
, type
);
712 if (TREE_CODE (val
) != INTEGER_CST
713 || tree_int_cst_sgn (val
) < 0)
717 val
= c_strlen (arg
, 1);
725 if (TREE_CODE (*length
) != INTEGER_CST
726 || TREE_CODE (val
) != INTEGER_CST
)
729 if (tree_int_cst_lt (*length
, val
))
733 else if (simple_cst_equal (val
, *length
) != 1)
741 /* If we were already here, break the infinite cycle. */
742 if (!bitmap_set_bit (visited
, SSA_NAME_VERSION (arg
)))
746 def_stmt
= SSA_NAME_DEF_STMT (var
);
748 switch (gimple_code (def_stmt
))
751 /* The RHS of the statement defining VAR must either have a
752 constant length or come from another SSA_NAME with a constant
754 if (gimple_assign_single_p (def_stmt
)
755 || gimple_assign_unary_nop_p (def_stmt
))
757 tree rhs
= gimple_assign_rhs1 (def_stmt
);
758 return get_maxval_strlen (rhs
, length
, visited
, type
);
764 /* All the arguments of the PHI node must have the same constant
768 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
770 tree arg
= gimple_phi_arg (def_stmt
, i
)->def
;
772 /* If this PHI has itself as an argument, we cannot
773 determine the string length of this argument. However,
774 if we can find a constant string length for the other
775 PHI args then we can still be sure that this is a
776 constant string length. So be optimistic and just
777 continue with the next argument. */
778 if (arg
== gimple_phi_result (def_stmt
))
781 if (!get_maxval_strlen (arg
, length
, visited
, type
))
793 /* Fold builtin call in statement STMT. Returns a simplified tree.
794 We may return a non-constant expression, including another call
795 to a different function and with different arguments, e.g.,
796 substituting memcpy for strcpy when the string length is known.
797 Note that some builtins expand into inline code that may not
798 be valid in GIMPLE. Callers must take care. */
801 gimple_fold_builtin (gimple stmt
)
809 location_t loc
= gimple_location (stmt
);
811 gcc_assert (is_gimple_call (stmt
));
813 ignore
= (gimple_call_lhs (stmt
) == NULL
);
815 /* First try the generic builtin folder. If that succeeds, return the
817 result
= fold_call_stmt (stmt
, ignore
);
825 /* Ignore MD builtins. */
826 callee
= gimple_call_fndecl (stmt
);
827 if (DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_MD
)
830 /* If the builtin could not be folded, and it has no argument list,
832 nargs
= gimple_call_num_args (stmt
);
836 /* Limit the work only for builtins we know how to simplify. */
837 switch (DECL_FUNCTION_CODE (callee
))
839 case BUILT_IN_STRLEN
:
841 case BUILT_IN_FPUTS_UNLOCKED
:
845 case BUILT_IN_STRCPY
:
846 case BUILT_IN_STRNCPY
:
850 case BUILT_IN_MEMCPY_CHK
:
851 case BUILT_IN_MEMPCPY_CHK
:
852 case BUILT_IN_MEMMOVE_CHK
:
853 case BUILT_IN_MEMSET_CHK
:
854 case BUILT_IN_STRNCPY_CHK
:
858 case BUILT_IN_STRCPY_CHK
:
859 case BUILT_IN_STPCPY_CHK
:
863 case BUILT_IN_SNPRINTF_CHK
:
864 case BUILT_IN_VSNPRINTF_CHK
:
872 if (arg_idx
>= nargs
)
875 /* Try to use the dataflow information gathered by the CCP process. */
876 visited
= BITMAP_ALLOC (NULL
);
877 bitmap_clear (visited
);
879 memset (val
, 0, sizeof (val
));
880 a
= gimple_call_arg (stmt
, arg_idx
);
881 if (!get_maxval_strlen (a
, &val
[arg_idx
], visited
, type
))
882 val
[arg_idx
] = NULL_TREE
;
884 BITMAP_FREE (visited
);
887 switch (DECL_FUNCTION_CODE (callee
))
889 case BUILT_IN_STRLEN
:
890 if (val
[0] && nargs
== 1)
893 fold_convert (TREE_TYPE (gimple_call_lhs (stmt
)), val
[0]);
895 /* If the result is not a valid gimple value, or not a cast
896 of a valid gimple value, then we cannot use the result. */
897 if (is_gimple_val (new_val
)
898 || (CONVERT_EXPR_P (new_val
)
899 && is_gimple_val (TREE_OPERAND (new_val
, 0))))
904 case BUILT_IN_STRCPY
:
905 if (val
[1] && is_gimple_val (val
[1]) && nargs
== 2)
906 result
= fold_builtin_strcpy (loc
, callee
,
907 gimple_call_arg (stmt
, 0),
908 gimple_call_arg (stmt
, 1),
912 case BUILT_IN_STRNCPY
:
913 if (val
[1] && is_gimple_val (val
[1]) && nargs
== 3)
914 result
= fold_builtin_strncpy (loc
, callee
,
915 gimple_call_arg (stmt
, 0),
916 gimple_call_arg (stmt
, 1),
917 gimple_call_arg (stmt
, 2),
923 result
= fold_builtin_fputs (loc
, gimple_call_arg (stmt
, 0),
924 gimple_call_arg (stmt
, 1),
925 ignore
, false, val
[0]);
928 case BUILT_IN_FPUTS_UNLOCKED
:
930 result
= fold_builtin_fputs (loc
, gimple_call_arg (stmt
, 0),
931 gimple_call_arg (stmt
, 1),
932 ignore
, true, val
[0]);
935 case BUILT_IN_MEMCPY_CHK
:
936 case BUILT_IN_MEMPCPY_CHK
:
937 case BUILT_IN_MEMMOVE_CHK
:
938 case BUILT_IN_MEMSET_CHK
:
939 if (val
[2] && is_gimple_val (val
[2]) && nargs
== 4)
940 result
= fold_builtin_memory_chk (loc
, callee
,
941 gimple_call_arg (stmt
, 0),
942 gimple_call_arg (stmt
, 1),
943 gimple_call_arg (stmt
, 2),
944 gimple_call_arg (stmt
, 3),
946 DECL_FUNCTION_CODE (callee
));
949 case BUILT_IN_STRCPY_CHK
:
950 case BUILT_IN_STPCPY_CHK
:
951 if (val
[1] && is_gimple_val (val
[1]) && nargs
== 3)
952 result
= fold_builtin_stxcpy_chk (loc
, callee
,
953 gimple_call_arg (stmt
, 0),
954 gimple_call_arg (stmt
, 1),
955 gimple_call_arg (stmt
, 2),
957 DECL_FUNCTION_CODE (callee
));
960 case BUILT_IN_STRNCPY_CHK
:
961 if (val
[2] && is_gimple_val (val
[2]) && nargs
== 4)
962 result
= fold_builtin_strncpy_chk (loc
, gimple_call_arg (stmt
, 0),
963 gimple_call_arg (stmt
, 1),
964 gimple_call_arg (stmt
, 2),
965 gimple_call_arg (stmt
, 3),
969 case BUILT_IN_SNPRINTF_CHK
:
970 case BUILT_IN_VSNPRINTF_CHK
:
971 if (val
[1] && is_gimple_val (val
[1]))
972 result
= gimple_fold_builtin_snprintf_chk (stmt
, val
[1],
973 DECL_FUNCTION_CODE (callee
));
980 if (result
&& ignore
)
981 result
= fold_ignored_result (result
);
985 /* Generate code adjusting the first parameter of a call statement determined
989 gimple_adjust_this_by_delta (gimple_stmt_iterator
*gsi
, tree delta
)
991 gimple call_stmt
= gsi_stmt (*gsi
);
995 delta
= convert_to_ptrofftype (delta
);
996 gcc_assert (gimple_call_num_args (call_stmt
) >= 1);
997 parm
= gimple_call_arg (call_stmt
, 0);
998 gcc_assert (POINTER_TYPE_P (TREE_TYPE (parm
)));
999 tmp
= create_tmp_var (TREE_TYPE (parm
), NULL
);
1000 add_referenced_var (tmp
);
1002 tmp
= make_ssa_name (tmp
, NULL
);
1003 new_stmt
= gimple_build_assign_with_ops (POINTER_PLUS_EXPR
, tmp
, parm
, delta
);
1004 SSA_NAME_DEF_STMT (tmp
) = new_stmt
;
1005 gsi_insert_before (gsi
, new_stmt
, GSI_SAME_STMT
);
1006 gimple_call_set_arg (call_stmt
, 0, tmp
);
1009 /* Return a binfo to be used for devirtualization of calls based on an object
1010 represented by a declaration (i.e. a global or automatically allocated one)
1011 or NULL if it cannot be found or is not safe. CST is expected to be an
1012 ADDR_EXPR of such object or the function will return NULL. Currently it is
1013 safe to use such binfo only if it has no base binfo (i.e. no ancestors). */
1016 gimple_extract_devirt_binfo_from_cst (tree cst
)
1018 HOST_WIDE_INT offset
, size
, max_size
;
1019 tree base
, type
, expected_type
, binfo
;
1020 bool last_artificial
= false;
1022 if (!flag_devirtualize
1023 || TREE_CODE (cst
) != ADDR_EXPR
1024 || TREE_CODE (TREE_TYPE (TREE_TYPE (cst
))) != RECORD_TYPE
)
1027 cst
= TREE_OPERAND (cst
, 0);
1028 expected_type
= TREE_TYPE (cst
);
1029 base
= get_ref_base_and_extent (cst
, &offset
, &size
, &max_size
);
1030 type
= TREE_TYPE (base
);
1034 || TREE_CODE (type
) != RECORD_TYPE
)
1037 /* Find the sub-object the constant actually refers to and mark whether it is
1038 an artificial one (as opposed to a user-defined one). */
1041 HOST_WIDE_INT pos
, size
;
1044 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (expected_type
))
1049 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
1051 if (TREE_CODE (fld
) != FIELD_DECL
)
1054 pos
= int_bit_position (fld
);
1055 size
= tree_low_cst (DECL_SIZE (fld
), 1);
1056 if (pos
<= offset
&& (pos
+ size
) > offset
)
1059 if (!fld
|| TREE_CODE (TREE_TYPE (fld
)) != RECORD_TYPE
)
1062 last_artificial
= DECL_ARTIFICIAL (fld
);
1063 type
= TREE_TYPE (fld
);
1066 /* Artifical sub-objects are ancestors, we do not want to use them for
1067 devirtualization, at least not here. */
1068 if (last_artificial
)
1070 binfo
= TYPE_BINFO (type
);
1071 if (!binfo
|| BINFO_N_BASE_BINFOS (binfo
) > 0)
1077 /* Attempt to fold a call statement referenced by the statement iterator GSI.
1078 The statement may be replaced by another statement, e.g., if the call
1079 simplifies to a constant value. Return true if any changes were made.
1080 It is assumed that the operands have been previously folded. */
1083 gimple_fold_call (gimple_stmt_iterator
*gsi
, bool inplace
)
1085 gimple stmt
= gsi_stmt (*gsi
);
1088 /* Check for builtins that CCP can handle using information not
1089 available in the generic fold routines. */
1090 callee
= gimple_call_fndecl (stmt
);
1091 if (!inplace
&& callee
&& DECL_BUILT_IN (callee
))
1093 tree result
= gimple_fold_builtin (stmt
);
1097 if (!update_call_from_tree (gsi
, result
))
1098 gimplify_and_update_call_from_tree (gsi
, result
);
1103 /* Check for virtual calls that became direct calls. */
1104 callee
= gimple_call_fn (stmt
);
1105 if (callee
&& TREE_CODE (callee
) == OBJ_TYPE_REF
)
1107 tree binfo
, fndecl
, obj
;
1108 HOST_WIDE_INT token
;
1110 if (gimple_call_addr_fndecl (OBJ_TYPE_REF_EXPR (callee
)) != NULL_TREE
)
1112 gimple_call_set_fn (stmt
, OBJ_TYPE_REF_EXPR (callee
));
1116 obj
= OBJ_TYPE_REF_OBJECT (callee
);
1117 binfo
= gimple_extract_devirt_binfo_from_cst (obj
);
1120 token
= TREE_INT_CST_LOW (OBJ_TYPE_REF_TOKEN (callee
));
1121 fndecl
= gimple_get_virt_method_for_binfo (token
, binfo
);
1124 gimple_call_set_fndecl (stmt
, fndecl
);
1131 /* Worker for both fold_stmt and fold_stmt_inplace. The INPLACE argument
1132 distinguishes both cases. */
1135 fold_stmt_1 (gimple_stmt_iterator
*gsi
, bool inplace
)
1137 bool changed
= false;
1138 gimple stmt
= gsi_stmt (*gsi
);
1140 gimple_stmt_iterator gsinext
= *gsi
;
1143 gsi_next (&gsinext
);
1144 next_stmt
= gsi_end_p (gsinext
) ? NULL
: gsi_stmt (gsinext
);
1146 /* Fold the main computation performed by the statement. */
1147 switch (gimple_code (stmt
))
1151 unsigned old_num_ops
= gimple_num_ops (stmt
);
1152 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
1153 tree lhs
= gimple_assign_lhs (stmt
);
1155 /* First canonicalize operand order. This avoids building new
1156 trees if this is the only thing fold would later do. */
1157 if ((commutative_tree_code (subcode
)
1158 || commutative_ternary_tree_code (subcode
))
1159 && tree_swap_operands_p (gimple_assign_rhs1 (stmt
),
1160 gimple_assign_rhs2 (stmt
), false))
1162 tree tem
= gimple_assign_rhs1 (stmt
);
1163 gimple_assign_set_rhs1 (stmt
, gimple_assign_rhs2 (stmt
));
1164 gimple_assign_set_rhs2 (stmt
, tem
);
1167 new_rhs
= fold_gimple_assign (gsi
);
1169 && !useless_type_conversion_p (TREE_TYPE (lhs
),
1170 TREE_TYPE (new_rhs
)))
1171 new_rhs
= fold_convert (TREE_TYPE (lhs
), new_rhs
);
1174 || get_gimple_rhs_num_ops (TREE_CODE (new_rhs
)) < old_num_ops
))
1176 gimple_assign_set_rhs_from_tree (gsi
, new_rhs
);
1183 changed
|= fold_gimple_cond (stmt
);
1187 /* Fold *& in call arguments. */
1188 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1189 if (REFERENCE_CLASS_P (gimple_call_arg (stmt
, i
)))
1191 tree tmp
= maybe_fold_reference (gimple_call_arg (stmt
, i
), false);
1194 gimple_call_set_arg (stmt
, i
, tmp
);
1198 changed
|= gimple_fold_call (gsi
, inplace
);
1202 /* Fold *& in asm operands. */
1203 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
1205 tree link
= gimple_asm_output_op (stmt
, i
);
1206 tree op
= TREE_VALUE (link
);
1207 if (REFERENCE_CLASS_P (op
)
1208 && (op
= maybe_fold_reference (op
, true)) != NULL_TREE
)
1210 TREE_VALUE (link
) = op
;
1214 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
1216 tree link
= gimple_asm_input_op (stmt
, i
);
1217 tree op
= TREE_VALUE (link
);
1218 if (REFERENCE_CLASS_P (op
)
1219 && (op
= maybe_fold_reference (op
, false)) != NULL_TREE
)
1221 TREE_VALUE (link
) = op
;
1228 if (gimple_debug_bind_p (stmt
))
1230 tree val
= gimple_debug_bind_get_value (stmt
);
1232 && REFERENCE_CLASS_P (val
))
1234 tree tem
= maybe_fold_reference (val
, false);
1237 gimple_debug_bind_set_value (stmt
, tem
);
1247 /* If stmt folds into nothing and it was the last stmt in a bb,
1248 don't call gsi_stmt. */
1249 if (gsi_end_p (*gsi
))
1251 gcc_assert (next_stmt
== NULL
);
1255 stmt
= gsi_stmt (*gsi
);
1257 /* Fold *& on the lhs. Don't do this if stmt folded into nothing,
1258 as we'd changing the next stmt. */
1259 if (gimple_has_lhs (stmt
) && stmt
!= next_stmt
)
1261 tree lhs
= gimple_get_lhs (stmt
);
1262 if (lhs
&& REFERENCE_CLASS_P (lhs
))
1264 tree new_lhs
= maybe_fold_reference (lhs
, true);
1267 gimple_set_lhs (stmt
, new_lhs
);
1276 /* Fold the statement pointed to by GSI. In some cases, this function may
1277 replace the whole statement with a new one. Returns true iff folding
1279 The statement pointed to by GSI should be in valid gimple form but may
1280 be in unfolded state as resulting from for example constant propagation
1281 which can produce *&x = 0. */
1284 fold_stmt (gimple_stmt_iterator
*gsi
)
1286 return fold_stmt_1 (gsi
, false);
1289 /* Perform the minimal folding on statement *GSI. Only operations like
1290 *&x created by constant propagation are handled. The statement cannot
1291 be replaced with a new one. Return true if the statement was
1292 changed, false otherwise.
1293 The statement *GSI should be in valid gimple form but may
1294 be in unfolded state as resulting from for example constant propagation
1295 which can produce *&x = 0. */
1298 fold_stmt_inplace (gimple_stmt_iterator
*gsi
)
1300 gimple stmt
= gsi_stmt (*gsi
);
1301 bool changed
= fold_stmt_1 (gsi
, true);
1302 gcc_assert (gsi_stmt (*gsi
) == stmt
);
1306 /* Canonicalize and possibly invert the boolean EXPR; return NULL_TREE
1307 if EXPR is null or we don't know how.
1308 If non-null, the result always has boolean type. */
1311 canonicalize_bool (tree expr
, bool invert
)
1317 if (integer_nonzerop (expr
))
1318 return boolean_false_node
;
1319 else if (integer_zerop (expr
))
1320 return boolean_true_node
;
1321 else if (TREE_CODE (expr
) == SSA_NAME
)
1322 return fold_build2 (EQ_EXPR
, boolean_type_node
, expr
,
1323 build_int_cst (TREE_TYPE (expr
), 0));
1324 else if (TREE_CODE_CLASS (TREE_CODE (expr
)) == tcc_comparison
)
1325 return fold_build2 (invert_tree_comparison (TREE_CODE (expr
), false),
1327 TREE_OPERAND (expr
, 0),
1328 TREE_OPERAND (expr
, 1));
1334 if (TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
)
1336 if (integer_nonzerop (expr
))
1337 return boolean_true_node
;
1338 else if (integer_zerop (expr
))
1339 return boolean_false_node
;
1340 else if (TREE_CODE (expr
) == SSA_NAME
)
1341 return fold_build2 (NE_EXPR
, boolean_type_node
, expr
,
1342 build_int_cst (TREE_TYPE (expr
), 0));
1343 else if (TREE_CODE_CLASS (TREE_CODE (expr
)) == tcc_comparison
)
1344 return fold_build2 (TREE_CODE (expr
),
1346 TREE_OPERAND (expr
, 0),
1347 TREE_OPERAND (expr
, 1));
1353 /* Check to see if a boolean expression EXPR is logically equivalent to the
1354 comparison (OP1 CODE OP2). Check for various identities involving
1358 same_bool_comparison_p (const_tree expr
, enum tree_code code
,
1359 const_tree op1
, const_tree op2
)
1363 /* The obvious case. */
1364 if (TREE_CODE (expr
) == code
1365 && operand_equal_p (TREE_OPERAND (expr
, 0), op1
, 0)
1366 && operand_equal_p (TREE_OPERAND (expr
, 1), op2
, 0))
1369 /* Check for comparing (name, name != 0) and the case where expr
1370 is an SSA_NAME with a definition matching the comparison. */
1371 if (TREE_CODE (expr
) == SSA_NAME
1372 && TREE_CODE (TREE_TYPE (expr
)) == BOOLEAN_TYPE
)
1374 if (operand_equal_p (expr
, op1
, 0))
1375 return ((code
== NE_EXPR
&& integer_zerop (op2
))
1376 || (code
== EQ_EXPR
&& integer_nonzerop (op2
)));
1377 s
= SSA_NAME_DEF_STMT (expr
);
1378 if (is_gimple_assign (s
)
1379 && gimple_assign_rhs_code (s
) == code
1380 && operand_equal_p (gimple_assign_rhs1 (s
), op1
, 0)
1381 && operand_equal_p (gimple_assign_rhs2 (s
), op2
, 0))
1385 /* If op1 is of the form (name != 0) or (name == 0), and the definition
1386 of name is a comparison, recurse. */
1387 if (TREE_CODE (op1
) == SSA_NAME
1388 && TREE_CODE (TREE_TYPE (op1
)) == BOOLEAN_TYPE
)
1390 s
= SSA_NAME_DEF_STMT (op1
);
1391 if (is_gimple_assign (s
)
1392 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
)
1394 enum tree_code c
= gimple_assign_rhs_code (s
);
1395 if ((c
== NE_EXPR
&& integer_zerop (op2
))
1396 || (c
== EQ_EXPR
&& integer_nonzerop (op2
)))
1397 return same_bool_comparison_p (expr
, c
,
1398 gimple_assign_rhs1 (s
),
1399 gimple_assign_rhs2 (s
));
1400 if ((c
== EQ_EXPR
&& integer_zerop (op2
))
1401 || (c
== NE_EXPR
&& integer_nonzerop (op2
)))
1402 return same_bool_comparison_p (expr
,
1403 invert_tree_comparison (c
, false),
1404 gimple_assign_rhs1 (s
),
1405 gimple_assign_rhs2 (s
));
1411 /* Check to see if two boolean expressions OP1 and OP2 are logically
1415 same_bool_result_p (const_tree op1
, const_tree op2
)
1417 /* Simple cases first. */
1418 if (operand_equal_p (op1
, op2
, 0))
1421 /* Check the cases where at least one of the operands is a comparison.
1422 These are a bit smarter than operand_equal_p in that they apply some
1423 identifies on SSA_NAMEs. */
1424 if (TREE_CODE_CLASS (TREE_CODE (op2
)) == tcc_comparison
1425 && same_bool_comparison_p (op1
, TREE_CODE (op2
),
1426 TREE_OPERAND (op2
, 0),
1427 TREE_OPERAND (op2
, 1)))
1429 if (TREE_CODE_CLASS (TREE_CODE (op1
)) == tcc_comparison
1430 && same_bool_comparison_p (op2
, TREE_CODE (op1
),
1431 TREE_OPERAND (op1
, 0),
1432 TREE_OPERAND (op1
, 1)))
1439 /* Forward declarations for some mutually recursive functions. */
1442 and_comparisons_1 (enum tree_code code1
, tree op1a
, tree op1b
,
1443 enum tree_code code2
, tree op2a
, tree op2b
);
1445 and_var_with_comparison (tree var
, bool invert
,
1446 enum tree_code code2
, tree op2a
, tree op2b
);
1448 and_var_with_comparison_1 (gimple stmt
,
1449 enum tree_code code2
, tree op2a
, tree op2b
);
1451 or_comparisons_1 (enum tree_code code1
, tree op1a
, tree op1b
,
1452 enum tree_code code2
, tree op2a
, tree op2b
);
1454 or_var_with_comparison (tree var
, bool invert
,
1455 enum tree_code code2
, tree op2a
, tree op2b
);
1457 or_var_with_comparison_1 (gimple stmt
,
1458 enum tree_code code2
, tree op2a
, tree op2b
);
1460 /* Helper function for and_comparisons_1: try to simplify the AND of the
1461 ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
1462 If INVERT is true, invert the value of the VAR before doing the AND.
1463 Return NULL_EXPR if we can't simplify this to a single expression. */
1466 and_var_with_comparison (tree var
, bool invert
,
1467 enum tree_code code2
, tree op2a
, tree op2b
)
1470 gimple stmt
= SSA_NAME_DEF_STMT (var
);
1472 /* We can only deal with variables whose definitions are assignments. */
1473 if (!is_gimple_assign (stmt
))
1476 /* If we have an inverted comparison, apply DeMorgan's law and rewrite
1477 !var AND (op2a code2 op2b) => !(var OR !(op2a code2 op2b))
1478 Then we only have to consider the simpler non-inverted cases. */
1480 t
= or_var_with_comparison_1 (stmt
,
1481 invert_tree_comparison (code2
, false),
1484 t
= and_var_with_comparison_1 (stmt
, code2
, op2a
, op2b
);
1485 return canonicalize_bool (t
, invert
);
1488 /* Try to simplify the AND of the ssa variable defined by the assignment
1489 STMT with the comparison specified by (OP2A CODE2 OP2B).
1490 Return NULL_EXPR if we can't simplify this to a single expression. */
1493 and_var_with_comparison_1 (gimple stmt
,
1494 enum tree_code code2
, tree op2a
, tree op2b
)
1496 tree var
= gimple_assign_lhs (stmt
);
1497 tree true_test_var
= NULL_TREE
;
1498 tree false_test_var
= NULL_TREE
;
1499 enum tree_code innercode
= gimple_assign_rhs_code (stmt
);
1501 /* Check for identities like (var AND (var == 0)) => false. */
1502 if (TREE_CODE (op2a
) == SSA_NAME
1503 && TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
)
1505 if ((code2
== NE_EXPR
&& integer_zerop (op2b
))
1506 || (code2
== EQ_EXPR
&& integer_nonzerop (op2b
)))
1508 true_test_var
= op2a
;
1509 if (var
== true_test_var
)
1512 else if ((code2
== EQ_EXPR
&& integer_zerop (op2b
))
1513 || (code2
== NE_EXPR
&& integer_nonzerop (op2b
)))
1515 false_test_var
= op2a
;
1516 if (var
== false_test_var
)
1517 return boolean_false_node
;
1521 /* If the definition is a comparison, recurse on it. */
1522 if (TREE_CODE_CLASS (innercode
) == tcc_comparison
)
1524 tree t
= and_comparisons_1 (innercode
,
1525 gimple_assign_rhs1 (stmt
),
1526 gimple_assign_rhs2 (stmt
),
1534 /* If the definition is an AND or OR expression, we may be able to
1535 simplify by reassociating. */
1536 if (TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
1537 && (innercode
== BIT_AND_EXPR
|| innercode
== BIT_IOR_EXPR
))
1539 tree inner1
= gimple_assign_rhs1 (stmt
);
1540 tree inner2
= gimple_assign_rhs2 (stmt
);
1543 tree partial
= NULL_TREE
;
1544 bool is_and
= (innercode
== BIT_AND_EXPR
);
1546 /* Check for boolean identities that don't require recursive examination
1548 inner1 AND (inner1 AND inner2) => inner1 AND inner2 => var
1549 inner1 AND (inner1 OR inner2) => inner1
1550 !inner1 AND (inner1 AND inner2) => false
1551 !inner1 AND (inner1 OR inner2) => !inner1 AND inner2
1552 Likewise for similar cases involving inner2. */
1553 if (inner1
== true_test_var
)
1554 return (is_and
? var
: inner1
);
1555 else if (inner2
== true_test_var
)
1556 return (is_and
? var
: inner2
);
1557 else if (inner1
== false_test_var
)
1559 ? boolean_false_node
1560 : and_var_with_comparison (inner2
, false, code2
, op2a
, op2b
));
1561 else if (inner2
== false_test_var
)
1563 ? boolean_false_node
1564 : and_var_with_comparison (inner1
, false, code2
, op2a
, op2b
));
1566 /* Next, redistribute/reassociate the AND across the inner tests.
1567 Compute the first partial result, (inner1 AND (op2a code op2b)) */
1568 if (TREE_CODE (inner1
) == SSA_NAME
1569 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner1
))
1570 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
1571 && (t
= maybe_fold_and_comparisons (gimple_assign_rhs_code (s
),
1572 gimple_assign_rhs1 (s
),
1573 gimple_assign_rhs2 (s
),
1574 code2
, op2a
, op2b
)))
1576 /* Handle the AND case, where we are reassociating:
1577 (inner1 AND inner2) AND (op2a code2 op2b)
1579 If the partial result t is a constant, we win. Otherwise
1580 continue on to try reassociating with the other inner test. */
1583 if (integer_onep (t
))
1585 else if (integer_zerop (t
))
1586 return boolean_false_node
;
1589 /* Handle the OR case, where we are redistributing:
1590 (inner1 OR inner2) AND (op2a code2 op2b)
1591 => (t OR (inner2 AND (op2a code2 op2b))) */
1592 else if (integer_onep (t
))
1593 return boolean_true_node
;
1595 /* Save partial result for later. */
1599 /* Compute the second partial result, (inner2 AND (op2a code op2b)) */
1600 if (TREE_CODE (inner2
) == SSA_NAME
1601 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner2
))
1602 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
1603 && (t
= maybe_fold_and_comparisons (gimple_assign_rhs_code (s
),
1604 gimple_assign_rhs1 (s
),
1605 gimple_assign_rhs2 (s
),
1606 code2
, op2a
, op2b
)))
1608 /* Handle the AND case, where we are reassociating:
1609 (inner1 AND inner2) AND (op2a code2 op2b)
1610 => (inner1 AND t) */
1613 if (integer_onep (t
))
1615 else if (integer_zerop (t
))
1616 return boolean_false_node
;
1617 /* If both are the same, we can apply the identity
1619 else if (partial
&& same_bool_result_p (t
, partial
))
1623 /* Handle the OR case. where we are redistributing:
1624 (inner1 OR inner2) AND (op2a code2 op2b)
1625 => (t OR (inner1 AND (op2a code2 op2b)))
1626 => (t OR partial) */
1629 if (integer_onep (t
))
1630 return boolean_true_node
;
1633 /* We already got a simplification for the other
1634 operand to the redistributed OR expression. The
1635 interesting case is when at least one is false.
1636 Or, if both are the same, we can apply the identity
1638 if (integer_zerop (partial
))
1640 else if (integer_zerop (t
))
1642 else if (same_bool_result_p (t
, partial
))
1651 /* Try to simplify the AND of two comparisons defined by
1652 (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
1653 If this can be done without constructing an intermediate value,
1654 return the resulting tree; otherwise NULL_TREE is returned.
1655 This function is deliberately asymmetric as it recurses on SSA_DEFs
1656 in the first comparison but not the second. */
1659 and_comparisons_1 (enum tree_code code1
, tree op1a
, tree op1b
,
1660 enum tree_code code2
, tree op2a
, tree op2b
)
1662 /* First check for ((x CODE1 y) AND (x CODE2 y)). */
1663 if (operand_equal_p (op1a
, op2a
, 0)
1664 && operand_equal_p (op1b
, op2b
, 0))
1666 /* Result will be either NULL_TREE, or a combined comparison. */
1667 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
1668 TRUTH_ANDIF_EXPR
, code1
, code2
,
1669 boolean_type_node
, op1a
, op1b
);
1674 /* Likewise the swapped case of the above. */
1675 if (operand_equal_p (op1a
, op2b
, 0)
1676 && operand_equal_p (op1b
, op2a
, 0))
1678 /* Result will be either NULL_TREE, or a combined comparison. */
1679 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
1680 TRUTH_ANDIF_EXPR
, code1
,
1681 swap_tree_comparison (code2
),
1682 boolean_type_node
, op1a
, op1b
);
1687 /* If both comparisons are of the same value against constants, we might
1688 be able to merge them. */
1689 if (operand_equal_p (op1a
, op2a
, 0)
1690 && TREE_CODE (op1b
) == INTEGER_CST
1691 && TREE_CODE (op2b
) == INTEGER_CST
)
1693 int cmp
= tree_int_cst_compare (op1b
, op2b
);
1695 /* If we have (op1a == op1b), we should either be able to
1696 return that or FALSE, depending on whether the constant op1b
1697 also satisfies the other comparison against op2b. */
1698 if (code1
== EQ_EXPR
)
1704 case EQ_EXPR
: val
= (cmp
== 0); break;
1705 case NE_EXPR
: val
= (cmp
!= 0); break;
1706 case LT_EXPR
: val
= (cmp
< 0); break;
1707 case GT_EXPR
: val
= (cmp
> 0); break;
1708 case LE_EXPR
: val
= (cmp
<= 0); break;
1709 case GE_EXPR
: val
= (cmp
>= 0); break;
1710 default: done
= false;
1715 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
1717 return boolean_false_node
;
1720 /* Likewise if the second comparison is an == comparison. */
1721 else if (code2
== EQ_EXPR
)
1727 case EQ_EXPR
: val
= (cmp
== 0); break;
1728 case NE_EXPR
: val
= (cmp
!= 0); break;
1729 case LT_EXPR
: val
= (cmp
> 0); break;
1730 case GT_EXPR
: val
= (cmp
< 0); break;
1731 case LE_EXPR
: val
= (cmp
>= 0); break;
1732 case GE_EXPR
: val
= (cmp
<= 0); break;
1733 default: done
= false;
1738 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
1740 return boolean_false_node
;
1744 /* Same business with inequality tests. */
1745 else if (code1
== NE_EXPR
)
1750 case EQ_EXPR
: val
= (cmp
!= 0); break;
1751 case NE_EXPR
: val
= (cmp
== 0); break;
1752 case LT_EXPR
: val
= (cmp
>= 0); break;
1753 case GT_EXPR
: val
= (cmp
<= 0); break;
1754 case LE_EXPR
: val
= (cmp
> 0); break;
1755 case GE_EXPR
: val
= (cmp
< 0); break;
1760 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
1762 else if (code2
== NE_EXPR
)
1767 case EQ_EXPR
: val
= (cmp
== 0); break;
1768 case NE_EXPR
: val
= (cmp
!= 0); break;
1769 case LT_EXPR
: val
= (cmp
<= 0); break;
1770 case GT_EXPR
: val
= (cmp
>= 0); break;
1771 case LE_EXPR
: val
= (cmp
< 0); break;
1772 case GE_EXPR
: val
= (cmp
> 0); break;
1777 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
1780 /* Chose the more restrictive of two < or <= comparisons. */
1781 else if ((code1
== LT_EXPR
|| code1
== LE_EXPR
)
1782 && (code2
== LT_EXPR
|| code2
== LE_EXPR
))
1784 if ((cmp
< 0) || (cmp
== 0 && code1
== LT_EXPR
))
1785 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
1787 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
1790 /* Likewise chose the more restrictive of two > or >= comparisons. */
1791 else if ((code1
== GT_EXPR
|| code1
== GE_EXPR
)
1792 && (code2
== GT_EXPR
|| code2
== GE_EXPR
))
1794 if ((cmp
> 0) || (cmp
== 0 && code1
== GT_EXPR
))
1795 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
1797 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
1800 /* Check for singleton ranges. */
1802 && ((code1
== LE_EXPR
&& code2
== GE_EXPR
)
1803 || (code1
== GE_EXPR
&& code2
== LE_EXPR
)))
1804 return fold_build2 (EQ_EXPR
, boolean_type_node
, op1a
, op2b
);
1806 /* Check for disjoint ranges. */
1808 && (code1
== LT_EXPR
|| code1
== LE_EXPR
)
1809 && (code2
== GT_EXPR
|| code2
== GE_EXPR
))
1810 return boolean_false_node
;
1812 && (code1
== GT_EXPR
|| code1
== GE_EXPR
)
1813 && (code2
== LT_EXPR
|| code2
== LE_EXPR
))
1814 return boolean_false_node
;
1817 /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
1818 NAME's definition is a truth value. See if there are any simplifications
1819 that can be done against the NAME's definition. */
1820 if (TREE_CODE (op1a
) == SSA_NAME
1821 && (code1
== NE_EXPR
|| code1
== EQ_EXPR
)
1822 && (integer_zerop (op1b
) || integer_onep (op1b
)))
1824 bool invert
= ((code1
== EQ_EXPR
&& integer_zerop (op1b
))
1825 || (code1
== NE_EXPR
&& integer_onep (op1b
)));
1826 gimple stmt
= SSA_NAME_DEF_STMT (op1a
);
1827 switch (gimple_code (stmt
))
1830 /* Try to simplify by copy-propagating the definition. */
1831 return and_var_with_comparison (op1a
, invert
, code2
, op2a
, op2b
);
1834 /* If every argument to the PHI produces the same result when
1835 ANDed with the second comparison, we win.
1836 Do not do this unless the type is bool since we need a bool
1837 result here anyway. */
1838 if (TREE_CODE (TREE_TYPE (op1a
)) == BOOLEAN_TYPE
)
1840 tree result
= NULL_TREE
;
1842 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
1844 tree arg
= gimple_phi_arg_def (stmt
, i
);
1846 /* If this PHI has itself as an argument, ignore it.
1847 If all the other args produce the same result,
1849 if (arg
== gimple_phi_result (stmt
))
1851 else if (TREE_CODE (arg
) == INTEGER_CST
)
1853 if (invert
? integer_nonzerop (arg
) : integer_zerop (arg
))
1856 result
= boolean_false_node
;
1857 else if (!integer_zerop (result
))
1861 result
= fold_build2 (code2
, boolean_type_node
,
1863 else if (!same_bool_comparison_p (result
,
1867 else if (TREE_CODE (arg
) == SSA_NAME
1868 && !SSA_NAME_IS_DEFAULT_DEF (arg
))
1871 gimple def_stmt
= SSA_NAME_DEF_STMT (arg
);
1872 /* In simple cases we can look through PHI nodes,
1873 but we have to be careful with loops.
1875 if (! dom_info_available_p (CDI_DOMINATORS
)
1876 || gimple_bb (def_stmt
) == gimple_bb (stmt
)
1877 || dominated_by_p (CDI_DOMINATORS
,
1878 gimple_bb (def_stmt
),
1881 temp
= and_var_with_comparison (arg
, invert
, code2
,
1887 else if (!same_bool_result_p (result
, temp
))
1903 /* Try to simplify the AND of two comparisons, specified by
1904 (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
1905 If this can be simplified to a single expression (without requiring
1906 introducing more SSA variables to hold intermediate values),
1907 return the resulting tree. Otherwise return NULL_TREE.
1908 If the result expression is non-null, it has boolean type. */
1911 maybe_fold_and_comparisons (enum tree_code code1
, tree op1a
, tree op1b
,
1912 enum tree_code code2
, tree op2a
, tree op2b
)
1914 tree t
= and_comparisons_1 (code1
, op1a
, op1b
, code2
, op2a
, op2b
);
1918 return and_comparisons_1 (code2
, op2a
, op2b
, code1
, op1a
, op1b
);
1921 /* Helper function for or_comparisons_1: try to simplify the OR of the
1922 ssa variable VAR with the comparison specified by (OP2A CODE2 OP2B).
1923 If INVERT is true, invert the value of VAR before doing the OR.
1924 Return NULL_EXPR if we can't simplify this to a single expression. */
1927 or_var_with_comparison (tree var
, bool invert
,
1928 enum tree_code code2
, tree op2a
, tree op2b
)
1931 gimple stmt
= SSA_NAME_DEF_STMT (var
);
1933 /* We can only deal with variables whose definitions are assignments. */
1934 if (!is_gimple_assign (stmt
))
1937 /* If we have an inverted comparison, apply DeMorgan's law and rewrite
1938 !var OR (op2a code2 op2b) => !(var AND !(op2a code2 op2b))
1939 Then we only have to consider the simpler non-inverted cases. */
1941 t
= and_var_with_comparison_1 (stmt
,
1942 invert_tree_comparison (code2
, false),
1945 t
= or_var_with_comparison_1 (stmt
, code2
, op2a
, op2b
);
1946 return canonicalize_bool (t
, invert
);
1949 /* Try to simplify the OR of the ssa variable defined by the assignment
1950 STMT with the comparison specified by (OP2A CODE2 OP2B).
1951 Return NULL_EXPR if we can't simplify this to a single expression. */
1954 or_var_with_comparison_1 (gimple stmt
,
1955 enum tree_code code2
, tree op2a
, tree op2b
)
1957 tree var
= gimple_assign_lhs (stmt
);
1958 tree true_test_var
= NULL_TREE
;
1959 tree false_test_var
= NULL_TREE
;
1960 enum tree_code innercode
= gimple_assign_rhs_code (stmt
);
1962 /* Check for identities like (var OR (var != 0)) => true . */
1963 if (TREE_CODE (op2a
) == SSA_NAME
1964 && TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
)
1966 if ((code2
== NE_EXPR
&& integer_zerop (op2b
))
1967 || (code2
== EQ_EXPR
&& integer_nonzerop (op2b
)))
1969 true_test_var
= op2a
;
1970 if (var
== true_test_var
)
1973 else if ((code2
== EQ_EXPR
&& integer_zerop (op2b
))
1974 || (code2
== NE_EXPR
&& integer_nonzerop (op2b
)))
1976 false_test_var
= op2a
;
1977 if (var
== false_test_var
)
1978 return boolean_true_node
;
1982 /* If the definition is a comparison, recurse on it. */
1983 if (TREE_CODE_CLASS (innercode
) == tcc_comparison
)
1985 tree t
= or_comparisons_1 (innercode
,
1986 gimple_assign_rhs1 (stmt
),
1987 gimple_assign_rhs2 (stmt
),
1995 /* If the definition is an AND or OR expression, we may be able to
1996 simplify by reassociating. */
1997 if (TREE_CODE (TREE_TYPE (var
)) == BOOLEAN_TYPE
1998 && (innercode
== BIT_AND_EXPR
|| innercode
== BIT_IOR_EXPR
))
2000 tree inner1
= gimple_assign_rhs1 (stmt
);
2001 tree inner2
= gimple_assign_rhs2 (stmt
);
2004 tree partial
= NULL_TREE
;
2005 bool is_or
= (innercode
== BIT_IOR_EXPR
);
2007 /* Check for boolean identities that don't require recursive examination
2009 inner1 OR (inner1 OR inner2) => inner1 OR inner2 => var
2010 inner1 OR (inner1 AND inner2) => inner1
2011 !inner1 OR (inner1 OR inner2) => true
2012 !inner1 OR (inner1 AND inner2) => !inner1 OR inner2
2014 if (inner1
== true_test_var
)
2015 return (is_or
? var
: inner1
);
2016 else if (inner2
== true_test_var
)
2017 return (is_or
? var
: inner2
);
2018 else if (inner1
== false_test_var
)
2021 : or_var_with_comparison (inner2
, false, code2
, op2a
, op2b
));
2022 else if (inner2
== false_test_var
)
2025 : or_var_with_comparison (inner1
, false, code2
, op2a
, op2b
));
2027 /* Next, redistribute/reassociate the OR across the inner tests.
2028 Compute the first partial result, (inner1 OR (op2a code op2b)) */
2029 if (TREE_CODE (inner1
) == SSA_NAME
2030 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner1
))
2031 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
2032 && (t
= maybe_fold_or_comparisons (gimple_assign_rhs_code (s
),
2033 gimple_assign_rhs1 (s
),
2034 gimple_assign_rhs2 (s
),
2035 code2
, op2a
, op2b
)))
2037 /* Handle the OR case, where we are reassociating:
2038 (inner1 OR inner2) OR (op2a code2 op2b)
2040 If the partial result t is a constant, we win. Otherwise
2041 continue on to try reassociating with the other inner test. */
2044 if (integer_onep (t
))
2045 return boolean_true_node
;
2046 else if (integer_zerop (t
))
2050 /* Handle the AND case, where we are redistributing:
2051 (inner1 AND inner2) OR (op2a code2 op2b)
2052 => (t AND (inner2 OR (op2a code op2b))) */
2053 else if (integer_zerop (t
))
2054 return boolean_false_node
;
2056 /* Save partial result for later. */
2060 /* Compute the second partial result, (inner2 OR (op2a code op2b)) */
2061 if (TREE_CODE (inner2
) == SSA_NAME
2062 && is_gimple_assign (s
= SSA_NAME_DEF_STMT (inner2
))
2063 && TREE_CODE_CLASS (gimple_assign_rhs_code (s
)) == tcc_comparison
2064 && (t
= maybe_fold_or_comparisons (gimple_assign_rhs_code (s
),
2065 gimple_assign_rhs1 (s
),
2066 gimple_assign_rhs2 (s
),
2067 code2
, op2a
, op2b
)))
2069 /* Handle the OR case, where we are reassociating:
2070 (inner1 OR inner2) OR (op2a code2 op2b)
2072 => (t OR partial) */
2075 if (integer_zerop (t
))
2077 else if (integer_onep (t
))
2078 return boolean_true_node
;
2079 /* If both are the same, we can apply the identity
2081 else if (partial
&& same_bool_result_p (t
, partial
))
2085 /* Handle the AND case, where we are redistributing:
2086 (inner1 AND inner2) OR (op2a code2 op2b)
2087 => (t AND (inner1 OR (op2a code2 op2b)))
2088 => (t AND partial) */
2091 if (integer_zerop (t
))
2092 return boolean_false_node
;
2095 /* We already got a simplification for the other
2096 operand to the redistributed AND expression. The
2097 interesting case is when at least one is true.
2098 Or, if both are the same, we can apply the identity
2100 if (integer_onep (partial
))
2102 else if (integer_onep (t
))
2104 else if (same_bool_result_p (t
, partial
))
2113 /* Try to simplify the OR of two comparisons defined by
2114 (OP1A CODE1 OP1B) and (OP2A CODE2 OP2B), respectively.
2115 If this can be done without constructing an intermediate value,
2116 return the resulting tree; otherwise NULL_TREE is returned.
2117 This function is deliberately asymmetric as it recurses on SSA_DEFs
2118 in the first comparison but not the second. */
2121 or_comparisons_1 (enum tree_code code1
, tree op1a
, tree op1b
,
2122 enum tree_code code2
, tree op2a
, tree op2b
)
2124 /* First check for ((x CODE1 y) OR (x CODE2 y)). */
2125 if (operand_equal_p (op1a
, op2a
, 0)
2126 && operand_equal_p (op1b
, op2b
, 0))
2128 /* Result will be either NULL_TREE, or a combined comparison. */
2129 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
2130 TRUTH_ORIF_EXPR
, code1
, code2
,
2131 boolean_type_node
, op1a
, op1b
);
2136 /* Likewise the swapped case of the above. */
2137 if (operand_equal_p (op1a
, op2b
, 0)
2138 && operand_equal_p (op1b
, op2a
, 0))
2140 /* Result will be either NULL_TREE, or a combined comparison. */
2141 tree t
= combine_comparisons (UNKNOWN_LOCATION
,
2142 TRUTH_ORIF_EXPR
, code1
,
2143 swap_tree_comparison (code2
),
2144 boolean_type_node
, op1a
, op1b
);
2149 /* If both comparisons are of the same value against constants, we might
2150 be able to merge them. */
2151 if (operand_equal_p (op1a
, op2a
, 0)
2152 && TREE_CODE (op1b
) == INTEGER_CST
2153 && TREE_CODE (op2b
) == INTEGER_CST
)
2155 int cmp
= tree_int_cst_compare (op1b
, op2b
);
2157 /* If we have (op1a != op1b), we should either be able to
2158 return that or TRUE, depending on whether the constant op1b
2159 also satisfies the other comparison against op2b. */
2160 if (code1
== NE_EXPR
)
2166 case EQ_EXPR
: val
= (cmp
== 0); break;
2167 case NE_EXPR
: val
= (cmp
!= 0); break;
2168 case LT_EXPR
: val
= (cmp
< 0); break;
2169 case GT_EXPR
: val
= (cmp
> 0); break;
2170 case LE_EXPR
: val
= (cmp
<= 0); break;
2171 case GE_EXPR
: val
= (cmp
>= 0); break;
2172 default: done
= false;
2177 return boolean_true_node
;
2179 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
2182 /* Likewise if the second comparison is a != comparison. */
2183 else if (code2
== NE_EXPR
)
2189 case EQ_EXPR
: val
= (cmp
== 0); break;
2190 case NE_EXPR
: val
= (cmp
!= 0); break;
2191 case LT_EXPR
: val
= (cmp
> 0); break;
2192 case GT_EXPR
: val
= (cmp
< 0); break;
2193 case LE_EXPR
: val
= (cmp
>= 0); break;
2194 case GE_EXPR
: val
= (cmp
<= 0); break;
2195 default: done
= false;
2200 return boolean_true_node
;
2202 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
2206 /* See if an equality test is redundant with the other comparison. */
2207 else if (code1
== EQ_EXPR
)
2212 case EQ_EXPR
: val
= (cmp
== 0); break;
2213 case NE_EXPR
: val
= (cmp
!= 0); break;
2214 case LT_EXPR
: val
= (cmp
< 0); break;
2215 case GT_EXPR
: val
= (cmp
> 0); break;
2216 case LE_EXPR
: val
= (cmp
<= 0); break;
2217 case GE_EXPR
: val
= (cmp
>= 0); break;
2222 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
2224 else if (code2
== EQ_EXPR
)
2229 case EQ_EXPR
: val
= (cmp
== 0); break;
2230 case NE_EXPR
: val
= (cmp
!= 0); break;
2231 case LT_EXPR
: val
= (cmp
> 0); break;
2232 case GT_EXPR
: val
= (cmp
< 0); break;
2233 case LE_EXPR
: val
= (cmp
>= 0); break;
2234 case GE_EXPR
: val
= (cmp
<= 0); break;
2239 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
2242 /* Chose the less restrictive of two < or <= comparisons. */
2243 else if ((code1
== LT_EXPR
|| code1
== LE_EXPR
)
2244 && (code2
== LT_EXPR
|| code2
== LE_EXPR
))
2246 if ((cmp
< 0) || (cmp
== 0 && code1
== LT_EXPR
))
2247 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
2249 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
2252 /* Likewise chose the less restrictive of two > or >= comparisons. */
2253 else if ((code1
== GT_EXPR
|| code1
== GE_EXPR
)
2254 && (code2
== GT_EXPR
|| code2
== GE_EXPR
))
2256 if ((cmp
> 0) || (cmp
== 0 && code1
== GT_EXPR
))
2257 return fold_build2 (code2
, boolean_type_node
, op2a
, op2b
);
2259 return fold_build2 (code1
, boolean_type_node
, op1a
, op1b
);
2262 /* Check for singleton ranges. */
2264 && ((code1
== LT_EXPR
&& code2
== GT_EXPR
)
2265 || (code1
== GT_EXPR
&& code2
== LT_EXPR
)))
2266 return fold_build2 (NE_EXPR
, boolean_type_node
, op1a
, op2b
);
2268 /* Check for less/greater pairs that don't restrict the range at all. */
2270 && (code1
== LT_EXPR
|| code1
== LE_EXPR
)
2271 && (code2
== GT_EXPR
|| code2
== GE_EXPR
))
2272 return boolean_true_node
;
2274 && (code1
== GT_EXPR
|| code1
== GE_EXPR
)
2275 && (code2
== LT_EXPR
|| code2
== LE_EXPR
))
2276 return boolean_true_node
;
2279 /* Perhaps the first comparison is (NAME != 0) or (NAME == 1) where
2280 NAME's definition is a truth value. See if there are any simplifications
2281 that can be done against the NAME's definition. */
2282 if (TREE_CODE (op1a
) == SSA_NAME
2283 && (code1
== NE_EXPR
|| code1
== EQ_EXPR
)
2284 && (integer_zerop (op1b
) || integer_onep (op1b
)))
2286 bool invert
= ((code1
== EQ_EXPR
&& integer_zerop (op1b
))
2287 || (code1
== NE_EXPR
&& integer_onep (op1b
)));
2288 gimple stmt
= SSA_NAME_DEF_STMT (op1a
);
2289 switch (gimple_code (stmt
))
2292 /* Try to simplify by copy-propagating the definition. */
2293 return or_var_with_comparison (op1a
, invert
, code2
, op2a
, op2b
);
2296 /* If every argument to the PHI produces the same result when
2297 ORed with the second comparison, we win.
2298 Do not do this unless the type is bool since we need a bool
2299 result here anyway. */
2300 if (TREE_CODE (TREE_TYPE (op1a
)) == BOOLEAN_TYPE
)
2302 tree result
= NULL_TREE
;
2304 for (i
= 0; i
< gimple_phi_num_args (stmt
); i
++)
2306 tree arg
= gimple_phi_arg_def (stmt
, i
);
2308 /* If this PHI has itself as an argument, ignore it.
2309 If all the other args produce the same result,
2311 if (arg
== gimple_phi_result (stmt
))
2313 else if (TREE_CODE (arg
) == INTEGER_CST
)
2315 if (invert
? integer_zerop (arg
) : integer_nonzerop (arg
))
2318 result
= boolean_true_node
;
2319 else if (!integer_onep (result
))
2323 result
= fold_build2 (code2
, boolean_type_node
,
2325 else if (!same_bool_comparison_p (result
,
2329 else if (TREE_CODE (arg
) == SSA_NAME
2330 && !SSA_NAME_IS_DEFAULT_DEF (arg
))
2333 gimple def_stmt
= SSA_NAME_DEF_STMT (arg
);
2334 /* In simple cases we can look through PHI nodes,
2335 but we have to be careful with loops.
2337 if (! dom_info_available_p (CDI_DOMINATORS
)
2338 || gimple_bb (def_stmt
) == gimple_bb (stmt
)
2339 || dominated_by_p (CDI_DOMINATORS
,
2340 gimple_bb (def_stmt
),
2343 temp
= or_var_with_comparison (arg
, invert
, code2
,
2349 else if (!same_bool_result_p (result
, temp
))
2365 /* Try to simplify the OR of two comparisons, specified by
2366 (OP1A CODE1 OP1B) and (OP2B CODE2 OP2B), respectively.
2367 If this can be simplified to a single expression (without requiring
2368 introducing more SSA variables to hold intermediate values),
2369 return the resulting tree. Otherwise return NULL_TREE.
2370 If the result expression is non-null, it has boolean type. */
2373 maybe_fold_or_comparisons (enum tree_code code1
, tree op1a
, tree op1b
,
2374 enum tree_code code2
, tree op2a
, tree op2b
)
2376 tree t
= or_comparisons_1 (code1
, op1a
, op1b
, code2
, op2a
, op2b
);
2380 return or_comparisons_1 (code2
, op2a
, op2b
, code1
, op1a
, op1b
);
2384 /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
2386 Either NULL_TREE, a simplified but non-constant or a constant
2389 ??? This should go into a gimple-fold-inline.h file to be eventually
2390 privatized with the single valueize function used in the various TUs
2391 to avoid the indirect function call overhead. */
2394 gimple_fold_stmt_to_constant_1 (gimple stmt
, tree (*valueize
) (tree
))
2396 location_t loc
= gimple_location (stmt
);
2397 switch (gimple_code (stmt
))
2401 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
2403 switch (get_gimple_rhs_class (subcode
))
2405 case GIMPLE_SINGLE_RHS
:
2407 tree rhs
= gimple_assign_rhs1 (stmt
);
2408 enum tree_code_class kind
= TREE_CODE_CLASS (subcode
);
2410 if (TREE_CODE (rhs
) == SSA_NAME
)
2412 /* If the RHS is an SSA_NAME, return its known constant value,
2414 return (*valueize
) (rhs
);
2416 /* Handle propagating invariant addresses into address
2418 else if (TREE_CODE (rhs
) == ADDR_EXPR
2419 && !is_gimple_min_invariant (rhs
))
2421 HOST_WIDE_INT offset
;
2423 base
= get_addr_base_and_unit_offset_1 (TREE_OPERAND (rhs
, 0),
2427 && (CONSTANT_CLASS_P (base
)
2428 || decl_address_invariant_p (base
)))
2429 return build_invariant_address (TREE_TYPE (rhs
),
2432 else if (TREE_CODE (rhs
) == CONSTRUCTOR
2433 && TREE_CODE (TREE_TYPE (rhs
)) == VECTOR_TYPE
2434 && (CONSTRUCTOR_NELTS (rhs
)
2435 == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs
))))
2441 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs
), i
, val
)
2443 val
= (*valueize
) (val
);
2444 if (TREE_CODE (val
) == INTEGER_CST
2445 || TREE_CODE (val
) == REAL_CST
2446 || TREE_CODE (val
) == FIXED_CST
)
2447 list
= tree_cons (NULL_TREE
, val
, list
);
2452 return build_vector (TREE_TYPE (rhs
), nreverse (list
));
2455 if (kind
== tcc_reference
)
2457 if ((TREE_CODE (rhs
) == VIEW_CONVERT_EXPR
2458 || TREE_CODE (rhs
) == REALPART_EXPR
2459 || TREE_CODE (rhs
) == IMAGPART_EXPR
)
2460 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
2462 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
2463 return fold_unary_loc (EXPR_LOCATION (rhs
),
2465 TREE_TYPE (rhs
), val
);
2467 else if (TREE_CODE (rhs
) == BIT_FIELD_REF
2468 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
2470 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
2471 return fold_ternary_loc (EXPR_LOCATION (rhs
),
2473 TREE_TYPE (rhs
), val
,
2474 TREE_OPERAND (rhs
, 1),
2475 TREE_OPERAND (rhs
, 2));
2477 else if (TREE_CODE (rhs
) == MEM_REF
2478 && TREE_CODE (TREE_OPERAND (rhs
, 0)) == SSA_NAME
)
2480 tree val
= (*valueize
) (TREE_OPERAND (rhs
, 0));
2481 if (TREE_CODE (val
) == ADDR_EXPR
2482 && is_gimple_min_invariant (val
))
2484 tree tem
= fold_build2 (MEM_REF
, TREE_TYPE (rhs
),
2486 TREE_OPERAND (rhs
, 1));
2491 return fold_const_aggregate_ref_1 (rhs
, valueize
);
2493 else if (kind
== tcc_declaration
)
2494 return get_symbol_constant_value (rhs
);
2498 case GIMPLE_UNARY_RHS
:
2500 /* Handle unary operators that can appear in GIMPLE form.
2501 Note that we know the single operand must be a constant,
2502 so this should almost always return a simplified RHS. */
2503 tree lhs
= gimple_assign_lhs (stmt
);
2504 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
2506 /* Conversions are useless for CCP purposes if they are
2507 value-preserving. Thus the restrictions that
2508 useless_type_conversion_p places for restrict qualification
2509 of pointer types should not apply here.
2510 Substitution later will only substitute to allowed places. */
2511 if (CONVERT_EXPR_CODE_P (subcode
)
2512 && POINTER_TYPE_P (TREE_TYPE (lhs
))
2513 && POINTER_TYPE_P (TREE_TYPE (op0
))
2514 && (TYPE_ADDR_SPACE (TREE_TYPE (lhs
))
2515 == TYPE_ADDR_SPACE (TREE_TYPE (op0
))))
2519 fold_unary_ignore_overflow_loc (loc
, subcode
,
2520 gimple_expr_type (stmt
), op0
);
2523 case GIMPLE_BINARY_RHS
:
2525 /* Handle binary operators that can appear in GIMPLE form. */
2526 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
2527 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
2529 /* Translate &x + CST into an invariant form suitable for
2530 further propagation. */
2531 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
2532 && TREE_CODE (op0
) == ADDR_EXPR
2533 && TREE_CODE (op1
) == INTEGER_CST
)
2535 tree off
= fold_convert (ptr_type_node
, op1
);
2536 return build_fold_addr_expr_loc
2538 fold_build2 (MEM_REF
,
2539 TREE_TYPE (TREE_TYPE (op0
)),
2540 unshare_expr (op0
), off
));
2543 return fold_binary_loc (loc
, subcode
,
2544 gimple_expr_type (stmt
), op0
, op1
);
2547 case GIMPLE_TERNARY_RHS
:
2549 /* Handle ternary operators that can appear in GIMPLE form. */
2550 tree op0
= (*valueize
) (gimple_assign_rhs1 (stmt
));
2551 tree op1
= (*valueize
) (gimple_assign_rhs2 (stmt
));
2552 tree op2
= (*valueize
) (gimple_assign_rhs3 (stmt
));
2554 return fold_ternary_loc (loc
, subcode
,
2555 gimple_expr_type (stmt
), op0
, op1
, op2
);
2567 if (gimple_call_internal_p (stmt
))
2568 /* No folding yet for these functions. */
2571 fn
= (*valueize
) (gimple_call_fn (stmt
));
2572 if (TREE_CODE (fn
) == ADDR_EXPR
2573 && TREE_CODE (TREE_OPERAND (fn
, 0)) == FUNCTION_DECL
2574 && DECL_BUILT_IN (TREE_OPERAND (fn
, 0)))
2576 tree
*args
= XALLOCAVEC (tree
, gimple_call_num_args (stmt
));
2579 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2580 args
[i
] = (*valueize
) (gimple_call_arg (stmt
, i
));
2581 call
= build_call_array_loc (loc
,
2582 gimple_call_return_type (stmt
),
2583 fn
, gimple_call_num_args (stmt
), args
);
2584 retval
= fold_call_expr (EXPR_LOCATION (call
), call
, false);
2586 /* fold_call_expr wraps the result inside a NOP_EXPR. */
2587 STRIP_NOPS (retval
);
2598 /* Fold STMT to a constant using VALUEIZE to valueize SSA names.
2599 Returns NULL_TREE if folding to a constant is not possible, otherwise
2600 returns a constant according to is_gimple_min_invariant. */
2603 gimple_fold_stmt_to_constant (gimple stmt
, tree (*valueize
) (tree
))
2605 tree res
= gimple_fold_stmt_to_constant_1 (stmt
, valueize
);
2606 if (res
&& is_gimple_min_invariant (res
))
2612 /* The following set of functions are supposed to fold references using
2613 their constant initializers. */
2615 static tree
fold_ctor_reference (tree type
, tree ctor
,
2616 unsigned HOST_WIDE_INT offset
,
2617 unsigned HOST_WIDE_INT size
);
2619 /* See if we can find constructor defining value of BASE.
2620 When we know the consructor with constant offset (such as
2621 base is array[40] and we do know constructor of array), then
2622 BIT_OFFSET is adjusted accordingly.
2624 As a special case, return error_mark_node when constructor
2625 is not explicitly available, but it is known to be zero
2626 such as 'static const int a;'. */
2628 get_base_constructor (tree base
, HOST_WIDE_INT
*bit_offset
,
2629 tree (*valueize
)(tree
))
2631 HOST_WIDE_INT bit_offset2
, size
, max_size
;
2632 if (TREE_CODE (base
) == MEM_REF
)
2634 if (!integer_zerop (TREE_OPERAND (base
, 1)))
2636 if (!host_integerp (TREE_OPERAND (base
, 1), 0))
2638 *bit_offset
+= (mem_ref_offset (base
).low
2643 && TREE_CODE (TREE_OPERAND (base
, 0)) == SSA_NAME
)
2644 base
= valueize (TREE_OPERAND (base
, 0));
2645 if (!base
|| TREE_CODE (base
) != ADDR_EXPR
)
2647 base
= TREE_OPERAND (base
, 0);
2650 /* Get a CONSTRUCTOR. If BASE is a VAR_DECL, get its
2651 DECL_INITIAL. If BASE is a nested reference into another
2652 ARRAY_REF or COMPONENT_REF, make a recursive call to resolve
2653 the inner reference. */
2654 switch (TREE_CODE (base
))
2657 if (!const_value_known_p (base
))
2662 if (!DECL_INITIAL (base
)
2663 && (TREE_STATIC (base
) || DECL_EXTERNAL (base
)))
2664 return error_mark_node
;
2665 return DECL_INITIAL (base
);
2669 base
= get_ref_base_and_extent (base
, &bit_offset2
, &size
, &max_size
);
2670 if (max_size
== -1 || size
!= max_size
)
2672 *bit_offset
+= bit_offset2
;
2673 return get_base_constructor (base
, bit_offset
, valueize
);
2684 /* CTOR is STRING_CST. Fold reference of type TYPE and size SIZE
2685 to the memory at bit OFFSET.
2687 We do only simple job of folding byte accesses. */
2690 fold_string_cst_ctor_reference (tree type
, tree ctor
,
2691 unsigned HOST_WIDE_INT offset
,
2692 unsigned HOST_WIDE_INT size
)
2694 if (INTEGRAL_TYPE_P (type
)
2695 && (TYPE_MODE (type
)
2696 == TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor
))))
2697 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor
))))
2699 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (ctor
)))) == 1
2700 && size
== BITS_PER_UNIT
2701 && !(offset
% BITS_PER_UNIT
))
2703 offset
/= BITS_PER_UNIT
;
2704 if (offset
< (unsigned HOST_WIDE_INT
) TREE_STRING_LENGTH (ctor
))
2705 return build_int_cst_type (type
, (TREE_STRING_POINTER (ctor
)
2708 const char a[20]="hello";
2711 might lead to offset greater than string length. In this case we
2712 know value is either initialized to 0 or out of bounds. Return 0
2714 return build_zero_cst (type
);
2719 /* CTOR is CONSTRUCTOR of an array type. Fold reference of type TYPE and size
2720 SIZE to the memory at bit OFFSET. */
2723 fold_array_ctor_reference (tree type
, tree ctor
,
2724 unsigned HOST_WIDE_INT offset
,
2725 unsigned HOST_WIDE_INT size
)
2727 unsigned HOST_WIDE_INT cnt
;
2729 double_int low_bound
, elt_size
;
2730 double_int index
, max_index
;
2731 double_int access_index
;
2732 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
2733 HOST_WIDE_INT inner_offset
;
2735 /* Compute low bound and elt size. */
2736 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
2738 /* Static constructors for variably sized objects makes no sense. */
2739 gcc_assert (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) == INTEGER_CST
);
2740 low_bound
= tree_to_double_int (TYPE_MIN_VALUE (domain_type
));
2743 low_bound
= double_int_zero
;
2744 /* Static constructors for variably sized objects makes no sense. */
2745 gcc_assert (TREE_CODE(TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor
))))
2748 tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor
))));
2751 /* We can handle only constantly sized accesses that are known to not
2752 be larger than size of array element. */
2753 if (!TYPE_SIZE_UNIT (type
)
2754 || TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
2755 || double_int_cmp (elt_size
,
2756 tree_to_double_int (TYPE_SIZE_UNIT (type
)), 0) < 0)
2759 /* Compute the array index we look for. */
2760 access_index
= double_int_udiv (uhwi_to_double_int (offset
/ BITS_PER_UNIT
),
2761 elt_size
, TRUNC_DIV_EXPR
);
2762 access_index
= double_int_add (access_index
, low_bound
);
2764 /* And offset within the access. */
2765 inner_offset
= offset
% (double_int_to_uhwi (elt_size
) * BITS_PER_UNIT
);
2767 /* See if the array field is large enough to span whole access. We do not
2768 care to fold accesses spanning multiple array indexes. */
2769 if (inner_offset
+ size
> double_int_to_uhwi (elt_size
) * BITS_PER_UNIT
)
2772 index
= double_int_sub (low_bound
, double_int_one
);
2773 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
, cval
)
2775 /* Array constructor might explicitely set index, or specify range
2776 or leave index NULL meaning that it is next index after previous
2780 if (TREE_CODE (cfield
) == INTEGER_CST
)
2781 max_index
= index
= tree_to_double_int (cfield
);
2784 gcc_assert (TREE_CODE (cfield
) == RANGE_EXPR
);
2785 index
= tree_to_double_int (TREE_OPERAND (cfield
, 0));
2786 max_index
= tree_to_double_int (TREE_OPERAND (cfield
, 1));
2790 max_index
= index
= double_int_add (index
, double_int_one
);
2792 /* Do we have match? */
2793 if (double_int_cmp (access_index
, index
, 1) >= 0
2794 && double_int_cmp (access_index
, max_index
, 1) <= 0)
2795 return fold_ctor_reference (type
, cval
, inner_offset
, size
);
2797 /* When memory is not explicitely mentioned in constructor,
2798 it is 0 (or out of range). */
2799 return build_zero_cst (type
);
2802 /* CTOR is CONSTRUCTOR of an aggregate or vector.
2803 Fold reference of type TYPE and size SIZE to the memory at bit OFFSET. */
2806 fold_nonarray_ctor_reference (tree type
, tree ctor
,
2807 unsigned HOST_WIDE_INT offset
,
2808 unsigned HOST_WIDE_INT size
)
2810 unsigned HOST_WIDE_INT cnt
;
2813 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
,
2816 tree byte_offset
= DECL_FIELD_OFFSET (cfield
);
2817 tree field_offset
= DECL_FIELD_BIT_OFFSET (cfield
);
2818 tree field_size
= DECL_SIZE (cfield
);
2819 double_int bitoffset
;
2820 double_int byte_offset_cst
= tree_to_double_int (byte_offset
);
2821 double_int bits_per_unit_cst
= uhwi_to_double_int (BITS_PER_UNIT
);
2822 double_int bitoffset_end
, access_end
;
2824 /* Variable sized objects in static constructors makes no sense,
2825 but field_size can be NULL for flexible array members. */
2826 gcc_assert (TREE_CODE (field_offset
) == INTEGER_CST
2827 && TREE_CODE (byte_offset
) == INTEGER_CST
2828 && (field_size
!= NULL_TREE
2829 ? TREE_CODE (field_size
) == INTEGER_CST
2830 : TREE_CODE (TREE_TYPE (cfield
)) == ARRAY_TYPE
));
2832 /* Compute bit offset of the field. */
2833 bitoffset
= double_int_add (tree_to_double_int (field_offset
),
2834 double_int_mul (byte_offset_cst
,
2835 bits_per_unit_cst
));
2836 /* Compute bit offset where the field ends. */
2837 if (field_size
!= NULL_TREE
)
2838 bitoffset_end
= double_int_add (bitoffset
,
2839 tree_to_double_int (field_size
));
2841 bitoffset_end
= double_int_zero
;
2843 access_end
= double_int_add (uhwi_to_double_int (offset
),
2844 uhwi_to_double_int (size
));
2846 /* Is there any overlap between [OFFSET, OFFSET+SIZE) and
2847 [BITOFFSET, BITOFFSET_END)? */
2848 if (double_int_cmp (access_end
, bitoffset
, 0) > 0
2849 && (field_size
== NULL_TREE
2850 || double_int_cmp (uhwi_to_double_int (offset
),
2851 bitoffset_end
, 0) < 0))
2853 double_int inner_offset
= double_int_sub (uhwi_to_double_int (offset
),
2855 /* We do have overlap. Now see if field is large enough to
2856 cover the access. Give up for accesses spanning multiple
2858 if (double_int_cmp (access_end
, bitoffset_end
, 0) > 0)
2860 if (double_int_cmp (uhwi_to_double_int (offset
), bitoffset
, 0) < 0)
2862 return fold_ctor_reference (type
, cval
,
2863 double_int_to_uhwi (inner_offset
), size
);
2866 /* When memory is not explicitely mentioned in constructor, it is 0. */
2867 return build_zero_cst (type
);
2870 /* CTOR is value initializing memory, fold reference of type TYPE and size SIZE
2871 to the memory at bit OFFSET. */
2874 fold_ctor_reference (tree type
, tree ctor
, unsigned HOST_WIDE_INT offset
,
2875 unsigned HOST_WIDE_INT size
)
2879 /* We found the field with exact match. */
2880 if (useless_type_conversion_p (type
, TREE_TYPE (ctor
))
2882 return canonicalize_constructor_val (ctor
);
2884 /* We are at the end of walk, see if we can view convert the
2886 if (!AGGREGATE_TYPE_P (TREE_TYPE (ctor
)) && !offset
2887 /* VIEW_CONVERT_EXPR is defined only for matching sizes. */
2888 && operand_equal_p (TYPE_SIZE (type
),
2889 TYPE_SIZE (TREE_TYPE (ctor
)), 0))
2891 ret
= canonicalize_constructor_val (ctor
);
2892 ret
= fold_unary (VIEW_CONVERT_EXPR
, type
, ret
);
2897 if (TREE_CODE (ctor
) == STRING_CST
)
2898 return fold_string_cst_ctor_reference (type
, ctor
, offset
, size
);
2899 if (TREE_CODE (ctor
) == CONSTRUCTOR
)
2902 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
2903 return fold_array_ctor_reference (type
, ctor
, offset
, size
);
2905 return fold_nonarray_ctor_reference (type
, ctor
, offset
, size
);
2911 /* Return the tree representing the element referenced by T if T is an
2912 ARRAY_REF or COMPONENT_REF into constant aggregates valuezing SSA
2913 names using VALUEIZE. Return NULL_TREE otherwise. */
2916 fold_const_aggregate_ref_1 (tree t
, tree (*valueize
) (tree
))
2918 tree ctor
, idx
, base
;
2919 HOST_WIDE_INT offset
, size
, max_size
;
2922 if (TREE_CODE_CLASS (TREE_CODE (t
)) == tcc_declaration
)
2923 return get_symbol_constant_value (t
);
2925 tem
= fold_read_from_constant_string (t
);
2929 switch (TREE_CODE (t
))
2932 case ARRAY_RANGE_REF
:
2933 /* Constant indexes are handled well by get_base_constructor.
2934 Only special case variable offsets.
2935 FIXME: This code can't handle nested references with variable indexes
2936 (they will be handled only by iteration of ccp). Perhaps we can bring
2937 get_ref_base_and_extent here and make it use a valueize callback. */
2938 if (TREE_CODE (TREE_OPERAND (t
, 1)) == SSA_NAME
2940 && (idx
= (*valueize
) (TREE_OPERAND (t
, 1)))
2941 && host_integerp (idx
, 0))
2943 tree low_bound
, unit_size
;
2945 /* If the resulting bit-offset is constant, track it. */
2946 if ((low_bound
= array_ref_low_bound (t
),
2947 host_integerp (low_bound
, 0))
2948 && (unit_size
= array_ref_element_size (t
),
2949 host_integerp (unit_size
, 1)))
2951 offset
= TREE_INT_CST_LOW (idx
);
2952 offset
-= TREE_INT_CST_LOW (low_bound
);
2953 offset
*= TREE_INT_CST_LOW (unit_size
);
2954 offset
*= BITS_PER_UNIT
;
2956 base
= TREE_OPERAND (t
, 0);
2957 ctor
= get_base_constructor (base
, &offset
, valueize
);
2958 /* Empty constructor. Always fold to 0. */
2959 if (ctor
== error_mark_node
)
2960 return build_zero_cst (TREE_TYPE (t
));
2961 /* Out of bound array access. Value is undefined,
2965 /* We can not determine ctor. */
2968 return fold_ctor_reference (TREE_TYPE (t
), ctor
, offset
,
2969 TREE_INT_CST_LOW (unit_size
)
2977 case TARGET_MEM_REF
:
2979 base
= get_ref_base_and_extent (t
, &offset
, &size
, &max_size
);
2980 ctor
= get_base_constructor (base
, &offset
, valueize
);
2982 /* Empty constructor. Always fold to 0. */
2983 if (ctor
== error_mark_node
)
2984 return build_zero_cst (TREE_TYPE (t
));
2985 /* We do not know precise address. */
2986 if (max_size
== -1 || max_size
!= size
)
2988 /* We can not determine ctor. */
2992 /* Out of bound array access. Value is undefined, but don't fold. */
2996 return fold_ctor_reference (TREE_TYPE (t
), ctor
, offset
, size
);
3001 tree c
= fold_const_aggregate_ref_1 (TREE_OPERAND (t
, 0), valueize
);
3002 if (c
&& TREE_CODE (c
) == COMPLEX_CST
)
3003 return fold_build1_loc (EXPR_LOCATION (t
),
3004 TREE_CODE (t
), TREE_TYPE (t
), c
);
3016 fold_const_aggregate_ref (tree t
)
3018 return fold_const_aggregate_ref_1 (t
, NULL
);
3021 /* Return a declaration of a function which an OBJ_TYPE_REF references. TOKEN
3022 is integer form of OBJ_TYPE_REF_TOKEN of the reference expression.
3023 KNOWN_BINFO carries the binfo describing the true type of
3024 OBJ_TYPE_REF_OBJECT(REF). */
3027 gimple_get_virt_method_for_binfo (HOST_WIDE_INT token
, tree known_binfo
)
3029 unsigned HOST_WIDE_INT offset
, size
;
3032 v
= BINFO_VTABLE (known_binfo
);
3033 /* If there is no virtual methods table, leave the OBJ_TYPE_REF alone. */
3037 if (TREE_CODE (v
) == POINTER_PLUS_EXPR
)
3039 offset
= tree_low_cst (TREE_OPERAND (v
, 1), 1) * BITS_PER_UNIT
;
3040 v
= TREE_OPERAND (v
, 0);
3045 if (TREE_CODE (v
) != ADDR_EXPR
)
3047 v
= TREE_OPERAND (v
, 0);
3049 if (TREE_CODE (v
) != VAR_DECL
3050 || !DECL_VIRTUAL_P (v
)
3051 || !DECL_INITIAL (v
)
3052 || DECL_INITIAL (v
) == error_mark_node
)
3054 gcc_checking_assert (TREE_CODE (TREE_TYPE (v
)) == ARRAY_TYPE
);
3055 size
= tree_low_cst (TYPE_SIZE (TREE_TYPE (TREE_TYPE (v
))), 1);
3056 offset
+= token
* size
;
3057 fn
= fold_ctor_reference (TREE_TYPE (TREE_TYPE (v
)), DECL_INITIAL (v
),
3061 gcc_assert (TREE_CODE (fn
) == ADDR_EXPR
3062 || TREE_CODE (fn
) == FDESC_EXPR
);
3063 fn
= TREE_OPERAND (fn
, 0);
3064 gcc_assert (TREE_CODE (fn
) == FUNCTION_DECL
);
3066 /* When cgraph node is missing and function is not public, we cannot
3067 devirtualize. This can happen in WHOPR when the actual method
3068 ends up in other partition, because we found devirtualization
3069 possibility too late. */
3070 if (!can_refer_decl_in_current_unit_p (fn
))
3076 /* Return true iff VAL is a gimple expression that is known to be
3077 non-negative. Restricted to floating-point inputs. */
3080 gimple_val_nonnegative_real_p (tree val
)
3084 gcc_assert (val
&& SCALAR_FLOAT_TYPE_P (TREE_TYPE (val
)));
3086 /* Use existing logic for non-gimple trees. */
3087 if (tree_expr_nonnegative_p (val
))
3090 if (TREE_CODE (val
) != SSA_NAME
)
3093 /* Currently we look only at the immediately defining statement
3094 to make this determination, since recursion on defining
3095 statements of operands can lead to quadratic behavior in the
3096 worst case. This is expected to catch almost all occurrences
3097 in practice. It would be possible to implement limited-depth
3098 recursion if important cases are lost. Alternatively, passes
3099 that need this information (such as the pow/powi lowering code
3100 in the cse_sincos pass) could be revised to provide it through
3101 dataflow propagation. */
3103 def_stmt
= SSA_NAME_DEF_STMT (val
);
3105 if (is_gimple_assign (def_stmt
))
3109 /* See fold-const.c:tree_expr_nonnegative_p for additional
3110 cases that could be handled with recursion. */
3112 switch (gimple_assign_rhs_code (def_stmt
))
3115 /* Always true for floating-point operands. */
3119 /* True if the two operands are identical (since we are
3120 restricted to floating-point inputs). */
3121 op0
= gimple_assign_rhs1 (def_stmt
);
3122 op1
= gimple_assign_rhs2 (def_stmt
);
3125 || operand_equal_p (op0
, op1
, 0))
3132 else if (is_gimple_call (def_stmt
))
3134 tree fndecl
= gimple_call_fndecl (def_stmt
);
3136 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
3140 switch (DECL_FUNCTION_CODE (fndecl
))
3142 CASE_FLT_FN (BUILT_IN_ACOS
):
3143 CASE_FLT_FN (BUILT_IN_ACOSH
):
3144 CASE_FLT_FN (BUILT_IN_CABS
):
3145 CASE_FLT_FN (BUILT_IN_COSH
):
3146 CASE_FLT_FN (BUILT_IN_ERFC
):
3147 CASE_FLT_FN (BUILT_IN_EXP
):
3148 CASE_FLT_FN (BUILT_IN_EXP10
):
3149 CASE_FLT_FN (BUILT_IN_EXP2
):
3150 CASE_FLT_FN (BUILT_IN_FABS
):
3151 CASE_FLT_FN (BUILT_IN_FDIM
):
3152 CASE_FLT_FN (BUILT_IN_HYPOT
):
3153 CASE_FLT_FN (BUILT_IN_POW10
):
3156 CASE_FLT_FN (BUILT_IN_SQRT
):
3157 /* sqrt(-0.0) is -0.0, and sqrt is not defined over other
3158 nonnegative inputs. */
3159 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (val
))))
3164 CASE_FLT_FN (BUILT_IN_POWI
):
3165 /* True if the second argument is an even integer. */
3166 arg1
= gimple_call_arg (def_stmt
, 1);
3168 if (TREE_CODE (arg1
) == INTEGER_CST
3169 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
3174 CASE_FLT_FN (BUILT_IN_POW
):
3175 /* True if the second argument is an even integer-valued
3177 arg1
= gimple_call_arg (def_stmt
, 1);
3179 if (TREE_CODE (arg1
) == REAL_CST
)
3184 c
= TREE_REAL_CST (arg1
);
3185 n
= real_to_integer (&c
);
3189 REAL_VALUE_TYPE cint
;
3190 real_from_integer (&cint
, VOIDmode
, n
, n
< 0 ? -1 : 0, 0);
3191 if (real_identical (&c
, &cint
))