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"
78 #include "tree-ssanames.h"
80 #ifndef LOAD_EXTEND_OP
81 #define LOAD_EXTEND_OP(M) UNKNOWN
84 /* Nonzero if we are folding constants inside an initializer; zero
86 int folding_initializer
= 0;
88 /* The following constants represent a bit based encoding of GCC's
89 comparison operators. This encoding simplifies transformations
90 on relational comparison operators, such as AND and OR. */
91 enum comparison_code
{
110 static bool negate_expr_p (tree
);
111 static tree
negate_expr (tree
);
112 static tree
split_tree (tree
, enum tree_code
, tree
*, tree
*, tree
*, int);
113 static tree
associate_trees (location_t
, tree
, tree
, enum tree_code
, tree
);
114 static enum comparison_code
comparison_to_compcode (enum tree_code
);
115 static enum tree_code
compcode_to_comparison (enum comparison_code
);
116 static int operand_equal_for_comparison_p (tree
, tree
, tree
);
117 static int twoval_comparison_p (tree
, tree
*, tree
*, int *);
118 static tree
eval_subst (location_t
, tree
, tree
, tree
, tree
, tree
);
119 static tree
make_bit_field_ref (location_t
, tree
, tree
,
120 HOST_WIDE_INT
, HOST_WIDE_INT
, int, int);
121 static tree
optimize_bit_field_compare (location_t
, enum tree_code
,
123 static tree
decode_field_reference (location_t
, tree
, HOST_WIDE_INT
*,
125 machine_mode
*, int *, int *, int *,
127 static int simple_operand_p (const_tree
);
128 static bool simple_operand_p_2 (tree
);
129 static tree
range_binop (enum tree_code
, tree
, tree
, int, tree
, int);
130 static tree
range_predecessor (tree
);
131 static tree
range_successor (tree
);
132 static tree
fold_range_test (location_t
, enum tree_code
, tree
, tree
, tree
);
133 static tree
fold_cond_expr_with_comparison (location_t
, tree
, tree
, tree
, tree
);
134 static tree
unextend (tree
, int, int, tree
);
135 static tree
optimize_minmax_comparison (location_t
, enum tree_code
,
137 static tree
extract_muldiv (tree
, tree
, enum tree_code
, tree
, bool *);
138 static tree
extract_muldiv_1 (tree
, tree
, enum tree_code
, tree
, bool *);
139 static tree
fold_binary_op_with_conditional_arg (location_t
,
140 enum tree_code
, tree
,
143 static tree
fold_div_compare (location_t
, enum tree_code
, tree
, tree
, tree
);
144 static bool reorder_operands_p (const_tree
, const_tree
);
145 static tree
fold_negate_const (tree
, tree
);
146 static tree
fold_not_const (const_tree
, tree
);
147 static tree
fold_relational_const (enum tree_code
, tree
, tree
, tree
);
148 static tree
fold_convert_const (enum tree_code
, tree
, tree
);
149 static tree
fold_view_convert_expr (tree
, tree
);
150 static bool vec_cst_ctor_to_array (tree
, tree
*);
153 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
154 Otherwise, return LOC. */
157 expr_location_or (tree t
, location_t loc
)
159 location_t tloc
= EXPR_LOCATION (t
);
160 return tloc
== UNKNOWN_LOCATION
? loc
: tloc
;
163 /* Similar to protected_set_expr_location, but never modify x in place,
164 if location can and needs to be set, unshare it. */
167 protected_set_expr_location_unshare (tree x
, location_t loc
)
169 if (CAN_HAVE_LOCATION_P (x
)
170 && EXPR_LOCATION (x
) != loc
171 && !(TREE_CODE (x
) == SAVE_EXPR
172 || TREE_CODE (x
) == TARGET_EXPR
173 || TREE_CODE (x
) == BIND_EXPR
))
176 SET_EXPR_LOCATION (x
, loc
);
181 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
182 division and returns the quotient. Otherwise returns
186 div_if_zero_remainder (const_tree arg1
, const_tree arg2
)
190 if (wi::multiple_of_p (wi::to_widest (arg1
), wi::to_widest (arg2
),
192 return wide_int_to_tree (TREE_TYPE (arg1
), quo
);
197 /* This is nonzero if we should defer warnings about undefined
198 overflow. This facility exists because these warnings are a
199 special case. The code to estimate loop iterations does not want
200 to issue any warnings, since it works with expressions which do not
201 occur in user code. Various bits of cleanup code call fold(), but
202 only use the result if it has certain characteristics (e.g., is a
203 constant); that code only wants to issue a warning if the result is
206 static int fold_deferring_overflow_warnings
;
208 /* If a warning about undefined overflow is deferred, this is the
209 warning. Note that this may cause us to turn two warnings into
210 one, but that is fine since it is sufficient to only give one
211 warning per expression. */
213 static const char* fold_deferred_overflow_warning
;
215 /* If a warning about undefined overflow is deferred, this is the
216 level at which the warning should be emitted. */
218 static enum warn_strict_overflow_code fold_deferred_overflow_code
;
220 /* Start deferring overflow warnings. We could use a stack here to
221 permit nested calls, but at present it is not necessary. */
224 fold_defer_overflow_warnings (void)
226 ++fold_deferring_overflow_warnings
;
229 /* Stop deferring overflow warnings. If there is a pending warning,
230 and ISSUE is true, then issue the warning if appropriate. STMT is
231 the statement with which the warning should be associated (used for
232 location information); STMT may be NULL. CODE is the level of the
233 warning--a warn_strict_overflow_code value. This function will use
234 the smaller of CODE and the deferred code when deciding whether to
235 issue the warning. CODE may be zero to mean to always use the
239 fold_undefer_overflow_warnings (bool issue
, const gimple
*stmt
, int code
)
244 gcc_assert (fold_deferring_overflow_warnings
> 0);
245 --fold_deferring_overflow_warnings
;
246 if (fold_deferring_overflow_warnings
> 0)
248 if (fold_deferred_overflow_warning
!= NULL
250 && code
< (int) fold_deferred_overflow_code
)
251 fold_deferred_overflow_code
= (enum warn_strict_overflow_code
) code
;
255 warnmsg
= fold_deferred_overflow_warning
;
256 fold_deferred_overflow_warning
= NULL
;
258 if (!issue
|| warnmsg
== NULL
)
261 if (gimple_no_warning_p (stmt
))
264 /* Use the smallest code level when deciding to issue the
266 if (code
== 0 || code
> (int) fold_deferred_overflow_code
)
267 code
= fold_deferred_overflow_code
;
269 if (!issue_strict_overflow_warning (code
))
273 locus
= input_location
;
275 locus
= gimple_location (stmt
);
276 warning_at (locus
, OPT_Wstrict_overflow
, "%s", warnmsg
);
279 /* Stop deferring overflow warnings, ignoring any deferred
283 fold_undefer_and_ignore_overflow_warnings (void)
285 fold_undefer_overflow_warnings (false, NULL
, 0);
288 /* Whether we are deferring overflow warnings. */
291 fold_deferring_overflow_warnings_p (void)
293 return fold_deferring_overflow_warnings
> 0;
296 /* This is called when we fold something based on the fact that signed
297 overflow is undefined. */
300 fold_overflow_warning (const char* gmsgid
, enum warn_strict_overflow_code wc
)
302 if (fold_deferring_overflow_warnings
> 0)
304 if (fold_deferred_overflow_warning
== NULL
305 || wc
< fold_deferred_overflow_code
)
307 fold_deferred_overflow_warning
= gmsgid
;
308 fold_deferred_overflow_code
= wc
;
311 else if (issue_strict_overflow_warning (wc
))
312 warning (OPT_Wstrict_overflow
, gmsgid
);
315 /* Return true if the built-in mathematical function specified by CODE
316 is odd, i.e. -f(x) == f(-x). */
319 negate_mathfn_p (combined_fn fn
)
352 return !flag_rounding_math
;
360 /* Check whether we may negate an integer constant T without causing
364 may_negate_without_overflow_p (const_tree t
)
368 gcc_assert (TREE_CODE (t
) == INTEGER_CST
);
370 type
= TREE_TYPE (t
);
371 if (TYPE_UNSIGNED (type
))
374 return !wi::only_sign_bit_p (t
);
377 /* Determine whether an expression T can be cheaply negated using
378 the function negate_expr without introducing undefined overflow. */
381 negate_expr_p (tree t
)
388 type
= TREE_TYPE (t
);
391 switch (TREE_CODE (t
))
394 if (INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_WRAPS (type
))
397 /* Check that -CST will not overflow type. */
398 return may_negate_without_overflow_p (t
);
400 return (INTEGRAL_TYPE_P (type
)
401 && TYPE_OVERFLOW_WRAPS (type
));
407 return !TYPE_OVERFLOW_SANITIZED (type
);
410 /* We want to canonicalize to positive real constants. Pretend
411 that only negative ones can be easily negated. */
412 return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
415 return negate_expr_p (TREE_REALPART (t
))
416 && negate_expr_p (TREE_IMAGPART (t
));
420 if (FLOAT_TYPE_P (TREE_TYPE (type
)) || TYPE_OVERFLOW_WRAPS (type
))
423 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
425 for (i
= 0; i
< count
; i
++)
426 if (!negate_expr_p (VECTOR_CST_ELT (t
, i
)))
433 return negate_expr_p (TREE_OPERAND (t
, 0))
434 && negate_expr_p (TREE_OPERAND (t
, 1));
437 return negate_expr_p (TREE_OPERAND (t
, 0));
440 if (HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
441 || HONOR_SIGNED_ZEROS (element_mode (type
))
442 || (INTEGRAL_TYPE_P (type
)
443 && ! TYPE_OVERFLOW_WRAPS (type
)))
445 /* -(A + B) -> (-B) - A. */
446 if (negate_expr_p (TREE_OPERAND (t
, 1))
447 && reorder_operands_p (TREE_OPERAND (t
, 0),
448 TREE_OPERAND (t
, 1)))
450 /* -(A + B) -> (-A) - B. */
451 return negate_expr_p (TREE_OPERAND (t
, 0));
454 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
455 return !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
456 && !HONOR_SIGNED_ZEROS (element_mode (type
))
457 && (! INTEGRAL_TYPE_P (type
)
458 || TYPE_OVERFLOW_WRAPS (type
))
459 && reorder_operands_p (TREE_OPERAND (t
, 0),
460 TREE_OPERAND (t
, 1));
463 if (TYPE_UNSIGNED (type
))
465 /* INT_MIN/n * n doesn't overflow while negating one operand it does
466 if n is a power of two. */
467 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
468 && ! TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
469 && ! ((TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
470 && ! integer_pow2p (TREE_OPERAND (t
, 0)))
471 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
472 && ! integer_pow2p (TREE_OPERAND (t
, 1)))))
478 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (TREE_TYPE (t
))))
479 return negate_expr_p (TREE_OPERAND (t
, 1))
480 || negate_expr_p (TREE_OPERAND (t
, 0));
486 if (TYPE_UNSIGNED (type
))
488 if (negate_expr_p (TREE_OPERAND (t
, 0)))
490 /* In general we can't negate B in A / B, because if A is INT_MIN and
491 B is 1, we may turn this into INT_MIN / -1 which is undefined
492 and actually traps on some architectures. */
493 if (! INTEGRAL_TYPE_P (TREE_TYPE (t
))
494 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
495 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
496 && ! integer_onep (TREE_OPERAND (t
, 1))))
497 return negate_expr_p (TREE_OPERAND (t
, 1));
501 /* Negate -((double)float) as (double)(-float). */
502 if (TREE_CODE (type
) == REAL_TYPE
)
504 tree tem
= strip_float_extensions (t
);
506 return negate_expr_p (tem
);
511 /* Negate -f(x) as f(-x). */
512 if (negate_mathfn_p (get_call_combined_fn (t
)))
513 return negate_expr_p (CALL_EXPR_ARG (t
, 0));
517 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
518 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
520 tree op1
= TREE_OPERAND (t
, 1);
521 if (wi::eq_p (op1
, TYPE_PRECISION (type
) - 1))
532 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
533 simplification is possible.
534 If negate_expr_p would return true for T, NULL_TREE will never be
538 fold_negate_expr (location_t loc
, tree t
)
540 tree type
= TREE_TYPE (t
);
543 switch (TREE_CODE (t
))
545 /* Convert - (~A) to A + 1. */
547 if (INTEGRAL_TYPE_P (type
))
548 return fold_build2_loc (loc
, PLUS_EXPR
, type
, TREE_OPERAND (t
, 0),
549 build_one_cst (type
));
553 tem
= fold_negate_const (t
, type
);
554 if (TREE_OVERFLOW (tem
) == TREE_OVERFLOW (t
)
555 || (ANY_INTEGRAL_TYPE_P (type
)
556 && !TYPE_OVERFLOW_TRAPS (type
)
557 && TYPE_OVERFLOW_WRAPS (type
))
558 || (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
563 tem
= fold_negate_const (t
, type
);
567 tem
= fold_negate_const (t
, type
);
572 tree rpart
= fold_negate_expr (loc
, TREE_REALPART (t
));
573 tree ipart
= fold_negate_expr (loc
, TREE_IMAGPART (t
));
575 return build_complex (type
, rpart
, ipart
);
581 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
582 tree
*elts
= XALLOCAVEC (tree
, count
);
584 for (i
= 0; i
< count
; i
++)
586 elts
[i
] = fold_negate_expr (loc
, VECTOR_CST_ELT (t
, i
));
587 if (elts
[i
] == NULL_TREE
)
591 return build_vector (type
, elts
);
595 if (negate_expr_p (t
))
596 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
597 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)),
598 fold_negate_expr (loc
, TREE_OPERAND (t
, 1)));
602 if (negate_expr_p (t
))
603 return fold_build1_loc (loc
, CONJ_EXPR
, type
,
604 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)));
608 if (!TYPE_OVERFLOW_SANITIZED (type
))
609 return TREE_OPERAND (t
, 0);
613 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
614 && !HONOR_SIGNED_ZEROS (element_mode (type
)))
616 /* -(A + B) -> (-B) - A. */
617 if (negate_expr_p (TREE_OPERAND (t
, 1))
618 && reorder_operands_p (TREE_OPERAND (t
, 0),
619 TREE_OPERAND (t
, 1)))
621 tem
= negate_expr (TREE_OPERAND (t
, 1));
622 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
623 tem
, TREE_OPERAND (t
, 0));
626 /* -(A + B) -> (-A) - B. */
627 if (negate_expr_p (TREE_OPERAND (t
, 0)))
629 tem
= negate_expr (TREE_OPERAND (t
, 0));
630 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
631 tem
, TREE_OPERAND (t
, 1));
637 /* - (A - B) -> B - A */
638 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
639 && !HONOR_SIGNED_ZEROS (element_mode (type
))
640 && reorder_operands_p (TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1)))
641 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
642 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 0));
646 if (TYPE_UNSIGNED (type
))
652 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
)))
654 tem
= TREE_OPERAND (t
, 1);
655 if (negate_expr_p (tem
))
656 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
657 TREE_OPERAND (t
, 0), negate_expr (tem
));
658 tem
= TREE_OPERAND (t
, 0);
659 if (negate_expr_p (tem
))
660 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
661 negate_expr (tem
), TREE_OPERAND (t
, 1));
668 if (TYPE_UNSIGNED (type
))
670 if (negate_expr_p (TREE_OPERAND (t
, 0)))
671 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
672 negate_expr (TREE_OPERAND (t
, 0)),
673 TREE_OPERAND (t
, 1));
674 /* In general we can't negate B in A / B, because if A is INT_MIN and
675 B is 1, we may turn this into INT_MIN / -1 which is undefined
676 and actually traps on some architectures. */
677 if ((! INTEGRAL_TYPE_P (TREE_TYPE (t
))
678 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
679 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
680 && ! integer_onep (TREE_OPERAND (t
, 1))))
681 && negate_expr_p (TREE_OPERAND (t
, 1)))
682 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
684 negate_expr (TREE_OPERAND (t
, 1)));
688 /* Convert -((double)float) into (double)(-float). */
689 if (TREE_CODE (type
) == REAL_TYPE
)
691 tem
= strip_float_extensions (t
);
692 if (tem
!= t
&& negate_expr_p (tem
))
693 return fold_convert_loc (loc
, type
, negate_expr (tem
));
698 /* Negate -f(x) as f(-x). */
699 if (negate_mathfn_p (get_call_combined_fn (t
))
700 && negate_expr_p (CALL_EXPR_ARG (t
, 0)))
704 fndecl
= get_callee_fndecl (t
);
705 arg
= negate_expr (CALL_EXPR_ARG (t
, 0));
706 return build_call_expr_loc (loc
, fndecl
, 1, arg
);
711 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
712 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
714 tree op1
= TREE_OPERAND (t
, 1);
715 if (wi::eq_p (op1
, TYPE_PRECISION (type
) - 1))
717 tree ntype
= TYPE_UNSIGNED (type
)
718 ? signed_type_for (type
)
719 : unsigned_type_for (type
);
720 tree temp
= fold_convert_loc (loc
, ntype
, TREE_OPERAND (t
, 0));
721 temp
= fold_build2_loc (loc
, RSHIFT_EXPR
, ntype
, temp
, op1
);
722 return fold_convert_loc (loc
, type
, temp
);
734 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
735 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
747 loc
= EXPR_LOCATION (t
);
748 type
= TREE_TYPE (t
);
751 tem
= fold_negate_expr (loc
, t
);
753 tem
= build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
754 return fold_convert_loc (loc
, type
, tem
);
757 /* Split a tree IN into a constant, literal and variable parts that could be
758 combined with CODE to make IN. "constant" means an expression with
759 TREE_CONSTANT but that isn't an actual constant. CODE must be a
760 commutative arithmetic operation. Store the constant part into *CONP,
761 the literal in *LITP and return the variable part. If a part isn't
762 present, set it to null. If the tree does not decompose in this way,
763 return the entire tree as the variable part and the other parts as null.
765 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
766 case, we negate an operand that was subtracted. Except if it is a
767 literal for which we use *MINUS_LITP instead.
769 If NEGATE_P is true, we are negating all of IN, again except a literal
770 for which we use *MINUS_LITP instead.
772 If IN is itself a literal or constant, return it as appropriate.
774 Note that we do not guarantee that any of the three values will be the
775 same type as IN, but they will have the same signedness and mode. */
778 split_tree (tree in
, enum tree_code code
, tree
*conp
, tree
*litp
,
779 tree
*minus_litp
, int negate_p
)
787 /* Strip any conversions that don't change the machine mode or signedness. */
788 STRIP_SIGN_NOPS (in
);
790 if (TREE_CODE (in
) == INTEGER_CST
|| TREE_CODE (in
) == REAL_CST
791 || TREE_CODE (in
) == FIXED_CST
)
793 else if (TREE_CODE (in
) == code
794 || ((! FLOAT_TYPE_P (TREE_TYPE (in
)) || flag_associative_math
)
795 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in
))
796 /* We can associate addition and subtraction together (even
797 though the C standard doesn't say so) for integers because
798 the value is not affected. For reals, the value might be
799 affected, so we can't. */
800 && ((code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
801 || (code
== MINUS_EXPR
&& TREE_CODE (in
) == PLUS_EXPR
))))
803 tree op0
= TREE_OPERAND (in
, 0);
804 tree op1
= TREE_OPERAND (in
, 1);
805 int neg1_p
= TREE_CODE (in
) == MINUS_EXPR
;
806 int neg_litp_p
= 0, neg_conp_p
= 0, neg_var_p
= 0;
808 /* First see if either of the operands is a literal, then a constant. */
809 if (TREE_CODE (op0
) == INTEGER_CST
|| TREE_CODE (op0
) == REAL_CST
810 || TREE_CODE (op0
) == FIXED_CST
)
811 *litp
= op0
, op0
= 0;
812 else if (TREE_CODE (op1
) == INTEGER_CST
|| TREE_CODE (op1
) == REAL_CST
813 || TREE_CODE (op1
) == FIXED_CST
)
814 *litp
= op1
, neg_litp_p
= neg1_p
, op1
= 0;
816 if (op0
!= 0 && TREE_CONSTANT (op0
))
817 *conp
= op0
, op0
= 0;
818 else if (op1
!= 0 && TREE_CONSTANT (op1
))
819 *conp
= op1
, neg_conp_p
= neg1_p
, op1
= 0;
821 /* If we haven't dealt with either operand, this is not a case we can
822 decompose. Otherwise, VAR is either of the ones remaining, if any. */
823 if (op0
!= 0 && op1
!= 0)
828 var
= op1
, neg_var_p
= neg1_p
;
830 /* Now do any needed negations. */
832 *minus_litp
= *litp
, *litp
= 0;
834 *conp
= negate_expr (*conp
);
836 var
= negate_expr (var
);
838 else if (TREE_CODE (in
) == BIT_NOT_EXPR
839 && code
== PLUS_EXPR
)
841 /* -X - 1 is folded to ~X, undo that here. */
842 *minus_litp
= build_one_cst (TREE_TYPE (in
));
843 var
= negate_expr (TREE_OPERAND (in
, 0));
845 else if (TREE_CONSTANT (in
))
853 *minus_litp
= *litp
, *litp
= 0;
854 else if (*minus_litp
)
855 *litp
= *minus_litp
, *minus_litp
= 0;
856 *conp
= negate_expr (*conp
);
857 var
= negate_expr (var
);
863 /* Re-associate trees split by the above function. T1 and T2 are
864 either expressions to associate or null. Return the new
865 expression, if any. LOC is the location of the new expression. If
866 we build an operation, do it in TYPE and with CODE. */
869 associate_trees (location_t loc
, tree t1
, tree t2
, enum tree_code code
, tree type
)
876 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
877 try to fold this since we will have infinite recursion. But do
878 deal with any NEGATE_EXPRs. */
879 if (TREE_CODE (t1
) == code
|| TREE_CODE (t2
) == code
880 || TREE_CODE (t1
) == MINUS_EXPR
|| TREE_CODE (t2
) == MINUS_EXPR
)
882 if (code
== PLUS_EXPR
)
884 if (TREE_CODE (t1
) == NEGATE_EXPR
)
885 return build2_loc (loc
, MINUS_EXPR
, type
,
886 fold_convert_loc (loc
, type
, t2
),
887 fold_convert_loc (loc
, type
,
888 TREE_OPERAND (t1
, 0)));
889 else if (TREE_CODE (t2
) == NEGATE_EXPR
)
890 return build2_loc (loc
, MINUS_EXPR
, type
,
891 fold_convert_loc (loc
, type
, t1
),
892 fold_convert_loc (loc
, type
,
893 TREE_OPERAND (t2
, 0)));
894 else if (integer_zerop (t2
))
895 return fold_convert_loc (loc
, type
, t1
);
897 else if (code
== MINUS_EXPR
)
899 if (integer_zerop (t2
))
900 return fold_convert_loc (loc
, type
, t1
);
903 return build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
904 fold_convert_loc (loc
, type
, t2
));
907 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
908 fold_convert_loc (loc
, type
, t2
));
911 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
912 for use in int_const_binop, size_binop and size_diffop. */
915 int_binop_types_match_p (enum tree_code code
, const_tree type1
, const_tree type2
)
917 if (!INTEGRAL_TYPE_P (type1
) && !POINTER_TYPE_P (type1
))
919 if (!INTEGRAL_TYPE_P (type2
) && !POINTER_TYPE_P (type2
))
934 return TYPE_UNSIGNED (type1
) == TYPE_UNSIGNED (type2
)
935 && TYPE_PRECISION (type1
) == TYPE_PRECISION (type2
)
936 && TYPE_MODE (type1
) == TYPE_MODE (type2
);
940 /* Combine two integer constants ARG1 and ARG2 under operation CODE
941 to produce a new constant. Return NULL_TREE if we don't know how
942 to evaluate CODE at compile-time. */
945 int_const_binop_1 (enum tree_code code
, const_tree arg1
, const_tree parg2
,
950 tree type
= TREE_TYPE (arg1
);
951 signop sign
= TYPE_SIGN (type
);
952 bool overflow
= false;
954 wide_int arg2
= wide_int::from (parg2
, TYPE_PRECISION (type
),
955 TYPE_SIGN (TREE_TYPE (parg2
)));
960 res
= wi::bit_or (arg1
, arg2
);
964 res
= wi::bit_xor (arg1
, arg2
);
968 res
= wi::bit_and (arg1
, arg2
);
973 if (wi::neg_p (arg2
))
976 if (code
== RSHIFT_EXPR
)
982 if (code
== RSHIFT_EXPR
)
983 /* It's unclear from the C standard whether shifts can overflow.
984 The following code ignores overflow; perhaps a C standard
985 interpretation ruling is needed. */
986 res
= wi::rshift (arg1
, arg2
, sign
);
988 res
= wi::lshift (arg1
, arg2
);
993 if (wi::neg_p (arg2
))
996 if (code
== RROTATE_EXPR
)
1002 if (code
== RROTATE_EXPR
)
1003 res
= wi::rrotate (arg1
, arg2
);
1005 res
= wi::lrotate (arg1
, arg2
);
1009 res
= wi::add (arg1
, arg2
, sign
, &overflow
);
1013 res
= wi::sub (arg1
, arg2
, sign
, &overflow
);
1017 res
= wi::mul (arg1
, arg2
, sign
, &overflow
);
1020 case MULT_HIGHPART_EXPR
:
1021 res
= wi::mul_high (arg1
, arg2
, sign
);
1024 case TRUNC_DIV_EXPR
:
1025 case EXACT_DIV_EXPR
:
1028 res
= wi::div_trunc (arg1
, arg2
, sign
, &overflow
);
1031 case FLOOR_DIV_EXPR
:
1034 res
= wi::div_floor (arg1
, arg2
, sign
, &overflow
);
1040 res
= wi::div_ceil (arg1
, arg2
, sign
, &overflow
);
1043 case ROUND_DIV_EXPR
:
1046 res
= wi::div_round (arg1
, arg2
, sign
, &overflow
);
1049 case TRUNC_MOD_EXPR
:
1052 res
= wi::mod_trunc (arg1
, arg2
, sign
, &overflow
);
1055 case FLOOR_MOD_EXPR
:
1058 res
= wi::mod_floor (arg1
, arg2
, sign
, &overflow
);
1064 res
= wi::mod_ceil (arg1
, arg2
, sign
, &overflow
);
1067 case ROUND_MOD_EXPR
:
1070 res
= wi::mod_round (arg1
, arg2
, sign
, &overflow
);
1074 res
= wi::min (arg1
, arg2
, sign
);
1078 res
= wi::max (arg1
, arg2
, sign
);
1085 t
= force_fit_type (type
, res
, overflowable
,
1086 (((sign
== SIGNED
|| overflowable
== -1)
1088 | TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (parg2
)));
1094 int_const_binop (enum tree_code code
, const_tree arg1
, const_tree arg2
)
1096 return int_const_binop_1 (code
, arg1
, arg2
, 1);
1099 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1100 constant. We assume ARG1 and ARG2 have the same data type, or at least
1101 are the same kind of constant and the same machine mode. Return zero if
1102 combining the constants is not allowed in the current operating mode. */
1105 const_binop (enum tree_code code
, tree arg1
, tree arg2
)
1107 /* Sanity check for the recursive cases. */
1114 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg2
) == INTEGER_CST
)
1116 if (code
== POINTER_PLUS_EXPR
)
1117 return int_const_binop (PLUS_EXPR
,
1118 arg1
, fold_convert (TREE_TYPE (arg1
), arg2
));
1120 return int_const_binop (code
, arg1
, arg2
);
1123 if (TREE_CODE (arg1
) == REAL_CST
&& TREE_CODE (arg2
) == REAL_CST
)
1128 REAL_VALUE_TYPE value
;
1129 REAL_VALUE_TYPE result
;
1133 /* The following codes are handled by real_arithmetic. */
1148 d1
= TREE_REAL_CST (arg1
);
1149 d2
= TREE_REAL_CST (arg2
);
1151 type
= TREE_TYPE (arg1
);
1152 mode
= TYPE_MODE (type
);
1154 /* Don't perform operation if we honor signaling NaNs and
1155 either operand is a signaling NaN. */
1156 if (HONOR_SNANS (mode
)
1157 && (REAL_VALUE_ISSIGNALING_NAN (d1
)
1158 || REAL_VALUE_ISSIGNALING_NAN (d2
)))
1161 /* Don't perform operation if it would raise a division
1162 by zero exception. */
1163 if (code
== RDIV_EXPR
1164 && real_equal (&d2
, &dconst0
)
1165 && (flag_trapping_math
|| ! MODE_HAS_INFINITIES (mode
)))
1168 /* If either operand is a NaN, just return it. Otherwise, set up
1169 for floating-point trap; we return an overflow. */
1170 if (REAL_VALUE_ISNAN (d1
))
1172 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1175 t
= build_real (type
, d1
);
1178 else if (REAL_VALUE_ISNAN (d2
))
1180 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1183 t
= build_real (type
, d2
);
1187 inexact
= real_arithmetic (&value
, code
, &d1
, &d2
);
1188 real_convert (&result
, mode
, &value
);
1190 /* Don't constant fold this floating point operation if
1191 the result has overflowed and flag_trapping_math. */
1192 if (flag_trapping_math
1193 && MODE_HAS_INFINITIES (mode
)
1194 && REAL_VALUE_ISINF (result
)
1195 && !REAL_VALUE_ISINF (d1
)
1196 && !REAL_VALUE_ISINF (d2
))
1199 /* Don't constant fold this floating point operation if the
1200 result may dependent upon the run-time rounding mode and
1201 flag_rounding_math is set, or if GCC's software emulation
1202 is unable to accurately represent the result. */
1203 if ((flag_rounding_math
1204 || (MODE_COMPOSITE_P (mode
) && !flag_unsafe_math_optimizations
))
1205 && (inexact
|| !real_identical (&result
, &value
)))
1208 t
= build_real (type
, result
);
1210 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
);
1214 if (TREE_CODE (arg1
) == FIXED_CST
)
1216 FIXED_VALUE_TYPE f1
;
1217 FIXED_VALUE_TYPE f2
;
1218 FIXED_VALUE_TYPE result
;
1223 /* The following codes are handled by fixed_arithmetic. */
1229 case TRUNC_DIV_EXPR
:
1230 if (TREE_CODE (arg2
) != FIXED_CST
)
1232 f2
= TREE_FIXED_CST (arg2
);
1238 if (TREE_CODE (arg2
) != INTEGER_CST
)
1241 f2
.data
.high
= w2
.elt (1);
1242 f2
.data
.low
= w2
.elt (0);
1251 f1
= TREE_FIXED_CST (arg1
);
1252 type
= TREE_TYPE (arg1
);
1253 sat_p
= TYPE_SATURATING (type
);
1254 overflow_p
= fixed_arithmetic (&result
, code
, &f1
, &f2
, sat_p
);
1255 t
= build_fixed (type
, result
);
1256 /* Propagate overflow flags. */
1257 if (overflow_p
| TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
))
1258 TREE_OVERFLOW (t
) = 1;
1262 if (TREE_CODE (arg1
) == COMPLEX_CST
&& TREE_CODE (arg2
) == COMPLEX_CST
)
1264 tree type
= TREE_TYPE (arg1
);
1265 tree r1
= TREE_REALPART (arg1
);
1266 tree i1
= TREE_IMAGPART (arg1
);
1267 tree r2
= TREE_REALPART (arg2
);
1268 tree i2
= TREE_IMAGPART (arg2
);
1275 real
= const_binop (code
, r1
, r2
);
1276 imag
= const_binop (code
, i1
, i2
);
1280 if (COMPLEX_FLOAT_TYPE_P (type
))
1281 return do_mpc_arg2 (arg1
, arg2
, type
,
1282 /* do_nonfinite= */ folding_initializer
,
1285 real
= const_binop (MINUS_EXPR
,
1286 const_binop (MULT_EXPR
, r1
, r2
),
1287 const_binop (MULT_EXPR
, i1
, i2
));
1288 imag
= const_binop (PLUS_EXPR
,
1289 const_binop (MULT_EXPR
, r1
, i2
),
1290 const_binop (MULT_EXPR
, i1
, r2
));
1294 if (COMPLEX_FLOAT_TYPE_P (type
))
1295 return do_mpc_arg2 (arg1
, arg2
, type
,
1296 /* do_nonfinite= */ folding_initializer
,
1299 case TRUNC_DIV_EXPR
:
1301 case FLOOR_DIV_EXPR
:
1302 case ROUND_DIV_EXPR
:
1303 if (flag_complex_method
== 0)
1305 /* Keep this algorithm in sync with
1306 tree-complex.c:expand_complex_div_straight().
1308 Expand complex division to scalars, straightforward algorithm.
1309 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1313 = const_binop (PLUS_EXPR
,
1314 const_binop (MULT_EXPR
, r2
, r2
),
1315 const_binop (MULT_EXPR
, i2
, i2
));
1317 = const_binop (PLUS_EXPR
,
1318 const_binop (MULT_EXPR
, r1
, r2
),
1319 const_binop (MULT_EXPR
, i1
, i2
));
1321 = const_binop (MINUS_EXPR
,
1322 const_binop (MULT_EXPR
, i1
, r2
),
1323 const_binop (MULT_EXPR
, r1
, i2
));
1325 real
= const_binop (code
, t1
, magsquared
);
1326 imag
= const_binop (code
, t2
, magsquared
);
1330 /* Keep this algorithm in sync with
1331 tree-complex.c:expand_complex_div_wide().
1333 Expand complex division to scalars, modified algorithm to minimize
1334 overflow with wide input ranges. */
1335 tree compare
= fold_build2 (LT_EXPR
, boolean_type_node
,
1336 fold_abs_const (r2
, TREE_TYPE (type
)),
1337 fold_abs_const (i2
, TREE_TYPE (type
)));
1339 if (integer_nonzerop (compare
))
1341 /* In the TRUE branch, we compute
1343 div = (br * ratio) + bi;
1344 tr = (ar * ratio) + ai;
1345 ti = (ai * ratio) - ar;
1348 tree ratio
= const_binop (code
, r2
, i2
);
1349 tree div
= const_binop (PLUS_EXPR
, i2
,
1350 const_binop (MULT_EXPR
, r2
, ratio
));
1351 real
= const_binop (MULT_EXPR
, r1
, ratio
);
1352 real
= const_binop (PLUS_EXPR
, real
, i1
);
1353 real
= const_binop (code
, real
, div
);
1355 imag
= const_binop (MULT_EXPR
, i1
, ratio
);
1356 imag
= const_binop (MINUS_EXPR
, imag
, r1
);
1357 imag
= const_binop (code
, imag
, div
);
1361 /* In the FALSE branch, we compute
1363 divisor = (d * ratio) + c;
1364 tr = (b * ratio) + a;
1365 ti = b - (a * ratio);
1368 tree ratio
= const_binop (code
, i2
, r2
);
1369 tree div
= const_binop (PLUS_EXPR
, r2
,
1370 const_binop (MULT_EXPR
, i2
, ratio
));
1372 real
= const_binop (MULT_EXPR
, i1
, ratio
);
1373 real
= const_binop (PLUS_EXPR
, real
, r1
);
1374 real
= const_binop (code
, real
, div
);
1376 imag
= const_binop (MULT_EXPR
, r1
, ratio
);
1377 imag
= const_binop (MINUS_EXPR
, i1
, imag
);
1378 imag
= const_binop (code
, imag
, div
);
1388 return build_complex (type
, real
, imag
);
1391 if (TREE_CODE (arg1
) == VECTOR_CST
1392 && TREE_CODE (arg2
) == VECTOR_CST
)
1394 tree type
= TREE_TYPE (arg1
);
1395 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1396 tree
*elts
= XALLOCAVEC (tree
, count
);
1398 for (i
= 0; i
< count
; i
++)
1400 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1401 tree elem2
= VECTOR_CST_ELT (arg2
, i
);
1403 elts
[i
] = const_binop (code
, elem1
, elem2
);
1405 /* It is possible that const_binop cannot handle the given
1406 code and return NULL_TREE */
1407 if (elts
[i
] == NULL_TREE
)
1411 return build_vector (type
, elts
);
1414 /* Shifts allow a scalar offset for a vector. */
1415 if (TREE_CODE (arg1
) == VECTOR_CST
1416 && TREE_CODE (arg2
) == INTEGER_CST
)
1418 tree type
= TREE_TYPE (arg1
);
1419 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1420 tree
*elts
= XALLOCAVEC (tree
, count
);
1422 for (i
= 0; i
< count
; i
++)
1424 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1426 elts
[i
] = const_binop (code
, elem1
, arg2
);
1428 /* It is possible that const_binop cannot handle the given
1429 code and return NULL_TREE. */
1430 if (elts
[i
] == NULL_TREE
)
1434 return build_vector (type
, elts
);
1439 /* Overload that adds a TYPE parameter to be able to dispatch
1440 to fold_relational_const. */
1443 const_binop (enum tree_code code
, tree type
, tree arg1
, tree arg2
)
1445 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
1446 return fold_relational_const (code
, type
, arg1
, arg2
);
1448 /* ??? Until we make the const_binop worker take the type of the
1449 result as argument put those cases that need it here. */
1453 if ((TREE_CODE (arg1
) == REAL_CST
1454 && TREE_CODE (arg2
) == REAL_CST
)
1455 || (TREE_CODE (arg1
) == INTEGER_CST
1456 && TREE_CODE (arg2
) == INTEGER_CST
))
1457 return build_complex (type
, arg1
, arg2
);
1460 case VEC_PACK_TRUNC_EXPR
:
1461 case VEC_PACK_FIX_TRUNC_EXPR
:
1463 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
1466 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
/ 2
1467 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2
)) == nelts
/ 2);
1468 if (TREE_CODE (arg1
) != VECTOR_CST
1469 || TREE_CODE (arg2
) != VECTOR_CST
)
1472 elts
= XALLOCAVEC (tree
, nelts
);
1473 if (!vec_cst_ctor_to_array (arg1
, elts
)
1474 || !vec_cst_ctor_to_array (arg2
, elts
+ nelts
/ 2))
1477 for (i
= 0; i
< nelts
; i
++)
1479 elts
[i
] = fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
1480 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
1481 TREE_TYPE (type
), elts
[i
]);
1482 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
1486 return build_vector (type
, elts
);
1489 case VEC_WIDEN_MULT_LO_EXPR
:
1490 case VEC_WIDEN_MULT_HI_EXPR
:
1491 case VEC_WIDEN_MULT_EVEN_EXPR
:
1492 case VEC_WIDEN_MULT_ODD_EXPR
:
1494 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
1495 unsigned int out
, ofs
, scale
;
1498 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
* 2
1499 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2
)) == nelts
* 2);
1500 if (TREE_CODE (arg1
) != VECTOR_CST
|| TREE_CODE (arg2
) != VECTOR_CST
)
1503 elts
= XALLOCAVEC (tree
, nelts
* 4);
1504 if (!vec_cst_ctor_to_array (arg1
, elts
)
1505 || !vec_cst_ctor_to_array (arg2
, elts
+ nelts
* 2))
1508 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
1509 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? nelts
: 0;
1510 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
1511 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : nelts
;
1512 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
1514 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
1517 for (out
= 0; out
< nelts
; out
++)
1519 unsigned int in1
= (out
<< scale
) + ofs
;
1520 unsigned int in2
= in1
+ nelts
* 2;
1523 t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in1
]);
1524 t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in2
]);
1526 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
1528 elts
[out
] = const_binop (MULT_EXPR
, t1
, t2
);
1529 if (elts
[out
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[out
]))
1533 return build_vector (type
, elts
);
1539 if (TREE_CODE_CLASS (code
) != tcc_binary
)
1542 /* Make sure type and arg0 have the same saturating flag. */
1543 gcc_checking_assert (TYPE_SATURATING (type
)
1544 == TYPE_SATURATING (TREE_TYPE (arg1
)));
1546 return const_binop (code
, arg1
, arg2
);
1549 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1550 Return zero if computing the constants is not possible. */
1553 const_unop (enum tree_code code
, tree type
, tree arg0
)
1555 /* Don't perform the operation, other than NEGATE and ABS, if
1556 flag_signaling_nans is on and the operand is a signaling NaN. */
1557 if (TREE_CODE (arg0
) == REAL_CST
1558 && HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
1559 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg0
))
1560 && code
!= NEGATE_EXPR
1561 && code
!= ABS_EXPR
)
1568 case FIX_TRUNC_EXPR
:
1569 case FIXED_CONVERT_EXPR
:
1570 return fold_convert_const (code
, type
, arg0
);
1572 case ADDR_SPACE_CONVERT_EXPR
:
1573 /* If the source address is 0, and the source address space
1574 cannot have a valid object at 0, fold to dest type null. */
1575 if (integer_zerop (arg0
)
1576 && !(targetm
.addr_space
.zero_address_valid
1577 (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
))))))
1578 return fold_convert_const (code
, type
, arg0
);
1581 case VIEW_CONVERT_EXPR
:
1582 return fold_view_convert_expr (type
, arg0
);
1586 /* Can't call fold_negate_const directly here as that doesn't
1587 handle all cases and we might not be able to negate some
1589 tree tem
= fold_negate_expr (UNKNOWN_LOCATION
, arg0
);
1590 if (tem
&& CONSTANT_CLASS_P (tem
))
1596 if (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
)
1597 return fold_abs_const (arg0
, type
);
1601 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1603 tree ipart
= fold_negate_const (TREE_IMAGPART (arg0
),
1605 return build_complex (type
, TREE_REALPART (arg0
), ipart
);
1610 if (TREE_CODE (arg0
) == INTEGER_CST
)
1611 return fold_not_const (arg0
, type
);
1612 /* Perform BIT_NOT_EXPR on each element individually. */
1613 else if (TREE_CODE (arg0
) == VECTOR_CST
)
1617 unsigned count
= VECTOR_CST_NELTS (arg0
), i
;
1619 elements
= XALLOCAVEC (tree
, count
);
1620 for (i
= 0; i
< count
; i
++)
1622 elem
= VECTOR_CST_ELT (arg0
, i
);
1623 elem
= const_unop (BIT_NOT_EXPR
, TREE_TYPE (type
), elem
);
1624 if (elem
== NULL_TREE
)
1629 return build_vector (type
, elements
);
1633 case TRUTH_NOT_EXPR
:
1634 if (TREE_CODE (arg0
) == INTEGER_CST
)
1635 return constant_boolean_node (integer_zerop (arg0
), type
);
1639 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1640 return fold_convert (type
, TREE_REALPART (arg0
));
1644 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1645 return fold_convert (type
, TREE_IMAGPART (arg0
));
1648 case VEC_UNPACK_LO_EXPR
:
1649 case VEC_UNPACK_HI_EXPR
:
1650 case VEC_UNPACK_FLOAT_LO_EXPR
:
1651 case VEC_UNPACK_FLOAT_HI_EXPR
:
1653 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
1655 enum tree_code subcode
;
1657 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2);
1658 if (TREE_CODE (arg0
) != VECTOR_CST
)
1661 elts
= XALLOCAVEC (tree
, nelts
* 2);
1662 if (!vec_cst_ctor_to_array (arg0
, elts
))
1665 if ((!BYTES_BIG_ENDIAN
) ^ (code
== VEC_UNPACK_LO_EXPR
1666 || code
== VEC_UNPACK_FLOAT_LO_EXPR
))
1669 if (code
== VEC_UNPACK_LO_EXPR
|| code
== VEC_UNPACK_HI_EXPR
)
1672 subcode
= FLOAT_EXPR
;
1674 for (i
= 0; i
< nelts
; i
++)
1676 elts
[i
] = fold_convert_const (subcode
, TREE_TYPE (type
), elts
[i
]);
1677 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
1681 return build_vector (type
, elts
);
1684 case REDUC_MIN_EXPR
:
1685 case REDUC_MAX_EXPR
:
1686 case REDUC_PLUS_EXPR
:
1688 unsigned int nelts
, i
;
1690 enum tree_code subcode
;
1692 if (TREE_CODE (arg0
) != VECTOR_CST
)
1694 nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
));
1696 elts
= XALLOCAVEC (tree
, nelts
);
1697 if (!vec_cst_ctor_to_array (arg0
, elts
))
1702 case REDUC_MIN_EXPR
: subcode
= MIN_EXPR
; break;
1703 case REDUC_MAX_EXPR
: subcode
= MAX_EXPR
; break;
1704 case REDUC_PLUS_EXPR
: subcode
= PLUS_EXPR
; break;
1705 default: gcc_unreachable ();
1708 for (i
= 1; i
< nelts
; i
++)
1710 elts
[0] = const_binop (subcode
, elts
[0], elts
[i
]);
1711 if (elts
[0] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[0]))
1725 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1726 indicates which particular sizetype to create. */
1729 size_int_kind (HOST_WIDE_INT number
, enum size_type_kind kind
)
1731 return build_int_cst (sizetype_tab
[(int) kind
], number
);
1734 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1735 is a tree code. The type of the result is taken from the operands.
1736 Both must be equivalent integer types, ala int_binop_types_match_p.
1737 If the operands are constant, so is the result. */
1740 size_binop_loc (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
)
1742 tree type
= TREE_TYPE (arg0
);
1744 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1745 return error_mark_node
;
1747 gcc_assert (int_binop_types_match_p (code
, TREE_TYPE (arg0
),
1750 /* Handle the special case of two integer constants faster. */
1751 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1753 /* And some specific cases even faster than that. */
1754 if (code
== PLUS_EXPR
)
1756 if (integer_zerop (arg0
) && !TREE_OVERFLOW (arg0
))
1758 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1761 else if (code
== MINUS_EXPR
)
1763 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1766 else if (code
== MULT_EXPR
)
1768 if (integer_onep (arg0
) && !TREE_OVERFLOW (arg0
))
1772 /* Handle general case of two integer constants. For sizetype
1773 constant calculations we always want to know about overflow,
1774 even in the unsigned case. */
1775 return int_const_binop_1 (code
, arg0
, arg1
, -1);
1778 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
1781 /* Given two values, either both of sizetype or both of bitsizetype,
1782 compute the difference between the two values. Return the value
1783 in signed type corresponding to the type of the operands. */
1786 size_diffop_loc (location_t loc
, tree arg0
, tree arg1
)
1788 tree type
= TREE_TYPE (arg0
);
1791 gcc_assert (int_binop_types_match_p (MINUS_EXPR
, TREE_TYPE (arg0
),
1794 /* If the type is already signed, just do the simple thing. */
1795 if (!TYPE_UNSIGNED (type
))
1796 return size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
);
1798 if (type
== sizetype
)
1800 else if (type
== bitsizetype
)
1801 ctype
= sbitsizetype
;
1803 ctype
= signed_type_for (type
);
1805 /* If either operand is not a constant, do the conversions to the signed
1806 type and subtract. The hardware will do the right thing with any
1807 overflow in the subtraction. */
1808 if (TREE_CODE (arg0
) != INTEGER_CST
|| TREE_CODE (arg1
) != INTEGER_CST
)
1809 return size_binop_loc (loc
, MINUS_EXPR
,
1810 fold_convert_loc (loc
, ctype
, arg0
),
1811 fold_convert_loc (loc
, ctype
, arg1
));
1813 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1814 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1815 overflow) and negate (which can't either). Special-case a result
1816 of zero while we're here. */
1817 if (tree_int_cst_equal (arg0
, arg1
))
1818 return build_int_cst (ctype
, 0);
1819 else if (tree_int_cst_lt (arg1
, arg0
))
1820 return fold_convert_loc (loc
, ctype
,
1821 size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
));
1823 return size_binop_loc (loc
, MINUS_EXPR
, build_int_cst (ctype
, 0),
1824 fold_convert_loc (loc
, ctype
,
1825 size_binop_loc (loc
,
1830 /* A subroutine of fold_convert_const handling conversions of an
1831 INTEGER_CST to another integer type. */
1834 fold_convert_const_int_from_int (tree type
, const_tree arg1
)
1836 /* Given an integer constant, make new constant with new type,
1837 appropriately sign-extended or truncated. Use widest_int
1838 so that any extension is done according ARG1's type. */
1839 return force_fit_type (type
, wi::to_widest (arg1
),
1840 !POINTER_TYPE_P (TREE_TYPE (arg1
)),
1841 TREE_OVERFLOW (arg1
));
1844 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1845 to an integer type. */
1848 fold_convert_const_int_from_real (enum tree_code code
, tree type
, const_tree arg1
)
1850 bool overflow
= false;
1853 /* The following code implements the floating point to integer
1854 conversion rules required by the Java Language Specification,
1855 that IEEE NaNs are mapped to zero and values that overflow
1856 the target precision saturate, i.e. values greater than
1857 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1858 are mapped to INT_MIN. These semantics are allowed by the
1859 C and C++ standards that simply state that the behavior of
1860 FP-to-integer conversion is unspecified upon overflow. */
1864 REAL_VALUE_TYPE x
= TREE_REAL_CST (arg1
);
1868 case FIX_TRUNC_EXPR
:
1869 real_trunc (&r
, VOIDmode
, &x
);
1876 /* If R is NaN, return zero and show we have an overflow. */
1877 if (REAL_VALUE_ISNAN (r
))
1880 val
= wi::zero (TYPE_PRECISION (type
));
1883 /* See if R is less than the lower bound or greater than the
1888 tree lt
= TYPE_MIN_VALUE (type
);
1889 REAL_VALUE_TYPE l
= real_value_from_int_cst (NULL_TREE
, lt
);
1890 if (real_less (&r
, &l
))
1899 tree ut
= TYPE_MAX_VALUE (type
);
1902 REAL_VALUE_TYPE u
= real_value_from_int_cst (NULL_TREE
, ut
);
1903 if (real_less (&u
, &r
))
1912 val
= real_to_integer (&r
, &overflow
, TYPE_PRECISION (type
));
1914 t
= force_fit_type (type
, val
, -1, overflow
| TREE_OVERFLOW (arg1
));
1918 /* A subroutine of fold_convert_const handling conversions of a
1919 FIXED_CST to an integer type. */
1922 fold_convert_const_int_from_fixed (tree type
, const_tree arg1
)
1925 double_int temp
, temp_trunc
;
1928 /* Right shift FIXED_CST to temp by fbit. */
1929 temp
= TREE_FIXED_CST (arg1
).data
;
1930 mode
= TREE_FIXED_CST (arg1
).mode
;
1931 if (GET_MODE_FBIT (mode
) < HOST_BITS_PER_DOUBLE_INT
)
1933 temp
= temp
.rshift (GET_MODE_FBIT (mode
),
1934 HOST_BITS_PER_DOUBLE_INT
,
1935 SIGNED_FIXED_POINT_MODE_P (mode
));
1937 /* Left shift temp to temp_trunc by fbit. */
1938 temp_trunc
= temp
.lshift (GET_MODE_FBIT (mode
),
1939 HOST_BITS_PER_DOUBLE_INT
,
1940 SIGNED_FIXED_POINT_MODE_P (mode
));
1944 temp
= double_int_zero
;
1945 temp_trunc
= double_int_zero
;
1948 /* If FIXED_CST is negative, we need to round the value toward 0.
1949 By checking if the fractional bits are not zero to add 1 to temp. */
1950 if (SIGNED_FIXED_POINT_MODE_P (mode
)
1951 && temp_trunc
.is_negative ()
1952 && TREE_FIXED_CST (arg1
).data
!= temp_trunc
)
1953 temp
+= double_int_one
;
1955 /* Given a fixed-point constant, make new constant with new type,
1956 appropriately sign-extended or truncated. */
1957 t
= force_fit_type (type
, temp
, -1,
1958 (temp
.is_negative ()
1959 && (TYPE_UNSIGNED (type
)
1960 < TYPE_UNSIGNED (TREE_TYPE (arg1
))))
1961 | TREE_OVERFLOW (arg1
));
1966 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1967 to another floating point type. */
1970 fold_convert_const_real_from_real (tree type
, const_tree arg1
)
1972 REAL_VALUE_TYPE value
;
1975 /* Don't perform the operation if flag_signaling_nans is on
1976 and the operand is a signaling NaN. */
1977 if (HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
)))
1978 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg1
)))
1981 real_convert (&value
, TYPE_MODE (type
), &TREE_REAL_CST (arg1
));
1982 t
= build_real (type
, value
);
1984 /* If converting an infinity or NAN to a representation that doesn't
1985 have one, set the overflow bit so that we can produce some kind of
1986 error message at the appropriate point if necessary. It's not the
1987 most user-friendly message, but it's better than nothing. */
1988 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1
))
1989 && !MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1990 TREE_OVERFLOW (t
) = 1;
1991 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
1992 && !MODE_HAS_NANS (TYPE_MODE (type
)))
1993 TREE_OVERFLOW (t
) = 1;
1994 /* Regular overflow, conversion produced an infinity in a mode that
1995 can't represent them. */
1996 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type
))
1997 && REAL_VALUE_ISINF (value
)
1998 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1
)))
1999 TREE_OVERFLOW (t
) = 1;
2001 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2005 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2006 to a floating point type. */
2009 fold_convert_const_real_from_fixed (tree type
, const_tree arg1
)
2011 REAL_VALUE_TYPE value
;
2014 real_convert_from_fixed (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
));
2015 t
= build_real (type
, value
);
2017 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2021 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2022 to another fixed-point type. */
2025 fold_convert_const_fixed_from_fixed (tree type
, const_tree arg1
)
2027 FIXED_VALUE_TYPE value
;
2031 overflow_p
= fixed_convert (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
),
2032 TYPE_SATURATING (type
));
2033 t
= build_fixed (type
, value
);
2035 /* Propagate overflow flags. */
2036 if (overflow_p
| TREE_OVERFLOW (arg1
))
2037 TREE_OVERFLOW (t
) = 1;
2041 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2042 to a fixed-point type. */
2045 fold_convert_const_fixed_from_int (tree type
, const_tree arg1
)
2047 FIXED_VALUE_TYPE value
;
2052 gcc_assert (TREE_INT_CST_NUNITS (arg1
) <= 2);
2054 di
.low
= TREE_INT_CST_ELT (arg1
, 0);
2055 if (TREE_INT_CST_NUNITS (arg1
) == 1)
2056 di
.high
= (HOST_WIDE_INT
) di
.low
< 0 ? (HOST_WIDE_INT
) -1 : 0;
2058 di
.high
= TREE_INT_CST_ELT (arg1
, 1);
2060 overflow_p
= fixed_convert_from_int (&value
, TYPE_MODE (type
), di
,
2061 TYPE_UNSIGNED (TREE_TYPE (arg1
)),
2062 TYPE_SATURATING (type
));
2063 t
= build_fixed (type
, value
);
2065 /* Propagate overflow flags. */
2066 if (overflow_p
| TREE_OVERFLOW (arg1
))
2067 TREE_OVERFLOW (t
) = 1;
2071 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2072 to a fixed-point type. */
2075 fold_convert_const_fixed_from_real (tree type
, const_tree arg1
)
2077 FIXED_VALUE_TYPE value
;
2081 overflow_p
= fixed_convert_from_real (&value
, TYPE_MODE (type
),
2082 &TREE_REAL_CST (arg1
),
2083 TYPE_SATURATING (type
));
2084 t
= build_fixed (type
, value
);
2086 /* Propagate overflow flags. */
2087 if (overflow_p
| TREE_OVERFLOW (arg1
))
2088 TREE_OVERFLOW (t
) = 1;
2092 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2093 type TYPE. If no simplification can be done return NULL_TREE. */
2096 fold_convert_const (enum tree_code code
, tree type
, tree arg1
)
2098 if (TREE_TYPE (arg1
) == type
)
2101 if (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
)
2102 || TREE_CODE (type
) == OFFSET_TYPE
)
2104 if (TREE_CODE (arg1
) == INTEGER_CST
)
2105 return fold_convert_const_int_from_int (type
, arg1
);
2106 else if (TREE_CODE (arg1
) == REAL_CST
)
2107 return fold_convert_const_int_from_real (code
, type
, arg1
);
2108 else if (TREE_CODE (arg1
) == FIXED_CST
)
2109 return fold_convert_const_int_from_fixed (type
, arg1
);
2111 else if (TREE_CODE (type
) == REAL_TYPE
)
2113 if (TREE_CODE (arg1
) == INTEGER_CST
)
2114 return build_real_from_int_cst (type
, arg1
);
2115 else if (TREE_CODE (arg1
) == REAL_CST
)
2116 return fold_convert_const_real_from_real (type
, arg1
);
2117 else if (TREE_CODE (arg1
) == FIXED_CST
)
2118 return fold_convert_const_real_from_fixed (type
, arg1
);
2120 else if (TREE_CODE (type
) == FIXED_POINT_TYPE
)
2122 if (TREE_CODE (arg1
) == FIXED_CST
)
2123 return fold_convert_const_fixed_from_fixed (type
, arg1
);
2124 else if (TREE_CODE (arg1
) == INTEGER_CST
)
2125 return fold_convert_const_fixed_from_int (type
, arg1
);
2126 else if (TREE_CODE (arg1
) == REAL_CST
)
2127 return fold_convert_const_fixed_from_real (type
, arg1
);
2129 else if (TREE_CODE (type
) == VECTOR_TYPE
)
2131 if (TREE_CODE (arg1
) == VECTOR_CST
2132 && TYPE_VECTOR_SUBPARTS (type
) == VECTOR_CST_NELTS (arg1
))
2134 int len
= TYPE_VECTOR_SUBPARTS (type
);
2135 tree elttype
= TREE_TYPE (type
);
2136 tree
*v
= XALLOCAVEC (tree
, len
);
2137 for (int i
= 0; i
< len
; ++i
)
2139 tree elt
= VECTOR_CST_ELT (arg1
, i
);
2140 tree cvt
= fold_convert_const (code
, elttype
, elt
);
2141 if (cvt
== NULL_TREE
)
2145 return build_vector (type
, v
);
2151 /* Construct a vector of zero elements of vector type TYPE. */
2154 build_zero_vector (tree type
)
2158 t
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), integer_zero_node
);
2159 return build_vector_from_val (type
, t
);
2162 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2165 fold_convertible_p (const_tree type
, const_tree arg
)
2167 tree orig
= TREE_TYPE (arg
);
2172 if (TREE_CODE (arg
) == ERROR_MARK
2173 || TREE_CODE (type
) == ERROR_MARK
2174 || TREE_CODE (orig
) == ERROR_MARK
)
2177 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2180 switch (TREE_CODE (type
))
2182 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2183 case POINTER_TYPE
: case REFERENCE_TYPE
:
2185 return (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2186 || TREE_CODE (orig
) == OFFSET_TYPE
);
2189 case FIXED_POINT_TYPE
:
2193 return TREE_CODE (type
) == TREE_CODE (orig
);
2200 /* Convert expression ARG to type TYPE. Used by the middle-end for
2201 simple conversions in preference to calling the front-end's convert. */
2204 fold_convert_loc (location_t loc
, tree type
, tree arg
)
2206 tree orig
= TREE_TYPE (arg
);
2212 if (TREE_CODE (arg
) == ERROR_MARK
2213 || TREE_CODE (type
) == ERROR_MARK
2214 || TREE_CODE (orig
) == ERROR_MARK
)
2215 return error_mark_node
;
2217 switch (TREE_CODE (type
))
2220 case REFERENCE_TYPE
:
2221 /* Handle conversions between pointers to different address spaces. */
2222 if (POINTER_TYPE_P (orig
)
2223 && (TYPE_ADDR_SPACE (TREE_TYPE (type
))
2224 != TYPE_ADDR_SPACE (TREE_TYPE (orig
))))
2225 return fold_build1_loc (loc
, ADDR_SPACE_CONVERT_EXPR
, type
, arg
);
2228 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2230 if (TREE_CODE (arg
) == INTEGER_CST
)
2232 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2233 if (tem
!= NULL_TREE
)
2236 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2237 || TREE_CODE (orig
) == OFFSET_TYPE
)
2238 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2239 if (TREE_CODE (orig
) == COMPLEX_TYPE
)
2240 return fold_convert_loc (loc
, type
,
2241 fold_build1_loc (loc
, REALPART_EXPR
,
2242 TREE_TYPE (orig
), arg
));
2243 gcc_assert (TREE_CODE (orig
) == VECTOR_TYPE
2244 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2245 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2248 if (TREE_CODE (arg
) == INTEGER_CST
)
2250 tem
= fold_convert_const (FLOAT_EXPR
, type
, arg
);
2251 if (tem
!= NULL_TREE
)
2254 else if (TREE_CODE (arg
) == REAL_CST
)
2256 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2257 if (tem
!= NULL_TREE
)
2260 else if (TREE_CODE (arg
) == FIXED_CST
)
2262 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2263 if (tem
!= NULL_TREE
)
2267 switch (TREE_CODE (orig
))
2270 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2271 case POINTER_TYPE
: case REFERENCE_TYPE
:
2272 return fold_build1_loc (loc
, FLOAT_EXPR
, type
, arg
);
2275 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2277 case FIXED_POINT_TYPE
:
2278 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2281 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2282 return fold_convert_loc (loc
, type
, tem
);
2288 case FIXED_POINT_TYPE
:
2289 if (TREE_CODE (arg
) == FIXED_CST
|| TREE_CODE (arg
) == INTEGER_CST
2290 || TREE_CODE (arg
) == REAL_CST
)
2292 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2293 if (tem
!= NULL_TREE
)
2294 goto fold_convert_exit
;
2297 switch (TREE_CODE (orig
))
2299 case FIXED_POINT_TYPE
:
2304 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2307 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2308 return fold_convert_loc (loc
, type
, tem
);
2315 switch (TREE_CODE (orig
))
2318 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2319 case POINTER_TYPE
: case REFERENCE_TYPE
:
2321 case FIXED_POINT_TYPE
:
2322 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
2323 fold_convert_loc (loc
, TREE_TYPE (type
), arg
),
2324 fold_convert_loc (loc
, TREE_TYPE (type
),
2325 integer_zero_node
));
2330 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
2332 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2333 TREE_OPERAND (arg
, 0));
2334 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2335 TREE_OPERAND (arg
, 1));
2336 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2339 arg
= save_expr (arg
);
2340 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2341 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, TREE_TYPE (orig
), arg
);
2342 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
), rpart
);
2343 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
), ipart
);
2344 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2352 if (integer_zerop (arg
))
2353 return build_zero_vector (type
);
2354 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2355 gcc_assert (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2356 || TREE_CODE (orig
) == VECTOR_TYPE
);
2357 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2360 tem
= fold_ignored_result (arg
);
2361 return fold_build1_loc (loc
, NOP_EXPR
, type
, tem
);
2364 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2365 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2369 protected_set_expr_location_unshare (tem
, loc
);
2373 /* Return false if expr can be assumed not to be an lvalue, true
2377 maybe_lvalue_p (const_tree x
)
2379 /* We only need to wrap lvalue tree codes. */
2380 switch (TREE_CODE (x
))
2393 case ARRAY_RANGE_REF
:
2399 case PREINCREMENT_EXPR
:
2400 case PREDECREMENT_EXPR
:
2402 case TRY_CATCH_EXPR
:
2403 case WITH_CLEANUP_EXPR
:
2412 /* Assume the worst for front-end tree codes. */
2413 if ((int)TREE_CODE (x
) >= NUM_TREE_CODES
)
2421 /* Return an expr equal to X but certainly not valid as an lvalue. */
2424 non_lvalue_loc (location_t loc
, tree x
)
2426 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2431 if (! maybe_lvalue_p (x
))
2433 return build1_loc (loc
, NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
2436 /* When pedantic, return an expr equal to X but certainly not valid as a
2437 pedantic lvalue. Otherwise, return X. */
2440 pedantic_non_lvalue_loc (location_t loc
, tree x
)
2442 return protected_set_expr_location_unshare (x
, loc
);
2445 /* Given a tree comparison code, return the code that is the logical inverse.
2446 It is generally not safe to do this for floating-point comparisons, except
2447 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2448 ERROR_MARK in this case. */
2451 invert_tree_comparison (enum tree_code code
, bool honor_nans
)
2453 if (honor_nans
&& flag_trapping_math
&& code
!= EQ_EXPR
&& code
!= NE_EXPR
2454 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
)
2464 return honor_nans
? UNLE_EXPR
: LE_EXPR
;
2466 return honor_nans
? UNLT_EXPR
: LT_EXPR
;
2468 return honor_nans
? UNGE_EXPR
: GE_EXPR
;
2470 return honor_nans
? UNGT_EXPR
: GT_EXPR
;
2484 return UNORDERED_EXPR
;
2485 case UNORDERED_EXPR
:
2486 return ORDERED_EXPR
;
2492 /* Similar, but return the comparison that results if the operands are
2493 swapped. This is safe for floating-point. */
2496 swap_tree_comparison (enum tree_code code
)
2503 case UNORDERED_EXPR
:
2529 /* Convert a comparison tree code from an enum tree_code representation
2530 into a compcode bit-based encoding. This function is the inverse of
2531 compcode_to_comparison. */
2533 static enum comparison_code
2534 comparison_to_compcode (enum tree_code code
)
2551 return COMPCODE_ORD
;
2552 case UNORDERED_EXPR
:
2553 return COMPCODE_UNORD
;
2555 return COMPCODE_UNLT
;
2557 return COMPCODE_UNEQ
;
2559 return COMPCODE_UNLE
;
2561 return COMPCODE_UNGT
;
2563 return COMPCODE_LTGT
;
2565 return COMPCODE_UNGE
;
2571 /* Convert a compcode bit-based encoding of a comparison operator back
2572 to GCC's enum tree_code representation. This function is the
2573 inverse of comparison_to_compcode. */
2575 static enum tree_code
2576 compcode_to_comparison (enum comparison_code code
)
2593 return ORDERED_EXPR
;
2594 case COMPCODE_UNORD
:
2595 return UNORDERED_EXPR
;
2613 /* Return a tree for the comparison which is the combination of
2614 doing the AND or OR (depending on CODE) of the two operations LCODE
2615 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2616 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2617 if this makes the transformation invalid. */
2620 combine_comparisons (location_t loc
,
2621 enum tree_code code
, enum tree_code lcode
,
2622 enum tree_code rcode
, tree truth_type
,
2623 tree ll_arg
, tree lr_arg
)
2625 bool honor_nans
= HONOR_NANS (ll_arg
);
2626 enum comparison_code lcompcode
= comparison_to_compcode (lcode
);
2627 enum comparison_code rcompcode
= comparison_to_compcode (rcode
);
2632 case TRUTH_AND_EXPR
: case TRUTH_ANDIF_EXPR
:
2633 compcode
= lcompcode
& rcompcode
;
2636 case TRUTH_OR_EXPR
: case TRUTH_ORIF_EXPR
:
2637 compcode
= lcompcode
| rcompcode
;
2646 /* Eliminate unordered comparisons, as well as LTGT and ORD
2647 which are not used unless the mode has NaNs. */
2648 compcode
&= ~COMPCODE_UNORD
;
2649 if (compcode
== COMPCODE_LTGT
)
2650 compcode
= COMPCODE_NE
;
2651 else if (compcode
== COMPCODE_ORD
)
2652 compcode
= COMPCODE_TRUE
;
2654 else if (flag_trapping_math
)
2656 /* Check that the original operation and the optimized ones will trap
2657 under the same condition. */
2658 bool ltrap
= (lcompcode
& COMPCODE_UNORD
) == 0
2659 && (lcompcode
!= COMPCODE_EQ
)
2660 && (lcompcode
!= COMPCODE_ORD
);
2661 bool rtrap
= (rcompcode
& COMPCODE_UNORD
) == 0
2662 && (rcompcode
!= COMPCODE_EQ
)
2663 && (rcompcode
!= COMPCODE_ORD
);
2664 bool trap
= (compcode
& COMPCODE_UNORD
) == 0
2665 && (compcode
!= COMPCODE_EQ
)
2666 && (compcode
!= COMPCODE_ORD
);
2668 /* In a short-circuited boolean expression the LHS might be
2669 such that the RHS, if evaluated, will never trap. For
2670 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2671 if neither x nor y is NaN. (This is a mixed blessing: for
2672 example, the expression above will never trap, hence
2673 optimizing it to x < y would be invalid). */
2674 if ((code
== TRUTH_ORIF_EXPR
&& (lcompcode
& COMPCODE_UNORD
))
2675 || (code
== TRUTH_ANDIF_EXPR
&& !(lcompcode
& COMPCODE_UNORD
)))
2678 /* If the comparison was short-circuited, and only the RHS
2679 trapped, we may now generate a spurious trap. */
2681 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2684 /* If we changed the conditions that cause a trap, we lose. */
2685 if ((ltrap
|| rtrap
) != trap
)
2689 if (compcode
== COMPCODE_TRUE
)
2690 return constant_boolean_node (true, truth_type
);
2691 else if (compcode
== COMPCODE_FALSE
)
2692 return constant_boolean_node (false, truth_type
);
2695 enum tree_code tcode
;
2697 tcode
= compcode_to_comparison ((enum comparison_code
) compcode
);
2698 return fold_build2_loc (loc
, tcode
, truth_type
, ll_arg
, lr_arg
);
2702 /* Return nonzero if two operands (typically of the same tree node)
2703 are necessarily equal. FLAGS modifies behavior as follows:
2705 If OEP_ONLY_CONST is set, only return nonzero for constants.
2706 This function tests whether the operands are indistinguishable;
2707 it does not test whether they are equal using C's == operation.
2708 The distinction is important for IEEE floating point, because
2709 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2710 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2712 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2713 even though it may hold multiple values during a function.
2714 This is because a GCC tree node guarantees that nothing else is
2715 executed between the evaluation of its "operands" (which may often
2716 be evaluated in arbitrary order). Hence if the operands themselves
2717 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2718 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2719 unset means assuming isochronic (or instantaneous) tree equivalence.
2720 Unless comparing arbitrary expression trees, such as from different
2721 statements, this flag can usually be left unset.
2723 If OEP_PURE_SAME is set, then pure functions with identical arguments
2724 are considered the same. It is used when the caller has other ways
2725 to ensure that global memory is unchanged in between.
2727 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2728 not values of expressions.
2730 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2731 any operand with side effect. This is unnecesarily conservative in the
2732 case we know that arg0 and arg1 are in disjoint code paths (such as in
2733 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2734 addresses with TREE_CONSTANT flag set so we know that &var == &var
2735 even if var is volatile. */
2738 operand_equal_p (const_tree arg0
, const_tree arg1
, unsigned int flags
)
2740 /* If either is ERROR_MARK, they aren't equal. */
2741 if (TREE_CODE (arg0
) == ERROR_MARK
|| TREE_CODE (arg1
) == ERROR_MARK
2742 || TREE_TYPE (arg0
) == error_mark_node
2743 || TREE_TYPE (arg1
) == error_mark_node
)
2746 /* Similar, if either does not have a type (like a released SSA name),
2747 they aren't equal. */
2748 if (!TREE_TYPE (arg0
) || !TREE_TYPE (arg1
))
2751 /* We cannot consider pointers to different address space equal. */
2752 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
2753 && POINTER_TYPE_P (TREE_TYPE (arg1
))
2754 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
)))
2755 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1
)))))
2758 /* Check equality of integer constants before bailing out due to
2759 precision differences. */
2760 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2762 /* Address of INTEGER_CST is not defined; check that we did not forget
2763 to drop the OEP_ADDRESS_OF flags. */
2764 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
2765 return tree_int_cst_equal (arg0
, arg1
);
2768 if (!(flags
& OEP_ADDRESS_OF
))
2770 /* If both types don't have the same signedness, then we can't consider
2771 them equal. We must check this before the STRIP_NOPS calls
2772 because they may change the signedness of the arguments. As pointers
2773 strictly don't have a signedness, require either two pointers or
2774 two non-pointers as well. */
2775 if (TYPE_UNSIGNED (TREE_TYPE (arg0
)) != TYPE_UNSIGNED (TREE_TYPE (arg1
))
2776 || POINTER_TYPE_P (TREE_TYPE (arg0
))
2777 != POINTER_TYPE_P (TREE_TYPE (arg1
)))
2780 /* If both types don't have the same precision, then it is not safe
2782 if (element_precision (TREE_TYPE (arg0
))
2783 != element_precision (TREE_TYPE (arg1
)))
2790 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2791 sanity check once the issue is solved. */
2793 /* Addresses of conversions and SSA_NAMEs (and many other things)
2794 are not defined. Check that we did not forget to drop the
2795 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2796 gcc_checking_assert (!CONVERT_EXPR_P (arg0
) && !CONVERT_EXPR_P (arg1
)
2797 && TREE_CODE (arg0
) != SSA_NAME
);
2800 /* In case both args are comparisons but with different comparison
2801 code, try to swap the comparison operands of one arg to produce
2802 a match and compare that variant. */
2803 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2804 && COMPARISON_CLASS_P (arg0
)
2805 && COMPARISON_CLASS_P (arg1
))
2807 enum tree_code swap_code
= swap_tree_comparison (TREE_CODE (arg1
));
2809 if (TREE_CODE (arg0
) == swap_code
)
2810 return operand_equal_p (TREE_OPERAND (arg0
, 0),
2811 TREE_OPERAND (arg1
, 1), flags
)
2812 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2813 TREE_OPERAND (arg1
, 0), flags
);
2816 if (TREE_CODE (arg0
) != TREE_CODE (arg1
))
2818 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2819 if (CONVERT_EXPR_P (arg0
) && CONVERT_EXPR_P (arg1
))
2821 else if (flags
& OEP_ADDRESS_OF
)
2823 /* If we are interested in comparing addresses ignore
2824 MEM_REF wrappings of the base that can appear just for
2826 if (TREE_CODE (arg0
) == MEM_REF
2828 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ADDR_EXPR
2829 && TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0) == arg1
2830 && integer_zerop (TREE_OPERAND (arg0
, 1)))
2832 else if (TREE_CODE (arg1
) == MEM_REF
2834 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ADDR_EXPR
2835 && TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0) == arg0
2836 && integer_zerop (TREE_OPERAND (arg1
, 1)))
2844 /* When not checking adddresses, this is needed for conversions and for
2845 COMPONENT_REF. Might as well play it safe and always test this. */
2846 if (TREE_CODE (TREE_TYPE (arg0
)) == ERROR_MARK
2847 || TREE_CODE (TREE_TYPE (arg1
)) == ERROR_MARK
2848 || (TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
))
2849 && !(flags
& OEP_ADDRESS_OF
)))
2852 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2853 We don't care about side effects in that case because the SAVE_EXPR
2854 takes care of that for us. In all other cases, two expressions are
2855 equal if they have no side effects. If we have two identical
2856 expressions with side effects that should be treated the same due
2857 to the only side effects being identical SAVE_EXPR's, that will
2858 be detected in the recursive calls below.
2859 If we are taking an invariant address of two identical objects
2860 they are necessarily equal as well. */
2861 if (arg0
== arg1
&& ! (flags
& OEP_ONLY_CONST
)
2862 && (TREE_CODE (arg0
) == SAVE_EXPR
2863 || (flags
& OEP_MATCH_SIDE_EFFECTS
)
2864 || (! TREE_SIDE_EFFECTS (arg0
) && ! TREE_SIDE_EFFECTS (arg1
))))
2867 /* Next handle constant cases, those for which we can return 1 even
2868 if ONLY_CONST is set. */
2869 if (TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
))
2870 switch (TREE_CODE (arg0
))
2873 return tree_int_cst_equal (arg0
, arg1
);
2876 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0
),
2877 TREE_FIXED_CST (arg1
));
2880 if (real_identical (&TREE_REAL_CST (arg0
), &TREE_REAL_CST (arg1
)))
2884 if (!HONOR_SIGNED_ZEROS (arg0
))
2886 /* If we do not distinguish between signed and unsigned zero,
2887 consider them equal. */
2888 if (real_zerop (arg0
) && real_zerop (arg1
))
2897 if (VECTOR_CST_NELTS (arg0
) != VECTOR_CST_NELTS (arg1
))
2900 for (i
= 0; i
< VECTOR_CST_NELTS (arg0
); ++i
)
2902 if (!operand_equal_p (VECTOR_CST_ELT (arg0
, i
),
2903 VECTOR_CST_ELT (arg1
, i
), flags
))
2910 return (operand_equal_p (TREE_REALPART (arg0
), TREE_REALPART (arg1
),
2912 && operand_equal_p (TREE_IMAGPART (arg0
), TREE_IMAGPART (arg1
),
2916 return (TREE_STRING_LENGTH (arg0
) == TREE_STRING_LENGTH (arg1
)
2917 && ! memcmp (TREE_STRING_POINTER (arg0
),
2918 TREE_STRING_POINTER (arg1
),
2919 TREE_STRING_LENGTH (arg0
)));
2922 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
2923 return operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0),
2924 flags
| OEP_ADDRESS_OF
2925 | OEP_MATCH_SIDE_EFFECTS
);
2927 /* In GIMPLE empty constructors are allowed in initializers of
2929 return (!vec_safe_length (CONSTRUCTOR_ELTS (arg0
))
2930 && !vec_safe_length (CONSTRUCTOR_ELTS (arg1
)));
2935 if (flags
& OEP_ONLY_CONST
)
2938 /* Define macros to test an operand from arg0 and arg1 for equality and a
2939 variant that allows null and views null as being different from any
2940 non-null value. In the latter case, if either is null, the both
2941 must be; otherwise, do the normal comparison. */
2942 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2943 TREE_OPERAND (arg1, N), flags)
2945 #define OP_SAME_WITH_NULL(N) \
2946 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2947 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2949 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
2952 /* Two conversions are equal only if signedness and modes match. */
2953 switch (TREE_CODE (arg0
))
2956 case FIX_TRUNC_EXPR
:
2957 if (TYPE_UNSIGNED (TREE_TYPE (arg0
))
2958 != TYPE_UNSIGNED (TREE_TYPE (arg1
)))
2968 case tcc_comparison
:
2970 if (OP_SAME (0) && OP_SAME (1))
2973 /* For commutative ops, allow the other order. */
2974 return (commutative_tree_code (TREE_CODE (arg0
))
2975 && operand_equal_p (TREE_OPERAND (arg0
, 0),
2976 TREE_OPERAND (arg1
, 1), flags
)
2977 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2978 TREE_OPERAND (arg1
, 0), flags
));
2981 /* If either of the pointer (or reference) expressions we are
2982 dereferencing contain a side effect, these cannot be equal,
2983 but their addresses can be. */
2984 if ((flags
& OEP_MATCH_SIDE_EFFECTS
) == 0
2985 && (TREE_SIDE_EFFECTS (arg0
)
2986 || TREE_SIDE_EFFECTS (arg1
)))
2989 switch (TREE_CODE (arg0
))
2992 if (!(flags
& OEP_ADDRESS_OF
)
2993 && (TYPE_ALIGN (TREE_TYPE (arg0
))
2994 != TYPE_ALIGN (TREE_TYPE (arg1
))))
2996 flags
&= ~OEP_ADDRESS_OF
;
3001 case VIEW_CONVERT_EXPR
:
3004 case TARGET_MEM_REF
:
3006 if (!(flags
& OEP_ADDRESS_OF
))
3008 /* Require equal access sizes */
3009 if (TYPE_SIZE (TREE_TYPE (arg0
)) != TYPE_SIZE (TREE_TYPE (arg1
))
3010 && (!TYPE_SIZE (TREE_TYPE (arg0
))
3011 || !TYPE_SIZE (TREE_TYPE (arg1
))
3012 || !operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3013 TYPE_SIZE (TREE_TYPE (arg1
)),
3016 /* Verify that accesses are TBAA compatible. */
3017 if (!alias_ptr_types_compatible_p
3018 (TREE_TYPE (TREE_OPERAND (arg0
, 1)),
3019 TREE_TYPE (TREE_OPERAND (arg1
, 1)))
3020 || (MR_DEPENDENCE_CLIQUE (arg0
)
3021 != MR_DEPENDENCE_CLIQUE (arg1
))
3022 || (MR_DEPENDENCE_BASE (arg0
)
3023 != MR_DEPENDENCE_BASE (arg1
)))
3025 /* Verify that alignment is compatible. */
3026 if (TYPE_ALIGN (TREE_TYPE (arg0
))
3027 != TYPE_ALIGN (TREE_TYPE (arg1
)))
3030 flags
&= ~OEP_ADDRESS_OF
;
3031 return (OP_SAME (0) && OP_SAME (1)
3032 /* TARGET_MEM_REF require equal extra operands. */
3033 && (TREE_CODE (arg0
) != TARGET_MEM_REF
3034 || (OP_SAME_WITH_NULL (2)
3035 && OP_SAME_WITH_NULL (3)
3036 && OP_SAME_WITH_NULL (4))));
3039 case ARRAY_RANGE_REF
:
3040 /* Operands 2 and 3 may be null.
3041 Compare the array index by value if it is constant first as we
3042 may have different types but same value here. */
3045 flags
&= ~OEP_ADDRESS_OF
;
3046 return ((tree_int_cst_equal (TREE_OPERAND (arg0
, 1),
3047 TREE_OPERAND (arg1
, 1))
3049 && OP_SAME_WITH_NULL (2)
3050 && OP_SAME_WITH_NULL (3));
3053 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3054 may be NULL when we're called to compare MEM_EXPRs. */
3055 if (!OP_SAME_WITH_NULL (0)
3058 flags
&= ~OEP_ADDRESS_OF
;
3059 return OP_SAME_WITH_NULL (2);
3064 flags
&= ~OEP_ADDRESS_OF
;
3065 return OP_SAME (1) && OP_SAME (2);
3071 case tcc_expression
:
3072 switch (TREE_CODE (arg0
))
3075 /* Be sure we pass right ADDRESS_OF flag. */
3076 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
3077 return operand_equal_p (TREE_OPERAND (arg0
, 0),
3078 TREE_OPERAND (arg1
, 0),
3079 flags
| OEP_ADDRESS_OF
);
3081 case TRUTH_NOT_EXPR
:
3084 case TRUTH_ANDIF_EXPR
:
3085 case TRUTH_ORIF_EXPR
:
3086 return OP_SAME (0) && OP_SAME (1);
3089 case WIDEN_MULT_PLUS_EXPR
:
3090 case WIDEN_MULT_MINUS_EXPR
:
3093 /* The multiplcation operands are commutative. */
3096 case TRUTH_AND_EXPR
:
3098 case TRUTH_XOR_EXPR
:
3099 if (OP_SAME (0) && OP_SAME (1))
3102 /* Otherwise take into account this is a commutative operation. */
3103 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
3104 TREE_OPERAND (arg1
, 1), flags
)
3105 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3106 TREE_OPERAND (arg1
, 0), flags
));
3111 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3118 switch (TREE_CODE (arg0
))
3121 if ((CALL_EXPR_FN (arg0
) == NULL_TREE
)
3122 != (CALL_EXPR_FN (arg1
) == NULL_TREE
))
3123 /* If not both CALL_EXPRs are either internal or normal function
3124 functions, then they are not equal. */
3126 else if (CALL_EXPR_FN (arg0
) == NULL_TREE
)
3128 /* If the CALL_EXPRs call different internal functions, then they
3130 if (CALL_EXPR_IFN (arg0
) != CALL_EXPR_IFN (arg1
))
3135 /* If the CALL_EXPRs call different functions, then they are not
3137 if (! operand_equal_p (CALL_EXPR_FN (arg0
), CALL_EXPR_FN (arg1
),
3142 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3144 unsigned int cef
= call_expr_flags (arg0
);
3145 if (flags
& OEP_PURE_SAME
)
3146 cef
&= ECF_CONST
| ECF_PURE
;
3153 /* Now see if all the arguments are the same. */
3155 const_call_expr_arg_iterator iter0
, iter1
;
3157 for (a0
= first_const_call_expr_arg (arg0
, &iter0
),
3158 a1
= first_const_call_expr_arg (arg1
, &iter1
);
3160 a0
= next_const_call_expr_arg (&iter0
),
3161 a1
= next_const_call_expr_arg (&iter1
))
3162 if (! operand_equal_p (a0
, a1
, flags
))
3165 /* If we get here and both argument lists are exhausted
3166 then the CALL_EXPRs are equal. */
3167 return ! (a0
|| a1
);
3173 case tcc_declaration
:
3174 /* Consider __builtin_sqrt equal to sqrt. */
3175 return (TREE_CODE (arg0
) == FUNCTION_DECL
3176 && DECL_BUILT_IN (arg0
) && DECL_BUILT_IN (arg1
)
3177 && DECL_BUILT_IN_CLASS (arg0
) == DECL_BUILT_IN_CLASS (arg1
)
3178 && DECL_FUNCTION_CODE (arg0
) == DECL_FUNCTION_CODE (arg1
));
3180 case tcc_exceptional
:
3181 if (TREE_CODE (arg0
) == CONSTRUCTOR
)
3183 /* In GIMPLE constructors are used only to build vectors from
3184 elements. Individual elements in the constructor must be
3185 indexed in increasing order and form an initial sequence.
3187 We make no effort to compare constructors in generic.
3188 (see sem_variable::equals in ipa-icf which can do so for
3190 if (!VECTOR_TYPE_P (TREE_TYPE (arg0
))
3191 || !VECTOR_TYPE_P (TREE_TYPE (arg1
)))
3194 /* Be sure that vectors constructed have the same representation.
3195 We only tested element precision and modes to match.
3196 Vectors may be BLKmode and thus also check that the number of
3198 if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
))
3199 != TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)))
3202 vec
<constructor_elt
, va_gc
> *v0
= CONSTRUCTOR_ELTS (arg0
);
3203 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (arg1
);
3204 unsigned int len
= vec_safe_length (v0
);
3206 if (len
!= vec_safe_length (v1
))
3209 for (unsigned int i
= 0; i
< len
; i
++)
3211 constructor_elt
*c0
= &(*v0
)[i
];
3212 constructor_elt
*c1
= &(*v1
)[i
];
3214 if (!operand_equal_p (c0
->value
, c1
->value
, flags
)
3215 /* In GIMPLE the indexes can be either NULL or matching i.
3216 Double check this so we won't get false
3217 positives for GENERIC. */
3219 && (TREE_CODE (c0
->index
) != INTEGER_CST
3220 || !compare_tree_int (c0
->index
, i
)))
3222 && (TREE_CODE (c1
->index
) != INTEGER_CST
3223 || !compare_tree_int (c1
->index
, i
))))
3235 #undef OP_SAME_WITH_NULL
3238 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3239 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3241 When in doubt, return 0. */
3244 operand_equal_for_comparison_p (tree arg0
, tree arg1
, tree other
)
3246 int unsignedp1
, unsignedpo
;
3247 tree primarg0
, primarg1
, primother
;
3248 unsigned int correct_width
;
3250 if (operand_equal_p (arg0
, arg1
, 0))
3253 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
3254 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
3257 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3258 and see if the inner values are the same. This removes any
3259 signedness comparison, which doesn't matter here. */
3260 primarg0
= arg0
, primarg1
= arg1
;
3261 STRIP_NOPS (primarg0
);
3262 STRIP_NOPS (primarg1
);
3263 if (operand_equal_p (primarg0
, primarg1
, 0))
3266 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3267 actual comparison operand, ARG0.
3269 First throw away any conversions to wider types
3270 already present in the operands. */
3272 primarg1
= get_narrower (arg1
, &unsignedp1
);
3273 primother
= get_narrower (other
, &unsignedpo
);
3275 correct_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
3276 if (unsignedp1
== unsignedpo
3277 && TYPE_PRECISION (TREE_TYPE (primarg1
)) < correct_width
3278 && TYPE_PRECISION (TREE_TYPE (primother
)) < correct_width
)
3280 tree type
= TREE_TYPE (arg0
);
3282 /* Make sure shorter operand is extended the right way
3283 to match the longer operand. */
3284 primarg1
= fold_convert (signed_or_unsigned_type_for
3285 (unsignedp1
, TREE_TYPE (primarg1
)), primarg1
);
3287 if (operand_equal_p (arg0
, fold_convert (type
, primarg1
), 0))
3294 /* See if ARG is an expression that is either a comparison or is performing
3295 arithmetic on comparisons. The comparisons must only be comparing
3296 two different values, which will be stored in *CVAL1 and *CVAL2; if
3297 they are nonzero it means that some operands have already been found.
3298 No variables may be used anywhere else in the expression except in the
3299 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3300 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3302 If this is true, return 1. Otherwise, return zero. */
3305 twoval_comparison_p (tree arg
, tree
*cval1
, tree
*cval2
, int *save_p
)
3307 enum tree_code code
= TREE_CODE (arg
);
3308 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3310 /* We can handle some of the tcc_expression cases here. */
3311 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3313 else if (tclass
== tcc_expression
3314 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
3315 || code
== COMPOUND_EXPR
))
3316 tclass
= tcc_binary
;
3318 else if (tclass
== tcc_expression
&& code
== SAVE_EXPR
3319 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
3321 /* If we've already found a CVAL1 or CVAL2, this expression is
3322 two complex to handle. */
3323 if (*cval1
|| *cval2
)
3333 return twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
);
3336 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
)
3337 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
3338 cval1
, cval2
, save_p
));
3343 case tcc_expression
:
3344 if (code
== COND_EXPR
)
3345 return (twoval_comparison_p (TREE_OPERAND (arg
, 0),
3346 cval1
, cval2
, save_p
)
3347 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
3348 cval1
, cval2
, save_p
)
3349 && twoval_comparison_p (TREE_OPERAND (arg
, 2),
3350 cval1
, cval2
, save_p
));
3353 case tcc_comparison
:
3354 /* First see if we can handle the first operand, then the second. For
3355 the second operand, we know *CVAL1 can't be zero. It must be that
3356 one side of the comparison is each of the values; test for the
3357 case where this isn't true by failing if the two operands
3360 if (operand_equal_p (TREE_OPERAND (arg
, 0),
3361 TREE_OPERAND (arg
, 1), 0))
3365 *cval1
= TREE_OPERAND (arg
, 0);
3366 else if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 0), 0))
3368 else if (*cval2
== 0)
3369 *cval2
= TREE_OPERAND (arg
, 0);
3370 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 0), 0))
3375 if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 1), 0))
3377 else if (*cval2
== 0)
3378 *cval2
= TREE_OPERAND (arg
, 1);
3379 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 1), 0))
3391 /* ARG is a tree that is known to contain just arithmetic operations and
3392 comparisons. Evaluate the operations in the tree substituting NEW0 for
3393 any occurrence of OLD0 as an operand of a comparison and likewise for
3397 eval_subst (location_t loc
, tree arg
, tree old0
, tree new0
,
3398 tree old1
, tree new1
)
3400 tree type
= TREE_TYPE (arg
);
3401 enum tree_code code
= TREE_CODE (arg
);
3402 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3404 /* We can handle some of the tcc_expression cases here. */
3405 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3407 else if (tclass
== tcc_expression
3408 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
3409 tclass
= tcc_binary
;
3414 return fold_build1_loc (loc
, code
, type
,
3415 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3416 old0
, new0
, old1
, new1
));
3419 return fold_build2_loc (loc
, code
, type
,
3420 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3421 old0
, new0
, old1
, new1
),
3422 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3423 old0
, new0
, old1
, new1
));
3425 case tcc_expression
:
3429 return eval_subst (loc
, TREE_OPERAND (arg
, 0), old0
, new0
,
3433 return eval_subst (loc
, TREE_OPERAND (arg
, 1), old0
, new0
,
3437 return fold_build3_loc (loc
, code
, type
,
3438 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3439 old0
, new0
, old1
, new1
),
3440 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3441 old0
, new0
, old1
, new1
),
3442 eval_subst (loc
, TREE_OPERAND (arg
, 2),
3443 old0
, new0
, old1
, new1
));
3447 /* Fall through - ??? */
3449 case tcc_comparison
:
3451 tree arg0
= TREE_OPERAND (arg
, 0);
3452 tree arg1
= TREE_OPERAND (arg
, 1);
3454 /* We need to check both for exact equality and tree equality. The
3455 former will be true if the operand has a side-effect. In that
3456 case, we know the operand occurred exactly once. */
3458 if (arg0
== old0
|| operand_equal_p (arg0
, old0
, 0))
3460 else if (arg0
== old1
|| operand_equal_p (arg0
, old1
, 0))
3463 if (arg1
== old0
|| operand_equal_p (arg1
, old0
, 0))
3465 else if (arg1
== old1
|| operand_equal_p (arg1
, old1
, 0))
3468 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
3476 /* Return a tree for the case when the result of an expression is RESULT
3477 converted to TYPE and OMITTED was previously an operand of the expression
3478 but is now not needed (e.g., we folded OMITTED * 0).
3480 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3481 the conversion of RESULT to TYPE. */
3484 omit_one_operand_loc (location_t loc
, tree type
, tree result
, tree omitted
)
3486 tree t
= fold_convert_loc (loc
, type
, result
);
3488 /* If the resulting operand is an empty statement, just return the omitted
3489 statement casted to void. */
3490 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
3491 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
3492 fold_ignored_result (omitted
));
3494 if (TREE_SIDE_EFFECTS (omitted
))
3495 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3496 fold_ignored_result (omitted
), t
);
3498 return non_lvalue_loc (loc
, t
);
3501 /* Return a tree for the case when the result of an expression is RESULT
3502 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3503 of the expression but are now not needed.
3505 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3506 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3507 evaluated before OMITTED2. Otherwise, if neither has side effects,
3508 just do the conversion of RESULT to TYPE. */
3511 omit_two_operands_loc (location_t loc
, tree type
, tree result
,
3512 tree omitted1
, tree omitted2
)
3514 tree t
= fold_convert_loc (loc
, type
, result
);
3516 if (TREE_SIDE_EFFECTS (omitted2
))
3517 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted2
, t
);
3518 if (TREE_SIDE_EFFECTS (omitted1
))
3519 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted1
, t
);
3521 return TREE_CODE (t
) != COMPOUND_EXPR
? non_lvalue_loc (loc
, t
) : t
;
3525 /* Return a simplified tree node for the truth-negation of ARG. This
3526 never alters ARG itself. We assume that ARG is an operation that
3527 returns a truth value (0 or 1).
3529 FIXME: one would think we would fold the result, but it causes
3530 problems with the dominator optimizer. */
3533 fold_truth_not_expr (location_t loc
, tree arg
)
3535 tree type
= TREE_TYPE (arg
);
3536 enum tree_code code
= TREE_CODE (arg
);
3537 location_t loc1
, loc2
;
3539 /* If this is a comparison, we can simply invert it, except for
3540 floating-point non-equality comparisons, in which case we just
3541 enclose a TRUTH_NOT_EXPR around what we have. */
3543 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3545 tree op_type
= TREE_TYPE (TREE_OPERAND (arg
, 0));
3546 if (FLOAT_TYPE_P (op_type
)
3547 && flag_trapping_math
3548 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
3549 && code
!= NE_EXPR
&& code
!= EQ_EXPR
)
3552 code
= invert_tree_comparison (code
, HONOR_NANS (op_type
));
3553 if (code
== ERROR_MARK
)
3556 return build2_loc (loc
, code
, type
, TREE_OPERAND (arg
, 0),
3557 TREE_OPERAND (arg
, 1));
3563 return constant_boolean_node (integer_zerop (arg
), type
);
3565 case TRUTH_AND_EXPR
:
3566 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3567 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3568 return build2_loc (loc
, TRUTH_OR_EXPR
, type
,
3569 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3570 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3573 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3574 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3575 return build2_loc (loc
, TRUTH_AND_EXPR
, type
,
3576 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3577 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3579 case TRUTH_XOR_EXPR
:
3580 /* Here we can invert either operand. We invert the first operand
3581 unless the second operand is a TRUTH_NOT_EXPR in which case our
3582 result is the XOR of the first operand with the inside of the
3583 negation of the second operand. */
3585 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == TRUTH_NOT_EXPR
)
3586 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
, TREE_OPERAND (arg
, 0),
3587 TREE_OPERAND (TREE_OPERAND (arg
, 1), 0));
3589 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
,
3590 invert_truthvalue_loc (loc
, TREE_OPERAND (arg
, 0)),
3591 TREE_OPERAND (arg
, 1));
3593 case TRUTH_ANDIF_EXPR
:
3594 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3595 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3596 return build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
3597 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3598 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3600 case TRUTH_ORIF_EXPR
:
3601 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3602 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3603 return build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
3604 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3605 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3607 case TRUTH_NOT_EXPR
:
3608 return TREE_OPERAND (arg
, 0);
3612 tree arg1
= TREE_OPERAND (arg
, 1);
3613 tree arg2
= TREE_OPERAND (arg
, 2);
3615 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3616 loc2
= expr_location_or (TREE_OPERAND (arg
, 2), loc
);
3618 /* A COND_EXPR may have a throw as one operand, which
3619 then has void type. Just leave void operands
3621 return build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
3622 VOID_TYPE_P (TREE_TYPE (arg1
))
3623 ? arg1
: invert_truthvalue_loc (loc1
, arg1
),
3624 VOID_TYPE_P (TREE_TYPE (arg2
))
3625 ? arg2
: invert_truthvalue_loc (loc2
, arg2
));
3629 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3630 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3631 TREE_OPERAND (arg
, 0),
3632 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 1)));
3634 case NON_LVALUE_EXPR
:
3635 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3636 return invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0));
3639 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
3640 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3642 /* ... fall through ... */
3645 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3646 return build1_loc (loc
, TREE_CODE (arg
), type
,
3647 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3650 if (!integer_onep (TREE_OPERAND (arg
, 1)))
3652 return build2_loc (loc
, EQ_EXPR
, type
, arg
, build_int_cst (type
, 0));
3655 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3657 case CLEANUP_POINT_EXPR
:
3658 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3659 return build1_loc (loc
, CLEANUP_POINT_EXPR
, type
,
3660 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3667 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3668 assume that ARG is an operation that returns a truth value (0 or 1
3669 for scalars, 0 or -1 for vectors). Return the folded expression if
3670 folding is successful. Otherwise, return NULL_TREE. */
3673 fold_invert_truthvalue (location_t loc
, tree arg
)
3675 tree type
= TREE_TYPE (arg
);
3676 return fold_unary_loc (loc
, VECTOR_TYPE_P (type
)
3682 /* Return a simplified tree node for the truth-negation of ARG. This
3683 never alters ARG itself. We assume that ARG is an operation that
3684 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3687 invert_truthvalue_loc (location_t loc
, tree arg
)
3689 if (TREE_CODE (arg
) == ERROR_MARK
)
3692 tree type
= TREE_TYPE (arg
);
3693 return fold_build1_loc (loc
, VECTOR_TYPE_P (type
)
3699 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3700 with code CODE. This optimization is unsafe. */
3702 distribute_real_division (location_t loc
, enum tree_code code
, tree type
,
3703 tree arg0
, tree arg1
)
3705 bool mul0
= TREE_CODE (arg0
) == MULT_EXPR
;
3706 bool mul1
= TREE_CODE (arg1
) == MULT_EXPR
;
3708 /* (A / C) +- (B / C) -> (A +- B) / C. */
3710 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3711 TREE_OPERAND (arg1
, 1), 0))
3712 return fold_build2_loc (loc
, mul0
? MULT_EXPR
: RDIV_EXPR
, type
,
3713 fold_build2_loc (loc
, code
, type
,
3714 TREE_OPERAND (arg0
, 0),
3715 TREE_OPERAND (arg1
, 0)),
3716 TREE_OPERAND (arg0
, 1));
3718 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3719 if (operand_equal_p (TREE_OPERAND (arg0
, 0),
3720 TREE_OPERAND (arg1
, 0), 0)
3721 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
3722 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
3724 REAL_VALUE_TYPE r0
, r1
;
3725 r0
= TREE_REAL_CST (TREE_OPERAND (arg0
, 1));
3726 r1
= TREE_REAL_CST (TREE_OPERAND (arg1
, 1));
3728 real_arithmetic (&r0
, RDIV_EXPR
, &dconst1
, &r0
);
3730 real_arithmetic (&r1
, RDIV_EXPR
, &dconst1
, &r1
);
3731 real_arithmetic (&r0
, code
, &r0
, &r1
);
3732 return fold_build2_loc (loc
, MULT_EXPR
, type
,
3733 TREE_OPERAND (arg0
, 0),
3734 build_real (type
, r0
));
3740 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3741 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3742 and uses reverse storage order if REVERSEP is nonzero. */
3745 make_bit_field_ref (location_t loc
, tree inner
, tree type
,
3746 HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
3747 int unsignedp
, int reversep
)
3749 tree result
, bftype
;
3751 if (bitpos
== 0 && !reversep
)
3753 tree size
= TYPE_SIZE (TREE_TYPE (inner
));
3754 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner
))
3755 || POINTER_TYPE_P (TREE_TYPE (inner
)))
3756 && tree_fits_shwi_p (size
)
3757 && tree_to_shwi (size
) == bitsize
)
3758 return fold_convert_loc (loc
, type
, inner
);
3762 if (TYPE_PRECISION (bftype
) != bitsize
3763 || TYPE_UNSIGNED (bftype
) == !unsignedp
)
3764 bftype
= build_nonstandard_integer_type (bitsize
, 0);
3766 result
= build3_loc (loc
, BIT_FIELD_REF
, bftype
, inner
,
3767 size_int (bitsize
), bitsize_int (bitpos
));
3768 REF_REVERSE_STORAGE_ORDER (result
) = reversep
;
3771 result
= fold_convert_loc (loc
, type
, result
);
3776 /* Optimize a bit-field compare.
3778 There are two cases: First is a compare against a constant and the
3779 second is a comparison of two items where the fields are at the same
3780 bit position relative to the start of a chunk (byte, halfword, word)
3781 large enough to contain it. In these cases we can avoid the shift
3782 implicit in bitfield extractions.
3784 For constants, we emit a compare of the shifted constant with the
3785 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3786 compared. For two fields at the same position, we do the ANDs with the
3787 similar mask and compare the result of the ANDs.
3789 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3790 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3791 are the left and right operands of the comparison, respectively.
3793 If the optimization described above can be done, we return the resulting
3794 tree. Otherwise we return zero. */
3797 optimize_bit_field_compare (location_t loc
, enum tree_code code
,
3798 tree compare_type
, tree lhs
, tree rhs
)
3800 HOST_WIDE_INT lbitpos
, lbitsize
, rbitpos
, rbitsize
, nbitpos
, nbitsize
;
3801 tree type
= TREE_TYPE (lhs
);
3803 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
3804 machine_mode lmode
, rmode
, nmode
;
3805 int lunsignedp
, runsignedp
;
3806 int lreversep
, rreversep
;
3807 int lvolatilep
= 0, rvolatilep
= 0;
3808 tree linner
, rinner
= NULL_TREE
;
3812 /* Get all the information about the extractions being done. If the bit size
3813 if the same as the size of the underlying object, we aren't doing an
3814 extraction at all and so can do nothing. We also don't want to
3815 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3816 then will no longer be able to replace it. */
3817 linner
= get_inner_reference (lhs
, &lbitsize
, &lbitpos
, &offset
, &lmode
,
3818 &lunsignedp
, &lreversep
, &lvolatilep
, false);
3819 if (linner
== lhs
|| lbitsize
== GET_MODE_BITSIZE (lmode
) || lbitsize
< 0
3820 || offset
!= 0 || TREE_CODE (linner
) == PLACEHOLDER_EXPR
|| lvolatilep
)
3824 rreversep
= lreversep
;
3827 /* If this is not a constant, we can only do something if bit positions,
3828 sizes, signedness and storage order are the same. */
3830 = get_inner_reference (rhs
, &rbitsize
, &rbitpos
, &offset
, &rmode
,
3831 &runsignedp
, &rreversep
, &rvolatilep
, false);
3833 if (rinner
== rhs
|| lbitpos
!= rbitpos
|| lbitsize
!= rbitsize
3834 || lunsignedp
!= runsignedp
|| lreversep
!= rreversep
|| offset
!= 0
3835 || TREE_CODE (rinner
) == PLACEHOLDER_EXPR
|| rvolatilep
)
3839 /* See if we can find a mode to refer to this field. We should be able to,
3840 but fail if we can't. */
3841 nmode
= get_best_mode (lbitsize
, lbitpos
, 0, 0,
3842 const_p
? TYPE_ALIGN (TREE_TYPE (linner
))
3843 : MIN (TYPE_ALIGN (TREE_TYPE (linner
)),
3844 TYPE_ALIGN (TREE_TYPE (rinner
))),
3846 if (nmode
== VOIDmode
)
3849 /* Set signed and unsigned types of the precision of this mode for the
3851 unsigned_type
= lang_hooks
.types
.type_for_mode (nmode
, 1);
3853 /* Compute the bit position and size for the new reference and our offset
3854 within it. If the new reference is the same size as the original, we
3855 won't optimize anything, so return zero. */
3856 nbitsize
= GET_MODE_BITSIZE (nmode
);
3857 nbitpos
= lbitpos
& ~ (nbitsize
- 1);
3859 if (nbitsize
== lbitsize
)
3862 if (lreversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
3863 lbitpos
= nbitsize
- lbitsize
- lbitpos
;
3865 /* Make the mask to be used against the extracted field. */
3866 mask
= build_int_cst_type (unsigned_type
, -1);
3867 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (nbitsize
- lbitsize
));
3868 mask
= const_binop (RSHIFT_EXPR
, mask
,
3869 size_int (nbitsize
- lbitsize
- lbitpos
));
3872 /* If not comparing with constant, just rework the comparison
3874 return fold_build2_loc (loc
, code
, compare_type
,
3875 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3876 make_bit_field_ref (loc
, linner
,
3881 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3882 make_bit_field_ref (loc
, rinner
,
3888 /* Otherwise, we are handling the constant case. See if the constant is too
3889 big for the field. Warn and return a tree for 0 (false) if so. We do
3890 this not only for its own sake, but to avoid having to test for this
3891 error case below. If we didn't, we might generate wrong code.
3893 For unsigned fields, the constant shifted right by the field length should
3894 be all zero. For signed fields, the high-order bits should agree with
3899 if (wi::lrshift (rhs
, lbitsize
) != 0)
3901 warning (0, "comparison is always %d due to width of bit-field",
3903 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3908 wide_int tem
= wi::arshift (rhs
, lbitsize
- 1);
3909 if (tem
!= 0 && tem
!= -1)
3911 warning (0, "comparison is always %d due to width of bit-field",
3913 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3917 /* Single-bit compares should always be against zero. */
3918 if (lbitsize
== 1 && ! integer_zerop (rhs
))
3920 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
3921 rhs
= build_int_cst (type
, 0);
3924 /* Make a new bitfield reference, shift the constant over the
3925 appropriate number of bits and mask it with the computed mask
3926 (in case this was a signed field). If we changed it, make a new one. */
3927 lhs
= make_bit_field_ref (loc
, linner
, unsigned_type
, nbitsize
, nbitpos
, 1,
3930 rhs
= const_binop (BIT_AND_EXPR
,
3931 const_binop (LSHIFT_EXPR
,
3932 fold_convert_loc (loc
, unsigned_type
, rhs
),
3933 size_int (lbitpos
)),
3936 lhs
= build2_loc (loc
, code
, compare_type
,
3937 build2 (BIT_AND_EXPR
, unsigned_type
, lhs
, mask
), rhs
);
3941 /* Subroutine for fold_truth_andor_1: decode a field reference.
3943 If EXP is a comparison reference, we return the innermost reference.
3945 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3946 set to the starting bit number.
3948 If the innermost field can be completely contained in a mode-sized
3949 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
3951 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3952 otherwise it is not changed.
3954 *PUNSIGNEDP is set to the signedness of the field.
3956 *PREVERSEP is set to the storage order of the field.
3958 *PMASK is set to the mask used. This is either contained in a
3959 BIT_AND_EXPR or derived from the width of the field.
3961 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3963 Return 0 if this is not a component reference or is one that we can't
3964 do anything with. */
3967 decode_field_reference (location_t loc
, tree exp
, HOST_WIDE_INT
*pbitsize
,
3968 HOST_WIDE_INT
*pbitpos
, machine_mode
*pmode
,
3969 int *punsignedp
, int *preversep
, int *pvolatilep
,
3970 tree
*pmask
, tree
*pand_mask
)
3972 tree outer_type
= 0;
3974 tree mask
, inner
, offset
;
3976 unsigned int precision
;
3978 /* All the optimizations using this function assume integer fields.
3979 There are problems with FP fields since the type_for_size call
3980 below can fail for, e.g., XFmode. */
3981 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp
)))
3984 /* We are interested in the bare arrangement of bits, so strip everything
3985 that doesn't affect the machine mode. However, record the type of the
3986 outermost expression if it may matter below. */
3987 if (CONVERT_EXPR_P (exp
)
3988 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
3989 outer_type
= TREE_TYPE (exp
);
3992 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
3994 and_mask
= TREE_OPERAND (exp
, 1);
3995 exp
= TREE_OPERAND (exp
, 0);
3996 STRIP_NOPS (exp
); STRIP_NOPS (and_mask
);
3997 if (TREE_CODE (and_mask
) != INTEGER_CST
)
4001 inner
= get_inner_reference (exp
, pbitsize
, pbitpos
, &offset
, pmode
,
4002 punsignedp
, preversep
, pvolatilep
, false);
4003 if ((inner
== exp
&& and_mask
== 0)
4004 || *pbitsize
< 0 || offset
!= 0
4005 || TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
4008 /* If the number of bits in the reference is the same as the bitsize of
4009 the outer type, then the outer type gives the signedness. Otherwise
4010 (in case of a small bitfield) the signedness is unchanged. */
4011 if (outer_type
&& *pbitsize
== TYPE_PRECISION (outer_type
))
4012 *punsignedp
= TYPE_UNSIGNED (outer_type
);
4014 /* Compute the mask to access the bitfield. */
4015 unsigned_type
= lang_hooks
.types
.type_for_size (*pbitsize
, 1);
4016 precision
= TYPE_PRECISION (unsigned_type
);
4018 mask
= build_int_cst_type (unsigned_type
, -1);
4020 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4021 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4023 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4025 mask
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
4026 fold_convert_loc (loc
, unsigned_type
, and_mask
), mask
);
4029 *pand_mask
= and_mask
;
4033 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4034 bit positions and MASK is SIGNED. */
4037 all_ones_mask_p (const_tree mask
, unsigned int size
)
4039 tree type
= TREE_TYPE (mask
);
4040 unsigned int precision
= TYPE_PRECISION (type
);
4042 /* If this function returns true when the type of the mask is
4043 UNSIGNED, then there will be errors. In particular see
4044 gcc.c-torture/execute/990326-1.c. There does not appear to be
4045 any documentation paper trail as to why this is so. But the pre
4046 wide-int worked with that restriction and it has been preserved
4048 if (size
> precision
|| TYPE_SIGN (type
) == UNSIGNED
)
4051 return wi::mask (size
, false, precision
) == mask
;
4054 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4055 represents the sign bit of EXP's type. If EXP represents a sign
4056 or zero extension, also test VAL against the unextended type.
4057 The return value is the (sub)expression whose sign bit is VAL,
4058 or NULL_TREE otherwise. */
4061 sign_bit_p (tree exp
, const_tree val
)
4066 /* Tree EXP must have an integral type. */
4067 t
= TREE_TYPE (exp
);
4068 if (! INTEGRAL_TYPE_P (t
))
4071 /* Tree VAL must be an integer constant. */
4072 if (TREE_CODE (val
) != INTEGER_CST
4073 || TREE_OVERFLOW (val
))
4076 width
= TYPE_PRECISION (t
);
4077 if (wi::only_sign_bit_p (val
, width
))
4080 /* Handle extension from a narrower type. */
4081 if (TREE_CODE (exp
) == NOP_EXPR
4082 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))) < width
)
4083 return sign_bit_p (TREE_OPERAND (exp
, 0), val
);
4088 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4089 to be evaluated unconditionally. */
4092 simple_operand_p (const_tree exp
)
4094 /* Strip any conversions that don't change the machine mode. */
4097 return (CONSTANT_CLASS_P (exp
)
4098 || TREE_CODE (exp
) == SSA_NAME
4100 && ! TREE_ADDRESSABLE (exp
)
4101 && ! TREE_THIS_VOLATILE (exp
)
4102 && ! DECL_NONLOCAL (exp
)
4103 /* Don't regard global variables as simple. They may be
4104 allocated in ways unknown to the compiler (shared memory,
4105 #pragma weak, etc). */
4106 && ! TREE_PUBLIC (exp
)
4107 && ! DECL_EXTERNAL (exp
)
4108 /* Weakrefs are not safe to be read, since they can be NULL.
4109 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4110 have DECL_WEAK flag set. */
4111 && (! VAR_OR_FUNCTION_DECL_P (exp
) || ! DECL_WEAK (exp
))
4112 /* Loading a static variable is unduly expensive, but global
4113 registers aren't expensive. */
4114 && (! TREE_STATIC (exp
) || DECL_REGISTER (exp
))));
4117 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4118 to be evaluated unconditionally.
4119 I addition to simple_operand_p, we assume that comparisons, conversions,
4120 and logic-not operations are simple, if their operands are simple, too. */
4123 simple_operand_p_2 (tree exp
)
4125 enum tree_code code
;
4127 if (TREE_SIDE_EFFECTS (exp
)
4128 || tree_could_trap_p (exp
))
4131 while (CONVERT_EXPR_P (exp
))
4132 exp
= TREE_OPERAND (exp
, 0);
4134 code
= TREE_CODE (exp
);
4136 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
4137 return (simple_operand_p (TREE_OPERAND (exp
, 0))
4138 && simple_operand_p (TREE_OPERAND (exp
, 1)));
4140 if (code
== TRUTH_NOT_EXPR
)
4141 return simple_operand_p_2 (TREE_OPERAND (exp
, 0));
4143 return simple_operand_p (exp
);
4147 /* The following functions are subroutines to fold_range_test and allow it to
4148 try to change a logical combination of comparisons into a range test.
4151 X == 2 || X == 3 || X == 4 || X == 5
4155 (unsigned) (X - 2) <= 3
4157 We describe each set of comparisons as being either inside or outside
4158 a range, using a variable named like IN_P, and then describe the
4159 range with a lower and upper bound. If one of the bounds is omitted,
4160 it represents either the highest or lowest value of the type.
4162 In the comments below, we represent a range by two numbers in brackets
4163 preceded by a "+" to designate being inside that range, or a "-" to
4164 designate being outside that range, so the condition can be inverted by
4165 flipping the prefix. An omitted bound is represented by a "-". For
4166 example, "- [-, 10]" means being outside the range starting at the lowest
4167 possible value and ending at 10, in other words, being greater than 10.
4168 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4171 We set up things so that the missing bounds are handled in a consistent
4172 manner so neither a missing bound nor "true" and "false" need to be
4173 handled using a special case. */
4175 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4176 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4177 and UPPER1_P are nonzero if the respective argument is an upper bound
4178 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4179 must be specified for a comparison. ARG1 will be converted to ARG0's
4180 type if both are specified. */
4183 range_binop (enum tree_code code
, tree type
, tree arg0
, int upper0_p
,
4184 tree arg1
, int upper1_p
)
4190 /* If neither arg represents infinity, do the normal operation.
4191 Else, if not a comparison, return infinity. Else handle the special
4192 comparison rules. Note that most of the cases below won't occur, but
4193 are handled for consistency. */
4195 if (arg0
!= 0 && arg1
!= 0)
4197 tem
= fold_build2 (code
, type
!= 0 ? type
: TREE_TYPE (arg0
),
4198 arg0
, fold_convert (TREE_TYPE (arg0
), arg1
));
4200 return TREE_CODE (tem
) == INTEGER_CST
? tem
: 0;
4203 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
4206 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4207 for neither. In real maths, we cannot assume open ended ranges are
4208 the same. But, this is computer arithmetic, where numbers are finite.
4209 We can therefore make the transformation of any unbounded range with
4210 the value Z, Z being greater than any representable number. This permits
4211 us to treat unbounded ranges as equal. */
4212 sgn0
= arg0
!= 0 ? 0 : (upper0_p
? 1 : -1);
4213 sgn1
= arg1
!= 0 ? 0 : (upper1_p
? 1 : -1);
4217 result
= sgn0
== sgn1
;
4220 result
= sgn0
!= sgn1
;
4223 result
= sgn0
< sgn1
;
4226 result
= sgn0
<= sgn1
;
4229 result
= sgn0
> sgn1
;
4232 result
= sgn0
>= sgn1
;
4238 return constant_boolean_node (result
, type
);
4241 /* Helper routine for make_range. Perform one step for it, return
4242 new expression if the loop should continue or NULL_TREE if it should
4246 make_range_step (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
,
4247 tree exp_type
, tree
*p_low
, tree
*p_high
, int *p_in_p
,
4248 bool *strict_overflow_p
)
4250 tree arg0_type
= TREE_TYPE (arg0
);
4251 tree n_low
, n_high
, low
= *p_low
, high
= *p_high
;
4252 int in_p
= *p_in_p
, n_in_p
;
4256 case TRUTH_NOT_EXPR
:
4257 /* We can only do something if the range is testing for zero. */
4258 if (low
== NULL_TREE
|| high
== NULL_TREE
4259 || ! integer_zerop (low
) || ! integer_zerop (high
))
4264 case EQ_EXPR
: case NE_EXPR
:
4265 case LT_EXPR
: case LE_EXPR
: case GE_EXPR
: case GT_EXPR
:
4266 /* We can only do something if the range is testing for zero
4267 and if the second operand is an integer constant. Note that
4268 saying something is "in" the range we make is done by
4269 complementing IN_P since it will set in the initial case of
4270 being not equal to zero; "out" is leaving it alone. */
4271 if (low
== NULL_TREE
|| high
== NULL_TREE
4272 || ! integer_zerop (low
) || ! integer_zerop (high
)
4273 || TREE_CODE (arg1
) != INTEGER_CST
)
4278 case NE_EXPR
: /* - [c, c] */
4281 case EQ_EXPR
: /* + [c, c] */
4282 in_p
= ! in_p
, low
= high
= arg1
;
4284 case GT_EXPR
: /* - [-, c] */
4285 low
= 0, high
= arg1
;
4287 case GE_EXPR
: /* + [c, -] */
4288 in_p
= ! in_p
, low
= arg1
, high
= 0;
4290 case LT_EXPR
: /* - [c, -] */
4291 low
= arg1
, high
= 0;
4293 case LE_EXPR
: /* + [-, c] */
4294 in_p
= ! in_p
, low
= 0, high
= arg1
;
4300 /* If this is an unsigned comparison, we also know that EXP is
4301 greater than or equal to zero. We base the range tests we make
4302 on that fact, so we record it here so we can parse existing
4303 range tests. We test arg0_type since often the return type
4304 of, e.g. EQ_EXPR, is boolean. */
4305 if (TYPE_UNSIGNED (arg0_type
) && (low
== 0 || high
== 0))
4307 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
4309 build_int_cst (arg0_type
, 0),
4313 in_p
= n_in_p
, low
= n_low
, high
= n_high
;
4315 /* If the high bound is missing, but we have a nonzero low
4316 bound, reverse the range so it goes from zero to the low bound
4318 if (high
== 0 && low
&& ! integer_zerop (low
))
4321 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low
, 0,
4322 build_int_cst (TREE_TYPE (low
), 1), 0);
4323 low
= build_int_cst (arg0_type
, 0);
4333 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4334 low and high are non-NULL, then normalize will DTRT. */
4335 if (!TYPE_UNSIGNED (arg0_type
)
4336 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4338 if (low
== NULL_TREE
)
4339 low
= TYPE_MIN_VALUE (arg0_type
);
4340 if (high
== NULL_TREE
)
4341 high
= TYPE_MAX_VALUE (arg0_type
);
4344 /* (-x) IN [a,b] -> x in [-b, -a] */
4345 n_low
= range_binop (MINUS_EXPR
, exp_type
,
4346 build_int_cst (exp_type
, 0),
4348 n_high
= range_binop (MINUS_EXPR
, exp_type
,
4349 build_int_cst (exp_type
, 0),
4351 if (n_high
!= 0 && TREE_OVERFLOW (n_high
))
4357 return build2_loc (loc
, MINUS_EXPR
, exp_type
, negate_expr (arg0
),
4358 build_int_cst (exp_type
, 1));
4362 if (TREE_CODE (arg1
) != INTEGER_CST
)
4365 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4366 move a constant to the other side. */
4367 if (!TYPE_UNSIGNED (arg0_type
)
4368 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4371 /* If EXP is signed, any overflow in the computation is undefined,
4372 so we don't worry about it so long as our computations on
4373 the bounds don't overflow. For unsigned, overflow is defined
4374 and this is exactly the right thing. */
4375 n_low
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4376 arg0_type
, low
, 0, arg1
, 0);
4377 n_high
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4378 arg0_type
, high
, 1, arg1
, 0);
4379 if ((n_low
!= 0 && TREE_OVERFLOW (n_low
))
4380 || (n_high
!= 0 && TREE_OVERFLOW (n_high
)))
4383 if (TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4384 *strict_overflow_p
= true;
4387 /* Check for an unsigned range which has wrapped around the maximum
4388 value thus making n_high < n_low, and normalize it. */
4389 if (n_low
&& n_high
&& tree_int_cst_lt (n_high
, n_low
))
4391 low
= range_binop (PLUS_EXPR
, arg0_type
, n_high
, 0,
4392 build_int_cst (TREE_TYPE (n_high
), 1), 0);
4393 high
= range_binop (MINUS_EXPR
, arg0_type
, n_low
, 0,
4394 build_int_cst (TREE_TYPE (n_low
), 1), 0);
4396 /* If the range is of the form +/- [ x+1, x ], we won't
4397 be able to normalize it. But then, it represents the
4398 whole range or the empty set, so make it
4400 if (tree_int_cst_equal (n_low
, low
)
4401 && tree_int_cst_equal (n_high
, high
))
4407 low
= n_low
, high
= n_high
;
4415 case NON_LVALUE_EXPR
:
4416 if (TYPE_PRECISION (arg0_type
) > TYPE_PRECISION (exp_type
))
4419 if (! INTEGRAL_TYPE_P (arg0_type
)
4420 || (low
!= 0 && ! int_fits_type_p (low
, arg0_type
))
4421 || (high
!= 0 && ! int_fits_type_p (high
, arg0_type
)))
4424 n_low
= low
, n_high
= high
;
4427 n_low
= fold_convert_loc (loc
, arg0_type
, n_low
);
4430 n_high
= fold_convert_loc (loc
, arg0_type
, n_high
);
4432 /* If we're converting arg0 from an unsigned type, to exp,
4433 a signed type, we will be doing the comparison as unsigned.
4434 The tests above have already verified that LOW and HIGH
4437 So we have to ensure that we will handle large unsigned
4438 values the same way that the current signed bounds treat
4441 if (!TYPE_UNSIGNED (exp_type
) && TYPE_UNSIGNED (arg0_type
))
4445 /* For fixed-point modes, we need to pass the saturating flag
4446 as the 2nd parameter. */
4447 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type
)))
4449 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
),
4450 TYPE_SATURATING (arg0_type
));
4453 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
), 1);
4455 /* A range without an upper bound is, naturally, unbounded.
4456 Since convert would have cropped a very large value, use
4457 the max value for the destination type. */
4459 = TYPE_MAX_VALUE (equiv_type
) ? TYPE_MAX_VALUE (equiv_type
)
4460 : TYPE_MAX_VALUE (arg0_type
);
4462 if (TYPE_PRECISION (exp_type
) == TYPE_PRECISION (arg0_type
))
4463 high_positive
= fold_build2_loc (loc
, RSHIFT_EXPR
, arg0_type
,
4464 fold_convert_loc (loc
, arg0_type
,
4466 build_int_cst (arg0_type
, 1));
4468 /* If the low bound is specified, "and" the range with the
4469 range for which the original unsigned value will be
4473 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 1, n_low
, n_high
,
4474 1, fold_convert_loc (loc
, arg0_type
,
4479 in_p
= (n_in_p
== in_p
);
4483 /* Otherwise, "or" the range with the range of the input
4484 that will be interpreted as negative. */
4485 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 0, n_low
, n_high
,
4486 1, fold_convert_loc (loc
, arg0_type
,
4491 in_p
= (in_p
!= n_in_p
);
4505 /* Given EXP, a logical expression, set the range it is testing into
4506 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4507 actually being tested. *PLOW and *PHIGH will be made of the same
4508 type as the returned expression. If EXP is not a comparison, we
4509 will most likely not be returning a useful value and range. Set
4510 *STRICT_OVERFLOW_P to true if the return value is only valid
4511 because signed overflow is undefined; otherwise, do not change
4512 *STRICT_OVERFLOW_P. */
4515 make_range (tree exp
, int *pin_p
, tree
*plow
, tree
*phigh
,
4516 bool *strict_overflow_p
)
4518 enum tree_code code
;
4519 tree arg0
, arg1
= NULL_TREE
;
4520 tree exp_type
, nexp
;
4523 location_t loc
= EXPR_LOCATION (exp
);
4525 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4526 and see if we can refine the range. Some of the cases below may not
4527 happen, but it doesn't seem worth worrying about this. We "continue"
4528 the outer loop when we've changed something; otherwise we "break"
4529 the switch, which will "break" the while. */
4532 low
= high
= build_int_cst (TREE_TYPE (exp
), 0);
4536 code
= TREE_CODE (exp
);
4537 exp_type
= TREE_TYPE (exp
);
4540 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
4542 if (TREE_OPERAND_LENGTH (exp
) > 0)
4543 arg0
= TREE_OPERAND (exp
, 0);
4544 if (TREE_CODE_CLASS (code
) == tcc_binary
4545 || TREE_CODE_CLASS (code
) == tcc_comparison
4546 || (TREE_CODE_CLASS (code
) == tcc_expression
4547 && TREE_OPERAND_LENGTH (exp
) > 1))
4548 arg1
= TREE_OPERAND (exp
, 1);
4550 if (arg0
== NULL_TREE
)
4553 nexp
= make_range_step (loc
, code
, arg0
, arg1
, exp_type
, &low
,
4554 &high
, &in_p
, strict_overflow_p
);
4555 if (nexp
== NULL_TREE
)
4560 /* If EXP is a constant, we can evaluate whether this is true or false. */
4561 if (TREE_CODE (exp
) == INTEGER_CST
)
4563 in_p
= in_p
== (integer_onep (range_binop (GE_EXPR
, integer_type_node
,
4565 && integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4571 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4575 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4576 type, TYPE, return an expression to test if EXP is in (or out of, depending
4577 on IN_P) the range. Return 0 if the test couldn't be created. */
4580 build_range_check (location_t loc
, tree type
, tree exp
, int in_p
,
4581 tree low
, tree high
)
4583 tree etype
= TREE_TYPE (exp
), value
;
4585 /* Disable this optimization for function pointer expressions
4586 on targets that require function pointer canonicalization. */
4587 if (targetm
.have_canonicalize_funcptr_for_compare ()
4588 && TREE_CODE (etype
) == POINTER_TYPE
4589 && TREE_CODE (TREE_TYPE (etype
)) == FUNCTION_TYPE
)
4594 value
= build_range_check (loc
, type
, exp
, 1, low
, high
);
4596 return invert_truthvalue_loc (loc
, value
);
4601 if (low
== 0 && high
== 0)
4602 return omit_one_operand_loc (loc
, type
, build_int_cst (type
, 1), exp
);
4605 return fold_build2_loc (loc
, LE_EXPR
, type
, exp
,
4606 fold_convert_loc (loc
, etype
, high
));
4609 return fold_build2_loc (loc
, GE_EXPR
, type
, exp
,
4610 fold_convert_loc (loc
, etype
, low
));
4612 if (operand_equal_p (low
, high
, 0))
4613 return fold_build2_loc (loc
, EQ_EXPR
, type
, exp
,
4614 fold_convert_loc (loc
, etype
, low
));
4616 if (integer_zerop (low
))
4618 if (! TYPE_UNSIGNED (etype
))
4620 etype
= unsigned_type_for (etype
);
4621 high
= fold_convert_loc (loc
, etype
, high
);
4622 exp
= fold_convert_loc (loc
, etype
, exp
);
4624 return build_range_check (loc
, type
, exp
, 1, 0, high
);
4627 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4628 if (integer_onep (low
) && TREE_CODE (high
) == INTEGER_CST
)
4630 int prec
= TYPE_PRECISION (etype
);
4632 if (wi::mask (prec
- 1, false, prec
) == high
)
4634 if (TYPE_UNSIGNED (etype
))
4636 tree signed_etype
= signed_type_for (etype
);
4637 if (TYPE_PRECISION (signed_etype
) != TYPE_PRECISION (etype
))
4639 = build_nonstandard_integer_type (TYPE_PRECISION (etype
), 0);
4641 etype
= signed_etype
;
4642 exp
= fold_convert_loc (loc
, etype
, exp
);
4644 return fold_build2_loc (loc
, GT_EXPR
, type
, exp
,
4645 build_int_cst (etype
, 0));
4649 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4650 This requires wrap-around arithmetics for the type of the expression.
4651 First make sure that arithmetics in this type is valid, then make sure
4652 that it wraps around. */
4653 if (TREE_CODE (etype
) == ENUMERAL_TYPE
|| TREE_CODE (etype
) == BOOLEAN_TYPE
)
4654 etype
= lang_hooks
.types
.type_for_size (TYPE_PRECISION (etype
),
4655 TYPE_UNSIGNED (etype
));
4657 if (TREE_CODE (etype
) == INTEGER_TYPE
&& !TYPE_OVERFLOW_WRAPS (etype
))
4659 tree utype
, minv
, maxv
;
4661 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4662 for the type in question, as we rely on this here. */
4663 utype
= unsigned_type_for (etype
);
4664 maxv
= fold_convert_loc (loc
, utype
, TYPE_MAX_VALUE (etype
));
4665 maxv
= range_binop (PLUS_EXPR
, NULL_TREE
, maxv
, 1,
4666 build_int_cst (TREE_TYPE (maxv
), 1), 1);
4667 minv
= fold_convert_loc (loc
, utype
, TYPE_MIN_VALUE (etype
));
4669 if (integer_zerop (range_binop (NE_EXPR
, integer_type_node
,
4676 high
= fold_convert_loc (loc
, etype
, high
);
4677 low
= fold_convert_loc (loc
, etype
, low
);
4678 exp
= fold_convert_loc (loc
, etype
, exp
);
4680 value
= const_binop (MINUS_EXPR
, high
, low
);
4683 if (POINTER_TYPE_P (etype
))
4685 if (value
!= 0 && !TREE_OVERFLOW (value
))
4687 low
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (low
), low
);
4688 return build_range_check (loc
, type
,
4689 fold_build_pointer_plus_loc (loc
, exp
, low
),
4690 1, build_int_cst (etype
, 0), value
);
4695 if (value
!= 0 && !TREE_OVERFLOW (value
))
4696 return build_range_check (loc
, type
,
4697 fold_build2_loc (loc
, MINUS_EXPR
, etype
, exp
, low
),
4698 1, build_int_cst (etype
, 0), value
);
4703 /* Return the predecessor of VAL in its type, handling the infinite case. */
4706 range_predecessor (tree val
)
4708 tree type
= TREE_TYPE (val
);
4710 if (INTEGRAL_TYPE_P (type
)
4711 && operand_equal_p (val
, TYPE_MIN_VALUE (type
), 0))
4714 return range_binop (MINUS_EXPR
, NULL_TREE
, val
, 0,
4715 build_int_cst (TREE_TYPE (val
), 1), 0);
4718 /* Return the successor of VAL in its type, handling the infinite case. */
4721 range_successor (tree val
)
4723 tree type
= TREE_TYPE (val
);
4725 if (INTEGRAL_TYPE_P (type
)
4726 && operand_equal_p (val
, TYPE_MAX_VALUE (type
), 0))
4729 return range_binop (PLUS_EXPR
, NULL_TREE
, val
, 0,
4730 build_int_cst (TREE_TYPE (val
), 1), 0);
4733 /* Given two ranges, see if we can merge them into one. Return 1 if we
4734 can, 0 if we can't. Set the output range into the specified parameters. */
4737 merge_ranges (int *pin_p
, tree
*plow
, tree
*phigh
, int in0_p
, tree low0
,
4738 tree high0
, int in1_p
, tree low1
, tree high1
)
4746 int lowequal
= ((low0
== 0 && low1
== 0)
4747 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4748 low0
, 0, low1
, 0)));
4749 int highequal
= ((high0
== 0 && high1
== 0)
4750 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4751 high0
, 1, high1
, 1)));
4753 /* Make range 0 be the range that starts first, or ends last if they
4754 start at the same value. Swap them if it isn't. */
4755 if (integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4758 && integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4759 high1
, 1, high0
, 1))))
4761 temp
= in0_p
, in0_p
= in1_p
, in1_p
= temp
;
4762 tem
= low0
, low0
= low1
, low1
= tem
;
4763 tem
= high0
, high0
= high1
, high1
= tem
;
4766 /* Now flag two cases, whether the ranges are disjoint or whether the
4767 second range is totally subsumed in the first. Note that the tests
4768 below are simplified by the ones above. */
4769 no_overlap
= integer_onep (range_binop (LT_EXPR
, integer_type_node
,
4770 high0
, 1, low1
, 0));
4771 subset
= integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4772 high1
, 1, high0
, 1));
4774 /* We now have four cases, depending on whether we are including or
4775 excluding the two ranges. */
4778 /* If they don't overlap, the result is false. If the second range
4779 is a subset it is the result. Otherwise, the range is from the start
4780 of the second to the end of the first. */
4782 in_p
= 0, low
= high
= 0;
4784 in_p
= 1, low
= low1
, high
= high1
;
4786 in_p
= 1, low
= low1
, high
= high0
;
4789 else if (in0_p
&& ! in1_p
)
4791 /* If they don't overlap, the result is the first range. If they are
4792 equal, the result is false. If the second range is a subset of the
4793 first, and the ranges begin at the same place, we go from just after
4794 the end of the second range to the end of the first. If the second
4795 range is not a subset of the first, or if it is a subset and both
4796 ranges end at the same place, the range starts at the start of the
4797 first range and ends just before the second range.
4798 Otherwise, we can't describe this as a single range. */
4800 in_p
= 1, low
= low0
, high
= high0
;
4801 else if (lowequal
&& highequal
)
4802 in_p
= 0, low
= high
= 0;
4803 else if (subset
&& lowequal
)
4805 low
= range_successor (high1
);
4810 /* We are in the weird situation where high0 > high1 but
4811 high1 has no successor. Punt. */
4815 else if (! subset
|| highequal
)
4818 high
= range_predecessor (low1
);
4822 /* low0 < low1 but low1 has no predecessor. Punt. */
4830 else if (! in0_p
&& in1_p
)
4832 /* If they don't overlap, the result is the second range. If the second
4833 is a subset of the first, the result is false. Otherwise,
4834 the range starts just after the first range and ends at the
4835 end of the second. */
4837 in_p
= 1, low
= low1
, high
= high1
;
4838 else if (subset
|| highequal
)
4839 in_p
= 0, low
= high
= 0;
4842 low
= range_successor (high0
);
4847 /* high1 > high0 but high0 has no successor. Punt. */
4855 /* The case where we are excluding both ranges. Here the complex case
4856 is if they don't overlap. In that case, the only time we have a
4857 range is if they are adjacent. If the second is a subset of the
4858 first, the result is the first. Otherwise, the range to exclude
4859 starts at the beginning of the first range and ends at the end of the
4863 if (integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4864 range_successor (high0
),
4866 in_p
= 0, low
= low0
, high
= high1
;
4869 /* Canonicalize - [min, x] into - [-, x]. */
4870 if (low0
&& TREE_CODE (low0
) == INTEGER_CST
)
4871 switch (TREE_CODE (TREE_TYPE (low0
)))
4874 if (TYPE_PRECISION (TREE_TYPE (low0
))
4875 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0
))))
4879 if (tree_int_cst_equal (low0
,
4880 TYPE_MIN_VALUE (TREE_TYPE (low0
))))
4884 if (TYPE_UNSIGNED (TREE_TYPE (low0
))
4885 && integer_zerop (low0
))
4892 /* Canonicalize - [x, max] into - [x, -]. */
4893 if (high1
&& TREE_CODE (high1
) == INTEGER_CST
)
4894 switch (TREE_CODE (TREE_TYPE (high1
)))
4897 if (TYPE_PRECISION (TREE_TYPE (high1
))
4898 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1
))))
4902 if (tree_int_cst_equal (high1
,
4903 TYPE_MAX_VALUE (TREE_TYPE (high1
))))
4907 if (TYPE_UNSIGNED (TREE_TYPE (high1
))
4908 && integer_zerop (range_binop (PLUS_EXPR
, NULL_TREE
,
4910 build_int_cst (TREE_TYPE (high1
), 1),
4918 /* The ranges might be also adjacent between the maximum and
4919 minimum values of the given type. For
4920 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4921 return + [x + 1, y - 1]. */
4922 if (low0
== 0 && high1
== 0)
4924 low
= range_successor (high0
);
4925 high
= range_predecessor (low1
);
4926 if (low
== 0 || high
== 0)
4936 in_p
= 0, low
= low0
, high
= high0
;
4938 in_p
= 0, low
= low0
, high
= high1
;
4941 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4946 /* Subroutine of fold, looking inside expressions of the form
4947 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4948 of the COND_EXPR. This function is being used also to optimize
4949 A op B ? C : A, by reversing the comparison first.
4951 Return a folded expression whose code is not a COND_EXPR
4952 anymore, or NULL_TREE if no folding opportunity is found. */
4955 fold_cond_expr_with_comparison (location_t loc
, tree type
,
4956 tree arg0
, tree arg1
, tree arg2
)
4958 enum tree_code comp_code
= TREE_CODE (arg0
);
4959 tree arg00
= TREE_OPERAND (arg0
, 0);
4960 tree arg01
= TREE_OPERAND (arg0
, 1);
4961 tree arg1_type
= TREE_TYPE (arg1
);
4967 /* If we have A op 0 ? A : -A, consider applying the following
4970 A == 0? A : -A same as -A
4971 A != 0? A : -A same as A
4972 A >= 0? A : -A same as abs (A)
4973 A > 0? A : -A same as abs (A)
4974 A <= 0? A : -A same as -abs (A)
4975 A < 0? A : -A same as -abs (A)
4977 None of these transformations work for modes with signed
4978 zeros. If A is +/-0, the first two transformations will
4979 change the sign of the result (from +0 to -0, or vice
4980 versa). The last four will fix the sign of the result,
4981 even though the original expressions could be positive or
4982 negative, depending on the sign of A.
4984 Note that all these transformations are correct if A is
4985 NaN, since the two alternatives (A and -A) are also NaNs. */
4986 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
4987 && (FLOAT_TYPE_P (TREE_TYPE (arg01
))
4988 ? real_zerop (arg01
)
4989 : integer_zerop (arg01
))
4990 && ((TREE_CODE (arg2
) == NEGATE_EXPR
4991 && operand_equal_p (TREE_OPERAND (arg2
, 0), arg1
, 0))
4992 /* In the case that A is of the form X-Y, '-A' (arg2) may
4993 have already been folded to Y-X, check for that. */
4994 || (TREE_CODE (arg1
) == MINUS_EXPR
4995 && TREE_CODE (arg2
) == MINUS_EXPR
4996 && operand_equal_p (TREE_OPERAND (arg1
, 0),
4997 TREE_OPERAND (arg2
, 1), 0)
4998 && operand_equal_p (TREE_OPERAND (arg1
, 1),
4999 TREE_OPERAND (arg2
, 0), 0))))
5004 tem
= fold_convert_loc (loc
, arg1_type
, arg1
);
5005 return pedantic_non_lvalue_loc (loc
,
5006 fold_convert_loc (loc
, type
,
5007 negate_expr (tem
)));
5010 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
5013 if (flag_trapping_math
)
5018 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5020 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5021 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
5024 if (flag_trapping_math
)
5028 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5030 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5031 return negate_expr (fold_convert_loc (loc
, type
, tem
));
5033 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5037 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5038 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5039 both transformations are correct when A is NaN: A != 0
5040 is then true, and A == 0 is false. */
5042 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5043 && integer_zerop (arg01
) && integer_zerop (arg2
))
5045 if (comp_code
== NE_EXPR
)
5046 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
5047 else if (comp_code
== EQ_EXPR
)
5048 return build_zero_cst (type
);
5051 /* Try some transformations of A op B ? A : B.
5053 A == B? A : B same as B
5054 A != B? A : B same as A
5055 A >= B? A : B same as max (A, B)
5056 A > B? A : B same as max (B, A)
5057 A <= B? A : B same as min (A, B)
5058 A < B? A : B same as min (B, A)
5060 As above, these transformations don't work in the presence
5061 of signed zeros. For example, if A and B are zeros of
5062 opposite sign, the first two transformations will change
5063 the sign of the result. In the last four, the original
5064 expressions give different results for (A=+0, B=-0) and
5065 (A=-0, B=+0), but the transformed expressions do not.
5067 The first two transformations are correct if either A or B
5068 is a NaN. In the first transformation, the condition will
5069 be false, and B will indeed be chosen. In the case of the
5070 second transformation, the condition A != B will be true,
5071 and A will be chosen.
5073 The conversions to max() and min() are not correct if B is
5074 a number and A is not. The conditions in the original
5075 expressions will be false, so all four give B. The min()
5076 and max() versions would give a NaN instead. */
5077 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5078 && operand_equal_for_comparison_p (arg01
, arg2
, arg00
)
5079 /* Avoid these transformations if the COND_EXPR may be used
5080 as an lvalue in the C++ front-end. PR c++/19199. */
5082 || VECTOR_TYPE_P (type
)
5083 || (! lang_GNU_CXX ()
5084 && strcmp (lang_hooks
.name
, "GNU Objective-C++") != 0)
5085 || ! maybe_lvalue_p (arg1
)
5086 || ! maybe_lvalue_p (arg2
)))
5088 tree comp_op0
= arg00
;
5089 tree comp_op1
= arg01
;
5090 tree comp_type
= TREE_TYPE (comp_op0
);
5092 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
5093 if (TYPE_MAIN_VARIANT (comp_type
) == TYPE_MAIN_VARIANT (type
))
5103 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg2
));
5105 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
5110 /* In C++ a ?: expression can be an lvalue, so put the
5111 operand which will be used if they are equal first
5112 so that we can convert this back to the
5113 corresponding COND_EXPR. */
5114 if (!HONOR_NANS (arg1
))
5116 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5117 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5118 tem
= (comp_code
== LE_EXPR
|| comp_code
== UNLE_EXPR
)
5119 ? fold_build2_loc (loc
, MIN_EXPR
, comp_type
, comp_op0
, comp_op1
)
5120 : fold_build2_loc (loc
, MIN_EXPR
, comp_type
,
5121 comp_op1
, comp_op0
);
5122 return pedantic_non_lvalue_loc (loc
,
5123 fold_convert_loc (loc
, type
, tem
));
5130 if (!HONOR_NANS (arg1
))
5132 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5133 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5134 tem
= (comp_code
== GE_EXPR
|| comp_code
== UNGE_EXPR
)
5135 ? fold_build2_loc (loc
, MAX_EXPR
, comp_type
, comp_op0
, comp_op1
)
5136 : fold_build2_loc (loc
, MAX_EXPR
, comp_type
,
5137 comp_op1
, comp_op0
);
5138 return pedantic_non_lvalue_loc (loc
,
5139 fold_convert_loc (loc
, type
, tem
));
5143 if (!HONOR_NANS (arg1
))
5144 return pedantic_non_lvalue_loc (loc
,
5145 fold_convert_loc (loc
, type
, arg2
));
5148 if (!HONOR_NANS (arg1
))
5149 return pedantic_non_lvalue_loc (loc
,
5150 fold_convert_loc (loc
, type
, arg1
));
5153 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5158 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5159 we might still be able to simplify this. For example,
5160 if C1 is one less or one more than C2, this might have started
5161 out as a MIN or MAX and been transformed by this function.
5162 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
5164 if (INTEGRAL_TYPE_P (type
)
5165 && TREE_CODE (arg01
) == INTEGER_CST
5166 && TREE_CODE (arg2
) == INTEGER_CST
)
5170 if (TREE_CODE (arg1
) == INTEGER_CST
)
5172 /* We can replace A with C1 in this case. */
5173 arg1
= fold_convert_loc (loc
, type
, arg01
);
5174 return fold_build3_loc (loc
, COND_EXPR
, type
, arg0
, arg1
, arg2
);
5177 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
5178 MIN_EXPR, to preserve the signedness of the comparison. */
5179 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
),
5181 && operand_equal_p (arg01
,
5182 const_binop (PLUS_EXPR
, arg2
,
5183 build_int_cst (type
, 1)),
5186 tem
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (arg00
), arg00
,
5187 fold_convert_loc (loc
, TREE_TYPE (arg00
),
5189 return pedantic_non_lvalue_loc (loc
,
5190 fold_convert_loc (loc
, type
, tem
));
5195 /* If C1 is C2 - 1, this is min(A, C2), with the same care
5197 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
),
5199 && operand_equal_p (arg01
,
5200 const_binop (MINUS_EXPR
, arg2
,
5201 build_int_cst (type
, 1)),
5204 tem
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (arg00
), arg00
,
5205 fold_convert_loc (loc
, TREE_TYPE (arg00
),
5207 return pedantic_non_lvalue_loc (loc
,
5208 fold_convert_loc (loc
, type
, tem
));
5213 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
5214 MAX_EXPR, to preserve the signedness of the comparison. */
5215 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
),
5217 && operand_equal_p (arg01
,
5218 const_binop (MINUS_EXPR
, arg2
,
5219 build_int_cst (type
, 1)),
5222 tem
= fold_build2_loc (loc
, MAX_EXPR
, TREE_TYPE (arg00
), arg00
,
5223 fold_convert_loc (loc
, TREE_TYPE (arg00
),
5225 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
5230 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
5231 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
),
5233 && operand_equal_p (arg01
,
5234 const_binop (PLUS_EXPR
, arg2
,
5235 build_int_cst (type
, 1)),
5238 tem
= fold_build2_loc (loc
, MAX_EXPR
, TREE_TYPE (arg00
), arg00
,
5239 fold_convert_loc (loc
, TREE_TYPE (arg00
),
5241 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
5255 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5256 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5257 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5261 /* EXP is some logical combination of boolean tests. See if we can
5262 merge it into some range test. Return the new tree if so. */
5265 fold_range_test (location_t loc
, enum tree_code code
, tree type
,
5268 int or_op
= (code
== TRUTH_ORIF_EXPR
5269 || code
== TRUTH_OR_EXPR
);
5270 int in0_p
, in1_p
, in_p
;
5271 tree low0
, low1
, low
, high0
, high1
, high
;
5272 bool strict_overflow_p
= false;
5274 const char * const warnmsg
= G_("assuming signed overflow does not occur "
5275 "when simplifying range test");
5277 if (!INTEGRAL_TYPE_P (type
))
5280 lhs
= make_range (op0
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
5281 rhs
= make_range (op1
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
5283 /* If this is an OR operation, invert both sides; we will invert
5284 again at the end. */
5286 in0_p
= ! in0_p
, in1_p
= ! in1_p
;
5288 /* If both expressions are the same, if we can merge the ranges, and we
5289 can build the range test, return it or it inverted. If one of the
5290 ranges is always true or always false, consider it to be the same
5291 expression as the other. */
5292 if ((lhs
== 0 || rhs
== 0 || operand_equal_p (lhs
, rhs
, 0))
5293 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
5295 && 0 != (tem
= (build_range_check (loc
, type
,
5297 : rhs
!= 0 ? rhs
: integer_zero_node
,
5300 if (strict_overflow_p
)
5301 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
5302 return or_op
? invert_truthvalue_loc (loc
, tem
) : tem
;
5305 /* On machines where the branch cost is expensive, if this is a
5306 short-circuited branch and the underlying object on both sides
5307 is the same, make a non-short-circuit operation. */
5308 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5309 && lhs
!= 0 && rhs
!= 0
5310 && (code
== TRUTH_ANDIF_EXPR
5311 || code
== TRUTH_ORIF_EXPR
)
5312 && operand_equal_p (lhs
, rhs
, 0))
5314 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5315 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5316 which cases we can't do this. */
5317 if (simple_operand_p (lhs
))
5318 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5319 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5322 else if (!lang_hooks
.decls
.global_bindings_p ()
5323 && !CONTAINS_PLACEHOLDER_P (lhs
))
5325 tree common
= save_expr (lhs
);
5327 if (0 != (lhs
= build_range_check (loc
, type
, common
,
5328 or_op
? ! in0_p
: in0_p
,
5330 && (0 != (rhs
= build_range_check (loc
, type
, common
,
5331 or_op
? ! in1_p
: in1_p
,
5334 if (strict_overflow_p
)
5335 fold_overflow_warning (warnmsg
,
5336 WARN_STRICT_OVERFLOW_COMPARISON
);
5337 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5338 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5347 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5348 bit value. Arrange things so the extra bits will be set to zero if and
5349 only if C is signed-extended to its full width. If MASK is nonzero,
5350 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5353 unextend (tree c
, int p
, int unsignedp
, tree mask
)
5355 tree type
= TREE_TYPE (c
);
5356 int modesize
= GET_MODE_BITSIZE (TYPE_MODE (type
));
5359 if (p
== modesize
|| unsignedp
)
5362 /* We work by getting just the sign bit into the low-order bit, then
5363 into the high-order bit, then sign-extend. We then XOR that value
5365 temp
= build_int_cst (TREE_TYPE (c
), wi::extract_uhwi (c
, p
- 1, 1));
5367 /* We must use a signed type in order to get an arithmetic right shift.
5368 However, we must also avoid introducing accidental overflows, so that
5369 a subsequent call to integer_zerop will work. Hence we must
5370 do the type conversion here. At this point, the constant is either
5371 zero or one, and the conversion to a signed type can never overflow.
5372 We could get an overflow if this conversion is done anywhere else. */
5373 if (TYPE_UNSIGNED (type
))
5374 temp
= fold_convert (signed_type_for (type
), temp
);
5376 temp
= const_binop (LSHIFT_EXPR
, temp
, size_int (modesize
- 1));
5377 temp
= const_binop (RSHIFT_EXPR
, temp
, size_int (modesize
- p
- 1));
5379 temp
= const_binop (BIT_AND_EXPR
, temp
,
5380 fold_convert (TREE_TYPE (c
), mask
));
5381 /* If necessary, convert the type back to match the type of C. */
5382 if (TYPE_UNSIGNED (type
))
5383 temp
= fold_convert (type
, temp
);
5385 return fold_convert (type
, const_binop (BIT_XOR_EXPR
, c
, temp
));
5388 /* For an expression that has the form
5392 we can drop one of the inner expressions and simplify to
5396 LOC is the location of the resulting expression. OP is the inner
5397 logical operation; the left-hand side in the examples above, while CMPOP
5398 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5399 removing a condition that guards another, as in
5400 (A != NULL && A->...) || A == NULL
5401 which we must not transform. If RHS_ONLY is true, only eliminate the
5402 right-most operand of the inner logical operation. */
5405 merge_truthop_with_opposite_arm (location_t loc
, tree op
, tree cmpop
,
5408 tree type
= TREE_TYPE (cmpop
);
5409 enum tree_code code
= TREE_CODE (cmpop
);
5410 enum tree_code truthop_code
= TREE_CODE (op
);
5411 tree lhs
= TREE_OPERAND (op
, 0);
5412 tree rhs
= TREE_OPERAND (op
, 1);
5413 tree orig_lhs
= lhs
, orig_rhs
= rhs
;
5414 enum tree_code rhs_code
= TREE_CODE (rhs
);
5415 enum tree_code lhs_code
= TREE_CODE (lhs
);
5416 enum tree_code inv_code
;
5418 if (TREE_SIDE_EFFECTS (op
) || TREE_SIDE_EFFECTS (cmpop
))
5421 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
5424 if (rhs_code
== truthop_code
)
5426 tree newrhs
= merge_truthop_with_opposite_arm (loc
, rhs
, cmpop
, rhs_only
);
5427 if (newrhs
!= NULL_TREE
)
5430 rhs_code
= TREE_CODE (rhs
);
5433 if (lhs_code
== truthop_code
&& !rhs_only
)
5435 tree newlhs
= merge_truthop_with_opposite_arm (loc
, lhs
, cmpop
, false);
5436 if (newlhs
!= NULL_TREE
)
5439 lhs_code
= TREE_CODE (lhs
);
5443 inv_code
= invert_tree_comparison (code
, HONOR_NANS (type
));
5444 if (inv_code
== rhs_code
5445 && operand_equal_p (TREE_OPERAND (rhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5446 && operand_equal_p (TREE_OPERAND (rhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5448 if (!rhs_only
&& inv_code
== lhs_code
5449 && operand_equal_p (TREE_OPERAND (lhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5450 && operand_equal_p (TREE_OPERAND (lhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5452 if (rhs
!= orig_rhs
|| lhs
!= orig_lhs
)
5453 return fold_build2_loc (loc
, truthop_code
, TREE_TYPE (cmpop
),
5458 /* Find ways of folding logical expressions of LHS and RHS:
5459 Try to merge two comparisons to the same innermost item.
5460 Look for range tests like "ch >= '0' && ch <= '9'".
5461 Look for combinations of simple terms on machines with expensive branches
5462 and evaluate the RHS unconditionally.
5464 For example, if we have p->a == 2 && p->b == 4 and we can make an
5465 object large enough to span both A and B, we can do this with a comparison
5466 against the object ANDed with the a mask.
5468 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5469 operations to do this with one comparison.
5471 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5472 function and the one above.
5474 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5475 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5477 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5480 We return the simplified tree or 0 if no optimization is possible. */
5483 fold_truth_andor_1 (location_t loc
, enum tree_code code
, tree truth_type
,
5486 /* If this is the "or" of two comparisons, we can do something if
5487 the comparisons are NE_EXPR. If this is the "and", we can do something
5488 if the comparisons are EQ_EXPR. I.e.,
5489 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5491 WANTED_CODE is this operation code. For single bit fields, we can
5492 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5493 comparison for one-bit fields. */
5495 enum tree_code wanted_code
;
5496 enum tree_code lcode
, rcode
;
5497 tree ll_arg
, lr_arg
, rl_arg
, rr_arg
;
5498 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
5499 HOST_WIDE_INT ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
5500 HOST_WIDE_INT rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
5501 HOST_WIDE_INT xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
5502 HOST_WIDE_INT lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
5503 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
5504 int ll_reversep
, lr_reversep
, rl_reversep
, rr_reversep
;
5505 machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
5506 machine_mode lnmode
, rnmode
;
5507 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
5508 tree ll_and_mask
, lr_and_mask
, rl_and_mask
, rr_and_mask
;
5509 tree l_const
, r_const
;
5510 tree lntype
, rntype
, result
;
5511 HOST_WIDE_INT first_bit
, end_bit
;
5514 /* Start by getting the comparison codes. Fail if anything is volatile.
5515 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5516 it were surrounded with a NE_EXPR. */
5518 if (TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
5521 lcode
= TREE_CODE (lhs
);
5522 rcode
= TREE_CODE (rhs
);
5524 if (lcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (lhs
, 1)))
5526 lhs
= build2 (NE_EXPR
, truth_type
, lhs
,
5527 build_int_cst (TREE_TYPE (lhs
), 0));
5531 if (rcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (rhs
, 1)))
5533 rhs
= build2 (NE_EXPR
, truth_type
, rhs
,
5534 build_int_cst (TREE_TYPE (rhs
), 0));
5538 if (TREE_CODE_CLASS (lcode
) != tcc_comparison
5539 || TREE_CODE_CLASS (rcode
) != tcc_comparison
)
5542 ll_arg
= TREE_OPERAND (lhs
, 0);
5543 lr_arg
= TREE_OPERAND (lhs
, 1);
5544 rl_arg
= TREE_OPERAND (rhs
, 0);
5545 rr_arg
= TREE_OPERAND (rhs
, 1);
5547 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5548 if (simple_operand_p (ll_arg
)
5549 && simple_operand_p (lr_arg
))
5551 if (operand_equal_p (ll_arg
, rl_arg
, 0)
5552 && operand_equal_p (lr_arg
, rr_arg
, 0))
5554 result
= combine_comparisons (loc
, code
, lcode
, rcode
,
5555 truth_type
, ll_arg
, lr_arg
);
5559 else if (operand_equal_p (ll_arg
, rr_arg
, 0)
5560 && operand_equal_p (lr_arg
, rl_arg
, 0))
5562 result
= combine_comparisons (loc
, code
, lcode
,
5563 swap_tree_comparison (rcode
),
5564 truth_type
, ll_arg
, lr_arg
);
5570 code
= ((code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
)
5571 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
);
5573 /* If the RHS can be evaluated unconditionally and its operands are
5574 simple, it wins to evaluate the RHS unconditionally on machines
5575 with expensive branches. In this case, this isn't a comparison
5576 that can be merged. */
5578 if (BRANCH_COST (optimize_function_for_speed_p (cfun
),
5580 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg
))
5581 && simple_operand_p (rl_arg
)
5582 && simple_operand_p (rr_arg
))
5584 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5585 if (code
== TRUTH_OR_EXPR
5586 && lcode
== NE_EXPR
&& integer_zerop (lr_arg
)
5587 && rcode
== NE_EXPR
&& integer_zerop (rr_arg
)
5588 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5589 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5590 return build2_loc (loc
, NE_EXPR
, truth_type
,
5591 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5593 build_int_cst (TREE_TYPE (ll_arg
), 0));
5595 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5596 if (code
== TRUTH_AND_EXPR
5597 && lcode
== EQ_EXPR
&& integer_zerop (lr_arg
)
5598 && rcode
== EQ_EXPR
&& integer_zerop (rr_arg
)
5599 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5600 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5601 return build2_loc (loc
, EQ_EXPR
, truth_type
,
5602 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5604 build_int_cst (TREE_TYPE (ll_arg
), 0));
5607 /* See if the comparisons can be merged. Then get all the parameters for
5610 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
5611 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
))
5614 ll_reversep
= lr_reversep
= rl_reversep
= rr_reversep
= 0;
5616 ll_inner
= decode_field_reference (loc
, ll_arg
,
5617 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
5618 &ll_unsignedp
, &ll_reversep
, &volatilep
,
5619 &ll_mask
, &ll_and_mask
);
5620 lr_inner
= decode_field_reference (loc
, lr_arg
,
5621 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
5622 &lr_unsignedp
, &lr_reversep
, &volatilep
,
5623 &lr_mask
, &lr_and_mask
);
5624 rl_inner
= decode_field_reference (loc
, rl_arg
,
5625 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
5626 &rl_unsignedp
, &rl_reversep
, &volatilep
,
5627 &rl_mask
, &rl_and_mask
);
5628 rr_inner
= decode_field_reference (loc
, rr_arg
,
5629 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
5630 &rr_unsignedp
, &rr_reversep
, &volatilep
,
5631 &rr_mask
, &rr_and_mask
);
5633 /* It must be true that the inner operation on the lhs of each
5634 comparison must be the same if we are to be able to do anything.
5635 Then see if we have constants. If not, the same must be true for
5638 || ll_reversep
!= rl_reversep
5639 || ll_inner
== 0 || rl_inner
== 0
5640 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
5643 if (TREE_CODE (lr_arg
) == INTEGER_CST
5644 && TREE_CODE (rr_arg
) == INTEGER_CST
)
5646 l_const
= lr_arg
, r_const
= rr_arg
;
5647 lr_reversep
= ll_reversep
;
5649 else if (lr_reversep
!= rr_reversep
5650 || lr_inner
== 0 || rr_inner
== 0
5651 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
5654 l_const
= r_const
= 0;
5656 /* If either comparison code is not correct for our logical operation,
5657 fail. However, we can convert a one-bit comparison against zero into
5658 the opposite comparison against that bit being set in the field. */
5660 wanted_code
= (code
== TRUTH_AND_EXPR
? EQ_EXPR
: NE_EXPR
);
5661 if (lcode
!= wanted_code
)
5663 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
5665 /* Make the left operand unsigned, since we are only interested
5666 in the value of one bit. Otherwise we are doing the wrong
5675 /* This is analogous to the code for l_const above. */
5676 if (rcode
!= wanted_code
)
5678 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
5687 /* See if we can find a mode that contains both fields being compared on
5688 the left. If we can't, fail. Otherwise, update all constants and masks
5689 to be relative to a field of that size. */
5690 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
5691 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
5692 lnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5693 TYPE_ALIGN (TREE_TYPE (ll_inner
)), word_mode
,
5695 if (lnmode
== VOIDmode
)
5698 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
5699 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
5700 lntype
= lang_hooks
.types
.type_for_size (lnbitsize
, 1);
5701 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
5703 if (ll_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5705 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
5706 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
5709 ll_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, ll_mask
),
5710 size_int (xll_bitpos
));
5711 rl_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, rl_mask
),
5712 size_int (xrl_bitpos
));
5716 l_const
= fold_convert_loc (loc
, lntype
, l_const
);
5717 l_const
= unextend (l_const
, ll_bitsize
, ll_unsignedp
, ll_and_mask
);
5718 l_const
= const_binop (LSHIFT_EXPR
, l_const
, size_int (xll_bitpos
));
5719 if (! integer_zerop (const_binop (BIT_AND_EXPR
, l_const
,
5720 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5723 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5725 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5730 r_const
= fold_convert_loc (loc
, lntype
, r_const
);
5731 r_const
= unextend (r_const
, rl_bitsize
, rl_unsignedp
, rl_and_mask
);
5732 r_const
= const_binop (LSHIFT_EXPR
, r_const
, size_int (xrl_bitpos
));
5733 if (! integer_zerop (const_binop (BIT_AND_EXPR
, r_const
,
5734 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5737 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5739 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5743 /* If the right sides are not constant, do the same for it. Also,
5744 disallow this optimization if a size or signedness mismatch occurs
5745 between the left and right sides. */
5748 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
5749 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
5750 /* Make sure the two fields on the right
5751 correspond to the left without being swapped. */
5752 || ll_bitpos
- rl_bitpos
!= lr_bitpos
- rr_bitpos
)
5755 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
5756 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
5757 rnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5758 TYPE_ALIGN (TREE_TYPE (lr_inner
)), word_mode
,
5760 if (rnmode
== VOIDmode
)
5763 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
5764 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
5765 rntype
= lang_hooks
.types
.type_for_size (rnbitsize
, 1);
5766 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
5768 if (lr_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5770 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
5771 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
5774 lr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5776 size_int (xlr_bitpos
));
5777 rr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5779 size_int (xrr_bitpos
));
5781 /* Make a mask that corresponds to both fields being compared.
5782 Do this for both items being compared. If the operands are the
5783 same size and the bits being compared are in the same position
5784 then we can do this by masking both and comparing the masked
5786 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5787 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
);
5788 if (lnbitsize
== rnbitsize
&& xll_bitpos
== xlr_bitpos
)
5790 lhs
= make_bit_field_ref (loc
, ll_inner
, lntype
, lnbitsize
, lnbitpos
,
5791 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
5792 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5793 lhs
= build2 (BIT_AND_EXPR
, lntype
, lhs
, ll_mask
);
5795 rhs
= make_bit_field_ref (loc
, lr_inner
, rntype
, rnbitsize
, rnbitpos
,
5796 lr_unsignedp
|| rr_unsignedp
, lr_reversep
);
5797 if (! all_ones_mask_p (lr_mask
, rnbitsize
))
5798 rhs
= build2 (BIT_AND_EXPR
, rntype
, rhs
, lr_mask
);
5800 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5803 /* There is still another way we can do something: If both pairs of
5804 fields being compared are adjacent, we may be able to make a wider
5805 field containing them both.
5807 Note that we still must mask the lhs/rhs expressions. Furthermore,
5808 the mask must be shifted to account for the shift done by
5809 make_bit_field_ref. */
5810 if ((ll_bitsize
+ ll_bitpos
== rl_bitpos
5811 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
5812 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
5813 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
5817 lhs
= make_bit_field_ref (loc
, ll_inner
, lntype
,
5818 ll_bitsize
+ rl_bitsize
,
5819 MIN (ll_bitpos
, rl_bitpos
),
5820 ll_unsignedp
, ll_reversep
);
5821 rhs
= make_bit_field_ref (loc
, lr_inner
, rntype
,
5822 lr_bitsize
+ rr_bitsize
,
5823 MIN (lr_bitpos
, rr_bitpos
),
5824 lr_unsignedp
, lr_reversep
);
5826 ll_mask
= const_binop (RSHIFT_EXPR
, ll_mask
,
5827 size_int (MIN (xll_bitpos
, xrl_bitpos
)));
5828 lr_mask
= const_binop (RSHIFT_EXPR
, lr_mask
,
5829 size_int (MIN (xlr_bitpos
, xrr_bitpos
)));
5831 /* Convert to the smaller type before masking out unwanted bits. */
5833 if (lntype
!= rntype
)
5835 if (lnbitsize
> rnbitsize
)
5837 lhs
= fold_convert_loc (loc
, rntype
, lhs
);
5838 ll_mask
= fold_convert_loc (loc
, rntype
, ll_mask
);
5841 else if (lnbitsize
< rnbitsize
)
5843 rhs
= fold_convert_loc (loc
, lntype
, rhs
);
5844 lr_mask
= fold_convert_loc (loc
, lntype
, lr_mask
);
5849 if (! all_ones_mask_p (ll_mask
, ll_bitsize
+ rl_bitsize
))
5850 lhs
= build2 (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
5852 if (! all_ones_mask_p (lr_mask
, lr_bitsize
+ rr_bitsize
))
5853 rhs
= build2 (BIT_AND_EXPR
, type
, rhs
, lr_mask
);
5855 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5861 /* Handle the case of comparisons with constants. If there is something in
5862 common between the masks, those bits of the constants must be the same.
5863 If not, the condition is always false. Test for this to avoid generating
5864 incorrect code below. */
5865 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
);
5866 if (! integer_zerop (result
)
5867 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
),
5868 const_binop (BIT_AND_EXPR
, result
, r_const
)) != 1)
5870 if (wanted_code
== NE_EXPR
)
5872 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5873 return constant_boolean_node (true, truth_type
);
5877 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5878 return constant_boolean_node (false, truth_type
);
5882 /* Construct the expression we will return. First get the component
5883 reference we will make. Unless the mask is all ones the width of
5884 that field, perform the mask operation. Then compare with the
5886 result
= make_bit_field_ref (loc
, ll_inner
, lntype
, lnbitsize
, lnbitpos
,
5887 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
5889 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5890 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5891 result
= build2_loc (loc
, BIT_AND_EXPR
, lntype
, result
, ll_mask
);
5893 return build2_loc (loc
, wanted_code
, truth_type
, result
,
5894 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
5897 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5901 optimize_minmax_comparison (location_t loc
, enum tree_code code
, tree type
,
5905 enum tree_code op_code
;
5908 int consts_equal
, consts_lt
;
5911 STRIP_SIGN_NOPS (arg0
);
5913 op_code
= TREE_CODE (arg0
);
5914 minmax_const
= TREE_OPERAND (arg0
, 1);
5915 comp_const
= fold_convert_loc (loc
, TREE_TYPE (arg0
), op1
);
5916 consts_equal
= tree_int_cst_equal (minmax_const
, comp_const
);
5917 consts_lt
= tree_int_cst_lt (minmax_const
, comp_const
);
5918 inner
= TREE_OPERAND (arg0
, 0);
5920 /* If something does not permit us to optimize, return the original tree. */
5921 if ((op_code
!= MIN_EXPR
&& op_code
!= MAX_EXPR
)
5922 || TREE_CODE (comp_const
) != INTEGER_CST
5923 || TREE_OVERFLOW (comp_const
)
5924 || TREE_CODE (minmax_const
) != INTEGER_CST
5925 || TREE_OVERFLOW (minmax_const
))
5928 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5929 and GT_EXPR, doing the rest with recursive calls using logical
5933 case NE_EXPR
: case LT_EXPR
: case LE_EXPR
:
5936 = optimize_minmax_comparison (loc
,
5937 invert_tree_comparison (code
, false),
5940 return invert_truthvalue_loc (loc
, tem
);
5946 fold_build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
5947 optimize_minmax_comparison
5948 (loc
, EQ_EXPR
, type
, arg0
, comp_const
),
5949 optimize_minmax_comparison
5950 (loc
, GT_EXPR
, type
, arg0
, comp_const
));
5953 if (op_code
== MAX_EXPR
&& consts_equal
)
5954 /* MAX (X, 0) == 0 -> X <= 0 */
5955 return fold_build2_loc (loc
, LE_EXPR
, type
, inner
, comp_const
);
5957 else if (op_code
== MAX_EXPR
&& consts_lt
)
5958 /* MAX (X, 0) == 5 -> X == 5 */
5959 return fold_build2_loc (loc
, EQ_EXPR
, type
, inner
, comp_const
);
5961 else if (op_code
== MAX_EXPR
)
5962 /* MAX (X, 0) == -1 -> false */
5963 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5965 else if (consts_equal
)
5966 /* MIN (X, 0) == 0 -> X >= 0 */
5967 return fold_build2_loc (loc
, GE_EXPR
, type
, inner
, comp_const
);
5970 /* MIN (X, 0) == 5 -> false */
5971 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5974 /* MIN (X, 0) == -1 -> X == -1 */
5975 return fold_build2_loc (loc
, EQ_EXPR
, type
, inner
, comp_const
);
5978 if (op_code
== MAX_EXPR
&& (consts_equal
|| consts_lt
))
5979 /* MAX (X, 0) > 0 -> X > 0
5980 MAX (X, 0) > 5 -> X > 5 */
5981 return fold_build2_loc (loc
, GT_EXPR
, type
, inner
, comp_const
);
5983 else if (op_code
== MAX_EXPR
)
5984 /* MAX (X, 0) > -1 -> true */
5985 return omit_one_operand_loc (loc
, type
, integer_one_node
, inner
);
5987 else if (op_code
== MIN_EXPR
&& (consts_equal
|| consts_lt
))
5988 /* MIN (X, 0) > 0 -> false
5989 MIN (X, 0) > 5 -> false */
5990 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5993 /* MIN (X, 0) > -1 -> X > -1 */
5994 return fold_build2_loc (loc
, GT_EXPR
, type
, inner
, comp_const
);
6001 /* T is an integer expression that is being multiplied, divided, or taken a
6002 modulus (CODE says which and what kind of divide or modulus) by a
6003 constant C. See if we can eliminate that operation by folding it with
6004 other operations already in T. WIDE_TYPE, if non-null, is a type that
6005 should be used for the computation if wider than our type.
6007 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
6008 (X * 2) + (Y * 4). We must, however, be assured that either the original
6009 expression would not overflow or that overflow is undefined for the type
6010 in the language in question.
6012 If we return a non-null expression, it is an equivalent form of the
6013 original computation, but need not be in the original type.
6015 We set *STRICT_OVERFLOW_P to true if the return values depends on
6016 signed overflow being undefined. Otherwise we do not change
6017 *STRICT_OVERFLOW_P. */
6020 extract_muldiv (tree t
, tree c
, enum tree_code code
, tree wide_type
,
6021 bool *strict_overflow_p
)
6023 /* To avoid exponential search depth, refuse to allow recursion past
6024 three levels. Beyond that (1) it's highly unlikely that we'll find
6025 something interesting and (2) we've probably processed it before
6026 when we built the inner expression. */
6035 ret
= extract_muldiv_1 (t
, c
, code
, wide_type
, strict_overflow_p
);
6042 extract_muldiv_1 (tree t
, tree c
, enum tree_code code
, tree wide_type
,
6043 bool *strict_overflow_p
)
6045 tree type
= TREE_TYPE (t
);
6046 enum tree_code tcode
= TREE_CODE (t
);
6047 tree ctype
= (wide_type
!= 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type
))
6048 > GET_MODE_SIZE (TYPE_MODE (type
)))
6049 ? wide_type
: type
);
6051 int same_p
= tcode
== code
;
6052 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
6053 bool sub_strict_overflow_p
;
6055 /* Don't deal with constants of zero here; they confuse the code below. */
6056 if (integer_zerop (c
))
6059 if (TREE_CODE_CLASS (tcode
) == tcc_unary
)
6060 op0
= TREE_OPERAND (t
, 0);
6062 if (TREE_CODE_CLASS (tcode
) == tcc_binary
)
6063 op0
= TREE_OPERAND (t
, 0), op1
= TREE_OPERAND (t
, 1);
6065 /* Note that we need not handle conditional operations here since fold
6066 already handles those cases. So just do arithmetic here. */
6070 /* For a constant, we can always simplify if we are a multiply
6071 or (for divide and modulus) if it is a multiple of our constant. */
6072 if (code
== MULT_EXPR
6073 || wi::multiple_of_p (t
, c
, TYPE_SIGN (type
)))
6075 tree tem
= const_binop (code
, fold_convert (ctype
, t
),
6076 fold_convert (ctype
, c
));
6077 /* If the multiplication overflowed to INT_MIN then we lost sign
6078 information on it and a subsequent multiplication might
6079 spuriously overflow. See PR68142. */
6080 if (TREE_OVERFLOW (tem
)
6081 && wi::eq_p (tem
, wi::min_value (TYPE_PRECISION (ctype
), SIGNED
)))
6087 CASE_CONVERT
: case NON_LVALUE_EXPR
:
6088 /* If op0 is an expression ... */
6089 if ((COMPARISON_CLASS_P (op0
)
6090 || UNARY_CLASS_P (op0
)
6091 || BINARY_CLASS_P (op0
)
6092 || VL_EXP_CLASS_P (op0
)
6093 || EXPRESSION_CLASS_P (op0
))
6094 /* ... and has wrapping overflow, and its type is smaller
6095 than ctype, then we cannot pass through as widening. */
6096 && (((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
6097 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0
)))
6098 && (TYPE_PRECISION (ctype
)
6099 > TYPE_PRECISION (TREE_TYPE (op0
))))
6100 /* ... or this is a truncation (t is narrower than op0),
6101 then we cannot pass through this narrowing. */
6102 || (TYPE_PRECISION (type
)
6103 < TYPE_PRECISION (TREE_TYPE (op0
)))
6104 /* ... or signedness changes for division or modulus,
6105 then we cannot pass through this conversion. */
6106 || (code
!= MULT_EXPR
6107 && (TYPE_UNSIGNED (ctype
)
6108 != TYPE_UNSIGNED (TREE_TYPE (op0
))))
6109 /* ... or has undefined overflow while the converted to
6110 type has not, we cannot do the operation in the inner type
6111 as that would introduce undefined overflow. */
6112 || ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
6113 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0
)))
6114 && !TYPE_OVERFLOW_UNDEFINED (type
))))
6117 /* Pass the constant down and see if we can make a simplification. If
6118 we can, replace this expression with the inner simplification for
6119 possible later conversion to our or some other type. */
6120 if ((t2
= fold_convert (TREE_TYPE (op0
), c
)) != 0
6121 && TREE_CODE (t2
) == INTEGER_CST
6122 && !TREE_OVERFLOW (t2
)
6123 && (0 != (t1
= extract_muldiv (op0
, t2
, code
,
6125 ? ctype
: NULL_TREE
,
6126 strict_overflow_p
))))
6131 /* If widening the type changes it from signed to unsigned, then we
6132 must avoid building ABS_EXPR itself as unsigned. */
6133 if (TYPE_UNSIGNED (ctype
) && !TYPE_UNSIGNED (type
))
6135 tree cstype
= (*signed_type_for
) (ctype
);
6136 if ((t1
= extract_muldiv (op0
, c
, code
, cstype
, strict_overflow_p
))
6139 t1
= fold_build1 (tcode
, cstype
, fold_convert (cstype
, t1
));
6140 return fold_convert (ctype
, t1
);
6144 /* If the constant is negative, we cannot simplify this. */
6145 if (tree_int_cst_sgn (c
) == -1)
6149 /* For division and modulus, type can't be unsigned, as e.g.
6150 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6151 For signed types, even with wrapping overflow, this is fine. */
6152 if (code
!= MULT_EXPR
&& TYPE_UNSIGNED (type
))
6154 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
, strict_overflow_p
))
6156 return fold_build1 (tcode
, ctype
, fold_convert (ctype
, t1
));
6159 case MIN_EXPR
: case MAX_EXPR
:
6160 /* If widening the type changes the signedness, then we can't perform
6161 this optimization as that changes the result. */
6162 if (TYPE_UNSIGNED (ctype
) != TYPE_UNSIGNED (type
))
6165 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6166 sub_strict_overflow_p
= false;
6167 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6168 &sub_strict_overflow_p
)) != 0
6169 && (t2
= extract_muldiv (op1
, c
, code
, wide_type
,
6170 &sub_strict_overflow_p
)) != 0)
6172 if (tree_int_cst_sgn (c
) < 0)
6173 tcode
= (tcode
== MIN_EXPR
? MAX_EXPR
: MIN_EXPR
);
6174 if (sub_strict_overflow_p
)
6175 *strict_overflow_p
= true;
6176 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6177 fold_convert (ctype
, t2
));
6181 case LSHIFT_EXPR
: case RSHIFT_EXPR
:
6182 /* If the second operand is constant, this is a multiplication
6183 or floor division, by a power of two, so we can treat it that
6184 way unless the multiplier or divisor overflows. Signed
6185 left-shift overflow is implementation-defined rather than
6186 undefined in C90, so do not convert signed left shift into
6188 if (TREE_CODE (op1
) == INTEGER_CST
6189 && (tcode
== RSHIFT_EXPR
|| TYPE_UNSIGNED (TREE_TYPE (op0
)))
6190 /* const_binop may not detect overflow correctly,
6191 so check for it explicitly here. */
6192 && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
6193 && 0 != (t1
= fold_convert (ctype
,
6194 const_binop (LSHIFT_EXPR
,
6197 && !TREE_OVERFLOW (t1
))
6198 return extract_muldiv (build2 (tcode
== LSHIFT_EXPR
6199 ? MULT_EXPR
: FLOOR_DIV_EXPR
,
6201 fold_convert (ctype
, op0
),
6203 c
, code
, wide_type
, strict_overflow_p
);
6206 case PLUS_EXPR
: case MINUS_EXPR
:
6207 /* See if we can eliminate the operation on both sides. If we can, we
6208 can return a new PLUS or MINUS. If we can't, the only remaining
6209 cases where we can do anything are if the second operand is a
6211 sub_strict_overflow_p
= false;
6212 t1
= extract_muldiv (op0
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6213 t2
= extract_muldiv (op1
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6214 if (t1
!= 0 && t2
!= 0
6215 && (code
== MULT_EXPR
6216 /* If not multiplication, we can only do this if both operands
6217 are divisible by c. */
6218 || (multiple_of_p (ctype
, op0
, c
)
6219 && multiple_of_p (ctype
, op1
, c
))))
6221 if (sub_strict_overflow_p
)
6222 *strict_overflow_p
= true;
6223 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6224 fold_convert (ctype
, t2
));
6227 /* If this was a subtraction, negate OP1 and set it to be an addition.
6228 This simplifies the logic below. */
6229 if (tcode
== MINUS_EXPR
)
6231 tcode
= PLUS_EXPR
, op1
= negate_expr (op1
);
6232 /* If OP1 was not easily negatable, the constant may be OP0. */
6233 if (TREE_CODE (op0
) == INTEGER_CST
)
6235 std::swap (op0
, op1
);
6240 if (TREE_CODE (op1
) != INTEGER_CST
)
6243 /* If either OP1 or C are negative, this optimization is not safe for
6244 some of the division and remainder types while for others we need
6245 to change the code. */
6246 if (tree_int_cst_sgn (op1
) < 0 || tree_int_cst_sgn (c
) < 0)
6248 if (code
== CEIL_DIV_EXPR
)
6249 code
= FLOOR_DIV_EXPR
;
6250 else if (code
== FLOOR_DIV_EXPR
)
6251 code
= CEIL_DIV_EXPR
;
6252 else if (code
!= MULT_EXPR
6253 && code
!= CEIL_MOD_EXPR
&& code
!= FLOOR_MOD_EXPR
)
6257 /* If it's a multiply or a division/modulus operation of a multiple
6258 of our constant, do the operation and verify it doesn't overflow. */
6259 if (code
== MULT_EXPR
6260 || wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6262 op1
= const_binop (code
, fold_convert (ctype
, op1
),
6263 fold_convert (ctype
, c
));
6264 /* We allow the constant to overflow with wrapping semantics. */
6266 || (TREE_OVERFLOW (op1
) && !TYPE_OVERFLOW_WRAPS (ctype
)))
6272 /* If we have an unsigned type, we cannot widen the operation since it
6273 will change the result if the original computation overflowed. */
6274 if (TYPE_UNSIGNED (ctype
) && ctype
!= type
)
6277 /* If we were able to eliminate our operation from the first side,
6278 apply our operation to the second side and reform the PLUS. */
6279 if (t1
!= 0 && (TREE_CODE (t1
) != code
|| code
== MULT_EXPR
))
6280 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
), op1
);
6282 /* The last case is if we are a multiply. In that case, we can
6283 apply the distributive law to commute the multiply and addition
6284 if the multiplication of the constants doesn't overflow
6285 and overflow is defined. With undefined overflow
6286 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6287 if (code
== MULT_EXPR
&& TYPE_OVERFLOW_WRAPS (ctype
))
6288 return fold_build2 (tcode
, ctype
,
6289 fold_build2 (code
, ctype
,
6290 fold_convert (ctype
, op0
),
6291 fold_convert (ctype
, c
)),
6297 /* We have a special case here if we are doing something like
6298 (C * 8) % 4 since we know that's zero. */
6299 if ((code
== TRUNC_MOD_EXPR
|| code
== CEIL_MOD_EXPR
6300 || code
== FLOOR_MOD_EXPR
|| code
== ROUND_MOD_EXPR
)
6301 /* If the multiplication can overflow we cannot optimize this. */
6302 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
))
6303 && TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
6304 && wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6306 *strict_overflow_p
= true;
6307 return omit_one_operand (type
, integer_zero_node
, op0
);
6310 /* ... fall through ... */
6312 case TRUNC_DIV_EXPR
: case CEIL_DIV_EXPR
: case FLOOR_DIV_EXPR
:
6313 case ROUND_DIV_EXPR
: case EXACT_DIV_EXPR
:
6314 /* If we can extract our operation from the LHS, do so and return a
6315 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6316 do something only if the second operand is a constant. */
6318 && (t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6319 strict_overflow_p
)) != 0)
6320 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6321 fold_convert (ctype
, op1
));
6322 else if (tcode
== MULT_EXPR
&& code
== MULT_EXPR
6323 && (t1
= extract_muldiv (op1
, c
, code
, wide_type
,
6324 strict_overflow_p
)) != 0)
6325 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6326 fold_convert (ctype
, t1
));
6327 else if (TREE_CODE (op1
) != INTEGER_CST
)
6330 /* If these are the same operation types, we can associate them
6331 assuming no overflow. */
6334 bool overflow_p
= false;
6335 bool overflow_mul_p
;
6336 signop sign
= TYPE_SIGN (ctype
);
6337 wide_int mul
= wi::mul (op1
, c
, sign
, &overflow_mul_p
);
6338 overflow_p
= TREE_OVERFLOW (c
) | TREE_OVERFLOW (op1
);
6340 && ((sign
== UNSIGNED
&& tcode
!= MULT_EXPR
) || sign
== SIGNED
))
6344 mul
= wide_int::from (mul
, TYPE_PRECISION (ctype
),
6345 TYPE_SIGN (TREE_TYPE (op1
)));
6346 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6347 wide_int_to_tree (ctype
, mul
));
6351 /* If these operations "cancel" each other, we have the main
6352 optimizations of this pass, which occur when either constant is a
6353 multiple of the other, in which case we replace this with either an
6354 operation or CODE or TCODE.
6356 If we have an unsigned type, we cannot do this since it will change
6357 the result if the original computation overflowed. */
6358 if (TYPE_OVERFLOW_UNDEFINED (ctype
)
6359 && ((code
== MULT_EXPR
&& tcode
== EXACT_DIV_EXPR
)
6360 || (tcode
== MULT_EXPR
6361 && code
!= TRUNC_MOD_EXPR
&& code
!= CEIL_MOD_EXPR
6362 && code
!= FLOOR_MOD_EXPR
&& code
!= ROUND_MOD_EXPR
6363 && code
!= MULT_EXPR
)))
6365 if (wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6367 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6368 *strict_overflow_p
= true;
6369 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6370 fold_convert (ctype
,
6371 const_binop (TRUNC_DIV_EXPR
,
6374 else if (wi::multiple_of_p (c
, op1
, TYPE_SIGN (type
)))
6376 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6377 *strict_overflow_p
= true;
6378 return fold_build2 (code
, ctype
, fold_convert (ctype
, op0
),
6379 fold_convert (ctype
,
6380 const_binop (TRUNC_DIV_EXPR
,
6393 /* Return a node which has the indicated constant VALUE (either 0 or
6394 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6395 and is of the indicated TYPE. */
6398 constant_boolean_node (bool value
, tree type
)
6400 if (type
== integer_type_node
)
6401 return value
? integer_one_node
: integer_zero_node
;
6402 else if (type
== boolean_type_node
)
6403 return value
? boolean_true_node
: boolean_false_node
;
6404 else if (TREE_CODE (type
) == VECTOR_TYPE
)
6405 return build_vector_from_val (type
,
6406 build_int_cst (TREE_TYPE (type
),
6409 return fold_convert (type
, value
? integer_one_node
: integer_zero_node
);
6413 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6414 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6415 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6416 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6417 COND is the first argument to CODE; otherwise (as in the example
6418 given here), it is the second argument. TYPE is the type of the
6419 original expression. Return NULL_TREE if no simplification is
6423 fold_binary_op_with_conditional_arg (location_t loc
,
6424 enum tree_code code
,
6425 tree type
, tree op0
, tree op1
,
6426 tree cond
, tree arg
, int cond_first_p
)
6428 tree cond_type
= cond_first_p
? TREE_TYPE (op0
) : TREE_TYPE (op1
);
6429 tree arg_type
= cond_first_p
? TREE_TYPE (op1
) : TREE_TYPE (op0
);
6430 tree test
, true_value
, false_value
;
6431 tree lhs
= NULL_TREE
;
6432 tree rhs
= NULL_TREE
;
6433 enum tree_code cond_code
= COND_EXPR
;
6435 if (TREE_CODE (cond
) == COND_EXPR
6436 || TREE_CODE (cond
) == VEC_COND_EXPR
)
6438 test
= TREE_OPERAND (cond
, 0);
6439 true_value
= TREE_OPERAND (cond
, 1);
6440 false_value
= TREE_OPERAND (cond
, 2);
6441 /* If this operand throws an expression, then it does not make
6442 sense to try to perform a logical or arithmetic operation
6444 if (VOID_TYPE_P (TREE_TYPE (true_value
)))
6446 if (VOID_TYPE_P (TREE_TYPE (false_value
)))
6451 tree testtype
= TREE_TYPE (cond
);
6453 true_value
= constant_boolean_node (true, testtype
);
6454 false_value
= constant_boolean_node (false, testtype
);
6457 if (TREE_CODE (TREE_TYPE (test
)) == VECTOR_TYPE
)
6458 cond_code
= VEC_COND_EXPR
;
6460 /* This transformation is only worthwhile if we don't have to wrap ARG
6461 in a SAVE_EXPR and the operation can be simplified without recursing
6462 on at least one of the branches once its pushed inside the COND_EXPR. */
6463 if (!TREE_CONSTANT (arg
)
6464 && (TREE_SIDE_EFFECTS (arg
)
6465 || TREE_CODE (arg
) == COND_EXPR
|| TREE_CODE (arg
) == VEC_COND_EXPR
6466 || TREE_CONSTANT (true_value
) || TREE_CONSTANT (false_value
)))
6469 arg
= fold_convert_loc (loc
, arg_type
, arg
);
6472 true_value
= fold_convert_loc (loc
, cond_type
, true_value
);
6474 lhs
= fold_build2_loc (loc
, code
, type
, true_value
, arg
);
6476 lhs
= fold_build2_loc (loc
, code
, type
, arg
, true_value
);
6480 false_value
= fold_convert_loc (loc
, cond_type
, false_value
);
6482 rhs
= fold_build2_loc (loc
, code
, type
, false_value
, arg
);
6484 rhs
= fold_build2_loc (loc
, code
, type
, arg
, false_value
);
6487 /* Check that we have simplified at least one of the branches. */
6488 if (!TREE_CONSTANT (arg
) && !TREE_CONSTANT (lhs
) && !TREE_CONSTANT (rhs
))
6491 return fold_build3_loc (loc
, cond_code
, type
, test
, lhs
, rhs
);
6495 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6497 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6498 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6499 ADDEND is the same as X.
6501 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6502 and finite. The problematic cases are when X is zero, and its mode
6503 has signed zeros. In the case of rounding towards -infinity,
6504 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6505 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6508 fold_real_zero_addition_p (const_tree type
, const_tree addend
, int negate
)
6510 if (!real_zerop (addend
))
6513 /* Don't allow the fold with -fsignaling-nans. */
6514 if (HONOR_SNANS (element_mode (type
)))
6517 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6518 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
6521 /* In a vector or complex, we would need to check the sign of all zeros. */
6522 if (TREE_CODE (addend
) != REAL_CST
)
6525 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6526 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend
)))
6529 /* The mode has signed zeros, and we have to honor their sign.
6530 In this situation, there is only one case we can return true for.
6531 X - 0 is the same as X unless rounding towards -infinity is
6533 return negate
&& !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
));
6536 /* Subroutine of fold() that optimizes comparisons of a division by
6537 a nonzero integer constant against an integer constant, i.e.
6540 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6541 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6542 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6544 The function returns the constant folded tree if a simplification
6545 can be made, and NULL_TREE otherwise. */
6548 fold_div_compare (location_t loc
,
6549 enum tree_code code
, tree type
, tree arg0
, tree arg1
)
6551 tree prod
, tmp
, hi
, lo
;
6552 tree arg00
= TREE_OPERAND (arg0
, 0);
6553 tree arg01
= TREE_OPERAND (arg0
, 1);
6554 signop sign
= TYPE_SIGN (TREE_TYPE (arg0
));
6555 bool neg_overflow
= false;
6558 /* We have to do this the hard way to detect unsigned overflow.
6559 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6560 wide_int val
= wi::mul (arg01
, arg1
, sign
, &overflow
);
6561 prod
= force_fit_type (TREE_TYPE (arg00
), val
, -1, overflow
);
6562 neg_overflow
= false;
6564 if (sign
== UNSIGNED
)
6566 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6567 build_int_cst (TREE_TYPE (arg01
), 1));
6570 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6571 val
= wi::add (prod
, tmp
, sign
, &overflow
);
6572 hi
= force_fit_type (TREE_TYPE (arg00
), val
,
6573 -1, overflow
| TREE_OVERFLOW (prod
));
6575 else if (tree_int_cst_sgn (arg01
) >= 0)
6577 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6578 build_int_cst (TREE_TYPE (arg01
), 1));
6579 switch (tree_int_cst_sgn (arg1
))
6582 neg_overflow
= true;
6583 lo
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6588 lo
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6593 hi
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6603 /* A negative divisor reverses the relational operators. */
6604 code
= swap_tree_comparison (code
);
6606 tmp
= int_const_binop (PLUS_EXPR
, arg01
,
6607 build_int_cst (TREE_TYPE (arg01
), 1));
6608 switch (tree_int_cst_sgn (arg1
))
6611 hi
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6616 hi
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6621 neg_overflow
= true;
6622 lo
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6634 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6635 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg00
);
6636 if (TREE_OVERFLOW (hi
))
6637 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6638 if (TREE_OVERFLOW (lo
))
6639 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6640 return build_range_check (loc
, type
, arg00
, 1, lo
, hi
);
6643 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6644 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg00
);
6645 if (TREE_OVERFLOW (hi
))
6646 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6647 if (TREE_OVERFLOW (lo
))
6648 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6649 return build_range_check (loc
, type
, arg00
, 0, lo
, hi
);
6652 if (TREE_OVERFLOW (lo
))
6654 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6655 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6657 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6660 if (TREE_OVERFLOW (hi
))
6662 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6663 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6665 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6668 if (TREE_OVERFLOW (hi
))
6670 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6671 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6673 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6676 if (TREE_OVERFLOW (lo
))
6678 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6679 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6681 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6691 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6692 equality/inequality test, then return a simplified form of the test
6693 using a sign testing. Otherwise return NULL. TYPE is the desired
6697 fold_single_bit_test_into_sign_test (location_t loc
,
6698 enum tree_code code
, tree arg0
, tree arg1
,
6701 /* If this is testing a single bit, we can optimize the test. */
6702 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6703 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6704 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6706 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6707 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6708 tree arg00
= sign_bit_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1));
6710 if (arg00
!= NULL_TREE
6711 /* This is only a win if casting to a signed type is cheap,
6712 i.e. when arg00's type is not a partial mode. */
6713 && TYPE_PRECISION (TREE_TYPE (arg00
))
6714 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg00
))))
6716 tree stype
= signed_type_for (TREE_TYPE (arg00
));
6717 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
6719 fold_convert_loc (loc
, stype
, arg00
),
6720 build_int_cst (stype
, 0));
6727 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6728 equality/inequality test, then return a simplified form of
6729 the test using shifts and logical operations. Otherwise return
6730 NULL. TYPE is the desired result type. */
6733 fold_single_bit_test (location_t loc
, enum tree_code code
,
6734 tree arg0
, tree arg1
, tree result_type
)
6736 /* If this is testing a single bit, we can optimize the test. */
6737 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6738 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6739 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6741 tree inner
= TREE_OPERAND (arg0
, 0);
6742 tree type
= TREE_TYPE (arg0
);
6743 int bitnum
= tree_log2 (TREE_OPERAND (arg0
, 1));
6744 machine_mode operand_mode
= TYPE_MODE (type
);
6746 tree signed_type
, unsigned_type
, intermediate_type
;
6749 /* First, see if we can fold the single bit test into a sign-bit
6751 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
,
6756 /* Otherwise we have (A & C) != 0 where C is a single bit,
6757 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6758 Similarly for (A & C) == 0. */
6760 /* If INNER is a right shift of a constant and it plus BITNUM does
6761 not overflow, adjust BITNUM and INNER. */
6762 if (TREE_CODE (inner
) == RSHIFT_EXPR
6763 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
6764 && bitnum
< TYPE_PRECISION (type
)
6765 && wi::ltu_p (TREE_OPERAND (inner
, 1),
6766 TYPE_PRECISION (type
) - bitnum
))
6768 bitnum
+= tree_to_uhwi (TREE_OPERAND (inner
, 1));
6769 inner
= TREE_OPERAND (inner
, 0);
6772 /* If we are going to be able to omit the AND below, we must do our
6773 operations as unsigned. If we must use the AND, we have a choice.
6774 Normally unsigned is faster, but for some machines signed is. */
6775 ops_unsigned
= (LOAD_EXTEND_OP (operand_mode
) == SIGN_EXTEND
6776 && !flag_syntax_only
) ? 0 : 1;
6778 signed_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 0);
6779 unsigned_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 1);
6780 intermediate_type
= ops_unsigned
? unsigned_type
: signed_type
;
6781 inner
= fold_convert_loc (loc
, intermediate_type
, inner
);
6784 inner
= build2 (RSHIFT_EXPR
, intermediate_type
,
6785 inner
, size_int (bitnum
));
6787 one
= build_int_cst (intermediate_type
, 1);
6789 if (code
== EQ_EXPR
)
6790 inner
= fold_build2_loc (loc
, BIT_XOR_EXPR
, intermediate_type
, inner
, one
);
6792 /* Put the AND last so it can combine with more things. */
6793 inner
= build2 (BIT_AND_EXPR
, intermediate_type
, inner
, one
);
6795 /* Make sure to return the proper type. */
6796 inner
= fold_convert_loc (loc
, result_type
, inner
);
6803 /* Check whether we are allowed to reorder operands arg0 and arg1,
6804 such that the evaluation of arg1 occurs before arg0. */
6807 reorder_operands_p (const_tree arg0
, const_tree arg1
)
6809 if (! flag_evaluation_order
)
6811 if (TREE_CONSTANT (arg0
) || TREE_CONSTANT (arg1
))
6813 return ! TREE_SIDE_EFFECTS (arg0
)
6814 && ! TREE_SIDE_EFFECTS (arg1
);
6817 /* Test whether it is preferable two swap two operands, ARG0 and
6818 ARG1, for example because ARG0 is an integer constant and ARG1
6819 isn't. If REORDER is true, only recommend swapping if we can
6820 evaluate the operands in reverse order. */
6823 tree_swap_operands_p (const_tree arg0
, const_tree arg1
, bool reorder
)
6825 if (CONSTANT_CLASS_P (arg1
))
6827 if (CONSTANT_CLASS_P (arg0
))
6833 if (TREE_CONSTANT (arg1
))
6835 if (TREE_CONSTANT (arg0
))
6838 if (reorder
&& flag_evaluation_order
6839 && (TREE_SIDE_EFFECTS (arg0
) || TREE_SIDE_EFFECTS (arg1
)))
6842 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6843 for commutative and comparison operators. Ensuring a canonical
6844 form allows the optimizers to find additional redundancies without
6845 having to explicitly check for both orderings. */
6846 if (TREE_CODE (arg0
) == SSA_NAME
6847 && TREE_CODE (arg1
) == SSA_NAME
6848 && SSA_NAME_VERSION (arg0
) > SSA_NAME_VERSION (arg1
))
6851 /* Put SSA_NAMEs last. */
6852 if (TREE_CODE (arg1
) == SSA_NAME
)
6854 if (TREE_CODE (arg0
) == SSA_NAME
)
6857 /* Put variables last. */
6867 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6868 means A >= Y && A != MAX, but in this case we know that
6869 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6872 fold_to_nonsharp_ineq_using_bound (location_t loc
, tree ineq
, tree bound
)
6874 tree a
, typea
, type
= TREE_TYPE (ineq
), a1
, diff
, y
;
6876 if (TREE_CODE (bound
) == LT_EXPR
)
6877 a
= TREE_OPERAND (bound
, 0);
6878 else if (TREE_CODE (bound
) == GT_EXPR
)
6879 a
= TREE_OPERAND (bound
, 1);
6883 typea
= TREE_TYPE (a
);
6884 if (!INTEGRAL_TYPE_P (typea
)
6885 && !POINTER_TYPE_P (typea
))
6888 if (TREE_CODE (ineq
) == LT_EXPR
)
6890 a1
= TREE_OPERAND (ineq
, 1);
6891 y
= TREE_OPERAND (ineq
, 0);
6893 else if (TREE_CODE (ineq
) == GT_EXPR
)
6895 a1
= TREE_OPERAND (ineq
, 0);
6896 y
= TREE_OPERAND (ineq
, 1);
6901 if (TREE_TYPE (a1
) != typea
)
6904 if (POINTER_TYPE_P (typea
))
6906 /* Convert the pointer types into integer before taking the difference. */
6907 tree ta
= fold_convert_loc (loc
, ssizetype
, a
);
6908 tree ta1
= fold_convert_loc (loc
, ssizetype
, a1
);
6909 diff
= fold_binary_loc (loc
, MINUS_EXPR
, ssizetype
, ta1
, ta
);
6912 diff
= fold_binary_loc (loc
, MINUS_EXPR
, typea
, a1
, a
);
6914 if (!diff
|| !integer_onep (diff
))
6917 return fold_build2_loc (loc
, GE_EXPR
, type
, a
, y
);
6920 /* Fold a sum or difference of at least one multiplication.
6921 Returns the folded tree or NULL if no simplification could be made. */
6924 fold_plusminus_mult_expr (location_t loc
, enum tree_code code
, tree type
,
6925 tree arg0
, tree arg1
)
6927 tree arg00
, arg01
, arg10
, arg11
;
6928 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
6930 /* (A * C) +- (B * C) -> (A+-B) * C.
6931 (A * C) +- A -> A * (C+-1).
6932 We are most concerned about the case where C is a constant,
6933 but other combinations show up during loop reduction. Since
6934 it is not difficult, try all four possibilities. */
6936 if (TREE_CODE (arg0
) == MULT_EXPR
)
6938 arg00
= TREE_OPERAND (arg0
, 0);
6939 arg01
= TREE_OPERAND (arg0
, 1);
6941 else if (TREE_CODE (arg0
) == INTEGER_CST
)
6943 arg00
= build_one_cst (type
);
6948 /* We cannot generate constant 1 for fract. */
6949 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
6952 arg01
= build_one_cst (type
);
6954 if (TREE_CODE (arg1
) == MULT_EXPR
)
6956 arg10
= TREE_OPERAND (arg1
, 0);
6957 arg11
= TREE_OPERAND (arg1
, 1);
6959 else if (TREE_CODE (arg1
) == INTEGER_CST
)
6961 arg10
= build_one_cst (type
);
6962 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6963 the purpose of this canonicalization. */
6964 if (wi::neg_p (arg1
, TYPE_SIGN (TREE_TYPE (arg1
)))
6965 && negate_expr_p (arg1
)
6966 && code
== PLUS_EXPR
)
6968 arg11
= negate_expr (arg1
);
6976 /* We cannot generate constant 1 for fract. */
6977 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
6980 arg11
= build_one_cst (type
);
6984 if (operand_equal_p (arg01
, arg11
, 0))
6985 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
6986 else if (operand_equal_p (arg00
, arg10
, 0))
6987 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
6988 else if (operand_equal_p (arg00
, arg11
, 0))
6989 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
6990 else if (operand_equal_p (arg01
, arg10
, 0))
6991 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
6993 /* No identical multiplicands; see if we can find a common
6994 power-of-two factor in non-power-of-two multiplies. This
6995 can help in multi-dimensional array access. */
6996 else if (tree_fits_shwi_p (arg01
)
6997 && tree_fits_shwi_p (arg11
))
6999 HOST_WIDE_INT int01
, int11
, tmp
;
7002 int01
= tree_to_shwi (arg01
);
7003 int11
= tree_to_shwi (arg11
);
7005 /* Move min of absolute values to int11. */
7006 if (absu_hwi (int01
) < absu_hwi (int11
))
7008 tmp
= int01
, int01
= int11
, int11
= tmp
;
7009 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
7016 if (exact_log2 (absu_hwi (int11
)) > 0 && int01
% int11
== 0
7017 /* The remainder should not be a constant, otherwise we
7018 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7019 increased the number of multiplications necessary. */
7020 && TREE_CODE (arg10
) != INTEGER_CST
)
7022 alt0
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (arg00
), arg00
,
7023 build_int_cst (TREE_TYPE (arg00
),
7028 maybe_same
= alt0
, alt0
= alt1
, alt1
= maybe_same
;
7033 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7034 fold_build2_loc (loc
, code
, type
,
7035 fold_convert_loc (loc
, type
, alt0
),
7036 fold_convert_loc (loc
, type
, alt1
)),
7037 fold_convert_loc (loc
, type
, same
));
7042 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7043 specified by EXPR into the buffer PTR of length LEN bytes.
7044 Return the number of bytes placed in the buffer, or zero
7048 native_encode_int (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7050 tree type
= TREE_TYPE (expr
);
7051 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7052 int byte
, offset
, word
, words
;
7053 unsigned char value
;
7055 if ((off
== -1 && total_bytes
> len
)
7056 || off
>= total_bytes
)
7060 words
= total_bytes
/ UNITS_PER_WORD
;
7062 for (byte
= 0; byte
< total_bytes
; byte
++)
7064 int bitpos
= byte
* BITS_PER_UNIT
;
7065 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7067 value
= wi::extract_uhwi (wi::to_widest (expr
), bitpos
, BITS_PER_UNIT
);
7069 if (total_bytes
> UNITS_PER_WORD
)
7071 word
= byte
/ UNITS_PER_WORD
;
7072 if (WORDS_BIG_ENDIAN
)
7073 word
= (words
- 1) - word
;
7074 offset
= word
* UNITS_PER_WORD
;
7075 if (BYTES_BIG_ENDIAN
)
7076 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7078 offset
+= byte
% UNITS_PER_WORD
;
7081 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
7083 && offset
- off
< len
)
7084 ptr
[offset
- off
] = value
;
7086 return MIN (len
, total_bytes
- off
);
7090 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7091 specified by EXPR into the buffer PTR of length LEN bytes.
7092 Return the number of bytes placed in the buffer, or zero
7096 native_encode_fixed (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7098 tree type
= TREE_TYPE (expr
);
7099 machine_mode mode
= TYPE_MODE (type
);
7100 int total_bytes
= GET_MODE_SIZE (mode
);
7101 FIXED_VALUE_TYPE value
;
7102 tree i_value
, i_type
;
7104 if (total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7107 i_type
= lang_hooks
.types
.type_for_size (GET_MODE_BITSIZE (mode
), 1);
7109 if (NULL_TREE
== i_type
7110 || TYPE_PRECISION (i_type
) != total_bytes
)
7113 value
= TREE_FIXED_CST (expr
);
7114 i_value
= double_int_to_tree (i_type
, value
.data
);
7116 return native_encode_int (i_value
, ptr
, len
, off
);
7120 /* Subroutine of native_encode_expr. Encode the REAL_CST
7121 specified by EXPR into the buffer PTR of length LEN bytes.
7122 Return the number of bytes placed in the buffer, or zero
7126 native_encode_real (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7128 tree type
= TREE_TYPE (expr
);
7129 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7130 int byte
, offset
, word
, words
, bitpos
;
7131 unsigned char value
;
7133 /* There are always 32 bits in each long, no matter the size of
7134 the hosts long. We handle floating point representations with
7138 if ((off
== -1 && total_bytes
> len
)
7139 || off
>= total_bytes
)
7143 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7145 real_to_target (tmp
, TREE_REAL_CST_PTR (expr
), TYPE_MODE (type
));
7147 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7148 bitpos
+= BITS_PER_UNIT
)
7150 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7151 value
= (unsigned char) (tmp
[bitpos
/ 32] >> (bitpos
& 31));
7153 if (UNITS_PER_WORD
< 4)
7155 word
= byte
/ UNITS_PER_WORD
;
7156 if (WORDS_BIG_ENDIAN
)
7157 word
= (words
- 1) - word
;
7158 offset
= word
* UNITS_PER_WORD
;
7159 if (BYTES_BIG_ENDIAN
)
7160 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7162 offset
+= byte
% UNITS_PER_WORD
;
7165 offset
= BYTES_BIG_ENDIAN
? 3 - byte
: byte
;
7166 offset
= offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3);
7168 && offset
- off
< len
)
7169 ptr
[offset
- off
] = value
;
7171 return MIN (len
, total_bytes
- off
);
7174 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7175 specified by EXPR into the buffer PTR of length LEN bytes.
7176 Return the number of bytes placed in the buffer, or zero
7180 native_encode_complex (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7185 part
= TREE_REALPART (expr
);
7186 rsize
= native_encode_expr (part
, ptr
, len
, off
);
7190 part
= TREE_IMAGPART (expr
);
7192 off
= MAX (0, off
- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (part
))));
7193 isize
= native_encode_expr (part
, ptr
+rsize
, len
-rsize
, off
);
7197 return rsize
+ isize
;
7201 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7202 specified by EXPR into the buffer PTR of length LEN bytes.
7203 Return the number of bytes placed in the buffer, or zero
7207 native_encode_vector (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7214 count
= VECTOR_CST_NELTS (expr
);
7215 itype
= TREE_TYPE (TREE_TYPE (expr
));
7216 size
= GET_MODE_SIZE (TYPE_MODE (itype
));
7217 for (i
= 0; i
< count
; i
++)
7224 elem
= VECTOR_CST_ELT (expr
, i
);
7225 int res
= native_encode_expr (elem
, ptr
+offset
, len
-offset
, off
);
7226 if ((off
== -1 && res
!= size
)
7239 /* Subroutine of native_encode_expr. Encode the STRING_CST
7240 specified by EXPR into the buffer PTR of length LEN bytes.
7241 Return the number of bytes placed in the buffer, or zero
7245 native_encode_string (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7247 tree type
= TREE_TYPE (expr
);
7248 HOST_WIDE_INT total_bytes
;
7250 if (TREE_CODE (type
) != ARRAY_TYPE
7251 || TREE_CODE (TREE_TYPE (type
)) != INTEGER_TYPE
7252 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))) != BITS_PER_UNIT
7253 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type
)))
7255 total_bytes
= tree_to_shwi (TYPE_SIZE_UNIT (type
));
7256 if ((off
== -1 && total_bytes
> len
)
7257 || off
>= total_bytes
)
7261 if (TREE_STRING_LENGTH (expr
) - off
< MIN (total_bytes
, len
))
7264 if (off
< TREE_STRING_LENGTH (expr
))
7266 written
= MIN (len
, TREE_STRING_LENGTH (expr
) - off
);
7267 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, written
);
7269 memset (ptr
+ written
, 0,
7270 MIN (total_bytes
- written
, len
- written
));
7273 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, MIN (total_bytes
, len
));
7274 return MIN (total_bytes
- off
, len
);
7278 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7279 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7280 buffer PTR of length LEN bytes. If OFF is not -1 then start
7281 the encoding at byte offset OFF and encode at most LEN bytes.
7282 Return the number of bytes placed in the buffer, or zero upon failure. */
7285 native_encode_expr (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7287 /* We don't support starting at negative offset and -1 is special. */
7291 switch (TREE_CODE (expr
))
7294 return native_encode_int (expr
, ptr
, len
, off
);
7297 return native_encode_real (expr
, ptr
, len
, off
);
7300 return native_encode_fixed (expr
, ptr
, len
, off
);
7303 return native_encode_complex (expr
, ptr
, len
, off
);
7306 return native_encode_vector (expr
, ptr
, len
, off
);
7309 return native_encode_string (expr
, ptr
, len
, off
);
7317 /* Subroutine of native_interpret_expr. Interpret the contents of
7318 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7319 If the buffer cannot be interpreted, return NULL_TREE. */
7322 native_interpret_int (tree type
, const unsigned char *ptr
, int len
)
7324 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7326 if (total_bytes
> len
7327 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7330 wide_int result
= wi::from_buffer (ptr
, total_bytes
);
7332 return wide_int_to_tree (type
, result
);
7336 /* Subroutine of native_interpret_expr. Interpret the contents of
7337 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7338 If the buffer cannot be interpreted, return NULL_TREE. */
7341 native_interpret_fixed (tree type
, const unsigned char *ptr
, int len
)
7343 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7345 FIXED_VALUE_TYPE fixed_value
;
7347 if (total_bytes
> len
7348 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7351 result
= double_int::from_buffer (ptr
, total_bytes
);
7352 fixed_value
= fixed_from_double_int (result
, TYPE_MODE (type
));
7354 return build_fixed (type
, fixed_value
);
7358 /* Subroutine of native_interpret_expr. Interpret the contents of
7359 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7360 If the buffer cannot be interpreted, return NULL_TREE. */
7363 native_interpret_real (tree type
, const unsigned char *ptr
, int len
)
7365 machine_mode mode
= TYPE_MODE (type
);
7366 int total_bytes
= GET_MODE_SIZE (mode
);
7367 unsigned char value
;
7368 /* There are always 32 bits in each long, no matter the size of
7369 the hosts long. We handle floating point representations with
7374 total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7375 if (total_bytes
> len
|| total_bytes
> 24)
7377 int words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7379 memset (tmp
, 0, sizeof (tmp
));
7380 for (int bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7381 bitpos
+= BITS_PER_UNIT
)
7383 /* Both OFFSET and BYTE index within a long;
7384 bitpos indexes the whole float. */
7385 int offset
, byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7386 if (UNITS_PER_WORD
< 4)
7388 int word
= byte
/ UNITS_PER_WORD
;
7389 if (WORDS_BIG_ENDIAN
)
7390 word
= (words
- 1) - word
;
7391 offset
= word
* UNITS_PER_WORD
;
7392 if (BYTES_BIG_ENDIAN
)
7393 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7395 offset
+= byte
% UNITS_PER_WORD
;
7400 if (BYTES_BIG_ENDIAN
)
7402 /* Reverse bytes within each long, or within the entire float
7403 if it's smaller than a long (for HFmode). */
7404 offset
= MIN (3, total_bytes
- 1) - offset
;
7405 gcc_assert (offset
>= 0);
7408 value
= ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)];
7410 tmp
[bitpos
/ 32] |= (unsigned long)value
<< (bitpos
& 31);
7413 real_from_target (&r
, tmp
, mode
);
7414 return build_real (type
, r
);
7418 /* Subroutine of native_interpret_expr. Interpret the contents of
7419 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7420 If the buffer cannot be interpreted, return NULL_TREE. */
7423 native_interpret_complex (tree type
, const unsigned char *ptr
, int len
)
7425 tree etype
, rpart
, ipart
;
7428 etype
= TREE_TYPE (type
);
7429 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7432 rpart
= native_interpret_expr (etype
, ptr
, size
);
7435 ipart
= native_interpret_expr (etype
, ptr
+size
, size
);
7438 return build_complex (type
, rpart
, ipart
);
7442 /* Subroutine of native_interpret_expr. Interpret the contents of
7443 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7444 If the buffer cannot be interpreted, return NULL_TREE. */
7447 native_interpret_vector (tree type
, const unsigned char *ptr
, int len
)
7453 etype
= TREE_TYPE (type
);
7454 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7455 count
= TYPE_VECTOR_SUBPARTS (type
);
7456 if (size
* count
> len
)
7459 elements
= XALLOCAVEC (tree
, count
);
7460 for (i
= count
- 1; i
>= 0; i
--)
7462 elem
= native_interpret_expr (etype
, ptr
+(i
*size
), size
);
7467 return build_vector (type
, elements
);
7471 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7472 the buffer PTR of length LEN as a constant of type TYPE. For
7473 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7474 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7475 return NULL_TREE. */
7478 native_interpret_expr (tree type
, const unsigned char *ptr
, int len
)
7480 switch (TREE_CODE (type
))
7486 case REFERENCE_TYPE
:
7487 return native_interpret_int (type
, ptr
, len
);
7490 return native_interpret_real (type
, ptr
, len
);
7492 case FIXED_POINT_TYPE
:
7493 return native_interpret_fixed (type
, ptr
, len
);
7496 return native_interpret_complex (type
, ptr
, len
);
7499 return native_interpret_vector (type
, ptr
, len
);
7506 /* Returns true if we can interpret the contents of a native encoding
7510 can_native_interpret_type_p (tree type
)
7512 switch (TREE_CODE (type
))
7518 case REFERENCE_TYPE
:
7519 case FIXED_POINT_TYPE
:
7529 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7530 TYPE at compile-time. If we're unable to perform the conversion
7531 return NULL_TREE. */
7534 fold_view_convert_expr (tree type
, tree expr
)
7536 /* We support up to 512-bit values (for V8DFmode). */
7537 unsigned char buffer
[64];
7540 /* Check that the host and target are sane. */
7541 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
7544 len
= native_encode_expr (expr
, buffer
, sizeof (buffer
));
7548 return native_interpret_expr (type
, buffer
, len
);
7551 /* Build an expression for the address of T. Folds away INDIRECT_REF
7552 to avoid confusing the gimplify process. */
7555 build_fold_addr_expr_with_type_loc (location_t loc
, tree t
, tree ptrtype
)
7557 /* The size of the object is not relevant when talking about its address. */
7558 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
7559 t
= TREE_OPERAND (t
, 0);
7561 if (TREE_CODE (t
) == INDIRECT_REF
)
7563 t
= TREE_OPERAND (t
, 0);
7565 if (TREE_TYPE (t
) != ptrtype
)
7566 t
= build1_loc (loc
, NOP_EXPR
, ptrtype
, t
);
7568 else if (TREE_CODE (t
) == MEM_REF
7569 && integer_zerop (TREE_OPERAND (t
, 1)))
7570 return TREE_OPERAND (t
, 0);
7571 else if (TREE_CODE (t
) == MEM_REF
7572 && TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
7573 return fold_binary (POINTER_PLUS_EXPR
, ptrtype
,
7574 TREE_OPERAND (t
, 0),
7575 convert_to_ptrofftype (TREE_OPERAND (t
, 1)));
7576 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
7578 t
= build_fold_addr_expr_loc (loc
, TREE_OPERAND (t
, 0));
7580 if (TREE_TYPE (t
) != ptrtype
)
7581 t
= fold_convert_loc (loc
, ptrtype
, t
);
7584 t
= build1_loc (loc
, ADDR_EXPR
, ptrtype
, t
);
7589 /* Build an expression for the address of T. */
7592 build_fold_addr_expr_loc (location_t loc
, tree t
)
7594 tree ptrtype
= build_pointer_type (TREE_TYPE (t
));
7596 return build_fold_addr_expr_with_type_loc (loc
, t
, ptrtype
);
7599 /* Fold a unary expression of code CODE and type TYPE with operand
7600 OP0. Return the folded expression if folding is successful.
7601 Otherwise, return NULL_TREE. */
7604 fold_unary_loc (location_t loc
, enum tree_code code
, tree type
, tree op0
)
7608 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
7610 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
7611 && TREE_CODE_LENGTH (code
) == 1);
7616 if (CONVERT_EXPR_CODE_P (code
)
7617 || code
== FLOAT_EXPR
|| code
== ABS_EXPR
|| code
== NEGATE_EXPR
)
7619 /* Don't use STRIP_NOPS, because signedness of argument type
7621 STRIP_SIGN_NOPS (arg0
);
7625 /* Strip any conversions that don't change the mode. This
7626 is safe for every expression, except for a comparison
7627 expression because its signedness is derived from its
7630 Note that this is done as an internal manipulation within
7631 the constant folder, in order to find the simplest
7632 representation of the arguments so that their form can be
7633 studied. In any cases, the appropriate type conversions
7634 should be put back in the tree that will get out of the
7639 if (CONSTANT_CLASS_P (arg0
))
7641 tree tem
= const_unop (code
, type
, arg0
);
7644 if (TREE_TYPE (tem
) != type
)
7645 tem
= fold_convert_loc (loc
, type
, tem
);
7651 tem
= generic_simplify (loc
, code
, type
, op0
);
7655 if (TREE_CODE_CLASS (code
) == tcc_unary
)
7657 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
7658 return build2 (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7659 fold_build1_loc (loc
, code
, type
,
7660 fold_convert_loc (loc
, TREE_TYPE (op0
),
7661 TREE_OPERAND (arg0
, 1))));
7662 else if (TREE_CODE (arg0
) == COND_EXPR
)
7664 tree arg01
= TREE_OPERAND (arg0
, 1);
7665 tree arg02
= TREE_OPERAND (arg0
, 2);
7666 if (! VOID_TYPE_P (TREE_TYPE (arg01
)))
7667 arg01
= fold_build1_loc (loc
, code
, type
,
7668 fold_convert_loc (loc
,
7669 TREE_TYPE (op0
), arg01
));
7670 if (! VOID_TYPE_P (TREE_TYPE (arg02
)))
7671 arg02
= fold_build1_loc (loc
, code
, type
,
7672 fold_convert_loc (loc
,
7673 TREE_TYPE (op0
), arg02
));
7674 tem
= fold_build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7677 /* If this was a conversion, and all we did was to move into
7678 inside the COND_EXPR, bring it back out. But leave it if
7679 it is a conversion from integer to integer and the
7680 result precision is no wider than a word since such a
7681 conversion is cheap and may be optimized away by combine,
7682 while it couldn't if it were outside the COND_EXPR. Then return
7683 so we don't get into an infinite recursion loop taking the
7684 conversion out and then back in. */
7686 if ((CONVERT_EXPR_CODE_P (code
)
7687 || code
== NON_LVALUE_EXPR
)
7688 && TREE_CODE (tem
) == COND_EXPR
7689 && TREE_CODE (TREE_OPERAND (tem
, 1)) == code
7690 && TREE_CODE (TREE_OPERAND (tem
, 2)) == code
7691 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 1))
7692 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 2))
7693 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))
7694 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 2), 0)))
7695 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7697 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))))
7698 && TYPE_PRECISION (TREE_TYPE (tem
)) <= BITS_PER_WORD
)
7699 || flag_syntax_only
))
7700 tem
= build1_loc (loc
, code
, type
,
7702 TREE_TYPE (TREE_OPERAND
7703 (TREE_OPERAND (tem
, 1), 0)),
7704 TREE_OPERAND (tem
, 0),
7705 TREE_OPERAND (TREE_OPERAND (tem
, 1), 0),
7706 TREE_OPERAND (TREE_OPERAND (tem
, 2),
7714 case NON_LVALUE_EXPR
:
7715 if (!maybe_lvalue_p (op0
))
7716 return fold_convert_loc (loc
, type
, op0
);
7721 case FIX_TRUNC_EXPR
:
7722 if (COMPARISON_CLASS_P (op0
))
7724 /* If we have (type) (a CMP b) and type is an integral type, return
7725 new expression involving the new type. Canonicalize
7726 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7728 Do not fold the result as that would not simplify further, also
7729 folding again results in recursions. */
7730 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
7731 return build2_loc (loc
, TREE_CODE (op0
), type
,
7732 TREE_OPERAND (op0
, 0),
7733 TREE_OPERAND (op0
, 1));
7734 else if (!INTEGRAL_TYPE_P (type
) && !VOID_TYPE_P (type
)
7735 && TREE_CODE (type
) != VECTOR_TYPE
)
7736 return build3_loc (loc
, COND_EXPR
, type
, op0
,
7737 constant_boolean_node (true, type
),
7738 constant_boolean_node (false, type
));
7741 /* Handle (T *)&A.B.C for A being of type T and B and C
7742 living at offset zero. This occurs frequently in
7743 C++ upcasting and then accessing the base. */
7744 if (TREE_CODE (op0
) == ADDR_EXPR
7745 && POINTER_TYPE_P (type
)
7746 && handled_component_p (TREE_OPERAND (op0
, 0)))
7748 HOST_WIDE_INT bitsize
, bitpos
;
7751 int unsignedp
, reversep
, volatilep
;
7753 = get_inner_reference (TREE_OPERAND (op0
, 0), &bitsize
, &bitpos
,
7754 &offset
, &mode
, &unsignedp
, &reversep
,
7756 /* If the reference was to a (constant) zero offset, we can use
7757 the address of the base if it has the same base type
7758 as the result type and the pointer type is unqualified. */
7759 if (! offset
&& bitpos
== 0
7760 && (TYPE_MAIN_VARIANT (TREE_TYPE (type
))
7761 == TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
7762 && TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
7763 return fold_convert_loc (loc
, type
,
7764 build_fold_addr_expr_loc (loc
, base
));
7767 if (TREE_CODE (op0
) == MODIFY_EXPR
7768 && TREE_CONSTANT (TREE_OPERAND (op0
, 1))
7769 /* Detect assigning a bitfield. */
7770 && !(TREE_CODE (TREE_OPERAND (op0
, 0)) == COMPONENT_REF
7772 (TREE_OPERAND (TREE_OPERAND (op0
, 0), 1))))
7774 /* Don't leave an assignment inside a conversion
7775 unless assigning a bitfield. */
7776 tem
= fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 1));
7777 /* First do the assignment, then return converted constant. */
7778 tem
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (tem
), op0
, tem
);
7779 TREE_NO_WARNING (tem
) = 1;
7780 TREE_USED (tem
) = 1;
7784 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7785 constants (if x has signed type, the sign bit cannot be set
7786 in c). This folds extension into the BIT_AND_EXPR.
7787 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7788 very likely don't have maximal range for their precision and this
7789 transformation effectively doesn't preserve non-maximal ranges. */
7790 if (TREE_CODE (type
) == INTEGER_TYPE
7791 && TREE_CODE (op0
) == BIT_AND_EXPR
7792 && TREE_CODE (TREE_OPERAND (op0
, 1)) == INTEGER_CST
)
7794 tree and_expr
= op0
;
7795 tree and0
= TREE_OPERAND (and_expr
, 0);
7796 tree and1
= TREE_OPERAND (and_expr
, 1);
7799 if (TYPE_UNSIGNED (TREE_TYPE (and_expr
))
7800 || (TYPE_PRECISION (type
)
7801 <= TYPE_PRECISION (TREE_TYPE (and_expr
))))
7803 else if (TYPE_PRECISION (TREE_TYPE (and1
))
7804 <= HOST_BITS_PER_WIDE_INT
7805 && tree_fits_uhwi_p (and1
))
7807 unsigned HOST_WIDE_INT cst
;
7809 cst
= tree_to_uhwi (and1
);
7810 cst
&= HOST_WIDE_INT_M1U
7811 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
7812 change
= (cst
== 0);
7814 && !flag_syntax_only
7815 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0
)))
7818 tree uns
= unsigned_type_for (TREE_TYPE (and0
));
7819 and0
= fold_convert_loc (loc
, uns
, and0
);
7820 and1
= fold_convert_loc (loc
, uns
, and1
);
7825 tem
= force_fit_type (type
, wi::to_widest (and1
), 0,
7826 TREE_OVERFLOW (and1
));
7827 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
7828 fold_convert_loc (loc
, type
, and0
), tem
);
7832 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7833 cast (T1)X will fold away. We assume that this happens when X itself
7835 if (POINTER_TYPE_P (type
)
7836 && TREE_CODE (arg0
) == POINTER_PLUS_EXPR
7837 && CONVERT_EXPR_P (TREE_OPERAND (arg0
, 0)))
7839 tree arg00
= TREE_OPERAND (arg0
, 0);
7840 tree arg01
= TREE_OPERAND (arg0
, 1);
7842 return fold_build_pointer_plus_loc
7843 (loc
, fold_convert_loc (loc
, type
, arg00
), arg01
);
7846 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7847 of the same precision, and X is an integer type not narrower than
7848 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7849 if (INTEGRAL_TYPE_P (type
)
7850 && TREE_CODE (op0
) == BIT_NOT_EXPR
7851 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7852 && CONVERT_EXPR_P (TREE_OPERAND (op0
, 0))
7853 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
7855 tem
= TREE_OPERAND (TREE_OPERAND (op0
, 0), 0);
7856 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7857 && TYPE_PRECISION (type
) <= TYPE_PRECISION (TREE_TYPE (tem
)))
7858 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
7859 fold_convert_loc (loc
, type
, tem
));
7862 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7863 type of X and Y (integer types only). */
7864 if (INTEGRAL_TYPE_P (type
)
7865 && TREE_CODE (op0
) == MULT_EXPR
7866 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7867 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7869 /* Be careful not to introduce new overflows. */
7871 if (TYPE_OVERFLOW_WRAPS (type
))
7874 mult_type
= unsigned_type_for (type
);
7876 if (TYPE_PRECISION (mult_type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7878 tem
= fold_build2_loc (loc
, MULT_EXPR
, mult_type
,
7879 fold_convert_loc (loc
, mult_type
,
7880 TREE_OPERAND (op0
, 0)),
7881 fold_convert_loc (loc
, mult_type
,
7882 TREE_OPERAND (op0
, 1)));
7883 return fold_convert_loc (loc
, type
, tem
);
7889 case VIEW_CONVERT_EXPR
:
7890 if (TREE_CODE (op0
) == MEM_REF
)
7892 tem
= fold_build2_loc (loc
, MEM_REF
, type
,
7893 TREE_OPERAND (op0
, 0), TREE_OPERAND (op0
, 1));
7894 REF_REVERSE_STORAGE_ORDER (tem
) = REF_REVERSE_STORAGE_ORDER (op0
);
7901 tem
= fold_negate_expr (loc
, arg0
);
7903 return fold_convert_loc (loc
, type
, tem
);
7907 /* Convert fabs((double)float) into (double)fabsf(float). */
7908 if (TREE_CODE (arg0
) == NOP_EXPR
7909 && TREE_CODE (type
) == REAL_TYPE
)
7911 tree targ0
= strip_float_extensions (arg0
);
7913 return fold_convert_loc (loc
, type
,
7914 fold_build1_loc (loc
, ABS_EXPR
,
7921 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
7922 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
7923 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
7924 fold_convert_loc (loc
, type
,
7925 TREE_OPERAND (arg0
, 0)))))
7926 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, tem
,
7927 fold_convert_loc (loc
, type
,
7928 TREE_OPERAND (arg0
, 1)));
7929 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
7930 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
7931 fold_convert_loc (loc
, type
,
7932 TREE_OPERAND (arg0
, 1)))))
7933 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
7934 fold_convert_loc (loc
, type
,
7935 TREE_OPERAND (arg0
, 0)), tem
);
7939 case TRUTH_NOT_EXPR
:
7940 /* Note that the operand of this must be an int
7941 and its values must be 0 or 1.
7942 ("true" is a fixed value perhaps depending on the language,
7943 but we don't handle values other than 1 correctly yet.) */
7944 tem
= fold_truth_not_expr (loc
, arg0
);
7947 return fold_convert_loc (loc
, type
, tem
);
7950 /* Fold *&X to X if X is an lvalue. */
7951 if (TREE_CODE (op0
) == ADDR_EXPR
)
7953 tree op00
= TREE_OPERAND (op0
, 0);
7954 if ((TREE_CODE (op00
) == VAR_DECL
7955 || TREE_CODE (op00
) == PARM_DECL
7956 || TREE_CODE (op00
) == RESULT_DECL
)
7957 && !TREE_READONLY (op00
))
7964 } /* switch (code) */
7968 /* If the operation was a conversion do _not_ mark a resulting constant
7969 with TREE_OVERFLOW if the original constant was not. These conversions
7970 have implementation defined behavior and retaining the TREE_OVERFLOW
7971 flag here would confuse later passes such as VRP. */
7973 fold_unary_ignore_overflow_loc (location_t loc
, enum tree_code code
,
7974 tree type
, tree op0
)
7976 tree res
= fold_unary_loc (loc
, code
, type
, op0
);
7978 && TREE_CODE (res
) == INTEGER_CST
7979 && TREE_CODE (op0
) == INTEGER_CST
7980 && CONVERT_EXPR_CODE_P (code
))
7981 TREE_OVERFLOW (res
) = TREE_OVERFLOW (op0
);
7986 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
7987 operands OP0 and OP1. LOC is the location of the resulting expression.
7988 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
7989 Return the folded expression if folding is successful. Otherwise,
7990 return NULL_TREE. */
7992 fold_truth_andor (location_t loc
, enum tree_code code
, tree type
,
7993 tree arg0
, tree arg1
, tree op0
, tree op1
)
7997 /* We only do these simplifications if we are optimizing. */
8001 /* Check for things like (A || B) && (A || C). We can convert this
8002 to A || (B && C). Note that either operator can be any of the four
8003 truth and/or operations and the transformation will still be
8004 valid. Also note that we only care about order for the
8005 ANDIF and ORIF operators. If B contains side effects, this
8006 might change the truth-value of A. */
8007 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8008 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
8009 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
8010 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
8011 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
8012 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
8014 tree a00
= TREE_OPERAND (arg0
, 0);
8015 tree a01
= TREE_OPERAND (arg0
, 1);
8016 tree a10
= TREE_OPERAND (arg1
, 0);
8017 tree a11
= TREE_OPERAND (arg1
, 1);
8018 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
8019 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
8020 && (code
== TRUTH_AND_EXPR
8021 || code
== TRUTH_OR_EXPR
));
8023 if (operand_equal_p (a00
, a10
, 0))
8024 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8025 fold_build2_loc (loc
, code
, type
, a01
, a11
));
8026 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
8027 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8028 fold_build2_loc (loc
, code
, type
, a01
, a10
));
8029 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
8030 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a01
,
8031 fold_build2_loc (loc
, code
, type
, a00
, a11
));
8033 /* This case if tricky because we must either have commutative
8034 operators or else A10 must not have side-effects. */
8036 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
8037 && operand_equal_p (a01
, a11
, 0))
8038 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
8039 fold_build2_loc (loc
, code
, type
, a00
, a10
),
8043 /* See if we can build a range comparison. */
8044 if (0 != (tem
= fold_range_test (loc
, code
, type
, op0
, op1
)))
8047 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
)
8048 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
))
8050 tem
= merge_truthop_with_opposite_arm (loc
, arg0
, arg1
, true);
8052 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
8055 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ORIF_EXPR
)
8056 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ANDIF_EXPR
))
8058 tem
= merge_truthop_with_opposite_arm (loc
, arg1
, arg0
, false);
8060 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
8063 /* Check for the possibility of merging component references. If our
8064 lhs is another similar operation, try to merge its rhs with our
8065 rhs. Then try to merge our lhs and rhs. */
8066 if (TREE_CODE (arg0
) == code
8067 && 0 != (tem
= fold_truth_andor_1 (loc
, code
, type
,
8068 TREE_OPERAND (arg0
, 1), arg1
)))
8069 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
8071 if ((tem
= fold_truth_andor_1 (loc
, code
, type
, arg0
, arg1
)) != 0)
8074 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8075 && (code
== TRUTH_AND_EXPR
8076 || code
== TRUTH_ANDIF_EXPR
8077 || code
== TRUTH_OR_EXPR
8078 || code
== TRUTH_ORIF_EXPR
))
8080 enum tree_code ncode
, icode
;
8082 ncode
= (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_AND_EXPR
)
8083 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
;
8084 icode
= ncode
== TRUTH_AND_EXPR
? TRUTH_ANDIF_EXPR
: TRUTH_ORIF_EXPR
;
8086 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8087 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8088 We don't want to pack more than two leafs to a non-IF AND/OR
8090 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8091 equal to IF-CODE, then we don't want to add right-hand operand.
8092 If the inner right-hand side of left-hand operand has
8093 side-effects, or isn't simple, then we can't add to it,
8094 as otherwise we might destroy if-sequence. */
8095 if (TREE_CODE (arg0
) == icode
8096 && simple_operand_p_2 (arg1
)
8097 /* Needed for sequence points to handle trappings, and
8099 && simple_operand_p_2 (TREE_OPERAND (arg0
, 1)))
8101 tem
= fold_build2_loc (loc
, ncode
, type
, TREE_OPERAND (arg0
, 1),
8103 return fold_build2_loc (loc
, icode
, type
, TREE_OPERAND (arg0
, 0),
8106 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8107 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8108 else if (TREE_CODE (arg1
) == icode
8109 && simple_operand_p_2 (arg0
)
8110 /* Needed for sequence points to handle trappings, and
8112 && simple_operand_p_2 (TREE_OPERAND (arg1
, 0)))
8114 tem
= fold_build2_loc (loc
, ncode
, type
,
8115 arg0
, TREE_OPERAND (arg1
, 0));
8116 return fold_build2_loc (loc
, icode
, type
, tem
,
8117 TREE_OPERAND (arg1
, 1));
8119 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8121 For sequence point consistancy, we need to check for trapping,
8122 and side-effects. */
8123 else if (code
== icode
&& simple_operand_p_2 (arg0
)
8124 && simple_operand_p_2 (arg1
))
8125 return fold_build2_loc (loc
, ncode
, type
, arg0
, arg1
);
8131 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8132 by changing CODE to reduce the magnitude of constants involved in
8133 ARG0 of the comparison.
8134 Returns a canonicalized comparison tree if a simplification was
8135 possible, otherwise returns NULL_TREE.
8136 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8137 valid if signed overflow is undefined. */
8140 maybe_canonicalize_comparison_1 (location_t loc
, enum tree_code code
, tree type
,
8141 tree arg0
, tree arg1
,
8142 bool *strict_overflow_p
)
8144 enum tree_code code0
= TREE_CODE (arg0
);
8145 tree t
, cst0
= NULL_TREE
;
8148 /* Match A +- CST code arg1. We can change this only if overflow
8150 if (!((ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8151 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8152 /* In principle pointers also have undefined overflow behavior,
8153 but that causes problems elsewhere. */
8154 && !POINTER_TYPE_P (TREE_TYPE (arg0
))
8155 && (code0
== MINUS_EXPR
8156 || code0
== PLUS_EXPR
)
8157 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
))
8160 /* Identify the constant in arg0 and its sign. */
8161 cst0
= TREE_OPERAND (arg0
, 1);
8162 sgn0
= tree_int_cst_sgn (cst0
);
8164 /* Overflowed constants and zero will cause problems. */
8165 if (integer_zerop (cst0
)
8166 || TREE_OVERFLOW (cst0
))
8169 /* See if we can reduce the magnitude of the constant in
8170 arg0 by changing the comparison code. */
8171 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8173 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8175 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8176 else if (code
== GT_EXPR
8177 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8179 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8180 else if (code
== LE_EXPR
8181 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8183 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8184 else if (code
== GE_EXPR
8185 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8189 *strict_overflow_p
= true;
8191 /* Now build the constant reduced in magnitude. But not if that
8192 would produce one outside of its types range. */
8193 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0
))
8195 && TYPE_MIN_VALUE (TREE_TYPE (cst0
))
8196 && tree_int_cst_equal (cst0
, TYPE_MIN_VALUE (TREE_TYPE (cst0
))))
8198 && TYPE_MAX_VALUE (TREE_TYPE (cst0
))
8199 && tree_int_cst_equal (cst0
, TYPE_MAX_VALUE (TREE_TYPE (cst0
))))))
8202 t
= int_const_binop (sgn0
== -1 ? PLUS_EXPR
: MINUS_EXPR
,
8203 cst0
, build_int_cst (TREE_TYPE (cst0
), 1));
8204 t
= fold_build2_loc (loc
, code0
, TREE_TYPE (arg0
), TREE_OPERAND (arg0
, 0), t
);
8205 t
= fold_convert (TREE_TYPE (arg1
), t
);
8207 return fold_build2_loc (loc
, code
, type
, t
, arg1
);
8210 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8211 overflow further. Try to decrease the magnitude of constants involved
8212 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8213 and put sole constants at the second argument position.
8214 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8217 maybe_canonicalize_comparison (location_t loc
, enum tree_code code
, tree type
,
8218 tree arg0
, tree arg1
)
8221 bool strict_overflow_p
;
8222 const char * const warnmsg
= G_("assuming signed overflow does not occur "
8223 "when reducing constant in comparison");
8225 /* Try canonicalization by simplifying arg0. */
8226 strict_overflow_p
= false;
8227 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg0
, arg1
,
8228 &strict_overflow_p
);
8231 if (strict_overflow_p
)
8232 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8236 /* Try canonicalization by simplifying arg1 using the swapped
8238 code
= swap_tree_comparison (code
);
8239 strict_overflow_p
= false;
8240 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg1
, arg0
,
8241 &strict_overflow_p
);
8242 if (t
&& strict_overflow_p
)
8243 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8247 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8248 space. This is used to avoid issuing overflow warnings for
8249 expressions like &p->x which can not wrap. */
8252 pointer_may_wrap_p (tree base
, tree offset
, HOST_WIDE_INT bitpos
)
8254 if (!POINTER_TYPE_P (TREE_TYPE (base
)))
8261 int precision
= TYPE_PRECISION (TREE_TYPE (base
));
8262 if (offset
== NULL_TREE
)
8263 wi_offset
= wi::zero (precision
);
8264 else if (TREE_CODE (offset
) != INTEGER_CST
|| TREE_OVERFLOW (offset
))
8270 wide_int units
= wi::shwi (bitpos
/ BITS_PER_UNIT
, precision
);
8271 wide_int total
= wi::add (wi_offset
, units
, UNSIGNED
, &overflow
);
8275 if (!wi::fits_uhwi_p (total
))
8278 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (TREE_TYPE (base
)));
8282 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8284 if (TREE_CODE (base
) == ADDR_EXPR
)
8286 HOST_WIDE_INT base_size
;
8288 base_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base
, 0)));
8289 if (base_size
> 0 && size
< base_size
)
8293 return total
.to_uhwi () > (unsigned HOST_WIDE_INT
) size
;
8296 /* Subroutine of fold_binary. This routine performs all of the
8297 transformations that are common to the equality/inequality
8298 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8299 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8300 fold_binary should call fold_binary. Fold a comparison with
8301 tree code CODE and type TYPE with operands OP0 and OP1. Return
8302 the folded comparison or NULL_TREE. */
8305 fold_comparison (location_t loc
, enum tree_code code
, tree type
,
8308 const bool equality_code
= (code
== EQ_EXPR
|| code
== NE_EXPR
);
8309 tree arg0
, arg1
, tem
;
8314 STRIP_SIGN_NOPS (arg0
);
8315 STRIP_SIGN_NOPS (arg1
);
8317 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8318 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8320 || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8321 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))))
8322 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8323 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
8324 && TREE_CODE (arg1
) == INTEGER_CST
8325 && !TREE_OVERFLOW (arg1
))
8327 const enum tree_code
8328 reverse_op
= TREE_CODE (arg0
) == PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
;
8329 tree const1
= TREE_OPERAND (arg0
, 1);
8330 tree const2
= fold_convert_loc (loc
, TREE_TYPE (const1
), arg1
);
8331 tree variable
= TREE_OPERAND (arg0
, 0);
8332 tree new_const
= int_const_binop (reverse_op
, const2
, const1
);
8334 /* If the constant operation overflowed this can be
8335 simplified as a comparison against INT_MAX/INT_MIN. */
8336 if (TREE_OVERFLOW (new_const
)
8337 && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
8339 int const1_sgn
= tree_int_cst_sgn (const1
);
8340 enum tree_code code2
= code
;
8342 /* Get the sign of the constant on the lhs if the
8343 operation were VARIABLE + CONST1. */
8344 if (TREE_CODE (arg0
) == MINUS_EXPR
)
8345 const1_sgn
= -const1_sgn
;
8347 /* The sign of the constant determines if we overflowed
8348 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8349 Canonicalize to the INT_MIN overflow by swapping the comparison
8351 if (const1_sgn
== -1)
8352 code2
= swap_tree_comparison (code
);
8354 /* We now can look at the canonicalized case
8355 VARIABLE + 1 CODE2 INT_MIN
8356 and decide on the result. */
8363 omit_one_operand_loc (loc
, type
, boolean_false_node
, variable
);
8369 omit_one_operand_loc (loc
, type
, boolean_true_node
, variable
);
8378 fold_overflow_warning ("assuming signed overflow does not occur "
8379 "when changing X +- C1 cmp C2 to "
8381 WARN_STRICT_OVERFLOW_COMPARISON
);
8382 return fold_build2_loc (loc
, code
, type
, variable
, new_const
);
8386 /* For comparisons of pointers we can decompose it to a compile time
8387 comparison of the base objects and the offsets into the object.
8388 This requires at least one operand being an ADDR_EXPR or a
8389 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8390 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
8391 && (TREE_CODE (arg0
) == ADDR_EXPR
8392 || TREE_CODE (arg1
) == ADDR_EXPR
8393 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8394 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
8396 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
8397 HOST_WIDE_INT bitsize
, bitpos0
= 0, bitpos1
= 0;
8399 int volatilep
, reversep
, unsignedp
;
8400 bool indirect_base0
= false, indirect_base1
= false;
8402 /* Get base and offset for the access. Strip ADDR_EXPR for
8403 get_inner_reference, but put it back by stripping INDIRECT_REF
8404 off the base object if possible. indirect_baseN will be true
8405 if baseN is not an address but refers to the object itself. */
8407 if (TREE_CODE (arg0
) == ADDR_EXPR
)
8410 = get_inner_reference (TREE_OPERAND (arg0
, 0),
8411 &bitsize
, &bitpos0
, &offset0
, &mode
,
8412 &unsignedp
, &reversep
, &volatilep
, false);
8413 if (TREE_CODE (base0
) == INDIRECT_REF
)
8414 base0
= TREE_OPERAND (base0
, 0);
8416 indirect_base0
= true;
8418 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
8420 base0
= TREE_OPERAND (arg0
, 0);
8421 STRIP_SIGN_NOPS (base0
);
8422 if (TREE_CODE (base0
) == ADDR_EXPR
)
8425 = get_inner_reference (TREE_OPERAND (base0
, 0),
8426 &bitsize
, &bitpos0
, &offset0
, &mode
,
8427 &unsignedp
, &reversep
, &volatilep
,
8429 if (TREE_CODE (base0
) == INDIRECT_REF
)
8430 base0
= TREE_OPERAND (base0
, 0);
8432 indirect_base0
= true;
8434 if (offset0
== NULL_TREE
|| integer_zerop (offset0
))
8435 offset0
= TREE_OPERAND (arg0
, 1);
8437 offset0
= size_binop (PLUS_EXPR
, offset0
,
8438 TREE_OPERAND (arg0
, 1));
8439 if (TREE_CODE (offset0
) == INTEGER_CST
)
8441 offset_int tem
= wi::sext (wi::to_offset (offset0
),
8442 TYPE_PRECISION (sizetype
));
8443 tem
= wi::lshift (tem
, LOG2_BITS_PER_UNIT
);
8445 if (wi::fits_shwi_p (tem
))
8447 bitpos0
= tem
.to_shwi ();
8448 offset0
= NULL_TREE
;
8454 if (TREE_CODE (arg1
) == ADDR_EXPR
)
8457 = get_inner_reference (TREE_OPERAND (arg1
, 0),
8458 &bitsize
, &bitpos1
, &offset1
, &mode
,
8459 &unsignedp
, &reversep
, &volatilep
, false);
8460 if (TREE_CODE (base1
) == INDIRECT_REF
)
8461 base1
= TREE_OPERAND (base1
, 0);
8463 indirect_base1
= true;
8465 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
8467 base1
= TREE_OPERAND (arg1
, 0);
8468 STRIP_SIGN_NOPS (base1
);
8469 if (TREE_CODE (base1
) == ADDR_EXPR
)
8472 = get_inner_reference (TREE_OPERAND (base1
, 0),
8473 &bitsize
, &bitpos1
, &offset1
, &mode
,
8474 &unsignedp
, &reversep
, &volatilep
,
8476 if (TREE_CODE (base1
) == INDIRECT_REF
)
8477 base1
= TREE_OPERAND (base1
, 0);
8479 indirect_base1
= true;
8481 if (offset1
== NULL_TREE
|| integer_zerop (offset1
))
8482 offset1
= TREE_OPERAND (arg1
, 1);
8484 offset1
= size_binop (PLUS_EXPR
, offset1
,
8485 TREE_OPERAND (arg1
, 1));
8486 if (TREE_CODE (offset1
) == INTEGER_CST
)
8488 offset_int tem
= wi::sext (wi::to_offset (offset1
),
8489 TYPE_PRECISION (sizetype
));
8490 tem
= wi::lshift (tem
, LOG2_BITS_PER_UNIT
);
8492 if (wi::fits_shwi_p (tem
))
8494 bitpos1
= tem
.to_shwi ();
8495 offset1
= NULL_TREE
;
8500 /* If we have equivalent bases we might be able to simplify. */
8501 if (indirect_base0
== indirect_base1
8502 && operand_equal_p (base0
, base1
,
8503 indirect_base0
? OEP_ADDRESS_OF
: 0))
8505 /* We can fold this expression to a constant if the non-constant
8506 offset parts are equal. */
8507 if ((offset0
== offset1
8508 || (offset0
&& offset1
8509 && operand_equal_p (offset0
, offset1
, 0)))
8512 || (indirect_base0
&& DECL_P (base0
))
8513 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8517 && bitpos0
!= bitpos1
8518 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8519 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8520 fold_overflow_warning (("assuming pointer wraparound does not "
8521 "occur when comparing P +- C1 with "
8523 WARN_STRICT_OVERFLOW_CONDITIONAL
);
8528 return constant_boolean_node (bitpos0
== bitpos1
, type
);
8530 return constant_boolean_node (bitpos0
!= bitpos1
, type
);
8532 return constant_boolean_node (bitpos0
< bitpos1
, type
);
8534 return constant_boolean_node (bitpos0
<= bitpos1
, type
);
8536 return constant_boolean_node (bitpos0
>= bitpos1
, type
);
8538 return constant_boolean_node (bitpos0
> bitpos1
, type
);
8542 /* We can simplify the comparison to a comparison of the variable
8543 offset parts if the constant offset parts are equal.
8544 Be careful to use signed sizetype here because otherwise we
8545 mess with array offsets in the wrong way. This is possible
8546 because pointer arithmetic is restricted to retain within an
8547 object and overflow on pointer differences is undefined as of
8548 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8549 else if (bitpos0
== bitpos1
8551 || (indirect_base0
&& DECL_P (base0
))
8552 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8554 /* By converting to signed sizetype we cover middle-end pointer
8555 arithmetic which operates on unsigned pointer types of size
8556 type size and ARRAY_REF offsets which are properly sign or
8557 zero extended from their type in case it is narrower than
8559 if (offset0
== NULL_TREE
)
8560 offset0
= build_int_cst (ssizetype
, 0);
8562 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
8563 if (offset1
== NULL_TREE
)
8564 offset1
= build_int_cst (ssizetype
, 0);
8566 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
8569 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8570 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8571 fold_overflow_warning (("assuming pointer wraparound does not "
8572 "occur when comparing P +- C1 with "
8574 WARN_STRICT_OVERFLOW_COMPARISON
);
8576 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
8579 /* For equal offsets we can simplify to a comparison of the
8581 else if (bitpos0
== bitpos1
8583 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
8585 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
8586 && ((offset0
== offset1
)
8587 || (offset0
&& offset1
8588 && operand_equal_p (offset0
, offset1
, 0))))
8591 base0
= build_fold_addr_expr_loc (loc
, base0
);
8593 base1
= build_fold_addr_expr_loc (loc
, base1
);
8594 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
8598 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8599 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8600 the resulting offset is smaller in absolute value than the
8601 original one and has the same sign. */
8602 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8603 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
8604 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8605 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8606 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
8607 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
8608 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
8609 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
8611 tree const1
= TREE_OPERAND (arg0
, 1);
8612 tree const2
= TREE_OPERAND (arg1
, 1);
8613 tree variable1
= TREE_OPERAND (arg0
, 0);
8614 tree variable2
= TREE_OPERAND (arg1
, 0);
8616 const char * const warnmsg
= G_("assuming signed overflow does not "
8617 "occur when combining constants around "
8620 /* Put the constant on the side where it doesn't overflow and is
8621 of lower absolute value and of same sign than before. */
8622 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8623 ? MINUS_EXPR
: PLUS_EXPR
,
8625 if (!TREE_OVERFLOW (cst
)
8626 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
)
8627 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const2
))
8629 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8630 return fold_build2_loc (loc
, code
, type
,
8632 fold_build2_loc (loc
, TREE_CODE (arg1
),
8637 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8638 ? MINUS_EXPR
: PLUS_EXPR
,
8640 if (!TREE_OVERFLOW (cst
)
8641 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
)
8642 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const1
))
8644 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8645 return fold_build2_loc (loc
, code
, type
,
8646 fold_build2_loc (loc
, TREE_CODE (arg0
),
8653 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
8657 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8658 constant, we can simplify it. */
8659 if (TREE_CODE (arg1
) == INTEGER_CST
8660 && (TREE_CODE (arg0
) == MIN_EXPR
8661 || TREE_CODE (arg0
) == MAX_EXPR
)
8662 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
8664 tem
= optimize_minmax_comparison (loc
, code
, type
, op0
, op1
);
8669 /* If we are comparing an expression that just has comparisons
8670 of two integer values, arithmetic expressions of those comparisons,
8671 and constants, we can simplify it. There are only three cases
8672 to check: the two values can either be equal, the first can be
8673 greater, or the second can be greater. Fold the expression for
8674 those three values. Since each value must be 0 or 1, we have
8675 eight possibilities, each of which corresponds to the constant 0
8676 or 1 or one of the six possible comparisons.
8678 This handles common cases like (a > b) == 0 but also handles
8679 expressions like ((x > y) - (y > x)) > 0, which supposedly
8680 occur in macroized code. */
8682 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
8684 tree cval1
= 0, cval2
= 0;
8687 if (twoval_comparison_p (arg0
, &cval1
, &cval2
, &save_p
)
8688 /* Don't handle degenerate cases here; they should already
8689 have been handled anyway. */
8690 && cval1
!= 0 && cval2
!= 0
8691 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
8692 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
8693 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
8694 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
8695 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
8696 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
8697 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
8699 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
8700 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
8702 /* We can't just pass T to eval_subst in case cval1 or cval2
8703 was the same as ARG1. */
8706 = fold_build2_loc (loc
, code
, type
,
8707 eval_subst (loc
, arg0
, cval1
, maxval
,
8711 = fold_build2_loc (loc
, code
, type
,
8712 eval_subst (loc
, arg0
, cval1
, maxval
,
8716 = fold_build2_loc (loc
, code
, type
,
8717 eval_subst (loc
, arg0
, cval1
, minval
,
8721 /* All three of these results should be 0 or 1. Confirm they are.
8722 Then use those values to select the proper code to use. */
8724 if (TREE_CODE (high_result
) == INTEGER_CST
8725 && TREE_CODE (equal_result
) == INTEGER_CST
8726 && TREE_CODE (low_result
) == INTEGER_CST
)
8728 /* Make a 3-bit mask with the high-order bit being the
8729 value for `>', the next for '=', and the low for '<'. */
8730 switch ((integer_onep (high_result
) * 4)
8731 + (integer_onep (equal_result
) * 2)
8732 + integer_onep (low_result
))
8736 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
8757 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
8762 tem
= save_expr (build2 (code
, type
, cval1
, cval2
));
8763 SET_EXPR_LOCATION (tem
, loc
);
8766 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
8771 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8772 into a single range test. */
8773 if ((TREE_CODE (arg0
) == TRUNC_DIV_EXPR
8774 || TREE_CODE (arg0
) == EXACT_DIV_EXPR
)
8775 && TREE_CODE (arg1
) == INTEGER_CST
8776 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8777 && !integer_zerop (TREE_OPERAND (arg0
, 1))
8778 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
8779 && !TREE_OVERFLOW (arg1
))
8781 tem
= fold_div_compare (loc
, code
, type
, arg0
, arg1
);
8782 if (tem
!= NULL_TREE
)
8790 /* Subroutine of fold_binary. Optimize complex multiplications of the
8791 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8792 argument EXPR represents the expression "z" of type TYPE. */
8795 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
8797 tree itype
= TREE_TYPE (type
);
8798 tree rpart
, ipart
, tem
;
8800 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
8802 rpart
= TREE_OPERAND (expr
, 0);
8803 ipart
= TREE_OPERAND (expr
, 1);
8805 else if (TREE_CODE (expr
) == COMPLEX_CST
)
8807 rpart
= TREE_REALPART (expr
);
8808 ipart
= TREE_IMAGPART (expr
);
8812 expr
= save_expr (expr
);
8813 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
8814 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
8817 rpart
= save_expr (rpart
);
8818 ipart
= save_expr (ipart
);
8819 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
8820 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
8821 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
8822 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
8823 build_zero_cst (itype
));
8827 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8828 CONSTRUCTOR ARG into array ELTS and return true if successful. */
8831 vec_cst_ctor_to_array (tree arg
, tree
*elts
)
8833 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg
)), i
;
8835 if (TREE_CODE (arg
) == VECTOR_CST
)
8837 for (i
= 0; i
< VECTOR_CST_NELTS (arg
); ++i
)
8838 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
8840 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
8842 constructor_elt
*elt
;
8844 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
8845 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
8848 elts
[i
] = elt
->value
;
8852 for (; i
< nelts
; i
++)
8854 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
8858 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8859 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8860 NULL_TREE otherwise. */
8863 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const unsigned char *sel
)
8865 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8867 bool need_ctor
= false;
8869 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
8870 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
);
8871 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
8872 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
8875 elts
= XALLOCAVEC (tree
, nelts
* 3);
8876 if (!vec_cst_ctor_to_array (arg0
, elts
)
8877 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
))
8880 for (i
= 0; i
< nelts
; i
++)
8882 if (!CONSTANT_CLASS_P (elts
[sel
[i
]]))
8884 elts
[i
+ 2 * nelts
] = unshare_expr (elts
[sel
[i
]]);
8889 vec
<constructor_elt
, va_gc
> *v
;
8890 vec_alloc (v
, nelts
);
8891 for (i
= 0; i
< nelts
; i
++)
8892 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, elts
[2 * nelts
+ i
]);
8893 return build_constructor (type
, v
);
8896 return build_vector (type
, &elts
[2 * nelts
]);
8899 /* Try to fold a pointer difference of type TYPE two address expressions of
8900 array references AREF0 and AREF1 using location LOC. Return a
8901 simplified expression for the difference or NULL_TREE. */
8904 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
8905 tree aref0
, tree aref1
)
8907 tree base0
= TREE_OPERAND (aref0
, 0);
8908 tree base1
= TREE_OPERAND (aref1
, 0);
8909 tree base_offset
= build_int_cst (type
, 0);
8911 /* If the bases are array references as well, recurse. If the bases
8912 are pointer indirections compute the difference of the pointers.
8913 If the bases are equal, we are set. */
8914 if ((TREE_CODE (base0
) == ARRAY_REF
8915 && TREE_CODE (base1
) == ARRAY_REF
8917 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
)))
8918 || (INDIRECT_REF_P (base0
)
8919 && INDIRECT_REF_P (base1
)
8921 = fold_binary_loc (loc
, MINUS_EXPR
, type
,
8922 fold_convert (type
, TREE_OPERAND (base0
, 0)),
8924 TREE_OPERAND (base1
, 0)))))
8925 || operand_equal_p (base0
, base1
, OEP_ADDRESS_OF
))
8927 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
8928 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
8929 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
8930 tree diff
= build2 (MINUS_EXPR
, type
, op0
, op1
);
8931 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
8933 fold_build2_loc (loc
, MULT_EXPR
, type
,
8939 /* If the real or vector real constant CST of type TYPE has an exact
8940 inverse, return it, else return NULL. */
8943 exact_inverse (tree type
, tree cst
)
8946 tree unit_type
, *elts
;
8948 unsigned vec_nelts
, i
;
8950 switch (TREE_CODE (cst
))
8953 r
= TREE_REAL_CST (cst
);
8955 if (exact_real_inverse (TYPE_MODE (type
), &r
))
8956 return build_real (type
, r
);
8961 vec_nelts
= VECTOR_CST_NELTS (cst
);
8962 elts
= XALLOCAVEC (tree
, vec_nelts
);
8963 unit_type
= TREE_TYPE (type
);
8964 mode
= TYPE_MODE (unit_type
);
8966 for (i
= 0; i
< vec_nelts
; i
++)
8968 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
8969 if (!exact_real_inverse (mode
, &r
))
8971 elts
[i
] = build_real (unit_type
, r
);
8974 return build_vector (type
, elts
);
8981 /* Mask out the tz least significant bits of X of type TYPE where
8982 tz is the number of trailing zeroes in Y. */
8984 mask_with_tz (tree type
, const wide_int
&x
, const wide_int
&y
)
8986 int tz
= wi::ctz (y
);
8988 return wi::mask (tz
, true, TYPE_PRECISION (type
)) & x
;
8992 /* Return true when T is an address and is known to be nonzero.
8993 For floating point we further ensure that T is not denormal.
8994 Similar logic is present in nonzero_address in rtlanal.h.
8996 If the return value is based on the assumption that signed overflow
8997 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
8998 change *STRICT_OVERFLOW_P. */
9001 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
9003 tree type
= TREE_TYPE (t
);
9004 enum tree_code code
;
9006 /* Doing something useful for floating point would need more work. */
9007 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
9010 code
= TREE_CODE (t
);
9011 switch (TREE_CODE_CLASS (code
))
9014 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9017 case tcc_comparison
:
9018 return tree_binary_nonzero_warnv_p (code
, type
,
9019 TREE_OPERAND (t
, 0),
9020 TREE_OPERAND (t
, 1),
9023 case tcc_declaration
:
9025 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9033 case TRUTH_NOT_EXPR
:
9034 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9037 case TRUTH_AND_EXPR
:
9039 case TRUTH_XOR_EXPR
:
9040 return tree_binary_nonzero_warnv_p (code
, type
,
9041 TREE_OPERAND (t
, 0),
9042 TREE_OPERAND (t
, 1),
9050 case WITH_SIZE_EXPR
:
9052 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9057 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
9061 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
9066 tree fndecl
= get_callee_fndecl (t
);
9067 if (!fndecl
) return false;
9068 if (flag_delete_null_pointer_checks
&& !flag_check_new
9069 && DECL_IS_OPERATOR_NEW (fndecl
)
9070 && !TREE_NOTHROW (fndecl
))
9072 if (flag_delete_null_pointer_checks
9073 && lookup_attribute ("returns_nonnull",
9074 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
9076 return alloca_call_p (t
);
9085 /* Return true when T is an address and is known to be nonzero.
9086 Handle warnings about undefined signed overflow. */
9089 tree_expr_nonzero_p (tree t
)
9091 bool ret
, strict_overflow_p
;
9093 strict_overflow_p
= false;
9094 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
9095 if (strict_overflow_p
)
9096 fold_overflow_warning (("assuming signed overflow does not occur when "
9097 "determining that expression is always "
9099 WARN_STRICT_OVERFLOW_MISC
);
9103 /* Return true if T is known not to be equal to an integer W. */
9106 expr_not_equal_to (tree t
, const wide_int
&w
)
9108 wide_int min
, max
, nz
;
9109 value_range_type rtype
;
9110 switch (TREE_CODE (t
))
9113 return wi::ne_p (t
, w
);
9116 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
9118 rtype
= get_range_info (t
, &min
, &max
);
9119 if (rtype
== VR_RANGE
)
9121 if (wi::lt_p (max
, w
, TYPE_SIGN (TREE_TYPE (t
))))
9123 if (wi::lt_p (w
, min
, TYPE_SIGN (TREE_TYPE (t
))))
9126 else if (rtype
== VR_ANTI_RANGE
9127 && wi::le_p (min
, w
, TYPE_SIGN (TREE_TYPE (t
)))
9128 && wi::le_p (w
, max
, TYPE_SIGN (TREE_TYPE (t
))))
9130 /* If T has some known zero bits and W has any of those bits set,
9131 then T is known not to be equal to W. */
9132 if (wi::ne_p (wi::zext (wi::bit_and_not (w
, get_nonzero_bits (t
)),
9133 TYPE_PRECISION (TREE_TYPE (t
))), 0))
9142 /* Fold a binary expression of code CODE and type TYPE with operands
9143 OP0 and OP1. LOC is the location of the resulting expression.
9144 Return the folded expression if folding is successful. Otherwise,
9145 return NULL_TREE. */
9148 fold_binary_loc (location_t loc
,
9149 enum tree_code code
, tree type
, tree op0
, tree op1
)
9151 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
9152 tree arg0
, arg1
, tem
;
9153 tree t1
= NULL_TREE
;
9154 bool strict_overflow_p
;
9157 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
9158 && TREE_CODE_LENGTH (code
) == 2
9160 && op1
!= NULL_TREE
);
9165 /* Strip any conversions that don't change the mode. This is
9166 safe for every expression, except for a comparison expression
9167 because its signedness is derived from its operands. So, in
9168 the latter case, only strip conversions that don't change the
9169 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9172 Note that this is done as an internal manipulation within the
9173 constant folder, in order to find the simplest representation
9174 of the arguments so that their form can be studied. In any
9175 cases, the appropriate type conversions should be put back in
9176 the tree that will get out of the constant folder. */
9178 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
9180 STRIP_SIGN_NOPS (arg0
);
9181 STRIP_SIGN_NOPS (arg1
);
9189 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9190 constant but we can't do arithmetic on them. */
9191 if (CONSTANT_CLASS_P (arg0
) && CONSTANT_CLASS_P (arg1
))
9193 tem
= const_binop (code
, type
, arg0
, arg1
);
9194 if (tem
!= NULL_TREE
)
9196 if (TREE_TYPE (tem
) != type
)
9197 tem
= fold_convert_loc (loc
, type
, tem
);
9202 /* If this is a commutative operation, and ARG0 is a constant, move it
9203 to ARG1 to reduce the number of tests below. */
9204 if (commutative_tree_code (code
)
9205 && tree_swap_operands_p (arg0
, arg1
, true))
9206 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
9208 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9209 to ARG1 to reduce the number of tests below. */
9210 if (kind
== tcc_comparison
9211 && tree_swap_operands_p (arg0
, arg1
, true))
9212 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
9214 tem
= generic_simplify (loc
, code
, type
, op0
, op1
);
9218 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9220 First check for cases where an arithmetic operation is applied to a
9221 compound, conditional, or comparison operation. Push the arithmetic
9222 operation inside the compound or conditional to see if any folding
9223 can then be done. Convert comparison to conditional for this purpose.
9224 The also optimizes non-constant cases that used to be done in
9227 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9228 one of the operands is a comparison and the other is a comparison, a
9229 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9230 code below would make the expression more complex. Change it to a
9231 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9232 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9234 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
9235 || code
== EQ_EXPR
|| code
== NE_EXPR
)
9236 && TREE_CODE (type
) != VECTOR_TYPE
9237 && ((truth_value_p (TREE_CODE (arg0
))
9238 && (truth_value_p (TREE_CODE (arg1
))
9239 || (TREE_CODE (arg1
) == BIT_AND_EXPR
9240 && integer_onep (TREE_OPERAND (arg1
, 1)))))
9241 || (truth_value_p (TREE_CODE (arg1
))
9242 && (truth_value_p (TREE_CODE (arg0
))
9243 || (TREE_CODE (arg0
) == BIT_AND_EXPR
9244 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
9246 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
9247 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
9250 fold_convert_loc (loc
, boolean_type_node
, arg0
),
9251 fold_convert_loc (loc
, boolean_type_node
, arg1
));
9253 if (code
== EQ_EXPR
)
9254 tem
= invert_truthvalue_loc (loc
, tem
);
9256 return fold_convert_loc (loc
, type
, tem
);
9259 if (TREE_CODE_CLASS (code
) == tcc_binary
9260 || TREE_CODE_CLASS (code
) == tcc_comparison
)
9262 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
9264 tem
= fold_build2_loc (loc
, code
, type
,
9265 fold_convert_loc (loc
, TREE_TYPE (op0
),
9266 TREE_OPERAND (arg0
, 1)), op1
);
9267 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
9270 if (TREE_CODE (arg1
) == COMPOUND_EXPR
9271 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
9273 tem
= fold_build2_loc (loc
, code
, type
, op0
,
9274 fold_convert_loc (loc
, TREE_TYPE (op1
),
9275 TREE_OPERAND (arg1
, 1)));
9276 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
9280 if (TREE_CODE (arg0
) == COND_EXPR
9281 || TREE_CODE (arg0
) == VEC_COND_EXPR
9282 || COMPARISON_CLASS_P (arg0
))
9284 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9286 /*cond_first_p=*/1);
9287 if (tem
!= NULL_TREE
)
9291 if (TREE_CODE (arg1
) == COND_EXPR
9292 || TREE_CODE (arg1
) == VEC_COND_EXPR
9293 || COMPARISON_CLASS_P (arg1
))
9295 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9297 /*cond_first_p=*/0);
9298 if (tem
!= NULL_TREE
)
9306 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9307 if (TREE_CODE (arg0
) == ADDR_EXPR
9308 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
9310 tree iref
= TREE_OPERAND (arg0
, 0);
9311 return fold_build2 (MEM_REF
, type
,
9312 TREE_OPERAND (iref
, 0),
9313 int_const_binop (PLUS_EXPR
, arg1
,
9314 TREE_OPERAND (iref
, 1)));
9317 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9318 if (TREE_CODE (arg0
) == ADDR_EXPR
9319 && handled_component_p (TREE_OPERAND (arg0
, 0)))
9322 HOST_WIDE_INT coffset
;
9323 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
9327 return fold_build2 (MEM_REF
, type
,
9328 build_fold_addr_expr (base
),
9329 int_const_binop (PLUS_EXPR
, arg1
,
9330 size_int (coffset
)));
9335 case POINTER_PLUS_EXPR
:
9336 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9337 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9338 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
9339 return fold_convert_loc (loc
, type
,
9340 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
9341 fold_convert_loc (loc
, sizetype
,
9343 fold_convert_loc (loc
, sizetype
,
9349 if (INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
9351 /* X + (X / CST) * -CST is X % CST. */
9352 if (TREE_CODE (arg1
) == MULT_EXPR
9353 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
9354 && operand_equal_p (arg0
,
9355 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
9357 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
9358 tree cst1
= TREE_OPERAND (arg1
, 1);
9359 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
9361 if (sum
&& integer_zerop (sum
))
9362 return fold_convert_loc (loc
, type
,
9363 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
9364 TREE_TYPE (arg0
), arg0
,
9369 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9370 one. Make sure the type is not saturating and has the signedness of
9371 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9372 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9373 if ((TREE_CODE (arg0
) == MULT_EXPR
9374 || TREE_CODE (arg1
) == MULT_EXPR
)
9375 && !TYPE_SATURATING (type
)
9376 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9377 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9378 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9380 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9385 if (! FLOAT_TYPE_P (type
))
9387 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9388 (plus (plus (mult) (mult)) (foo)) so that we can
9389 take advantage of the factoring cases below. */
9390 if (ANY_INTEGRAL_TYPE_P (type
)
9391 && TYPE_OVERFLOW_WRAPS (type
)
9392 && (((TREE_CODE (arg0
) == PLUS_EXPR
9393 || TREE_CODE (arg0
) == MINUS_EXPR
)
9394 && TREE_CODE (arg1
) == MULT_EXPR
)
9395 || ((TREE_CODE (arg1
) == PLUS_EXPR
9396 || TREE_CODE (arg1
) == MINUS_EXPR
)
9397 && TREE_CODE (arg0
) == MULT_EXPR
)))
9399 tree parg0
, parg1
, parg
, marg
;
9400 enum tree_code pcode
;
9402 if (TREE_CODE (arg1
) == MULT_EXPR
)
9403 parg
= arg0
, marg
= arg1
;
9405 parg
= arg1
, marg
= arg0
;
9406 pcode
= TREE_CODE (parg
);
9407 parg0
= TREE_OPERAND (parg
, 0);
9408 parg1
= TREE_OPERAND (parg
, 1);
9412 if (TREE_CODE (parg0
) == MULT_EXPR
9413 && TREE_CODE (parg1
) != MULT_EXPR
)
9414 return fold_build2_loc (loc
, pcode
, type
,
9415 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9416 fold_convert_loc (loc
, type
,
9418 fold_convert_loc (loc
, type
,
9420 fold_convert_loc (loc
, type
, parg1
));
9421 if (TREE_CODE (parg0
) != MULT_EXPR
9422 && TREE_CODE (parg1
) == MULT_EXPR
)
9424 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9425 fold_convert_loc (loc
, type
, parg0
),
9426 fold_build2_loc (loc
, pcode
, type
,
9427 fold_convert_loc (loc
, type
, marg
),
9428 fold_convert_loc (loc
, type
,
9434 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9435 to __complex__ ( x, y ). This is not the same for SNaNs or
9436 if signed zeros are involved. */
9437 if (!HONOR_SNANS (element_mode (arg0
))
9438 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9439 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9441 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9442 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9443 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9444 bool arg0rz
= false, arg0iz
= false;
9445 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9446 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9448 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9449 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9450 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9452 tree rp
= arg1r
? arg1r
9453 : build1 (REALPART_EXPR
, rtype
, arg1
);
9454 tree ip
= arg0i
? arg0i
9455 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9456 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9458 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9460 tree rp
= arg0r
? arg0r
9461 : build1 (REALPART_EXPR
, rtype
, arg0
);
9462 tree ip
= arg1i
? arg1i
9463 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
9464 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9469 if (flag_unsafe_math_optimizations
9470 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
9471 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
9472 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
9475 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9476 We associate floats only if the user has specified
9477 -fassociative-math. */
9478 if (flag_associative_math
9479 && TREE_CODE (arg1
) == PLUS_EXPR
9480 && TREE_CODE (arg0
) != MULT_EXPR
)
9482 tree tree10
= TREE_OPERAND (arg1
, 0);
9483 tree tree11
= TREE_OPERAND (arg1
, 1);
9484 if (TREE_CODE (tree11
) == MULT_EXPR
9485 && TREE_CODE (tree10
) == MULT_EXPR
)
9488 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
9489 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
9492 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9493 We associate floats only if the user has specified
9494 -fassociative-math. */
9495 if (flag_associative_math
9496 && TREE_CODE (arg0
) == PLUS_EXPR
9497 && TREE_CODE (arg1
) != MULT_EXPR
)
9499 tree tree00
= TREE_OPERAND (arg0
, 0);
9500 tree tree01
= TREE_OPERAND (arg0
, 1);
9501 if (TREE_CODE (tree01
) == MULT_EXPR
9502 && TREE_CODE (tree00
) == MULT_EXPR
)
9505 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
9506 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
9512 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9513 is a rotate of A by C1 bits. */
9514 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9515 is a rotate of A by B bits. */
9517 enum tree_code code0
, code1
;
9519 code0
= TREE_CODE (arg0
);
9520 code1
= TREE_CODE (arg1
);
9521 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
9522 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
9523 && operand_equal_p (TREE_OPERAND (arg0
, 0),
9524 TREE_OPERAND (arg1
, 0), 0)
9525 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9526 TYPE_UNSIGNED (rtype
))
9527 /* Only create rotates in complete modes. Other cases are not
9528 expanded properly. */
9529 && (element_precision (rtype
)
9530 == GET_MODE_UNIT_PRECISION (TYPE_MODE (rtype
))))
9532 tree tree01
, tree11
;
9533 enum tree_code code01
, code11
;
9535 tree01
= TREE_OPERAND (arg0
, 1);
9536 tree11
= TREE_OPERAND (arg1
, 1);
9537 STRIP_NOPS (tree01
);
9538 STRIP_NOPS (tree11
);
9539 code01
= TREE_CODE (tree01
);
9540 code11
= TREE_CODE (tree11
);
9541 if (code01
== INTEGER_CST
9542 && code11
== INTEGER_CST
9543 && (wi::to_widest (tree01
) + wi::to_widest (tree11
)
9544 == element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)))))
9546 tem
= build2_loc (loc
, LROTATE_EXPR
,
9547 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9548 TREE_OPERAND (arg0
, 0),
9549 code0
== LSHIFT_EXPR
9550 ? TREE_OPERAND (arg0
, 1)
9551 : TREE_OPERAND (arg1
, 1));
9552 return fold_convert_loc (loc
, type
, tem
);
9554 else if (code11
== MINUS_EXPR
)
9556 tree tree110
, tree111
;
9557 tree110
= TREE_OPERAND (tree11
, 0);
9558 tree111
= TREE_OPERAND (tree11
, 1);
9559 STRIP_NOPS (tree110
);
9560 STRIP_NOPS (tree111
);
9561 if (TREE_CODE (tree110
) == INTEGER_CST
9562 && 0 == compare_tree_int (tree110
,
9564 (TREE_TYPE (TREE_OPERAND
9566 && operand_equal_p (tree01
, tree111
, 0))
9568 fold_convert_loc (loc
, type
,
9569 build2 ((code0
== LSHIFT_EXPR
9572 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9573 TREE_OPERAND (arg0
, 0),
9574 TREE_OPERAND (arg0
, 1)));
9576 else if (code01
== MINUS_EXPR
)
9578 tree tree010
, tree011
;
9579 tree010
= TREE_OPERAND (tree01
, 0);
9580 tree011
= TREE_OPERAND (tree01
, 1);
9581 STRIP_NOPS (tree010
);
9582 STRIP_NOPS (tree011
);
9583 if (TREE_CODE (tree010
) == INTEGER_CST
9584 && 0 == compare_tree_int (tree010
,
9586 (TREE_TYPE (TREE_OPERAND
9588 && operand_equal_p (tree11
, tree011
, 0))
9589 return fold_convert_loc
9591 build2 ((code0
!= LSHIFT_EXPR
9594 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9595 TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 1)));
9601 /* In most languages, can't associate operations on floats through
9602 parentheses. Rather than remember where the parentheses were, we
9603 don't associate floats at all, unless the user has specified
9605 And, we need to make sure type is not saturating. */
9607 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
9608 && !TYPE_SATURATING (type
))
9610 tree var0
, con0
, lit0
, minus_lit0
;
9611 tree var1
, con1
, lit1
, minus_lit1
;
9615 /* Split both trees into variables, constants, and literals. Then
9616 associate each group together, the constants with literals,
9617 then the result with variables. This increases the chances of
9618 literals being recombined later and of generating relocatable
9619 expressions for the sum of a constant and literal. */
9620 var0
= split_tree (arg0
, code
, &con0
, &lit0
, &minus_lit0
, 0);
9621 var1
= split_tree (arg1
, code
, &con1
, &lit1
, &minus_lit1
,
9622 code
== MINUS_EXPR
);
9624 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9625 if (code
== MINUS_EXPR
)
9628 /* With undefined overflow prefer doing association in a type
9629 which wraps on overflow, if that is one of the operand types. */
9630 if ((POINTER_TYPE_P (type
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
9631 || (INTEGRAL_TYPE_P (type
) && !TYPE_OVERFLOW_WRAPS (type
)))
9633 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
9634 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
9635 atype
= TREE_TYPE (arg0
);
9636 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9637 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
9638 atype
= TREE_TYPE (arg1
);
9639 gcc_assert (TYPE_PRECISION (atype
) == TYPE_PRECISION (type
));
9642 /* With undefined overflow we can only associate constants with one
9643 variable, and constants whose association doesn't overflow. */
9644 if ((POINTER_TYPE_P (atype
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
9645 || (INTEGRAL_TYPE_P (atype
) && !TYPE_OVERFLOW_WRAPS (atype
)))
9651 bool one_neg
= false;
9653 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
9655 tmp0
= TREE_OPERAND (tmp0
, 0);
9658 if (CONVERT_EXPR_P (tmp0
)
9659 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9660 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9661 <= TYPE_PRECISION (atype
)))
9662 tmp0
= TREE_OPERAND (tmp0
, 0);
9663 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
9665 tmp1
= TREE_OPERAND (tmp1
, 0);
9668 if (CONVERT_EXPR_P (tmp1
)
9669 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9670 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9671 <= TYPE_PRECISION (atype
)))
9672 tmp1
= TREE_OPERAND (tmp1
, 0);
9673 /* The only case we can still associate with two variables
9674 is if they cancel out. */
9676 || !operand_equal_p (tmp0
, tmp1
, 0))
9681 /* Only do something if we found more than two objects. Otherwise,
9682 nothing has changed and we risk infinite recursion. */
9684 && (2 < ((var0
!= 0) + (var1
!= 0)
9685 + (con0
!= 0) + (con1
!= 0)
9686 + (lit0
!= 0) + (lit1
!= 0)
9687 + (minus_lit0
!= 0) + (minus_lit1
!= 0))))
9689 bool any_overflows
= false;
9690 if (lit0
) any_overflows
|= TREE_OVERFLOW (lit0
);
9691 if (lit1
) any_overflows
|= TREE_OVERFLOW (lit1
);
9692 if (minus_lit0
) any_overflows
|= TREE_OVERFLOW (minus_lit0
);
9693 if (minus_lit1
) any_overflows
|= TREE_OVERFLOW (minus_lit1
);
9694 var0
= associate_trees (loc
, var0
, var1
, code
, atype
);
9695 con0
= associate_trees (loc
, con0
, con1
, code
, atype
);
9696 lit0
= associate_trees (loc
, lit0
, lit1
, code
, atype
);
9697 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
,
9700 /* Preserve the MINUS_EXPR if the negative part of the literal is
9701 greater than the positive part. Otherwise, the multiplicative
9702 folding code (i.e extract_muldiv) may be fooled in case
9703 unsigned constants are subtracted, like in the following
9704 example: ((X*2 + 4) - 8U)/2. */
9705 if (minus_lit0
&& lit0
)
9707 if (TREE_CODE (lit0
) == INTEGER_CST
9708 && TREE_CODE (minus_lit0
) == INTEGER_CST
9709 && tree_int_cst_lt (lit0
, minus_lit0
))
9711 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
9717 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
9723 /* Don't introduce overflows through reassociation. */
9725 && ((lit0
&& TREE_OVERFLOW_P (lit0
))
9726 || (minus_lit0
&& TREE_OVERFLOW_P (minus_lit0
))))
9733 fold_convert_loc (loc
, type
,
9734 associate_trees (loc
, var0
, minus_lit0
,
9735 MINUS_EXPR
, atype
));
9738 con0
= associate_trees (loc
, con0
, minus_lit0
,
9741 fold_convert_loc (loc
, type
,
9742 associate_trees (loc
, var0
, con0
,
9747 con0
= associate_trees (loc
, con0
, lit0
, code
, atype
);
9749 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
9757 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9758 if (TREE_CODE (arg0
) == NEGATE_EXPR
9759 && negate_expr_p (op1
)
9760 && reorder_operands_p (arg0
, arg1
))
9761 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
9763 fold_convert_loc (loc
, type
,
9764 TREE_OPERAND (arg0
, 0)));
9766 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9767 __complex__ ( x, -y ). This is not the same for SNaNs or if
9768 signed zeros are involved. */
9769 if (!HONOR_SNANS (element_mode (arg0
))
9770 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9771 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9773 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9774 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9775 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9776 bool arg0rz
= false, arg0iz
= false;
9777 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9778 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9780 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9781 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9782 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9784 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9786 : build1 (REALPART_EXPR
, rtype
, arg1
));
9787 tree ip
= arg0i
? arg0i
9788 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9789 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9791 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9793 tree rp
= arg0r
? arg0r
9794 : build1 (REALPART_EXPR
, rtype
, arg0
);
9795 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9797 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
9798 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9803 /* A - B -> A + (-B) if B is easily negatable. */
9804 if (negate_expr_p (op1
)
9805 && ! TYPE_OVERFLOW_SANITIZED (type
)
9806 && ((FLOAT_TYPE_P (type
)
9807 /* Avoid this transformation if B is a positive REAL_CST. */
9808 && (TREE_CODE (op1
) != REAL_CST
9809 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (op1
))))
9810 || INTEGRAL_TYPE_P (type
)))
9811 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9812 fold_convert_loc (loc
, type
, arg0
),
9815 /* Fold &a[i] - &a[j] to i-j. */
9816 if (TREE_CODE (arg0
) == ADDR_EXPR
9817 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
9818 && TREE_CODE (arg1
) == ADDR_EXPR
9819 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
9821 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
9822 TREE_OPERAND (arg0
, 0),
9823 TREE_OPERAND (arg1
, 0));
9828 if (FLOAT_TYPE_P (type
)
9829 && flag_unsafe_math_optimizations
9830 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
9831 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
9832 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
9835 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9836 one. Make sure the type is not saturating and has the signedness of
9837 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9838 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9839 if ((TREE_CODE (arg0
) == MULT_EXPR
9840 || TREE_CODE (arg1
) == MULT_EXPR
)
9841 && !TYPE_SATURATING (type
)
9842 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9843 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9844 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9846 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9854 if (! FLOAT_TYPE_P (type
))
9856 /* Transform x * -C into -x * C if x is easily negatable. */
9857 if (TREE_CODE (op1
) == INTEGER_CST
9858 && tree_int_cst_sgn (op1
) == -1
9859 && negate_expr_p (op0
)
9860 && (tem
= negate_expr (op1
)) != op1
9861 && ! TREE_OVERFLOW (tem
))
9862 return fold_build2_loc (loc
, MULT_EXPR
, type
,
9863 fold_convert_loc (loc
, type
,
9864 negate_expr (op0
)), tem
);
9866 /* (A + A) * C -> A * 2 * C */
9867 if (TREE_CODE (arg0
) == PLUS_EXPR
9868 && TREE_CODE (arg1
) == INTEGER_CST
9869 && operand_equal_p (TREE_OPERAND (arg0
, 0),
9870 TREE_OPERAND (arg0
, 1), 0))
9871 return fold_build2_loc (loc
, MULT_EXPR
, type
,
9872 omit_one_operand_loc (loc
, type
,
9873 TREE_OPERAND (arg0
, 0),
9874 TREE_OPERAND (arg0
, 1)),
9875 fold_build2_loc (loc
, MULT_EXPR
, type
,
9876 build_int_cst (type
, 2) , arg1
));
9878 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
9879 sign-changing only. */
9880 if (TREE_CODE (arg1
) == INTEGER_CST
9881 && TREE_CODE (arg0
) == EXACT_DIV_EXPR
9882 && operand_equal_p (arg1
, TREE_OPERAND (arg0
, 1), 0))
9883 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
9885 strict_overflow_p
= false;
9886 if (TREE_CODE (arg1
) == INTEGER_CST
9887 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
9888 &strict_overflow_p
)))
9890 if (strict_overflow_p
)
9891 fold_overflow_warning (("assuming signed overflow does not "
9892 "occur when simplifying "
9894 WARN_STRICT_OVERFLOW_MISC
);
9895 return fold_convert_loc (loc
, type
, tem
);
9898 /* Optimize z * conj(z) for integer complex numbers. */
9899 if (TREE_CODE (arg0
) == CONJ_EXPR
9900 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
9901 return fold_mult_zconjz (loc
, type
, arg1
);
9902 if (TREE_CODE (arg1
) == CONJ_EXPR
9903 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
9904 return fold_mult_zconjz (loc
, type
, arg0
);
9908 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
9909 This is not the same for NaNs or if signed zeros are
9911 if (!HONOR_NANS (arg0
)
9912 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9913 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
9914 && TREE_CODE (arg1
) == COMPLEX_CST
9915 && real_zerop (TREE_REALPART (arg1
)))
9917 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9918 if (real_onep (TREE_IMAGPART (arg1
)))
9920 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
9921 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
9923 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
9924 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
9926 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
9927 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
9928 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
9932 /* Optimize z * conj(z) for floating point complex numbers.
9933 Guarded by flag_unsafe_math_optimizations as non-finite
9934 imaginary components don't produce scalar results. */
9935 if (flag_unsafe_math_optimizations
9936 && TREE_CODE (arg0
) == CONJ_EXPR
9937 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
9938 return fold_mult_zconjz (loc
, type
, arg1
);
9939 if (flag_unsafe_math_optimizations
9940 && TREE_CODE (arg1
) == CONJ_EXPR
9941 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
9942 return fold_mult_zconjz (loc
, type
, arg0
);
9944 if (flag_unsafe_math_optimizations
)
9947 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
9950 && operand_equal_p (arg0
, arg1
, 0))
9952 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
9956 tree arg
= build_real (type
, dconst2
);
9957 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
9965 /* Canonicalize (X & C1) | C2. */
9966 if (TREE_CODE (arg0
) == BIT_AND_EXPR
9967 && TREE_CODE (arg1
) == INTEGER_CST
9968 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
9970 int width
= TYPE_PRECISION (type
), w
;
9971 wide_int c1
= TREE_OPERAND (arg0
, 1);
9974 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
9975 if ((c1
& c2
) == c1
)
9976 return omit_one_operand_loc (loc
, type
, arg1
,
9977 TREE_OPERAND (arg0
, 0));
9979 wide_int msk
= wi::mask (width
, false,
9980 TYPE_PRECISION (TREE_TYPE (arg1
)));
9982 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
9983 if (msk
.and_not (c1
| c2
) == 0)
9984 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
9985 TREE_OPERAND (arg0
, 0), arg1
);
9987 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
9988 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
9989 mode which allows further optimizations. */
9992 wide_int c3
= c1
.and_not (c2
);
9993 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
9995 wide_int mask
= wi::mask (w
, false,
9996 TYPE_PRECISION (type
));
9997 if (((c1
| c2
) & mask
) == mask
&& c1
.and_not (mask
) == 0)
10005 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
10006 fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10007 TREE_OPERAND (arg0
, 0),
10008 wide_int_to_tree (type
,
10013 /* See if this can be simplified into a rotate first. If that
10014 is unsuccessful continue in the association code. */
10018 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
10019 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10020 && INTEGRAL_TYPE_P (type
)
10021 && integer_onep (TREE_OPERAND (arg0
, 1))
10022 && integer_onep (arg1
))
10023 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
10024 build_zero_cst (TREE_TYPE (arg0
)));
10026 /* See if this can be simplified into a rotate first. If that
10027 is unsuccessful continue in the association code. */
10031 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
10032 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10033 && INTEGRAL_TYPE_P (type
)
10034 && integer_onep (TREE_OPERAND (arg0
, 1))
10035 && integer_onep (arg1
))
10038 tem
= TREE_OPERAND (arg0
, 0);
10039 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
10040 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
10042 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
10043 build_zero_cst (TREE_TYPE (tem
)));
10045 /* Fold ~X & 1 as (X & 1) == 0. */
10046 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10047 && INTEGRAL_TYPE_P (type
)
10048 && integer_onep (arg1
))
10051 tem
= TREE_OPERAND (arg0
, 0);
10052 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
10053 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
10055 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
10056 build_zero_cst (TREE_TYPE (tem
)));
10058 /* Fold !X & 1 as X == 0. */
10059 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10060 && integer_onep (arg1
))
10062 tem
= TREE_OPERAND (arg0
, 0);
10063 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
10064 build_zero_cst (TREE_TYPE (tem
)));
10067 /* Fold (X ^ Y) & Y as ~X & Y. */
10068 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10069 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
10071 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10072 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10073 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
10074 fold_convert_loc (loc
, type
, arg1
));
10076 /* Fold (X ^ Y) & X as ~Y & X. */
10077 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10078 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
10079 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
10081 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10082 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10083 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
10084 fold_convert_loc (loc
, type
, arg1
));
10086 /* Fold X & (X ^ Y) as X & ~Y. */
10087 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
10088 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10090 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10091 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10092 fold_convert_loc (loc
, type
, arg0
),
10093 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
10095 /* Fold X & (Y ^ X) as ~Y & X. */
10096 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
10097 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
10098 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
10100 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10101 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10102 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
10103 fold_convert_loc (loc
, type
, arg0
));
10106 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
10107 multiple of 1 << CST. */
10108 if (TREE_CODE (arg1
) == INTEGER_CST
)
10110 wide_int cst1
= arg1
;
10111 wide_int ncst1
= -cst1
;
10112 if ((cst1
& ncst1
) == ncst1
10113 && multiple_of_p (type
, arg0
,
10114 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
10115 return fold_convert_loc (loc
, type
, arg0
);
10118 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10120 if (TREE_CODE (arg1
) == INTEGER_CST
10121 && TREE_CODE (arg0
) == MULT_EXPR
10122 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10124 wide_int warg1
= arg1
;
10125 wide_int masked
= mask_with_tz (type
, warg1
, TREE_OPERAND (arg0
, 1));
10128 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
10130 else if (masked
!= warg1
)
10132 /* Avoid the transform if arg1 is a mask of some
10133 mode which allows further optimizations. */
10134 int pop
= wi::popcount (warg1
);
10135 if (!(pop
>= BITS_PER_UNIT
10136 && exact_log2 (pop
) != -1
10137 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
10138 return fold_build2_loc (loc
, code
, type
, op0
,
10139 wide_int_to_tree (type
, masked
));
10143 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10144 ((A & N) + B) & M -> (A + B) & M
10145 Similarly if (N & M) == 0,
10146 ((A | N) + B) & M -> (A + B) & M
10147 and for - instead of + (or unary - instead of +)
10148 and/or ^ instead of |.
10149 If B is constant and (B & M) == 0, fold into A & M. */
10150 if (TREE_CODE (arg1
) == INTEGER_CST
)
10152 wide_int cst1
= arg1
;
10153 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
10154 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10155 && (TREE_CODE (arg0
) == PLUS_EXPR
10156 || TREE_CODE (arg0
) == MINUS_EXPR
10157 || TREE_CODE (arg0
) == NEGATE_EXPR
)
10158 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
10159 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
10165 /* Now we know that arg0 is (C + D) or (C - D) or
10166 -C and arg1 (M) is == (1LL << cst) - 1.
10167 Store C into PMOP[0] and D into PMOP[1]. */
10168 pmop
[0] = TREE_OPERAND (arg0
, 0);
10170 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
10172 pmop
[1] = TREE_OPERAND (arg0
, 1);
10176 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
10179 for (; which
>= 0; which
--)
10180 switch (TREE_CODE (pmop
[which
]))
10185 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
10188 cst0
= TREE_OPERAND (pmop
[which
], 1);
10190 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
10195 else if (cst0
!= 0)
10197 /* If C or D is of the form (A & N) where
10198 (N & M) == M, or of the form (A | N) or
10199 (A ^ N) where (N & M) == 0, replace it with A. */
10200 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
10203 /* If C or D is a N where (N & M) == 0, it can be
10204 omitted (assumed 0). */
10205 if ((TREE_CODE (arg0
) == PLUS_EXPR
10206 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
10207 && (cst1
& pmop
[which
]) == 0)
10208 pmop
[which
] = NULL
;
10214 /* Only build anything new if we optimized one or both arguments
10216 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
10217 || (TREE_CODE (arg0
) != NEGATE_EXPR
10218 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
10220 tree utype
= TREE_TYPE (arg0
);
10221 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
10223 /* Perform the operations in a type that has defined
10224 overflow behavior. */
10225 utype
= unsigned_type_for (TREE_TYPE (arg0
));
10226 if (pmop
[0] != NULL
)
10227 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
10228 if (pmop
[1] != NULL
)
10229 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
10232 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
10233 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
10234 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
10236 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
10237 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
10239 else if (pmop
[0] != NULL
)
10241 else if (pmop
[1] != NULL
)
10244 return build_int_cst (type
, 0);
10246 else if (pmop
[0] == NULL
)
10247 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
10249 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
10251 /* TEM is now the new binary +, - or unary - replacement. */
10252 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
10253 fold_convert_loc (loc
, utype
, arg1
));
10254 return fold_convert_loc (loc
, type
, tem
);
10259 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10260 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
10261 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
10263 prec
= element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
10265 wide_int mask
= wide_int::from (arg1
, prec
, UNSIGNED
);
10268 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10274 /* Don't touch a floating-point divide by zero unless the mode
10275 of the constant can represent infinity. */
10276 if (TREE_CODE (arg1
) == REAL_CST
10277 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
10278 && real_zerop (arg1
))
10281 /* (-A) / (-B) -> A / B */
10282 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10283 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10284 TREE_OPERAND (arg0
, 0),
10285 negate_expr (arg1
));
10286 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10287 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10288 negate_expr (arg0
),
10289 TREE_OPERAND (arg1
, 0));
10292 case TRUNC_DIV_EXPR
:
10295 case FLOOR_DIV_EXPR
:
10296 /* Simplify A / (B << N) where A and B are positive and B is
10297 a power of 2, to A >> (N + log2(B)). */
10298 strict_overflow_p
= false;
10299 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10300 && (TYPE_UNSIGNED (type
)
10301 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
10303 tree sval
= TREE_OPERAND (arg1
, 0);
10304 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
10306 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
10307 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
10308 wi::exact_log2 (sval
));
10310 if (strict_overflow_p
)
10311 fold_overflow_warning (("assuming signed overflow does not "
10312 "occur when simplifying A / (B << N)"),
10313 WARN_STRICT_OVERFLOW_MISC
);
10315 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
10317 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
10318 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
10324 case ROUND_DIV_EXPR
:
10325 case CEIL_DIV_EXPR
:
10326 case EXACT_DIV_EXPR
:
10327 if (integer_zerop (arg1
))
10330 /* Convert -A / -B to A / B when the type is signed and overflow is
10332 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10333 && TREE_CODE (arg0
) == NEGATE_EXPR
10334 && negate_expr_p (op1
))
10336 if (INTEGRAL_TYPE_P (type
))
10337 fold_overflow_warning (("assuming signed overflow does not occur "
10338 "when distributing negation across "
10340 WARN_STRICT_OVERFLOW_MISC
);
10341 return fold_build2_loc (loc
, code
, type
,
10342 fold_convert_loc (loc
, type
,
10343 TREE_OPERAND (arg0
, 0)),
10344 negate_expr (op1
));
10346 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10347 && TREE_CODE (arg1
) == NEGATE_EXPR
10348 && negate_expr_p (op0
))
10350 if (INTEGRAL_TYPE_P (type
))
10351 fold_overflow_warning (("assuming signed overflow does not occur "
10352 "when distributing negation across "
10354 WARN_STRICT_OVERFLOW_MISC
);
10355 return fold_build2_loc (loc
, code
, type
,
10357 fold_convert_loc (loc
, type
,
10358 TREE_OPERAND (arg1
, 0)));
10361 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10362 operation, EXACT_DIV_EXPR.
10364 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10365 At one time others generated faster code, it's not clear if they do
10366 after the last round to changes to the DIV code in expmed.c. */
10367 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
10368 && multiple_of_p (type
, arg0
, arg1
))
10369 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
,
10370 fold_convert (type
, arg0
),
10371 fold_convert (type
, arg1
));
10373 strict_overflow_p
= false;
10374 if (TREE_CODE (arg1
) == INTEGER_CST
10375 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10376 &strict_overflow_p
)))
10378 if (strict_overflow_p
)
10379 fold_overflow_warning (("assuming signed overflow does not occur "
10380 "when simplifying division"),
10381 WARN_STRICT_OVERFLOW_MISC
);
10382 return fold_convert_loc (loc
, type
, tem
);
10387 case CEIL_MOD_EXPR
:
10388 case FLOOR_MOD_EXPR
:
10389 case ROUND_MOD_EXPR
:
10390 case TRUNC_MOD_EXPR
:
10391 strict_overflow_p
= false;
10392 if (TREE_CODE (arg1
) == INTEGER_CST
10393 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10394 &strict_overflow_p
)))
10396 if (strict_overflow_p
)
10397 fold_overflow_warning (("assuming signed overflow does not occur "
10398 "when simplifying modulus"),
10399 WARN_STRICT_OVERFLOW_MISC
);
10400 return fold_convert_loc (loc
, type
, tem
);
10409 /* Since negative shift count is not well-defined,
10410 don't try to compute it in the compiler. */
10411 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
10414 prec
= element_precision (type
);
10416 /* If we have a rotate of a bit operation with the rotate count and
10417 the second operand of the bit operation both constant,
10418 permute the two operations. */
10419 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10420 && (TREE_CODE (arg0
) == BIT_AND_EXPR
10421 || TREE_CODE (arg0
) == BIT_IOR_EXPR
10422 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
10423 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10424 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
10425 fold_build2_loc (loc
, code
, type
,
10426 TREE_OPERAND (arg0
, 0), arg1
),
10427 fold_build2_loc (loc
, code
, type
,
10428 TREE_OPERAND (arg0
, 1), arg1
));
10430 /* Two consecutive rotates adding up to the some integer
10431 multiple of the precision of the type can be ignored. */
10432 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10433 && TREE_CODE (arg0
) == RROTATE_EXPR
10434 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10435 && wi::umod_trunc (wi::add (arg1
, TREE_OPERAND (arg0
, 1)),
10437 return TREE_OPERAND (arg0
, 0);
10445 case TRUTH_ANDIF_EXPR
:
10446 /* Note that the operands of this must be ints
10447 and their values must be 0 or 1.
10448 ("true" is a fixed value perhaps depending on the language.) */
10449 /* If first arg is constant zero, return it. */
10450 if (integer_zerop (arg0
))
10451 return fold_convert_loc (loc
, type
, arg0
);
10452 case TRUTH_AND_EXPR
:
10453 /* If either arg is constant true, drop it. */
10454 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10455 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10456 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
10457 /* Preserve sequence points. */
10458 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10459 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10460 /* If second arg is constant zero, result is zero, but first arg
10461 must be evaluated. */
10462 if (integer_zerop (arg1
))
10463 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10464 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10465 case will be handled here. */
10466 if (integer_zerop (arg0
))
10467 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10469 /* !X && X is always false. */
10470 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10471 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10472 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
10473 /* X && !X is always false. */
10474 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10475 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10476 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10478 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10479 means A >= Y && A != MAX, but in this case we know that
10482 if (!TREE_SIDE_EFFECTS (arg0
)
10483 && !TREE_SIDE_EFFECTS (arg1
))
10485 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
10486 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
10487 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
10489 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
10490 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
10491 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
10494 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10500 case TRUTH_ORIF_EXPR
:
10501 /* Note that the operands of this must be ints
10502 and their values must be 0 or true.
10503 ("true" is a fixed value perhaps depending on the language.) */
10504 /* If first arg is constant true, return it. */
10505 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10506 return fold_convert_loc (loc
, type
, arg0
);
10507 case TRUTH_OR_EXPR
:
10508 /* If either arg is constant zero, drop it. */
10509 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
10510 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10511 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
10512 /* Preserve sequence points. */
10513 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10514 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10515 /* If second arg is constant true, result is true, but we must
10516 evaluate first arg. */
10517 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
10518 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10519 /* Likewise for first arg, but note this only occurs here for
10521 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10522 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10524 /* !X || X is always true. */
10525 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10526 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10527 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10528 /* X || !X is always true. */
10529 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10530 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10531 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10533 /* (X && !Y) || (!X && Y) is X ^ Y */
10534 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
10535 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
10537 tree a0
, a1
, l0
, l1
, n0
, n1
;
10539 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10540 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10542 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10543 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10545 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
10546 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
10548 if ((operand_equal_p (n0
, a0
, 0)
10549 && operand_equal_p (n1
, a1
, 0))
10550 || (operand_equal_p (n0
, a1
, 0)
10551 && operand_equal_p (n1
, a0
, 0)))
10552 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
10555 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10561 case TRUTH_XOR_EXPR
:
10562 /* If the second arg is constant zero, drop it. */
10563 if (integer_zerop (arg1
))
10564 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10565 /* If the second arg is constant true, this is a logical inversion. */
10566 if (integer_onep (arg1
))
10568 tem
= invert_truthvalue_loc (loc
, arg0
);
10569 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
10571 /* Identical arguments cancel to zero. */
10572 if (operand_equal_p (arg0
, arg1
, 0))
10573 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10575 /* !X ^ X is always true. */
10576 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10577 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10578 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10580 /* X ^ !X is always true. */
10581 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10582 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10583 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10592 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
10593 if (tem
!= NULL_TREE
)
10596 /* bool_var != 1 becomes !bool_var. */
10597 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
10598 && code
== NE_EXPR
)
10599 return fold_convert_loc (loc
, type
,
10600 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10601 TREE_TYPE (arg0
), arg0
));
10603 /* bool_var == 0 becomes !bool_var. */
10604 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
10605 && code
== EQ_EXPR
)
10606 return fold_convert_loc (loc
, type
,
10607 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10608 TREE_TYPE (arg0
), arg0
));
10610 /* !exp != 0 becomes !exp */
10611 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
10612 && code
== NE_EXPR
)
10613 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10615 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
10616 if ((TREE_CODE (arg0
) == PLUS_EXPR
10617 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
10618 || TREE_CODE (arg0
) == MINUS_EXPR
)
10619 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
10622 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10623 || POINTER_TYPE_P (TREE_TYPE (arg0
))))
10625 tree val
= TREE_OPERAND (arg0
, 1);
10626 val
= fold_build2_loc (loc
, code
, type
, val
,
10627 build_int_cst (TREE_TYPE (val
), 0));
10628 return omit_two_operands_loc (loc
, type
, val
,
10629 TREE_OPERAND (arg0
, 0), arg1
);
10632 /* Transform comparisons of the form X CMP X +- Y to Y CMP 0. */
10633 if ((TREE_CODE (arg1
) == PLUS_EXPR
10634 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
10635 || TREE_CODE (arg1
) == MINUS_EXPR
)
10636 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1
,
10639 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10640 || POINTER_TYPE_P (TREE_TYPE (arg1
))))
10642 tree val
= TREE_OPERAND (arg1
, 1);
10643 val
= fold_build2_loc (loc
, code
, type
, val
,
10644 build_int_cst (TREE_TYPE (val
), 0));
10645 return omit_two_operands_loc (loc
, type
, val
,
10646 TREE_OPERAND (arg1
, 0), arg0
);
10649 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
10650 if (TREE_CODE (arg0
) == MINUS_EXPR
10651 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == INTEGER_CST
10652 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
10655 && wi::extract_uhwi (TREE_OPERAND (arg0
, 0), 0, 1) == 1)
10656 return omit_two_operands_loc (loc
, type
,
10658 ? boolean_true_node
: boolean_false_node
,
10659 TREE_OPERAND (arg0
, 1), arg1
);
10661 /* Transform comparisons of the form X CMP C - X if C % 2 == 1. */
10662 if (TREE_CODE (arg1
) == MINUS_EXPR
10663 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == INTEGER_CST
10664 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1
,
10667 && wi::extract_uhwi (TREE_OPERAND (arg1
, 0), 0, 1) == 1)
10668 return omit_two_operands_loc (loc
, type
,
10670 ? boolean_true_node
: boolean_false_node
,
10671 TREE_OPERAND (arg1
, 1), arg0
);
10673 /* If this is an EQ or NE comparison with zero and ARG0 is
10674 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10675 two operations, but the latter can be done in one less insn
10676 on machines that have only two-operand insns or on which a
10677 constant cannot be the first operand. */
10678 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10679 && integer_zerop (arg1
))
10681 tree arg00
= TREE_OPERAND (arg0
, 0);
10682 tree arg01
= TREE_OPERAND (arg0
, 1);
10683 if (TREE_CODE (arg00
) == LSHIFT_EXPR
10684 && integer_onep (TREE_OPERAND (arg00
, 0)))
10686 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
10687 arg01
, TREE_OPERAND (arg00
, 1));
10688 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10689 build_int_cst (TREE_TYPE (arg0
), 1));
10690 return fold_build2_loc (loc
, code
, type
,
10691 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10694 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
10695 && integer_onep (TREE_OPERAND (arg01
, 0)))
10697 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
10698 arg00
, TREE_OPERAND (arg01
, 1));
10699 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10700 build_int_cst (TREE_TYPE (arg0
), 1));
10701 return fold_build2_loc (loc
, code
, type
,
10702 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10707 /* If this is an NE or EQ comparison of zero against the result of a
10708 signed MOD operation whose second operand is a power of 2, make
10709 the MOD operation unsigned since it is simpler and equivalent. */
10710 if (integer_zerop (arg1
)
10711 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
10712 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
10713 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
10714 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
10715 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
10716 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10718 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
10719 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
10720 fold_convert_loc (loc
, newtype
,
10721 TREE_OPERAND (arg0
, 0)),
10722 fold_convert_loc (loc
, newtype
,
10723 TREE_OPERAND (arg0
, 1)));
10725 return fold_build2_loc (loc
, code
, type
, newmod
,
10726 fold_convert_loc (loc
, newtype
, arg1
));
10729 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10730 C1 is a valid shift constant, and C2 is a power of two, i.e.
10732 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10733 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
10734 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
10736 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10737 && integer_zerop (arg1
))
10739 tree itype
= TREE_TYPE (arg0
);
10740 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
10741 prec
= TYPE_PRECISION (itype
);
10743 /* Check for a valid shift count. */
10744 if (wi::ltu_p (arg001
, prec
))
10746 tree arg01
= TREE_OPERAND (arg0
, 1);
10747 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10748 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
10749 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10750 can be rewritten as (X & (C2 << C1)) != 0. */
10751 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
10753 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
10754 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
10755 return fold_build2_loc (loc
, code
, type
, tem
,
10756 fold_convert_loc (loc
, itype
, arg1
));
10758 /* Otherwise, for signed (arithmetic) shifts,
10759 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10760 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10761 else if (!TYPE_UNSIGNED (itype
))
10762 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
10763 arg000
, build_int_cst (itype
, 0));
10764 /* Otherwise, of unsigned (logical) shifts,
10765 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10766 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10768 return omit_one_operand_loc (loc
, type
,
10769 code
== EQ_EXPR
? integer_one_node
10770 : integer_zero_node
,
10775 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10776 Similarly for NE_EXPR. */
10777 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10778 && TREE_CODE (arg1
) == INTEGER_CST
10779 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10781 tree notc
= fold_build1_loc (loc
, BIT_NOT_EXPR
,
10782 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
10783 TREE_OPERAND (arg0
, 1));
10785 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
10786 fold_convert_loc (loc
, TREE_TYPE (arg0
), arg1
),
10788 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
10789 if (integer_nonzerop (dandnotc
))
10790 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
10793 /* If this is a comparison of a field, we may be able to simplify it. */
10794 if ((TREE_CODE (arg0
) == COMPONENT_REF
10795 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
10796 /* Handle the constant case even without -O
10797 to make sure the warnings are given. */
10798 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
10800 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
10805 /* Optimize comparisons of strlen vs zero to a compare of the
10806 first character of the string vs zero. To wit,
10807 strlen(ptr) == 0 => *ptr == 0
10808 strlen(ptr) != 0 => *ptr != 0
10809 Other cases should reduce to one of these two (or a constant)
10810 due to the return value of strlen being unsigned. */
10811 if (TREE_CODE (arg0
) == CALL_EXPR
10812 && integer_zerop (arg1
))
10814 tree fndecl
= get_callee_fndecl (arg0
);
10817 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
10818 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
10819 && call_expr_nargs (arg0
) == 1
10820 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
10822 tree iref
= build_fold_indirect_ref_loc (loc
,
10823 CALL_EXPR_ARG (arg0
, 0));
10824 return fold_build2_loc (loc
, code
, type
, iref
,
10825 build_int_cst (TREE_TYPE (iref
), 0));
10829 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10830 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10831 if (TREE_CODE (arg0
) == RSHIFT_EXPR
10832 && integer_zerop (arg1
)
10833 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10835 tree arg00
= TREE_OPERAND (arg0
, 0);
10836 tree arg01
= TREE_OPERAND (arg0
, 1);
10837 tree itype
= TREE_TYPE (arg00
);
10838 if (wi::eq_p (arg01
, element_precision (itype
) - 1))
10840 if (TYPE_UNSIGNED (itype
))
10842 itype
= signed_type_for (itype
);
10843 arg00
= fold_convert_loc (loc
, itype
, arg00
);
10845 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
10846 type
, arg00
, build_zero_cst (itype
));
10850 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10851 (X & C) == 0 when C is a single bit. */
10852 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10853 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
10854 && integer_zerop (arg1
)
10855 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10857 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
10858 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
10859 TREE_OPERAND (arg0
, 1));
10860 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
10862 fold_convert_loc (loc
, TREE_TYPE (arg0
),
10866 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10867 constant C is a power of two, i.e. a single bit. */
10868 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10869 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
10870 && integer_zerop (arg1
)
10871 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10872 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10873 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10875 tree arg00
= TREE_OPERAND (arg0
, 0);
10876 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10877 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
10880 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10881 when is C is a power of two, i.e. a single bit. */
10882 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10883 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
10884 && integer_zerop (arg1
)
10885 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10886 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10887 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10889 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10890 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
10891 arg000
, TREE_OPERAND (arg0
, 1));
10892 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10893 tem
, build_int_cst (TREE_TYPE (tem
), 0));
10896 if (integer_zerop (arg1
)
10897 && tree_expr_nonzero_p (arg0
))
10899 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
10900 return omit_one_operand_loc (loc
, type
, res
, arg0
);
10903 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10904 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10905 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10907 tree arg00
= TREE_OPERAND (arg0
, 0);
10908 tree arg01
= TREE_OPERAND (arg0
, 1);
10909 tree arg10
= TREE_OPERAND (arg1
, 0);
10910 tree arg11
= TREE_OPERAND (arg1
, 1);
10911 tree itype
= TREE_TYPE (arg0
);
10913 if (operand_equal_p (arg01
, arg11
, 0))
10914 return fold_build2_loc (loc
, code
, type
,
10915 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10916 fold_build2_loc (loc
,
10917 BIT_XOR_EXPR
, itype
,
10920 build_zero_cst (itype
));
10922 if (operand_equal_p (arg01
, arg10
, 0))
10923 return fold_build2_loc (loc
, code
, type
,
10924 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10925 fold_build2_loc (loc
,
10926 BIT_XOR_EXPR
, itype
,
10929 build_zero_cst (itype
));
10931 if (operand_equal_p (arg00
, arg11
, 0))
10932 return fold_build2_loc (loc
, code
, type
,
10933 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10934 fold_build2_loc (loc
,
10935 BIT_XOR_EXPR
, itype
,
10938 build_zero_cst (itype
));
10940 if (operand_equal_p (arg00
, arg10
, 0))
10941 return fold_build2_loc (loc
, code
, type
,
10942 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10943 fold_build2_loc (loc
,
10944 BIT_XOR_EXPR
, itype
,
10947 build_zero_cst (itype
));
10950 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10951 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
10953 tree arg00
= TREE_OPERAND (arg0
, 0);
10954 tree arg01
= TREE_OPERAND (arg0
, 1);
10955 tree arg10
= TREE_OPERAND (arg1
, 0);
10956 tree arg11
= TREE_OPERAND (arg1
, 1);
10957 tree itype
= TREE_TYPE (arg0
);
10959 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10960 operand_equal_p guarantees no side-effects so we don't need
10961 to use omit_one_operand on Z. */
10962 if (operand_equal_p (arg01
, arg11
, 0))
10963 return fold_build2_loc (loc
, code
, type
, arg00
,
10964 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10966 if (operand_equal_p (arg01
, arg10
, 0))
10967 return fold_build2_loc (loc
, code
, type
, arg00
,
10968 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10970 if (operand_equal_p (arg00
, arg11
, 0))
10971 return fold_build2_loc (loc
, code
, type
, arg01
,
10972 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10974 if (operand_equal_p (arg00
, arg10
, 0))
10975 return fold_build2_loc (loc
, code
, type
, arg01
,
10976 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10979 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
10980 if (TREE_CODE (arg01
) == INTEGER_CST
10981 && TREE_CODE (arg11
) == INTEGER_CST
)
10983 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
10984 fold_convert_loc (loc
, itype
, arg11
));
10985 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
10986 return fold_build2_loc (loc
, code
, type
, tem
,
10987 fold_convert_loc (loc
, itype
, arg10
));
10991 /* Attempt to simplify equality/inequality comparisons of complex
10992 values. Only lower the comparison if the result is known or
10993 can be simplified to a single scalar comparison. */
10994 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
10995 || TREE_CODE (arg0
) == COMPLEX_CST
)
10996 && (TREE_CODE (arg1
) == COMPLEX_EXPR
10997 || TREE_CODE (arg1
) == COMPLEX_CST
))
10999 tree real0
, imag0
, real1
, imag1
;
11002 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
11004 real0
= TREE_OPERAND (arg0
, 0);
11005 imag0
= TREE_OPERAND (arg0
, 1);
11009 real0
= TREE_REALPART (arg0
);
11010 imag0
= TREE_IMAGPART (arg0
);
11013 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
11015 real1
= TREE_OPERAND (arg1
, 0);
11016 imag1
= TREE_OPERAND (arg1
, 1);
11020 real1
= TREE_REALPART (arg1
);
11021 imag1
= TREE_IMAGPART (arg1
);
11024 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
11025 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
11027 if (integer_zerop (rcond
))
11029 if (code
== EQ_EXPR
)
11030 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
11032 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
11036 if (code
== NE_EXPR
)
11037 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
11039 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
11043 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
11044 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
11046 if (integer_zerop (icond
))
11048 if (code
== EQ_EXPR
)
11049 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
11051 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
11055 if (code
== NE_EXPR
)
11056 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
11058 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
11069 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
11070 if (tem
!= NULL_TREE
)
11073 /* Transform comparisons of the form X +- C CMP X. */
11074 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
11075 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11076 && ((TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
11077 && !HONOR_SNANS (arg0
))
11078 || (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
11079 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))))
11081 tree arg01
= TREE_OPERAND (arg0
, 1);
11082 enum tree_code code0
= TREE_CODE (arg0
);
11085 if (TREE_CODE (arg01
) == REAL_CST
)
11086 is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
11088 is_positive
= tree_int_cst_sgn (arg01
);
11090 /* (X - c) > X becomes false. */
11091 if (code
== GT_EXPR
11092 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
11093 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
11095 if (TREE_CODE (arg01
) == INTEGER_CST
11096 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11097 fold_overflow_warning (("assuming signed overflow does not "
11098 "occur when assuming that (X - c) > X "
11099 "is always false"),
11100 WARN_STRICT_OVERFLOW_ALL
);
11101 return constant_boolean_node (0, type
);
11104 /* Likewise (X + c) < X becomes false. */
11105 if (code
== LT_EXPR
11106 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
11107 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
11109 if (TREE_CODE (arg01
) == INTEGER_CST
11110 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11111 fold_overflow_warning (("assuming signed overflow does not "
11112 "occur when assuming that "
11113 "(X + c) < X is always false"),
11114 WARN_STRICT_OVERFLOW_ALL
);
11115 return constant_boolean_node (0, type
);
11118 /* Convert (X - c) <= X to true. */
11119 if (!HONOR_NANS (arg1
)
11121 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
11122 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
11124 if (TREE_CODE (arg01
) == INTEGER_CST
11125 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11126 fold_overflow_warning (("assuming signed overflow does not "
11127 "occur when assuming that "
11128 "(X - c) <= X is always true"),
11129 WARN_STRICT_OVERFLOW_ALL
);
11130 return constant_boolean_node (1, type
);
11133 /* Convert (X + c) >= X to true. */
11134 if (!HONOR_NANS (arg1
)
11136 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
11137 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
11139 if (TREE_CODE (arg01
) == INTEGER_CST
11140 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11141 fold_overflow_warning (("assuming signed overflow does not "
11142 "occur when assuming that "
11143 "(X + c) >= X is always true"),
11144 WARN_STRICT_OVERFLOW_ALL
);
11145 return constant_boolean_node (1, type
);
11148 if (TREE_CODE (arg01
) == INTEGER_CST
)
11150 /* Convert X + c > X and X - c < X to true for integers. */
11151 if (code
== GT_EXPR
11152 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
11153 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
11155 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11156 fold_overflow_warning (("assuming signed overflow does "
11157 "not occur when assuming that "
11158 "(X + c) > X is always true"),
11159 WARN_STRICT_OVERFLOW_ALL
);
11160 return constant_boolean_node (1, type
);
11163 if (code
== LT_EXPR
11164 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
11165 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
11167 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11168 fold_overflow_warning (("assuming signed overflow does "
11169 "not occur when assuming that "
11170 "(X - c) < X is always true"),
11171 WARN_STRICT_OVERFLOW_ALL
);
11172 return constant_boolean_node (1, type
);
11175 /* Convert X + c <= X and X - c >= X to false for integers. */
11176 if (code
== LE_EXPR
11177 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
11178 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
11180 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11181 fold_overflow_warning (("assuming signed overflow does "
11182 "not occur when assuming that "
11183 "(X + c) <= X is always false"),
11184 WARN_STRICT_OVERFLOW_ALL
);
11185 return constant_boolean_node (0, type
);
11188 if (code
== GE_EXPR
11189 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
11190 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
11192 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
11193 fold_overflow_warning (("assuming signed overflow does "
11194 "not occur when assuming that "
11195 "(X - c) >= X is always false"),
11196 WARN_STRICT_OVERFLOW_ALL
);
11197 return constant_boolean_node (0, type
);
11202 /* If we are comparing an ABS_EXPR with a constant, we can
11203 convert all the cases into explicit comparisons, but they may
11204 well not be faster than doing the ABS and one comparison.
11205 But ABS (X) <= C is a range comparison, which becomes a subtraction
11206 and a comparison, and is probably faster. */
11207 if (code
== LE_EXPR
11208 && TREE_CODE (arg1
) == INTEGER_CST
11209 && TREE_CODE (arg0
) == ABS_EXPR
11210 && ! TREE_SIDE_EFFECTS (arg0
)
11211 && (0 != (tem
= negate_expr (arg1
)))
11212 && TREE_CODE (tem
) == INTEGER_CST
11213 && !TREE_OVERFLOW (tem
))
11214 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
11215 build2 (GE_EXPR
, type
,
11216 TREE_OPERAND (arg0
, 0), tem
),
11217 build2 (LE_EXPR
, type
,
11218 TREE_OPERAND (arg0
, 0), arg1
));
11220 /* Convert ABS_EXPR<x> >= 0 to true. */
11221 strict_overflow_p
= false;
11222 if (code
== GE_EXPR
11223 && (integer_zerop (arg1
)
11224 || (! HONOR_NANS (arg0
)
11225 && real_zerop (arg1
)))
11226 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11228 if (strict_overflow_p
)
11229 fold_overflow_warning (("assuming signed overflow does not occur "
11230 "when simplifying comparison of "
11231 "absolute value and zero"),
11232 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11233 return omit_one_operand_loc (loc
, type
,
11234 constant_boolean_node (true, type
),
11238 /* Convert ABS_EXPR<x> < 0 to false. */
11239 strict_overflow_p
= false;
11240 if (code
== LT_EXPR
11241 && (integer_zerop (arg1
) || real_zerop (arg1
))
11242 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11244 if (strict_overflow_p
)
11245 fold_overflow_warning (("assuming signed overflow does not occur "
11246 "when simplifying comparison of "
11247 "absolute value and zero"),
11248 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11249 return omit_one_operand_loc (loc
, type
,
11250 constant_boolean_node (false, type
),
11254 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11255 and similarly for >= into !=. */
11256 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11257 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11258 && TREE_CODE (arg1
) == LSHIFT_EXPR
11259 && integer_onep (TREE_OPERAND (arg1
, 0)))
11260 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11261 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11262 TREE_OPERAND (arg1
, 1)),
11263 build_zero_cst (TREE_TYPE (arg0
)));
11265 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11266 otherwise Y might be >= # of bits in X's type and thus e.g.
11267 (unsigned char) (1 << Y) for Y 15 might be 0.
11268 If the cast is widening, then 1 << Y should have unsigned type,
11269 otherwise if Y is number of bits in the signed shift type minus 1,
11270 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11271 31 might be 0xffffffff80000000. */
11272 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11273 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11274 && CONVERT_EXPR_P (arg1
)
11275 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
11276 && (element_precision (TREE_TYPE (arg1
))
11277 >= element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
11278 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
11279 || (element_precision (TREE_TYPE (arg1
))
11280 == element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
11281 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
11283 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11284 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
11285 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11286 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
11287 build_zero_cst (TREE_TYPE (arg0
)));
11292 case UNORDERED_EXPR
:
11300 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11302 tree targ0
= strip_float_extensions (arg0
);
11303 tree targ1
= strip_float_extensions (arg1
);
11304 tree newtype
= TREE_TYPE (targ0
);
11306 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
11307 newtype
= TREE_TYPE (targ1
);
11309 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
11310 return fold_build2_loc (loc
, code
, type
,
11311 fold_convert_loc (loc
, newtype
, targ0
),
11312 fold_convert_loc (loc
, newtype
, targ1
));
11317 case COMPOUND_EXPR
:
11318 /* When pedantic, a compound expression can be neither an lvalue
11319 nor an integer constant expression. */
11320 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
11322 /* Don't let (0, 0) be null pointer constant. */
11323 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
11324 : fold_convert_loc (loc
, type
, arg1
);
11325 return pedantic_non_lvalue_loc (loc
, tem
);
11328 /* An ASSERT_EXPR should never be passed to fold_binary. */
11329 gcc_unreachable ();
11333 } /* switch (code) */
11336 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11337 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
11341 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
11343 switch (TREE_CODE (*tp
))
11349 *walk_subtrees
= 0;
11351 /* ... fall through ... */
11358 /* Return whether the sub-tree ST contains a label which is accessible from
11359 outside the sub-tree. */
11362 contains_label_p (tree st
)
11365 (walk_tree_without_duplicates (&st
, contains_label_1
, NULL
) != NULL_TREE
);
11368 /* Fold a ternary expression of code CODE and type TYPE with operands
11369 OP0, OP1, and OP2. Return the folded expression if folding is
11370 successful. Otherwise, return NULL_TREE. */
11373 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
11374 tree op0
, tree op1
, tree op2
)
11377 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
11378 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11380 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
11381 && TREE_CODE_LENGTH (code
) == 3);
11383 /* If this is a commutative operation, and OP0 is a constant, move it
11384 to OP1 to reduce the number of tests below. */
11385 if (commutative_ternary_tree_code (code
)
11386 && tree_swap_operands_p (op0
, op1
, true))
11387 return fold_build3_loc (loc
, code
, type
, op1
, op0
, op2
);
11389 tem
= generic_simplify (loc
, code
, type
, op0
, op1
, op2
);
11393 /* Strip any conversions that don't change the mode. This is safe
11394 for every expression, except for a comparison expression because
11395 its signedness is derived from its operands. So, in the latter
11396 case, only strip conversions that don't change the signedness.
11398 Note that this is done as an internal manipulation within the
11399 constant folder, in order to find the simplest representation of
11400 the arguments so that their form can be studied. In any cases,
11401 the appropriate type conversions should be put back in the tree
11402 that will get out of the constant folder. */
11423 case COMPONENT_REF
:
11424 if (TREE_CODE (arg0
) == CONSTRUCTOR
11425 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
11427 unsigned HOST_WIDE_INT idx
;
11429 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
11436 case VEC_COND_EXPR
:
11437 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11438 so all simple results must be passed through pedantic_non_lvalue. */
11439 if (TREE_CODE (arg0
) == INTEGER_CST
)
11441 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
11442 tem
= integer_zerop (arg0
) ? op2
: op1
;
11443 /* Only optimize constant conditions when the selected branch
11444 has the same type as the COND_EXPR. This avoids optimizing
11445 away "c ? x : throw", where the throw has a void type.
11446 Avoid throwing away that operand which contains label. */
11447 if ((!TREE_SIDE_EFFECTS (unused_op
)
11448 || !contains_label_p (unused_op
))
11449 && (! VOID_TYPE_P (TREE_TYPE (tem
))
11450 || VOID_TYPE_P (type
)))
11451 return pedantic_non_lvalue_loc (loc
, tem
);
11454 else if (TREE_CODE (arg0
) == VECTOR_CST
)
11456 if ((TREE_CODE (arg1
) == VECTOR_CST
11457 || TREE_CODE (arg1
) == CONSTRUCTOR
)
11458 && (TREE_CODE (arg2
) == VECTOR_CST
11459 || TREE_CODE (arg2
) == CONSTRUCTOR
))
11461 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
11462 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
11463 gcc_assert (nelts
== VECTOR_CST_NELTS (arg0
));
11464 for (i
= 0; i
< nelts
; i
++)
11466 tree val
= VECTOR_CST_ELT (arg0
, i
);
11467 if (integer_all_onesp (val
))
11469 else if (integer_zerop (val
))
11470 sel
[i
] = nelts
+ i
;
11471 else /* Currently unreachable. */
11474 tree t
= fold_vec_perm (type
, arg1
, arg2
, sel
);
11475 if (t
!= NULL_TREE
)
11480 /* If we have A op B ? A : C, we may be able to convert this to a
11481 simpler expression, depending on the operation and the values
11482 of B and C. Signed zeros prevent all of these transformations,
11483 for reasons given above each one.
11485 Also try swapping the arguments and inverting the conditional. */
11486 if (COMPARISON_CLASS_P (arg0
)
11487 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
11488 arg1
, TREE_OPERAND (arg0
, 1))
11489 && !HONOR_SIGNED_ZEROS (element_mode (arg1
)))
11491 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
11496 if (COMPARISON_CLASS_P (arg0
)
11497 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
11499 TREE_OPERAND (arg0
, 1))
11500 && !HONOR_SIGNED_ZEROS (element_mode (op2
)))
11502 location_t loc0
= expr_location_or (arg0
, loc
);
11503 tem
= fold_invert_truthvalue (loc0
, arg0
);
11504 if (tem
&& COMPARISON_CLASS_P (tem
))
11506 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
11512 /* If the second operand is simpler than the third, swap them
11513 since that produces better jump optimization results. */
11514 if (truth_value_p (TREE_CODE (arg0
))
11515 && tree_swap_operands_p (op1
, op2
, false))
11517 location_t loc0
= expr_location_or (arg0
, loc
);
11518 /* See if this can be inverted. If it can't, possibly because
11519 it was a floating-point inequality comparison, don't do
11521 tem
= fold_invert_truthvalue (loc0
, arg0
);
11523 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
11526 /* Convert A ? 1 : 0 to simply A. */
11527 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
11528 : (integer_onep (op1
)
11529 && !VECTOR_TYPE_P (type
)))
11530 && integer_zerop (op2
)
11531 /* If we try to convert OP0 to our type, the
11532 call to fold will try to move the conversion inside
11533 a COND, which will recurse. In that case, the COND_EXPR
11534 is probably the best choice, so leave it alone. */
11535 && type
== TREE_TYPE (arg0
))
11536 return pedantic_non_lvalue_loc (loc
, arg0
);
11538 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11539 over COND_EXPR in cases such as floating point comparisons. */
11540 if (integer_zerop (op1
)
11541 && (code
== VEC_COND_EXPR
? integer_all_onesp (op2
)
11542 : (integer_onep (op2
)
11543 && !VECTOR_TYPE_P (type
)))
11544 && truth_value_p (TREE_CODE (arg0
)))
11545 return pedantic_non_lvalue_loc (loc
,
11546 fold_convert_loc (loc
, type
,
11547 invert_truthvalue_loc (loc
,
11550 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11551 if (TREE_CODE (arg0
) == LT_EXPR
11552 && integer_zerop (TREE_OPERAND (arg0
, 1))
11553 && integer_zerop (op2
)
11554 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
11556 /* sign_bit_p looks through both zero and sign extensions,
11557 but for this optimization only sign extensions are
11559 tree tem2
= TREE_OPERAND (arg0
, 0);
11560 while (tem
!= tem2
)
11562 if (TREE_CODE (tem2
) != NOP_EXPR
11563 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
11568 tem2
= TREE_OPERAND (tem2
, 0);
11570 /* sign_bit_p only checks ARG1 bits within A's precision.
11571 If <sign bit of A> has wider type than A, bits outside
11572 of A's precision in <sign bit of A> need to be checked.
11573 If they are all 0, this optimization needs to be done
11574 in unsigned A's type, if they are all 1 in signed A's type,
11575 otherwise this can't be done. */
11577 && TYPE_PRECISION (TREE_TYPE (tem
))
11578 < TYPE_PRECISION (TREE_TYPE (arg1
))
11579 && TYPE_PRECISION (TREE_TYPE (tem
))
11580 < TYPE_PRECISION (type
))
11582 int inner_width
, outer_width
;
11585 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
11586 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
11587 if (outer_width
> TYPE_PRECISION (type
))
11588 outer_width
= TYPE_PRECISION (type
);
11590 wide_int mask
= wi::shifted_mask
11591 (inner_width
, outer_width
- inner_width
, false,
11592 TYPE_PRECISION (TREE_TYPE (arg1
)));
11594 wide_int common
= mask
& arg1
;
11595 if (common
== mask
)
11597 tem_type
= signed_type_for (TREE_TYPE (tem
));
11598 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11600 else if (common
== 0)
11602 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
11603 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11611 fold_convert_loc (loc
, type
,
11612 fold_build2_loc (loc
, BIT_AND_EXPR
,
11613 TREE_TYPE (tem
), tem
,
11614 fold_convert_loc (loc
,
11619 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11620 already handled above. */
11621 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11622 && integer_onep (TREE_OPERAND (arg0
, 1))
11623 && integer_zerop (op2
)
11624 && integer_pow2p (arg1
))
11626 tree tem
= TREE_OPERAND (arg0
, 0);
11628 if (TREE_CODE (tem
) == RSHIFT_EXPR
11629 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
11630 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
) ==
11631 tree_to_uhwi (TREE_OPERAND (tem
, 1)))
11632 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11633 TREE_OPERAND (tem
, 0), arg1
);
11636 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11637 is probably obsolete because the first operand should be a
11638 truth value (that's why we have the two cases above), but let's
11639 leave it in until we can confirm this for all front-ends. */
11640 if (integer_zerop (op2
)
11641 && TREE_CODE (arg0
) == NE_EXPR
11642 && integer_zerop (TREE_OPERAND (arg0
, 1))
11643 && integer_pow2p (arg1
)
11644 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
11645 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
11646 arg1
, OEP_ONLY_CONST
))
11647 return pedantic_non_lvalue_loc (loc
,
11648 fold_convert_loc (loc
, type
,
11649 TREE_OPERAND (arg0
, 0)));
11651 /* Disable the transformations below for vectors, since
11652 fold_binary_op_with_conditional_arg may undo them immediately,
11653 yielding an infinite loop. */
11654 if (code
== VEC_COND_EXPR
)
11657 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11658 if (integer_zerop (op2
)
11659 && truth_value_p (TREE_CODE (arg0
))
11660 && truth_value_p (TREE_CODE (arg1
))
11661 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11662 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
11663 : TRUTH_ANDIF_EXPR
,
11664 type
, fold_convert_loc (loc
, type
, arg0
), arg1
);
11666 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11667 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
11668 && truth_value_p (TREE_CODE (arg0
))
11669 && truth_value_p (TREE_CODE (arg1
))
11670 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11672 location_t loc0
= expr_location_or (arg0
, loc
);
11673 /* Only perform transformation if ARG0 is easily inverted. */
11674 tem
= fold_invert_truthvalue (loc0
, arg0
);
11676 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11679 type
, fold_convert_loc (loc
, type
, tem
),
11683 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11684 if (integer_zerop (arg1
)
11685 && truth_value_p (TREE_CODE (arg0
))
11686 && truth_value_p (TREE_CODE (op2
))
11687 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11689 location_t loc0
= expr_location_or (arg0
, loc
);
11690 /* Only perform transformation if ARG0 is easily inverted. */
11691 tem
= fold_invert_truthvalue (loc0
, arg0
);
11693 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11694 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
11695 type
, fold_convert_loc (loc
, type
, tem
),
11699 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11700 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
11701 && truth_value_p (TREE_CODE (arg0
))
11702 && truth_value_p (TREE_CODE (op2
))
11703 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11704 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11705 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
11706 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
11711 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11712 of fold_ternary on them. */
11713 gcc_unreachable ();
11715 case BIT_FIELD_REF
:
11716 if ((TREE_CODE (arg0
) == VECTOR_CST
11717 || (TREE_CODE (arg0
) == CONSTRUCTOR
11718 && TREE_CODE (TREE_TYPE (arg0
)) == VECTOR_TYPE
))
11719 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
11720 || (TREE_CODE (type
) == VECTOR_TYPE
11721 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
)))))
11723 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
11724 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
11725 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
11726 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
11729 && (idx
% width
) == 0
11730 && (n
% width
) == 0
11731 && ((idx
+ n
) / width
) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)))
11736 if (TREE_CODE (arg0
) == VECTOR_CST
)
11739 return VECTOR_CST_ELT (arg0
, idx
);
11741 tree
*vals
= XALLOCAVEC (tree
, n
);
11742 for (unsigned i
= 0; i
< n
; ++i
)
11743 vals
[i
] = VECTOR_CST_ELT (arg0
, idx
+ i
);
11744 return build_vector (type
, vals
);
11747 /* Constructor elements can be subvectors. */
11748 unsigned HOST_WIDE_INT k
= 1;
11749 if (CONSTRUCTOR_NELTS (arg0
) != 0)
11751 tree cons_elem
= TREE_TYPE (CONSTRUCTOR_ELT (arg0
, 0)->value
);
11752 if (TREE_CODE (cons_elem
) == VECTOR_TYPE
)
11753 k
= TYPE_VECTOR_SUBPARTS (cons_elem
);
11756 /* We keep an exact subset of the constructor elements. */
11757 if ((idx
% k
) == 0 && (n
% k
) == 0)
11759 if (CONSTRUCTOR_NELTS (arg0
) == 0)
11760 return build_constructor (type
, NULL
);
11765 if (idx
< CONSTRUCTOR_NELTS (arg0
))
11766 return CONSTRUCTOR_ELT (arg0
, idx
)->value
;
11767 return build_zero_cst (type
);
11770 vec
<constructor_elt
, va_gc
> *vals
;
11771 vec_alloc (vals
, n
);
11772 for (unsigned i
= 0;
11773 i
< n
&& idx
+ i
< CONSTRUCTOR_NELTS (arg0
);
11775 CONSTRUCTOR_APPEND_ELT (vals
, NULL_TREE
,
11777 (arg0
, idx
+ i
)->value
);
11778 return build_constructor (type
, vals
);
11780 /* The bitfield references a single constructor element. */
11781 else if (idx
+ n
<= (idx
/ k
+ 1) * k
)
11783 if (CONSTRUCTOR_NELTS (arg0
) <= idx
/ k
)
11784 return build_zero_cst (type
);
11786 return CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
;
11788 return fold_build3_loc (loc
, code
, type
,
11789 CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
, op1
,
11790 build_int_cst (TREE_TYPE (op2
), (idx
% k
) * width
));
11795 /* A bit-field-ref that referenced the full argument can be stripped. */
11796 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
11797 && TYPE_PRECISION (TREE_TYPE (arg0
)) == tree_to_uhwi (arg1
)
11798 && integer_zerop (op2
))
11799 return fold_convert_loc (loc
, type
, arg0
);
11801 /* On constants we can use native encode/interpret to constant
11802 fold (nearly) all BIT_FIELD_REFs. */
11803 if (CONSTANT_CLASS_P (arg0
)
11804 && can_native_interpret_type_p (type
)
11805 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)))
11806 /* This limitation should not be necessary, we just need to
11807 round this up to mode size. */
11808 && tree_to_uhwi (op1
) % BITS_PER_UNIT
== 0
11809 /* Need bit-shifting of the buffer to relax the following. */
11810 && tree_to_uhwi (op2
) % BITS_PER_UNIT
== 0)
11812 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11813 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
11814 unsigned HOST_WIDE_INT clen
;
11815 clen
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)));
11816 /* ??? We cannot tell native_encode_expr to start at
11817 some random byte only. So limit us to a reasonable amount
11821 unsigned char *b
= XALLOCAVEC (unsigned char, clen
);
11822 unsigned HOST_WIDE_INT len
= native_encode_expr (arg0
, b
, clen
);
11824 && len
* BITS_PER_UNIT
>= bitpos
+ bitsize
)
11826 tree v
= native_interpret_expr (type
,
11827 b
+ bitpos
/ BITS_PER_UNIT
,
11828 bitsize
/ BITS_PER_UNIT
);
11838 /* For integers we can decompose the FMA if possible. */
11839 if (TREE_CODE (arg0
) == INTEGER_CST
11840 && TREE_CODE (arg1
) == INTEGER_CST
)
11841 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
11842 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
11843 if (integer_zerop (arg2
))
11844 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
11846 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
11848 case VEC_PERM_EXPR
:
11849 if (TREE_CODE (arg2
) == VECTOR_CST
)
11851 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
, mask
, mask2
;
11852 unsigned char *sel
= XALLOCAVEC (unsigned char, 2 * nelts
);
11853 unsigned char *sel2
= sel
+ nelts
;
11854 bool need_mask_canon
= false;
11855 bool need_mask_canon2
= false;
11856 bool all_in_vec0
= true;
11857 bool all_in_vec1
= true;
11858 bool maybe_identity
= true;
11859 bool single_arg
= (op0
== op1
);
11860 bool changed
= false;
11862 mask2
= 2 * nelts
- 1;
11863 mask
= single_arg
? (nelts
- 1) : mask2
;
11864 gcc_assert (nelts
== VECTOR_CST_NELTS (arg2
));
11865 for (i
= 0; i
< nelts
; i
++)
11867 tree val
= VECTOR_CST_ELT (arg2
, i
);
11868 if (TREE_CODE (val
) != INTEGER_CST
)
11871 /* Make sure that the perm value is in an acceptable
11874 need_mask_canon
|= wi::gtu_p (t
, mask
);
11875 need_mask_canon2
|= wi::gtu_p (t
, mask2
);
11876 sel
[i
] = t
.to_uhwi () & mask
;
11877 sel2
[i
] = t
.to_uhwi () & mask2
;
11879 if (sel
[i
] < nelts
)
11880 all_in_vec1
= false;
11882 all_in_vec0
= false;
11884 if ((sel
[i
] & (nelts
-1)) != i
)
11885 maybe_identity
= false;
11888 if (maybe_identity
)
11898 else if (all_in_vec1
)
11901 for (i
= 0; i
< nelts
; i
++)
11903 need_mask_canon
= true;
11906 if ((TREE_CODE (op0
) == VECTOR_CST
11907 || TREE_CODE (op0
) == CONSTRUCTOR
)
11908 && (TREE_CODE (op1
) == VECTOR_CST
11909 || TREE_CODE (op1
) == CONSTRUCTOR
))
11911 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
11912 if (t
!= NULL_TREE
)
11916 if (op0
== op1
&& !single_arg
)
11919 /* Some targets are deficient and fail to expand a single
11920 argument permutation while still allowing an equivalent
11921 2-argument version. */
11922 if (need_mask_canon
&& arg2
== op2
11923 && !can_vec_perm_p (TYPE_MODE (type
), false, sel
)
11924 && can_vec_perm_p (TYPE_MODE (type
), false, sel2
))
11926 need_mask_canon
= need_mask_canon2
;
11930 if (need_mask_canon
&& arg2
== op2
)
11932 tree
*tsel
= XALLOCAVEC (tree
, nelts
);
11933 tree eltype
= TREE_TYPE (TREE_TYPE (arg2
));
11934 for (i
= 0; i
< nelts
; i
++)
11935 tsel
[i
] = build_int_cst (eltype
, sel
[i
]);
11936 op2
= build_vector (TREE_TYPE (arg2
), tsel
);
11941 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
11947 } /* switch (code) */
11950 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
11951 of an array (or vector). */
11954 get_array_ctor_element_at_index (tree ctor
, offset_int access_index
)
11956 tree index_type
= NULL_TREE
;
11957 offset_int low_bound
= 0;
11959 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
11961 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
11962 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
11964 /* Static constructors for variably sized objects makes no sense. */
11965 gcc_assert (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) == INTEGER_CST
);
11966 index_type
= TREE_TYPE (TYPE_MIN_VALUE (domain_type
));
11967 low_bound
= wi::to_offset (TYPE_MIN_VALUE (domain_type
));
11972 access_index
= wi::ext (access_index
, TYPE_PRECISION (index_type
),
11973 TYPE_SIGN (index_type
));
11975 offset_int index
= low_bound
- 1;
11977 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11978 TYPE_SIGN (index_type
));
11980 offset_int max_index
;
11981 unsigned HOST_WIDE_INT cnt
;
11984 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
, cval
)
11986 /* Array constructor might explicitly set index, or specify a range,
11987 or leave index NULL meaning that it is next index after previous
11991 if (TREE_CODE (cfield
) == INTEGER_CST
)
11992 max_index
= index
= wi::to_offset (cfield
);
11995 gcc_assert (TREE_CODE (cfield
) == RANGE_EXPR
);
11996 index
= wi::to_offset (TREE_OPERAND (cfield
, 0));
11997 max_index
= wi::to_offset (TREE_OPERAND (cfield
, 1));
12004 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
12005 TYPE_SIGN (index_type
));
12009 /* Do we have match? */
12010 if (wi::cmpu (access_index
, index
) >= 0
12011 && wi::cmpu (access_index
, max_index
) <= 0)
12017 /* Perform constant folding and related simplification of EXPR.
12018 The related simplifications include x*1 => x, x*0 => 0, etc.,
12019 and application of the associative law.
12020 NOP_EXPR conversions may be removed freely (as long as we
12021 are careful not to change the type of the overall expression).
12022 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
12023 but we can constant-fold them if they have constant operands. */
12025 #ifdef ENABLE_FOLD_CHECKING
12026 # define fold(x) fold_1 (x)
12027 static tree
fold_1 (tree
);
12033 const tree t
= expr
;
12034 enum tree_code code
= TREE_CODE (t
);
12035 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
12037 location_t loc
= EXPR_LOCATION (expr
);
12039 /* Return right away if a constant. */
12040 if (kind
== tcc_constant
)
12043 /* CALL_EXPR-like objects with variable numbers of operands are
12044 treated specially. */
12045 if (kind
== tcc_vl_exp
)
12047 if (code
== CALL_EXPR
)
12049 tem
= fold_call_expr (loc
, expr
, false);
12050 return tem
? tem
: expr
;
12055 if (IS_EXPR_CODE_CLASS (kind
))
12057 tree type
= TREE_TYPE (t
);
12058 tree op0
, op1
, op2
;
12060 switch (TREE_CODE_LENGTH (code
))
12063 op0
= TREE_OPERAND (t
, 0);
12064 tem
= fold_unary_loc (loc
, code
, type
, op0
);
12065 return tem
? tem
: expr
;
12067 op0
= TREE_OPERAND (t
, 0);
12068 op1
= TREE_OPERAND (t
, 1);
12069 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
12070 return tem
? tem
: expr
;
12072 op0
= TREE_OPERAND (t
, 0);
12073 op1
= TREE_OPERAND (t
, 1);
12074 op2
= TREE_OPERAND (t
, 2);
12075 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
12076 return tem
? tem
: expr
;
12086 tree op0
= TREE_OPERAND (t
, 0);
12087 tree op1
= TREE_OPERAND (t
, 1);
12089 if (TREE_CODE (op1
) == INTEGER_CST
12090 && TREE_CODE (op0
) == CONSTRUCTOR
12091 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
12093 tree val
= get_array_ctor_element_at_index (op0
,
12094 wi::to_offset (op1
));
12102 /* Return a VECTOR_CST if possible. */
12105 tree type
= TREE_TYPE (t
);
12106 if (TREE_CODE (type
) != VECTOR_TYPE
)
12111 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
12112 if (! CONSTANT_CLASS_P (val
))
12115 return build_vector_from_ctor (type
, CONSTRUCTOR_ELTS (t
));
12119 return fold (DECL_INITIAL (t
));
12123 } /* switch (code) */
12126 #ifdef ENABLE_FOLD_CHECKING
12129 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
12130 hash_table
<nofree_ptr_hash
<const tree_node
> > *);
12131 static void fold_check_failed (const_tree
, const_tree
);
12132 void print_fold_checksum (const_tree
);
12134 /* When --enable-checking=fold, compute a digest of expr before
12135 and after actual fold call to see if fold did not accidentally
12136 change original expr. */
12142 struct md5_ctx ctx
;
12143 unsigned char checksum_before
[16], checksum_after
[16];
12144 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12146 md5_init_ctx (&ctx
);
12147 fold_checksum_tree (expr
, &ctx
, &ht
);
12148 md5_finish_ctx (&ctx
, checksum_before
);
12151 ret
= fold_1 (expr
);
12153 md5_init_ctx (&ctx
);
12154 fold_checksum_tree (expr
, &ctx
, &ht
);
12155 md5_finish_ctx (&ctx
, checksum_after
);
12157 if (memcmp (checksum_before
, checksum_after
, 16))
12158 fold_check_failed (expr
, ret
);
12164 print_fold_checksum (const_tree expr
)
12166 struct md5_ctx ctx
;
12167 unsigned char checksum
[16], cnt
;
12168 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12170 md5_init_ctx (&ctx
);
12171 fold_checksum_tree (expr
, &ctx
, &ht
);
12172 md5_finish_ctx (&ctx
, checksum
);
12173 for (cnt
= 0; cnt
< 16; ++cnt
)
12174 fprintf (stderr
, "%02x", checksum
[cnt
]);
12175 putc ('\n', stderr
);
12179 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
12181 internal_error ("fold check: original tree changed by fold");
12185 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
12186 hash_table
<nofree_ptr_hash
<const tree_node
> > *ht
)
12188 const tree_node
**slot
;
12189 enum tree_code code
;
12190 union tree_node buf
;
12196 slot
= ht
->find_slot (expr
, INSERT
);
12200 code
= TREE_CODE (expr
);
12201 if (TREE_CODE_CLASS (code
) == tcc_declaration
12202 && HAS_DECL_ASSEMBLER_NAME_P (expr
))
12204 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
12205 memcpy ((char *) &buf
, expr
, tree_size (expr
));
12206 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
12207 buf
.decl_with_vis
.symtab_node
= NULL
;
12208 expr
= (tree
) &buf
;
12210 else if (TREE_CODE_CLASS (code
) == tcc_type
12211 && (TYPE_POINTER_TO (expr
)
12212 || TYPE_REFERENCE_TO (expr
)
12213 || TYPE_CACHED_VALUES_P (expr
)
12214 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
12215 || TYPE_NEXT_VARIANT (expr
)))
12217 /* Allow these fields to be modified. */
12219 memcpy ((char *) &buf
, expr
, tree_size (expr
));
12220 expr
= tmp
= (tree
) &buf
;
12221 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
12222 TYPE_POINTER_TO (tmp
) = NULL
;
12223 TYPE_REFERENCE_TO (tmp
) = NULL
;
12224 TYPE_NEXT_VARIANT (tmp
) = NULL
;
12225 if (TYPE_CACHED_VALUES_P (tmp
))
12227 TYPE_CACHED_VALUES_P (tmp
) = 0;
12228 TYPE_CACHED_VALUES (tmp
) = NULL
;
12231 md5_process_bytes (expr
, tree_size (expr
), ctx
);
12232 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
12233 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
12234 if (TREE_CODE_CLASS (code
) != tcc_type
12235 && TREE_CODE_CLASS (code
) != tcc_declaration
12236 && code
!= TREE_LIST
12237 && code
!= SSA_NAME
12238 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
12239 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
12240 switch (TREE_CODE_CLASS (code
))
12246 md5_process_bytes (TREE_STRING_POINTER (expr
),
12247 TREE_STRING_LENGTH (expr
), ctx
);
12250 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
12251 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
12254 for (i
= 0; i
< (int) VECTOR_CST_NELTS (expr
); ++i
)
12255 fold_checksum_tree (VECTOR_CST_ELT (expr
, i
), ctx
, ht
);
12261 case tcc_exceptional
:
12265 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
12266 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
12267 expr
= TREE_CHAIN (expr
);
12268 goto recursive_label
;
12271 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
12272 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
12278 case tcc_expression
:
12279 case tcc_reference
:
12280 case tcc_comparison
:
12283 case tcc_statement
:
12285 len
= TREE_OPERAND_LENGTH (expr
);
12286 for (i
= 0; i
< len
; ++i
)
12287 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
12289 case tcc_declaration
:
12290 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
12291 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
12292 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
12294 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
12295 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
12296 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
12297 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
12298 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
12301 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
12303 if (TREE_CODE (expr
) == FUNCTION_DECL
)
12305 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
12306 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
12308 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
12312 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
12313 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
12314 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
12315 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
12316 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
12317 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
12318 if (INTEGRAL_TYPE_P (expr
)
12319 || SCALAR_FLOAT_TYPE_P (expr
))
12321 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
12322 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
12324 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
12325 if (TREE_CODE (expr
) == RECORD_TYPE
12326 || TREE_CODE (expr
) == UNION_TYPE
12327 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
12328 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
12329 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
12336 /* Helper function for outputting the checksum of a tree T. When
12337 debugging with gdb, you can "define mynext" to be "next" followed
12338 by "call debug_fold_checksum (op0)", then just trace down till the
12341 DEBUG_FUNCTION
void
12342 debug_fold_checksum (const_tree t
)
12345 unsigned char checksum
[16];
12346 struct md5_ctx ctx
;
12347 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12349 md5_init_ctx (&ctx
);
12350 fold_checksum_tree (t
, &ctx
, &ht
);
12351 md5_finish_ctx (&ctx
, checksum
);
12354 for (i
= 0; i
< 16; i
++)
12355 fprintf (stderr
, "%d ", checksum
[i
]);
12357 fprintf (stderr
, "\n");
12362 /* Fold a unary tree expression with code CODE of type TYPE with an
12363 operand OP0. LOC is the location of the resulting expression.
12364 Return a folded expression if successful. Otherwise, return a tree
12365 expression with code CODE of type TYPE with an operand OP0. */
12368 fold_build1_stat_loc (location_t loc
,
12369 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
12372 #ifdef ENABLE_FOLD_CHECKING
12373 unsigned char checksum_before
[16], checksum_after
[16];
12374 struct md5_ctx ctx
;
12375 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12377 md5_init_ctx (&ctx
);
12378 fold_checksum_tree (op0
, &ctx
, &ht
);
12379 md5_finish_ctx (&ctx
, checksum_before
);
12383 tem
= fold_unary_loc (loc
, code
, type
, op0
);
12385 tem
= build1_stat_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
12387 #ifdef ENABLE_FOLD_CHECKING
12388 md5_init_ctx (&ctx
);
12389 fold_checksum_tree (op0
, &ctx
, &ht
);
12390 md5_finish_ctx (&ctx
, checksum_after
);
12392 if (memcmp (checksum_before
, checksum_after
, 16))
12393 fold_check_failed (op0
, tem
);
12398 /* Fold a binary tree expression with code CODE of type TYPE with
12399 operands OP0 and OP1. LOC is the location of the resulting
12400 expression. Return a folded expression if successful. Otherwise,
12401 return a tree expression with code CODE of type TYPE with operands
12405 fold_build2_stat_loc (location_t loc
,
12406 enum tree_code code
, tree type
, tree op0
, tree op1
12410 #ifdef ENABLE_FOLD_CHECKING
12411 unsigned char checksum_before_op0
[16],
12412 checksum_before_op1
[16],
12413 checksum_after_op0
[16],
12414 checksum_after_op1
[16];
12415 struct md5_ctx ctx
;
12416 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12418 md5_init_ctx (&ctx
);
12419 fold_checksum_tree (op0
, &ctx
, &ht
);
12420 md5_finish_ctx (&ctx
, checksum_before_op0
);
12423 md5_init_ctx (&ctx
);
12424 fold_checksum_tree (op1
, &ctx
, &ht
);
12425 md5_finish_ctx (&ctx
, checksum_before_op1
);
12429 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
12431 tem
= build2_stat_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
12433 #ifdef ENABLE_FOLD_CHECKING
12434 md5_init_ctx (&ctx
);
12435 fold_checksum_tree (op0
, &ctx
, &ht
);
12436 md5_finish_ctx (&ctx
, checksum_after_op0
);
12439 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12440 fold_check_failed (op0
, tem
);
12442 md5_init_ctx (&ctx
);
12443 fold_checksum_tree (op1
, &ctx
, &ht
);
12444 md5_finish_ctx (&ctx
, checksum_after_op1
);
12446 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12447 fold_check_failed (op1
, tem
);
12452 /* Fold a ternary tree expression with code CODE of type TYPE with
12453 operands OP0, OP1, and OP2. Return a folded expression if
12454 successful. Otherwise, return a tree expression with code CODE of
12455 type TYPE with operands OP0, OP1, and OP2. */
12458 fold_build3_stat_loc (location_t loc
, enum tree_code code
, tree type
,
12459 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
12462 #ifdef ENABLE_FOLD_CHECKING
12463 unsigned char checksum_before_op0
[16],
12464 checksum_before_op1
[16],
12465 checksum_before_op2
[16],
12466 checksum_after_op0
[16],
12467 checksum_after_op1
[16],
12468 checksum_after_op2
[16];
12469 struct md5_ctx ctx
;
12470 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12472 md5_init_ctx (&ctx
);
12473 fold_checksum_tree (op0
, &ctx
, &ht
);
12474 md5_finish_ctx (&ctx
, checksum_before_op0
);
12477 md5_init_ctx (&ctx
);
12478 fold_checksum_tree (op1
, &ctx
, &ht
);
12479 md5_finish_ctx (&ctx
, checksum_before_op1
);
12482 md5_init_ctx (&ctx
);
12483 fold_checksum_tree (op2
, &ctx
, &ht
);
12484 md5_finish_ctx (&ctx
, checksum_before_op2
);
12488 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
12489 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
12491 tem
= build3_stat_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
12493 #ifdef ENABLE_FOLD_CHECKING
12494 md5_init_ctx (&ctx
);
12495 fold_checksum_tree (op0
, &ctx
, &ht
);
12496 md5_finish_ctx (&ctx
, checksum_after_op0
);
12499 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12500 fold_check_failed (op0
, tem
);
12502 md5_init_ctx (&ctx
);
12503 fold_checksum_tree (op1
, &ctx
, &ht
);
12504 md5_finish_ctx (&ctx
, checksum_after_op1
);
12507 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12508 fold_check_failed (op1
, tem
);
12510 md5_init_ctx (&ctx
);
12511 fold_checksum_tree (op2
, &ctx
, &ht
);
12512 md5_finish_ctx (&ctx
, checksum_after_op2
);
12514 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
12515 fold_check_failed (op2
, tem
);
12520 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12521 arguments in ARGARRAY, and a null static chain.
12522 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12523 of type TYPE from the given operands as constructed by build_call_array. */
12526 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
12527 int nargs
, tree
*argarray
)
12530 #ifdef ENABLE_FOLD_CHECKING
12531 unsigned char checksum_before_fn
[16],
12532 checksum_before_arglist
[16],
12533 checksum_after_fn
[16],
12534 checksum_after_arglist
[16];
12535 struct md5_ctx ctx
;
12536 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12539 md5_init_ctx (&ctx
);
12540 fold_checksum_tree (fn
, &ctx
, &ht
);
12541 md5_finish_ctx (&ctx
, checksum_before_fn
);
12544 md5_init_ctx (&ctx
);
12545 for (i
= 0; i
< nargs
; i
++)
12546 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12547 md5_finish_ctx (&ctx
, checksum_before_arglist
);
12551 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
12553 tem
= build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12555 #ifdef ENABLE_FOLD_CHECKING
12556 md5_init_ctx (&ctx
);
12557 fold_checksum_tree (fn
, &ctx
, &ht
);
12558 md5_finish_ctx (&ctx
, checksum_after_fn
);
12561 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
12562 fold_check_failed (fn
, tem
);
12564 md5_init_ctx (&ctx
);
12565 for (i
= 0; i
< nargs
; i
++)
12566 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12567 md5_finish_ctx (&ctx
, checksum_after_arglist
);
12569 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
12570 fold_check_failed (NULL_TREE
, tem
);
12575 /* Perform constant folding and related simplification of initializer
12576 expression EXPR. These behave identically to "fold_buildN" but ignore
12577 potential run-time traps and exceptions that fold must preserve. */
12579 #define START_FOLD_INIT \
12580 int saved_signaling_nans = flag_signaling_nans;\
12581 int saved_trapping_math = flag_trapping_math;\
12582 int saved_rounding_math = flag_rounding_math;\
12583 int saved_trapv = flag_trapv;\
12584 int saved_folding_initializer = folding_initializer;\
12585 flag_signaling_nans = 0;\
12586 flag_trapping_math = 0;\
12587 flag_rounding_math = 0;\
12589 folding_initializer = 1;
12591 #define END_FOLD_INIT \
12592 flag_signaling_nans = saved_signaling_nans;\
12593 flag_trapping_math = saved_trapping_math;\
12594 flag_rounding_math = saved_rounding_math;\
12595 flag_trapv = saved_trapv;\
12596 folding_initializer = saved_folding_initializer;
12599 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
12600 tree type
, tree op
)
12605 result
= fold_build1_loc (loc
, code
, type
, op
);
12612 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
12613 tree type
, tree op0
, tree op1
)
12618 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
12625 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
12626 int nargs
, tree
*argarray
)
12631 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12637 #undef START_FOLD_INIT
12638 #undef END_FOLD_INIT
12640 /* Determine if first argument is a multiple of second argument. Return 0 if
12641 it is not, or we cannot easily determined it to be.
12643 An example of the sort of thing we care about (at this point; this routine
12644 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12645 fold cases do now) is discovering that
12647 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12653 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12655 This code also handles discovering that
12657 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12659 is a multiple of 8 so we don't have to worry about dealing with a
12660 possible remainder.
12662 Note that we *look* inside a SAVE_EXPR only to determine how it was
12663 calculated; it is not safe for fold to do much of anything else with the
12664 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12665 at run time. For example, the latter example above *cannot* be implemented
12666 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12667 evaluation time of the original SAVE_EXPR is not necessarily the same at
12668 the time the new expression is evaluated. The only optimization of this
12669 sort that would be valid is changing
12671 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12675 SAVE_EXPR (I) * SAVE_EXPR (J)
12677 (where the same SAVE_EXPR (J) is used in the original and the
12678 transformed version). */
12681 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
12683 if (operand_equal_p (top
, bottom
, 0))
12686 if (TREE_CODE (type
) != INTEGER_TYPE
)
12689 switch (TREE_CODE (top
))
12692 /* Bitwise and provides a power of two multiple. If the mask is
12693 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12694 if (!integer_pow2p (bottom
))
12699 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
12700 || multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
12704 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
12705 && multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
12708 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
12712 op1
= TREE_OPERAND (top
, 1);
12713 /* const_binop may not detect overflow correctly,
12714 so check for it explicitly here. */
12715 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
12716 && 0 != (t1
= fold_convert (type
,
12717 const_binop (LSHIFT_EXPR
,
12720 && !TREE_OVERFLOW (t1
))
12721 return multiple_of_p (type
, t1
, bottom
);
12726 /* Can't handle conversions from non-integral or wider integral type. */
12727 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
12728 || (TYPE_PRECISION (type
)
12729 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
12732 /* .. fall through ... */
12735 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
12738 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12739 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
12742 if (TREE_CODE (bottom
) != INTEGER_CST
12743 || integer_zerop (bottom
)
12744 || (TYPE_UNSIGNED (type
)
12745 && (tree_int_cst_sgn (top
) < 0
12746 || tree_int_cst_sgn (bottom
) < 0)))
12748 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
12756 #define tree_expr_nonnegative_warnv_p(X, Y) \
12757 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
12759 #define RECURSE(X) \
12760 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12762 /* Return true if CODE or TYPE is known to be non-negative. */
12765 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
12767 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
12768 && truth_value_p (code
))
12769 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12770 have a signed:1 type (where the value is -1 and 0). */
12775 /* Return true if (CODE OP0) is known to be non-negative. If the return
12776 value is based on the assumption that signed overflow is undefined,
12777 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12778 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12781 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12782 bool *strict_overflow_p
, int depth
)
12784 if (TYPE_UNSIGNED (type
))
12790 /* We can't return 1 if flag_wrapv is set because
12791 ABS_EXPR<INT_MIN> = INT_MIN. */
12792 if (!ANY_INTEGRAL_TYPE_P (type
))
12794 if (TYPE_OVERFLOW_UNDEFINED (type
))
12796 *strict_overflow_p
= true;
12801 case NON_LVALUE_EXPR
:
12803 case FIX_TRUNC_EXPR
:
12804 return RECURSE (op0
);
12808 tree inner_type
= TREE_TYPE (op0
);
12809 tree outer_type
= type
;
12811 if (TREE_CODE (outer_type
) == REAL_TYPE
)
12813 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12814 return RECURSE (op0
);
12815 if (INTEGRAL_TYPE_P (inner_type
))
12817 if (TYPE_UNSIGNED (inner_type
))
12819 return RECURSE (op0
);
12822 else if (INTEGRAL_TYPE_P (outer_type
))
12824 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12825 return RECURSE (op0
);
12826 if (INTEGRAL_TYPE_P (inner_type
))
12827 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
12828 && TYPE_UNSIGNED (inner_type
);
12834 return tree_simple_nonnegative_warnv_p (code
, type
);
12837 /* We don't know sign of `t', so be conservative and return false. */
12841 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12842 value is based on the assumption that signed overflow is undefined,
12843 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12844 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12847 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12848 tree op1
, bool *strict_overflow_p
,
12851 if (TYPE_UNSIGNED (type
))
12856 case POINTER_PLUS_EXPR
:
12858 if (FLOAT_TYPE_P (type
))
12859 return RECURSE (op0
) && RECURSE (op1
);
12861 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12862 both unsigned and at least 2 bits shorter than the result. */
12863 if (TREE_CODE (type
) == INTEGER_TYPE
12864 && TREE_CODE (op0
) == NOP_EXPR
12865 && TREE_CODE (op1
) == NOP_EXPR
)
12867 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
12868 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
12869 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
12870 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
12872 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
12873 TYPE_PRECISION (inner2
)) + 1;
12874 return prec
< TYPE_PRECISION (type
);
12880 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12882 /* x * x is always non-negative for floating point x
12883 or without overflow. */
12884 if (operand_equal_p (op0
, op1
, 0)
12885 || (RECURSE (op0
) && RECURSE (op1
)))
12887 if (ANY_INTEGRAL_TYPE_P (type
)
12888 && TYPE_OVERFLOW_UNDEFINED (type
))
12889 *strict_overflow_p
= true;
12894 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12895 both unsigned and their total bits is shorter than the result. */
12896 if (TREE_CODE (type
) == INTEGER_TYPE
12897 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
12898 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
12900 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
12901 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
12903 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
12904 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
12907 bool unsigned0
= TYPE_UNSIGNED (inner0
);
12908 bool unsigned1
= TYPE_UNSIGNED (inner1
);
12910 if (TREE_CODE (op0
) == INTEGER_CST
)
12911 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
12913 if (TREE_CODE (op1
) == INTEGER_CST
)
12914 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
12916 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
12917 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
12919 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
12920 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
12921 : TYPE_PRECISION (inner0
);
12923 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
12924 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
12925 : TYPE_PRECISION (inner1
);
12927 return precision0
+ precision1
< TYPE_PRECISION (type
);
12934 return RECURSE (op0
) || RECURSE (op1
);
12940 case TRUNC_DIV_EXPR
:
12941 case CEIL_DIV_EXPR
:
12942 case FLOOR_DIV_EXPR
:
12943 case ROUND_DIV_EXPR
:
12944 return RECURSE (op0
) && RECURSE (op1
);
12946 case TRUNC_MOD_EXPR
:
12947 return RECURSE (op0
);
12949 case FLOOR_MOD_EXPR
:
12950 return RECURSE (op1
);
12952 case CEIL_MOD_EXPR
:
12953 case ROUND_MOD_EXPR
:
12955 return tree_simple_nonnegative_warnv_p (code
, type
);
12958 /* We don't know sign of `t', so be conservative and return false. */
12962 /* Return true if T is known to be non-negative. If the return
12963 value is based on the assumption that signed overflow is undefined,
12964 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12965 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12968 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
12970 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
12973 switch (TREE_CODE (t
))
12976 return tree_int_cst_sgn (t
) >= 0;
12979 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
12982 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
12985 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
12988 /* Limit the depth of recursion to avoid quadratic behavior.
12989 This is expected to catch almost all occurrences in practice.
12990 If this code misses important cases that unbounded recursion
12991 would not, passes that need this information could be revised
12992 to provide it through dataflow propagation. */
12993 return (!name_registered_for_update_p (t
)
12994 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
12995 && gimple_stmt_nonnegative_warnv_p (SSA_NAME_DEF_STMT (t
),
12996 strict_overflow_p
, depth
));
12999 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
13003 /* Return true if T is known to be non-negative. If the return
13004 value is based on the assumption that signed overflow is undefined,
13005 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13006 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13009 tree_call_nonnegative_warnv_p (tree type
, combined_fn fn
, tree arg0
, tree arg1
,
13010 bool *strict_overflow_p
, int depth
)
13031 case CFN_BUILT_IN_BSWAP32
:
13032 case CFN_BUILT_IN_BSWAP64
:
13037 /* sqrt(-0.0) is -0.0. */
13038 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
13040 return RECURSE (arg0
);
13066 CASE_CFN_NEARBYINT
:
13073 CASE_CFN_SIGNIFICAND
:
13077 /* True if the 1st argument is nonnegative. */
13078 return RECURSE (arg0
);
13081 /* True if the 1st OR 2nd arguments are nonnegative. */
13082 return RECURSE (arg0
) || RECURSE (arg1
);
13085 /* True if the 1st AND 2nd arguments are nonnegative. */
13086 return RECURSE (arg0
) && RECURSE (arg1
);
13089 /* True if the 2nd argument is nonnegative. */
13090 return RECURSE (arg1
);
13093 /* True if the 1st argument is nonnegative or the second
13094 argument is an even integer. */
13095 if (TREE_CODE (arg1
) == INTEGER_CST
13096 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
13098 return RECURSE (arg0
);
13101 /* True if the 1st argument is nonnegative or the second
13102 argument is an even integer valued real. */
13103 if (TREE_CODE (arg1
) == REAL_CST
)
13108 c
= TREE_REAL_CST (arg1
);
13109 n
= real_to_integer (&c
);
13112 REAL_VALUE_TYPE cint
;
13113 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
13114 if (real_identical (&c
, &cint
))
13118 return RECURSE (arg0
);
13123 return tree_simple_nonnegative_warnv_p (CALL_EXPR
, type
);
13126 /* Return true if T is known to be non-negative. If the return
13127 value is based on the assumption that signed overflow is undefined,
13128 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13129 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13132 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13134 enum tree_code code
= TREE_CODE (t
);
13135 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
13142 tree temp
= TARGET_EXPR_SLOT (t
);
13143 t
= TARGET_EXPR_INITIAL (t
);
13145 /* If the initializer is non-void, then it's a normal expression
13146 that will be assigned to the slot. */
13147 if (!VOID_TYPE_P (t
))
13148 return RECURSE (t
);
13150 /* Otherwise, the initializer sets the slot in some way. One common
13151 way is an assignment statement at the end of the initializer. */
13154 if (TREE_CODE (t
) == BIND_EXPR
)
13155 t
= expr_last (BIND_EXPR_BODY (t
));
13156 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
13157 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
13158 t
= expr_last (TREE_OPERAND (t
, 0));
13159 else if (TREE_CODE (t
) == STATEMENT_LIST
)
13164 if (TREE_CODE (t
) == MODIFY_EXPR
13165 && TREE_OPERAND (t
, 0) == temp
)
13166 return RECURSE (TREE_OPERAND (t
, 1));
13173 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
13174 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
13176 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
13177 get_call_combined_fn (t
),
13180 strict_overflow_p
, depth
);
13182 case COMPOUND_EXPR
:
13184 return RECURSE (TREE_OPERAND (t
, 1));
13187 return RECURSE (expr_last (TREE_OPERAND (t
, 1)));
13190 return RECURSE (TREE_OPERAND (t
, 0));
13193 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
13198 #undef tree_expr_nonnegative_warnv_p
13200 /* Return true if T is known to be non-negative. If the return
13201 value is based on the assumption that signed overflow is undefined,
13202 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13203 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13206 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13208 enum tree_code code
;
13209 if (t
== error_mark_node
)
13212 code
= TREE_CODE (t
);
13213 switch (TREE_CODE_CLASS (code
))
13216 case tcc_comparison
:
13217 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13219 TREE_OPERAND (t
, 0),
13220 TREE_OPERAND (t
, 1),
13221 strict_overflow_p
, depth
);
13224 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13226 TREE_OPERAND (t
, 0),
13227 strict_overflow_p
, depth
);
13230 case tcc_declaration
:
13231 case tcc_reference
:
13232 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13240 case TRUTH_AND_EXPR
:
13241 case TRUTH_OR_EXPR
:
13242 case TRUTH_XOR_EXPR
:
13243 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13245 TREE_OPERAND (t
, 0),
13246 TREE_OPERAND (t
, 1),
13247 strict_overflow_p
, depth
);
13248 case TRUTH_NOT_EXPR
:
13249 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13251 TREE_OPERAND (t
, 0),
13252 strict_overflow_p
, depth
);
13259 case WITH_SIZE_EXPR
:
13261 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13264 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13268 /* Return true if `t' is known to be non-negative. Handle warnings
13269 about undefined signed overflow. */
13272 tree_expr_nonnegative_p (tree t
)
13274 bool ret
, strict_overflow_p
;
13276 strict_overflow_p
= false;
13277 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
13278 if (strict_overflow_p
)
13279 fold_overflow_warning (("assuming signed overflow does not occur when "
13280 "determining that expression is always "
13282 WARN_STRICT_OVERFLOW_MISC
);
13287 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13288 For floating point we further ensure that T is not denormal.
13289 Similar logic is present in nonzero_address in rtlanal.h.
13291 If the return value is based on the assumption that signed overflow
13292 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13293 change *STRICT_OVERFLOW_P. */
13296 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
13297 bool *strict_overflow_p
)
13302 return tree_expr_nonzero_warnv_p (op0
,
13303 strict_overflow_p
);
13307 tree inner_type
= TREE_TYPE (op0
);
13308 tree outer_type
= type
;
13310 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
13311 && tree_expr_nonzero_warnv_p (op0
,
13312 strict_overflow_p
));
13316 case NON_LVALUE_EXPR
:
13317 return tree_expr_nonzero_warnv_p (op0
,
13318 strict_overflow_p
);
13327 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13328 For floating point we further ensure that T is not denormal.
13329 Similar logic is present in nonzero_address in rtlanal.h.
13331 If the return value is based on the assumption that signed overflow
13332 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13333 change *STRICT_OVERFLOW_P. */
13336 tree_binary_nonzero_warnv_p (enum tree_code code
,
13339 tree op1
, bool *strict_overflow_p
)
13341 bool sub_strict_overflow_p
;
13344 case POINTER_PLUS_EXPR
:
13346 if (ANY_INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_UNDEFINED (type
))
13348 /* With the presence of negative values it is hard
13349 to say something. */
13350 sub_strict_overflow_p
= false;
13351 if (!tree_expr_nonnegative_warnv_p (op0
,
13352 &sub_strict_overflow_p
)
13353 || !tree_expr_nonnegative_warnv_p (op1
,
13354 &sub_strict_overflow_p
))
13356 /* One of operands must be positive and the other non-negative. */
13357 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13358 overflows, on a twos-complement machine the sum of two
13359 nonnegative numbers can never be zero. */
13360 return (tree_expr_nonzero_warnv_p (op0
,
13362 || tree_expr_nonzero_warnv_p (op1
,
13363 strict_overflow_p
));
13368 if (TYPE_OVERFLOW_UNDEFINED (type
))
13370 if (tree_expr_nonzero_warnv_p (op0
,
13372 && tree_expr_nonzero_warnv_p (op1
,
13373 strict_overflow_p
))
13375 *strict_overflow_p
= true;
13382 sub_strict_overflow_p
= false;
13383 if (tree_expr_nonzero_warnv_p (op0
,
13384 &sub_strict_overflow_p
)
13385 && tree_expr_nonzero_warnv_p (op1
,
13386 &sub_strict_overflow_p
))
13388 if (sub_strict_overflow_p
)
13389 *strict_overflow_p
= true;
13394 sub_strict_overflow_p
= false;
13395 if (tree_expr_nonzero_warnv_p (op0
,
13396 &sub_strict_overflow_p
))
13398 if (sub_strict_overflow_p
)
13399 *strict_overflow_p
= true;
13401 /* When both operands are nonzero, then MAX must be too. */
13402 if (tree_expr_nonzero_warnv_p (op1
,
13403 strict_overflow_p
))
13406 /* MAX where operand 0 is positive is positive. */
13407 return tree_expr_nonnegative_warnv_p (op0
,
13408 strict_overflow_p
);
13410 /* MAX where operand 1 is positive is positive. */
13411 else if (tree_expr_nonzero_warnv_p (op1
,
13412 &sub_strict_overflow_p
)
13413 && tree_expr_nonnegative_warnv_p (op1
,
13414 &sub_strict_overflow_p
))
13416 if (sub_strict_overflow_p
)
13417 *strict_overflow_p
= true;
13423 return (tree_expr_nonzero_warnv_p (op1
,
13425 || tree_expr_nonzero_warnv_p (op0
,
13426 strict_overflow_p
));
13435 /* Return true when T is an address and is known to be nonzero.
13436 For floating point we further ensure that T is not denormal.
13437 Similar logic is present in nonzero_address in rtlanal.h.
13439 If the return value is based on the assumption that signed overflow
13440 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13441 change *STRICT_OVERFLOW_P. */
13444 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
13446 bool sub_strict_overflow_p
;
13447 switch (TREE_CODE (t
))
13450 return !integer_zerop (t
);
13454 tree base
= TREE_OPERAND (t
, 0);
13456 if (!DECL_P (base
))
13457 base
= get_base_address (base
);
13462 /* For objects in symbol table check if we know they are non-zero.
13463 Don't do anything for variables and functions before symtab is built;
13464 it is quite possible that they will be declared weak later. */
13465 if (DECL_P (base
) && decl_in_symtab_p (base
))
13467 struct symtab_node
*symbol
;
13469 symbol
= symtab_node::get_create (base
);
13471 return symbol
->nonzero_address ();
13476 /* Function local objects are never NULL. */
13478 && (DECL_CONTEXT (base
)
13479 && TREE_CODE (DECL_CONTEXT (base
)) == FUNCTION_DECL
13480 && auto_var_in_fn_p (base
, DECL_CONTEXT (base
))))
13483 /* Constants are never weak. */
13484 if (CONSTANT_CLASS_P (base
))
13491 sub_strict_overflow_p
= false;
13492 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
13493 &sub_strict_overflow_p
)
13494 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
13495 &sub_strict_overflow_p
))
13497 if (sub_strict_overflow_p
)
13498 *strict_overflow_p
= true;
13509 #define integer_valued_real_p(X) \
13510 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
13512 #define RECURSE(X) \
13513 ((integer_valued_real_p) (X, depth + 1))
13515 /* Return true if the floating point result of (CODE OP0) has an
13516 integer value. We also allow +Inf, -Inf and NaN to be considered
13517 integer values. Return false for signaling NaN.
13519 DEPTH is the current nesting depth of the query. */
13522 integer_valued_real_unary_p (tree_code code
, tree op0
, int depth
)
13530 return RECURSE (op0
);
13534 tree type
= TREE_TYPE (op0
);
13535 if (TREE_CODE (type
) == INTEGER_TYPE
)
13537 if (TREE_CODE (type
) == REAL_TYPE
)
13538 return RECURSE (op0
);
13548 /* Return true if the floating point result of (CODE OP0 OP1) has an
13549 integer value. We also allow +Inf, -Inf and NaN to be considered
13550 integer values. Return false for signaling NaN.
13552 DEPTH is the current nesting depth of the query. */
13555 integer_valued_real_binary_p (tree_code code
, tree op0
, tree op1
, int depth
)
13564 return RECURSE (op0
) && RECURSE (op1
);
13572 /* Return true if the floating point result of calling FNDECL with arguments
13573 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13574 considered integer values. Return false for signaling NaN. If FNDECL
13575 takes fewer than 2 arguments, the remaining ARGn are null.
13577 DEPTH is the current nesting depth of the query. */
13580 integer_valued_real_call_p (combined_fn fn
, tree arg0
, tree arg1
, int depth
)
13586 CASE_CFN_NEARBYINT
:
13594 return RECURSE (arg0
) && RECURSE (arg1
);
13602 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13603 has an integer value. We also allow +Inf, -Inf and NaN to be
13604 considered integer values. Return false for signaling NaN.
13606 DEPTH is the current nesting depth of the query. */
13609 integer_valued_real_single_p (tree t
, int depth
)
13611 switch (TREE_CODE (t
))
13614 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
13617 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
13620 /* Limit the depth of recursion to avoid quadratic behavior.
13621 This is expected to catch almost all occurrences in practice.
13622 If this code misses important cases that unbounded recursion
13623 would not, passes that need this information could be revised
13624 to provide it through dataflow propagation. */
13625 return (!name_registered_for_update_p (t
)
13626 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
13627 && gimple_stmt_integer_valued_real_p (SSA_NAME_DEF_STMT (t
),
13636 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13637 has an integer value. We also allow +Inf, -Inf and NaN to be
13638 considered integer values. Return false for signaling NaN.
13640 DEPTH is the current nesting depth of the query. */
13643 integer_valued_real_invalid_p (tree t
, int depth
)
13645 switch (TREE_CODE (t
))
13647 case COMPOUND_EXPR
:
13650 return RECURSE (TREE_OPERAND (t
, 1));
13653 return RECURSE (TREE_OPERAND (t
, 0));
13662 #undef integer_valued_real_p
13664 /* Return true if the floating point expression T has an integer value.
13665 We also allow +Inf, -Inf and NaN to be considered integer values.
13666 Return false for signaling NaN.
13668 DEPTH is the current nesting depth of the query. */
13671 integer_valued_real_p (tree t
, int depth
)
13673 if (t
== error_mark_node
)
13676 tree_code code
= TREE_CODE (t
);
13677 switch (TREE_CODE_CLASS (code
))
13680 case tcc_comparison
:
13681 return integer_valued_real_binary_p (code
, TREE_OPERAND (t
, 0),
13682 TREE_OPERAND (t
, 1), depth
);
13685 return integer_valued_real_unary_p (code
, TREE_OPERAND (t
, 0), depth
);
13688 case tcc_declaration
:
13689 case tcc_reference
:
13690 return integer_valued_real_single_p (t
, depth
);
13700 return integer_valued_real_single_p (t
, depth
);
13704 tree arg0
= (call_expr_nargs (t
) > 0
13705 ? CALL_EXPR_ARG (t
, 0)
13707 tree arg1
= (call_expr_nargs (t
) > 1
13708 ? CALL_EXPR_ARG (t
, 1)
13710 return integer_valued_real_call_p (get_call_combined_fn (t
),
13711 arg0
, arg1
, depth
);
13715 return integer_valued_real_invalid_p (t
, depth
);
13719 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13720 attempt to fold the expression to a constant without modifying TYPE,
13723 If the expression could be simplified to a constant, then return
13724 the constant. If the expression would not be simplified to a
13725 constant, then return NULL_TREE. */
13728 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
13730 tree tem
= fold_binary (code
, type
, op0
, op1
);
13731 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13734 /* Given the components of a unary expression CODE, TYPE and OP0,
13735 attempt to fold the expression to a constant without modifying
13738 If the expression could be simplified to a constant, then return
13739 the constant. If the expression would not be simplified to a
13740 constant, then return NULL_TREE. */
13743 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
13745 tree tem
= fold_unary (code
, type
, op0
);
13746 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13749 /* If EXP represents referencing an element in a constant string
13750 (either via pointer arithmetic or array indexing), return the
13751 tree representing the value accessed, otherwise return NULL. */
13754 fold_read_from_constant_string (tree exp
)
13756 if ((TREE_CODE (exp
) == INDIRECT_REF
13757 || TREE_CODE (exp
) == ARRAY_REF
)
13758 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
13760 tree exp1
= TREE_OPERAND (exp
, 0);
13763 location_t loc
= EXPR_LOCATION (exp
);
13765 if (TREE_CODE (exp
) == INDIRECT_REF
)
13766 string
= string_constant (exp1
, &index
);
13769 tree low_bound
= array_ref_low_bound (exp
);
13770 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
13772 /* Optimize the special-case of a zero lower bound.
13774 We convert the low_bound to sizetype to avoid some problems
13775 with constant folding. (E.g. suppose the lower bound is 1,
13776 and its mode is QI. Without the conversion,l (ARRAY
13777 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13778 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13779 if (! integer_zerop (low_bound
))
13780 index
= size_diffop_loc (loc
, index
,
13781 fold_convert_loc (loc
, sizetype
, low_bound
));
13787 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
13788 && TREE_CODE (string
) == STRING_CST
13789 && TREE_CODE (index
) == INTEGER_CST
13790 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
13791 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))))
13793 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))) == 1))
13794 return build_int_cst_type (TREE_TYPE (exp
),
13795 (TREE_STRING_POINTER (string
)
13796 [TREE_INT_CST_LOW (index
)]));
13801 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13802 an integer constant, real, or fixed-point constant.
13804 TYPE is the type of the result. */
13807 fold_negate_const (tree arg0
, tree type
)
13809 tree t
= NULL_TREE
;
13811 switch (TREE_CODE (arg0
))
13816 wide_int val
= wi::neg (arg0
, &overflow
);
13817 t
= force_fit_type (type
, val
, 1,
13818 (overflow
| TREE_OVERFLOW (arg0
))
13819 && !TYPE_UNSIGNED (type
));
13824 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13829 FIXED_VALUE_TYPE f
;
13830 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
13831 &(TREE_FIXED_CST (arg0
)), NULL
,
13832 TYPE_SATURATING (type
));
13833 t
= build_fixed (type
, f
);
13834 /* Propagate overflow flags. */
13835 if (overflow_p
| TREE_OVERFLOW (arg0
))
13836 TREE_OVERFLOW (t
) = 1;
13841 gcc_unreachable ();
13847 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13848 an integer constant or real constant.
13850 TYPE is the type of the result. */
13853 fold_abs_const (tree arg0
, tree type
)
13855 tree t
= NULL_TREE
;
13857 switch (TREE_CODE (arg0
))
13861 /* If the value is unsigned or non-negative, then the absolute value
13862 is the same as the ordinary value. */
13863 if (!wi::neg_p (arg0
, TYPE_SIGN (type
)))
13866 /* If the value is negative, then the absolute value is
13871 wide_int val
= wi::neg (arg0
, &overflow
);
13872 t
= force_fit_type (type
, val
, -1,
13873 overflow
| TREE_OVERFLOW (arg0
));
13879 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
13880 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13886 gcc_unreachable ();
13892 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13893 constant. TYPE is the type of the result. */
13896 fold_not_const (const_tree arg0
, tree type
)
13898 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
13900 return force_fit_type (type
, wi::bit_not (arg0
), 0, TREE_OVERFLOW (arg0
));
13903 /* Given CODE, a relational operator, the target type, TYPE and two
13904 constant operands OP0 and OP1, return the result of the
13905 relational operation. If the result is not a compile time
13906 constant, then return NULL_TREE. */
13909 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
13911 int result
, invert
;
13913 /* From here on, the only cases we handle are when the result is
13914 known to be a constant. */
13916 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
13918 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
13919 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
13921 /* Handle the cases where either operand is a NaN. */
13922 if (real_isnan (c0
) || real_isnan (c1
))
13932 case UNORDERED_EXPR
:
13946 if (flag_trapping_math
)
13952 gcc_unreachable ();
13955 return constant_boolean_node (result
, type
);
13958 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
13961 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
13963 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
13964 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
13965 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
13968 /* Handle equality/inequality of complex constants. */
13969 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
13971 tree rcond
= fold_relational_const (code
, type
,
13972 TREE_REALPART (op0
),
13973 TREE_REALPART (op1
));
13974 tree icond
= fold_relational_const (code
, type
,
13975 TREE_IMAGPART (op0
),
13976 TREE_IMAGPART (op1
));
13977 if (code
== EQ_EXPR
)
13978 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
13979 else if (code
== NE_EXPR
)
13980 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
13985 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
13987 unsigned count
= VECTOR_CST_NELTS (op0
);
13988 tree
*elts
= XALLOCAVEC (tree
, count
);
13989 gcc_assert (VECTOR_CST_NELTS (op1
) == count
13990 && TYPE_VECTOR_SUBPARTS (type
) == count
);
13992 for (unsigned i
= 0; i
< count
; i
++)
13994 tree elem_type
= TREE_TYPE (type
);
13995 tree elem0
= VECTOR_CST_ELT (op0
, i
);
13996 tree elem1
= VECTOR_CST_ELT (op1
, i
);
13998 tree tem
= fold_relational_const (code
, elem_type
,
14001 if (tem
== NULL_TREE
)
14004 elts
[i
] = build_int_cst (elem_type
, integer_zerop (tem
) ? 0 : -1);
14007 return build_vector (type
, elts
);
14010 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
14012 To compute GT, swap the arguments and do LT.
14013 To compute GE, do LT and invert the result.
14014 To compute LE, swap the arguments, do LT and invert the result.
14015 To compute NE, do EQ and invert the result.
14017 Therefore, the code below must handle only EQ and LT. */
14019 if (code
== LE_EXPR
|| code
== GT_EXPR
)
14021 std::swap (op0
, op1
);
14022 code
= swap_tree_comparison (code
);
14025 /* Note that it is safe to invert for real values here because we
14026 have already handled the one case that it matters. */
14029 if (code
== NE_EXPR
|| code
== GE_EXPR
)
14032 code
= invert_tree_comparison (code
, false);
14035 /* Compute a result for LT or EQ if args permit;
14036 Otherwise return T. */
14037 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
14039 if (code
== EQ_EXPR
)
14040 result
= tree_int_cst_equal (op0
, op1
);
14042 result
= tree_int_cst_lt (op0
, op1
);
14049 return constant_boolean_node (result
, type
);
14052 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
14053 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
14057 fold_build_cleanup_point_expr (tree type
, tree expr
)
14059 /* If the expression does not have side effects then we don't have to wrap
14060 it with a cleanup point expression. */
14061 if (!TREE_SIDE_EFFECTS (expr
))
14064 /* If the expression is a return, check to see if the expression inside the
14065 return has no side effects or the right hand side of the modify expression
14066 inside the return. If either don't have side effects set we don't need to
14067 wrap the expression in a cleanup point expression. Note we don't check the
14068 left hand side of the modify because it should always be a return decl. */
14069 if (TREE_CODE (expr
) == RETURN_EXPR
)
14071 tree op
= TREE_OPERAND (expr
, 0);
14072 if (!op
|| !TREE_SIDE_EFFECTS (op
))
14074 op
= TREE_OPERAND (op
, 1);
14075 if (!TREE_SIDE_EFFECTS (op
))
14079 return build1 (CLEANUP_POINT_EXPR
, type
, expr
);
14082 /* Given a pointer value OP0 and a type TYPE, return a simplified version
14083 of an indirection through OP0, or NULL_TREE if no simplification is
14087 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
14093 subtype
= TREE_TYPE (sub
);
14094 if (!POINTER_TYPE_P (subtype
))
14097 if (TREE_CODE (sub
) == ADDR_EXPR
)
14099 tree op
= TREE_OPERAND (sub
, 0);
14100 tree optype
= TREE_TYPE (op
);
14101 /* *&CONST_DECL -> to the value of the const decl. */
14102 if (TREE_CODE (op
) == CONST_DECL
)
14103 return DECL_INITIAL (op
);
14104 /* *&p => p; make sure to handle *&"str"[cst] here. */
14105 if (type
== optype
)
14107 tree fop
= fold_read_from_constant_string (op
);
14113 /* *(foo *)&fooarray => fooarray[0] */
14114 else if (TREE_CODE (optype
) == ARRAY_TYPE
14115 && type
== TREE_TYPE (optype
)
14116 && (!in_gimple_form
14117 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14119 tree type_domain
= TYPE_DOMAIN (optype
);
14120 tree min_val
= size_zero_node
;
14121 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14122 min_val
= TYPE_MIN_VALUE (type_domain
);
14124 && TREE_CODE (min_val
) != INTEGER_CST
)
14126 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
14127 NULL_TREE
, NULL_TREE
);
14129 /* *(foo *)&complexfoo => __real__ complexfoo */
14130 else if (TREE_CODE (optype
) == COMPLEX_TYPE
14131 && type
== TREE_TYPE (optype
))
14132 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
14133 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
14134 else if (TREE_CODE (optype
) == VECTOR_TYPE
14135 && type
== TREE_TYPE (optype
))
14137 tree part_width
= TYPE_SIZE (type
);
14138 tree index
= bitsize_int (0);
14139 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
14143 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
14144 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
14146 tree op00
= TREE_OPERAND (sub
, 0);
14147 tree op01
= TREE_OPERAND (sub
, 1);
14150 if (TREE_CODE (op00
) == ADDR_EXPR
)
14153 op00
= TREE_OPERAND (op00
, 0);
14154 op00type
= TREE_TYPE (op00
);
14156 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
14157 if (TREE_CODE (op00type
) == VECTOR_TYPE
14158 && type
== TREE_TYPE (op00type
))
14160 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
14161 tree part_width
= TYPE_SIZE (type
);
14162 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
14163 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
14164 tree index
= bitsize_int (indexi
);
14166 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
14167 return fold_build3_loc (loc
,
14168 BIT_FIELD_REF
, type
, op00
,
14169 part_width
, index
);
14172 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14173 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
14174 && type
== TREE_TYPE (op00type
))
14176 tree size
= TYPE_SIZE_UNIT (type
);
14177 if (tree_int_cst_equal (size
, op01
))
14178 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
14180 /* ((foo *)&fooarray)[1] => fooarray[1] */
14181 else if (TREE_CODE (op00type
) == ARRAY_TYPE
14182 && type
== TREE_TYPE (op00type
))
14184 tree type_domain
= TYPE_DOMAIN (op00type
);
14185 tree min_val
= size_zero_node
;
14186 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14187 min_val
= TYPE_MIN_VALUE (type_domain
);
14188 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
14189 TYPE_SIZE_UNIT (type
));
14190 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
14191 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
14192 NULL_TREE
, NULL_TREE
);
14197 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14198 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
14199 && type
== TREE_TYPE (TREE_TYPE (subtype
))
14200 && (!in_gimple_form
14201 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14204 tree min_val
= size_zero_node
;
14205 sub
= build_fold_indirect_ref_loc (loc
, sub
);
14206 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
14207 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14208 min_val
= TYPE_MIN_VALUE (type_domain
);
14210 && TREE_CODE (min_val
) != INTEGER_CST
)
14212 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
14219 /* Builds an expression for an indirection through T, simplifying some
14223 build_fold_indirect_ref_loc (location_t loc
, tree t
)
14225 tree type
= TREE_TYPE (TREE_TYPE (t
));
14226 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
14231 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
14234 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14237 fold_indirect_ref_loc (location_t loc
, tree t
)
14239 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
14247 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14248 whose result is ignored. The type of the returned tree need not be
14249 the same as the original expression. */
14252 fold_ignored_result (tree t
)
14254 if (!TREE_SIDE_EFFECTS (t
))
14255 return integer_zero_node
;
14258 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
14261 t
= TREE_OPERAND (t
, 0);
14265 case tcc_comparison
:
14266 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14267 t
= TREE_OPERAND (t
, 0);
14268 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
14269 t
= TREE_OPERAND (t
, 1);
14274 case tcc_expression
:
14275 switch (TREE_CODE (t
))
14277 case COMPOUND_EXPR
:
14278 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14280 t
= TREE_OPERAND (t
, 0);
14284 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
14285 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
14287 t
= TREE_OPERAND (t
, 0);
14300 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14303 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
14305 tree div
= NULL_TREE
;
14310 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14311 have to do anything. Only do this when we are not given a const,
14312 because in that case, this check is more expensive than just
14314 if (TREE_CODE (value
) != INTEGER_CST
)
14316 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14318 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14322 /* If divisor is a power of two, simplify this to bit manipulation. */
14323 if (divisor
== (divisor
& -divisor
))
14325 if (TREE_CODE (value
) == INTEGER_CST
)
14327 wide_int val
= value
;
14330 if ((val
& (divisor
- 1)) == 0)
14333 overflow_p
= TREE_OVERFLOW (value
);
14334 val
+= divisor
- 1;
14335 val
&= - (int) divisor
;
14339 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
14345 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
14346 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
14347 t
= build_int_cst (TREE_TYPE (value
), - (int) divisor
);
14348 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14354 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14355 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
14356 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14362 /* Likewise, but round down. */
14365 round_down_loc (location_t loc
, tree value
, int divisor
)
14367 tree div
= NULL_TREE
;
14369 gcc_assert (divisor
> 0);
14373 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14374 have to do anything. Only do this when we are not given a const,
14375 because in that case, this check is more expensive than just
14377 if (TREE_CODE (value
) != INTEGER_CST
)
14379 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14381 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14385 /* If divisor is a power of two, simplify this to bit manipulation. */
14386 if (divisor
== (divisor
& -divisor
))
14390 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
14391 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14396 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14397 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
14398 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14404 /* Returns the pointer to the base of the object addressed by EXP and
14405 extracts the information about the offset of the access, storing it
14406 to PBITPOS and POFFSET. */
14409 split_address_to_core_and_offset (tree exp
,
14410 HOST_WIDE_INT
*pbitpos
, tree
*poffset
)
14414 int unsignedp
, reversep
, volatilep
;
14415 HOST_WIDE_INT bitsize
;
14416 location_t loc
= EXPR_LOCATION (exp
);
14418 if (TREE_CODE (exp
) == ADDR_EXPR
)
14420 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
14421 poffset
, &mode
, &unsignedp
, &reversep
,
14422 &volatilep
, false);
14423 core
= build_fold_addr_expr_loc (loc
, core
);
14429 *poffset
= NULL_TREE
;
14435 /* Returns true if addresses of E1 and E2 differ by a constant, false
14436 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14439 ptr_difference_const (tree e1
, tree e2
, HOST_WIDE_INT
*diff
)
14442 HOST_WIDE_INT bitpos1
, bitpos2
;
14443 tree toffset1
, toffset2
, tdiff
, type
;
14445 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
14446 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
14448 if (bitpos1
% BITS_PER_UNIT
!= 0
14449 || bitpos2
% BITS_PER_UNIT
!= 0
14450 || !operand_equal_p (core1
, core2
, 0))
14453 if (toffset1
&& toffset2
)
14455 type
= TREE_TYPE (toffset1
);
14456 if (type
!= TREE_TYPE (toffset2
))
14457 toffset2
= fold_convert (type
, toffset2
);
14459 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
14460 if (!cst_and_fits_in_hwi (tdiff
))
14463 *diff
= int_cst_value (tdiff
);
14465 else if (toffset1
|| toffset2
)
14467 /* If only one of the offsets is non-constant, the difference cannot
14474 *diff
+= (bitpos1
- bitpos2
) / BITS_PER_UNIT
;
14478 /* Return OFF converted to a pointer offset type suitable as offset for
14479 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14481 convert_to_ptrofftype_loc (location_t loc
, tree off
)
14483 return fold_convert_loc (loc
, sizetype
, off
);
14486 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14488 fold_build_pointer_plus_loc (location_t loc
, tree ptr
, tree off
)
14490 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14491 ptr
, convert_to_ptrofftype_loc (loc
, off
));
14494 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14496 fold_build_pointer_plus_hwi_loc (location_t loc
, tree ptr
, HOST_WIDE_INT off
)
14498 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14499 ptr
, size_int (off
));
14502 /* Return a char pointer for a C string if it is a string constant
14503 or sum of string constant and integer constant. */
14506 c_getstr (tree src
)
14510 src
= string_constant (src
, &offset_node
);
14514 if (offset_node
== 0)
14515 return TREE_STRING_POINTER (src
);
14516 else if (!tree_fits_uhwi_p (offset_node
)
14517 || compare_tree_int (offset_node
, TREE_STRING_LENGTH (src
) - 1) > 0)
14520 return TREE_STRING_POINTER (src
) + tree_to_uhwi (offset_node
);