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 (location_t, tree, tree, enum tree_code,
113 tree *, tree *, tree *, int);
114 static tree associate_trees (location_t, tree, tree, enum tree_code, tree);
115 static enum comparison_code comparison_to_compcode (enum tree_code);
116 static enum tree_code compcode_to_comparison (enum comparison_code);
117 static int operand_equal_for_comparison_p (tree, tree, tree);
118 static int twoval_comparison_p (tree, tree *, tree *, int *);
119 static tree eval_subst (location_t, tree, tree, tree, tree, tree);
120 static tree optimize_bit_field_compare (location_t, enum tree_code,
122 static int simple_operand_p (const_tree);
123 static bool simple_operand_p_2 (tree);
124 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
125 static tree range_predecessor (tree);
126 static tree range_successor (tree);
127 static tree fold_range_test (location_t, enum tree_code, tree, tree, tree);
128 static tree fold_cond_expr_with_comparison (location_t, tree, tree, tree, tree);
129 static tree unextend (tree, int, int, tree);
130 static tree optimize_minmax_comparison (location_t, enum tree_code,
132 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
133 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
134 static tree fold_binary_op_with_conditional_arg (location_t,
135 enum tree_code, tree,
138 static tree fold_div_compare (location_t, enum tree_code, tree, tree, tree);
139 static bool reorder_operands_p (const_tree, const_tree);
140 static tree fold_negate_const (tree, tree);
141 static tree fold_not_const (const_tree, tree);
142 static tree fold_relational_const (enum tree_code, tree, tree, tree);
143 static tree fold_convert_const (enum tree_code, tree, tree);
144 static tree fold_view_convert_expr (tree, tree);
145 static bool vec_cst_ctor_to_array (tree, tree *);
148 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
149 Otherwise, return LOC. */
152 expr_location_or (tree t, location_t loc)
154 location_t tloc = EXPR_LOCATION (t);
155 return tloc == UNKNOWN_LOCATION ? loc : tloc;
158 /* Similar to protected_set_expr_location, but never modify x in place,
159 if location can and needs to be set, unshare it. */
162 protected_set_expr_location_unshare (tree x, location_t loc)
164 if (CAN_HAVE_LOCATION_P (x)
165 && EXPR_LOCATION (x) != loc
166 && !(TREE_CODE (x) == SAVE_EXPR
167 || TREE_CODE (x) == TARGET_EXPR
168 || TREE_CODE (x) == BIND_EXPR))
171 SET_EXPR_LOCATION (x, loc);
176 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
177 division and returns the quotient. Otherwise returns
181 div_if_zero_remainder (const_tree arg1, const_tree arg2)
185 if (wi::multiple_of_p (wi::to_widest (arg1), wi::to_widest (arg2),
187 return wide_int_to_tree (TREE_TYPE (arg1), quo);
192 /* This is nonzero if we should defer warnings about undefined
193 overflow. This facility exists because these warnings are a
194 special case. The code to estimate loop iterations does not want
195 to issue any warnings, since it works with expressions which do not
196 occur in user code. Various bits of cleanup code call fold(), but
197 only use the result if it has certain characteristics (e.g., is a
198 constant); that code only wants to issue a warning if the result is
201 static int fold_deferring_overflow_warnings;
203 /* If a warning about undefined overflow is deferred, this is the
204 warning. Note that this may cause us to turn two warnings into
205 one, but that is fine since it is sufficient to only give one
206 warning per expression. */
208 static const char* fold_deferred_overflow_warning;
210 /* If a warning about undefined overflow is deferred, this is the
211 level at which the warning should be emitted. */
213 static enum warn_strict_overflow_code fold_deferred_overflow_code;
215 /* Start deferring overflow warnings. We could use a stack here to
216 permit nested calls, but at present it is not necessary. */
219 fold_defer_overflow_warnings (void)
221 ++fold_deferring_overflow_warnings;
224 /* Stop deferring overflow warnings. If there is a pending warning,
225 and ISSUE is true, then issue the warning if appropriate. STMT is
226 the statement with which the warning should be associated (used for
227 location information); STMT may be NULL. CODE is the level of the
228 warning--a warn_strict_overflow_code value. This function will use
229 the smaller of CODE and the deferred code when deciding whether to
230 issue the warning. CODE may be zero to mean to always use the
234 fold_undefer_overflow_warnings (bool issue, const gimple *stmt, int code)
239 gcc_assert (fold_deferring_overflow_warnings > 0);
240 --fold_deferring_overflow_warnings;
241 if (fold_deferring_overflow_warnings > 0)
243 if (fold_deferred_overflow_warning != NULL
245 && code < (int) fold_deferred_overflow_code)
246 fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
250 warnmsg = fold_deferred_overflow_warning;
251 fold_deferred_overflow_warning = NULL;
253 if (!issue || warnmsg == NULL)
256 if (gimple_no_warning_p (stmt))
259 /* Use the smallest code level when deciding to issue the
261 if (code == 0 || code > (int) fold_deferred_overflow_code)
262 code = fold_deferred_overflow_code;
264 if (!issue_strict_overflow_warning (code))
268 locus = input_location;
270 locus = gimple_location (stmt);
271 warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
274 /* Stop deferring overflow warnings, ignoring any deferred
278 fold_undefer_and_ignore_overflow_warnings (void)
280 fold_undefer_overflow_warnings (false, NULL, 0);
283 /* Whether we are deferring overflow warnings. */
286 fold_deferring_overflow_warnings_p (void)
288 return fold_deferring_overflow_warnings > 0;
291 /* This is called when we fold something based on the fact that signed
292 overflow is undefined. */
295 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
297 if (fold_deferring_overflow_warnings > 0)
299 if (fold_deferred_overflow_warning == NULL
300 || wc < fold_deferred_overflow_code)
302 fold_deferred_overflow_warning = gmsgid;
303 fold_deferred_overflow_code = wc;
306 else if (issue_strict_overflow_warning (wc))
307 warning (OPT_Wstrict_overflow, gmsgid);
310 /* Return true if the built-in mathematical function specified by CODE
311 is odd, i.e. -f(x) == f(-x). */
314 negate_mathfn_p (combined_fn fn)
347 return !flag_rounding_math;
355 /* Check whether we may negate an integer constant T without causing
359 may_negate_without_overflow_p (const_tree t)
363 gcc_assert (TREE_CODE (t) == INTEGER_CST);
365 type = TREE_TYPE (t);
366 if (TYPE_UNSIGNED (type))
369 return !wi::only_sign_bit_p (t);
372 /* Determine whether an expression T can be cheaply negated using
373 the function negate_expr without introducing undefined overflow. */
376 negate_expr_p (tree t)
383 type = TREE_TYPE (t);
386 switch (TREE_CODE (t))
389 if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_WRAPS (type))
392 /* Check that -CST will not overflow type. */
393 return may_negate_without_overflow_p (t);
395 return (INTEGRAL_TYPE_P (type)
396 && TYPE_OVERFLOW_WRAPS (type));
402 return !TYPE_OVERFLOW_SANITIZED (type);
405 /* We want to canonicalize to positive real constants. Pretend
406 that only negative ones can be easily negated. */
407 return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
410 return negate_expr_p (TREE_REALPART (t))
411 && negate_expr_p (TREE_IMAGPART (t));
415 if (FLOAT_TYPE_P (TREE_TYPE (type)) || TYPE_OVERFLOW_WRAPS (type))
418 int count = TYPE_VECTOR_SUBPARTS (type), i;
420 for (i = 0; i < count; i++)
421 if (!negate_expr_p (VECTOR_CST_ELT (t, i)))
428 return negate_expr_p (TREE_OPERAND (t, 0))
429 && negate_expr_p (TREE_OPERAND (t, 1));
432 return negate_expr_p (TREE_OPERAND (t, 0));
435 if (HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type))
436 || HONOR_SIGNED_ZEROS (element_mode (type))
437 || (INTEGRAL_TYPE_P (type)
438 && ! TYPE_OVERFLOW_WRAPS (type)))
440 /* -(A + B) -> (-B) - A. */
441 if (negate_expr_p (TREE_OPERAND (t, 1))
442 && reorder_operands_p (TREE_OPERAND (t, 0),
443 TREE_OPERAND (t, 1)))
445 /* -(A + B) -> (-A) - B. */
446 return negate_expr_p (TREE_OPERAND (t, 0));
449 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
450 return !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type))
451 && !HONOR_SIGNED_ZEROS (element_mode (type))
452 && (! INTEGRAL_TYPE_P (type)
453 || TYPE_OVERFLOW_WRAPS (type))
454 && reorder_operands_p (TREE_OPERAND (t, 0),
455 TREE_OPERAND (t, 1));
458 if (TYPE_UNSIGNED (type))
460 /* INT_MIN/n * n doesn't overflow while negating one operand it does
461 if n is a (negative) power of two. */
462 if (INTEGRAL_TYPE_P (TREE_TYPE (t))
463 && ! TYPE_OVERFLOW_WRAPS (TREE_TYPE (t))
464 && ! ((TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST
465 && wi::popcount (wi::abs (TREE_OPERAND (t, 0))) != 1)
466 || (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
467 && wi::popcount (wi::abs (TREE_OPERAND (t, 1))) != 1)))
473 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (TREE_TYPE (t))))
474 return negate_expr_p (TREE_OPERAND (t, 1))
475 || negate_expr_p (TREE_OPERAND (t, 0));
481 if (TYPE_UNSIGNED (type))
483 if (negate_expr_p (TREE_OPERAND (t, 0)))
485 /* In general we can't negate B in A / B, because if A is INT_MIN and
486 B is 1, we may turn this into INT_MIN / -1 which is undefined
487 and actually traps on some architectures. */
488 if (! INTEGRAL_TYPE_P (TREE_TYPE (t))
489 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t))
490 || (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
491 && ! integer_onep (TREE_OPERAND (t, 1))))
492 return negate_expr_p (TREE_OPERAND (t, 1));
496 /* Negate -((double)float) as (double)(-float). */
497 if (TREE_CODE (type) == REAL_TYPE)
499 tree tem = strip_float_extensions (t);
501 return negate_expr_p (tem);
506 /* Negate -f(x) as f(-x). */
507 if (negate_mathfn_p (get_call_combined_fn (t)))
508 return negate_expr_p (CALL_EXPR_ARG (t, 0));
512 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
513 if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
515 tree op1 = TREE_OPERAND (t, 1);
516 if (wi::eq_p (op1, TYPE_PRECISION (type) - 1))
527 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
528 simplification is possible.
529 If negate_expr_p would return true for T, NULL_TREE will never be
533 fold_negate_expr (location_t loc, tree t)
535 tree type = TREE_TYPE (t);
538 switch (TREE_CODE (t))
540 /* Convert - (~A) to A + 1. */
542 if (INTEGRAL_TYPE_P (type))
543 return fold_build2_loc (loc, PLUS_EXPR, type, TREE_OPERAND (t, 0),
544 build_one_cst (type));
548 tem = fold_negate_const (t, type);
549 if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
550 || (ANY_INTEGRAL_TYPE_P (type)
551 && !TYPE_OVERFLOW_TRAPS (type)
552 && TYPE_OVERFLOW_WRAPS (type))
553 || (flag_sanitize & SANITIZE_SI_OVERFLOW) == 0)
558 tem = fold_negate_const (t, type);
562 tem = fold_negate_const (t, type);
567 tree rpart = fold_negate_expr (loc, TREE_REALPART (t));
568 tree ipart = fold_negate_expr (loc, TREE_IMAGPART (t));
570 return build_complex (type, rpart, ipart);
576 int count = TYPE_VECTOR_SUBPARTS (type), i;
577 tree *elts = XALLOCAVEC (tree, count);
579 for (i = 0; i < count; i++)
581 elts[i] = fold_negate_expr (loc, VECTOR_CST_ELT (t, i));
582 if (elts[i] == NULL_TREE)
586 return build_vector (type, elts);
590 if (negate_expr_p (t))
591 return fold_build2_loc (loc, COMPLEX_EXPR, type,
592 fold_negate_expr (loc, TREE_OPERAND (t, 0)),
593 fold_negate_expr (loc, TREE_OPERAND (t, 1)));
597 if (negate_expr_p (t))
598 return fold_build1_loc (loc, CONJ_EXPR, type,
599 fold_negate_expr (loc, TREE_OPERAND (t, 0)));
603 if (!TYPE_OVERFLOW_SANITIZED (type))
604 return TREE_OPERAND (t, 0);
608 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type))
609 && !HONOR_SIGNED_ZEROS (element_mode (type)))
611 /* -(A + B) -> (-B) - A. */
612 if (negate_expr_p (TREE_OPERAND (t, 1))
613 && reorder_operands_p (TREE_OPERAND (t, 0),
614 TREE_OPERAND (t, 1)))
616 tem = negate_expr (TREE_OPERAND (t, 1));
617 return fold_build2_loc (loc, MINUS_EXPR, type,
618 tem, TREE_OPERAND (t, 0));
621 /* -(A + B) -> (-A) - B. */
622 if (negate_expr_p (TREE_OPERAND (t, 0)))
624 tem = negate_expr (TREE_OPERAND (t, 0));
625 return fold_build2_loc (loc, MINUS_EXPR, type,
626 tem, TREE_OPERAND (t, 1));
632 /* - (A - B) -> B - A */
633 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type))
634 && !HONOR_SIGNED_ZEROS (element_mode (type))
635 && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
636 return fold_build2_loc (loc, MINUS_EXPR, type,
637 TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
641 if (TYPE_UNSIGNED (type))
647 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type)))
649 tem = TREE_OPERAND (t, 1);
650 if (negate_expr_p (tem))
651 return fold_build2_loc (loc, TREE_CODE (t), type,
652 TREE_OPERAND (t, 0), negate_expr (tem));
653 tem = TREE_OPERAND (t, 0);
654 if (negate_expr_p (tem))
655 return fold_build2_loc (loc, TREE_CODE (t), type,
656 negate_expr (tem), TREE_OPERAND (t, 1));
663 if (TYPE_UNSIGNED (type))
665 if (negate_expr_p (TREE_OPERAND (t, 0)))
666 return fold_build2_loc (loc, TREE_CODE (t), type,
667 negate_expr (TREE_OPERAND (t, 0)),
668 TREE_OPERAND (t, 1));
669 /* In general we can't negate B in A / B, because if A is INT_MIN and
670 B is 1, we may turn this into INT_MIN / -1 which is undefined
671 and actually traps on some architectures. */
672 if ((! INTEGRAL_TYPE_P (TREE_TYPE (t))
673 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t))
674 || (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
675 && ! integer_onep (TREE_OPERAND (t, 1))))
676 && negate_expr_p (TREE_OPERAND (t, 1)))
677 return fold_build2_loc (loc, TREE_CODE (t), type,
679 negate_expr (TREE_OPERAND (t, 1)));
683 /* Convert -((double)float) into (double)(-float). */
684 if (TREE_CODE (type) == REAL_TYPE)
686 tem = strip_float_extensions (t);
687 if (tem != t && negate_expr_p (tem))
688 return fold_convert_loc (loc, type, negate_expr (tem));
693 /* Negate -f(x) as f(-x). */
694 if (negate_mathfn_p (get_call_combined_fn (t))
695 && negate_expr_p (CALL_EXPR_ARG (t, 0)))
699 fndecl = get_callee_fndecl (t);
700 arg = negate_expr (CALL_EXPR_ARG (t, 0));
701 return build_call_expr_loc (loc, fndecl, 1, arg);
706 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
707 if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
709 tree op1 = TREE_OPERAND (t, 1);
710 if (wi::eq_p (op1, TYPE_PRECISION (type) - 1))
712 tree ntype = TYPE_UNSIGNED (type)
713 ? signed_type_for (type)
714 : unsigned_type_for (type);
715 tree temp = fold_convert_loc (loc, ntype, TREE_OPERAND (t, 0));
716 temp = fold_build2_loc (loc, RSHIFT_EXPR, ntype, temp, op1);
717 return fold_convert_loc (loc, type, temp);
729 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
730 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
742 loc = EXPR_LOCATION (t);
743 type = TREE_TYPE (t);
746 tem = fold_negate_expr (loc, t);
748 tem = build1_loc (loc, NEGATE_EXPR, TREE_TYPE (t), t);
749 return fold_convert_loc (loc, type, tem);
752 /* Split a tree IN into a constant, literal and variable parts that could be
753 combined with CODE to make IN. "constant" means an expression with
754 TREE_CONSTANT but that isn't an actual constant. CODE must be a
755 commutative arithmetic operation. Store the constant part into *CONP,
756 the literal in *LITP and return the variable part. If a part isn't
757 present, set it to null. If the tree does not decompose in this way,
758 return the entire tree as the variable part and the other parts as null.
760 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
761 case, we negate an operand that was subtracted. Except if it is a
762 literal for which we use *MINUS_LITP instead.
764 If NEGATE_P is true, we are negating all of IN, again except a literal
765 for which we use *MINUS_LITP instead. If a variable part is of pointer
766 type, it is negated after converting to TYPE. This prevents us from
767 generating illegal MINUS pointer expression. LOC is the location of
768 the converted variable part.
770 If IN is itself a literal or constant, return it as appropriate.
772 Note that we do not guarantee that any of the three values will be the
773 same type as IN, but they will have the same signedness and mode. */
776 split_tree (location_t loc, tree in, tree type, enum tree_code code,
777 tree *conp, tree *litp, tree *minus_litp, int negate_p)
785 /* Strip any conversions that don't change the machine mode or signedness. */
786 STRIP_SIGN_NOPS (in);
788 if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
789 || TREE_CODE (in) == FIXED_CST)
791 else if (TREE_CODE (in) == code
792 || ((! FLOAT_TYPE_P (TREE_TYPE (in)) || flag_associative_math)
793 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
794 /* We can associate addition and subtraction together (even
795 though the C standard doesn't say so) for integers because
796 the value is not affected. For reals, the value might be
797 affected, so we can't. */
798 && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
799 || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
801 tree op0 = TREE_OPERAND (in, 0);
802 tree op1 = TREE_OPERAND (in, 1);
803 int neg1_p = TREE_CODE (in) == MINUS_EXPR;
804 int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
806 /* First see if either of the operands is a literal, then a constant. */
807 if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
808 || TREE_CODE (op0) == FIXED_CST)
809 *litp = op0, op0 = 0;
810 else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
811 || TREE_CODE (op1) == FIXED_CST)
812 *litp = op1, neg_litp_p = neg1_p, op1 = 0;
814 if (op0 != 0 && TREE_CONSTANT (op0))
815 *conp = op0, op0 = 0;
816 else if (op1 != 0 && TREE_CONSTANT (op1))
817 *conp = op1, neg_conp_p = neg1_p, op1 = 0;
819 /* If we haven't dealt with either operand, this is not a case we can
820 decompose. Otherwise, VAR is either of the ones remaining, if any. */
821 if (op0 != 0 && op1 != 0)
826 var = op1, neg_var_p = neg1_p;
828 /* Now do any needed negations. */
830 *minus_litp = *litp, *litp = 0;
832 *conp = negate_expr (*conp);
833 if (neg_var_p && var)
835 /* Convert to TYPE before negating. */
836 var = fold_convert_loc (loc, type, var);
837 var = negate_expr (var);
840 else if (TREE_CONSTANT (in))
842 else if (TREE_CODE (in) == BIT_NOT_EXPR
843 && code == PLUS_EXPR)
845 /* -X - 1 is folded to ~X, undo that here. Do _not_ do this
846 when IN is constant. */
847 *minus_litp = build_one_cst (TREE_TYPE (in));
848 var = negate_expr (TREE_OPERAND (in, 0));
856 *minus_litp = *litp, *litp = 0;
857 else if (*minus_litp)
858 *litp = *minus_litp, *minus_litp = 0;
859 *conp = negate_expr (*conp);
862 /* Convert to TYPE before negating. */
863 var = fold_convert_loc (loc, type, var);
864 var = negate_expr (var);
871 /* Re-associate trees split by the above function. T1 and T2 are
872 either expressions to associate or null. Return the new
873 expression, if any. LOC is the location of the new expression. If
874 we build an operation, do it in TYPE and with CODE. */
877 associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree type)
884 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
885 try to fold this since we will have infinite recursion. But do
886 deal with any NEGATE_EXPRs. */
887 if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
888 || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
890 if (code == PLUS_EXPR)
892 if (TREE_CODE (t1) == NEGATE_EXPR)
893 return build2_loc (loc, MINUS_EXPR, type,
894 fold_convert_loc (loc, type, t2),
895 fold_convert_loc (loc, type,
896 TREE_OPERAND (t1, 0)));
897 else if (TREE_CODE (t2) == NEGATE_EXPR)
898 return build2_loc (loc, MINUS_EXPR, type,
899 fold_convert_loc (loc, type, t1),
900 fold_convert_loc (loc, type,
901 TREE_OPERAND (t2, 0)));
902 else if (integer_zerop (t2))
903 return fold_convert_loc (loc, type, t1);
905 else if (code == MINUS_EXPR)
907 if (integer_zerop (t2))
908 return fold_convert_loc (loc, type, t1);
911 return build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
912 fold_convert_loc (loc, type, t2));
915 return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
916 fold_convert_loc (loc, type, t2));
919 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
920 for use in int_const_binop, size_binop and size_diffop. */
923 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
925 if (!INTEGRAL_TYPE_P (type1) && !POINTER_TYPE_P (type1))
927 if (!INTEGRAL_TYPE_P (type2) && !POINTER_TYPE_P (type2))
942 return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
943 && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
944 && TYPE_MODE (type1) == TYPE_MODE (type2);
948 /* Combine two integer constants ARG1 and ARG2 under operation CODE
949 to produce a new constant. Return NULL_TREE if we don't know how
950 to evaluate CODE at compile-time. */
953 int_const_binop_1 (enum tree_code code, const_tree arg1, const_tree parg2,
958 tree type = TREE_TYPE (arg1);
959 signop sign = TYPE_SIGN (type);
960 bool overflow = false;
962 wide_int arg2 = wide_int::from (parg2, TYPE_PRECISION (type),
963 TYPE_SIGN (TREE_TYPE (parg2)));
968 res = wi::bit_or (arg1, arg2);
972 res = wi::bit_xor (arg1, arg2);
976 res = wi::bit_and (arg1, arg2);
981 if (wi::neg_p (arg2))
984 if (code == RSHIFT_EXPR)
990 if (code == RSHIFT_EXPR)
991 /* It's unclear from the C standard whether shifts can overflow.
992 The following code ignores overflow; perhaps a C standard
993 interpretation ruling is needed. */
994 res = wi::rshift (arg1, arg2, sign);
996 res = wi::lshift (arg1, arg2);
1001 if (wi::neg_p (arg2))
1004 if (code == RROTATE_EXPR)
1005 code = LROTATE_EXPR;
1007 code = RROTATE_EXPR;
1010 if (code == RROTATE_EXPR)
1011 res = wi::rrotate (arg1, arg2);
1013 res = wi::lrotate (arg1, arg2);
1017 res = wi::add (arg1, arg2, sign, &overflow);
1021 res = wi::sub (arg1, arg2, sign, &overflow);
1025 res = wi::mul (arg1, arg2, sign, &overflow);
1028 case MULT_HIGHPART_EXPR:
1029 res = wi::mul_high (arg1, arg2, sign);
1032 case TRUNC_DIV_EXPR:
1033 case EXACT_DIV_EXPR:
1036 res = wi::div_trunc (arg1, arg2, sign, &overflow);
1039 case FLOOR_DIV_EXPR:
1042 res = wi::div_floor (arg1, arg2, sign, &overflow);
1048 res = wi::div_ceil (arg1, arg2, sign, &overflow);
1051 case ROUND_DIV_EXPR:
1054 res = wi::div_round (arg1, arg2, sign, &overflow);
1057 case TRUNC_MOD_EXPR:
1060 res = wi::mod_trunc (arg1, arg2, sign, &overflow);
1063 case FLOOR_MOD_EXPR:
1066 res = wi::mod_floor (arg1, arg2, sign, &overflow);
1072 res = wi::mod_ceil (arg1, arg2, sign, &overflow);
1075 case ROUND_MOD_EXPR:
1078 res = wi::mod_round (arg1, arg2, sign, &overflow);
1082 res = wi::min (arg1, arg2, sign);
1086 res = wi::max (arg1, arg2, sign);
1093 t = force_fit_type (type, res, overflowable,
1094 (((sign == SIGNED || overflowable == -1)
1096 | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (parg2)));
1102 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2)
1104 return int_const_binop_1 (code, arg1, arg2, 1);
1107 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1108 constant. We assume ARG1 and ARG2 have the same data type, or at least
1109 are the same kind of constant and the same machine mode. Return zero if
1110 combining the constants is not allowed in the current operating mode. */
1113 const_binop (enum tree_code code, tree arg1, tree arg2)
1115 /* Sanity check for the recursive cases. */
1122 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg2) == INTEGER_CST)
1124 if (code == POINTER_PLUS_EXPR)
1125 return int_const_binop (PLUS_EXPR,
1126 arg1, fold_convert (TREE_TYPE (arg1), arg2));
1128 return int_const_binop (code, arg1, arg2);
1131 if (TREE_CODE (arg1) == REAL_CST && TREE_CODE (arg2) == REAL_CST)
1136 REAL_VALUE_TYPE value;
1137 REAL_VALUE_TYPE result;
1141 /* The following codes are handled by real_arithmetic. */
1156 d1 = TREE_REAL_CST (arg1);
1157 d2 = TREE_REAL_CST (arg2);
1159 type = TREE_TYPE (arg1);
1160 mode = TYPE_MODE (type);
1162 /* Don't perform operation if we honor signaling NaNs and
1163 either operand is a signaling NaN. */
1164 if (HONOR_SNANS (mode)
1165 && (REAL_VALUE_ISSIGNALING_NAN (d1)
1166 || REAL_VALUE_ISSIGNALING_NAN (d2)))
1169 /* Don't perform operation if it would raise a division
1170 by zero exception. */
1171 if (code == RDIV_EXPR
1172 && real_equal (&d2, &dconst0)
1173 && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1176 /* If either operand is a NaN, just return it. Otherwise, set up
1177 for floating-point trap; we return an overflow. */
1178 if (REAL_VALUE_ISNAN (d1))
1180 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1183 t = build_real (type, d1);
1186 else if (REAL_VALUE_ISNAN (d2))
1188 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1191 t = build_real (type, d2);
1195 inexact = real_arithmetic (&value, code, &d1, &d2);
1196 real_convert (&result, mode, &value);
1198 /* Don't constant fold this floating point operation if
1199 the result has overflowed and flag_trapping_math. */
1200 if (flag_trapping_math
1201 && MODE_HAS_INFINITIES (mode)
1202 && REAL_VALUE_ISINF (result)
1203 && !REAL_VALUE_ISINF (d1)
1204 && !REAL_VALUE_ISINF (d2))
1207 /* Don't constant fold this floating point operation if the
1208 result may dependent upon the run-time rounding mode and
1209 flag_rounding_math is set, or if GCC's software emulation
1210 is unable to accurately represent the result. */
1211 if ((flag_rounding_math
1212 || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
1213 && (inexact || !real_identical (&result, &value)))
1216 t = build_real (type, result);
1218 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1222 if (TREE_CODE (arg1) == FIXED_CST)
1224 FIXED_VALUE_TYPE f1;
1225 FIXED_VALUE_TYPE f2;
1226 FIXED_VALUE_TYPE result;
1231 /* The following codes are handled by fixed_arithmetic. */
1237 case TRUNC_DIV_EXPR:
1238 if (TREE_CODE (arg2) != FIXED_CST)
1240 f2 = TREE_FIXED_CST (arg2);
1246 if (TREE_CODE (arg2) != INTEGER_CST)
1249 f2.data.high = w2.elt (1);
1250 f2.data.low = w2.elt (0);
1259 f1 = TREE_FIXED_CST (arg1);
1260 type = TREE_TYPE (arg1);
1261 sat_p = TYPE_SATURATING (type);
1262 overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1263 t = build_fixed (type, result);
1264 /* Propagate overflow flags. */
1265 if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1266 TREE_OVERFLOW (t) = 1;
1270 if (TREE_CODE (arg1) == COMPLEX_CST && TREE_CODE (arg2) == COMPLEX_CST)
1272 tree type = TREE_TYPE (arg1);
1273 tree r1 = TREE_REALPART (arg1);
1274 tree i1 = TREE_IMAGPART (arg1);
1275 tree r2 = TREE_REALPART (arg2);
1276 tree i2 = TREE_IMAGPART (arg2);
1283 real = const_binop (code, r1, r2);
1284 imag = const_binop (code, i1, i2);
1288 if (COMPLEX_FLOAT_TYPE_P (type))
1289 return do_mpc_arg2 (arg1, arg2, type,
1290 /* do_nonfinite= */ folding_initializer,
1293 real = const_binop (MINUS_EXPR,
1294 const_binop (MULT_EXPR, r1, r2),
1295 const_binop (MULT_EXPR, i1, i2));
1296 imag = const_binop (PLUS_EXPR,
1297 const_binop (MULT_EXPR, r1, i2),
1298 const_binop (MULT_EXPR, i1, r2));
1302 if (COMPLEX_FLOAT_TYPE_P (type))
1303 return do_mpc_arg2 (arg1, arg2, type,
1304 /* do_nonfinite= */ folding_initializer,
1307 case TRUNC_DIV_EXPR:
1309 case FLOOR_DIV_EXPR:
1310 case ROUND_DIV_EXPR:
1311 if (flag_complex_method == 0)
1313 /* Keep this algorithm in sync with
1314 tree-complex.c:expand_complex_div_straight().
1316 Expand complex division to scalars, straightforward algorithm.
1317 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1321 = const_binop (PLUS_EXPR,
1322 const_binop (MULT_EXPR, r2, r2),
1323 const_binop (MULT_EXPR, i2, i2));
1325 = const_binop (PLUS_EXPR,
1326 const_binop (MULT_EXPR, r1, r2),
1327 const_binop (MULT_EXPR, i1, i2));
1329 = const_binop (MINUS_EXPR,
1330 const_binop (MULT_EXPR, i1, r2),
1331 const_binop (MULT_EXPR, r1, i2));
1333 real = const_binop (code, t1, magsquared);
1334 imag = const_binop (code, t2, magsquared);
1338 /* Keep this algorithm in sync with
1339 tree-complex.c:expand_complex_div_wide().
1341 Expand complex division to scalars, modified algorithm to minimize
1342 overflow with wide input ranges. */
1343 tree compare = fold_build2 (LT_EXPR, boolean_type_node,
1344 fold_abs_const (r2, TREE_TYPE (type)),
1345 fold_abs_const (i2, TREE_TYPE (type)));
1347 if (integer_nonzerop (compare))
1349 /* In the TRUE branch, we compute
1351 div = (br * ratio) + bi;
1352 tr = (ar * ratio) + ai;
1353 ti = (ai * ratio) - ar;
1356 tree ratio = const_binop (code, r2, i2);
1357 tree div = const_binop (PLUS_EXPR, i2,
1358 const_binop (MULT_EXPR, r2, ratio));
1359 real = const_binop (MULT_EXPR, r1, ratio);
1360 real = const_binop (PLUS_EXPR, real, i1);
1361 real = const_binop (code, real, div);
1363 imag = const_binop (MULT_EXPR, i1, ratio);
1364 imag = const_binop (MINUS_EXPR, imag, r1);
1365 imag = const_binop (code, imag, div);
1369 /* In the FALSE branch, we compute
1371 divisor = (d * ratio) + c;
1372 tr = (b * ratio) + a;
1373 ti = b - (a * ratio);
1376 tree ratio = const_binop (code, i2, r2);
1377 tree div = const_binop (PLUS_EXPR, r2,
1378 const_binop (MULT_EXPR, i2, ratio));
1380 real = const_binop (MULT_EXPR, i1, ratio);
1381 real = const_binop (PLUS_EXPR, real, r1);
1382 real = const_binop (code, real, div);
1384 imag = const_binop (MULT_EXPR, r1, ratio);
1385 imag = const_binop (MINUS_EXPR, i1, imag);
1386 imag = const_binop (code, imag, div);
1396 return build_complex (type, real, imag);
1399 if (TREE_CODE (arg1) == VECTOR_CST
1400 && TREE_CODE (arg2) == VECTOR_CST)
1402 tree type = TREE_TYPE (arg1);
1403 int count = TYPE_VECTOR_SUBPARTS (type), i;
1404 tree *elts = XALLOCAVEC (tree, count);
1406 for (i = 0; i < count; i++)
1408 tree elem1 = VECTOR_CST_ELT (arg1, i);
1409 tree elem2 = VECTOR_CST_ELT (arg2, i);
1411 elts[i] = const_binop (code, elem1, elem2);
1413 /* It is possible that const_binop cannot handle the given
1414 code and return NULL_TREE */
1415 if (elts[i] == NULL_TREE)
1419 return build_vector (type, elts);
1422 /* Shifts allow a scalar offset for a vector. */
1423 if (TREE_CODE (arg1) == VECTOR_CST
1424 && TREE_CODE (arg2) == INTEGER_CST)
1426 tree type = TREE_TYPE (arg1);
1427 int count = TYPE_VECTOR_SUBPARTS (type), i;
1428 tree *elts = XALLOCAVEC (tree, count);
1430 for (i = 0; i < count; i++)
1432 tree elem1 = VECTOR_CST_ELT (arg1, i);
1434 elts[i] = const_binop (code, elem1, arg2);
1436 /* It is possible that const_binop cannot handle the given
1437 code and return NULL_TREE. */
1438 if (elts[i] == NULL_TREE)
1442 return build_vector (type, elts);
1447 /* Overload that adds a TYPE parameter to be able to dispatch
1448 to fold_relational_const. */
1451 const_binop (enum tree_code code, tree type, tree arg1, tree arg2)
1453 if (TREE_CODE_CLASS (code) == tcc_comparison)
1454 return fold_relational_const (code, type, arg1, arg2);
1456 /* ??? Until we make the const_binop worker take the type of the
1457 result as argument put those cases that need it here. */
1461 if ((TREE_CODE (arg1) == REAL_CST
1462 && TREE_CODE (arg2) == REAL_CST)
1463 || (TREE_CODE (arg1) == INTEGER_CST
1464 && TREE_CODE (arg2) == INTEGER_CST))
1465 return build_complex (type, arg1, arg2);
1468 case VEC_PACK_TRUNC_EXPR:
1469 case VEC_PACK_FIX_TRUNC_EXPR:
1471 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
1474 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts / 2
1475 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2)) == nelts / 2);
1476 if (TREE_CODE (arg1) != VECTOR_CST
1477 || TREE_CODE (arg2) != VECTOR_CST)
1480 elts = XALLOCAVEC (tree, nelts);
1481 if (!vec_cst_ctor_to_array (arg1, elts)
1482 || !vec_cst_ctor_to_array (arg2, elts + nelts / 2))
1485 for (i = 0; i < nelts; i++)
1487 elts[i] = fold_convert_const (code == VEC_PACK_TRUNC_EXPR
1488 ? NOP_EXPR : FIX_TRUNC_EXPR,
1489 TREE_TYPE (type), elts[i]);
1490 if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
1494 return build_vector (type, elts);
1497 case VEC_WIDEN_MULT_LO_EXPR:
1498 case VEC_WIDEN_MULT_HI_EXPR:
1499 case VEC_WIDEN_MULT_EVEN_EXPR:
1500 case VEC_WIDEN_MULT_ODD_EXPR:
1502 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type);
1503 unsigned int out, ofs, scale;
1506 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts * 2
1507 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2)) == nelts * 2);
1508 if (TREE_CODE (arg1) != VECTOR_CST || TREE_CODE (arg2) != VECTOR_CST)
1511 elts = XALLOCAVEC (tree, nelts * 4);
1512 if (!vec_cst_ctor_to_array (arg1, elts)
1513 || !vec_cst_ctor_to_array (arg2, elts + nelts * 2))
1516 if (code == VEC_WIDEN_MULT_LO_EXPR)
1517 scale = 0, ofs = BYTES_BIG_ENDIAN ? nelts : 0;
1518 else if (code == VEC_WIDEN_MULT_HI_EXPR)
1519 scale = 0, ofs = BYTES_BIG_ENDIAN ? 0 : nelts;
1520 else if (code == VEC_WIDEN_MULT_EVEN_EXPR)
1522 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
1525 for (out = 0; out < nelts; out++)
1527 unsigned int in1 = (out << scale) + ofs;
1528 unsigned int in2 = in1 + nelts * 2;
1531 t1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in1]);
1532 t2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in2]);
1534 if (t1 == NULL_TREE || t2 == NULL_TREE)
1536 elts[out] = const_binop (MULT_EXPR, t1, t2);
1537 if (elts[out] == NULL_TREE || !CONSTANT_CLASS_P (elts[out]))
1541 return build_vector (type, elts);
1547 if (TREE_CODE_CLASS (code) != tcc_binary)
1550 /* Make sure type and arg0 have the same saturating flag. */
1551 gcc_checking_assert (TYPE_SATURATING (type)
1552 == TYPE_SATURATING (TREE_TYPE (arg1)));
1554 return const_binop (code, arg1, arg2);
1557 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1558 Return zero if computing the constants is not possible. */
1561 const_unop (enum tree_code code, tree type, tree arg0)
1563 /* Don't perform the operation, other than NEGATE and ABS, if
1564 flag_signaling_nans is on and the operand is a signaling NaN. */
1565 if (TREE_CODE (arg0) == REAL_CST
1566 && HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
1567 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg0))
1568 && code != NEGATE_EXPR
1569 && code != ABS_EXPR)
1576 case FIX_TRUNC_EXPR:
1577 case FIXED_CONVERT_EXPR:
1578 return fold_convert_const (code, type, arg0);
1580 case ADDR_SPACE_CONVERT_EXPR:
1581 /* If the source address is 0, and the source address space
1582 cannot have a valid object at 0, fold to dest type null. */
1583 if (integer_zerop (arg0)
1584 && !(targetm.addr_space.zero_address_valid
1585 (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0))))))
1586 return fold_convert_const (code, type, arg0);
1589 case VIEW_CONVERT_EXPR:
1590 return fold_view_convert_expr (type, arg0);
1594 /* Can't call fold_negate_const directly here as that doesn't
1595 handle all cases and we might not be able to negate some
1597 tree tem = fold_negate_expr (UNKNOWN_LOCATION, arg0);
1598 if (tem && CONSTANT_CLASS_P (tem))
1604 if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
1605 return fold_abs_const (arg0, type);
1609 if (TREE_CODE (arg0) == COMPLEX_CST)
1611 tree ipart = fold_negate_const (TREE_IMAGPART (arg0),
1613 return build_complex (type, TREE_REALPART (arg0), ipart);
1618 if (TREE_CODE (arg0) == INTEGER_CST)
1619 return fold_not_const (arg0, type);
1620 /* Perform BIT_NOT_EXPR on each element individually. */
1621 else if (TREE_CODE (arg0) == VECTOR_CST)
1625 unsigned count = VECTOR_CST_NELTS (arg0), i;
1627 elements = XALLOCAVEC (tree, count);
1628 for (i = 0; i < count; i++)
1630 elem = VECTOR_CST_ELT (arg0, i);
1631 elem = const_unop (BIT_NOT_EXPR, TREE_TYPE (type), elem);
1632 if (elem == NULL_TREE)
1637 return build_vector (type, elements);
1641 case TRUTH_NOT_EXPR:
1642 if (TREE_CODE (arg0) == INTEGER_CST)
1643 return constant_boolean_node (integer_zerop (arg0), type);
1647 if (TREE_CODE (arg0) == COMPLEX_CST)
1648 return fold_convert (type, TREE_REALPART (arg0));
1652 if (TREE_CODE (arg0) == COMPLEX_CST)
1653 return fold_convert (type, TREE_IMAGPART (arg0));
1656 case VEC_UNPACK_LO_EXPR:
1657 case VEC_UNPACK_HI_EXPR:
1658 case VEC_UNPACK_FLOAT_LO_EXPR:
1659 case VEC_UNPACK_FLOAT_HI_EXPR:
1661 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
1663 enum tree_code subcode;
1665 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2);
1666 if (TREE_CODE (arg0) != VECTOR_CST)
1669 elts = XALLOCAVEC (tree, nelts * 2);
1670 if (!vec_cst_ctor_to_array (arg0, elts))
1673 if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_UNPACK_LO_EXPR
1674 || code == VEC_UNPACK_FLOAT_LO_EXPR))
1677 if (code == VEC_UNPACK_LO_EXPR || code == VEC_UNPACK_HI_EXPR)
1680 subcode = FLOAT_EXPR;
1682 for (i = 0; i < nelts; i++)
1684 elts[i] = fold_convert_const (subcode, TREE_TYPE (type), elts[i]);
1685 if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
1689 return build_vector (type, elts);
1692 case REDUC_MIN_EXPR:
1693 case REDUC_MAX_EXPR:
1694 case REDUC_PLUS_EXPR:
1696 unsigned int nelts, i;
1698 enum tree_code subcode;
1700 if (TREE_CODE (arg0) != VECTOR_CST)
1702 nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0));
1704 elts = XALLOCAVEC (tree, nelts);
1705 if (!vec_cst_ctor_to_array (arg0, elts))
1710 case REDUC_MIN_EXPR: subcode = MIN_EXPR; break;
1711 case REDUC_MAX_EXPR: subcode = MAX_EXPR; break;
1712 case REDUC_PLUS_EXPR: subcode = PLUS_EXPR; break;
1713 default: gcc_unreachable ();
1716 for (i = 1; i < nelts; i++)
1718 elts[0] = const_binop (subcode, elts[0], elts[i]);
1719 if (elts[0] == NULL_TREE || !CONSTANT_CLASS_P (elts[0]))
1733 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1734 indicates which particular sizetype to create. */
1737 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1739 return build_int_cst (sizetype_tab[(int) kind], number);
1742 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1743 is a tree code. The type of the result is taken from the operands.
1744 Both must be equivalent integer types, ala int_binop_types_match_p.
1745 If the operands are constant, so is the result. */
1748 size_binop_loc (location_t loc, enum tree_code code, tree arg0, tree arg1)
1750 tree type = TREE_TYPE (arg0);
1752 if (arg0 == error_mark_node || arg1 == error_mark_node)
1753 return error_mark_node;
1755 gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
1758 /* Handle the special case of two integer constants faster. */
1759 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1761 /* And some specific cases even faster than that. */
1762 if (code == PLUS_EXPR)
1764 if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
1766 if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1769 else if (code == MINUS_EXPR)
1771 if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1774 else if (code == MULT_EXPR)
1776 if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
1780 /* Handle general case of two integer constants. For sizetype
1781 constant calculations we always want to know about overflow,
1782 even in the unsigned case. */
1783 return int_const_binop_1 (code, arg0, arg1, -1);
1786 return fold_build2_loc (loc, code, type, arg0, arg1);
1789 /* Given two values, either both of sizetype or both of bitsizetype,
1790 compute the difference between the two values. Return the value
1791 in signed type corresponding to the type of the operands. */
1794 size_diffop_loc (location_t loc, tree arg0, tree arg1)
1796 tree type = TREE_TYPE (arg0);
1799 gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
1802 /* If the type is already signed, just do the simple thing. */
1803 if (!TYPE_UNSIGNED (type))
1804 return size_binop_loc (loc, MINUS_EXPR, arg0, arg1);
1806 if (type == sizetype)
1808 else if (type == bitsizetype)
1809 ctype = sbitsizetype;
1811 ctype = signed_type_for (type);
1813 /* If either operand is not a constant, do the conversions to the signed
1814 type and subtract. The hardware will do the right thing with any
1815 overflow in the subtraction. */
1816 if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1817 return size_binop_loc (loc, MINUS_EXPR,
1818 fold_convert_loc (loc, ctype, arg0),
1819 fold_convert_loc (loc, ctype, arg1));
1821 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1822 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1823 overflow) and negate (which can't either). Special-case a result
1824 of zero while we're here. */
1825 if (tree_int_cst_equal (arg0, arg1))
1826 return build_int_cst (ctype, 0);
1827 else if (tree_int_cst_lt (arg1, arg0))
1828 return fold_convert_loc (loc, ctype,
1829 size_binop_loc (loc, MINUS_EXPR, arg0, arg1));
1831 return size_binop_loc (loc, MINUS_EXPR, build_int_cst (ctype, 0),
1832 fold_convert_loc (loc, ctype,
1833 size_binop_loc (loc,
1838 /* A subroutine of fold_convert_const handling conversions of an
1839 INTEGER_CST to another integer type. */
1842 fold_convert_const_int_from_int (tree type, const_tree arg1)
1844 /* Given an integer constant, make new constant with new type,
1845 appropriately sign-extended or truncated. Use widest_int
1846 so that any extension is done according ARG1's type. */
1847 return force_fit_type (type, wi::to_widest (arg1),
1848 !POINTER_TYPE_P (TREE_TYPE (arg1)),
1849 TREE_OVERFLOW (arg1));
1852 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1853 to an integer type. */
1856 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
1858 bool overflow = false;
1861 /* The following code implements the floating point to integer
1862 conversion rules required by the Java Language Specification,
1863 that IEEE NaNs are mapped to zero and values that overflow
1864 the target precision saturate, i.e. values greater than
1865 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1866 are mapped to INT_MIN. These semantics are allowed by the
1867 C and C++ standards that simply state that the behavior of
1868 FP-to-integer conversion is unspecified upon overflow. */
1872 REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1876 case FIX_TRUNC_EXPR:
1877 real_trunc (&r, VOIDmode, &x);
1884 /* If R is NaN, return zero and show we have an overflow. */
1885 if (REAL_VALUE_ISNAN (r))
1888 val = wi::zero (TYPE_PRECISION (type));
1891 /* See if R is less than the lower bound or greater than the
1896 tree lt = TYPE_MIN_VALUE (type);
1897 REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
1898 if (real_less (&r, &l))
1907 tree ut = TYPE_MAX_VALUE (type);
1910 REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
1911 if (real_less (&u, &r))
1920 val = real_to_integer (&r, &overflow, TYPE_PRECISION (type));
1922 t = force_fit_type (type, val, -1, overflow | TREE_OVERFLOW (arg1));
1926 /* A subroutine of fold_convert_const handling conversions of a
1927 FIXED_CST to an integer type. */
1930 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
1933 double_int temp, temp_trunc;
1936 /* Right shift FIXED_CST to temp by fbit. */
1937 temp = TREE_FIXED_CST (arg1).data;
1938 mode = TREE_FIXED_CST (arg1).mode;
1939 if (GET_MODE_FBIT (mode) < HOST_BITS_PER_DOUBLE_INT)
1941 temp = temp.rshift (GET_MODE_FBIT (mode),
1942 HOST_BITS_PER_DOUBLE_INT,
1943 SIGNED_FIXED_POINT_MODE_P (mode));
1945 /* Left shift temp to temp_trunc by fbit. */
1946 temp_trunc = temp.lshift (GET_MODE_FBIT (mode),
1947 HOST_BITS_PER_DOUBLE_INT,
1948 SIGNED_FIXED_POINT_MODE_P (mode));
1952 temp = double_int_zero;
1953 temp_trunc = double_int_zero;
1956 /* If FIXED_CST is negative, we need to round the value toward 0.
1957 By checking if the fractional bits are not zero to add 1 to temp. */
1958 if (SIGNED_FIXED_POINT_MODE_P (mode)
1959 && temp_trunc.is_negative ()
1960 && TREE_FIXED_CST (arg1).data != temp_trunc)
1961 temp += double_int_one;
1963 /* Given a fixed-point constant, make new constant with new type,
1964 appropriately sign-extended or truncated. */
1965 t = force_fit_type (type, temp, -1,
1966 (temp.is_negative ()
1967 && (TYPE_UNSIGNED (type)
1968 < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1969 | TREE_OVERFLOW (arg1));
1974 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1975 to another floating point type. */
1978 fold_convert_const_real_from_real (tree type, const_tree arg1)
1980 REAL_VALUE_TYPE value;
1983 /* Don't perform the operation if flag_signaling_nans is on
1984 and the operand is a signaling NaN. */
1985 if (HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
1986 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg1)))
1989 real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
1990 t = build_real (type, value);
1992 /* If converting an infinity or NAN to a representation that doesn't
1993 have one, set the overflow bit so that we can produce some kind of
1994 error message at the appropriate point if necessary. It's not the
1995 most user-friendly message, but it's better than nothing. */
1996 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1))
1997 && !MODE_HAS_INFINITIES (TYPE_MODE (type)))
1998 TREE_OVERFLOW (t) = 1;
1999 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
2000 && !MODE_HAS_NANS (TYPE_MODE (type)))
2001 TREE_OVERFLOW (t) = 1;
2002 /* Regular overflow, conversion produced an infinity in a mode that
2003 can't represent them. */
2004 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type))
2005 && REAL_VALUE_ISINF (value)
2006 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1)))
2007 TREE_OVERFLOW (t) = 1;
2009 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2013 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2014 to a floating point type. */
2017 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
2019 REAL_VALUE_TYPE value;
2022 real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
2023 t = build_real (type, value);
2025 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2029 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2030 to another fixed-point type. */
2033 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
2035 FIXED_VALUE_TYPE value;
2039 overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
2040 TYPE_SATURATING (type));
2041 t = build_fixed (type, value);
2043 /* Propagate overflow flags. */
2044 if (overflow_p | TREE_OVERFLOW (arg1))
2045 TREE_OVERFLOW (t) = 1;
2049 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2050 to a fixed-point type. */
2053 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
2055 FIXED_VALUE_TYPE value;
2060 gcc_assert (TREE_INT_CST_NUNITS (arg1) <= 2);
2062 di.low = TREE_INT_CST_ELT (arg1, 0);
2063 if (TREE_INT_CST_NUNITS (arg1) == 1)
2064 di.high = (HOST_WIDE_INT) di.low < 0 ? (HOST_WIDE_INT) -1 : 0;
2066 di.high = TREE_INT_CST_ELT (arg1, 1);
2068 overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type), di,
2069 TYPE_UNSIGNED (TREE_TYPE (arg1)),
2070 TYPE_SATURATING (type));
2071 t = build_fixed (type, value);
2073 /* Propagate overflow flags. */
2074 if (overflow_p | TREE_OVERFLOW (arg1))
2075 TREE_OVERFLOW (t) = 1;
2079 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2080 to a fixed-point type. */
2083 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
2085 FIXED_VALUE_TYPE value;
2089 overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
2090 &TREE_REAL_CST (arg1),
2091 TYPE_SATURATING (type));
2092 t = build_fixed (type, value);
2094 /* Propagate overflow flags. */
2095 if (overflow_p | TREE_OVERFLOW (arg1))
2096 TREE_OVERFLOW (t) = 1;
2100 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2101 type TYPE. If no simplification can be done return NULL_TREE. */
2104 fold_convert_const (enum tree_code code, tree type, tree arg1)
2106 if (TREE_TYPE (arg1) == type)
2109 if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
2110 || TREE_CODE (type) == OFFSET_TYPE)
2112 if (TREE_CODE (arg1) == INTEGER_CST)
2113 return fold_convert_const_int_from_int (type, arg1);
2114 else if (TREE_CODE (arg1) == REAL_CST)
2115 return fold_convert_const_int_from_real (code, type, arg1);
2116 else if (TREE_CODE (arg1) == FIXED_CST)
2117 return fold_convert_const_int_from_fixed (type, arg1);
2119 else if (TREE_CODE (type) == REAL_TYPE)
2121 if (TREE_CODE (arg1) == INTEGER_CST)
2122 return build_real_from_int_cst (type, arg1);
2123 else if (TREE_CODE (arg1) == REAL_CST)
2124 return fold_convert_const_real_from_real (type, arg1);
2125 else if (TREE_CODE (arg1) == FIXED_CST)
2126 return fold_convert_const_real_from_fixed (type, arg1);
2128 else if (TREE_CODE (type) == FIXED_POINT_TYPE)
2130 if (TREE_CODE (arg1) == FIXED_CST)
2131 return fold_convert_const_fixed_from_fixed (type, arg1);
2132 else if (TREE_CODE (arg1) == INTEGER_CST)
2133 return fold_convert_const_fixed_from_int (type, arg1);
2134 else if (TREE_CODE (arg1) == REAL_CST)
2135 return fold_convert_const_fixed_from_real (type, arg1);
2137 else if (TREE_CODE (type) == VECTOR_TYPE)
2139 if (TREE_CODE (arg1) == VECTOR_CST
2140 && TYPE_VECTOR_SUBPARTS (type) == VECTOR_CST_NELTS (arg1))
2142 int len = TYPE_VECTOR_SUBPARTS (type);
2143 tree elttype = TREE_TYPE (type);
2144 tree *v = XALLOCAVEC (tree, len);
2145 for (int i = 0; i < len; ++i)
2147 tree elt = VECTOR_CST_ELT (arg1, i);
2148 tree cvt = fold_convert_const (code, elttype, elt);
2149 if (cvt == NULL_TREE)
2153 return build_vector (type, v);
2159 /* Construct a vector of zero elements of vector type TYPE. */
2162 build_zero_vector (tree type)
2166 t = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2167 return build_vector_from_val (type, t);
2170 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2173 fold_convertible_p (const_tree type, const_tree arg)
2175 tree orig = TREE_TYPE (arg);
2180 if (TREE_CODE (arg) == ERROR_MARK
2181 || TREE_CODE (type) == ERROR_MARK
2182 || TREE_CODE (orig) == ERROR_MARK)
2185 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2188 switch (TREE_CODE (type))
2190 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2191 case POINTER_TYPE: case REFERENCE_TYPE:
2193 return (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2194 || TREE_CODE (orig) == OFFSET_TYPE);
2197 case FIXED_POINT_TYPE:
2200 return TREE_CODE (type) == TREE_CODE (orig);
2207 /* Convert expression ARG to type TYPE. Used by the middle-end for
2208 simple conversions in preference to calling the front-end's convert. */
2211 fold_convert_loc (location_t loc, tree type, tree arg)
2213 tree orig = TREE_TYPE (arg);
2219 if (TREE_CODE (arg) == ERROR_MARK
2220 || TREE_CODE (type) == ERROR_MARK
2221 || TREE_CODE (orig) == ERROR_MARK)
2222 return error_mark_node;
2224 switch (TREE_CODE (type))
2227 case REFERENCE_TYPE:
2228 /* Handle conversions between pointers to different address spaces. */
2229 if (POINTER_TYPE_P (orig)
2230 && (TYPE_ADDR_SPACE (TREE_TYPE (type))
2231 != TYPE_ADDR_SPACE (TREE_TYPE (orig))))
2232 return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, arg);
2235 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2237 if (TREE_CODE (arg) == INTEGER_CST)
2239 tem = fold_convert_const (NOP_EXPR, type, arg);
2240 if (tem != NULL_TREE)
2243 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2244 || TREE_CODE (orig) == OFFSET_TYPE)
2245 return fold_build1_loc (loc, NOP_EXPR, type, arg);
2246 if (TREE_CODE (orig) == COMPLEX_TYPE)
2247 return fold_convert_loc (loc, type,
2248 fold_build1_loc (loc, REALPART_EXPR,
2249 TREE_TYPE (orig), arg));
2250 gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
2251 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2252 return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
2255 if (TREE_CODE (arg) == INTEGER_CST)
2257 tem = fold_convert_const (FLOAT_EXPR, type, arg);
2258 if (tem != NULL_TREE)
2261 else if (TREE_CODE (arg) == REAL_CST)
2263 tem = fold_convert_const (NOP_EXPR, type, arg);
2264 if (tem != NULL_TREE)
2267 else if (TREE_CODE (arg) == FIXED_CST)
2269 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2270 if (tem != NULL_TREE)
2274 switch (TREE_CODE (orig))
2277 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2278 case POINTER_TYPE: case REFERENCE_TYPE:
2279 return fold_build1_loc (loc, FLOAT_EXPR, type, arg);
2282 return fold_build1_loc (loc, NOP_EXPR, type, arg);
2284 case FIXED_POINT_TYPE:
2285 return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
2288 tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2289 return fold_convert_loc (loc, type, tem);
2295 case FIXED_POINT_TYPE:
2296 if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
2297 || TREE_CODE (arg) == REAL_CST)
2299 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2300 if (tem != NULL_TREE)
2301 goto fold_convert_exit;
2304 switch (TREE_CODE (orig))
2306 case FIXED_POINT_TYPE:
2311 return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
2314 tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2315 return fold_convert_loc (loc, type, tem);
2322 switch (TREE_CODE (orig))
2325 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2326 case POINTER_TYPE: case REFERENCE_TYPE:
2328 case FIXED_POINT_TYPE:
2329 return fold_build2_loc (loc, COMPLEX_EXPR, type,
2330 fold_convert_loc (loc, TREE_TYPE (type), arg),
2331 fold_convert_loc (loc, TREE_TYPE (type),
2332 integer_zero_node));
2337 if (TREE_CODE (arg) == COMPLEX_EXPR)
2339 rpart = fold_convert_loc (loc, TREE_TYPE (type),
2340 TREE_OPERAND (arg, 0));
2341 ipart = fold_convert_loc (loc, TREE_TYPE (type),
2342 TREE_OPERAND (arg, 1));
2343 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2346 arg = save_expr (arg);
2347 rpart = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2348 ipart = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (orig), arg);
2349 rpart = fold_convert_loc (loc, TREE_TYPE (type), rpart);
2350 ipart = fold_convert_loc (loc, TREE_TYPE (type), ipart);
2351 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2359 if (integer_zerop (arg))
2360 return build_zero_vector (type);
2361 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2362 gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2363 || TREE_CODE (orig) == VECTOR_TYPE);
2364 return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
2367 tem = fold_ignored_result (arg);
2368 return fold_build1_loc (loc, NOP_EXPR, type, tem);
2371 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2372 return fold_build1_loc (loc, NOP_EXPR, type, arg);
2376 protected_set_expr_location_unshare (tem, loc);
2380 /* Return false if expr can be assumed not to be an lvalue, true
2384 maybe_lvalue_p (const_tree x)
2386 /* We only need to wrap lvalue tree codes. */
2387 switch (TREE_CODE (x))
2400 case ARRAY_RANGE_REF:
2406 case PREINCREMENT_EXPR:
2407 case PREDECREMENT_EXPR:
2409 case TRY_CATCH_EXPR:
2410 case WITH_CLEANUP_EXPR:
2419 /* Assume the worst for front-end tree codes. */
2420 if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2428 /* Return an expr equal to X but certainly not valid as an lvalue. */
2431 non_lvalue_loc (location_t loc, tree x)
2433 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2438 if (! maybe_lvalue_p (x))
2440 return build1_loc (loc, NON_LVALUE_EXPR, TREE_TYPE (x), x);
2443 /* When pedantic, return an expr equal to X but certainly not valid as a
2444 pedantic lvalue. Otherwise, return X. */
2447 pedantic_non_lvalue_loc (location_t loc, tree x)
2449 return protected_set_expr_location_unshare (x, loc);
2452 /* Given a tree comparison code, return the code that is the logical inverse.
2453 It is generally not safe to do this for floating-point comparisons, except
2454 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2455 ERROR_MARK in this case. */
2458 invert_tree_comparison (enum tree_code code, bool honor_nans)
2460 if (honor_nans && flag_trapping_math && code != EQ_EXPR && code != NE_EXPR
2461 && code != ORDERED_EXPR && code != UNORDERED_EXPR)
2471 return honor_nans ? UNLE_EXPR : LE_EXPR;
2473 return honor_nans ? UNLT_EXPR : LT_EXPR;
2475 return honor_nans ? UNGE_EXPR : GE_EXPR;
2477 return honor_nans ? UNGT_EXPR : GT_EXPR;
2491 return UNORDERED_EXPR;
2492 case UNORDERED_EXPR:
2493 return ORDERED_EXPR;
2499 /* Similar, but return the comparison that results if the operands are
2500 swapped. This is safe for floating-point. */
2503 swap_tree_comparison (enum tree_code code)
2510 case UNORDERED_EXPR:
2536 /* Convert a comparison tree code from an enum tree_code representation
2537 into a compcode bit-based encoding. This function is the inverse of
2538 compcode_to_comparison. */
2540 static enum comparison_code
2541 comparison_to_compcode (enum tree_code code)
2558 return COMPCODE_ORD;
2559 case UNORDERED_EXPR:
2560 return COMPCODE_UNORD;
2562 return COMPCODE_UNLT;
2564 return COMPCODE_UNEQ;
2566 return COMPCODE_UNLE;
2568 return COMPCODE_UNGT;
2570 return COMPCODE_LTGT;
2572 return COMPCODE_UNGE;
2578 /* Convert a compcode bit-based encoding of a comparison operator back
2579 to GCC's enum tree_code representation. This function is the
2580 inverse of comparison_to_compcode. */
2582 static enum tree_code
2583 compcode_to_comparison (enum comparison_code code)
2600 return ORDERED_EXPR;
2601 case COMPCODE_UNORD:
2602 return UNORDERED_EXPR;
2620 /* Return a tree for the comparison which is the combination of
2621 doing the AND or OR (depending on CODE) of the two operations LCODE
2622 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2623 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2624 if this makes the transformation invalid. */
2627 combine_comparisons (location_t loc,
2628 enum tree_code code, enum tree_code lcode,
2629 enum tree_code rcode, tree truth_type,
2630 tree ll_arg, tree lr_arg)
2632 bool honor_nans = HONOR_NANS (ll_arg);
2633 enum comparison_code lcompcode = comparison_to_compcode (lcode);
2634 enum comparison_code rcompcode = comparison_to_compcode (rcode);
2639 case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2640 compcode = lcompcode & rcompcode;
2643 case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2644 compcode = lcompcode | rcompcode;
2653 /* Eliminate unordered comparisons, as well as LTGT and ORD
2654 which are not used unless the mode has NaNs. */
2655 compcode &= ~COMPCODE_UNORD;
2656 if (compcode == COMPCODE_LTGT)
2657 compcode = COMPCODE_NE;
2658 else if (compcode == COMPCODE_ORD)
2659 compcode = COMPCODE_TRUE;
2661 else if (flag_trapping_math)
2663 /* Check that the original operation and the optimized ones will trap
2664 under the same condition. */
2665 bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2666 && (lcompcode != COMPCODE_EQ)
2667 && (lcompcode != COMPCODE_ORD);
2668 bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2669 && (rcompcode != COMPCODE_EQ)
2670 && (rcompcode != COMPCODE_ORD);
2671 bool trap = (compcode & COMPCODE_UNORD) == 0
2672 && (compcode != COMPCODE_EQ)
2673 && (compcode != COMPCODE_ORD);
2675 /* In a short-circuited boolean expression the LHS might be
2676 such that the RHS, if evaluated, will never trap. For
2677 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2678 if neither x nor y is NaN. (This is a mixed blessing: for
2679 example, the expression above will never trap, hence
2680 optimizing it to x < y would be invalid). */
2681 if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2682 || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2685 /* If the comparison was short-circuited, and only the RHS
2686 trapped, we may now generate a spurious trap. */
2688 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2691 /* If we changed the conditions that cause a trap, we lose. */
2692 if ((ltrap || rtrap) != trap)
2696 if (compcode == COMPCODE_TRUE)
2697 return constant_boolean_node (true, truth_type);
2698 else if (compcode == COMPCODE_FALSE)
2699 return constant_boolean_node (false, truth_type);
2702 enum tree_code tcode;
2704 tcode = compcode_to_comparison ((enum comparison_code) compcode);
2705 return fold_build2_loc (loc, tcode, truth_type, ll_arg, lr_arg);
2709 /* Return nonzero if two operands (typically of the same tree node)
2710 are necessarily equal. FLAGS modifies behavior as follows:
2712 If OEP_ONLY_CONST is set, only return nonzero for constants.
2713 This function tests whether the operands are indistinguishable;
2714 it does not test whether they are equal using C's == operation.
2715 The distinction is important for IEEE floating point, because
2716 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2717 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2719 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2720 even though it may hold multiple values during a function.
2721 This is because a GCC tree node guarantees that nothing else is
2722 executed between the evaluation of its "operands" (which may often
2723 be evaluated in arbitrary order). Hence if the operands themselves
2724 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2725 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2726 unset means assuming isochronic (or instantaneous) tree equivalence.
2727 Unless comparing arbitrary expression trees, such as from different
2728 statements, this flag can usually be left unset.
2730 If OEP_PURE_SAME is set, then pure functions with identical arguments
2731 are considered the same. It is used when the caller has other ways
2732 to ensure that global memory is unchanged in between.
2734 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2735 not values of expressions.
2737 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2738 any operand with side effect. This is unnecesarily conservative in the
2739 case we know that arg0 and arg1 are in disjoint code paths (such as in
2740 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2741 addresses with TREE_CONSTANT flag set so we know that &var == &var
2742 even if var is volatile. */
2745 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
2747 /* If either is ERROR_MARK, they aren't equal. */
2748 if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK
2749 || TREE_TYPE (arg0) == error_mark_node
2750 || TREE_TYPE (arg1) == error_mark_node)
2753 /* Similar, if either does not have a type (like a released SSA name),
2754 they aren't equal. */
2755 if (!TREE_TYPE (arg0) || !TREE_TYPE (arg1))
2758 /* We cannot consider pointers to different address space equal. */
2759 if (POINTER_TYPE_P (TREE_TYPE (arg0))
2760 && POINTER_TYPE_P (TREE_TYPE (arg1))
2761 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0)))
2762 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1)))))
2765 /* Check equality of integer constants before bailing out due to
2766 precision differences. */
2767 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2769 /* Address of INTEGER_CST is not defined; check that we did not forget
2770 to drop the OEP_ADDRESS_OF flags. */
2771 gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
2772 return tree_int_cst_equal (arg0, arg1);
2775 if (!(flags & OEP_ADDRESS_OF))
2777 /* If both types don't have the same signedness, then we can't consider
2778 them equal. We must check this before the STRIP_NOPS calls
2779 because they may change the signedness of the arguments. As pointers
2780 strictly don't have a signedness, require either two pointers or
2781 two non-pointers as well. */
2782 if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
2783 || POINTER_TYPE_P (TREE_TYPE (arg0))
2784 != POINTER_TYPE_P (TREE_TYPE (arg1)))
2787 /* If both types don't have the same precision, then it is not safe
2789 if (element_precision (TREE_TYPE (arg0))
2790 != element_precision (TREE_TYPE (arg1)))
2797 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2798 sanity check once the issue is solved. */
2800 /* Addresses of conversions and SSA_NAMEs (and many other things)
2801 are not defined. Check that we did not forget to drop the
2802 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2803 gcc_checking_assert (!CONVERT_EXPR_P (arg0) && !CONVERT_EXPR_P (arg1)
2804 && TREE_CODE (arg0) != SSA_NAME);
2807 /* In case both args are comparisons but with different comparison
2808 code, try to swap the comparison operands of one arg to produce
2809 a match and compare that variant. */
2810 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2811 && COMPARISON_CLASS_P (arg0)
2812 && COMPARISON_CLASS_P (arg1))
2814 enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
2816 if (TREE_CODE (arg0) == swap_code)
2817 return operand_equal_p (TREE_OPERAND (arg0, 0),
2818 TREE_OPERAND (arg1, 1), flags)
2819 && operand_equal_p (TREE_OPERAND (arg0, 1),
2820 TREE_OPERAND (arg1, 0), flags);
2823 if (TREE_CODE (arg0) != TREE_CODE (arg1))
2825 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2826 if (CONVERT_EXPR_P (arg0) && CONVERT_EXPR_P (arg1))
2828 else if (flags & OEP_ADDRESS_OF)
2830 /* If we are interested in comparing addresses ignore
2831 MEM_REF wrappings of the base that can appear just for
2833 if (TREE_CODE (arg0) == MEM_REF
2835 && TREE_CODE (TREE_OPERAND (arg0, 0)) == ADDR_EXPR
2836 && TREE_OPERAND (TREE_OPERAND (arg0, 0), 0) == arg1
2837 && integer_zerop (TREE_OPERAND (arg0, 1)))
2839 else if (TREE_CODE (arg1) == MEM_REF
2841 && TREE_CODE (TREE_OPERAND (arg1, 0)) == ADDR_EXPR
2842 && TREE_OPERAND (TREE_OPERAND (arg1, 0), 0) == arg0
2843 && integer_zerop (TREE_OPERAND (arg1, 1)))
2851 /* When not checking adddresses, this is needed for conversions and for
2852 COMPONENT_REF. Might as well play it safe and always test this. */
2853 if (TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2854 || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2855 || (TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1))
2856 && !(flags & OEP_ADDRESS_OF)))
2859 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2860 We don't care about side effects in that case because the SAVE_EXPR
2861 takes care of that for us. In all other cases, two expressions are
2862 equal if they have no side effects. If we have two identical
2863 expressions with side effects that should be treated the same due
2864 to the only side effects being identical SAVE_EXPR's, that will
2865 be detected in the recursive calls below.
2866 If we are taking an invariant address of two identical objects
2867 they are necessarily equal as well. */
2868 if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2869 && (TREE_CODE (arg0) == SAVE_EXPR
2870 || (flags & OEP_MATCH_SIDE_EFFECTS)
2871 || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2874 /* Next handle constant cases, those for which we can return 1 even
2875 if ONLY_CONST is set. */
2876 if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2877 switch (TREE_CODE (arg0))
2880 return tree_int_cst_equal (arg0, arg1);
2883 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
2884 TREE_FIXED_CST (arg1));
2887 if (real_identical (&TREE_REAL_CST (arg0), &TREE_REAL_CST (arg1)))
2891 if (!HONOR_SIGNED_ZEROS (arg0))
2893 /* If we do not distinguish between signed and unsigned zero,
2894 consider them equal. */
2895 if (real_zerop (arg0) && real_zerop (arg1))
2904 if (VECTOR_CST_NELTS (arg0) != VECTOR_CST_NELTS (arg1))
2907 for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
2909 if (!operand_equal_p (VECTOR_CST_ELT (arg0, i),
2910 VECTOR_CST_ELT (arg1, i), flags))
2917 return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2919 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2923 return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2924 && ! memcmp (TREE_STRING_POINTER (arg0),
2925 TREE_STRING_POINTER (arg1),
2926 TREE_STRING_LENGTH (arg0)));
2929 gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
2930 return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2931 flags | OEP_ADDRESS_OF
2932 | OEP_MATCH_SIDE_EFFECTS);
2934 /* In GIMPLE empty constructors are allowed in initializers of
2936 return (!vec_safe_length (CONSTRUCTOR_ELTS (arg0))
2937 && !vec_safe_length (CONSTRUCTOR_ELTS (arg1)));
2942 if (flags & OEP_ONLY_CONST)
2945 /* Define macros to test an operand from arg0 and arg1 for equality and a
2946 variant that allows null and views null as being different from any
2947 non-null value. In the latter case, if either is null, the both
2948 must be; otherwise, do the normal comparison. */
2949 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2950 TREE_OPERAND (arg1, N), flags)
2952 #define OP_SAME_WITH_NULL(N) \
2953 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2954 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2956 switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2959 /* Two conversions are equal only if signedness and modes match. */
2960 switch (TREE_CODE (arg0))
2963 case FIX_TRUNC_EXPR:
2964 if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2965 != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2975 case tcc_comparison:
2977 if (OP_SAME (0) && OP_SAME (1))
2980 /* For commutative ops, allow the other order. */
2981 return (commutative_tree_code (TREE_CODE (arg0))
2982 && operand_equal_p (TREE_OPERAND (arg0, 0),
2983 TREE_OPERAND (arg1, 1), flags)
2984 && operand_equal_p (TREE_OPERAND (arg0, 1),
2985 TREE_OPERAND (arg1, 0), flags));
2988 /* If either of the pointer (or reference) expressions we are
2989 dereferencing contain a side effect, these cannot be equal,
2990 but their addresses can be. */
2991 if ((flags & OEP_MATCH_SIDE_EFFECTS) == 0
2992 && (TREE_SIDE_EFFECTS (arg0)
2993 || TREE_SIDE_EFFECTS (arg1)))
2996 switch (TREE_CODE (arg0))
2999 if (!(flags & OEP_ADDRESS_OF)
3000 && (TYPE_ALIGN (TREE_TYPE (arg0))
3001 != TYPE_ALIGN (TREE_TYPE (arg1))))
3003 flags &= ~OEP_ADDRESS_OF;
3007 /* Require the same offset. */
3008 if (!operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
3009 TYPE_SIZE (TREE_TYPE (arg1)),
3010 flags & ~OEP_ADDRESS_OF))
3015 case VIEW_CONVERT_EXPR:
3018 case TARGET_MEM_REF:
3020 if (!(flags & OEP_ADDRESS_OF))
3022 /* Require equal access sizes */
3023 if (TYPE_SIZE (TREE_TYPE (arg0)) != TYPE_SIZE (TREE_TYPE (arg1))
3024 && (!TYPE_SIZE (TREE_TYPE (arg0))
3025 || !TYPE_SIZE (TREE_TYPE (arg1))
3026 || !operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
3027 TYPE_SIZE (TREE_TYPE (arg1)),
3030 /* Verify that access happens in similar types. */
3031 if (!types_compatible_p (TREE_TYPE (arg0), TREE_TYPE (arg1)))
3033 /* Verify that accesses are TBAA compatible. */
3034 if (!alias_ptr_types_compatible_p
3035 (TREE_TYPE (TREE_OPERAND (arg0, 1)),
3036 TREE_TYPE (TREE_OPERAND (arg1, 1)))
3037 || (MR_DEPENDENCE_CLIQUE (arg0)
3038 != MR_DEPENDENCE_CLIQUE (arg1))
3039 || (MR_DEPENDENCE_BASE (arg0)
3040 != MR_DEPENDENCE_BASE (arg1)))
3042 /* Verify that alignment is compatible. */
3043 if (TYPE_ALIGN (TREE_TYPE (arg0))
3044 != TYPE_ALIGN (TREE_TYPE (arg1)))
3047 flags &= ~OEP_ADDRESS_OF;
3048 return (OP_SAME (0) && OP_SAME (1)
3049 /* TARGET_MEM_REF require equal extra operands. */
3050 && (TREE_CODE (arg0) != TARGET_MEM_REF
3051 || (OP_SAME_WITH_NULL (2)
3052 && OP_SAME_WITH_NULL (3)
3053 && OP_SAME_WITH_NULL (4))));
3056 case ARRAY_RANGE_REF:
3059 flags &= ~OEP_ADDRESS_OF;
3060 /* Compare the array index by value if it is constant first as we
3061 may have different types but same value here. */
3062 return ((tree_int_cst_equal (TREE_OPERAND (arg0, 1),
3063 TREE_OPERAND (arg1, 1))
3065 && OP_SAME_WITH_NULL (2)
3066 && OP_SAME_WITH_NULL (3)
3067 /* Compare low bound and element size as with OEP_ADDRESS_OF
3068 we have to account for the offset of the ref. */
3069 && (TREE_TYPE (TREE_OPERAND (arg0, 0))
3070 == TREE_TYPE (TREE_OPERAND (arg1, 0))
3071 || (operand_equal_p (array_ref_low_bound
3072 (CONST_CAST_TREE (arg0)),
3074 (CONST_CAST_TREE (arg1)), flags)
3075 && operand_equal_p (array_ref_element_size
3076 (CONST_CAST_TREE (arg0)),
3077 array_ref_element_size
3078 (CONST_CAST_TREE (arg1)),
3082 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3083 may be NULL when we're called to compare MEM_EXPRs. */
3084 if (!OP_SAME_WITH_NULL (0)
3087 flags &= ~OEP_ADDRESS_OF;
3088 return OP_SAME_WITH_NULL (2);
3093 flags &= ~OEP_ADDRESS_OF;
3094 return OP_SAME (1) && OP_SAME (2);
3100 case tcc_expression:
3101 switch (TREE_CODE (arg0))
3104 /* Be sure we pass right ADDRESS_OF flag. */
3105 gcc_checking_assert (!(flags & OEP_ADDRESS_OF));
3106 return operand_equal_p (TREE_OPERAND (arg0, 0),
3107 TREE_OPERAND (arg1, 0),
3108 flags | OEP_ADDRESS_OF);
3110 case TRUTH_NOT_EXPR:
3113 case TRUTH_ANDIF_EXPR:
3114 case TRUTH_ORIF_EXPR:
3115 return OP_SAME (0) && OP_SAME (1);
3118 case WIDEN_MULT_PLUS_EXPR:
3119 case WIDEN_MULT_MINUS_EXPR:
3122 /* The multiplcation operands are commutative. */
3125 case TRUTH_AND_EXPR:
3127 case TRUTH_XOR_EXPR:
3128 if (OP_SAME (0) && OP_SAME (1))
3131 /* Otherwise take into account this is a commutative operation. */
3132 return (operand_equal_p (TREE_OPERAND (arg0, 0),
3133 TREE_OPERAND (arg1, 1), flags)
3134 && operand_equal_p (TREE_OPERAND (arg0, 1),
3135 TREE_OPERAND (arg1, 0), flags));
3138 if (! OP_SAME (1) || ! OP_SAME (2))
3140 flags &= ~OEP_ADDRESS_OF;
3145 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3152 switch (TREE_CODE (arg0))
3155 if ((CALL_EXPR_FN (arg0) == NULL_TREE)
3156 != (CALL_EXPR_FN (arg1) == NULL_TREE))
3157 /* If not both CALL_EXPRs are either internal or normal function
3158 functions, then they are not equal. */
3160 else if (CALL_EXPR_FN (arg0) == NULL_TREE)
3162 /* If the CALL_EXPRs call different internal functions, then they
3164 if (CALL_EXPR_IFN (arg0) != CALL_EXPR_IFN (arg1))
3169 /* If the CALL_EXPRs call different functions, then they are not
3171 if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
3176 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3178 unsigned int cef = call_expr_flags (arg0);
3179 if (flags & OEP_PURE_SAME)
3180 cef &= ECF_CONST | ECF_PURE;
3187 /* Now see if all the arguments are the same. */
3189 const_call_expr_arg_iterator iter0, iter1;
3191 for (a0 = first_const_call_expr_arg (arg0, &iter0),
3192 a1 = first_const_call_expr_arg (arg1, &iter1);
3194 a0 = next_const_call_expr_arg (&iter0),
3195 a1 = next_const_call_expr_arg (&iter1))
3196 if (! operand_equal_p (a0, a1, flags))
3199 /* If we get here and both argument lists are exhausted
3200 then the CALL_EXPRs are equal. */
3201 return ! (a0 || a1);
3207 case tcc_declaration:
3208 /* Consider __builtin_sqrt equal to sqrt. */
3209 return (TREE_CODE (arg0) == FUNCTION_DECL
3210 && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
3211 && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
3212 && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
3214 case tcc_exceptional:
3215 if (TREE_CODE (arg0) == CONSTRUCTOR)
3217 /* In GIMPLE constructors are used only to build vectors from
3218 elements. Individual elements in the constructor must be
3219 indexed in increasing order and form an initial sequence.
3221 We make no effort to compare constructors in generic.
3222 (see sem_variable::equals in ipa-icf which can do so for
3224 if (!VECTOR_TYPE_P (TREE_TYPE (arg0))
3225 || !VECTOR_TYPE_P (TREE_TYPE (arg1)))
3228 /* Be sure that vectors constructed have the same representation.
3229 We only tested element precision and modes to match.
3230 Vectors may be BLKmode and thus also check that the number of
3232 if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0))
3233 != TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)))
3236 vec<constructor_elt, va_gc> *v0 = CONSTRUCTOR_ELTS (arg0);
3237 vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (arg1);
3238 unsigned int len = vec_safe_length (v0);
3240 if (len != vec_safe_length (v1))
3243 for (unsigned int i = 0; i < len; i++)
3245 constructor_elt *c0 = &(*v0)[i];
3246 constructor_elt *c1 = &(*v1)[i];
3248 if (!operand_equal_p (c0->value, c1->value, flags)
3249 /* In GIMPLE the indexes can be either NULL or matching i.
3250 Double check this so we won't get false
3251 positives for GENERIC. */
3253 && (TREE_CODE (c0->index) != INTEGER_CST
3254 || !compare_tree_int (c0->index, i)))
3256 && (TREE_CODE (c1->index) != INTEGER_CST
3257 || !compare_tree_int (c1->index, i))))
3269 #undef OP_SAME_WITH_NULL
3272 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3273 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3275 When in doubt, return 0. */
3278 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
3280 int unsignedp1, unsignedpo;
3281 tree primarg0, primarg1, primother;
3282 unsigned int correct_width;
3284 if (operand_equal_p (arg0, arg1, 0))
3287 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
3288 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
3291 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3292 and see if the inner values are the same. This removes any
3293 signedness comparison, which doesn't matter here. */
3294 primarg0 = arg0, primarg1 = arg1;
3295 STRIP_NOPS (primarg0);
3296 STRIP_NOPS (primarg1);
3297 if (operand_equal_p (primarg0, primarg1, 0))
3300 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3301 actual comparison operand, ARG0.
3303 First throw away any conversions to wider types
3304 already present in the operands. */
3306 primarg1 = get_narrower (arg1, &unsignedp1);
3307 primother = get_narrower (other, &unsignedpo);
3309 correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
3310 if (unsignedp1 == unsignedpo
3311 && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
3312 && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
3314 tree type = TREE_TYPE (arg0);
3316 /* Make sure shorter operand is extended the right way
3317 to match the longer operand. */
3318 primarg1 = fold_convert (signed_or_unsigned_type_for
3319 (unsignedp1, TREE_TYPE (primarg1)), primarg1);
3321 if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
3328 /* See if ARG is an expression that is either a comparison or is performing
3329 arithmetic on comparisons. The comparisons must only be comparing
3330 two different values, which will be stored in *CVAL1 and *CVAL2; if
3331 they are nonzero it means that some operands have already been found.
3332 No variables may be used anywhere else in the expression except in the
3333 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3334 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3336 If this is true, return 1. Otherwise, return zero. */
3339 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
3341 enum tree_code code = TREE_CODE (arg);
3342 enum tree_code_class tclass = TREE_CODE_CLASS (code);
3344 /* We can handle some of the tcc_expression cases here. */
3345 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3347 else if (tclass == tcc_expression
3348 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
3349 || code == COMPOUND_EXPR))
3350 tclass = tcc_binary;
3352 else if (tclass == tcc_expression && code == SAVE_EXPR
3353 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
3355 /* If we've already found a CVAL1 or CVAL2, this expression is
3356 two complex to handle. */
3357 if (*cval1 || *cval2)
3367 return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
3370 return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
3371 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3372 cval1, cval2, save_p));
3377 case tcc_expression:
3378 if (code == COND_EXPR)
3379 return (twoval_comparison_p (TREE_OPERAND (arg, 0),
3380 cval1, cval2, save_p)
3381 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3382 cval1, cval2, save_p)
3383 && twoval_comparison_p (TREE_OPERAND (arg, 2),
3384 cval1, cval2, save_p));
3387 case tcc_comparison:
3388 /* First see if we can handle the first operand, then the second. For
3389 the second operand, we know *CVAL1 can't be zero. It must be that
3390 one side of the comparison is each of the values; test for the
3391 case where this isn't true by failing if the two operands
3394 if (operand_equal_p (TREE_OPERAND (arg, 0),
3395 TREE_OPERAND (arg, 1), 0))
3399 *cval1 = TREE_OPERAND (arg, 0);
3400 else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
3402 else if (*cval2 == 0)
3403 *cval2 = TREE_OPERAND (arg, 0);
3404 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
3409 if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
3411 else if (*cval2 == 0)
3412 *cval2 = TREE_OPERAND (arg, 1);
3413 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
3425 /* ARG is a tree that is known to contain just arithmetic operations and
3426 comparisons. Evaluate the operations in the tree substituting NEW0 for
3427 any occurrence of OLD0 as an operand of a comparison and likewise for
3431 eval_subst (location_t loc, tree arg, tree old0, tree new0,
3432 tree old1, tree new1)
3434 tree type = TREE_TYPE (arg);
3435 enum tree_code code = TREE_CODE (arg);
3436 enum tree_code_class tclass = TREE_CODE_CLASS (code);
3438 /* We can handle some of the tcc_expression cases here. */
3439 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3441 else if (tclass == tcc_expression
3442 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3443 tclass = tcc_binary;
3448 return fold_build1_loc (loc, code, type,
3449 eval_subst (loc, TREE_OPERAND (arg, 0),
3450 old0, new0, old1, new1));
3453 return fold_build2_loc (loc, code, type,
3454 eval_subst (loc, TREE_OPERAND (arg, 0),
3455 old0, new0, old1, new1),
3456 eval_subst (loc, TREE_OPERAND (arg, 1),
3457 old0, new0, old1, new1));
3459 case tcc_expression:
3463 return eval_subst (loc, TREE_OPERAND (arg, 0), old0, new0,
3467 return eval_subst (loc, TREE_OPERAND (arg, 1), old0, new0,
3471 return fold_build3_loc (loc, code, type,
3472 eval_subst (loc, TREE_OPERAND (arg, 0),
3473 old0, new0, old1, new1),
3474 eval_subst (loc, TREE_OPERAND (arg, 1),
3475 old0, new0, old1, new1),
3476 eval_subst (loc, TREE_OPERAND (arg, 2),
3477 old0, new0, old1, new1));
3481 /* Fall through - ??? */
3483 case tcc_comparison:
3485 tree arg0 = TREE_OPERAND (arg, 0);
3486 tree arg1 = TREE_OPERAND (arg, 1);
3488 /* We need to check both for exact equality and tree equality. The
3489 former will be true if the operand has a side-effect. In that
3490 case, we know the operand occurred exactly once. */
3492 if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3494 else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3497 if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3499 else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3502 return fold_build2_loc (loc, code, type, arg0, arg1);
3510 /* Return a tree for the case when the result of an expression is RESULT
3511 converted to TYPE and OMITTED was previously an operand of the expression
3512 but is now not needed (e.g., we folded OMITTED * 0).
3514 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3515 the conversion of RESULT to TYPE. */
3518 omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted)
3520 tree t = fold_convert_loc (loc, type, result);
3522 /* If the resulting operand is an empty statement, just return the omitted
3523 statement casted to void. */
3524 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3525 return build1_loc (loc, NOP_EXPR, void_type_node,
3526 fold_ignored_result (omitted));
3528 if (TREE_SIDE_EFFECTS (omitted))
3529 return build2_loc (loc, COMPOUND_EXPR, type,
3530 fold_ignored_result (omitted), t);
3532 return non_lvalue_loc (loc, t);
3535 /* Return a tree for the case when the result of an expression is RESULT
3536 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3537 of the expression but are now not needed.
3539 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3540 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3541 evaluated before OMITTED2. Otherwise, if neither has side effects,
3542 just do the conversion of RESULT to TYPE. */
3545 omit_two_operands_loc (location_t loc, tree type, tree result,
3546 tree omitted1, tree omitted2)
3548 tree t = fold_convert_loc (loc, type, result);
3550 if (TREE_SIDE_EFFECTS (omitted2))
3551 t = build2_loc (loc, COMPOUND_EXPR, type, omitted2, t);
3552 if (TREE_SIDE_EFFECTS (omitted1))
3553 t = build2_loc (loc, COMPOUND_EXPR, type, omitted1, t);
3555 return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue_loc (loc, t) : t;
3559 /* Return a simplified tree node for the truth-negation of ARG. This
3560 never alters ARG itself. We assume that ARG is an operation that
3561 returns a truth value (0 or 1).
3563 FIXME: one would think we would fold the result, but it causes
3564 problems with the dominator optimizer. */
3567 fold_truth_not_expr (location_t loc, tree arg)
3569 tree type = TREE_TYPE (arg);
3570 enum tree_code code = TREE_CODE (arg);
3571 location_t loc1, loc2;
3573 /* If this is a comparison, we can simply invert it, except for
3574 floating-point non-equality comparisons, in which case we just
3575 enclose a TRUTH_NOT_EXPR around what we have. */
3577 if (TREE_CODE_CLASS (code) == tcc_comparison)
3579 tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3580 if (FLOAT_TYPE_P (op_type)
3581 && flag_trapping_math
3582 && code != ORDERED_EXPR && code != UNORDERED_EXPR
3583 && code != NE_EXPR && code != EQ_EXPR)
3586 code = invert_tree_comparison (code, HONOR_NANS (op_type));
3587 if (code == ERROR_MARK)
3590 tree ret = build2_loc (loc, code, type, TREE_OPERAND (arg, 0),
3591 TREE_OPERAND (arg, 1));
3592 if (TREE_NO_WARNING (arg))
3593 TREE_NO_WARNING (ret) = 1;
3600 return constant_boolean_node (integer_zerop (arg), type);
3602 case TRUTH_AND_EXPR:
3603 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3604 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3605 return build2_loc (loc, TRUTH_OR_EXPR, type,
3606 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3607 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3610 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3611 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3612 return build2_loc (loc, TRUTH_AND_EXPR, type,
3613 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3614 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3616 case TRUTH_XOR_EXPR:
3617 /* Here we can invert either operand. We invert the first operand
3618 unless the second operand is a TRUTH_NOT_EXPR in which case our
3619 result is the XOR of the first operand with the inside of the
3620 negation of the second operand. */
3622 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3623 return build2_loc (loc, TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3624 TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3626 return build2_loc (loc, TRUTH_XOR_EXPR, type,
3627 invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
3628 TREE_OPERAND (arg, 1));
3630 case TRUTH_ANDIF_EXPR:
3631 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3632 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3633 return build2_loc (loc, TRUTH_ORIF_EXPR, type,
3634 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3635 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3637 case TRUTH_ORIF_EXPR:
3638 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3639 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3640 return build2_loc (loc, TRUTH_ANDIF_EXPR, type,
3641 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3642 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3644 case TRUTH_NOT_EXPR:
3645 return TREE_OPERAND (arg, 0);
3649 tree arg1 = TREE_OPERAND (arg, 1);
3650 tree arg2 = TREE_OPERAND (arg, 2);
3652 loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3653 loc2 = expr_location_or (TREE_OPERAND (arg, 2), loc);
3655 /* A COND_EXPR may have a throw as one operand, which
3656 then has void type. Just leave void operands
3658 return build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg, 0),
3659 VOID_TYPE_P (TREE_TYPE (arg1))
3660 ? arg1 : invert_truthvalue_loc (loc1, arg1),
3661 VOID_TYPE_P (TREE_TYPE (arg2))
3662 ? arg2 : invert_truthvalue_loc (loc2, arg2));
3666 loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3667 return build2_loc (loc, COMPOUND_EXPR, type,
3668 TREE_OPERAND (arg, 0),
3669 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
3671 case NON_LVALUE_EXPR:
3672 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3673 return invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0));
3676 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3677 return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3679 /* ... fall through ... */
3682 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3683 return build1_loc (loc, TREE_CODE (arg), type,
3684 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3687 if (!integer_onep (TREE_OPERAND (arg, 1)))
3689 return build2_loc (loc, EQ_EXPR, type, arg, build_int_cst (type, 0));
3692 return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3694 case CLEANUP_POINT_EXPR:
3695 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3696 return build1_loc (loc, CLEANUP_POINT_EXPR, type,
3697 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3704 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3705 assume that ARG is an operation that returns a truth value (0 or 1
3706 for scalars, 0 or -1 for vectors). Return the folded expression if
3707 folding is successful. Otherwise, return NULL_TREE. */
3710 fold_invert_truthvalue (location_t loc, tree arg)
3712 tree type = TREE_TYPE (arg);
3713 return fold_unary_loc (loc, VECTOR_TYPE_P (type)
3719 /* Return a simplified tree node for the truth-negation of ARG. This
3720 never alters ARG itself. We assume that ARG is an operation that
3721 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3724 invert_truthvalue_loc (location_t loc, tree arg)
3726 if (TREE_CODE (arg) == ERROR_MARK)
3729 tree type = TREE_TYPE (arg);
3730 return fold_build1_loc (loc, VECTOR_TYPE_P (type)
3736 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3737 with code CODE. This optimization is unsafe. */
3739 distribute_real_division (location_t loc, enum tree_code code, tree type,
3740 tree arg0, tree arg1)
3742 bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3743 bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3745 /* (A / C) +- (B / C) -> (A +- B) / C. */
3747 && operand_equal_p (TREE_OPERAND (arg0, 1),
3748 TREE_OPERAND (arg1, 1), 0))
3749 return fold_build2_loc (loc, mul0 ? MULT_EXPR : RDIV_EXPR, type,
3750 fold_build2_loc (loc, code, type,
3751 TREE_OPERAND (arg0, 0),
3752 TREE_OPERAND (arg1, 0)),
3753 TREE_OPERAND (arg0, 1));
3755 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3756 if (operand_equal_p (TREE_OPERAND (arg0, 0),
3757 TREE_OPERAND (arg1, 0), 0)
3758 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3759 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3761 REAL_VALUE_TYPE r0, r1;
3762 r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3763 r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3765 real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3767 real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3768 real_arithmetic (&r0, code, &r0, &r1);
3769 return fold_build2_loc (loc, MULT_EXPR, type,
3770 TREE_OPERAND (arg0, 0),
3771 build_real (type, r0));
3777 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3778 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3779 and uses reverse storage order if REVERSEP is nonzero. ORIG_INNER
3780 is the original memory reference used to preserve the alias set of
3784 make_bit_field_ref (location_t loc, tree inner, tree orig_inner, tree type,
3785 HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
3786 int unsignedp, int reversep)
3788 tree result, bftype;
3790 alias_set_type iset = get_alias_set (orig_inner);
3791 if (iset == 0 && get_alias_set (inner) != iset)
3792 inner = fold_build2 (MEM_REF, TREE_TYPE (inner),
3793 build_fold_addr_expr (inner),
3794 build_int_cst (ptr_type_node, 0));
3796 if (bitpos == 0 && !reversep)
3798 tree size = TYPE_SIZE (TREE_TYPE (inner));
3799 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3800 || POINTER_TYPE_P (TREE_TYPE (inner)))
3801 && tree_fits_shwi_p (size)
3802 && tree_to_shwi (size) == bitsize)
3803 return fold_convert_loc (loc, type, inner);
3807 if (TYPE_PRECISION (bftype) != bitsize
3808 || TYPE_UNSIGNED (bftype) == !unsignedp)
3809 bftype = build_nonstandard_integer_type (bitsize, 0);
3811 result = build3_loc (loc, BIT_FIELD_REF, bftype, inner,
3812 size_int (bitsize), bitsize_int (bitpos));
3813 REF_REVERSE_STORAGE_ORDER (result) = reversep;
3816 result = fold_convert_loc (loc, type, result);
3821 /* Optimize a bit-field compare.
3823 There are two cases: First is a compare against a constant and the
3824 second is a comparison of two items where the fields are at the same
3825 bit position relative to the start of a chunk (byte, halfword, word)
3826 large enough to contain it. In these cases we can avoid the shift
3827 implicit in bitfield extractions.
3829 For constants, we emit a compare of the shifted constant with the
3830 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3831 compared. For two fields at the same position, we do the ANDs with the
3832 similar mask and compare the result of the ANDs.
3834 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3835 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3836 are the left and right operands of the comparison, respectively.
3838 If the optimization described above can be done, we return the resulting
3839 tree. Otherwise we return zero. */
3842 optimize_bit_field_compare (location_t loc, enum tree_code code,
3843 tree compare_type, tree lhs, tree rhs)
3845 HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3846 tree type = TREE_TYPE (lhs);
3848 int const_p = TREE_CODE (rhs) == INTEGER_CST;
3849 machine_mode lmode, rmode, nmode;
3850 int lunsignedp, runsignedp;
3851 int lreversep, rreversep;
3852 int lvolatilep = 0, rvolatilep = 0;
3853 tree linner, rinner = NULL_TREE;
3857 /* Get all the information about the extractions being done. If the bit size
3858 if the same as the size of the underlying object, we aren't doing an
3859 extraction at all and so can do nothing. We also don't want to
3860 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3861 then will no longer be able to replace it. */
3862 linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3863 &lunsignedp, &lreversep, &lvolatilep, false);
3864 if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3865 || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR || lvolatilep)
3869 rreversep = lreversep;
3872 /* If this is not a constant, we can only do something if bit positions,
3873 sizes, signedness and storage order are the same. */
3875 = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3876 &runsignedp, &rreversep, &rvolatilep, false);
3878 if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3879 || lunsignedp != runsignedp || lreversep != rreversep || offset != 0
3880 || TREE_CODE (rinner) == PLACEHOLDER_EXPR || rvolatilep)
3884 /* See if we can find a mode to refer to this field. We should be able to,
3885 but fail if we can't. */
3886 nmode = get_best_mode (lbitsize, lbitpos, 0, 0,
3887 const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3888 : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3889 TYPE_ALIGN (TREE_TYPE (rinner))),
3891 if (nmode == VOIDmode)
3894 /* Set signed and unsigned types of the precision of this mode for the
3896 unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3898 /* Compute the bit position and size for the new reference and our offset
3899 within it. If the new reference is the same size as the original, we
3900 won't optimize anything, so return zero. */
3901 nbitsize = GET_MODE_BITSIZE (nmode);
3902 nbitpos = lbitpos & ~ (nbitsize - 1);
3904 if (nbitsize == lbitsize)
3907 if (lreversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
3908 lbitpos = nbitsize - lbitsize - lbitpos;
3910 /* Make the mask to be used against the extracted field. */
3911 mask = build_int_cst_type (unsigned_type, -1);
3912 mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize));
3913 mask = const_binop (RSHIFT_EXPR, mask,
3914 size_int (nbitsize - lbitsize - lbitpos));
3917 /* If not comparing with constant, just rework the comparison
3919 return fold_build2_loc (loc, code, compare_type,
3920 fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3921 make_bit_field_ref (loc, linner, lhs,
3926 fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3927 make_bit_field_ref (loc, rinner, rhs,
3933 /* Otherwise, we are handling the constant case. See if the constant is too
3934 big for the field. Warn and return a tree for 0 (false) if so. We do
3935 this not only for its own sake, but to avoid having to test for this
3936 error case below. If we didn't, we might generate wrong code.
3938 For unsigned fields, the constant shifted right by the field length should
3939 be all zero. For signed fields, the high-order bits should agree with
3944 if (wi::lrshift (rhs, lbitsize) != 0)
3946 warning (0, "comparison is always %d due to width of bit-field",
3948 return constant_boolean_node (code == NE_EXPR, compare_type);
3953 wide_int tem = wi::arshift (rhs, lbitsize - 1);
3954 if (tem != 0 && tem != -1)
3956 warning (0, "comparison is always %d due to width of bit-field",
3958 return constant_boolean_node (code == NE_EXPR, compare_type);
3962 /* Single-bit compares should always be against zero. */
3963 if (lbitsize == 1 && ! integer_zerop (rhs))
3965 code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3966 rhs = build_int_cst (type, 0);
3969 /* Make a new bitfield reference, shift the constant over the
3970 appropriate number of bits and mask it with the computed mask
3971 (in case this was a signed field). If we changed it, make a new one. */
3972 lhs = make_bit_field_ref (loc, linner, lhs, unsigned_type,
3973 nbitsize, nbitpos, 1, lreversep);
3975 rhs = const_binop (BIT_AND_EXPR,
3976 const_binop (LSHIFT_EXPR,
3977 fold_convert_loc (loc, unsigned_type, rhs),
3978 size_int (lbitpos)),
3981 lhs = build2_loc (loc, code, compare_type,
3982 build2 (BIT_AND_EXPR, unsigned_type, lhs, mask), rhs);
3986 /* Subroutine for fold_truth_andor_1: decode a field reference.
3988 If EXP is a comparison reference, we return the innermost reference.
3990 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3991 set to the starting bit number.
3993 If the innermost field can be completely contained in a mode-sized
3994 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
3996 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3997 otherwise it is not changed.
3999 *PUNSIGNEDP is set to the signedness of the field.
4001 *PREVERSEP is set to the storage order of the field.
4003 *PMASK is set to the mask used. This is either contained in a
4004 BIT_AND_EXPR or derived from the width of the field.
4006 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4008 Return 0 if this is not a component reference or is one that we can't
4009 do anything with. */
4012 decode_field_reference (location_t loc, tree *exp_, HOST_WIDE_INT *pbitsize,
4013 HOST_WIDE_INT *pbitpos, machine_mode *pmode,
4014 int *punsignedp, int *preversep, int *pvolatilep,
4015 tree *pmask, tree *pand_mask)
4018 tree outer_type = 0;
4020 tree mask, inner, offset;
4022 unsigned int precision;
4024 /* All the optimizations using this function assume integer fields.
4025 There are problems with FP fields since the type_for_size call
4026 below can fail for, e.g., XFmode. */
4027 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
4030 /* We are interested in the bare arrangement of bits, so strip everything
4031 that doesn't affect the machine mode. However, record the type of the
4032 outermost expression if it may matter below. */
4033 if (CONVERT_EXPR_P (exp)
4034 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4035 outer_type = TREE_TYPE (exp);
4038 if (TREE_CODE (exp) == BIT_AND_EXPR)
4040 and_mask = TREE_OPERAND (exp, 1);
4041 exp = TREE_OPERAND (exp, 0);
4042 STRIP_NOPS (exp); STRIP_NOPS (and_mask);
4043 if (TREE_CODE (and_mask) != INTEGER_CST)
4047 inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
4048 punsignedp, preversep, pvolatilep, false);
4049 if ((inner == exp && and_mask == 0)
4050 || *pbitsize < 0 || offset != 0
4051 || TREE_CODE (inner) == PLACEHOLDER_EXPR)
4056 /* If the number of bits in the reference is the same as the bitsize of
4057 the outer type, then the outer type gives the signedness. Otherwise
4058 (in case of a small bitfield) the signedness is unchanged. */
4059 if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
4060 *punsignedp = TYPE_UNSIGNED (outer_type);
4062 /* Compute the mask to access the bitfield. */
4063 unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
4064 precision = TYPE_PRECISION (unsigned_type);
4066 mask = build_int_cst_type (unsigned_type, -1);
4068 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize));
4069 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize));
4071 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4073 mask = fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
4074 fold_convert_loc (loc, unsigned_type, and_mask), mask);
4077 *pand_mask = and_mask;
4081 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4082 bit positions and MASK is SIGNED. */
4085 all_ones_mask_p (const_tree mask, unsigned int size)
4087 tree type = TREE_TYPE (mask);
4088 unsigned int precision = TYPE_PRECISION (type);
4090 /* If this function returns true when the type of the mask is
4091 UNSIGNED, then there will be errors. In particular see
4092 gcc.c-torture/execute/990326-1.c. There does not appear to be
4093 any documentation paper trail as to why this is so. But the pre
4094 wide-int worked with that restriction and it has been preserved
4096 if (size > precision || TYPE_SIGN (type) == UNSIGNED)
4099 return wi::mask (size, false, precision) == mask;
4102 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4103 represents the sign bit of EXP's type. If EXP represents a sign
4104 or zero extension, also test VAL against the unextended type.
4105 The return value is the (sub)expression whose sign bit is VAL,
4106 or NULL_TREE otherwise. */
4109 sign_bit_p (tree exp, const_tree val)
4114 /* Tree EXP must have an integral type. */
4115 t = TREE_TYPE (exp);
4116 if (! INTEGRAL_TYPE_P (t))
4119 /* Tree VAL must be an integer constant. */
4120 if (TREE_CODE (val) != INTEGER_CST
4121 || TREE_OVERFLOW (val))
4124 width = TYPE_PRECISION (t);
4125 if (wi::only_sign_bit_p (val, width))
4128 /* Handle extension from a narrower type. */
4129 if (TREE_CODE (exp) == NOP_EXPR
4130 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
4131 return sign_bit_p (TREE_OPERAND (exp, 0), val);
4136 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4137 to be evaluated unconditionally. */
4140 simple_operand_p (const_tree exp)
4142 /* Strip any conversions that don't change the machine mode. */
4145 return (CONSTANT_CLASS_P (exp)
4146 || TREE_CODE (exp) == SSA_NAME
4148 && ! TREE_ADDRESSABLE (exp)
4149 && ! TREE_THIS_VOLATILE (exp)
4150 && ! DECL_NONLOCAL (exp)
4151 /* Don't regard global variables as simple. They may be
4152 allocated in ways unknown to the compiler (shared memory,
4153 #pragma weak, etc). */
4154 && ! TREE_PUBLIC (exp)
4155 && ! DECL_EXTERNAL (exp)
4156 /* Weakrefs are not safe to be read, since they can be NULL.
4157 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4158 have DECL_WEAK flag set. */
4159 && (! VAR_OR_FUNCTION_DECL_P (exp) || ! DECL_WEAK (exp))
4160 /* Loading a static variable is unduly expensive, but global
4161 registers aren't expensive. */
4162 && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
4165 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4166 to be evaluated unconditionally.
4167 I addition to simple_operand_p, we assume that comparisons, conversions,
4168 and logic-not operations are simple, if their operands are simple, too. */
4171 simple_operand_p_2 (tree exp)
4173 enum tree_code code;
4175 if (TREE_SIDE_EFFECTS (exp)
4176 || tree_could_trap_p (exp))
4179 while (CONVERT_EXPR_P (exp))
4180 exp = TREE_OPERAND (exp, 0);
4182 code = TREE_CODE (exp);
4184 if (TREE_CODE_CLASS (code) == tcc_comparison)
4185 return (simple_operand_p (TREE_OPERAND (exp, 0))
4186 && simple_operand_p (TREE_OPERAND (exp, 1)));
4188 if (code == TRUTH_NOT_EXPR)
4189 return simple_operand_p_2 (TREE_OPERAND (exp, 0));
4191 return simple_operand_p (exp);
4195 /* The following functions are subroutines to fold_range_test and allow it to
4196 try to change a logical combination of comparisons into a range test.
4199 X == 2 || X == 3 || X == 4 || X == 5
4203 (unsigned) (X - 2) <= 3
4205 We describe each set of comparisons as being either inside or outside
4206 a range, using a variable named like IN_P, and then describe the
4207 range with a lower and upper bound. If one of the bounds is omitted,
4208 it represents either the highest or lowest value of the type.
4210 In the comments below, we represent a range by two numbers in brackets
4211 preceded by a "+" to designate being inside that range, or a "-" to
4212 designate being outside that range, so the condition can be inverted by
4213 flipping the prefix. An omitted bound is represented by a "-". For
4214 example, "- [-, 10]" means being outside the range starting at the lowest
4215 possible value and ending at 10, in other words, being greater than 10.
4216 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4219 We set up things so that the missing bounds are handled in a consistent
4220 manner so neither a missing bound nor "true" and "false" need to be
4221 handled using a special case. */
4223 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4224 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4225 and UPPER1_P are nonzero if the respective argument is an upper bound
4226 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4227 must be specified for a comparison. ARG1 will be converted to ARG0's
4228 type if both are specified. */
4231 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
4232 tree arg1, int upper1_p)
4238 /* If neither arg represents infinity, do the normal operation.
4239 Else, if not a comparison, return infinity. Else handle the special
4240 comparison rules. Note that most of the cases below won't occur, but
4241 are handled for consistency. */
4243 if (arg0 != 0 && arg1 != 0)
4245 tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
4246 arg0, fold_convert (TREE_TYPE (arg0), arg1));
4248 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
4251 if (TREE_CODE_CLASS (code) != tcc_comparison)
4254 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4255 for neither. In real maths, we cannot assume open ended ranges are
4256 the same. But, this is computer arithmetic, where numbers are finite.
4257 We can therefore make the transformation of any unbounded range with
4258 the value Z, Z being greater than any representable number. This permits
4259 us to treat unbounded ranges as equal. */
4260 sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
4261 sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
4265 result = sgn0 == sgn1;
4268 result = sgn0 != sgn1;
4271 result = sgn0 < sgn1;
4274 result = sgn0 <= sgn1;
4277 result = sgn0 > sgn1;
4280 result = sgn0 >= sgn1;
4286 return constant_boolean_node (result, type);
4289 /* Helper routine for make_range. Perform one step for it, return
4290 new expression if the loop should continue or NULL_TREE if it should
4294 make_range_step (location_t loc, enum tree_code code, tree arg0, tree arg1,
4295 tree exp_type, tree *p_low, tree *p_high, int *p_in_p,
4296 bool *strict_overflow_p)
4298 tree arg0_type = TREE_TYPE (arg0);
4299 tree n_low, n_high, low = *p_low, high = *p_high;
4300 int in_p = *p_in_p, n_in_p;
4304 case TRUTH_NOT_EXPR:
4305 /* We can only do something if the range is testing for zero. */
4306 if (low == NULL_TREE || high == NULL_TREE
4307 || ! integer_zerop (low) || ! integer_zerop (high))
4312 case EQ_EXPR: case NE_EXPR:
4313 case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
4314 /* We can only do something if the range is testing for zero
4315 and if the second operand is an integer constant. Note that
4316 saying something is "in" the range we make is done by
4317 complementing IN_P since it will set in the initial case of
4318 being not equal to zero; "out" is leaving it alone. */
4319 if (low == NULL_TREE || high == NULL_TREE
4320 || ! integer_zerop (low) || ! integer_zerop (high)
4321 || TREE_CODE (arg1) != INTEGER_CST)
4326 case NE_EXPR: /* - [c, c] */
4329 case EQ_EXPR: /* + [c, c] */
4330 in_p = ! in_p, low = high = arg1;
4332 case GT_EXPR: /* - [-, c] */
4333 low = 0, high = arg1;
4335 case GE_EXPR: /* + [c, -] */
4336 in_p = ! in_p, low = arg1, high = 0;
4338 case LT_EXPR: /* - [c, -] */
4339 low = arg1, high = 0;
4341 case LE_EXPR: /* + [-, c] */
4342 in_p = ! in_p, low = 0, high = arg1;
4348 /* If this is an unsigned comparison, we also know that EXP is
4349 greater than or equal to zero. We base the range tests we make
4350 on that fact, so we record it here so we can parse existing
4351 range tests. We test arg0_type since often the return type
4352 of, e.g. EQ_EXPR, is boolean. */
4353 if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
4355 if (! merge_ranges (&n_in_p, &n_low, &n_high,
4357 build_int_cst (arg0_type, 0),
4361 in_p = n_in_p, low = n_low, high = n_high;
4363 /* If the high bound is missing, but we have a nonzero low
4364 bound, reverse the range so it goes from zero to the low bound
4366 if (high == 0 && low && ! integer_zerop (low))
4369 high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
4370 build_int_cst (TREE_TYPE (low), 1), 0);
4371 low = build_int_cst (arg0_type, 0);
4381 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4382 low and high are non-NULL, then normalize will DTRT. */
4383 if (!TYPE_UNSIGNED (arg0_type)
4384 && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4386 if (low == NULL_TREE)
4387 low = TYPE_MIN_VALUE (arg0_type);
4388 if (high == NULL_TREE)
4389 high = TYPE_MAX_VALUE (arg0_type);
4392 /* (-x) IN [a,b] -> x in [-b, -a] */
4393 n_low = range_binop (MINUS_EXPR, exp_type,
4394 build_int_cst (exp_type, 0),
4396 n_high = range_binop (MINUS_EXPR, exp_type,
4397 build_int_cst (exp_type, 0),
4399 if (n_high != 0 && TREE_OVERFLOW (n_high))
4405 return build2_loc (loc, MINUS_EXPR, exp_type, negate_expr (arg0),
4406 build_int_cst (exp_type, 1));
4410 if (TREE_CODE (arg1) != INTEGER_CST)
4413 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4414 move a constant to the other side. */
4415 if (!TYPE_UNSIGNED (arg0_type)
4416 && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4419 /* If EXP is signed, any overflow in the computation is undefined,
4420 so we don't worry about it so long as our computations on
4421 the bounds don't overflow. For unsigned, overflow is defined
4422 and this is exactly the right thing. */
4423 n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4424 arg0_type, low, 0, arg1, 0);
4425 n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4426 arg0_type, high, 1, arg1, 0);
4427 if ((n_low != 0 && TREE_OVERFLOW (n_low))
4428 || (n_high != 0 && TREE_OVERFLOW (n_high)))
4431 if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
4432 *strict_overflow_p = true;
4435 /* Check for an unsigned range which has wrapped around the maximum
4436 value thus making n_high < n_low, and normalize it. */
4437 if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
4439 low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
4440 build_int_cst (TREE_TYPE (n_high), 1), 0);
4441 high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
4442 build_int_cst (TREE_TYPE (n_low), 1), 0);
4444 /* If the range is of the form +/- [ x+1, x ], we won't
4445 be able to normalize it. But then, it represents the
4446 whole range or the empty set, so make it
4448 if (tree_int_cst_equal (n_low, low)
4449 && tree_int_cst_equal (n_high, high))
4455 low = n_low, high = n_high;
4463 case NON_LVALUE_EXPR:
4464 if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4467 if (! INTEGRAL_TYPE_P (arg0_type)
4468 || (low != 0 && ! int_fits_type_p (low, arg0_type))
4469 || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4472 n_low = low, n_high = high;
4475 n_low = fold_convert_loc (loc, arg0_type, n_low);
4478 n_high = fold_convert_loc (loc, arg0_type, n_high);
4480 /* If we're converting arg0 from an unsigned type, to exp,
4481 a signed type, we will be doing the comparison as unsigned.
4482 The tests above have already verified that LOW and HIGH
4485 So we have to ensure that we will handle large unsigned
4486 values the same way that the current signed bounds treat
4489 if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4493 /* For fixed-point modes, we need to pass the saturating flag
4494 as the 2nd parameter. */
4495 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4497 = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type),
4498 TYPE_SATURATING (arg0_type));
4501 = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type), 1);
4503 /* A range without an upper bound is, naturally, unbounded.
4504 Since convert would have cropped a very large value, use
4505 the max value for the destination type. */
4507 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4508 : TYPE_MAX_VALUE (arg0_type);
4510 if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4511 high_positive = fold_build2_loc (loc, RSHIFT_EXPR, arg0_type,
4512 fold_convert_loc (loc, arg0_type,
4514 build_int_cst (arg0_type, 1));
4516 /* If the low bound is specified, "and" the range with the
4517 range for which the original unsigned value will be
4521 if (! merge_ranges (&n_in_p, &n_low, &n_high, 1, n_low, n_high,
4522 1, fold_convert_loc (loc, arg0_type,
4527 in_p = (n_in_p == in_p);
4531 /* Otherwise, "or" the range with the range of the input
4532 that will be interpreted as negative. */
4533 if (! merge_ranges (&n_in_p, &n_low, &n_high, 0, n_low, n_high,
4534 1, fold_convert_loc (loc, arg0_type,
4539 in_p = (in_p != n_in_p);
4553 /* Given EXP, a logical expression, set the range it is testing into
4554 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4555 actually being tested. *PLOW and *PHIGH will be made of the same
4556 type as the returned expression. If EXP is not a comparison, we
4557 will most likely not be returning a useful value and range. Set
4558 *STRICT_OVERFLOW_P to true if the return value is only valid
4559 because signed overflow is undefined; otherwise, do not change
4560 *STRICT_OVERFLOW_P. */
4563 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
4564 bool *strict_overflow_p)
4566 enum tree_code code;
4567 tree arg0, arg1 = NULL_TREE;
4568 tree exp_type, nexp;
4571 location_t loc = EXPR_LOCATION (exp);
4573 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4574 and see if we can refine the range. Some of the cases below may not
4575 happen, but it doesn't seem worth worrying about this. We "continue"
4576 the outer loop when we've changed something; otherwise we "break"
4577 the switch, which will "break" the while. */
4580 low = high = build_int_cst (TREE_TYPE (exp), 0);
4584 code = TREE_CODE (exp);
4585 exp_type = TREE_TYPE (exp);
4588 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
4590 if (TREE_OPERAND_LENGTH (exp) > 0)
4591 arg0 = TREE_OPERAND (exp, 0);
4592 if (TREE_CODE_CLASS (code) == tcc_binary
4593 || TREE_CODE_CLASS (code) == tcc_comparison
4594 || (TREE_CODE_CLASS (code) == tcc_expression
4595 && TREE_OPERAND_LENGTH (exp) > 1))
4596 arg1 = TREE_OPERAND (exp, 1);
4598 if (arg0 == NULL_TREE)
4601 nexp = make_range_step (loc, code, arg0, arg1, exp_type, &low,
4602 &high, &in_p, strict_overflow_p);
4603 if (nexp == NULL_TREE)
4608 /* If EXP is a constant, we can evaluate whether this is true or false. */
4609 if (TREE_CODE (exp) == INTEGER_CST)
4611 in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4613 && integer_onep (range_binop (LE_EXPR, integer_type_node,
4619 *pin_p = in_p, *plow = low, *phigh = high;
4623 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4624 type, TYPE, return an expression to test if EXP is in (or out of, depending
4625 on IN_P) the range. Return 0 if the test couldn't be created. */
4628 build_range_check (location_t loc, tree type, tree exp, int in_p,
4629 tree low, tree high)
4631 tree etype = TREE_TYPE (exp), value;
4633 /* Disable this optimization for function pointer expressions
4634 on targets that require function pointer canonicalization. */
4635 if (targetm.have_canonicalize_funcptr_for_compare ()
4636 && TREE_CODE (etype) == POINTER_TYPE
4637 && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4642 value = build_range_check (loc, type, exp, 1, low, high);
4644 return invert_truthvalue_loc (loc, value);
4649 if (low == 0 && high == 0)
4650 return omit_one_operand_loc (loc, type, build_int_cst (type, 1), exp);
4653 return fold_build2_loc (loc, LE_EXPR, type, exp,
4654 fold_convert_loc (loc, etype, high));
4657 return fold_build2_loc (loc, GE_EXPR, type, exp,
4658 fold_convert_loc (loc, etype, low));
4660 if (operand_equal_p (low, high, 0))
4661 return fold_build2_loc (loc, EQ_EXPR, type, exp,
4662 fold_convert_loc (loc, etype, low));
4664 if (integer_zerop (low))
4666 if (! TYPE_UNSIGNED (etype))
4668 etype = unsigned_type_for (etype);
4669 high = fold_convert_loc (loc, etype, high);
4670 exp = fold_convert_loc (loc, etype, exp);
4672 return build_range_check (loc, type, exp, 1, 0, high);
4675 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4676 if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4678 int prec = TYPE_PRECISION (etype);
4680 if (wi::mask (prec - 1, false, prec) == high)
4682 if (TYPE_UNSIGNED (etype))
4684 tree signed_etype = signed_type_for (etype);
4685 if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
4687 = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
4689 etype = signed_etype;
4690 exp = fold_convert_loc (loc, etype, exp);
4692 return fold_build2_loc (loc, GT_EXPR, type, exp,
4693 build_int_cst (etype, 0));
4697 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4698 This requires wrap-around arithmetics for the type of the expression.
4699 First make sure that arithmetics in this type is valid, then make sure
4700 that it wraps around. */
4701 if (TREE_CODE (etype) == ENUMERAL_TYPE || TREE_CODE (etype) == BOOLEAN_TYPE)
4702 etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4703 TYPE_UNSIGNED (etype));
4705 if (TREE_CODE (etype) == INTEGER_TYPE && !TYPE_OVERFLOW_WRAPS (etype))
4707 tree utype, minv, maxv;
4709 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4710 for the type in question, as we rely on this here. */
4711 utype = unsigned_type_for (etype);
4712 maxv = fold_convert_loc (loc, utype, TYPE_MAX_VALUE (etype));
4713 maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4714 build_int_cst (TREE_TYPE (maxv), 1), 1);
4715 minv = fold_convert_loc (loc, utype, TYPE_MIN_VALUE (etype));
4717 if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4724 high = fold_convert_loc (loc, etype, high);
4725 low = fold_convert_loc (loc, etype, low);
4726 exp = fold_convert_loc (loc, etype, exp);
4728 value = const_binop (MINUS_EXPR, high, low);
4731 if (POINTER_TYPE_P (etype))
4733 if (value != 0 && !TREE_OVERFLOW (value))
4735 low = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (low), low);
4736 return build_range_check (loc, type,
4737 fold_build_pointer_plus_loc (loc, exp, low),
4738 1, build_int_cst (etype, 0), value);
4743 if (value != 0 && !TREE_OVERFLOW (value))
4744 return build_range_check (loc, type,
4745 fold_build2_loc (loc, MINUS_EXPR, etype, exp, low),
4746 1, build_int_cst (etype, 0), value);
4751 /* Return the predecessor of VAL in its type, handling the infinite case. */
4754 range_predecessor (tree val)
4756 tree type = TREE_TYPE (val);
4758 if (INTEGRAL_TYPE_P (type)
4759 && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4762 return range_binop (MINUS_EXPR, NULL_TREE, val, 0,
4763 build_int_cst (TREE_TYPE (val), 1), 0);
4766 /* Return the successor of VAL in its type, handling the infinite case. */
4769 range_successor (tree val)
4771 tree type = TREE_TYPE (val);
4773 if (INTEGRAL_TYPE_P (type)
4774 && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4777 return range_binop (PLUS_EXPR, NULL_TREE, val, 0,
4778 build_int_cst (TREE_TYPE (val), 1), 0);
4781 /* Given two ranges, see if we can merge them into one. Return 1 if we
4782 can, 0 if we can't. Set the output range into the specified parameters. */
4785 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4786 tree high0, int in1_p, tree low1, tree high1)
4794 int lowequal = ((low0 == 0 && low1 == 0)
4795 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4796 low0, 0, low1, 0)));
4797 int highequal = ((high0 == 0 && high1 == 0)
4798 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4799 high0, 1, high1, 1)));
4801 /* Make range 0 be the range that starts first, or ends last if they
4802 start at the same value. Swap them if it isn't. */
4803 if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4806 && integer_onep (range_binop (GT_EXPR, integer_type_node,
4807 high1, 1, high0, 1))))
4809 temp = in0_p, in0_p = in1_p, in1_p = temp;
4810 tem = low0, low0 = low1, low1 = tem;
4811 tem = high0, high0 = high1, high1 = tem;
4814 /* Now flag two cases, whether the ranges are disjoint or whether the
4815 second range is totally subsumed in the first. Note that the tests
4816 below are simplified by the ones above. */
4817 no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4818 high0, 1, low1, 0));
4819 subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4820 high1, 1, high0, 1));
4822 /* We now have four cases, depending on whether we are including or
4823 excluding the two ranges. */
4826 /* If they don't overlap, the result is false. If the second range
4827 is a subset it is the result. Otherwise, the range is from the start
4828 of the second to the end of the first. */
4830 in_p = 0, low = high = 0;
4832 in_p = 1, low = low1, high = high1;
4834 in_p = 1, low = low1, high = high0;
4837 else if (in0_p && ! in1_p)
4839 /* If they don't overlap, the result is the first range. If they are
4840 equal, the result is false. If the second range is a subset of the
4841 first, and the ranges begin at the same place, we go from just after
4842 the end of the second range to the end of the first. If the second
4843 range is not a subset of the first, or if it is a subset and both
4844 ranges end at the same place, the range starts at the start of the
4845 first range and ends just before the second range.
4846 Otherwise, we can't describe this as a single range. */
4848 in_p = 1, low = low0, high = high0;
4849 else if (lowequal && highequal)
4850 in_p = 0, low = high = 0;
4851 else if (subset && lowequal)
4853 low = range_successor (high1);
4858 /* We are in the weird situation where high0 > high1 but
4859 high1 has no successor. Punt. */
4863 else if (! subset || highequal)
4866 high = range_predecessor (low1);
4870 /* low0 < low1 but low1 has no predecessor. Punt. */
4878 else if (! in0_p && in1_p)
4880 /* If they don't overlap, the result is the second range. If the second
4881 is a subset of the first, the result is false. Otherwise,
4882 the range starts just after the first range and ends at the
4883 end of the second. */
4885 in_p = 1, low = low1, high = high1;
4886 else if (subset || highequal)
4887 in_p = 0, low = high = 0;
4890 low = range_successor (high0);
4895 /* high1 > high0 but high0 has no successor. Punt. */
4903 /* The case where we are excluding both ranges. Here the complex case
4904 is if they don't overlap. In that case, the only time we have a
4905 range is if they are adjacent. If the second is a subset of the
4906 first, the result is the first. Otherwise, the range to exclude
4907 starts at the beginning of the first range and ends at the end of the
4911 if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4912 range_successor (high0),
4914 in_p = 0, low = low0, high = high1;
4917 /* Canonicalize - [min, x] into - [-, x]. */
4918 if (low0 && TREE_CODE (low0) == INTEGER_CST)
4919 switch (TREE_CODE (TREE_TYPE (low0)))
4922 if (TYPE_PRECISION (TREE_TYPE (low0))
4923 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4927 if (tree_int_cst_equal (low0,
4928 TYPE_MIN_VALUE (TREE_TYPE (low0))))
4932 if (TYPE_UNSIGNED (TREE_TYPE (low0))
4933 && integer_zerop (low0))
4940 /* Canonicalize - [x, max] into - [x, -]. */
4941 if (high1 && TREE_CODE (high1) == INTEGER_CST)
4942 switch (TREE_CODE (TREE_TYPE (high1)))
4945 if (TYPE_PRECISION (TREE_TYPE (high1))
4946 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4950 if (tree_int_cst_equal (high1,
4951 TYPE_MAX_VALUE (TREE_TYPE (high1))))
4955 if (TYPE_UNSIGNED (TREE_TYPE (high1))
4956 && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4958 build_int_cst (TREE_TYPE (high1), 1),
4966 /* The ranges might be also adjacent between the maximum and
4967 minimum values of the given type. For
4968 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4969 return + [x + 1, y - 1]. */
4970 if (low0 == 0 && high1 == 0)
4972 low = range_successor (high0);
4973 high = range_predecessor (low1);
4974 if (low == 0 || high == 0)
4984 in_p = 0, low = low0, high = high0;
4986 in_p = 0, low = low0, high = high1;
4989 *pin_p = in_p, *plow = low, *phigh = high;
4994 /* Subroutine of fold, looking inside expressions of the form
4995 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4996 of the COND_EXPR. This function is being used also to optimize
4997 A op B ? C : A, by reversing the comparison first.
4999 Return a folded expression whose code is not a COND_EXPR
5000 anymore, or NULL_TREE if no folding opportunity is found. */
5003 fold_cond_expr_with_comparison (location_t loc, tree type,
5004 tree arg0, tree arg1, tree arg2)
5006 enum tree_code comp_code = TREE_CODE (arg0);
5007 tree arg00 = TREE_OPERAND (arg0, 0);
5008 tree arg01 = TREE_OPERAND (arg0, 1);
5009 tree arg1_type = TREE_TYPE (arg1);
5015 /* If we have A op 0 ? A : -A, consider applying the following
5018 A == 0? A : -A same as -A
5019 A != 0? A : -A same as A
5020 A >= 0? A : -A same as abs (A)
5021 A > 0? A : -A same as abs (A)
5022 A <= 0? A : -A same as -abs (A)
5023 A < 0? A : -A same as -abs (A)
5025 None of these transformations work for modes with signed
5026 zeros. If A is +/-0, the first two transformations will
5027 change the sign of the result (from +0 to -0, or vice
5028 versa). The last four will fix the sign of the result,
5029 even though the original expressions could be positive or
5030 negative, depending on the sign of A.
5032 Note that all these transformations are correct if A is
5033 NaN, since the two alternatives (A and -A) are also NaNs. */
5034 if (!HONOR_SIGNED_ZEROS (element_mode (type))
5035 && (FLOAT_TYPE_P (TREE_TYPE (arg01))
5036 ? real_zerop (arg01)
5037 : integer_zerop (arg01))
5038 && ((TREE_CODE (arg2) == NEGATE_EXPR
5039 && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
5040 /* In the case that A is of the form X-Y, '-A' (arg2) may
5041 have already been folded to Y-X, check for that. */
5042 || (TREE_CODE (arg1) == MINUS_EXPR
5043 && TREE_CODE (arg2) == MINUS_EXPR
5044 && operand_equal_p (TREE_OPERAND (arg1, 0),
5045 TREE_OPERAND (arg2, 1), 0)
5046 && operand_equal_p (TREE_OPERAND (arg1, 1),
5047 TREE_OPERAND (arg2, 0), 0))))
5052 tem = fold_convert_loc (loc, arg1_type, arg1);
5053 return pedantic_non_lvalue_loc (loc,
5054 fold_convert_loc (loc, type,
5055 negate_expr (tem)));
5058 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
5061 if (flag_trapping_math)
5066 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
5068 tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
5069 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
5072 if (flag_trapping_math)
5076 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
5078 tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
5079 return negate_expr (fold_convert_loc (loc, type, tem));
5081 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
5085 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5086 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5087 both transformations are correct when A is NaN: A != 0
5088 is then true, and A == 0 is false. */
5090 if (!HONOR_SIGNED_ZEROS (element_mode (type))
5091 && integer_zerop (arg01) && integer_zerop (arg2))
5093 if (comp_code == NE_EXPR)
5094 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
5095 else if (comp_code == EQ_EXPR)
5096 return build_zero_cst (type);
5099 /* Try some transformations of A op B ? A : B.
5101 A == B? A : B same as B
5102 A != B? A : B same as A
5103 A >= B? A : B same as max (A, B)
5104 A > B? A : B same as max (B, A)
5105 A <= B? A : B same as min (A, B)
5106 A < B? A : B same as min (B, A)
5108 As above, these transformations don't work in the presence
5109 of signed zeros. For example, if A and B are zeros of
5110 opposite sign, the first two transformations will change
5111 the sign of the result. In the last four, the original
5112 expressions give different results for (A=+0, B=-0) and
5113 (A=-0, B=+0), but the transformed expressions do not.
5115 The first two transformations are correct if either A or B
5116 is a NaN. In the first transformation, the condition will
5117 be false, and B will indeed be chosen. In the case of the
5118 second transformation, the condition A != B will be true,
5119 and A will be chosen.
5121 The conversions to max() and min() are not correct if B is
5122 a number and A is not. The conditions in the original
5123 expressions will be false, so all four give B. The min()
5124 and max() versions would give a NaN instead. */
5125 if (!HONOR_SIGNED_ZEROS (element_mode (type))
5126 && operand_equal_for_comparison_p (arg01, arg2, arg00)
5127 /* Avoid these transformations if the COND_EXPR may be used
5128 as an lvalue in the C++ front-end. PR c++/19199. */
5130 || VECTOR_TYPE_P (type)
5131 || (! lang_GNU_CXX ()
5132 && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
5133 || ! maybe_lvalue_p (arg1)
5134 || ! maybe_lvalue_p (arg2)))
5136 tree comp_op0 = arg00;
5137 tree comp_op1 = arg01;
5138 tree comp_type = TREE_TYPE (comp_op0);
5140 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
5141 if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
5151 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg2));
5153 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
5158 /* In C++ a ?: expression can be an lvalue, so put the
5159 operand which will be used if they are equal first
5160 so that we can convert this back to the
5161 corresponding COND_EXPR. */
5162 if (!HONOR_NANS (arg1))
5164 comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
5165 comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
5166 tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
5167 ? fold_build2_loc (loc, MIN_EXPR, comp_type, comp_op0, comp_op1)
5168 : fold_build2_loc (loc, MIN_EXPR, comp_type,
5169 comp_op1, comp_op0);
5170 return pedantic_non_lvalue_loc (loc,
5171 fold_convert_loc (loc, type, tem));
5178 if (!HONOR_NANS (arg1))
5180 comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
5181 comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
5182 tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
5183 ? fold_build2_loc (loc, MAX_EXPR, comp_type, comp_op0, comp_op1)
5184 : fold_build2_loc (loc, MAX_EXPR, comp_type,
5185 comp_op1, comp_op0);
5186 return pedantic_non_lvalue_loc (loc,
5187 fold_convert_loc (loc, type, tem));
5191 if (!HONOR_NANS (arg1))
5192 return pedantic_non_lvalue_loc (loc,
5193 fold_convert_loc (loc, type, arg2));
5196 if (!HONOR_NANS (arg1))
5197 return pedantic_non_lvalue_loc (loc,
5198 fold_convert_loc (loc, type, arg1));
5201 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
5206 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5207 we might still be able to simplify this. For example,
5208 if C1 is one less or one more than C2, this might have started
5209 out as a MIN or MAX and been transformed by this function.
5210 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
5212 if (INTEGRAL_TYPE_P (type)
5213 && TREE_CODE (arg01) == INTEGER_CST
5214 && TREE_CODE (arg2) == INTEGER_CST)
5218 if (TREE_CODE (arg1) == INTEGER_CST)
5220 /* We can replace A with C1 in this case. */
5221 arg1 = fold_convert_loc (loc, type, arg01);
5222 return fold_build3_loc (loc, COND_EXPR, type, arg0, arg1, arg2);
5225 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
5226 MIN_EXPR, to preserve the signedness of the comparison. */
5227 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5229 && operand_equal_p (arg01,
5230 const_binop (PLUS_EXPR, arg2,
5231 build_int_cst (type, 1)),
5234 tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
5235 fold_convert_loc (loc, TREE_TYPE (arg00),
5237 return pedantic_non_lvalue_loc (loc,
5238 fold_convert_loc (loc, type, tem));
5243 /* If C1 is C2 - 1, this is min(A, C2), with the same care
5245 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5247 && operand_equal_p (arg01,
5248 const_binop (MINUS_EXPR, arg2,
5249 build_int_cst (type, 1)),
5252 tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
5253 fold_convert_loc (loc, TREE_TYPE (arg00),
5255 return pedantic_non_lvalue_loc (loc,
5256 fold_convert_loc (loc, type, tem));
5261 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
5262 MAX_EXPR, to preserve the signedness of the comparison. */
5263 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5265 && operand_equal_p (arg01,
5266 const_binop (MINUS_EXPR, arg2,
5267 build_int_cst (type, 1)),
5270 tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
5271 fold_convert_loc (loc, TREE_TYPE (arg00),
5273 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
5278 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
5279 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5281 && operand_equal_p (arg01,
5282 const_binop (PLUS_EXPR, arg2,
5283 build_int_cst (type, 1)),
5286 tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
5287 fold_convert_loc (loc, TREE_TYPE (arg00),
5289 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
5303 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5304 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5305 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5309 /* EXP is some logical combination of boolean tests. See if we can
5310 merge it into some range test. Return the new tree if so. */
5313 fold_range_test (location_t loc, enum tree_code code, tree type,
5316 int or_op = (code == TRUTH_ORIF_EXPR
5317 || code == TRUTH_OR_EXPR);
5318 int in0_p, in1_p, in_p;
5319 tree low0, low1, low, high0, high1, high;
5320 bool strict_overflow_p = false;
5322 const char * const warnmsg = G_("assuming signed overflow does not occur "
5323 "when simplifying range test");
5325 if (!INTEGRAL_TYPE_P (type))
5328 lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
5329 rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
5331 /* If this is an OR operation, invert both sides; we will invert
5332 again at the end. */
5334 in0_p = ! in0_p, in1_p = ! in1_p;
5336 /* If both expressions are the same, if we can merge the ranges, and we
5337 can build the range test, return it or it inverted. If one of the
5338 ranges is always true or always false, consider it to be the same
5339 expression as the other. */
5340 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
5341 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
5343 && 0 != (tem = (build_range_check (loc, type,
5345 : rhs != 0 ? rhs : integer_zero_node,
5348 if (strict_overflow_p)
5349 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
5350 return or_op ? invert_truthvalue_loc (loc, tem) : tem;
5353 /* On machines where the branch cost is expensive, if this is a
5354 short-circuited branch and the underlying object on both sides
5355 is the same, make a non-short-circuit operation. */
5356 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5357 && lhs != 0 && rhs != 0
5358 && (code == TRUTH_ANDIF_EXPR
5359 || code == TRUTH_ORIF_EXPR)
5360 && operand_equal_p (lhs, rhs, 0))
5362 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5363 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5364 which cases we can't do this. */
5365 if (simple_operand_p (lhs))
5366 return build2_loc (loc, code == TRUTH_ANDIF_EXPR
5367 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5370 else if (!lang_hooks.decls.global_bindings_p ()
5371 && !CONTAINS_PLACEHOLDER_P (lhs))
5373 tree common = save_expr (lhs);
5375 if (0 != (lhs = build_range_check (loc, type, common,
5376 or_op ? ! in0_p : in0_p,
5378 && (0 != (rhs = build_range_check (loc, type, common,
5379 or_op ? ! in1_p : in1_p,
5382 if (strict_overflow_p)
5383 fold_overflow_warning (warnmsg,
5384 WARN_STRICT_OVERFLOW_COMPARISON);
5385 return build2_loc (loc, code == TRUTH_ANDIF_EXPR
5386 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5395 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5396 bit value. Arrange things so the extra bits will be set to zero if and
5397 only if C is signed-extended to its full width. If MASK is nonzero,
5398 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5401 unextend (tree c, int p, int unsignedp, tree mask)
5403 tree type = TREE_TYPE (c);
5404 int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
5407 if (p == modesize || unsignedp)
5410 /* We work by getting just the sign bit into the low-order bit, then
5411 into the high-order bit, then sign-extend. We then XOR that value
5413 temp = build_int_cst (TREE_TYPE (c), wi::extract_uhwi (c, p - 1, 1));
5415 /* We must use a signed type in order to get an arithmetic right shift.
5416 However, we must also avoid introducing accidental overflows, so that
5417 a subsequent call to integer_zerop will work. Hence we must
5418 do the type conversion here. At this point, the constant is either
5419 zero or one, and the conversion to a signed type can never overflow.
5420 We could get an overflow if this conversion is done anywhere else. */
5421 if (TYPE_UNSIGNED (type))
5422 temp = fold_convert (signed_type_for (type), temp);
5424 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1));
5425 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1));
5427 temp = const_binop (BIT_AND_EXPR, temp,
5428 fold_convert (TREE_TYPE (c), mask));
5429 /* If necessary, convert the type back to match the type of C. */
5430 if (TYPE_UNSIGNED (type))
5431 temp = fold_convert (type, temp);
5433 return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp));
5436 /* For an expression that has the form
5440 we can drop one of the inner expressions and simplify to
5444 LOC is the location of the resulting expression. OP is the inner
5445 logical operation; the left-hand side in the examples above, while CMPOP
5446 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5447 removing a condition that guards another, as in
5448 (A != NULL && A->...) || A == NULL
5449 which we must not transform. If RHS_ONLY is true, only eliminate the
5450 right-most operand of the inner logical operation. */
5453 merge_truthop_with_opposite_arm (location_t loc, tree op, tree cmpop,
5456 tree type = TREE_TYPE (cmpop);
5457 enum tree_code code = TREE_CODE (cmpop);
5458 enum tree_code truthop_code = TREE_CODE (op);
5459 tree lhs = TREE_OPERAND (op, 0);
5460 tree rhs = TREE_OPERAND (op, 1);
5461 tree orig_lhs = lhs, orig_rhs = rhs;
5462 enum tree_code rhs_code = TREE_CODE (rhs);
5463 enum tree_code lhs_code = TREE_CODE (lhs);
5464 enum tree_code inv_code;
5466 if (TREE_SIDE_EFFECTS (op) || TREE_SIDE_EFFECTS (cmpop))
5469 if (TREE_CODE_CLASS (code) != tcc_comparison)
5472 if (rhs_code == truthop_code)
5474 tree newrhs = merge_truthop_with_opposite_arm (loc, rhs, cmpop, rhs_only);
5475 if (newrhs != NULL_TREE)
5478 rhs_code = TREE_CODE (rhs);
5481 if (lhs_code == truthop_code && !rhs_only)
5483 tree newlhs = merge_truthop_with_opposite_arm (loc, lhs, cmpop, false);
5484 if (newlhs != NULL_TREE)
5487 lhs_code = TREE_CODE (lhs);
5491 inv_code = invert_tree_comparison (code, HONOR_NANS (type));
5492 if (inv_code == rhs_code
5493 && operand_equal_p (TREE_OPERAND (rhs, 0), TREE_OPERAND (cmpop, 0), 0)
5494 && operand_equal_p (TREE_OPERAND (rhs, 1), TREE_OPERAND (cmpop, 1), 0))
5496 if (!rhs_only && inv_code == lhs_code
5497 && operand_equal_p (TREE_OPERAND (lhs, 0), TREE_OPERAND (cmpop, 0), 0)
5498 && operand_equal_p (TREE_OPERAND (lhs, 1), TREE_OPERAND (cmpop, 1), 0))
5500 if (rhs != orig_rhs || lhs != orig_lhs)
5501 return fold_build2_loc (loc, truthop_code, TREE_TYPE (cmpop),
5506 /* Find ways of folding logical expressions of LHS and RHS:
5507 Try to merge two comparisons to the same innermost item.
5508 Look for range tests like "ch >= '0' && ch <= '9'".
5509 Look for combinations of simple terms on machines with expensive branches
5510 and evaluate the RHS unconditionally.
5512 For example, if we have p->a == 2 && p->b == 4 and we can make an
5513 object large enough to span both A and B, we can do this with a comparison
5514 against the object ANDed with the a mask.
5516 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5517 operations to do this with one comparison.
5519 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5520 function and the one above.
5522 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5523 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5525 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5528 We return the simplified tree or 0 if no optimization is possible. */
5531 fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
5534 /* If this is the "or" of two comparisons, we can do something if
5535 the comparisons are NE_EXPR. If this is the "and", we can do something
5536 if the comparisons are EQ_EXPR. I.e.,
5537 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5539 WANTED_CODE is this operation code. For single bit fields, we can
5540 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5541 comparison for one-bit fields. */
5543 enum tree_code wanted_code;
5544 enum tree_code lcode, rcode;
5545 tree ll_arg, lr_arg, rl_arg, rr_arg;
5546 tree ll_inner, lr_inner, rl_inner, rr_inner;
5547 HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5548 HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5549 HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5550 HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5551 int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5552 int ll_reversep, lr_reversep, rl_reversep, rr_reversep;
5553 machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5554 machine_mode lnmode, rnmode;
5555 tree ll_mask, lr_mask, rl_mask, rr_mask;
5556 tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5557 tree l_const, r_const;
5558 tree lntype, rntype, result;
5559 HOST_WIDE_INT first_bit, end_bit;
5562 /* Start by getting the comparison codes. Fail if anything is volatile.
5563 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5564 it were surrounded with a NE_EXPR. */
5566 if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5569 lcode = TREE_CODE (lhs);
5570 rcode = TREE_CODE (rhs);
5572 if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5574 lhs = build2 (NE_EXPR, truth_type, lhs,
5575 build_int_cst (TREE_TYPE (lhs), 0));
5579 if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5581 rhs = build2 (NE_EXPR, truth_type, rhs,
5582 build_int_cst (TREE_TYPE (rhs), 0));
5586 if (TREE_CODE_CLASS (lcode) != tcc_comparison
5587 || TREE_CODE_CLASS (rcode) != tcc_comparison)
5590 ll_arg = TREE_OPERAND (lhs, 0);
5591 lr_arg = TREE_OPERAND (lhs, 1);
5592 rl_arg = TREE_OPERAND (rhs, 0);
5593 rr_arg = TREE_OPERAND (rhs, 1);
5595 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5596 if (simple_operand_p (ll_arg)
5597 && simple_operand_p (lr_arg))
5599 if (operand_equal_p (ll_arg, rl_arg, 0)
5600 && operand_equal_p (lr_arg, rr_arg, 0))
5602 result = combine_comparisons (loc, code, lcode, rcode,
5603 truth_type, ll_arg, lr_arg);
5607 else if (operand_equal_p (ll_arg, rr_arg, 0)
5608 && operand_equal_p (lr_arg, rl_arg, 0))
5610 result = combine_comparisons (loc, code, lcode,
5611 swap_tree_comparison (rcode),
5612 truth_type, ll_arg, lr_arg);
5618 code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5619 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5621 /* If the RHS can be evaluated unconditionally and its operands are
5622 simple, it wins to evaluate the RHS unconditionally on machines
5623 with expensive branches. In this case, this isn't a comparison
5624 that can be merged. */
5626 if (BRANCH_COST (optimize_function_for_speed_p (cfun),
5628 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5629 && simple_operand_p (rl_arg)
5630 && simple_operand_p (rr_arg))
5632 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5633 if (code == TRUTH_OR_EXPR
5634 && lcode == NE_EXPR && integer_zerop (lr_arg)
5635 && rcode == NE_EXPR && integer_zerop (rr_arg)
5636 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5637 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5638 return build2_loc (loc, NE_EXPR, truth_type,
5639 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5641 build_int_cst (TREE_TYPE (ll_arg), 0));
5643 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5644 if (code == TRUTH_AND_EXPR
5645 && lcode == EQ_EXPR && integer_zerop (lr_arg)
5646 && rcode == EQ_EXPR && integer_zerop (rr_arg)
5647 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5648 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5649 return build2_loc (loc, EQ_EXPR, truth_type,
5650 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5652 build_int_cst (TREE_TYPE (ll_arg), 0));
5655 /* See if the comparisons can be merged. Then get all the parameters for
5658 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5659 || (rcode != EQ_EXPR && rcode != NE_EXPR))
5662 ll_reversep = lr_reversep = rl_reversep = rr_reversep = 0;
5664 ll_inner = decode_field_reference (loc, &ll_arg,
5665 &ll_bitsize, &ll_bitpos, &ll_mode,
5666 &ll_unsignedp, &ll_reversep, &volatilep,
5667 &ll_mask, &ll_and_mask);
5668 lr_inner = decode_field_reference (loc, &lr_arg,
5669 &lr_bitsize, &lr_bitpos, &lr_mode,
5670 &lr_unsignedp, &lr_reversep, &volatilep,
5671 &lr_mask, &lr_and_mask);
5672 rl_inner = decode_field_reference (loc, &rl_arg,
5673 &rl_bitsize, &rl_bitpos, &rl_mode,
5674 &rl_unsignedp, &rl_reversep, &volatilep,
5675 &rl_mask, &rl_and_mask);
5676 rr_inner = decode_field_reference (loc, &rr_arg,
5677 &rr_bitsize, &rr_bitpos, &rr_mode,
5678 &rr_unsignedp, &rr_reversep, &volatilep,
5679 &rr_mask, &rr_and_mask);
5681 /* It must be true that the inner operation on the lhs of each
5682 comparison must be the same if we are to be able to do anything.
5683 Then see if we have constants. If not, the same must be true for
5686 || ll_reversep != rl_reversep
5687 || ll_inner == 0 || rl_inner == 0
5688 || ! operand_equal_p (ll_inner, rl_inner, 0))
5691 if (TREE_CODE (lr_arg) == INTEGER_CST
5692 && TREE_CODE (rr_arg) == INTEGER_CST)
5694 l_const = lr_arg, r_const = rr_arg;
5695 lr_reversep = ll_reversep;
5697 else if (lr_reversep != rr_reversep
5698 || lr_inner == 0 || rr_inner == 0
5699 || ! operand_equal_p (lr_inner, rr_inner, 0))
5702 l_const = r_const = 0;
5704 /* If either comparison code is not correct for our logical operation,
5705 fail. However, we can convert a one-bit comparison against zero into
5706 the opposite comparison against that bit being set in the field. */
5708 wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5709 if (lcode != wanted_code)
5711 if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5713 /* Make the left operand unsigned, since we are only interested
5714 in the value of one bit. Otherwise we are doing the wrong
5723 /* This is analogous to the code for l_const above. */
5724 if (rcode != wanted_code)
5726 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5735 /* See if we can find a mode that contains both fields being compared on
5736 the left. If we can't, fail. Otherwise, update all constants and masks
5737 to be relative to a field of that size. */
5738 first_bit = MIN (ll_bitpos, rl_bitpos);
5739 end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5740 lnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5741 TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5743 if (lnmode == VOIDmode)
5746 lnbitsize = GET_MODE_BITSIZE (lnmode);
5747 lnbitpos = first_bit & ~ (lnbitsize - 1);
5748 lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5749 xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5751 if (ll_reversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
5753 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5754 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5757 ll_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, ll_mask),
5758 size_int (xll_bitpos));
5759 rl_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, rl_mask),
5760 size_int (xrl_bitpos));
5764 l_const = fold_convert_loc (loc, lntype, l_const);
5765 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5766 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos));
5767 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5768 fold_build1_loc (loc, BIT_NOT_EXPR,
5771 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5773 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5778 r_const = fold_convert_loc (loc, lntype, r_const);
5779 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5780 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos));
5781 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5782 fold_build1_loc (loc, BIT_NOT_EXPR,
5785 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5787 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5791 /* If the right sides are not constant, do the same for it. Also,
5792 disallow this optimization if a size or signedness mismatch occurs
5793 between the left and right sides. */
5796 if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5797 || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5798 /* Make sure the two fields on the right
5799 correspond to the left without being swapped. */
5800 || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5803 first_bit = MIN (lr_bitpos, rr_bitpos);
5804 end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5805 rnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5806 TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5808 if (rnmode == VOIDmode)
5811 rnbitsize = GET_MODE_BITSIZE (rnmode);
5812 rnbitpos = first_bit & ~ (rnbitsize - 1);
5813 rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5814 xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5816 if (lr_reversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
5818 xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5819 xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5822 lr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5824 size_int (xlr_bitpos));
5825 rr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5827 size_int (xrr_bitpos));
5829 /* Make a mask that corresponds to both fields being compared.
5830 Do this for both items being compared. If the operands are the
5831 same size and the bits being compared are in the same position
5832 then we can do this by masking both and comparing the masked
5834 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5835 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
5836 if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5838 lhs = make_bit_field_ref (loc, ll_inner, ll_arg,
5839 lntype, lnbitsize, lnbitpos,
5840 ll_unsignedp || rl_unsignedp, ll_reversep);
5841 if (! all_ones_mask_p (ll_mask, lnbitsize))
5842 lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5844 rhs = make_bit_field_ref (loc, lr_inner, lr_arg,
5845 rntype, rnbitsize, rnbitpos,
5846 lr_unsignedp || rr_unsignedp, lr_reversep);
5847 if (! all_ones_mask_p (lr_mask, rnbitsize))
5848 rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5850 return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5853 /* There is still another way we can do something: If both pairs of
5854 fields being compared are adjacent, we may be able to make a wider
5855 field containing them both.
5857 Note that we still must mask the lhs/rhs expressions. Furthermore,
5858 the mask must be shifted to account for the shift done by
5859 make_bit_field_ref. */
5860 if ((ll_bitsize + ll_bitpos == rl_bitpos
5861 && lr_bitsize + lr_bitpos == rr_bitpos)
5862 || (ll_bitpos == rl_bitpos + rl_bitsize
5863 && lr_bitpos == rr_bitpos + rr_bitsize))
5867 lhs = make_bit_field_ref (loc, ll_inner, ll_arg, lntype,
5868 ll_bitsize + rl_bitsize,
5869 MIN (ll_bitpos, rl_bitpos),
5870 ll_unsignedp, ll_reversep);
5871 rhs = make_bit_field_ref (loc, lr_inner, lr_arg, rntype,
5872 lr_bitsize + rr_bitsize,
5873 MIN (lr_bitpos, rr_bitpos),
5874 lr_unsignedp, lr_reversep);
5876 ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5877 size_int (MIN (xll_bitpos, xrl_bitpos)));
5878 lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5879 size_int (MIN (xlr_bitpos, xrr_bitpos)));
5881 /* Convert to the smaller type before masking out unwanted bits. */
5883 if (lntype != rntype)
5885 if (lnbitsize > rnbitsize)
5887 lhs = fold_convert_loc (loc, rntype, lhs);
5888 ll_mask = fold_convert_loc (loc, rntype, ll_mask);
5891 else if (lnbitsize < rnbitsize)
5893 rhs = fold_convert_loc (loc, lntype, rhs);
5894 lr_mask = fold_convert_loc (loc, lntype, lr_mask);
5899 if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5900 lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5902 if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5903 rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5905 return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5911 /* Handle the case of comparisons with constants. If there is something in
5912 common between the masks, those bits of the constants must be the same.
5913 If not, the condition is always false. Test for this to avoid generating
5914 incorrect code below. */
5915 result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask);
5916 if (! integer_zerop (result)
5917 && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const),
5918 const_binop (BIT_AND_EXPR, result, r_const)) != 1)
5920 if (wanted_code == NE_EXPR)
5922 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5923 return constant_boolean_node (true, truth_type);
5927 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5928 return constant_boolean_node (false, truth_type);
5932 /* Construct the expression we will return. First get the component
5933 reference we will make. Unless the mask is all ones the width of
5934 that field, perform the mask operation. Then compare with the
5936 result = make_bit_field_ref (loc, ll_inner, ll_arg,
5937 lntype, lnbitsize, lnbitpos,
5938 ll_unsignedp || rl_unsignedp, ll_reversep);
5940 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5941 if (! all_ones_mask_p (ll_mask, lnbitsize))
5942 result = build2_loc (loc, BIT_AND_EXPR, lntype, result, ll_mask);
5944 return build2_loc (loc, wanted_code, truth_type, result,
5945 const_binop (BIT_IOR_EXPR, l_const, r_const));
5948 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5952 optimize_minmax_comparison (location_t loc, enum tree_code code, tree type,
5956 enum tree_code op_code;
5959 int consts_equal, consts_lt;
5962 STRIP_SIGN_NOPS (arg0);
5964 op_code = TREE_CODE (arg0);
5965 minmax_const = TREE_OPERAND (arg0, 1);
5966 comp_const = fold_convert_loc (loc, TREE_TYPE (arg0), op1);
5967 consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5968 consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5969 inner = TREE_OPERAND (arg0, 0);
5971 /* If something does not permit us to optimize, return the original tree. */
5972 if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5973 || TREE_CODE (comp_const) != INTEGER_CST
5974 || TREE_OVERFLOW (comp_const)
5975 || TREE_CODE (minmax_const) != INTEGER_CST
5976 || TREE_OVERFLOW (minmax_const))
5979 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5980 and GT_EXPR, doing the rest with recursive calls using logical
5984 case NE_EXPR: case LT_EXPR: case LE_EXPR:
5987 = optimize_minmax_comparison (loc,
5988 invert_tree_comparison (code, false),
5991 return invert_truthvalue_loc (loc, tem);
5997 fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
5998 optimize_minmax_comparison
5999 (loc, EQ_EXPR, type, arg0, comp_const),
6000 optimize_minmax_comparison
6001 (loc, GT_EXPR, type, arg0, comp_const));
6004 if (op_code == MAX_EXPR && consts_equal)
6005 /* MAX (X, 0) == 0 -> X <= 0 */
6006 return fold_build2_loc (loc, LE_EXPR, type, inner, comp_const);
6008 else if (op_code == MAX_EXPR && consts_lt)
6009 /* MAX (X, 0) == 5 -> X == 5 */
6010 return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
6012 else if (op_code == MAX_EXPR)
6013 /* MAX (X, 0) == -1 -> false */
6014 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
6016 else if (consts_equal)
6017 /* MIN (X, 0) == 0 -> X >= 0 */
6018 return fold_build2_loc (loc, GE_EXPR, type, inner, comp_const);
6021 /* MIN (X, 0) == 5 -> false */
6022 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
6025 /* MIN (X, 0) == -1 -> X == -1 */
6026 return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
6029 if (op_code == MAX_EXPR && (consts_equal || consts_lt))
6030 /* MAX (X, 0) > 0 -> X > 0
6031 MAX (X, 0) > 5 -> X > 5 */
6032 return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
6034 else if (op_code == MAX_EXPR)
6035 /* MAX (X, 0) > -1 -> true */
6036 return omit_one_operand_loc (loc, type, integer_one_node, inner);
6038 else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
6039 /* MIN (X, 0) > 0 -> false
6040 MIN (X, 0) > 5 -> false */
6041 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
6044 /* MIN (X, 0) > -1 -> X > -1 */
6045 return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
6052 /* T is an integer expression that is being multiplied, divided, or taken a
6053 modulus (CODE says which and what kind of divide or modulus) by a
6054 constant C. See if we can eliminate that operation by folding it with
6055 other operations already in T. WIDE_TYPE, if non-null, is a type that
6056 should be used for the computation if wider than our type.
6058 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
6059 (X * 2) + (Y * 4). We must, however, be assured that either the original
6060 expression would not overflow or that overflow is undefined for the type
6061 in the language in question.
6063 If we return a non-null expression, it is an equivalent form of the
6064 original computation, but need not be in the original type.
6066 We set *STRICT_OVERFLOW_P to true if the return values depends on
6067 signed overflow being undefined. Otherwise we do not change
6068 *STRICT_OVERFLOW_P. */
6071 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
6072 bool *strict_overflow_p)
6074 /* To avoid exponential search depth, refuse to allow recursion past
6075 three levels. Beyond that (1) it's highly unlikely that we'll find
6076 something interesting and (2) we've probably processed it before
6077 when we built the inner expression. */
6086 ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
6093 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
6094 bool *strict_overflow_p)
6096 tree type = TREE_TYPE (t);
6097 enum tree_code tcode = TREE_CODE (t);
6098 tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
6099 > GET_MODE_SIZE (TYPE_MODE (type)))
6100 ? wide_type : type);
6102 int same_p = tcode == code;
6103 tree op0 = NULL_TREE, op1 = NULL_TREE;
6104 bool sub_strict_overflow_p;
6106 /* Don't deal with constants of zero here; they confuse the code below. */
6107 if (integer_zerop (c))
6110 if (TREE_CODE_CLASS (tcode) == tcc_unary)
6111 op0 = TREE_OPERAND (t, 0);
6113 if (TREE_CODE_CLASS (tcode) == tcc_binary)
6114 op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
6116 /* Note that we need not handle conditional operations here since fold
6117 already handles those cases. So just do arithmetic here. */
6121 /* For a constant, we can always simplify if we are a multiply
6122 or (for divide and modulus) if it is a multiple of our constant. */
6123 if (code == MULT_EXPR
6124 || wi::multiple_of_p (t, c, TYPE_SIGN (type)))
6126 tree tem = const_binop (code, fold_convert (ctype, t),
6127 fold_convert (ctype, c));
6128 /* If the multiplication overflowed, we lost information on it.
6129 See PR68142 and PR69845. */
6130 if (TREE_OVERFLOW (tem))
6136 CASE_CONVERT: case NON_LVALUE_EXPR:
6137 /* If op0 is an expression ... */
6138 if ((COMPARISON_CLASS_P (op0)
6139 || UNARY_CLASS_P (op0)
6140 || BINARY_CLASS_P (op0)
6141 || VL_EXP_CLASS_P (op0)
6142 || EXPRESSION_CLASS_P (op0))
6143 /* ... and has wrapping overflow, and its type is smaller
6144 than ctype, then we cannot pass through as widening. */
6145 && (((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0))
6146 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0)))
6147 && (TYPE_PRECISION (ctype)
6148 > TYPE_PRECISION (TREE_TYPE (op0))))
6149 /* ... or this is a truncation (t is narrower than op0),
6150 then we cannot pass through this narrowing. */
6151 || (TYPE_PRECISION (type)
6152 < TYPE_PRECISION (TREE_TYPE (op0)))
6153 /* ... or signedness changes for division or modulus,
6154 then we cannot pass through this conversion. */
6155 || (code != MULT_EXPR
6156 && (TYPE_UNSIGNED (ctype)
6157 != TYPE_UNSIGNED (TREE_TYPE (op0))))
6158 /* ... or has undefined overflow while the converted to
6159 type has not, we cannot do the operation in the inner type
6160 as that would introduce undefined overflow. */
6161 || ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0))
6162 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0)))
6163 && !TYPE_OVERFLOW_UNDEFINED (type))))
6166 /* Pass the constant down and see if we can make a simplification. If
6167 we can, replace this expression with the inner simplification for
6168 possible later conversion to our or some other type. */
6169 if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
6170 && TREE_CODE (t2) == INTEGER_CST
6171 && !TREE_OVERFLOW (t2)
6172 && (0 != (t1 = extract_muldiv (op0, t2, code,
6174 ? ctype : NULL_TREE,
6175 strict_overflow_p))))
6180 /* If widening the type changes it from signed to unsigned, then we
6181 must avoid building ABS_EXPR itself as unsigned. */
6182 if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
6184 tree cstype = (*signed_type_for) (ctype);
6185 if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
6188 t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
6189 return fold_convert (ctype, t1);
6193 /* If the constant is negative, we cannot simplify this. */
6194 if (tree_int_cst_sgn (c) == -1)
6198 /* For division and modulus, type can't be unsigned, as e.g.
6199 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6200 For signed types, even with wrapping overflow, this is fine. */
6201 if (code != MULT_EXPR && TYPE_UNSIGNED (type))
6203 if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
6205 return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
6208 case MIN_EXPR: case MAX_EXPR:
6209 /* If widening the type changes the signedness, then we can't perform
6210 this optimization as that changes the result. */
6211 if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
6214 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6215 sub_strict_overflow_p = false;
6216 if ((t1 = extract_muldiv (op0, c, code, wide_type,
6217 &sub_strict_overflow_p)) != 0
6218 && (t2 = extract_muldiv (op1, c, code, wide_type,
6219 &sub_strict_overflow_p)) != 0)
6221 if (tree_int_cst_sgn (c) < 0)
6222 tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
6223 if (sub_strict_overflow_p)
6224 *strict_overflow_p = true;
6225 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6226 fold_convert (ctype, t2));
6230 case LSHIFT_EXPR: case RSHIFT_EXPR:
6231 /* If the second operand is constant, this is a multiplication
6232 or floor division, by a power of two, so we can treat it that
6233 way unless the multiplier or divisor overflows. Signed
6234 left-shift overflow is implementation-defined rather than
6235 undefined in C90, so do not convert signed left shift into
6237 if (TREE_CODE (op1) == INTEGER_CST
6238 && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
6239 /* const_binop may not detect overflow correctly,
6240 so check for it explicitly here. */
6241 && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
6242 && 0 != (t1 = fold_convert (ctype,
6243 const_binop (LSHIFT_EXPR,
6246 && !TREE_OVERFLOW (t1))
6247 return extract_muldiv (build2 (tcode == LSHIFT_EXPR
6248 ? MULT_EXPR : FLOOR_DIV_EXPR,
6250 fold_convert (ctype, op0),
6252 c, code, wide_type, strict_overflow_p);
6255 case PLUS_EXPR: case MINUS_EXPR:
6256 /* See if we can eliminate the operation on both sides. If we can, we
6257 can return a new PLUS or MINUS. If we can't, the only remaining
6258 cases where we can do anything are if the second operand is a
6260 sub_strict_overflow_p = false;
6261 t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
6262 t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
6263 if (t1 != 0 && t2 != 0
6264 && (code == MULT_EXPR
6265 /* If not multiplication, we can only do this if both operands
6266 are divisible by c. */
6267 || (multiple_of_p (ctype, op0, c)
6268 && multiple_of_p (ctype, op1, c))))
6270 if (sub_strict_overflow_p)
6271 *strict_overflow_p = true;
6272 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6273 fold_convert (ctype, t2));
6276 /* If this was a subtraction, negate OP1 and set it to be an addition.
6277 This simplifies the logic below. */
6278 if (tcode == MINUS_EXPR)
6280 tcode = PLUS_EXPR, op1 = negate_expr (op1);
6281 /* If OP1 was not easily negatable, the constant may be OP0. */
6282 if (TREE_CODE (op0) == INTEGER_CST)
6284 std::swap (op0, op1);
6289 if (TREE_CODE (op1) != INTEGER_CST)
6292 /* If either OP1 or C are negative, this optimization is not safe for
6293 some of the division and remainder types while for others we need
6294 to change the code. */
6295 if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
6297 if (code == CEIL_DIV_EXPR)
6298 code = FLOOR_DIV_EXPR;
6299 else if (code == FLOOR_DIV_EXPR)
6300 code = CEIL_DIV_EXPR;
6301 else if (code != MULT_EXPR
6302 && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
6306 /* If it's a multiply or a division/modulus operation of a multiple
6307 of our constant, do the operation and verify it doesn't overflow. */
6308 if (code == MULT_EXPR
6309 || wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
6311 op1 = const_binop (code, fold_convert (ctype, op1),
6312 fold_convert (ctype, c));
6313 /* We allow the constant to overflow with wrapping semantics. */
6315 || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
6321 /* If we have an unsigned type, we cannot widen the operation since it
6322 will change the result if the original computation overflowed. */
6323 if (TYPE_UNSIGNED (ctype) && ctype != type)
6326 /* If we were able to eliminate our operation from the first side,
6327 apply our operation to the second side and reform the PLUS. */
6328 if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
6329 return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
6331 /* The last case is if we are a multiply. In that case, we can
6332 apply the distributive law to commute the multiply and addition
6333 if the multiplication of the constants doesn't overflow
6334 and overflow is defined. With undefined overflow
6335 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6336 if (code == MULT_EXPR && TYPE_OVERFLOW_WRAPS (ctype))
6337 return fold_build2 (tcode, ctype,
6338 fold_build2 (code, ctype,
6339 fold_convert (ctype, op0),
6340 fold_convert (ctype, c)),
6346 /* We have a special case here if we are doing something like
6347 (C * 8) % 4 since we know that's zero. */
6348 if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
6349 || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
6350 /* If the multiplication can overflow we cannot optimize this. */
6351 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t))
6352 && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
6353 && wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
6355 *strict_overflow_p = true;
6356 return omit_one_operand (type, integer_zero_node, op0);
6359 /* ... fall through ... */
6361 case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: case FLOOR_DIV_EXPR:
6362 case ROUND_DIV_EXPR: case EXACT_DIV_EXPR:
6363 /* If we can extract our operation from the LHS, do so and return a
6364 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6365 do something only if the second operand is a constant. */
6367 && (t1 = extract_muldiv (op0, c, code, wide_type,
6368 strict_overflow_p)) != 0)
6369 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6370 fold_convert (ctype, op1));
6371 else if (tcode == MULT_EXPR && code == MULT_EXPR
6372 && (t1 = extract_muldiv (op1, c, code, wide_type,
6373 strict_overflow_p)) != 0)
6374 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6375 fold_convert (ctype, t1));
6376 else if (TREE_CODE (op1) != INTEGER_CST)
6379 /* If these are the same operation types, we can associate them
6380 assuming no overflow. */
6383 bool overflow_p = false;
6384 bool overflow_mul_p;
6385 signop sign = TYPE_SIGN (ctype);
6386 unsigned prec = TYPE_PRECISION (ctype);
6387 wide_int mul = wi::mul (wide_int::from (op1, prec,
6388 TYPE_SIGN (TREE_TYPE (op1))),
6389 wide_int::from (c, prec,
6390 TYPE_SIGN (TREE_TYPE (c))),
6391 sign, &overflow_mul_p);
6392 overflow_p = TREE_OVERFLOW (c) | TREE_OVERFLOW (op1);
6394 && ((sign == UNSIGNED && tcode != MULT_EXPR) || sign == SIGNED))
6397 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6398 wide_int_to_tree (ctype, mul));
6401 /* If these operations "cancel" each other, we have the main
6402 optimizations of this pass, which occur when either constant is a
6403 multiple of the other, in which case we replace this with either an
6404 operation or CODE or TCODE.
6406 If we have an unsigned type, we cannot do this since it will change
6407 the result if the original computation overflowed. */
6408 if (TYPE_OVERFLOW_UNDEFINED (ctype)
6409 && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
6410 || (tcode == MULT_EXPR
6411 && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
6412 && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
6413 && code != MULT_EXPR)))
6415 if (wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
6417 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6418 *strict_overflow_p = true;
6419 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6420 fold_convert (ctype,
6421 const_binop (TRUNC_DIV_EXPR,
6424 else if (wi::multiple_of_p (c, op1, TYPE_SIGN (type)))
6426 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6427 *strict_overflow_p = true;
6428 return fold_build2 (code, ctype, fold_convert (ctype, op0),
6429 fold_convert (ctype,
6430 const_binop (TRUNC_DIV_EXPR,
6443 /* Return a node which has the indicated constant VALUE (either 0 or
6444 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6445 and is of the indicated TYPE. */
6448 constant_boolean_node (bool value, tree type)
6450 if (type == integer_type_node)
6451 return value ? integer_one_node : integer_zero_node;
6452 else if (type == boolean_type_node)
6453 return value ? boolean_true_node : boolean_false_node;
6454 else if (TREE_CODE (type) == VECTOR_TYPE)
6455 return build_vector_from_val (type,
6456 build_int_cst (TREE_TYPE (type),
6459 return fold_convert (type, value ? integer_one_node : integer_zero_node);
6463 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6464 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6465 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6466 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6467 COND is the first argument to CODE; otherwise (as in the example
6468 given here), it is the second argument. TYPE is the type of the
6469 original expression. Return NULL_TREE if no simplification is
6473 fold_binary_op_with_conditional_arg (location_t loc,
6474 enum tree_code code,
6475 tree type, tree op0, tree op1,
6476 tree cond, tree arg, int cond_first_p)
6478 tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
6479 tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6480 tree test, true_value, false_value;
6481 tree lhs = NULL_TREE;
6482 tree rhs = NULL_TREE;
6483 enum tree_code cond_code = COND_EXPR;
6485 if (TREE_CODE (cond) == COND_EXPR
6486 || TREE_CODE (cond) == VEC_COND_EXPR)
6488 test = TREE_OPERAND (cond, 0);
6489 true_value = TREE_OPERAND (cond, 1);
6490 false_value = TREE_OPERAND (cond, 2);
6491 /* If this operand throws an expression, then it does not make
6492 sense to try to perform a logical or arithmetic operation
6494 if (VOID_TYPE_P (TREE_TYPE (true_value)))
6496 if (VOID_TYPE_P (TREE_TYPE (false_value)))
6499 else if (!(TREE_CODE (type) != VECTOR_TYPE
6500 && TREE_CODE (TREE_TYPE (cond)) == VECTOR_TYPE))
6502 tree testtype = TREE_TYPE (cond);
6504 true_value = constant_boolean_node (true, testtype);
6505 false_value = constant_boolean_node (false, testtype);
6508 /* Detect the case of mixing vector and scalar types - bail out. */
6511 if (TREE_CODE (TREE_TYPE (test)) == VECTOR_TYPE)
6512 cond_code = VEC_COND_EXPR;
6514 /* This transformation is only worthwhile if we don't have to wrap ARG
6515 in a SAVE_EXPR and the operation can be simplified without recursing
6516 on at least one of the branches once its pushed inside the COND_EXPR. */
6517 if (!TREE_CONSTANT (arg)
6518 && (TREE_SIDE_EFFECTS (arg)
6519 || TREE_CODE (arg) == COND_EXPR || TREE_CODE (arg) == VEC_COND_EXPR
6520 || TREE_CONSTANT (true_value) || TREE_CONSTANT (false_value)))
6523 arg = fold_convert_loc (loc, arg_type, arg);
6526 true_value = fold_convert_loc (loc, cond_type, true_value);
6528 lhs = fold_build2_loc (loc, code, type, true_value, arg);
6530 lhs = fold_build2_loc (loc, code, type, arg, true_value);
6534 false_value = fold_convert_loc (loc, cond_type, false_value);
6536 rhs = fold_build2_loc (loc, code, type, false_value, arg);
6538 rhs = fold_build2_loc (loc, code, type, arg, false_value);
6541 /* Check that we have simplified at least one of the branches. */
6542 if (!TREE_CONSTANT (arg) && !TREE_CONSTANT (lhs) && !TREE_CONSTANT (rhs))
6545 return fold_build3_loc (loc, cond_code, type, test, lhs, rhs);
6549 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6551 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6552 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6553 ADDEND is the same as X.
6555 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6556 and finite. The problematic cases are when X is zero, and its mode
6557 has signed zeros. In the case of rounding towards -infinity,
6558 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6559 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6562 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6564 if (!real_zerop (addend))
6567 /* Don't allow the fold with -fsignaling-nans. */
6568 if (HONOR_SNANS (element_mode (type)))
6571 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6572 if (!HONOR_SIGNED_ZEROS (element_mode (type)))
6575 /* In a vector or complex, we would need to check the sign of all zeros. */
6576 if (TREE_CODE (addend) != REAL_CST)
6579 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6580 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6583 /* The mode has signed zeros, and we have to honor their sign.
6584 In this situation, there is only one case we can return true for.
6585 X - 0 is the same as X unless rounding towards -infinity is
6587 return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type));
6590 /* Subroutine of fold() that optimizes comparisons of a division by
6591 a nonzero integer constant against an integer constant, i.e.
6594 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6595 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6596 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6598 The function returns the constant folded tree if a simplification
6599 can be made, and NULL_TREE otherwise. */
6602 fold_div_compare (location_t loc,
6603 enum tree_code code, tree type, tree arg0, tree arg1)
6605 tree prod, tmp, hi, lo;
6606 tree arg00 = TREE_OPERAND (arg0, 0);
6607 tree arg01 = TREE_OPERAND (arg0, 1);
6608 signop sign = TYPE_SIGN (TREE_TYPE (arg0));
6609 bool neg_overflow = false;
6612 /* We have to do this the hard way to detect unsigned overflow.
6613 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6614 wide_int val = wi::mul (arg01, arg1, sign, &overflow);
6615 prod = force_fit_type (TREE_TYPE (arg00), val, -1, overflow);
6616 neg_overflow = false;
6618 if (sign == UNSIGNED)
6620 tmp = int_const_binop (MINUS_EXPR, arg01,
6621 build_int_cst (TREE_TYPE (arg01), 1));
6624 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6625 val = wi::add (prod, tmp, sign, &overflow);
6626 hi = force_fit_type (TREE_TYPE (arg00), val,
6627 -1, overflow | TREE_OVERFLOW (prod));
6629 else if (tree_int_cst_sgn (arg01) >= 0)
6631 tmp = int_const_binop (MINUS_EXPR, arg01,
6632 build_int_cst (TREE_TYPE (arg01), 1));
6633 switch (tree_int_cst_sgn (arg1))
6636 neg_overflow = true;
6637 lo = int_const_binop (MINUS_EXPR, prod, tmp);
6642 lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6647 hi = int_const_binop (PLUS_EXPR, prod, tmp);
6657 /* A negative divisor reverses the relational operators. */
6658 code = swap_tree_comparison (code);
6660 tmp = int_const_binop (PLUS_EXPR, arg01,
6661 build_int_cst (TREE_TYPE (arg01), 1));
6662 switch (tree_int_cst_sgn (arg1))
6665 hi = int_const_binop (MINUS_EXPR, prod, tmp);
6670 hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6675 neg_overflow = true;
6676 lo = int_const_binop (PLUS_EXPR, prod, tmp);
6688 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6689 return omit_one_operand_loc (loc, type, integer_zero_node, arg00);
6690 if (TREE_OVERFLOW (hi))
6691 return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6692 if (TREE_OVERFLOW (lo))
6693 return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6694 return build_range_check (loc, type, arg00, 1, lo, hi);
6697 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6698 return omit_one_operand_loc (loc, type, integer_one_node, arg00);
6699 if (TREE_OVERFLOW (hi))
6700 return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6701 if (TREE_OVERFLOW (lo))
6702 return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6703 return build_range_check (loc, type, arg00, 0, lo, hi);
6706 if (TREE_OVERFLOW (lo))
6708 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6709 return omit_one_operand_loc (loc, type, tmp, arg00);
6711 return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6714 if (TREE_OVERFLOW (hi))
6716 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6717 return omit_one_operand_loc (loc, type, tmp, arg00);
6719 return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6722 if (TREE_OVERFLOW (hi))
6724 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6725 return omit_one_operand_loc (loc, type, tmp, arg00);
6727 return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6730 if (TREE_OVERFLOW (lo))
6732 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6733 return omit_one_operand_loc (loc, type, tmp, arg00);
6735 return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6745 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6746 equality/inequality test, then return a simplified form of the test
6747 using a sign testing. Otherwise return NULL. TYPE is the desired
6751 fold_single_bit_test_into_sign_test (location_t loc,
6752 enum tree_code code, tree arg0, tree arg1,
6755 /* If this is testing a single bit, we can optimize the test. */
6756 if ((code == NE_EXPR || code == EQ_EXPR)
6757 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6758 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6760 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6761 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6762 tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6764 if (arg00 != NULL_TREE
6765 /* This is only a win if casting to a signed type is cheap,
6766 i.e. when arg00's type is not a partial mode. */
6767 && TYPE_PRECISION (TREE_TYPE (arg00))
6768 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg00))))
6770 tree stype = signed_type_for (TREE_TYPE (arg00));
6771 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6773 fold_convert_loc (loc, stype, arg00),
6774 build_int_cst (stype, 0));
6781 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6782 equality/inequality test, then return a simplified form of
6783 the test using shifts and logical operations. Otherwise return
6784 NULL. TYPE is the desired result type. */
6787 fold_single_bit_test (location_t loc, enum tree_code code,
6788 tree arg0, tree arg1, tree result_type)
6790 /* If this is testing a single bit, we can optimize the test. */
6791 if ((code == NE_EXPR || code == EQ_EXPR)
6792 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6793 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6795 tree inner = TREE_OPERAND (arg0, 0);
6796 tree type = TREE_TYPE (arg0);
6797 int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6798 machine_mode operand_mode = TYPE_MODE (type);
6800 tree signed_type, unsigned_type, intermediate_type;
6803 /* First, see if we can fold the single bit test into a sign-bit
6805 tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1,
6810 /* Otherwise we have (A & C) != 0 where C is a single bit,
6811 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6812 Similarly for (A & C) == 0. */
6814 /* If INNER is a right shift of a constant and it plus BITNUM does
6815 not overflow, adjust BITNUM and INNER. */
6816 if (TREE_CODE (inner) == RSHIFT_EXPR
6817 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6818 && bitnum < TYPE_PRECISION (type)
6819 && wi::ltu_p (TREE_OPERAND (inner, 1),
6820 TYPE_PRECISION (type) - bitnum))
6822 bitnum += tree_to_uhwi (TREE_OPERAND (inner, 1));
6823 inner = TREE_OPERAND (inner, 0);
6826 /* If we are going to be able to omit the AND below, we must do our
6827 operations as unsigned. If we must use the AND, we have a choice.
6828 Normally unsigned is faster, but for some machines signed is. */
6829 ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6830 && !flag_syntax_only) ? 0 : 1;
6832 signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6833 unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6834 intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6835 inner = fold_convert_loc (loc, intermediate_type, inner);
6838 inner = build2 (RSHIFT_EXPR, intermediate_type,
6839 inner, size_int (bitnum));
6841 one = build_int_cst (intermediate_type, 1);
6843 if (code == EQ_EXPR)
6844 inner = fold_build2_loc (loc, BIT_XOR_EXPR, intermediate_type, inner, one);
6846 /* Put the AND last so it can combine with more things. */
6847 inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
6849 /* Make sure to return the proper type. */
6850 inner = fold_convert_loc (loc, result_type, inner);
6857 /* Check whether we are allowed to reorder operands arg0 and arg1,
6858 such that the evaluation of arg1 occurs before arg0. */
6861 reorder_operands_p (const_tree arg0, const_tree arg1)
6863 if (! flag_evaluation_order)
6865 if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6867 return ! TREE_SIDE_EFFECTS (arg0)
6868 && ! TREE_SIDE_EFFECTS (arg1);
6871 /* Test whether it is preferable two swap two operands, ARG0 and
6872 ARG1, for example because ARG0 is an integer constant and ARG1
6873 isn't. If REORDER is true, only recommend swapping if we can
6874 evaluate the operands in reverse order. */
6877 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
6879 if (CONSTANT_CLASS_P (arg1))
6881 if (CONSTANT_CLASS_P (arg0))
6887 if (TREE_CONSTANT (arg1))
6889 if (TREE_CONSTANT (arg0))
6892 if (reorder && flag_evaluation_order
6893 && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6896 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6897 for commutative and comparison operators. Ensuring a canonical
6898 form allows the optimizers to find additional redundancies without
6899 having to explicitly check for both orderings. */
6900 if (TREE_CODE (arg0) == SSA_NAME
6901 && TREE_CODE (arg1) == SSA_NAME
6902 && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6905 /* Put SSA_NAMEs last. */
6906 if (TREE_CODE (arg1) == SSA_NAME)
6908 if (TREE_CODE (arg0) == SSA_NAME)
6911 /* Put variables last. */
6921 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6922 means A >= Y && A != MAX, but in this case we know that
6923 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6926 fold_to_nonsharp_ineq_using_bound (location_t loc, tree ineq, tree bound)
6928 tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
6930 if (TREE_CODE (bound) == LT_EXPR)
6931 a = TREE_OPERAND (bound, 0);
6932 else if (TREE_CODE (bound) == GT_EXPR)
6933 a = TREE_OPERAND (bound, 1);
6937 typea = TREE_TYPE (a);
6938 if (!INTEGRAL_TYPE_P (typea)
6939 && !POINTER_TYPE_P (typea))
6942 if (TREE_CODE (ineq) == LT_EXPR)
6944 a1 = TREE_OPERAND (ineq, 1);
6945 y = TREE_OPERAND (ineq, 0);
6947 else if (TREE_CODE (ineq) == GT_EXPR)
6949 a1 = TREE_OPERAND (ineq, 0);
6950 y = TREE_OPERAND (ineq, 1);
6955 if (TREE_TYPE (a1) != typea)
6958 if (POINTER_TYPE_P (typea))
6960 /* Convert the pointer types into integer before taking the difference. */
6961 tree ta = fold_convert_loc (loc, ssizetype, a);
6962 tree ta1 = fold_convert_loc (loc, ssizetype, a1);
6963 diff = fold_binary_loc (loc, MINUS_EXPR, ssizetype, ta1, ta);
6966 diff = fold_binary_loc (loc, MINUS_EXPR, typea, a1, a);
6968 if (!diff || !integer_onep (diff))
6971 return fold_build2_loc (loc, GE_EXPR, type, a, y);
6974 /* Fold a sum or difference of at least one multiplication.
6975 Returns the folded tree or NULL if no simplification could be made. */
6978 fold_plusminus_mult_expr (location_t loc, enum tree_code code, tree type,
6979 tree arg0, tree arg1)
6981 tree arg00, arg01, arg10, arg11;
6982 tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6984 /* (A * C) +- (B * C) -> (A+-B) * C.
6985 (A * C) +- A -> A * (C+-1).
6986 We are most concerned about the case where C is a constant,
6987 but other combinations show up during loop reduction. Since
6988 it is not difficult, try all four possibilities. */
6990 if (TREE_CODE (arg0) == MULT_EXPR)
6992 arg00 = TREE_OPERAND (arg0, 0);
6993 arg01 = TREE_OPERAND (arg0, 1);
6995 else if (TREE_CODE (arg0) == INTEGER_CST)
6997 arg00 = build_one_cst (type);
7002 /* We cannot generate constant 1 for fract. */
7003 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7006 arg01 = build_one_cst (type);
7008 if (TREE_CODE (arg1) == MULT_EXPR)
7010 arg10 = TREE_OPERAND (arg1, 0);
7011 arg11 = TREE_OPERAND (arg1, 1);
7013 else if (TREE_CODE (arg1) == INTEGER_CST)
7015 arg10 = build_one_cst (type);
7016 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7017 the purpose of this canonicalization. */
7018 if (wi::neg_p (arg1, TYPE_SIGN (TREE_TYPE (arg1)))
7019 && negate_expr_p (arg1)
7020 && code == PLUS_EXPR)
7022 arg11 = negate_expr (arg1);
7030 /* We cannot generate constant 1 for fract. */
7031 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7034 arg11 = build_one_cst (type);
7038 if (operand_equal_p (arg01, arg11, 0))
7039 same = arg01, alt0 = arg00, alt1 = arg10;
7040 else if (operand_equal_p (arg00, arg10, 0))
7041 same = arg00, alt0 = arg01, alt1 = arg11;
7042 else if (operand_equal_p (arg00, arg11, 0))
7043 same = arg00, alt0 = arg01, alt1 = arg10;
7044 else if (operand_equal_p (arg01, arg10, 0))
7045 same = arg01, alt0 = arg00, alt1 = arg11;
7047 /* No identical multiplicands; see if we can find a common
7048 power-of-two factor in non-power-of-two multiplies. This
7049 can help in multi-dimensional array access. */
7050 else if (tree_fits_shwi_p (arg01)
7051 && tree_fits_shwi_p (arg11))
7053 HOST_WIDE_INT int01, int11, tmp;
7056 int01 = tree_to_shwi (arg01);
7057 int11 = tree_to_shwi (arg11);
7059 /* Move min of absolute values to int11. */
7060 if (absu_hwi (int01) < absu_hwi (int11))
7062 tmp = int01, int01 = int11, int11 = tmp;
7063 alt0 = arg00, arg00 = arg10, arg10 = alt0;
7070 if (exact_log2 (absu_hwi (int11)) > 0 && int01 % int11 == 0
7071 /* The remainder should not be a constant, otherwise we
7072 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7073 increased the number of multiplications necessary. */
7074 && TREE_CODE (arg10) != INTEGER_CST)
7076 alt0 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (arg00), arg00,
7077 build_int_cst (TREE_TYPE (arg00),
7082 maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7087 return fold_build2_loc (loc, MULT_EXPR, type,
7088 fold_build2_loc (loc, code, type,
7089 fold_convert_loc (loc, type, alt0),
7090 fold_convert_loc (loc, type, alt1)),
7091 fold_convert_loc (loc, type, same));
7096 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7097 specified by EXPR into the buffer PTR of length LEN bytes.
7098 Return the number of bytes placed in the buffer, or zero
7102 native_encode_int (const_tree expr, unsigned char *ptr, int len, int off)
7104 tree type = TREE_TYPE (expr);
7105 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7106 int byte, offset, word, words;
7107 unsigned char value;
7109 if ((off == -1 && total_bytes > len)
7110 || off >= total_bytes)
7114 words = total_bytes / UNITS_PER_WORD;
7116 for (byte = 0; byte < total_bytes; byte++)
7118 int bitpos = byte * BITS_PER_UNIT;
7119 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7121 value = wi::extract_uhwi (wi::to_widest (expr), bitpos, BITS_PER_UNIT);
7123 if (total_bytes > UNITS_PER_WORD)
7125 word = byte / UNITS_PER_WORD;
7126 if (WORDS_BIG_ENDIAN)
7127 word = (words - 1) - word;
7128 offset = word * UNITS_PER_WORD;
7129 if (BYTES_BIG_ENDIAN)
7130 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7132 offset += byte % UNITS_PER_WORD;
7135 offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7137 && offset - off < len)
7138 ptr[offset - off] = value;
7140 return MIN (len, total_bytes - off);
7144 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7145 specified by EXPR into the buffer PTR of length LEN bytes.
7146 Return the number of bytes placed in the buffer, or zero
7150 native_encode_fixed (const_tree expr, unsigned char *ptr, int len, int off)
7152 tree type = TREE_TYPE (expr);
7153 machine_mode mode = TYPE_MODE (type);
7154 int total_bytes = GET_MODE_SIZE (mode);
7155 FIXED_VALUE_TYPE value;
7156 tree i_value, i_type;
7158 if (total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7161 i_type = lang_hooks.types.type_for_size (GET_MODE_BITSIZE (mode), 1);
7163 if (NULL_TREE == i_type
7164 || TYPE_PRECISION (i_type) != total_bytes)
7167 value = TREE_FIXED_CST (expr);
7168 i_value = double_int_to_tree (i_type, value.data);
7170 return native_encode_int (i_value, ptr, len, off);
7174 /* Subroutine of native_encode_expr. Encode the REAL_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_real (const_tree expr, unsigned char *ptr, int len, int off)
7182 tree type = TREE_TYPE (expr);
7183 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7184 int byte, offset, word, words, bitpos;
7185 unsigned char value;
7187 /* There are always 32 bits in each long, no matter the size of
7188 the hosts long. We handle floating point representations with
7192 if ((off == -1 && total_bytes > len)
7193 || off >= total_bytes)
7197 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7199 real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7201 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7202 bitpos += BITS_PER_UNIT)
7204 byte = (bitpos / BITS_PER_UNIT) & 3;
7205 value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7207 if (UNITS_PER_WORD < 4)
7209 word = byte / UNITS_PER_WORD;
7210 if (WORDS_BIG_ENDIAN)
7211 word = (words - 1) - word;
7212 offset = word * UNITS_PER_WORD;
7213 if (BYTES_BIG_ENDIAN)
7214 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7216 offset += byte % UNITS_PER_WORD;
7221 if (BYTES_BIG_ENDIAN)
7223 /* Reverse bytes within each long, or within the entire float
7224 if it's smaller than a long (for HFmode). */
7225 offset = MIN (3, total_bytes - 1) - offset;
7226 gcc_assert (offset >= 0);
7229 offset = offset + ((bitpos / BITS_PER_UNIT) & ~3);
7231 && offset - off < len)
7232 ptr[offset - off] = value;
7234 return MIN (len, total_bytes - off);
7237 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7238 specified by EXPR into the buffer PTR of length LEN bytes.
7239 Return the number of bytes placed in the buffer, or zero
7243 native_encode_complex (const_tree expr, unsigned char *ptr, int len, int off)
7248 part = TREE_REALPART (expr);
7249 rsize = native_encode_expr (part, ptr, len, off);
7253 part = TREE_IMAGPART (expr);
7255 off = MAX (0, off - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (part))));
7256 isize = native_encode_expr (part, ptr+rsize, len-rsize, off);
7260 return rsize + isize;
7264 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7265 specified by EXPR into the buffer PTR of length LEN bytes.
7266 Return the number of bytes placed in the buffer, or zero
7270 native_encode_vector (const_tree expr, unsigned char *ptr, int len, int off)
7277 count = VECTOR_CST_NELTS (expr);
7278 itype = TREE_TYPE (TREE_TYPE (expr));
7279 size = GET_MODE_SIZE (TYPE_MODE (itype));
7280 for (i = 0; i < count; i++)
7287 elem = VECTOR_CST_ELT (expr, i);
7288 int res = native_encode_expr (elem, ptr+offset, len-offset, off);
7289 if ((off == -1 && res != size)
7302 /* Subroutine of native_encode_expr. Encode the STRING_CST
7303 specified by EXPR into the buffer PTR of length LEN bytes.
7304 Return the number of bytes placed in the buffer, or zero
7308 native_encode_string (const_tree expr, unsigned char *ptr, int len, int off)
7310 tree type = TREE_TYPE (expr);
7311 HOST_WIDE_INT total_bytes;
7313 if (TREE_CODE (type) != ARRAY_TYPE
7314 || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE
7315 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT
7316 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type)))
7318 total_bytes = tree_to_shwi (TYPE_SIZE_UNIT (type));
7319 if ((off == -1 && total_bytes > len)
7320 || off >= total_bytes)
7324 if (TREE_STRING_LENGTH (expr) - off < MIN (total_bytes, len))
7327 if (off < TREE_STRING_LENGTH (expr))
7329 written = MIN (len, TREE_STRING_LENGTH (expr) - off);
7330 memcpy (ptr, TREE_STRING_POINTER (expr) + off, written);
7332 memset (ptr + written, 0,
7333 MIN (total_bytes - written, len - written));
7336 memcpy (ptr, TREE_STRING_POINTER (expr) + off, MIN (total_bytes, len));
7337 return MIN (total_bytes - off, len);
7341 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7342 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7343 buffer PTR of length LEN bytes. If OFF is not -1 then start
7344 the encoding at byte offset OFF and encode at most LEN bytes.
7345 Return the number of bytes placed in the buffer, or zero upon failure. */
7348 native_encode_expr (const_tree expr, unsigned char *ptr, int len, int off)
7350 /* We don't support starting at negative offset and -1 is special. */
7354 switch (TREE_CODE (expr))
7357 return native_encode_int (expr, ptr, len, off);
7360 return native_encode_real (expr, ptr, len, off);
7363 return native_encode_fixed (expr, ptr, len, off);
7366 return native_encode_complex (expr, ptr, len, off);
7369 return native_encode_vector (expr, ptr, len, off);
7372 return native_encode_string (expr, ptr, len, off);
7380 /* Subroutine of native_interpret_expr. Interpret the contents of
7381 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7382 If the buffer cannot be interpreted, return NULL_TREE. */
7385 native_interpret_int (tree type, const unsigned char *ptr, int len)
7387 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7389 if (total_bytes > len
7390 || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7393 wide_int result = wi::from_buffer (ptr, total_bytes);
7395 return wide_int_to_tree (type, result);
7399 /* Subroutine of native_interpret_expr. Interpret the contents of
7400 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7401 If the buffer cannot be interpreted, return NULL_TREE. */
7404 native_interpret_fixed (tree type, const unsigned char *ptr, int len)
7406 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7408 FIXED_VALUE_TYPE fixed_value;
7410 if (total_bytes > len
7411 || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7414 result = double_int::from_buffer (ptr, total_bytes);
7415 fixed_value = fixed_from_double_int (result, TYPE_MODE (type));
7417 return build_fixed (type, fixed_value);
7421 /* Subroutine of native_interpret_expr. Interpret the contents of
7422 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7423 If the buffer cannot be interpreted, return NULL_TREE. */
7426 native_interpret_real (tree type, const unsigned char *ptr, int len)
7428 machine_mode mode = TYPE_MODE (type);
7429 int total_bytes = GET_MODE_SIZE (mode);
7430 unsigned char value;
7431 /* There are always 32 bits in each long, no matter the size of
7432 the hosts long. We handle floating point representations with
7437 total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7438 if (total_bytes > len || total_bytes > 24)
7440 int words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7442 memset (tmp, 0, sizeof (tmp));
7443 for (int bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7444 bitpos += BITS_PER_UNIT)
7446 /* Both OFFSET and BYTE index within a long;
7447 bitpos indexes the whole float. */
7448 int offset, byte = (bitpos / BITS_PER_UNIT) & 3;
7449 if (UNITS_PER_WORD < 4)
7451 int word = byte / UNITS_PER_WORD;
7452 if (WORDS_BIG_ENDIAN)
7453 word = (words - 1) - word;
7454 offset = word * UNITS_PER_WORD;
7455 if (BYTES_BIG_ENDIAN)
7456 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7458 offset += byte % UNITS_PER_WORD;
7463 if (BYTES_BIG_ENDIAN)
7465 /* Reverse bytes within each long, or within the entire float
7466 if it's smaller than a long (for HFmode). */
7467 offset = MIN (3, total_bytes - 1) - offset;
7468 gcc_assert (offset >= 0);
7471 value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7473 tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7476 real_from_target (&r, tmp, mode);
7477 return build_real (type, r);
7481 /* Subroutine of native_interpret_expr. Interpret the contents of
7482 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7483 If the buffer cannot be interpreted, return NULL_TREE. */
7486 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7488 tree etype, rpart, ipart;
7491 etype = TREE_TYPE (type);
7492 size = GET_MODE_SIZE (TYPE_MODE (etype));
7495 rpart = native_interpret_expr (etype, ptr, size);
7498 ipart = native_interpret_expr (etype, ptr+size, size);
7501 return build_complex (type, rpart, ipart);
7505 /* Subroutine of native_interpret_expr. Interpret the contents of
7506 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7507 If the buffer cannot be interpreted, return NULL_TREE. */
7510 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7516 etype = TREE_TYPE (type);
7517 size = GET_MODE_SIZE (TYPE_MODE (etype));
7518 count = TYPE_VECTOR_SUBPARTS (type);
7519 if (size * count > len)
7522 elements = XALLOCAVEC (tree, count);
7523 for (i = count - 1; i >= 0; i--)
7525 elem = native_interpret_expr (etype, ptr+(i*size), size);
7530 return build_vector (type, elements);
7534 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7535 the buffer PTR of length LEN as a constant of type TYPE. For
7536 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7537 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7538 return NULL_TREE. */
7541 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7543 switch (TREE_CODE (type))
7549 case REFERENCE_TYPE:
7550 return native_interpret_int (type, ptr, len);
7553 return native_interpret_real (type, ptr, len);
7555 case FIXED_POINT_TYPE:
7556 return native_interpret_fixed (type, ptr, len);
7559 return native_interpret_complex (type, ptr, len);
7562 return native_interpret_vector (type, ptr, len);
7569 /* Returns true if we can interpret the contents of a native encoding
7573 can_native_interpret_type_p (tree type)
7575 switch (TREE_CODE (type))
7581 case REFERENCE_TYPE:
7582 case FIXED_POINT_TYPE:
7592 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7593 TYPE at compile-time. If we're unable to perform the conversion
7594 return NULL_TREE. */
7597 fold_view_convert_expr (tree type, tree expr)
7599 /* We support up to 512-bit values (for V8DFmode). */
7600 unsigned char buffer[64];
7603 /* Check that the host and target are sane. */
7604 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7607 len = native_encode_expr (expr, buffer, sizeof (buffer));
7611 return native_interpret_expr (type, buffer, len);
7614 /* Build an expression for the address of T. Folds away INDIRECT_REF
7615 to avoid confusing the gimplify process. */
7618 build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
7620 /* The size of the object is not relevant when talking about its address. */
7621 if (TREE_CODE (t) == WITH_SIZE_EXPR)
7622 t = TREE_OPERAND (t, 0);
7624 if (TREE_CODE (t) == INDIRECT_REF)
7626 t = TREE_OPERAND (t, 0);
7628 if (TREE_TYPE (t) != ptrtype)
7629 t = build1_loc (loc, NOP_EXPR, ptrtype, t);
7631 else if (TREE_CODE (t) == MEM_REF
7632 && integer_zerop (TREE_OPERAND (t, 1)))
7633 return TREE_OPERAND (t, 0);
7634 else if (TREE_CODE (t) == MEM_REF
7635 && TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST)
7636 return fold_binary (POINTER_PLUS_EXPR, ptrtype,
7637 TREE_OPERAND (t, 0),
7638 convert_to_ptrofftype (TREE_OPERAND (t, 1)));
7639 else if (TREE_CODE (t) == VIEW_CONVERT_EXPR)
7641 t = build_fold_addr_expr_loc (loc, TREE_OPERAND (t, 0));
7643 if (TREE_TYPE (t) != ptrtype)
7644 t = fold_convert_loc (loc, ptrtype, t);
7647 t = build1_loc (loc, ADDR_EXPR, ptrtype, t);
7652 /* Build an expression for the address of T. */
7655 build_fold_addr_expr_loc (location_t loc, tree t)
7657 tree ptrtype = build_pointer_type (TREE_TYPE (t));
7659 return build_fold_addr_expr_with_type_loc (loc, t, ptrtype);
7662 /* Fold a unary expression of code CODE and type TYPE with operand
7663 OP0. Return the folded expression if folding is successful.
7664 Otherwise, return NULL_TREE. */
7667 fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
7671 enum tree_code_class kind = TREE_CODE_CLASS (code);
7673 gcc_assert (IS_EXPR_CODE_CLASS (kind)
7674 && TREE_CODE_LENGTH (code) == 1);
7679 if (CONVERT_EXPR_CODE_P (code)
7680 || code == FLOAT_EXPR || code == ABS_EXPR || code == NEGATE_EXPR)
7682 /* Don't use STRIP_NOPS, because signedness of argument type
7684 STRIP_SIGN_NOPS (arg0);
7688 /* Strip any conversions that don't change the mode. This
7689 is safe for every expression, except for a comparison
7690 expression because its signedness is derived from its
7693 Note that this is done as an internal manipulation within
7694 the constant folder, in order to find the simplest
7695 representation of the arguments so that their form can be
7696 studied. In any cases, the appropriate type conversions
7697 should be put back in the tree that will get out of the
7702 if (CONSTANT_CLASS_P (arg0))
7704 tree tem = const_unop (code, type, arg0);
7707 if (TREE_TYPE (tem) != type)
7708 tem = fold_convert_loc (loc, type, tem);
7714 tem = generic_simplify (loc, code, type, op0);
7718 if (TREE_CODE_CLASS (code) == tcc_unary)
7720 if (TREE_CODE (arg0) == COMPOUND_EXPR)
7721 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7722 fold_build1_loc (loc, code, type,
7723 fold_convert_loc (loc, TREE_TYPE (op0),
7724 TREE_OPERAND (arg0, 1))));
7725 else if (TREE_CODE (arg0) == COND_EXPR)
7727 tree arg01 = TREE_OPERAND (arg0, 1);
7728 tree arg02 = TREE_OPERAND (arg0, 2);
7729 if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7730 arg01 = fold_build1_loc (loc, code, type,
7731 fold_convert_loc (loc,
7732 TREE_TYPE (op0), arg01));
7733 if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7734 arg02 = fold_build1_loc (loc, code, type,
7735 fold_convert_loc (loc,
7736 TREE_TYPE (op0), arg02));
7737 tem = fold_build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg0, 0),
7740 /* If this was a conversion, and all we did was to move into
7741 inside the COND_EXPR, bring it back out. But leave it if
7742 it is a conversion from integer to integer and the
7743 result precision is no wider than a word since such a
7744 conversion is cheap and may be optimized away by combine,
7745 while it couldn't if it were outside the COND_EXPR. Then return
7746 so we don't get into an infinite recursion loop taking the
7747 conversion out and then back in. */
7749 if ((CONVERT_EXPR_CODE_P (code)
7750 || code == NON_LVALUE_EXPR)
7751 && TREE_CODE (tem) == COND_EXPR
7752 && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7753 && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7754 && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7755 && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7756 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7757 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7758 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7760 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7761 && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7762 || flag_syntax_only))
7763 tem = build1_loc (loc, code, type,
7765 TREE_TYPE (TREE_OPERAND
7766 (TREE_OPERAND (tem, 1), 0)),
7767 TREE_OPERAND (tem, 0),
7768 TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7769 TREE_OPERAND (TREE_OPERAND (tem, 2),
7777 case NON_LVALUE_EXPR:
7778 if (!maybe_lvalue_p (op0))
7779 return fold_convert_loc (loc, type, op0);
7784 case FIX_TRUNC_EXPR:
7785 if (COMPARISON_CLASS_P (op0))
7787 /* If we have (type) (a CMP b) and type is an integral type, return
7788 new expression involving the new type. Canonicalize
7789 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7791 Do not fold the result as that would not simplify further, also
7792 folding again results in recursions. */
7793 if (TREE_CODE (type) == BOOLEAN_TYPE)
7794 return build2_loc (loc, TREE_CODE (op0), type,
7795 TREE_OPERAND (op0, 0),
7796 TREE_OPERAND (op0, 1));
7797 else if (!INTEGRAL_TYPE_P (type) && !VOID_TYPE_P (type)
7798 && TREE_CODE (type) != VECTOR_TYPE)
7799 return build3_loc (loc, COND_EXPR, type, op0,
7800 constant_boolean_node (true, type),
7801 constant_boolean_node (false, type));
7804 /* Handle (T *)&A.B.C for A being of type T and B and C
7805 living at offset zero. This occurs frequently in
7806 C++ upcasting and then accessing the base. */
7807 if (TREE_CODE (op0) == ADDR_EXPR
7808 && POINTER_TYPE_P (type)
7809 && handled_component_p (TREE_OPERAND (op0, 0)))
7811 HOST_WIDE_INT bitsize, bitpos;
7814 int unsignedp, reversep, volatilep;
7816 = get_inner_reference (TREE_OPERAND (op0, 0), &bitsize, &bitpos,
7817 &offset, &mode, &unsignedp, &reversep,
7819 /* If the reference was to a (constant) zero offset, we can use
7820 the address of the base if it has the same base type
7821 as the result type and the pointer type is unqualified. */
7822 if (! offset && bitpos == 0
7823 && (TYPE_MAIN_VARIANT (TREE_TYPE (type))
7824 == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
7825 && TYPE_QUALS (type) == TYPE_UNQUALIFIED)
7826 return fold_convert_loc (loc, type,
7827 build_fold_addr_expr_loc (loc, base));
7830 if (TREE_CODE (op0) == MODIFY_EXPR
7831 && TREE_CONSTANT (TREE_OPERAND (op0, 1))
7832 /* Detect assigning a bitfield. */
7833 && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
7835 (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
7837 /* Don't leave an assignment inside a conversion
7838 unless assigning a bitfield. */
7839 tem = fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 1));
7840 /* First do the assignment, then return converted constant. */
7841 tem = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
7842 TREE_NO_WARNING (tem) = 1;
7843 TREE_USED (tem) = 1;
7847 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7848 constants (if x has signed type, the sign bit cannot be set
7849 in c). This folds extension into the BIT_AND_EXPR.
7850 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7851 very likely don't have maximal range for their precision and this
7852 transformation effectively doesn't preserve non-maximal ranges. */
7853 if (TREE_CODE (type) == INTEGER_TYPE
7854 && TREE_CODE (op0) == BIT_AND_EXPR
7855 && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
7857 tree and_expr = op0;
7858 tree and0 = TREE_OPERAND (and_expr, 0);
7859 tree and1 = TREE_OPERAND (and_expr, 1);
7862 if (TYPE_UNSIGNED (TREE_TYPE (and_expr))
7863 || (TYPE_PRECISION (type)
7864 <= TYPE_PRECISION (TREE_TYPE (and_expr))))
7866 else if (TYPE_PRECISION (TREE_TYPE (and1))
7867 <= HOST_BITS_PER_WIDE_INT
7868 && tree_fits_uhwi_p (and1))
7870 unsigned HOST_WIDE_INT cst;
7872 cst = tree_to_uhwi (and1);
7873 cst &= HOST_WIDE_INT_M1U
7874 << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
7875 change = (cst == 0);
7877 && !flag_syntax_only
7878 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
7881 tree uns = unsigned_type_for (TREE_TYPE (and0));
7882 and0 = fold_convert_loc (loc, uns, and0);
7883 and1 = fold_convert_loc (loc, uns, and1);
7888 tem = force_fit_type (type, wi::to_widest (and1), 0,
7889 TREE_OVERFLOW (and1));
7890 return fold_build2_loc (loc, BIT_AND_EXPR, type,
7891 fold_convert_loc (loc, type, and0), tem);
7895 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7896 cast (T1)X will fold away. We assume that this happens when X itself
7898 if (POINTER_TYPE_P (type)
7899 && TREE_CODE (arg0) == POINTER_PLUS_EXPR
7900 && CONVERT_EXPR_P (TREE_OPERAND (arg0, 0)))
7902 tree arg00 = TREE_OPERAND (arg0, 0);
7903 tree arg01 = TREE_OPERAND (arg0, 1);
7905 return fold_build_pointer_plus_loc
7906 (loc, fold_convert_loc (loc, type, arg00), arg01);
7909 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7910 of the same precision, and X is an integer type not narrower than
7911 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7912 if (INTEGRAL_TYPE_P (type)
7913 && TREE_CODE (op0) == BIT_NOT_EXPR
7914 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7915 && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
7916 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
7918 tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
7919 if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7920 && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
7921 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
7922 fold_convert_loc (loc, type, tem));
7925 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7926 type of X and Y (integer types only). */
7927 if (INTEGRAL_TYPE_P (type)
7928 && TREE_CODE (op0) == MULT_EXPR
7929 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7930 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
7932 /* Be careful not to introduce new overflows. */
7934 if (TYPE_OVERFLOW_WRAPS (type))
7937 mult_type = unsigned_type_for (type);
7939 if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
7941 tem = fold_build2_loc (loc, MULT_EXPR, mult_type,
7942 fold_convert_loc (loc, mult_type,
7943 TREE_OPERAND (op0, 0)),
7944 fold_convert_loc (loc, mult_type,
7945 TREE_OPERAND (op0, 1)));
7946 return fold_convert_loc (loc, type, tem);
7952 case VIEW_CONVERT_EXPR:
7953 if (TREE_CODE (op0) == MEM_REF)
7955 if (TYPE_ALIGN (TREE_TYPE (op0)) != TYPE_ALIGN (type))
7956 type = build_aligned_type (type, TYPE_ALIGN (TREE_TYPE (op0)));
7957 tem = fold_build2_loc (loc, MEM_REF, type,
7958 TREE_OPERAND (op0, 0), TREE_OPERAND (op0, 1));
7959 REF_REVERSE_STORAGE_ORDER (tem) = REF_REVERSE_STORAGE_ORDER (op0);
7966 tem = fold_negate_expr (loc, arg0);
7968 return fold_convert_loc (loc, type, tem);
7972 /* Convert fabs((double)float) into (double)fabsf(float). */
7973 if (TREE_CODE (arg0) == NOP_EXPR
7974 && TREE_CODE (type) == REAL_TYPE)
7976 tree targ0 = strip_float_extensions (arg0);
7978 return fold_convert_loc (loc, type,
7979 fold_build1_loc (loc, ABS_EXPR,
7986 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
7987 if (TREE_CODE (arg0) == BIT_XOR_EXPR
7988 && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
7989 fold_convert_loc (loc, type,
7990 TREE_OPERAND (arg0, 0)))))
7991 return fold_build2_loc (loc, BIT_XOR_EXPR, type, tem,
7992 fold_convert_loc (loc, type,
7993 TREE_OPERAND (arg0, 1)));
7994 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
7995 && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
7996 fold_convert_loc (loc, type,
7997 TREE_OPERAND (arg0, 1)))))
7998 return fold_build2_loc (loc, BIT_XOR_EXPR, type,
7999 fold_convert_loc (loc, type,
8000 TREE_OPERAND (arg0, 0)), tem);
8004 case TRUTH_NOT_EXPR:
8005 /* Note that the operand of this must be an int
8006 and its values must be 0 or 1.
8007 ("true" is a fixed value perhaps depending on the language,
8008 but we don't handle values other than 1 correctly yet.) */
8009 tem = fold_truth_not_expr (loc, arg0);
8012 return fold_convert_loc (loc, type, tem);
8015 /* Fold *&X to X if X is an lvalue. */
8016 if (TREE_CODE (op0) == ADDR_EXPR)
8018 tree op00 = TREE_OPERAND (op0, 0);
8019 if ((TREE_CODE (op00) == VAR_DECL
8020 || TREE_CODE (op00) == PARM_DECL
8021 || TREE_CODE (op00) == RESULT_DECL)
8022 && !TREE_READONLY (op00))
8029 } /* switch (code) */
8033 /* If the operation was a conversion do _not_ mark a resulting constant
8034 with TREE_OVERFLOW if the original constant was not. These conversions
8035 have implementation defined behavior and retaining the TREE_OVERFLOW
8036 flag here would confuse later passes such as VRP. */
8038 fold_unary_ignore_overflow_loc (location_t loc, enum tree_code code,
8039 tree type, tree op0)
8041 tree res = fold_unary_loc (loc, code, type, op0);
8043 && TREE_CODE (res) == INTEGER_CST
8044 && TREE_CODE (op0) == INTEGER_CST
8045 && CONVERT_EXPR_CODE_P (code))
8046 TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
8051 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8052 operands OP0 and OP1. LOC is the location of the resulting expression.
8053 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8054 Return the folded expression if folding is successful. Otherwise,
8055 return NULL_TREE. */
8057 fold_truth_andor (location_t loc, enum tree_code code, tree type,
8058 tree arg0, tree arg1, tree op0, tree op1)
8062 /* We only do these simplifications if we are optimizing. */
8066 /* Check for things like (A || B) && (A || C). We can convert this
8067 to A || (B && C). Note that either operator can be any of the four
8068 truth and/or operations and the transformation will still be
8069 valid. Also note that we only care about order for the
8070 ANDIF and ORIF operators. If B contains side effects, this
8071 might change the truth-value of A. */
8072 if (TREE_CODE (arg0) == TREE_CODE (arg1)
8073 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
8074 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
8075 || TREE_CODE (arg0) == TRUTH_AND_EXPR
8076 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
8077 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
8079 tree a00 = TREE_OPERAND (arg0, 0);
8080 tree a01 = TREE_OPERAND (arg0, 1);
8081 tree a10 = TREE_OPERAND (arg1, 0);
8082 tree a11 = TREE_OPERAND (arg1, 1);
8083 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
8084 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
8085 && (code == TRUTH_AND_EXPR
8086 || code == TRUTH_OR_EXPR));
8088 if (operand_equal_p (a00, a10, 0))
8089 return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8090 fold_build2_loc (loc, code, type, a01, a11));
8091 else if (commutative && operand_equal_p (a00, a11, 0))
8092 return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8093 fold_build2_loc (loc, code, type, a01, a10));
8094 else if (commutative && operand_equal_p (a01, a10, 0))
8095 return fold_build2_loc (loc, TREE_CODE (arg0), type, a01,
8096 fold_build2_loc (loc, code, type, a00, a11));
8098 /* This case if tricky because we must either have commutative
8099 operators or else A10 must not have side-effects. */
8101 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
8102 && operand_equal_p (a01, a11, 0))
8103 return fold_build2_loc (loc, TREE_CODE (arg0), type,
8104 fold_build2_loc (loc, code, type, a00, a10),
8108 /* See if we can build a range comparison. */
8109 if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
8112 if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg0) == TRUTH_ORIF_EXPR)
8113 || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg0) == TRUTH_ANDIF_EXPR))
8115 tem = merge_truthop_with_opposite_arm (loc, arg0, arg1, true);
8117 return fold_build2_loc (loc, code, type, tem, arg1);
8120 if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg1) == TRUTH_ORIF_EXPR)
8121 || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg1) == TRUTH_ANDIF_EXPR))
8123 tem = merge_truthop_with_opposite_arm (loc, arg1, arg0, false);
8125 return fold_build2_loc (loc, code, type, arg0, tem);
8128 /* Check for the possibility of merging component references. If our
8129 lhs is another similar operation, try to merge its rhs with our
8130 rhs. Then try to merge our lhs and rhs. */
8131 if (TREE_CODE (arg0) == code
8132 && 0 != (tem = fold_truth_andor_1 (loc, code, type,
8133 TREE_OPERAND (arg0, 1), arg1)))
8134 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
8136 if ((tem = fold_truth_andor_1 (loc, code, type, arg0, arg1)) != 0)
8139 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8140 && (code == TRUTH_AND_EXPR
8141 || code == TRUTH_ANDIF_EXPR
8142 || code == TRUTH_OR_EXPR
8143 || code == TRUTH_ORIF_EXPR))
8145 enum tree_code ncode, icode;
8147 ncode = (code == TRUTH_ANDIF_EXPR || code == TRUTH_AND_EXPR)
8148 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR;
8149 icode = ncode == TRUTH_AND_EXPR ? TRUTH_ANDIF_EXPR : TRUTH_ORIF_EXPR;
8151 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8152 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8153 We don't want to pack more than two leafs to a non-IF AND/OR
8155 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8156 equal to IF-CODE, then we don't want to add right-hand operand.
8157 If the inner right-hand side of left-hand operand has
8158 side-effects, or isn't simple, then we can't add to it,
8159 as otherwise we might destroy if-sequence. */
8160 if (TREE_CODE (arg0) == icode
8161 && simple_operand_p_2 (arg1)
8162 /* Needed for sequence points to handle trappings, and
8164 && simple_operand_p_2 (TREE_OPERAND (arg0, 1)))
8166 tem = fold_build2_loc (loc, ncode, type, TREE_OPERAND (arg0, 1),
8168 return fold_build2_loc (loc, icode, type, TREE_OPERAND (arg0, 0),
8171 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8172 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8173 else if (TREE_CODE (arg1) == icode
8174 && simple_operand_p_2 (arg0)
8175 /* Needed for sequence points to handle trappings, and
8177 && simple_operand_p_2 (TREE_OPERAND (arg1, 0)))
8179 tem = fold_build2_loc (loc, ncode, type,
8180 arg0, TREE_OPERAND (arg1, 0));
8181 return fold_build2_loc (loc, icode, type, tem,
8182 TREE_OPERAND (arg1, 1));
8184 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8186 For sequence point consistancy, we need to check for trapping,
8187 and side-effects. */
8188 else if (code == icode && simple_operand_p_2 (arg0)
8189 && simple_operand_p_2 (arg1))
8190 return fold_build2_loc (loc, ncode, type, arg0, arg1);
8196 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8197 by changing CODE to reduce the magnitude of constants involved in
8198 ARG0 of the comparison.
8199 Returns a canonicalized comparison tree if a simplification was
8200 possible, otherwise returns NULL_TREE.
8201 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8202 valid if signed overflow is undefined. */
8205 maybe_canonicalize_comparison_1 (location_t loc, enum tree_code code, tree type,
8206 tree arg0, tree arg1,
8207 bool *strict_overflow_p)
8209 enum tree_code code0 = TREE_CODE (arg0);
8210 tree t, cst0 = NULL_TREE;
8213 /* Match A +- CST code arg1. We can change this only if overflow
8215 if (!((ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8216 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0)))
8217 /* In principle pointers also have undefined overflow behavior,
8218 but that causes problems elsewhere. */
8219 && !POINTER_TYPE_P (TREE_TYPE (arg0))
8220 && (code0 == MINUS_EXPR
8221 || code0 == PLUS_EXPR)
8222 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST))
8225 /* Identify the constant in arg0 and its sign. */
8226 cst0 = TREE_OPERAND (arg0, 1);
8227 sgn0 = tree_int_cst_sgn (cst0);
8229 /* Overflowed constants and zero will cause problems. */
8230 if (integer_zerop (cst0)
8231 || TREE_OVERFLOW (cst0))
8234 /* See if we can reduce the magnitude of the constant in
8235 arg0 by changing the comparison code. */
8236 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8238 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8240 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8241 else if (code == GT_EXPR
8242 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8244 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8245 else if (code == LE_EXPR
8246 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8248 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8249 else if (code == GE_EXPR
8250 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8254 *strict_overflow_p = true;
8256 /* Now build the constant reduced in magnitude. But not if that
8257 would produce one outside of its types range. */
8258 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8260 && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8261 && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8263 && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8264 && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8267 t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8268 cst0, build_int_cst (TREE_TYPE (cst0), 1));
8269 t = fold_build2_loc (loc, code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8270 t = fold_convert (TREE_TYPE (arg1), t);
8272 return fold_build2_loc (loc, code, type, t, arg1);
8275 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8276 overflow further. Try to decrease the magnitude of constants involved
8277 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8278 and put sole constants at the second argument position.
8279 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8282 maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
8283 tree arg0, tree arg1)
8286 bool strict_overflow_p;
8287 const char * const warnmsg = G_("assuming signed overflow does not occur "
8288 "when reducing constant in comparison");
8290 /* Try canonicalization by simplifying arg0. */
8291 strict_overflow_p = false;
8292 t = maybe_canonicalize_comparison_1 (loc, code, type, arg0, arg1,
8293 &strict_overflow_p);
8296 if (strict_overflow_p)
8297 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8301 /* Try canonicalization by simplifying arg1 using the swapped
8303 code = swap_tree_comparison (code);
8304 strict_overflow_p = false;
8305 t = maybe_canonicalize_comparison_1 (loc, code, type, arg1, arg0,
8306 &strict_overflow_p);
8307 if (t && strict_overflow_p)
8308 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8312 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8313 space. This is used to avoid issuing overflow warnings for
8314 expressions like &p->x which can not wrap. */
8317 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8319 if (!POINTER_TYPE_P (TREE_TYPE (base)))
8326 int precision = TYPE_PRECISION (TREE_TYPE (base));
8327 if (offset == NULL_TREE)
8328 wi_offset = wi::zero (precision);
8329 else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8335 wide_int units = wi::shwi (bitpos / BITS_PER_UNIT, precision);
8336 wide_int total = wi::add (wi_offset, units, UNSIGNED, &overflow);
8340 if (!wi::fits_uhwi_p (total))
8343 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8347 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8349 if (TREE_CODE (base) == ADDR_EXPR)
8351 HOST_WIDE_INT base_size;
8353 base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8354 if (base_size > 0 && size < base_size)
8358 return total.to_uhwi () > (unsigned HOST_WIDE_INT) size;
8361 /* Return a positive integer when the symbol DECL is known to have
8362 a nonzero address, zero when it's known not to (e.g., it's a weak
8363 symbol), and a negative integer when the symbol is not yet in the
8364 symbol table and so whether or not its address is zero is unknown. */
8366 maybe_nonzero_address (tree decl)
8368 if (DECL_P (decl) && decl_in_symtab_p (decl))
8369 if (struct symtab_node *symbol = symtab_node::get_create (decl))
8370 return symbol->nonzero_address ();
8375 /* Subroutine of fold_binary. This routine performs all of the
8376 transformations that are common to the equality/inequality
8377 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8378 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8379 fold_binary should call fold_binary. Fold a comparison with
8380 tree code CODE and type TYPE with operands OP0 and OP1. Return
8381 the folded comparison or NULL_TREE. */
8384 fold_comparison (location_t loc, enum tree_code code, tree type,
8387 const bool equality_code = (code == EQ_EXPR || code == NE_EXPR);
8388 tree arg0, arg1, tem;
8393 STRIP_SIGN_NOPS (arg0);
8394 STRIP_SIGN_NOPS (arg1);
8396 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8397 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8399 || (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8400 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))))
8401 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8402 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8403 && TREE_CODE (arg1) == INTEGER_CST
8404 && !TREE_OVERFLOW (arg1))
8406 const enum tree_code
8407 reverse_op = TREE_CODE (arg0) == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR;
8408 tree const1 = TREE_OPERAND (arg0, 1);
8409 tree const2 = fold_convert_loc (loc, TREE_TYPE (const1), arg1);
8410 tree variable = TREE_OPERAND (arg0, 0);
8411 tree new_const = int_const_binop (reverse_op, const2, const1);
8413 /* If the constant operation overflowed this can be
8414 simplified as a comparison against INT_MAX/INT_MIN. */
8415 if (TREE_OVERFLOW (new_const)
8416 && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
8418 int const1_sgn = tree_int_cst_sgn (const1);
8419 enum tree_code code2 = code;
8421 /* Get the sign of the constant on the lhs if the
8422 operation were VARIABLE + CONST1. */
8423 if (TREE_CODE (arg0) == MINUS_EXPR)
8424 const1_sgn = -const1_sgn;
8426 /* The sign of the constant determines if we overflowed
8427 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8428 Canonicalize to the INT_MIN overflow by swapping the comparison
8430 if (const1_sgn == -1)
8431 code2 = swap_tree_comparison (code);
8433 /* We now can look at the canonicalized case
8434 VARIABLE + 1 CODE2 INT_MIN
8435 and decide on the result. */
8442 omit_one_operand_loc (loc, type, boolean_false_node, variable);
8448 omit_one_operand_loc (loc, type, boolean_true_node, variable);
8457 fold_overflow_warning ("assuming signed overflow does not occur "
8458 "when changing X +- C1 cmp C2 to "
8460 WARN_STRICT_OVERFLOW_COMPARISON);
8461 return fold_build2_loc (loc, code, type, variable, new_const);
8465 /* For comparisons of pointers we can decompose it to a compile time
8466 comparison of the base objects and the offsets into the object.
8467 This requires at least one operand being an ADDR_EXPR or a
8468 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8469 if (POINTER_TYPE_P (TREE_TYPE (arg0))
8470 && (TREE_CODE (arg0) == ADDR_EXPR
8471 || TREE_CODE (arg1) == ADDR_EXPR
8472 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
8473 || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
8475 tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
8476 HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
8478 int volatilep, reversep, unsignedp;
8479 bool indirect_base0 = false, indirect_base1 = false;
8481 /* Get base and offset for the access. Strip ADDR_EXPR for
8482 get_inner_reference, but put it back by stripping INDIRECT_REF
8483 off the base object if possible. indirect_baseN will be true
8484 if baseN is not an address but refers to the object itself. */
8486 if (TREE_CODE (arg0) == ADDR_EXPR)
8489 = get_inner_reference (TREE_OPERAND (arg0, 0),
8490 &bitsize, &bitpos0, &offset0, &mode,
8491 &unsignedp, &reversep, &volatilep, false);
8492 if (TREE_CODE (base0) == INDIRECT_REF)
8493 base0 = TREE_OPERAND (base0, 0);
8495 indirect_base0 = true;
8497 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
8499 base0 = TREE_OPERAND (arg0, 0);
8500 STRIP_SIGN_NOPS (base0);
8501 if (TREE_CODE (base0) == ADDR_EXPR)
8504 = get_inner_reference (TREE_OPERAND (base0, 0),
8505 &bitsize, &bitpos0, &offset0, &mode,
8506 &unsignedp, &reversep, &volatilep,
8508 if (TREE_CODE (base0) == INDIRECT_REF)
8509 base0 = TREE_OPERAND (base0, 0);
8511 indirect_base0 = true;
8513 if (offset0 == NULL_TREE || integer_zerop (offset0))
8514 offset0 = TREE_OPERAND (arg0, 1);
8516 offset0 = size_binop (PLUS_EXPR, offset0,
8517 TREE_OPERAND (arg0, 1));
8518 if (TREE_CODE (offset0) == INTEGER_CST)
8520 offset_int tem = wi::sext (wi::to_offset (offset0),
8521 TYPE_PRECISION (sizetype));
8522 tem = wi::lshift (tem, LOG2_BITS_PER_UNIT);
8524 if (wi::fits_shwi_p (tem))
8526 bitpos0 = tem.to_shwi ();
8527 offset0 = NULL_TREE;
8533 if (TREE_CODE (arg1) == ADDR_EXPR)
8536 = get_inner_reference (TREE_OPERAND (arg1, 0),
8537 &bitsize, &bitpos1, &offset1, &mode,
8538 &unsignedp, &reversep, &volatilep, false);
8539 if (TREE_CODE (base1) == INDIRECT_REF)
8540 base1 = TREE_OPERAND (base1, 0);
8542 indirect_base1 = true;
8544 else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
8546 base1 = TREE_OPERAND (arg1, 0);
8547 STRIP_SIGN_NOPS (base1);
8548 if (TREE_CODE (base1) == ADDR_EXPR)
8551 = get_inner_reference (TREE_OPERAND (base1, 0),
8552 &bitsize, &bitpos1, &offset1, &mode,
8553 &unsignedp, &reversep, &volatilep,
8555 if (TREE_CODE (base1) == INDIRECT_REF)
8556 base1 = TREE_OPERAND (base1, 0);
8558 indirect_base1 = true;
8560 if (offset1 == NULL_TREE || integer_zerop (offset1))
8561 offset1 = TREE_OPERAND (arg1, 1);
8563 offset1 = size_binop (PLUS_EXPR, offset1,
8564 TREE_OPERAND (arg1, 1));
8565 if (TREE_CODE (offset1) == INTEGER_CST)
8567 offset_int tem = wi::sext (wi::to_offset (offset1),
8568 TYPE_PRECISION (sizetype));
8569 tem = wi::lshift (tem, LOG2_BITS_PER_UNIT);
8571 if (wi::fits_shwi_p (tem))
8573 bitpos1 = tem.to_shwi ();
8574 offset1 = NULL_TREE;
8579 /* If we have equivalent bases we might be able to simplify. */
8580 if (indirect_base0 == indirect_base1
8581 && operand_equal_p (base0, base1,
8582 indirect_base0 ? OEP_ADDRESS_OF : 0))
8584 /* We can fold this expression to a constant if the non-constant
8585 offset parts are equal. */
8586 if ((offset0 == offset1
8587 || (offset0 && offset1
8588 && operand_equal_p (offset0, offset1, 0)))
8591 && (DECL_P (base0) || CONSTANT_CLASS_P (base0)))
8592 || POINTER_TYPE_OVERFLOW_UNDEFINED))
8596 && bitpos0 != bitpos1
8597 && (pointer_may_wrap_p (base0, offset0, bitpos0)
8598 || pointer_may_wrap_p (base1, offset1, bitpos1)))
8599 fold_overflow_warning (("assuming pointer wraparound does not "
8600 "occur when comparing P +- C1 with "
8602 WARN_STRICT_OVERFLOW_CONDITIONAL);
8607 return constant_boolean_node (bitpos0 == bitpos1, type);
8609 return constant_boolean_node (bitpos0 != bitpos1, type);
8611 return constant_boolean_node (bitpos0 < bitpos1, type);
8613 return constant_boolean_node (bitpos0 <= bitpos1, type);
8615 return constant_boolean_node (bitpos0 >= bitpos1, type);
8617 return constant_boolean_node (bitpos0 > bitpos1, type);
8621 /* We can simplify the comparison to a comparison of the variable
8622 offset parts if the constant offset parts are equal.
8623 Be careful to use signed sizetype here because otherwise we
8624 mess with array offsets in the wrong way. This is possible
8625 because pointer arithmetic is restricted to retain within an
8626 object and overflow on pointer differences is undefined as of
8627 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8628 else if (bitpos0 == bitpos1
8631 && (DECL_P (base0) || CONSTANT_CLASS_P (base0)))
8632 || POINTER_TYPE_OVERFLOW_UNDEFINED))
8634 /* By converting to signed sizetype we cover middle-end pointer
8635 arithmetic which operates on unsigned pointer types of size
8636 type size and ARRAY_REF offsets which are properly sign or
8637 zero extended from their type in case it is narrower than
8639 if (offset0 == NULL_TREE)
8640 offset0 = build_int_cst (ssizetype, 0);
8642 offset0 = fold_convert_loc (loc, ssizetype, offset0);
8643 if (offset1 == NULL_TREE)
8644 offset1 = build_int_cst (ssizetype, 0);
8646 offset1 = fold_convert_loc (loc, ssizetype, offset1);
8649 && (pointer_may_wrap_p (base0, offset0, bitpos0)
8650 || pointer_may_wrap_p (base1, offset1, bitpos1)))
8651 fold_overflow_warning (("assuming pointer wraparound does not "
8652 "occur when comparing P +- C1 with "
8654 WARN_STRICT_OVERFLOW_COMPARISON);
8656 return fold_build2_loc (loc, code, type, offset0, offset1);
8659 /* For equal offsets we can simplify to a comparison of the
8661 else if (bitpos0 == bitpos1
8663 ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
8665 ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
8666 && ((offset0 == offset1)
8667 || (offset0 && offset1
8668 && operand_equal_p (offset0, offset1, 0))))
8671 base0 = build_fold_addr_expr_loc (loc, base0);
8673 base1 = build_fold_addr_expr_loc (loc, base1);
8674 return fold_build2_loc (loc, code, type, base0, base1);
8676 /* Comparison between an ordinary (non-weak) symbol and a null
8677 pointer can be eliminated since such symbols must have a non
8678 null address. In C, relational expressions between pointers
8679 to objects and null pointers are undefined. The results
8680 below follow the C++ rules with the additional property that
8681 every object pointer compares greater than a null pointer.
8683 else if (DECL_P (base0)
8684 && maybe_nonzero_address (base0) > 0
8685 /* Avoid folding references to struct members at offset 0 to
8686 prevent tests like '&ptr->firstmember == 0' from getting
8687 eliminated. When ptr is null, although the -> expression
8688 is strictly speaking invalid, GCC retains it as a matter
8689 of QoI. See PR c/44555. */
8690 && (offset0 == NULL_TREE && bitpos0 != 0)
8691 /* The caller guarantees that when one of the arguments is
8692 constant (i.e., null in this case) it is second. */
8693 && integer_zerop (arg1))
8700 return constant_boolean_node (false, type);
8704 return constant_boolean_node (true, type);
8711 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8712 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8713 the resulting offset is smaller in absolute value than the
8714 original one and has the same sign. */
8715 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8716 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8717 && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8718 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8719 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
8720 && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
8721 && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
8722 && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
8724 tree const1 = TREE_OPERAND (arg0, 1);
8725 tree const2 = TREE_OPERAND (arg1, 1);
8726 tree variable1 = TREE_OPERAND (arg0, 0);
8727 tree variable2 = TREE_OPERAND (arg1, 0);
8729 const char * const warnmsg = G_("assuming signed overflow does not "
8730 "occur when combining constants around "
8733 /* Put the constant on the side where it doesn't overflow and is
8734 of lower absolute value and of same sign than before. */
8735 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
8736 ? MINUS_EXPR : PLUS_EXPR,
8738 if (!TREE_OVERFLOW (cst)
8739 && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2)
8740 && tree_int_cst_sgn (cst) == tree_int_cst_sgn (const2))
8742 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
8743 return fold_build2_loc (loc, code, type,
8745 fold_build2_loc (loc, TREE_CODE (arg1),
8750 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
8751 ? MINUS_EXPR : PLUS_EXPR,
8753 if (!TREE_OVERFLOW (cst)
8754 && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1)
8755 && tree_int_cst_sgn (cst) == tree_int_cst_sgn (const1))
8757 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
8758 return fold_build2_loc (loc, code, type,
8759 fold_build2_loc (loc, TREE_CODE (arg0),
8766 tem = maybe_canonicalize_comparison (loc, code, type, arg0, arg1);
8770 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8771 constant, we can simplify it. */
8772 if (TREE_CODE (arg1) == INTEGER_CST
8773 && (TREE_CODE (arg0) == MIN_EXPR
8774 || TREE_CODE (arg0) == MAX_EXPR)
8775 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8777 tem = optimize_minmax_comparison (loc, code, type, op0, op1);
8782 /* If we are comparing an expression that just has comparisons
8783 of two integer values, arithmetic expressions of those comparisons,
8784 and constants, we can simplify it. There are only three cases
8785 to check: the two values can either be equal, the first can be
8786 greater, or the second can be greater. Fold the expression for
8787 those three values. Since each value must be 0 or 1, we have
8788 eight possibilities, each of which corresponds to the constant 0
8789 or 1 or one of the six possible comparisons.
8791 This handles common cases like (a > b) == 0 but also handles
8792 expressions like ((x > y) - (y > x)) > 0, which supposedly
8793 occur in macroized code. */
8795 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8797 tree cval1 = 0, cval2 = 0;
8800 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8801 /* Don't handle degenerate cases here; they should already
8802 have been handled anyway. */
8803 && cval1 != 0 && cval2 != 0
8804 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8805 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8806 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8807 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8808 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8809 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8810 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8812 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8813 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8815 /* We can't just pass T to eval_subst in case cval1 or cval2
8816 was the same as ARG1. */
8819 = fold_build2_loc (loc, code, type,
8820 eval_subst (loc, arg0, cval1, maxval,
8824 = fold_build2_loc (loc, code, type,
8825 eval_subst (loc, arg0, cval1, maxval,
8829 = fold_build2_loc (loc, code, type,
8830 eval_subst (loc, arg0, cval1, minval,
8834 /* All three of these results should be 0 or 1. Confirm they are.
8835 Then use those values to select the proper code to use. */
8837 if (TREE_CODE (high_result) == INTEGER_CST
8838 && TREE_CODE (equal_result) == INTEGER_CST
8839 && TREE_CODE (low_result) == INTEGER_CST)
8841 /* Make a 3-bit mask with the high-order bit being the
8842 value for `>', the next for '=', and the low for '<'. */
8843 switch ((integer_onep (high_result) * 4)
8844 + (integer_onep (equal_result) * 2)
8845 + integer_onep (low_result))
8849 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
8870 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
8875 tem = save_expr (build2 (code, type, cval1, cval2));
8876 SET_EXPR_LOCATION (tem, loc);
8879 return fold_build2_loc (loc, code, type, cval1, cval2);
8884 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8885 into a single range test. */
8886 if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
8887 || TREE_CODE (arg0) == EXACT_DIV_EXPR)
8888 && TREE_CODE (arg1) == INTEGER_CST
8889 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8890 && !integer_zerop (TREE_OPERAND (arg0, 1))
8891 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8892 && !TREE_OVERFLOW (arg1))
8894 tem = fold_div_compare (loc, code, type, arg0, arg1);
8895 if (tem != NULL_TREE)
8903 /* Subroutine of fold_binary. Optimize complex multiplications of the
8904 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8905 argument EXPR represents the expression "z" of type TYPE. */
8908 fold_mult_zconjz (location_t loc, tree type, tree expr)
8910 tree itype = TREE_TYPE (type);
8911 tree rpart, ipart, tem;
8913 if (TREE_CODE (expr) == COMPLEX_EXPR)
8915 rpart = TREE_OPERAND (expr, 0);
8916 ipart = TREE_OPERAND (expr, 1);
8918 else if (TREE_CODE (expr) == COMPLEX_CST)
8920 rpart = TREE_REALPART (expr);
8921 ipart = TREE_IMAGPART (expr);
8925 expr = save_expr (expr);
8926 rpart = fold_build1_loc (loc, REALPART_EXPR, itype, expr);
8927 ipart = fold_build1_loc (loc, IMAGPART_EXPR, itype, expr);
8930 rpart = save_expr (rpart);
8931 ipart = save_expr (ipart);
8932 tem = fold_build2_loc (loc, PLUS_EXPR, itype,
8933 fold_build2_loc (loc, MULT_EXPR, itype, rpart, rpart),
8934 fold_build2_loc (loc, MULT_EXPR, itype, ipart, ipart));
8935 return fold_build2_loc (loc, COMPLEX_EXPR, type, tem,
8936 build_zero_cst (itype));
8940 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8941 CONSTRUCTOR ARG into array ELTS and return true if successful. */
8944 vec_cst_ctor_to_array (tree arg, tree *elts)
8946 unsigned int nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg)), i;
8948 if (TREE_CODE (arg) == VECTOR_CST)
8950 for (i = 0; i < VECTOR_CST_NELTS (arg); ++i)
8951 elts[i] = VECTOR_CST_ELT (arg, i);
8953 else if (TREE_CODE (arg) == CONSTRUCTOR)
8955 constructor_elt *elt;
8957 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg), i, elt)
8958 if (i >= nelts || TREE_CODE (TREE_TYPE (elt->value)) == VECTOR_TYPE)
8961 elts[i] = elt->value;
8965 for (; i < nelts; i++)
8967 = fold_convert (TREE_TYPE (TREE_TYPE (arg)), integer_zero_node);
8971 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8972 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8973 NULL_TREE otherwise. */
8976 fold_vec_perm (tree type, tree arg0, tree arg1, const unsigned char *sel)
8978 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
8980 bool need_ctor = false;
8982 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts
8983 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts);
8984 if (TREE_TYPE (TREE_TYPE (arg0)) != TREE_TYPE (type)
8985 || TREE_TYPE (TREE_TYPE (arg1)) != TREE_TYPE (type))
8988 elts = XALLOCAVEC (tree, nelts * 3);
8989 if (!vec_cst_ctor_to_array (arg0, elts)
8990 || !vec_cst_ctor_to_array (arg1, elts + nelts))
8993 for (i = 0; i < nelts; i++)
8995 if (!CONSTANT_CLASS_P (elts[sel[i]]))
8997 elts[i + 2 * nelts] = unshare_expr (elts[sel[i]]);
9002 vec<constructor_elt, va_gc> *v;
9003 vec_alloc (v, nelts);
9004 for (i = 0; i < nelts; i++)
9005 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[2 * nelts + i]);
9006 return build_constructor (type, v);
9009 return build_vector (type, &elts[2 * nelts]);
9012 /* Try to fold a pointer difference of type TYPE two address expressions of
9013 array references AREF0 and AREF1 using location LOC. Return a
9014 simplified expression for the difference or NULL_TREE. */
9017 fold_addr_of_array_ref_difference (location_t loc, tree type,
9018 tree aref0, tree aref1)
9020 tree base0 = TREE_OPERAND (aref0, 0);
9021 tree base1 = TREE_OPERAND (aref1, 0);
9022 tree base_offset = build_int_cst (type, 0);
9024 /* If the bases are array references as well, recurse. If the bases
9025 are pointer indirections compute the difference of the pointers.
9026 If the bases are equal, we are set. */
9027 if ((TREE_CODE (base0) == ARRAY_REF
9028 && TREE_CODE (base1) == ARRAY_REF
9030 = fold_addr_of_array_ref_difference (loc, type, base0, base1)))
9031 || (INDIRECT_REF_P (base0)
9032 && INDIRECT_REF_P (base1)
9034 = fold_binary_loc (loc, MINUS_EXPR, type,
9035 fold_convert (type, TREE_OPERAND (base0, 0)),
9037 TREE_OPERAND (base1, 0)))))
9038 || operand_equal_p (base0, base1, OEP_ADDRESS_OF))
9040 tree op0 = fold_convert_loc (loc, type, TREE_OPERAND (aref0, 1));
9041 tree op1 = fold_convert_loc (loc, type, TREE_OPERAND (aref1, 1));
9042 tree esz = fold_convert_loc (loc, type, array_ref_element_size (aref0));
9043 tree diff = build2 (MINUS_EXPR, type, op0, op1);
9044 return fold_build2_loc (loc, PLUS_EXPR, type,
9046 fold_build2_loc (loc, MULT_EXPR, type,
9052 /* If the real or vector real constant CST of type TYPE has an exact
9053 inverse, return it, else return NULL. */
9056 exact_inverse (tree type, tree cst)
9059 tree unit_type, *elts;
9061 unsigned vec_nelts, i;
9063 switch (TREE_CODE (cst))
9066 r = TREE_REAL_CST (cst);
9068 if (exact_real_inverse (TYPE_MODE (type), &r))
9069 return build_real (type, r);
9074 vec_nelts = VECTOR_CST_NELTS (cst);
9075 elts = XALLOCAVEC (tree, vec_nelts);
9076 unit_type = TREE_TYPE (type);
9077 mode = TYPE_MODE (unit_type);
9079 for (i = 0; i < vec_nelts; i++)
9081 r = TREE_REAL_CST (VECTOR_CST_ELT (cst, i));
9082 if (!exact_real_inverse (mode, &r))
9084 elts[i] = build_real (unit_type, r);
9087 return build_vector (type, elts);
9094 /* Mask out the tz least significant bits of X of type TYPE where
9095 tz is the number of trailing zeroes in Y. */
9097 mask_with_tz (tree type, const wide_int &x, const wide_int &y)
9099 int tz = wi::ctz (y);
9101 return wi::mask (tz, true, TYPE_PRECISION (type)) & x;
9105 /* Return true when T is an address and is known to be nonzero.
9106 For floating point we further ensure that T is not denormal.
9107 Similar logic is present in nonzero_address in rtlanal.h.
9109 If the return value is based on the assumption that signed overflow
9110 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9111 change *STRICT_OVERFLOW_P. */
9114 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
9116 tree type = TREE_TYPE (t);
9117 enum tree_code code;
9119 /* Doing something useful for floating point would need more work. */
9120 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9123 code = TREE_CODE (t);
9124 switch (TREE_CODE_CLASS (code))
9127 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
9130 case tcc_comparison:
9131 return tree_binary_nonzero_warnv_p (code, type,
9132 TREE_OPERAND (t, 0),
9133 TREE_OPERAND (t, 1),
9136 case tcc_declaration:
9138 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
9146 case TRUTH_NOT_EXPR:
9147 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
9150 case TRUTH_AND_EXPR:
9152 case TRUTH_XOR_EXPR:
9153 return tree_binary_nonzero_warnv_p (code, type,
9154 TREE_OPERAND (t, 0),
9155 TREE_OPERAND (t, 1),
9163 case WITH_SIZE_EXPR:
9165 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
9170 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
9174 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
9179 tree fndecl = get_callee_fndecl (t);
9180 if (!fndecl) return false;
9181 if (flag_delete_null_pointer_checks && !flag_check_new
9182 && DECL_IS_OPERATOR_NEW (fndecl)
9183 && !TREE_NOTHROW (fndecl))
9185 if (flag_delete_null_pointer_checks
9186 && lookup_attribute ("returns_nonnull",
9187 TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
9189 return alloca_call_p (t);
9198 /* Return true when T is an address and is known to be nonzero.
9199 Handle warnings about undefined signed overflow. */
9202 tree_expr_nonzero_p (tree t)
9204 bool ret, strict_overflow_p;
9206 strict_overflow_p = false;
9207 ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
9208 if (strict_overflow_p)
9209 fold_overflow_warning (("assuming signed overflow does not occur when "
9210 "determining that expression is always "
9212 WARN_STRICT_OVERFLOW_MISC);
9216 /* Return true if T is known not to be equal to an integer W. */
9219 expr_not_equal_to (tree t, const wide_int &w)
9221 wide_int min, max, nz;
9222 value_range_type rtype;
9223 switch (TREE_CODE (t))
9226 return wi::ne_p (t, w);
9229 if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
9231 rtype = get_range_info (t, &min, &max);
9232 if (rtype == VR_RANGE)
9234 if (wi::lt_p (max, w, TYPE_SIGN (TREE_TYPE (t))))
9236 if (wi::lt_p (w, min, TYPE_SIGN (TREE_TYPE (t))))
9239 else if (rtype == VR_ANTI_RANGE
9240 && wi::le_p (min, w, TYPE_SIGN (TREE_TYPE (t)))
9241 && wi::le_p (w, max, TYPE_SIGN (TREE_TYPE (t))))
9243 /* If T has some known zero bits and W has any of those bits set,
9244 then T is known not to be equal to W. */
9245 if (wi::ne_p (wi::zext (wi::bit_and_not (w, get_nonzero_bits (t)),
9246 TYPE_PRECISION (TREE_TYPE (t))), 0))
9255 /* Fold a binary expression of code CODE and type TYPE with operands
9256 OP0 and OP1. LOC is the location of the resulting expression.
9257 Return the folded expression if folding is successful. Otherwise,
9258 return NULL_TREE. */
9261 fold_binary_loc (location_t loc,
9262 enum tree_code code, tree type, tree op0, tree op1)
9264 enum tree_code_class kind = TREE_CODE_CLASS (code);
9265 tree arg0, arg1, tem;
9266 tree t1 = NULL_TREE;
9267 bool strict_overflow_p;
9270 gcc_assert (IS_EXPR_CODE_CLASS (kind)
9271 && TREE_CODE_LENGTH (code) == 2
9273 && op1 != NULL_TREE);
9278 /* Strip any conversions that don't change the mode. This is
9279 safe for every expression, except for a comparison expression
9280 because its signedness is derived from its operands. So, in
9281 the latter case, only strip conversions that don't change the
9282 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9285 Note that this is done as an internal manipulation within the
9286 constant folder, in order to find the simplest representation
9287 of the arguments so that their form can be studied. In any
9288 cases, the appropriate type conversions should be put back in
9289 the tree that will get out of the constant folder. */
9291 if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
9293 STRIP_SIGN_NOPS (arg0);
9294 STRIP_SIGN_NOPS (arg1);
9302 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9303 constant but we can't do arithmetic on them. */
9304 if (CONSTANT_CLASS_P (arg0) && CONSTANT_CLASS_P (arg1))
9306 tem = const_binop (code, type, arg0, arg1);
9307 if (tem != NULL_TREE)
9309 if (TREE_TYPE (tem) != type)
9310 tem = fold_convert_loc (loc, type, tem);
9315 /* If this is a commutative operation, and ARG0 is a constant, move it
9316 to ARG1 to reduce the number of tests below. */
9317 if (commutative_tree_code (code)
9318 && tree_swap_operands_p (arg0, arg1, true))
9319 return fold_build2_loc (loc, code, type, op1, op0);
9321 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9322 to ARG1 to reduce the number of tests below. */
9323 if (kind == tcc_comparison
9324 && tree_swap_operands_p (arg0, arg1, true))
9325 return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
9327 tem = generic_simplify (loc, code, type, op0, op1);
9331 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9333 First check for cases where an arithmetic operation is applied to a
9334 compound, conditional, or comparison operation. Push the arithmetic
9335 operation inside the compound or conditional to see if any folding
9336 can then be done. Convert comparison to conditional for this purpose.
9337 The also optimizes non-constant cases that used to be done in
9340 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9341 one of the operands is a comparison and the other is a comparison, a
9342 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9343 code below would make the expression more complex. Change it to a
9344 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9345 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9347 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9348 || code == EQ_EXPR || code == NE_EXPR)
9349 && TREE_CODE (type) != VECTOR_TYPE
9350 && ((truth_value_p (TREE_CODE (arg0))
9351 && (truth_value_p (TREE_CODE (arg1))
9352 || (TREE_CODE (arg1) == BIT_AND_EXPR
9353 && integer_onep (TREE_OPERAND (arg1, 1)))))
9354 || (truth_value_p (TREE_CODE (arg1))
9355 && (truth_value_p (TREE_CODE (arg0))
9356 || (TREE_CODE (arg0) == BIT_AND_EXPR
9357 && integer_onep (TREE_OPERAND (arg0, 1)))))))
9359 tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9360 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9363 fold_convert_loc (loc, boolean_type_node, arg0),
9364 fold_convert_loc (loc, boolean_type_node, arg1));
9366 if (code == EQ_EXPR)
9367 tem = invert_truthvalue_loc (loc, tem);
9369 return fold_convert_loc (loc, type, tem);
9372 if (TREE_CODE_CLASS (code) == tcc_binary
9373 || TREE_CODE_CLASS (code) == tcc_comparison)
9375 if (TREE_CODE (arg0) == COMPOUND_EXPR)
9377 tem = fold_build2_loc (loc, code, type,
9378 fold_convert_loc (loc, TREE_TYPE (op0),
9379 TREE_OPERAND (arg0, 1)), op1);
9380 return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9383 if (TREE_CODE (arg1) == COMPOUND_EXPR
9384 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9386 tem = fold_build2_loc (loc, code, type, op0,
9387 fold_convert_loc (loc, TREE_TYPE (op1),
9388 TREE_OPERAND (arg1, 1)));
9389 return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9393 if (TREE_CODE (arg0) == COND_EXPR
9394 || TREE_CODE (arg0) == VEC_COND_EXPR
9395 || COMPARISON_CLASS_P (arg0))
9397 tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9399 /*cond_first_p=*/1);
9400 if (tem != NULL_TREE)
9404 if (TREE_CODE (arg1) == COND_EXPR
9405 || TREE_CODE (arg1) == VEC_COND_EXPR
9406 || COMPARISON_CLASS_P (arg1))
9408 tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9410 /*cond_first_p=*/0);
9411 if (tem != NULL_TREE)
9419 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9420 if (TREE_CODE (arg0) == ADDR_EXPR
9421 && TREE_CODE (TREE_OPERAND (arg0, 0)) == MEM_REF)
9423 tree iref = TREE_OPERAND (arg0, 0);
9424 return fold_build2 (MEM_REF, type,
9425 TREE_OPERAND (iref, 0),
9426 int_const_binop (PLUS_EXPR, arg1,
9427 TREE_OPERAND (iref, 1)));
9430 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9431 if (TREE_CODE (arg0) == ADDR_EXPR
9432 && handled_component_p (TREE_OPERAND (arg0, 0)))
9435 HOST_WIDE_INT coffset;
9436 base = get_addr_base_and_unit_offset (TREE_OPERAND (arg0, 0),
9440 return fold_build2 (MEM_REF, type,
9441 build_fold_addr_expr (base),
9442 int_const_binop (PLUS_EXPR, arg1,
9443 size_int (coffset)));
9448 case POINTER_PLUS_EXPR:
9449 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9450 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9451 && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9452 return fold_convert_loc (loc, type,
9453 fold_build2_loc (loc, PLUS_EXPR, sizetype,
9454 fold_convert_loc (loc, sizetype,
9456 fold_convert_loc (loc, sizetype,
9462 if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
9464 /* X + (X / CST) * -CST is X % CST. */
9465 if (TREE_CODE (arg1) == MULT_EXPR
9466 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
9467 && operand_equal_p (arg0,
9468 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
9470 tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
9471 tree cst1 = TREE_OPERAND (arg1, 1);
9472 tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (cst1),
9474 if (sum && integer_zerop (sum))
9475 return fold_convert_loc (loc, type,
9476 fold_build2_loc (loc, TRUNC_MOD_EXPR,
9477 TREE_TYPE (arg0), arg0,
9482 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9483 one. Make sure the type is not saturating and has the signedness of
9484 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9485 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9486 if ((TREE_CODE (arg0) == MULT_EXPR
9487 || TREE_CODE (arg1) == MULT_EXPR)
9488 && !TYPE_SATURATING (type)
9489 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
9490 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
9491 && (!FLOAT_TYPE_P (type) || flag_associative_math))
9493 tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
9498 if (! FLOAT_TYPE_P (type))
9500 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9501 (plus (plus (mult) (mult)) (foo)) so that we can
9502 take advantage of the factoring cases below. */
9503 if (ANY_INTEGRAL_TYPE_P (type)
9504 && TYPE_OVERFLOW_WRAPS (type)
9505 && (((TREE_CODE (arg0) == PLUS_EXPR
9506 || TREE_CODE (arg0) == MINUS_EXPR)
9507 && TREE_CODE (arg1) == MULT_EXPR)
9508 || ((TREE_CODE (arg1) == PLUS_EXPR
9509 || TREE_CODE (arg1) == MINUS_EXPR)
9510 && TREE_CODE (arg0) == MULT_EXPR)))
9512 tree parg0, parg1, parg, marg;
9513 enum tree_code pcode;
9515 if (TREE_CODE (arg1) == MULT_EXPR)
9516 parg = arg0, marg = arg1;
9518 parg = arg1, marg = arg0;
9519 pcode = TREE_CODE (parg);
9520 parg0 = TREE_OPERAND (parg, 0);
9521 parg1 = TREE_OPERAND (parg, 1);
9525 if (TREE_CODE (parg0) == MULT_EXPR
9526 && TREE_CODE (parg1) != MULT_EXPR)
9527 return fold_build2_loc (loc, pcode, type,
9528 fold_build2_loc (loc, PLUS_EXPR, type,
9529 fold_convert_loc (loc, type,
9531 fold_convert_loc (loc, type,
9533 fold_convert_loc (loc, type, parg1));
9534 if (TREE_CODE (parg0) != MULT_EXPR
9535 && TREE_CODE (parg1) == MULT_EXPR)
9537 fold_build2_loc (loc, PLUS_EXPR, type,
9538 fold_convert_loc (loc, type, parg0),
9539 fold_build2_loc (loc, pcode, type,
9540 fold_convert_loc (loc, type, marg),
9541 fold_convert_loc (loc, type,
9547 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9548 to __complex__ ( x, y ). This is not the same for SNaNs or
9549 if signed zeros are involved. */
9550 if (!HONOR_SNANS (element_mode (arg0))
9551 && !HONOR_SIGNED_ZEROS (element_mode (arg0))
9552 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
9554 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
9555 tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
9556 tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
9557 bool arg0rz = false, arg0iz = false;
9558 if ((arg0r && (arg0rz = real_zerop (arg0r)))
9559 || (arg0i && (arg0iz = real_zerop (arg0i))))
9561 tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
9562 tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
9563 if (arg0rz && arg1i && real_zerop (arg1i))
9565 tree rp = arg1r ? arg1r
9566 : build1 (REALPART_EXPR, rtype, arg1);
9567 tree ip = arg0i ? arg0i
9568 : build1 (IMAGPART_EXPR, rtype, arg0);
9569 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9571 else if (arg0iz && arg1r && real_zerop (arg1r))
9573 tree rp = arg0r ? arg0r
9574 : build1 (REALPART_EXPR, rtype, arg0);
9575 tree ip = arg1i ? arg1i
9576 : build1 (IMAGPART_EXPR, rtype, arg1);
9577 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9582 if (flag_unsafe_math_optimizations
9583 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
9584 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
9585 && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
9588 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9589 We associate floats only if the user has specified
9590 -fassociative-math. */
9591 if (flag_associative_math
9592 && TREE_CODE (arg1) == PLUS_EXPR
9593 && TREE_CODE (arg0) != MULT_EXPR)
9595 tree tree10 = TREE_OPERAND (arg1, 0);
9596 tree tree11 = TREE_OPERAND (arg1, 1);
9597 if (TREE_CODE (tree11) == MULT_EXPR
9598 && TREE_CODE (tree10) == MULT_EXPR)
9601 tree0 = fold_build2_loc (loc, PLUS_EXPR, type, arg0, tree10);
9602 return fold_build2_loc (loc, PLUS_EXPR, type, tree0, tree11);
9605 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9606 We associate floats only if the user has specified
9607 -fassociative-math. */
9608 if (flag_associative_math
9609 && TREE_CODE (arg0) == PLUS_EXPR
9610 && TREE_CODE (arg1) != MULT_EXPR)
9612 tree tree00 = TREE_OPERAND (arg0, 0);
9613 tree tree01 = TREE_OPERAND (arg0, 1);
9614 if (TREE_CODE (tree01) == MULT_EXPR
9615 && TREE_CODE (tree00) == MULT_EXPR)
9618 tree0 = fold_build2_loc (loc, PLUS_EXPR, type, tree01, arg1);
9619 return fold_build2_loc (loc, PLUS_EXPR, type, tree00, tree0);
9625 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9626 is a rotate of A by C1 bits. */
9627 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9628 is a rotate of A by B bits. */
9630 enum tree_code code0, code1;
9632 code0 = TREE_CODE (arg0);
9633 code1 = TREE_CODE (arg1);
9634 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
9635 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
9636 && operand_equal_p (TREE_OPERAND (arg0, 0),
9637 TREE_OPERAND (arg1, 0), 0)
9638 && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
9639 TYPE_UNSIGNED (rtype))
9640 /* Only create rotates in complete modes. Other cases are not
9641 expanded properly. */
9642 && (element_precision (rtype)
9643 == GET_MODE_UNIT_PRECISION (TYPE_MODE (rtype))))
9645 tree tree01, tree11;
9646 enum tree_code code01, code11;
9648 tree01 = TREE_OPERAND (arg0, 1);
9649 tree11 = TREE_OPERAND (arg1, 1);
9650 STRIP_NOPS (tree01);
9651 STRIP_NOPS (tree11);
9652 code01 = TREE_CODE (tree01);
9653 code11 = TREE_CODE (tree11);
9654 if (code01 == INTEGER_CST
9655 && code11 == INTEGER_CST
9656 && (wi::to_widest (tree01) + wi::to_widest (tree11)
9657 == element_precision (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
9659 tem = build2_loc (loc, LROTATE_EXPR,
9660 TREE_TYPE (TREE_OPERAND (arg0, 0)),
9661 TREE_OPERAND (arg0, 0),
9662 code0 == LSHIFT_EXPR
9663 ? TREE_OPERAND (arg0, 1)
9664 : TREE_OPERAND (arg1, 1));
9665 return fold_convert_loc (loc, type, tem);
9667 else if (code11 == MINUS_EXPR)
9669 tree tree110, tree111;
9670 tree110 = TREE_OPERAND (tree11, 0);
9671 tree111 = TREE_OPERAND (tree11, 1);
9672 STRIP_NOPS (tree110);
9673 STRIP_NOPS (tree111);
9674 if (TREE_CODE (tree110) == INTEGER_CST
9675 && 0 == compare_tree_int (tree110,
9677 (TREE_TYPE (TREE_OPERAND
9679 && operand_equal_p (tree01, tree111, 0))
9681 fold_convert_loc (loc, type,
9682 build2 ((code0 == LSHIFT_EXPR
9685 TREE_TYPE (TREE_OPERAND (arg0, 0)),
9686 TREE_OPERAND (arg0, 0),
9687 TREE_OPERAND (arg0, 1)));
9689 else if (code01 == MINUS_EXPR)
9691 tree tree010, tree011;
9692 tree010 = TREE_OPERAND (tree01, 0);
9693 tree011 = TREE_OPERAND (tree01, 1);
9694 STRIP_NOPS (tree010);
9695 STRIP_NOPS (tree011);
9696 if (TREE_CODE (tree010) == INTEGER_CST
9697 && 0 == compare_tree_int (tree010,
9699 (TREE_TYPE (TREE_OPERAND
9701 && operand_equal_p (tree11, tree011, 0))
9702 return fold_convert_loc
9704 build2 ((code0 != LSHIFT_EXPR
9707 TREE_TYPE (TREE_OPERAND (arg0, 0)),
9708 TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1)));
9714 /* In most languages, can't associate operations on floats through
9715 parentheses. Rather than remember where the parentheses were, we
9716 don't associate floats at all, unless the user has specified
9718 And, we need to make sure type is not saturating. */
9720 if ((! FLOAT_TYPE_P (type) || flag_associative_math)
9721 && !TYPE_SATURATING (type))
9723 tree var0, con0, lit0, minus_lit0;
9724 tree var1, con1, lit1, minus_lit1;
9728 /* Split both trees into variables, constants, and literals. Then
9729 associate each group together, the constants with literals,
9730 then the result with variables. This increases the chances of
9731 literals being recombined later and of generating relocatable
9732 expressions for the sum of a constant and literal. */
9733 var0 = split_tree (loc, arg0, type, code,
9734 &con0, &lit0, &minus_lit0, 0);
9735 var1 = split_tree (loc, arg1, type, code,
9736 &con1, &lit1, &minus_lit1, code == MINUS_EXPR);
9738 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9739 if (code == MINUS_EXPR)
9742 /* With undefined overflow prefer doing association in a type
9743 which wraps on overflow, if that is one of the operand types. */
9744 if ((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
9745 || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
9747 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
9748 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
9749 atype = TREE_TYPE (arg0);
9750 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9751 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
9752 atype = TREE_TYPE (arg1);
9753 gcc_assert (TYPE_PRECISION (atype) == TYPE_PRECISION (type));
9756 /* With undefined overflow we can only associate constants with one
9757 variable, and constants whose association doesn't overflow. */
9758 if ((POINTER_TYPE_P (atype) && POINTER_TYPE_OVERFLOW_UNDEFINED)
9759 || (INTEGRAL_TYPE_P (atype) && !TYPE_OVERFLOW_WRAPS (atype)))
9765 bool one_neg = false;
9767 if (TREE_CODE (tmp0) == NEGATE_EXPR)
9769 tmp0 = TREE_OPERAND (tmp0, 0);
9772 if (CONVERT_EXPR_P (tmp0)
9773 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
9774 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
9775 <= TYPE_PRECISION (atype)))
9776 tmp0 = TREE_OPERAND (tmp0, 0);
9777 if (TREE_CODE (tmp1) == NEGATE_EXPR)
9779 tmp1 = TREE_OPERAND (tmp1, 0);
9782 if (CONVERT_EXPR_P (tmp1)
9783 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
9784 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
9785 <= TYPE_PRECISION (atype)))
9786 tmp1 = TREE_OPERAND (tmp1, 0);
9787 /* The only case we can still associate with two variables
9788 is if they cancel out. */
9790 || !operand_equal_p (tmp0, tmp1, 0))
9795 /* Only do something if we found more than two objects. Otherwise,
9796 nothing has changed and we risk infinite recursion. */
9798 && (2 < ((var0 != 0) + (var1 != 0)
9799 + (con0 != 0) + (con1 != 0)
9800 + (lit0 != 0) + (lit1 != 0)
9801 + (minus_lit0 != 0) + (minus_lit1 != 0))))
9803 bool any_overflows = false;
9804 if (lit0) any_overflows |= TREE_OVERFLOW (lit0);
9805 if (lit1) any_overflows |= TREE_OVERFLOW (lit1);
9806 if (minus_lit0) any_overflows |= TREE_OVERFLOW (minus_lit0);
9807 if (minus_lit1) any_overflows |= TREE_OVERFLOW (minus_lit1);
9808 var0 = associate_trees (loc, var0, var1, code, atype);
9809 con0 = associate_trees (loc, con0, con1, code, atype);
9810 lit0 = associate_trees (loc, lit0, lit1, code, atype);
9811 minus_lit0 = associate_trees (loc, minus_lit0, minus_lit1,
9814 /* Preserve the MINUS_EXPR if the negative part of the literal is
9815 greater than the positive part. Otherwise, the multiplicative
9816 folding code (i.e extract_muldiv) may be fooled in case
9817 unsigned constants are subtracted, like in the following
9818 example: ((X*2 + 4) - 8U)/2. */
9819 if (minus_lit0 && lit0)
9821 if (TREE_CODE (lit0) == INTEGER_CST
9822 && TREE_CODE (minus_lit0) == INTEGER_CST
9823 && tree_int_cst_lt (lit0, minus_lit0))
9825 minus_lit0 = associate_trees (loc, minus_lit0, lit0,
9831 lit0 = associate_trees (loc, lit0, minus_lit0,
9837 /* Don't introduce overflows through reassociation. */
9839 && ((lit0 && TREE_OVERFLOW_P (lit0))
9840 || (minus_lit0 && TREE_OVERFLOW_P (minus_lit0))))
9847 fold_convert_loc (loc, type,
9848 associate_trees (loc, var0, minus_lit0,
9849 MINUS_EXPR, atype));
9852 con0 = associate_trees (loc, con0, minus_lit0,
9855 fold_convert_loc (loc, type,
9856 associate_trees (loc, var0, con0,
9861 con0 = associate_trees (loc, con0, lit0, code, atype);
9863 fold_convert_loc (loc, type, associate_trees (loc, var0, con0,
9871 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9872 if (TREE_CODE (arg0) == NEGATE_EXPR
9873 && negate_expr_p (op1)
9874 && reorder_operands_p (arg0, arg1))
9875 return fold_build2_loc (loc, MINUS_EXPR, type,
9877 fold_convert_loc (loc, type,
9878 TREE_OPERAND (arg0, 0)));
9880 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9881 __complex__ ( x, -y ). This is not the same for SNaNs or if
9882 signed zeros are involved. */
9883 if (!HONOR_SNANS (element_mode (arg0))
9884 && !HONOR_SIGNED_ZEROS (element_mode (arg0))
9885 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
9887 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
9888 tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
9889 tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
9890 bool arg0rz = false, arg0iz = false;
9891 if ((arg0r && (arg0rz = real_zerop (arg0r)))
9892 || (arg0i && (arg0iz = real_zerop (arg0i))))
9894 tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
9895 tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
9896 if (arg0rz && arg1i && real_zerop (arg1i))
9898 tree rp = fold_build1_loc (loc, NEGATE_EXPR, rtype,
9900 : build1 (REALPART_EXPR, rtype, arg1));
9901 tree ip = arg0i ? arg0i
9902 : build1 (IMAGPART_EXPR, rtype, arg0);
9903 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9905 else if (arg0iz && arg1r && real_zerop (arg1r))
9907 tree rp = arg0r ? arg0r
9908 : build1 (REALPART_EXPR, rtype, arg0);
9909 tree ip = fold_build1_loc (loc, NEGATE_EXPR, rtype,
9911 : build1 (IMAGPART_EXPR, rtype, arg1));
9912 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
9917 /* A - B -> A + (-B) if B is easily negatable. */
9918 if (negate_expr_p (op1)
9919 && ! TYPE_OVERFLOW_SANITIZED (type)
9920 && ((FLOAT_TYPE_P (type)
9921 /* Avoid this transformation if B is a positive REAL_CST. */
9922 && (TREE_CODE (op1) != REAL_CST
9923 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (op1))))
9924 || INTEGRAL_TYPE_P (type)))
9925 return fold_build2_loc (loc, PLUS_EXPR, type,
9926 fold_convert_loc (loc, type, arg0),
9929 /* Fold &a[i] - &a[j] to i-j. */
9930 if (TREE_CODE (arg0) == ADDR_EXPR
9931 && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
9932 && TREE_CODE (arg1) == ADDR_EXPR
9933 && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
9935 tree tem = fold_addr_of_array_ref_difference (loc, type,
9936 TREE_OPERAND (arg0, 0),
9937 TREE_OPERAND (arg1, 0));
9942 if (FLOAT_TYPE_P (type)
9943 && flag_unsafe_math_optimizations
9944 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
9945 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
9946 && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
9949 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9950 one. Make sure the type is not saturating and has the signedness of
9951 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9952 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9953 if ((TREE_CODE (arg0) == MULT_EXPR
9954 || TREE_CODE (arg1) == MULT_EXPR)
9955 && !TYPE_SATURATING (type)
9956 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
9957 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
9958 && (!FLOAT_TYPE_P (type) || flag_associative_math))
9960 tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
9968 if (! FLOAT_TYPE_P (type))
9970 /* Transform x * -C into -x * C if x is easily negatable. */
9971 if (TREE_CODE (op1) == INTEGER_CST
9972 && tree_int_cst_sgn (op1) == -1
9973 && negate_expr_p (op0)
9974 && (tem = negate_expr (op1)) != op1
9975 && ! TREE_OVERFLOW (tem))
9976 return fold_build2_loc (loc, MULT_EXPR, type,
9977 fold_convert_loc (loc, type,
9978 negate_expr (op0)), tem);
9980 /* (A + A) * C -> A * 2 * C */
9981 if (TREE_CODE (arg0) == PLUS_EXPR
9982 && TREE_CODE (arg1) == INTEGER_CST
9983 && operand_equal_p (TREE_OPERAND (arg0, 0),
9984 TREE_OPERAND (arg0, 1), 0))
9985 return fold_build2_loc (loc, MULT_EXPR, type,
9986 omit_one_operand_loc (loc, type,
9987 TREE_OPERAND (arg0, 0),
9988 TREE_OPERAND (arg0, 1)),
9989 fold_build2_loc (loc, MULT_EXPR, type,
9990 build_int_cst (type, 2) , arg1));
9992 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
9993 sign-changing only. */
9994 if (TREE_CODE (arg1) == INTEGER_CST
9995 && TREE_CODE (arg0) == EXACT_DIV_EXPR
9996 && operand_equal_p (arg1, TREE_OPERAND (arg0, 1), 0))
9997 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
9999 strict_overflow_p = false;
10000 if (TREE_CODE (arg1) == INTEGER_CST
10001 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10002 &strict_overflow_p)))
10004 if (strict_overflow_p)
10005 fold_overflow_warning (("assuming signed overflow does not "
10006 "occur when simplifying "
10008 WARN_STRICT_OVERFLOW_MISC);
10009 return fold_convert_loc (loc, type, tem);
10012 /* Optimize z * conj(z) for integer complex numbers. */
10013 if (TREE_CODE (arg0) == CONJ_EXPR
10014 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10015 return fold_mult_zconjz (loc, type, arg1);
10016 if (TREE_CODE (arg1) == CONJ_EXPR
10017 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10018 return fold_mult_zconjz (loc, type, arg0);
10022 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10023 This is not the same for NaNs or if signed zeros are
10025 if (!HONOR_NANS (arg0)
10026 && !HONOR_SIGNED_ZEROS (element_mode (arg0))
10027 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
10028 && TREE_CODE (arg1) == COMPLEX_CST
10029 && real_zerop (TREE_REALPART (arg1)))
10031 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10032 if (real_onep (TREE_IMAGPART (arg1)))
10034 fold_build2_loc (loc, COMPLEX_EXPR, type,
10035 negate_expr (fold_build1_loc (loc, IMAGPART_EXPR,
10037 fold_build1_loc (loc, REALPART_EXPR, rtype, arg0));
10038 else if (real_minus_onep (TREE_IMAGPART (arg1)))
10040 fold_build2_loc (loc, COMPLEX_EXPR, type,
10041 fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0),
10042 negate_expr (fold_build1_loc (loc, REALPART_EXPR,
10046 /* Optimize z * conj(z) for floating point complex numbers.
10047 Guarded by flag_unsafe_math_optimizations as non-finite
10048 imaginary components don't produce scalar results. */
10049 if (flag_unsafe_math_optimizations
10050 && TREE_CODE (arg0) == CONJ_EXPR
10051 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10052 return fold_mult_zconjz (loc, type, arg1);
10053 if (flag_unsafe_math_optimizations
10054 && TREE_CODE (arg1) == CONJ_EXPR
10055 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10056 return fold_mult_zconjz (loc, type, arg0);
10058 if (flag_unsafe_math_optimizations)
10061 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
10062 if (!in_gimple_form
10064 && operand_equal_p (arg0, arg1, 0))
10066 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
10070 tree arg = build_real (type, dconst2);
10071 return build_call_expr_loc (loc, powfn, 2, arg0, arg);
10079 /* Canonicalize (X & C1) | C2. */
10080 if (TREE_CODE (arg0) == BIT_AND_EXPR
10081 && TREE_CODE (arg1) == INTEGER_CST
10082 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10084 int width = TYPE_PRECISION (type), w;
10085 wide_int c1 = TREE_OPERAND (arg0, 1);
10086 wide_int c2 = arg1;
10088 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
10089 if ((c1 & c2) == c1)
10090 return omit_one_operand_loc (loc, type, arg1,
10091 TREE_OPERAND (arg0, 0));
10093 wide_int msk = wi::mask (width, false,
10094 TYPE_PRECISION (TREE_TYPE (arg1)));
10096 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
10097 if (msk.and_not (c1 | c2) == 0)
10098 return fold_build2_loc (loc, BIT_IOR_EXPR, type,
10099 TREE_OPERAND (arg0, 0), arg1);
10101 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
10102 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
10103 mode which allows further optimizations. */
10106 wide_int c3 = c1.and_not (c2);
10107 for (w = BITS_PER_UNIT; w <= width; w <<= 1)
10109 wide_int mask = wi::mask (w, false,
10110 TYPE_PRECISION (type));
10111 if (((c1 | c2) & mask) == mask && c1.and_not (mask) == 0)
10119 return fold_build2_loc (loc, BIT_IOR_EXPR, type,
10120 fold_build2_loc (loc, BIT_AND_EXPR, type,
10121 TREE_OPERAND (arg0, 0),
10122 wide_int_to_tree (type,
10127 /* See if this can be simplified into a rotate first. If that
10128 is unsuccessful continue in the association code. */
10132 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
10133 if (TREE_CODE (arg0) == BIT_AND_EXPR
10134 && INTEGRAL_TYPE_P (type)
10135 && integer_onep (TREE_OPERAND (arg0, 1))
10136 && integer_onep (arg1))
10137 return fold_build2_loc (loc, EQ_EXPR, type, arg0,
10138 build_zero_cst (TREE_TYPE (arg0)));
10140 /* See if this can be simplified into a rotate first. If that
10141 is unsuccessful continue in the association code. */
10145 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
10146 if (TREE_CODE (arg0) == BIT_XOR_EXPR
10147 && INTEGRAL_TYPE_P (type)
10148 && integer_onep (TREE_OPERAND (arg0, 1))
10149 && integer_onep (arg1))
10152 tem = TREE_OPERAND (arg0, 0);
10153 tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
10154 tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
10156 return fold_build2_loc (loc, EQ_EXPR, type, tem2,
10157 build_zero_cst (TREE_TYPE (tem)));
10159 /* Fold ~X & 1 as (X & 1) == 0. */
10160 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10161 && INTEGRAL_TYPE_P (type)
10162 && integer_onep (arg1))
10165 tem = TREE_OPERAND (arg0, 0);
10166 tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
10167 tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
10169 return fold_build2_loc (loc, EQ_EXPR, type, tem2,
10170 build_zero_cst (TREE_TYPE (tem)));
10172 /* Fold !X & 1 as X == 0. */
10173 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10174 && integer_onep (arg1))
10176 tem = TREE_OPERAND (arg0, 0);
10177 return fold_build2_loc (loc, EQ_EXPR, type, tem,
10178 build_zero_cst (TREE_TYPE (tem)));
10181 /* Fold (X ^ Y) & Y as ~X & Y. */
10182 if (TREE_CODE (arg0) == BIT_XOR_EXPR
10183 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10185 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10186 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10187 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10188 fold_convert_loc (loc, type, arg1));
10190 /* Fold (X ^ Y) & X as ~Y & X. */
10191 if (TREE_CODE (arg0) == BIT_XOR_EXPR
10192 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10193 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10195 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10196 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10197 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10198 fold_convert_loc (loc, type, arg1));
10200 /* Fold X & (X ^ Y) as X & ~Y. */
10201 if (TREE_CODE (arg1) == BIT_XOR_EXPR
10202 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10204 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10205 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10206 fold_convert_loc (loc, type, arg0),
10207 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
10209 /* Fold X & (Y ^ X) as ~Y & X. */
10210 if (TREE_CODE (arg1) == BIT_XOR_EXPR
10211 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10212 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10214 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10215 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10216 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
10217 fold_convert_loc (loc, type, arg0));
10220 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
10221 multiple of 1 << CST. */
10222 if (TREE_CODE (arg1) == INTEGER_CST)
10224 wide_int cst1 = arg1;
10225 wide_int ncst1 = -cst1;
10226 if ((cst1 & ncst1) == ncst1
10227 && multiple_of_p (type, arg0,
10228 wide_int_to_tree (TREE_TYPE (arg1), ncst1)))
10229 return fold_convert_loc (loc, type, arg0);
10232 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10234 if (TREE_CODE (arg1) == INTEGER_CST
10235 && TREE_CODE (arg0) == MULT_EXPR
10236 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10238 wide_int warg1 = arg1;
10239 wide_int masked = mask_with_tz (type, warg1, TREE_OPERAND (arg0, 1));
10242 return omit_two_operands_loc (loc, type, build_zero_cst (type),
10244 else if (masked != warg1)
10246 /* Avoid the transform if arg1 is a mask of some
10247 mode which allows further optimizations. */
10248 int pop = wi::popcount (warg1);
10249 if (!(pop >= BITS_PER_UNIT
10250 && exact_log2 (pop) != -1
10251 && wi::mask (pop, false, warg1.get_precision ()) == warg1))
10252 return fold_build2_loc (loc, code, type, op0,
10253 wide_int_to_tree (type, masked));
10257 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10258 ((A & N) + B) & M -> (A + B) & M
10259 Similarly if (N & M) == 0,
10260 ((A | N) + B) & M -> (A + B) & M
10261 and for - instead of + (or unary - instead of +)
10262 and/or ^ instead of |.
10263 If B is constant and (B & M) == 0, fold into A & M. */
10264 if (TREE_CODE (arg1) == INTEGER_CST)
10266 wide_int cst1 = arg1;
10267 if ((~cst1 != 0) && (cst1 & (cst1 + 1)) == 0
10268 && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
10269 && (TREE_CODE (arg0) == PLUS_EXPR
10270 || TREE_CODE (arg0) == MINUS_EXPR
10271 || TREE_CODE (arg0) == NEGATE_EXPR)
10272 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
10273 || TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE))
10279 /* Now we know that arg0 is (C + D) or (C - D) or
10280 -C and arg1 (M) is == (1LL << cst) - 1.
10281 Store C into PMOP[0] and D into PMOP[1]. */
10282 pmop[0] = TREE_OPERAND (arg0, 0);
10284 if (TREE_CODE (arg0) != NEGATE_EXPR)
10286 pmop[1] = TREE_OPERAND (arg0, 1);
10290 if ((wi::max_value (TREE_TYPE (arg0)) & cst1) != cst1)
10293 for (; which >= 0; which--)
10294 switch (TREE_CODE (pmop[which]))
10299 if (TREE_CODE (TREE_OPERAND (pmop[which], 1))
10302 cst0 = TREE_OPERAND (pmop[which], 1);
10304 if (TREE_CODE (pmop[which]) == BIT_AND_EXPR)
10309 else if (cst0 != 0)
10311 /* If C or D is of the form (A & N) where
10312 (N & M) == M, or of the form (A | N) or
10313 (A ^ N) where (N & M) == 0, replace it with A. */
10314 pmop[which] = TREE_OPERAND (pmop[which], 0);
10317 /* If C or D is a N where (N & M) == 0, it can be
10318 omitted (assumed 0). */
10319 if ((TREE_CODE (arg0) == PLUS_EXPR
10320 || (TREE_CODE (arg0) == MINUS_EXPR && which == 0))
10321 && (cst1 & pmop[which]) == 0)
10322 pmop[which] = NULL;
10328 /* Only build anything new if we optimized one or both arguments
10330 if (pmop[0] != TREE_OPERAND (arg0, 0)
10331 || (TREE_CODE (arg0) != NEGATE_EXPR
10332 && pmop[1] != TREE_OPERAND (arg0, 1)))
10334 tree utype = TREE_TYPE (arg0);
10335 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
10337 /* Perform the operations in a type that has defined
10338 overflow behavior. */
10339 utype = unsigned_type_for (TREE_TYPE (arg0));
10340 if (pmop[0] != NULL)
10341 pmop[0] = fold_convert_loc (loc, utype, pmop[0]);
10342 if (pmop[1] != NULL)
10343 pmop[1] = fold_convert_loc (loc, utype, pmop[1]);
10346 if (TREE_CODE (arg0) == NEGATE_EXPR)
10347 tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[0]);
10348 else if (TREE_CODE (arg0) == PLUS_EXPR)
10350 if (pmop[0] != NULL && pmop[1] != NULL)
10351 tem = fold_build2_loc (loc, PLUS_EXPR, utype,
10353 else if (pmop[0] != NULL)
10355 else if (pmop[1] != NULL)
10358 return build_int_cst (type, 0);
10360 else if (pmop[0] == NULL)
10361 tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[1]);
10363 tem = fold_build2_loc (loc, MINUS_EXPR, utype,
10365 /* TEM is now the new binary +, - or unary - replacement. */
10366 tem = fold_build2_loc (loc, BIT_AND_EXPR, utype, tem,
10367 fold_convert_loc (loc, utype, arg1));
10368 return fold_convert_loc (loc, type, tem);
10373 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10374 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
10375 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
10377 prec = element_precision (TREE_TYPE (TREE_OPERAND (arg0, 0)));
10379 wide_int mask = wide_int::from (arg1, prec, UNSIGNED);
10382 fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10388 /* Don't touch a floating-point divide by zero unless the mode
10389 of the constant can represent infinity. */
10390 if (TREE_CODE (arg1) == REAL_CST
10391 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
10392 && real_zerop (arg1))
10395 /* (-A) / (-B) -> A / B */
10396 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10397 return fold_build2_loc (loc, RDIV_EXPR, type,
10398 TREE_OPERAND (arg0, 0),
10399 negate_expr (arg1));
10400 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10401 return fold_build2_loc (loc, RDIV_EXPR, type,
10402 negate_expr (arg0),
10403 TREE_OPERAND (arg1, 0));
10406 case TRUNC_DIV_EXPR:
10409 case FLOOR_DIV_EXPR:
10410 /* Simplify A / (B << N) where A and B are positive and B is
10411 a power of 2, to A >> (N + log2(B)). */
10412 strict_overflow_p = false;
10413 if (TREE_CODE (arg1) == LSHIFT_EXPR
10414 && (TYPE_UNSIGNED (type)
10415 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
10417 tree sval = TREE_OPERAND (arg1, 0);
10418 if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
10420 tree sh_cnt = TREE_OPERAND (arg1, 1);
10421 tree pow2 = build_int_cst (TREE_TYPE (sh_cnt),
10422 wi::exact_log2 (sval));
10424 if (strict_overflow_p)
10425 fold_overflow_warning (("assuming signed overflow does not "
10426 "occur when simplifying A / (B << N)"),
10427 WARN_STRICT_OVERFLOW_MISC);
10429 sh_cnt = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (sh_cnt),
10431 return fold_build2_loc (loc, RSHIFT_EXPR, type,
10432 fold_convert_loc (loc, type, arg0), sh_cnt);
10438 case ROUND_DIV_EXPR:
10439 case CEIL_DIV_EXPR:
10440 case EXACT_DIV_EXPR:
10441 if (integer_zerop (arg1))
10444 /* Convert -A / -B to A / B when the type is signed and overflow is
10446 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
10447 && TREE_CODE (arg0) == NEGATE_EXPR
10448 && negate_expr_p (op1))
10450 if (INTEGRAL_TYPE_P (type))
10451 fold_overflow_warning (("assuming signed overflow does not occur "
10452 "when distributing negation across "
10454 WARN_STRICT_OVERFLOW_MISC);
10455 return fold_build2_loc (loc, code, type,
10456 fold_convert_loc (loc, type,
10457 TREE_OPERAND (arg0, 0)),
10458 negate_expr (op1));
10460 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
10461 && TREE_CODE (arg1) == NEGATE_EXPR
10462 && negate_expr_p (op0))
10464 if (INTEGRAL_TYPE_P (type))
10465 fold_overflow_warning (("assuming signed overflow does not occur "
10466 "when distributing negation across "
10468 WARN_STRICT_OVERFLOW_MISC);
10469 return fold_build2_loc (loc, code, type,
10471 fold_convert_loc (loc, type,
10472 TREE_OPERAND (arg1, 0)));
10475 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10476 operation, EXACT_DIV_EXPR.
10478 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10479 At one time others generated faster code, it's not clear if they do
10480 after the last round to changes to the DIV code in expmed.c. */
10481 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
10482 && multiple_of_p (type, arg0, arg1))
10483 return fold_build2_loc (loc, EXACT_DIV_EXPR, type,
10484 fold_convert (type, arg0),
10485 fold_convert (type, arg1));
10487 strict_overflow_p = false;
10488 if (TREE_CODE (arg1) == INTEGER_CST
10489 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10490 &strict_overflow_p)))
10492 if (strict_overflow_p)
10493 fold_overflow_warning (("assuming signed overflow does not occur "
10494 "when simplifying division"),
10495 WARN_STRICT_OVERFLOW_MISC);
10496 return fold_convert_loc (loc, type, tem);
10501 case CEIL_MOD_EXPR:
10502 case FLOOR_MOD_EXPR:
10503 case ROUND_MOD_EXPR:
10504 case TRUNC_MOD_EXPR:
10505 strict_overflow_p = false;
10506 if (TREE_CODE (arg1) == INTEGER_CST
10507 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10508 &strict_overflow_p)))
10510 if (strict_overflow_p)
10511 fold_overflow_warning (("assuming signed overflow does not occur "
10512 "when simplifying modulus"),
10513 WARN_STRICT_OVERFLOW_MISC);
10514 return fold_convert_loc (loc, type, tem);
10523 /* Since negative shift count is not well-defined,
10524 don't try to compute it in the compiler. */
10525 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
10528 prec = element_precision (type);
10530 /* If we have a rotate of a bit operation with the rotate count and
10531 the second operand of the bit operation both constant,
10532 permute the two operations. */
10533 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10534 && (TREE_CODE (arg0) == BIT_AND_EXPR
10535 || TREE_CODE (arg0) == BIT_IOR_EXPR
10536 || TREE_CODE (arg0) == BIT_XOR_EXPR)
10537 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10539 tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10540 tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10541 return fold_build2_loc (loc, TREE_CODE (arg0), type,
10542 fold_build2_loc (loc, code, type,
10544 fold_build2_loc (loc, code, type,
10548 /* Two consecutive rotates adding up to the some integer
10549 multiple of the precision of the type can be ignored. */
10550 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10551 && TREE_CODE (arg0) == RROTATE_EXPR
10552 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10553 && wi::umod_trunc (wi::add (arg1, TREE_OPERAND (arg0, 1)),
10555 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10563 case TRUTH_ANDIF_EXPR:
10564 /* Note that the operands of this must be ints
10565 and their values must be 0 or 1.
10566 ("true" is a fixed value perhaps depending on the language.) */
10567 /* If first arg is constant zero, return it. */
10568 if (integer_zerop (arg0))
10569 return fold_convert_loc (loc, type, arg0);
10570 case TRUTH_AND_EXPR:
10571 /* If either arg is constant true, drop it. */
10572 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10573 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10574 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
10575 /* Preserve sequence points. */
10576 && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10577 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10578 /* If second arg is constant zero, result is zero, but first arg
10579 must be evaluated. */
10580 if (integer_zerop (arg1))
10581 return omit_one_operand_loc (loc, type, arg1, arg0);
10582 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10583 case will be handled here. */
10584 if (integer_zerop (arg0))
10585 return omit_one_operand_loc (loc, type, arg0, arg1);
10587 /* !X && X is always false. */
10588 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10589 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10590 return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
10591 /* X && !X is always false. */
10592 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10593 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10594 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
10596 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10597 means A >= Y && A != MAX, but in this case we know that
10600 if (!TREE_SIDE_EFFECTS (arg0)
10601 && !TREE_SIDE_EFFECTS (arg1))
10603 tem = fold_to_nonsharp_ineq_using_bound (loc, arg0, arg1);
10604 if (tem && !operand_equal_p (tem, arg0, 0))
10605 return fold_build2_loc (loc, code, type, tem, arg1);
10607 tem = fold_to_nonsharp_ineq_using_bound (loc, arg1, arg0);
10608 if (tem && !operand_equal_p (tem, arg1, 0))
10609 return fold_build2_loc (loc, code, type, arg0, tem);
10612 if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
10618 case TRUTH_ORIF_EXPR:
10619 /* Note that the operands of this must be ints
10620 and their values must be 0 or true.
10621 ("true" is a fixed value perhaps depending on the language.) */
10622 /* If first arg is constant true, return it. */
10623 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10624 return fold_convert_loc (loc, type, arg0);
10625 case TRUTH_OR_EXPR:
10626 /* If either arg is constant zero, drop it. */
10627 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
10628 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10629 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
10630 /* Preserve sequence points. */
10631 && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10632 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10633 /* If second arg is constant true, result is true, but we must
10634 evaluate first arg. */
10635 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
10636 return omit_one_operand_loc (loc, type, arg1, arg0);
10637 /* Likewise for first arg, but note this only occurs here for
10639 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10640 return omit_one_operand_loc (loc, type, arg0, arg1);
10642 /* !X || X is always true. */
10643 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10644 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10645 return omit_one_operand_loc (loc, type, integer_one_node, arg1);
10646 /* X || !X is always true. */
10647 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10648 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10649 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
10651 /* (X && !Y) || (!X && Y) is X ^ Y */
10652 if (TREE_CODE (arg0) == TRUTH_AND_EXPR
10653 && TREE_CODE (arg1) == TRUTH_AND_EXPR)
10655 tree a0, a1, l0, l1, n0, n1;
10657 a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10658 a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10660 l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10661 l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10663 n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
10664 n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
10666 if ((operand_equal_p (n0, a0, 0)
10667 && operand_equal_p (n1, a1, 0))
10668 || (operand_equal_p (n0, a1, 0)
10669 && operand_equal_p (n1, a0, 0)))
10670 return fold_build2_loc (loc, TRUTH_XOR_EXPR, type, l0, n1);
10673 if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
10679 case TRUTH_XOR_EXPR:
10680 /* If the second arg is constant zero, drop it. */
10681 if (integer_zerop (arg1))
10682 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10683 /* If the second arg is constant true, this is a logical inversion. */
10684 if (integer_onep (arg1))
10686 tem = invert_truthvalue_loc (loc, arg0);
10687 return non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
10689 /* Identical arguments cancel to zero. */
10690 if (operand_equal_p (arg0, arg1, 0))
10691 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
10693 /* !X ^ X is always true. */
10694 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10695 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10696 return omit_one_operand_loc (loc, type, integer_one_node, arg1);
10698 /* X ^ !X is always true. */
10699 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10700 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10701 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
10710 tem = fold_comparison (loc, code, type, op0, op1);
10711 if (tem != NULL_TREE)
10714 /* bool_var != 1 becomes !bool_var. */
10715 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
10716 && code == NE_EXPR)
10717 return fold_convert_loc (loc, type,
10718 fold_build1_loc (loc, TRUTH_NOT_EXPR,
10719 TREE_TYPE (arg0), arg0));
10721 /* bool_var == 0 becomes !bool_var. */
10722 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
10723 && code == EQ_EXPR)
10724 return fold_convert_loc (loc, type,
10725 fold_build1_loc (loc, TRUTH_NOT_EXPR,
10726 TREE_TYPE (arg0), arg0));
10728 /* !exp != 0 becomes !exp */
10729 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR && integer_zerop (arg1)
10730 && code == NE_EXPR)
10731 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10733 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
10734 if ((TREE_CODE (arg0) == PLUS_EXPR
10735 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
10736 || TREE_CODE (arg0) == MINUS_EXPR)
10737 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
10740 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
10741 || POINTER_TYPE_P (TREE_TYPE (arg0))))
10743 tree val = TREE_OPERAND (arg0, 1);
10744 val = fold_build2_loc (loc, code, type, val,
10745 build_int_cst (TREE_TYPE (val), 0));
10746 return omit_two_operands_loc (loc, type, val,
10747 TREE_OPERAND (arg0, 0), arg1);
10750 /* Transform comparisons of the form X CMP X +- Y to Y CMP 0. */
10751 if ((TREE_CODE (arg1) == PLUS_EXPR
10752 || TREE_CODE (arg1) == POINTER_PLUS_EXPR
10753 || TREE_CODE (arg1) == MINUS_EXPR)
10754 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1,
10757 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10758 || POINTER_TYPE_P (TREE_TYPE (arg1))))
10760 tree val = TREE_OPERAND (arg1, 1);
10761 val = fold_build2_loc (loc, code, type, val,
10762 build_int_cst (TREE_TYPE (val), 0));
10763 return omit_two_operands_loc (loc, type, val,
10764 TREE_OPERAND (arg1, 0), arg0);
10767 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
10768 if (TREE_CODE (arg0) == MINUS_EXPR
10769 && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
10770 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
10773 && wi::extract_uhwi (TREE_OPERAND (arg0, 0), 0, 1) == 1)
10774 return omit_two_operands_loc (loc, type,
10776 ? boolean_true_node : boolean_false_node,
10777 TREE_OPERAND (arg0, 1), arg1);
10779 /* Transform comparisons of the form X CMP C - X if C % 2 == 1. */
10780 if (TREE_CODE (arg1) == MINUS_EXPR
10781 && TREE_CODE (TREE_OPERAND (arg1, 0)) == INTEGER_CST
10782 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1,
10785 && wi::extract_uhwi (TREE_OPERAND (arg1, 0), 0, 1) == 1)
10786 return omit_two_operands_loc (loc, type,
10788 ? boolean_true_node : boolean_false_node,
10789 TREE_OPERAND (arg1, 1), arg0);
10791 /* If this is an EQ or NE comparison with zero and ARG0 is
10792 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10793 two operations, but the latter can be done in one less insn
10794 on machines that have only two-operand insns or on which a
10795 constant cannot be the first operand. */
10796 if (TREE_CODE (arg0) == BIT_AND_EXPR
10797 && integer_zerop (arg1))
10799 tree arg00 = TREE_OPERAND (arg0, 0);
10800 tree arg01 = TREE_OPERAND (arg0, 1);
10801 if (TREE_CODE (arg00) == LSHIFT_EXPR
10802 && integer_onep (TREE_OPERAND (arg00, 0)))
10804 tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
10805 arg01, TREE_OPERAND (arg00, 1));
10806 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
10807 build_int_cst (TREE_TYPE (arg0), 1));
10808 return fold_build2_loc (loc, code, type,
10809 fold_convert_loc (loc, TREE_TYPE (arg1), tem),
10812 else if (TREE_CODE (arg01) == LSHIFT_EXPR
10813 && integer_onep (TREE_OPERAND (arg01, 0)))
10815 tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
10816 arg00, TREE_OPERAND (arg01, 1));
10817 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
10818 build_int_cst (TREE_TYPE (arg0), 1));
10819 return fold_build2_loc (loc, code, type,
10820 fold_convert_loc (loc, TREE_TYPE (arg1), tem),
10825 /* If this is an NE or EQ comparison of zero against the result of a
10826 signed MOD operation whose second operand is a power of 2, make
10827 the MOD operation unsigned since it is simpler and equivalent. */
10828 if (integer_zerop (arg1)
10829 && !TYPE_UNSIGNED (TREE_TYPE (arg0))
10830 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
10831 || TREE_CODE (arg0) == CEIL_MOD_EXPR
10832 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
10833 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
10834 && integer_pow2p (TREE_OPERAND (arg0, 1)))
10836 tree newtype = unsigned_type_for (TREE_TYPE (arg0));
10837 tree newmod = fold_build2_loc (loc, TREE_CODE (arg0), newtype,
10838 fold_convert_loc (loc, newtype,
10839 TREE_OPERAND (arg0, 0)),
10840 fold_convert_loc (loc, newtype,
10841 TREE_OPERAND (arg0, 1)));
10843 return fold_build2_loc (loc, code, type, newmod,
10844 fold_convert_loc (loc, newtype, arg1));
10847 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10848 C1 is a valid shift constant, and C2 is a power of two, i.e.
10850 if (TREE_CODE (arg0) == BIT_AND_EXPR
10851 && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
10852 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
10854 && integer_pow2p (TREE_OPERAND (arg0, 1))
10855 && integer_zerop (arg1))
10857 tree itype = TREE_TYPE (arg0);
10858 tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
10859 prec = TYPE_PRECISION (itype);
10861 /* Check for a valid shift count. */
10862 if (wi::ltu_p (arg001, prec))
10864 tree arg01 = TREE_OPERAND (arg0, 1);
10865 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10866 unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
10867 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10868 can be rewritten as (X & (C2 << C1)) != 0. */
10869 if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
10871 tem = fold_build2_loc (loc, LSHIFT_EXPR, itype, arg01, arg001);
10872 tem = fold_build2_loc (loc, BIT_AND_EXPR, itype, arg000, tem);
10873 return fold_build2_loc (loc, code, type, tem,
10874 fold_convert_loc (loc, itype, arg1));
10876 /* Otherwise, for signed (arithmetic) shifts,
10877 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10878 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10879 else if (!TYPE_UNSIGNED (itype))
10880 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
10881 arg000, build_int_cst (itype, 0));
10882 /* Otherwise, of unsigned (logical) shifts,
10883 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10884 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10886 return omit_one_operand_loc (loc, type,
10887 code == EQ_EXPR ? integer_one_node
10888 : integer_zero_node,
10893 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10894 Similarly for NE_EXPR. */
10895 if (TREE_CODE (arg0) == BIT_AND_EXPR
10896 && TREE_CODE (arg1) == INTEGER_CST
10897 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10899 tree notc = fold_build1_loc (loc, BIT_NOT_EXPR,
10900 TREE_TYPE (TREE_OPERAND (arg0, 1)),
10901 TREE_OPERAND (arg0, 1));
10903 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
10904 fold_convert_loc (loc, TREE_TYPE (arg0), arg1),
10906 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
10907 if (integer_nonzerop (dandnotc))
10908 return omit_one_operand_loc (loc, type, rslt, arg0);
10911 /* If this is a comparison of a field, we may be able to simplify it. */
10912 if ((TREE_CODE (arg0) == COMPONENT_REF
10913 || TREE_CODE (arg0) == BIT_FIELD_REF)
10914 /* Handle the constant case even without -O
10915 to make sure the warnings are given. */
10916 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
10918 t1 = optimize_bit_field_compare (loc, code, type, arg0, arg1);
10923 /* Optimize comparisons of strlen vs zero to a compare of the
10924 first character of the string vs zero. To wit,
10925 strlen(ptr) == 0 => *ptr == 0
10926 strlen(ptr) != 0 => *ptr != 0
10927 Other cases should reduce to one of these two (or a constant)
10928 due to the return value of strlen being unsigned. */
10929 if (TREE_CODE (arg0) == CALL_EXPR
10930 && integer_zerop (arg1))
10932 tree fndecl = get_callee_fndecl (arg0);
10935 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
10936 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
10937 && call_expr_nargs (arg0) == 1
10938 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
10940 tree iref = build_fold_indirect_ref_loc (loc,
10941 CALL_EXPR_ARG (arg0, 0));
10942 return fold_build2_loc (loc, code, type, iref,
10943 build_int_cst (TREE_TYPE (iref), 0));
10947 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10948 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10949 if (TREE_CODE (arg0) == RSHIFT_EXPR
10950 && integer_zerop (arg1)
10951 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10953 tree arg00 = TREE_OPERAND (arg0, 0);
10954 tree arg01 = TREE_OPERAND (arg0, 1);
10955 tree itype = TREE_TYPE (arg00);
10956 if (wi::eq_p (arg01, element_precision (itype) - 1))
10958 if (TYPE_UNSIGNED (itype))
10960 itype = signed_type_for (itype);
10961 arg00 = fold_convert_loc (loc, itype, arg00);
10963 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
10964 type, arg00, build_zero_cst (itype));
10968 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10969 (X & C) == 0 when C is a single bit. */
10970 if (TREE_CODE (arg0) == BIT_AND_EXPR
10971 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
10972 && integer_zerop (arg1)
10973 && integer_pow2p (TREE_OPERAND (arg0, 1)))
10975 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
10976 TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
10977 TREE_OPERAND (arg0, 1));
10978 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
10980 fold_convert_loc (loc, TREE_TYPE (arg0),
10984 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10985 constant C is a power of two, i.e. a single bit. */
10986 if (TREE_CODE (arg0) == BIT_XOR_EXPR
10987 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
10988 && integer_zerop (arg1)
10989 && integer_pow2p (TREE_OPERAND (arg0, 1))
10990 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10991 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10993 tree arg00 = TREE_OPERAND (arg0, 0);
10994 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10995 arg00, build_int_cst (TREE_TYPE (arg00), 0));
10998 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10999 when is C is a power of two, i.e. a single bit. */
11000 if (TREE_CODE (arg0) == BIT_AND_EXPR
11001 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
11002 && integer_zerop (arg1)
11003 && integer_pow2p (TREE_OPERAND (arg0, 1))
11004 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
11005 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
11007 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
11008 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg000),
11009 arg000, TREE_OPERAND (arg0, 1));
11010 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
11011 tem, build_int_cst (TREE_TYPE (tem), 0));
11014 if (integer_zerop (arg1)
11015 && tree_expr_nonzero_p (arg0))
11017 tree res = constant_boolean_node (code==NE_EXPR, type);
11018 return omit_one_operand_loc (loc, type, res, arg0);
11021 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
11022 if (TREE_CODE (arg0) == BIT_AND_EXPR
11023 && TREE_CODE (arg1) == BIT_AND_EXPR)
11025 tree arg00 = TREE_OPERAND (arg0, 0);
11026 tree arg01 = TREE_OPERAND (arg0, 1);
11027 tree arg10 = TREE_OPERAND (arg1, 0);
11028 tree arg11 = TREE_OPERAND (arg1, 1);
11029 tree itype = TREE_TYPE (arg0);
11031 if (operand_equal_p (arg01, arg11, 0))
11032 return fold_build2_loc (loc, code, type,
11033 fold_build2_loc (loc, BIT_AND_EXPR, itype,
11034 fold_build2_loc (loc,
11035 BIT_XOR_EXPR, itype,
11038 build_zero_cst (itype));
11040 if (operand_equal_p (arg01, arg10, 0))
11041 return fold_build2_loc (loc, code, type,
11042 fold_build2_loc (loc, BIT_AND_EXPR, itype,
11043 fold_build2_loc (loc,
11044 BIT_XOR_EXPR, itype,
11047 build_zero_cst (itype));
11049 if (operand_equal_p (arg00, arg11, 0))
11050 return fold_build2_loc (loc, code, type,
11051 fold_build2_loc (loc, BIT_AND_EXPR, itype,
11052 fold_build2_loc (loc,
11053 BIT_XOR_EXPR, itype,
11056 build_zero_cst (itype));
11058 if (operand_equal_p (arg00, arg10, 0))
11059 return fold_build2_loc (loc, code, type,
11060 fold_build2_loc (loc, BIT_AND_EXPR, itype,
11061 fold_build2_loc (loc,
11062 BIT_XOR_EXPR, itype,
11065 build_zero_cst (itype));
11068 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11069 && TREE_CODE (arg1) == BIT_XOR_EXPR)
11071 tree arg00 = TREE_OPERAND (arg0, 0);
11072 tree arg01 = TREE_OPERAND (arg0, 1);
11073 tree arg10 = TREE_OPERAND (arg1, 0);
11074 tree arg11 = TREE_OPERAND (arg1, 1);
11075 tree itype = TREE_TYPE (arg0);
11077 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
11078 operand_equal_p guarantees no side-effects so we don't need
11079 to use omit_one_operand on Z. */
11080 if (operand_equal_p (arg01, arg11, 0))
11081 return fold_build2_loc (loc, code, type, arg00,
11082 fold_convert_loc (loc, TREE_TYPE (arg00),
11084 if (operand_equal_p (arg01, arg10, 0))
11085 return fold_build2_loc (loc, code, type, arg00,
11086 fold_convert_loc (loc, TREE_TYPE (arg00),
11088 if (operand_equal_p (arg00, arg11, 0))
11089 return fold_build2_loc (loc, code, type, arg01,
11090 fold_convert_loc (loc, TREE_TYPE (arg01),
11092 if (operand_equal_p (arg00, arg10, 0))
11093 return fold_build2_loc (loc, code, type, arg01,
11094 fold_convert_loc (loc, TREE_TYPE (arg01),
11097 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
11098 if (TREE_CODE (arg01) == INTEGER_CST
11099 && TREE_CODE (arg11) == INTEGER_CST)
11101 tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg01,
11102 fold_convert_loc (loc, itype, arg11));
11103 tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg00, tem);
11104 return fold_build2_loc (loc, code, type, tem,
11105 fold_convert_loc (loc, itype, arg10));
11109 /* Attempt to simplify equality/inequality comparisons of complex
11110 values. Only lower the comparison if the result is known or
11111 can be simplified to a single scalar comparison. */
11112 if ((TREE_CODE (arg0) == COMPLEX_EXPR
11113 || TREE_CODE (arg0) == COMPLEX_CST)
11114 && (TREE_CODE (arg1) == COMPLEX_EXPR
11115 || TREE_CODE (arg1) == COMPLEX_CST))
11117 tree real0, imag0, real1, imag1;
11120 if (TREE_CODE (arg0) == COMPLEX_EXPR)
11122 real0 = TREE_OPERAND (arg0, 0);
11123 imag0 = TREE_OPERAND (arg0, 1);
11127 real0 = TREE_REALPART (arg0);
11128 imag0 = TREE_IMAGPART (arg0);
11131 if (TREE_CODE (arg1) == COMPLEX_EXPR)
11133 real1 = TREE_OPERAND (arg1, 0);
11134 imag1 = TREE_OPERAND (arg1, 1);
11138 real1 = TREE_REALPART (arg1);
11139 imag1 = TREE_IMAGPART (arg1);
11142 rcond = fold_binary_loc (loc, code, type, real0, real1);
11143 if (rcond && TREE_CODE (rcond) == INTEGER_CST)
11145 if (integer_zerop (rcond))
11147 if (code == EQ_EXPR)
11148 return omit_two_operands_loc (loc, type, boolean_false_node,
11150 return fold_build2_loc (loc, NE_EXPR, type, imag0, imag1);
11154 if (code == NE_EXPR)
11155 return omit_two_operands_loc (loc, type, boolean_true_node,
11157 return fold_build2_loc (loc, EQ_EXPR, type, imag0, imag1);
11161 icond = fold_binary_loc (loc, code, type, imag0, imag1);
11162 if (icond && TREE_CODE (icond) == INTEGER_CST)
11164 if (integer_zerop (icond))
11166 if (code == EQ_EXPR)
11167 return omit_two_operands_loc (loc, type, boolean_false_node,
11169 return fold_build2_loc (loc, NE_EXPR, type, real0, real1);
11173 if (code == NE_EXPR)
11174 return omit_two_operands_loc (loc, type, boolean_true_node,
11176 return fold_build2_loc (loc, EQ_EXPR, type, real0, real1);
11187 tem = fold_comparison (loc, code, type, op0, op1);
11188 if (tem != NULL_TREE)
11191 /* Transform comparisons of the form X +- C CMP X. */
11192 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
11193 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11194 && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
11195 && !HONOR_SNANS (arg0))
11196 || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11197 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
11199 tree arg01 = TREE_OPERAND (arg0, 1);
11200 enum tree_code code0 = TREE_CODE (arg0);
11203 if (TREE_CODE (arg01) == REAL_CST)
11204 is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
11206 is_positive = tree_int_cst_sgn (arg01);
11208 /* (X - c) > X becomes false. */
11209 if (code == GT_EXPR
11210 && ((code0 == MINUS_EXPR && is_positive >= 0)
11211 || (code0 == PLUS_EXPR && is_positive <= 0)))
11213 if (TREE_CODE (arg01) == INTEGER_CST
11214 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11215 fold_overflow_warning (("assuming signed overflow does not "
11216 "occur when assuming that (X - c) > X "
11217 "is always false"),
11218 WARN_STRICT_OVERFLOW_ALL);
11219 return constant_boolean_node (0, type);
11222 /* Likewise (X + c) < X becomes false. */
11223 if (code == LT_EXPR
11224 && ((code0 == PLUS_EXPR && is_positive >= 0)
11225 || (code0 == MINUS_EXPR && is_positive <= 0)))
11227 if (TREE_CODE (arg01) == INTEGER_CST
11228 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11229 fold_overflow_warning (("assuming signed overflow does not "
11230 "occur when assuming that "
11231 "(X + c) < X is always false"),
11232 WARN_STRICT_OVERFLOW_ALL);
11233 return constant_boolean_node (0, type);
11236 /* Convert (X - c) <= X to true. */
11237 if (!HONOR_NANS (arg1)
11239 && ((code0 == MINUS_EXPR && is_positive >= 0)
11240 || (code0 == PLUS_EXPR && is_positive <= 0)))
11242 if (TREE_CODE (arg01) == INTEGER_CST
11243 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11244 fold_overflow_warning (("assuming signed overflow does not "
11245 "occur when assuming that "
11246 "(X - c) <= X is always true"),
11247 WARN_STRICT_OVERFLOW_ALL);
11248 return constant_boolean_node (1, type);
11251 /* Convert (X + c) >= X to true. */
11252 if (!HONOR_NANS (arg1)
11254 && ((code0 == PLUS_EXPR && is_positive >= 0)
11255 || (code0 == MINUS_EXPR && is_positive <= 0)))
11257 if (TREE_CODE (arg01) == INTEGER_CST
11258 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11259 fold_overflow_warning (("assuming signed overflow does not "
11260 "occur when assuming that "
11261 "(X + c) >= X is always true"),
11262 WARN_STRICT_OVERFLOW_ALL);
11263 return constant_boolean_node (1, type);
11266 if (TREE_CODE (arg01) == INTEGER_CST)
11268 /* Convert X + c > X and X - c < X to true for integers. */
11269 if (code == GT_EXPR
11270 && ((code0 == PLUS_EXPR && is_positive > 0)
11271 || (code0 == MINUS_EXPR && is_positive < 0)))
11273 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11274 fold_overflow_warning (("assuming signed overflow does "
11275 "not occur when assuming that "
11276 "(X + c) > X is always true"),
11277 WARN_STRICT_OVERFLOW_ALL);
11278 return constant_boolean_node (1, type);
11281 if (code == LT_EXPR
11282 && ((code0 == MINUS_EXPR && is_positive > 0)
11283 || (code0 == PLUS_EXPR && is_positive < 0)))
11285 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11286 fold_overflow_warning (("assuming signed overflow does "
11287 "not occur when assuming that "
11288 "(X - c) < X is always true"),
11289 WARN_STRICT_OVERFLOW_ALL);
11290 return constant_boolean_node (1, type);
11293 /* Convert X + c <= X and X - c >= X to false for integers. */
11294 if (code == LE_EXPR
11295 && ((code0 == PLUS_EXPR && is_positive > 0)
11296 || (code0 == MINUS_EXPR && is_positive < 0)))
11298 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11299 fold_overflow_warning (("assuming signed overflow does "
11300 "not occur when assuming that "
11301 "(X + c) <= X is always false"),
11302 WARN_STRICT_OVERFLOW_ALL);
11303 return constant_boolean_node (0, type);
11306 if (code == GE_EXPR
11307 && ((code0 == MINUS_EXPR && is_positive > 0)
11308 || (code0 == PLUS_EXPR && is_positive < 0)))
11310 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11311 fold_overflow_warning (("assuming signed overflow does "
11312 "not occur when assuming that "
11313 "(X - c) >= X is always false"),
11314 WARN_STRICT_OVERFLOW_ALL);
11315 return constant_boolean_node (0, type);
11320 /* If we are comparing an ABS_EXPR with a constant, we can
11321 convert all the cases into explicit comparisons, but they may
11322 well not be faster than doing the ABS and one comparison.
11323 But ABS (X) <= C is a range comparison, which becomes a subtraction
11324 and a comparison, and is probably faster. */
11325 if (code == LE_EXPR
11326 && TREE_CODE (arg1) == INTEGER_CST
11327 && TREE_CODE (arg0) == ABS_EXPR
11328 && ! TREE_SIDE_EFFECTS (arg0)
11329 && (0 != (tem = negate_expr (arg1)))
11330 && TREE_CODE (tem) == INTEGER_CST
11331 && !TREE_OVERFLOW (tem))
11332 return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
11333 build2 (GE_EXPR, type,
11334 TREE_OPERAND (arg0, 0), tem),
11335 build2 (LE_EXPR, type,
11336 TREE_OPERAND (arg0, 0), arg1));
11338 /* Convert ABS_EXPR<x> >= 0 to true. */
11339 strict_overflow_p = false;
11340 if (code == GE_EXPR
11341 && (integer_zerop (arg1)
11342 || (! HONOR_NANS (arg0)
11343 && real_zerop (arg1)))
11344 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
11346 if (strict_overflow_p)
11347 fold_overflow_warning (("assuming signed overflow does not occur "
11348 "when simplifying comparison of "
11349 "absolute value and zero"),
11350 WARN_STRICT_OVERFLOW_CONDITIONAL);
11351 return omit_one_operand_loc (loc, type,
11352 constant_boolean_node (true, type),
11356 /* Convert ABS_EXPR<x> < 0 to false. */
11357 strict_overflow_p = false;
11358 if (code == LT_EXPR
11359 && (integer_zerop (arg1) || real_zerop (arg1))
11360 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
11362 if (strict_overflow_p)
11363 fold_overflow_warning (("assuming signed overflow does not occur "
11364 "when simplifying comparison of "
11365 "absolute value and zero"),
11366 WARN_STRICT_OVERFLOW_CONDITIONAL);
11367 return omit_one_operand_loc (loc, type,
11368 constant_boolean_node (false, type),
11372 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11373 and similarly for >= into !=. */
11374 if ((code == LT_EXPR || code == GE_EXPR)
11375 && TYPE_UNSIGNED (TREE_TYPE (arg0))
11376 && TREE_CODE (arg1) == LSHIFT_EXPR
11377 && integer_onep (TREE_OPERAND (arg1, 0)))
11378 return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
11379 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
11380 TREE_OPERAND (arg1, 1)),
11381 build_zero_cst (TREE_TYPE (arg0)));
11383 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11384 otherwise Y might be >= # of bits in X's type and thus e.g.
11385 (unsigned char) (1 << Y) for Y 15 might be 0.
11386 If the cast is widening, then 1 << Y should have unsigned type,
11387 otherwise if Y is number of bits in the signed shift type minus 1,
11388 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11389 31 might be 0xffffffff80000000. */
11390 if ((code == LT_EXPR || code == GE_EXPR)
11391 && TYPE_UNSIGNED (TREE_TYPE (arg0))
11392 && CONVERT_EXPR_P (arg1)
11393 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
11394 && (element_precision (TREE_TYPE (arg1))
11395 >= element_precision (TREE_TYPE (TREE_OPERAND (arg1, 0))))
11396 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0)))
11397 || (element_precision (TREE_TYPE (arg1))
11398 == element_precision (TREE_TYPE (TREE_OPERAND (arg1, 0)))))
11399 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
11401 tem = build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
11402 TREE_OPERAND (TREE_OPERAND (arg1, 0), 1));
11403 return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
11404 fold_convert_loc (loc, TREE_TYPE (arg0), tem),
11405 build_zero_cst (TREE_TYPE (arg0)));
11410 case UNORDERED_EXPR:
11418 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11420 tree targ0 = strip_float_extensions (arg0);
11421 tree targ1 = strip_float_extensions (arg1);
11422 tree newtype = TREE_TYPE (targ0);
11424 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
11425 newtype = TREE_TYPE (targ1);
11427 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
11428 return fold_build2_loc (loc, code, type,
11429 fold_convert_loc (loc, newtype, targ0),
11430 fold_convert_loc (loc, newtype, targ1));
11435 case COMPOUND_EXPR:
11436 /* When pedantic, a compound expression can be neither an lvalue
11437 nor an integer constant expression. */
11438 if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
11440 /* Don't let (0, 0) be null pointer constant. */
11441 tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
11442 : fold_convert_loc (loc, type, arg1);
11443 return pedantic_non_lvalue_loc (loc, tem);
11446 /* An ASSERT_EXPR should never be passed to fold_binary. */
11447 gcc_unreachable ();
11451 } /* switch (code) */
11454 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11455 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
11459 contains_label_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
11461 switch (TREE_CODE (*tp))
11467 *walk_subtrees = 0;
11469 /* ... fall through ... */
11476 /* Return whether the sub-tree ST contains a label which is accessible from
11477 outside the sub-tree. */
11480 contains_label_p (tree st)
11483 (walk_tree_without_duplicates (&st, contains_label_1 , NULL) != NULL_TREE);
11486 /* Fold a ternary expression of code CODE and type TYPE with operands
11487 OP0, OP1, and OP2. Return the folded expression if folding is
11488 successful. Otherwise, return NULL_TREE. */
11491 fold_ternary_loc (location_t loc, enum tree_code code, tree type,
11492 tree op0, tree op1, tree op2)
11495 tree arg0 = NULL_TREE, arg1 = NULL_TREE, arg2 = NULL_TREE;
11496 enum tree_code_class kind = TREE_CODE_CLASS (code);
11498 gcc_assert (IS_EXPR_CODE_CLASS (kind)
11499 && TREE_CODE_LENGTH (code) == 3);
11501 /* If this is a commutative operation, and OP0 is a constant, move it
11502 to OP1 to reduce the number of tests below. */
11503 if (commutative_ternary_tree_code (code)
11504 && tree_swap_operands_p (op0, op1, true))
11505 return fold_build3_loc (loc, code, type, op1, op0, op2);
11507 tem = generic_simplify (loc, code, type, op0, op1, op2);
11511 /* Strip any conversions that don't change the mode. This is safe
11512 for every expression, except for a comparison expression because
11513 its signedness is derived from its operands. So, in the latter
11514 case, only strip conversions that don't change the signedness.
11516 Note that this is done as an internal manipulation within the
11517 constant folder, in order to find the simplest representation of
11518 the arguments so that their form can be studied. In any cases,
11519 the appropriate type conversions should be put back in the tree
11520 that will get out of the constant folder. */
11541 case COMPONENT_REF:
11542 if (TREE_CODE (arg0) == CONSTRUCTOR
11543 && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
11545 unsigned HOST_WIDE_INT idx;
11547 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
11554 case VEC_COND_EXPR:
11555 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11556 so all simple results must be passed through pedantic_non_lvalue. */
11557 if (TREE_CODE (arg0) == INTEGER_CST)
11559 tree unused_op = integer_zerop (arg0) ? op1 : op2;
11560 tem = integer_zerop (arg0) ? op2 : op1;
11561 /* Only optimize constant conditions when the selected branch
11562 has the same type as the COND_EXPR. This avoids optimizing
11563 away "c ? x : throw", where the throw has a void type.
11564 Avoid throwing away that operand which contains label. */
11565 if ((!TREE_SIDE_EFFECTS (unused_op)
11566 || !contains_label_p (unused_op))
11567 && (! VOID_TYPE_P (TREE_TYPE (tem))
11568 || VOID_TYPE_P (type)))
11569 return pedantic_non_lvalue_loc (loc, tem);
11572 else if (TREE_CODE (arg0) == VECTOR_CST)
11574 if ((TREE_CODE (arg1) == VECTOR_CST
11575 || TREE_CODE (arg1) == CONSTRUCTOR)
11576 && (TREE_CODE (arg2) == VECTOR_CST
11577 || TREE_CODE (arg2) == CONSTRUCTOR))
11579 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
11580 unsigned char *sel = XALLOCAVEC (unsigned char, nelts);
11581 gcc_assert (nelts == VECTOR_CST_NELTS (arg0));
11582 for (i = 0; i < nelts; i++)
11584 tree val = VECTOR_CST_ELT (arg0, i);
11585 if (integer_all_onesp (val))
11587 else if (integer_zerop (val))
11588 sel[i] = nelts + i;
11589 else /* Currently unreachable. */
11592 tree t = fold_vec_perm (type, arg1, arg2, sel);
11593 if (t != NULL_TREE)
11598 /* If we have A op B ? A : C, we may be able to convert this to a
11599 simpler expression, depending on the operation and the values
11600 of B and C. Signed zeros prevent all of these transformations,
11601 for reasons given above each one.
11603 Also try swapping the arguments and inverting the conditional. */
11604 if (COMPARISON_CLASS_P (arg0)
11605 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11606 arg1, TREE_OPERAND (arg0, 1))
11607 && !HONOR_SIGNED_ZEROS (element_mode (arg1)))
11609 tem = fold_cond_expr_with_comparison (loc, type, arg0, op1, op2);
11614 if (COMPARISON_CLASS_P (arg0)
11615 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11617 TREE_OPERAND (arg0, 1))
11618 && !HONOR_SIGNED_ZEROS (element_mode (op2)))
11620 location_t loc0 = expr_location_or (arg0, loc);
11621 tem = fold_invert_truthvalue (loc0, arg0);
11622 if (tem && COMPARISON_CLASS_P (tem))
11624 tem = fold_cond_expr_with_comparison (loc, type, tem, op2, op1);
11630 /* If the second operand is simpler than the third, swap them
11631 since that produces better jump optimization results. */
11632 if (truth_value_p (TREE_CODE (arg0))
11633 && tree_swap_operands_p (op1, op2, false))
11635 location_t loc0 = expr_location_or (arg0, loc);
11636 /* See if this can be inverted. If it can't, possibly because
11637 it was a floating-point inequality comparison, don't do
11639 tem = fold_invert_truthvalue (loc0, arg0);
11641 return fold_build3_loc (loc, code, type, tem, op2, op1);
11644 /* Convert A ? 1 : 0 to simply A. */
11645 if ((code == VEC_COND_EXPR ? integer_all_onesp (op1)
11646 : (integer_onep (op1)
11647 && !VECTOR_TYPE_P (type)))
11648 && integer_zerop (op2)
11649 /* If we try to convert OP0 to our type, the
11650 call to fold will try to move the conversion inside
11651 a COND, which will recurse. In that case, the COND_EXPR
11652 is probably the best choice, so leave it alone. */
11653 && type == TREE_TYPE (arg0))
11654 return pedantic_non_lvalue_loc (loc, arg0);
11656 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11657 over COND_EXPR in cases such as floating point comparisons. */
11658 if (integer_zerop (op1)
11659 && code == COND_EXPR
11660 && integer_onep (op2)
11661 && !VECTOR_TYPE_P (type)
11662 && truth_value_p (TREE_CODE (arg0)))
11663 return pedantic_non_lvalue_loc (loc,
11664 fold_convert_loc (loc, type,
11665 invert_truthvalue_loc (loc,
11668 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11669 if (TREE_CODE (arg0) == LT_EXPR
11670 && integer_zerop (TREE_OPERAND (arg0, 1))
11671 && integer_zerop (op2)
11672 && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
11674 /* sign_bit_p looks through both zero and sign extensions,
11675 but for this optimization only sign extensions are
11677 tree tem2 = TREE_OPERAND (arg0, 0);
11678 while (tem != tem2)
11680 if (TREE_CODE (tem2) != NOP_EXPR
11681 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2, 0))))
11686 tem2 = TREE_OPERAND (tem2, 0);
11688 /* sign_bit_p only checks ARG1 bits within A's precision.
11689 If <sign bit of A> has wider type than A, bits outside
11690 of A's precision in <sign bit of A> need to be checked.
11691 If they are all 0, this optimization needs to be done
11692 in unsigned A's type, if they are all 1 in signed A's type,
11693 otherwise this can't be done. */
11695 && TYPE_PRECISION (TREE_TYPE (tem))
11696 < TYPE_PRECISION (TREE_TYPE (arg1))
11697 && TYPE_PRECISION (TREE_TYPE (tem))
11698 < TYPE_PRECISION (type))
11700 int inner_width, outer_width;
11703 inner_width = TYPE_PRECISION (TREE_TYPE (tem));
11704 outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
11705 if (outer_width > TYPE_PRECISION (type))
11706 outer_width = TYPE_PRECISION (type);
11708 wide_int mask = wi::shifted_mask
11709 (inner_width, outer_width - inner_width, false,
11710 TYPE_PRECISION (TREE_TYPE (arg1)));
11712 wide_int common = mask & arg1;
11713 if (common == mask)
11715 tem_type = signed_type_for (TREE_TYPE (tem));
11716 tem = fold_convert_loc (loc, tem_type, tem);
11718 else if (common == 0)
11720 tem_type = unsigned_type_for (TREE_TYPE (tem));
11721 tem = fold_convert_loc (loc, tem_type, tem);
11729 fold_convert_loc (loc, type,
11730 fold_build2_loc (loc, BIT_AND_EXPR,
11731 TREE_TYPE (tem), tem,
11732 fold_convert_loc (loc,
11737 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11738 already handled above. */
11739 if (TREE_CODE (arg0) == BIT_AND_EXPR
11740 && integer_onep (TREE_OPERAND (arg0, 1))
11741 && integer_zerop (op2)
11742 && integer_pow2p (arg1))
11744 tree tem = TREE_OPERAND (arg0, 0);
11746 if (TREE_CODE (tem) == RSHIFT_EXPR
11747 && tree_fits_uhwi_p (TREE_OPERAND (tem, 1))
11748 && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
11749 tree_to_uhwi (TREE_OPERAND (tem, 1)))
11750 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11751 TREE_OPERAND (tem, 0), arg1);
11754 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11755 is probably obsolete because the first operand should be a
11756 truth value (that's why we have the two cases above), but let's
11757 leave it in until we can confirm this for all front-ends. */
11758 if (integer_zerop (op2)
11759 && TREE_CODE (arg0) == NE_EXPR
11760 && integer_zerop (TREE_OPERAND (arg0, 1))
11761 && integer_pow2p (arg1)
11762 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
11763 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
11764 arg1, OEP_ONLY_CONST))
11765 return pedantic_non_lvalue_loc (loc,
11766 fold_convert_loc (loc, type,
11767 TREE_OPERAND (arg0, 0)));
11769 /* Disable the transformations below for vectors, since
11770 fold_binary_op_with_conditional_arg may undo them immediately,
11771 yielding an infinite loop. */
11772 if (code == VEC_COND_EXPR)
11775 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11776 if (integer_zerop (op2)
11777 && truth_value_p (TREE_CODE (arg0))
11778 && truth_value_p (TREE_CODE (arg1))
11779 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
11780 return fold_build2_loc (loc, code == VEC_COND_EXPR ? BIT_AND_EXPR
11781 : TRUTH_ANDIF_EXPR,
11782 type, fold_convert_loc (loc, type, arg0), arg1);
11784 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11785 if (code == VEC_COND_EXPR ? integer_all_onesp (op2) : integer_onep (op2)
11786 && truth_value_p (TREE_CODE (arg0))
11787 && truth_value_p (TREE_CODE (arg1))
11788 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
11790 location_t loc0 = expr_location_or (arg0, loc);
11791 /* Only perform transformation if ARG0 is easily inverted. */
11792 tem = fold_invert_truthvalue (loc0, arg0);
11794 return fold_build2_loc (loc, code == VEC_COND_EXPR
11797 type, fold_convert_loc (loc, type, tem),
11801 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11802 if (integer_zerop (arg1)
11803 && truth_value_p (TREE_CODE (arg0))
11804 && truth_value_p (TREE_CODE (op2))
11805 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
11807 location_t loc0 = expr_location_or (arg0, loc);
11808 /* Only perform transformation if ARG0 is easily inverted. */
11809 tem = fold_invert_truthvalue (loc0, arg0);
11811 return fold_build2_loc (loc, code == VEC_COND_EXPR
11812 ? BIT_AND_EXPR : TRUTH_ANDIF_EXPR,
11813 type, fold_convert_loc (loc, type, tem),
11817 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11818 if (code == VEC_COND_EXPR ? integer_all_onesp (arg1) : integer_onep (arg1)
11819 && truth_value_p (TREE_CODE (arg0))
11820 && truth_value_p (TREE_CODE (op2))
11821 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
11822 return fold_build2_loc (loc, code == VEC_COND_EXPR
11823 ? BIT_IOR_EXPR : TRUTH_ORIF_EXPR,
11824 type, fold_convert_loc (loc, type, arg0), op2);
11829 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11830 of fold_ternary on them. */
11831 gcc_unreachable ();
11833 case BIT_FIELD_REF:
11834 if ((TREE_CODE (arg0) == VECTOR_CST
11835 || (TREE_CODE (arg0) == CONSTRUCTOR
11836 && TREE_CODE (TREE_TYPE (arg0)) == VECTOR_TYPE))
11837 && (type == TREE_TYPE (TREE_TYPE (arg0))
11838 || (TREE_CODE (type) == VECTOR_TYPE
11839 && TREE_TYPE (type) == TREE_TYPE (TREE_TYPE (arg0)))))
11841 tree eltype = TREE_TYPE (TREE_TYPE (arg0));
11842 unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
11843 unsigned HOST_WIDE_INT n = tree_to_uhwi (arg1);
11844 unsigned HOST_WIDE_INT idx = tree_to_uhwi (op2);
11847 && (idx % width) == 0
11848 && (n % width) == 0
11849 && ((idx + n) / width) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
11854 if (TREE_CODE (arg0) == VECTOR_CST)
11857 return VECTOR_CST_ELT (arg0, idx);
11859 tree *vals = XALLOCAVEC (tree, n);
11860 for (unsigned i = 0; i < n; ++i)
11861 vals[i] = VECTOR_CST_ELT (arg0, idx + i);
11862 return build_vector (type, vals);
11865 /* Constructor elements can be subvectors. */
11866 unsigned HOST_WIDE_INT k = 1;
11867 if (CONSTRUCTOR_NELTS (arg0) != 0)
11869 tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (arg0, 0)->value);
11870 if (TREE_CODE (cons_elem) == VECTOR_TYPE)
11871 k = TYPE_VECTOR_SUBPARTS (cons_elem);
11874 /* We keep an exact subset of the constructor elements. */
11875 if ((idx % k) == 0 && (n % k) == 0)
11877 if (CONSTRUCTOR_NELTS (arg0) == 0)
11878 return build_constructor (type, NULL);
11883 if (idx < CONSTRUCTOR_NELTS (arg0))
11884 return CONSTRUCTOR_ELT (arg0, idx)->value;
11885 return build_zero_cst (type);
11888 vec<constructor_elt, va_gc> *vals;
11889 vec_alloc (vals, n);
11890 for (unsigned i = 0;
11891 i < n && idx + i < CONSTRUCTOR_NELTS (arg0);
11893 CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE,
11895 (arg0, idx + i)->value);
11896 return build_constructor (type, vals);
11898 /* The bitfield references a single constructor element. */
11899 else if (idx + n <= (idx / k + 1) * k)
11901 if (CONSTRUCTOR_NELTS (arg0) <= idx / k)
11902 return build_zero_cst (type);
11904 return CONSTRUCTOR_ELT (arg0, idx / k)->value;
11906 return fold_build3_loc (loc, code, type,
11907 CONSTRUCTOR_ELT (arg0, idx / k)->value, op1,
11908 build_int_cst (TREE_TYPE (op2), (idx % k) * width));
11913 /* A bit-field-ref that referenced the full argument can be stripped. */
11914 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
11915 && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_to_uhwi (arg1)
11916 && integer_zerop (op2))
11917 return fold_convert_loc (loc, type, arg0);
11919 /* On constants we can use native encode/interpret to constant
11920 fold (nearly) all BIT_FIELD_REFs. */
11921 if (CONSTANT_CLASS_P (arg0)
11922 && can_native_interpret_type_p (type)
11923 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0)))
11924 /* This limitation should not be necessary, we just need to
11925 round this up to mode size. */
11926 && tree_to_uhwi (op1) % BITS_PER_UNIT == 0
11927 /* Need bit-shifting of the buffer to relax the following. */
11928 && tree_to_uhwi (op2) % BITS_PER_UNIT == 0)
11930 unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (op2);
11931 unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (op1);
11932 unsigned HOST_WIDE_INT clen;
11933 clen = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0)));
11934 /* ??? We cannot tell native_encode_expr to start at
11935 some random byte only. So limit us to a reasonable amount
11939 unsigned char *b = XALLOCAVEC (unsigned char, clen);
11940 unsigned HOST_WIDE_INT len = native_encode_expr (arg0, b, clen);
11942 && len * BITS_PER_UNIT >= bitpos + bitsize)
11944 tree v = native_interpret_expr (type,
11945 b + bitpos / BITS_PER_UNIT,
11946 bitsize / BITS_PER_UNIT);
11956 /* For integers we can decompose the FMA if possible. */
11957 if (TREE_CODE (arg0) == INTEGER_CST
11958 && TREE_CODE (arg1) == INTEGER_CST)
11959 return fold_build2_loc (loc, PLUS_EXPR, type,
11960 const_binop (MULT_EXPR, arg0, arg1), arg2);
11961 if (integer_zerop (arg2))
11962 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
11964 return fold_fma (loc, type, arg0, arg1, arg2);
11966 case VEC_PERM_EXPR:
11967 if (TREE_CODE (arg2) == VECTOR_CST)
11969 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i, mask, mask2;
11970 unsigned char *sel = XALLOCAVEC (unsigned char, 2 * nelts);
11971 unsigned char *sel2 = sel + nelts;
11972 bool need_mask_canon = false;
11973 bool need_mask_canon2 = false;
11974 bool all_in_vec0 = true;
11975 bool all_in_vec1 = true;
11976 bool maybe_identity = true;
11977 bool single_arg = (op0 == op1);
11978 bool changed = false;
11980 mask2 = 2 * nelts - 1;
11981 mask = single_arg ? (nelts - 1) : mask2;
11982 gcc_assert (nelts == VECTOR_CST_NELTS (arg2));
11983 for (i = 0; i < nelts; i++)
11985 tree val = VECTOR_CST_ELT (arg2, i);
11986 if (TREE_CODE (val) != INTEGER_CST)
11989 /* Make sure that the perm value is in an acceptable
11992 need_mask_canon |= wi::gtu_p (t, mask);
11993 need_mask_canon2 |= wi::gtu_p (t, mask2);
11994 sel[i] = t.to_uhwi () & mask;
11995 sel2[i] = t.to_uhwi () & mask2;
11997 if (sel[i] < nelts)
11998 all_in_vec1 = false;
12000 all_in_vec0 = false;
12002 if ((sel[i] & (nelts-1)) != i)
12003 maybe_identity = false;
12006 if (maybe_identity)
12016 else if (all_in_vec1)
12019 for (i = 0; i < nelts; i++)
12021 need_mask_canon = true;
12024 if ((TREE_CODE (op0) == VECTOR_CST
12025 || TREE_CODE (op0) == CONSTRUCTOR)
12026 && (TREE_CODE (op1) == VECTOR_CST
12027 || TREE_CODE (op1) == CONSTRUCTOR))
12029 tree t = fold_vec_perm (type, op0, op1, sel);
12030 if (t != NULL_TREE)
12034 if (op0 == op1 && !single_arg)
12037 /* Some targets are deficient and fail to expand a single
12038 argument permutation while still allowing an equivalent
12039 2-argument version. */
12040 if (need_mask_canon && arg2 == op2
12041 && !can_vec_perm_p (TYPE_MODE (type), false, sel)
12042 && can_vec_perm_p (TYPE_MODE (type), false, sel2))
12044 need_mask_canon = need_mask_canon2;
12048 if (need_mask_canon && arg2 == op2)
12050 tree *tsel = XALLOCAVEC (tree, nelts);
12051 tree eltype = TREE_TYPE (TREE_TYPE (arg2));
12052 for (i = 0; i < nelts; i++)
12053 tsel[i] = build_int_cst (eltype, sel[i]);
12054 op2 = build_vector (TREE_TYPE (arg2), tsel);
12059 return build3_loc (loc, VEC_PERM_EXPR, type, op0, op1, op2);
12065 } /* switch (code) */
12068 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
12069 of an array (or vector). */
12072 get_array_ctor_element_at_index (tree ctor, offset_int access_index)
12074 tree index_type = NULL_TREE;
12075 offset_int low_bound = 0;
12077 if (TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE)
12079 tree domain_type = TYPE_DOMAIN (TREE_TYPE (ctor));
12080 if (domain_type && TYPE_MIN_VALUE (domain_type))
12082 /* Static constructors for variably sized objects makes no sense. */
12083 gcc_assert (TREE_CODE (TYPE_MIN_VALUE (domain_type)) == INTEGER_CST);
12084 index_type = TREE_TYPE (TYPE_MIN_VALUE (domain_type));
12085 low_bound = wi::to_offset (TYPE_MIN_VALUE (domain_type));
12090 access_index = wi::ext (access_index, TYPE_PRECISION (index_type),
12091 TYPE_SIGN (index_type));
12093 offset_int index = low_bound - 1;
12095 index = wi::ext (index, TYPE_PRECISION (index_type),
12096 TYPE_SIGN (index_type));
12098 offset_int max_index;
12099 unsigned HOST_WIDE_INT cnt;
12102 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield, cval)
12104 /* Array constructor might explicitly set index, or specify a range,
12105 or leave index NULL meaning that it is next index after previous
12109 if (TREE_CODE (cfield) == INTEGER_CST)
12110 max_index = index = wi::to_offset (cfield);
12113 gcc_assert (TREE_CODE (cfield) == RANGE_EXPR);
12114 index = wi::to_offset (TREE_OPERAND (cfield, 0));
12115 max_index = wi::to_offset (TREE_OPERAND (cfield, 1));
12122 index = wi::ext (index, TYPE_PRECISION (index_type),
12123 TYPE_SIGN (index_type));
12127 /* Do we have match? */
12128 if (wi::cmpu (access_index, index) >= 0
12129 && wi::cmpu (access_index, max_index) <= 0)
12135 /* Perform constant folding and related simplification of EXPR.
12136 The related simplifications include x*1 => x, x*0 => 0, etc.,
12137 and application of the associative law.
12138 NOP_EXPR conversions may be removed freely (as long as we
12139 are careful not to change the type of the overall expression).
12140 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
12141 but we can constant-fold them if they have constant operands. */
12143 #ifdef ENABLE_FOLD_CHECKING
12144 # define fold(x) fold_1 (x)
12145 static tree fold_1 (tree);
12151 const tree t = expr;
12152 enum tree_code code = TREE_CODE (t);
12153 enum tree_code_class kind = TREE_CODE_CLASS (code);
12155 location_t loc = EXPR_LOCATION (expr);
12157 /* Return right away if a constant. */
12158 if (kind == tcc_constant)
12161 /* CALL_EXPR-like objects with variable numbers of operands are
12162 treated specially. */
12163 if (kind == tcc_vl_exp)
12165 if (code == CALL_EXPR)
12167 tem = fold_call_expr (loc, expr, false);
12168 return tem ? tem : expr;
12173 if (IS_EXPR_CODE_CLASS (kind))
12175 tree type = TREE_TYPE (t);
12176 tree op0, op1, op2;
12178 switch (TREE_CODE_LENGTH (code))
12181 op0 = TREE_OPERAND (t, 0);
12182 tem = fold_unary_loc (loc, code, type, op0);
12183 return tem ? tem : expr;
12185 op0 = TREE_OPERAND (t, 0);
12186 op1 = TREE_OPERAND (t, 1);
12187 tem = fold_binary_loc (loc, code, type, op0, op1);
12188 return tem ? tem : expr;
12190 op0 = TREE_OPERAND (t, 0);
12191 op1 = TREE_OPERAND (t, 1);
12192 op2 = TREE_OPERAND (t, 2);
12193 tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
12194 return tem ? tem : expr;
12204 tree op0 = TREE_OPERAND (t, 0);
12205 tree op1 = TREE_OPERAND (t, 1);
12207 if (TREE_CODE (op1) == INTEGER_CST
12208 && TREE_CODE (op0) == CONSTRUCTOR
12209 && ! type_contains_placeholder_p (TREE_TYPE (op0)))
12211 tree val = get_array_ctor_element_at_index (op0,
12212 wi::to_offset (op1));
12220 /* Return a VECTOR_CST if possible. */
12223 tree type = TREE_TYPE (t);
12224 if (TREE_CODE (type) != VECTOR_TYPE)
12229 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), i, val)
12230 if (! CONSTANT_CLASS_P (val))
12233 return build_vector_from_ctor (type, CONSTRUCTOR_ELTS (t));
12237 return fold (DECL_INITIAL (t));
12241 } /* switch (code) */
12244 #ifdef ENABLE_FOLD_CHECKING
12247 static void fold_checksum_tree (const_tree, struct md5_ctx *,
12248 hash_table<nofree_ptr_hash<const tree_node> > *);
12249 static void fold_check_failed (const_tree, const_tree);
12250 void print_fold_checksum (const_tree);
12252 /* When --enable-checking=fold, compute a digest of expr before
12253 and after actual fold call to see if fold did not accidentally
12254 change original expr. */
12260 struct md5_ctx ctx;
12261 unsigned char checksum_before[16], checksum_after[16];
12262 hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12264 md5_init_ctx (&ctx);
12265 fold_checksum_tree (expr, &ctx, &ht);
12266 md5_finish_ctx (&ctx, checksum_before);
12269 ret = fold_1 (expr);
12271 md5_init_ctx (&ctx);
12272 fold_checksum_tree (expr, &ctx, &ht);
12273 md5_finish_ctx (&ctx, checksum_after);
12275 if (memcmp (checksum_before, checksum_after, 16))
12276 fold_check_failed (expr, ret);
12282 print_fold_checksum (const_tree expr)
12284 struct md5_ctx ctx;
12285 unsigned char checksum[16], cnt;
12286 hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12288 md5_init_ctx (&ctx);
12289 fold_checksum_tree (expr, &ctx, &ht);
12290 md5_finish_ctx (&ctx, checksum);
12291 for (cnt = 0; cnt < 16; ++cnt)
12292 fprintf (stderr, "%02x", checksum[cnt]);
12293 putc ('\n', stderr);
12297 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
12299 internal_error ("fold check: original tree changed by fold");
12303 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx,
12304 hash_table<nofree_ptr_hash <const tree_node> > *ht)
12306 const tree_node **slot;
12307 enum tree_code code;
12308 union tree_node buf;
12314 slot = ht->find_slot (expr, INSERT);
12318 code = TREE_CODE (expr);
12319 if (TREE_CODE_CLASS (code) == tcc_declaration
12320 && HAS_DECL_ASSEMBLER_NAME_P (expr))
12322 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
12323 memcpy ((char *) &buf, expr, tree_size (expr));
12324 SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
12325 buf.decl_with_vis.symtab_node = NULL;
12326 expr = (tree) &buf;
12328 else if (TREE_CODE_CLASS (code) == tcc_type
12329 && (TYPE_POINTER_TO (expr)
12330 || TYPE_REFERENCE_TO (expr)
12331 || TYPE_CACHED_VALUES_P (expr)
12332 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
12333 || TYPE_NEXT_VARIANT (expr)
12334 || TYPE_ALIAS_SET_KNOWN_P (expr)))
12336 /* Allow these fields to be modified. */
12338 memcpy ((char *) &buf, expr, tree_size (expr));
12339 expr = tmp = (tree) &buf;
12340 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
12341 TYPE_POINTER_TO (tmp) = NULL;
12342 TYPE_REFERENCE_TO (tmp) = NULL;
12343 TYPE_NEXT_VARIANT (tmp) = NULL;
12344 TYPE_ALIAS_SET (tmp) = -1;
12345 if (TYPE_CACHED_VALUES_P (tmp))
12347 TYPE_CACHED_VALUES_P (tmp) = 0;
12348 TYPE_CACHED_VALUES (tmp) = NULL;
12351 md5_process_bytes (expr, tree_size (expr), ctx);
12352 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
12353 fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
12354 if (TREE_CODE_CLASS (code) != tcc_type
12355 && TREE_CODE_CLASS (code) != tcc_declaration
12356 && code != TREE_LIST
12357 && code != SSA_NAME
12358 && CODE_CONTAINS_STRUCT (code, TS_COMMON))
12359 fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
12360 switch (TREE_CODE_CLASS (code))
12366 md5_process_bytes (TREE_STRING_POINTER (expr),
12367 TREE_STRING_LENGTH (expr), ctx);
12370 fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
12371 fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
12374 for (i = 0; i < (int) VECTOR_CST_NELTS (expr); ++i)
12375 fold_checksum_tree (VECTOR_CST_ELT (expr, i), ctx, ht);
12381 case tcc_exceptional:
12385 fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
12386 fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
12387 expr = TREE_CHAIN (expr);
12388 goto recursive_label;
12391 for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
12392 fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
12398 case tcc_expression:
12399 case tcc_reference:
12400 case tcc_comparison:
12403 case tcc_statement:
12405 len = TREE_OPERAND_LENGTH (expr);
12406 for (i = 0; i < len; ++i)
12407 fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
12409 case tcc_declaration:
12410 fold_checksum_tree (DECL_NAME (expr), ctx, ht);
12411 fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
12412 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
12414 fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
12415 fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
12416 fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
12417 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
12418 fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
12421 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
12423 if (TREE_CODE (expr) == FUNCTION_DECL)
12425 fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
12426 fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
12428 fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
12432 if (TREE_CODE (expr) == ENUMERAL_TYPE)
12433 fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
12434 fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
12435 fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
12436 fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
12437 fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
12438 if (INTEGRAL_TYPE_P (expr)
12439 || SCALAR_FLOAT_TYPE_P (expr))
12441 fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
12442 fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
12444 fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
12445 if (TREE_CODE (expr) == RECORD_TYPE
12446 || TREE_CODE (expr) == UNION_TYPE
12447 || TREE_CODE (expr) == QUAL_UNION_TYPE)
12448 fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
12449 fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
12456 /* Helper function for outputting the checksum of a tree T. When
12457 debugging with gdb, you can "define mynext" to be "next" followed
12458 by "call debug_fold_checksum (op0)", then just trace down till the
12461 DEBUG_FUNCTION void
12462 debug_fold_checksum (const_tree t)
12465 unsigned char checksum[16];
12466 struct md5_ctx ctx;
12467 hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12469 md5_init_ctx (&ctx);
12470 fold_checksum_tree (t, &ctx, &ht);
12471 md5_finish_ctx (&ctx, checksum);
12474 for (i = 0; i < 16; i++)
12475 fprintf (stderr, "%d ", checksum[i]);
12477 fprintf (stderr, "\n");
12482 /* Fold a unary tree expression with code CODE of type TYPE with an
12483 operand OP0. LOC is the location of the resulting expression.
12484 Return a folded expression if successful. Otherwise, return a tree
12485 expression with code CODE of type TYPE with an operand OP0. */
12488 fold_build1_stat_loc (location_t loc,
12489 enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
12492 #ifdef ENABLE_FOLD_CHECKING
12493 unsigned char checksum_before[16], checksum_after[16];
12494 struct md5_ctx ctx;
12495 hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12497 md5_init_ctx (&ctx);
12498 fold_checksum_tree (op0, &ctx, &ht);
12499 md5_finish_ctx (&ctx, checksum_before);
12503 tem = fold_unary_loc (loc, code, type, op0);
12505 tem = build1_stat_loc (loc, code, type, op0 PASS_MEM_STAT);
12507 #ifdef ENABLE_FOLD_CHECKING
12508 md5_init_ctx (&ctx);
12509 fold_checksum_tree (op0, &ctx, &ht);
12510 md5_finish_ctx (&ctx, checksum_after);
12512 if (memcmp (checksum_before, checksum_after, 16))
12513 fold_check_failed (op0, tem);
12518 /* Fold a binary tree expression with code CODE of type TYPE with
12519 operands OP0 and OP1. LOC is the location of the resulting
12520 expression. Return a folded expression if successful. Otherwise,
12521 return a tree expression with code CODE of type TYPE with operands
12525 fold_build2_stat_loc (location_t loc,
12526 enum tree_code code, tree type, tree op0, tree op1
12530 #ifdef ENABLE_FOLD_CHECKING
12531 unsigned char checksum_before_op0[16],
12532 checksum_before_op1[16],
12533 checksum_after_op0[16],
12534 checksum_after_op1[16];
12535 struct md5_ctx ctx;
12536 hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12538 md5_init_ctx (&ctx);
12539 fold_checksum_tree (op0, &ctx, &ht);
12540 md5_finish_ctx (&ctx, checksum_before_op0);
12543 md5_init_ctx (&ctx);
12544 fold_checksum_tree (op1, &ctx, &ht);
12545 md5_finish_ctx (&ctx, checksum_before_op1);
12549 tem = fold_binary_loc (loc, code, type, op0, op1);
12551 tem = build2_stat_loc (loc, code, type, op0, op1 PASS_MEM_STAT);
12553 #ifdef ENABLE_FOLD_CHECKING
12554 md5_init_ctx (&ctx);
12555 fold_checksum_tree (op0, &ctx, &ht);
12556 md5_finish_ctx (&ctx, checksum_after_op0);
12559 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
12560 fold_check_failed (op0, tem);
12562 md5_init_ctx (&ctx);
12563 fold_checksum_tree (op1, &ctx, &ht);
12564 md5_finish_ctx (&ctx, checksum_after_op1);
12566 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
12567 fold_check_failed (op1, tem);
12572 /* Fold a ternary tree expression with code CODE of type TYPE with
12573 operands OP0, OP1, and OP2. Return a folded expression if
12574 successful. Otherwise, return a tree expression with code CODE of
12575 type TYPE with operands OP0, OP1, and OP2. */
12578 fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
12579 tree op0, tree op1, tree op2 MEM_STAT_DECL)
12582 #ifdef ENABLE_FOLD_CHECKING
12583 unsigned char checksum_before_op0[16],
12584 checksum_before_op1[16],
12585 checksum_before_op2[16],
12586 checksum_after_op0[16],
12587 checksum_after_op1[16],
12588 checksum_after_op2[16];
12589 struct md5_ctx ctx;
12590 hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12592 md5_init_ctx (&ctx);
12593 fold_checksum_tree (op0, &ctx, &ht);
12594 md5_finish_ctx (&ctx, checksum_before_op0);
12597 md5_init_ctx (&ctx);
12598 fold_checksum_tree (op1, &ctx, &ht);
12599 md5_finish_ctx (&ctx, checksum_before_op1);
12602 md5_init_ctx (&ctx);
12603 fold_checksum_tree (op2, &ctx, &ht);
12604 md5_finish_ctx (&ctx, checksum_before_op2);
12608 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
12609 tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
12611 tem = build3_stat_loc (loc, code, type, op0, op1, op2 PASS_MEM_STAT);
12613 #ifdef ENABLE_FOLD_CHECKING
12614 md5_init_ctx (&ctx);
12615 fold_checksum_tree (op0, &ctx, &ht);
12616 md5_finish_ctx (&ctx, checksum_after_op0);
12619 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
12620 fold_check_failed (op0, tem);
12622 md5_init_ctx (&ctx);
12623 fold_checksum_tree (op1, &ctx, &ht);
12624 md5_finish_ctx (&ctx, checksum_after_op1);
12627 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
12628 fold_check_failed (op1, tem);
12630 md5_init_ctx (&ctx);
12631 fold_checksum_tree (op2, &ctx, &ht);
12632 md5_finish_ctx (&ctx, checksum_after_op2);
12634 if (memcmp (checksum_before_op2, checksum_after_op2, 16))
12635 fold_check_failed (op2, tem);
12640 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12641 arguments in ARGARRAY, and a null static chain.
12642 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12643 of type TYPE from the given operands as constructed by build_call_array. */
12646 fold_build_call_array_loc (location_t loc, tree type, tree fn,
12647 int nargs, tree *argarray)
12650 #ifdef ENABLE_FOLD_CHECKING
12651 unsigned char checksum_before_fn[16],
12652 checksum_before_arglist[16],
12653 checksum_after_fn[16],
12654 checksum_after_arglist[16];
12655 struct md5_ctx ctx;
12656 hash_table<nofree_ptr_hash<const tree_node> > ht (32);
12659 md5_init_ctx (&ctx);
12660 fold_checksum_tree (fn, &ctx, &ht);
12661 md5_finish_ctx (&ctx, checksum_before_fn);
12664 md5_init_ctx (&ctx);
12665 for (i = 0; i < nargs; i++)
12666 fold_checksum_tree (argarray[i], &ctx, &ht);
12667 md5_finish_ctx (&ctx, checksum_before_arglist);
12671 tem = fold_builtin_call_array (loc, type, fn, nargs, argarray);
12673 tem = build_call_array_loc (loc, type, fn, nargs, argarray);
12675 #ifdef ENABLE_FOLD_CHECKING
12676 md5_init_ctx (&ctx);
12677 fold_checksum_tree (fn, &ctx, &ht);
12678 md5_finish_ctx (&ctx, checksum_after_fn);
12681 if (memcmp (checksum_before_fn, checksum_after_fn, 16))
12682 fold_check_failed (fn, tem);
12684 md5_init_ctx (&ctx);
12685 for (i = 0; i < nargs; i++)
12686 fold_checksum_tree (argarray[i], &ctx, &ht);
12687 md5_finish_ctx (&ctx, checksum_after_arglist);
12689 if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
12690 fold_check_failed (NULL_TREE, tem);
12695 /* Perform constant folding and related simplification of initializer
12696 expression EXPR. These behave identically to "fold_buildN" but ignore
12697 potential run-time traps and exceptions that fold must preserve. */
12699 #define START_FOLD_INIT \
12700 int saved_signaling_nans = flag_signaling_nans;\
12701 int saved_trapping_math = flag_trapping_math;\
12702 int saved_rounding_math = flag_rounding_math;\
12703 int saved_trapv = flag_trapv;\
12704 int saved_folding_initializer = folding_initializer;\
12705 flag_signaling_nans = 0;\
12706 flag_trapping_math = 0;\
12707 flag_rounding_math = 0;\
12709 folding_initializer = 1;
12711 #define END_FOLD_INIT \
12712 flag_signaling_nans = saved_signaling_nans;\
12713 flag_trapping_math = saved_trapping_math;\
12714 flag_rounding_math = saved_rounding_math;\
12715 flag_trapv = saved_trapv;\
12716 folding_initializer = saved_folding_initializer;
12719 fold_build1_initializer_loc (location_t loc, enum tree_code code,
12720 tree type, tree op)
12725 result = fold_build1_loc (loc, code, type, op);
12732 fold_build2_initializer_loc (location_t loc, enum tree_code code,
12733 tree type, tree op0, tree op1)
12738 result = fold_build2_loc (loc, code, type, op0, op1);
12745 fold_build_call_array_initializer_loc (location_t loc, tree type, tree fn,
12746 int nargs, tree *argarray)
12751 result = fold_build_call_array_loc (loc, type, fn, nargs, argarray);
12757 #undef START_FOLD_INIT
12758 #undef END_FOLD_INIT
12760 /* Determine if first argument is a multiple of second argument. Return 0 if
12761 it is not, or we cannot easily determined it to be.
12763 An example of the sort of thing we care about (at this point; this routine
12764 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12765 fold cases do now) is discovering that
12767 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12773 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12775 This code also handles discovering that
12777 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12779 is a multiple of 8 so we don't have to worry about dealing with a
12780 possible remainder.
12782 Note that we *look* inside a SAVE_EXPR only to determine how it was
12783 calculated; it is not safe for fold to do much of anything else with the
12784 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12785 at run time. For example, the latter example above *cannot* be implemented
12786 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12787 evaluation time of the original SAVE_EXPR is not necessarily the same at
12788 the time the new expression is evaluated. The only optimization of this
12789 sort that would be valid is changing
12791 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12795 SAVE_EXPR (I) * SAVE_EXPR (J)
12797 (where the same SAVE_EXPR (J) is used in the original and the
12798 transformed version). */
12801 multiple_of_p (tree type, const_tree top, const_tree bottom)
12803 if (operand_equal_p (top, bottom, 0))
12806 if (TREE_CODE (type) != INTEGER_TYPE)
12809 switch (TREE_CODE (top))
12812 /* Bitwise and provides a power of two multiple. If the mask is
12813 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12814 if (!integer_pow2p (bottom))
12819 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
12820 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
12824 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
12825 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
12828 if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
12832 op1 = TREE_OPERAND (top, 1);
12833 /* const_binop may not detect overflow correctly,
12834 so check for it explicitly here. */
12835 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
12836 && 0 != (t1 = fold_convert (type,
12837 const_binop (LSHIFT_EXPR,
12840 && !TREE_OVERFLOW (t1))
12841 return multiple_of_p (type, t1, bottom);
12846 /* Can't handle conversions from non-integral or wider integral type. */
12847 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
12848 || (TYPE_PRECISION (type)
12849 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
12852 /* .. fall through ... */
12855 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
12858 return (multiple_of_p (type, TREE_OPERAND (top, 1), bottom)
12859 && multiple_of_p (type, TREE_OPERAND (top, 2), bottom));
12862 if (TREE_CODE (bottom) != INTEGER_CST
12863 || integer_zerop (bottom)
12864 || (TYPE_UNSIGNED (type)
12865 && (tree_int_cst_sgn (top) < 0
12866 || tree_int_cst_sgn (bottom) < 0)))
12868 return wi::multiple_of_p (wi::to_widest (top), wi::to_widest (bottom),
12876 #define tree_expr_nonnegative_warnv_p(X, Y) \
12877 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
12879 #define RECURSE(X) \
12880 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12882 /* Return true if CODE or TYPE is known to be non-negative. */
12885 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
12887 if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
12888 && truth_value_p (code))
12889 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12890 have a signed:1 type (where the value is -1 and 0). */
12895 /* Return true if (CODE OP0) is known to be non-negative. If the return
12896 value is based on the assumption that signed overflow is undefined,
12897 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12898 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12901 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
12902 bool *strict_overflow_p, int depth)
12904 if (TYPE_UNSIGNED (type))
12910 /* We can't return 1 if flag_wrapv is set because
12911 ABS_EXPR<INT_MIN> = INT_MIN. */
12912 if (!ANY_INTEGRAL_TYPE_P (type))
12914 if (TYPE_OVERFLOW_UNDEFINED (type))
12916 *strict_overflow_p = true;
12921 case NON_LVALUE_EXPR:
12923 case FIX_TRUNC_EXPR:
12924 return RECURSE (op0);
12928 tree inner_type = TREE_TYPE (op0);
12929 tree outer_type = type;
12931 if (TREE_CODE (outer_type) == REAL_TYPE)
12933 if (TREE_CODE (inner_type) == REAL_TYPE)
12934 return RECURSE (op0);
12935 if (INTEGRAL_TYPE_P (inner_type))
12937 if (TYPE_UNSIGNED (inner_type))
12939 return RECURSE (op0);
12942 else if (INTEGRAL_TYPE_P (outer_type))
12944 if (TREE_CODE (inner_type) == REAL_TYPE)
12945 return RECURSE (op0);
12946 if (INTEGRAL_TYPE_P (inner_type))
12947 return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
12948 && TYPE_UNSIGNED (inner_type);
12954 return tree_simple_nonnegative_warnv_p (code, type);
12957 /* We don't know sign of `t', so be conservative and return false. */
12961 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12962 value is based on the assumption that signed overflow is undefined,
12963 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12964 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12967 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
12968 tree op1, bool *strict_overflow_p,
12971 if (TYPE_UNSIGNED (type))
12976 case POINTER_PLUS_EXPR:
12978 if (FLOAT_TYPE_P (type))
12979 return RECURSE (op0) && RECURSE (op1);
12981 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12982 both unsigned and at least 2 bits shorter than the result. */
12983 if (TREE_CODE (type) == INTEGER_TYPE
12984 && TREE_CODE (op0) == NOP_EXPR
12985 && TREE_CODE (op1) == NOP_EXPR)
12987 tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
12988 tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
12989 if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
12990 && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
12992 unsigned int prec = MAX (TYPE_PRECISION (inner1),
12993 TYPE_PRECISION (inner2)) + 1;
12994 return prec < TYPE_PRECISION (type);
13000 if (FLOAT_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
13002 /* x * x is always non-negative for floating point x
13003 or without overflow. */
13004 if (operand_equal_p (op0, op1, 0)
13005 || (RECURSE (op0) && RECURSE (op1)))
13007 if (ANY_INTEGRAL_TYPE_P (type)
13008 && TYPE_OVERFLOW_UNDEFINED (type))
13009 *strict_overflow_p = true;
13014 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
13015 both unsigned and their total bits is shorter than the result. */
13016 if (TREE_CODE (type) == INTEGER_TYPE
13017 && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
13018 && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
13020 tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
13021 ? TREE_TYPE (TREE_OPERAND (op0, 0))
13023 tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
13024 ? TREE_TYPE (TREE_OPERAND (op1, 0))
13027 bool unsigned0 = TYPE_UNSIGNED (inner0);
13028 bool unsigned1 = TYPE_UNSIGNED (inner1);
13030 if (TREE_CODE (op0) == INTEGER_CST)
13031 unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
13033 if (TREE_CODE (op1) == INTEGER_CST)
13034 unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
13036 if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
13037 && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
13039 unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
13040 ? tree_int_cst_min_precision (op0, UNSIGNED)
13041 : TYPE_PRECISION (inner0);
13043 unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
13044 ? tree_int_cst_min_precision (op1, UNSIGNED)
13045 : TYPE_PRECISION (inner1);
13047 return precision0 + precision1 < TYPE_PRECISION (type);
13054 return RECURSE (op0) || RECURSE (op1);
13060 case TRUNC_DIV_EXPR:
13061 case CEIL_DIV_EXPR:
13062 case FLOOR_DIV_EXPR:
13063 case ROUND_DIV_EXPR:
13064 return RECURSE (op0) && RECURSE (op1);
13066 case TRUNC_MOD_EXPR:
13067 return RECURSE (op0);
13069 case FLOOR_MOD_EXPR:
13070 return RECURSE (op1);
13072 case CEIL_MOD_EXPR:
13073 case ROUND_MOD_EXPR:
13075 return tree_simple_nonnegative_warnv_p (code, type);
13078 /* We don't know sign of `t', so be conservative and return false. */
13082 /* Return true if T is known to be non-negative. If the return
13083 value is based on the assumption that signed overflow is undefined,
13084 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13085 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13088 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p, int depth)
13090 if (TYPE_UNSIGNED (TREE_TYPE (t)))
13093 switch (TREE_CODE (t))
13096 return tree_int_cst_sgn (t) >= 0;
13099 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
13102 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
13105 return RECURSE (TREE_OPERAND (t, 1)) && RECURSE (TREE_OPERAND (t, 2));
13108 /* Limit the depth of recursion to avoid quadratic behavior.
13109 This is expected to catch almost all occurrences in practice.
13110 If this code misses important cases that unbounded recursion
13111 would not, passes that need this information could be revised
13112 to provide it through dataflow propagation. */
13113 return (!name_registered_for_update_p (t)
13114 && depth < PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH)
13115 && gimple_stmt_nonnegative_warnv_p (SSA_NAME_DEF_STMT (t),
13116 strict_overflow_p, depth));
13119 return tree_simple_nonnegative_warnv_p (TREE_CODE (t), TREE_TYPE (t));
13123 /* Return true if T is known to be non-negative. If the return
13124 value is based on the assumption that signed overflow is undefined,
13125 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13126 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13129 tree_call_nonnegative_warnv_p (tree type, combined_fn fn, tree arg0, tree arg1,
13130 bool *strict_overflow_p, int depth)
13151 case CFN_BUILT_IN_BSWAP32:
13152 case CFN_BUILT_IN_BSWAP64:
13157 /* sqrt(-0.0) is -0.0. */
13158 if (!HONOR_SIGNED_ZEROS (element_mode (type)))
13160 return RECURSE (arg0);
13186 CASE_CFN_NEARBYINT:
13193 CASE_CFN_SIGNIFICAND:
13197 /* True if the 1st argument is nonnegative. */
13198 return RECURSE (arg0);
13201 /* True if the 1st OR 2nd arguments are nonnegative. */
13202 return RECURSE (arg0) || RECURSE (arg1);
13205 /* True if the 1st AND 2nd arguments are nonnegative. */
13206 return RECURSE (arg0) && RECURSE (arg1);
13209 /* True if the 2nd argument is nonnegative. */
13210 return RECURSE (arg1);
13213 /* True if the 1st argument is nonnegative or the second
13214 argument is an even integer. */
13215 if (TREE_CODE (arg1) == INTEGER_CST
13216 && (TREE_INT_CST_LOW (arg1) & 1) == 0)
13218 return RECURSE (arg0);
13221 /* True if the 1st argument is nonnegative or the second
13222 argument is an even integer valued real. */
13223 if (TREE_CODE (arg1) == REAL_CST)
13228 c = TREE_REAL_CST (arg1);
13229 n = real_to_integer (&c);
13232 REAL_VALUE_TYPE cint;
13233 real_from_integer (&cint, VOIDmode, n, SIGNED);
13234 if (real_identical (&c, &cint))
13238 return RECURSE (arg0);
13243 return tree_simple_nonnegative_warnv_p (CALL_EXPR, type);
13246 /* Return true if T is known to be non-negative. If the return
13247 value is based on the assumption that signed overflow is undefined,
13248 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13249 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13252 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p, int depth)
13254 enum tree_code code = TREE_CODE (t);
13255 if (TYPE_UNSIGNED (TREE_TYPE (t)))
13262 tree temp = TARGET_EXPR_SLOT (t);
13263 t = TARGET_EXPR_INITIAL (t);
13265 /* If the initializer is non-void, then it's a normal expression
13266 that will be assigned to the slot. */
13267 if (!VOID_TYPE_P (t))
13268 return RECURSE (t);
13270 /* Otherwise, the initializer sets the slot in some way. One common
13271 way is an assignment statement at the end of the initializer. */
13274 if (TREE_CODE (t) == BIND_EXPR)
13275 t = expr_last (BIND_EXPR_BODY (t));
13276 else if (TREE_CODE (t) == TRY_FINALLY_EXPR
13277 || TREE_CODE (t) == TRY_CATCH_EXPR)
13278 t = expr_last (TREE_OPERAND (t, 0));
13279 else if (TREE_CODE (t) == STATEMENT_LIST)
13284 if (TREE_CODE (t) == MODIFY_EXPR
13285 && TREE_OPERAND (t, 0) == temp)
13286 return RECURSE (TREE_OPERAND (t, 1));
13293 tree arg0 = call_expr_nargs (t) > 0 ? CALL_EXPR_ARG (t, 0) : NULL_TREE;
13294 tree arg1 = call_expr_nargs (t) > 1 ? CALL_EXPR_ARG (t, 1) : NULL_TREE;
13296 return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
13297 get_call_combined_fn (t),
13300 strict_overflow_p, depth);
13302 case COMPOUND_EXPR:
13304 return RECURSE (TREE_OPERAND (t, 1));
13307 return RECURSE (expr_last (TREE_OPERAND (t, 1)));
13310 return RECURSE (TREE_OPERAND (t, 0));
13313 return tree_simple_nonnegative_warnv_p (TREE_CODE (t), TREE_TYPE (t));
13318 #undef tree_expr_nonnegative_warnv_p
13320 /* Return true if T is known to be non-negative. If the return
13321 value is based on the assumption that signed overflow is undefined,
13322 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13323 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13326 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p, int depth)
13328 enum tree_code code;
13329 if (t == error_mark_node)
13332 code = TREE_CODE (t);
13333 switch (TREE_CODE_CLASS (code))
13336 case tcc_comparison:
13337 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
13339 TREE_OPERAND (t, 0),
13340 TREE_OPERAND (t, 1),
13341 strict_overflow_p, depth);
13344 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
13346 TREE_OPERAND (t, 0),
13347 strict_overflow_p, depth);
13350 case tcc_declaration:
13351 case tcc_reference:
13352 return tree_single_nonnegative_warnv_p (t, strict_overflow_p, depth);
13360 case TRUTH_AND_EXPR:
13361 case TRUTH_OR_EXPR:
13362 case TRUTH_XOR_EXPR:
13363 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
13365 TREE_OPERAND (t, 0),
13366 TREE_OPERAND (t, 1),
13367 strict_overflow_p, depth);
13368 case TRUTH_NOT_EXPR:
13369 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
13371 TREE_OPERAND (t, 0),
13372 strict_overflow_p, depth);
13379 case WITH_SIZE_EXPR:
13381 return tree_single_nonnegative_warnv_p (t, strict_overflow_p, depth);
13384 return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p, depth);
13388 /* Return true if `t' is known to be non-negative. Handle warnings
13389 about undefined signed overflow. */
13392 tree_expr_nonnegative_p (tree t)
13394 bool ret, strict_overflow_p;
13396 strict_overflow_p = false;
13397 ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
13398 if (strict_overflow_p)
13399 fold_overflow_warning (("assuming signed overflow does not occur when "
13400 "determining that expression is always "
13402 WARN_STRICT_OVERFLOW_MISC);
13407 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13408 For floating point we further ensure that T is not denormal.
13409 Similar logic is present in nonzero_address in rtlanal.h.
13411 If the return value is based on the assumption that signed overflow
13412 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13413 change *STRICT_OVERFLOW_P. */
13416 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
13417 bool *strict_overflow_p)
13422 return tree_expr_nonzero_warnv_p (op0,
13423 strict_overflow_p);
13427 tree inner_type = TREE_TYPE (op0);
13428 tree outer_type = type;
13430 return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
13431 && tree_expr_nonzero_warnv_p (op0,
13432 strict_overflow_p));
13436 case NON_LVALUE_EXPR:
13437 return tree_expr_nonzero_warnv_p (op0,
13438 strict_overflow_p);
13447 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13448 For floating point we further ensure that T is not denormal.
13449 Similar logic is present in nonzero_address in rtlanal.h.
13451 If the return value is based on the assumption that signed overflow
13452 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13453 change *STRICT_OVERFLOW_P. */
13456 tree_binary_nonzero_warnv_p (enum tree_code code,
13459 tree op1, bool *strict_overflow_p)
13461 bool sub_strict_overflow_p;
13464 case POINTER_PLUS_EXPR:
13466 if (ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_UNDEFINED (type))
13468 /* With the presence of negative values it is hard
13469 to say something. */
13470 sub_strict_overflow_p = false;
13471 if (!tree_expr_nonnegative_warnv_p (op0,
13472 &sub_strict_overflow_p)
13473 || !tree_expr_nonnegative_warnv_p (op1,
13474 &sub_strict_overflow_p))
13476 /* One of operands must be positive and the other non-negative. */
13477 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13478 overflows, on a twos-complement machine the sum of two
13479 nonnegative numbers can never be zero. */
13480 return (tree_expr_nonzero_warnv_p (op0,
13482 || tree_expr_nonzero_warnv_p (op1,
13483 strict_overflow_p));
13488 if (TYPE_OVERFLOW_UNDEFINED (type))
13490 if (tree_expr_nonzero_warnv_p (op0,
13492 && tree_expr_nonzero_warnv_p (op1,
13493 strict_overflow_p))
13495 *strict_overflow_p = true;
13502 sub_strict_overflow_p = false;
13503 if (tree_expr_nonzero_warnv_p (op0,
13504 &sub_strict_overflow_p)
13505 && tree_expr_nonzero_warnv_p (op1,
13506 &sub_strict_overflow_p))
13508 if (sub_strict_overflow_p)
13509 *strict_overflow_p = true;
13514 sub_strict_overflow_p = false;
13515 if (tree_expr_nonzero_warnv_p (op0,
13516 &sub_strict_overflow_p))
13518 if (sub_strict_overflow_p)
13519 *strict_overflow_p = true;
13521 /* When both operands are nonzero, then MAX must be too. */
13522 if (tree_expr_nonzero_warnv_p (op1,
13523 strict_overflow_p))
13526 /* MAX where operand 0 is positive is positive. */
13527 return tree_expr_nonnegative_warnv_p (op0,
13528 strict_overflow_p);
13530 /* MAX where operand 1 is positive is positive. */
13531 else if (tree_expr_nonzero_warnv_p (op1,
13532 &sub_strict_overflow_p)
13533 && tree_expr_nonnegative_warnv_p (op1,
13534 &sub_strict_overflow_p))
13536 if (sub_strict_overflow_p)
13537 *strict_overflow_p = true;
13543 return (tree_expr_nonzero_warnv_p (op1,
13545 || tree_expr_nonzero_warnv_p (op0,
13546 strict_overflow_p));
13555 /* Return true when T is an address and is known to be nonzero.
13556 For floating point we further ensure that T is not denormal.
13557 Similar logic is present in nonzero_address in rtlanal.h.
13559 If the return value is based on the assumption that signed overflow
13560 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13561 change *STRICT_OVERFLOW_P. */
13564 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
13566 bool sub_strict_overflow_p;
13567 switch (TREE_CODE (t))
13570 return !integer_zerop (t);
13574 tree base = TREE_OPERAND (t, 0);
13576 if (!DECL_P (base))
13577 base = get_base_address (base);
13579 if (base && TREE_CODE (base) == TARGET_EXPR)
13580 base = TARGET_EXPR_SLOT (base);
13585 /* For objects in symbol table check if we know they are non-zero.
13586 Don't do anything for variables and functions before symtab is built;
13587 it is quite possible that they will be declared weak later. */
13588 int nonzero_addr = maybe_nonzero_address (base);
13589 if (nonzero_addr >= 0)
13590 return nonzero_addr;
13592 /* Function local objects are never NULL. */
13594 && (DECL_CONTEXT (base)
13595 && TREE_CODE (DECL_CONTEXT (base)) == FUNCTION_DECL
13596 && auto_var_in_fn_p (base, DECL_CONTEXT (base))))
13599 /* Constants are never weak. */
13600 if (CONSTANT_CLASS_P (base))
13607 sub_strict_overflow_p = false;
13608 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
13609 &sub_strict_overflow_p)
13610 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
13611 &sub_strict_overflow_p))
13613 if (sub_strict_overflow_p)
13614 *strict_overflow_p = true;
13625 #define integer_valued_real_p(X) \
13626 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
13628 #define RECURSE(X) \
13629 ((integer_valued_real_p) (X, depth + 1))
13631 /* Return true if the floating point result of (CODE OP0) has an
13632 integer value. We also allow +Inf, -Inf and NaN to be considered
13633 integer values. Return false for signaling NaN.
13635 DEPTH is the current nesting depth of the query. */
13638 integer_valued_real_unary_p (tree_code code, tree op0, int depth)
13646 return RECURSE (op0);
13650 tree type = TREE_TYPE (op0);
13651 if (TREE_CODE (type) == INTEGER_TYPE)
13653 if (TREE_CODE (type) == REAL_TYPE)
13654 return RECURSE (op0);
13664 /* Return true if the floating point result of (CODE OP0 OP1) has an
13665 integer value. We also allow +Inf, -Inf and NaN to be considered
13666 integer values. Return false for signaling NaN.
13668 DEPTH is the current nesting depth of the query. */
13671 integer_valued_real_binary_p (tree_code code, tree op0, tree op1, int depth)
13680 return RECURSE (op0) && RECURSE (op1);
13688 /* Return true if the floating point result of calling FNDECL with arguments
13689 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13690 considered integer values. Return false for signaling NaN. If FNDECL
13691 takes fewer than 2 arguments, the remaining ARGn are null.
13693 DEPTH is the current nesting depth of the query. */
13696 integer_valued_real_call_p (combined_fn fn, tree arg0, tree arg1, int depth)
13702 CASE_CFN_NEARBYINT:
13710 return RECURSE (arg0) && RECURSE (arg1);
13718 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13719 has an integer value. We also allow +Inf, -Inf and NaN to be
13720 considered integer values. Return false for signaling NaN.
13722 DEPTH is the current nesting depth of the query. */
13725 integer_valued_real_single_p (tree t, int depth)
13727 switch (TREE_CODE (t))
13730 return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
13733 return RECURSE (TREE_OPERAND (t, 1)) && RECURSE (TREE_OPERAND (t, 2));
13736 /* Limit the depth of recursion to avoid quadratic behavior.
13737 This is expected to catch almost all occurrences in practice.
13738 If this code misses important cases that unbounded recursion
13739 would not, passes that need this information could be revised
13740 to provide it through dataflow propagation. */
13741 return (!name_registered_for_update_p (t)
13742 && depth < PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH)
13743 && gimple_stmt_integer_valued_real_p (SSA_NAME_DEF_STMT (t),
13752 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13753 has an integer value. We also allow +Inf, -Inf and NaN to be
13754 considered integer values. Return false for signaling NaN.
13756 DEPTH is the current nesting depth of the query. */
13759 integer_valued_real_invalid_p (tree t, int depth)
13761 switch (TREE_CODE (t))
13763 case COMPOUND_EXPR:
13766 return RECURSE (TREE_OPERAND (t, 1));
13769 return RECURSE (TREE_OPERAND (t, 0));
13778 #undef integer_valued_real_p
13780 /* Return true if the floating point expression T has an integer value.
13781 We also allow +Inf, -Inf and NaN to be considered integer values.
13782 Return false for signaling NaN.
13784 DEPTH is the current nesting depth of the query. */
13787 integer_valued_real_p (tree t, int depth)
13789 if (t == error_mark_node)
13792 tree_code code = TREE_CODE (t);
13793 switch (TREE_CODE_CLASS (code))
13796 case tcc_comparison:
13797 return integer_valued_real_binary_p (code, TREE_OPERAND (t, 0),
13798 TREE_OPERAND (t, 1), depth);
13801 return integer_valued_real_unary_p (code, TREE_OPERAND (t, 0), depth);
13804 case tcc_declaration:
13805 case tcc_reference:
13806 return integer_valued_real_single_p (t, depth);
13816 return integer_valued_real_single_p (t, depth);
13820 tree arg0 = (call_expr_nargs (t) > 0
13821 ? CALL_EXPR_ARG (t, 0)
13823 tree arg1 = (call_expr_nargs (t) > 1
13824 ? CALL_EXPR_ARG (t, 1)
13826 return integer_valued_real_call_p (get_call_combined_fn (t),
13827 arg0, arg1, depth);
13831 return integer_valued_real_invalid_p (t, depth);
13835 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13836 attempt to fold the expression to a constant without modifying TYPE,
13839 If the expression could be simplified to a constant, then return
13840 the constant. If the expression would not be simplified to a
13841 constant, then return NULL_TREE. */
13844 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
13846 tree tem = fold_binary (code, type, op0, op1);
13847 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
13850 /* Given the components of a unary expression CODE, TYPE and OP0,
13851 attempt to fold the expression to a constant without modifying
13854 If the expression could be simplified to a constant, then return
13855 the constant. If the expression would not be simplified to a
13856 constant, then return NULL_TREE. */
13859 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
13861 tree tem = fold_unary (code, type, op0);
13862 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
13865 /* If EXP represents referencing an element in a constant string
13866 (either via pointer arithmetic or array indexing), return the
13867 tree representing the value accessed, otherwise return NULL. */
13870 fold_read_from_constant_string (tree exp)
13872 if ((TREE_CODE (exp) == INDIRECT_REF
13873 || TREE_CODE (exp) == ARRAY_REF)
13874 && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
13876 tree exp1 = TREE_OPERAND (exp, 0);
13879 location_t loc = EXPR_LOCATION (exp);
13881 if (TREE_CODE (exp) == INDIRECT_REF)
13882 string = string_constant (exp1, &index);
13885 tree low_bound = array_ref_low_bound (exp);
13886 index = fold_convert_loc (loc, sizetype, TREE_OPERAND (exp, 1));
13888 /* Optimize the special-case of a zero lower bound.
13890 We convert the low_bound to sizetype to avoid some problems
13891 with constant folding. (E.g. suppose the lower bound is 1,
13892 and its mode is QI. Without the conversion,l (ARRAY
13893 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13894 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13895 if (! integer_zerop (low_bound))
13896 index = size_diffop_loc (loc, index,
13897 fold_convert_loc (loc, sizetype, low_bound));
13903 && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
13904 && TREE_CODE (string) == STRING_CST
13905 && TREE_CODE (index) == INTEGER_CST
13906 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
13907 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
13909 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
13910 return build_int_cst_type (TREE_TYPE (exp),
13911 (TREE_STRING_POINTER (string)
13912 [TREE_INT_CST_LOW (index)]));
13917 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13918 an integer constant, real, or fixed-point constant.
13920 TYPE is the type of the result. */
13923 fold_negate_const (tree arg0, tree type)
13925 tree t = NULL_TREE;
13927 switch (TREE_CODE (arg0))
13932 wide_int val = wi::neg (arg0, &overflow);
13933 t = force_fit_type (type, val, 1,
13934 (overflow | TREE_OVERFLOW (arg0))
13935 && !TYPE_UNSIGNED (type));
13940 t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
13945 FIXED_VALUE_TYPE f;
13946 bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
13947 &(TREE_FIXED_CST (arg0)), NULL,
13948 TYPE_SATURATING (type));
13949 t = build_fixed (type, f);
13950 /* Propagate overflow flags. */
13951 if (overflow_p | TREE_OVERFLOW (arg0))
13952 TREE_OVERFLOW (t) = 1;
13957 gcc_unreachable ();
13963 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13964 an integer constant or real constant.
13966 TYPE is the type of the result. */
13969 fold_abs_const (tree arg0, tree type)
13971 tree t = NULL_TREE;
13973 switch (TREE_CODE (arg0))
13977 /* If the value is unsigned or non-negative, then the absolute value
13978 is the same as the ordinary value. */
13979 if (!wi::neg_p (arg0, TYPE_SIGN (type)))
13982 /* If the value is negative, then the absolute value is
13987 wide_int val = wi::neg (arg0, &overflow);
13988 t = force_fit_type (type, val, -1,
13989 overflow | TREE_OVERFLOW (arg0));
13995 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
13996 t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
14002 gcc_unreachable ();
14008 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
14009 constant. TYPE is the type of the result. */
14012 fold_not_const (const_tree arg0, tree type)
14014 gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
14016 return force_fit_type (type, wi::bit_not (arg0), 0, TREE_OVERFLOW (arg0));
14019 /* Given CODE, a relational operator, the target type, TYPE and two
14020 constant operands OP0 and OP1, return the result of the
14021 relational operation. If the result is not a compile time
14022 constant, then return NULL_TREE. */
14025 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
14027 int result, invert;
14029 /* From here on, the only cases we handle are when the result is
14030 known to be a constant. */
14032 if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
14034 const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
14035 const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
14037 /* Handle the cases where either operand is a NaN. */
14038 if (real_isnan (c0) || real_isnan (c1))
14048 case UNORDERED_EXPR:
14062 if (flag_trapping_math)
14068 gcc_unreachable ();
14071 return constant_boolean_node (result, type);
14074 return constant_boolean_node (real_compare (code, c0, c1), type);
14077 if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
14079 const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
14080 const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
14081 return constant_boolean_node (fixed_compare (code, c0, c1), type);
14084 /* Handle equality/inequality of complex constants. */
14085 if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
14087 tree rcond = fold_relational_const (code, type,
14088 TREE_REALPART (op0),
14089 TREE_REALPART (op1));
14090 tree icond = fold_relational_const (code, type,
14091 TREE_IMAGPART (op0),
14092 TREE_IMAGPART (op1));
14093 if (code == EQ_EXPR)
14094 return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
14095 else if (code == NE_EXPR)
14096 return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
14101 if (TREE_CODE (op0) == VECTOR_CST && TREE_CODE (op1) == VECTOR_CST)
14103 if (!VECTOR_TYPE_P (type))
14105 /* Have vector comparison with scalar boolean result. */
14106 gcc_assert ((code == EQ_EXPR || code == NE_EXPR)
14107 && VECTOR_CST_NELTS (op0) == VECTOR_CST_NELTS (op1));
14108 for (unsigned i = 0; i < VECTOR_CST_NELTS (op0); i++)
14110 tree elem0 = VECTOR_CST_ELT (op0, i);
14111 tree elem1 = VECTOR_CST_ELT (op1, i);
14112 tree tmp = fold_relational_const (code, type, elem0, elem1);
14113 if (tmp == NULL_TREE)
14115 if (integer_zerop (tmp))
14116 return constant_boolean_node (false, type);
14118 return constant_boolean_node (true, type);
14120 unsigned count = VECTOR_CST_NELTS (op0);
14121 tree *elts = XALLOCAVEC (tree, count);
14122 gcc_assert (VECTOR_CST_NELTS (op1) == count
14123 && TYPE_VECTOR_SUBPARTS (type) == count);
14125 for (unsigned i = 0; i < count; i++)
14127 tree elem_type = TREE_TYPE (type);
14128 tree elem0 = VECTOR_CST_ELT (op0, i);
14129 tree elem1 = VECTOR_CST_ELT (op1, i);
14131 tree tem = fold_relational_const (code, elem_type,
14134 if (tem == NULL_TREE)
14137 elts[i] = build_int_cst (elem_type, integer_zerop (tem) ? 0 : -1);
14140 return build_vector (type, elts);
14143 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
14145 To compute GT, swap the arguments and do LT.
14146 To compute GE, do LT and invert the result.
14147 To compute LE, swap the arguments, do LT and invert the result.
14148 To compute NE, do EQ and invert the result.
14150 Therefore, the code below must handle only EQ and LT. */
14152 if (code == LE_EXPR || code == GT_EXPR)
14154 std::swap (op0, op1);
14155 code = swap_tree_comparison (code);
14158 /* Note that it is safe to invert for real values here because we
14159 have already handled the one case that it matters. */
14162 if (code == NE_EXPR || code == GE_EXPR)
14165 code = invert_tree_comparison (code, false);
14168 /* Compute a result for LT or EQ if args permit;
14169 Otherwise return T. */
14170 if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
14172 if (code == EQ_EXPR)
14173 result = tree_int_cst_equal (op0, op1);
14175 result = tree_int_cst_lt (op0, op1);
14182 return constant_boolean_node (result, type);
14185 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
14186 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
14190 fold_build_cleanup_point_expr (tree type, tree expr)
14192 /* If the expression does not have side effects then we don't have to wrap
14193 it with a cleanup point expression. */
14194 if (!TREE_SIDE_EFFECTS (expr))
14197 /* If the expression is a return, check to see if the expression inside the
14198 return has no side effects or the right hand side of the modify expression
14199 inside the return. If either don't have side effects set we don't need to
14200 wrap the expression in a cleanup point expression. Note we don't check the
14201 left hand side of the modify because it should always be a return decl. */
14202 if (TREE_CODE (expr) == RETURN_EXPR)
14204 tree op = TREE_OPERAND (expr, 0);
14205 if (!op || !TREE_SIDE_EFFECTS (op))
14207 op = TREE_OPERAND (op, 1);
14208 if (!TREE_SIDE_EFFECTS (op))
14212 return build1 (CLEANUP_POINT_EXPR, type, expr);
14215 /* Given a pointer value OP0 and a type TYPE, return a simplified version
14216 of an indirection through OP0, or NULL_TREE if no simplification is
14220 fold_indirect_ref_1 (location_t loc, tree type, tree op0)
14226 subtype = TREE_TYPE (sub);
14227 if (!POINTER_TYPE_P (subtype))
14230 if (TREE_CODE (sub) == ADDR_EXPR)
14232 tree op = TREE_OPERAND (sub, 0);
14233 tree optype = TREE_TYPE (op);
14234 /* *&CONST_DECL -> to the value of the const decl. */
14235 if (TREE_CODE (op) == CONST_DECL)
14236 return DECL_INITIAL (op);
14237 /* *&p => p; make sure to handle *&"str"[cst] here. */
14238 if (type == optype)
14240 tree fop = fold_read_from_constant_string (op);
14246 /* *(foo *)&fooarray => fooarray[0] */
14247 else if (TREE_CODE (optype) == ARRAY_TYPE
14248 && type == TREE_TYPE (optype)
14249 && (!in_gimple_form
14250 || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
14252 tree type_domain = TYPE_DOMAIN (optype);
14253 tree min_val = size_zero_node;
14254 if (type_domain && TYPE_MIN_VALUE (type_domain))
14255 min_val = TYPE_MIN_VALUE (type_domain);
14257 && TREE_CODE (min_val) != INTEGER_CST)
14259 return build4_loc (loc, ARRAY_REF, type, op, min_val,
14260 NULL_TREE, NULL_TREE);
14262 /* *(foo *)&complexfoo => __real__ complexfoo */
14263 else if (TREE_CODE (optype) == COMPLEX_TYPE
14264 && type == TREE_TYPE (optype))
14265 return fold_build1_loc (loc, REALPART_EXPR, type, op);
14266 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
14267 else if (TREE_CODE (optype) == VECTOR_TYPE
14268 && type == TREE_TYPE (optype))
14270 tree part_width = TYPE_SIZE (type);
14271 tree index = bitsize_int (0);
14272 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
14276 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
14277 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
14279 tree op00 = TREE_OPERAND (sub, 0);
14280 tree op01 = TREE_OPERAND (sub, 1);
14283 if (TREE_CODE (op00) == ADDR_EXPR)
14286 op00 = TREE_OPERAND (op00, 0);
14287 op00type = TREE_TYPE (op00);
14289 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
14290 if (TREE_CODE (op00type) == VECTOR_TYPE
14291 && type == TREE_TYPE (op00type))
14293 tree part_width = TYPE_SIZE (type);
14294 unsigned HOST_WIDE_INT max_offset
14295 = (tree_to_uhwi (part_width) / BITS_PER_UNIT
14296 * TYPE_VECTOR_SUBPARTS (op00type));
14297 if (tree_int_cst_sign_bit (op01) == 0
14298 && compare_tree_int (op01, max_offset) == -1)
14300 unsigned HOST_WIDE_INT offset = tree_to_uhwi (op01);
14301 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
14302 tree index = bitsize_int (indexi);
14303 return fold_build3_loc (loc,
14304 BIT_FIELD_REF, type, op00,
14305 part_width, index);
14308 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14309 else if (TREE_CODE (op00type) == COMPLEX_TYPE
14310 && type == TREE_TYPE (op00type))
14312 tree size = TYPE_SIZE_UNIT (type);
14313 if (tree_int_cst_equal (size, op01))
14314 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
14316 /* ((foo *)&fooarray)[1] => fooarray[1] */
14317 else if (TREE_CODE (op00type) == ARRAY_TYPE
14318 && type == TREE_TYPE (op00type))
14320 tree type_domain = TYPE_DOMAIN (op00type);
14321 tree min_val = size_zero_node;
14322 if (type_domain && TYPE_MIN_VALUE (type_domain))
14323 min_val = TYPE_MIN_VALUE (type_domain);
14324 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
14325 TYPE_SIZE_UNIT (type));
14326 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
14327 return build4_loc (loc, ARRAY_REF, type, op00, op01,
14328 NULL_TREE, NULL_TREE);
14333 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14334 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
14335 && type == TREE_TYPE (TREE_TYPE (subtype))
14336 && (!in_gimple_form
14337 || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
14340 tree min_val = size_zero_node;
14341 sub = build_fold_indirect_ref_loc (loc, sub);
14342 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
14343 if (type_domain && TYPE_MIN_VALUE (type_domain))
14344 min_val = TYPE_MIN_VALUE (type_domain);
14346 && TREE_CODE (min_val) != INTEGER_CST)
14348 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
14355 /* Builds an expression for an indirection through T, simplifying some
14359 build_fold_indirect_ref_loc (location_t loc, tree t)
14361 tree type = TREE_TYPE (TREE_TYPE (t));
14362 tree sub = fold_indirect_ref_1 (loc, type, t);
14367 return build1_loc (loc, INDIRECT_REF, type, t);
14370 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14373 fold_indirect_ref_loc (location_t loc, tree t)
14375 tree sub = fold_indirect_ref_1 (loc, TREE_TYPE (t), TREE_OPERAND (t, 0));
14383 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14384 whose result is ignored. The type of the returned tree need not be
14385 the same as the original expression. */
14388 fold_ignored_result (tree t)
14390 if (!TREE_SIDE_EFFECTS (t))
14391 return integer_zero_node;
14394 switch (TREE_CODE_CLASS (TREE_CODE (t)))
14397 t = TREE_OPERAND (t, 0);
14401 case tcc_comparison:
14402 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
14403 t = TREE_OPERAND (t, 0);
14404 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
14405 t = TREE_OPERAND (t, 1);
14410 case tcc_expression:
14411 switch (TREE_CODE (t))
14413 case COMPOUND_EXPR:
14414 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
14416 t = TREE_OPERAND (t, 0);
14420 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
14421 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
14423 t = TREE_OPERAND (t, 0);
14436 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14439 round_up_loc (location_t loc, tree value, unsigned int divisor)
14441 tree div = NULL_TREE;
14446 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14447 have to do anything. Only do this when we are not given a const,
14448 because in that case, this check is more expensive than just
14450 if (TREE_CODE (value) != INTEGER_CST)
14452 div = build_int_cst (TREE_TYPE (value), divisor);
14454 if (multiple_of_p (TREE_TYPE (value), value, div))
14458 /* If divisor is a power of two, simplify this to bit manipulation. */
14459 if (divisor == (divisor & -divisor))
14461 if (TREE_CODE (value) == INTEGER_CST)
14463 wide_int val = value;
14466 if ((val & (divisor - 1)) == 0)
14469 overflow_p = TREE_OVERFLOW (value);
14470 val += divisor - 1;
14471 val &= - (int) divisor;
14475 return force_fit_type (TREE_TYPE (value), val, -1, overflow_p);
14481 t = build_int_cst (TREE_TYPE (value), divisor - 1);
14482 value = size_binop_loc (loc, PLUS_EXPR, value, t);
14483 t = build_int_cst (TREE_TYPE (value), - (int) divisor);
14484 value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
14490 div = build_int_cst (TREE_TYPE (value), divisor);
14491 value = size_binop_loc (loc, CEIL_DIV_EXPR, value, div);
14492 value = size_binop_loc (loc, MULT_EXPR, value, div);
14498 /* Likewise, but round down. */
14501 round_down_loc (location_t loc, tree value, int divisor)
14503 tree div = NULL_TREE;
14505 gcc_assert (divisor > 0);
14509 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14510 have to do anything. Only do this when we are not given a const,
14511 because in that case, this check is more expensive than just
14513 if (TREE_CODE (value) != INTEGER_CST)
14515 div = build_int_cst (TREE_TYPE (value), divisor);
14517 if (multiple_of_p (TREE_TYPE (value), value, div))
14521 /* If divisor is a power of two, simplify this to bit manipulation. */
14522 if (divisor == (divisor & -divisor))
14526 t = build_int_cst (TREE_TYPE (value), -divisor);
14527 value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
14532 div = build_int_cst (TREE_TYPE (value), divisor);
14533 value = size_binop_loc (loc, FLOOR_DIV_EXPR, value, div);
14534 value = size_binop_loc (loc, MULT_EXPR, value, div);
14540 /* Returns the pointer to the base of the object addressed by EXP and
14541 extracts the information about the offset of the access, storing it
14542 to PBITPOS and POFFSET. */
14545 split_address_to_core_and_offset (tree exp,
14546 HOST_WIDE_INT *pbitpos, tree *poffset)
14550 int unsignedp, reversep, volatilep;
14551 HOST_WIDE_INT bitsize;
14552 location_t loc = EXPR_LOCATION (exp);
14554 if (TREE_CODE (exp) == ADDR_EXPR)
14556 core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
14557 poffset, &mode, &unsignedp, &reversep,
14558 &volatilep, false);
14559 core = build_fold_addr_expr_loc (loc, core);
14565 *poffset = NULL_TREE;
14571 /* Returns true if addresses of E1 and E2 differ by a constant, false
14572 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14575 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
14578 HOST_WIDE_INT bitpos1, bitpos2;
14579 tree toffset1, toffset2, tdiff, type;
14581 core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
14582 core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
14584 if (bitpos1 % BITS_PER_UNIT != 0
14585 || bitpos2 % BITS_PER_UNIT != 0
14586 || !operand_equal_p (core1, core2, 0))
14589 if (toffset1 && toffset2)
14591 type = TREE_TYPE (toffset1);
14592 if (type != TREE_TYPE (toffset2))
14593 toffset2 = fold_convert (type, toffset2);
14595 tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
14596 if (!cst_and_fits_in_hwi (tdiff))
14599 *diff = int_cst_value (tdiff);
14601 else if (toffset1 || toffset2)
14603 /* If only one of the offsets is non-constant, the difference cannot
14610 *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
14614 /* Return OFF converted to a pointer offset type suitable as offset for
14615 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14617 convert_to_ptrofftype_loc (location_t loc, tree off)
14619 return fold_convert_loc (loc, sizetype, off);
14622 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14624 fold_build_pointer_plus_loc (location_t loc, tree ptr, tree off)
14626 return fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (ptr),
14627 ptr, convert_to_ptrofftype_loc (loc, off));
14630 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14632 fold_build_pointer_plus_hwi_loc (location_t loc, tree ptr, HOST_WIDE_INT off)
14634 return fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (ptr),
14635 ptr, size_int (off));
14638 /* Return a char pointer for a C string if it is a string constant
14639 or sum of string constant and integer constant. */
14642 c_getstr (tree src)
14646 src = string_constant (src, &offset_node);
14650 if (offset_node == 0)
14651 return TREE_STRING_POINTER (src);
14652 else if (!tree_fits_uhwi_p (offset_node)
14653 || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
14656 return TREE_STRING_POINTER (src) + tree_to_uhwi (offset_node);