1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /*@@ This file should be rewritten to use an arbitrary precision
21 @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
22 @@ Perhaps the routines could also be used for bc/dc, and made a lib.
23 @@ The routines that translate from the ap rep should
24 @@ warn if precision et. al. is lost.
25 @@ This would also make life easier when this technology is used
26 @@ for cross-compilers. */
28 /* The entry points in this file are fold, size_int_wide and size_binop.
30 fold takes a tree as argument and returns a simplified tree.
32 size_binop takes a tree code for an arithmetic operation
33 and two operands that are trees, and produces a tree for the
34 result, assuming the type comes from `sizetype'.
36 size_int takes an integer value, and creates a tree constant
37 with type from `sizetype'.
39 Note: Since the folders get called on non-gimple code as well as
40 gimple code, we need to handle GIMPLE tuples as well as their
41 corresponding tree equivalents. */
45 #include "coretypes.h"
53 #include "tree-ssa-operands.h"
54 #include "optabs-query.h"
56 #include "diagnostic-core.h"
59 #include "fold-const.h"
60 #include "fold-const-call.h"
61 #include "stor-layout.h"
63 #include "tree-iterator.h"
66 #include "langhooks.h"
71 #include "generic-match.h"
72 #include "gimple-fold.h"
74 #include "tree-into-ssa.h"
76 #include "case-cfn-macros.h"
77 #include "stringpool.h"
79 #include "tree-ssanames.h"
82 #ifndef LOAD_EXTEND_OP
83 #define LOAD_EXTEND_OP(M) UNKNOWN
86 /* Nonzero if we are folding constants inside an initializer; zero
88 int folding_initializer
= 0;
90 /* The following constants represent a bit based encoding of GCC's
91 comparison operators. This encoding simplifies transformations
92 on relational comparison operators, such as AND and OR. */
93 enum comparison_code
{
112 static bool negate_expr_p (tree
);
113 static tree
negate_expr (tree
);
114 static tree
split_tree (location_t
, tree
, tree
, enum tree_code
,
115 tree
*, tree
*, tree
*, int);
116 static tree
associate_trees (location_t
, tree
, tree
, enum tree_code
, tree
);
117 static enum comparison_code
comparison_to_compcode (enum tree_code
);
118 static enum tree_code
compcode_to_comparison (enum comparison_code
);
119 static int operand_equal_for_comparison_p (tree
, tree
, tree
);
120 static int twoval_comparison_p (tree
, tree
*, tree
*, int *);
121 static tree
eval_subst (location_t
, tree
, tree
, tree
, tree
, tree
);
122 static tree
optimize_bit_field_compare (location_t
, enum tree_code
,
124 static int simple_operand_p (const_tree
);
125 static bool simple_operand_p_2 (tree
);
126 static tree
range_binop (enum tree_code
, tree
, tree
, int, tree
, int);
127 static tree
range_predecessor (tree
);
128 static tree
range_successor (tree
);
129 static tree
fold_range_test (location_t
, enum tree_code
, tree
, tree
, tree
);
130 static tree
fold_cond_expr_with_comparison (location_t
, tree
, tree
, tree
, tree
);
131 static tree
unextend (tree
, int, int, tree
);
132 static tree
extract_muldiv (tree
, tree
, enum tree_code
, tree
, bool *);
133 static tree
extract_muldiv_1 (tree
, tree
, enum tree_code
, tree
, bool *);
134 static tree
fold_binary_op_with_conditional_arg (location_t
,
135 enum tree_code
, tree
,
138 static tree
fold_div_compare (location_t
, enum tree_code
, tree
, tree
, tree
);
139 static bool reorder_operands_p (const_tree
, const_tree
);
140 static tree
fold_negate_const (tree
, tree
);
141 static tree
fold_not_const (const_tree
, tree
);
142 static tree
fold_relational_const (enum tree_code
, tree
, tree
, tree
);
143 static tree
fold_convert_const (enum tree_code
, tree
, tree
);
144 static tree
fold_view_convert_expr (tree
, tree
);
145 static bool vec_cst_ctor_to_array (tree
, tree
*);
148 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
149 Otherwise, return LOC. */
152 expr_location_or (tree t
, location_t loc
)
154 location_t tloc
= EXPR_LOCATION (t
);
155 return tloc
== UNKNOWN_LOCATION
? loc
: tloc
;
158 /* Similar to protected_set_expr_location, but never modify x in place,
159 if location can and needs to be set, unshare it. */
162 protected_set_expr_location_unshare (tree x
, location_t loc
)
164 if (CAN_HAVE_LOCATION_P (x
)
165 && EXPR_LOCATION (x
) != loc
166 && !(TREE_CODE (x
) == SAVE_EXPR
167 || TREE_CODE (x
) == TARGET_EXPR
168 || TREE_CODE (x
) == BIND_EXPR
))
171 SET_EXPR_LOCATION (x
, loc
);
176 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
177 division and returns the quotient. Otherwise returns
181 div_if_zero_remainder (const_tree arg1
, const_tree arg2
)
185 if (wi::multiple_of_p (wi::to_widest (arg1
), wi::to_widest (arg2
),
187 return wide_int_to_tree (TREE_TYPE (arg1
), quo
);
192 /* This is nonzero if we should defer warnings about undefined
193 overflow. This facility exists because these warnings are a
194 special case. The code to estimate loop iterations does not want
195 to issue any warnings, since it works with expressions which do not
196 occur in user code. Various bits of cleanup code call fold(), but
197 only use the result if it has certain characteristics (e.g., is a
198 constant); that code only wants to issue a warning if the result is
201 static int fold_deferring_overflow_warnings
;
203 /* If a warning about undefined overflow is deferred, this is the
204 warning. Note that this may cause us to turn two warnings into
205 one, but that is fine since it is sufficient to only give one
206 warning per expression. */
208 static const char* fold_deferred_overflow_warning
;
210 /* If a warning about undefined overflow is deferred, this is the
211 level at which the warning should be emitted. */
213 static enum warn_strict_overflow_code fold_deferred_overflow_code
;
215 /* Start deferring overflow warnings. We could use a stack here to
216 permit nested calls, but at present it is not necessary. */
219 fold_defer_overflow_warnings (void)
221 ++fold_deferring_overflow_warnings
;
224 /* Stop deferring overflow warnings. If there is a pending warning,
225 and ISSUE is true, then issue the warning if appropriate. STMT is
226 the statement with which the warning should be associated (used for
227 location information); STMT may be NULL. CODE is the level of the
228 warning--a warn_strict_overflow_code value. This function will use
229 the smaller of CODE and the deferred code when deciding whether to
230 issue the warning. CODE may be zero to mean to always use the
234 fold_undefer_overflow_warnings (bool issue
, const gimple
*stmt
, int code
)
239 gcc_assert (fold_deferring_overflow_warnings
> 0);
240 --fold_deferring_overflow_warnings
;
241 if (fold_deferring_overflow_warnings
> 0)
243 if (fold_deferred_overflow_warning
!= NULL
245 && code
< (int) fold_deferred_overflow_code
)
246 fold_deferred_overflow_code
= (enum warn_strict_overflow_code
) code
;
250 warnmsg
= fold_deferred_overflow_warning
;
251 fold_deferred_overflow_warning
= NULL
;
253 if (!issue
|| warnmsg
== NULL
)
256 if (gimple_no_warning_p (stmt
))
259 /* Use the smallest code level when deciding to issue the
261 if (code
== 0 || code
> (int) fold_deferred_overflow_code
)
262 code
= fold_deferred_overflow_code
;
264 if (!issue_strict_overflow_warning (code
))
268 locus
= input_location
;
270 locus
= gimple_location (stmt
);
271 warning_at (locus
, OPT_Wstrict_overflow
, "%s", warnmsg
);
274 /* Stop deferring overflow warnings, ignoring any deferred
278 fold_undefer_and_ignore_overflow_warnings (void)
280 fold_undefer_overflow_warnings (false, NULL
, 0);
283 /* Whether we are deferring overflow warnings. */
286 fold_deferring_overflow_warnings_p (void)
288 return fold_deferring_overflow_warnings
> 0;
291 /* This is called when we fold something based on the fact that signed
292 overflow is undefined. */
295 fold_overflow_warning (const char* gmsgid
, enum warn_strict_overflow_code wc
)
297 if (fold_deferring_overflow_warnings
> 0)
299 if (fold_deferred_overflow_warning
== NULL
300 || wc
< fold_deferred_overflow_code
)
302 fold_deferred_overflow_warning
= gmsgid
;
303 fold_deferred_overflow_code
= wc
;
306 else if (issue_strict_overflow_warning (wc
))
307 warning (OPT_Wstrict_overflow
, gmsgid
);
310 /* Return true if the built-in mathematical function specified by CODE
311 is odd, i.e. -f(x) == f(-x). */
314 negate_mathfn_p (combined_fn fn
)
347 return !flag_rounding_math
;
355 /* Check whether we may negate an integer constant T without causing
359 may_negate_without_overflow_p (const_tree t
)
363 gcc_assert (TREE_CODE (t
) == INTEGER_CST
);
365 type
= TREE_TYPE (t
);
366 if (TYPE_UNSIGNED (type
))
369 return !wi::only_sign_bit_p (t
);
372 /* Determine whether an expression T can be cheaply negated using
373 the function negate_expr without introducing undefined overflow. */
376 negate_expr_p (tree t
)
383 type
= TREE_TYPE (t
);
386 switch (TREE_CODE (t
))
389 if (INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_WRAPS (type
))
392 /* Check that -CST will not overflow type. */
393 return may_negate_without_overflow_p (t
);
395 return (INTEGRAL_TYPE_P (type
)
396 && TYPE_OVERFLOW_WRAPS (type
));
402 return !TYPE_OVERFLOW_SANITIZED (type
);
405 /* We want to canonicalize to positive real constants. Pretend
406 that only negative ones can be easily negated. */
407 return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
410 return negate_expr_p (TREE_REALPART (t
))
411 && negate_expr_p (TREE_IMAGPART (t
));
415 if (FLOAT_TYPE_P (TREE_TYPE (type
)) || TYPE_OVERFLOW_WRAPS (type
))
418 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
420 for (i
= 0; i
< count
; i
++)
421 if (!negate_expr_p (VECTOR_CST_ELT (t
, i
)))
428 return negate_expr_p (TREE_OPERAND (t
, 0))
429 && negate_expr_p (TREE_OPERAND (t
, 1));
432 return negate_expr_p (TREE_OPERAND (t
, 0));
435 if (HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
436 || HONOR_SIGNED_ZEROS (element_mode (type
))
437 || (INTEGRAL_TYPE_P (type
)
438 && ! TYPE_OVERFLOW_WRAPS (type
)))
440 /* -(A + B) -> (-B) - A. */
441 if (negate_expr_p (TREE_OPERAND (t
, 1))
442 && reorder_operands_p (TREE_OPERAND (t
, 0),
443 TREE_OPERAND (t
, 1)))
445 /* -(A + B) -> (-A) - B. */
446 return negate_expr_p (TREE_OPERAND (t
, 0));
449 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
450 return !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
451 && !HONOR_SIGNED_ZEROS (element_mode (type
))
452 && (! INTEGRAL_TYPE_P (type
)
453 || TYPE_OVERFLOW_WRAPS (type
))
454 && reorder_operands_p (TREE_OPERAND (t
, 0),
455 TREE_OPERAND (t
, 1));
458 if (TYPE_UNSIGNED (type
))
460 /* INT_MIN/n * n doesn't overflow while negating one operand it does
461 if n is a power of two. */
462 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
463 && ! TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
464 && ! ((TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
465 && ! integer_pow2p (TREE_OPERAND (t
, 0)))
466 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
467 && ! integer_pow2p (TREE_OPERAND (t
, 1)))))
473 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (TREE_TYPE (t
))))
474 return negate_expr_p (TREE_OPERAND (t
, 1))
475 || negate_expr_p (TREE_OPERAND (t
, 0));
481 if (TYPE_UNSIGNED (type
))
483 if (negate_expr_p (TREE_OPERAND (t
, 0)))
485 /* In general we can't negate B in A / B, because if A is INT_MIN and
486 B is 1, we may turn this into INT_MIN / -1 which is undefined
487 and actually traps on some architectures. */
488 if (! INTEGRAL_TYPE_P (TREE_TYPE (t
))
489 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
490 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
491 && ! integer_onep (TREE_OPERAND (t
, 1))))
492 return negate_expr_p (TREE_OPERAND (t
, 1));
496 /* Negate -((double)float) as (double)(-float). */
497 if (TREE_CODE (type
) == REAL_TYPE
)
499 tree tem
= strip_float_extensions (t
);
501 return negate_expr_p (tem
);
506 /* Negate -f(x) as f(-x). */
507 if (negate_mathfn_p (get_call_combined_fn (t
)))
508 return negate_expr_p (CALL_EXPR_ARG (t
, 0));
512 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
513 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
515 tree op1
= TREE_OPERAND (t
, 1);
516 if (wi::eq_p (op1
, TYPE_PRECISION (type
) - 1))
527 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
528 simplification is possible.
529 If negate_expr_p would return true for T, NULL_TREE will never be
533 fold_negate_expr (location_t loc
, tree t
)
535 tree type
= TREE_TYPE (t
);
538 switch (TREE_CODE (t
))
540 /* Convert - (~A) to A + 1. */
542 if (INTEGRAL_TYPE_P (type
))
543 return fold_build2_loc (loc
, PLUS_EXPR
, type
, TREE_OPERAND (t
, 0),
544 build_one_cst (type
));
548 tem
= fold_negate_const (t
, type
);
549 if (TREE_OVERFLOW (tem
) == TREE_OVERFLOW (t
)
550 || (ANY_INTEGRAL_TYPE_P (type
)
551 && !TYPE_OVERFLOW_TRAPS (type
)
552 && TYPE_OVERFLOW_WRAPS (type
))
553 || (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
558 tem
= fold_negate_const (t
, type
);
562 tem
= fold_negate_const (t
, type
);
567 tree rpart
= fold_negate_expr (loc
, TREE_REALPART (t
));
568 tree ipart
= fold_negate_expr (loc
, TREE_IMAGPART (t
));
570 return build_complex (type
, rpart
, ipart
);
576 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
577 tree
*elts
= XALLOCAVEC (tree
, count
);
579 for (i
= 0; i
< count
; i
++)
581 elts
[i
] = fold_negate_expr (loc
, VECTOR_CST_ELT (t
, i
));
582 if (elts
[i
] == NULL_TREE
)
586 return build_vector (type
, elts
);
590 if (negate_expr_p (t
))
591 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
592 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)),
593 fold_negate_expr (loc
, TREE_OPERAND (t
, 1)));
597 if (negate_expr_p (t
))
598 return fold_build1_loc (loc
, CONJ_EXPR
, type
,
599 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)));
603 if (!TYPE_OVERFLOW_SANITIZED (type
))
604 return TREE_OPERAND (t
, 0);
608 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
609 && !HONOR_SIGNED_ZEROS (element_mode (type
)))
611 /* -(A + B) -> (-B) - A. */
612 if (negate_expr_p (TREE_OPERAND (t
, 1))
613 && reorder_operands_p (TREE_OPERAND (t
, 0),
614 TREE_OPERAND (t
, 1)))
616 tem
= negate_expr (TREE_OPERAND (t
, 1));
617 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
618 tem
, TREE_OPERAND (t
, 0));
621 /* -(A + B) -> (-A) - B. */
622 if (negate_expr_p (TREE_OPERAND (t
, 0)))
624 tem
= negate_expr (TREE_OPERAND (t
, 0));
625 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
626 tem
, TREE_OPERAND (t
, 1));
632 /* - (A - B) -> B - A */
633 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
634 && !HONOR_SIGNED_ZEROS (element_mode (type
))
635 && reorder_operands_p (TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1)))
636 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
637 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 0));
641 if (TYPE_UNSIGNED (type
))
647 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
)))
649 tem
= TREE_OPERAND (t
, 1);
650 if (negate_expr_p (tem
))
651 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
652 TREE_OPERAND (t
, 0), negate_expr (tem
));
653 tem
= TREE_OPERAND (t
, 0);
654 if (negate_expr_p (tem
))
655 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
656 negate_expr (tem
), TREE_OPERAND (t
, 1));
663 if (TYPE_UNSIGNED (type
))
665 if (negate_expr_p (TREE_OPERAND (t
, 0)))
666 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
667 negate_expr (TREE_OPERAND (t
, 0)),
668 TREE_OPERAND (t
, 1));
669 /* In general we can't negate B in A / B, because if A is INT_MIN and
670 B is 1, we may turn this into INT_MIN / -1 which is undefined
671 and actually traps on some architectures. */
672 if ((! INTEGRAL_TYPE_P (TREE_TYPE (t
))
673 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
674 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
675 && ! integer_onep (TREE_OPERAND (t
, 1))))
676 && negate_expr_p (TREE_OPERAND (t
, 1)))
677 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
679 negate_expr (TREE_OPERAND (t
, 1)));
683 /* Convert -((double)float) into (double)(-float). */
684 if (TREE_CODE (type
) == REAL_TYPE
)
686 tem
= strip_float_extensions (t
);
687 if (tem
!= t
&& negate_expr_p (tem
))
688 return fold_convert_loc (loc
, type
, negate_expr (tem
));
693 /* Negate -f(x) as f(-x). */
694 if (negate_mathfn_p (get_call_combined_fn (t
))
695 && negate_expr_p (CALL_EXPR_ARG (t
, 0)))
699 fndecl
= get_callee_fndecl (t
);
700 arg
= negate_expr (CALL_EXPR_ARG (t
, 0));
701 return build_call_expr_loc (loc
, fndecl
, 1, arg
);
706 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
707 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
709 tree op1
= TREE_OPERAND (t
, 1);
710 if (wi::eq_p (op1
, TYPE_PRECISION (type
) - 1))
712 tree ntype
= TYPE_UNSIGNED (type
)
713 ? signed_type_for (type
)
714 : unsigned_type_for (type
);
715 tree temp
= fold_convert_loc (loc
, ntype
, TREE_OPERAND (t
, 0));
716 temp
= fold_build2_loc (loc
, RSHIFT_EXPR
, ntype
, temp
, op1
);
717 return fold_convert_loc (loc
, type
, temp
);
729 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
730 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
742 loc
= EXPR_LOCATION (t
);
743 type
= TREE_TYPE (t
);
746 tem
= fold_negate_expr (loc
, t
);
748 tem
= build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
749 return fold_convert_loc (loc
, type
, tem
);
752 /* Split a tree IN into a constant, literal and variable parts that could be
753 combined with CODE to make IN. "constant" means an expression with
754 TREE_CONSTANT but that isn't an actual constant. CODE must be a
755 commutative arithmetic operation. Store the constant part into *CONP,
756 the literal in *LITP and return the variable part. If a part isn't
757 present, set it to null. If the tree does not decompose in this way,
758 return the entire tree as the variable part and the other parts as null.
760 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
761 case, we negate an operand that was subtracted. Except if it is a
762 literal for which we use *MINUS_LITP instead.
764 If NEGATE_P is true, we are negating all of IN, again except a literal
765 for which we use *MINUS_LITP instead. If a variable part is of pointer
766 type, it is negated after converting to TYPE. This prevents us from
767 generating illegal MINUS pointer expression. LOC is the location of
768 the converted variable part.
770 If IN is itself a literal or constant, return it as appropriate.
772 Note that we do not guarantee that any of the three values will be the
773 same type as IN, but they will have the same signedness and mode. */
776 split_tree (location_t loc
, tree in
, tree type
, enum tree_code code
,
777 tree
*conp
, tree
*litp
, tree
*minus_litp
, int negate_p
)
785 /* Strip any conversions that don't change the machine mode or signedness. */
786 STRIP_SIGN_NOPS (in
);
788 if (TREE_CODE (in
) == INTEGER_CST
|| TREE_CODE (in
) == REAL_CST
789 || TREE_CODE (in
) == FIXED_CST
)
791 else if (TREE_CODE (in
) == code
792 || ((! FLOAT_TYPE_P (TREE_TYPE (in
)) || flag_associative_math
)
793 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in
))
794 /* We can associate addition and subtraction together (even
795 though the C standard doesn't say so) for integers because
796 the value is not affected. For reals, the value might be
797 affected, so we can't. */
798 && ((code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
799 || (code
== MINUS_EXPR
&& TREE_CODE (in
) == PLUS_EXPR
))))
801 tree op0
= TREE_OPERAND (in
, 0);
802 tree op1
= TREE_OPERAND (in
, 1);
803 int neg1_p
= TREE_CODE (in
) == MINUS_EXPR
;
804 int neg_litp_p
= 0, neg_conp_p
= 0, neg_var_p
= 0;
806 /* First see if either of the operands is a literal, then a constant. */
807 if (TREE_CODE (op0
) == INTEGER_CST
|| TREE_CODE (op0
) == REAL_CST
808 || TREE_CODE (op0
) == FIXED_CST
)
809 *litp
= op0
, op0
= 0;
810 else if (TREE_CODE (op1
) == INTEGER_CST
|| TREE_CODE (op1
) == REAL_CST
811 || TREE_CODE (op1
) == FIXED_CST
)
812 *litp
= op1
, neg_litp_p
= neg1_p
, op1
= 0;
814 if (op0
!= 0 && TREE_CONSTANT (op0
))
815 *conp
= op0
, op0
= 0;
816 else if (op1
!= 0 && TREE_CONSTANT (op1
))
817 *conp
= op1
, neg_conp_p
= neg1_p
, op1
= 0;
819 /* If we haven't dealt with either operand, this is not a case we can
820 decompose. Otherwise, VAR is either of the ones remaining, if any. */
821 if (op0
!= 0 && op1
!= 0)
826 var
= op1
, neg_var_p
= neg1_p
;
828 /* Now do any needed negations. */
830 *minus_litp
= *litp
, *litp
= 0;
832 *conp
= negate_expr (*conp
);
833 if (neg_var_p
&& var
)
835 /* Convert to TYPE before negating. */
836 var
= fold_convert_loc (loc
, type
, var
);
837 var
= negate_expr (var
);
840 else if (TREE_CONSTANT (in
))
842 else if (TREE_CODE (in
) == BIT_NOT_EXPR
843 && code
== PLUS_EXPR
)
845 /* -X - 1 is folded to ~X, undo that here. Do _not_ do this
846 when IN is constant. */
847 *minus_litp
= build_one_cst (TREE_TYPE (in
));
848 var
= negate_expr (TREE_OPERAND (in
, 0));
856 *minus_litp
= *litp
, *litp
= 0;
857 else if (*minus_litp
)
858 *litp
= *minus_litp
, *minus_litp
= 0;
859 *conp
= negate_expr (*conp
);
862 /* Convert to TYPE before negating. */
863 var
= fold_convert_loc (loc
, type
, var
);
864 var
= negate_expr (var
);
871 /* Re-associate trees split by the above function. T1 and T2 are
872 either expressions to associate or null. Return the new
873 expression, if any. LOC is the location of the new expression. If
874 we build an operation, do it in TYPE and with CODE. */
877 associate_trees (location_t loc
, tree t1
, tree t2
, enum tree_code code
, tree type
)
884 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
885 try to fold this since we will have infinite recursion. But do
886 deal with any NEGATE_EXPRs. */
887 if (TREE_CODE (t1
) == code
|| TREE_CODE (t2
) == code
888 || TREE_CODE (t1
) == MINUS_EXPR
|| TREE_CODE (t2
) == MINUS_EXPR
)
890 if (code
== PLUS_EXPR
)
892 if (TREE_CODE (t1
) == NEGATE_EXPR
)
893 return build2_loc (loc
, MINUS_EXPR
, type
,
894 fold_convert_loc (loc
, type
, t2
),
895 fold_convert_loc (loc
, type
,
896 TREE_OPERAND (t1
, 0)));
897 else if (TREE_CODE (t2
) == NEGATE_EXPR
)
898 return build2_loc (loc
, MINUS_EXPR
, type
,
899 fold_convert_loc (loc
, type
, t1
),
900 fold_convert_loc (loc
, type
,
901 TREE_OPERAND (t2
, 0)));
902 else if (integer_zerop (t2
))
903 return fold_convert_loc (loc
, type
, t1
);
905 else if (code
== MINUS_EXPR
)
907 if (integer_zerop (t2
))
908 return fold_convert_loc (loc
, type
, t1
);
911 return build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
912 fold_convert_loc (loc
, type
, t2
));
915 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
916 fold_convert_loc (loc
, type
, t2
));
919 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
920 for use in int_const_binop, size_binop and size_diffop. */
923 int_binop_types_match_p (enum tree_code code
, const_tree type1
, const_tree type2
)
925 if (!INTEGRAL_TYPE_P (type1
) && !POINTER_TYPE_P (type1
))
927 if (!INTEGRAL_TYPE_P (type2
) && !POINTER_TYPE_P (type2
))
942 return TYPE_UNSIGNED (type1
) == TYPE_UNSIGNED (type2
)
943 && TYPE_PRECISION (type1
) == TYPE_PRECISION (type2
)
944 && TYPE_MODE (type1
) == TYPE_MODE (type2
);
948 /* Combine two integer constants ARG1 and ARG2 under operation CODE
949 to produce a new constant. Return NULL_TREE if we don't know how
950 to evaluate CODE at compile-time. */
953 int_const_binop_1 (enum tree_code code
, const_tree arg1
, const_tree parg2
,
958 tree type
= TREE_TYPE (arg1
);
959 signop sign
= TYPE_SIGN (type
);
960 bool overflow
= false;
962 wide_int arg2
= wi::to_wide (parg2
, TYPE_PRECISION (type
));
967 res
= wi::bit_or (arg1
, arg2
);
971 res
= wi::bit_xor (arg1
, arg2
);
975 res
= wi::bit_and (arg1
, arg2
);
980 if (wi::neg_p (arg2
))
983 if (code
== RSHIFT_EXPR
)
989 if (code
== RSHIFT_EXPR
)
990 /* It's unclear from the C standard whether shifts can overflow.
991 The following code ignores overflow; perhaps a C standard
992 interpretation ruling is needed. */
993 res
= wi::rshift (arg1
, arg2
, sign
);
995 res
= wi::lshift (arg1
, arg2
);
1000 if (wi::neg_p (arg2
))
1003 if (code
== RROTATE_EXPR
)
1004 code
= LROTATE_EXPR
;
1006 code
= RROTATE_EXPR
;
1009 if (code
== RROTATE_EXPR
)
1010 res
= wi::rrotate (arg1
, arg2
);
1012 res
= wi::lrotate (arg1
, arg2
);
1016 res
= wi::add (arg1
, arg2
, sign
, &overflow
);
1020 res
= wi::sub (arg1
, arg2
, sign
, &overflow
);
1024 res
= wi::mul (arg1
, arg2
, sign
, &overflow
);
1027 case MULT_HIGHPART_EXPR
:
1028 res
= wi::mul_high (arg1
, arg2
, sign
);
1031 case TRUNC_DIV_EXPR
:
1032 case EXACT_DIV_EXPR
:
1035 res
= wi::div_trunc (arg1
, arg2
, sign
, &overflow
);
1038 case FLOOR_DIV_EXPR
:
1041 res
= wi::div_floor (arg1
, arg2
, sign
, &overflow
);
1047 res
= wi::div_ceil (arg1
, arg2
, sign
, &overflow
);
1050 case ROUND_DIV_EXPR
:
1053 res
= wi::div_round (arg1
, arg2
, sign
, &overflow
);
1056 case TRUNC_MOD_EXPR
:
1059 res
= wi::mod_trunc (arg1
, arg2
, sign
, &overflow
);
1062 case FLOOR_MOD_EXPR
:
1065 res
= wi::mod_floor (arg1
, arg2
, sign
, &overflow
);
1071 res
= wi::mod_ceil (arg1
, arg2
, sign
, &overflow
);
1074 case ROUND_MOD_EXPR
:
1077 res
= wi::mod_round (arg1
, arg2
, sign
, &overflow
);
1081 res
= wi::min (arg1
, arg2
, sign
);
1085 res
= wi::max (arg1
, arg2
, sign
);
1092 t
= force_fit_type (type
, res
, overflowable
,
1093 (((sign
== SIGNED
|| overflowable
== -1)
1095 | TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (parg2
)));
1101 int_const_binop (enum tree_code code
, const_tree arg1
, const_tree arg2
)
1103 return int_const_binop_1 (code
, arg1
, arg2
, 1);
1106 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1107 constant. We assume ARG1 and ARG2 have the same data type, or at least
1108 are the same kind of constant and the same machine mode. Return zero if
1109 combining the constants is not allowed in the current operating mode. */
1112 const_binop (enum tree_code code
, tree arg1
, tree arg2
)
1114 /* Sanity check for the recursive cases. */
1121 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg2
) == INTEGER_CST
)
1123 if (code
== POINTER_PLUS_EXPR
)
1124 return int_const_binop (PLUS_EXPR
,
1125 arg1
, fold_convert (TREE_TYPE (arg1
), arg2
));
1127 return int_const_binop (code
, arg1
, arg2
);
1130 if (TREE_CODE (arg1
) == REAL_CST
&& TREE_CODE (arg2
) == REAL_CST
)
1135 REAL_VALUE_TYPE value
;
1136 REAL_VALUE_TYPE result
;
1140 /* The following codes are handled by real_arithmetic. */
1155 d1
= TREE_REAL_CST (arg1
);
1156 d2
= TREE_REAL_CST (arg2
);
1158 type
= TREE_TYPE (arg1
);
1159 mode
= TYPE_MODE (type
);
1161 /* Don't perform operation if we honor signaling NaNs and
1162 either operand is a signaling NaN. */
1163 if (HONOR_SNANS (mode
)
1164 && (REAL_VALUE_ISSIGNALING_NAN (d1
)
1165 || REAL_VALUE_ISSIGNALING_NAN (d2
)))
1168 /* Don't perform operation if it would raise a division
1169 by zero exception. */
1170 if (code
== RDIV_EXPR
1171 && real_equal (&d2
, &dconst0
)
1172 && (flag_trapping_math
|| ! MODE_HAS_INFINITIES (mode
)))
1175 /* If either operand is a NaN, just return it. Otherwise, set up
1176 for floating-point trap; we return an overflow. */
1177 if (REAL_VALUE_ISNAN (d1
))
1179 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1182 t
= build_real (type
, d1
);
1185 else if (REAL_VALUE_ISNAN (d2
))
1187 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1190 t
= build_real (type
, d2
);
1194 inexact
= real_arithmetic (&value
, code
, &d1
, &d2
);
1195 real_convert (&result
, mode
, &value
);
1197 /* Don't constant fold this floating point operation if
1198 the result has overflowed and flag_trapping_math. */
1199 if (flag_trapping_math
1200 && MODE_HAS_INFINITIES (mode
)
1201 && REAL_VALUE_ISINF (result
)
1202 && !REAL_VALUE_ISINF (d1
)
1203 && !REAL_VALUE_ISINF (d2
))
1206 /* Don't constant fold this floating point operation if the
1207 result may dependent upon the run-time rounding mode and
1208 flag_rounding_math is set, or if GCC's software emulation
1209 is unable to accurately represent the result. */
1210 if ((flag_rounding_math
1211 || (MODE_COMPOSITE_P (mode
) && !flag_unsafe_math_optimizations
))
1212 && (inexact
|| !real_identical (&result
, &value
)))
1215 t
= build_real (type
, result
);
1217 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
);
1221 if (TREE_CODE (arg1
) == FIXED_CST
)
1223 FIXED_VALUE_TYPE f1
;
1224 FIXED_VALUE_TYPE f2
;
1225 FIXED_VALUE_TYPE result
;
1230 /* The following codes are handled by fixed_arithmetic. */
1236 case TRUNC_DIV_EXPR
:
1237 if (TREE_CODE (arg2
) != FIXED_CST
)
1239 f2
= TREE_FIXED_CST (arg2
);
1245 if (TREE_CODE (arg2
) != INTEGER_CST
)
1248 f2
.data
.high
= w2
.elt (1);
1249 f2
.data
.low
= w2
.elt (0);
1258 f1
= TREE_FIXED_CST (arg1
);
1259 type
= TREE_TYPE (arg1
);
1260 sat_p
= TYPE_SATURATING (type
);
1261 overflow_p
= fixed_arithmetic (&result
, code
, &f1
, &f2
, sat_p
);
1262 t
= build_fixed (type
, result
);
1263 /* Propagate overflow flags. */
1264 if (overflow_p
| TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
))
1265 TREE_OVERFLOW (t
) = 1;
1269 if (TREE_CODE (arg1
) == COMPLEX_CST
&& TREE_CODE (arg2
) == COMPLEX_CST
)
1271 tree type
= TREE_TYPE (arg1
);
1272 tree r1
= TREE_REALPART (arg1
);
1273 tree i1
= TREE_IMAGPART (arg1
);
1274 tree r2
= TREE_REALPART (arg2
);
1275 tree i2
= TREE_IMAGPART (arg2
);
1282 real
= const_binop (code
, r1
, r2
);
1283 imag
= const_binop (code
, i1
, i2
);
1287 if (COMPLEX_FLOAT_TYPE_P (type
))
1288 return do_mpc_arg2 (arg1
, arg2
, type
,
1289 /* do_nonfinite= */ folding_initializer
,
1292 real
= const_binop (MINUS_EXPR
,
1293 const_binop (MULT_EXPR
, r1
, r2
),
1294 const_binop (MULT_EXPR
, i1
, i2
));
1295 imag
= const_binop (PLUS_EXPR
,
1296 const_binop (MULT_EXPR
, r1
, i2
),
1297 const_binop (MULT_EXPR
, i1
, r2
));
1301 if (COMPLEX_FLOAT_TYPE_P (type
))
1302 return do_mpc_arg2 (arg1
, arg2
, type
,
1303 /* do_nonfinite= */ folding_initializer
,
1306 case TRUNC_DIV_EXPR
:
1308 case FLOOR_DIV_EXPR
:
1309 case ROUND_DIV_EXPR
:
1310 if (flag_complex_method
== 0)
1312 /* Keep this algorithm in sync with
1313 tree-complex.c:expand_complex_div_straight().
1315 Expand complex division to scalars, straightforward algorithm.
1316 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1320 = const_binop (PLUS_EXPR
,
1321 const_binop (MULT_EXPR
, r2
, r2
),
1322 const_binop (MULT_EXPR
, i2
, i2
));
1324 = const_binop (PLUS_EXPR
,
1325 const_binop (MULT_EXPR
, r1
, r2
),
1326 const_binop (MULT_EXPR
, i1
, i2
));
1328 = const_binop (MINUS_EXPR
,
1329 const_binop (MULT_EXPR
, i1
, r2
),
1330 const_binop (MULT_EXPR
, r1
, i2
));
1332 real
= const_binop (code
, t1
, magsquared
);
1333 imag
= const_binop (code
, t2
, magsquared
);
1337 /* Keep this algorithm in sync with
1338 tree-complex.c:expand_complex_div_wide().
1340 Expand complex division to scalars, modified algorithm to minimize
1341 overflow with wide input ranges. */
1342 tree compare
= fold_build2 (LT_EXPR
, boolean_type_node
,
1343 fold_abs_const (r2
, TREE_TYPE (type
)),
1344 fold_abs_const (i2
, TREE_TYPE (type
)));
1346 if (integer_nonzerop (compare
))
1348 /* In the TRUE branch, we compute
1350 div = (br * ratio) + bi;
1351 tr = (ar * ratio) + ai;
1352 ti = (ai * ratio) - ar;
1355 tree ratio
= const_binop (code
, r2
, i2
);
1356 tree div
= const_binop (PLUS_EXPR
, i2
,
1357 const_binop (MULT_EXPR
, r2
, ratio
));
1358 real
= const_binop (MULT_EXPR
, r1
, ratio
);
1359 real
= const_binop (PLUS_EXPR
, real
, i1
);
1360 real
= const_binop (code
, real
, div
);
1362 imag
= const_binop (MULT_EXPR
, i1
, ratio
);
1363 imag
= const_binop (MINUS_EXPR
, imag
, r1
);
1364 imag
= const_binop (code
, imag
, div
);
1368 /* In the FALSE branch, we compute
1370 divisor = (d * ratio) + c;
1371 tr = (b * ratio) + a;
1372 ti = b - (a * ratio);
1375 tree ratio
= const_binop (code
, i2
, r2
);
1376 tree div
= const_binop (PLUS_EXPR
, r2
,
1377 const_binop (MULT_EXPR
, i2
, ratio
));
1379 real
= const_binop (MULT_EXPR
, i1
, ratio
);
1380 real
= const_binop (PLUS_EXPR
, real
, r1
);
1381 real
= const_binop (code
, real
, div
);
1383 imag
= const_binop (MULT_EXPR
, r1
, ratio
);
1384 imag
= const_binop (MINUS_EXPR
, i1
, imag
);
1385 imag
= const_binop (code
, imag
, div
);
1395 return build_complex (type
, real
, imag
);
1398 if (TREE_CODE (arg1
) == VECTOR_CST
1399 && TREE_CODE (arg2
) == VECTOR_CST
)
1401 tree type
= TREE_TYPE (arg1
);
1402 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1403 tree
*elts
= XALLOCAVEC (tree
, count
);
1405 for (i
= 0; i
< count
; i
++)
1407 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1408 tree elem2
= VECTOR_CST_ELT (arg2
, i
);
1410 elts
[i
] = const_binop (code
, elem1
, elem2
);
1412 /* It is possible that const_binop cannot handle the given
1413 code and return NULL_TREE */
1414 if (elts
[i
] == NULL_TREE
)
1418 return build_vector (type
, elts
);
1421 /* Shifts allow a scalar offset for a vector. */
1422 if (TREE_CODE (arg1
) == VECTOR_CST
1423 && TREE_CODE (arg2
) == INTEGER_CST
)
1425 tree type
= TREE_TYPE (arg1
);
1426 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1427 tree
*elts
= XALLOCAVEC (tree
, count
);
1429 for (i
= 0; i
< count
; i
++)
1431 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1433 elts
[i
] = const_binop (code
, elem1
, arg2
);
1435 /* It is possible that const_binop cannot handle the given
1436 code and return NULL_TREE. */
1437 if (elts
[i
] == NULL_TREE
)
1441 return build_vector (type
, elts
);
1446 /* Overload that adds a TYPE parameter to be able to dispatch
1447 to fold_relational_const. */
1450 const_binop (enum tree_code code
, tree type
, tree arg1
, tree arg2
)
1452 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
1453 return fold_relational_const (code
, type
, arg1
, arg2
);
1455 /* ??? Until we make the const_binop worker take the type of the
1456 result as argument put those cases that need it here. */
1460 if ((TREE_CODE (arg1
) == REAL_CST
1461 && TREE_CODE (arg2
) == REAL_CST
)
1462 || (TREE_CODE (arg1
) == INTEGER_CST
1463 && TREE_CODE (arg2
) == INTEGER_CST
))
1464 return build_complex (type
, arg1
, arg2
);
1467 case VEC_PACK_TRUNC_EXPR
:
1468 case VEC_PACK_FIX_TRUNC_EXPR
:
1470 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
1473 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
/ 2
1474 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2
)) == nelts
/ 2);
1475 if (TREE_CODE (arg1
) != VECTOR_CST
1476 || TREE_CODE (arg2
) != VECTOR_CST
)
1479 elts
= XALLOCAVEC (tree
, nelts
);
1480 if (!vec_cst_ctor_to_array (arg1
, elts
)
1481 || !vec_cst_ctor_to_array (arg2
, elts
+ nelts
/ 2))
1484 for (i
= 0; i
< nelts
; i
++)
1486 elts
[i
] = fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
1487 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
1488 TREE_TYPE (type
), elts
[i
]);
1489 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
1493 return build_vector (type
, elts
);
1496 case VEC_WIDEN_MULT_LO_EXPR
:
1497 case VEC_WIDEN_MULT_HI_EXPR
:
1498 case VEC_WIDEN_MULT_EVEN_EXPR
:
1499 case VEC_WIDEN_MULT_ODD_EXPR
:
1501 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
1502 unsigned int out
, ofs
, scale
;
1505 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
* 2
1506 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2
)) == nelts
* 2);
1507 if (TREE_CODE (arg1
) != VECTOR_CST
|| TREE_CODE (arg2
) != VECTOR_CST
)
1510 elts
= XALLOCAVEC (tree
, nelts
* 4);
1511 if (!vec_cst_ctor_to_array (arg1
, elts
)
1512 || !vec_cst_ctor_to_array (arg2
, elts
+ nelts
* 2))
1515 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
1516 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? nelts
: 0;
1517 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
1518 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : nelts
;
1519 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
1521 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
1524 for (out
= 0; out
< nelts
; out
++)
1526 unsigned int in1
= (out
<< scale
) + ofs
;
1527 unsigned int in2
= in1
+ nelts
* 2;
1530 t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in1
]);
1531 t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in2
]);
1533 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
1535 elts
[out
] = const_binop (MULT_EXPR
, t1
, t2
);
1536 if (elts
[out
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[out
]))
1540 return build_vector (type
, elts
);
1546 if (TREE_CODE_CLASS (code
) != tcc_binary
)
1549 /* Make sure type and arg0 have the same saturating flag. */
1550 gcc_checking_assert (TYPE_SATURATING (type
)
1551 == TYPE_SATURATING (TREE_TYPE (arg1
)));
1553 return const_binop (code
, arg1
, arg2
);
1556 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1557 Return zero if computing the constants is not possible. */
1560 const_unop (enum tree_code code
, tree type
, tree arg0
)
1562 /* Don't perform the operation, other than NEGATE and ABS, if
1563 flag_signaling_nans is on and the operand is a signaling NaN. */
1564 if (TREE_CODE (arg0
) == REAL_CST
1565 && HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
1566 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg0
))
1567 && code
!= NEGATE_EXPR
1568 && code
!= ABS_EXPR
)
1575 case FIX_TRUNC_EXPR
:
1576 case FIXED_CONVERT_EXPR
:
1577 return fold_convert_const (code
, type
, arg0
);
1579 case ADDR_SPACE_CONVERT_EXPR
:
1580 /* If the source address is 0, and the source address space
1581 cannot have a valid object at 0, fold to dest type null. */
1582 if (integer_zerop (arg0
)
1583 && !(targetm
.addr_space
.zero_address_valid
1584 (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
))))))
1585 return fold_convert_const (code
, type
, arg0
);
1588 case VIEW_CONVERT_EXPR
:
1589 return fold_view_convert_expr (type
, arg0
);
1593 /* Can't call fold_negate_const directly here as that doesn't
1594 handle all cases and we might not be able to negate some
1596 tree tem
= fold_negate_expr (UNKNOWN_LOCATION
, arg0
);
1597 if (tem
&& CONSTANT_CLASS_P (tem
))
1603 if (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
)
1604 return fold_abs_const (arg0
, type
);
1608 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1610 tree ipart
= fold_negate_const (TREE_IMAGPART (arg0
),
1612 return build_complex (type
, TREE_REALPART (arg0
), ipart
);
1617 if (TREE_CODE (arg0
) == INTEGER_CST
)
1618 return fold_not_const (arg0
, type
);
1619 /* Perform BIT_NOT_EXPR on each element individually. */
1620 else if (TREE_CODE (arg0
) == VECTOR_CST
)
1624 unsigned count
= VECTOR_CST_NELTS (arg0
), i
;
1626 elements
= XALLOCAVEC (tree
, count
);
1627 for (i
= 0; i
< count
; i
++)
1629 elem
= VECTOR_CST_ELT (arg0
, i
);
1630 elem
= const_unop (BIT_NOT_EXPR
, TREE_TYPE (type
), elem
);
1631 if (elem
== NULL_TREE
)
1636 return build_vector (type
, elements
);
1640 case TRUTH_NOT_EXPR
:
1641 if (TREE_CODE (arg0
) == INTEGER_CST
)
1642 return constant_boolean_node (integer_zerop (arg0
), type
);
1646 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1647 return fold_convert (type
, TREE_REALPART (arg0
));
1651 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1652 return fold_convert (type
, TREE_IMAGPART (arg0
));
1655 case VEC_UNPACK_LO_EXPR
:
1656 case VEC_UNPACK_HI_EXPR
:
1657 case VEC_UNPACK_FLOAT_LO_EXPR
:
1658 case VEC_UNPACK_FLOAT_HI_EXPR
:
1660 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
1662 enum tree_code subcode
;
1664 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2);
1665 if (TREE_CODE (arg0
) != VECTOR_CST
)
1668 elts
= XALLOCAVEC (tree
, nelts
* 2);
1669 if (!vec_cst_ctor_to_array (arg0
, elts
))
1672 if ((!BYTES_BIG_ENDIAN
) ^ (code
== VEC_UNPACK_LO_EXPR
1673 || code
== VEC_UNPACK_FLOAT_LO_EXPR
))
1676 if (code
== VEC_UNPACK_LO_EXPR
|| code
== VEC_UNPACK_HI_EXPR
)
1679 subcode
= FLOAT_EXPR
;
1681 for (i
= 0; i
< nelts
; i
++)
1683 elts
[i
] = fold_convert_const (subcode
, TREE_TYPE (type
), elts
[i
]);
1684 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
1688 return build_vector (type
, elts
);
1691 case REDUC_MIN_EXPR
:
1692 case REDUC_MAX_EXPR
:
1693 case REDUC_PLUS_EXPR
:
1695 unsigned int nelts
, i
;
1697 enum tree_code subcode
;
1699 if (TREE_CODE (arg0
) != VECTOR_CST
)
1701 nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
));
1703 elts
= XALLOCAVEC (tree
, nelts
);
1704 if (!vec_cst_ctor_to_array (arg0
, elts
))
1709 case REDUC_MIN_EXPR
: subcode
= MIN_EXPR
; break;
1710 case REDUC_MAX_EXPR
: subcode
= MAX_EXPR
; break;
1711 case REDUC_PLUS_EXPR
: subcode
= PLUS_EXPR
; break;
1712 default: gcc_unreachable ();
1715 for (i
= 1; i
< nelts
; i
++)
1717 elts
[0] = const_binop (subcode
, elts
[0], elts
[i
]);
1718 if (elts
[0] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[0]))
1732 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1733 indicates which particular sizetype to create. */
1736 size_int_kind (HOST_WIDE_INT number
, enum size_type_kind kind
)
1738 return build_int_cst (sizetype_tab
[(int) kind
], number
);
1741 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1742 is a tree code. The type of the result is taken from the operands.
1743 Both must be equivalent integer types, ala int_binop_types_match_p.
1744 If the operands are constant, so is the result. */
1747 size_binop_loc (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
)
1749 tree type
= TREE_TYPE (arg0
);
1751 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1752 return error_mark_node
;
1754 gcc_assert (int_binop_types_match_p (code
, TREE_TYPE (arg0
),
1757 /* Handle the special case of two integer constants faster. */
1758 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1760 /* And some specific cases even faster than that. */
1761 if (code
== PLUS_EXPR
)
1763 if (integer_zerop (arg0
) && !TREE_OVERFLOW (arg0
))
1765 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1768 else if (code
== MINUS_EXPR
)
1770 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1773 else if (code
== MULT_EXPR
)
1775 if (integer_onep (arg0
) && !TREE_OVERFLOW (arg0
))
1779 /* Handle general case of two integer constants. For sizetype
1780 constant calculations we always want to know about overflow,
1781 even in the unsigned case. */
1782 return int_const_binop_1 (code
, arg0
, arg1
, -1);
1785 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
1788 /* Given two values, either both of sizetype or both of bitsizetype,
1789 compute the difference between the two values. Return the value
1790 in signed type corresponding to the type of the operands. */
1793 size_diffop_loc (location_t loc
, tree arg0
, tree arg1
)
1795 tree type
= TREE_TYPE (arg0
);
1798 gcc_assert (int_binop_types_match_p (MINUS_EXPR
, TREE_TYPE (arg0
),
1801 /* If the type is already signed, just do the simple thing. */
1802 if (!TYPE_UNSIGNED (type
))
1803 return size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
);
1805 if (type
== sizetype
)
1807 else if (type
== bitsizetype
)
1808 ctype
= sbitsizetype
;
1810 ctype
= signed_type_for (type
);
1812 /* If either operand is not a constant, do the conversions to the signed
1813 type and subtract. The hardware will do the right thing with any
1814 overflow in the subtraction. */
1815 if (TREE_CODE (arg0
) != INTEGER_CST
|| TREE_CODE (arg1
) != INTEGER_CST
)
1816 return size_binop_loc (loc
, MINUS_EXPR
,
1817 fold_convert_loc (loc
, ctype
, arg0
),
1818 fold_convert_loc (loc
, ctype
, arg1
));
1820 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1821 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1822 overflow) and negate (which can't either). Special-case a result
1823 of zero while we're here. */
1824 if (tree_int_cst_equal (arg0
, arg1
))
1825 return build_int_cst (ctype
, 0);
1826 else if (tree_int_cst_lt (arg1
, arg0
))
1827 return fold_convert_loc (loc
, ctype
,
1828 size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
));
1830 return size_binop_loc (loc
, MINUS_EXPR
, build_int_cst (ctype
, 0),
1831 fold_convert_loc (loc
, ctype
,
1832 size_binop_loc (loc
,
1837 /* A subroutine of fold_convert_const handling conversions of an
1838 INTEGER_CST to another integer type. */
1841 fold_convert_const_int_from_int (tree type
, const_tree arg1
)
1843 /* Given an integer constant, make new constant with new type,
1844 appropriately sign-extended or truncated. Use widest_int
1845 so that any extension is done according ARG1's type. */
1846 return force_fit_type (type
, wi::to_widest (arg1
),
1847 !POINTER_TYPE_P (TREE_TYPE (arg1
)),
1848 TREE_OVERFLOW (arg1
));
1851 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1852 to an integer type. */
1855 fold_convert_const_int_from_real (enum tree_code code
, tree type
, const_tree arg1
)
1857 bool overflow
= false;
1860 /* The following code implements the floating point to integer
1861 conversion rules required by the Java Language Specification,
1862 that IEEE NaNs are mapped to zero and values that overflow
1863 the target precision saturate, i.e. values greater than
1864 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1865 are mapped to INT_MIN. These semantics are allowed by the
1866 C and C++ standards that simply state that the behavior of
1867 FP-to-integer conversion is unspecified upon overflow. */
1871 REAL_VALUE_TYPE x
= TREE_REAL_CST (arg1
);
1875 case FIX_TRUNC_EXPR
:
1876 real_trunc (&r
, VOIDmode
, &x
);
1883 /* If R is NaN, return zero and show we have an overflow. */
1884 if (REAL_VALUE_ISNAN (r
))
1887 val
= wi::zero (TYPE_PRECISION (type
));
1890 /* See if R is less than the lower bound or greater than the
1895 tree lt
= TYPE_MIN_VALUE (type
);
1896 REAL_VALUE_TYPE l
= real_value_from_int_cst (NULL_TREE
, lt
);
1897 if (real_less (&r
, &l
))
1906 tree ut
= TYPE_MAX_VALUE (type
);
1909 REAL_VALUE_TYPE u
= real_value_from_int_cst (NULL_TREE
, ut
);
1910 if (real_less (&u
, &r
))
1919 val
= real_to_integer (&r
, &overflow
, TYPE_PRECISION (type
));
1921 t
= force_fit_type (type
, val
, -1, overflow
| TREE_OVERFLOW (arg1
));
1925 /* A subroutine of fold_convert_const handling conversions of a
1926 FIXED_CST to an integer type. */
1929 fold_convert_const_int_from_fixed (tree type
, const_tree arg1
)
1932 double_int temp
, temp_trunc
;
1935 /* Right shift FIXED_CST to temp by fbit. */
1936 temp
= TREE_FIXED_CST (arg1
).data
;
1937 mode
= TREE_FIXED_CST (arg1
).mode
;
1938 if (GET_MODE_FBIT (mode
) < HOST_BITS_PER_DOUBLE_INT
)
1940 temp
= temp
.rshift (GET_MODE_FBIT (mode
),
1941 HOST_BITS_PER_DOUBLE_INT
,
1942 SIGNED_FIXED_POINT_MODE_P (mode
));
1944 /* Left shift temp to temp_trunc by fbit. */
1945 temp_trunc
= temp
.lshift (GET_MODE_FBIT (mode
),
1946 HOST_BITS_PER_DOUBLE_INT
,
1947 SIGNED_FIXED_POINT_MODE_P (mode
));
1951 temp
= double_int_zero
;
1952 temp_trunc
= double_int_zero
;
1955 /* If FIXED_CST is negative, we need to round the value toward 0.
1956 By checking if the fractional bits are not zero to add 1 to temp. */
1957 if (SIGNED_FIXED_POINT_MODE_P (mode
)
1958 && temp_trunc
.is_negative ()
1959 && TREE_FIXED_CST (arg1
).data
!= temp_trunc
)
1960 temp
+= double_int_one
;
1962 /* Given a fixed-point constant, make new constant with new type,
1963 appropriately sign-extended or truncated. */
1964 t
= force_fit_type (type
, temp
, -1,
1965 (temp
.is_negative ()
1966 && (TYPE_UNSIGNED (type
)
1967 < TYPE_UNSIGNED (TREE_TYPE (arg1
))))
1968 | TREE_OVERFLOW (arg1
));
1973 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1974 to another floating point type. */
1977 fold_convert_const_real_from_real (tree type
, const_tree arg1
)
1979 REAL_VALUE_TYPE value
;
1982 /* Don't perform the operation if flag_signaling_nans is on
1983 and the operand is a signaling NaN. */
1984 if (HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
)))
1985 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg1
)))
1988 real_convert (&value
, TYPE_MODE (type
), &TREE_REAL_CST (arg1
));
1989 t
= build_real (type
, value
);
1991 /* If converting an infinity or NAN to a representation that doesn't
1992 have one, set the overflow bit so that we can produce some kind of
1993 error message at the appropriate point if necessary. It's not the
1994 most user-friendly message, but it's better than nothing. */
1995 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1
))
1996 && !MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1997 TREE_OVERFLOW (t
) = 1;
1998 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
1999 && !MODE_HAS_NANS (TYPE_MODE (type
)))
2000 TREE_OVERFLOW (t
) = 1;
2001 /* Regular overflow, conversion produced an infinity in a mode that
2002 can't represent them. */
2003 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type
))
2004 && REAL_VALUE_ISINF (value
)
2005 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1
)))
2006 TREE_OVERFLOW (t
) = 1;
2008 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2012 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2013 to a floating point type. */
2016 fold_convert_const_real_from_fixed (tree type
, const_tree arg1
)
2018 REAL_VALUE_TYPE value
;
2021 real_convert_from_fixed (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
));
2022 t
= build_real (type
, value
);
2024 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2028 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2029 to another fixed-point type. */
2032 fold_convert_const_fixed_from_fixed (tree type
, const_tree arg1
)
2034 FIXED_VALUE_TYPE value
;
2038 overflow_p
= fixed_convert (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
),
2039 TYPE_SATURATING (type
));
2040 t
= build_fixed (type
, value
);
2042 /* Propagate overflow flags. */
2043 if (overflow_p
| TREE_OVERFLOW (arg1
))
2044 TREE_OVERFLOW (t
) = 1;
2048 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2049 to a fixed-point type. */
2052 fold_convert_const_fixed_from_int (tree type
, const_tree arg1
)
2054 FIXED_VALUE_TYPE value
;
2059 gcc_assert (TREE_INT_CST_NUNITS (arg1
) <= 2);
2061 di
.low
= TREE_INT_CST_ELT (arg1
, 0);
2062 if (TREE_INT_CST_NUNITS (arg1
) == 1)
2063 di
.high
= (HOST_WIDE_INT
) di
.low
< 0 ? HOST_WIDE_INT_M1
: 0;
2065 di
.high
= TREE_INT_CST_ELT (arg1
, 1);
2067 overflow_p
= fixed_convert_from_int (&value
, TYPE_MODE (type
), di
,
2068 TYPE_UNSIGNED (TREE_TYPE (arg1
)),
2069 TYPE_SATURATING (type
));
2070 t
= build_fixed (type
, value
);
2072 /* Propagate overflow flags. */
2073 if (overflow_p
| TREE_OVERFLOW (arg1
))
2074 TREE_OVERFLOW (t
) = 1;
2078 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2079 to a fixed-point type. */
2082 fold_convert_const_fixed_from_real (tree type
, const_tree arg1
)
2084 FIXED_VALUE_TYPE value
;
2088 overflow_p
= fixed_convert_from_real (&value
, TYPE_MODE (type
),
2089 &TREE_REAL_CST (arg1
),
2090 TYPE_SATURATING (type
));
2091 t
= build_fixed (type
, value
);
2093 /* Propagate overflow flags. */
2094 if (overflow_p
| TREE_OVERFLOW (arg1
))
2095 TREE_OVERFLOW (t
) = 1;
2099 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2100 type TYPE. If no simplification can be done return NULL_TREE. */
2103 fold_convert_const (enum tree_code code
, tree type
, tree arg1
)
2105 if (TREE_TYPE (arg1
) == type
)
2108 if (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
)
2109 || TREE_CODE (type
) == OFFSET_TYPE
)
2111 if (TREE_CODE (arg1
) == INTEGER_CST
)
2112 return fold_convert_const_int_from_int (type
, arg1
);
2113 else if (TREE_CODE (arg1
) == REAL_CST
)
2114 return fold_convert_const_int_from_real (code
, type
, arg1
);
2115 else if (TREE_CODE (arg1
) == FIXED_CST
)
2116 return fold_convert_const_int_from_fixed (type
, arg1
);
2118 else if (TREE_CODE (type
) == REAL_TYPE
)
2120 if (TREE_CODE (arg1
) == INTEGER_CST
)
2121 return build_real_from_int_cst (type
, arg1
);
2122 else if (TREE_CODE (arg1
) == REAL_CST
)
2123 return fold_convert_const_real_from_real (type
, arg1
);
2124 else if (TREE_CODE (arg1
) == FIXED_CST
)
2125 return fold_convert_const_real_from_fixed (type
, arg1
);
2127 else if (TREE_CODE (type
) == FIXED_POINT_TYPE
)
2129 if (TREE_CODE (arg1
) == FIXED_CST
)
2130 return fold_convert_const_fixed_from_fixed (type
, arg1
);
2131 else if (TREE_CODE (arg1
) == INTEGER_CST
)
2132 return fold_convert_const_fixed_from_int (type
, arg1
);
2133 else if (TREE_CODE (arg1
) == REAL_CST
)
2134 return fold_convert_const_fixed_from_real (type
, arg1
);
2136 else if (TREE_CODE (type
) == VECTOR_TYPE
)
2138 if (TREE_CODE (arg1
) == VECTOR_CST
2139 && TYPE_VECTOR_SUBPARTS (type
) == VECTOR_CST_NELTS (arg1
))
2141 int len
= TYPE_VECTOR_SUBPARTS (type
);
2142 tree elttype
= TREE_TYPE (type
);
2143 tree
*v
= XALLOCAVEC (tree
, len
);
2144 for (int i
= 0; i
< len
; ++i
)
2146 tree elt
= VECTOR_CST_ELT (arg1
, i
);
2147 tree cvt
= fold_convert_const (code
, elttype
, elt
);
2148 if (cvt
== NULL_TREE
)
2152 return build_vector (type
, v
);
2158 /* Construct a vector of zero elements of vector type TYPE. */
2161 build_zero_vector (tree type
)
2165 t
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), integer_zero_node
);
2166 return build_vector_from_val (type
, t
);
2169 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2172 fold_convertible_p (const_tree type
, const_tree arg
)
2174 tree orig
= TREE_TYPE (arg
);
2179 if (TREE_CODE (arg
) == ERROR_MARK
2180 || TREE_CODE (type
) == ERROR_MARK
2181 || TREE_CODE (orig
) == ERROR_MARK
)
2184 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2187 switch (TREE_CODE (type
))
2189 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2190 case POINTER_TYPE
: case REFERENCE_TYPE
:
2192 return (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2193 || TREE_CODE (orig
) == OFFSET_TYPE
);
2196 case FIXED_POINT_TYPE
:
2199 return TREE_CODE (type
) == TREE_CODE (orig
);
2206 /* Convert expression ARG to type TYPE. Used by the middle-end for
2207 simple conversions in preference to calling the front-end's convert. */
2210 fold_convert_loc (location_t loc
, tree type
, tree arg
)
2212 tree orig
= TREE_TYPE (arg
);
2218 if (TREE_CODE (arg
) == ERROR_MARK
2219 || TREE_CODE (type
) == ERROR_MARK
2220 || TREE_CODE (orig
) == ERROR_MARK
)
2221 return error_mark_node
;
2223 switch (TREE_CODE (type
))
2226 case REFERENCE_TYPE
:
2227 /* Handle conversions between pointers to different address spaces. */
2228 if (POINTER_TYPE_P (orig
)
2229 && (TYPE_ADDR_SPACE (TREE_TYPE (type
))
2230 != TYPE_ADDR_SPACE (TREE_TYPE (orig
))))
2231 return fold_build1_loc (loc
, ADDR_SPACE_CONVERT_EXPR
, type
, arg
);
2234 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2236 if (TREE_CODE (arg
) == INTEGER_CST
)
2238 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2239 if (tem
!= NULL_TREE
)
2242 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2243 || TREE_CODE (orig
) == OFFSET_TYPE
)
2244 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2245 if (TREE_CODE (orig
) == COMPLEX_TYPE
)
2246 return fold_convert_loc (loc
, type
,
2247 fold_build1_loc (loc
, REALPART_EXPR
,
2248 TREE_TYPE (orig
), arg
));
2249 gcc_assert (TREE_CODE (orig
) == VECTOR_TYPE
2250 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2251 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2254 if (TREE_CODE (arg
) == INTEGER_CST
)
2256 tem
= fold_convert_const (FLOAT_EXPR
, type
, arg
);
2257 if (tem
!= NULL_TREE
)
2260 else if (TREE_CODE (arg
) == REAL_CST
)
2262 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2263 if (tem
!= NULL_TREE
)
2266 else if (TREE_CODE (arg
) == FIXED_CST
)
2268 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2269 if (tem
!= NULL_TREE
)
2273 switch (TREE_CODE (orig
))
2276 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2277 case POINTER_TYPE
: case REFERENCE_TYPE
:
2278 return fold_build1_loc (loc
, FLOAT_EXPR
, type
, arg
);
2281 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2283 case FIXED_POINT_TYPE
:
2284 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2287 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2288 return fold_convert_loc (loc
, type
, tem
);
2294 case FIXED_POINT_TYPE
:
2295 if (TREE_CODE (arg
) == FIXED_CST
|| TREE_CODE (arg
) == INTEGER_CST
2296 || TREE_CODE (arg
) == REAL_CST
)
2298 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2299 if (tem
!= NULL_TREE
)
2300 goto fold_convert_exit
;
2303 switch (TREE_CODE (orig
))
2305 case FIXED_POINT_TYPE
:
2310 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2313 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2314 return fold_convert_loc (loc
, type
, tem
);
2321 switch (TREE_CODE (orig
))
2324 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2325 case POINTER_TYPE
: case REFERENCE_TYPE
:
2327 case FIXED_POINT_TYPE
:
2328 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
2329 fold_convert_loc (loc
, TREE_TYPE (type
), arg
),
2330 fold_convert_loc (loc
, TREE_TYPE (type
),
2331 integer_zero_node
));
2336 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
2338 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2339 TREE_OPERAND (arg
, 0));
2340 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2341 TREE_OPERAND (arg
, 1));
2342 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2345 arg
= save_expr (arg
);
2346 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2347 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, TREE_TYPE (orig
), arg
);
2348 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
), rpart
);
2349 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
), ipart
);
2350 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2358 if (integer_zerop (arg
))
2359 return build_zero_vector (type
);
2360 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2361 gcc_assert (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2362 || TREE_CODE (orig
) == VECTOR_TYPE
);
2363 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2366 tem
= fold_ignored_result (arg
);
2367 return fold_build1_loc (loc
, NOP_EXPR
, type
, tem
);
2370 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2371 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2375 protected_set_expr_location_unshare (tem
, loc
);
2379 /* Return false if expr can be assumed not to be an lvalue, true
2383 maybe_lvalue_p (const_tree x
)
2385 /* We only need to wrap lvalue tree codes. */
2386 switch (TREE_CODE (x
))
2399 case ARRAY_RANGE_REF
:
2405 case PREINCREMENT_EXPR
:
2406 case PREDECREMENT_EXPR
:
2408 case TRY_CATCH_EXPR
:
2409 case WITH_CLEANUP_EXPR
:
2418 /* Assume the worst for front-end tree codes. */
2419 if ((int)TREE_CODE (x
) >= NUM_TREE_CODES
)
2427 /* Return an expr equal to X but certainly not valid as an lvalue. */
2430 non_lvalue_loc (location_t loc
, tree x
)
2432 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2437 if (! maybe_lvalue_p (x
))
2439 return build1_loc (loc
, NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
2442 /* When pedantic, return an expr equal to X but certainly not valid as a
2443 pedantic lvalue. Otherwise, return X. */
2446 pedantic_non_lvalue_loc (location_t loc
, tree x
)
2448 return protected_set_expr_location_unshare (x
, loc
);
2451 /* Given a tree comparison code, return the code that is the logical inverse.
2452 It is generally not safe to do this for floating-point comparisons, except
2453 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2454 ERROR_MARK in this case. */
2457 invert_tree_comparison (enum tree_code code
, bool honor_nans
)
2459 if (honor_nans
&& flag_trapping_math
&& code
!= EQ_EXPR
&& code
!= NE_EXPR
2460 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
)
2470 return honor_nans
? UNLE_EXPR
: LE_EXPR
;
2472 return honor_nans
? UNLT_EXPR
: LT_EXPR
;
2474 return honor_nans
? UNGE_EXPR
: GE_EXPR
;
2476 return honor_nans
? UNGT_EXPR
: GT_EXPR
;
2490 return UNORDERED_EXPR
;
2491 case UNORDERED_EXPR
:
2492 return ORDERED_EXPR
;
2498 /* Similar, but return the comparison that results if the operands are
2499 swapped. This is safe for floating-point. */
2502 swap_tree_comparison (enum tree_code code
)
2509 case UNORDERED_EXPR
:
2535 /* Convert a comparison tree code from an enum tree_code representation
2536 into a compcode bit-based encoding. This function is the inverse of
2537 compcode_to_comparison. */
2539 static enum comparison_code
2540 comparison_to_compcode (enum tree_code code
)
2557 return COMPCODE_ORD
;
2558 case UNORDERED_EXPR
:
2559 return COMPCODE_UNORD
;
2561 return COMPCODE_UNLT
;
2563 return COMPCODE_UNEQ
;
2565 return COMPCODE_UNLE
;
2567 return COMPCODE_UNGT
;
2569 return COMPCODE_LTGT
;
2571 return COMPCODE_UNGE
;
2577 /* Convert a compcode bit-based encoding of a comparison operator back
2578 to GCC's enum tree_code representation. This function is the
2579 inverse of comparison_to_compcode. */
2581 static enum tree_code
2582 compcode_to_comparison (enum comparison_code code
)
2599 return ORDERED_EXPR
;
2600 case COMPCODE_UNORD
:
2601 return UNORDERED_EXPR
;
2619 /* Return a tree for the comparison which is the combination of
2620 doing the AND or OR (depending on CODE) of the two operations LCODE
2621 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2622 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2623 if this makes the transformation invalid. */
2626 combine_comparisons (location_t loc
,
2627 enum tree_code code
, enum tree_code lcode
,
2628 enum tree_code rcode
, tree truth_type
,
2629 tree ll_arg
, tree lr_arg
)
2631 bool honor_nans
= HONOR_NANS (ll_arg
);
2632 enum comparison_code lcompcode
= comparison_to_compcode (lcode
);
2633 enum comparison_code rcompcode
= comparison_to_compcode (rcode
);
2638 case TRUTH_AND_EXPR
: case TRUTH_ANDIF_EXPR
:
2639 compcode
= lcompcode
& rcompcode
;
2642 case TRUTH_OR_EXPR
: case TRUTH_ORIF_EXPR
:
2643 compcode
= lcompcode
| rcompcode
;
2652 /* Eliminate unordered comparisons, as well as LTGT and ORD
2653 which are not used unless the mode has NaNs. */
2654 compcode
&= ~COMPCODE_UNORD
;
2655 if (compcode
== COMPCODE_LTGT
)
2656 compcode
= COMPCODE_NE
;
2657 else if (compcode
== COMPCODE_ORD
)
2658 compcode
= COMPCODE_TRUE
;
2660 else if (flag_trapping_math
)
2662 /* Check that the original operation and the optimized ones will trap
2663 under the same condition. */
2664 bool ltrap
= (lcompcode
& COMPCODE_UNORD
) == 0
2665 && (lcompcode
!= COMPCODE_EQ
)
2666 && (lcompcode
!= COMPCODE_ORD
);
2667 bool rtrap
= (rcompcode
& COMPCODE_UNORD
) == 0
2668 && (rcompcode
!= COMPCODE_EQ
)
2669 && (rcompcode
!= COMPCODE_ORD
);
2670 bool trap
= (compcode
& COMPCODE_UNORD
) == 0
2671 && (compcode
!= COMPCODE_EQ
)
2672 && (compcode
!= COMPCODE_ORD
);
2674 /* In a short-circuited boolean expression the LHS might be
2675 such that the RHS, if evaluated, will never trap. For
2676 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2677 if neither x nor y is NaN. (This is a mixed blessing: for
2678 example, the expression above will never trap, hence
2679 optimizing it to x < y would be invalid). */
2680 if ((code
== TRUTH_ORIF_EXPR
&& (lcompcode
& COMPCODE_UNORD
))
2681 || (code
== TRUTH_ANDIF_EXPR
&& !(lcompcode
& COMPCODE_UNORD
)))
2684 /* If the comparison was short-circuited, and only the RHS
2685 trapped, we may now generate a spurious trap. */
2687 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2690 /* If we changed the conditions that cause a trap, we lose. */
2691 if ((ltrap
|| rtrap
) != trap
)
2695 if (compcode
== COMPCODE_TRUE
)
2696 return constant_boolean_node (true, truth_type
);
2697 else if (compcode
== COMPCODE_FALSE
)
2698 return constant_boolean_node (false, truth_type
);
2701 enum tree_code tcode
;
2703 tcode
= compcode_to_comparison ((enum comparison_code
) compcode
);
2704 return fold_build2_loc (loc
, tcode
, truth_type
, ll_arg
, lr_arg
);
2708 /* Return nonzero if two operands (typically of the same tree node)
2709 are necessarily equal. FLAGS modifies behavior as follows:
2711 If OEP_ONLY_CONST is set, only return nonzero for constants.
2712 This function tests whether the operands are indistinguishable;
2713 it does not test whether they are equal using C's == operation.
2714 The distinction is important for IEEE floating point, because
2715 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2716 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2718 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2719 even though it may hold multiple values during a function.
2720 This is because a GCC tree node guarantees that nothing else is
2721 executed between the evaluation of its "operands" (which may often
2722 be evaluated in arbitrary order). Hence if the operands themselves
2723 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2724 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2725 unset means assuming isochronic (or instantaneous) tree equivalence.
2726 Unless comparing arbitrary expression trees, such as from different
2727 statements, this flag can usually be left unset.
2729 If OEP_PURE_SAME is set, then pure functions with identical arguments
2730 are considered the same. It is used when the caller has other ways
2731 to ensure that global memory is unchanged in between.
2733 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2734 not values of expressions.
2736 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2737 any operand with side effect. This is unnecesarily conservative in the
2738 case we know that arg0 and arg1 are in disjoint code paths (such as in
2739 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2740 addresses with TREE_CONSTANT flag set so we know that &var == &var
2741 even if var is volatile. */
2744 operand_equal_p (const_tree arg0
, const_tree arg1
, unsigned int flags
)
2746 /* When checking, verify at the outermost operand_equal_p call that
2747 if operand_equal_p returns non-zero then ARG0 and ARG1 has the same
2749 if (flag_checking
&& !(flags
& OEP_NO_HASH_CHECK
))
2751 if (operand_equal_p (arg0
, arg1
, flags
| OEP_NO_HASH_CHECK
))
2755 inchash::hash
hstate0 (0), hstate1 (0);
2756 inchash::add_expr (arg0
, hstate0
, flags
| OEP_HASH_CHECK
);
2757 inchash::add_expr (arg1
, hstate1
, flags
| OEP_HASH_CHECK
);
2758 hashval_t h0
= hstate0
.end ();
2759 hashval_t h1
= hstate1
.end ();
2760 gcc_assert (h0
== h1
);
2768 /* If either is ERROR_MARK, they aren't equal. */
2769 if (TREE_CODE (arg0
) == ERROR_MARK
|| TREE_CODE (arg1
) == ERROR_MARK
2770 || TREE_TYPE (arg0
) == error_mark_node
2771 || TREE_TYPE (arg1
) == error_mark_node
)
2774 /* Similar, if either does not have a type (like a released SSA name),
2775 they aren't equal. */
2776 if (!TREE_TYPE (arg0
) || !TREE_TYPE (arg1
))
2779 /* We cannot consider pointers to different address space equal. */
2780 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
2781 && POINTER_TYPE_P (TREE_TYPE (arg1
))
2782 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
)))
2783 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1
)))))
2786 /* Check equality of integer constants before bailing out due to
2787 precision differences. */
2788 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2790 /* Address of INTEGER_CST is not defined; check that we did not forget
2791 to drop the OEP_ADDRESS_OF flags. */
2792 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
2793 return tree_int_cst_equal (arg0
, arg1
);
2796 if (!(flags
& OEP_ADDRESS_OF
))
2798 /* If both types don't have the same signedness, then we can't consider
2799 them equal. We must check this before the STRIP_NOPS calls
2800 because they may change the signedness of the arguments. As pointers
2801 strictly don't have a signedness, require either two pointers or
2802 two non-pointers as well. */
2803 if (TYPE_UNSIGNED (TREE_TYPE (arg0
)) != TYPE_UNSIGNED (TREE_TYPE (arg1
))
2804 || POINTER_TYPE_P (TREE_TYPE (arg0
))
2805 != POINTER_TYPE_P (TREE_TYPE (arg1
)))
2808 /* If both types don't have the same precision, then it is not safe
2810 if (element_precision (TREE_TYPE (arg0
))
2811 != element_precision (TREE_TYPE (arg1
)))
2818 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2819 sanity check once the issue is solved. */
2821 /* Addresses of conversions and SSA_NAMEs (and many other things)
2822 are not defined. Check that we did not forget to drop the
2823 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2824 gcc_checking_assert (!CONVERT_EXPR_P (arg0
) && !CONVERT_EXPR_P (arg1
)
2825 && TREE_CODE (arg0
) != SSA_NAME
);
2828 /* In case both args are comparisons but with different comparison
2829 code, try to swap the comparison operands of one arg to produce
2830 a match and compare that variant. */
2831 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2832 && COMPARISON_CLASS_P (arg0
)
2833 && COMPARISON_CLASS_P (arg1
))
2835 enum tree_code swap_code
= swap_tree_comparison (TREE_CODE (arg1
));
2837 if (TREE_CODE (arg0
) == swap_code
)
2838 return operand_equal_p (TREE_OPERAND (arg0
, 0),
2839 TREE_OPERAND (arg1
, 1), flags
)
2840 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2841 TREE_OPERAND (arg1
, 0), flags
);
2844 if (TREE_CODE (arg0
) != TREE_CODE (arg1
))
2846 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2847 if (CONVERT_EXPR_P (arg0
) && CONVERT_EXPR_P (arg1
))
2849 else if (flags
& OEP_ADDRESS_OF
)
2851 /* If we are interested in comparing addresses ignore
2852 MEM_REF wrappings of the base that can appear just for
2854 if (TREE_CODE (arg0
) == MEM_REF
2856 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ADDR_EXPR
2857 && TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0) == arg1
2858 && integer_zerop (TREE_OPERAND (arg0
, 1)))
2860 else if (TREE_CODE (arg1
) == MEM_REF
2862 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ADDR_EXPR
2863 && TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0) == arg0
2864 && integer_zerop (TREE_OPERAND (arg1
, 1)))
2872 /* When not checking adddresses, this is needed for conversions and for
2873 COMPONENT_REF. Might as well play it safe and always test this. */
2874 if (TREE_CODE (TREE_TYPE (arg0
)) == ERROR_MARK
2875 || TREE_CODE (TREE_TYPE (arg1
)) == ERROR_MARK
2876 || (TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
))
2877 && !(flags
& OEP_ADDRESS_OF
)))
2880 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2881 We don't care about side effects in that case because the SAVE_EXPR
2882 takes care of that for us. In all other cases, two expressions are
2883 equal if they have no side effects. If we have two identical
2884 expressions with side effects that should be treated the same due
2885 to the only side effects being identical SAVE_EXPR's, that will
2886 be detected in the recursive calls below.
2887 If we are taking an invariant address of two identical objects
2888 they are necessarily equal as well. */
2889 if (arg0
== arg1
&& ! (flags
& OEP_ONLY_CONST
)
2890 && (TREE_CODE (arg0
) == SAVE_EXPR
2891 || (flags
& OEP_MATCH_SIDE_EFFECTS
)
2892 || (! TREE_SIDE_EFFECTS (arg0
) && ! TREE_SIDE_EFFECTS (arg1
))))
2895 /* Next handle constant cases, those for which we can return 1 even
2896 if ONLY_CONST is set. */
2897 if (TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
))
2898 switch (TREE_CODE (arg0
))
2901 return tree_int_cst_equal (arg0
, arg1
);
2904 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0
),
2905 TREE_FIXED_CST (arg1
));
2908 if (real_identical (&TREE_REAL_CST (arg0
), &TREE_REAL_CST (arg1
)))
2912 if (!HONOR_SIGNED_ZEROS (arg0
))
2914 /* If we do not distinguish between signed and unsigned zero,
2915 consider them equal. */
2916 if (real_zerop (arg0
) && real_zerop (arg1
))
2925 if (VECTOR_CST_NELTS (arg0
) != VECTOR_CST_NELTS (arg1
))
2928 for (i
= 0; i
< VECTOR_CST_NELTS (arg0
); ++i
)
2930 if (!operand_equal_p (VECTOR_CST_ELT (arg0
, i
),
2931 VECTOR_CST_ELT (arg1
, i
), flags
))
2938 return (operand_equal_p (TREE_REALPART (arg0
), TREE_REALPART (arg1
),
2940 && operand_equal_p (TREE_IMAGPART (arg0
), TREE_IMAGPART (arg1
),
2944 return (TREE_STRING_LENGTH (arg0
) == TREE_STRING_LENGTH (arg1
)
2945 && ! memcmp (TREE_STRING_POINTER (arg0
),
2946 TREE_STRING_POINTER (arg1
),
2947 TREE_STRING_LENGTH (arg0
)));
2950 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
2951 return operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0),
2952 flags
| OEP_ADDRESS_OF
2953 | OEP_MATCH_SIDE_EFFECTS
);
2955 /* In GIMPLE empty constructors are allowed in initializers of
2957 return !CONSTRUCTOR_NELTS (arg0
) && !CONSTRUCTOR_NELTS (arg1
);
2962 if (flags
& OEP_ONLY_CONST
)
2965 /* Define macros to test an operand from arg0 and arg1 for equality and a
2966 variant that allows null and views null as being different from any
2967 non-null value. In the latter case, if either is null, the both
2968 must be; otherwise, do the normal comparison. */
2969 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2970 TREE_OPERAND (arg1, N), flags)
2972 #define OP_SAME_WITH_NULL(N) \
2973 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2974 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2976 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
2979 /* Two conversions are equal only if signedness and modes match. */
2980 switch (TREE_CODE (arg0
))
2983 case FIX_TRUNC_EXPR
:
2984 if (TYPE_UNSIGNED (TREE_TYPE (arg0
))
2985 != TYPE_UNSIGNED (TREE_TYPE (arg1
)))
2995 case tcc_comparison
:
2997 if (OP_SAME (0) && OP_SAME (1))
3000 /* For commutative ops, allow the other order. */
3001 return (commutative_tree_code (TREE_CODE (arg0
))
3002 && operand_equal_p (TREE_OPERAND (arg0
, 0),
3003 TREE_OPERAND (arg1
, 1), flags
)
3004 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3005 TREE_OPERAND (arg1
, 0), flags
));
3008 /* If either of the pointer (or reference) expressions we are
3009 dereferencing contain a side effect, these cannot be equal,
3010 but their addresses can be. */
3011 if ((flags
& OEP_MATCH_SIDE_EFFECTS
) == 0
3012 && (TREE_SIDE_EFFECTS (arg0
)
3013 || TREE_SIDE_EFFECTS (arg1
)))
3016 switch (TREE_CODE (arg0
))
3019 if (!(flags
& OEP_ADDRESS_OF
)
3020 && (TYPE_ALIGN (TREE_TYPE (arg0
))
3021 != TYPE_ALIGN (TREE_TYPE (arg1
))))
3023 flags
&= ~OEP_ADDRESS_OF
;
3027 /* Require the same offset. */
3028 if (!operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3029 TYPE_SIZE (TREE_TYPE (arg1
)),
3030 flags
& ~OEP_ADDRESS_OF
))
3035 case VIEW_CONVERT_EXPR
:
3038 case TARGET_MEM_REF
:
3040 if (!(flags
& OEP_ADDRESS_OF
))
3042 /* Require equal access sizes */
3043 if (TYPE_SIZE (TREE_TYPE (arg0
)) != TYPE_SIZE (TREE_TYPE (arg1
))
3044 && (!TYPE_SIZE (TREE_TYPE (arg0
))
3045 || !TYPE_SIZE (TREE_TYPE (arg1
))
3046 || !operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3047 TYPE_SIZE (TREE_TYPE (arg1
)),
3050 /* Verify that access happens in similar types. */
3051 if (!types_compatible_p (TREE_TYPE (arg0
), TREE_TYPE (arg1
)))
3053 /* Verify that accesses are TBAA compatible. */
3054 if (!alias_ptr_types_compatible_p
3055 (TREE_TYPE (TREE_OPERAND (arg0
, 1)),
3056 TREE_TYPE (TREE_OPERAND (arg1
, 1)))
3057 || (MR_DEPENDENCE_CLIQUE (arg0
)
3058 != MR_DEPENDENCE_CLIQUE (arg1
))
3059 || (MR_DEPENDENCE_BASE (arg0
)
3060 != MR_DEPENDENCE_BASE (arg1
)))
3062 /* Verify that alignment is compatible. */
3063 if (TYPE_ALIGN (TREE_TYPE (arg0
))
3064 != TYPE_ALIGN (TREE_TYPE (arg1
)))
3067 flags
&= ~OEP_ADDRESS_OF
;
3068 return (OP_SAME (0) && OP_SAME (1)
3069 /* TARGET_MEM_REF require equal extra operands. */
3070 && (TREE_CODE (arg0
) != TARGET_MEM_REF
3071 || (OP_SAME_WITH_NULL (2)
3072 && OP_SAME_WITH_NULL (3)
3073 && OP_SAME_WITH_NULL (4))));
3076 case ARRAY_RANGE_REF
:
3079 flags
&= ~OEP_ADDRESS_OF
;
3080 /* Compare the array index by value if it is constant first as we
3081 may have different types but same value here. */
3082 return ((tree_int_cst_equal (TREE_OPERAND (arg0
, 1),
3083 TREE_OPERAND (arg1
, 1))
3085 && OP_SAME_WITH_NULL (2)
3086 && OP_SAME_WITH_NULL (3)
3087 /* Compare low bound and element size as with OEP_ADDRESS_OF
3088 we have to account for the offset of the ref. */
3089 && (TREE_TYPE (TREE_OPERAND (arg0
, 0))
3090 == TREE_TYPE (TREE_OPERAND (arg1
, 0))
3091 || (operand_equal_p (array_ref_low_bound
3092 (CONST_CAST_TREE (arg0
)),
3094 (CONST_CAST_TREE (arg1
)), flags
)
3095 && operand_equal_p (array_ref_element_size
3096 (CONST_CAST_TREE (arg0
)),
3097 array_ref_element_size
3098 (CONST_CAST_TREE (arg1
)),
3102 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3103 may be NULL when we're called to compare MEM_EXPRs. */
3104 if (!OP_SAME_WITH_NULL (0)
3107 flags
&= ~OEP_ADDRESS_OF
;
3108 return OP_SAME_WITH_NULL (2);
3113 flags
&= ~OEP_ADDRESS_OF
;
3114 return OP_SAME (1) && OP_SAME (2);
3120 case tcc_expression
:
3121 switch (TREE_CODE (arg0
))
3124 /* Be sure we pass right ADDRESS_OF flag. */
3125 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
3126 return operand_equal_p (TREE_OPERAND (arg0
, 0),
3127 TREE_OPERAND (arg1
, 0),
3128 flags
| OEP_ADDRESS_OF
);
3130 case TRUTH_NOT_EXPR
:
3133 case TRUTH_ANDIF_EXPR
:
3134 case TRUTH_ORIF_EXPR
:
3135 return OP_SAME (0) && OP_SAME (1);
3138 case WIDEN_MULT_PLUS_EXPR
:
3139 case WIDEN_MULT_MINUS_EXPR
:
3142 /* The multiplcation operands are commutative. */
3145 case TRUTH_AND_EXPR
:
3147 case TRUTH_XOR_EXPR
:
3148 if (OP_SAME (0) && OP_SAME (1))
3151 /* Otherwise take into account this is a commutative operation. */
3152 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
3153 TREE_OPERAND (arg1
, 1), flags
)
3154 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3155 TREE_OPERAND (arg1
, 0), flags
));
3158 if (! OP_SAME (1) || ! OP_SAME (2))
3160 flags
&= ~OEP_ADDRESS_OF
;
3165 case BIT_INSERT_EXPR
:
3166 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3173 switch (TREE_CODE (arg0
))
3176 if ((CALL_EXPR_FN (arg0
) == NULL_TREE
)
3177 != (CALL_EXPR_FN (arg1
) == NULL_TREE
))
3178 /* If not both CALL_EXPRs are either internal or normal function
3179 functions, then they are not equal. */
3181 else if (CALL_EXPR_FN (arg0
) == NULL_TREE
)
3183 /* If the CALL_EXPRs call different internal functions, then they
3185 if (CALL_EXPR_IFN (arg0
) != CALL_EXPR_IFN (arg1
))
3190 /* If the CALL_EXPRs call different functions, then they are not
3192 if (! operand_equal_p (CALL_EXPR_FN (arg0
), CALL_EXPR_FN (arg1
),
3197 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3199 unsigned int cef
= call_expr_flags (arg0
);
3200 if (flags
& OEP_PURE_SAME
)
3201 cef
&= ECF_CONST
| ECF_PURE
;
3208 /* Now see if all the arguments are the same. */
3210 const_call_expr_arg_iterator iter0
, iter1
;
3212 for (a0
= first_const_call_expr_arg (arg0
, &iter0
),
3213 a1
= first_const_call_expr_arg (arg1
, &iter1
);
3215 a0
= next_const_call_expr_arg (&iter0
),
3216 a1
= next_const_call_expr_arg (&iter1
))
3217 if (! operand_equal_p (a0
, a1
, flags
))
3220 /* If we get here and both argument lists are exhausted
3221 then the CALL_EXPRs are equal. */
3222 return ! (a0
|| a1
);
3228 case tcc_declaration
:
3229 /* Consider __builtin_sqrt equal to sqrt. */
3230 return (TREE_CODE (arg0
) == FUNCTION_DECL
3231 && DECL_BUILT_IN (arg0
) && DECL_BUILT_IN (arg1
)
3232 && DECL_BUILT_IN_CLASS (arg0
) == DECL_BUILT_IN_CLASS (arg1
)
3233 && DECL_FUNCTION_CODE (arg0
) == DECL_FUNCTION_CODE (arg1
));
3235 case tcc_exceptional
:
3236 if (TREE_CODE (arg0
) == CONSTRUCTOR
)
3238 /* In GIMPLE constructors are used only to build vectors from
3239 elements. Individual elements in the constructor must be
3240 indexed in increasing order and form an initial sequence.
3242 We make no effort to compare constructors in generic.
3243 (see sem_variable::equals in ipa-icf which can do so for
3245 if (!VECTOR_TYPE_P (TREE_TYPE (arg0
))
3246 || !VECTOR_TYPE_P (TREE_TYPE (arg1
)))
3249 /* Be sure that vectors constructed have the same representation.
3250 We only tested element precision and modes to match.
3251 Vectors may be BLKmode and thus also check that the number of
3253 if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
))
3254 != TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)))
3257 vec
<constructor_elt
, va_gc
> *v0
= CONSTRUCTOR_ELTS (arg0
);
3258 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (arg1
);
3259 unsigned int len
= vec_safe_length (v0
);
3261 if (len
!= vec_safe_length (v1
))
3264 for (unsigned int i
= 0; i
< len
; i
++)
3266 constructor_elt
*c0
= &(*v0
)[i
];
3267 constructor_elt
*c1
= &(*v1
)[i
];
3269 if (!operand_equal_p (c0
->value
, c1
->value
, flags
)
3270 /* In GIMPLE the indexes can be either NULL or matching i.
3271 Double check this so we won't get false
3272 positives for GENERIC. */
3274 && (TREE_CODE (c0
->index
) != INTEGER_CST
3275 || !compare_tree_int (c0
->index
, i
)))
3277 && (TREE_CODE (c1
->index
) != INTEGER_CST
3278 || !compare_tree_int (c1
->index
, i
))))
3290 #undef OP_SAME_WITH_NULL
3293 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3294 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3296 When in doubt, return 0. */
3299 operand_equal_for_comparison_p (tree arg0
, tree arg1
, tree other
)
3301 int unsignedp1
, unsignedpo
;
3302 tree primarg0
, primarg1
, primother
;
3303 unsigned int correct_width
;
3305 if (operand_equal_p (arg0
, arg1
, 0))
3308 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
3309 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
3312 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3313 and see if the inner values are the same. This removes any
3314 signedness comparison, which doesn't matter here. */
3315 primarg0
= arg0
, primarg1
= arg1
;
3316 STRIP_NOPS (primarg0
);
3317 STRIP_NOPS (primarg1
);
3318 if (operand_equal_p (primarg0
, primarg1
, 0))
3321 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3322 actual comparison operand, ARG0.
3324 First throw away any conversions to wider types
3325 already present in the operands. */
3327 primarg1
= get_narrower (arg1
, &unsignedp1
);
3328 primother
= get_narrower (other
, &unsignedpo
);
3330 correct_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
3331 if (unsignedp1
== unsignedpo
3332 && TYPE_PRECISION (TREE_TYPE (primarg1
)) < correct_width
3333 && TYPE_PRECISION (TREE_TYPE (primother
)) < correct_width
)
3335 tree type
= TREE_TYPE (arg0
);
3337 /* Make sure shorter operand is extended the right way
3338 to match the longer operand. */
3339 primarg1
= fold_convert (signed_or_unsigned_type_for
3340 (unsignedp1
, TREE_TYPE (primarg1
)), primarg1
);
3342 if (operand_equal_p (arg0
, fold_convert (type
, primarg1
), 0))
3349 /* See if ARG is an expression that is either a comparison or is performing
3350 arithmetic on comparisons. The comparisons must only be comparing
3351 two different values, which will be stored in *CVAL1 and *CVAL2; if
3352 they are nonzero it means that some operands have already been found.
3353 No variables may be used anywhere else in the expression except in the
3354 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3355 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3357 If this is true, return 1. Otherwise, return zero. */
3360 twoval_comparison_p (tree arg
, tree
*cval1
, tree
*cval2
, int *save_p
)
3362 enum tree_code code
= TREE_CODE (arg
);
3363 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3365 /* We can handle some of the tcc_expression cases here. */
3366 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3368 else if (tclass
== tcc_expression
3369 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
3370 || code
== COMPOUND_EXPR
))
3371 tclass
= tcc_binary
;
3373 else if (tclass
== tcc_expression
&& code
== SAVE_EXPR
3374 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
3376 /* If we've already found a CVAL1 or CVAL2, this expression is
3377 two complex to handle. */
3378 if (*cval1
|| *cval2
)
3388 return twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
);
3391 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
)
3392 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
3393 cval1
, cval2
, save_p
));
3398 case tcc_expression
:
3399 if (code
== COND_EXPR
)
3400 return (twoval_comparison_p (TREE_OPERAND (arg
, 0),
3401 cval1
, cval2
, save_p
)
3402 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
3403 cval1
, cval2
, save_p
)
3404 && twoval_comparison_p (TREE_OPERAND (arg
, 2),
3405 cval1
, cval2
, save_p
));
3408 case tcc_comparison
:
3409 /* First see if we can handle the first operand, then the second. For
3410 the second operand, we know *CVAL1 can't be zero. It must be that
3411 one side of the comparison is each of the values; test for the
3412 case where this isn't true by failing if the two operands
3415 if (operand_equal_p (TREE_OPERAND (arg
, 0),
3416 TREE_OPERAND (arg
, 1), 0))
3420 *cval1
= TREE_OPERAND (arg
, 0);
3421 else if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 0), 0))
3423 else if (*cval2
== 0)
3424 *cval2
= TREE_OPERAND (arg
, 0);
3425 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 0), 0))
3430 if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 1), 0))
3432 else if (*cval2
== 0)
3433 *cval2
= TREE_OPERAND (arg
, 1);
3434 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 1), 0))
3446 /* ARG is a tree that is known to contain just arithmetic operations and
3447 comparisons. Evaluate the operations in the tree substituting NEW0 for
3448 any occurrence of OLD0 as an operand of a comparison and likewise for
3452 eval_subst (location_t loc
, tree arg
, tree old0
, tree new0
,
3453 tree old1
, tree new1
)
3455 tree type
= TREE_TYPE (arg
);
3456 enum tree_code code
= TREE_CODE (arg
);
3457 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3459 /* We can handle some of the tcc_expression cases here. */
3460 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3462 else if (tclass
== tcc_expression
3463 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
3464 tclass
= tcc_binary
;
3469 return fold_build1_loc (loc
, code
, type
,
3470 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3471 old0
, new0
, old1
, new1
));
3474 return fold_build2_loc (loc
, code
, type
,
3475 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3476 old0
, new0
, old1
, new1
),
3477 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3478 old0
, new0
, old1
, new1
));
3480 case tcc_expression
:
3484 return eval_subst (loc
, TREE_OPERAND (arg
, 0), old0
, new0
,
3488 return eval_subst (loc
, TREE_OPERAND (arg
, 1), old0
, new0
,
3492 return fold_build3_loc (loc
, code
, type
,
3493 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3494 old0
, new0
, old1
, new1
),
3495 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3496 old0
, new0
, old1
, new1
),
3497 eval_subst (loc
, TREE_OPERAND (arg
, 2),
3498 old0
, new0
, old1
, new1
));
3502 /* Fall through - ??? */
3504 case tcc_comparison
:
3506 tree arg0
= TREE_OPERAND (arg
, 0);
3507 tree arg1
= TREE_OPERAND (arg
, 1);
3509 /* We need to check both for exact equality and tree equality. The
3510 former will be true if the operand has a side-effect. In that
3511 case, we know the operand occurred exactly once. */
3513 if (arg0
== old0
|| operand_equal_p (arg0
, old0
, 0))
3515 else if (arg0
== old1
|| operand_equal_p (arg0
, old1
, 0))
3518 if (arg1
== old0
|| operand_equal_p (arg1
, old0
, 0))
3520 else if (arg1
== old1
|| operand_equal_p (arg1
, old1
, 0))
3523 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
3531 /* Return a tree for the case when the result of an expression is RESULT
3532 converted to TYPE and OMITTED was previously an operand of the expression
3533 but is now not needed (e.g., we folded OMITTED * 0).
3535 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3536 the conversion of RESULT to TYPE. */
3539 omit_one_operand_loc (location_t loc
, tree type
, tree result
, tree omitted
)
3541 tree t
= fold_convert_loc (loc
, type
, result
);
3543 /* If the resulting operand is an empty statement, just return the omitted
3544 statement casted to void. */
3545 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
3546 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
3547 fold_ignored_result (omitted
));
3549 if (TREE_SIDE_EFFECTS (omitted
))
3550 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3551 fold_ignored_result (omitted
), t
);
3553 return non_lvalue_loc (loc
, t
);
3556 /* Return a tree for the case when the result of an expression is RESULT
3557 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3558 of the expression but are now not needed.
3560 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3561 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3562 evaluated before OMITTED2. Otherwise, if neither has side effects,
3563 just do the conversion of RESULT to TYPE. */
3566 omit_two_operands_loc (location_t loc
, tree type
, tree result
,
3567 tree omitted1
, tree omitted2
)
3569 tree t
= fold_convert_loc (loc
, type
, result
);
3571 if (TREE_SIDE_EFFECTS (omitted2
))
3572 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted2
, t
);
3573 if (TREE_SIDE_EFFECTS (omitted1
))
3574 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted1
, t
);
3576 return TREE_CODE (t
) != COMPOUND_EXPR
? non_lvalue_loc (loc
, t
) : t
;
3580 /* Return a simplified tree node for the truth-negation of ARG. This
3581 never alters ARG itself. We assume that ARG is an operation that
3582 returns a truth value (0 or 1).
3584 FIXME: one would think we would fold the result, but it causes
3585 problems with the dominator optimizer. */
3588 fold_truth_not_expr (location_t loc
, tree arg
)
3590 tree type
= TREE_TYPE (arg
);
3591 enum tree_code code
= TREE_CODE (arg
);
3592 location_t loc1
, loc2
;
3594 /* If this is a comparison, we can simply invert it, except for
3595 floating-point non-equality comparisons, in which case we just
3596 enclose a TRUTH_NOT_EXPR around what we have. */
3598 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3600 tree op_type
= TREE_TYPE (TREE_OPERAND (arg
, 0));
3601 if (FLOAT_TYPE_P (op_type
)
3602 && flag_trapping_math
3603 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
3604 && code
!= NE_EXPR
&& code
!= EQ_EXPR
)
3607 code
= invert_tree_comparison (code
, HONOR_NANS (op_type
));
3608 if (code
== ERROR_MARK
)
3611 tree ret
= build2_loc (loc
, code
, type
, TREE_OPERAND (arg
, 0),
3612 TREE_OPERAND (arg
, 1));
3613 if (TREE_NO_WARNING (arg
))
3614 TREE_NO_WARNING (ret
) = 1;
3621 return constant_boolean_node (integer_zerop (arg
), type
);
3623 case TRUTH_AND_EXPR
:
3624 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3625 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3626 return build2_loc (loc
, TRUTH_OR_EXPR
, type
,
3627 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3628 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3631 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3632 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3633 return build2_loc (loc
, TRUTH_AND_EXPR
, type
,
3634 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3635 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3637 case TRUTH_XOR_EXPR
:
3638 /* Here we can invert either operand. We invert the first operand
3639 unless the second operand is a TRUTH_NOT_EXPR in which case our
3640 result is the XOR of the first operand with the inside of the
3641 negation of the second operand. */
3643 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == TRUTH_NOT_EXPR
)
3644 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
, TREE_OPERAND (arg
, 0),
3645 TREE_OPERAND (TREE_OPERAND (arg
, 1), 0));
3647 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
,
3648 invert_truthvalue_loc (loc
, TREE_OPERAND (arg
, 0)),
3649 TREE_OPERAND (arg
, 1));
3651 case TRUTH_ANDIF_EXPR
:
3652 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3653 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3654 return build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
3655 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3656 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3658 case TRUTH_ORIF_EXPR
:
3659 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3660 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3661 return build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
3662 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3663 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3665 case TRUTH_NOT_EXPR
:
3666 return TREE_OPERAND (arg
, 0);
3670 tree arg1
= TREE_OPERAND (arg
, 1);
3671 tree arg2
= TREE_OPERAND (arg
, 2);
3673 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3674 loc2
= expr_location_or (TREE_OPERAND (arg
, 2), loc
);
3676 /* A COND_EXPR may have a throw as one operand, which
3677 then has void type. Just leave void operands
3679 return build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
3680 VOID_TYPE_P (TREE_TYPE (arg1
))
3681 ? arg1
: invert_truthvalue_loc (loc1
, arg1
),
3682 VOID_TYPE_P (TREE_TYPE (arg2
))
3683 ? arg2
: invert_truthvalue_loc (loc2
, arg2
));
3687 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3688 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3689 TREE_OPERAND (arg
, 0),
3690 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 1)));
3692 case NON_LVALUE_EXPR
:
3693 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3694 return invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0));
3697 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
3698 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3703 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3704 return build1_loc (loc
, TREE_CODE (arg
), type
,
3705 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3708 if (!integer_onep (TREE_OPERAND (arg
, 1)))
3710 return build2_loc (loc
, EQ_EXPR
, type
, arg
, build_int_cst (type
, 0));
3713 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3715 case CLEANUP_POINT_EXPR
:
3716 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3717 return build1_loc (loc
, CLEANUP_POINT_EXPR
, type
,
3718 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3725 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3726 assume that ARG is an operation that returns a truth value (0 or 1
3727 for scalars, 0 or -1 for vectors). Return the folded expression if
3728 folding is successful. Otherwise, return NULL_TREE. */
3731 fold_invert_truthvalue (location_t loc
, tree arg
)
3733 tree type
= TREE_TYPE (arg
);
3734 return fold_unary_loc (loc
, VECTOR_TYPE_P (type
)
3740 /* Return a simplified tree node for the truth-negation of ARG. This
3741 never alters ARG itself. We assume that ARG is an operation that
3742 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3745 invert_truthvalue_loc (location_t loc
, tree arg
)
3747 if (TREE_CODE (arg
) == ERROR_MARK
)
3750 tree type
= TREE_TYPE (arg
);
3751 return fold_build1_loc (loc
, VECTOR_TYPE_P (type
)
3757 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3758 with code CODE. This optimization is unsafe. */
3760 distribute_real_division (location_t loc
, enum tree_code code
, tree type
,
3761 tree arg0
, tree arg1
)
3763 bool mul0
= TREE_CODE (arg0
) == MULT_EXPR
;
3764 bool mul1
= TREE_CODE (arg1
) == MULT_EXPR
;
3766 /* (A / C) +- (B / C) -> (A +- B) / C. */
3768 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3769 TREE_OPERAND (arg1
, 1), 0))
3770 return fold_build2_loc (loc
, mul0
? MULT_EXPR
: RDIV_EXPR
, type
,
3771 fold_build2_loc (loc
, code
, type
,
3772 TREE_OPERAND (arg0
, 0),
3773 TREE_OPERAND (arg1
, 0)),
3774 TREE_OPERAND (arg0
, 1));
3776 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3777 if (operand_equal_p (TREE_OPERAND (arg0
, 0),
3778 TREE_OPERAND (arg1
, 0), 0)
3779 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
3780 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
3782 REAL_VALUE_TYPE r0
, r1
;
3783 r0
= TREE_REAL_CST (TREE_OPERAND (arg0
, 1));
3784 r1
= TREE_REAL_CST (TREE_OPERAND (arg1
, 1));
3786 real_arithmetic (&r0
, RDIV_EXPR
, &dconst1
, &r0
);
3788 real_arithmetic (&r1
, RDIV_EXPR
, &dconst1
, &r1
);
3789 real_arithmetic (&r0
, code
, &r0
, &r1
);
3790 return fold_build2_loc (loc
, MULT_EXPR
, type
,
3791 TREE_OPERAND (arg0
, 0),
3792 build_real (type
, r0
));
3798 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3799 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3800 and uses reverse storage order if REVERSEP is nonzero. ORIG_INNER
3801 is the original memory reference used to preserve the alias set of
3805 make_bit_field_ref (location_t loc
, tree inner
, tree orig_inner
, tree type
,
3806 HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
3807 int unsignedp
, int reversep
)
3809 tree result
, bftype
;
3811 if (get_alias_set (inner
) != get_alias_set (orig_inner
))
3812 inner
= fold_build2 (MEM_REF
, TREE_TYPE (inner
),
3813 build_fold_addr_expr (inner
),
3815 (reference_alias_ptr_type (orig_inner
), 0));
3817 if (bitpos
== 0 && !reversep
)
3819 tree size
= TYPE_SIZE (TREE_TYPE (inner
));
3820 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner
))
3821 || POINTER_TYPE_P (TREE_TYPE (inner
)))
3822 && tree_fits_shwi_p (size
)
3823 && tree_to_shwi (size
) == bitsize
)
3824 return fold_convert_loc (loc
, type
, inner
);
3828 if (TYPE_PRECISION (bftype
) != bitsize
3829 || TYPE_UNSIGNED (bftype
) == !unsignedp
)
3830 bftype
= build_nonstandard_integer_type (bitsize
, 0);
3832 result
= build3_loc (loc
, BIT_FIELD_REF
, bftype
, inner
,
3833 size_int (bitsize
), bitsize_int (bitpos
));
3834 REF_REVERSE_STORAGE_ORDER (result
) = reversep
;
3837 result
= fold_convert_loc (loc
, type
, result
);
3842 /* Optimize a bit-field compare.
3844 There are two cases: First is a compare against a constant and the
3845 second is a comparison of two items where the fields are at the same
3846 bit position relative to the start of a chunk (byte, halfword, word)
3847 large enough to contain it. In these cases we can avoid the shift
3848 implicit in bitfield extractions.
3850 For constants, we emit a compare of the shifted constant with the
3851 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3852 compared. For two fields at the same position, we do the ANDs with the
3853 similar mask and compare the result of the ANDs.
3855 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3856 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3857 are the left and right operands of the comparison, respectively.
3859 If the optimization described above can be done, we return the resulting
3860 tree. Otherwise we return zero. */
3863 optimize_bit_field_compare (location_t loc
, enum tree_code code
,
3864 tree compare_type
, tree lhs
, tree rhs
)
3866 HOST_WIDE_INT lbitpos
, lbitsize
, rbitpos
, rbitsize
, nbitpos
, nbitsize
;
3867 tree type
= TREE_TYPE (lhs
);
3869 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
3870 machine_mode lmode
, rmode
, nmode
;
3871 int lunsignedp
, runsignedp
;
3872 int lreversep
, rreversep
;
3873 int lvolatilep
= 0, rvolatilep
= 0;
3874 tree linner
, rinner
= NULL_TREE
;
3878 /* Get all the information about the extractions being done. If the bit size
3879 if the same as the size of the underlying object, we aren't doing an
3880 extraction at all and so can do nothing. We also don't want to
3881 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3882 then will no longer be able to replace it. */
3883 linner
= get_inner_reference (lhs
, &lbitsize
, &lbitpos
, &offset
, &lmode
,
3884 &lunsignedp
, &lreversep
, &lvolatilep
);
3885 if (linner
== lhs
|| lbitsize
== GET_MODE_BITSIZE (lmode
) || lbitsize
< 0
3886 || offset
!= 0 || TREE_CODE (linner
) == PLACEHOLDER_EXPR
|| lvolatilep
)
3890 rreversep
= lreversep
;
3893 /* If this is not a constant, we can only do something if bit positions,
3894 sizes, signedness and storage order are the same. */
3896 = get_inner_reference (rhs
, &rbitsize
, &rbitpos
, &offset
, &rmode
,
3897 &runsignedp
, &rreversep
, &rvolatilep
);
3899 if (rinner
== rhs
|| lbitpos
!= rbitpos
|| lbitsize
!= rbitsize
3900 || lunsignedp
!= runsignedp
|| lreversep
!= rreversep
|| offset
!= 0
3901 || TREE_CODE (rinner
) == PLACEHOLDER_EXPR
|| rvolatilep
)
3905 /* Honor the C++ memory model and mimic what RTL expansion does. */
3906 unsigned HOST_WIDE_INT bitstart
= 0;
3907 unsigned HOST_WIDE_INT bitend
= 0;
3908 if (TREE_CODE (lhs
) == COMPONENT_REF
)
3910 get_bit_range (&bitstart
, &bitend
, lhs
, &lbitpos
, &offset
);
3911 if (offset
!= NULL_TREE
)
3915 /* See if we can find a mode to refer to this field. We should be able to,
3916 but fail if we can't. */
3917 nmode
= get_best_mode (lbitsize
, lbitpos
, bitstart
, bitend
,
3918 const_p
? TYPE_ALIGN (TREE_TYPE (linner
))
3919 : MIN (TYPE_ALIGN (TREE_TYPE (linner
)),
3920 TYPE_ALIGN (TREE_TYPE (rinner
))),
3922 if (nmode
== VOIDmode
)
3925 /* Set signed and unsigned types of the precision of this mode for the
3927 unsigned_type
= lang_hooks
.types
.type_for_mode (nmode
, 1);
3929 /* Compute the bit position and size for the new reference and our offset
3930 within it. If the new reference is the same size as the original, we
3931 won't optimize anything, so return zero. */
3932 nbitsize
= GET_MODE_BITSIZE (nmode
);
3933 nbitpos
= lbitpos
& ~ (nbitsize
- 1);
3935 if (nbitsize
== lbitsize
)
3938 if (lreversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
3939 lbitpos
= nbitsize
- lbitsize
- lbitpos
;
3941 /* Make the mask to be used against the extracted field. */
3942 mask
= build_int_cst_type (unsigned_type
, -1);
3943 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (nbitsize
- lbitsize
));
3944 mask
= const_binop (RSHIFT_EXPR
, mask
,
3945 size_int (nbitsize
- lbitsize
- lbitpos
));
3948 /* If not comparing with constant, just rework the comparison
3950 return fold_build2_loc (loc
, code
, compare_type
,
3951 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3952 make_bit_field_ref (loc
, linner
, lhs
,
3957 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3958 make_bit_field_ref (loc
, rinner
, rhs
,
3964 /* Otherwise, we are handling the constant case. See if the constant is too
3965 big for the field. Warn and return a tree for 0 (false) if so. We do
3966 this not only for its own sake, but to avoid having to test for this
3967 error case below. If we didn't, we might generate wrong code.
3969 For unsigned fields, the constant shifted right by the field length should
3970 be all zero. For signed fields, the high-order bits should agree with
3975 if (wi::lrshift (rhs
, lbitsize
) != 0)
3977 warning (0, "comparison is always %d due to width of bit-field",
3979 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3984 wide_int tem
= wi::arshift (rhs
, lbitsize
- 1);
3985 if (tem
!= 0 && tem
!= -1)
3987 warning (0, "comparison is always %d due to width of bit-field",
3989 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3993 /* Single-bit compares should always be against zero. */
3994 if (lbitsize
== 1 && ! integer_zerop (rhs
))
3996 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
3997 rhs
= build_int_cst (type
, 0);
4000 /* Make a new bitfield reference, shift the constant over the
4001 appropriate number of bits and mask it with the computed mask
4002 (in case this was a signed field). If we changed it, make a new one. */
4003 lhs
= make_bit_field_ref (loc
, linner
, lhs
, unsigned_type
,
4004 nbitsize
, nbitpos
, 1, lreversep
);
4006 rhs
= const_binop (BIT_AND_EXPR
,
4007 const_binop (LSHIFT_EXPR
,
4008 fold_convert_loc (loc
, unsigned_type
, rhs
),
4009 size_int (lbitpos
)),
4012 lhs
= build2_loc (loc
, code
, compare_type
,
4013 build2 (BIT_AND_EXPR
, unsigned_type
, lhs
, mask
), rhs
);
4017 /* Subroutine for fold_truth_andor_1: decode a field reference.
4019 If EXP is a comparison reference, we return the innermost reference.
4021 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4022 set to the starting bit number.
4024 If the innermost field can be completely contained in a mode-sized
4025 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4027 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4028 otherwise it is not changed.
4030 *PUNSIGNEDP is set to the signedness of the field.
4032 *PREVERSEP is set to the storage order of the field.
4034 *PMASK is set to the mask used. This is either contained in a
4035 BIT_AND_EXPR or derived from the width of the field.
4037 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4039 Return 0 if this is not a component reference or is one that we can't
4040 do anything with. */
4043 decode_field_reference (location_t loc
, tree
*exp_
, HOST_WIDE_INT
*pbitsize
,
4044 HOST_WIDE_INT
*pbitpos
, machine_mode
*pmode
,
4045 int *punsignedp
, int *preversep
, int *pvolatilep
,
4046 tree
*pmask
, tree
*pand_mask
)
4049 tree outer_type
= 0;
4051 tree mask
, inner
, offset
;
4053 unsigned int precision
;
4055 /* All the optimizations using this function assume integer fields.
4056 There are problems with FP fields since the type_for_size call
4057 below can fail for, e.g., XFmode. */
4058 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp
)))
4061 /* We are interested in the bare arrangement of bits, so strip everything
4062 that doesn't affect the machine mode. However, record the type of the
4063 outermost expression if it may matter below. */
4064 if (CONVERT_EXPR_P (exp
)
4065 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4066 outer_type
= TREE_TYPE (exp
);
4069 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
4071 and_mask
= TREE_OPERAND (exp
, 1);
4072 exp
= TREE_OPERAND (exp
, 0);
4073 STRIP_NOPS (exp
); STRIP_NOPS (and_mask
);
4074 if (TREE_CODE (and_mask
) != INTEGER_CST
)
4078 inner
= get_inner_reference (exp
, pbitsize
, pbitpos
, &offset
, pmode
,
4079 punsignedp
, preversep
, pvolatilep
);
4080 if ((inner
== exp
&& and_mask
== 0)
4081 || *pbitsize
< 0 || offset
!= 0
4082 || TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
4087 /* If the number of bits in the reference is the same as the bitsize of
4088 the outer type, then the outer type gives the signedness. Otherwise
4089 (in case of a small bitfield) the signedness is unchanged. */
4090 if (outer_type
&& *pbitsize
== TYPE_PRECISION (outer_type
))
4091 *punsignedp
= TYPE_UNSIGNED (outer_type
);
4093 /* Compute the mask to access the bitfield. */
4094 unsigned_type
= lang_hooks
.types
.type_for_size (*pbitsize
, 1);
4095 precision
= TYPE_PRECISION (unsigned_type
);
4097 mask
= build_int_cst_type (unsigned_type
, -1);
4099 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4100 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4102 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4104 mask
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
4105 fold_convert_loc (loc
, unsigned_type
, and_mask
), mask
);
4108 *pand_mask
= and_mask
;
4112 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4113 bit positions and MASK is SIGNED. */
4116 all_ones_mask_p (const_tree mask
, unsigned int size
)
4118 tree type
= TREE_TYPE (mask
);
4119 unsigned int precision
= TYPE_PRECISION (type
);
4121 /* If this function returns true when the type of the mask is
4122 UNSIGNED, then there will be errors. In particular see
4123 gcc.c-torture/execute/990326-1.c. There does not appear to be
4124 any documentation paper trail as to why this is so. But the pre
4125 wide-int worked with that restriction and it has been preserved
4127 if (size
> precision
|| TYPE_SIGN (type
) == UNSIGNED
)
4130 return wi::mask (size
, false, precision
) == mask
;
4133 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4134 represents the sign bit of EXP's type. If EXP represents a sign
4135 or zero extension, also test VAL against the unextended type.
4136 The return value is the (sub)expression whose sign bit is VAL,
4137 or NULL_TREE otherwise. */
4140 sign_bit_p (tree exp
, const_tree val
)
4145 /* Tree EXP must have an integral type. */
4146 t
= TREE_TYPE (exp
);
4147 if (! INTEGRAL_TYPE_P (t
))
4150 /* Tree VAL must be an integer constant. */
4151 if (TREE_CODE (val
) != INTEGER_CST
4152 || TREE_OVERFLOW (val
))
4155 width
= TYPE_PRECISION (t
);
4156 if (wi::only_sign_bit_p (val
, width
))
4159 /* Handle extension from a narrower type. */
4160 if (TREE_CODE (exp
) == NOP_EXPR
4161 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))) < width
)
4162 return sign_bit_p (TREE_OPERAND (exp
, 0), val
);
4167 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4168 to be evaluated unconditionally. */
4171 simple_operand_p (const_tree exp
)
4173 /* Strip any conversions that don't change the machine mode. */
4176 return (CONSTANT_CLASS_P (exp
)
4177 || TREE_CODE (exp
) == SSA_NAME
4179 && ! TREE_ADDRESSABLE (exp
)
4180 && ! TREE_THIS_VOLATILE (exp
)
4181 && ! DECL_NONLOCAL (exp
)
4182 /* Don't regard global variables as simple. They may be
4183 allocated in ways unknown to the compiler (shared memory,
4184 #pragma weak, etc). */
4185 && ! TREE_PUBLIC (exp
)
4186 && ! DECL_EXTERNAL (exp
)
4187 /* Weakrefs are not safe to be read, since they can be NULL.
4188 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4189 have DECL_WEAK flag set. */
4190 && (! VAR_OR_FUNCTION_DECL_P (exp
) || ! DECL_WEAK (exp
))
4191 /* Loading a static variable is unduly expensive, but global
4192 registers aren't expensive. */
4193 && (! TREE_STATIC (exp
) || DECL_REGISTER (exp
))));
4196 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4197 to be evaluated unconditionally.
4198 I addition to simple_operand_p, we assume that comparisons, conversions,
4199 and logic-not operations are simple, if their operands are simple, too. */
4202 simple_operand_p_2 (tree exp
)
4204 enum tree_code code
;
4206 if (TREE_SIDE_EFFECTS (exp
)
4207 || tree_could_trap_p (exp
))
4210 while (CONVERT_EXPR_P (exp
))
4211 exp
= TREE_OPERAND (exp
, 0);
4213 code
= TREE_CODE (exp
);
4215 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
4216 return (simple_operand_p (TREE_OPERAND (exp
, 0))
4217 && simple_operand_p (TREE_OPERAND (exp
, 1)));
4219 if (code
== TRUTH_NOT_EXPR
)
4220 return simple_operand_p_2 (TREE_OPERAND (exp
, 0));
4222 return simple_operand_p (exp
);
4226 /* The following functions are subroutines to fold_range_test and allow it to
4227 try to change a logical combination of comparisons into a range test.
4230 X == 2 || X == 3 || X == 4 || X == 5
4234 (unsigned) (X - 2) <= 3
4236 We describe each set of comparisons as being either inside or outside
4237 a range, using a variable named like IN_P, and then describe the
4238 range with a lower and upper bound. If one of the bounds is omitted,
4239 it represents either the highest or lowest value of the type.
4241 In the comments below, we represent a range by two numbers in brackets
4242 preceded by a "+" to designate being inside that range, or a "-" to
4243 designate being outside that range, so the condition can be inverted by
4244 flipping the prefix. An omitted bound is represented by a "-". For
4245 example, "- [-, 10]" means being outside the range starting at the lowest
4246 possible value and ending at 10, in other words, being greater than 10.
4247 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4250 We set up things so that the missing bounds are handled in a consistent
4251 manner so neither a missing bound nor "true" and "false" need to be
4252 handled using a special case. */
4254 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4255 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4256 and UPPER1_P are nonzero if the respective argument is an upper bound
4257 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4258 must be specified for a comparison. ARG1 will be converted to ARG0's
4259 type if both are specified. */
4262 range_binop (enum tree_code code
, tree type
, tree arg0
, int upper0_p
,
4263 tree arg1
, int upper1_p
)
4269 /* If neither arg represents infinity, do the normal operation.
4270 Else, if not a comparison, return infinity. Else handle the special
4271 comparison rules. Note that most of the cases below won't occur, but
4272 are handled for consistency. */
4274 if (arg0
!= 0 && arg1
!= 0)
4276 tem
= fold_build2 (code
, type
!= 0 ? type
: TREE_TYPE (arg0
),
4277 arg0
, fold_convert (TREE_TYPE (arg0
), arg1
));
4279 return TREE_CODE (tem
) == INTEGER_CST
? tem
: 0;
4282 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
4285 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4286 for neither. In real maths, we cannot assume open ended ranges are
4287 the same. But, this is computer arithmetic, where numbers are finite.
4288 We can therefore make the transformation of any unbounded range with
4289 the value Z, Z being greater than any representable number. This permits
4290 us to treat unbounded ranges as equal. */
4291 sgn0
= arg0
!= 0 ? 0 : (upper0_p
? 1 : -1);
4292 sgn1
= arg1
!= 0 ? 0 : (upper1_p
? 1 : -1);
4296 result
= sgn0
== sgn1
;
4299 result
= sgn0
!= sgn1
;
4302 result
= sgn0
< sgn1
;
4305 result
= sgn0
<= sgn1
;
4308 result
= sgn0
> sgn1
;
4311 result
= sgn0
>= sgn1
;
4317 return constant_boolean_node (result
, type
);
4320 /* Helper routine for make_range. Perform one step for it, return
4321 new expression if the loop should continue or NULL_TREE if it should
4325 make_range_step (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
,
4326 tree exp_type
, tree
*p_low
, tree
*p_high
, int *p_in_p
,
4327 bool *strict_overflow_p
)
4329 tree arg0_type
= TREE_TYPE (arg0
);
4330 tree n_low
, n_high
, low
= *p_low
, high
= *p_high
;
4331 int in_p
= *p_in_p
, n_in_p
;
4335 case TRUTH_NOT_EXPR
:
4336 /* We can only do something if the range is testing for zero. */
4337 if (low
== NULL_TREE
|| high
== NULL_TREE
4338 || ! integer_zerop (low
) || ! integer_zerop (high
))
4343 case EQ_EXPR
: case NE_EXPR
:
4344 case LT_EXPR
: case LE_EXPR
: case GE_EXPR
: case GT_EXPR
:
4345 /* We can only do something if the range is testing for zero
4346 and if the second operand is an integer constant. Note that
4347 saying something is "in" the range we make is done by
4348 complementing IN_P since it will set in the initial case of
4349 being not equal to zero; "out" is leaving it alone. */
4350 if (low
== NULL_TREE
|| high
== NULL_TREE
4351 || ! integer_zerop (low
) || ! integer_zerop (high
)
4352 || TREE_CODE (arg1
) != INTEGER_CST
)
4357 case NE_EXPR
: /* - [c, c] */
4360 case EQ_EXPR
: /* + [c, c] */
4361 in_p
= ! in_p
, low
= high
= arg1
;
4363 case GT_EXPR
: /* - [-, c] */
4364 low
= 0, high
= arg1
;
4366 case GE_EXPR
: /* + [c, -] */
4367 in_p
= ! in_p
, low
= arg1
, high
= 0;
4369 case LT_EXPR
: /* - [c, -] */
4370 low
= arg1
, high
= 0;
4372 case LE_EXPR
: /* + [-, c] */
4373 in_p
= ! in_p
, low
= 0, high
= arg1
;
4379 /* If this is an unsigned comparison, we also know that EXP is
4380 greater than or equal to zero. We base the range tests we make
4381 on that fact, so we record it here so we can parse existing
4382 range tests. We test arg0_type since often the return type
4383 of, e.g. EQ_EXPR, is boolean. */
4384 if (TYPE_UNSIGNED (arg0_type
) && (low
== 0 || high
== 0))
4386 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
4388 build_int_cst (arg0_type
, 0),
4392 in_p
= n_in_p
, low
= n_low
, high
= n_high
;
4394 /* If the high bound is missing, but we have a nonzero low
4395 bound, reverse the range so it goes from zero to the low bound
4397 if (high
== 0 && low
&& ! integer_zerop (low
))
4400 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low
, 0,
4401 build_int_cst (TREE_TYPE (low
), 1), 0);
4402 low
= build_int_cst (arg0_type
, 0);
4412 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4413 low and high are non-NULL, then normalize will DTRT. */
4414 if (!TYPE_UNSIGNED (arg0_type
)
4415 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4417 if (low
== NULL_TREE
)
4418 low
= TYPE_MIN_VALUE (arg0_type
);
4419 if (high
== NULL_TREE
)
4420 high
= TYPE_MAX_VALUE (arg0_type
);
4423 /* (-x) IN [a,b] -> x in [-b, -a] */
4424 n_low
= range_binop (MINUS_EXPR
, exp_type
,
4425 build_int_cst (exp_type
, 0),
4427 n_high
= range_binop (MINUS_EXPR
, exp_type
,
4428 build_int_cst (exp_type
, 0),
4430 if (n_high
!= 0 && TREE_OVERFLOW (n_high
))
4436 return build2_loc (loc
, MINUS_EXPR
, exp_type
, negate_expr (arg0
),
4437 build_int_cst (exp_type
, 1));
4441 if (TREE_CODE (arg1
) != INTEGER_CST
)
4444 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4445 move a constant to the other side. */
4446 if (!TYPE_UNSIGNED (arg0_type
)
4447 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4450 /* If EXP is signed, any overflow in the computation is undefined,
4451 so we don't worry about it so long as our computations on
4452 the bounds don't overflow. For unsigned, overflow is defined
4453 and this is exactly the right thing. */
4454 n_low
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4455 arg0_type
, low
, 0, arg1
, 0);
4456 n_high
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4457 arg0_type
, high
, 1, arg1
, 0);
4458 if ((n_low
!= 0 && TREE_OVERFLOW (n_low
))
4459 || (n_high
!= 0 && TREE_OVERFLOW (n_high
)))
4462 if (TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4463 *strict_overflow_p
= true;
4466 /* Check for an unsigned range which has wrapped around the maximum
4467 value thus making n_high < n_low, and normalize it. */
4468 if (n_low
&& n_high
&& tree_int_cst_lt (n_high
, n_low
))
4470 low
= range_binop (PLUS_EXPR
, arg0_type
, n_high
, 0,
4471 build_int_cst (TREE_TYPE (n_high
), 1), 0);
4472 high
= range_binop (MINUS_EXPR
, arg0_type
, n_low
, 0,
4473 build_int_cst (TREE_TYPE (n_low
), 1), 0);
4475 /* If the range is of the form +/- [ x+1, x ], we won't
4476 be able to normalize it. But then, it represents the
4477 whole range or the empty set, so make it
4479 if (tree_int_cst_equal (n_low
, low
)
4480 && tree_int_cst_equal (n_high
, high
))
4486 low
= n_low
, high
= n_high
;
4494 case NON_LVALUE_EXPR
:
4495 if (TYPE_PRECISION (arg0_type
) > TYPE_PRECISION (exp_type
))
4498 if (! INTEGRAL_TYPE_P (arg0_type
)
4499 || (low
!= 0 && ! int_fits_type_p (low
, arg0_type
))
4500 || (high
!= 0 && ! int_fits_type_p (high
, arg0_type
)))
4503 n_low
= low
, n_high
= high
;
4506 n_low
= fold_convert_loc (loc
, arg0_type
, n_low
);
4509 n_high
= fold_convert_loc (loc
, arg0_type
, n_high
);
4511 /* If we're converting arg0 from an unsigned type, to exp,
4512 a signed type, we will be doing the comparison as unsigned.
4513 The tests above have already verified that LOW and HIGH
4516 So we have to ensure that we will handle large unsigned
4517 values the same way that the current signed bounds treat
4520 if (!TYPE_UNSIGNED (exp_type
) && TYPE_UNSIGNED (arg0_type
))
4524 /* For fixed-point modes, we need to pass the saturating flag
4525 as the 2nd parameter. */
4526 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type
)))
4528 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
),
4529 TYPE_SATURATING (arg0_type
));
4532 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
), 1);
4534 /* A range without an upper bound is, naturally, unbounded.
4535 Since convert would have cropped a very large value, use
4536 the max value for the destination type. */
4538 = TYPE_MAX_VALUE (equiv_type
) ? TYPE_MAX_VALUE (equiv_type
)
4539 : TYPE_MAX_VALUE (arg0_type
);
4541 if (TYPE_PRECISION (exp_type
) == TYPE_PRECISION (arg0_type
))
4542 high_positive
= fold_build2_loc (loc
, RSHIFT_EXPR
, arg0_type
,
4543 fold_convert_loc (loc
, arg0_type
,
4545 build_int_cst (arg0_type
, 1));
4547 /* If the low bound is specified, "and" the range with the
4548 range for which the original unsigned value will be
4552 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 1, n_low
, n_high
,
4553 1, fold_convert_loc (loc
, arg0_type
,
4558 in_p
= (n_in_p
== in_p
);
4562 /* Otherwise, "or" the range with the range of the input
4563 that will be interpreted as negative. */
4564 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 0, n_low
, n_high
,
4565 1, fold_convert_loc (loc
, arg0_type
,
4570 in_p
= (in_p
!= n_in_p
);
4584 /* Given EXP, a logical expression, set the range it is testing into
4585 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4586 actually being tested. *PLOW and *PHIGH will be made of the same
4587 type as the returned expression. If EXP is not a comparison, we
4588 will most likely not be returning a useful value and range. Set
4589 *STRICT_OVERFLOW_P to true if the return value is only valid
4590 because signed overflow is undefined; otherwise, do not change
4591 *STRICT_OVERFLOW_P. */
4594 make_range (tree exp
, int *pin_p
, tree
*plow
, tree
*phigh
,
4595 bool *strict_overflow_p
)
4597 enum tree_code code
;
4598 tree arg0
, arg1
= NULL_TREE
;
4599 tree exp_type
, nexp
;
4602 location_t loc
= EXPR_LOCATION (exp
);
4604 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4605 and see if we can refine the range. Some of the cases below may not
4606 happen, but it doesn't seem worth worrying about this. We "continue"
4607 the outer loop when we've changed something; otherwise we "break"
4608 the switch, which will "break" the while. */
4611 low
= high
= build_int_cst (TREE_TYPE (exp
), 0);
4615 code
= TREE_CODE (exp
);
4616 exp_type
= TREE_TYPE (exp
);
4619 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
4621 if (TREE_OPERAND_LENGTH (exp
) > 0)
4622 arg0
= TREE_OPERAND (exp
, 0);
4623 if (TREE_CODE_CLASS (code
) == tcc_binary
4624 || TREE_CODE_CLASS (code
) == tcc_comparison
4625 || (TREE_CODE_CLASS (code
) == tcc_expression
4626 && TREE_OPERAND_LENGTH (exp
) > 1))
4627 arg1
= TREE_OPERAND (exp
, 1);
4629 if (arg0
== NULL_TREE
)
4632 nexp
= make_range_step (loc
, code
, arg0
, arg1
, exp_type
, &low
,
4633 &high
, &in_p
, strict_overflow_p
);
4634 if (nexp
== NULL_TREE
)
4639 /* If EXP is a constant, we can evaluate whether this is true or false. */
4640 if (TREE_CODE (exp
) == INTEGER_CST
)
4642 in_p
= in_p
== (integer_onep (range_binop (GE_EXPR
, integer_type_node
,
4644 && integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4650 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4654 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4655 type, TYPE, return an expression to test if EXP is in (or out of, depending
4656 on IN_P) the range. Return 0 if the test couldn't be created. */
4659 build_range_check (location_t loc
, tree type
, tree exp
, int in_p
,
4660 tree low
, tree high
)
4662 tree etype
= TREE_TYPE (exp
), value
;
4664 /* Disable this optimization for function pointer expressions
4665 on targets that require function pointer canonicalization. */
4666 if (targetm
.have_canonicalize_funcptr_for_compare ()
4667 && TREE_CODE (etype
) == POINTER_TYPE
4668 && TREE_CODE (TREE_TYPE (etype
)) == FUNCTION_TYPE
)
4673 value
= build_range_check (loc
, type
, exp
, 1, low
, high
);
4675 return invert_truthvalue_loc (loc
, value
);
4680 if (low
== 0 && high
== 0)
4681 return omit_one_operand_loc (loc
, type
, build_int_cst (type
, 1), exp
);
4684 return fold_build2_loc (loc
, LE_EXPR
, type
, exp
,
4685 fold_convert_loc (loc
, etype
, high
));
4688 return fold_build2_loc (loc
, GE_EXPR
, type
, exp
,
4689 fold_convert_loc (loc
, etype
, low
));
4691 if (operand_equal_p (low
, high
, 0))
4692 return fold_build2_loc (loc
, EQ_EXPR
, type
, exp
,
4693 fold_convert_loc (loc
, etype
, low
));
4695 if (integer_zerop (low
))
4697 if (! TYPE_UNSIGNED (etype
))
4699 etype
= unsigned_type_for (etype
);
4700 high
= fold_convert_loc (loc
, etype
, high
);
4701 exp
= fold_convert_loc (loc
, etype
, exp
);
4703 return build_range_check (loc
, type
, exp
, 1, 0, high
);
4706 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4707 if (integer_onep (low
) && TREE_CODE (high
) == INTEGER_CST
)
4709 int prec
= TYPE_PRECISION (etype
);
4711 if (wi::mask (prec
- 1, false, prec
) == high
)
4713 if (TYPE_UNSIGNED (etype
))
4715 tree signed_etype
= signed_type_for (etype
);
4716 if (TYPE_PRECISION (signed_etype
) != TYPE_PRECISION (etype
))
4718 = build_nonstandard_integer_type (TYPE_PRECISION (etype
), 0);
4720 etype
= signed_etype
;
4721 exp
= fold_convert_loc (loc
, etype
, exp
);
4723 return fold_build2_loc (loc
, GT_EXPR
, type
, exp
,
4724 build_int_cst (etype
, 0));
4728 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4729 This requires wrap-around arithmetics for the type of the expression.
4730 First make sure that arithmetics in this type is valid, then make sure
4731 that it wraps around. */
4732 if (TREE_CODE (etype
) == ENUMERAL_TYPE
|| TREE_CODE (etype
) == BOOLEAN_TYPE
)
4733 etype
= lang_hooks
.types
.type_for_size (TYPE_PRECISION (etype
),
4734 TYPE_UNSIGNED (etype
));
4736 if (TREE_CODE (etype
) == INTEGER_TYPE
&& !TYPE_OVERFLOW_WRAPS (etype
))
4738 tree utype
, minv
, maxv
;
4740 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4741 for the type in question, as we rely on this here. */
4742 utype
= unsigned_type_for (etype
);
4743 maxv
= fold_convert_loc (loc
, utype
, TYPE_MAX_VALUE (etype
));
4744 maxv
= range_binop (PLUS_EXPR
, NULL_TREE
, maxv
, 1,
4745 build_int_cst (TREE_TYPE (maxv
), 1), 1);
4746 minv
= fold_convert_loc (loc
, utype
, TYPE_MIN_VALUE (etype
));
4748 if (integer_zerop (range_binop (NE_EXPR
, integer_type_node
,
4755 high
= fold_convert_loc (loc
, etype
, high
);
4756 low
= fold_convert_loc (loc
, etype
, low
);
4757 exp
= fold_convert_loc (loc
, etype
, exp
);
4759 value
= const_binop (MINUS_EXPR
, high
, low
);
4762 if (POINTER_TYPE_P (etype
))
4764 if (value
!= 0 && !TREE_OVERFLOW (value
))
4766 low
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (low
), low
);
4767 return build_range_check (loc
, type
,
4768 fold_build_pointer_plus_loc (loc
, exp
, low
),
4769 1, build_int_cst (etype
, 0), value
);
4774 if (value
!= 0 && !TREE_OVERFLOW (value
))
4775 return build_range_check (loc
, type
,
4776 fold_build2_loc (loc
, MINUS_EXPR
, etype
, exp
, low
),
4777 1, build_int_cst (etype
, 0), value
);
4782 /* Return the predecessor of VAL in its type, handling the infinite case. */
4785 range_predecessor (tree val
)
4787 tree type
= TREE_TYPE (val
);
4789 if (INTEGRAL_TYPE_P (type
)
4790 && operand_equal_p (val
, TYPE_MIN_VALUE (type
), 0))
4793 return range_binop (MINUS_EXPR
, NULL_TREE
, val
, 0,
4794 build_int_cst (TREE_TYPE (val
), 1), 0);
4797 /* Return the successor of VAL in its type, handling the infinite case. */
4800 range_successor (tree val
)
4802 tree type
= TREE_TYPE (val
);
4804 if (INTEGRAL_TYPE_P (type
)
4805 && operand_equal_p (val
, TYPE_MAX_VALUE (type
), 0))
4808 return range_binop (PLUS_EXPR
, NULL_TREE
, val
, 0,
4809 build_int_cst (TREE_TYPE (val
), 1), 0);
4812 /* Given two ranges, see if we can merge them into one. Return 1 if we
4813 can, 0 if we can't. Set the output range into the specified parameters. */
4816 merge_ranges (int *pin_p
, tree
*plow
, tree
*phigh
, int in0_p
, tree low0
,
4817 tree high0
, int in1_p
, tree low1
, tree high1
)
4825 int lowequal
= ((low0
== 0 && low1
== 0)
4826 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4827 low0
, 0, low1
, 0)));
4828 int highequal
= ((high0
== 0 && high1
== 0)
4829 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4830 high0
, 1, high1
, 1)));
4832 /* Make range 0 be the range that starts first, or ends last if they
4833 start at the same value. Swap them if it isn't. */
4834 if (integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4837 && integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4838 high1
, 1, high0
, 1))))
4840 temp
= in0_p
, in0_p
= in1_p
, in1_p
= temp
;
4841 tem
= low0
, low0
= low1
, low1
= tem
;
4842 tem
= high0
, high0
= high1
, high1
= tem
;
4845 /* Now flag two cases, whether the ranges are disjoint or whether the
4846 second range is totally subsumed in the first. Note that the tests
4847 below are simplified by the ones above. */
4848 no_overlap
= integer_onep (range_binop (LT_EXPR
, integer_type_node
,
4849 high0
, 1, low1
, 0));
4850 subset
= integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4851 high1
, 1, high0
, 1));
4853 /* We now have four cases, depending on whether we are including or
4854 excluding the two ranges. */
4857 /* If they don't overlap, the result is false. If the second range
4858 is a subset it is the result. Otherwise, the range is from the start
4859 of the second to the end of the first. */
4861 in_p
= 0, low
= high
= 0;
4863 in_p
= 1, low
= low1
, high
= high1
;
4865 in_p
= 1, low
= low1
, high
= high0
;
4868 else if (in0_p
&& ! in1_p
)
4870 /* If they don't overlap, the result is the first range. If they are
4871 equal, the result is false. If the second range is a subset of the
4872 first, and the ranges begin at the same place, we go from just after
4873 the end of the second range to the end of the first. If the second
4874 range is not a subset of the first, or if it is a subset and both
4875 ranges end at the same place, the range starts at the start of the
4876 first range and ends just before the second range.
4877 Otherwise, we can't describe this as a single range. */
4879 in_p
= 1, low
= low0
, high
= high0
;
4880 else if (lowequal
&& highequal
)
4881 in_p
= 0, low
= high
= 0;
4882 else if (subset
&& lowequal
)
4884 low
= range_successor (high1
);
4889 /* We are in the weird situation where high0 > high1 but
4890 high1 has no successor. Punt. */
4894 else if (! subset
|| highequal
)
4897 high
= range_predecessor (low1
);
4901 /* low0 < low1 but low1 has no predecessor. Punt. */
4909 else if (! in0_p
&& in1_p
)
4911 /* If they don't overlap, the result is the second range. If the second
4912 is a subset of the first, the result is false. Otherwise,
4913 the range starts just after the first range and ends at the
4914 end of the second. */
4916 in_p
= 1, low
= low1
, high
= high1
;
4917 else if (subset
|| highequal
)
4918 in_p
= 0, low
= high
= 0;
4921 low
= range_successor (high0
);
4926 /* high1 > high0 but high0 has no successor. Punt. */
4934 /* The case where we are excluding both ranges. Here the complex case
4935 is if they don't overlap. In that case, the only time we have a
4936 range is if they are adjacent. If the second is a subset of the
4937 first, the result is the first. Otherwise, the range to exclude
4938 starts at the beginning of the first range and ends at the end of the
4942 if (integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4943 range_successor (high0
),
4945 in_p
= 0, low
= low0
, high
= high1
;
4948 /* Canonicalize - [min, x] into - [-, x]. */
4949 if (low0
&& TREE_CODE (low0
) == INTEGER_CST
)
4950 switch (TREE_CODE (TREE_TYPE (low0
)))
4953 if (TYPE_PRECISION (TREE_TYPE (low0
))
4954 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0
))))
4958 if (tree_int_cst_equal (low0
,
4959 TYPE_MIN_VALUE (TREE_TYPE (low0
))))
4963 if (TYPE_UNSIGNED (TREE_TYPE (low0
))
4964 && integer_zerop (low0
))
4971 /* Canonicalize - [x, max] into - [x, -]. */
4972 if (high1
&& TREE_CODE (high1
) == INTEGER_CST
)
4973 switch (TREE_CODE (TREE_TYPE (high1
)))
4976 if (TYPE_PRECISION (TREE_TYPE (high1
))
4977 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1
))))
4981 if (tree_int_cst_equal (high1
,
4982 TYPE_MAX_VALUE (TREE_TYPE (high1
))))
4986 if (TYPE_UNSIGNED (TREE_TYPE (high1
))
4987 && integer_zerop (range_binop (PLUS_EXPR
, NULL_TREE
,
4989 build_int_cst (TREE_TYPE (high1
), 1),
4997 /* The ranges might be also adjacent between the maximum and
4998 minimum values of the given type. For
4999 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
5000 return + [x + 1, y - 1]. */
5001 if (low0
== 0 && high1
== 0)
5003 low
= range_successor (high0
);
5004 high
= range_predecessor (low1
);
5005 if (low
== 0 || high
== 0)
5015 in_p
= 0, low
= low0
, high
= high0
;
5017 in_p
= 0, low
= low0
, high
= high1
;
5020 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
5025 /* Subroutine of fold, looking inside expressions of the form
5026 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5027 of the COND_EXPR. This function is being used also to optimize
5028 A op B ? C : A, by reversing the comparison first.
5030 Return a folded expression whose code is not a COND_EXPR
5031 anymore, or NULL_TREE if no folding opportunity is found. */
5034 fold_cond_expr_with_comparison (location_t loc
, tree type
,
5035 tree arg0
, tree arg1
, tree arg2
)
5037 enum tree_code comp_code
= TREE_CODE (arg0
);
5038 tree arg00
= TREE_OPERAND (arg0
, 0);
5039 tree arg01
= TREE_OPERAND (arg0
, 1);
5040 tree arg1_type
= TREE_TYPE (arg1
);
5046 /* If we have A op 0 ? A : -A, consider applying the following
5049 A == 0? A : -A same as -A
5050 A != 0? A : -A same as A
5051 A >= 0? A : -A same as abs (A)
5052 A > 0? A : -A same as abs (A)
5053 A <= 0? A : -A same as -abs (A)
5054 A < 0? A : -A same as -abs (A)
5056 None of these transformations work for modes with signed
5057 zeros. If A is +/-0, the first two transformations will
5058 change the sign of the result (from +0 to -0, or vice
5059 versa). The last four will fix the sign of the result,
5060 even though the original expressions could be positive or
5061 negative, depending on the sign of A.
5063 Note that all these transformations are correct if A is
5064 NaN, since the two alternatives (A and -A) are also NaNs. */
5065 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5066 && (FLOAT_TYPE_P (TREE_TYPE (arg01
))
5067 ? real_zerop (arg01
)
5068 : integer_zerop (arg01
))
5069 && ((TREE_CODE (arg2
) == NEGATE_EXPR
5070 && operand_equal_p (TREE_OPERAND (arg2
, 0), arg1
, 0))
5071 /* In the case that A is of the form X-Y, '-A' (arg2) may
5072 have already been folded to Y-X, check for that. */
5073 || (TREE_CODE (arg1
) == MINUS_EXPR
5074 && TREE_CODE (arg2
) == MINUS_EXPR
5075 && operand_equal_p (TREE_OPERAND (arg1
, 0),
5076 TREE_OPERAND (arg2
, 1), 0)
5077 && operand_equal_p (TREE_OPERAND (arg1
, 1),
5078 TREE_OPERAND (arg2
, 0), 0))))
5083 tem
= fold_convert_loc (loc
, arg1_type
, arg1
);
5084 return pedantic_non_lvalue_loc (loc
,
5085 fold_convert_loc (loc
, type
,
5086 negate_expr (tem
)));
5089 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
5092 if (flag_trapping_math
)
5097 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5099 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5100 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
5103 if (flag_trapping_math
)
5108 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5110 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5111 return negate_expr (fold_convert_loc (loc
, type
, tem
));
5113 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5117 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5118 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5119 both transformations are correct when A is NaN: A != 0
5120 is then true, and A == 0 is false. */
5122 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5123 && integer_zerop (arg01
) && integer_zerop (arg2
))
5125 if (comp_code
== NE_EXPR
)
5126 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
5127 else if (comp_code
== EQ_EXPR
)
5128 return build_zero_cst (type
);
5131 /* Try some transformations of A op B ? A : B.
5133 A == B? A : B same as B
5134 A != B? A : B same as A
5135 A >= B? A : B same as max (A, B)
5136 A > B? A : B same as max (B, A)
5137 A <= B? A : B same as min (A, B)
5138 A < B? A : B same as min (B, A)
5140 As above, these transformations don't work in the presence
5141 of signed zeros. For example, if A and B are zeros of
5142 opposite sign, the first two transformations will change
5143 the sign of the result. In the last four, the original
5144 expressions give different results for (A=+0, B=-0) and
5145 (A=-0, B=+0), but the transformed expressions do not.
5147 The first two transformations are correct if either A or B
5148 is a NaN. In the first transformation, the condition will
5149 be false, and B will indeed be chosen. In the case of the
5150 second transformation, the condition A != B will be true,
5151 and A will be chosen.
5153 The conversions to max() and min() are not correct if B is
5154 a number and A is not. The conditions in the original
5155 expressions will be false, so all four give B. The min()
5156 and max() versions would give a NaN instead. */
5157 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5158 && operand_equal_for_comparison_p (arg01
, arg2
, arg00
)
5159 /* Avoid these transformations if the COND_EXPR may be used
5160 as an lvalue in the C++ front-end. PR c++/19199. */
5162 || VECTOR_TYPE_P (type
)
5163 || (! lang_GNU_CXX ()
5164 && strcmp (lang_hooks
.name
, "GNU Objective-C++") != 0)
5165 || ! maybe_lvalue_p (arg1
)
5166 || ! maybe_lvalue_p (arg2
)))
5168 tree comp_op0
= arg00
;
5169 tree comp_op1
= arg01
;
5170 tree comp_type
= TREE_TYPE (comp_op0
);
5172 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
5173 if (TYPE_MAIN_VARIANT (comp_type
) == TYPE_MAIN_VARIANT (type
))
5183 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg2
));
5185 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
5190 /* In C++ a ?: expression can be an lvalue, so put the
5191 operand which will be used if they are equal first
5192 so that we can convert this back to the
5193 corresponding COND_EXPR. */
5194 if (!HONOR_NANS (arg1
))
5196 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5197 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5198 tem
= (comp_code
== LE_EXPR
|| comp_code
== UNLE_EXPR
)
5199 ? fold_build2_loc (loc
, MIN_EXPR
, comp_type
, comp_op0
, comp_op1
)
5200 : fold_build2_loc (loc
, MIN_EXPR
, comp_type
,
5201 comp_op1
, comp_op0
);
5202 return pedantic_non_lvalue_loc (loc
,
5203 fold_convert_loc (loc
, type
, tem
));
5210 if (!HONOR_NANS (arg1
))
5212 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5213 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5214 tem
= (comp_code
== GE_EXPR
|| comp_code
== UNGE_EXPR
)
5215 ? fold_build2_loc (loc
, MAX_EXPR
, comp_type
, comp_op0
, comp_op1
)
5216 : fold_build2_loc (loc
, MAX_EXPR
, comp_type
,
5217 comp_op1
, comp_op0
);
5218 return pedantic_non_lvalue_loc (loc
,
5219 fold_convert_loc (loc
, type
, tem
));
5223 if (!HONOR_NANS (arg1
))
5224 return pedantic_non_lvalue_loc (loc
,
5225 fold_convert_loc (loc
, type
, arg2
));
5228 if (!HONOR_NANS (arg1
))
5229 return pedantic_non_lvalue_loc (loc
,
5230 fold_convert_loc (loc
, type
, arg1
));
5233 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5238 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5239 we might still be able to simplify this. For example,
5240 if C1 is one less or one more than C2, this might have started
5241 out as a MIN or MAX and been transformed by this function.
5242 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
5244 if (INTEGRAL_TYPE_P (type
)
5245 && TREE_CODE (arg01
) == INTEGER_CST
5246 && TREE_CODE (arg2
) == INTEGER_CST
)
5250 if (TREE_CODE (arg1
) == INTEGER_CST
)
5252 /* We can replace A with C1 in this case. */
5253 arg1
= fold_convert_loc (loc
, type
, arg01
);
5254 return fold_build3_loc (loc
, COND_EXPR
, type
, arg0
, arg1
, arg2
);
5257 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
5258 MIN_EXPR, to preserve the signedness of the comparison. */
5259 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
),
5261 && operand_equal_p (arg01
,
5262 const_binop (PLUS_EXPR
, arg2
,
5263 build_int_cst (type
, 1)),
5266 tem
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (arg00
), arg00
,
5267 fold_convert_loc (loc
, TREE_TYPE (arg00
),
5269 return pedantic_non_lvalue_loc (loc
,
5270 fold_convert_loc (loc
, type
, tem
));
5275 /* If C1 is C2 - 1, this is min(A, C2), with the same care
5277 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
),
5279 && operand_equal_p (arg01
,
5280 const_binop (MINUS_EXPR
, arg2
,
5281 build_int_cst (type
, 1)),
5284 tem
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (arg00
), arg00
,
5285 fold_convert_loc (loc
, TREE_TYPE (arg00
),
5287 return pedantic_non_lvalue_loc (loc
,
5288 fold_convert_loc (loc
, type
, tem
));
5293 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
5294 MAX_EXPR, to preserve the signedness of the comparison. */
5295 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
),
5297 && operand_equal_p (arg01
,
5298 const_binop (MINUS_EXPR
, arg2
,
5299 build_int_cst (type
, 1)),
5302 tem
= fold_build2_loc (loc
, MAX_EXPR
, TREE_TYPE (arg00
), arg00
,
5303 fold_convert_loc (loc
, TREE_TYPE (arg00
),
5305 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
5310 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
5311 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
),
5313 && operand_equal_p (arg01
,
5314 const_binop (PLUS_EXPR
, arg2
,
5315 build_int_cst (type
, 1)),
5318 tem
= fold_build2_loc (loc
, MAX_EXPR
, TREE_TYPE (arg00
), arg00
,
5319 fold_convert_loc (loc
, TREE_TYPE (arg00
),
5321 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
5335 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5336 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5337 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5341 /* EXP is some logical combination of boolean tests. See if we can
5342 merge it into some range test. Return the new tree if so. */
5345 fold_range_test (location_t loc
, enum tree_code code
, tree type
,
5348 int or_op
= (code
== TRUTH_ORIF_EXPR
5349 || code
== TRUTH_OR_EXPR
);
5350 int in0_p
, in1_p
, in_p
;
5351 tree low0
, low1
, low
, high0
, high1
, high
;
5352 bool strict_overflow_p
= false;
5354 const char * const warnmsg
= G_("assuming signed overflow does not occur "
5355 "when simplifying range test");
5357 if (!INTEGRAL_TYPE_P (type
))
5360 lhs
= make_range (op0
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
5361 rhs
= make_range (op1
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
5363 /* If this is an OR operation, invert both sides; we will invert
5364 again at the end. */
5366 in0_p
= ! in0_p
, in1_p
= ! in1_p
;
5368 /* If both expressions are the same, if we can merge the ranges, and we
5369 can build the range test, return it or it inverted. If one of the
5370 ranges is always true or always false, consider it to be the same
5371 expression as the other. */
5372 if ((lhs
== 0 || rhs
== 0 || operand_equal_p (lhs
, rhs
, 0))
5373 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
5375 && 0 != (tem
= (build_range_check (loc
, type
,
5377 : rhs
!= 0 ? rhs
: integer_zero_node
,
5380 if (strict_overflow_p
)
5381 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
5382 return or_op
? invert_truthvalue_loc (loc
, tem
) : tem
;
5385 /* On machines where the branch cost is expensive, if this is a
5386 short-circuited branch and the underlying object on both sides
5387 is the same, make a non-short-circuit operation. */
5388 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5389 && lhs
!= 0 && rhs
!= 0
5390 && (code
== TRUTH_ANDIF_EXPR
5391 || code
== TRUTH_ORIF_EXPR
)
5392 && operand_equal_p (lhs
, rhs
, 0))
5394 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5395 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5396 which cases we can't do this. */
5397 if (simple_operand_p (lhs
))
5398 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5399 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5402 else if (!lang_hooks
.decls
.global_bindings_p ()
5403 && !CONTAINS_PLACEHOLDER_P (lhs
))
5405 tree common
= save_expr (lhs
);
5407 if (0 != (lhs
= build_range_check (loc
, type
, common
,
5408 or_op
? ! in0_p
: in0_p
,
5410 && (0 != (rhs
= build_range_check (loc
, type
, common
,
5411 or_op
? ! in1_p
: in1_p
,
5414 if (strict_overflow_p
)
5415 fold_overflow_warning (warnmsg
,
5416 WARN_STRICT_OVERFLOW_COMPARISON
);
5417 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5418 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5427 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5428 bit value. Arrange things so the extra bits will be set to zero if and
5429 only if C is signed-extended to its full width. If MASK is nonzero,
5430 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5433 unextend (tree c
, int p
, int unsignedp
, tree mask
)
5435 tree type
= TREE_TYPE (c
);
5436 int modesize
= GET_MODE_BITSIZE (TYPE_MODE (type
));
5439 if (p
== modesize
|| unsignedp
)
5442 /* We work by getting just the sign bit into the low-order bit, then
5443 into the high-order bit, then sign-extend. We then XOR that value
5445 temp
= build_int_cst (TREE_TYPE (c
), wi::extract_uhwi (c
, p
- 1, 1));
5447 /* We must use a signed type in order to get an arithmetic right shift.
5448 However, we must also avoid introducing accidental overflows, so that
5449 a subsequent call to integer_zerop will work. Hence we must
5450 do the type conversion here. At this point, the constant is either
5451 zero or one, and the conversion to a signed type can never overflow.
5452 We could get an overflow if this conversion is done anywhere else. */
5453 if (TYPE_UNSIGNED (type
))
5454 temp
= fold_convert (signed_type_for (type
), temp
);
5456 temp
= const_binop (LSHIFT_EXPR
, temp
, size_int (modesize
- 1));
5457 temp
= const_binop (RSHIFT_EXPR
, temp
, size_int (modesize
- p
- 1));
5459 temp
= const_binop (BIT_AND_EXPR
, temp
,
5460 fold_convert (TREE_TYPE (c
), mask
));
5461 /* If necessary, convert the type back to match the type of C. */
5462 if (TYPE_UNSIGNED (type
))
5463 temp
= fold_convert (type
, temp
);
5465 return fold_convert (type
, const_binop (BIT_XOR_EXPR
, c
, temp
));
5468 /* For an expression that has the form
5472 we can drop one of the inner expressions and simplify to
5476 LOC is the location of the resulting expression. OP is the inner
5477 logical operation; the left-hand side in the examples above, while CMPOP
5478 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5479 removing a condition that guards another, as in
5480 (A != NULL && A->...) || A == NULL
5481 which we must not transform. If RHS_ONLY is true, only eliminate the
5482 right-most operand of the inner logical operation. */
5485 merge_truthop_with_opposite_arm (location_t loc
, tree op
, tree cmpop
,
5488 tree type
= TREE_TYPE (cmpop
);
5489 enum tree_code code
= TREE_CODE (cmpop
);
5490 enum tree_code truthop_code
= TREE_CODE (op
);
5491 tree lhs
= TREE_OPERAND (op
, 0);
5492 tree rhs
= TREE_OPERAND (op
, 1);
5493 tree orig_lhs
= lhs
, orig_rhs
= rhs
;
5494 enum tree_code rhs_code
= TREE_CODE (rhs
);
5495 enum tree_code lhs_code
= TREE_CODE (lhs
);
5496 enum tree_code inv_code
;
5498 if (TREE_SIDE_EFFECTS (op
) || TREE_SIDE_EFFECTS (cmpop
))
5501 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
5504 if (rhs_code
== truthop_code
)
5506 tree newrhs
= merge_truthop_with_opposite_arm (loc
, rhs
, cmpop
, rhs_only
);
5507 if (newrhs
!= NULL_TREE
)
5510 rhs_code
= TREE_CODE (rhs
);
5513 if (lhs_code
== truthop_code
&& !rhs_only
)
5515 tree newlhs
= merge_truthop_with_opposite_arm (loc
, lhs
, cmpop
, false);
5516 if (newlhs
!= NULL_TREE
)
5519 lhs_code
= TREE_CODE (lhs
);
5523 inv_code
= invert_tree_comparison (code
, HONOR_NANS (type
));
5524 if (inv_code
== rhs_code
5525 && operand_equal_p (TREE_OPERAND (rhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5526 && operand_equal_p (TREE_OPERAND (rhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5528 if (!rhs_only
&& inv_code
== lhs_code
5529 && operand_equal_p (TREE_OPERAND (lhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5530 && operand_equal_p (TREE_OPERAND (lhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5532 if (rhs
!= orig_rhs
|| lhs
!= orig_lhs
)
5533 return fold_build2_loc (loc
, truthop_code
, TREE_TYPE (cmpop
),
5538 /* Find ways of folding logical expressions of LHS and RHS:
5539 Try to merge two comparisons to the same innermost item.
5540 Look for range tests like "ch >= '0' && ch <= '9'".
5541 Look for combinations of simple terms on machines with expensive branches
5542 and evaluate the RHS unconditionally.
5544 For example, if we have p->a == 2 && p->b == 4 and we can make an
5545 object large enough to span both A and B, we can do this with a comparison
5546 against the object ANDed with the a mask.
5548 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5549 operations to do this with one comparison.
5551 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5552 function and the one above.
5554 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5555 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5557 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5560 We return the simplified tree or 0 if no optimization is possible. */
5563 fold_truth_andor_1 (location_t loc
, enum tree_code code
, tree truth_type
,
5566 /* If this is the "or" of two comparisons, we can do something if
5567 the comparisons are NE_EXPR. If this is the "and", we can do something
5568 if the comparisons are EQ_EXPR. I.e.,
5569 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5571 WANTED_CODE is this operation code. For single bit fields, we can
5572 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5573 comparison for one-bit fields. */
5575 enum tree_code wanted_code
;
5576 enum tree_code lcode
, rcode
;
5577 tree ll_arg
, lr_arg
, rl_arg
, rr_arg
;
5578 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
5579 HOST_WIDE_INT ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
5580 HOST_WIDE_INT rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
5581 HOST_WIDE_INT xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
5582 HOST_WIDE_INT lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
5583 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
5584 int ll_reversep
, lr_reversep
, rl_reversep
, rr_reversep
;
5585 machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
5586 machine_mode lnmode
, rnmode
;
5587 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
5588 tree ll_and_mask
, lr_and_mask
, rl_and_mask
, rr_and_mask
;
5589 tree l_const
, r_const
;
5590 tree lntype
, rntype
, result
;
5591 HOST_WIDE_INT first_bit
, end_bit
;
5594 /* Start by getting the comparison codes. Fail if anything is volatile.
5595 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5596 it were surrounded with a NE_EXPR. */
5598 if (TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
5601 lcode
= TREE_CODE (lhs
);
5602 rcode
= TREE_CODE (rhs
);
5604 if (lcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (lhs
, 1)))
5606 lhs
= build2 (NE_EXPR
, truth_type
, lhs
,
5607 build_int_cst (TREE_TYPE (lhs
), 0));
5611 if (rcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (rhs
, 1)))
5613 rhs
= build2 (NE_EXPR
, truth_type
, rhs
,
5614 build_int_cst (TREE_TYPE (rhs
), 0));
5618 if (TREE_CODE_CLASS (lcode
) != tcc_comparison
5619 || TREE_CODE_CLASS (rcode
) != tcc_comparison
)
5622 ll_arg
= TREE_OPERAND (lhs
, 0);
5623 lr_arg
= TREE_OPERAND (lhs
, 1);
5624 rl_arg
= TREE_OPERAND (rhs
, 0);
5625 rr_arg
= TREE_OPERAND (rhs
, 1);
5627 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5628 if (simple_operand_p (ll_arg
)
5629 && simple_operand_p (lr_arg
))
5631 if (operand_equal_p (ll_arg
, rl_arg
, 0)
5632 && operand_equal_p (lr_arg
, rr_arg
, 0))
5634 result
= combine_comparisons (loc
, code
, lcode
, rcode
,
5635 truth_type
, ll_arg
, lr_arg
);
5639 else if (operand_equal_p (ll_arg
, rr_arg
, 0)
5640 && operand_equal_p (lr_arg
, rl_arg
, 0))
5642 result
= combine_comparisons (loc
, code
, lcode
,
5643 swap_tree_comparison (rcode
),
5644 truth_type
, ll_arg
, lr_arg
);
5650 code
= ((code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
)
5651 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
);
5653 /* If the RHS can be evaluated unconditionally and its operands are
5654 simple, it wins to evaluate the RHS unconditionally on machines
5655 with expensive branches. In this case, this isn't a comparison
5656 that can be merged. */
5658 if (BRANCH_COST (optimize_function_for_speed_p (cfun
),
5660 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg
))
5661 && simple_operand_p (rl_arg
)
5662 && simple_operand_p (rr_arg
))
5664 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5665 if (code
== TRUTH_OR_EXPR
5666 && lcode
== NE_EXPR
&& integer_zerop (lr_arg
)
5667 && rcode
== NE_EXPR
&& integer_zerop (rr_arg
)
5668 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5669 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5670 return build2_loc (loc
, NE_EXPR
, truth_type
,
5671 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5673 build_int_cst (TREE_TYPE (ll_arg
), 0));
5675 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5676 if (code
== TRUTH_AND_EXPR
5677 && lcode
== EQ_EXPR
&& integer_zerop (lr_arg
)
5678 && rcode
== EQ_EXPR
&& integer_zerop (rr_arg
)
5679 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5680 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5681 return build2_loc (loc
, EQ_EXPR
, truth_type
,
5682 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5684 build_int_cst (TREE_TYPE (ll_arg
), 0));
5687 /* See if the comparisons can be merged. Then get all the parameters for
5690 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
5691 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
))
5694 ll_reversep
= lr_reversep
= rl_reversep
= rr_reversep
= 0;
5696 ll_inner
= decode_field_reference (loc
, &ll_arg
,
5697 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
5698 &ll_unsignedp
, &ll_reversep
, &volatilep
,
5699 &ll_mask
, &ll_and_mask
);
5700 lr_inner
= decode_field_reference (loc
, &lr_arg
,
5701 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
5702 &lr_unsignedp
, &lr_reversep
, &volatilep
,
5703 &lr_mask
, &lr_and_mask
);
5704 rl_inner
= decode_field_reference (loc
, &rl_arg
,
5705 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
5706 &rl_unsignedp
, &rl_reversep
, &volatilep
,
5707 &rl_mask
, &rl_and_mask
);
5708 rr_inner
= decode_field_reference (loc
, &rr_arg
,
5709 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
5710 &rr_unsignedp
, &rr_reversep
, &volatilep
,
5711 &rr_mask
, &rr_and_mask
);
5713 /* It must be true that the inner operation on the lhs of each
5714 comparison must be the same if we are to be able to do anything.
5715 Then see if we have constants. If not, the same must be true for
5718 || ll_reversep
!= rl_reversep
5719 || ll_inner
== 0 || rl_inner
== 0
5720 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
5723 if (TREE_CODE (lr_arg
) == INTEGER_CST
5724 && TREE_CODE (rr_arg
) == INTEGER_CST
)
5726 l_const
= lr_arg
, r_const
= rr_arg
;
5727 lr_reversep
= ll_reversep
;
5729 else if (lr_reversep
!= rr_reversep
5730 || lr_inner
== 0 || rr_inner
== 0
5731 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
5734 l_const
= r_const
= 0;
5736 /* If either comparison code is not correct for our logical operation,
5737 fail. However, we can convert a one-bit comparison against zero into
5738 the opposite comparison against that bit being set in the field. */
5740 wanted_code
= (code
== TRUTH_AND_EXPR
? EQ_EXPR
: NE_EXPR
);
5741 if (lcode
!= wanted_code
)
5743 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
5745 /* Make the left operand unsigned, since we are only interested
5746 in the value of one bit. Otherwise we are doing the wrong
5755 /* This is analogous to the code for l_const above. */
5756 if (rcode
!= wanted_code
)
5758 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
5767 /* See if we can find a mode that contains both fields being compared on
5768 the left. If we can't, fail. Otherwise, update all constants and masks
5769 to be relative to a field of that size. */
5770 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
5771 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
5772 lnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5773 TYPE_ALIGN (TREE_TYPE (ll_inner
)), word_mode
,
5775 if (lnmode
== VOIDmode
)
5778 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
5779 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
5780 lntype
= lang_hooks
.types
.type_for_size (lnbitsize
, 1);
5781 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
5783 if (ll_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5785 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
5786 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
5789 ll_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, ll_mask
),
5790 size_int (xll_bitpos
));
5791 rl_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, rl_mask
),
5792 size_int (xrl_bitpos
));
5796 l_const
= fold_convert_loc (loc
, lntype
, l_const
);
5797 l_const
= unextend (l_const
, ll_bitsize
, ll_unsignedp
, ll_and_mask
);
5798 l_const
= const_binop (LSHIFT_EXPR
, l_const
, size_int (xll_bitpos
));
5799 if (! integer_zerop (const_binop (BIT_AND_EXPR
, l_const
,
5800 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5803 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5805 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5810 r_const
= fold_convert_loc (loc
, lntype
, r_const
);
5811 r_const
= unextend (r_const
, rl_bitsize
, rl_unsignedp
, rl_and_mask
);
5812 r_const
= const_binop (LSHIFT_EXPR
, r_const
, size_int (xrl_bitpos
));
5813 if (! integer_zerop (const_binop (BIT_AND_EXPR
, r_const
,
5814 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5817 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5819 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5823 /* If the right sides are not constant, do the same for it. Also,
5824 disallow this optimization if a size or signedness mismatch occurs
5825 between the left and right sides. */
5828 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
5829 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
5830 /* Make sure the two fields on the right
5831 correspond to the left without being swapped. */
5832 || ll_bitpos
- rl_bitpos
!= lr_bitpos
- rr_bitpos
)
5835 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
5836 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
5837 rnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5838 TYPE_ALIGN (TREE_TYPE (lr_inner
)), word_mode
,
5840 if (rnmode
== VOIDmode
)
5843 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
5844 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
5845 rntype
= lang_hooks
.types
.type_for_size (rnbitsize
, 1);
5846 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
5848 if (lr_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5850 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
5851 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
5854 lr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5856 size_int (xlr_bitpos
));
5857 rr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5859 size_int (xrr_bitpos
));
5861 /* Make a mask that corresponds to both fields being compared.
5862 Do this for both items being compared. If the operands are the
5863 same size and the bits being compared are in the same position
5864 then we can do this by masking both and comparing the masked
5866 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5867 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
);
5868 if (lnbitsize
== rnbitsize
&& xll_bitpos
== xlr_bitpos
)
5870 lhs
= make_bit_field_ref (loc
, ll_inner
, ll_arg
,
5871 lntype
, lnbitsize
, lnbitpos
,
5872 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
5873 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5874 lhs
= build2 (BIT_AND_EXPR
, lntype
, lhs
, ll_mask
);
5876 rhs
= make_bit_field_ref (loc
, lr_inner
, lr_arg
,
5877 rntype
, rnbitsize
, rnbitpos
,
5878 lr_unsignedp
|| rr_unsignedp
, lr_reversep
);
5879 if (! all_ones_mask_p (lr_mask
, rnbitsize
))
5880 rhs
= build2 (BIT_AND_EXPR
, rntype
, rhs
, lr_mask
);
5882 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5885 /* There is still another way we can do something: If both pairs of
5886 fields being compared are adjacent, we may be able to make a wider
5887 field containing them both.
5889 Note that we still must mask the lhs/rhs expressions. Furthermore,
5890 the mask must be shifted to account for the shift done by
5891 make_bit_field_ref. */
5892 if ((ll_bitsize
+ ll_bitpos
== rl_bitpos
5893 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
5894 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
5895 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
5899 lhs
= make_bit_field_ref (loc
, ll_inner
, ll_arg
, lntype
,
5900 ll_bitsize
+ rl_bitsize
,
5901 MIN (ll_bitpos
, rl_bitpos
),
5902 ll_unsignedp
, ll_reversep
);
5903 rhs
= make_bit_field_ref (loc
, lr_inner
, lr_arg
, rntype
,
5904 lr_bitsize
+ rr_bitsize
,
5905 MIN (lr_bitpos
, rr_bitpos
),
5906 lr_unsignedp
, lr_reversep
);
5908 ll_mask
= const_binop (RSHIFT_EXPR
, ll_mask
,
5909 size_int (MIN (xll_bitpos
, xrl_bitpos
)));
5910 lr_mask
= const_binop (RSHIFT_EXPR
, lr_mask
,
5911 size_int (MIN (xlr_bitpos
, xrr_bitpos
)));
5913 /* Convert to the smaller type before masking out unwanted bits. */
5915 if (lntype
!= rntype
)
5917 if (lnbitsize
> rnbitsize
)
5919 lhs
= fold_convert_loc (loc
, rntype
, lhs
);
5920 ll_mask
= fold_convert_loc (loc
, rntype
, ll_mask
);
5923 else if (lnbitsize
< rnbitsize
)
5925 rhs
= fold_convert_loc (loc
, lntype
, rhs
);
5926 lr_mask
= fold_convert_loc (loc
, lntype
, lr_mask
);
5931 if (! all_ones_mask_p (ll_mask
, ll_bitsize
+ rl_bitsize
))
5932 lhs
= build2 (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
5934 if (! all_ones_mask_p (lr_mask
, lr_bitsize
+ rr_bitsize
))
5935 rhs
= build2 (BIT_AND_EXPR
, type
, rhs
, lr_mask
);
5937 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5943 /* Handle the case of comparisons with constants. If there is something in
5944 common between the masks, those bits of the constants must be the same.
5945 If not, the condition is always false. Test for this to avoid generating
5946 incorrect code below. */
5947 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
);
5948 if (! integer_zerop (result
)
5949 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
),
5950 const_binop (BIT_AND_EXPR
, result
, r_const
)) != 1)
5952 if (wanted_code
== NE_EXPR
)
5954 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5955 return constant_boolean_node (true, truth_type
);
5959 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5960 return constant_boolean_node (false, truth_type
);
5964 /* Construct the expression we will return. First get the component
5965 reference we will make. Unless the mask is all ones the width of
5966 that field, perform the mask operation. Then compare with the
5968 result
= make_bit_field_ref (loc
, ll_inner
, ll_arg
,
5969 lntype
, lnbitsize
, lnbitpos
,
5970 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
5972 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5973 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5974 result
= build2_loc (loc
, BIT_AND_EXPR
, lntype
, result
, ll_mask
);
5976 return build2_loc (loc
, wanted_code
, truth_type
, result
,
5977 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
5980 /* T is an integer expression that is being multiplied, divided, or taken a
5981 modulus (CODE says which and what kind of divide or modulus) by a
5982 constant C. See if we can eliminate that operation by folding it with
5983 other operations already in T. WIDE_TYPE, if non-null, is a type that
5984 should be used for the computation if wider than our type.
5986 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5987 (X * 2) + (Y * 4). We must, however, be assured that either the original
5988 expression would not overflow or that overflow is undefined for the type
5989 in the language in question.
5991 If we return a non-null expression, it is an equivalent form of the
5992 original computation, but need not be in the original type.
5994 We set *STRICT_OVERFLOW_P to true if the return values depends on
5995 signed overflow being undefined. Otherwise we do not change
5996 *STRICT_OVERFLOW_P. */
5999 extract_muldiv (tree t
, tree c
, enum tree_code code
, tree wide_type
,
6000 bool *strict_overflow_p
)
6002 /* To avoid exponential search depth, refuse to allow recursion past
6003 three levels. Beyond that (1) it's highly unlikely that we'll find
6004 something interesting and (2) we've probably processed it before
6005 when we built the inner expression. */
6014 ret
= extract_muldiv_1 (t
, c
, code
, wide_type
, strict_overflow_p
);
6021 extract_muldiv_1 (tree t
, tree c
, enum tree_code code
, tree wide_type
,
6022 bool *strict_overflow_p
)
6024 tree type
= TREE_TYPE (t
);
6025 enum tree_code tcode
= TREE_CODE (t
);
6026 tree ctype
= (wide_type
!= 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type
))
6027 > GET_MODE_SIZE (TYPE_MODE (type
)))
6028 ? wide_type
: type
);
6030 int same_p
= tcode
== code
;
6031 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
6032 bool sub_strict_overflow_p
;
6034 /* Don't deal with constants of zero here; they confuse the code below. */
6035 if (integer_zerop (c
))
6038 if (TREE_CODE_CLASS (tcode
) == tcc_unary
)
6039 op0
= TREE_OPERAND (t
, 0);
6041 if (TREE_CODE_CLASS (tcode
) == tcc_binary
)
6042 op0
= TREE_OPERAND (t
, 0), op1
= TREE_OPERAND (t
, 1);
6044 /* Note that we need not handle conditional operations here since fold
6045 already handles those cases. So just do arithmetic here. */
6049 /* For a constant, we can always simplify if we are a multiply
6050 or (for divide and modulus) if it is a multiple of our constant. */
6051 if (code
== MULT_EXPR
6052 || wi::multiple_of_p (t
, c
, TYPE_SIGN (type
)))
6054 tree tem
= const_binop (code
, fold_convert (ctype
, t
),
6055 fold_convert (ctype
, c
));
6056 /* If the multiplication overflowed, we lost information on it.
6057 See PR68142 and PR69845. */
6058 if (TREE_OVERFLOW (tem
))
6064 CASE_CONVERT
: case NON_LVALUE_EXPR
:
6065 /* If op0 is an expression ... */
6066 if ((COMPARISON_CLASS_P (op0
)
6067 || UNARY_CLASS_P (op0
)
6068 || BINARY_CLASS_P (op0
)
6069 || VL_EXP_CLASS_P (op0
)
6070 || EXPRESSION_CLASS_P (op0
))
6071 /* ... and has wrapping overflow, and its type is smaller
6072 than ctype, then we cannot pass through as widening. */
6073 && (((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
6074 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0
)))
6075 && (TYPE_PRECISION (ctype
)
6076 > TYPE_PRECISION (TREE_TYPE (op0
))))
6077 /* ... or this is a truncation (t is narrower than op0),
6078 then we cannot pass through this narrowing. */
6079 || (TYPE_PRECISION (type
)
6080 < TYPE_PRECISION (TREE_TYPE (op0
)))
6081 /* ... or signedness changes for division or modulus,
6082 then we cannot pass through this conversion. */
6083 || (code
!= MULT_EXPR
6084 && (TYPE_UNSIGNED (ctype
)
6085 != TYPE_UNSIGNED (TREE_TYPE (op0
))))
6086 /* ... or has undefined overflow while the converted to
6087 type has not, we cannot do the operation in the inner type
6088 as that would introduce undefined overflow. */
6089 || ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
6090 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0
)))
6091 && !TYPE_OVERFLOW_UNDEFINED (type
))))
6094 /* Pass the constant down and see if we can make a simplification. If
6095 we can, replace this expression with the inner simplification for
6096 possible later conversion to our or some other type. */
6097 if ((t2
= fold_convert (TREE_TYPE (op0
), c
)) != 0
6098 && TREE_CODE (t2
) == INTEGER_CST
6099 && !TREE_OVERFLOW (t2
)
6100 && (0 != (t1
= extract_muldiv (op0
, t2
, code
,
6102 ? ctype
: NULL_TREE
,
6103 strict_overflow_p
))))
6108 /* If widening the type changes it from signed to unsigned, then we
6109 must avoid building ABS_EXPR itself as unsigned. */
6110 if (TYPE_UNSIGNED (ctype
) && !TYPE_UNSIGNED (type
))
6112 tree cstype
= (*signed_type_for
) (ctype
);
6113 if ((t1
= extract_muldiv (op0
, c
, code
, cstype
, strict_overflow_p
))
6116 t1
= fold_build1 (tcode
, cstype
, fold_convert (cstype
, t1
));
6117 return fold_convert (ctype
, t1
);
6121 /* If the constant is negative, we cannot simplify this. */
6122 if (tree_int_cst_sgn (c
) == -1)
6126 /* For division and modulus, type can't be unsigned, as e.g.
6127 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6128 For signed types, even with wrapping overflow, this is fine. */
6129 if (code
!= MULT_EXPR
&& TYPE_UNSIGNED (type
))
6131 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
, strict_overflow_p
))
6133 return fold_build1 (tcode
, ctype
, fold_convert (ctype
, t1
));
6136 case MIN_EXPR
: case MAX_EXPR
:
6137 /* If widening the type changes the signedness, then we can't perform
6138 this optimization as that changes the result. */
6139 if (TYPE_UNSIGNED (ctype
) != TYPE_UNSIGNED (type
))
6142 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6143 sub_strict_overflow_p
= false;
6144 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6145 &sub_strict_overflow_p
)) != 0
6146 && (t2
= extract_muldiv (op1
, c
, code
, wide_type
,
6147 &sub_strict_overflow_p
)) != 0)
6149 if (tree_int_cst_sgn (c
) < 0)
6150 tcode
= (tcode
== MIN_EXPR
? MAX_EXPR
: MIN_EXPR
);
6151 if (sub_strict_overflow_p
)
6152 *strict_overflow_p
= true;
6153 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6154 fold_convert (ctype
, t2
));
6158 case LSHIFT_EXPR
: case RSHIFT_EXPR
:
6159 /* If the second operand is constant, this is a multiplication
6160 or floor division, by a power of two, so we can treat it that
6161 way unless the multiplier or divisor overflows. Signed
6162 left-shift overflow is implementation-defined rather than
6163 undefined in C90, so do not convert signed left shift into
6165 if (TREE_CODE (op1
) == INTEGER_CST
6166 && (tcode
== RSHIFT_EXPR
|| TYPE_UNSIGNED (TREE_TYPE (op0
)))
6167 /* const_binop may not detect overflow correctly,
6168 so check for it explicitly here. */
6169 && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
6170 && 0 != (t1
= fold_convert (ctype
,
6171 const_binop (LSHIFT_EXPR
,
6174 && !TREE_OVERFLOW (t1
))
6175 return extract_muldiv (build2 (tcode
== LSHIFT_EXPR
6176 ? MULT_EXPR
: FLOOR_DIV_EXPR
,
6178 fold_convert (ctype
, op0
),
6180 c
, code
, wide_type
, strict_overflow_p
);
6183 case PLUS_EXPR
: case MINUS_EXPR
:
6184 /* See if we can eliminate the operation on both sides. If we can, we
6185 can return a new PLUS or MINUS. If we can't, the only remaining
6186 cases where we can do anything are if the second operand is a
6188 sub_strict_overflow_p
= false;
6189 t1
= extract_muldiv (op0
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6190 t2
= extract_muldiv (op1
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6191 if (t1
!= 0 && t2
!= 0
6192 && (code
== MULT_EXPR
6193 /* If not multiplication, we can only do this if both operands
6194 are divisible by c. */
6195 || (multiple_of_p (ctype
, op0
, c
)
6196 && multiple_of_p (ctype
, op1
, c
))))
6198 if (sub_strict_overflow_p
)
6199 *strict_overflow_p
= true;
6200 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6201 fold_convert (ctype
, t2
));
6204 /* If this was a subtraction, negate OP1 and set it to be an addition.
6205 This simplifies the logic below. */
6206 if (tcode
== MINUS_EXPR
)
6208 tcode
= PLUS_EXPR
, op1
= negate_expr (op1
);
6209 /* If OP1 was not easily negatable, the constant may be OP0. */
6210 if (TREE_CODE (op0
) == INTEGER_CST
)
6212 std::swap (op0
, op1
);
6217 if (TREE_CODE (op1
) != INTEGER_CST
)
6220 /* If either OP1 or C are negative, this optimization is not safe for
6221 some of the division and remainder types while for others we need
6222 to change the code. */
6223 if (tree_int_cst_sgn (op1
) < 0 || tree_int_cst_sgn (c
) < 0)
6225 if (code
== CEIL_DIV_EXPR
)
6226 code
= FLOOR_DIV_EXPR
;
6227 else if (code
== FLOOR_DIV_EXPR
)
6228 code
= CEIL_DIV_EXPR
;
6229 else if (code
!= MULT_EXPR
6230 && code
!= CEIL_MOD_EXPR
&& code
!= FLOOR_MOD_EXPR
)
6234 /* If it's a multiply or a division/modulus operation of a multiple
6235 of our constant, do the operation and verify it doesn't overflow. */
6236 if (code
== MULT_EXPR
6237 || wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6239 op1
= const_binop (code
, fold_convert (ctype
, op1
),
6240 fold_convert (ctype
, c
));
6241 /* We allow the constant to overflow with wrapping semantics. */
6243 || (TREE_OVERFLOW (op1
) && !TYPE_OVERFLOW_WRAPS (ctype
)))
6249 /* If we have an unsigned type, we cannot widen the operation since it
6250 will change the result if the original computation overflowed. */
6251 if (TYPE_UNSIGNED (ctype
) && ctype
!= type
)
6254 /* If we were able to eliminate our operation from the first side,
6255 apply our operation to the second side and reform the PLUS. */
6256 if (t1
!= 0 && (TREE_CODE (t1
) != code
|| code
== MULT_EXPR
))
6257 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
), op1
);
6259 /* The last case is if we are a multiply. In that case, we can
6260 apply the distributive law to commute the multiply and addition
6261 if the multiplication of the constants doesn't overflow
6262 and overflow is defined. With undefined overflow
6263 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6264 if (code
== MULT_EXPR
&& TYPE_OVERFLOW_WRAPS (ctype
))
6265 return fold_build2 (tcode
, ctype
,
6266 fold_build2 (code
, ctype
,
6267 fold_convert (ctype
, op0
),
6268 fold_convert (ctype
, c
)),
6274 /* We have a special case here if we are doing something like
6275 (C * 8) % 4 since we know that's zero. */
6276 if ((code
== TRUNC_MOD_EXPR
|| code
== CEIL_MOD_EXPR
6277 || code
== FLOOR_MOD_EXPR
|| code
== ROUND_MOD_EXPR
)
6278 /* If the multiplication can overflow we cannot optimize this. */
6279 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
))
6280 && TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
6281 && wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6283 *strict_overflow_p
= true;
6284 return omit_one_operand (type
, integer_zero_node
, op0
);
6287 /* ... fall through ... */
6289 case TRUNC_DIV_EXPR
: case CEIL_DIV_EXPR
: case FLOOR_DIV_EXPR
:
6290 case ROUND_DIV_EXPR
: case EXACT_DIV_EXPR
:
6291 /* If we can extract our operation from the LHS, do so and return a
6292 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6293 do something only if the second operand is a constant. */
6295 && (t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6296 strict_overflow_p
)) != 0)
6297 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6298 fold_convert (ctype
, op1
));
6299 else if (tcode
== MULT_EXPR
&& code
== MULT_EXPR
6300 && (t1
= extract_muldiv (op1
, c
, code
, wide_type
,
6301 strict_overflow_p
)) != 0)
6302 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6303 fold_convert (ctype
, t1
));
6304 else if (TREE_CODE (op1
) != INTEGER_CST
)
6307 /* If these are the same operation types, we can associate them
6308 assuming no overflow. */
6311 bool overflow_p
= false;
6312 bool overflow_mul_p
;
6313 signop sign
= TYPE_SIGN (ctype
);
6314 unsigned prec
= TYPE_PRECISION (ctype
);
6315 wide_int mul
= wi::mul (wi::to_wide (op1
, prec
),
6316 wi::to_wide (c
, prec
),
6317 sign
, &overflow_mul_p
);
6318 overflow_p
= TREE_OVERFLOW (c
) | TREE_OVERFLOW (op1
);
6320 && ((sign
== UNSIGNED
&& tcode
!= MULT_EXPR
) || sign
== SIGNED
))
6323 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6324 wide_int_to_tree (ctype
, mul
));
6327 /* If these operations "cancel" each other, we have the main
6328 optimizations of this pass, which occur when either constant is a
6329 multiple of the other, in which case we replace this with either an
6330 operation or CODE or TCODE.
6332 If we have an unsigned type, we cannot do this since it will change
6333 the result if the original computation overflowed. */
6334 if (TYPE_OVERFLOW_UNDEFINED (ctype
)
6335 && ((code
== MULT_EXPR
&& tcode
== EXACT_DIV_EXPR
)
6336 || (tcode
== MULT_EXPR
6337 && code
!= TRUNC_MOD_EXPR
&& code
!= CEIL_MOD_EXPR
6338 && code
!= FLOOR_MOD_EXPR
&& code
!= ROUND_MOD_EXPR
6339 && code
!= MULT_EXPR
)))
6341 if (wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6343 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6344 *strict_overflow_p
= true;
6345 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6346 fold_convert (ctype
,
6347 const_binop (TRUNC_DIV_EXPR
,
6350 else if (wi::multiple_of_p (c
, op1
, TYPE_SIGN (type
)))
6352 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6353 *strict_overflow_p
= true;
6354 return fold_build2 (code
, ctype
, fold_convert (ctype
, op0
),
6355 fold_convert (ctype
,
6356 const_binop (TRUNC_DIV_EXPR
,
6369 /* Return a node which has the indicated constant VALUE (either 0 or
6370 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6371 and is of the indicated TYPE. */
6374 constant_boolean_node (bool value
, tree type
)
6376 if (type
== integer_type_node
)
6377 return value
? integer_one_node
: integer_zero_node
;
6378 else if (type
== boolean_type_node
)
6379 return value
? boolean_true_node
: boolean_false_node
;
6380 else if (TREE_CODE (type
) == VECTOR_TYPE
)
6381 return build_vector_from_val (type
,
6382 build_int_cst (TREE_TYPE (type
),
6385 return fold_convert (type
, value
? integer_one_node
: integer_zero_node
);
6389 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6390 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6391 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6392 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6393 COND is the first argument to CODE; otherwise (as in the example
6394 given here), it is the second argument. TYPE is the type of the
6395 original expression. Return NULL_TREE if no simplification is
6399 fold_binary_op_with_conditional_arg (location_t loc
,
6400 enum tree_code code
,
6401 tree type
, tree op0
, tree op1
,
6402 tree cond
, tree arg
, int cond_first_p
)
6404 tree cond_type
= cond_first_p
? TREE_TYPE (op0
) : TREE_TYPE (op1
);
6405 tree arg_type
= cond_first_p
? TREE_TYPE (op1
) : TREE_TYPE (op0
);
6406 tree test
, true_value
, false_value
;
6407 tree lhs
= NULL_TREE
;
6408 tree rhs
= NULL_TREE
;
6409 enum tree_code cond_code
= COND_EXPR
;
6411 if (TREE_CODE (cond
) == COND_EXPR
6412 || TREE_CODE (cond
) == VEC_COND_EXPR
)
6414 test
= TREE_OPERAND (cond
, 0);
6415 true_value
= TREE_OPERAND (cond
, 1);
6416 false_value
= TREE_OPERAND (cond
, 2);
6417 /* If this operand throws an expression, then it does not make
6418 sense to try to perform a logical or arithmetic operation
6420 if (VOID_TYPE_P (TREE_TYPE (true_value
)))
6422 if (VOID_TYPE_P (TREE_TYPE (false_value
)))
6425 else if (!(TREE_CODE (type
) != VECTOR_TYPE
6426 && TREE_CODE (TREE_TYPE (cond
)) == VECTOR_TYPE
))
6428 tree testtype
= TREE_TYPE (cond
);
6430 true_value
= constant_boolean_node (true, testtype
);
6431 false_value
= constant_boolean_node (false, testtype
);
6434 /* Detect the case of mixing vector and scalar types - bail out. */
6437 if (TREE_CODE (TREE_TYPE (test
)) == VECTOR_TYPE
)
6438 cond_code
= VEC_COND_EXPR
;
6440 /* This transformation is only worthwhile if we don't have to wrap ARG
6441 in a SAVE_EXPR and the operation can be simplified without recursing
6442 on at least one of the branches once its pushed inside the COND_EXPR. */
6443 if (!TREE_CONSTANT (arg
)
6444 && (TREE_SIDE_EFFECTS (arg
)
6445 || TREE_CODE (arg
) == COND_EXPR
|| TREE_CODE (arg
) == VEC_COND_EXPR
6446 || TREE_CONSTANT (true_value
) || TREE_CONSTANT (false_value
)))
6449 arg
= fold_convert_loc (loc
, arg_type
, arg
);
6452 true_value
= fold_convert_loc (loc
, cond_type
, true_value
);
6454 lhs
= fold_build2_loc (loc
, code
, type
, true_value
, arg
);
6456 lhs
= fold_build2_loc (loc
, code
, type
, arg
, true_value
);
6460 false_value
= fold_convert_loc (loc
, cond_type
, false_value
);
6462 rhs
= fold_build2_loc (loc
, code
, type
, false_value
, arg
);
6464 rhs
= fold_build2_loc (loc
, code
, type
, arg
, false_value
);
6467 /* Check that we have simplified at least one of the branches. */
6468 if (!TREE_CONSTANT (arg
) && !TREE_CONSTANT (lhs
) && !TREE_CONSTANT (rhs
))
6471 return fold_build3_loc (loc
, cond_code
, type
, test
, lhs
, rhs
);
6475 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6477 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6478 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6479 ADDEND is the same as X.
6481 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6482 and finite. The problematic cases are when X is zero, and its mode
6483 has signed zeros. In the case of rounding towards -infinity,
6484 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6485 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6488 fold_real_zero_addition_p (const_tree type
, const_tree addend
, int negate
)
6490 if (!real_zerop (addend
))
6493 /* Don't allow the fold with -fsignaling-nans. */
6494 if (HONOR_SNANS (element_mode (type
)))
6497 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6498 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
6501 /* In a vector or complex, we would need to check the sign of all zeros. */
6502 if (TREE_CODE (addend
) != REAL_CST
)
6505 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6506 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend
)))
6509 /* The mode has signed zeros, and we have to honor their sign.
6510 In this situation, there is only one case we can return true for.
6511 X - 0 is the same as X unless rounding towards -infinity is
6513 return negate
&& !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
));
6516 /* Subroutine of fold() that optimizes comparisons of a division by
6517 a nonzero integer constant against an integer constant, i.e.
6520 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6521 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6522 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6524 The function returns the constant folded tree if a simplification
6525 can be made, and NULL_TREE otherwise. */
6528 fold_div_compare (location_t loc
,
6529 enum tree_code code
, tree type
, tree arg0
, tree arg1
)
6531 tree prod
, tmp
, hi
, lo
;
6532 tree arg00
= TREE_OPERAND (arg0
, 0);
6533 tree arg01
= TREE_OPERAND (arg0
, 1);
6534 signop sign
= TYPE_SIGN (TREE_TYPE (arg0
));
6535 bool neg_overflow
= false;
6538 /* We have to do this the hard way to detect unsigned overflow.
6539 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6540 wide_int val
= wi::mul (arg01
, arg1
, sign
, &overflow
);
6541 prod
= force_fit_type (TREE_TYPE (arg00
), val
, -1, overflow
);
6542 neg_overflow
= false;
6544 if (sign
== UNSIGNED
)
6546 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6547 build_int_cst (TREE_TYPE (arg01
), 1));
6550 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6551 val
= wi::add (prod
, tmp
, sign
, &overflow
);
6552 hi
= force_fit_type (TREE_TYPE (arg00
), val
,
6553 -1, overflow
| TREE_OVERFLOW (prod
));
6555 else if (tree_int_cst_sgn (arg01
) >= 0)
6557 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6558 build_int_cst (TREE_TYPE (arg01
), 1));
6559 switch (tree_int_cst_sgn (arg1
))
6562 neg_overflow
= true;
6563 lo
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6568 lo
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6573 hi
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6583 /* A negative divisor reverses the relational operators. */
6584 code
= swap_tree_comparison (code
);
6586 tmp
= int_const_binop (PLUS_EXPR
, arg01
,
6587 build_int_cst (TREE_TYPE (arg01
), 1));
6588 switch (tree_int_cst_sgn (arg1
))
6591 hi
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6596 hi
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6601 neg_overflow
= true;
6602 lo
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6614 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6615 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg00
);
6616 if (TREE_OVERFLOW (hi
))
6617 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6618 if (TREE_OVERFLOW (lo
))
6619 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6620 return build_range_check (loc
, type
, arg00
, 1, lo
, hi
);
6623 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6624 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg00
);
6625 if (TREE_OVERFLOW (hi
))
6626 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6627 if (TREE_OVERFLOW (lo
))
6628 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6629 return build_range_check (loc
, type
, arg00
, 0, lo
, hi
);
6632 if (TREE_OVERFLOW (lo
))
6634 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6635 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6637 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6640 if (TREE_OVERFLOW (hi
))
6642 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6643 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6645 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6648 if (TREE_OVERFLOW (hi
))
6650 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6651 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6653 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6656 if (TREE_OVERFLOW (lo
))
6658 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6659 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6661 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6671 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6672 equality/inequality test, then return a simplified form of the test
6673 using a sign testing. Otherwise return NULL. TYPE is the desired
6677 fold_single_bit_test_into_sign_test (location_t loc
,
6678 enum tree_code code
, tree arg0
, tree arg1
,
6681 /* If this is testing a single bit, we can optimize the test. */
6682 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6683 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6684 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6686 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6687 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6688 tree arg00
= sign_bit_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1));
6690 if (arg00
!= NULL_TREE
6691 /* This is only a win if casting to a signed type is cheap,
6692 i.e. when arg00's type is not a partial mode. */
6693 && TYPE_PRECISION (TREE_TYPE (arg00
))
6694 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg00
))))
6696 tree stype
= signed_type_for (TREE_TYPE (arg00
));
6697 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
6699 fold_convert_loc (loc
, stype
, arg00
),
6700 build_int_cst (stype
, 0));
6707 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6708 equality/inequality test, then return a simplified form of
6709 the test using shifts and logical operations. Otherwise return
6710 NULL. TYPE is the desired result type. */
6713 fold_single_bit_test (location_t loc
, enum tree_code code
,
6714 tree arg0
, tree arg1
, tree result_type
)
6716 /* If this is testing a single bit, we can optimize the test. */
6717 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6718 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6719 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6721 tree inner
= TREE_OPERAND (arg0
, 0);
6722 tree type
= TREE_TYPE (arg0
);
6723 int bitnum
= tree_log2 (TREE_OPERAND (arg0
, 1));
6724 machine_mode operand_mode
= TYPE_MODE (type
);
6726 tree signed_type
, unsigned_type
, intermediate_type
;
6729 /* First, see if we can fold the single bit test into a sign-bit
6731 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
,
6736 /* Otherwise we have (A & C) != 0 where C is a single bit,
6737 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6738 Similarly for (A & C) == 0. */
6740 /* If INNER is a right shift of a constant and it plus BITNUM does
6741 not overflow, adjust BITNUM and INNER. */
6742 if (TREE_CODE (inner
) == RSHIFT_EXPR
6743 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
6744 && bitnum
< TYPE_PRECISION (type
)
6745 && wi::ltu_p (TREE_OPERAND (inner
, 1),
6746 TYPE_PRECISION (type
) - bitnum
))
6748 bitnum
+= tree_to_uhwi (TREE_OPERAND (inner
, 1));
6749 inner
= TREE_OPERAND (inner
, 0);
6752 /* If we are going to be able to omit the AND below, we must do our
6753 operations as unsigned. If we must use the AND, we have a choice.
6754 Normally unsigned is faster, but for some machines signed is. */
6755 ops_unsigned
= (LOAD_EXTEND_OP (operand_mode
) == SIGN_EXTEND
6756 && !flag_syntax_only
) ? 0 : 1;
6758 signed_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 0);
6759 unsigned_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 1);
6760 intermediate_type
= ops_unsigned
? unsigned_type
: signed_type
;
6761 inner
= fold_convert_loc (loc
, intermediate_type
, inner
);
6764 inner
= build2 (RSHIFT_EXPR
, intermediate_type
,
6765 inner
, size_int (bitnum
));
6767 one
= build_int_cst (intermediate_type
, 1);
6769 if (code
== EQ_EXPR
)
6770 inner
= fold_build2_loc (loc
, BIT_XOR_EXPR
, intermediate_type
, inner
, one
);
6772 /* Put the AND last so it can combine with more things. */
6773 inner
= build2 (BIT_AND_EXPR
, intermediate_type
, inner
, one
);
6775 /* Make sure to return the proper type. */
6776 inner
= fold_convert_loc (loc
, result_type
, inner
);
6783 /* Check whether we are allowed to reorder operands arg0 and arg1,
6784 such that the evaluation of arg1 occurs before arg0. */
6787 reorder_operands_p (const_tree arg0
, const_tree arg1
)
6789 if (! flag_evaluation_order
)
6791 if (TREE_CONSTANT (arg0
) || TREE_CONSTANT (arg1
))
6793 return ! TREE_SIDE_EFFECTS (arg0
)
6794 && ! TREE_SIDE_EFFECTS (arg1
);
6797 /* Test whether it is preferable two swap two operands, ARG0 and
6798 ARG1, for example because ARG0 is an integer constant and ARG1
6799 isn't. If REORDER is true, only recommend swapping if we can
6800 evaluate the operands in reverse order. */
6803 tree_swap_operands_p (const_tree arg0
, const_tree arg1
, bool reorder
)
6805 if (CONSTANT_CLASS_P (arg1
))
6807 if (CONSTANT_CLASS_P (arg0
))
6813 if (TREE_CONSTANT (arg1
))
6815 if (TREE_CONSTANT (arg0
))
6818 if (reorder
&& flag_evaluation_order
6819 && (TREE_SIDE_EFFECTS (arg0
) || TREE_SIDE_EFFECTS (arg1
)))
6822 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6823 for commutative and comparison operators. Ensuring a canonical
6824 form allows the optimizers to find additional redundancies without
6825 having to explicitly check for both orderings. */
6826 if (TREE_CODE (arg0
) == SSA_NAME
6827 && TREE_CODE (arg1
) == SSA_NAME
6828 && SSA_NAME_VERSION (arg0
) > SSA_NAME_VERSION (arg1
))
6831 /* Put SSA_NAMEs last. */
6832 if (TREE_CODE (arg1
) == SSA_NAME
)
6834 if (TREE_CODE (arg0
) == SSA_NAME
)
6837 /* Put variables last. */
6847 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6848 means A >= Y && A != MAX, but in this case we know that
6849 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6852 fold_to_nonsharp_ineq_using_bound (location_t loc
, tree ineq
, tree bound
)
6854 tree a
, typea
, type
= TREE_TYPE (ineq
), a1
, diff
, y
;
6856 if (TREE_CODE (bound
) == LT_EXPR
)
6857 a
= TREE_OPERAND (bound
, 0);
6858 else if (TREE_CODE (bound
) == GT_EXPR
)
6859 a
= TREE_OPERAND (bound
, 1);
6863 typea
= TREE_TYPE (a
);
6864 if (!INTEGRAL_TYPE_P (typea
)
6865 && !POINTER_TYPE_P (typea
))
6868 if (TREE_CODE (ineq
) == LT_EXPR
)
6870 a1
= TREE_OPERAND (ineq
, 1);
6871 y
= TREE_OPERAND (ineq
, 0);
6873 else if (TREE_CODE (ineq
) == GT_EXPR
)
6875 a1
= TREE_OPERAND (ineq
, 0);
6876 y
= TREE_OPERAND (ineq
, 1);
6881 if (TREE_TYPE (a1
) != typea
)
6884 if (POINTER_TYPE_P (typea
))
6886 /* Convert the pointer types into integer before taking the difference. */
6887 tree ta
= fold_convert_loc (loc
, ssizetype
, a
);
6888 tree ta1
= fold_convert_loc (loc
, ssizetype
, a1
);
6889 diff
= fold_binary_loc (loc
, MINUS_EXPR
, ssizetype
, ta1
, ta
);
6892 diff
= fold_binary_loc (loc
, MINUS_EXPR
, typea
, a1
, a
);
6894 if (!diff
|| !integer_onep (diff
))
6897 return fold_build2_loc (loc
, GE_EXPR
, type
, a
, y
);
6900 /* Fold a sum or difference of at least one multiplication.
6901 Returns the folded tree or NULL if no simplification could be made. */
6904 fold_plusminus_mult_expr (location_t loc
, enum tree_code code
, tree type
,
6905 tree arg0
, tree arg1
)
6907 tree arg00
, arg01
, arg10
, arg11
;
6908 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
6910 /* (A * C) +- (B * C) -> (A+-B) * C.
6911 (A * C) +- A -> A * (C+-1).
6912 We are most concerned about the case where C is a constant,
6913 but other combinations show up during loop reduction. Since
6914 it is not difficult, try all four possibilities. */
6916 if (TREE_CODE (arg0
) == MULT_EXPR
)
6918 arg00
= TREE_OPERAND (arg0
, 0);
6919 arg01
= TREE_OPERAND (arg0
, 1);
6921 else if (TREE_CODE (arg0
) == INTEGER_CST
)
6923 arg00
= build_one_cst (type
);
6928 /* We cannot generate constant 1 for fract. */
6929 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
6932 arg01
= build_one_cst (type
);
6934 if (TREE_CODE (arg1
) == MULT_EXPR
)
6936 arg10
= TREE_OPERAND (arg1
, 0);
6937 arg11
= TREE_OPERAND (arg1
, 1);
6939 else if (TREE_CODE (arg1
) == INTEGER_CST
)
6941 arg10
= build_one_cst (type
);
6942 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6943 the purpose of this canonicalization. */
6944 if (wi::neg_p (arg1
, TYPE_SIGN (TREE_TYPE (arg1
)))
6945 && negate_expr_p (arg1
)
6946 && code
== PLUS_EXPR
)
6948 arg11
= negate_expr (arg1
);
6956 /* We cannot generate constant 1 for fract. */
6957 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
6960 arg11
= build_one_cst (type
);
6964 if (operand_equal_p (arg01
, arg11
, 0))
6965 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
6966 else if (operand_equal_p (arg00
, arg10
, 0))
6967 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
6968 else if (operand_equal_p (arg00
, arg11
, 0))
6969 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
6970 else if (operand_equal_p (arg01
, arg10
, 0))
6971 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
6973 /* No identical multiplicands; see if we can find a common
6974 power-of-two factor in non-power-of-two multiplies. This
6975 can help in multi-dimensional array access. */
6976 else if (tree_fits_shwi_p (arg01
)
6977 && tree_fits_shwi_p (arg11
))
6979 HOST_WIDE_INT int01
, int11
, tmp
;
6982 int01
= tree_to_shwi (arg01
);
6983 int11
= tree_to_shwi (arg11
);
6985 /* Move min of absolute values to int11. */
6986 if (absu_hwi (int01
) < absu_hwi (int11
))
6988 tmp
= int01
, int01
= int11
, int11
= tmp
;
6989 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
6996 if (exact_log2 (absu_hwi (int11
)) > 0 && int01
% int11
== 0
6997 /* The remainder should not be a constant, otherwise we
6998 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6999 increased the number of multiplications necessary. */
7000 && TREE_CODE (arg10
) != INTEGER_CST
)
7002 alt0
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (arg00
), arg00
,
7003 build_int_cst (TREE_TYPE (arg00
),
7008 maybe_same
= alt0
, alt0
= alt1
, alt1
= maybe_same
;
7013 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7014 fold_build2_loc (loc
, code
, type
,
7015 fold_convert_loc (loc
, type
, alt0
),
7016 fold_convert_loc (loc
, type
, alt1
)),
7017 fold_convert_loc (loc
, type
, same
));
7022 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7023 specified by EXPR into the buffer PTR of length LEN bytes.
7024 Return the number of bytes placed in the buffer, or zero
7028 native_encode_int (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7030 tree type
= TREE_TYPE (expr
);
7031 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7032 int byte
, offset
, word
, words
;
7033 unsigned char value
;
7035 if ((off
== -1 && total_bytes
> len
)
7036 || off
>= total_bytes
)
7040 words
= total_bytes
/ UNITS_PER_WORD
;
7042 for (byte
= 0; byte
< total_bytes
; byte
++)
7044 int bitpos
= byte
* BITS_PER_UNIT
;
7045 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7047 value
= wi::extract_uhwi (wi::to_widest (expr
), bitpos
, BITS_PER_UNIT
);
7049 if (total_bytes
> UNITS_PER_WORD
)
7051 word
= byte
/ UNITS_PER_WORD
;
7052 if (WORDS_BIG_ENDIAN
)
7053 word
= (words
- 1) - word
;
7054 offset
= word
* UNITS_PER_WORD
;
7055 if (BYTES_BIG_ENDIAN
)
7056 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7058 offset
+= byte
% UNITS_PER_WORD
;
7061 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
7063 && offset
- off
< len
)
7064 ptr
[offset
- off
] = value
;
7066 return MIN (len
, total_bytes
- off
);
7070 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7071 specified by EXPR into the buffer PTR of length LEN bytes.
7072 Return the number of bytes placed in the buffer, or zero
7076 native_encode_fixed (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7078 tree type
= TREE_TYPE (expr
);
7079 machine_mode mode
= TYPE_MODE (type
);
7080 int total_bytes
= GET_MODE_SIZE (mode
);
7081 FIXED_VALUE_TYPE value
;
7082 tree i_value
, i_type
;
7084 if (total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7087 i_type
= lang_hooks
.types
.type_for_size (GET_MODE_BITSIZE (mode
), 1);
7089 if (NULL_TREE
== i_type
7090 || TYPE_PRECISION (i_type
) != total_bytes
)
7093 value
= TREE_FIXED_CST (expr
);
7094 i_value
= double_int_to_tree (i_type
, value
.data
);
7096 return native_encode_int (i_value
, ptr
, len
, off
);
7100 /* Subroutine of native_encode_expr. Encode the REAL_CST
7101 specified by EXPR into the buffer PTR of length LEN bytes.
7102 Return the number of bytes placed in the buffer, or zero
7106 native_encode_real (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7108 tree type
= TREE_TYPE (expr
);
7109 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7110 int byte
, offset
, word
, words
, bitpos
;
7111 unsigned char value
;
7113 /* There are always 32 bits in each long, no matter the size of
7114 the hosts long. We handle floating point representations with
7118 if ((off
== -1 && total_bytes
> len
)
7119 || off
>= total_bytes
)
7123 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7125 real_to_target (tmp
, TREE_REAL_CST_PTR (expr
), TYPE_MODE (type
));
7127 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7128 bitpos
+= BITS_PER_UNIT
)
7130 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7131 value
= (unsigned char) (tmp
[bitpos
/ 32] >> (bitpos
& 31));
7133 if (UNITS_PER_WORD
< 4)
7135 word
= byte
/ UNITS_PER_WORD
;
7136 if (WORDS_BIG_ENDIAN
)
7137 word
= (words
- 1) - word
;
7138 offset
= word
* UNITS_PER_WORD
;
7139 if (BYTES_BIG_ENDIAN
)
7140 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7142 offset
+= byte
% UNITS_PER_WORD
;
7147 if (BYTES_BIG_ENDIAN
)
7149 /* Reverse bytes within each long, or within the entire float
7150 if it's smaller than a long (for HFmode). */
7151 offset
= MIN (3, total_bytes
- 1) - offset
;
7152 gcc_assert (offset
>= 0);
7155 offset
= offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3);
7157 && offset
- off
< len
)
7158 ptr
[offset
- off
] = value
;
7160 return MIN (len
, total_bytes
- off
);
7163 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7164 specified by EXPR into the buffer PTR of length LEN bytes.
7165 Return the number of bytes placed in the buffer, or zero
7169 native_encode_complex (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7174 part
= TREE_REALPART (expr
);
7175 rsize
= native_encode_expr (part
, ptr
, len
, off
);
7179 part
= TREE_IMAGPART (expr
);
7181 off
= MAX (0, off
- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (part
))));
7182 isize
= native_encode_expr (part
, ptr
+rsize
, len
-rsize
, off
);
7186 return rsize
+ isize
;
7190 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7191 specified by EXPR into the buffer PTR of length LEN bytes.
7192 Return the number of bytes placed in the buffer, or zero
7196 native_encode_vector (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7203 count
= VECTOR_CST_NELTS (expr
);
7204 itype
= TREE_TYPE (TREE_TYPE (expr
));
7205 size
= GET_MODE_SIZE (TYPE_MODE (itype
));
7206 for (i
= 0; i
< count
; i
++)
7213 elem
= VECTOR_CST_ELT (expr
, i
);
7214 int res
= native_encode_expr (elem
, ptr
+offset
, len
-offset
, off
);
7215 if ((off
== -1 && res
!= size
)
7228 /* Subroutine of native_encode_expr. Encode the STRING_CST
7229 specified by EXPR into the buffer PTR of length LEN bytes.
7230 Return the number of bytes placed in the buffer, or zero
7234 native_encode_string (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7236 tree type
= TREE_TYPE (expr
);
7237 HOST_WIDE_INT total_bytes
;
7239 if (TREE_CODE (type
) != ARRAY_TYPE
7240 || TREE_CODE (TREE_TYPE (type
)) != INTEGER_TYPE
7241 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))) != BITS_PER_UNIT
7242 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type
)))
7244 total_bytes
= tree_to_shwi (TYPE_SIZE_UNIT (type
));
7245 if ((off
== -1 && total_bytes
> len
)
7246 || off
>= total_bytes
)
7250 if (TREE_STRING_LENGTH (expr
) - off
< MIN (total_bytes
, len
))
7253 if (off
< TREE_STRING_LENGTH (expr
))
7255 written
= MIN (len
, TREE_STRING_LENGTH (expr
) - off
);
7256 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, written
);
7258 memset (ptr
+ written
, 0,
7259 MIN (total_bytes
- written
, len
- written
));
7262 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, MIN (total_bytes
, len
));
7263 return MIN (total_bytes
- off
, len
);
7267 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7268 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7269 buffer PTR of length LEN bytes. If OFF is not -1 then start
7270 the encoding at byte offset OFF and encode at most LEN bytes.
7271 Return the number of bytes placed in the buffer, or zero upon failure. */
7274 native_encode_expr (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7276 /* We don't support starting at negative offset and -1 is special. */
7280 switch (TREE_CODE (expr
))
7283 return native_encode_int (expr
, ptr
, len
, off
);
7286 return native_encode_real (expr
, ptr
, len
, off
);
7289 return native_encode_fixed (expr
, ptr
, len
, off
);
7292 return native_encode_complex (expr
, ptr
, len
, off
);
7295 return native_encode_vector (expr
, ptr
, len
, off
);
7298 return native_encode_string (expr
, ptr
, len
, off
);
7306 /* Subroutine of native_interpret_expr. Interpret the contents of
7307 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7308 If the buffer cannot be interpreted, return NULL_TREE. */
7311 native_interpret_int (tree type
, const unsigned char *ptr
, int len
)
7313 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7315 if (total_bytes
> len
7316 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7319 wide_int result
= wi::from_buffer (ptr
, total_bytes
);
7321 return wide_int_to_tree (type
, result
);
7325 /* Subroutine of native_interpret_expr. Interpret the contents of
7326 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7327 If the buffer cannot be interpreted, return NULL_TREE. */
7330 native_interpret_fixed (tree type
, const unsigned char *ptr
, int len
)
7332 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7334 FIXED_VALUE_TYPE fixed_value
;
7336 if (total_bytes
> len
7337 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7340 result
= double_int::from_buffer (ptr
, total_bytes
);
7341 fixed_value
= fixed_from_double_int (result
, TYPE_MODE (type
));
7343 return build_fixed (type
, fixed_value
);
7347 /* Subroutine of native_interpret_expr. Interpret the contents of
7348 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7349 If the buffer cannot be interpreted, return NULL_TREE. */
7352 native_interpret_real (tree type
, const unsigned char *ptr
, int len
)
7354 machine_mode mode
= TYPE_MODE (type
);
7355 int total_bytes
= GET_MODE_SIZE (mode
);
7356 unsigned char value
;
7357 /* There are always 32 bits in each long, no matter the size of
7358 the hosts long. We handle floating point representations with
7363 total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7364 if (total_bytes
> len
|| total_bytes
> 24)
7366 int words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7368 memset (tmp
, 0, sizeof (tmp
));
7369 for (int bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7370 bitpos
+= BITS_PER_UNIT
)
7372 /* Both OFFSET and BYTE index within a long;
7373 bitpos indexes the whole float. */
7374 int offset
, byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7375 if (UNITS_PER_WORD
< 4)
7377 int word
= byte
/ UNITS_PER_WORD
;
7378 if (WORDS_BIG_ENDIAN
)
7379 word
= (words
- 1) - word
;
7380 offset
= word
* UNITS_PER_WORD
;
7381 if (BYTES_BIG_ENDIAN
)
7382 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7384 offset
+= byte
% UNITS_PER_WORD
;
7389 if (BYTES_BIG_ENDIAN
)
7391 /* Reverse bytes within each long, or within the entire float
7392 if it's smaller than a long (for HFmode). */
7393 offset
= MIN (3, total_bytes
- 1) - offset
;
7394 gcc_assert (offset
>= 0);
7397 value
= ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)];
7399 tmp
[bitpos
/ 32] |= (unsigned long)value
<< (bitpos
& 31);
7402 real_from_target (&r
, tmp
, mode
);
7403 return build_real (type
, r
);
7407 /* Subroutine of native_interpret_expr. Interpret the contents of
7408 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7409 If the buffer cannot be interpreted, return NULL_TREE. */
7412 native_interpret_complex (tree type
, const unsigned char *ptr
, int len
)
7414 tree etype
, rpart
, ipart
;
7417 etype
= TREE_TYPE (type
);
7418 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7421 rpart
= native_interpret_expr (etype
, ptr
, size
);
7424 ipart
= native_interpret_expr (etype
, ptr
+size
, size
);
7427 return build_complex (type
, rpart
, ipart
);
7431 /* Subroutine of native_interpret_expr. Interpret the contents of
7432 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7433 If the buffer cannot be interpreted, return NULL_TREE. */
7436 native_interpret_vector (tree type
, const unsigned char *ptr
, int len
)
7442 etype
= TREE_TYPE (type
);
7443 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7444 count
= TYPE_VECTOR_SUBPARTS (type
);
7445 if (size
* count
> len
)
7448 elements
= XALLOCAVEC (tree
, count
);
7449 for (i
= count
- 1; i
>= 0; i
--)
7451 elem
= native_interpret_expr (etype
, ptr
+(i
*size
), size
);
7456 return build_vector (type
, elements
);
7460 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7461 the buffer PTR of length LEN as a constant of type TYPE. For
7462 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7463 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7464 return NULL_TREE. */
7467 native_interpret_expr (tree type
, const unsigned char *ptr
, int len
)
7469 switch (TREE_CODE (type
))
7475 case REFERENCE_TYPE
:
7476 return native_interpret_int (type
, ptr
, len
);
7479 return native_interpret_real (type
, ptr
, len
);
7481 case FIXED_POINT_TYPE
:
7482 return native_interpret_fixed (type
, ptr
, len
);
7485 return native_interpret_complex (type
, ptr
, len
);
7488 return native_interpret_vector (type
, ptr
, len
);
7495 /* Returns true if we can interpret the contents of a native encoding
7499 can_native_interpret_type_p (tree type
)
7501 switch (TREE_CODE (type
))
7507 case REFERENCE_TYPE
:
7508 case FIXED_POINT_TYPE
:
7518 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7519 TYPE at compile-time. If we're unable to perform the conversion
7520 return NULL_TREE. */
7523 fold_view_convert_expr (tree type
, tree expr
)
7525 /* We support up to 512-bit values (for V8DFmode). */
7526 unsigned char buffer
[64];
7529 /* Check that the host and target are sane. */
7530 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
7533 len
= native_encode_expr (expr
, buffer
, sizeof (buffer
));
7537 return native_interpret_expr (type
, buffer
, len
);
7540 /* Build an expression for the address of T. Folds away INDIRECT_REF
7541 to avoid confusing the gimplify process. */
7544 build_fold_addr_expr_with_type_loc (location_t loc
, tree t
, tree ptrtype
)
7546 /* The size of the object is not relevant when talking about its address. */
7547 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
7548 t
= TREE_OPERAND (t
, 0);
7550 if (TREE_CODE (t
) == INDIRECT_REF
)
7552 t
= TREE_OPERAND (t
, 0);
7554 if (TREE_TYPE (t
) != ptrtype
)
7555 t
= build1_loc (loc
, NOP_EXPR
, ptrtype
, t
);
7557 else if (TREE_CODE (t
) == MEM_REF
7558 && integer_zerop (TREE_OPERAND (t
, 1)))
7559 return TREE_OPERAND (t
, 0);
7560 else if (TREE_CODE (t
) == MEM_REF
7561 && TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
7562 return fold_binary (POINTER_PLUS_EXPR
, ptrtype
,
7563 TREE_OPERAND (t
, 0),
7564 convert_to_ptrofftype (TREE_OPERAND (t
, 1)));
7565 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
7567 t
= build_fold_addr_expr_loc (loc
, TREE_OPERAND (t
, 0));
7569 if (TREE_TYPE (t
) != ptrtype
)
7570 t
= fold_convert_loc (loc
, ptrtype
, t
);
7573 t
= build1_loc (loc
, ADDR_EXPR
, ptrtype
, t
);
7578 /* Build an expression for the address of T. */
7581 build_fold_addr_expr_loc (location_t loc
, tree t
)
7583 tree ptrtype
= build_pointer_type (TREE_TYPE (t
));
7585 return build_fold_addr_expr_with_type_loc (loc
, t
, ptrtype
);
7588 /* Fold a unary expression of code CODE and type TYPE with operand
7589 OP0. Return the folded expression if folding is successful.
7590 Otherwise, return NULL_TREE. */
7593 fold_unary_loc (location_t loc
, enum tree_code code
, tree type
, tree op0
)
7597 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
7599 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
7600 && TREE_CODE_LENGTH (code
) == 1);
7605 if (CONVERT_EXPR_CODE_P (code
)
7606 || code
== FLOAT_EXPR
|| code
== ABS_EXPR
|| code
== NEGATE_EXPR
)
7608 /* Don't use STRIP_NOPS, because signedness of argument type
7610 STRIP_SIGN_NOPS (arg0
);
7614 /* Strip any conversions that don't change the mode. This
7615 is safe for every expression, except for a comparison
7616 expression because its signedness is derived from its
7619 Note that this is done as an internal manipulation within
7620 the constant folder, in order to find the simplest
7621 representation of the arguments so that their form can be
7622 studied. In any cases, the appropriate type conversions
7623 should be put back in the tree that will get out of the
7628 if (CONSTANT_CLASS_P (arg0
))
7630 tree tem
= const_unop (code
, type
, arg0
);
7633 if (TREE_TYPE (tem
) != type
)
7634 tem
= fold_convert_loc (loc
, type
, tem
);
7640 tem
= generic_simplify (loc
, code
, type
, op0
);
7644 if (TREE_CODE_CLASS (code
) == tcc_unary
)
7646 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
7647 return build2 (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7648 fold_build1_loc (loc
, code
, type
,
7649 fold_convert_loc (loc
, TREE_TYPE (op0
),
7650 TREE_OPERAND (arg0
, 1))));
7651 else if (TREE_CODE (arg0
) == COND_EXPR
)
7653 tree arg01
= TREE_OPERAND (arg0
, 1);
7654 tree arg02
= TREE_OPERAND (arg0
, 2);
7655 if (! VOID_TYPE_P (TREE_TYPE (arg01
)))
7656 arg01
= fold_build1_loc (loc
, code
, type
,
7657 fold_convert_loc (loc
,
7658 TREE_TYPE (op0
), arg01
));
7659 if (! VOID_TYPE_P (TREE_TYPE (arg02
)))
7660 arg02
= fold_build1_loc (loc
, code
, type
,
7661 fold_convert_loc (loc
,
7662 TREE_TYPE (op0
), arg02
));
7663 tem
= fold_build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7666 /* If this was a conversion, and all we did was to move into
7667 inside the COND_EXPR, bring it back out. But leave it if
7668 it is a conversion from integer to integer and the
7669 result precision is no wider than a word since such a
7670 conversion is cheap and may be optimized away by combine,
7671 while it couldn't if it were outside the COND_EXPR. Then return
7672 so we don't get into an infinite recursion loop taking the
7673 conversion out and then back in. */
7675 if ((CONVERT_EXPR_CODE_P (code
)
7676 || code
== NON_LVALUE_EXPR
)
7677 && TREE_CODE (tem
) == COND_EXPR
7678 && TREE_CODE (TREE_OPERAND (tem
, 1)) == code
7679 && TREE_CODE (TREE_OPERAND (tem
, 2)) == code
7680 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 1))
7681 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 2))
7682 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))
7683 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 2), 0)))
7684 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7686 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))))
7687 && TYPE_PRECISION (TREE_TYPE (tem
)) <= BITS_PER_WORD
)
7688 || flag_syntax_only
))
7689 tem
= build1_loc (loc
, code
, type
,
7691 TREE_TYPE (TREE_OPERAND
7692 (TREE_OPERAND (tem
, 1), 0)),
7693 TREE_OPERAND (tem
, 0),
7694 TREE_OPERAND (TREE_OPERAND (tem
, 1), 0),
7695 TREE_OPERAND (TREE_OPERAND (tem
, 2),
7703 case NON_LVALUE_EXPR
:
7704 if (!maybe_lvalue_p (op0
))
7705 return fold_convert_loc (loc
, type
, op0
);
7710 case FIX_TRUNC_EXPR
:
7711 if (COMPARISON_CLASS_P (op0
))
7713 /* If we have (type) (a CMP b) and type is an integral type, return
7714 new expression involving the new type. Canonicalize
7715 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7717 Do not fold the result as that would not simplify further, also
7718 folding again results in recursions. */
7719 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
7720 return build2_loc (loc
, TREE_CODE (op0
), type
,
7721 TREE_OPERAND (op0
, 0),
7722 TREE_OPERAND (op0
, 1));
7723 else if (!INTEGRAL_TYPE_P (type
) && !VOID_TYPE_P (type
)
7724 && TREE_CODE (type
) != VECTOR_TYPE
)
7725 return build3_loc (loc
, COND_EXPR
, type
, op0
,
7726 constant_boolean_node (true, type
),
7727 constant_boolean_node (false, type
));
7730 /* Handle (T *)&A.B.C for A being of type T and B and C
7731 living at offset zero. This occurs frequently in
7732 C++ upcasting and then accessing the base. */
7733 if (TREE_CODE (op0
) == ADDR_EXPR
7734 && POINTER_TYPE_P (type
)
7735 && handled_component_p (TREE_OPERAND (op0
, 0)))
7737 HOST_WIDE_INT bitsize
, bitpos
;
7740 int unsignedp
, reversep
, volatilep
;
7742 = get_inner_reference (TREE_OPERAND (op0
, 0), &bitsize
, &bitpos
,
7743 &offset
, &mode
, &unsignedp
, &reversep
,
7745 /* If the reference was to a (constant) zero offset, we can use
7746 the address of the base if it has the same base type
7747 as the result type and the pointer type is unqualified. */
7748 if (! offset
&& bitpos
== 0
7749 && (TYPE_MAIN_VARIANT (TREE_TYPE (type
))
7750 == TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
7751 && TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
7752 return fold_convert_loc (loc
, type
,
7753 build_fold_addr_expr_loc (loc
, base
));
7756 if (TREE_CODE (op0
) == MODIFY_EXPR
7757 && TREE_CONSTANT (TREE_OPERAND (op0
, 1))
7758 /* Detect assigning a bitfield. */
7759 && !(TREE_CODE (TREE_OPERAND (op0
, 0)) == COMPONENT_REF
7761 (TREE_OPERAND (TREE_OPERAND (op0
, 0), 1))))
7763 /* Don't leave an assignment inside a conversion
7764 unless assigning a bitfield. */
7765 tem
= fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 1));
7766 /* First do the assignment, then return converted constant. */
7767 tem
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (tem
), op0
, tem
);
7768 TREE_NO_WARNING (tem
) = 1;
7769 TREE_USED (tem
) = 1;
7773 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7774 constants (if x has signed type, the sign bit cannot be set
7775 in c). This folds extension into the BIT_AND_EXPR.
7776 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7777 very likely don't have maximal range for their precision and this
7778 transformation effectively doesn't preserve non-maximal ranges. */
7779 if (TREE_CODE (type
) == INTEGER_TYPE
7780 && TREE_CODE (op0
) == BIT_AND_EXPR
7781 && TREE_CODE (TREE_OPERAND (op0
, 1)) == INTEGER_CST
)
7783 tree and_expr
= op0
;
7784 tree and0
= TREE_OPERAND (and_expr
, 0);
7785 tree and1
= TREE_OPERAND (and_expr
, 1);
7788 if (TYPE_UNSIGNED (TREE_TYPE (and_expr
))
7789 || (TYPE_PRECISION (type
)
7790 <= TYPE_PRECISION (TREE_TYPE (and_expr
))))
7792 else if (TYPE_PRECISION (TREE_TYPE (and1
))
7793 <= HOST_BITS_PER_WIDE_INT
7794 && tree_fits_uhwi_p (and1
))
7796 unsigned HOST_WIDE_INT cst
;
7798 cst
= tree_to_uhwi (and1
);
7799 cst
&= HOST_WIDE_INT_M1U
7800 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
7801 change
= (cst
== 0);
7803 && !flag_syntax_only
7804 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0
)))
7807 tree uns
= unsigned_type_for (TREE_TYPE (and0
));
7808 and0
= fold_convert_loc (loc
, uns
, and0
);
7809 and1
= fold_convert_loc (loc
, uns
, and1
);
7814 tem
= force_fit_type (type
, wi::to_widest (and1
), 0,
7815 TREE_OVERFLOW (and1
));
7816 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
7817 fold_convert_loc (loc
, type
, and0
), tem
);
7821 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7822 cast (T1)X will fold away. We assume that this happens when X itself
7824 if (POINTER_TYPE_P (type
)
7825 && TREE_CODE (arg0
) == POINTER_PLUS_EXPR
7826 && CONVERT_EXPR_P (TREE_OPERAND (arg0
, 0)))
7828 tree arg00
= TREE_OPERAND (arg0
, 0);
7829 tree arg01
= TREE_OPERAND (arg0
, 1);
7831 return fold_build_pointer_plus_loc
7832 (loc
, fold_convert_loc (loc
, type
, arg00
), arg01
);
7835 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7836 of the same precision, and X is an integer type not narrower than
7837 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7838 if (INTEGRAL_TYPE_P (type
)
7839 && TREE_CODE (op0
) == BIT_NOT_EXPR
7840 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7841 && CONVERT_EXPR_P (TREE_OPERAND (op0
, 0))
7842 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
7844 tem
= TREE_OPERAND (TREE_OPERAND (op0
, 0), 0);
7845 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7846 && TYPE_PRECISION (type
) <= TYPE_PRECISION (TREE_TYPE (tem
)))
7847 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
7848 fold_convert_loc (loc
, type
, tem
));
7851 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7852 type of X and Y (integer types only). */
7853 if (INTEGRAL_TYPE_P (type
)
7854 && TREE_CODE (op0
) == MULT_EXPR
7855 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7856 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7858 /* Be careful not to introduce new overflows. */
7860 if (TYPE_OVERFLOW_WRAPS (type
))
7863 mult_type
= unsigned_type_for (type
);
7865 if (TYPE_PRECISION (mult_type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7867 tem
= fold_build2_loc (loc
, MULT_EXPR
, mult_type
,
7868 fold_convert_loc (loc
, mult_type
,
7869 TREE_OPERAND (op0
, 0)),
7870 fold_convert_loc (loc
, mult_type
,
7871 TREE_OPERAND (op0
, 1)));
7872 return fold_convert_loc (loc
, type
, tem
);
7878 case VIEW_CONVERT_EXPR
:
7879 if (TREE_CODE (op0
) == MEM_REF
)
7881 if (TYPE_ALIGN (TREE_TYPE (op0
)) != TYPE_ALIGN (type
))
7882 type
= build_aligned_type (type
, TYPE_ALIGN (TREE_TYPE (op0
)));
7883 tem
= fold_build2_loc (loc
, MEM_REF
, type
,
7884 TREE_OPERAND (op0
, 0), TREE_OPERAND (op0
, 1));
7885 REF_REVERSE_STORAGE_ORDER (tem
) = REF_REVERSE_STORAGE_ORDER (op0
);
7892 tem
= fold_negate_expr (loc
, arg0
);
7894 return fold_convert_loc (loc
, type
, tem
);
7898 /* Convert fabs((double)float) into (double)fabsf(float). */
7899 if (TREE_CODE (arg0
) == NOP_EXPR
7900 && TREE_CODE (type
) == REAL_TYPE
)
7902 tree targ0
= strip_float_extensions (arg0
);
7904 return fold_convert_loc (loc
, type
,
7905 fold_build1_loc (loc
, ABS_EXPR
,
7912 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
7913 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
7914 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
7915 fold_convert_loc (loc
, type
,
7916 TREE_OPERAND (arg0
, 0)))))
7917 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, tem
,
7918 fold_convert_loc (loc
, type
,
7919 TREE_OPERAND (arg0
, 1)));
7920 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
7921 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
7922 fold_convert_loc (loc
, type
,
7923 TREE_OPERAND (arg0
, 1)))))
7924 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
7925 fold_convert_loc (loc
, type
,
7926 TREE_OPERAND (arg0
, 0)), tem
);
7930 case TRUTH_NOT_EXPR
:
7931 /* Note that the operand of this must be an int
7932 and its values must be 0 or 1.
7933 ("true" is a fixed value perhaps depending on the language,
7934 but we don't handle values other than 1 correctly yet.) */
7935 tem
= fold_truth_not_expr (loc
, arg0
);
7938 return fold_convert_loc (loc
, type
, tem
);
7941 /* Fold *&X to X if X is an lvalue. */
7942 if (TREE_CODE (op0
) == ADDR_EXPR
)
7944 tree op00
= TREE_OPERAND (op0
, 0);
7945 if ((TREE_CODE (op00
) == VAR_DECL
7946 || TREE_CODE (op00
) == PARM_DECL
7947 || TREE_CODE (op00
) == RESULT_DECL
)
7948 && !TREE_READONLY (op00
))
7955 } /* switch (code) */
7959 /* If the operation was a conversion do _not_ mark a resulting constant
7960 with TREE_OVERFLOW if the original constant was not. These conversions
7961 have implementation defined behavior and retaining the TREE_OVERFLOW
7962 flag here would confuse later passes such as VRP. */
7964 fold_unary_ignore_overflow_loc (location_t loc
, enum tree_code code
,
7965 tree type
, tree op0
)
7967 tree res
= fold_unary_loc (loc
, code
, type
, op0
);
7969 && TREE_CODE (res
) == INTEGER_CST
7970 && TREE_CODE (op0
) == INTEGER_CST
7971 && CONVERT_EXPR_CODE_P (code
))
7972 TREE_OVERFLOW (res
) = TREE_OVERFLOW (op0
);
7977 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
7978 operands OP0 and OP1. LOC is the location of the resulting expression.
7979 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
7980 Return the folded expression if folding is successful. Otherwise,
7981 return NULL_TREE. */
7983 fold_truth_andor (location_t loc
, enum tree_code code
, tree type
,
7984 tree arg0
, tree arg1
, tree op0
, tree op1
)
7988 /* We only do these simplifications if we are optimizing. */
7992 /* Check for things like (A || B) && (A || C). We can convert this
7993 to A || (B && C). Note that either operator can be any of the four
7994 truth and/or operations and the transformation will still be
7995 valid. Also note that we only care about order for the
7996 ANDIF and ORIF operators. If B contains side effects, this
7997 might change the truth-value of A. */
7998 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
7999 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
8000 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
8001 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
8002 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
8003 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
8005 tree a00
= TREE_OPERAND (arg0
, 0);
8006 tree a01
= TREE_OPERAND (arg0
, 1);
8007 tree a10
= TREE_OPERAND (arg1
, 0);
8008 tree a11
= TREE_OPERAND (arg1
, 1);
8009 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
8010 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
8011 && (code
== TRUTH_AND_EXPR
8012 || code
== TRUTH_OR_EXPR
));
8014 if (operand_equal_p (a00
, a10
, 0))
8015 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8016 fold_build2_loc (loc
, code
, type
, a01
, a11
));
8017 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
8018 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8019 fold_build2_loc (loc
, code
, type
, a01
, a10
));
8020 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
8021 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a01
,
8022 fold_build2_loc (loc
, code
, type
, a00
, a11
));
8024 /* This case if tricky because we must either have commutative
8025 operators or else A10 must not have side-effects. */
8027 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
8028 && operand_equal_p (a01
, a11
, 0))
8029 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
8030 fold_build2_loc (loc
, code
, type
, a00
, a10
),
8034 /* See if we can build a range comparison. */
8035 if (0 != (tem
= fold_range_test (loc
, code
, type
, op0
, op1
)))
8038 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
)
8039 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
))
8041 tem
= merge_truthop_with_opposite_arm (loc
, arg0
, arg1
, true);
8043 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
8046 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ORIF_EXPR
)
8047 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ANDIF_EXPR
))
8049 tem
= merge_truthop_with_opposite_arm (loc
, arg1
, arg0
, false);
8051 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
8054 /* Check for the possibility of merging component references. If our
8055 lhs is another similar operation, try to merge its rhs with our
8056 rhs. Then try to merge our lhs and rhs. */
8057 if (TREE_CODE (arg0
) == code
8058 && 0 != (tem
= fold_truth_andor_1 (loc
, code
, type
,
8059 TREE_OPERAND (arg0
, 1), arg1
)))
8060 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
8062 if ((tem
= fold_truth_andor_1 (loc
, code
, type
, arg0
, arg1
)) != 0)
8065 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8066 && (code
== TRUTH_AND_EXPR
8067 || code
== TRUTH_ANDIF_EXPR
8068 || code
== TRUTH_OR_EXPR
8069 || code
== TRUTH_ORIF_EXPR
))
8071 enum tree_code ncode
, icode
;
8073 ncode
= (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_AND_EXPR
)
8074 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
;
8075 icode
= ncode
== TRUTH_AND_EXPR
? TRUTH_ANDIF_EXPR
: TRUTH_ORIF_EXPR
;
8077 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8078 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8079 We don't want to pack more than two leafs to a non-IF AND/OR
8081 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8082 equal to IF-CODE, then we don't want to add right-hand operand.
8083 If the inner right-hand side of left-hand operand has
8084 side-effects, or isn't simple, then we can't add to it,
8085 as otherwise we might destroy if-sequence. */
8086 if (TREE_CODE (arg0
) == icode
8087 && simple_operand_p_2 (arg1
)
8088 /* Needed for sequence points to handle trappings, and
8090 && simple_operand_p_2 (TREE_OPERAND (arg0
, 1)))
8092 tem
= fold_build2_loc (loc
, ncode
, type
, TREE_OPERAND (arg0
, 1),
8094 return fold_build2_loc (loc
, icode
, type
, TREE_OPERAND (arg0
, 0),
8097 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8098 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8099 else if (TREE_CODE (arg1
) == icode
8100 && simple_operand_p_2 (arg0
)
8101 /* Needed for sequence points to handle trappings, and
8103 && simple_operand_p_2 (TREE_OPERAND (arg1
, 0)))
8105 tem
= fold_build2_loc (loc
, ncode
, type
,
8106 arg0
, TREE_OPERAND (arg1
, 0));
8107 return fold_build2_loc (loc
, icode
, type
, tem
,
8108 TREE_OPERAND (arg1
, 1));
8110 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8112 For sequence point consistancy, we need to check for trapping,
8113 and side-effects. */
8114 else if (code
== icode
&& simple_operand_p_2 (arg0
)
8115 && simple_operand_p_2 (arg1
))
8116 return fold_build2_loc (loc
, ncode
, type
, arg0
, arg1
);
8122 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8123 by changing CODE to reduce the magnitude of constants involved in
8124 ARG0 of the comparison.
8125 Returns a canonicalized comparison tree if a simplification was
8126 possible, otherwise returns NULL_TREE.
8127 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8128 valid if signed overflow is undefined. */
8131 maybe_canonicalize_comparison_1 (location_t loc
, enum tree_code code
, tree type
,
8132 tree arg0
, tree arg1
,
8133 bool *strict_overflow_p
)
8135 enum tree_code code0
= TREE_CODE (arg0
);
8136 tree t
, cst0
= NULL_TREE
;
8139 /* Match A +- CST code arg1. We can change this only if overflow
8141 if (!((ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8142 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8143 /* In principle pointers also have undefined overflow behavior,
8144 but that causes problems elsewhere. */
8145 && !POINTER_TYPE_P (TREE_TYPE (arg0
))
8146 && (code0
== MINUS_EXPR
8147 || code0
== PLUS_EXPR
)
8148 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
))
8151 /* Identify the constant in arg0 and its sign. */
8152 cst0
= TREE_OPERAND (arg0
, 1);
8153 sgn0
= tree_int_cst_sgn (cst0
);
8155 /* Overflowed constants and zero will cause problems. */
8156 if (integer_zerop (cst0
)
8157 || TREE_OVERFLOW (cst0
))
8160 /* See if we can reduce the magnitude of the constant in
8161 arg0 by changing the comparison code. */
8162 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8164 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8166 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8167 else if (code
== GT_EXPR
8168 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8170 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8171 else if (code
== LE_EXPR
8172 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8174 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8175 else if (code
== GE_EXPR
8176 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8180 *strict_overflow_p
= true;
8182 /* Now build the constant reduced in magnitude. But not if that
8183 would produce one outside of its types range. */
8184 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0
))
8186 && TYPE_MIN_VALUE (TREE_TYPE (cst0
))
8187 && tree_int_cst_equal (cst0
, TYPE_MIN_VALUE (TREE_TYPE (cst0
))))
8189 && TYPE_MAX_VALUE (TREE_TYPE (cst0
))
8190 && tree_int_cst_equal (cst0
, TYPE_MAX_VALUE (TREE_TYPE (cst0
))))))
8193 t
= int_const_binop (sgn0
== -1 ? PLUS_EXPR
: MINUS_EXPR
,
8194 cst0
, build_int_cst (TREE_TYPE (cst0
), 1));
8195 t
= fold_build2_loc (loc
, code0
, TREE_TYPE (arg0
), TREE_OPERAND (arg0
, 0), t
);
8196 t
= fold_convert (TREE_TYPE (arg1
), t
);
8198 return fold_build2_loc (loc
, code
, type
, t
, arg1
);
8201 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8202 overflow further. Try to decrease the magnitude of constants involved
8203 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8204 and put sole constants at the second argument position.
8205 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8208 maybe_canonicalize_comparison (location_t loc
, enum tree_code code
, tree type
,
8209 tree arg0
, tree arg1
)
8212 bool strict_overflow_p
;
8213 const char * const warnmsg
= G_("assuming signed overflow does not occur "
8214 "when reducing constant in comparison");
8216 /* Try canonicalization by simplifying arg0. */
8217 strict_overflow_p
= false;
8218 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg0
, arg1
,
8219 &strict_overflow_p
);
8222 if (strict_overflow_p
)
8223 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8227 /* Try canonicalization by simplifying arg1 using the swapped
8229 code
= swap_tree_comparison (code
);
8230 strict_overflow_p
= false;
8231 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg1
, arg0
,
8232 &strict_overflow_p
);
8233 if (t
&& strict_overflow_p
)
8234 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8238 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8239 space. This is used to avoid issuing overflow warnings for
8240 expressions like &p->x which can not wrap. */
8243 pointer_may_wrap_p (tree base
, tree offset
, HOST_WIDE_INT bitpos
)
8245 if (!POINTER_TYPE_P (TREE_TYPE (base
)))
8252 int precision
= TYPE_PRECISION (TREE_TYPE (base
));
8253 if (offset
== NULL_TREE
)
8254 wi_offset
= wi::zero (precision
);
8255 else if (TREE_CODE (offset
) != INTEGER_CST
|| TREE_OVERFLOW (offset
))
8261 wide_int units
= wi::shwi (bitpos
/ BITS_PER_UNIT
, precision
);
8262 wide_int total
= wi::add (wi_offset
, units
, UNSIGNED
, &overflow
);
8266 if (!wi::fits_uhwi_p (total
))
8269 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (TREE_TYPE (base
)));
8273 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8275 if (TREE_CODE (base
) == ADDR_EXPR
)
8277 HOST_WIDE_INT base_size
;
8279 base_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base
, 0)));
8280 if (base_size
> 0 && size
< base_size
)
8284 return total
.to_uhwi () > (unsigned HOST_WIDE_INT
) size
;
8287 /* Return a positive integer when the symbol DECL is known to have
8288 a nonzero address, zero when it's known not to (e.g., it's a weak
8289 symbol), and a negative integer when the symbol is not yet in the
8290 symbol table and so whether or not its address is zero is unknown. */
8292 maybe_nonzero_address (tree decl
)
8294 if (DECL_P (decl
) && decl_in_symtab_p (decl
))
8295 if (struct symtab_node
*symbol
= symtab_node::get_create (decl
))
8296 return symbol
->nonzero_address ();
8301 /* Subroutine of fold_binary. This routine performs all of the
8302 transformations that are common to the equality/inequality
8303 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8304 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8305 fold_binary should call fold_binary. Fold a comparison with
8306 tree code CODE and type TYPE with operands OP0 and OP1. Return
8307 the folded comparison or NULL_TREE. */
8310 fold_comparison (location_t loc
, enum tree_code code
, tree type
,
8313 const bool equality_code
= (code
== EQ_EXPR
|| code
== NE_EXPR
);
8314 tree arg0
, arg1
, tem
;
8319 STRIP_SIGN_NOPS (arg0
);
8320 STRIP_SIGN_NOPS (arg1
);
8322 /* For comparisons of pointers we can decompose it to a compile time
8323 comparison of the base objects and the offsets into the object.
8324 This requires at least one operand being an ADDR_EXPR or a
8325 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8326 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
8327 && (TREE_CODE (arg0
) == ADDR_EXPR
8328 || TREE_CODE (arg1
) == ADDR_EXPR
8329 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8330 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
8332 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
8333 HOST_WIDE_INT bitsize
, bitpos0
= 0, bitpos1
= 0;
8335 int volatilep
, reversep
, unsignedp
;
8336 bool indirect_base0
= false, indirect_base1
= false;
8338 /* Get base and offset for the access. Strip ADDR_EXPR for
8339 get_inner_reference, but put it back by stripping INDIRECT_REF
8340 off the base object if possible. indirect_baseN will be true
8341 if baseN is not an address but refers to the object itself. */
8343 if (TREE_CODE (arg0
) == ADDR_EXPR
)
8346 = get_inner_reference (TREE_OPERAND (arg0
, 0),
8347 &bitsize
, &bitpos0
, &offset0
, &mode
,
8348 &unsignedp
, &reversep
, &volatilep
);
8349 if (TREE_CODE (base0
) == INDIRECT_REF
)
8350 base0
= TREE_OPERAND (base0
, 0);
8352 indirect_base0
= true;
8354 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
8356 base0
= TREE_OPERAND (arg0
, 0);
8357 STRIP_SIGN_NOPS (base0
);
8358 if (TREE_CODE (base0
) == ADDR_EXPR
)
8361 = get_inner_reference (TREE_OPERAND (base0
, 0),
8362 &bitsize
, &bitpos0
, &offset0
, &mode
,
8363 &unsignedp
, &reversep
, &volatilep
);
8364 if (TREE_CODE (base0
) == INDIRECT_REF
)
8365 base0
= TREE_OPERAND (base0
, 0);
8367 indirect_base0
= true;
8369 if (offset0
== NULL_TREE
|| integer_zerop (offset0
))
8370 offset0
= TREE_OPERAND (arg0
, 1);
8372 offset0
= size_binop (PLUS_EXPR
, offset0
,
8373 TREE_OPERAND (arg0
, 1));
8374 if (TREE_CODE (offset0
) == INTEGER_CST
)
8376 offset_int tem
= wi::sext (wi::to_offset (offset0
),
8377 TYPE_PRECISION (sizetype
));
8378 tem
<<= LOG2_BITS_PER_UNIT
;
8380 if (wi::fits_shwi_p (tem
))
8382 bitpos0
= tem
.to_shwi ();
8383 offset0
= NULL_TREE
;
8389 if (TREE_CODE (arg1
) == ADDR_EXPR
)
8392 = get_inner_reference (TREE_OPERAND (arg1
, 0),
8393 &bitsize
, &bitpos1
, &offset1
, &mode
,
8394 &unsignedp
, &reversep
, &volatilep
);
8395 if (TREE_CODE (base1
) == INDIRECT_REF
)
8396 base1
= TREE_OPERAND (base1
, 0);
8398 indirect_base1
= true;
8400 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
8402 base1
= TREE_OPERAND (arg1
, 0);
8403 STRIP_SIGN_NOPS (base1
);
8404 if (TREE_CODE (base1
) == ADDR_EXPR
)
8407 = get_inner_reference (TREE_OPERAND (base1
, 0),
8408 &bitsize
, &bitpos1
, &offset1
, &mode
,
8409 &unsignedp
, &reversep
, &volatilep
);
8410 if (TREE_CODE (base1
) == INDIRECT_REF
)
8411 base1
= TREE_OPERAND (base1
, 0);
8413 indirect_base1
= true;
8415 if (offset1
== NULL_TREE
|| integer_zerop (offset1
))
8416 offset1
= TREE_OPERAND (arg1
, 1);
8418 offset1
= size_binop (PLUS_EXPR
, offset1
,
8419 TREE_OPERAND (arg1
, 1));
8420 if (TREE_CODE (offset1
) == INTEGER_CST
)
8422 offset_int tem
= wi::sext (wi::to_offset (offset1
),
8423 TYPE_PRECISION (sizetype
));
8424 tem
<<= LOG2_BITS_PER_UNIT
;
8426 if (wi::fits_shwi_p (tem
))
8428 bitpos1
= tem
.to_shwi ();
8429 offset1
= NULL_TREE
;
8434 /* If we have equivalent bases we might be able to simplify. */
8435 if (indirect_base0
== indirect_base1
8436 && operand_equal_p (base0
, base1
,
8437 indirect_base0
? OEP_ADDRESS_OF
: 0))
8439 /* We can fold this expression to a constant if the non-constant
8440 offset parts are equal. */
8441 if ((offset0
== offset1
8442 || (offset0
&& offset1
8443 && operand_equal_p (offset0
, offset1
, 0)))
8446 && (DECL_P (base0
) || CONSTANT_CLASS_P (base0
)))
8447 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8451 && bitpos0
!= bitpos1
8452 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8453 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8454 fold_overflow_warning (("assuming pointer wraparound does not "
8455 "occur when comparing P +- C1 with "
8457 WARN_STRICT_OVERFLOW_CONDITIONAL
);
8462 return constant_boolean_node (bitpos0
== bitpos1
, type
);
8464 return constant_boolean_node (bitpos0
!= bitpos1
, type
);
8466 return constant_boolean_node (bitpos0
< bitpos1
, type
);
8468 return constant_boolean_node (bitpos0
<= bitpos1
, type
);
8470 return constant_boolean_node (bitpos0
>= bitpos1
, type
);
8472 return constant_boolean_node (bitpos0
> bitpos1
, type
);
8476 /* We can simplify the comparison to a comparison of the variable
8477 offset parts if the constant offset parts are equal.
8478 Be careful to use signed sizetype here because otherwise we
8479 mess with array offsets in the wrong way. This is possible
8480 because pointer arithmetic is restricted to retain within an
8481 object and overflow on pointer differences is undefined as of
8482 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8483 else if (bitpos0
== bitpos1
8486 && (DECL_P (base0
) || CONSTANT_CLASS_P (base0
)))
8487 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8489 /* By converting to signed sizetype we cover middle-end pointer
8490 arithmetic which operates on unsigned pointer types of size
8491 type size and ARRAY_REF offsets which are properly sign or
8492 zero extended from their type in case it is narrower than
8494 if (offset0
== NULL_TREE
)
8495 offset0
= build_int_cst (ssizetype
, 0);
8497 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
8498 if (offset1
== NULL_TREE
)
8499 offset1
= build_int_cst (ssizetype
, 0);
8501 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
8504 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8505 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8506 fold_overflow_warning (("assuming pointer wraparound does not "
8507 "occur when comparing P +- C1 with "
8509 WARN_STRICT_OVERFLOW_COMPARISON
);
8511 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
8514 /* For equal offsets we can simplify to a comparison of the
8516 else if (bitpos0
== bitpos1
8518 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
8520 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
8521 && ((offset0
== offset1
)
8522 || (offset0
&& offset1
8523 && operand_equal_p (offset0
, offset1
, 0))))
8526 base0
= build_fold_addr_expr_loc (loc
, base0
);
8528 base1
= build_fold_addr_expr_loc (loc
, base1
);
8529 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
8531 /* Comparison between an ordinary (non-weak) symbol and a null
8532 pointer can be eliminated since such symbols must have a non
8533 null address. In C, relational expressions between pointers
8534 to objects and null pointers are undefined. The results
8535 below follow the C++ rules with the additional property that
8536 every object pointer compares greater than a null pointer.
8538 else if (DECL_P (base0
)
8539 && maybe_nonzero_address (base0
) > 0
8540 /* Avoid folding references to struct members at offset 0 to
8541 prevent tests like '&ptr->firstmember == 0' from getting
8542 eliminated. When ptr is null, although the -> expression
8543 is strictly speaking invalid, GCC retains it as a matter
8544 of QoI. See PR c/44555. */
8545 && (offset0
== NULL_TREE
&& bitpos0
!= 0)
8546 /* The caller guarantees that when one of the arguments is
8547 constant (i.e., null in this case) it is second. */
8548 && integer_zerop (arg1
))
8555 return constant_boolean_node (false, type
);
8559 return constant_boolean_node (true, type
);
8566 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8567 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8568 the resulting offset is smaller in absolute value than the
8569 original one and has the same sign. */
8570 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8571 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
8572 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8573 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8574 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
8575 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
8576 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
8577 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
8579 tree const1
= TREE_OPERAND (arg0
, 1);
8580 tree const2
= TREE_OPERAND (arg1
, 1);
8581 tree variable1
= TREE_OPERAND (arg0
, 0);
8582 tree variable2
= TREE_OPERAND (arg1
, 0);
8584 const char * const warnmsg
= G_("assuming signed overflow does not "
8585 "occur when combining constants around "
8588 /* Put the constant on the side where it doesn't overflow and is
8589 of lower absolute value and of same sign than before. */
8590 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8591 ? MINUS_EXPR
: PLUS_EXPR
,
8593 if (!TREE_OVERFLOW (cst
)
8594 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
)
8595 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const2
))
8597 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8598 return fold_build2_loc (loc
, code
, type
,
8600 fold_build2_loc (loc
, TREE_CODE (arg1
),
8605 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8606 ? MINUS_EXPR
: PLUS_EXPR
,
8608 if (!TREE_OVERFLOW (cst
)
8609 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
)
8610 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const1
))
8612 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8613 return fold_build2_loc (loc
, code
, type
,
8614 fold_build2_loc (loc
, TREE_CODE (arg0
),
8621 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
8625 /* If we are comparing an expression that just has comparisons
8626 of two integer values, arithmetic expressions of those comparisons,
8627 and constants, we can simplify it. There are only three cases
8628 to check: the two values can either be equal, the first can be
8629 greater, or the second can be greater. Fold the expression for
8630 those three values. Since each value must be 0 or 1, we have
8631 eight possibilities, each of which corresponds to the constant 0
8632 or 1 or one of the six possible comparisons.
8634 This handles common cases like (a > b) == 0 but also handles
8635 expressions like ((x > y) - (y > x)) > 0, which supposedly
8636 occur in macroized code. */
8638 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
8640 tree cval1
= 0, cval2
= 0;
8643 if (twoval_comparison_p (arg0
, &cval1
, &cval2
, &save_p
)
8644 /* Don't handle degenerate cases here; they should already
8645 have been handled anyway. */
8646 && cval1
!= 0 && cval2
!= 0
8647 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
8648 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
8649 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
8650 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
8651 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
8652 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
8653 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
8655 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
8656 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
8658 /* We can't just pass T to eval_subst in case cval1 or cval2
8659 was the same as ARG1. */
8662 = fold_build2_loc (loc
, code
, type
,
8663 eval_subst (loc
, arg0
, cval1
, maxval
,
8667 = fold_build2_loc (loc
, code
, type
,
8668 eval_subst (loc
, arg0
, cval1
, maxval
,
8672 = fold_build2_loc (loc
, code
, type
,
8673 eval_subst (loc
, arg0
, cval1
, minval
,
8677 /* All three of these results should be 0 or 1. Confirm they are.
8678 Then use those values to select the proper code to use. */
8680 if (TREE_CODE (high_result
) == INTEGER_CST
8681 && TREE_CODE (equal_result
) == INTEGER_CST
8682 && TREE_CODE (low_result
) == INTEGER_CST
)
8684 /* Make a 3-bit mask with the high-order bit being the
8685 value for `>', the next for '=', and the low for '<'. */
8686 switch ((integer_onep (high_result
) * 4)
8687 + (integer_onep (equal_result
) * 2)
8688 + integer_onep (low_result
))
8692 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
8713 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
8718 tem
= save_expr (build2 (code
, type
, cval1
, cval2
));
8719 SET_EXPR_LOCATION (tem
, loc
);
8722 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
8727 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8728 into a single range test. */
8729 if ((TREE_CODE (arg0
) == TRUNC_DIV_EXPR
8730 || TREE_CODE (arg0
) == EXACT_DIV_EXPR
)
8731 && TREE_CODE (arg1
) == INTEGER_CST
8732 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8733 && !integer_zerop (TREE_OPERAND (arg0
, 1))
8734 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
8735 && !TREE_OVERFLOW (arg1
))
8737 tem
= fold_div_compare (loc
, code
, type
, arg0
, arg1
);
8738 if (tem
!= NULL_TREE
)
8746 /* Subroutine of fold_binary. Optimize complex multiplications of the
8747 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8748 argument EXPR represents the expression "z" of type TYPE. */
8751 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
8753 tree itype
= TREE_TYPE (type
);
8754 tree rpart
, ipart
, tem
;
8756 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
8758 rpart
= TREE_OPERAND (expr
, 0);
8759 ipart
= TREE_OPERAND (expr
, 1);
8761 else if (TREE_CODE (expr
) == COMPLEX_CST
)
8763 rpart
= TREE_REALPART (expr
);
8764 ipart
= TREE_IMAGPART (expr
);
8768 expr
= save_expr (expr
);
8769 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
8770 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
8773 rpart
= save_expr (rpart
);
8774 ipart
= save_expr (ipart
);
8775 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
8776 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
8777 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
8778 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
8779 build_zero_cst (itype
));
8783 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8784 CONSTRUCTOR ARG into array ELTS and return true if successful. */
8787 vec_cst_ctor_to_array (tree arg
, tree
*elts
)
8789 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg
)), i
;
8791 if (TREE_CODE (arg
) == VECTOR_CST
)
8793 for (i
= 0; i
< VECTOR_CST_NELTS (arg
); ++i
)
8794 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
8796 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
8798 constructor_elt
*elt
;
8800 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
8801 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
8804 elts
[i
] = elt
->value
;
8808 for (; i
< nelts
; i
++)
8810 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
8814 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8815 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8816 NULL_TREE otherwise. */
8819 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const unsigned char *sel
)
8821 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8823 bool need_ctor
= false;
8825 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
8826 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
);
8827 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
8828 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
8831 elts
= XALLOCAVEC (tree
, nelts
* 3);
8832 if (!vec_cst_ctor_to_array (arg0
, elts
)
8833 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
))
8836 for (i
= 0; i
< nelts
; i
++)
8838 if (!CONSTANT_CLASS_P (elts
[sel
[i
]]))
8840 elts
[i
+ 2 * nelts
] = unshare_expr (elts
[sel
[i
]]);
8845 vec
<constructor_elt
, va_gc
> *v
;
8846 vec_alloc (v
, nelts
);
8847 for (i
= 0; i
< nelts
; i
++)
8848 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, elts
[2 * nelts
+ i
]);
8849 return build_constructor (type
, v
);
8852 return build_vector (type
, &elts
[2 * nelts
]);
8855 /* Try to fold a pointer difference of type TYPE two address expressions of
8856 array references AREF0 and AREF1 using location LOC. Return a
8857 simplified expression for the difference or NULL_TREE. */
8860 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
8861 tree aref0
, tree aref1
)
8863 tree base0
= TREE_OPERAND (aref0
, 0);
8864 tree base1
= TREE_OPERAND (aref1
, 0);
8865 tree base_offset
= build_int_cst (type
, 0);
8867 /* If the bases are array references as well, recurse. If the bases
8868 are pointer indirections compute the difference of the pointers.
8869 If the bases are equal, we are set. */
8870 if ((TREE_CODE (base0
) == ARRAY_REF
8871 && TREE_CODE (base1
) == ARRAY_REF
8873 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
)))
8874 || (INDIRECT_REF_P (base0
)
8875 && INDIRECT_REF_P (base1
)
8877 = fold_binary_loc (loc
, MINUS_EXPR
, type
,
8878 fold_convert (type
, TREE_OPERAND (base0
, 0)),
8880 TREE_OPERAND (base1
, 0)))))
8881 || operand_equal_p (base0
, base1
, OEP_ADDRESS_OF
))
8883 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
8884 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
8885 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
8886 tree diff
= build2 (MINUS_EXPR
, type
, op0
, op1
);
8887 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
8889 fold_build2_loc (loc
, MULT_EXPR
, type
,
8895 /* If the real or vector real constant CST of type TYPE has an exact
8896 inverse, return it, else return NULL. */
8899 exact_inverse (tree type
, tree cst
)
8902 tree unit_type
, *elts
;
8904 unsigned vec_nelts
, i
;
8906 switch (TREE_CODE (cst
))
8909 r
= TREE_REAL_CST (cst
);
8911 if (exact_real_inverse (TYPE_MODE (type
), &r
))
8912 return build_real (type
, r
);
8917 vec_nelts
= VECTOR_CST_NELTS (cst
);
8918 elts
= XALLOCAVEC (tree
, vec_nelts
);
8919 unit_type
= TREE_TYPE (type
);
8920 mode
= TYPE_MODE (unit_type
);
8922 for (i
= 0; i
< vec_nelts
; i
++)
8924 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
8925 if (!exact_real_inverse (mode
, &r
))
8927 elts
[i
] = build_real (unit_type
, r
);
8930 return build_vector (type
, elts
);
8937 /* Mask out the tz least significant bits of X of type TYPE where
8938 tz is the number of trailing zeroes in Y. */
8940 mask_with_tz (tree type
, const wide_int
&x
, const wide_int
&y
)
8942 int tz
= wi::ctz (y
);
8944 return wi::mask (tz
, true, TYPE_PRECISION (type
)) & x
;
8948 /* Return true when T is an address and is known to be nonzero.
8949 For floating point we further ensure that T is not denormal.
8950 Similar logic is present in nonzero_address in rtlanal.h.
8952 If the return value is based on the assumption that signed overflow
8953 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
8954 change *STRICT_OVERFLOW_P. */
8957 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
8959 tree type
= TREE_TYPE (t
);
8960 enum tree_code code
;
8962 /* Doing something useful for floating point would need more work. */
8963 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
8966 code
= TREE_CODE (t
);
8967 switch (TREE_CODE_CLASS (code
))
8970 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
8973 case tcc_comparison
:
8974 return tree_binary_nonzero_warnv_p (code
, type
,
8975 TREE_OPERAND (t
, 0),
8976 TREE_OPERAND (t
, 1),
8979 case tcc_declaration
:
8981 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
8989 case TRUTH_NOT_EXPR
:
8990 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
8993 case TRUTH_AND_EXPR
:
8995 case TRUTH_XOR_EXPR
:
8996 return tree_binary_nonzero_warnv_p (code
, type
,
8997 TREE_OPERAND (t
, 0),
8998 TREE_OPERAND (t
, 1),
9006 case WITH_SIZE_EXPR
:
9008 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9013 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
9017 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
9022 tree fndecl
= get_callee_fndecl (t
);
9023 if (!fndecl
) return false;
9024 if (flag_delete_null_pointer_checks
&& !flag_check_new
9025 && DECL_IS_OPERATOR_NEW (fndecl
)
9026 && !TREE_NOTHROW (fndecl
))
9028 if (flag_delete_null_pointer_checks
9029 && lookup_attribute ("returns_nonnull",
9030 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
9032 return alloca_call_p (t
);
9041 /* Return true when T is an address and is known to be nonzero.
9042 Handle warnings about undefined signed overflow. */
9045 tree_expr_nonzero_p (tree t
)
9047 bool ret
, strict_overflow_p
;
9049 strict_overflow_p
= false;
9050 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
9051 if (strict_overflow_p
)
9052 fold_overflow_warning (("assuming signed overflow does not occur when "
9053 "determining that expression is always "
9055 WARN_STRICT_OVERFLOW_MISC
);
9059 /* Return true if T is known not to be equal to an integer W. */
9062 expr_not_equal_to (tree t
, const wide_int
&w
)
9064 wide_int min
, max
, nz
;
9065 value_range_type rtype
;
9066 switch (TREE_CODE (t
))
9069 return wi::ne_p (t
, w
);
9072 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
9074 rtype
= get_range_info (t
, &min
, &max
);
9075 if (rtype
== VR_RANGE
)
9077 if (wi::lt_p (max
, w
, TYPE_SIGN (TREE_TYPE (t
))))
9079 if (wi::lt_p (w
, min
, TYPE_SIGN (TREE_TYPE (t
))))
9082 else if (rtype
== VR_ANTI_RANGE
9083 && wi::le_p (min
, w
, TYPE_SIGN (TREE_TYPE (t
)))
9084 && wi::le_p (w
, max
, TYPE_SIGN (TREE_TYPE (t
))))
9086 /* If T has some known zero bits and W has any of those bits set,
9087 then T is known not to be equal to W. */
9088 if (wi::ne_p (wi::zext (wi::bit_and_not (w
, get_nonzero_bits (t
)),
9089 TYPE_PRECISION (TREE_TYPE (t
))), 0))
9098 /* Fold a binary expression of code CODE and type TYPE with operands
9099 OP0 and OP1. LOC is the location of the resulting expression.
9100 Return the folded expression if folding is successful. Otherwise,
9101 return NULL_TREE. */
9104 fold_binary_loc (location_t loc
,
9105 enum tree_code code
, tree type
, tree op0
, tree op1
)
9107 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
9108 tree arg0
, arg1
, tem
;
9109 tree t1
= NULL_TREE
;
9110 bool strict_overflow_p
;
9113 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
9114 && TREE_CODE_LENGTH (code
) == 2
9116 && op1
!= NULL_TREE
);
9121 /* Strip any conversions that don't change the mode. This is
9122 safe for every expression, except for a comparison expression
9123 because its signedness is derived from its operands. So, in
9124 the latter case, only strip conversions that don't change the
9125 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9128 Note that this is done as an internal manipulation within the
9129 constant folder, in order to find the simplest representation
9130 of the arguments so that their form can be studied. In any
9131 cases, the appropriate type conversions should be put back in
9132 the tree that will get out of the constant folder. */
9134 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
9136 STRIP_SIGN_NOPS (arg0
);
9137 STRIP_SIGN_NOPS (arg1
);
9145 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9146 constant but we can't do arithmetic on them. */
9147 if (CONSTANT_CLASS_P (arg0
) && CONSTANT_CLASS_P (arg1
))
9149 tem
= const_binop (code
, type
, arg0
, arg1
);
9150 if (tem
!= NULL_TREE
)
9152 if (TREE_TYPE (tem
) != type
)
9153 tem
= fold_convert_loc (loc
, type
, tem
);
9158 /* If this is a commutative operation, and ARG0 is a constant, move it
9159 to ARG1 to reduce the number of tests below. */
9160 if (commutative_tree_code (code
)
9161 && tree_swap_operands_p (arg0
, arg1
, true))
9162 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
9164 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9165 to ARG1 to reduce the number of tests below. */
9166 if (kind
== tcc_comparison
9167 && tree_swap_operands_p (arg0
, arg1
, true))
9168 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
9170 tem
= generic_simplify (loc
, code
, type
, op0
, op1
);
9174 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9176 First check for cases where an arithmetic operation is applied to a
9177 compound, conditional, or comparison operation. Push the arithmetic
9178 operation inside the compound or conditional to see if any folding
9179 can then be done. Convert comparison to conditional for this purpose.
9180 The also optimizes non-constant cases that used to be done in
9183 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9184 one of the operands is a comparison and the other is a comparison, a
9185 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9186 code below would make the expression more complex. Change it to a
9187 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9188 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9190 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
9191 || code
== EQ_EXPR
|| code
== NE_EXPR
)
9192 && TREE_CODE (type
) != VECTOR_TYPE
9193 && ((truth_value_p (TREE_CODE (arg0
))
9194 && (truth_value_p (TREE_CODE (arg1
))
9195 || (TREE_CODE (arg1
) == BIT_AND_EXPR
9196 && integer_onep (TREE_OPERAND (arg1
, 1)))))
9197 || (truth_value_p (TREE_CODE (arg1
))
9198 && (truth_value_p (TREE_CODE (arg0
))
9199 || (TREE_CODE (arg0
) == BIT_AND_EXPR
9200 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
9202 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
9203 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
9206 fold_convert_loc (loc
, boolean_type_node
, arg0
),
9207 fold_convert_loc (loc
, boolean_type_node
, arg1
));
9209 if (code
== EQ_EXPR
)
9210 tem
= invert_truthvalue_loc (loc
, tem
);
9212 return fold_convert_loc (loc
, type
, tem
);
9215 if (TREE_CODE_CLASS (code
) == tcc_binary
9216 || TREE_CODE_CLASS (code
) == tcc_comparison
)
9218 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
9220 tem
= fold_build2_loc (loc
, code
, type
,
9221 fold_convert_loc (loc
, TREE_TYPE (op0
),
9222 TREE_OPERAND (arg0
, 1)), op1
);
9223 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
9226 if (TREE_CODE (arg1
) == COMPOUND_EXPR
9227 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
9229 tem
= fold_build2_loc (loc
, code
, type
, op0
,
9230 fold_convert_loc (loc
, TREE_TYPE (op1
),
9231 TREE_OPERAND (arg1
, 1)));
9232 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
9236 if (TREE_CODE (arg0
) == COND_EXPR
9237 || TREE_CODE (arg0
) == VEC_COND_EXPR
9238 || COMPARISON_CLASS_P (arg0
))
9240 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9242 /*cond_first_p=*/1);
9243 if (tem
!= NULL_TREE
)
9247 if (TREE_CODE (arg1
) == COND_EXPR
9248 || TREE_CODE (arg1
) == VEC_COND_EXPR
9249 || COMPARISON_CLASS_P (arg1
))
9251 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9253 /*cond_first_p=*/0);
9254 if (tem
!= NULL_TREE
)
9262 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9263 if (TREE_CODE (arg0
) == ADDR_EXPR
9264 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
9266 tree iref
= TREE_OPERAND (arg0
, 0);
9267 return fold_build2 (MEM_REF
, type
,
9268 TREE_OPERAND (iref
, 0),
9269 int_const_binop (PLUS_EXPR
, arg1
,
9270 TREE_OPERAND (iref
, 1)));
9273 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9274 if (TREE_CODE (arg0
) == ADDR_EXPR
9275 && handled_component_p (TREE_OPERAND (arg0
, 0)))
9278 HOST_WIDE_INT coffset
;
9279 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
9283 return fold_build2 (MEM_REF
, type
,
9284 build_fold_addr_expr (base
),
9285 int_const_binop (PLUS_EXPR
, arg1
,
9286 size_int (coffset
)));
9291 case POINTER_PLUS_EXPR
:
9292 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9293 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9294 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
9295 return fold_convert_loc (loc
, type
,
9296 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
9297 fold_convert_loc (loc
, sizetype
,
9299 fold_convert_loc (loc
, sizetype
,
9305 if (INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
9307 /* X + (X / CST) * -CST is X % CST. */
9308 if (TREE_CODE (arg1
) == MULT_EXPR
9309 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
9310 && operand_equal_p (arg0
,
9311 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
9313 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
9314 tree cst1
= TREE_OPERAND (arg1
, 1);
9315 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
9317 if (sum
&& integer_zerop (sum
))
9318 return fold_convert_loc (loc
, type
,
9319 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
9320 TREE_TYPE (arg0
), arg0
,
9325 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9326 one. Make sure the type is not saturating and has the signedness of
9327 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9328 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9329 if ((TREE_CODE (arg0
) == MULT_EXPR
9330 || TREE_CODE (arg1
) == MULT_EXPR
)
9331 && !TYPE_SATURATING (type
)
9332 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9333 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9334 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9336 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9341 if (! FLOAT_TYPE_P (type
))
9343 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9344 (plus (plus (mult) (mult)) (foo)) so that we can
9345 take advantage of the factoring cases below. */
9346 if (ANY_INTEGRAL_TYPE_P (type
)
9347 && TYPE_OVERFLOW_WRAPS (type
)
9348 && (((TREE_CODE (arg0
) == PLUS_EXPR
9349 || TREE_CODE (arg0
) == MINUS_EXPR
)
9350 && TREE_CODE (arg1
) == MULT_EXPR
)
9351 || ((TREE_CODE (arg1
) == PLUS_EXPR
9352 || TREE_CODE (arg1
) == MINUS_EXPR
)
9353 && TREE_CODE (arg0
) == MULT_EXPR
)))
9355 tree parg0
, parg1
, parg
, marg
;
9356 enum tree_code pcode
;
9358 if (TREE_CODE (arg1
) == MULT_EXPR
)
9359 parg
= arg0
, marg
= arg1
;
9361 parg
= arg1
, marg
= arg0
;
9362 pcode
= TREE_CODE (parg
);
9363 parg0
= TREE_OPERAND (parg
, 0);
9364 parg1
= TREE_OPERAND (parg
, 1);
9368 if (TREE_CODE (parg0
) == MULT_EXPR
9369 && TREE_CODE (parg1
) != MULT_EXPR
)
9370 return fold_build2_loc (loc
, pcode
, type
,
9371 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9372 fold_convert_loc (loc
, type
,
9374 fold_convert_loc (loc
, type
,
9376 fold_convert_loc (loc
, type
, parg1
));
9377 if (TREE_CODE (parg0
) != MULT_EXPR
9378 && TREE_CODE (parg1
) == MULT_EXPR
)
9380 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9381 fold_convert_loc (loc
, type
, parg0
),
9382 fold_build2_loc (loc
, pcode
, type
,
9383 fold_convert_loc (loc
, type
, marg
),
9384 fold_convert_loc (loc
, type
,
9390 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9391 to __complex__ ( x, y ). This is not the same for SNaNs or
9392 if signed zeros are involved. */
9393 if (!HONOR_SNANS (element_mode (arg0
))
9394 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9395 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9397 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9398 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9399 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9400 bool arg0rz
= false, arg0iz
= false;
9401 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9402 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9404 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9405 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9406 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9408 tree rp
= arg1r
? arg1r
9409 : build1 (REALPART_EXPR
, rtype
, arg1
);
9410 tree ip
= arg0i
? arg0i
9411 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9412 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9414 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9416 tree rp
= arg0r
? arg0r
9417 : build1 (REALPART_EXPR
, rtype
, arg0
);
9418 tree ip
= arg1i
? arg1i
9419 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
9420 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9425 if (flag_unsafe_math_optimizations
9426 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
9427 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
9428 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
9431 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9432 We associate floats only if the user has specified
9433 -fassociative-math. */
9434 if (flag_associative_math
9435 && TREE_CODE (arg1
) == PLUS_EXPR
9436 && TREE_CODE (arg0
) != MULT_EXPR
)
9438 tree tree10
= TREE_OPERAND (arg1
, 0);
9439 tree tree11
= TREE_OPERAND (arg1
, 1);
9440 if (TREE_CODE (tree11
) == MULT_EXPR
9441 && TREE_CODE (tree10
) == MULT_EXPR
)
9444 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
9445 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
9448 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9449 We associate floats only if the user has specified
9450 -fassociative-math. */
9451 if (flag_associative_math
9452 && TREE_CODE (arg0
) == PLUS_EXPR
9453 && TREE_CODE (arg1
) != MULT_EXPR
)
9455 tree tree00
= TREE_OPERAND (arg0
, 0);
9456 tree tree01
= TREE_OPERAND (arg0
, 1);
9457 if (TREE_CODE (tree01
) == MULT_EXPR
9458 && TREE_CODE (tree00
) == MULT_EXPR
)
9461 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
9462 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
9468 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9469 is a rotate of A by C1 bits. */
9470 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9471 is a rotate of A by B bits. */
9473 enum tree_code code0
, code1
;
9475 code0
= TREE_CODE (arg0
);
9476 code1
= TREE_CODE (arg1
);
9477 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
9478 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
9479 && operand_equal_p (TREE_OPERAND (arg0
, 0),
9480 TREE_OPERAND (arg1
, 0), 0)
9481 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9482 TYPE_UNSIGNED (rtype
))
9483 /* Only create rotates in complete modes. Other cases are not
9484 expanded properly. */
9485 && (element_precision (rtype
)
9486 == GET_MODE_UNIT_PRECISION (TYPE_MODE (rtype
))))
9488 tree tree01
, tree11
;
9489 enum tree_code code01
, code11
;
9491 tree01
= TREE_OPERAND (arg0
, 1);
9492 tree11
= TREE_OPERAND (arg1
, 1);
9493 STRIP_NOPS (tree01
);
9494 STRIP_NOPS (tree11
);
9495 code01
= TREE_CODE (tree01
);
9496 code11
= TREE_CODE (tree11
);
9497 if (code01
== INTEGER_CST
9498 && code11
== INTEGER_CST
9499 && (wi::to_widest (tree01
) + wi::to_widest (tree11
)
9500 == element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)))))
9502 tem
= build2_loc (loc
, LROTATE_EXPR
,
9503 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9504 TREE_OPERAND (arg0
, 0),
9505 code0
== LSHIFT_EXPR
9506 ? TREE_OPERAND (arg0
, 1)
9507 : TREE_OPERAND (arg1
, 1));
9508 return fold_convert_loc (loc
, type
, tem
);
9510 else if (code11
== MINUS_EXPR
)
9512 tree tree110
, tree111
;
9513 tree110
= TREE_OPERAND (tree11
, 0);
9514 tree111
= TREE_OPERAND (tree11
, 1);
9515 STRIP_NOPS (tree110
);
9516 STRIP_NOPS (tree111
);
9517 if (TREE_CODE (tree110
) == INTEGER_CST
9518 && 0 == compare_tree_int (tree110
,
9520 (TREE_TYPE (TREE_OPERAND
9522 && operand_equal_p (tree01
, tree111
, 0))
9524 fold_convert_loc (loc
, type
,
9525 build2 ((code0
== LSHIFT_EXPR
9528 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9529 TREE_OPERAND (arg0
, 0),
9530 TREE_OPERAND (arg0
, 1)));
9532 else if (code01
== MINUS_EXPR
)
9534 tree tree010
, tree011
;
9535 tree010
= TREE_OPERAND (tree01
, 0);
9536 tree011
= TREE_OPERAND (tree01
, 1);
9537 STRIP_NOPS (tree010
);
9538 STRIP_NOPS (tree011
);
9539 if (TREE_CODE (tree010
) == INTEGER_CST
9540 && 0 == compare_tree_int (tree010
,
9542 (TREE_TYPE (TREE_OPERAND
9544 && operand_equal_p (tree11
, tree011
, 0))
9545 return fold_convert_loc
9547 build2 ((code0
!= LSHIFT_EXPR
9550 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9551 TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 1)));
9557 /* In most languages, can't associate operations on floats through
9558 parentheses. Rather than remember where the parentheses were, we
9559 don't associate floats at all, unless the user has specified
9561 And, we need to make sure type is not saturating. */
9563 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
9564 && !TYPE_SATURATING (type
))
9566 tree var0
, con0
, lit0
, minus_lit0
;
9567 tree var1
, con1
, lit1
, minus_lit1
;
9571 /* Split both trees into variables, constants, and literals. Then
9572 associate each group together, the constants with literals,
9573 then the result with variables. This increases the chances of
9574 literals being recombined later and of generating relocatable
9575 expressions for the sum of a constant and literal. */
9576 var0
= split_tree (loc
, arg0
, type
, code
,
9577 &con0
, &lit0
, &minus_lit0
, 0);
9578 var1
= split_tree (loc
, arg1
, type
, code
,
9579 &con1
, &lit1
, &minus_lit1
, code
== MINUS_EXPR
);
9581 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9582 if (code
== MINUS_EXPR
)
9585 /* With undefined overflow prefer doing association in a type
9586 which wraps on overflow, if that is one of the operand types. */
9587 if ((POINTER_TYPE_P (type
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
9588 || (INTEGRAL_TYPE_P (type
) && !TYPE_OVERFLOW_WRAPS (type
)))
9590 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
9591 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
9592 atype
= TREE_TYPE (arg0
);
9593 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9594 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
9595 atype
= TREE_TYPE (arg1
);
9596 gcc_assert (TYPE_PRECISION (atype
) == TYPE_PRECISION (type
));
9599 /* With undefined overflow we can only associate constants with one
9600 variable, and constants whose association doesn't overflow. */
9601 if ((POINTER_TYPE_P (atype
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
9602 || (INTEGRAL_TYPE_P (atype
) && !TYPE_OVERFLOW_WRAPS (atype
)))
9608 bool one_neg
= false;
9610 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
9612 tmp0
= TREE_OPERAND (tmp0
, 0);
9615 if (CONVERT_EXPR_P (tmp0
)
9616 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9617 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9618 <= TYPE_PRECISION (atype
)))
9619 tmp0
= TREE_OPERAND (tmp0
, 0);
9620 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
9622 tmp1
= TREE_OPERAND (tmp1
, 0);
9625 if (CONVERT_EXPR_P (tmp1
)
9626 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9627 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9628 <= TYPE_PRECISION (atype
)))
9629 tmp1
= TREE_OPERAND (tmp1
, 0);
9630 /* The only case we can still associate with two variables
9631 is if they cancel out. */
9633 || !operand_equal_p (tmp0
, tmp1
, 0))
9638 /* Only do something if we found more than two objects. Otherwise,
9639 nothing has changed and we risk infinite recursion. */
9641 && (2 < ((var0
!= 0) + (var1
!= 0)
9642 + (con0
!= 0) + (con1
!= 0)
9643 + (lit0
!= 0) + (lit1
!= 0)
9644 + (minus_lit0
!= 0) + (minus_lit1
!= 0))))
9646 bool any_overflows
= false;
9647 if (lit0
) any_overflows
|= TREE_OVERFLOW (lit0
);
9648 if (lit1
) any_overflows
|= TREE_OVERFLOW (lit1
);
9649 if (minus_lit0
) any_overflows
|= TREE_OVERFLOW (minus_lit0
);
9650 if (minus_lit1
) any_overflows
|= TREE_OVERFLOW (minus_lit1
);
9651 var0
= associate_trees (loc
, var0
, var1
, code
, atype
);
9652 con0
= associate_trees (loc
, con0
, con1
, code
, atype
);
9653 lit0
= associate_trees (loc
, lit0
, lit1
, code
, atype
);
9654 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
,
9657 /* Preserve the MINUS_EXPR if the negative part of the literal is
9658 greater than the positive part. Otherwise, the multiplicative
9659 folding code (i.e extract_muldiv) may be fooled in case
9660 unsigned constants are subtracted, like in the following
9661 example: ((X*2 + 4) - 8U)/2. */
9662 if (minus_lit0
&& lit0
)
9664 if (TREE_CODE (lit0
) == INTEGER_CST
9665 && TREE_CODE (minus_lit0
) == INTEGER_CST
9666 && tree_int_cst_lt (lit0
, minus_lit0
))
9668 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
9674 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
9680 /* Don't introduce overflows through reassociation. */
9682 && ((lit0
&& TREE_OVERFLOW_P (lit0
))
9683 || (minus_lit0
&& TREE_OVERFLOW_P (minus_lit0
))))
9690 fold_convert_loc (loc
, type
,
9691 associate_trees (loc
, var0
, minus_lit0
,
9692 MINUS_EXPR
, atype
));
9695 con0
= associate_trees (loc
, con0
, minus_lit0
,
9698 fold_convert_loc (loc
, type
,
9699 associate_trees (loc
, var0
, con0
,
9704 con0
= associate_trees (loc
, con0
, lit0
, code
, atype
);
9706 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
9714 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9715 if (TREE_CODE (arg0
) == NEGATE_EXPR
9716 && negate_expr_p (op1
)
9717 && reorder_operands_p (arg0
, arg1
))
9718 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
9720 fold_convert_loc (loc
, type
,
9721 TREE_OPERAND (arg0
, 0)));
9723 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9724 __complex__ ( x, -y ). This is not the same for SNaNs or if
9725 signed zeros are involved. */
9726 if (!HONOR_SNANS (element_mode (arg0
))
9727 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9728 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9730 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9731 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9732 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9733 bool arg0rz
= false, arg0iz
= false;
9734 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9735 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9737 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9738 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9739 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9741 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9743 : build1 (REALPART_EXPR
, rtype
, arg1
));
9744 tree ip
= arg0i
? arg0i
9745 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9746 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9748 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9750 tree rp
= arg0r
? arg0r
9751 : build1 (REALPART_EXPR
, rtype
, arg0
);
9752 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9754 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
9755 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9760 /* A - B -> A + (-B) if B is easily negatable. */
9761 if (negate_expr_p (op1
)
9762 && ! TYPE_OVERFLOW_SANITIZED (type
)
9763 && ((FLOAT_TYPE_P (type
)
9764 /* Avoid this transformation if B is a positive REAL_CST. */
9765 && (TREE_CODE (op1
) != REAL_CST
9766 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (op1
))))
9767 || INTEGRAL_TYPE_P (type
)))
9768 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9769 fold_convert_loc (loc
, type
, arg0
),
9772 /* Fold &a[i] - &a[j] to i-j. */
9773 if (TREE_CODE (arg0
) == ADDR_EXPR
9774 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
9775 && TREE_CODE (arg1
) == ADDR_EXPR
9776 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
9778 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
9779 TREE_OPERAND (arg0
, 0),
9780 TREE_OPERAND (arg1
, 0));
9785 if (FLOAT_TYPE_P (type
)
9786 && flag_unsafe_math_optimizations
9787 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
9788 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
9789 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
9792 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9793 one. Make sure the type is not saturating and has the signedness of
9794 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9795 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9796 if ((TREE_CODE (arg0
) == MULT_EXPR
9797 || TREE_CODE (arg1
) == MULT_EXPR
)
9798 && !TYPE_SATURATING (type
)
9799 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9800 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9801 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9803 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9811 if (! FLOAT_TYPE_P (type
))
9813 /* Transform x * -C into -x * C if x is easily negatable. */
9814 if (TREE_CODE (op1
) == INTEGER_CST
9815 && tree_int_cst_sgn (op1
) == -1
9816 && negate_expr_p (op0
)
9817 && (tem
= negate_expr (op1
)) != op1
9818 && ! TREE_OVERFLOW (tem
))
9819 return fold_build2_loc (loc
, MULT_EXPR
, type
,
9820 fold_convert_loc (loc
, type
,
9821 negate_expr (op0
)), tem
);
9823 strict_overflow_p
= false;
9824 if (TREE_CODE (arg1
) == INTEGER_CST
9825 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
9826 &strict_overflow_p
)))
9828 if (strict_overflow_p
)
9829 fold_overflow_warning (("assuming signed overflow does not "
9830 "occur when simplifying "
9832 WARN_STRICT_OVERFLOW_MISC
);
9833 return fold_convert_loc (loc
, type
, tem
);
9836 /* Optimize z * conj(z) for integer complex numbers. */
9837 if (TREE_CODE (arg0
) == CONJ_EXPR
9838 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
9839 return fold_mult_zconjz (loc
, type
, arg1
);
9840 if (TREE_CODE (arg1
) == CONJ_EXPR
9841 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
9842 return fold_mult_zconjz (loc
, type
, arg0
);
9846 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
9847 This is not the same for NaNs or if signed zeros are
9849 if (!HONOR_NANS (arg0
)
9850 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9851 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
9852 && TREE_CODE (arg1
) == COMPLEX_CST
9853 && real_zerop (TREE_REALPART (arg1
)))
9855 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9856 if (real_onep (TREE_IMAGPART (arg1
)))
9858 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
9859 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
9861 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
9862 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
9864 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
9865 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
9866 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
9870 /* Optimize z * conj(z) for floating point complex numbers.
9871 Guarded by flag_unsafe_math_optimizations as non-finite
9872 imaginary components don't produce scalar results. */
9873 if (flag_unsafe_math_optimizations
9874 && TREE_CODE (arg0
) == CONJ_EXPR
9875 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
9876 return fold_mult_zconjz (loc
, type
, arg1
);
9877 if (flag_unsafe_math_optimizations
9878 && TREE_CODE (arg1
) == CONJ_EXPR
9879 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
9880 return fold_mult_zconjz (loc
, type
, arg0
);
9885 /* Canonicalize (X & C1) | C2. */
9886 if (TREE_CODE (arg0
) == BIT_AND_EXPR
9887 && TREE_CODE (arg1
) == INTEGER_CST
9888 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
9890 int width
= TYPE_PRECISION (type
), w
;
9891 wide_int c1
= TREE_OPERAND (arg0
, 1);
9894 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
9895 if ((c1
& c2
) == c1
)
9896 return omit_one_operand_loc (loc
, type
, arg1
,
9897 TREE_OPERAND (arg0
, 0));
9899 wide_int msk
= wi::mask (width
, false,
9900 TYPE_PRECISION (TREE_TYPE (arg1
)));
9902 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
9903 if (msk
.and_not (c1
| c2
) == 0)
9904 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
9905 TREE_OPERAND (arg0
, 0), arg1
);
9907 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
9908 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
9909 mode which allows further optimizations. */
9912 wide_int c3
= c1
.and_not (c2
);
9913 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
9915 wide_int mask
= wi::mask (w
, false,
9916 TYPE_PRECISION (type
));
9917 if (((c1
| c2
) & mask
) == mask
&& c1
.and_not (mask
) == 0)
9925 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
9926 fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
9927 TREE_OPERAND (arg0
, 0),
9928 wide_int_to_tree (type
,
9933 /* See if this can be simplified into a rotate first. If that
9934 is unsuccessful continue in the association code. */
9938 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
9939 if (TREE_CODE (arg0
) == BIT_AND_EXPR
9940 && INTEGRAL_TYPE_P (type
)
9941 && integer_onep (TREE_OPERAND (arg0
, 1))
9942 && integer_onep (arg1
))
9943 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
9944 build_zero_cst (TREE_TYPE (arg0
)));
9946 /* See if this can be simplified into a rotate first. If that
9947 is unsuccessful continue in the association code. */
9951 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
9952 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
9953 && INTEGRAL_TYPE_P (type
)
9954 && integer_onep (TREE_OPERAND (arg0
, 1))
9955 && integer_onep (arg1
))
9958 tem
= TREE_OPERAND (arg0
, 0);
9959 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
9960 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
9962 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
9963 build_zero_cst (TREE_TYPE (tem
)));
9965 /* Fold ~X & 1 as (X & 1) == 0. */
9966 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9967 && INTEGRAL_TYPE_P (type
)
9968 && integer_onep (arg1
))
9971 tem
= TREE_OPERAND (arg0
, 0);
9972 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
9973 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
9975 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
9976 build_zero_cst (TREE_TYPE (tem
)));
9978 /* Fold !X & 1 as X == 0. */
9979 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
9980 && integer_onep (arg1
))
9982 tem
= TREE_OPERAND (arg0
, 0);
9983 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
9984 build_zero_cst (TREE_TYPE (tem
)));
9987 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
9988 multiple of 1 << CST. */
9989 if (TREE_CODE (arg1
) == INTEGER_CST
)
9991 wide_int cst1
= arg1
;
9992 wide_int ncst1
= -cst1
;
9993 if ((cst1
& ncst1
) == ncst1
9994 && multiple_of_p (type
, arg0
,
9995 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
9996 return fold_convert_loc (loc
, type
, arg0
);
9999 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10001 if (TREE_CODE (arg1
) == INTEGER_CST
10002 && TREE_CODE (arg0
) == MULT_EXPR
10003 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10005 wide_int warg1
= arg1
;
10006 wide_int masked
= mask_with_tz (type
, warg1
, TREE_OPERAND (arg0
, 1));
10009 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
10011 else if (masked
!= warg1
)
10013 /* Avoid the transform if arg1 is a mask of some
10014 mode which allows further optimizations. */
10015 int pop
= wi::popcount (warg1
);
10016 if (!(pop
>= BITS_PER_UNIT
10018 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
10019 return fold_build2_loc (loc
, code
, type
, op0
,
10020 wide_int_to_tree (type
, masked
));
10024 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10025 ((A & N) + B) & M -> (A + B) & M
10026 Similarly if (N & M) == 0,
10027 ((A | N) + B) & M -> (A + B) & M
10028 and for - instead of + (or unary - instead of +)
10029 and/or ^ instead of |.
10030 If B is constant and (B & M) == 0, fold into A & M. */
10031 if (TREE_CODE (arg1
) == INTEGER_CST
)
10033 wide_int cst1
= arg1
;
10034 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
10035 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10036 && (TREE_CODE (arg0
) == PLUS_EXPR
10037 || TREE_CODE (arg0
) == MINUS_EXPR
10038 || TREE_CODE (arg0
) == NEGATE_EXPR
)
10039 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
10040 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
10046 /* Now we know that arg0 is (C + D) or (C - D) or
10047 -C and arg1 (M) is == (1LL << cst) - 1.
10048 Store C into PMOP[0] and D into PMOP[1]. */
10049 pmop
[0] = TREE_OPERAND (arg0
, 0);
10051 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
10053 pmop
[1] = TREE_OPERAND (arg0
, 1);
10057 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
10060 for (; which
>= 0; which
--)
10061 switch (TREE_CODE (pmop
[which
]))
10066 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
10069 cst0
= TREE_OPERAND (pmop
[which
], 1);
10071 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
10076 else if (cst0
!= 0)
10078 /* If C or D is of the form (A & N) where
10079 (N & M) == M, or of the form (A | N) or
10080 (A ^ N) where (N & M) == 0, replace it with A. */
10081 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
10084 /* If C or D is a N where (N & M) == 0, it can be
10085 omitted (assumed 0). */
10086 if ((TREE_CODE (arg0
) == PLUS_EXPR
10087 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
10088 && (cst1
& pmop
[which
]) == 0)
10089 pmop
[which
] = NULL
;
10095 /* Only build anything new if we optimized one or both arguments
10097 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
10098 || (TREE_CODE (arg0
) != NEGATE_EXPR
10099 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
10101 tree utype
= TREE_TYPE (arg0
);
10102 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
10104 /* Perform the operations in a type that has defined
10105 overflow behavior. */
10106 utype
= unsigned_type_for (TREE_TYPE (arg0
));
10107 if (pmop
[0] != NULL
)
10108 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
10109 if (pmop
[1] != NULL
)
10110 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
10113 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
10114 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
10115 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
10117 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
10118 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
10120 else if (pmop
[0] != NULL
)
10122 else if (pmop
[1] != NULL
)
10125 return build_int_cst (type
, 0);
10127 else if (pmop
[0] == NULL
)
10128 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
10130 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
10132 /* TEM is now the new binary +, - or unary - replacement. */
10133 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
10134 fold_convert_loc (loc
, utype
, arg1
));
10135 return fold_convert_loc (loc
, type
, tem
);
10140 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10141 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
10142 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
10144 prec
= element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
10146 wide_int mask
= wide_int::from (arg1
, prec
, UNSIGNED
);
10149 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10155 /* Don't touch a floating-point divide by zero unless the mode
10156 of the constant can represent infinity. */
10157 if (TREE_CODE (arg1
) == REAL_CST
10158 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
10159 && real_zerop (arg1
))
10162 /* (-A) / (-B) -> A / B */
10163 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10164 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10165 TREE_OPERAND (arg0
, 0),
10166 negate_expr (arg1
));
10167 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10168 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10169 negate_expr (arg0
),
10170 TREE_OPERAND (arg1
, 0));
10173 case TRUNC_DIV_EXPR
:
10176 case FLOOR_DIV_EXPR
:
10177 /* Simplify A / (B << N) where A and B are positive and B is
10178 a power of 2, to A >> (N + log2(B)). */
10179 strict_overflow_p
= false;
10180 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10181 && (TYPE_UNSIGNED (type
)
10182 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
10184 tree sval
= TREE_OPERAND (arg1
, 0);
10185 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
10187 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
10188 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
10189 wi::exact_log2 (sval
));
10191 if (strict_overflow_p
)
10192 fold_overflow_warning (("assuming signed overflow does not "
10193 "occur when simplifying A / (B << N)"),
10194 WARN_STRICT_OVERFLOW_MISC
);
10196 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
10198 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
10199 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
10205 case ROUND_DIV_EXPR
:
10206 case CEIL_DIV_EXPR
:
10207 case EXACT_DIV_EXPR
:
10208 if (integer_zerop (arg1
))
10211 /* Convert -A / -B to A / B when the type is signed and overflow is
10213 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10214 && TREE_CODE (arg0
) == NEGATE_EXPR
10215 && negate_expr_p (op1
))
10217 if (INTEGRAL_TYPE_P (type
))
10218 fold_overflow_warning (("assuming signed overflow does not occur "
10219 "when distributing negation across "
10221 WARN_STRICT_OVERFLOW_MISC
);
10222 return fold_build2_loc (loc
, code
, type
,
10223 fold_convert_loc (loc
, type
,
10224 TREE_OPERAND (arg0
, 0)),
10225 negate_expr (op1
));
10227 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10228 && TREE_CODE (arg1
) == NEGATE_EXPR
10229 && negate_expr_p (op0
))
10231 if (INTEGRAL_TYPE_P (type
))
10232 fold_overflow_warning (("assuming signed overflow does not occur "
10233 "when distributing negation across "
10235 WARN_STRICT_OVERFLOW_MISC
);
10236 return fold_build2_loc (loc
, code
, type
,
10238 fold_convert_loc (loc
, type
,
10239 TREE_OPERAND (arg1
, 0)));
10242 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10243 operation, EXACT_DIV_EXPR.
10245 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10246 At one time others generated faster code, it's not clear if they do
10247 after the last round to changes to the DIV code in expmed.c. */
10248 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
10249 && multiple_of_p (type
, arg0
, arg1
))
10250 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
,
10251 fold_convert (type
, arg0
),
10252 fold_convert (type
, arg1
));
10254 strict_overflow_p
= false;
10255 if (TREE_CODE (arg1
) == INTEGER_CST
10256 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10257 &strict_overflow_p
)))
10259 if (strict_overflow_p
)
10260 fold_overflow_warning (("assuming signed overflow does not occur "
10261 "when simplifying division"),
10262 WARN_STRICT_OVERFLOW_MISC
);
10263 return fold_convert_loc (loc
, type
, tem
);
10268 case CEIL_MOD_EXPR
:
10269 case FLOOR_MOD_EXPR
:
10270 case ROUND_MOD_EXPR
:
10271 case TRUNC_MOD_EXPR
:
10272 strict_overflow_p
= false;
10273 if (TREE_CODE (arg1
) == INTEGER_CST
10274 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10275 &strict_overflow_p
)))
10277 if (strict_overflow_p
)
10278 fold_overflow_warning (("assuming signed overflow does not occur "
10279 "when simplifying modulus"),
10280 WARN_STRICT_OVERFLOW_MISC
);
10281 return fold_convert_loc (loc
, type
, tem
);
10290 /* Since negative shift count is not well-defined,
10291 don't try to compute it in the compiler. */
10292 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
10295 prec
= element_precision (type
);
10297 /* If we have a rotate of a bit operation with the rotate count and
10298 the second operand of the bit operation both constant,
10299 permute the two operations. */
10300 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10301 && (TREE_CODE (arg0
) == BIT_AND_EXPR
10302 || TREE_CODE (arg0
) == BIT_IOR_EXPR
10303 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
10304 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10306 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10307 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10308 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
10309 fold_build2_loc (loc
, code
, type
,
10311 fold_build2_loc (loc
, code
, type
,
10315 /* Two consecutive rotates adding up to the some integer
10316 multiple of the precision of the type can be ignored. */
10317 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10318 && TREE_CODE (arg0
) == RROTATE_EXPR
10319 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10320 && wi::umod_trunc (wi::add (arg1
, TREE_OPERAND (arg0
, 1)),
10322 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10330 case TRUTH_ANDIF_EXPR
:
10331 /* Note that the operands of this must be ints
10332 and their values must be 0 or 1.
10333 ("true" is a fixed value perhaps depending on the language.) */
10334 /* If first arg is constant zero, return it. */
10335 if (integer_zerop (arg0
))
10336 return fold_convert_loc (loc
, type
, arg0
);
10338 case TRUTH_AND_EXPR
:
10339 /* If either arg is constant true, drop it. */
10340 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10341 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10342 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
10343 /* Preserve sequence points. */
10344 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10345 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10346 /* If second arg is constant zero, result is zero, but first arg
10347 must be evaluated. */
10348 if (integer_zerop (arg1
))
10349 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10350 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10351 case will be handled here. */
10352 if (integer_zerop (arg0
))
10353 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10355 /* !X && X is always false. */
10356 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10357 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10358 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
10359 /* X && !X is always false. */
10360 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10361 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10362 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10364 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10365 means A >= Y && A != MAX, but in this case we know that
10368 if (!TREE_SIDE_EFFECTS (arg0
)
10369 && !TREE_SIDE_EFFECTS (arg1
))
10371 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
10372 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
10373 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
10375 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
10376 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
10377 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
10380 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10386 case TRUTH_ORIF_EXPR
:
10387 /* Note that the operands of this must be ints
10388 and their values must be 0 or true.
10389 ("true" is a fixed value perhaps depending on the language.) */
10390 /* If first arg is constant true, return it. */
10391 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10392 return fold_convert_loc (loc
, type
, arg0
);
10394 case TRUTH_OR_EXPR
:
10395 /* If either arg is constant zero, drop it. */
10396 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
10397 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10398 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
10399 /* Preserve sequence points. */
10400 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10401 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10402 /* If second arg is constant true, result is true, but we must
10403 evaluate first arg. */
10404 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
10405 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10406 /* Likewise for first arg, but note this only occurs here for
10408 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10409 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10411 /* !X || X is always true. */
10412 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10413 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10414 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10415 /* X || !X is always true. */
10416 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10417 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10418 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10420 /* (X && !Y) || (!X && Y) is X ^ Y */
10421 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
10422 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
10424 tree a0
, a1
, l0
, l1
, n0
, n1
;
10426 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10427 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10429 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10430 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10432 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
10433 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
10435 if ((operand_equal_p (n0
, a0
, 0)
10436 && operand_equal_p (n1
, a1
, 0))
10437 || (operand_equal_p (n0
, a1
, 0)
10438 && operand_equal_p (n1
, a0
, 0)))
10439 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
10442 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10448 case TRUTH_XOR_EXPR
:
10449 /* If the second arg is constant zero, drop it. */
10450 if (integer_zerop (arg1
))
10451 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10452 /* If the second arg is constant true, this is a logical inversion. */
10453 if (integer_onep (arg1
))
10455 tem
= invert_truthvalue_loc (loc
, arg0
);
10456 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
10458 /* Identical arguments cancel to zero. */
10459 if (operand_equal_p (arg0
, arg1
, 0))
10460 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10462 /* !X ^ X is always true. */
10463 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10464 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10465 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10467 /* X ^ !X is always true. */
10468 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10469 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10470 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10479 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
10480 if (tem
!= NULL_TREE
)
10483 /* bool_var != 1 becomes !bool_var. */
10484 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
10485 && code
== NE_EXPR
)
10486 return fold_convert_loc (loc
, type
,
10487 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10488 TREE_TYPE (arg0
), arg0
));
10490 /* bool_var == 0 becomes !bool_var. */
10491 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
10492 && code
== EQ_EXPR
)
10493 return fold_convert_loc (loc
, type
,
10494 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10495 TREE_TYPE (arg0
), arg0
));
10497 /* !exp != 0 becomes !exp */
10498 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
10499 && code
== NE_EXPR
)
10500 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10502 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
10503 if ((TREE_CODE (arg0
) == PLUS_EXPR
10504 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
10505 || TREE_CODE (arg0
) == MINUS_EXPR
)
10506 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
10509 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10510 || POINTER_TYPE_P (TREE_TYPE (arg0
))))
10512 tree val
= TREE_OPERAND (arg0
, 1);
10513 val
= fold_build2_loc (loc
, code
, type
, val
,
10514 build_int_cst (TREE_TYPE (val
), 0));
10515 return omit_two_operands_loc (loc
, type
, val
,
10516 TREE_OPERAND (arg0
, 0), arg1
);
10519 /* Transform comparisons of the form X CMP X +- Y to Y CMP 0. */
10520 if ((TREE_CODE (arg1
) == PLUS_EXPR
10521 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
10522 || TREE_CODE (arg1
) == MINUS_EXPR
)
10523 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1
,
10526 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10527 || POINTER_TYPE_P (TREE_TYPE (arg1
))))
10529 tree val
= TREE_OPERAND (arg1
, 1);
10530 val
= fold_build2_loc (loc
, code
, type
, val
,
10531 build_int_cst (TREE_TYPE (val
), 0));
10532 return omit_two_operands_loc (loc
, type
, val
,
10533 TREE_OPERAND (arg1
, 0), arg0
);
10536 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
10537 if (TREE_CODE (arg0
) == MINUS_EXPR
10538 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == INTEGER_CST
10539 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
10542 && wi::extract_uhwi (TREE_OPERAND (arg0
, 0), 0, 1) == 1)
10543 return omit_two_operands_loc (loc
, type
,
10545 ? boolean_true_node
: boolean_false_node
,
10546 TREE_OPERAND (arg0
, 1), arg1
);
10548 /* Transform comparisons of the form X CMP C - X if C % 2 == 1. */
10549 if (TREE_CODE (arg1
) == MINUS_EXPR
10550 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == INTEGER_CST
10551 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1
,
10554 && wi::extract_uhwi (TREE_OPERAND (arg1
, 0), 0, 1) == 1)
10555 return omit_two_operands_loc (loc
, type
,
10557 ? boolean_true_node
: boolean_false_node
,
10558 TREE_OPERAND (arg1
, 1), arg0
);
10560 /* If this is an EQ or NE comparison with zero and ARG0 is
10561 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10562 two operations, but the latter can be done in one less insn
10563 on machines that have only two-operand insns or on which a
10564 constant cannot be the first operand. */
10565 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10566 && integer_zerop (arg1
))
10568 tree arg00
= TREE_OPERAND (arg0
, 0);
10569 tree arg01
= TREE_OPERAND (arg0
, 1);
10570 if (TREE_CODE (arg00
) == LSHIFT_EXPR
10571 && integer_onep (TREE_OPERAND (arg00
, 0)))
10573 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
10574 arg01
, TREE_OPERAND (arg00
, 1));
10575 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10576 build_int_cst (TREE_TYPE (arg0
), 1));
10577 return fold_build2_loc (loc
, code
, type
,
10578 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10581 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
10582 && integer_onep (TREE_OPERAND (arg01
, 0)))
10584 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
10585 arg00
, TREE_OPERAND (arg01
, 1));
10586 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10587 build_int_cst (TREE_TYPE (arg0
), 1));
10588 return fold_build2_loc (loc
, code
, type
,
10589 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10594 /* If this is an NE or EQ comparison of zero against the result of a
10595 signed MOD operation whose second operand is a power of 2, make
10596 the MOD operation unsigned since it is simpler and equivalent. */
10597 if (integer_zerop (arg1
)
10598 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
10599 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
10600 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
10601 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
10602 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
10603 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10605 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
10606 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
10607 fold_convert_loc (loc
, newtype
,
10608 TREE_OPERAND (arg0
, 0)),
10609 fold_convert_loc (loc
, newtype
,
10610 TREE_OPERAND (arg0
, 1)));
10612 return fold_build2_loc (loc
, code
, type
, newmod
,
10613 fold_convert_loc (loc
, newtype
, arg1
));
10616 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10617 C1 is a valid shift constant, and C2 is a power of two, i.e.
10619 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10620 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
10621 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
10623 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10624 && integer_zerop (arg1
))
10626 tree itype
= TREE_TYPE (arg0
);
10627 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
10628 prec
= TYPE_PRECISION (itype
);
10630 /* Check for a valid shift count. */
10631 if (wi::ltu_p (arg001
, prec
))
10633 tree arg01
= TREE_OPERAND (arg0
, 1);
10634 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10635 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
10636 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10637 can be rewritten as (X & (C2 << C1)) != 0. */
10638 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
10640 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
10641 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
10642 return fold_build2_loc (loc
, code
, type
, tem
,
10643 fold_convert_loc (loc
, itype
, arg1
));
10645 /* Otherwise, for signed (arithmetic) shifts,
10646 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10647 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10648 else if (!TYPE_UNSIGNED (itype
))
10649 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
10650 arg000
, build_int_cst (itype
, 0));
10651 /* Otherwise, of unsigned (logical) shifts,
10652 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10653 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10655 return omit_one_operand_loc (loc
, type
,
10656 code
== EQ_EXPR
? integer_one_node
10657 : integer_zero_node
,
10662 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10663 Similarly for NE_EXPR. */
10664 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10665 && TREE_CODE (arg1
) == INTEGER_CST
10666 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10668 tree notc
= fold_build1_loc (loc
, BIT_NOT_EXPR
,
10669 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
10670 TREE_OPERAND (arg0
, 1));
10672 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
10673 fold_convert_loc (loc
, TREE_TYPE (arg0
), arg1
),
10675 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
10676 if (integer_nonzerop (dandnotc
))
10677 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
10680 /* If this is a comparison of a field, we may be able to simplify it. */
10681 if ((TREE_CODE (arg0
) == COMPONENT_REF
10682 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
10683 /* Handle the constant case even without -O
10684 to make sure the warnings are given. */
10685 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
10687 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
10692 /* Optimize comparisons of strlen vs zero to a compare of the
10693 first character of the string vs zero. To wit,
10694 strlen(ptr) == 0 => *ptr == 0
10695 strlen(ptr) != 0 => *ptr != 0
10696 Other cases should reduce to one of these two (or a constant)
10697 due to the return value of strlen being unsigned. */
10698 if (TREE_CODE (arg0
) == CALL_EXPR
10699 && integer_zerop (arg1
))
10701 tree fndecl
= get_callee_fndecl (arg0
);
10704 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
10705 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
10706 && call_expr_nargs (arg0
) == 1
10707 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
10709 tree iref
= build_fold_indirect_ref_loc (loc
,
10710 CALL_EXPR_ARG (arg0
, 0));
10711 return fold_build2_loc (loc
, code
, type
, iref
,
10712 build_int_cst (TREE_TYPE (iref
), 0));
10716 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10717 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10718 if (TREE_CODE (arg0
) == RSHIFT_EXPR
10719 && integer_zerop (arg1
)
10720 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10722 tree arg00
= TREE_OPERAND (arg0
, 0);
10723 tree arg01
= TREE_OPERAND (arg0
, 1);
10724 tree itype
= TREE_TYPE (arg00
);
10725 if (wi::eq_p (arg01
, element_precision (itype
) - 1))
10727 if (TYPE_UNSIGNED (itype
))
10729 itype
= signed_type_for (itype
);
10730 arg00
= fold_convert_loc (loc
, itype
, arg00
);
10732 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
10733 type
, arg00
, build_zero_cst (itype
));
10737 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10738 (X & C) == 0 when C is a single bit. */
10739 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10740 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
10741 && integer_zerop (arg1
)
10742 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10744 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
10745 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
10746 TREE_OPERAND (arg0
, 1));
10747 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
10749 fold_convert_loc (loc
, TREE_TYPE (arg0
),
10753 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10754 constant C is a power of two, i.e. a single bit. */
10755 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10756 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
10757 && integer_zerop (arg1
)
10758 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10759 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10760 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10762 tree arg00
= TREE_OPERAND (arg0
, 0);
10763 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10764 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
10767 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10768 when is C is a power of two, i.e. a single bit. */
10769 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10770 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
10771 && integer_zerop (arg1
)
10772 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10773 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10774 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10776 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10777 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
10778 arg000
, TREE_OPERAND (arg0
, 1));
10779 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10780 tem
, build_int_cst (TREE_TYPE (tem
), 0));
10783 if (integer_zerop (arg1
)
10784 && tree_expr_nonzero_p (arg0
))
10786 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
10787 return omit_one_operand_loc (loc
, type
, res
, arg0
);
10790 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10791 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10792 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10794 tree arg00
= TREE_OPERAND (arg0
, 0);
10795 tree arg01
= TREE_OPERAND (arg0
, 1);
10796 tree arg10
= TREE_OPERAND (arg1
, 0);
10797 tree arg11
= TREE_OPERAND (arg1
, 1);
10798 tree itype
= TREE_TYPE (arg0
);
10800 if (operand_equal_p (arg01
, arg11
, 0))
10801 return fold_build2_loc (loc
, code
, type
,
10802 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10803 fold_build2_loc (loc
,
10804 BIT_XOR_EXPR
, itype
,
10807 build_zero_cst (itype
));
10809 if (operand_equal_p (arg01
, arg10
, 0))
10810 return fold_build2_loc (loc
, code
, type
,
10811 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10812 fold_build2_loc (loc
,
10813 BIT_XOR_EXPR
, itype
,
10816 build_zero_cst (itype
));
10818 if (operand_equal_p (arg00
, arg11
, 0))
10819 return fold_build2_loc (loc
, code
, type
,
10820 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10821 fold_build2_loc (loc
,
10822 BIT_XOR_EXPR
, itype
,
10825 build_zero_cst (itype
));
10827 if (operand_equal_p (arg00
, arg10
, 0))
10828 return fold_build2_loc (loc
, code
, type
,
10829 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10830 fold_build2_loc (loc
,
10831 BIT_XOR_EXPR
, itype
,
10834 build_zero_cst (itype
));
10837 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10838 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
10840 tree arg00
= TREE_OPERAND (arg0
, 0);
10841 tree arg01
= TREE_OPERAND (arg0
, 1);
10842 tree arg10
= TREE_OPERAND (arg1
, 0);
10843 tree arg11
= TREE_OPERAND (arg1
, 1);
10844 tree itype
= TREE_TYPE (arg0
);
10846 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10847 operand_equal_p guarantees no side-effects so we don't need
10848 to use omit_one_operand on Z. */
10849 if (operand_equal_p (arg01
, arg11
, 0))
10850 return fold_build2_loc (loc
, code
, type
, arg00
,
10851 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10853 if (operand_equal_p (arg01
, arg10
, 0))
10854 return fold_build2_loc (loc
, code
, type
, arg00
,
10855 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10857 if (operand_equal_p (arg00
, arg11
, 0))
10858 return fold_build2_loc (loc
, code
, type
, arg01
,
10859 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10861 if (operand_equal_p (arg00
, arg10
, 0))
10862 return fold_build2_loc (loc
, code
, type
, arg01
,
10863 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10866 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
10867 if (TREE_CODE (arg01
) == INTEGER_CST
10868 && TREE_CODE (arg11
) == INTEGER_CST
)
10870 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
10871 fold_convert_loc (loc
, itype
, arg11
));
10872 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
10873 return fold_build2_loc (loc
, code
, type
, tem
,
10874 fold_convert_loc (loc
, itype
, arg10
));
10878 /* Attempt to simplify equality/inequality comparisons of complex
10879 values. Only lower the comparison if the result is known or
10880 can be simplified to a single scalar comparison. */
10881 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
10882 || TREE_CODE (arg0
) == COMPLEX_CST
)
10883 && (TREE_CODE (arg1
) == COMPLEX_EXPR
10884 || TREE_CODE (arg1
) == COMPLEX_CST
))
10886 tree real0
, imag0
, real1
, imag1
;
10889 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
10891 real0
= TREE_OPERAND (arg0
, 0);
10892 imag0
= TREE_OPERAND (arg0
, 1);
10896 real0
= TREE_REALPART (arg0
);
10897 imag0
= TREE_IMAGPART (arg0
);
10900 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
10902 real1
= TREE_OPERAND (arg1
, 0);
10903 imag1
= TREE_OPERAND (arg1
, 1);
10907 real1
= TREE_REALPART (arg1
);
10908 imag1
= TREE_IMAGPART (arg1
);
10911 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
10912 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
10914 if (integer_zerop (rcond
))
10916 if (code
== EQ_EXPR
)
10917 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
10919 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
10923 if (code
== NE_EXPR
)
10924 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
10926 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
10930 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
10931 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
10933 if (integer_zerop (icond
))
10935 if (code
== EQ_EXPR
)
10936 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
10938 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
10942 if (code
== NE_EXPR
)
10943 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
10945 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
10956 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
10957 if (tem
!= NULL_TREE
)
10960 /* Transform comparisons of the form X +- C CMP X. */
10961 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
10962 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
10963 && ((TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
10964 && !HONOR_SNANS (arg0
))
10965 || (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10966 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))))
10968 tree arg01
= TREE_OPERAND (arg0
, 1);
10969 enum tree_code code0
= TREE_CODE (arg0
);
10972 if (TREE_CODE (arg01
) == REAL_CST
)
10973 is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
10975 is_positive
= tree_int_cst_sgn (arg01
);
10977 /* (X - c) > X becomes false. */
10978 if (code
== GT_EXPR
10979 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
10980 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
10982 if (TREE_CODE (arg01
) == INTEGER_CST
10983 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10984 fold_overflow_warning (("assuming signed overflow does not "
10985 "occur when assuming that (X - c) > X "
10986 "is always false"),
10987 WARN_STRICT_OVERFLOW_ALL
);
10988 return constant_boolean_node (0, type
);
10991 /* Likewise (X + c) < X becomes false. */
10992 if (code
== LT_EXPR
10993 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
10994 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
10996 if (TREE_CODE (arg01
) == INTEGER_CST
10997 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10998 fold_overflow_warning (("assuming signed overflow does not "
10999 "occur when assuming that "
11000 "(X + c) < X is always false"),
11001 WARN_STRICT_OVERFLOW_ALL
);
11002 return constant_boolean_node (0, type
);
11005 /* Convert (X - c) <= X to true. */
11006 if (!HONOR_NANS (arg1
)
11008 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
11009 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
11011 if (TREE_CODE (arg01
) == INTEGER_CST
11012 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11013 fold_overflow_warning (("assuming signed overflow does not "
11014 "occur when assuming that "
11015 "(X - c) <= X is always true"),
11016 WARN_STRICT_OVERFLOW_ALL
);
11017 return constant_boolean_node (1, type
);
11020 /* Convert (X + c) >= X to true. */
11021 if (!HONOR_NANS (arg1
)
11023 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
11024 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
11026 if (TREE_CODE (arg01
) == INTEGER_CST
11027 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11028 fold_overflow_warning (("assuming signed overflow does not "
11029 "occur when assuming that "
11030 "(X + c) >= X is always true"),
11031 WARN_STRICT_OVERFLOW_ALL
);
11032 return constant_boolean_node (1, type
);
11035 if (TREE_CODE (arg01
) == INTEGER_CST
)
11037 /* Convert X + c > X and X - c < X to true for integers. */
11038 if (code
== GT_EXPR
11039 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
11040 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
11042 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11043 fold_overflow_warning (("assuming signed overflow does "
11044 "not occur when assuming that "
11045 "(X + c) > X is always true"),
11046 WARN_STRICT_OVERFLOW_ALL
);
11047 return constant_boolean_node (1, type
);
11050 if (code
== LT_EXPR
11051 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
11052 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
11054 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11055 fold_overflow_warning (("assuming signed overflow does "
11056 "not occur when assuming that "
11057 "(X - c) < X is always true"),
11058 WARN_STRICT_OVERFLOW_ALL
);
11059 return constant_boolean_node (1, type
);
11062 /* Convert X + c <= X and X - c >= X to false for integers. */
11063 if (code
== LE_EXPR
11064 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
11065 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
11067 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11068 fold_overflow_warning (("assuming signed overflow does "
11069 "not occur when assuming that "
11070 "(X + c) <= X is always false"),
11071 WARN_STRICT_OVERFLOW_ALL
);
11072 return constant_boolean_node (0, type
);
11075 if (code
== GE_EXPR
11076 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
11077 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
11079 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11080 fold_overflow_warning (("assuming signed overflow does "
11081 "not occur when assuming that "
11082 "(X - c) >= X is always false"),
11083 WARN_STRICT_OVERFLOW_ALL
);
11084 return constant_boolean_node (0, type
);
11089 /* If we are comparing an ABS_EXPR with a constant, we can
11090 convert all the cases into explicit comparisons, but they may
11091 well not be faster than doing the ABS and one comparison.
11092 But ABS (X) <= C is a range comparison, which becomes a subtraction
11093 and a comparison, and is probably faster. */
11094 if (code
== LE_EXPR
11095 && TREE_CODE (arg1
) == INTEGER_CST
11096 && TREE_CODE (arg0
) == ABS_EXPR
11097 && ! TREE_SIDE_EFFECTS (arg0
)
11098 && (0 != (tem
= negate_expr (arg1
)))
11099 && TREE_CODE (tem
) == INTEGER_CST
11100 && !TREE_OVERFLOW (tem
))
11101 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
11102 build2 (GE_EXPR
, type
,
11103 TREE_OPERAND (arg0
, 0), tem
),
11104 build2 (LE_EXPR
, type
,
11105 TREE_OPERAND (arg0
, 0), arg1
));
11107 /* Convert ABS_EXPR<x> >= 0 to true. */
11108 strict_overflow_p
= false;
11109 if (code
== GE_EXPR
11110 && (integer_zerop (arg1
)
11111 || (! HONOR_NANS (arg0
)
11112 && real_zerop (arg1
)))
11113 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11115 if (strict_overflow_p
)
11116 fold_overflow_warning (("assuming signed overflow does not occur "
11117 "when simplifying comparison of "
11118 "absolute value and zero"),
11119 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11120 return omit_one_operand_loc (loc
, type
,
11121 constant_boolean_node (true, type
),
11125 /* Convert ABS_EXPR<x> < 0 to false. */
11126 strict_overflow_p
= false;
11127 if (code
== LT_EXPR
11128 && (integer_zerop (arg1
) || real_zerop (arg1
))
11129 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11131 if (strict_overflow_p
)
11132 fold_overflow_warning (("assuming signed overflow does not occur "
11133 "when simplifying comparison of "
11134 "absolute value and zero"),
11135 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11136 return omit_one_operand_loc (loc
, type
,
11137 constant_boolean_node (false, type
),
11141 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11142 and similarly for >= into !=. */
11143 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11144 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11145 && TREE_CODE (arg1
) == LSHIFT_EXPR
11146 && integer_onep (TREE_OPERAND (arg1
, 0)))
11147 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11148 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11149 TREE_OPERAND (arg1
, 1)),
11150 build_zero_cst (TREE_TYPE (arg0
)));
11152 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11153 otherwise Y might be >= # of bits in X's type and thus e.g.
11154 (unsigned char) (1 << Y) for Y 15 might be 0.
11155 If the cast is widening, then 1 << Y should have unsigned type,
11156 otherwise if Y is number of bits in the signed shift type minus 1,
11157 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11158 31 might be 0xffffffff80000000. */
11159 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11160 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11161 && CONVERT_EXPR_P (arg1
)
11162 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
11163 && (element_precision (TREE_TYPE (arg1
))
11164 >= element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
11165 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
11166 || (element_precision (TREE_TYPE (arg1
))
11167 == element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
11168 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
11170 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11171 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
11172 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11173 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
11174 build_zero_cst (TREE_TYPE (arg0
)));
11179 case UNORDERED_EXPR
:
11187 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11189 tree targ0
= strip_float_extensions (arg0
);
11190 tree targ1
= strip_float_extensions (arg1
);
11191 tree newtype
= TREE_TYPE (targ0
);
11193 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
11194 newtype
= TREE_TYPE (targ1
);
11196 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
11197 return fold_build2_loc (loc
, code
, type
,
11198 fold_convert_loc (loc
, newtype
, targ0
),
11199 fold_convert_loc (loc
, newtype
, targ1
));
11204 case COMPOUND_EXPR
:
11205 /* When pedantic, a compound expression can be neither an lvalue
11206 nor an integer constant expression. */
11207 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
11209 /* Don't let (0, 0) be null pointer constant. */
11210 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
11211 : fold_convert_loc (loc
, type
, arg1
);
11212 return pedantic_non_lvalue_loc (loc
, tem
);
11215 /* An ASSERT_EXPR should never be passed to fold_binary. */
11216 gcc_unreachable ();
11220 } /* switch (code) */
11223 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11224 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
11228 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
11230 switch (TREE_CODE (*tp
))
11236 *walk_subtrees
= 0;
11245 /* Return whether the sub-tree ST contains a label which is accessible from
11246 outside the sub-tree. */
11249 contains_label_p (tree st
)
11252 (walk_tree_without_duplicates (&st
, contains_label_1
, NULL
) != NULL_TREE
);
11255 /* Fold a ternary expression of code CODE and type TYPE with operands
11256 OP0, OP1, and OP2. Return the folded expression if folding is
11257 successful. Otherwise, return NULL_TREE. */
11260 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
11261 tree op0
, tree op1
, tree op2
)
11264 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
11265 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11267 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
11268 && TREE_CODE_LENGTH (code
) == 3);
11270 /* If this is a commutative operation, and OP0 is a constant, move it
11271 to OP1 to reduce the number of tests below. */
11272 if (commutative_ternary_tree_code (code
)
11273 && tree_swap_operands_p (op0
, op1
, true))
11274 return fold_build3_loc (loc
, code
, type
, op1
, op0
, op2
);
11276 tem
= generic_simplify (loc
, code
, type
, op0
, op1
, op2
);
11280 /* Strip any conversions that don't change the mode. This is safe
11281 for every expression, except for a comparison expression because
11282 its signedness is derived from its operands. So, in the latter
11283 case, only strip conversions that don't change the signedness.
11285 Note that this is done as an internal manipulation within the
11286 constant folder, in order to find the simplest representation of
11287 the arguments so that their form can be studied. In any cases,
11288 the appropriate type conversions should be put back in the tree
11289 that will get out of the constant folder. */
11310 case COMPONENT_REF
:
11311 if (TREE_CODE (arg0
) == CONSTRUCTOR
11312 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
11314 unsigned HOST_WIDE_INT idx
;
11316 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
11323 case VEC_COND_EXPR
:
11324 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11325 so all simple results must be passed through pedantic_non_lvalue. */
11326 if (TREE_CODE (arg0
) == INTEGER_CST
)
11328 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
11329 tem
= integer_zerop (arg0
) ? op2
: op1
;
11330 /* Only optimize constant conditions when the selected branch
11331 has the same type as the COND_EXPR. This avoids optimizing
11332 away "c ? x : throw", where the throw has a void type.
11333 Avoid throwing away that operand which contains label. */
11334 if ((!TREE_SIDE_EFFECTS (unused_op
)
11335 || !contains_label_p (unused_op
))
11336 && (! VOID_TYPE_P (TREE_TYPE (tem
))
11337 || VOID_TYPE_P (type
)))
11338 return pedantic_non_lvalue_loc (loc
, tem
);
11341 else if (TREE_CODE (arg0
) == VECTOR_CST
)
11343 if ((TREE_CODE (arg1
) == VECTOR_CST
11344 || TREE_CODE (arg1
) == CONSTRUCTOR
)
11345 && (TREE_CODE (arg2
) == VECTOR_CST
11346 || TREE_CODE (arg2
) == CONSTRUCTOR
))
11348 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
11349 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
11350 gcc_assert (nelts
== VECTOR_CST_NELTS (arg0
));
11351 for (i
= 0; i
< nelts
; i
++)
11353 tree val
= VECTOR_CST_ELT (arg0
, i
);
11354 if (integer_all_onesp (val
))
11356 else if (integer_zerop (val
))
11357 sel
[i
] = nelts
+ i
;
11358 else /* Currently unreachable. */
11361 tree t
= fold_vec_perm (type
, arg1
, arg2
, sel
);
11362 if (t
!= NULL_TREE
)
11367 /* If we have A op B ? A : C, we may be able to convert this to a
11368 simpler expression, depending on the operation and the values
11369 of B and C. Signed zeros prevent all of these transformations,
11370 for reasons given above each one.
11372 Also try swapping the arguments and inverting the conditional. */
11373 if (COMPARISON_CLASS_P (arg0
)
11374 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
11375 arg1
, TREE_OPERAND (arg0
, 1))
11376 && !HONOR_SIGNED_ZEROS (element_mode (arg1
)))
11378 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
11383 if (COMPARISON_CLASS_P (arg0
)
11384 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
11386 TREE_OPERAND (arg0
, 1))
11387 && !HONOR_SIGNED_ZEROS (element_mode (op2
)))
11389 location_t loc0
= expr_location_or (arg0
, loc
);
11390 tem
= fold_invert_truthvalue (loc0
, arg0
);
11391 if (tem
&& COMPARISON_CLASS_P (tem
))
11393 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
11399 /* If the second operand is simpler than the third, swap them
11400 since that produces better jump optimization results. */
11401 if (truth_value_p (TREE_CODE (arg0
))
11402 && tree_swap_operands_p (op1
, op2
, false))
11404 location_t loc0
= expr_location_or (arg0
, loc
);
11405 /* See if this can be inverted. If it can't, possibly because
11406 it was a floating-point inequality comparison, don't do
11408 tem
= fold_invert_truthvalue (loc0
, arg0
);
11410 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
11413 /* Convert A ? 1 : 0 to simply A. */
11414 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
11415 : (integer_onep (op1
)
11416 && !VECTOR_TYPE_P (type
)))
11417 && integer_zerop (op2
)
11418 /* If we try to convert OP0 to our type, the
11419 call to fold will try to move the conversion inside
11420 a COND, which will recurse. In that case, the COND_EXPR
11421 is probably the best choice, so leave it alone. */
11422 && type
== TREE_TYPE (arg0
))
11423 return pedantic_non_lvalue_loc (loc
, arg0
);
11425 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11426 over COND_EXPR in cases such as floating point comparisons. */
11427 if (integer_zerop (op1
)
11428 && code
== COND_EXPR
11429 && integer_onep (op2
)
11430 && !VECTOR_TYPE_P (type
)
11431 && truth_value_p (TREE_CODE (arg0
)))
11432 return pedantic_non_lvalue_loc (loc
,
11433 fold_convert_loc (loc
, type
,
11434 invert_truthvalue_loc (loc
,
11437 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11438 if (TREE_CODE (arg0
) == LT_EXPR
11439 && integer_zerop (TREE_OPERAND (arg0
, 1))
11440 && integer_zerop (op2
)
11441 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
11443 /* sign_bit_p looks through both zero and sign extensions,
11444 but for this optimization only sign extensions are
11446 tree tem2
= TREE_OPERAND (arg0
, 0);
11447 while (tem
!= tem2
)
11449 if (TREE_CODE (tem2
) != NOP_EXPR
11450 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
11455 tem2
= TREE_OPERAND (tem2
, 0);
11457 /* sign_bit_p only checks ARG1 bits within A's precision.
11458 If <sign bit of A> has wider type than A, bits outside
11459 of A's precision in <sign bit of A> need to be checked.
11460 If they are all 0, this optimization needs to be done
11461 in unsigned A's type, if they are all 1 in signed A's type,
11462 otherwise this can't be done. */
11464 && TYPE_PRECISION (TREE_TYPE (tem
))
11465 < TYPE_PRECISION (TREE_TYPE (arg1
))
11466 && TYPE_PRECISION (TREE_TYPE (tem
))
11467 < TYPE_PRECISION (type
))
11469 int inner_width
, outer_width
;
11472 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
11473 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
11474 if (outer_width
> TYPE_PRECISION (type
))
11475 outer_width
= TYPE_PRECISION (type
);
11477 wide_int mask
= wi::shifted_mask
11478 (inner_width
, outer_width
- inner_width
, false,
11479 TYPE_PRECISION (TREE_TYPE (arg1
)));
11481 wide_int common
= mask
& arg1
;
11482 if (common
== mask
)
11484 tem_type
= signed_type_for (TREE_TYPE (tem
));
11485 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11487 else if (common
== 0)
11489 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
11490 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11498 fold_convert_loc (loc
, type
,
11499 fold_build2_loc (loc
, BIT_AND_EXPR
,
11500 TREE_TYPE (tem
), tem
,
11501 fold_convert_loc (loc
,
11506 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11507 already handled above. */
11508 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11509 && integer_onep (TREE_OPERAND (arg0
, 1))
11510 && integer_zerop (op2
)
11511 && integer_pow2p (arg1
))
11513 tree tem
= TREE_OPERAND (arg0
, 0);
11515 if (TREE_CODE (tem
) == RSHIFT_EXPR
11516 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
11517 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
) ==
11518 tree_to_uhwi (TREE_OPERAND (tem
, 1)))
11519 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11520 TREE_OPERAND (tem
, 0), arg1
);
11523 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11524 is probably obsolete because the first operand should be a
11525 truth value (that's why we have the two cases above), but let's
11526 leave it in until we can confirm this for all front-ends. */
11527 if (integer_zerop (op2
)
11528 && TREE_CODE (arg0
) == NE_EXPR
11529 && integer_zerop (TREE_OPERAND (arg0
, 1))
11530 && integer_pow2p (arg1
)
11531 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
11532 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
11533 arg1
, OEP_ONLY_CONST
))
11534 return pedantic_non_lvalue_loc (loc
,
11535 fold_convert_loc (loc
, type
,
11536 TREE_OPERAND (arg0
, 0)));
11538 /* Disable the transformations below for vectors, since
11539 fold_binary_op_with_conditional_arg may undo them immediately,
11540 yielding an infinite loop. */
11541 if (code
== VEC_COND_EXPR
)
11544 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11545 if (integer_zerop (op2
)
11546 && truth_value_p (TREE_CODE (arg0
))
11547 && truth_value_p (TREE_CODE (arg1
))
11548 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11549 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
11550 : TRUTH_ANDIF_EXPR
,
11551 type
, fold_convert_loc (loc
, type
, arg0
), arg1
);
11553 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11554 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
11555 && truth_value_p (TREE_CODE (arg0
))
11556 && truth_value_p (TREE_CODE (arg1
))
11557 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11559 location_t loc0
= expr_location_or (arg0
, loc
);
11560 /* Only perform transformation if ARG0 is easily inverted. */
11561 tem
= fold_invert_truthvalue (loc0
, arg0
);
11563 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11566 type
, fold_convert_loc (loc
, type
, tem
),
11570 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11571 if (integer_zerop (arg1
)
11572 && truth_value_p (TREE_CODE (arg0
))
11573 && truth_value_p (TREE_CODE (op2
))
11574 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11576 location_t loc0
= expr_location_or (arg0
, loc
);
11577 /* Only perform transformation if ARG0 is easily inverted. */
11578 tem
= fold_invert_truthvalue (loc0
, arg0
);
11580 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11581 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
11582 type
, fold_convert_loc (loc
, type
, tem
),
11586 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11587 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
11588 && truth_value_p (TREE_CODE (arg0
))
11589 && truth_value_p (TREE_CODE (op2
))
11590 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11591 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11592 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
11593 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
11598 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11599 of fold_ternary on them. */
11600 gcc_unreachable ();
11602 case BIT_FIELD_REF
:
11603 if (TREE_CODE (arg0
) == VECTOR_CST
11604 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
11605 || (TREE_CODE (type
) == VECTOR_TYPE
11606 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
)))))
11608 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
11609 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
11610 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
11611 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
11614 && (idx
% width
) == 0
11615 && (n
% width
) == 0
11616 && ((idx
+ n
) / width
) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)))
11621 if (TREE_CODE (arg0
) == VECTOR_CST
)
11624 return VECTOR_CST_ELT (arg0
, idx
);
11626 tree
*vals
= XALLOCAVEC (tree
, n
);
11627 for (unsigned i
= 0; i
< n
; ++i
)
11628 vals
[i
] = VECTOR_CST_ELT (arg0
, idx
+ i
);
11629 return build_vector (type
, vals
);
11634 /* On constants we can use native encode/interpret to constant
11635 fold (nearly) all BIT_FIELD_REFs. */
11636 if (CONSTANT_CLASS_P (arg0
)
11637 && can_native_interpret_type_p (type
)
11638 && BITS_PER_UNIT
== 8)
11640 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11641 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
11642 /* Limit us to a reasonable amount of work. To relax the
11643 other limitations we need bit-shifting of the buffer
11644 and rounding up the size. */
11645 if (bitpos
% BITS_PER_UNIT
== 0
11646 && bitsize
% BITS_PER_UNIT
== 0
11647 && bitsize
<= MAX_BITSIZE_MODE_ANY_MODE
)
11649 unsigned char b
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
11650 unsigned HOST_WIDE_INT len
11651 = native_encode_expr (arg0
, b
, bitsize
/ BITS_PER_UNIT
,
11652 bitpos
/ BITS_PER_UNIT
);
11654 && len
* BITS_PER_UNIT
>= bitsize
)
11656 tree v
= native_interpret_expr (type
, b
,
11657 bitsize
/ BITS_PER_UNIT
);
11667 /* For integers we can decompose the FMA if possible. */
11668 if (TREE_CODE (arg0
) == INTEGER_CST
11669 && TREE_CODE (arg1
) == INTEGER_CST
)
11670 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
11671 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
11672 if (integer_zerop (arg2
))
11673 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
11675 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
11677 case VEC_PERM_EXPR
:
11678 if (TREE_CODE (arg2
) == VECTOR_CST
)
11680 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
, mask
, mask2
;
11681 unsigned char *sel
= XALLOCAVEC (unsigned char, 2 * nelts
);
11682 unsigned char *sel2
= sel
+ nelts
;
11683 bool need_mask_canon
= false;
11684 bool need_mask_canon2
= false;
11685 bool all_in_vec0
= true;
11686 bool all_in_vec1
= true;
11687 bool maybe_identity
= true;
11688 bool single_arg
= (op0
== op1
);
11689 bool changed
= false;
11691 mask2
= 2 * nelts
- 1;
11692 mask
= single_arg
? (nelts
- 1) : mask2
;
11693 gcc_assert (nelts
== VECTOR_CST_NELTS (arg2
));
11694 for (i
= 0; i
< nelts
; i
++)
11696 tree val
= VECTOR_CST_ELT (arg2
, i
);
11697 if (TREE_CODE (val
) != INTEGER_CST
)
11700 /* Make sure that the perm value is in an acceptable
11703 need_mask_canon
|= wi::gtu_p (t
, mask
);
11704 need_mask_canon2
|= wi::gtu_p (t
, mask2
);
11705 sel
[i
] = t
.to_uhwi () & mask
;
11706 sel2
[i
] = t
.to_uhwi () & mask2
;
11708 if (sel
[i
] < nelts
)
11709 all_in_vec1
= false;
11711 all_in_vec0
= false;
11713 if ((sel
[i
] & (nelts
-1)) != i
)
11714 maybe_identity
= false;
11717 if (maybe_identity
)
11727 else if (all_in_vec1
)
11730 for (i
= 0; i
< nelts
; i
++)
11732 need_mask_canon
= true;
11735 if ((TREE_CODE (op0
) == VECTOR_CST
11736 || TREE_CODE (op0
) == CONSTRUCTOR
)
11737 && (TREE_CODE (op1
) == VECTOR_CST
11738 || TREE_CODE (op1
) == CONSTRUCTOR
))
11740 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
11741 if (t
!= NULL_TREE
)
11745 if (op0
== op1
&& !single_arg
)
11748 /* Some targets are deficient and fail to expand a single
11749 argument permutation while still allowing an equivalent
11750 2-argument version. */
11751 if (need_mask_canon
&& arg2
== op2
11752 && !can_vec_perm_p (TYPE_MODE (type
), false, sel
)
11753 && can_vec_perm_p (TYPE_MODE (type
), false, sel2
))
11755 need_mask_canon
= need_mask_canon2
;
11759 if (need_mask_canon
&& arg2
== op2
)
11761 tree
*tsel
= XALLOCAVEC (tree
, nelts
);
11762 tree eltype
= TREE_TYPE (TREE_TYPE (arg2
));
11763 for (i
= 0; i
< nelts
; i
++)
11764 tsel
[i
] = build_int_cst (eltype
, sel
[i
]);
11765 op2
= build_vector (TREE_TYPE (arg2
), tsel
);
11770 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
11774 case BIT_INSERT_EXPR
:
11775 /* Perform (partial) constant folding of BIT_INSERT_EXPR. */
11776 if (TREE_CODE (arg0
) == INTEGER_CST
11777 && TREE_CODE (arg1
) == INTEGER_CST
)
11779 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11780 unsigned bitsize
= TYPE_PRECISION (TREE_TYPE (arg1
));
11781 wide_int tem
= wi::bit_and (arg0
,
11782 wi::shifted_mask (bitpos
, bitsize
, true,
11783 TYPE_PRECISION (type
)));
11785 = wi::lshift (wi::zext (wi::to_wide (arg1
, TYPE_PRECISION (type
)),
11787 return wide_int_to_tree (type
, wi::bit_or (tem
, tem2
));
11789 else if (TREE_CODE (arg0
) == VECTOR_CST
11790 && CONSTANT_CLASS_P (arg1
)
11791 && types_compatible_p (TREE_TYPE (TREE_TYPE (arg0
)),
11794 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11795 unsigned HOST_WIDE_INT elsize
11796 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (arg1
)));
11797 if (bitpos
% elsize
== 0)
11799 unsigned k
= bitpos
/ elsize
;
11800 if (operand_equal_p (VECTOR_CST_ELT (arg0
, k
), arg1
, 0))
11804 tree
*elts
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
11805 memcpy (elts
, VECTOR_CST_ELTS (arg0
),
11806 sizeof (tree
) * TYPE_VECTOR_SUBPARTS (type
));
11808 return build_vector (type
, elts
);
11816 } /* switch (code) */
11819 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
11820 of an array (or vector). */
11823 get_array_ctor_element_at_index (tree ctor
, offset_int access_index
)
11825 tree index_type
= NULL_TREE
;
11826 offset_int low_bound
= 0;
11828 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
11830 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
11831 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
11833 /* Static constructors for variably sized objects makes no sense. */
11834 gcc_assert (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) == INTEGER_CST
);
11835 index_type
= TREE_TYPE (TYPE_MIN_VALUE (domain_type
));
11836 low_bound
= wi::to_offset (TYPE_MIN_VALUE (domain_type
));
11841 access_index
= wi::ext (access_index
, TYPE_PRECISION (index_type
),
11842 TYPE_SIGN (index_type
));
11844 offset_int index
= low_bound
- 1;
11846 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11847 TYPE_SIGN (index_type
));
11849 offset_int max_index
;
11850 unsigned HOST_WIDE_INT cnt
;
11853 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
, cval
)
11855 /* Array constructor might explicitly set index, or specify a range,
11856 or leave index NULL meaning that it is next index after previous
11860 if (TREE_CODE (cfield
) == INTEGER_CST
)
11861 max_index
= index
= wi::to_offset (cfield
);
11864 gcc_assert (TREE_CODE (cfield
) == RANGE_EXPR
);
11865 index
= wi::to_offset (TREE_OPERAND (cfield
, 0));
11866 max_index
= wi::to_offset (TREE_OPERAND (cfield
, 1));
11873 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11874 TYPE_SIGN (index_type
));
11878 /* Do we have match? */
11879 if (wi::cmpu (access_index
, index
) >= 0
11880 && wi::cmpu (access_index
, max_index
) <= 0)
11886 /* Perform constant folding and related simplification of EXPR.
11887 The related simplifications include x*1 => x, x*0 => 0, etc.,
11888 and application of the associative law.
11889 NOP_EXPR conversions may be removed freely (as long as we
11890 are careful not to change the type of the overall expression).
11891 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11892 but we can constant-fold them if they have constant operands. */
11894 #ifdef ENABLE_FOLD_CHECKING
11895 # define fold(x) fold_1 (x)
11896 static tree
fold_1 (tree
);
11902 const tree t
= expr
;
11903 enum tree_code code
= TREE_CODE (t
);
11904 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11906 location_t loc
= EXPR_LOCATION (expr
);
11908 /* Return right away if a constant. */
11909 if (kind
== tcc_constant
)
11912 /* CALL_EXPR-like objects with variable numbers of operands are
11913 treated specially. */
11914 if (kind
== tcc_vl_exp
)
11916 if (code
== CALL_EXPR
)
11918 tem
= fold_call_expr (loc
, expr
, false);
11919 return tem
? tem
: expr
;
11924 if (IS_EXPR_CODE_CLASS (kind
))
11926 tree type
= TREE_TYPE (t
);
11927 tree op0
, op1
, op2
;
11929 switch (TREE_CODE_LENGTH (code
))
11932 op0
= TREE_OPERAND (t
, 0);
11933 tem
= fold_unary_loc (loc
, code
, type
, op0
);
11934 return tem
? tem
: expr
;
11936 op0
= TREE_OPERAND (t
, 0);
11937 op1
= TREE_OPERAND (t
, 1);
11938 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
11939 return tem
? tem
: expr
;
11941 op0
= TREE_OPERAND (t
, 0);
11942 op1
= TREE_OPERAND (t
, 1);
11943 op2
= TREE_OPERAND (t
, 2);
11944 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
11945 return tem
? tem
: expr
;
11955 tree op0
= TREE_OPERAND (t
, 0);
11956 tree op1
= TREE_OPERAND (t
, 1);
11958 if (TREE_CODE (op1
) == INTEGER_CST
11959 && TREE_CODE (op0
) == CONSTRUCTOR
11960 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
11962 tree val
= get_array_ctor_element_at_index (op0
,
11963 wi::to_offset (op1
));
11971 /* Return a VECTOR_CST if possible. */
11974 tree type
= TREE_TYPE (t
);
11975 if (TREE_CODE (type
) != VECTOR_TYPE
)
11980 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
11981 if (! CONSTANT_CLASS_P (val
))
11984 return build_vector_from_ctor (type
, CONSTRUCTOR_ELTS (t
));
11988 return fold (DECL_INITIAL (t
));
11992 } /* switch (code) */
11995 #ifdef ENABLE_FOLD_CHECKING
11998 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
11999 hash_table
<nofree_ptr_hash
<const tree_node
> > *);
12000 static void fold_check_failed (const_tree
, const_tree
);
12001 void print_fold_checksum (const_tree
);
12003 /* When --enable-checking=fold, compute a digest of expr before
12004 and after actual fold call to see if fold did not accidentally
12005 change original expr. */
12011 struct md5_ctx ctx
;
12012 unsigned char checksum_before
[16], checksum_after
[16];
12013 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12015 md5_init_ctx (&ctx
);
12016 fold_checksum_tree (expr
, &ctx
, &ht
);
12017 md5_finish_ctx (&ctx
, checksum_before
);
12020 ret
= fold_1 (expr
);
12022 md5_init_ctx (&ctx
);
12023 fold_checksum_tree (expr
, &ctx
, &ht
);
12024 md5_finish_ctx (&ctx
, checksum_after
);
12026 if (memcmp (checksum_before
, checksum_after
, 16))
12027 fold_check_failed (expr
, ret
);
12033 print_fold_checksum (const_tree expr
)
12035 struct md5_ctx ctx
;
12036 unsigned char checksum
[16], cnt
;
12037 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12039 md5_init_ctx (&ctx
);
12040 fold_checksum_tree (expr
, &ctx
, &ht
);
12041 md5_finish_ctx (&ctx
, checksum
);
12042 for (cnt
= 0; cnt
< 16; ++cnt
)
12043 fprintf (stderr
, "%02x", checksum
[cnt
]);
12044 putc ('\n', stderr
);
12048 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
12050 internal_error ("fold check: original tree changed by fold");
12054 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
12055 hash_table
<nofree_ptr_hash
<const tree_node
> > *ht
)
12057 const tree_node
**slot
;
12058 enum tree_code code
;
12059 union tree_node buf
;
12065 slot
= ht
->find_slot (expr
, INSERT
);
12069 code
= TREE_CODE (expr
);
12070 if (TREE_CODE_CLASS (code
) == tcc_declaration
12071 && HAS_DECL_ASSEMBLER_NAME_P (expr
))
12073 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
12074 memcpy ((char *) &buf
, expr
, tree_size (expr
));
12075 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
12076 buf
.decl_with_vis
.symtab_node
= NULL
;
12077 expr
= (tree
) &buf
;
12079 else if (TREE_CODE_CLASS (code
) == tcc_type
12080 && (TYPE_POINTER_TO (expr
)
12081 || TYPE_REFERENCE_TO (expr
)
12082 || TYPE_CACHED_VALUES_P (expr
)
12083 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
12084 || TYPE_NEXT_VARIANT (expr
)
12085 || TYPE_ALIAS_SET_KNOWN_P (expr
)))
12087 /* Allow these fields to be modified. */
12089 memcpy ((char *) &buf
, expr
, tree_size (expr
));
12090 expr
= tmp
= (tree
) &buf
;
12091 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
12092 TYPE_POINTER_TO (tmp
) = NULL
;
12093 TYPE_REFERENCE_TO (tmp
) = NULL
;
12094 TYPE_NEXT_VARIANT (tmp
) = NULL
;
12095 TYPE_ALIAS_SET (tmp
) = -1;
12096 if (TYPE_CACHED_VALUES_P (tmp
))
12098 TYPE_CACHED_VALUES_P (tmp
) = 0;
12099 TYPE_CACHED_VALUES (tmp
) = NULL
;
12102 md5_process_bytes (expr
, tree_size (expr
), ctx
);
12103 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
12104 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
12105 if (TREE_CODE_CLASS (code
) != tcc_type
12106 && TREE_CODE_CLASS (code
) != tcc_declaration
12107 && code
!= TREE_LIST
12108 && code
!= SSA_NAME
12109 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
12110 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
12111 switch (TREE_CODE_CLASS (code
))
12117 md5_process_bytes (TREE_STRING_POINTER (expr
),
12118 TREE_STRING_LENGTH (expr
), ctx
);
12121 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
12122 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
12125 for (i
= 0; i
< (int) VECTOR_CST_NELTS (expr
); ++i
)
12126 fold_checksum_tree (VECTOR_CST_ELT (expr
, i
), ctx
, ht
);
12132 case tcc_exceptional
:
12136 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
12137 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
12138 expr
= TREE_CHAIN (expr
);
12139 goto recursive_label
;
12142 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
12143 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
12149 case tcc_expression
:
12150 case tcc_reference
:
12151 case tcc_comparison
:
12154 case tcc_statement
:
12156 len
= TREE_OPERAND_LENGTH (expr
);
12157 for (i
= 0; i
< len
; ++i
)
12158 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
12160 case tcc_declaration
:
12161 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
12162 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
12163 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
12165 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
12166 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
12167 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
12168 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
12169 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
12172 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
12174 if (TREE_CODE (expr
) == FUNCTION_DECL
)
12176 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
12177 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
12179 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
12183 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
12184 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
12185 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
12186 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
12187 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
12188 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
12189 if (INTEGRAL_TYPE_P (expr
)
12190 || SCALAR_FLOAT_TYPE_P (expr
))
12192 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
12193 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
12195 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
12196 if (TREE_CODE (expr
) == RECORD_TYPE
12197 || TREE_CODE (expr
) == UNION_TYPE
12198 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
12199 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
12200 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
12207 /* Helper function for outputting the checksum of a tree T. When
12208 debugging with gdb, you can "define mynext" to be "next" followed
12209 by "call debug_fold_checksum (op0)", then just trace down till the
12212 DEBUG_FUNCTION
void
12213 debug_fold_checksum (const_tree t
)
12216 unsigned char checksum
[16];
12217 struct md5_ctx ctx
;
12218 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12220 md5_init_ctx (&ctx
);
12221 fold_checksum_tree (t
, &ctx
, &ht
);
12222 md5_finish_ctx (&ctx
, checksum
);
12225 for (i
= 0; i
< 16; i
++)
12226 fprintf (stderr
, "%d ", checksum
[i
]);
12228 fprintf (stderr
, "\n");
12233 /* Fold a unary tree expression with code CODE of type TYPE with an
12234 operand OP0. LOC is the location of the resulting expression.
12235 Return a folded expression if successful. Otherwise, return a tree
12236 expression with code CODE of type TYPE with an operand OP0. */
12239 fold_build1_stat_loc (location_t loc
,
12240 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
12243 #ifdef ENABLE_FOLD_CHECKING
12244 unsigned char checksum_before
[16], checksum_after
[16];
12245 struct md5_ctx ctx
;
12246 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12248 md5_init_ctx (&ctx
);
12249 fold_checksum_tree (op0
, &ctx
, &ht
);
12250 md5_finish_ctx (&ctx
, checksum_before
);
12254 tem
= fold_unary_loc (loc
, code
, type
, op0
);
12256 tem
= build1_stat_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
12258 #ifdef ENABLE_FOLD_CHECKING
12259 md5_init_ctx (&ctx
);
12260 fold_checksum_tree (op0
, &ctx
, &ht
);
12261 md5_finish_ctx (&ctx
, checksum_after
);
12263 if (memcmp (checksum_before
, checksum_after
, 16))
12264 fold_check_failed (op0
, tem
);
12269 /* Fold a binary tree expression with code CODE of type TYPE with
12270 operands OP0 and OP1. LOC is the location of the resulting
12271 expression. Return a folded expression if successful. Otherwise,
12272 return a tree expression with code CODE of type TYPE with operands
12276 fold_build2_stat_loc (location_t loc
,
12277 enum tree_code code
, tree type
, tree op0
, tree op1
12281 #ifdef ENABLE_FOLD_CHECKING
12282 unsigned char checksum_before_op0
[16],
12283 checksum_before_op1
[16],
12284 checksum_after_op0
[16],
12285 checksum_after_op1
[16];
12286 struct md5_ctx ctx
;
12287 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12289 md5_init_ctx (&ctx
);
12290 fold_checksum_tree (op0
, &ctx
, &ht
);
12291 md5_finish_ctx (&ctx
, checksum_before_op0
);
12294 md5_init_ctx (&ctx
);
12295 fold_checksum_tree (op1
, &ctx
, &ht
);
12296 md5_finish_ctx (&ctx
, checksum_before_op1
);
12300 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
12302 tem
= build2_stat_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
12304 #ifdef ENABLE_FOLD_CHECKING
12305 md5_init_ctx (&ctx
);
12306 fold_checksum_tree (op0
, &ctx
, &ht
);
12307 md5_finish_ctx (&ctx
, checksum_after_op0
);
12310 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12311 fold_check_failed (op0
, tem
);
12313 md5_init_ctx (&ctx
);
12314 fold_checksum_tree (op1
, &ctx
, &ht
);
12315 md5_finish_ctx (&ctx
, checksum_after_op1
);
12317 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12318 fold_check_failed (op1
, tem
);
12323 /* Fold a ternary tree expression with code CODE of type TYPE with
12324 operands OP0, OP1, and OP2. Return a folded expression if
12325 successful. Otherwise, return a tree expression with code CODE of
12326 type TYPE with operands OP0, OP1, and OP2. */
12329 fold_build3_stat_loc (location_t loc
, enum tree_code code
, tree type
,
12330 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
12333 #ifdef ENABLE_FOLD_CHECKING
12334 unsigned char checksum_before_op0
[16],
12335 checksum_before_op1
[16],
12336 checksum_before_op2
[16],
12337 checksum_after_op0
[16],
12338 checksum_after_op1
[16],
12339 checksum_after_op2
[16];
12340 struct md5_ctx ctx
;
12341 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12343 md5_init_ctx (&ctx
);
12344 fold_checksum_tree (op0
, &ctx
, &ht
);
12345 md5_finish_ctx (&ctx
, checksum_before_op0
);
12348 md5_init_ctx (&ctx
);
12349 fold_checksum_tree (op1
, &ctx
, &ht
);
12350 md5_finish_ctx (&ctx
, checksum_before_op1
);
12353 md5_init_ctx (&ctx
);
12354 fold_checksum_tree (op2
, &ctx
, &ht
);
12355 md5_finish_ctx (&ctx
, checksum_before_op2
);
12359 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
12360 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
12362 tem
= build3_stat_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
12364 #ifdef ENABLE_FOLD_CHECKING
12365 md5_init_ctx (&ctx
);
12366 fold_checksum_tree (op0
, &ctx
, &ht
);
12367 md5_finish_ctx (&ctx
, checksum_after_op0
);
12370 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12371 fold_check_failed (op0
, tem
);
12373 md5_init_ctx (&ctx
);
12374 fold_checksum_tree (op1
, &ctx
, &ht
);
12375 md5_finish_ctx (&ctx
, checksum_after_op1
);
12378 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12379 fold_check_failed (op1
, tem
);
12381 md5_init_ctx (&ctx
);
12382 fold_checksum_tree (op2
, &ctx
, &ht
);
12383 md5_finish_ctx (&ctx
, checksum_after_op2
);
12385 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
12386 fold_check_failed (op2
, tem
);
12391 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12392 arguments in ARGARRAY, and a null static chain.
12393 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12394 of type TYPE from the given operands as constructed by build_call_array. */
12397 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
12398 int nargs
, tree
*argarray
)
12401 #ifdef ENABLE_FOLD_CHECKING
12402 unsigned char checksum_before_fn
[16],
12403 checksum_before_arglist
[16],
12404 checksum_after_fn
[16],
12405 checksum_after_arglist
[16];
12406 struct md5_ctx ctx
;
12407 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12410 md5_init_ctx (&ctx
);
12411 fold_checksum_tree (fn
, &ctx
, &ht
);
12412 md5_finish_ctx (&ctx
, checksum_before_fn
);
12415 md5_init_ctx (&ctx
);
12416 for (i
= 0; i
< nargs
; i
++)
12417 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12418 md5_finish_ctx (&ctx
, checksum_before_arglist
);
12422 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
12424 tem
= build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12426 #ifdef ENABLE_FOLD_CHECKING
12427 md5_init_ctx (&ctx
);
12428 fold_checksum_tree (fn
, &ctx
, &ht
);
12429 md5_finish_ctx (&ctx
, checksum_after_fn
);
12432 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
12433 fold_check_failed (fn
, tem
);
12435 md5_init_ctx (&ctx
);
12436 for (i
= 0; i
< nargs
; i
++)
12437 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12438 md5_finish_ctx (&ctx
, checksum_after_arglist
);
12440 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
12441 fold_check_failed (NULL_TREE
, tem
);
12446 /* Perform constant folding and related simplification of initializer
12447 expression EXPR. These behave identically to "fold_buildN" but ignore
12448 potential run-time traps and exceptions that fold must preserve. */
12450 #define START_FOLD_INIT \
12451 int saved_signaling_nans = flag_signaling_nans;\
12452 int saved_trapping_math = flag_trapping_math;\
12453 int saved_rounding_math = flag_rounding_math;\
12454 int saved_trapv = flag_trapv;\
12455 int saved_folding_initializer = folding_initializer;\
12456 flag_signaling_nans = 0;\
12457 flag_trapping_math = 0;\
12458 flag_rounding_math = 0;\
12460 folding_initializer = 1;
12462 #define END_FOLD_INIT \
12463 flag_signaling_nans = saved_signaling_nans;\
12464 flag_trapping_math = saved_trapping_math;\
12465 flag_rounding_math = saved_rounding_math;\
12466 flag_trapv = saved_trapv;\
12467 folding_initializer = saved_folding_initializer;
12470 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
12471 tree type
, tree op
)
12476 result
= fold_build1_loc (loc
, code
, type
, op
);
12483 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
12484 tree type
, tree op0
, tree op1
)
12489 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
12496 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
12497 int nargs
, tree
*argarray
)
12502 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12508 #undef START_FOLD_INIT
12509 #undef END_FOLD_INIT
12511 /* Determine if first argument is a multiple of second argument. Return 0 if
12512 it is not, or we cannot easily determined it to be.
12514 An example of the sort of thing we care about (at this point; this routine
12515 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12516 fold cases do now) is discovering that
12518 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12524 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12526 This code also handles discovering that
12528 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12530 is a multiple of 8 so we don't have to worry about dealing with a
12531 possible remainder.
12533 Note that we *look* inside a SAVE_EXPR only to determine how it was
12534 calculated; it is not safe for fold to do much of anything else with the
12535 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12536 at run time. For example, the latter example above *cannot* be implemented
12537 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12538 evaluation time of the original SAVE_EXPR is not necessarily the same at
12539 the time the new expression is evaluated. The only optimization of this
12540 sort that would be valid is changing
12542 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12546 SAVE_EXPR (I) * SAVE_EXPR (J)
12548 (where the same SAVE_EXPR (J) is used in the original and the
12549 transformed version). */
12552 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
12557 if (operand_equal_p (top
, bottom
, 0))
12560 if (TREE_CODE (type
) != INTEGER_TYPE
)
12563 switch (TREE_CODE (top
))
12566 /* Bitwise and provides a power of two multiple. If the mask is
12567 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12568 if (!integer_pow2p (bottom
))
12573 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12574 || multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12577 /* It is impossible to prove if op0 - op1 is multiple of bottom
12578 precisely, so be conservative here checking if both op0 and op1
12579 are multiple of bottom. Note we check the second operand first
12580 since it's usually simpler. */
12581 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12582 && multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12585 /* The same as MINUS_EXPR, but handle cases like op0 + 0xfffffffd
12586 as op0 - 3 if the expression has unsigned type. For example,
12587 (X / 3) + 0xfffffffd is multiple of 3, but 0xfffffffd is not. */
12588 op1
= TREE_OPERAND (top
, 1);
12589 if (TYPE_UNSIGNED (type
)
12590 && TREE_CODE (op1
) == INTEGER_CST
&& tree_int_cst_sign_bit (op1
))
12591 op1
= fold_build1 (NEGATE_EXPR
, type
, op1
);
12592 return (multiple_of_p (type
, op1
, bottom
)
12593 && multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12596 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
12598 op1
= TREE_OPERAND (top
, 1);
12599 /* const_binop may not detect overflow correctly,
12600 so check for it explicitly here. */
12601 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
12602 && 0 != (t1
= fold_convert (type
,
12603 const_binop (LSHIFT_EXPR
,
12606 && !TREE_OVERFLOW (t1
))
12607 return multiple_of_p (type
, t1
, bottom
);
12612 /* Can't handle conversions from non-integral or wider integral type. */
12613 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
12614 || (TYPE_PRECISION (type
)
12615 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
12621 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
12624 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12625 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
12628 if (TREE_CODE (bottom
) != INTEGER_CST
12629 || integer_zerop (bottom
)
12630 || (TYPE_UNSIGNED (type
)
12631 && (tree_int_cst_sgn (top
) < 0
12632 || tree_int_cst_sgn (bottom
) < 0)))
12634 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
12638 if (TREE_CODE (bottom
) == INTEGER_CST
12639 && (stmt
= SSA_NAME_DEF_STMT (top
)) != NULL
12640 && gimple_code (stmt
) == GIMPLE_ASSIGN
)
12642 enum tree_code code
= gimple_assign_rhs_code (stmt
);
12644 /* Check for special cases to see if top is defined as multiple
12647 top = (X & ~(bottom - 1) ; bottom is power of 2
12653 if (code
== BIT_AND_EXPR
12654 && (op2
= gimple_assign_rhs2 (stmt
)) != NULL_TREE
12655 && TREE_CODE (op2
) == INTEGER_CST
12656 && integer_pow2p (bottom
)
12657 && wi::multiple_of_p (wi::to_widest (op2
),
12658 wi::to_widest (bottom
), UNSIGNED
))
12661 op1
= gimple_assign_rhs1 (stmt
);
12662 if (code
== MINUS_EXPR
12663 && (op2
= gimple_assign_rhs2 (stmt
)) != NULL_TREE
12664 && TREE_CODE (op2
) == SSA_NAME
12665 && (stmt
= SSA_NAME_DEF_STMT (op2
)) != NULL
12666 && gimple_code (stmt
) == GIMPLE_ASSIGN
12667 && (code
= gimple_assign_rhs_code (stmt
)) == TRUNC_MOD_EXPR
12668 && operand_equal_p (op1
, gimple_assign_rhs1 (stmt
), 0)
12669 && operand_equal_p (bottom
, gimple_assign_rhs2 (stmt
), 0))
12680 #define tree_expr_nonnegative_warnv_p(X, Y) \
12681 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
12683 #define RECURSE(X) \
12684 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12686 /* Return true if CODE or TYPE is known to be non-negative. */
12689 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
12691 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
12692 && truth_value_p (code
))
12693 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12694 have a signed:1 type (where the value is -1 and 0). */
12699 /* Return true if (CODE OP0) is known to be non-negative. If the return
12700 value is based on the assumption that signed overflow is undefined,
12701 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12702 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12705 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12706 bool *strict_overflow_p
, int depth
)
12708 if (TYPE_UNSIGNED (type
))
12714 /* We can't return 1 if flag_wrapv is set because
12715 ABS_EXPR<INT_MIN> = INT_MIN. */
12716 if (!ANY_INTEGRAL_TYPE_P (type
))
12718 if (TYPE_OVERFLOW_UNDEFINED (type
))
12720 *strict_overflow_p
= true;
12725 case NON_LVALUE_EXPR
:
12727 case FIX_TRUNC_EXPR
:
12728 return RECURSE (op0
);
12732 tree inner_type
= TREE_TYPE (op0
);
12733 tree outer_type
= type
;
12735 if (TREE_CODE (outer_type
) == REAL_TYPE
)
12737 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12738 return RECURSE (op0
);
12739 if (INTEGRAL_TYPE_P (inner_type
))
12741 if (TYPE_UNSIGNED (inner_type
))
12743 return RECURSE (op0
);
12746 else if (INTEGRAL_TYPE_P (outer_type
))
12748 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12749 return RECURSE (op0
);
12750 if (INTEGRAL_TYPE_P (inner_type
))
12751 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
12752 && TYPE_UNSIGNED (inner_type
);
12758 return tree_simple_nonnegative_warnv_p (code
, type
);
12761 /* We don't know sign of `t', so be conservative and return false. */
12765 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12766 value is based on the assumption that signed overflow is undefined,
12767 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12768 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12771 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12772 tree op1
, bool *strict_overflow_p
,
12775 if (TYPE_UNSIGNED (type
))
12780 case POINTER_PLUS_EXPR
:
12782 if (FLOAT_TYPE_P (type
))
12783 return RECURSE (op0
) && RECURSE (op1
);
12785 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12786 both unsigned and at least 2 bits shorter than the result. */
12787 if (TREE_CODE (type
) == INTEGER_TYPE
12788 && TREE_CODE (op0
) == NOP_EXPR
12789 && TREE_CODE (op1
) == NOP_EXPR
)
12791 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
12792 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
12793 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
12794 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
12796 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
12797 TYPE_PRECISION (inner2
)) + 1;
12798 return prec
< TYPE_PRECISION (type
);
12804 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12806 /* x * x is always non-negative for floating point x
12807 or without overflow. */
12808 if (operand_equal_p (op0
, op1
, 0)
12809 || (RECURSE (op0
) && RECURSE (op1
)))
12811 if (ANY_INTEGRAL_TYPE_P (type
)
12812 && TYPE_OVERFLOW_UNDEFINED (type
))
12813 *strict_overflow_p
= true;
12818 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12819 both unsigned and their total bits is shorter than the result. */
12820 if (TREE_CODE (type
) == INTEGER_TYPE
12821 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
12822 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
12824 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
12825 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
12827 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
12828 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
12831 bool unsigned0
= TYPE_UNSIGNED (inner0
);
12832 bool unsigned1
= TYPE_UNSIGNED (inner1
);
12834 if (TREE_CODE (op0
) == INTEGER_CST
)
12835 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
12837 if (TREE_CODE (op1
) == INTEGER_CST
)
12838 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
12840 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
12841 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
12843 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
12844 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
12845 : TYPE_PRECISION (inner0
);
12847 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
12848 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
12849 : TYPE_PRECISION (inner1
);
12851 return precision0
+ precision1
< TYPE_PRECISION (type
);
12858 return RECURSE (op0
) || RECURSE (op1
);
12864 case TRUNC_DIV_EXPR
:
12865 case CEIL_DIV_EXPR
:
12866 case FLOOR_DIV_EXPR
:
12867 case ROUND_DIV_EXPR
:
12868 return RECURSE (op0
) && RECURSE (op1
);
12870 case TRUNC_MOD_EXPR
:
12871 return RECURSE (op0
);
12873 case FLOOR_MOD_EXPR
:
12874 return RECURSE (op1
);
12876 case CEIL_MOD_EXPR
:
12877 case ROUND_MOD_EXPR
:
12879 return tree_simple_nonnegative_warnv_p (code
, type
);
12882 /* We don't know sign of `t', so be conservative and return false. */
12886 /* Return true if T is known to be non-negative. If the return
12887 value is based on the assumption that signed overflow is undefined,
12888 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12889 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12892 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
12894 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
12897 switch (TREE_CODE (t
))
12900 return tree_int_cst_sgn (t
) >= 0;
12903 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
12906 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
12909 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
12912 /* Limit the depth of recursion to avoid quadratic behavior.
12913 This is expected to catch almost all occurrences in practice.
12914 If this code misses important cases that unbounded recursion
12915 would not, passes that need this information could be revised
12916 to provide it through dataflow propagation. */
12917 return (!name_registered_for_update_p (t
)
12918 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
12919 && gimple_stmt_nonnegative_warnv_p (SSA_NAME_DEF_STMT (t
),
12920 strict_overflow_p
, depth
));
12923 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
12927 /* Return true if T is known to be non-negative. If the return
12928 value is based on the assumption that signed overflow is undefined,
12929 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12930 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12933 tree_call_nonnegative_warnv_p (tree type
, combined_fn fn
, tree arg0
, tree arg1
,
12934 bool *strict_overflow_p
, int depth
)
12955 case CFN_BUILT_IN_BSWAP32
:
12956 case CFN_BUILT_IN_BSWAP64
:
12961 /* sqrt(-0.0) is -0.0. */
12962 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
12964 return RECURSE (arg0
);
12990 CASE_CFN_NEARBYINT
:
12997 CASE_CFN_SIGNIFICAND
:
13001 /* True if the 1st argument is nonnegative. */
13002 return RECURSE (arg0
);
13005 /* True if the 1st OR 2nd arguments are nonnegative. */
13006 return RECURSE (arg0
) || RECURSE (arg1
);
13009 /* True if the 1st AND 2nd arguments are nonnegative. */
13010 return RECURSE (arg0
) && RECURSE (arg1
);
13013 /* True if the 2nd argument is nonnegative. */
13014 return RECURSE (arg1
);
13017 /* True if the 1st argument is nonnegative or the second
13018 argument is an even integer. */
13019 if (TREE_CODE (arg1
) == INTEGER_CST
13020 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
13022 return RECURSE (arg0
);
13025 /* True if the 1st argument is nonnegative or the second
13026 argument is an even integer valued real. */
13027 if (TREE_CODE (arg1
) == REAL_CST
)
13032 c
= TREE_REAL_CST (arg1
);
13033 n
= real_to_integer (&c
);
13036 REAL_VALUE_TYPE cint
;
13037 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
13038 if (real_identical (&c
, &cint
))
13042 return RECURSE (arg0
);
13047 return tree_simple_nonnegative_warnv_p (CALL_EXPR
, type
);
13050 /* Return true if T is known to be non-negative. If the return
13051 value is based on the assumption that signed overflow is undefined,
13052 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13053 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13056 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13058 enum tree_code code
= TREE_CODE (t
);
13059 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
13066 tree temp
= TARGET_EXPR_SLOT (t
);
13067 t
= TARGET_EXPR_INITIAL (t
);
13069 /* If the initializer is non-void, then it's a normal expression
13070 that will be assigned to the slot. */
13071 if (!VOID_TYPE_P (t
))
13072 return RECURSE (t
);
13074 /* Otherwise, the initializer sets the slot in some way. One common
13075 way is an assignment statement at the end of the initializer. */
13078 if (TREE_CODE (t
) == BIND_EXPR
)
13079 t
= expr_last (BIND_EXPR_BODY (t
));
13080 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
13081 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
13082 t
= expr_last (TREE_OPERAND (t
, 0));
13083 else if (TREE_CODE (t
) == STATEMENT_LIST
)
13088 if (TREE_CODE (t
) == MODIFY_EXPR
13089 && TREE_OPERAND (t
, 0) == temp
)
13090 return RECURSE (TREE_OPERAND (t
, 1));
13097 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
13098 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
13100 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
13101 get_call_combined_fn (t
),
13104 strict_overflow_p
, depth
);
13106 case COMPOUND_EXPR
:
13108 return RECURSE (TREE_OPERAND (t
, 1));
13111 return RECURSE (expr_last (TREE_OPERAND (t
, 1)));
13114 return RECURSE (TREE_OPERAND (t
, 0));
13117 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
13122 #undef tree_expr_nonnegative_warnv_p
13124 /* Return true if T is known to be non-negative. If the return
13125 value is based on the assumption that signed overflow is undefined,
13126 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13127 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13130 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13132 enum tree_code code
;
13133 if (t
== error_mark_node
)
13136 code
= TREE_CODE (t
);
13137 switch (TREE_CODE_CLASS (code
))
13140 case tcc_comparison
:
13141 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13143 TREE_OPERAND (t
, 0),
13144 TREE_OPERAND (t
, 1),
13145 strict_overflow_p
, depth
);
13148 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13150 TREE_OPERAND (t
, 0),
13151 strict_overflow_p
, depth
);
13154 case tcc_declaration
:
13155 case tcc_reference
:
13156 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13164 case TRUTH_AND_EXPR
:
13165 case TRUTH_OR_EXPR
:
13166 case TRUTH_XOR_EXPR
:
13167 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13169 TREE_OPERAND (t
, 0),
13170 TREE_OPERAND (t
, 1),
13171 strict_overflow_p
, depth
);
13172 case TRUTH_NOT_EXPR
:
13173 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13175 TREE_OPERAND (t
, 0),
13176 strict_overflow_p
, depth
);
13183 case WITH_SIZE_EXPR
:
13185 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13188 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13192 /* Return true if `t' is known to be non-negative. Handle warnings
13193 about undefined signed overflow. */
13196 tree_expr_nonnegative_p (tree t
)
13198 bool ret
, strict_overflow_p
;
13200 strict_overflow_p
= false;
13201 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
13202 if (strict_overflow_p
)
13203 fold_overflow_warning (("assuming signed overflow does not occur when "
13204 "determining that expression is always "
13206 WARN_STRICT_OVERFLOW_MISC
);
13211 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13212 For floating point we further ensure that T is not denormal.
13213 Similar logic is present in nonzero_address in rtlanal.h.
13215 If the return value is based on the assumption that signed overflow
13216 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13217 change *STRICT_OVERFLOW_P. */
13220 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
13221 bool *strict_overflow_p
)
13226 return tree_expr_nonzero_warnv_p (op0
,
13227 strict_overflow_p
);
13231 tree inner_type
= TREE_TYPE (op0
);
13232 tree outer_type
= type
;
13234 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
13235 && tree_expr_nonzero_warnv_p (op0
,
13236 strict_overflow_p
));
13240 case NON_LVALUE_EXPR
:
13241 return tree_expr_nonzero_warnv_p (op0
,
13242 strict_overflow_p
);
13251 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13252 For floating point we further ensure that T is not denormal.
13253 Similar logic is present in nonzero_address in rtlanal.h.
13255 If the return value is based on the assumption that signed overflow
13256 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13257 change *STRICT_OVERFLOW_P. */
13260 tree_binary_nonzero_warnv_p (enum tree_code code
,
13263 tree op1
, bool *strict_overflow_p
)
13265 bool sub_strict_overflow_p
;
13268 case POINTER_PLUS_EXPR
:
13270 if (ANY_INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_UNDEFINED (type
))
13272 /* With the presence of negative values it is hard
13273 to say something. */
13274 sub_strict_overflow_p
= false;
13275 if (!tree_expr_nonnegative_warnv_p (op0
,
13276 &sub_strict_overflow_p
)
13277 || !tree_expr_nonnegative_warnv_p (op1
,
13278 &sub_strict_overflow_p
))
13280 /* One of operands must be positive and the other non-negative. */
13281 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13282 overflows, on a twos-complement machine the sum of two
13283 nonnegative numbers can never be zero. */
13284 return (tree_expr_nonzero_warnv_p (op0
,
13286 || tree_expr_nonzero_warnv_p (op1
,
13287 strict_overflow_p
));
13292 if (TYPE_OVERFLOW_UNDEFINED (type
))
13294 if (tree_expr_nonzero_warnv_p (op0
,
13296 && tree_expr_nonzero_warnv_p (op1
,
13297 strict_overflow_p
))
13299 *strict_overflow_p
= true;
13306 sub_strict_overflow_p
= false;
13307 if (tree_expr_nonzero_warnv_p (op0
,
13308 &sub_strict_overflow_p
)
13309 && tree_expr_nonzero_warnv_p (op1
,
13310 &sub_strict_overflow_p
))
13312 if (sub_strict_overflow_p
)
13313 *strict_overflow_p
= true;
13318 sub_strict_overflow_p
= false;
13319 if (tree_expr_nonzero_warnv_p (op0
,
13320 &sub_strict_overflow_p
))
13322 if (sub_strict_overflow_p
)
13323 *strict_overflow_p
= true;
13325 /* When both operands are nonzero, then MAX must be too. */
13326 if (tree_expr_nonzero_warnv_p (op1
,
13327 strict_overflow_p
))
13330 /* MAX where operand 0 is positive is positive. */
13331 return tree_expr_nonnegative_warnv_p (op0
,
13332 strict_overflow_p
);
13334 /* MAX where operand 1 is positive is positive. */
13335 else if (tree_expr_nonzero_warnv_p (op1
,
13336 &sub_strict_overflow_p
)
13337 && tree_expr_nonnegative_warnv_p (op1
,
13338 &sub_strict_overflow_p
))
13340 if (sub_strict_overflow_p
)
13341 *strict_overflow_p
= true;
13347 return (tree_expr_nonzero_warnv_p (op1
,
13349 || tree_expr_nonzero_warnv_p (op0
,
13350 strict_overflow_p
));
13359 /* Return true when T is an address and is known to be nonzero.
13360 For floating point we further ensure that T is not denormal.
13361 Similar logic is present in nonzero_address in rtlanal.h.
13363 If the return value is based on the assumption that signed overflow
13364 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13365 change *STRICT_OVERFLOW_P. */
13368 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
13370 bool sub_strict_overflow_p
;
13371 switch (TREE_CODE (t
))
13374 return !integer_zerop (t
);
13378 tree base
= TREE_OPERAND (t
, 0);
13380 if (!DECL_P (base
))
13381 base
= get_base_address (base
);
13383 if (base
&& TREE_CODE (base
) == TARGET_EXPR
)
13384 base
= TARGET_EXPR_SLOT (base
);
13389 /* For objects in symbol table check if we know they are non-zero.
13390 Don't do anything for variables and functions before symtab is built;
13391 it is quite possible that they will be declared weak later. */
13392 int nonzero_addr
= maybe_nonzero_address (base
);
13393 if (nonzero_addr
>= 0)
13394 return nonzero_addr
;
13396 /* Function local objects are never NULL. */
13398 && (DECL_CONTEXT (base
)
13399 && TREE_CODE (DECL_CONTEXT (base
)) == FUNCTION_DECL
13400 && auto_var_in_fn_p (base
, DECL_CONTEXT (base
))))
13403 /* Constants are never weak. */
13404 if (CONSTANT_CLASS_P (base
))
13411 sub_strict_overflow_p
= false;
13412 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
13413 &sub_strict_overflow_p
)
13414 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
13415 &sub_strict_overflow_p
))
13417 if (sub_strict_overflow_p
)
13418 *strict_overflow_p
= true;
13429 #define integer_valued_real_p(X) \
13430 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
13432 #define RECURSE(X) \
13433 ((integer_valued_real_p) (X, depth + 1))
13435 /* Return true if the floating point result of (CODE OP0) has an
13436 integer value. We also allow +Inf, -Inf and NaN to be considered
13437 integer values. Return false for signaling NaN.
13439 DEPTH is the current nesting depth of the query. */
13442 integer_valued_real_unary_p (tree_code code
, tree op0
, int depth
)
13450 return RECURSE (op0
);
13454 tree type
= TREE_TYPE (op0
);
13455 if (TREE_CODE (type
) == INTEGER_TYPE
)
13457 if (TREE_CODE (type
) == REAL_TYPE
)
13458 return RECURSE (op0
);
13468 /* Return true if the floating point result of (CODE OP0 OP1) has an
13469 integer value. We also allow +Inf, -Inf and NaN to be considered
13470 integer values. Return false for signaling NaN.
13472 DEPTH is the current nesting depth of the query. */
13475 integer_valued_real_binary_p (tree_code code
, tree op0
, tree op1
, int depth
)
13484 return RECURSE (op0
) && RECURSE (op1
);
13492 /* Return true if the floating point result of calling FNDECL with arguments
13493 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13494 considered integer values. Return false for signaling NaN. If FNDECL
13495 takes fewer than 2 arguments, the remaining ARGn are null.
13497 DEPTH is the current nesting depth of the query. */
13500 integer_valued_real_call_p (combined_fn fn
, tree arg0
, tree arg1
, int depth
)
13506 CASE_CFN_NEARBYINT
:
13514 return RECURSE (arg0
) && RECURSE (arg1
);
13522 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13523 has an integer value. We also allow +Inf, -Inf and NaN to be
13524 considered integer values. Return false for signaling NaN.
13526 DEPTH is the current nesting depth of the query. */
13529 integer_valued_real_single_p (tree t
, int depth
)
13531 switch (TREE_CODE (t
))
13534 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
13537 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
13540 /* Limit the depth of recursion to avoid quadratic behavior.
13541 This is expected to catch almost all occurrences in practice.
13542 If this code misses important cases that unbounded recursion
13543 would not, passes that need this information could be revised
13544 to provide it through dataflow propagation. */
13545 return (!name_registered_for_update_p (t
)
13546 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
13547 && gimple_stmt_integer_valued_real_p (SSA_NAME_DEF_STMT (t
),
13556 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13557 has an integer value. We also allow +Inf, -Inf and NaN to be
13558 considered integer values. Return false for signaling NaN.
13560 DEPTH is the current nesting depth of the query. */
13563 integer_valued_real_invalid_p (tree t
, int depth
)
13565 switch (TREE_CODE (t
))
13567 case COMPOUND_EXPR
:
13570 return RECURSE (TREE_OPERAND (t
, 1));
13573 return RECURSE (TREE_OPERAND (t
, 0));
13582 #undef integer_valued_real_p
13584 /* Return true if the floating point expression T has an integer value.
13585 We also allow +Inf, -Inf and NaN to be considered integer values.
13586 Return false for signaling NaN.
13588 DEPTH is the current nesting depth of the query. */
13591 integer_valued_real_p (tree t
, int depth
)
13593 if (t
== error_mark_node
)
13596 tree_code code
= TREE_CODE (t
);
13597 switch (TREE_CODE_CLASS (code
))
13600 case tcc_comparison
:
13601 return integer_valued_real_binary_p (code
, TREE_OPERAND (t
, 0),
13602 TREE_OPERAND (t
, 1), depth
);
13605 return integer_valued_real_unary_p (code
, TREE_OPERAND (t
, 0), depth
);
13608 case tcc_declaration
:
13609 case tcc_reference
:
13610 return integer_valued_real_single_p (t
, depth
);
13620 return integer_valued_real_single_p (t
, depth
);
13624 tree arg0
= (call_expr_nargs (t
) > 0
13625 ? CALL_EXPR_ARG (t
, 0)
13627 tree arg1
= (call_expr_nargs (t
) > 1
13628 ? CALL_EXPR_ARG (t
, 1)
13630 return integer_valued_real_call_p (get_call_combined_fn (t
),
13631 arg0
, arg1
, depth
);
13635 return integer_valued_real_invalid_p (t
, depth
);
13639 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13640 attempt to fold the expression to a constant without modifying TYPE,
13643 If the expression could be simplified to a constant, then return
13644 the constant. If the expression would not be simplified to a
13645 constant, then return NULL_TREE. */
13648 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
13650 tree tem
= fold_binary (code
, type
, op0
, op1
);
13651 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13654 /* Given the components of a unary expression CODE, TYPE and OP0,
13655 attempt to fold the expression to a constant without modifying
13658 If the expression could be simplified to a constant, then return
13659 the constant. If the expression would not be simplified to a
13660 constant, then return NULL_TREE. */
13663 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
13665 tree tem
= fold_unary (code
, type
, op0
);
13666 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13669 /* If EXP represents referencing an element in a constant string
13670 (either via pointer arithmetic or array indexing), return the
13671 tree representing the value accessed, otherwise return NULL. */
13674 fold_read_from_constant_string (tree exp
)
13676 if ((TREE_CODE (exp
) == INDIRECT_REF
13677 || TREE_CODE (exp
) == ARRAY_REF
)
13678 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
13680 tree exp1
= TREE_OPERAND (exp
, 0);
13683 location_t loc
= EXPR_LOCATION (exp
);
13685 if (TREE_CODE (exp
) == INDIRECT_REF
)
13686 string
= string_constant (exp1
, &index
);
13689 tree low_bound
= array_ref_low_bound (exp
);
13690 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
13692 /* Optimize the special-case of a zero lower bound.
13694 We convert the low_bound to sizetype to avoid some problems
13695 with constant folding. (E.g. suppose the lower bound is 1,
13696 and its mode is QI. Without the conversion,l (ARRAY
13697 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13698 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13699 if (! integer_zerop (low_bound
))
13700 index
= size_diffop_loc (loc
, index
,
13701 fold_convert_loc (loc
, sizetype
, low_bound
));
13707 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
13708 && TREE_CODE (string
) == STRING_CST
13709 && TREE_CODE (index
) == INTEGER_CST
13710 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
13711 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))))
13713 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))) == 1))
13714 return build_int_cst_type (TREE_TYPE (exp
),
13715 (TREE_STRING_POINTER (string
)
13716 [TREE_INT_CST_LOW (index
)]));
13721 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13722 an integer constant, real, or fixed-point constant.
13724 TYPE is the type of the result. */
13727 fold_negate_const (tree arg0
, tree type
)
13729 tree t
= NULL_TREE
;
13731 switch (TREE_CODE (arg0
))
13736 wide_int val
= wi::neg (arg0
, &overflow
);
13737 t
= force_fit_type (type
, val
, 1,
13738 (overflow
| TREE_OVERFLOW (arg0
))
13739 && !TYPE_UNSIGNED (type
));
13744 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13749 FIXED_VALUE_TYPE f
;
13750 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
13751 &(TREE_FIXED_CST (arg0
)), NULL
,
13752 TYPE_SATURATING (type
));
13753 t
= build_fixed (type
, f
);
13754 /* Propagate overflow flags. */
13755 if (overflow_p
| TREE_OVERFLOW (arg0
))
13756 TREE_OVERFLOW (t
) = 1;
13761 gcc_unreachable ();
13767 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13768 an integer constant or real constant.
13770 TYPE is the type of the result. */
13773 fold_abs_const (tree arg0
, tree type
)
13775 tree t
= NULL_TREE
;
13777 switch (TREE_CODE (arg0
))
13781 /* If the value is unsigned or non-negative, then the absolute value
13782 is the same as the ordinary value. */
13783 if (!wi::neg_p (arg0
, TYPE_SIGN (type
)))
13786 /* If the value is negative, then the absolute value is
13791 wide_int val
= wi::neg (arg0
, &overflow
);
13792 t
= force_fit_type (type
, val
, -1,
13793 overflow
| TREE_OVERFLOW (arg0
));
13799 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
13800 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13806 gcc_unreachable ();
13812 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13813 constant. TYPE is the type of the result. */
13816 fold_not_const (const_tree arg0
, tree type
)
13818 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
13820 return force_fit_type (type
, wi::bit_not (arg0
), 0, TREE_OVERFLOW (arg0
));
13823 /* Given CODE, a relational operator, the target type, TYPE and two
13824 constant operands OP0 and OP1, return the result of the
13825 relational operation. If the result is not a compile time
13826 constant, then return NULL_TREE. */
13829 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
13831 int result
, invert
;
13833 /* From here on, the only cases we handle are when the result is
13834 known to be a constant. */
13836 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
13838 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
13839 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
13841 /* Handle the cases where either operand is a NaN. */
13842 if (real_isnan (c0
) || real_isnan (c1
))
13852 case UNORDERED_EXPR
:
13866 if (flag_trapping_math
)
13872 gcc_unreachable ();
13875 return constant_boolean_node (result
, type
);
13878 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
13881 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
13883 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
13884 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
13885 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
13888 /* Handle equality/inequality of complex constants. */
13889 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
13891 tree rcond
= fold_relational_const (code
, type
,
13892 TREE_REALPART (op0
),
13893 TREE_REALPART (op1
));
13894 tree icond
= fold_relational_const (code
, type
,
13895 TREE_IMAGPART (op0
),
13896 TREE_IMAGPART (op1
));
13897 if (code
== EQ_EXPR
)
13898 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
13899 else if (code
== NE_EXPR
)
13900 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
13905 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
13907 if (!VECTOR_TYPE_P (type
))
13909 /* Have vector comparison with scalar boolean result. */
13910 gcc_assert ((code
== EQ_EXPR
|| code
== NE_EXPR
)
13911 && VECTOR_CST_NELTS (op0
) == VECTOR_CST_NELTS (op1
));
13912 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (op0
); i
++)
13914 tree elem0
= VECTOR_CST_ELT (op0
, i
);
13915 tree elem1
= VECTOR_CST_ELT (op1
, i
);
13916 tree tmp
= fold_relational_const (code
, type
, elem0
, elem1
);
13917 if (tmp
== NULL_TREE
)
13919 if (integer_zerop (tmp
))
13920 return constant_boolean_node (false, type
);
13922 return constant_boolean_node (true, type
);
13924 unsigned count
= VECTOR_CST_NELTS (op0
);
13925 tree
*elts
= XALLOCAVEC (tree
, count
);
13926 gcc_assert (VECTOR_CST_NELTS (op1
) == count
13927 && TYPE_VECTOR_SUBPARTS (type
) == count
);
13929 for (unsigned i
= 0; i
< count
; i
++)
13931 tree elem_type
= TREE_TYPE (type
);
13932 tree elem0
= VECTOR_CST_ELT (op0
, i
);
13933 tree elem1
= VECTOR_CST_ELT (op1
, i
);
13935 tree tem
= fold_relational_const (code
, elem_type
,
13938 if (tem
== NULL_TREE
)
13941 elts
[i
] = build_int_cst (elem_type
, integer_zerop (tem
) ? 0 : -1);
13944 return build_vector (type
, elts
);
13947 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
13949 To compute GT, swap the arguments and do LT.
13950 To compute GE, do LT and invert the result.
13951 To compute LE, swap the arguments, do LT and invert the result.
13952 To compute NE, do EQ and invert the result.
13954 Therefore, the code below must handle only EQ and LT. */
13956 if (code
== LE_EXPR
|| code
== GT_EXPR
)
13958 std::swap (op0
, op1
);
13959 code
= swap_tree_comparison (code
);
13962 /* Note that it is safe to invert for real values here because we
13963 have already handled the one case that it matters. */
13966 if (code
== NE_EXPR
|| code
== GE_EXPR
)
13969 code
= invert_tree_comparison (code
, false);
13972 /* Compute a result for LT or EQ if args permit;
13973 Otherwise return T. */
13974 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
13976 if (code
== EQ_EXPR
)
13977 result
= tree_int_cst_equal (op0
, op1
);
13979 result
= tree_int_cst_lt (op0
, op1
);
13986 return constant_boolean_node (result
, type
);
13989 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
13990 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
13994 fold_build_cleanup_point_expr (tree type
, tree expr
)
13996 /* If the expression does not have side effects then we don't have to wrap
13997 it with a cleanup point expression. */
13998 if (!TREE_SIDE_EFFECTS (expr
))
14001 /* If the expression is a return, check to see if the expression inside the
14002 return has no side effects or the right hand side of the modify expression
14003 inside the return. If either don't have side effects set we don't need to
14004 wrap the expression in a cleanup point expression. Note we don't check the
14005 left hand side of the modify because it should always be a return decl. */
14006 if (TREE_CODE (expr
) == RETURN_EXPR
)
14008 tree op
= TREE_OPERAND (expr
, 0);
14009 if (!op
|| !TREE_SIDE_EFFECTS (op
))
14011 op
= TREE_OPERAND (op
, 1);
14012 if (!TREE_SIDE_EFFECTS (op
))
14016 return build1 (CLEANUP_POINT_EXPR
, type
, expr
);
14019 /* Given a pointer value OP0 and a type TYPE, return a simplified version
14020 of an indirection through OP0, or NULL_TREE if no simplification is
14024 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
14030 subtype
= TREE_TYPE (sub
);
14031 if (!POINTER_TYPE_P (subtype
))
14034 if (TREE_CODE (sub
) == ADDR_EXPR
)
14036 tree op
= TREE_OPERAND (sub
, 0);
14037 tree optype
= TREE_TYPE (op
);
14038 /* *&CONST_DECL -> to the value of the const decl. */
14039 if (TREE_CODE (op
) == CONST_DECL
)
14040 return DECL_INITIAL (op
);
14041 /* *&p => p; make sure to handle *&"str"[cst] here. */
14042 if (type
== optype
)
14044 tree fop
= fold_read_from_constant_string (op
);
14050 /* *(foo *)&fooarray => fooarray[0] */
14051 else if (TREE_CODE (optype
) == ARRAY_TYPE
14052 && type
== TREE_TYPE (optype
)
14053 && (!in_gimple_form
14054 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14056 tree type_domain
= TYPE_DOMAIN (optype
);
14057 tree min_val
= size_zero_node
;
14058 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14059 min_val
= TYPE_MIN_VALUE (type_domain
);
14061 && TREE_CODE (min_val
) != INTEGER_CST
)
14063 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
14064 NULL_TREE
, NULL_TREE
);
14066 /* *(foo *)&complexfoo => __real__ complexfoo */
14067 else if (TREE_CODE (optype
) == COMPLEX_TYPE
14068 && type
== TREE_TYPE (optype
))
14069 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
14070 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
14071 else if (TREE_CODE (optype
) == VECTOR_TYPE
14072 && type
== TREE_TYPE (optype
))
14074 tree part_width
= TYPE_SIZE (type
);
14075 tree index
= bitsize_int (0);
14076 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
14080 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
14081 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
14083 tree op00
= TREE_OPERAND (sub
, 0);
14084 tree op01
= TREE_OPERAND (sub
, 1);
14087 if (TREE_CODE (op00
) == ADDR_EXPR
)
14090 op00
= TREE_OPERAND (op00
, 0);
14091 op00type
= TREE_TYPE (op00
);
14093 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
14094 if (TREE_CODE (op00type
) == VECTOR_TYPE
14095 && type
== TREE_TYPE (op00type
))
14097 tree part_width
= TYPE_SIZE (type
);
14098 unsigned HOST_WIDE_INT max_offset
14099 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
14100 * TYPE_VECTOR_SUBPARTS (op00type
));
14101 if (tree_int_cst_sign_bit (op01
) == 0
14102 && compare_tree_int (op01
, max_offset
) == -1)
14104 unsigned HOST_WIDE_INT offset
= tree_to_uhwi (op01
);
14105 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
14106 tree index
= bitsize_int (indexi
);
14107 return fold_build3_loc (loc
,
14108 BIT_FIELD_REF
, type
, op00
,
14109 part_width
, index
);
14112 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14113 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
14114 && type
== TREE_TYPE (op00type
))
14116 tree size
= TYPE_SIZE_UNIT (type
);
14117 if (tree_int_cst_equal (size
, op01
))
14118 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
14120 /* ((foo *)&fooarray)[1] => fooarray[1] */
14121 else if (TREE_CODE (op00type
) == ARRAY_TYPE
14122 && type
== TREE_TYPE (op00type
))
14124 tree type_domain
= TYPE_DOMAIN (op00type
);
14125 tree min_val
= size_zero_node
;
14126 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14127 min_val
= TYPE_MIN_VALUE (type_domain
);
14128 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
14129 TYPE_SIZE_UNIT (type
));
14130 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
14131 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
14132 NULL_TREE
, NULL_TREE
);
14137 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14138 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
14139 && type
== TREE_TYPE (TREE_TYPE (subtype
))
14140 && (!in_gimple_form
14141 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14144 tree min_val
= size_zero_node
;
14145 sub
= build_fold_indirect_ref_loc (loc
, sub
);
14146 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
14147 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14148 min_val
= TYPE_MIN_VALUE (type_domain
);
14150 && TREE_CODE (min_val
) != INTEGER_CST
)
14152 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
14159 /* Builds an expression for an indirection through T, simplifying some
14163 build_fold_indirect_ref_loc (location_t loc
, tree t
)
14165 tree type
= TREE_TYPE (TREE_TYPE (t
));
14166 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
14171 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
14174 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14177 fold_indirect_ref_loc (location_t loc
, tree t
)
14179 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
14187 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14188 whose result is ignored. The type of the returned tree need not be
14189 the same as the original expression. */
14192 fold_ignored_result (tree t
)
14194 if (!TREE_SIDE_EFFECTS (t
))
14195 return integer_zero_node
;
14198 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
14201 t
= TREE_OPERAND (t
, 0);
14205 case tcc_comparison
:
14206 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14207 t
= TREE_OPERAND (t
, 0);
14208 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
14209 t
= TREE_OPERAND (t
, 1);
14214 case tcc_expression
:
14215 switch (TREE_CODE (t
))
14217 case COMPOUND_EXPR
:
14218 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14220 t
= TREE_OPERAND (t
, 0);
14224 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
14225 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
14227 t
= TREE_OPERAND (t
, 0);
14240 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14243 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
14245 tree div
= NULL_TREE
;
14250 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14251 have to do anything. Only do this when we are not given a const,
14252 because in that case, this check is more expensive than just
14254 if (TREE_CODE (value
) != INTEGER_CST
)
14256 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14258 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14262 /* If divisor is a power of two, simplify this to bit manipulation. */
14263 if (pow2_or_zerop (divisor
))
14265 if (TREE_CODE (value
) == INTEGER_CST
)
14267 wide_int val
= value
;
14270 if ((val
& (divisor
- 1)) == 0)
14273 overflow_p
= TREE_OVERFLOW (value
);
14274 val
+= divisor
- 1;
14275 val
&= - (int) divisor
;
14279 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
14285 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
14286 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
14287 t
= build_int_cst (TREE_TYPE (value
), - (int) divisor
);
14288 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14294 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14295 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
14296 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14302 /* Likewise, but round down. */
14305 round_down_loc (location_t loc
, tree value
, int divisor
)
14307 tree div
= NULL_TREE
;
14309 gcc_assert (divisor
> 0);
14313 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14314 have to do anything. Only do this when we are not given a const,
14315 because in that case, this check is more expensive than just
14317 if (TREE_CODE (value
) != INTEGER_CST
)
14319 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14321 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14325 /* If divisor is a power of two, simplify this to bit manipulation. */
14326 if (pow2_or_zerop (divisor
))
14330 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
14331 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14336 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14337 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
14338 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14344 /* Returns the pointer to the base of the object addressed by EXP and
14345 extracts the information about the offset of the access, storing it
14346 to PBITPOS and POFFSET. */
14349 split_address_to_core_and_offset (tree exp
,
14350 HOST_WIDE_INT
*pbitpos
, tree
*poffset
)
14354 int unsignedp
, reversep
, volatilep
;
14355 HOST_WIDE_INT bitsize
;
14356 location_t loc
= EXPR_LOCATION (exp
);
14358 if (TREE_CODE (exp
) == ADDR_EXPR
)
14360 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
14361 poffset
, &mode
, &unsignedp
, &reversep
,
14363 core
= build_fold_addr_expr_loc (loc
, core
);
14369 *poffset
= NULL_TREE
;
14375 /* Returns true if addresses of E1 and E2 differ by a constant, false
14376 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14379 ptr_difference_const (tree e1
, tree e2
, HOST_WIDE_INT
*diff
)
14382 HOST_WIDE_INT bitpos1
, bitpos2
;
14383 tree toffset1
, toffset2
, tdiff
, type
;
14385 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
14386 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
14388 if (bitpos1
% BITS_PER_UNIT
!= 0
14389 || bitpos2
% BITS_PER_UNIT
!= 0
14390 || !operand_equal_p (core1
, core2
, 0))
14393 if (toffset1
&& toffset2
)
14395 type
= TREE_TYPE (toffset1
);
14396 if (type
!= TREE_TYPE (toffset2
))
14397 toffset2
= fold_convert (type
, toffset2
);
14399 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
14400 if (!cst_and_fits_in_hwi (tdiff
))
14403 *diff
= int_cst_value (tdiff
);
14405 else if (toffset1
|| toffset2
)
14407 /* If only one of the offsets is non-constant, the difference cannot
14414 *diff
+= (bitpos1
- bitpos2
) / BITS_PER_UNIT
;
14418 /* Return OFF converted to a pointer offset type suitable as offset for
14419 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14421 convert_to_ptrofftype_loc (location_t loc
, tree off
)
14423 return fold_convert_loc (loc
, sizetype
, off
);
14426 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14428 fold_build_pointer_plus_loc (location_t loc
, tree ptr
, tree off
)
14430 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14431 ptr
, convert_to_ptrofftype_loc (loc
, off
));
14434 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14436 fold_build_pointer_plus_hwi_loc (location_t loc
, tree ptr
, HOST_WIDE_INT off
)
14438 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14439 ptr
, size_int (off
));
14442 /* Return a char pointer for a C string if it is a string constant
14443 or sum of string constant and integer constant. */
14446 c_getstr (tree src
)
14450 src
= string_constant (src
, &offset_node
);
14454 if (offset_node
== 0)
14455 return TREE_STRING_POINTER (src
);
14456 else if (!tree_fits_uhwi_p (offset_node
)
14457 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
14460 return TREE_STRING_POINTER (src
) + tree_to_uhwi (offset_node
);
14465 namespace selftest
{
14467 /* Helper functions for writing tests of folding trees. */
14469 /* Verify that the binary op (LHS CODE RHS) folds to CONSTANT. */
14472 assert_binop_folds_to_const (tree lhs
, enum tree_code code
, tree rhs
,
14475 ASSERT_EQ (constant
, fold_build2 (code
, TREE_TYPE (lhs
), lhs
, rhs
));
14478 /* Verify that the binary op (LHS CODE RHS) folds to an NON_LVALUE_EXPR
14479 wrapping WRAPPED_EXPR. */
14482 assert_binop_folds_to_nonlvalue (tree lhs
, enum tree_code code
, tree rhs
,
14485 tree result
= fold_build2 (code
, TREE_TYPE (lhs
), lhs
, rhs
);
14486 ASSERT_NE (wrapped_expr
, result
);
14487 ASSERT_EQ (NON_LVALUE_EXPR
, TREE_CODE (result
));
14488 ASSERT_EQ (wrapped_expr
, TREE_OPERAND (result
, 0));
14491 /* Verify that various arithmetic binary operations are folded
14495 test_arithmetic_folding ()
14497 tree type
= integer_type_node
;
14498 tree x
= create_tmp_var_raw (type
, "x");
14499 tree zero
= build_zero_cst (type
);
14500 tree one
= build_int_cst (type
, 1);
14503 /* 1 <-- (0 + 1) */
14504 assert_binop_folds_to_const (zero
, PLUS_EXPR
, one
,
14506 assert_binop_folds_to_const (one
, PLUS_EXPR
, zero
,
14509 /* (nonlvalue)x <-- (x + 0) */
14510 assert_binop_folds_to_nonlvalue (x
, PLUS_EXPR
, zero
,
14514 /* 0 <-- (x - x) */
14515 assert_binop_folds_to_const (x
, MINUS_EXPR
, x
,
14517 assert_binop_folds_to_nonlvalue (x
, MINUS_EXPR
, zero
,
14520 /* Multiplication. */
14521 /* 0 <-- (x * 0) */
14522 assert_binop_folds_to_const (x
, MULT_EXPR
, zero
,
14525 /* (nonlvalue)x <-- (x * 1) */
14526 assert_binop_folds_to_nonlvalue (x
, MULT_EXPR
, one
,
14530 /* Verify that various binary operations on vectors are folded
14534 test_vector_folding ()
14536 tree inner_type
= integer_type_node
;
14537 tree type
= build_vector_type (inner_type
, 4);
14538 tree zero
= build_zero_cst (type
);
14539 tree one
= build_one_cst (type
);
14541 /* Verify equality tests that return a scalar boolean result. */
14542 tree res_type
= boolean_type_node
;
14543 ASSERT_FALSE (integer_nonzerop (fold_build2 (EQ_EXPR
, res_type
, zero
, one
)));
14544 ASSERT_TRUE (integer_nonzerop (fold_build2 (EQ_EXPR
, res_type
, zero
, zero
)));
14545 ASSERT_TRUE (integer_nonzerop (fold_build2 (NE_EXPR
, res_type
, zero
, one
)));
14546 ASSERT_FALSE (integer_nonzerop (fold_build2 (NE_EXPR
, res_type
, one
, one
)));
14549 /* Run all of the selftests within this file. */
14552 fold_const_c_tests ()
14554 test_arithmetic_folding ();
14555 test_vector_folding ();
14558 } // namespace selftest
14560 #endif /* CHECKING_P */