1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2014 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"
49 #include "stor-layout.h"
51 #include "tree-iterator.h"
57 #include "diagnostic-core.h"
59 #include "langhooks.h"
66 #include "hard-reg-set.h"
69 #include "basic-block.h"
70 #include "tree-ssa-alias.h"
71 #include "internal-fn.h"
73 #include "gimple-expr.h"
78 #include "hash-table.h" /* Required for ENABLE_FOLD_CHECKING. */
81 #include "plugin-api.h"
84 #include "generic-match.h"
87 /* Nonzero if we are folding constants inside an initializer; zero
89 int folding_initializer = 0;
91 /* The following constants represent a bit based encoding of GCC's
92 comparison operators. This encoding simplifies transformations
93 on relational comparison operators, such as AND and OR. */
94 enum comparison_code {
113 static bool negate_mathfn_p (enum built_in_function);
114 static bool negate_expr_p (tree);
115 static tree negate_expr (tree);
116 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
117 static tree associate_trees (location_t, tree, tree, enum tree_code, tree);
118 static tree const_binop (enum tree_code, tree, tree);
119 static enum comparison_code comparison_to_compcode (enum tree_code);
120 static enum tree_code compcode_to_comparison (enum comparison_code);
121 static int operand_equal_for_comparison_p (tree, tree, tree);
122 static int twoval_comparison_p (tree, tree *, tree *, int *);
123 static tree eval_subst (location_t, tree, tree, tree, tree, tree);
124 static tree pedantic_omit_one_operand_loc (location_t, tree, tree, tree);
125 static tree distribute_bit_expr (location_t, enum tree_code, tree, tree, tree);
126 static tree make_bit_field_ref (location_t, tree, tree,
127 HOST_WIDE_INT, HOST_WIDE_INT, int);
128 static tree optimize_bit_field_compare (location_t, enum tree_code,
130 static tree decode_field_reference (location_t, tree, HOST_WIDE_INT *,
132 machine_mode *, int *, int *,
134 static tree sign_bit_p (tree, const_tree);
135 static int simple_operand_p (const_tree);
136 static bool simple_operand_p_2 (tree);
137 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
138 static tree range_predecessor (tree);
139 static tree range_successor (tree);
140 static tree fold_range_test (location_t, enum tree_code, tree, tree, tree);
141 static tree fold_cond_expr_with_comparison (location_t, tree, tree, tree, tree);
142 static tree unextend (tree, int, int, tree);
143 static tree optimize_minmax_comparison (location_t, enum tree_code,
145 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
146 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
147 static tree fold_binary_op_with_conditional_arg (location_t,
148 enum tree_code, tree,
151 static tree fold_mathfn_compare (location_t,
152 enum built_in_function, enum tree_code,
154 static tree fold_inf_compare (location_t, enum tree_code, tree, tree, tree);
155 static tree fold_div_compare (location_t, enum tree_code, tree, tree, tree);
156 static bool reorder_operands_p (const_tree, const_tree);
157 static tree fold_negate_const (tree, tree);
158 static tree fold_not_const (const_tree, tree);
159 static tree fold_relational_const (enum tree_code, tree, tree, tree);
160 static tree fold_convert_const (enum tree_code, tree, tree);
162 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
163 Otherwise, return LOC. */
166 expr_location_or (tree t, location_t loc)
168 location_t tloc = EXPR_LOCATION (t);
169 return tloc == UNKNOWN_LOCATION ? loc : tloc;
172 /* Similar to protected_set_expr_location, but never modify x in place,
173 if location can and needs to be set, unshare it. */
176 protected_set_expr_location_unshare (tree x, location_t loc)
178 if (CAN_HAVE_LOCATION_P (x)
179 && EXPR_LOCATION (x) != loc
180 && !(TREE_CODE (x) == SAVE_EXPR
181 || TREE_CODE (x) == TARGET_EXPR
182 || TREE_CODE (x) == BIND_EXPR))
185 SET_EXPR_LOCATION (x, loc);
190 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
191 division and returns the quotient. Otherwise returns
195 div_if_zero_remainder (const_tree arg1, const_tree arg2)
199 if (wi::multiple_of_p (wi::to_widest (arg1), wi::to_widest (arg2),
201 return wide_int_to_tree (TREE_TYPE (arg1), quo);
206 /* This is nonzero if we should defer warnings about undefined
207 overflow. This facility exists because these warnings are a
208 special case. The code to estimate loop iterations does not want
209 to issue any warnings, since it works with expressions which do not
210 occur in user code. Various bits of cleanup code call fold(), but
211 only use the result if it has certain characteristics (e.g., is a
212 constant); that code only wants to issue a warning if the result is
215 static int fold_deferring_overflow_warnings;
217 /* If a warning about undefined overflow is deferred, this is the
218 warning. Note that this may cause us to turn two warnings into
219 one, but that is fine since it is sufficient to only give one
220 warning per expression. */
222 static const char* fold_deferred_overflow_warning;
224 /* If a warning about undefined overflow is deferred, this is the
225 level at which the warning should be emitted. */
227 static enum warn_strict_overflow_code fold_deferred_overflow_code;
229 /* Start deferring overflow warnings. We could use a stack here to
230 permit nested calls, but at present it is not necessary. */
233 fold_defer_overflow_warnings (void)
235 ++fold_deferring_overflow_warnings;
238 /* Stop deferring overflow warnings. If there is a pending warning,
239 and ISSUE is true, then issue the warning if appropriate. STMT is
240 the statement with which the warning should be associated (used for
241 location information); STMT may be NULL. CODE is the level of the
242 warning--a warn_strict_overflow_code value. This function will use
243 the smaller of CODE and the deferred code when deciding whether to
244 issue the warning. CODE may be zero to mean to always use the
248 fold_undefer_overflow_warnings (bool issue, const_gimple stmt, int code)
253 gcc_assert (fold_deferring_overflow_warnings > 0);
254 --fold_deferring_overflow_warnings;
255 if (fold_deferring_overflow_warnings > 0)
257 if (fold_deferred_overflow_warning != NULL
259 && code < (int) fold_deferred_overflow_code)
260 fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
264 warnmsg = fold_deferred_overflow_warning;
265 fold_deferred_overflow_warning = NULL;
267 if (!issue || warnmsg == NULL)
270 if (gimple_no_warning_p (stmt))
273 /* Use the smallest code level when deciding to issue the
275 if (code == 0 || code > (int) fold_deferred_overflow_code)
276 code = fold_deferred_overflow_code;
278 if (!issue_strict_overflow_warning (code))
282 locus = input_location;
284 locus = gimple_location (stmt);
285 warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
288 /* Stop deferring overflow warnings, ignoring any deferred
292 fold_undefer_and_ignore_overflow_warnings (void)
294 fold_undefer_overflow_warnings (false, NULL, 0);
297 /* Whether we are deferring overflow warnings. */
300 fold_deferring_overflow_warnings_p (void)
302 return fold_deferring_overflow_warnings > 0;
305 /* This is called when we fold something based on the fact that signed
306 overflow is undefined. */
309 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
311 if (fold_deferring_overflow_warnings > 0)
313 if (fold_deferred_overflow_warning == NULL
314 || wc < fold_deferred_overflow_code)
316 fold_deferred_overflow_warning = gmsgid;
317 fold_deferred_overflow_code = wc;
320 else if (issue_strict_overflow_warning (wc))
321 warning (OPT_Wstrict_overflow, gmsgid);
324 /* Return true if the built-in mathematical function specified by CODE
325 is odd, i.e. -f(x) == f(-x). */
328 negate_mathfn_p (enum built_in_function code)
332 CASE_FLT_FN (BUILT_IN_ASIN):
333 CASE_FLT_FN (BUILT_IN_ASINH):
334 CASE_FLT_FN (BUILT_IN_ATAN):
335 CASE_FLT_FN (BUILT_IN_ATANH):
336 CASE_FLT_FN (BUILT_IN_CASIN):
337 CASE_FLT_FN (BUILT_IN_CASINH):
338 CASE_FLT_FN (BUILT_IN_CATAN):
339 CASE_FLT_FN (BUILT_IN_CATANH):
340 CASE_FLT_FN (BUILT_IN_CBRT):
341 CASE_FLT_FN (BUILT_IN_CPROJ):
342 CASE_FLT_FN (BUILT_IN_CSIN):
343 CASE_FLT_FN (BUILT_IN_CSINH):
344 CASE_FLT_FN (BUILT_IN_CTAN):
345 CASE_FLT_FN (BUILT_IN_CTANH):
346 CASE_FLT_FN (BUILT_IN_ERF):
347 CASE_FLT_FN (BUILT_IN_LLROUND):
348 CASE_FLT_FN (BUILT_IN_LROUND):
349 CASE_FLT_FN (BUILT_IN_ROUND):
350 CASE_FLT_FN (BUILT_IN_SIN):
351 CASE_FLT_FN (BUILT_IN_SINH):
352 CASE_FLT_FN (BUILT_IN_TAN):
353 CASE_FLT_FN (BUILT_IN_TANH):
354 CASE_FLT_FN (BUILT_IN_TRUNC):
357 CASE_FLT_FN (BUILT_IN_LLRINT):
358 CASE_FLT_FN (BUILT_IN_LRINT):
359 CASE_FLT_FN (BUILT_IN_NEARBYINT):
360 CASE_FLT_FN (BUILT_IN_RINT):
361 return !flag_rounding_math;
369 /* Check whether we may negate an integer constant T without causing
373 may_negate_without_overflow_p (const_tree t)
377 gcc_assert (TREE_CODE (t) == INTEGER_CST);
379 type = TREE_TYPE (t);
380 if (TYPE_UNSIGNED (type))
383 return !wi::only_sign_bit_p (t);
386 /* Determine whether an expression T can be cheaply negated using
387 the function negate_expr without introducing undefined overflow. */
390 negate_expr_p (tree t)
397 type = TREE_TYPE (t);
400 switch (TREE_CODE (t))
403 if (TYPE_OVERFLOW_WRAPS (type))
406 /* Check that -CST will not overflow type. */
407 return may_negate_without_overflow_p (t);
409 return (INTEGRAL_TYPE_P (type)
410 && TYPE_OVERFLOW_WRAPS (type));
417 /* We want to canonicalize to positive real constants. Pretend
418 that only negative ones can be easily negated. */
419 return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
422 return negate_expr_p (TREE_REALPART (t))
423 && negate_expr_p (TREE_IMAGPART (t));
427 if (FLOAT_TYPE_P (TREE_TYPE (type)) || TYPE_OVERFLOW_WRAPS (type))
430 int count = TYPE_VECTOR_SUBPARTS (type), i;
432 for (i = 0; i < count; i++)
433 if (!negate_expr_p (VECTOR_CST_ELT (t, i)))
440 return negate_expr_p (TREE_OPERAND (t, 0))
441 && negate_expr_p (TREE_OPERAND (t, 1));
444 return negate_expr_p (TREE_OPERAND (t, 0));
447 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
448 || HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
450 /* -(A + B) -> (-B) - A. */
451 if (negate_expr_p (TREE_OPERAND (t, 1))
452 && reorder_operands_p (TREE_OPERAND (t, 0),
453 TREE_OPERAND (t, 1)))
455 /* -(A + B) -> (-A) - B. */
456 return negate_expr_p (TREE_OPERAND (t, 0));
459 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
460 return !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
461 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
462 && reorder_operands_p (TREE_OPERAND (t, 0),
463 TREE_OPERAND (t, 1));
466 if (TYPE_UNSIGNED (TREE_TYPE (t)))
472 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
473 return negate_expr_p (TREE_OPERAND (t, 1))
474 || negate_expr_p (TREE_OPERAND (t, 0));
480 /* In general we can't negate A / B, because if A is INT_MIN and
481 B is 1, we may turn this into INT_MIN / -1 which is undefined
482 and actually traps on some architectures. But if overflow is
483 undefined, we can negate, because - (INT_MIN / 1) is an
485 if (INTEGRAL_TYPE_P (TREE_TYPE (t)))
487 if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
489 /* If overflow is undefined then we have to be careful because
490 we ask whether it's ok to associate the negate with the
491 division which is not ok for example for
492 -((a - b) / c) where (-(a - b)) / c may invoke undefined
493 overflow because of negating INT_MIN. So do not use
494 negate_expr_p here but open-code the two important cases. */
495 if (TREE_CODE (TREE_OPERAND (t, 0)) == NEGATE_EXPR
496 || (TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST
497 && may_negate_without_overflow_p (TREE_OPERAND (t, 0))))
500 else if (negate_expr_p (TREE_OPERAND (t, 0)))
502 return negate_expr_p (TREE_OPERAND (t, 1));
505 /* Negate -((double)float) as (double)(-float). */
506 if (TREE_CODE (type) == REAL_TYPE)
508 tree tem = strip_float_extensions (t);
510 return negate_expr_p (tem);
515 /* Negate -f(x) as f(-x). */
516 if (negate_mathfn_p (builtin_mathfn_code (t)))
517 return negate_expr_p (CALL_EXPR_ARG (t, 0));
521 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
522 if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
524 tree op1 = TREE_OPERAND (t, 1);
525 if (wi::eq_p (op1, TYPE_PRECISION (type) - 1))
536 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
537 simplification is possible.
538 If negate_expr_p would return true for T, NULL_TREE will never be
542 fold_negate_expr (location_t loc, tree t)
544 tree type = TREE_TYPE (t);
547 switch (TREE_CODE (t))
549 /* Convert - (~A) to A + 1. */
551 if (INTEGRAL_TYPE_P (type))
552 return fold_build2_loc (loc, PLUS_EXPR, type, TREE_OPERAND (t, 0),
553 build_one_cst (type));
557 tem = fold_negate_const (t, type);
558 if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
559 || !TYPE_OVERFLOW_TRAPS (type))
564 tem = fold_negate_const (t, type);
565 /* Two's complement FP formats, such as c4x, may overflow. */
566 if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
571 tem = fold_negate_const (t, type);
576 tree rpart = negate_expr (TREE_REALPART (t));
577 tree ipart = negate_expr (TREE_IMAGPART (t));
579 if ((TREE_CODE (rpart) == REAL_CST
580 && TREE_CODE (ipart) == REAL_CST)
581 || (TREE_CODE (rpart) == INTEGER_CST
582 && TREE_CODE (ipart) == INTEGER_CST))
583 return build_complex (type, rpart, ipart);
589 int count = TYPE_VECTOR_SUBPARTS (type), i;
590 tree *elts = XALLOCAVEC (tree, count);
592 for (i = 0; i < count; i++)
594 elts[i] = fold_negate_expr (loc, VECTOR_CST_ELT (t, i));
595 if (elts[i] == NULL_TREE)
599 return build_vector (type, elts);
603 if (negate_expr_p (t))
604 return fold_build2_loc (loc, COMPLEX_EXPR, type,
605 fold_negate_expr (loc, TREE_OPERAND (t, 0)),
606 fold_negate_expr (loc, TREE_OPERAND (t, 1)));
610 if (negate_expr_p (t))
611 return fold_build1_loc (loc, CONJ_EXPR, type,
612 fold_negate_expr (loc, TREE_OPERAND (t, 0)));
616 return TREE_OPERAND (t, 0);
619 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
620 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
622 /* -(A + B) -> (-B) - A. */
623 if (negate_expr_p (TREE_OPERAND (t, 1))
624 && reorder_operands_p (TREE_OPERAND (t, 0),
625 TREE_OPERAND (t, 1)))
627 tem = negate_expr (TREE_OPERAND (t, 1));
628 return fold_build2_loc (loc, MINUS_EXPR, type,
629 tem, TREE_OPERAND (t, 0));
632 /* -(A + B) -> (-A) - B. */
633 if (negate_expr_p (TREE_OPERAND (t, 0)))
635 tem = negate_expr (TREE_OPERAND (t, 0));
636 return fold_build2_loc (loc, MINUS_EXPR, type,
637 tem, TREE_OPERAND (t, 1));
643 /* - (A - B) -> B - A */
644 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
645 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
646 && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
647 return fold_build2_loc (loc, MINUS_EXPR, type,
648 TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
652 if (TYPE_UNSIGNED (type))
658 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
660 tem = TREE_OPERAND (t, 1);
661 if (negate_expr_p (tem))
662 return fold_build2_loc (loc, TREE_CODE (t), type,
663 TREE_OPERAND (t, 0), negate_expr (tem));
664 tem = TREE_OPERAND (t, 0);
665 if (negate_expr_p (tem))
666 return fold_build2_loc (loc, TREE_CODE (t), type,
667 negate_expr (tem), TREE_OPERAND (t, 1));
674 /* In general we can't negate A / B, because if A is INT_MIN and
675 B is 1, we may turn this into INT_MIN / -1 which is undefined
676 and actually traps on some architectures. But if overflow is
677 undefined, we can negate, because - (INT_MIN / 1) is an
679 if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
681 const char * const warnmsg = G_("assuming signed overflow does not "
682 "occur when negating a division");
683 tem = TREE_OPERAND (t, 1);
684 if (negate_expr_p (tem))
686 if (INTEGRAL_TYPE_P (type)
687 && (TREE_CODE (tem) != INTEGER_CST
688 || integer_onep (tem)))
689 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
690 return fold_build2_loc (loc, TREE_CODE (t), type,
691 TREE_OPERAND (t, 0), negate_expr (tem));
693 /* If overflow is undefined then we have to be careful because
694 we ask whether it's ok to associate the negate with the
695 division which is not ok for example for
696 -((a - b) / c) where (-(a - b)) / c may invoke undefined
697 overflow because of negating INT_MIN. So do not use
698 negate_expr_p here but open-code the two important cases. */
699 tem = TREE_OPERAND (t, 0);
700 if ((INTEGRAL_TYPE_P (type)
701 && (TREE_CODE (tem) == NEGATE_EXPR
702 || (TREE_CODE (tem) == INTEGER_CST
703 && may_negate_without_overflow_p (tem))))
704 || !INTEGRAL_TYPE_P (type))
705 return fold_build2_loc (loc, TREE_CODE (t), type,
706 negate_expr (tem), TREE_OPERAND (t, 1));
711 /* Convert -((double)float) into (double)(-float). */
712 if (TREE_CODE (type) == REAL_TYPE)
714 tem = strip_float_extensions (t);
715 if (tem != t && negate_expr_p (tem))
716 return fold_convert_loc (loc, type, negate_expr (tem));
721 /* Negate -f(x) as f(-x). */
722 if (negate_mathfn_p (builtin_mathfn_code (t))
723 && negate_expr_p (CALL_EXPR_ARG (t, 0)))
727 fndecl = get_callee_fndecl (t);
728 arg = negate_expr (CALL_EXPR_ARG (t, 0));
729 return build_call_expr_loc (loc, fndecl, 1, arg);
734 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
735 if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
737 tree op1 = TREE_OPERAND (t, 1);
738 if (wi::eq_p (op1, TYPE_PRECISION (type) - 1))
740 tree ntype = TYPE_UNSIGNED (type)
741 ? signed_type_for (type)
742 : unsigned_type_for (type);
743 tree temp = fold_convert_loc (loc, ntype, TREE_OPERAND (t, 0));
744 temp = fold_build2_loc (loc, RSHIFT_EXPR, ntype, temp, op1);
745 return fold_convert_loc (loc, type, temp);
757 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
758 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
770 loc = EXPR_LOCATION (t);
771 type = TREE_TYPE (t);
774 tem = fold_negate_expr (loc, t);
776 tem = build1_loc (loc, NEGATE_EXPR, TREE_TYPE (t), t);
777 return fold_convert_loc (loc, type, tem);
780 /* Split a tree IN into a constant, literal and variable parts that could be
781 combined with CODE to make IN. "constant" means an expression with
782 TREE_CONSTANT but that isn't an actual constant. CODE must be a
783 commutative arithmetic operation. Store the constant part into *CONP,
784 the literal in *LITP and return the variable part. If a part isn't
785 present, set it to null. If the tree does not decompose in this way,
786 return the entire tree as the variable part and the other parts as null.
788 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
789 case, we negate an operand that was subtracted. Except if it is a
790 literal for which we use *MINUS_LITP instead.
792 If NEGATE_P is true, we are negating all of IN, again except a literal
793 for which we use *MINUS_LITP instead.
795 If IN is itself a literal or constant, return it as appropriate.
797 Note that we do not guarantee that any of the three values will be the
798 same type as IN, but they will have the same signedness and mode. */
801 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
802 tree *minus_litp, int negate_p)
810 /* Strip any conversions that don't change the machine mode or signedness. */
811 STRIP_SIGN_NOPS (in);
813 if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
814 || TREE_CODE (in) == FIXED_CST)
816 else if (TREE_CODE (in) == code
817 || ((! FLOAT_TYPE_P (TREE_TYPE (in)) || flag_associative_math)
818 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
819 /* We can associate addition and subtraction together (even
820 though the C standard doesn't say so) for integers because
821 the value is not affected. For reals, the value might be
822 affected, so we can't. */
823 && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
824 || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
826 tree op0 = TREE_OPERAND (in, 0);
827 tree op1 = TREE_OPERAND (in, 1);
828 int neg1_p = TREE_CODE (in) == MINUS_EXPR;
829 int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
831 /* First see if either of the operands is a literal, then a constant. */
832 if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
833 || TREE_CODE (op0) == FIXED_CST)
834 *litp = op0, op0 = 0;
835 else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
836 || TREE_CODE (op1) == FIXED_CST)
837 *litp = op1, neg_litp_p = neg1_p, op1 = 0;
839 if (op0 != 0 && TREE_CONSTANT (op0))
840 *conp = op0, op0 = 0;
841 else if (op1 != 0 && TREE_CONSTANT (op1))
842 *conp = op1, neg_conp_p = neg1_p, op1 = 0;
844 /* If we haven't dealt with either operand, this is not a case we can
845 decompose. Otherwise, VAR is either of the ones remaining, if any. */
846 if (op0 != 0 && op1 != 0)
851 var = op1, neg_var_p = neg1_p;
853 /* Now do any needed negations. */
855 *minus_litp = *litp, *litp = 0;
857 *conp = negate_expr (*conp);
859 var = negate_expr (var);
861 else if (TREE_CODE (in) == BIT_NOT_EXPR
862 && code == PLUS_EXPR)
864 /* -X - 1 is folded to ~X, undo that here. */
865 *minus_litp = build_one_cst (TREE_TYPE (in));
866 var = negate_expr (TREE_OPERAND (in, 0));
868 else if (TREE_CONSTANT (in))
876 *minus_litp = *litp, *litp = 0;
877 else if (*minus_litp)
878 *litp = *minus_litp, *minus_litp = 0;
879 *conp = negate_expr (*conp);
880 var = negate_expr (var);
886 /* Re-associate trees split by the above function. T1 and T2 are
887 either expressions to associate or null. Return the new
888 expression, if any. LOC is the location of the new expression. If
889 we build an operation, do it in TYPE and with CODE. */
892 associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree type)
899 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
900 try to fold this since we will have infinite recursion. But do
901 deal with any NEGATE_EXPRs. */
902 if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
903 || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
905 if (code == PLUS_EXPR)
907 if (TREE_CODE (t1) == NEGATE_EXPR)
908 return build2_loc (loc, MINUS_EXPR, type,
909 fold_convert_loc (loc, type, t2),
910 fold_convert_loc (loc, type,
911 TREE_OPERAND (t1, 0)));
912 else if (TREE_CODE (t2) == NEGATE_EXPR)
913 return build2_loc (loc, MINUS_EXPR, type,
914 fold_convert_loc (loc, type, t1),
915 fold_convert_loc (loc, type,
916 TREE_OPERAND (t2, 0)));
917 else if (integer_zerop (t2))
918 return fold_convert_loc (loc, type, t1);
920 else if (code == MINUS_EXPR)
922 if (integer_zerop (t2))
923 return fold_convert_loc (loc, type, t1);
926 return build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
927 fold_convert_loc (loc, type, t2));
930 return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
931 fold_convert_loc (loc, type, t2));
934 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
935 for use in int_const_binop, size_binop and size_diffop. */
938 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
940 if (!INTEGRAL_TYPE_P (type1) && !POINTER_TYPE_P (type1))
942 if (!INTEGRAL_TYPE_P (type2) && !POINTER_TYPE_P (type2))
957 return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
958 && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
959 && TYPE_MODE (type1) == TYPE_MODE (type2);
963 /* Combine two integer constants ARG1 and ARG2 under operation CODE
964 to produce a new constant. Return NULL_TREE if we don't know how
965 to evaluate CODE at compile-time. */
968 int_const_binop_1 (enum tree_code code, const_tree arg1, const_tree parg2,
973 tree type = TREE_TYPE (arg1);
974 signop sign = TYPE_SIGN (type);
975 bool overflow = false;
977 wide_int arg2 = wide_int::from (parg2, TYPE_PRECISION (type),
978 TYPE_SIGN (TREE_TYPE (parg2)));
983 res = wi::bit_or (arg1, arg2);
987 res = wi::bit_xor (arg1, arg2);
991 res = wi::bit_and (arg1, arg2);
996 if (wi::neg_p (arg2))
999 if (code == RSHIFT_EXPR)
1005 if (code == RSHIFT_EXPR)
1006 /* It's unclear from the C standard whether shifts can overflow.
1007 The following code ignores overflow; perhaps a C standard
1008 interpretation ruling is needed. */
1009 res = wi::rshift (arg1, arg2, sign);
1011 res = wi::lshift (arg1, arg2);
1016 if (wi::neg_p (arg2))
1019 if (code == RROTATE_EXPR)
1020 code = LROTATE_EXPR;
1022 code = RROTATE_EXPR;
1025 if (code == RROTATE_EXPR)
1026 res = wi::rrotate (arg1, arg2);
1028 res = wi::lrotate (arg1, arg2);
1032 res = wi::add (arg1, arg2, sign, &overflow);
1036 res = wi::sub (arg1, arg2, sign, &overflow);
1040 res = wi::mul (arg1, arg2, sign, &overflow);
1043 case MULT_HIGHPART_EXPR:
1044 res = wi::mul_high (arg1, arg2, sign);
1047 case TRUNC_DIV_EXPR:
1048 case EXACT_DIV_EXPR:
1051 res = wi::div_trunc (arg1, arg2, sign, &overflow);
1054 case FLOOR_DIV_EXPR:
1057 res = wi::div_floor (arg1, arg2, sign, &overflow);
1063 res = wi::div_ceil (arg1, arg2, sign, &overflow);
1066 case ROUND_DIV_EXPR:
1069 res = wi::div_round (arg1, arg2, sign, &overflow);
1072 case TRUNC_MOD_EXPR:
1075 res = wi::mod_trunc (arg1, arg2, sign, &overflow);
1078 case FLOOR_MOD_EXPR:
1081 res = wi::mod_floor (arg1, arg2, sign, &overflow);
1087 res = wi::mod_ceil (arg1, arg2, sign, &overflow);
1090 case ROUND_MOD_EXPR:
1093 res = wi::mod_round (arg1, arg2, sign, &overflow);
1097 res = wi::min (arg1, arg2, sign);
1101 res = wi::max (arg1, arg2, sign);
1108 t = force_fit_type (type, res, overflowable,
1109 (((sign == SIGNED || overflowable == -1)
1111 | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (parg2)));
1117 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2)
1119 return int_const_binop_1 (code, arg1, arg2, 1);
1122 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1123 constant. We assume ARG1 and ARG2 have the same data type, or at least
1124 are the same kind of constant and the same machine mode. Return zero if
1125 combining the constants is not allowed in the current operating mode. */
1128 const_binop (enum tree_code code, tree arg1, tree arg2)
1130 /* Sanity check for the recursive cases. */
1137 if (TREE_CODE (arg1) == INTEGER_CST)
1138 return int_const_binop (code, arg1, arg2);
1140 if (TREE_CODE (arg1) == REAL_CST)
1145 REAL_VALUE_TYPE value;
1146 REAL_VALUE_TYPE result;
1150 /* The following codes are handled by real_arithmetic. */
1165 d1 = TREE_REAL_CST (arg1);
1166 d2 = TREE_REAL_CST (arg2);
1168 type = TREE_TYPE (arg1);
1169 mode = TYPE_MODE (type);
1171 /* Don't perform operation if we honor signaling NaNs and
1172 either operand is a NaN. */
1173 if (HONOR_SNANS (mode)
1174 && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1177 /* Don't perform operation if it would raise a division
1178 by zero exception. */
1179 if (code == RDIV_EXPR
1180 && REAL_VALUES_EQUAL (d2, dconst0)
1181 && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1184 /* If either operand is a NaN, just return it. Otherwise, set up
1185 for floating-point trap; we return an overflow. */
1186 if (REAL_VALUE_ISNAN (d1))
1188 else if (REAL_VALUE_ISNAN (d2))
1191 inexact = real_arithmetic (&value, code, &d1, &d2);
1192 real_convert (&result, mode, &value);
1194 /* Don't constant fold this floating point operation if
1195 the result has overflowed and flag_trapping_math. */
1196 if (flag_trapping_math
1197 && MODE_HAS_INFINITIES (mode)
1198 && REAL_VALUE_ISINF (result)
1199 && !REAL_VALUE_ISINF (d1)
1200 && !REAL_VALUE_ISINF (d2))
1203 /* Don't constant fold this floating point operation if the
1204 result may dependent upon the run-time rounding mode and
1205 flag_rounding_math is set, or if GCC's software emulation
1206 is unable to accurately represent the result. */
1207 if ((flag_rounding_math
1208 || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
1209 && (inexact || !real_identical (&result, &value)))
1212 t = build_real (type, result);
1214 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1218 if (TREE_CODE (arg1) == FIXED_CST)
1220 FIXED_VALUE_TYPE f1;
1221 FIXED_VALUE_TYPE f2;
1222 FIXED_VALUE_TYPE result;
1227 /* The following codes are handled by fixed_arithmetic. */
1233 case TRUNC_DIV_EXPR:
1234 f2 = TREE_FIXED_CST (arg2);
1241 f2.data.high = w2.elt (1);
1242 f2.data.low = w2.elt (0);
1251 f1 = TREE_FIXED_CST (arg1);
1252 type = TREE_TYPE (arg1);
1253 sat_p = TYPE_SATURATING (type);
1254 overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1255 t = build_fixed (type, result);
1256 /* Propagate overflow flags. */
1257 if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1258 TREE_OVERFLOW (t) = 1;
1262 if (TREE_CODE (arg1) == COMPLEX_CST)
1264 tree type = TREE_TYPE (arg1);
1265 tree r1 = TREE_REALPART (arg1);
1266 tree i1 = TREE_IMAGPART (arg1);
1267 tree r2 = TREE_REALPART (arg2);
1268 tree i2 = TREE_IMAGPART (arg2);
1275 real = const_binop (code, r1, r2);
1276 imag = const_binop (code, i1, i2);
1280 if (COMPLEX_FLOAT_TYPE_P (type))
1281 return do_mpc_arg2 (arg1, arg2, type,
1282 /* do_nonfinite= */ folding_initializer,
1285 real = const_binop (MINUS_EXPR,
1286 const_binop (MULT_EXPR, r1, r2),
1287 const_binop (MULT_EXPR, i1, i2));
1288 imag = const_binop (PLUS_EXPR,
1289 const_binop (MULT_EXPR, r1, i2),
1290 const_binop (MULT_EXPR, i1, r2));
1294 if (COMPLEX_FLOAT_TYPE_P (type))
1295 return do_mpc_arg2 (arg1, arg2, type,
1296 /* do_nonfinite= */ folding_initializer,
1299 case TRUNC_DIV_EXPR:
1301 case FLOOR_DIV_EXPR:
1302 case ROUND_DIV_EXPR:
1303 if (flag_complex_method == 0)
1305 /* Keep this algorithm in sync with
1306 tree-complex.c:expand_complex_div_straight().
1308 Expand complex division to scalars, straightforward algorithm.
1309 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1313 = const_binop (PLUS_EXPR,
1314 const_binop (MULT_EXPR, r2, r2),
1315 const_binop (MULT_EXPR, i2, i2));
1317 = const_binop (PLUS_EXPR,
1318 const_binop (MULT_EXPR, r1, r2),
1319 const_binop (MULT_EXPR, i1, i2));
1321 = const_binop (MINUS_EXPR,
1322 const_binop (MULT_EXPR, i1, r2),
1323 const_binop (MULT_EXPR, r1, i2));
1325 real = const_binop (code, t1, magsquared);
1326 imag = const_binop (code, t2, magsquared);
1330 /* Keep this algorithm in sync with
1331 tree-complex.c:expand_complex_div_wide().
1333 Expand complex division to scalars, modified algorithm to minimize
1334 overflow with wide input ranges. */
1335 tree compare = fold_build2 (LT_EXPR, boolean_type_node,
1336 fold_abs_const (r2, TREE_TYPE (type)),
1337 fold_abs_const (i2, TREE_TYPE (type)));
1339 if (integer_nonzerop (compare))
1341 /* In the TRUE branch, we compute
1343 div = (br * ratio) + bi;
1344 tr = (ar * ratio) + ai;
1345 ti = (ai * ratio) - ar;
1348 tree ratio = const_binop (code, r2, i2);
1349 tree div = const_binop (PLUS_EXPR, i2,
1350 const_binop (MULT_EXPR, r2, ratio));
1351 real = const_binop (MULT_EXPR, r1, ratio);
1352 real = const_binop (PLUS_EXPR, real, i1);
1353 real = const_binop (code, real, div);
1355 imag = const_binop (MULT_EXPR, i1, ratio);
1356 imag = const_binop (MINUS_EXPR, imag, r1);
1357 imag = const_binop (code, imag, div);
1361 /* In the FALSE branch, we compute
1363 divisor = (d * ratio) + c;
1364 tr = (b * ratio) + a;
1365 ti = b - (a * ratio);
1368 tree ratio = const_binop (code, i2, r2);
1369 tree div = const_binop (PLUS_EXPR, r2,
1370 const_binop (MULT_EXPR, i2, ratio));
1372 real = const_binop (MULT_EXPR, i1, ratio);
1373 real = const_binop (PLUS_EXPR, real, r1);
1374 real = const_binop (code, real, div);
1376 imag = const_binop (MULT_EXPR, r1, ratio);
1377 imag = const_binop (MINUS_EXPR, i1, imag);
1378 imag = const_binop (code, imag, div);
1388 return build_complex (type, real, imag);
1391 if (TREE_CODE (arg1) == VECTOR_CST
1392 && TREE_CODE (arg2) == VECTOR_CST)
1394 tree type = TREE_TYPE (arg1);
1395 int count = TYPE_VECTOR_SUBPARTS (type), i;
1396 tree *elts = XALLOCAVEC (tree, count);
1398 for (i = 0; i < count; i++)
1400 tree elem1 = VECTOR_CST_ELT (arg1, i);
1401 tree elem2 = VECTOR_CST_ELT (arg2, i);
1403 elts[i] = const_binop (code, elem1, elem2);
1405 /* It is possible that const_binop cannot handle the given
1406 code and return NULL_TREE */
1407 if (elts[i] == NULL_TREE)
1411 return build_vector (type, elts);
1414 /* Shifts allow a scalar offset for a vector. */
1415 if (TREE_CODE (arg1) == VECTOR_CST
1416 && TREE_CODE (arg2) == INTEGER_CST)
1418 tree type = TREE_TYPE (arg1);
1419 int count = TYPE_VECTOR_SUBPARTS (type), i;
1420 tree *elts = XALLOCAVEC (tree, count);
1422 if (code == VEC_RSHIFT_EXPR)
1424 if (!tree_fits_uhwi_p (arg2))
1427 unsigned HOST_WIDE_INT shiftc = tree_to_uhwi (arg2);
1428 unsigned HOST_WIDE_INT outerc = tree_to_uhwi (TYPE_SIZE (type));
1429 unsigned HOST_WIDE_INT innerc
1430 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type)));
1431 if (shiftc >= outerc || (shiftc % innerc) != 0)
1433 int offset = shiftc / innerc;
1434 /* The direction of VEC_RSHIFT_EXPR is endian dependent.
1435 For reductions, if !BYTES_BIG_ENDIAN then compiler picks first
1436 vector element, but last element if BYTES_BIG_ENDIAN. */
1437 if (BYTES_BIG_ENDIAN)
1439 tree zero = build_zero_cst (TREE_TYPE (type));
1440 for (i = 0; i < count; i++)
1442 if (i + offset < 0 || i + offset >= count)
1445 elts[i] = VECTOR_CST_ELT (arg1, i + offset);
1449 for (i = 0; i < count; i++)
1451 tree elem1 = VECTOR_CST_ELT (arg1, i);
1453 elts[i] = const_binop (code, elem1, arg2);
1455 /* It is possible that const_binop cannot handle the given
1456 code and return NULL_TREE */
1457 if (elts[i] == NULL_TREE)
1461 return build_vector (type, elts);
1466 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1467 indicates which particular sizetype to create. */
1470 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1472 return build_int_cst (sizetype_tab[(int) kind], number);
1475 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1476 is a tree code. The type of the result is taken from the operands.
1477 Both must be equivalent integer types, ala int_binop_types_match_p.
1478 If the operands are constant, so is the result. */
1481 size_binop_loc (location_t loc, enum tree_code code, tree arg0, tree arg1)
1483 tree type = TREE_TYPE (arg0);
1485 if (arg0 == error_mark_node || arg1 == error_mark_node)
1486 return error_mark_node;
1488 gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
1491 /* Handle the special case of two integer constants faster. */
1492 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1494 /* And some specific cases even faster than that. */
1495 if (code == PLUS_EXPR)
1497 if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
1499 if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1502 else if (code == MINUS_EXPR)
1504 if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1507 else if (code == MULT_EXPR)
1509 if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
1513 /* Handle general case of two integer constants. For sizetype
1514 constant calculations we always want to know about overflow,
1515 even in the unsigned case. */
1516 return int_const_binop_1 (code, arg0, arg1, -1);
1519 return fold_build2_loc (loc, code, type, arg0, arg1);
1522 /* Given two values, either both of sizetype or both of bitsizetype,
1523 compute the difference between the two values. Return the value
1524 in signed type corresponding to the type of the operands. */
1527 size_diffop_loc (location_t loc, tree arg0, tree arg1)
1529 tree type = TREE_TYPE (arg0);
1532 gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
1535 /* If the type is already signed, just do the simple thing. */
1536 if (!TYPE_UNSIGNED (type))
1537 return size_binop_loc (loc, MINUS_EXPR, arg0, arg1);
1539 if (type == sizetype)
1541 else if (type == bitsizetype)
1542 ctype = sbitsizetype;
1544 ctype = signed_type_for (type);
1546 /* If either operand is not a constant, do the conversions to the signed
1547 type and subtract. The hardware will do the right thing with any
1548 overflow in the subtraction. */
1549 if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1550 return size_binop_loc (loc, MINUS_EXPR,
1551 fold_convert_loc (loc, ctype, arg0),
1552 fold_convert_loc (loc, ctype, arg1));
1554 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1555 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1556 overflow) and negate (which can't either). Special-case a result
1557 of zero while we're here. */
1558 if (tree_int_cst_equal (arg0, arg1))
1559 return build_int_cst (ctype, 0);
1560 else if (tree_int_cst_lt (arg1, arg0))
1561 return fold_convert_loc (loc, ctype,
1562 size_binop_loc (loc, MINUS_EXPR, arg0, arg1));
1564 return size_binop_loc (loc, MINUS_EXPR, build_int_cst (ctype, 0),
1565 fold_convert_loc (loc, ctype,
1566 size_binop_loc (loc,
1571 /* A subroutine of fold_convert_const handling conversions of an
1572 INTEGER_CST to another integer type. */
1575 fold_convert_const_int_from_int (tree type, const_tree arg1)
1577 /* Given an integer constant, make new constant with new type,
1578 appropriately sign-extended or truncated. Use widest_int
1579 so that any extension is done according ARG1's type. */
1580 return force_fit_type (type, wi::to_widest (arg1),
1581 !POINTER_TYPE_P (TREE_TYPE (arg1)),
1582 TREE_OVERFLOW (arg1));
1585 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1586 to an integer type. */
1589 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
1591 bool overflow = false;
1594 /* The following code implements the floating point to integer
1595 conversion rules required by the Java Language Specification,
1596 that IEEE NaNs are mapped to zero and values that overflow
1597 the target precision saturate, i.e. values greater than
1598 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1599 are mapped to INT_MIN. These semantics are allowed by the
1600 C and C++ standards that simply state that the behavior of
1601 FP-to-integer conversion is unspecified upon overflow. */
1605 REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1609 case FIX_TRUNC_EXPR:
1610 real_trunc (&r, VOIDmode, &x);
1617 /* If R is NaN, return zero and show we have an overflow. */
1618 if (REAL_VALUE_ISNAN (r))
1621 val = wi::zero (TYPE_PRECISION (type));
1624 /* See if R is less than the lower bound or greater than the
1629 tree lt = TYPE_MIN_VALUE (type);
1630 REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
1631 if (REAL_VALUES_LESS (r, l))
1640 tree ut = TYPE_MAX_VALUE (type);
1643 REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
1644 if (REAL_VALUES_LESS (u, r))
1653 val = real_to_integer (&r, &overflow, TYPE_PRECISION (type));
1655 t = force_fit_type (type, val, -1, overflow | TREE_OVERFLOW (arg1));
1659 /* A subroutine of fold_convert_const handling conversions of a
1660 FIXED_CST to an integer type. */
1663 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
1666 double_int temp, temp_trunc;
1669 /* Right shift FIXED_CST to temp by fbit. */
1670 temp = TREE_FIXED_CST (arg1).data;
1671 mode = TREE_FIXED_CST (arg1).mode;
1672 if (GET_MODE_FBIT (mode) < HOST_BITS_PER_DOUBLE_INT)
1674 temp = temp.rshift (GET_MODE_FBIT (mode),
1675 HOST_BITS_PER_DOUBLE_INT,
1676 SIGNED_FIXED_POINT_MODE_P (mode));
1678 /* Left shift temp to temp_trunc by fbit. */
1679 temp_trunc = temp.lshift (GET_MODE_FBIT (mode),
1680 HOST_BITS_PER_DOUBLE_INT,
1681 SIGNED_FIXED_POINT_MODE_P (mode));
1685 temp = double_int_zero;
1686 temp_trunc = double_int_zero;
1689 /* If FIXED_CST is negative, we need to round the value toward 0.
1690 By checking if the fractional bits are not zero to add 1 to temp. */
1691 if (SIGNED_FIXED_POINT_MODE_P (mode)
1692 && temp_trunc.is_negative ()
1693 && TREE_FIXED_CST (arg1).data != temp_trunc)
1694 temp += double_int_one;
1696 /* Given a fixed-point constant, make new constant with new type,
1697 appropriately sign-extended or truncated. */
1698 t = force_fit_type (type, temp, -1,
1699 (temp.is_negative ()
1700 && (TYPE_UNSIGNED (type)
1701 < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1702 | TREE_OVERFLOW (arg1));
1707 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1708 to another floating point type. */
1711 fold_convert_const_real_from_real (tree type, const_tree arg1)
1713 REAL_VALUE_TYPE value;
1716 real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
1717 t = build_real (type, value);
1719 /* If converting an infinity or NAN to a representation that doesn't
1720 have one, set the overflow bit so that we can produce some kind of
1721 error message at the appropriate point if necessary. It's not the
1722 most user-friendly message, but it's better than nothing. */
1723 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1))
1724 && !MODE_HAS_INFINITIES (TYPE_MODE (type)))
1725 TREE_OVERFLOW (t) = 1;
1726 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
1727 && !MODE_HAS_NANS (TYPE_MODE (type)))
1728 TREE_OVERFLOW (t) = 1;
1729 /* Regular overflow, conversion produced an infinity in a mode that
1730 can't represent them. */
1731 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type))
1732 && REAL_VALUE_ISINF (value)
1733 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1)))
1734 TREE_OVERFLOW (t) = 1;
1736 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1740 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1741 to a floating point type. */
1744 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
1746 REAL_VALUE_TYPE value;
1749 real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
1750 t = build_real (type, value);
1752 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1756 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1757 to another fixed-point type. */
1760 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
1762 FIXED_VALUE_TYPE value;
1766 overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
1767 TYPE_SATURATING (type));
1768 t = build_fixed (type, value);
1770 /* Propagate overflow flags. */
1771 if (overflow_p | TREE_OVERFLOW (arg1))
1772 TREE_OVERFLOW (t) = 1;
1776 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
1777 to a fixed-point type. */
1780 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
1782 FIXED_VALUE_TYPE value;
1787 gcc_assert (TREE_INT_CST_NUNITS (arg1) <= 2);
1789 di.low = TREE_INT_CST_ELT (arg1, 0);
1790 if (TREE_INT_CST_NUNITS (arg1) == 1)
1791 di.high = (HOST_WIDE_INT) di.low < 0 ? (HOST_WIDE_INT) -1 : 0;
1793 di.high = TREE_INT_CST_ELT (arg1, 1);
1795 overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type), di,
1796 TYPE_UNSIGNED (TREE_TYPE (arg1)),
1797 TYPE_SATURATING (type));
1798 t = build_fixed (type, value);
1800 /* Propagate overflow flags. */
1801 if (overflow_p | TREE_OVERFLOW (arg1))
1802 TREE_OVERFLOW (t) = 1;
1806 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1807 to a fixed-point type. */
1810 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
1812 FIXED_VALUE_TYPE value;
1816 overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
1817 &TREE_REAL_CST (arg1),
1818 TYPE_SATURATING (type));
1819 t = build_fixed (type, value);
1821 /* Propagate overflow flags. */
1822 if (overflow_p | TREE_OVERFLOW (arg1))
1823 TREE_OVERFLOW (t) = 1;
1827 /* Attempt to fold type conversion operation CODE of expression ARG1 to
1828 type TYPE. If no simplification can be done return NULL_TREE. */
1831 fold_convert_const (enum tree_code code, tree type, tree arg1)
1833 if (TREE_TYPE (arg1) == type)
1836 if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
1837 || TREE_CODE (type) == OFFSET_TYPE)
1839 if (TREE_CODE (arg1) == INTEGER_CST)
1840 return fold_convert_const_int_from_int (type, arg1);
1841 else if (TREE_CODE (arg1) == REAL_CST)
1842 return fold_convert_const_int_from_real (code, type, arg1);
1843 else if (TREE_CODE (arg1) == FIXED_CST)
1844 return fold_convert_const_int_from_fixed (type, arg1);
1846 else if (TREE_CODE (type) == REAL_TYPE)
1848 if (TREE_CODE (arg1) == INTEGER_CST)
1849 return build_real_from_int_cst (type, arg1);
1850 else if (TREE_CODE (arg1) == REAL_CST)
1851 return fold_convert_const_real_from_real (type, arg1);
1852 else if (TREE_CODE (arg1) == FIXED_CST)
1853 return fold_convert_const_real_from_fixed (type, arg1);
1855 else if (TREE_CODE (type) == FIXED_POINT_TYPE)
1857 if (TREE_CODE (arg1) == FIXED_CST)
1858 return fold_convert_const_fixed_from_fixed (type, arg1);
1859 else if (TREE_CODE (arg1) == INTEGER_CST)
1860 return fold_convert_const_fixed_from_int (type, arg1);
1861 else if (TREE_CODE (arg1) == REAL_CST)
1862 return fold_convert_const_fixed_from_real (type, arg1);
1867 /* Construct a vector of zero elements of vector type TYPE. */
1870 build_zero_vector (tree type)
1874 t = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1875 return build_vector_from_val (type, t);
1878 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
1881 fold_convertible_p (const_tree type, const_tree arg)
1883 tree orig = TREE_TYPE (arg);
1888 if (TREE_CODE (arg) == ERROR_MARK
1889 || TREE_CODE (type) == ERROR_MARK
1890 || TREE_CODE (orig) == ERROR_MARK)
1893 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
1896 switch (TREE_CODE (type))
1898 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1899 case POINTER_TYPE: case REFERENCE_TYPE:
1901 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1902 || TREE_CODE (orig) == OFFSET_TYPE)
1904 return (TREE_CODE (orig) == VECTOR_TYPE
1905 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1908 case FIXED_POINT_TYPE:
1912 return TREE_CODE (type) == TREE_CODE (orig);
1919 /* Convert expression ARG to type TYPE. Used by the middle-end for
1920 simple conversions in preference to calling the front-end's convert. */
1923 fold_convert_loc (location_t loc, tree type, tree arg)
1925 tree orig = TREE_TYPE (arg);
1931 if (TREE_CODE (arg) == ERROR_MARK
1932 || TREE_CODE (type) == ERROR_MARK
1933 || TREE_CODE (orig) == ERROR_MARK)
1934 return error_mark_node;
1936 switch (TREE_CODE (type))
1939 case REFERENCE_TYPE:
1940 /* Handle conversions between pointers to different address spaces. */
1941 if (POINTER_TYPE_P (orig)
1942 && (TYPE_ADDR_SPACE (TREE_TYPE (type))
1943 != TYPE_ADDR_SPACE (TREE_TYPE (orig))))
1944 return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, arg);
1947 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1949 if (TREE_CODE (arg) == INTEGER_CST)
1951 tem = fold_convert_const (NOP_EXPR, type, arg);
1952 if (tem != NULL_TREE)
1955 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1956 || TREE_CODE (orig) == OFFSET_TYPE)
1957 return fold_build1_loc (loc, NOP_EXPR, type, arg);
1958 if (TREE_CODE (orig) == COMPLEX_TYPE)
1959 return fold_convert_loc (loc, type,
1960 fold_build1_loc (loc, REALPART_EXPR,
1961 TREE_TYPE (orig), arg));
1962 gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
1963 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1964 return fold_build1_loc (loc, NOP_EXPR, type, arg);
1967 if (TREE_CODE (arg) == INTEGER_CST)
1969 tem = fold_convert_const (FLOAT_EXPR, type, arg);
1970 if (tem != NULL_TREE)
1973 else if (TREE_CODE (arg) == REAL_CST)
1975 tem = fold_convert_const (NOP_EXPR, type, arg);
1976 if (tem != NULL_TREE)
1979 else if (TREE_CODE (arg) == FIXED_CST)
1981 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
1982 if (tem != NULL_TREE)
1986 switch (TREE_CODE (orig))
1989 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
1990 case POINTER_TYPE: case REFERENCE_TYPE:
1991 return fold_build1_loc (loc, FLOAT_EXPR, type, arg);
1994 return fold_build1_loc (loc, NOP_EXPR, type, arg);
1996 case FIXED_POINT_TYPE:
1997 return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
2000 tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2001 return fold_convert_loc (loc, type, tem);
2007 case FIXED_POINT_TYPE:
2008 if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
2009 || TREE_CODE (arg) == REAL_CST)
2011 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2012 if (tem != NULL_TREE)
2013 goto fold_convert_exit;
2016 switch (TREE_CODE (orig))
2018 case FIXED_POINT_TYPE:
2023 return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
2026 tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2027 return fold_convert_loc (loc, type, tem);
2034 switch (TREE_CODE (orig))
2037 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2038 case POINTER_TYPE: case REFERENCE_TYPE:
2040 case FIXED_POINT_TYPE:
2041 return fold_build2_loc (loc, COMPLEX_EXPR, type,
2042 fold_convert_loc (loc, TREE_TYPE (type), arg),
2043 fold_convert_loc (loc, TREE_TYPE (type),
2044 integer_zero_node));
2049 if (TREE_CODE (arg) == COMPLEX_EXPR)
2051 rpart = fold_convert_loc (loc, TREE_TYPE (type),
2052 TREE_OPERAND (arg, 0));
2053 ipart = fold_convert_loc (loc, TREE_TYPE (type),
2054 TREE_OPERAND (arg, 1));
2055 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2058 arg = save_expr (arg);
2059 rpart = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2060 ipart = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (orig), arg);
2061 rpart = fold_convert_loc (loc, TREE_TYPE (type), rpart);
2062 ipart = fold_convert_loc (loc, TREE_TYPE (type), ipart);
2063 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2071 if (integer_zerop (arg))
2072 return build_zero_vector (type);
2073 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2074 gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2075 || TREE_CODE (orig) == VECTOR_TYPE);
2076 return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
2079 tem = fold_ignored_result (arg);
2080 return fold_build1_loc (loc, NOP_EXPR, type, tem);
2083 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2084 return fold_build1_loc (loc, NOP_EXPR, type, arg);
2088 protected_set_expr_location_unshare (tem, loc);
2092 /* Return false if expr can be assumed not to be an lvalue, true
2096 maybe_lvalue_p (const_tree x)
2098 /* We only need to wrap lvalue tree codes. */
2099 switch (TREE_CODE (x))
2112 case ARRAY_RANGE_REF:
2118 case PREINCREMENT_EXPR:
2119 case PREDECREMENT_EXPR:
2121 case TRY_CATCH_EXPR:
2122 case WITH_CLEANUP_EXPR:
2131 /* Assume the worst for front-end tree codes. */
2132 if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2140 /* Return an expr equal to X but certainly not valid as an lvalue. */
2143 non_lvalue_loc (location_t loc, tree x)
2145 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2150 if (! maybe_lvalue_p (x))
2152 return build1_loc (loc, NON_LVALUE_EXPR, TREE_TYPE (x), x);
2155 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2156 Zero means allow extended lvalues. */
2158 int pedantic_lvalues;
2160 /* When pedantic, return an expr equal to X but certainly not valid as a
2161 pedantic lvalue. Otherwise, return X. */
2164 pedantic_non_lvalue_loc (location_t loc, tree x)
2166 if (pedantic_lvalues)
2167 return non_lvalue_loc (loc, x);
2169 return protected_set_expr_location_unshare (x, loc);
2172 /* Given a tree comparison code, return the code that is the logical inverse.
2173 It is generally not safe to do this for floating-point comparisons, except
2174 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2175 ERROR_MARK in this case. */
2178 invert_tree_comparison (enum tree_code code, bool honor_nans)
2180 if (honor_nans && flag_trapping_math && code != EQ_EXPR && code != NE_EXPR
2181 && code != ORDERED_EXPR && code != UNORDERED_EXPR)
2191 return honor_nans ? UNLE_EXPR : LE_EXPR;
2193 return honor_nans ? UNLT_EXPR : LT_EXPR;
2195 return honor_nans ? UNGE_EXPR : GE_EXPR;
2197 return honor_nans ? UNGT_EXPR : GT_EXPR;
2211 return UNORDERED_EXPR;
2212 case UNORDERED_EXPR:
2213 return ORDERED_EXPR;
2219 /* Similar, but return the comparison that results if the operands are
2220 swapped. This is safe for floating-point. */
2223 swap_tree_comparison (enum tree_code code)
2230 case UNORDERED_EXPR:
2256 /* Convert a comparison tree code from an enum tree_code representation
2257 into a compcode bit-based encoding. This function is the inverse of
2258 compcode_to_comparison. */
2260 static enum comparison_code
2261 comparison_to_compcode (enum tree_code code)
2278 return COMPCODE_ORD;
2279 case UNORDERED_EXPR:
2280 return COMPCODE_UNORD;
2282 return COMPCODE_UNLT;
2284 return COMPCODE_UNEQ;
2286 return COMPCODE_UNLE;
2288 return COMPCODE_UNGT;
2290 return COMPCODE_LTGT;
2292 return COMPCODE_UNGE;
2298 /* Convert a compcode bit-based encoding of a comparison operator back
2299 to GCC's enum tree_code representation. This function is the
2300 inverse of comparison_to_compcode. */
2302 static enum tree_code
2303 compcode_to_comparison (enum comparison_code code)
2320 return ORDERED_EXPR;
2321 case COMPCODE_UNORD:
2322 return UNORDERED_EXPR;
2340 /* Return a tree for the comparison which is the combination of
2341 doing the AND or OR (depending on CODE) of the two operations LCODE
2342 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2343 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2344 if this makes the transformation invalid. */
2347 combine_comparisons (location_t loc,
2348 enum tree_code code, enum tree_code lcode,
2349 enum tree_code rcode, tree truth_type,
2350 tree ll_arg, tree lr_arg)
2352 bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2353 enum comparison_code lcompcode = comparison_to_compcode (lcode);
2354 enum comparison_code rcompcode = comparison_to_compcode (rcode);
2359 case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2360 compcode = lcompcode & rcompcode;
2363 case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2364 compcode = lcompcode | rcompcode;
2373 /* Eliminate unordered comparisons, as well as LTGT and ORD
2374 which are not used unless the mode has NaNs. */
2375 compcode &= ~COMPCODE_UNORD;
2376 if (compcode == COMPCODE_LTGT)
2377 compcode = COMPCODE_NE;
2378 else if (compcode == COMPCODE_ORD)
2379 compcode = COMPCODE_TRUE;
2381 else if (flag_trapping_math)
2383 /* Check that the original operation and the optimized ones will trap
2384 under the same condition. */
2385 bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2386 && (lcompcode != COMPCODE_EQ)
2387 && (lcompcode != COMPCODE_ORD);
2388 bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2389 && (rcompcode != COMPCODE_EQ)
2390 && (rcompcode != COMPCODE_ORD);
2391 bool trap = (compcode & COMPCODE_UNORD) == 0
2392 && (compcode != COMPCODE_EQ)
2393 && (compcode != COMPCODE_ORD);
2395 /* In a short-circuited boolean expression the LHS might be
2396 such that the RHS, if evaluated, will never trap. For
2397 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2398 if neither x nor y is NaN. (This is a mixed blessing: for
2399 example, the expression above will never trap, hence
2400 optimizing it to x < y would be invalid). */
2401 if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2402 || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2405 /* If the comparison was short-circuited, and only the RHS
2406 trapped, we may now generate a spurious trap. */
2408 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2411 /* If we changed the conditions that cause a trap, we lose. */
2412 if ((ltrap || rtrap) != trap)
2416 if (compcode == COMPCODE_TRUE)
2417 return constant_boolean_node (true, truth_type);
2418 else if (compcode == COMPCODE_FALSE)
2419 return constant_boolean_node (false, truth_type);
2422 enum tree_code tcode;
2424 tcode = compcode_to_comparison ((enum comparison_code) compcode);
2425 return fold_build2_loc (loc, tcode, truth_type, ll_arg, lr_arg);
2429 /* Return nonzero if two operands (typically of the same tree node)
2430 are necessarily equal. If either argument has side-effects this
2431 function returns zero. FLAGS modifies behavior as follows:
2433 If OEP_ONLY_CONST is set, only return nonzero for constants.
2434 This function tests whether the operands are indistinguishable;
2435 it does not test whether they are equal using C's == operation.
2436 The distinction is important for IEEE floating point, because
2437 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2438 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2440 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2441 even though it may hold multiple values during a function.
2442 This is because a GCC tree node guarantees that nothing else is
2443 executed between the evaluation of its "operands" (which may often
2444 be evaluated in arbitrary order). Hence if the operands themselves
2445 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2446 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2447 unset means assuming isochronic (or instantaneous) tree equivalence.
2448 Unless comparing arbitrary expression trees, such as from different
2449 statements, this flag can usually be left unset.
2451 If OEP_PURE_SAME is set, then pure functions with identical arguments
2452 are considered the same. It is used when the caller has other ways
2453 to ensure that global memory is unchanged in between. */
2456 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
2458 /* If either is ERROR_MARK, they aren't equal. */
2459 if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK
2460 || TREE_TYPE (arg0) == error_mark_node
2461 || TREE_TYPE (arg1) == error_mark_node)
2464 /* Similar, if either does not have a type (like a released SSA name),
2465 they aren't equal. */
2466 if (!TREE_TYPE (arg0) || !TREE_TYPE (arg1))
2469 /* Check equality of integer constants before bailing out due to
2470 precision differences. */
2471 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2472 return tree_int_cst_equal (arg0, arg1);
2474 /* If both types don't have the same signedness, then we can't consider
2475 them equal. We must check this before the STRIP_NOPS calls
2476 because they may change the signedness of the arguments. As pointers
2477 strictly don't have a signedness, require either two pointers or
2478 two non-pointers as well. */
2479 if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
2480 || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
2483 /* We cannot consider pointers to different address space equal. */
2484 if (POINTER_TYPE_P (TREE_TYPE (arg0)) && POINTER_TYPE_P (TREE_TYPE (arg1))
2485 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0)))
2486 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1)))))
2489 /* If both types don't have the same precision, then it is not safe
2491 if (element_precision (TREE_TYPE (arg0))
2492 != element_precision (TREE_TYPE (arg1)))
2498 /* In case both args are comparisons but with different comparison
2499 code, try to swap the comparison operands of one arg to produce
2500 a match and compare that variant. */
2501 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2502 && COMPARISON_CLASS_P (arg0)
2503 && COMPARISON_CLASS_P (arg1))
2505 enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
2507 if (TREE_CODE (arg0) == swap_code)
2508 return operand_equal_p (TREE_OPERAND (arg0, 0),
2509 TREE_OPERAND (arg1, 1), flags)
2510 && operand_equal_p (TREE_OPERAND (arg0, 1),
2511 TREE_OPERAND (arg1, 0), flags);
2514 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2515 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2516 && !(CONVERT_EXPR_P (arg0) && CONVERT_EXPR_P (arg1)))
2519 /* This is needed for conversions and for COMPONENT_REF.
2520 Might as well play it safe and always test this. */
2521 if (TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2522 || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2523 || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2526 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2527 We don't care about side effects in that case because the SAVE_EXPR
2528 takes care of that for us. In all other cases, two expressions are
2529 equal if they have no side effects. If we have two identical
2530 expressions with side effects that should be treated the same due
2531 to the only side effects being identical SAVE_EXPR's, that will
2532 be detected in the recursive calls below.
2533 If we are taking an invariant address of two identical objects
2534 they are necessarily equal as well. */
2535 if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2536 && (TREE_CODE (arg0) == SAVE_EXPR
2537 || (flags & OEP_CONSTANT_ADDRESS_OF)
2538 || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2541 /* Next handle constant cases, those for which we can return 1 even
2542 if ONLY_CONST is set. */
2543 if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2544 switch (TREE_CODE (arg0))
2547 return tree_int_cst_equal (arg0, arg1);
2550 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
2551 TREE_FIXED_CST (arg1));
2554 if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2555 TREE_REAL_CST (arg1)))
2559 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
2561 /* If we do not distinguish between signed and unsigned zero,
2562 consider them equal. */
2563 if (real_zerop (arg0) && real_zerop (arg1))
2572 if (VECTOR_CST_NELTS (arg0) != VECTOR_CST_NELTS (arg1))
2575 for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
2577 if (!operand_equal_p (VECTOR_CST_ELT (arg0, i),
2578 VECTOR_CST_ELT (arg1, i), flags))
2585 return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2587 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2591 return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2592 && ! memcmp (TREE_STRING_POINTER (arg0),
2593 TREE_STRING_POINTER (arg1),
2594 TREE_STRING_LENGTH (arg0)));
2597 return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2598 TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1)
2599 ? OEP_CONSTANT_ADDRESS_OF : 0);
2604 if (flags & OEP_ONLY_CONST)
2607 /* Define macros to test an operand from arg0 and arg1 for equality and a
2608 variant that allows null and views null as being different from any
2609 non-null value. In the latter case, if either is null, the both
2610 must be; otherwise, do the normal comparison. */
2611 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2612 TREE_OPERAND (arg1, N), flags)
2614 #define OP_SAME_WITH_NULL(N) \
2615 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2616 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2618 switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2621 /* Two conversions are equal only if signedness and modes match. */
2622 switch (TREE_CODE (arg0))
2625 case FIX_TRUNC_EXPR:
2626 if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2627 != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2637 case tcc_comparison:
2639 if (OP_SAME (0) && OP_SAME (1))
2642 /* For commutative ops, allow the other order. */
2643 return (commutative_tree_code (TREE_CODE (arg0))
2644 && operand_equal_p (TREE_OPERAND (arg0, 0),
2645 TREE_OPERAND (arg1, 1), flags)
2646 && operand_equal_p (TREE_OPERAND (arg0, 1),
2647 TREE_OPERAND (arg1, 0), flags));
2650 /* If either of the pointer (or reference) expressions we are
2651 dereferencing contain a side effect, these cannot be equal,
2652 but their addresses can be. */
2653 if ((flags & OEP_CONSTANT_ADDRESS_OF) == 0
2654 && (TREE_SIDE_EFFECTS (arg0)
2655 || TREE_SIDE_EFFECTS (arg1)))
2658 switch (TREE_CODE (arg0))
2661 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2668 case TARGET_MEM_REF:
2669 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2670 /* Require equal extra operands and then fall through to MEM_REF
2671 handling of the two common operands. */
2672 if (!OP_SAME_WITH_NULL (2)
2673 || !OP_SAME_WITH_NULL (3)
2674 || !OP_SAME_WITH_NULL (4))
2678 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2679 /* Require equal access sizes, and similar pointer types.
2680 We can have incomplete types for array references of
2681 variable-sized arrays from the Fortran frontend
2682 though. Also verify the types are compatible. */
2683 return ((TYPE_SIZE (TREE_TYPE (arg0)) == TYPE_SIZE (TREE_TYPE (arg1))
2684 || (TYPE_SIZE (TREE_TYPE (arg0))
2685 && TYPE_SIZE (TREE_TYPE (arg1))
2686 && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
2687 TYPE_SIZE (TREE_TYPE (arg1)), flags)))
2688 && types_compatible_p (TREE_TYPE (arg0), TREE_TYPE (arg1))
2689 && alias_ptr_types_compatible_p
2690 (TREE_TYPE (TREE_OPERAND (arg0, 1)),
2691 TREE_TYPE (TREE_OPERAND (arg1, 1)))
2692 && OP_SAME (0) && OP_SAME (1));
2695 case ARRAY_RANGE_REF:
2696 /* Operands 2 and 3 may be null.
2697 Compare the array index by value if it is constant first as we
2698 may have different types but same value here. */
2701 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2702 return ((tree_int_cst_equal (TREE_OPERAND (arg0, 1),
2703 TREE_OPERAND (arg1, 1))
2705 && OP_SAME_WITH_NULL (2)
2706 && OP_SAME_WITH_NULL (3));
2709 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
2710 may be NULL when we're called to compare MEM_EXPRs. */
2711 if (!OP_SAME_WITH_NULL (0)
2714 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2715 return OP_SAME_WITH_NULL (2);
2720 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2721 return OP_SAME (1) && OP_SAME (2);
2727 case tcc_expression:
2728 switch (TREE_CODE (arg0))
2731 case TRUTH_NOT_EXPR:
2734 case TRUTH_ANDIF_EXPR:
2735 case TRUTH_ORIF_EXPR:
2736 return OP_SAME (0) && OP_SAME (1);
2739 case WIDEN_MULT_PLUS_EXPR:
2740 case WIDEN_MULT_MINUS_EXPR:
2743 /* The multiplcation operands are commutative. */
2746 case TRUTH_AND_EXPR:
2748 case TRUTH_XOR_EXPR:
2749 if (OP_SAME (0) && OP_SAME (1))
2752 /* Otherwise take into account this is a commutative operation. */
2753 return (operand_equal_p (TREE_OPERAND (arg0, 0),
2754 TREE_OPERAND (arg1, 1), flags)
2755 && operand_equal_p (TREE_OPERAND (arg0, 1),
2756 TREE_OPERAND (arg1, 0), flags));
2761 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2768 switch (TREE_CODE (arg0))
2771 /* If the CALL_EXPRs call different functions, then they
2772 clearly can not be equal. */
2773 if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
2778 unsigned int cef = call_expr_flags (arg0);
2779 if (flags & OEP_PURE_SAME)
2780 cef &= ECF_CONST | ECF_PURE;
2787 /* Now see if all the arguments are the same. */
2789 const_call_expr_arg_iterator iter0, iter1;
2791 for (a0 = first_const_call_expr_arg (arg0, &iter0),
2792 a1 = first_const_call_expr_arg (arg1, &iter1);
2794 a0 = next_const_call_expr_arg (&iter0),
2795 a1 = next_const_call_expr_arg (&iter1))
2796 if (! operand_equal_p (a0, a1, flags))
2799 /* If we get here and both argument lists are exhausted
2800 then the CALL_EXPRs are equal. */
2801 return ! (a0 || a1);
2807 case tcc_declaration:
2808 /* Consider __builtin_sqrt equal to sqrt. */
2809 return (TREE_CODE (arg0) == FUNCTION_DECL
2810 && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
2811 && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
2812 && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
2819 #undef OP_SAME_WITH_NULL
2822 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2823 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2825 When in doubt, return 0. */
2828 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
2830 int unsignedp1, unsignedpo;
2831 tree primarg0, primarg1, primother;
2832 unsigned int correct_width;
2834 if (operand_equal_p (arg0, arg1, 0))
2837 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2838 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2841 /* Discard any conversions that don't change the modes of ARG0 and ARG1
2842 and see if the inner values are the same. This removes any
2843 signedness comparison, which doesn't matter here. */
2844 primarg0 = arg0, primarg1 = arg1;
2845 STRIP_NOPS (primarg0);
2846 STRIP_NOPS (primarg1);
2847 if (operand_equal_p (primarg0, primarg1, 0))
2850 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2851 actual comparison operand, ARG0.
2853 First throw away any conversions to wider types
2854 already present in the operands. */
2856 primarg1 = get_narrower (arg1, &unsignedp1);
2857 primother = get_narrower (other, &unsignedpo);
2859 correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2860 if (unsignedp1 == unsignedpo
2861 && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2862 && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2864 tree type = TREE_TYPE (arg0);
2866 /* Make sure shorter operand is extended the right way
2867 to match the longer operand. */
2868 primarg1 = fold_convert (signed_or_unsigned_type_for
2869 (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2871 if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
2878 /* See if ARG is an expression that is either a comparison or is performing
2879 arithmetic on comparisons. The comparisons must only be comparing
2880 two different values, which will be stored in *CVAL1 and *CVAL2; if
2881 they are nonzero it means that some operands have already been found.
2882 No variables may be used anywhere else in the expression except in the
2883 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
2884 the expression and save_expr needs to be called with CVAL1 and CVAL2.
2886 If this is true, return 1. Otherwise, return zero. */
2889 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
2891 enum tree_code code = TREE_CODE (arg);
2892 enum tree_code_class tclass = TREE_CODE_CLASS (code);
2894 /* We can handle some of the tcc_expression cases here. */
2895 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
2897 else if (tclass == tcc_expression
2898 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2899 || code == COMPOUND_EXPR))
2900 tclass = tcc_binary;
2902 else if (tclass == tcc_expression && code == SAVE_EXPR
2903 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2905 /* If we've already found a CVAL1 or CVAL2, this expression is
2906 two complex to handle. */
2907 if (*cval1 || *cval2)
2917 return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2920 return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2921 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2922 cval1, cval2, save_p));
2927 case tcc_expression:
2928 if (code == COND_EXPR)
2929 return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2930 cval1, cval2, save_p)
2931 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2932 cval1, cval2, save_p)
2933 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2934 cval1, cval2, save_p));
2937 case tcc_comparison:
2938 /* First see if we can handle the first operand, then the second. For
2939 the second operand, we know *CVAL1 can't be zero. It must be that
2940 one side of the comparison is each of the values; test for the
2941 case where this isn't true by failing if the two operands
2944 if (operand_equal_p (TREE_OPERAND (arg, 0),
2945 TREE_OPERAND (arg, 1), 0))
2949 *cval1 = TREE_OPERAND (arg, 0);
2950 else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2952 else if (*cval2 == 0)
2953 *cval2 = TREE_OPERAND (arg, 0);
2954 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2959 if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2961 else if (*cval2 == 0)
2962 *cval2 = TREE_OPERAND (arg, 1);
2963 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2975 /* ARG is a tree that is known to contain just arithmetic operations and
2976 comparisons. Evaluate the operations in the tree substituting NEW0 for
2977 any occurrence of OLD0 as an operand of a comparison and likewise for
2981 eval_subst (location_t loc, tree arg, tree old0, tree new0,
2982 tree old1, tree new1)
2984 tree type = TREE_TYPE (arg);
2985 enum tree_code code = TREE_CODE (arg);
2986 enum tree_code_class tclass = TREE_CODE_CLASS (code);
2988 /* We can handle some of the tcc_expression cases here. */
2989 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
2991 else if (tclass == tcc_expression
2992 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2993 tclass = tcc_binary;
2998 return fold_build1_loc (loc, code, type,
2999 eval_subst (loc, TREE_OPERAND (arg, 0),
3000 old0, new0, old1, new1));
3003 return fold_build2_loc (loc, code, type,
3004 eval_subst (loc, TREE_OPERAND (arg, 0),
3005 old0, new0, old1, new1),
3006 eval_subst (loc, TREE_OPERAND (arg, 1),
3007 old0, new0, old1, new1));
3009 case tcc_expression:
3013 return eval_subst (loc, TREE_OPERAND (arg, 0), old0, new0,
3017 return eval_subst (loc, TREE_OPERAND (arg, 1), old0, new0,
3021 return fold_build3_loc (loc, code, type,
3022 eval_subst (loc, TREE_OPERAND (arg, 0),
3023 old0, new0, old1, new1),
3024 eval_subst (loc, TREE_OPERAND (arg, 1),
3025 old0, new0, old1, new1),
3026 eval_subst (loc, TREE_OPERAND (arg, 2),
3027 old0, new0, old1, new1));
3031 /* Fall through - ??? */
3033 case tcc_comparison:
3035 tree arg0 = TREE_OPERAND (arg, 0);
3036 tree arg1 = TREE_OPERAND (arg, 1);
3038 /* We need to check both for exact equality and tree equality. The
3039 former will be true if the operand has a side-effect. In that
3040 case, we know the operand occurred exactly once. */
3042 if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3044 else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3047 if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3049 else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3052 return fold_build2_loc (loc, code, type, arg0, arg1);
3060 /* Return a tree for the case when the result of an expression is RESULT
3061 converted to TYPE and OMITTED was previously an operand of the expression
3062 but is now not needed (e.g., we folded OMITTED * 0).
3064 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3065 the conversion of RESULT to TYPE. */
3068 omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted)
3070 tree t = fold_convert_loc (loc, type, result);
3072 /* If the resulting operand is an empty statement, just return the omitted
3073 statement casted to void. */
3074 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3075 return build1_loc (loc, NOP_EXPR, void_type_node,
3076 fold_ignored_result (omitted));
3078 if (TREE_SIDE_EFFECTS (omitted))
3079 return build2_loc (loc, COMPOUND_EXPR, type,
3080 fold_ignored_result (omitted), t);
3082 return non_lvalue_loc (loc, t);
3085 /* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
3088 pedantic_omit_one_operand_loc (location_t loc, tree type, tree result,
3091 tree t = fold_convert_loc (loc, type, result);
3093 /* If the resulting operand is an empty statement, just return the omitted
3094 statement casted to void. */
3095 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3096 return build1_loc (loc, NOP_EXPR, void_type_node,
3097 fold_ignored_result (omitted));
3099 if (TREE_SIDE_EFFECTS (omitted))
3100 return build2_loc (loc, COMPOUND_EXPR, type,
3101 fold_ignored_result (omitted), t);
3103 return pedantic_non_lvalue_loc (loc, t);
3106 /* Return a tree for the case when the result of an expression is RESULT
3107 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3108 of the expression but are now not needed.
3110 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3111 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3112 evaluated before OMITTED2. Otherwise, if neither has side effects,
3113 just do the conversion of RESULT to TYPE. */
3116 omit_two_operands_loc (location_t loc, tree type, tree result,
3117 tree omitted1, tree omitted2)
3119 tree t = fold_convert_loc (loc, type, result);
3121 if (TREE_SIDE_EFFECTS (omitted2))
3122 t = build2_loc (loc, COMPOUND_EXPR, type, omitted2, t);
3123 if (TREE_SIDE_EFFECTS (omitted1))
3124 t = build2_loc (loc, COMPOUND_EXPR, type, omitted1, t);
3126 return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue_loc (loc, t) : t;
3130 /* Return a simplified tree node for the truth-negation of ARG. This
3131 never alters ARG itself. We assume that ARG is an operation that
3132 returns a truth value (0 or 1).
3134 FIXME: one would think we would fold the result, but it causes
3135 problems with the dominator optimizer. */
3138 fold_truth_not_expr (location_t loc, tree arg)
3140 tree type = TREE_TYPE (arg);
3141 enum tree_code code = TREE_CODE (arg);
3142 location_t loc1, loc2;
3144 /* If this is a comparison, we can simply invert it, except for
3145 floating-point non-equality comparisons, in which case we just
3146 enclose a TRUTH_NOT_EXPR around what we have. */
3148 if (TREE_CODE_CLASS (code) == tcc_comparison)
3150 tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3151 if (FLOAT_TYPE_P (op_type)
3152 && flag_trapping_math
3153 && code != ORDERED_EXPR && code != UNORDERED_EXPR
3154 && code != NE_EXPR && code != EQ_EXPR)
3157 code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (op_type)));
3158 if (code == ERROR_MARK)
3161 return build2_loc (loc, code, type, TREE_OPERAND (arg, 0),
3162 TREE_OPERAND (arg, 1));
3168 return constant_boolean_node (integer_zerop (arg), type);
3170 case TRUTH_AND_EXPR:
3171 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3172 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3173 return build2_loc (loc, TRUTH_OR_EXPR, type,
3174 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3175 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3178 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3179 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3180 return build2_loc (loc, TRUTH_AND_EXPR, type,
3181 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3182 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3184 case TRUTH_XOR_EXPR:
3185 /* Here we can invert either operand. We invert the first operand
3186 unless the second operand is a TRUTH_NOT_EXPR in which case our
3187 result is the XOR of the first operand with the inside of the
3188 negation of the second operand. */
3190 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3191 return build2_loc (loc, TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3192 TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3194 return build2_loc (loc, TRUTH_XOR_EXPR, type,
3195 invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
3196 TREE_OPERAND (arg, 1));
3198 case TRUTH_ANDIF_EXPR:
3199 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3200 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3201 return build2_loc (loc, TRUTH_ORIF_EXPR, type,
3202 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3203 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3205 case TRUTH_ORIF_EXPR:
3206 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3207 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3208 return build2_loc (loc, TRUTH_ANDIF_EXPR, type,
3209 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3210 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3212 case TRUTH_NOT_EXPR:
3213 return TREE_OPERAND (arg, 0);
3217 tree arg1 = TREE_OPERAND (arg, 1);
3218 tree arg2 = TREE_OPERAND (arg, 2);
3220 loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3221 loc2 = expr_location_or (TREE_OPERAND (arg, 2), loc);
3223 /* A COND_EXPR may have a throw as one operand, which
3224 then has void type. Just leave void operands
3226 return build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg, 0),
3227 VOID_TYPE_P (TREE_TYPE (arg1))
3228 ? arg1 : invert_truthvalue_loc (loc1, arg1),
3229 VOID_TYPE_P (TREE_TYPE (arg2))
3230 ? arg2 : invert_truthvalue_loc (loc2, arg2));
3234 loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3235 return build2_loc (loc, COMPOUND_EXPR, type,
3236 TREE_OPERAND (arg, 0),
3237 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
3239 case NON_LVALUE_EXPR:
3240 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3241 return invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0));
3244 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3245 return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3247 /* ... fall through ... */
3250 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3251 return build1_loc (loc, TREE_CODE (arg), type,
3252 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3255 if (!integer_onep (TREE_OPERAND (arg, 1)))
3257 return build2_loc (loc, EQ_EXPR, type, arg, build_int_cst (type, 0));
3260 return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3262 case CLEANUP_POINT_EXPR:
3263 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3264 return build1_loc (loc, CLEANUP_POINT_EXPR, type,
3265 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3272 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3273 assume that ARG is an operation that returns a truth value (0 or 1
3274 for scalars, 0 or -1 for vectors). Return the folded expression if
3275 folding is successful. Otherwise, return NULL_TREE. */
3278 fold_invert_truthvalue (location_t loc, tree arg)
3280 tree type = TREE_TYPE (arg);
3281 return fold_unary_loc (loc, VECTOR_TYPE_P (type)
3287 /* Return a simplified tree node for the truth-negation of ARG. This
3288 never alters ARG itself. We assume that ARG is an operation that
3289 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3292 invert_truthvalue_loc (location_t loc, tree arg)
3294 if (TREE_CODE (arg) == ERROR_MARK)
3297 tree type = TREE_TYPE (arg);
3298 return fold_build1_loc (loc, VECTOR_TYPE_P (type)
3304 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3305 operands are another bit-wise operation with a common input. If so,
3306 distribute the bit operations to save an operation and possibly two if
3307 constants are involved. For example, convert
3308 (A | B) & (A | C) into A | (B & C)
3309 Further simplification will occur if B and C are constants.
3311 If this optimization cannot be done, 0 will be returned. */
3314 distribute_bit_expr (location_t loc, enum tree_code code, tree type,
3315 tree arg0, tree arg1)
3320 if (TREE_CODE (arg0) != TREE_CODE (arg1)
3321 || TREE_CODE (arg0) == code
3322 || (TREE_CODE (arg0) != BIT_AND_EXPR
3323 && TREE_CODE (arg0) != BIT_IOR_EXPR))
3326 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3328 common = TREE_OPERAND (arg0, 0);
3329 left = TREE_OPERAND (arg0, 1);
3330 right = TREE_OPERAND (arg1, 1);
3332 else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3334 common = TREE_OPERAND (arg0, 0);
3335 left = TREE_OPERAND (arg0, 1);
3336 right = TREE_OPERAND (arg1, 0);
3338 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3340 common = TREE_OPERAND (arg0, 1);
3341 left = TREE_OPERAND (arg0, 0);
3342 right = TREE_OPERAND (arg1, 1);
3344 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3346 common = TREE_OPERAND (arg0, 1);
3347 left = TREE_OPERAND (arg0, 0);
3348 right = TREE_OPERAND (arg1, 0);
3353 common = fold_convert_loc (loc, type, common);
3354 left = fold_convert_loc (loc, type, left);
3355 right = fold_convert_loc (loc, type, right);
3356 return fold_build2_loc (loc, TREE_CODE (arg0), type, common,
3357 fold_build2_loc (loc, code, type, left, right));
3360 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3361 with code CODE. This optimization is unsafe. */
3363 distribute_real_division (location_t loc, enum tree_code code, tree type,
3364 tree arg0, tree arg1)
3366 bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3367 bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3369 /* (A / C) +- (B / C) -> (A +- B) / C. */
3371 && operand_equal_p (TREE_OPERAND (arg0, 1),
3372 TREE_OPERAND (arg1, 1), 0))
3373 return fold_build2_loc (loc, mul0 ? MULT_EXPR : RDIV_EXPR, type,
3374 fold_build2_loc (loc, code, type,
3375 TREE_OPERAND (arg0, 0),
3376 TREE_OPERAND (arg1, 0)),
3377 TREE_OPERAND (arg0, 1));
3379 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3380 if (operand_equal_p (TREE_OPERAND (arg0, 0),
3381 TREE_OPERAND (arg1, 0), 0)
3382 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3383 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3385 REAL_VALUE_TYPE r0, r1;
3386 r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3387 r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3389 real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3391 real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3392 real_arithmetic (&r0, code, &r0, &r1);
3393 return fold_build2_loc (loc, MULT_EXPR, type,
3394 TREE_OPERAND (arg0, 0),
3395 build_real (type, r0));
3401 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3402 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
3405 make_bit_field_ref (location_t loc, tree inner, tree type,
3406 HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos, int unsignedp)
3408 tree result, bftype;
3412 tree size = TYPE_SIZE (TREE_TYPE (inner));
3413 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3414 || POINTER_TYPE_P (TREE_TYPE (inner)))
3415 && tree_fits_shwi_p (size)
3416 && tree_to_shwi (size) == bitsize)
3417 return fold_convert_loc (loc, type, inner);
3421 if (TYPE_PRECISION (bftype) != bitsize
3422 || TYPE_UNSIGNED (bftype) == !unsignedp)
3423 bftype = build_nonstandard_integer_type (bitsize, 0);
3425 result = build3_loc (loc, BIT_FIELD_REF, bftype, inner,
3426 size_int (bitsize), bitsize_int (bitpos));
3429 result = fold_convert_loc (loc, type, result);
3434 /* Optimize a bit-field compare.
3436 There are two cases: First is a compare against a constant and the
3437 second is a comparison of two items where the fields are at the same
3438 bit position relative to the start of a chunk (byte, halfword, word)
3439 large enough to contain it. In these cases we can avoid the shift
3440 implicit in bitfield extractions.
3442 For constants, we emit a compare of the shifted constant with the
3443 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3444 compared. For two fields at the same position, we do the ANDs with the
3445 similar mask and compare the result of the ANDs.
3447 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3448 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3449 are the left and right operands of the comparison, respectively.
3451 If the optimization described above can be done, we return the resulting
3452 tree. Otherwise we return zero. */
3455 optimize_bit_field_compare (location_t loc, enum tree_code code,
3456 tree compare_type, tree lhs, tree rhs)
3458 HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3459 tree type = TREE_TYPE (lhs);
3461 int const_p = TREE_CODE (rhs) == INTEGER_CST;
3462 machine_mode lmode, rmode, nmode;
3463 int lunsignedp, runsignedp;
3464 int lvolatilep = 0, rvolatilep = 0;
3465 tree linner, rinner = NULL_TREE;
3469 /* Get all the information about the extractions being done. If the bit size
3470 if the same as the size of the underlying object, we aren't doing an
3471 extraction at all and so can do nothing. We also don't want to
3472 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3473 then will no longer be able to replace it. */
3474 linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3475 &lunsignedp, &lvolatilep, false);
3476 if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3477 || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR || lvolatilep)
3482 /* If this is not a constant, we can only do something if bit positions,
3483 sizes, and signedness are the same. */
3484 rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3485 &runsignedp, &rvolatilep, false);
3487 if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3488 || lunsignedp != runsignedp || offset != 0
3489 || TREE_CODE (rinner) == PLACEHOLDER_EXPR || rvolatilep)
3493 /* See if we can find a mode to refer to this field. We should be able to,
3494 but fail if we can't. */
3495 nmode = get_best_mode (lbitsize, lbitpos, 0, 0,
3496 const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3497 : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3498 TYPE_ALIGN (TREE_TYPE (rinner))),
3500 if (nmode == VOIDmode)
3503 /* Set signed and unsigned types of the precision of this mode for the
3505 unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3507 /* Compute the bit position and size for the new reference and our offset
3508 within it. If the new reference is the same size as the original, we
3509 won't optimize anything, so return zero. */
3510 nbitsize = GET_MODE_BITSIZE (nmode);
3511 nbitpos = lbitpos & ~ (nbitsize - 1);
3513 if (nbitsize == lbitsize)
3516 if (BYTES_BIG_ENDIAN)
3517 lbitpos = nbitsize - lbitsize - lbitpos;
3519 /* Make the mask to be used against the extracted field. */
3520 mask = build_int_cst_type (unsigned_type, -1);
3521 mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize));
3522 mask = const_binop (RSHIFT_EXPR, mask,
3523 size_int (nbitsize - lbitsize - lbitpos));
3526 /* If not comparing with constant, just rework the comparison
3528 return fold_build2_loc (loc, code, compare_type,
3529 fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3530 make_bit_field_ref (loc, linner,
3535 fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3536 make_bit_field_ref (loc, rinner,
3542 /* Otherwise, we are handling the constant case. See if the constant is too
3543 big for the field. Warn and return a tree of for 0 (false) if so. We do
3544 this not only for its own sake, but to avoid having to test for this
3545 error case below. If we didn't, we might generate wrong code.
3547 For unsigned fields, the constant shifted right by the field length should
3548 be all zero. For signed fields, the high-order bits should agree with
3553 if (wi::lrshift (rhs, lbitsize) != 0)
3555 warning (0, "comparison is always %d due to width of bit-field",
3557 return constant_boolean_node (code == NE_EXPR, compare_type);
3562 wide_int tem = wi::arshift (rhs, lbitsize - 1);
3563 if (tem != 0 && tem != -1)
3565 warning (0, "comparison is always %d due to width of bit-field",
3567 return constant_boolean_node (code == NE_EXPR, compare_type);
3571 /* Single-bit compares should always be against zero. */
3572 if (lbitsize == 1 && ! integer_zerop (rhs))
3574 code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3575 rhs = build_int_cst (type, 0);
3578 /* Make a new bitfield reference, shift the constant over the
3579 appropriate number of bits and mask it with the computed mask
3580 (in case this was a signed field). If we changed it, make a new one. */
3581 lhs = make_bit_field_ref (loc, linner, unsigned_type, nbitsize, nbitpos, 1);
3583 rhs = const_binop (BIT_AND_EXPR,
3584 const_binop (LSHIFT_EXPR,
3585 fold_convert_loc (loc, unsigned_type, rhs),
3586 size_int (lbitpos)),
3589 lhs = build2_loc (loc, code, compare_type,
3590 build2 (BIT_AND_EXPR, unsigned_type, lhs, mask), rhs);
3594 /* Subroutine for fold_truth_andor_1: decode a field reference.
3596 If EXP is a comparison reference, we return the innermost reference.
3598 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3599 set to the starting bit number.
3601 If the innermost field can be completely contained in a mode-sized
3602 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
3604 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3605 otherwise it is not changed.
3607 *PUNSIGNEDP is set to the signedness of the field.
3609 *PMASK is set to the mask used. This is either contained in a
3610 BIT_AND_EXPR or derived from the width of the field.
3612 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3614 Return 0 if this is not a component reference or is one that we can't
3615 do anything with. */
3618 decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize,
3619 HOST_WIDE_INT *pbitpos, machine_mode *pmode,
3620 int *punsignedp, int *pvolatilep,
3621 tree *pmask, tree *pand_mask)
3623 tree outer_type = 0;
3625 tree mask, inner, offset;
3627 unsigned int precision;
3629 /* All the optimizations using this function assume integer fields.
3630 There are problems with FP fields since the type_for_size call
3631 below can fail for, e.g., XFmode. */
3632 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3635 /* We are interested in the bare arrangement of bits, so strip everything
3636 that doesn't affect the machine mode. However, record the type of the
3637 outermost expression if it may matter below. */
3638 if (CONVERT_EXPR_P (exp)
3639 || TREE_CODE (exp) == NON_LVALUE_EXPR)
3640 outer_type = TREE_TYPE (exp);
3643 if (TREE_CODE (exp) == BIT_AND_EXPR)
3645 and_mask = TREE_OPERAND (exp, 1);
3646 exp = TREE_OPERAND (exp, 0);
3647 STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3648 if (TREE_CODE (and_mask) != INTEGER_CST)
3652 inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3653 punsignedp, pvolatilep, false);
3654 if ((inner == exp && and_mask == 0)
3655 || *pbitsize < 0 || offset != 0
3656 || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3659 /* If the number of bits in the reference is the same as the bitsize of
3660 the outer type, then the outer type gives the signedness. Otherwise
3661 (in case of a small bitfield) the signedness is unchanged. */
3662 if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3663 *punsignedp = TYPE_UNSIGNED (outer_type);
3665 /* Compute the mask to access the bitfield. */
3666 unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3667 precision = TYPE_PRECISION (unsigned_type);
3669 mask = build_int_cst_type (unsigned_type, -1);
3671 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3672 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3674 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
3676 mask = fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3677 fold_convert_loc (loc, unsigned_type, and_mask), mask);
3680 *pand_mask = and_mask;
3684 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3685 bit positions and MASK is SIGNED. */
3688 all_ones_mask_p (const_tree mask, unsigned int size)
3690 tree type = TREE_TYPE (mask);
3691 unsigned int precision = TYPE_PRECISION (type);
3693 /* If this function returns true when the type of the mask is
3694 UNSIGNED, then there will be errors. In particular see
3695 gcc.c-torture/execute/990326-1.c. There does not appear to be
3696 any documentation paper trail as to why this is so. But the pre
3697 wide-int worked with that restriction and it has been preserved
3699 if (size > precision || TYPE_SIGN (type) == UNSIGNED)
3702 return wi::mask (size, false, precision) == mask;
3705 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3706 represents the sign bit of EXP's type. If EXP represents a sign
3707 or zero extension, also test VAL against the unextended type.
3708 The return value is the (sub)expression whose sign bit is VAL,
3709 or NULL_TREE otherwise. */
3712 sign_bit_p (tree exp, const_tree val)
3717 /* Tree EXP must have an integral type. */
3718 t = TREE_TYPE (exp);
3719 if (! INTEGRAL_TYPE_P (t))
3722 /* Tree VAL must be an integer constant. */
3723 if (TREE_CODE (val) != INTEGER_CST
3724 || TREE_OVERFLOW (val))
3727 width = TYPE_PRECISION (t);
3728 if (wi::only_sign_bit_p (val, width))
3731 /* Handle extension from a narrower type. */
3732 if (TREE_CODE (exp) == NOP_EXPR
3733 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3734 return sign_bit_p (TREE_OPERAND (exp, 0), val);
3739 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
3740 to be evaluated unconditionally. */
3743 simple_operand_p (const_tree exp)
3745 /* Strip any conversions that don't change the machine mode. */
3748 return (CONSTANT_CLASS_P (exp)
3749 || TREE_CODE (exp) == SSA_NAME
3751 && ! TREE_ADDRESSABLE (exp)
3752 && ! TREE_THIS_VOLATILE (exp)
3753 && ! DECL_NONLOCAL (exp)
3754 /* Don't regard global variables as simple. They may be
3755 allocated in ways unknown to the compiler (shared memory,
3756 #pragma weak, etc). */
3757 && ! TREE_PUBLIC (exp)
3758 && ! DECL_EXTERNAL (exp)
3759 /* Weakrefs are not safe to be read, since they can be NULL.
3760 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
3761 have DECL_WEAK flag set. */
3762 && (! VAR_OR_FUNCTION_DECL_P (exp) || ! DECL_WEAK (exp))
3763 /* Loading a static variable is unduly expensive, but global
3764 registers aren't expensive. */
3765 && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3768 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
3769 to be evaluated unconditionally.
3770 I addition to simple_operand_p, we assume that comparisons, conversions,
3771 and logic-not operations are simple, if their operands are simple, too. */
3774 simple_operand_p_2 (tree exp)
3776 enum tree_code code;
3778 if (TREE_SIDE_EFFECTS (exp)
3779 || tree_could_trap_p (exp))
3782 while (CONVERT_EXPR_P (exp))
3783 exp = TREE_OPERAND (exp, 0);
3785 code = TREE_CODE (exp);
3787 if (TREE_CODE_CLASS (code) == tcc_comparison)
3788 return (simple_operand_p (TREE_OPERAND (exp, 0))
3789 && simple_operand_p (TREE_OPERAND (exp, 1)));
3791 if (code == TRUTH_NOT_EXPR)
3792 return simple_operand_p_2 (TREE_OPERAND (exp, 0));
3794 return simple_operand_p (exp);
3798 /* The following functions are subroutines to fold_range_test and allow it to
3799 try to change a logical combination of comparisons into a range test.
3802 X == 2 || X == 3 || X == 4 || X == 5
3806 (unsigned) (X - 2) <= 3
3808 We describe each set of comparisons as being either inside or outside
3809 a range, using a variable named like IN_P, and then describe the
3810 range with a lower and upper bound. If one of the bounds is omitted,
3811 it represents either the highest or lowest value of the type.
3813 In the comments below, we represent a range by two numbers in brackets
3814 preceded by a "+" to designate being inside that range, or a "-" to
3815 designate being outside that range, so the condition can be inverted by
3816 flipping the prefix. An omitted bound is represented by a "-". For
3817 example, "- [-, 10]" means being outside the range starting at the lowest
3818 possible value and ending at 10, in other words, being greater than 10.
3819 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3822 We set up things so that the missing bounds are handled in a consistent
3823 manner so neither a missing bound nor "true" and "false" need to be
3824 handled using a special case. */
3826 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3827 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3828 and UPPER1_P are nonzero if the respective argument is an upper bound
3829 and zero for a lower. TYPE, if nonzero, is the type of the result; it
3830 must be specified for a comparison. ARG1 will be converted to ARG0's
3831 type if both are specified. */
3834 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
3835 tree arg1, int upper1_p)
3841 /* If neither arg represents infinity, do the normal operation.
3842 Else, if not a comparison, return infinity. Else handle the special
3843 comparison rules. Note that most of the cases below won't occur, but
3844 are handled for consistency. */
3846 if (arg0 != 0 && arg1 != 0)
3848 tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3849 arg0, fold_convert (TREE_TYPE (arg0), arg1));
3851 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3854 if (TREE_CODE_CLASS (code) != tcc_comparison)
3857 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3858 for neither. In real maths, we cannot assume open ended ranges are
3859 the same. But, this is computer arithmetic, where numbers are finite.
3860 We can therefore make the transformation of any unbounded range with
3861 the value Z, Z being greater than any representable number. This permits
3862 us to treat unbounded ranges as equal. */
3863 sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3864 sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3868 result = sgn0 == sgn1;
3871 result = sgn0 != sgn1;
3874 result = sgn0 < sgn1;
3877 result = sgn0 <= sgn1;
3880 result = sgn0 > sgn1;
3883 result = sgn0 >= sgn1;
3889 return constant_boolean_node (result, type);
3892 /* Helper routine for make_range. Perform one step for it, return
3893 new expression if the loop should continue or NULL_TREE if it should
3897 make_range_step (location_t loc, enum tree_code code, tree arg0, tree arg1,
3898 tree exp_type, tree *p_low, tree *p_high, int *p_in_p,
3899 bool *strict_overflow_p)
3901 tree arg0_type = TREE_TYPE (arg0);
3902 tree n_low, n_high, low = *p_low, high = *p_high;
3903 int in_p = *p_in_p, n_in_p;
3907 case TRUTH_NOT_EXPR:
3908 /* We can only do something if the range is testing for zero. */
3909 if (low == NULL_TREE || high == NULL_TREE
3910 || ! integer_zerop (low) || ! integer_zerop (high))
3915 case EQ_EXPR: case NE_EXPR:
3916 case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3917 /* We can only do something if the range is testing for zero
3918 and if the second operand is an integer constant. Note that
3919 saying something is "in" the range we make is done by
3920 complementing IN_P since it will set in the initial case of
3921 being not equal to zero; "out" is leaving it alone. */
3922 if (low == NULL_TREE || high == NULL_TREE
3923 || ! integer_zerop (low) || ! integer_zerop (high)
3924 || TREE_CODE (arg1) != INTEGER_CST)
3929 case NE_EXPR: /* - [c, c] */
3932 case EQ_EXPR: /* + [c, c] */
3933 in_p = ! in_p, low = high = arg1;
3935 case GT_EXPR: /* - [-, c] */
3936 low = 0, high = arg1;
3938 case GE_EXPR: /* + [c, -] */
3939 in_p = ! in_p, low = arg1, high = 0;
3941 case LT_EXPR: /* - [c, -] */
3942 low = arg1, high = 0;
3944 case LE_EXPR: /* + [-, c] */
3945 in_p = ! in_p, low = 0, high = arg1;
3951 /* If this is an unsigned comparison, we also know that EXP is
3952 greater than or equal to zero. We base the range tests we make
3953 on that fact, so we record it here so we can parse existing
3954 range tests. We test arg0_type since often the return type
3955 of, e.g. EQ_EXPR, is boolean. */
3956 if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
3958 if (! merge_ranges (&n_in_p, &n_low, &n_high,
3960 build_int_cst (arg0_type, 0),
3964 in_p = n_in_p, low = n_low, high = n_high;
3966 /* If the high bound is missing, but we have a nonzero low
3967 bound, reverse the range so it goes from zero to the low bound
3969 if (high == 0 && low && ! integer_zerop (low))
3972 high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
3973 build_int_cst (TREE_TYPE (low), 1), 0);
3974 low = build_int_cst (arg0_type, 0);
3984 /* If flag_wrapv and ARG0_TYPE is signed, make sure
3985 low and high are non-NULL, then normalize will DTRT. */
3986 if (!TYPE_UNSIGNED (arg0_type)
3987 && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
3989 if (low == NULL_TREE)
3990 low = TYPE_MIN_VALUE (arg0_type);
3991 if (high == NULL_TREE)
3992 high = TYPE_MAX_VALUE (arg0_type);
3995 /* (-x) IN [a,b] -> x in [-b, -a] */
3996 n_low = range_binop (MINUS_EXPR, exp_type,
3997 build_int_cst (exp_type, 0),
3999 n_high = range_binop (MINUS_EXPR, exp_type,
4000 build_int_cst (exp_type, 0),
4002 if (n_high != 0 && TREE_OVERFLOW (n_high))
4008 return build2_loc (loc, MINUS_EXPR, exp_type, negate_expr (arg0),
4009 build_int_cst (exp_type, 1));
4013 if (TREE_CODE (arg1) != INTEGER_CST)
4016 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4017 move a constant to the other side. */
4018 if (!TYPE_UNSIGNED (arg0_type)
4019 && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4022 /* If EXP is signed, any overflow in the computation is undefined,
4023 so we don't worry about it so long as our computations on
4024 the bounds don't overflow. For unsigned, overflow is defined
4025 and this is exactly the right thing. */
4026 n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4027 arg0_type, low, 0, arg1, 0);
4028 n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4029 arg0_type, high, 1, arg1, 0);
4030 if ((n_low != 0 && TREE_OVERFLOW (n_low))
4031 || (n_high != 0 && TREE_OVERFLOW (n_high)))
4034 if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
4035 *strict_overflow_p = true;
4038 /* Check for an unsigned range which has wrapped around the maximum
4039 value thus making n_high < n_low, and normalize it. */
4040 if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
4042 low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
4043 build_int_cst (TREE_TYPE (n_high), 1), 0);
4044 high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
4045 build_int_cst (TREE_TYPE (n_low), 1), 0);
4047 /* If the range is of the form +/- [ x+1, x ], we won't
4048 be able to normalize it. But then, it represents the
4049 whole range or the empty set, so make it
4051 if (tree_int_cst_equal (n_low, low)
4052 && tree_int_cst_equal (n_high, high))
4058 low = n_low, high = n_high;
4066 case NON_LVALUE_EXPR:
4067 if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4070 if (! INTEGRAL_TYPE_P (arg0_type)
4071 || (low != 0 && ! int_fits_type_p (low, arg0_type))
4072 || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4075 n_low = low, n_high = high;
4078 n_low = fold_convert_loc (loc, arg0_type, n_low);
4081 n_high = fold_convert_loc (loc, arg0_type, n_high);
4083 /* If we're converting arg0 from an unsigned type, to exp,
4084 a signed type, we will be doing the comparison as unsigned.
4085 The tests above have already verified that LOW and HIGH
4088 So we have to ensure that we will handle large unsigned
4089 values the same way that the current signed bounds treat
4092 if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4096 /* For fixed-point modes, we need to pass the saturating flag
4097 as the 2nd parameter. */
4098 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4100 = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type),
4101 TYPE_SATURATING (arg0_type));
4104 = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type), 1);
4106 /* A range without an upper bound is, naturally, unbounded.
4107 Since convert would have cropped a very large value, use
4108 the max value for the destination type. */
4110 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4111 : TYPE_MAX_VALUE (arg0_type);
4113 if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4114 high_positive = fold_build2_loc (loc, RSHIFT_EXPR, arg0_type,
4115 fold_convert_loc (loc, arg0_type,
4117 build_int_cst (arg0_type, 1));
4119 /* If the low bound is specified, "and" the range with the
4120 range for which the original unsigned value will be
4124 if (! merge_ranges (&n_in_p, &n_low, &n_high, 1, n_low, n_high,
4125 1, fold_convert_loc (loc, arg0_type,
4130 in_p = (n_in_p == in_p);
4134 /* Otherwise, "or" the range with the range of the input
4135 that will be interpreted as negative. */
4136 if (! merge_ranges (&n_in_p, &n_low, &n_high, 0, n_low, n_high,
4137 1, fold_convert_loc (loc, arg0_type,
4142 in_p = (in_p != n_in_p);
4156 /* Given EXP, a logical expression, set the range it is testing into
4157 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4158 actually being tested. *PLOW and *PHIGH will be made of the same
4159 type as the returned expression. If EXP is not a comparison, we
4160 will most likely not be returning a useful value and range. Set
4161 *STRICT_OVERFLOW_P to true if the return value is only valid
4162 because signed overflow is undefined; otherwise, do not change
4163 *STRICT_OVERFLOW_P. */
4166 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
4167 bool *strict_overflow_p)
4169 enum tree_code code;
4170 tree arg0, arg1 = NULL_TREE;
4171 tree exp_type, nexp;
4174 location_t loc = EXPR_LOCATION (exp);
4176 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4177 and see if we can refine the range. Some of the cases below may not
4178 happen, but it doesn't seem worth worrying about this. We "continue"
4179 the outer loop when we've changed something; otherwise we "break"
4180 the switch, which will "break" the while. */
4183 low = high = build_int_cst (TREE_TYPE (exp), 0);
4187 code = TREE_CODE (exp);
4188 exp_type = TREE_TYPE (exp);
4191 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
4193 if (TREE_OPERAND_LENGTH (exp) > 0)
4194 arg0 = TREE_OPERAND (exp, 0);
4195 if (TREE_CODE_CLASS (code) == tcc_binary
4196 || TREE_CODE_CLASS (code) == tcc_comparison
4197 || (TREE_CODE_CLASS (code) == tcc_expression
4198 && TREE_OPERAND_LENGTH (exp) > 1))
4199 arg1 = TREE_OPERAND (exp, 1);
4201 if (arg0 == NULL_TREE)
4204 nexp = make_range_step (loc, code, arg0, arg1, exp_type, &low,
4205 &high, &in_p, strict_overflow_p);
4206 if (nexp == NULL_TREE)
4211 /* If EXP is a constant, we can evaluate whether this is true or false. */
4212 if (TREE_CODE (exp) == INTEGER_CST)
4214 in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4216 && integer_onep (range_binop (LE_EXPR, integer_type_node,
4222 *pin_p = in_p, *plow = low, *phigh = high;
4226 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4227 type, TYPE, return an expression to test if EXP is in (or out of, depending
4228 on IN_P) the range. Return 0 if the test couldn't be created. */
4231 build_range_check (location_t loc, tree type, tree exp, int in_p,
4232 tree low, tree high)
4234 tree etype = TREE_TYPE (exp), value;
4236 #ifdef HAVE_canonicalize_funcptr_for_compare
4237 /* Disable this optimization for function pointer expressions
4238 on targets that require function pointer canonicalization. */
4239 if (HAVE_canonicalize_funcptr_for_compare
4240 && TREE_CODE (etype) == POINTER_TYPE
4241 && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4247 value = build_range_check (loc, type, exp, 1, low, high);
4249 return invert_truthvalue_loc (loc, value);
4254 if (low == 0 && high == 0)
4255 return omit_one_operand_loc (loc, type, build_int_cst (type, 1), exp);
4258 return fold_build2_loc (loc, LE_EXPR, type, exp,
4259 fold_convert_loc (loc, etype, high));
4262 return fold_build2_loc (loc, GE_EXPR, type, exp,
4263 fold_convert_loc (loc, etype, low));
4265 if (operand_equal_p (low, high, 0))
4266 return fold_build2_loc (loc, EQ_EXPR, type, exp,
4267 fold_convert_loc (loc, etype, low));
4269 if (integer_zerop (low))
4271 if (! TYPE_UNSIGNED (etype))
4273 etype = unsigned_type_for (etype);
4274 high = fold_convert_loc (loc, etype, high);
4275 exp = fold_convert_loc (loc, etype, exp);
4277 return build_range_check (loc, type, exp, 1, 0, high);
4280 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4281 if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4283 int prec = TYPE_PRECISION (etype);
4285 if (wi::mask (prec - 1, false, prec) == high)
4287 if (TYPE_UNSIGNED (etype))
4289 tree signed_etype = signed_type_for (etype);
4290 if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
4292 = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
4294 etype = signed_etype;
4295 exp = fold_convert_loc (loc, etype, exp);
4297 return fold_build2_loc (loc, GT_EXPR, type, exp,
4298 build_int_cst (etype, 0));
4302 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4303 This requires wrap-around arithmetics for the type of the expression.
4304 First make sure that arithmetics in this type is valid, then make sure
4305 that it wraps around. */
4306 if (TREE_CODE (etype) == ENUMERAL_TYPE || TREE_CODE (etype) == BOOLEAN_TYPE)
4307 etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4308 TYPE_UNSIGNED (etype));
4310 if (TREE_CODE (etype) == INTEGER_TYPE && !TYPE_OVERFLOW_WRAPS (etype))
4312 tree utype, minv, maxv;
4314 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4315 for the type in question, as we rely on this here. */
4316 utype = unsigned_type_for (etype);
4317 maxv = fold_convert_loc (loc, utype, TYPE_MAX_VALUE (etype));
4318 maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4319 build_int_cst (TREE_TYPE (maxv), 1), 1);
4320 minv = fold_convert_loc (loc, utype, TYPE_MIN_VALUE (etype));
4322 if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4329 high = fold_convert_loc (loc, etype, high);
4330 low = fold_convert_loc (loc, etype, low);
4331 exp = fold_convert_loc (loc, etype, exp);
4333 value = const_binop (MINUS_EXPR, high, low);
4336 if (POINTER_TYPE_P (etype))
4338 if (value != 0 && !TREE_OVERFLOW (value))
4340 low = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (low), low);
4341 return build_range_check (loc, type,
4342 fold_build_pointer_plus_loc (loc, exp, low),
4343 1, build_int_cst (etype, 0), value);
4348 if (value != 0 && !TREE_OVERFLOW (value))
4349 return build_range_check (loc, type,
4350 fold_build2_loc (loc, MINUS_EXPR, etype, exp, low),
4351 1, build_int_cst (etype, 0), value);
4356 /* Return the predecessor of VAL in its type, handling the infinite case. */
4359 range_predecessor (tree val)
4361 tree type = TREE_TYPE (val);
4363 if (INTEGRAL_TYPE_P (type)
4364 && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4367 return range_binop (MINUS_EXPR, NULL_TREE, val, 0,
4368 build_int_cst (TREE_TYPE (val), 1), 0);
4371 /* Return the successor of VAL in its type, handling the infinite case. */
4374 range_successor (tree val)
4376 tree type = TREE_TYPE (val);
4378 if (INTEGRAL_TYPE_P (type)
4379 && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4382 return range_binop (PLUS_EXPR, NULL_TREE, val, 0,
4383 build_int_cst (TREE_TYPE (val), 1), 0);
4386 /* Given two ranges, see if we can merge them into one. Return 1 if we
4387 can, 0 if we can't. Set the output range into the specified parameters. */
4390 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4391 tree high0, int in1_p, tree low1, tree high1)
4399 int lowequal = ((low0 == 0 && low1 == 0)
4400 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4401 low0, 0, low1, 0)));
4402 int highequal = ((high0 == 0 && high1 == 0)
4403 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4404 high0, 1, high1, 1)));
4406 /* Make range 0 be the range that starts first, or ends last if they
4407 start at the same value. Swap them if it isn't. */
4408 if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4411 && integer_onep (range_binop (GT_EXPR, integer_type_node,
4412 high1, 1, high0, 1))))
4414 temp = in0_p, in0_p = in1_p, in1_p = temp;
4415 tem = low0, low0 = low1, low1 = tem;
4416 tem = high0, high0 = high1, high1 = tem;
4419 /* Now flag two cases, whether the ranges are disjoint or whether the
4420 second range is totally subsumed in the first. Note that the tests
4421 below are simplified by the ones above. */
4422 no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4423 high0, 1, low1, 0));
4424 subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4425 high1, 1, high0, 1));
4427 /* We now have four cases, depending on whether we are including or
4428 excluding the two ranges. */
4431 /* If they don't overlap, the result is false. If the second range
4432 is a subset it is the result. Otherwise, the range is from the start
4433 of the second to the end of the first. */
4435 in_p = 0, low = high = 0;
4437 in_p = 1, low = low1, high = high1;
4439 in_p = 1, low = low1, high = high0;
4442 else if (in0_p && ! in1_p)
4444 /* If they don't overlap, the result is the first range. If they are
4445 equal, the result is false. If the second range is a subset of the
4446 first, and the ranges begin at the same place, we go from just after
4447 the end of the second range to the end of the first. If the second
4448 range is not a subset of the first, or if it is a subset and both
4449 ranges end at the same place, the range starts at the start of the
4450 first range and ends just before the second range.
4451 Otherwise, we can't describe this as a single range. */
4453 in_p = 1, low = low0, high = high0;
4454 else if (lowequal && highequal)
4455 in_p = 0, low = high = 0;
4456 else if (subset && lowequal)
4458 low = range_successor (high1);
4463 /* We are in the weird situation where high0 > high1 but
4464 high1 has no successor. Punt. */
4468 else if (! subset || highequal)
4471 high = range_predecessor (low1);
4475 /* low0 < low1 but low1 has no predecessor. Punt. */
4483 else if (! in0_p && in1_p)
4485 /* If they don't overlap, the result is the second range. If the second
4486 is a subset of the first, the result is false. Otherwise,
4487 the range starts just after the first range and ends at the
4488 end of the second. */
4490 in_p = 1, low = low1, high = high1;
4491 else if (subset || highequal)
4492 in_p = 0, low = high = 0;
4495 low = range_successor (high0);
4500 /* high1 > high0 but high0 has no successor. Punt. */
4508 /* The case where we are excluding both ranges. Here the complex case
4509 is if they don't overlap. In that case, the only time we have a
4510 range is if they are adjacent. If the second is a subset of the
4511 first, the result is the first. Otherwise, the range to exclude
4512 starts at the beginning of the first range and ends at the end of the
4516 if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4517 range_successor (high0),
4519 in_p = 0, low = low0, high = high1;
4522 /* Canonicalize - [min, x] into - [-, x]. */
4523 if (low0 && TREE_CODE (low0) == INTEGER_CST)
4524 switch (TREE_CODE (TREE_TYPE (low0)))
4527 if (TYPE_PRECISION (TREE_TYPE (low0))
4528 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4532 if (tree_int_cst_equal (low0,
4533 TYPE_MIN_VALUE (TREE_TYPE (low0))))
4537 if (TYPE_UNSIGNED (TREE_TYPE (low0))
4538 && integer_zerop (low0))
4545 /* Canonicalize - [x, max] into - [x, -]. */
4546 if (high1 && TREE_CODE (high1) == INTEGER_CST)
4547 switch (TREE_CODE (TREE_TYPE (high1)))
4550 if (TYPE_PRECISION (TREE_TYPE (high1))
4551 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4555 if (tree_int_cst_equal (high1,
4556 TYPE_MAX_VALUE (TREE_TYPE (high1))))
4560 if (TYPE_UNSIGNED (TREE_TYPE (high1))
4561 && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4563 build_int_cst (TREE_TYPE (high1), 1),
4571 /* The ranges might be also adjacent between the maximum and
4572 minimum values of the given type. For
4573 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4574 return + [x + 1, y - 1]. */
4575 if (low0 == 0 && high1 == 0)
4577 low = range_successor (high0);
4578 high = range_predecessor (low1);
4579 if (low == 0 || high == 0)
4589 in_p = 0, low = low0, high = high0;
4591 in_p = 0, low = low0, high = high1;
4594 *pin_p = in_p, *plow = low, *phigh = high;
4599 /* Subroutine of fold, looking inside expressions of the form
4600 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4601 of the COND_EXPR. This function is being used also to optimize
4602 A op B ? C : A, by reversing the comparison first.
4604 Return a folded expression whose code is not a COND_EXPR
4605 anymore, or NULL_TREE if no folding opportunity is found. */
4608 fold_cond_expr_with_comparison (location_t loc, tree type,
4609 tree arg0, tree arg1, tree arg2)
4611 enum tree_code comp_code = TREE_CODE (arg0);
4612 tree arg00 = TREE_OPERAND (arg0, 0);
4613 tree arg01 = TREE_OPERAND (arg0, 1);
4614 tree arg1_type = TREE_TYPE (arg1);
4620 /* If we have A op 0 ? A : -A, consider applying the following
4623 A == 0? A : -A same as -A
4624 A != 0? A : -A same as A
4625 A >= 0? A : -A same as abs (A)
4626 A > 0? A : -A same as abs (A)
4627 A <= 0? A : -A same as -abs (A)
4628 A < 0? A : -A same as -abs (A)
4630 None of these transformations work for modes with signed
4631 zeros. If A is +/-0, the first two transformations will
4632 change the sign of the result (from +0 to -0, or vice
4633 versa). The last four will fix the sign of the result,
4634 even though the original expressions could be positive or
4635 negative, depending on the sign of A.
4637 Note that all these transformations are correct if A is
4638 NaN, since the two alternatives (A and -A) are also NaNs. */
4639 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4640 && (FLOAT_TYPE_P (TREE_TYPE (arg01))
4641 ? real_zerop (arg01)
4642 : integer_zerop (arg01))
4643 && ((TREE_CODE (arg2) == NEGATE_EXPR
4644 && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4645 /* In the case that A is of the form X-Y, '-A' (arg2) may
4646 have already been folded to Y-X, check for that. */
4647 || (TREE_CODE (arg1) == MINUS_EXPR
4648 && TREE_CODE (arg2) == MINUS_EXPR
4649 && operand_equal_p (TREE_OPERAND (arg1, 0),
4650 TREE_OPERAND (arg2, 1), 0)
4651 && operand_equal_p (TREE_OPERAND (arg1, 1),
4652 TREE_OPERAND (arg2, 0), 0))))
4657 tem = fold_convert_loc (loc, arg1_type, arg1);
4658 return pedantic_non_lvalue_loc (loc,
4659 fold_convert_loc (loc, type,
4660 negate_expr (tem)));
4663 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4666 if (flag_trapping_math)
4671 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4672 arg1 = fold_convert_loc (loc, signed_type_for
4673 (TREE_TYPE (arg1)), arg1);
4674 tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4675 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4678 if (flag_trapping_math)
4682 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4683 arg1 = fold_convert_loc (loc, signed_type_for
4684 (TREE_TYPE (arg1)), arg1);
4685 tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4686 return negate_expr (fold_convert_loc (loc, type, tem));
4688 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4692 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
4693 A == 0 ? A : 0 is always 0 unless A is -0. Note that
4694 both transformations are correct when A is NaN: A != 0
4695 is then true, and A == 0 is false. */
4697 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4698 && integer_zerop (arg01) && integer_zerop (arg2))
4700 if (comp_code == NE_EXPR)
4701 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4702 else if (comp_code == EQ_EXPR)
4703 return build_zero_cst (type);
4706 /* Try some transformations of A op B ? A : B.
4708 A == B? A : B same as B
4709 A != B? A : B same as A
4710 A >= B? A : B same as max (A, B)
4711 A > B? A : B same as max (B, A)
4712 A <= B? A : B same as min (A, B)
4713 A < B? A : B same as min (B, A)
4715 As above, these transformations don't work in the presence
4716 of signed zeros. For example, if A and B are zeros of
4717 opposite sign, the first two transformations will change
4718 the sign of the result. In the last four, the original
4719 expressions give different results for (A=+0, B=-0) and
4720 (A=-0, B=+0), but the transformed expressions do not.
4722 The first two transformations are correct if either A or B
4723 is a NaN. In the first transformation, the condition will
4724 be false, and B will indeed be chosen. In the case of the
4725 second transformation, the condition A != B will be true,
4726 and A will be chosen.
4728 The conversions to max() and min() are not correct if B is
4729 a number and A is not. The conditions in the original
4730 expressions will be false, so all four give B. The min()
4731 and max() versions would give a NaN instead. */
4732 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4733 && operand_equal_for_comparison_p (arg01, arg2, arg00)
4734 /* Avoid these transformations if the COND_EXPR may be used
4735 as an lvalue in the C++ front-end. PR c++/19199. */
4737 || VECTOR_TYPE_P (type)
4738 || (strcmp (lang_hooks.name, "GNU C++") != 0
4739 && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
4740 || ! maybe_lvalue_p (arg1)
4741 || ! maybe_lvalue_p (arg2)))
4743 tree comp_op0 = arg00;
4744 tree comp_op1 = arg01;
4745 tree comp_type = TREE_TYPE (comp_op0);
4747 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
4748 if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4758 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg2));
4760 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4765 /* In C++ a ?: expression can be an lvalue, so put the
4766 operand which will be used if they are equal first
4767 so that we can convert this back to the
4768 corresponding COND_EXPR. */
4769 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4771 comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4772 comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4773 tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4774 ? fold_build2_loc (loc, MIN_EXPR, comp_type, comp_op0, comp_op1)
4775 : fold_build2_loc (loc, MIN_EXPR, comp_type,
4776 comp_op1, comp_op0);
4777 return pedantic_non_lvalue_loc (loc,
4778 fold_convert_loc (loc, type, tem));
4785 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4787 comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4788 comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4789 tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4790 ? fold_build2_loc (loc, MAX_EXPR, comp_type, comp_op0, comp_op1)
4791 : fold_build2_loc (loc, MAX_EXPR, comp_type,
4792 comp_op1, comp_op0);
4793 return pedantic_non_lvalue_loc (loc,
4794 fold_convert_loc (loc, type, tem));
4798 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4799 return pedantic_non_lvalue_loc (loc,
4800 fold_convert_loc (loc, type, arg2));
4803 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4804 return pedantic_non_lvalue_loc (loc,
4805 fold_convert_loc (loc, type, arg1));
4808 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4813 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4814 we might still be able to simplify this. For example,
4815 if C1 is one less or one more than C2, this might have started
4816 out as a MIN or MAX and been transformed by this function.
4817 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
4819 if (INTEGRAL_TYPE_P (type)
4820 && TREE_CODE (arg01) == INTEGER_CST
4821 && TREE_CODE (arg2) == INTEGER_CST)
4825 if (TREE_CODE (arg1) == INTEGER_CST)
4827 /* We can replace A with C1 in this case. */
4828 arg1 = fold_convert_loc (loc, type, arg01);
4829 return fold_build3_loc (loc, COND_EXPR, type, arg0, arg1, arg2);
4832 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
4833 MIN_EXPR, to preserve the signedness of the comparison. */
4834 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4836 && operand_equal_p (arg01,
4837 const_binop (PLUS_EXPR, arg2,
4838 build_int_cst (type, 1)),
4841 tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
4842 fold_convert_loc (loc, TREE_TYPE (arg00),
4844 return pedantic_non_lvalue_loc (loc,
4845 fold_convert_loc (loc, type, tem));
4850 /* If C1 is C2 - 1, this is min(A, C2), with the same care
4852 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4854 && operand_equal_p (arg01,
4855 const_binop (MINUS_EXPR, arg2,
4856 build_int_cst (type, 1)),
4859 tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
4860 fold_convert_loc (loc, TREE_TYPE (arg00),
4862 return pedantic_non_lvalue_loc (loc,
4863 fold_convert_loc (loc, type, tem));
4868 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
4869 MAX_EXPR, to preserve the signedness of the comparison. */
4870 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4872 && operand_equal_p (arg01,
4873 const_binop (MINUS_EXPR, arg2,
4874 build_int_cst (type, 1)),
4877 tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
4878 fold_convert_loc (loc, TREE_TYPE (arg00),
4880 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4885 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
4886 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4888 && operand_equal_p (arg01,
4889 const_binop (PLUS_EXPR, arg2,
4890 build_int_cst (type, 1)),
4893 tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
4894 fold_convert_loc (loc, TREE_TYPE (arg00),
4896 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4910 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
4911 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
4912 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
4916 /* EXP is some logical combination of boolean tests. See if we can
4917 merge it into some range test. Return the new tree if so. */
4920 fold_range_test (location_t loc, enum tree_code code, tree type,
4923 int or_op = (code == TRUTH_ORIF_EXPR
4924 || code == TRUTH_OR_EXPR);
4925 int in0_p, in1_p, in_p;
4926 tree low0, low1, low, high0, high1, high;
4927 bool strict_overflow_p = false;
4929 const char * const warnmsg = G_("assuming signed overflow does not occur "
4930 "when simplifying range test");
4932 if (!INTEGRAL_TYPE_P (type))
4935 lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
4936 rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
4938 /* If this is an OR operation, invert both sides; we will invert
4939 again at the end. */
4941 in0_p = ! in0_p, in1_p = ! in1_p;
4943 /* If both expressions are the same, if we can merge the ranges, and we
4944 can build the range test, return it or it inverted. If one of the
4945 ranges is always true or always false, consider it to be the same
4946 expression as the other. */
4947 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
4948 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
4950 && 0 != (tem = (build_range_check (loc, type,
4952 : rhs != 0 ? rhs : integer_zero_node,
4955 if (strict_overflow_p)
4956 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
4957 return or_op ? invert_truthvalue_loc (loc, tem) : tem;
4960 /* On machines where the branch cost is expensive, if this is a
4961 short-circuited branch and the underlying object on both sides
4962 is the same, make a non-short-circuit operation. */
4963 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
4964 && lhs != 0 && rhs != 0
4965 && (code == TRUTH_ANDIF_EXPR
4966 || code == TRUTH_ORIF_EXPR)
4967 && operand_equal_p (lhs, rhs, 0))
4969 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
4970 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4971 which cases we can't do this. */
4972 if (simple_operand_p (lhs))
4973 return build2_loc (loc, code == TRUTH_ANDIF_EXPR
4974 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4977 else if (!lang_hooks.decls.global_bindings_p ()
4978 && !CONTAINS_PLACEHOLDER_P (lhs))
4980 tree common = save_expr (lhs);
4982 if (0 != (lhs = build_range_check (loc, type, common,
4983 or_op ? ! in0_p : in0_p,
4985 && (0 != (rhs = build_range_check (loc, type, common,
4986 or_op ? ! in1_p : in1_p,
4989 if (strict_overflow_p)
4990 fold_overflow_warning (warnmsg,
4991 WARN_STRICT_OVERFLOW_COMPARISON);
4992 return build2_loc (loc, code == TRUTH_ANDIF_EXPR
4993 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5002 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5003 bit value. Arrange things so the extra bits will be set to zero if and
5004 only if C is signed-extended to its full width. If MASK is nonzero,
5005 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5008 unextend (tree c, int p, int unsignedp, tree mask)
5010 tree type = TREE_TYPE (c);
5011 int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
5014 if (p == modesize || unsignedp)
5017 /* We work by getting just the sign bit into the low-order bit, then
5018 into the high-order bit, then sign-extend. We then XOR that value
5020 temp = build_int_cst (TREE_TYPE (c), wi::extract_uhwi (c, p - 1, 1));
5022 /* We must use a signed type in order to get an arithmetic right shift.
5023 However, we must also avoid introducing accidental overflows, so that
5024 a subsequent call to integer_zerop will work. Hence we must
5025 do the type conversion here. At this point, the constant is either
5026 zero or one, and the conversion to a signed type can never overflow.
5027 We could get an overflow if this conversion is done anywhere else. */
5028 if (TYPE_UNSIGNED (type))
5029 temp = fold_convert (signed_type_for (type), temp);
5031 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1));
5032 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1));
5034 temp = const_binop (BIT_AND_EXPR, temp,
5035 fold_convert (TREE_TYPE (c), mask));
5036 /* If necessary, convert the type back to match the type of C. */
5037 if (TYPE_UNSIGNED (type))
5038 temp = fold_convert (type, temp);
5040 return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp));
5043 /* For an expression that has the form
5047 we can drop one of the inner expressions and simplify to
5051 LOC is the location of the resulting expression. OP is the inner
5052 logical operation; the left-hand side in the examples above, while CMPOP
5053 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5054 removing a condition that guards another, as in
5055 (A != NULL && A->...) || A == NULL
5056 which we must not transform. If RHS_ONLY is true, only eliminate the
5057 right-most operand of the inner logical operation. */
5060 merge_truthop_with_opposite_arm (location_t loc, tree op, tree cmpop,
5063 tree type = TREE_TYPE (cmpop);
5064 enum tree_code code = TREE_CODE (cmpop);
5065 enum tree_code truthop_code = TREE_CODE (op);
5066 tree lhs = TREE_OPERAND (op, 0);
5067 tree rhs = TREE_OPERAND (op, 1);
5068 tree orig_lhs = lhs, orig_rhs = rhs;
5069 enum tree_code rhs_code = TREE_CODE (rhs);
5070 enum tree_code lhs_code = TREE_CODE (lhs);
5071 enum tree_code inv_code;
5073 if (TREE_SIDE_EFFECTS (op) || TREE_SIDE_EFFECTS (cmpop))
5076 if (TREE_CODE_CLASS (code) != tcc_comparison)
5079 if (rhs_code == truthop_code)
5081 tree newrhs = merge_truthop_with_opposite_arm (loc, rhs, cmpop, rhs_only);
5082 if (newrhs != NULL_TREE)
5085 rhs_code = TREE_CODE (rhs);
5088 if (lhs_code == truthop_code && !rhs_only)
5090 tree newlhs = merge_truthop_with_opposite_arm (loc, lhs, cmpop, false);
5091 if (newlhs != NULL_TREE)
5094 lhs_code = TREE_CODE (lhs);
5098 inv_code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (type)));
5099 if (inv_code == rhs_code
5100 && operand_equal_p (TREE_OPERAND (rhs, 0), TREE_OPERAND (cmpop, 0), 0)
5101 && operand_equal_p (TREE_OPERAND (rhs, 1), TREE_OPERAND (cmpop, 1), 0))
5103 if (!rhs_only && inv_code == lhs_code
5104 && operand_equal_p (TREE_OPERAND (lhs, 0), TREE_OPERAND (cmpop, 0), 0)
5105 && operand_equal_p (TREE_OPERAND (lhs, 1), TREE_OPERAND (cmpop, 1), 0))
5107 if (rhs != orig_rhs || lhs != orig_lhs)
5108 return fold_build2_loc (loc, truthop_code, TREE_TYPE (cmpop),
5113 /* Find ways of folding logical expressions of LHS and RHS:
5114 Try to merge two comparisons to the same innermost item.
5115 Look for range tests like "ch >= '0' && ch <= '9'".
5116 Look for combinations of simple terms on machines with expensive branches
5117 and evaluate the RHS unconditionally.
5119 For example, if we have p->a == 2 && p->b == 4 and we can make an
5120 object large enough to span both A and B, we can do this with a comparison
5121 against the object ANDed with the a mask.
5123 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5124 operations to do this with one comparison.
5126 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5127 function and the one above.
5129 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5130 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5132 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5135 We return the simplified tree or 0 if no optimization is possible. */
5138 fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
5141 /* If this is the "or" of two comparisons, we can do something if
5142 the comparisons are NE_EXPR. If this is the "and", we can do something
5143 if the comparisons are EQ_EXPR. I.e.,
5144 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5146 WANTED_CODE is this operation code. For single bit fields, we can
5147 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5148 comparison for one-bit fields. */
5150 enum tree_code wanted_code;
5151 enum tree_code lcode, rcode;
5152 tree ll_arg, lr_arg, rl_arg, rr_arg;
5153 tree ll_inner, lr_inner, rl_inner, rr_inner;
5154 HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5155 HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5156 HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5157 HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5158 int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5159 machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5160 machine_mode lnmode, rnmode;
5161 tree ll_mask, lr_mask, rl_mask, rr_mask;
5162 tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5163 tree l_const, r_const;
5164 tree lntype, rntype, result;
5165 HOST_WIDE_INT first_bit, end_bit;
5168 /* Start by getting the comparison codes. Fail if anything is volatile.
5169 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5170 it were surrounded with a NE_EXPR. */
5172 if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5175 lcode = TREE_CODE (lhs);
5176 rcode = TREE_CODE (rhs);
5178 if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5180 lhs = build2 (NE_EXPR, truth_type, lhs,
5181 build_int_cst (TREE_TYPE (lhs), 0));
5185 if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5187 rhs = build2 (NE_EXPR, truth_type, rhs,
5188 build_int_cst (TREE_TYPE (rhs), 0));
5192 if (TREE_CODE_CLASS (lcode) != tcc_comparison
5193 || TREE_CODE_CLASS (rcode) != tcc_comparison)
5196 ll_arg = TREE_OPERAND (lhs, 0);
5197 lr_arg = TREE_OPERAND (lhs, 1);
5198 rl_arg = TREE_OPERAND (rhs, 0);
5199 rr_arg = TREE_OPERAND (rhs, 1);
5201 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5202 if (simple_operand_p (ll_arg)
5203 && simple_operand_p (lr_arg))
5205 if (operand_equal_p (ll_arg, rl_arg, 0)
5206 && operand_equal_p (lr_arg, rr_arg, 0))
5208 result = combine_comparisons (loc, code, lcode, rcode,
5209 truth_type, ll_arg, lr_arg);
5213 else if (operand_equal_p (ll_arg, rr_arg, 0)
5214 && operand_equal_p (lr_arg, rl_arg, 0))
5216 result = combine_comparisons (loc, code, lcode,
5217 swap_tree_comparison (rcode),
5218 truth_type, ll_arg, lr_arg);
5224 code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5225 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5227 /* If the RHS can be evaluated unconditionally and its operands are
5228 simple, it wins to evaluate the RHS unconditionally on machines
5229 with expensive branches. In this case, this isn't a comparison
5230 that can be merged. */
5232 if (BRANCH_COST (optimize_function_for_speed_p (cfun),
5234 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5235 && simple_operand_p (rl_arg)
5236 && simple_operand_p (rr_arg))
5238 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5239 if (code == TRUTH_OR_EXPR
5240 && lcode == NE_EXPR && integer_zerop (lr_arg)
5241 && rcode == NE_EXPR && integer_zerop (rr_arg)
5242 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5243 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5244 return build2_loc (loc, NE_EXPR, truth_type,
5245 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5247 build_int_cst (TREE_TYPE (ll_arg), 0));
5249 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5250 if (code == TRUTH_AND_EXPR
5251 && lcode == EQ_EXPR && integer_zerop (lr_arg)
5252 && rcode == EQ_EXPR && integer_zerop (rr_arg)
5253 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5254 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5255 return build2_loc (loc, EQ_EXPR, truth_type,
5256 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5258 build_int_cst (TREE_TYPE (ll_arg), 0));
5261 /* See if the comparisons can be merged. Then get all the parameters for
5264 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5265 || (rcode != EQ_EXPR && rcode != NE_EXPR))
5269 ll_inner = decode_field_reference (loc, ll_arg,
5270 &ll_bitsize, &ll_bitpos, &ll_mode,
5271 &ll_unsignedp, &volatilep, &ll_mask,
5273 lr_inner = decode_field_reference (loc, lr_arg,
5274 &lr_bitsize, &lr_bitpos, &lr_mode,
5275 &lr_unsignedp, &volatilep, &lr_mask,
5277 rl_inner = decode_field_reference (loc, rl_arg,
5278 &rl_bitsize, &rl_bitpos, &rl_mode,
5279 &rl_unsignedp, &volatilep, &rl_mask,
5281 rr_inner = decode_field_reference (loc, rr_arg,
5282 &rr_bitsize, &rr_bitpos, &rr_mode,
5283 &rr_unsignedp, &volatilep, &rr_mask,
5286 /* It must be true that the inner operation on the lhs of each
5287 comparison must be the same if we are to be able to do anything.
5288 Then see if we have constants. If not, the same must be true for
5290 if (volatilep || ll_inner == 0 || rl_inner == 0
5291 || ! operand_equal_p (ll_inner, rl_inner, 0))
5294 if (TREE_CODE (lr_arg) == INTEGER_CST
5295 && TREE_CODE (rr_arg) == INTEGER_CST)
5296 l_const = lr_arg, r_const = rr_arg;
5297 else if (lr_inner == 0 || rr_inner == 0
5298 || ! operand_equal_p (lr_inner, rr_inner, 0))
5301 l_const = r_const = 0;
5303 /* If either comparison code is not correct for our logical operation,
5304 fail. However, we can convert a one-bit comparison against zero into
5305 the opposite comparison against that bit being set in the field. */
5307 wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5308 if (lcode != wanted_code)
5310 if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5312 /* Make the left operand unsigned, since we are only interested
5313 in the value of one bit. Otherwise we are doing the wrong
5322 /* This is analogous to the code for l_const above. */
5323 if (rcode != wanted_code)
5325 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5334 /* See if we can find a mode that contains both fields being compared on
5335 the left. If we can't, fail. Otherwise, update all constants and masks
5336 to be relative to a field of that size. */
5337 first_bit = MIN (ll_bitpos, rl_bitpos);
5338 end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5339 lnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5340 TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5342 if (lnmode == VOIDmode)
5345 lnbitsize = GET_MODE_BITSIZE (lnmode);
5346 lnbitpos = first_bit & ~ (lnbitsize - 1);
5347 lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5348 xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5350 if (BYTES_BIG_ENDIAN)
5352 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5353 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5356 ll_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, ll_mask),
5357 size_int (xll_bitpos));
5358 rl_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, rl_mask),
5359 size_int (xrl_bitpos));
5363 l_const = fold_convert_loc (loc, lntype, l_const);
5364 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5365 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos));
5366 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5367 fold_build1_loc (loc, BIT_NOT_EXPR,
5370 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5372 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5377 r_const = fold_convert_loc (loc, lntype, r_const);
5378 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5379 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos));
5380 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5381 fold_build1_loc (loc, BIT_NOT_EXPR,
5384 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5386 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5390 /* If the right sides are not constant, do the same for it. Also,
5391 disallow this optimization if a size or signedness mismatch occurs
5392 between the left and right sides. */
5395 if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5396 || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5397 /* Make sure the two fields on the right
5398 correspond to the left without being swapped. */
5399 || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5402 first_bit = MIN (lr_bitpos, rr_bitpos);
5403 end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5404 rnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5405 TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5407 if (rnmode == VOIDmode)
5410 rnbitsize = GET_MODE_BITSIZE (rnmode);
5411 rnbitpos = first_bit & ~ (rnbitsize - 1);
5412 rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5413 xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5415 if (BYTES_BIG_ENDIAN)
5417 xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5418 xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5421 lr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5423 size_int (xlr_bitpos));
5424 rr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5426 size_int (xrr_bitpos));
5428 /* Make a mask that corresponds to both fields being compared.
5429 Do this for both items being compared. If the operands are the
5430 same size and the bits being compared are in the same position
5431 then we can do this by masking both and comparing the masked
5433 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5434 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
5435 if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5437 lhs = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5438 ll_unsignedp || rl_unsignedp);
5439 if (! all_ones_mask_p (ll_mask, lnbitsize))
5440 lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5442 rhs = make_bit_field_ref (loc, lr_inner, rntype, rnbitsize, rnbitpos,
5443 lr_unsignedp || rr_unsignedp);
5444 if (! all_ones_mask_p (lr_mask, rnbitsize))
5445 rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5447 return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5450 /* There is still another way we can do something: If both pairs of
5451 fields being compared are adjacent, we may be able to make a wider
5452 field containing them both.
5454 Note that we still must mask the lhs/rhs expressions. Furthermore,
5455 the mask must be shifted to account for the shift done by
5456 make_bit_field_ref. */
5457 if ((ll_bitsize + ll_bitpos == rl_bitpos
5458 && lr_bitsize + lr_bitpos == rr_bitpos)
5459 || (ll_bitpos == rl_bitpos + rl_bitsize
5460 && lr_bitpos == rr_bitpos + rr_bitsize))
5464 lhs = make_bit_field_ref (loc, ll_inner, lntype,
5465 ll_bitsize + rl_bitsize,
5466 MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5467 rhs = make_bit_field_ref (loc, lr_inner, rntype,
5468 lr_bitsize + rr_bitsize,
5469 MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5471 ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5472 size_int (MIN (xll_bitpos, xrl_bitpos)));
5473 lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5474 size_int (MIN (xlr_bitpos, xrr_bitpos)));
5476 /* Convert to the smaller type before masking out unwanted bits. */
5478 if (lntype != rntype)
5480 if (lnbitsize > rnbitsize)
5482 lhs = fold_convert_loc (loc, rntype, lhs);
5483 ll_mask = fold_convert_loc (loc, rntype, ll_mask);
5486 else if (lnbitsize < rnbitsize)
5488 rhs = fold_convert_loc (loc, lntype, rhs);
5489 lr_mask = fold_convert_loc (loc, lntype, lr_mask);
5494 if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5495 lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5497 if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5498 rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5500 return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5506 /* Handle the case of comparisons with constants. If there is something in
5507 common between the masks, those bits of the constants must be the same.
5508 If not, the condition is always false. Test for this to avoid generating
5509 incorrect code below. */
5510 result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask);
5511 if (! integer_zerop (result)
5512 && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const),
5513 const_binop (BIT_AND_EXPR, result, r_const)) != 1)
5515 if (wanted_code == NE_EXPR)
5517 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5518 return constant_boolean_node (true, truth_type);
5522 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5523 return constant_boolean_node (false, truth_type);
5527 /* Construct the expression we will return. First get the component
5528 reference we will make. Unless the mask is all ones the width of
5529 that field, perform the mask operation. Then compare with the
5531 result = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5532 ll_unsignedp || rl_unsignedp);
5534 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5535 if (! all_ones_mask_p (ll_mask, lnbitsize))
5536 result = build2_loc (loc, BIT_AND_EXPR, lntype, result, ll_mask);
5538 return build2_loc (loc, wanted_code, truth_type, result,
5539 const_binop (BIT_IOR_EXPR, l_const, r_const));
5542 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5546 optimize_minmax_comparison (location_t loc, enum tree_code code, tree type,
5550 enum tree_code op_code;
5553 int consts_equal, consts_lt;
5556 STRIP_SIGN_NOPS (arg0);
5558 op_code = TREE_CODE (arg0);
5559 minmax_const = TREE_OPERAND (arg0, 1);
5560 comp_const = fold_convert_loc (loc, TREE_TYPE (arg0), op1);
5561 consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5562 consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5563 inner = TREE_OPERAND (arg0, 0);
5565 /* If something does not permit us to optimize, return the original tree. */
5566 if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5567 || TREE_CODE (comp_const) != INTEGER_CST
5568 || TREE_OVERFLOW (comp_const)
5569 || TREE_CODE (minmax_const) != INTEGER_CST
5570 || TREE_OVERFLOW (minmax_const))
5573 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5574 and GT_EXPR, doing the rest with recursive calls using logical
5578 case NE_EXPR: case LT_EXPR: case LE_EXPR:
5581 = optimize_minmax_comparison (loc,
5582 invert_tree_comparison (code, false),
5585 return invert_truthvalue_loc (loc, tem);
5591 fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
5592 optimize_minmax_comparison
5593 (loc, EQ_EXPR, type, arg0, comp_const),
5594 optimize_minmax_comparison
5595 (loc, GT_EXPR, type, arg0, comp_const));
5598 if (op_code == MAX_EXPR && consts_equal)
5599 /* MAX (X, 0) == 0 -> X <= 0 */
5600 return fold_build2_loc (loc, LE_EXPR, type, inner, comp_const);
5602 else if (op_code == MAX_EXPR && consts_lt)
5603 /* MAX (X, 0) == 5 -> X == 5 */
5604 return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5606 else if (op_code == MAX_EXPR)
5607 /* MAX (X, 0) == -1 -> false */
5608 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5610 else if (consts_equal)
5611 /* MIN (X, 0) == 0 -> X >= 0 */
5612 return fold_build2_loc (loc, GE_EXPR, type, inner, comp_const);
5615 /* MIN (X, 0) == 5 -> false */
5616 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5619 /* MIN (X, 0) == -1 -> X == -1 */
5620 return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5623 if (op_code == MAX_EXPR && (consts_equal || consts_lt))
5624 /* MAX (X, 0) > 0 -> X > 0
5625 MAX (X, 0) > 5 -> X > 5 */
5626 return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5628 else if (op_code == MAX_EXPR)
5629 /* MAX (X, 0) > -1 -> true */
5630 return omit_one_operand_loc (loc, type, integer_one_node, inner);
5632 else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5633 /* MIN (X, 0) > 0 -> false
5634 MIN (X, 0) > 5 -> false */
5635 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5638 /* MIN (X, 0) > -1 -> X > -1 */
5639 return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5646 /* T is an integer expression that is being multiplied, divided, or taken a
5647 modulus (CODE says which and what kind of divide or modulus) by a
5648 constant C. See if we can eliminate that operation by folding it with
5649 other operations already in T. WIDE_TYPE, if non-null, is a type that
5650 should be used for the computation if wider than our type.
5652 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5653 (X * 2) + (Y * 4). We must, however, be assured that either the original
5654 expression would not overflow or that overflow is undefined for the type
5655 in the language in question.
5657 If we return a non-null expression, it is an equivalent form of the
5658 original computation, but need not be in the original type.
5660 We set *STRICT_OVERFLOW_P to true if the return values depends on
5661 signed overflow being undefined. Otherwise we do not change
5662 *STRICT_OVERFLOW_P. */
5665 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
5666 bool *strict_overflow_p)
5668 /* To avoid exponential search depth, refuse to allow recursion past
5669 three levels. Beyond that (1) it's highly unlikely that we'll find
5670 something interesting and (2) we've probably processed it before
5671 when we built the inner expression. */
5680 ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
5687 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
5688 bool *strict_overflow_p)
5690 tree type = TREE_TYPE (t);
5691 enum tree_code tcode = TREE_CODE (t);
5692 tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5693 > GET_MODE_SIZE (TYPE_MODE (type)))
5694 ? wide_type : type);
5696 int same_p = tcode == code;
5697 tree op0 = NULL_TREE, op1 = NULL_TREE;
5698 bool sub_strict_overflow_p;
5700 /* Don't deal with constants of zero here; they confuse the code below. */
5701 if (integer_zerop (c))
5704 if (TREE_CODE_CLASS (tcode) == tcc_unary)
5705 op0 = TREE_OPERAND (t, 0);
5707 if (TREE_CODE_CLASS (tcode) == tcc_binary)
5708 op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5710 /* Note that we need not handle conditional operations here since fold
5711 already handles those cases. So just do arithmetic here. */
5715 /* For a constant, we can always simplify if we are a multiply
5716 or (for divide and modulus) if it is a multiple of our constant. */
5717 if (code == MULT_EXPR
5718 || wi::multiple_of_p (t, c, TYPE_SIGN (type)))
5719 return const_binop (code, fold_convert (ctype, t),
5720 fold_convert (ctype, c));
5723 CASE_CONVERT: case NON_LVALUE_EXPR:
5724 /* If op0 is an expression ... */
5725 if ((COMPARISON_CLASS_P (op0)
5726 || UNARY_CLASS_P (op0)
5727 || BINARY_CLASS_P (op0)
5728 || VL_EXP_CLASS_P (op0)
5729 || EXPRESSION_CLASS_P (op0))
5730 /* ... and has wrapping overflow, and its type is smaller
5731 than ctype, then we cannot pass through as widening. */
5732 && ((TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0))
5733 && (TYPE_PRECISION (ctype)
5734 > TYPE_PRECISION (TREE_TYPE (op0))))
5735 /* ... or this is a truncation (t is narrower than op0),
5736 then we cannot pass through this narrowing. */
5737 || (TYPE_PRECISION (type)
5738 < TYPE_PRECISION (TREE_TYPE (op0)))
5739 /* ... or signedness changes for division or modulus,
5740 then we cannot pass through this conversion. */
5741 || (code != MULT_EXPR
5742 && (TYPE_UNSIGNED (ctype)
5743 != TYPE_UNSIGNED (TREE_TYPE (op0))))
5744 /* ... or has undefined overflow while the converted to
5745 type has not, we cannot do the operation in the inner type
5746 as that would introduce undefined overflow. */
5747 || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))
5748 && !TYPE_OVERFLOW_UNDEFINED (type))))
5751 /* Pass the constant down and see if we can make a simplification. If
5752 we can, replace this expression with the inner simplification for
5753 possible later conversion to our or some other type. */
5754 if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5755 && TREE_CODE (t2) == INTEGER_CST
5756 && !TREE_OVERFLOW (t2)
5757 && (0 != (t1 = extract_muldiv (op0, t2, code,
5759 ? ctype : NULL_TREE,
5760 strict_overflow_p))))
5765 /* If widening the type changes it from signed to unsigned, then we
5766 must avoid building ABS_EXPR itself as unsigned. */
5767 if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
5769 tree cstype = (*signed_type_for) (ctype);
5770 if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
5773 t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
5774 return fold_convert (ctype, t1);
5778 /* If the constant is negative, we cannot simplify this. */
5779 if (tree_int_cst_sgn (c) == -1)
5783 /* For division and modulus, type can't be unsigned, as e.g.
5784 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
5785 For signed types, even with wrapping overflow, this is fine. */
5786 if (code != MULT_EXPR && TYPE_UNSIGNED (type))
5788 if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
5790 return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
5793 case MIN_EXPR: case MAX_EXPR:
5794 /* If widening the type changes the signedness, then we can't perform
5795 this optimization as that changes the result. */
5796 if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5799 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
5800 sub_strict_overflow_p = false;
5801 if ((t1 = extract_muldiv (op0, c, code, wide_type,
5802 &sub_strict_overflow_p)) != 0
5803 && (t2 = extract_muldiv (op1, c, code, wide_type,
5804 &sub_strict_overflow_p)) != 0)
5806 if (tree_int_cst_sgn (c) < 0)
5807 tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5808 if (sub_strict_overflow_p)
5809 *strict_overflow_p = true;
5810 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5811 fold_convert (ctype, t2));
5815 case LSHIFT_EXPR: case RSHIFT_EXPR:
5816 /* If the second operand is constant, this is a multiplication
5817 or floor division, by a power of two, so we can treat it that
5818 way unless the multiplier or divisor overflows. Signed
5819 left-shift overflow is implementation-defined rather than
5820 undefined in C90, so do not convert signed left shift into
5822 if (TREE_CODE (op1) == INTEGER_CST
5823 && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
5824 /* const_binop may not detect overflow correctly,
5825 so check for it explicitly here. */
5826 && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
5827 && 0 != (t1 = fold_convert (ctype,
5828 const_binop (LSHIFT_EXPR,
5831 && !TREE_OVERFLOW (t1))
5832 return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5833 ? MULT_EXPR : FLOOR_DIV_EXPR,
5835 fold_convert (ctype, op0),
5837 c, code, wide_type, strict_overflow_p);
5840 case PLUS_EXPR: case MINUS_EXPR:
5841 /* See if we can eliminate the operation on both sides. If we can, we
5842 can return a new PLUS or MINUS. If we can't, the only remaining
5843 cases where we can do anything are if the second operand is a
5845 sub_strict_overflow_p = false;
5846 t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
5847 t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
5848 if (t1 != 0 && t2 != 0
5849 && (code == MULT_EXPR
5850 /* If not multiplication, we can only do this if both operands
5851 are divisible by c. */
5852 || (multiple_of_p (ctype, op0, c)
5853 && multiple_of_p (ctype, op1, c))))
5855 if (sub_strict_overflow_p)
5856 *strict_overflow_p = true;
5857 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5858 fold_convert (ctype, t2));
5861 /* If this was a subtraction, negate OP1 and set it to be an addition.
5862 This simplifies the logic below. */
5863 if (tcode == MINUS_EXPR)
5865 tcode = PLUS_EXPR, op1 = negate_expr (op1);
5866 /* If OP1 was not easily negatable, the constant may be OP0. */
5867 if (TREE_CODE (op0) == INTEGER_CST)
5878 if (TREE_CODE (op1) != INTEGER_CST)
5881 /* If either OP1 or C are negative, this optimization is not safe for
5882 some of the division and remainder types while for others we need
5883 to change the code. */
5884 if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5886 if (code == CEIL_DIV_EXPR)
5887 code = FLOOR_DIV_EXPR;
5888 else if (code == FLOOR_DIV_EXPR)
5889 code = CEIL_DIV_EXPR;
5890 else if (code != MULT_EXPR
5891 && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5895 /* If it's a multiply or a division/modulus operation of a multiple
5896 of our constant, do the operation and verify it doesn't overflow. */
5897 if (code == MULT_EXPR
5898 || wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
5900 op1 = const_binop (code, fold_convert (ctype, op1),
5901 fold_convert (ctype, c));
5902 /* We allow the constant to overflow with wrapping semantics. */
5904 || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
5910 /* If we have an unsigned type, we cannot widen the operation since it
5911 will change the result if the original computation overflowed. */
5912 if (TYPE_UNSIGNED (ctype) && ctype != type)
5915 /* If we were able to eliminate our operation from the first side,
5916 apply our operation to the second side and reform the PLUS. */
5917 if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5918 return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
5920 /* The last case is if we are a multiply. In that case, we can
5921 apply the distributive law to commute the multiply and addition
5922 if the multiplication of the constants doesn't overflow
5923 and overflow is defined. With undefined overflow
5924 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
5925 if (code == MULT_EXPR && TYPE_OVERFLOW_WRAPS (ctype))
5926 return fold_build2 (tcode, ctype,
5927 fold_build2 (code, ctype,
5928 fold_convert (ctype, op0),
5929 fold_convert (ctype, c)),
5935 /* We have a special case here if we are doing something like
5936 (C * 8) % 4 since we know that's zero. */
5937 if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
5938 || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
5939 /* If the multiplication can overflow we cannot optimize this. */
5940 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t))
5941 && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
5942 && wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
5944 *strict_overflow_p = true;
5945 return omit_one_operand (type, integer_zero_node, op0);
5948 /* ... fall through ... */
5950 case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: case FLOOR_DIV_EXPR:
5951 case ROUND_DIV_EXPR: case EXACT_DIV_EXPR:
5952 /* If we can extract our operation from the LHS, do so and return a
5953 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
5954 do something only if the second operand is a constant. */
5956 && (t1 = extract_muldiv (op0, c, code, wide_type,
5957 strict_overflow_p)) != 0)
5958 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5959 fold_convert (ctype, op1));
5960 else if (tcode == MULT_EXPR && code == MULT_EXPR
5961 && (t1 = extract_muldiv (op1, c, code, wide_type,
5962 strict_overflow_p)) != 0)
5963 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5964 fold_convert (ctype, t1));
5965 else if (TREE_CODE (op1) != INTEGER_CST)
5968 /* If these are the same operation types, we can associate them
5969 assuming no overflow. */
5972 bool overflow_p = false;
5973 bool overflow_mul_p;
5974 signop sign = TYPE_SIGN (ctype);
5975 wide_int mul = wi::mul (op1, c, sign, &overflow_mul_p);
5976 overflow_p = TREE_OVERFLOW (c) | TREE_OVERFLOW (op1);
5978 && ((sign == UNSIGNED && tcode != MULT_EXPR) || sign == SIGNED))
5981 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5982 wide_int_to_tree (ctype, mul));
5985 /* If these operations "cancel" each other, we have the main
5986 optimizations of this pass, which occur when either constant is a
5987 multiple of the other, in which case we replace this with either an
5988 operation or CODE or TCODE.
5990 If we have an unsigned type, we cannot do this since it will change
5991 the result if the original computation overflowed. */
5992 if (TYPE_OVERFLOW_UNDEFINED (ctype)
5993 && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
5994 || (tcode == MULT_EXPR
5995 && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
5996 && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
5997 && code != MULT_EXPR)))
5999 if (wi::multiple_of_p (op1, c, TYPE_SIGN (type)))
6001 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6002 *strict_overflow_p = true;
6003 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6004 fold_convert (ctype,
6005 const_binop (TRUNC_DIV_EXPR,
6008 else if (wi::multiple_of_p (c, op1, TYPE_SIGN (type)))
6010 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6011 *strict_overflow_p = true;
6012 return fold_build2 (code, ctype, fold_convert (ctype, op0),
6013 fold_convert (ctype,
6014 const_binop (TRUNC_DIV_EXPR,
6027 /* Return a node which has the indicated constant VALUE (either 0 or
6028 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6029 and is of the indicated TYPE. */
6032 constant_boolean_node (bool value, tree type)
6034 if (type == integer_type_node)
6035 return value ? integer_one_node : integer_zero_node;
6036 else if (type == boolean_type_node)
6037 return value ? boolean_true_node : boolean_false_node;
6038 else if (TREE_CODE (type) == VECTOR_TYPE)
6039 return build_vector_from_val (type,
6040 build_int_cst (TREE_TYPE (type),
6043 return fold_convert (type, value ? integer_one_node : integer_zero_node);
6047 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6048 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6049 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6050 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6051 COND is the first argument to CODE; otherwise (as in the example
6052 given here), it is the second argument. TYPE is the type of the
6053 original expression. Return NULL_TREE if no simplification is
6057 fold_binary_op_with_conditional_arg (location_t loc,
6058 enum tree_code code,
6059 tree type, tree op0, tree op1,
6060 tree cond, tree arg, int cond_first_p)
6062 tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
6063 tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6064 tree test, true_value, false_value;
6065 tree lhs = NULL_TREE;
6066 tree rhs = NULL_TREE;
6067 enum tree_code cond_code = COND_EXPR;
6069 if (TREE_CODE (cond) == COND_EXPR
6070 || TREE_CODE (cond) == VEC_COND_EXPR)
6072 test = TREE_OPERAND (cond, 0);
6073 true_value = TREE_OPERAND (cond, 1);
6074 false_value = TREE_OPERAND (cond, 2);
6075 /* If this operand throws an expression, then it does not make
6076 sense to try to perform a logical or arithmetic operation
6078 if (VOID_TYPE_P (TREE_TYPE (true_value)))
6080 if (VOID_TYPE_P (TREE_TYPE (false_value)))
6085 tree testtype = TREE_TYPE (cond);
6087 true_value = constant_boolean_node (true, testtype);
6088 false_value = constant_boolean_node (false, testtype);
6091 if (TREE_CODE (TREE_TYPE (test)) == VECTOR_TYPE)
6092 cond_code = VEC_COND_EXPR;
6094 /* This transformation is only worthwhile if we don't have to wrap ARG
6095 in a SAVE_EXPR and the operation can be simplified without recursing
6096 on at least one of the branches once its pushed inside the COND_EXPR. */
6097 if (!TREE_CONSTANT (arg)
6098 && (TREE_SIDE_EFFECTS (arg)
6099 || TREE_CODE (arg) == COND_EXPR || TREE_CODE (arg) == VEC_COND_EXPR
6100 || TREE_CONSTANT (true_value) || TREE_CONSTANT (false_value)))
6103 arg = fold_convert_loc (loc, arg_type, arg);
6106 true_value = fold_convert_loc (loc, cond_type, true_value);
6108 lhs = fold_build2_loc (loc, code, type, true_value, arg);
6110 lhs = fold_build2_loc (loc, code, type, arg, true_value);
6114 false_value = fold_convert_loc (loc, cond_type, false_value);
6116 rhs = fold_build2_loc (loc, code, type, false_value, arg);
6118 rhs = fold_build2_loc (loc, code, type, arg, false_value);
6121 /* Check that we have simplified at least one of the branches. */
6122 if (!TREE_CONSTANT (arg) && !TREE_CONSTANT (lhs) && !TREE_CONSTANT (rhs))
6125 return fold_build3_loc (loc, cond_code, type, test, lhs, rhs);
6129 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6131 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6132 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6133 ADDEND is the same as X.
6135 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6136 and finite. The problematic cases are when X is zero, and its mode
6137 has signed zeros. In the case of rounding towards -infinity,
6138 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6139 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6142 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6144 if (!real_zerop (addend))
6147 /* Don't allow the fold with -fsignaling-nans. */
6148 if (HONOR_SNANS (TYPE_MODE (type)))
6151 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6152 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
6155 /* In a vector or complex, we would need to check the sign of all zeros. */
6156 if (TREE_CODE (addend) != REAL_CST)
6159 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6160 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6163 /* The mode has signed zeros, and we have to honor their sign.
6164 In this situation, there is only one case we can return true for.
6165 X - 0 is the same as X unless rounding towards -infinity is
6167 return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
6170 /* Subroutine of fold() that checks comparisons of built-in math
6171 functions against real constants.
6173 FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6174 operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR. TYPE
6175 is the type of the result and ARG0 and ARG1 are the operands of the
6176 comparison. ARG1 must be a TREE_REAL_CST.
6178 The function returns the constant folded tree if a simplification
6179 can be made, and NULL_TREE otherwise. */
6182 fold_mathfn_compare (location_t loc,
6183 enum built_in_function fcode, enum tree_code code,
6184 tree type, tree arg0, tree arg1)
6188 if (BUILTIN_SQRT_P (fcode))
6190 tree arg = CALL_EXPR_ARG (arg0, 0);
6191 machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
6193 c = TREE_REAL_CST (arg1);
6194 if (REAL_VALUE_NEGATIVE (c))
6196 /* sqrt(x) < y is always false, if y is negative. */
6197 if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
6198 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
6200 /* sqrt(x) > y is always true, if y is negative and we
6201 don't care about NaNs, i.e. negative values of x. */
6202 if (code == NE_EXPR || !HONOR_NANS (mode))
6203 return omit_one_operand_loc (loc, type, integer_one_node, arg);
6205 /* sqrt(x) > y is the same as x >= 0, if y is negative. */
6206 return fold_build2_loc (loc, GE_EXPR, type, arg,
6207 build_real (TREE_TYPE (arg), dconst0));
6209 else if (code == GT_EXPR || code == GE_EXPR)
6213 REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6214 real_convert (&c2, mode, &c2);
6216 if (REAL_VALUE_ISINF (c2))
6218 /* sqrt(x) > y is x == +Inf, when y is very large. */
6219 if (HONOR_INFINITIES (mode))
6220 return fold_build2_loc (loc, EQ_EXPR, type, arg,
6221 build_real (TREE_TYPE (arg), c2));
6223 /* sqrt(x) > y is always false, when y is very large
6224 and we don't care about infinities. */
6225 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
6228 /* sqrt(x) > c is the same as x > c*c. */
6229 return fold_build2_loc (loc, code, type, arg,
6230 build_real (TREE_TYPE (arg), c2));
6232 else if (code == LT_EXPR || code == LE_EXPR)
6236 REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6237 real_convert (&c2, mode, &c2);
6239 if (REAL_VALUE_ISINF (c2))
6241 /* sqrt(x) < y is always true, when y is a very large
6242 value and we don't care about NaNs or Infinities. */
6243 if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
6244 return omit_one_operand_loc (loc, type, integer_one_node, arg);
6246 /* sqrt(x) < y is x != +Inf when y is very large and we
6247 don't care about NaNs. */
6248 if (! HONOR_NANS (mode))
6249 return fold_build2_loc (loc, NE_EXPR, type, arg,
6250 build_real (TREE_TYPE (arg), c2));
6252 /* sqrt(x) < y is x >= 0 when y is very large and we
6253 don't care about Infinities. */
6254 if (! HONOR_INFINITIES (mode))
6255 return fold_build2_loc (loc, GE_EXPR, type, arg,
6256 build_real (TREE_TYPE (arg), dconst0));
6258 /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large. */
6259 arg = save_expr (arg);
6260 return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
6261 fold_build2_loc (loc, GE_EXPR, type, arg,
6262 build_real (TREE_TYPE (arg),
6264 fold_build2_loc (loc, NE_EXPR, type, arg,
6265 build_real (TREE_TYPE (arg),
6269 /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs. */
6270 if (! HONOR_NANS (mode))
6271 return fold_build2_loc (loc, code, type, arg,
6272 build_real (TREE_TYPE (arg), c2));
6274 /* sqrt(x) < c is the same as x >= 0 && x < c*c. */
6275 arg = save_expr (arg);
6276 return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
6277 fold_build2_loc (loc, GE_EXPR, type, arg,
6278 build_real (TREE_TYPE (arg),
6280 fold_build2_loc (loc, code, type, arg,
6281 build_real (TREE_TYPE (arg),
6289 /* Subroutine of fold() that optimizes comparisons against Infinities,
6290 either +Inf or -Inf.
6292 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6293 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6294 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6296 The function returns the constant folded tree if a simplification
6297 can be made, and NULL_TREE otherwise. */
6300 fold_inf_compare (location_t loc, enum tree_code code, tree type,
6301 tree arg0, tree arg1)
6304 REAL_VALUE_TYPE max;
6308 mode = TYPE_MODE (TREE_TYPE (arg0));
6310 /* For negative infinity swap the sense of the comparison. */
6311 neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6313 code = swap_tree_comparison (code);
6318 /* x > +Inf is always false, if with ignore sNANs. */
6319 if (HONOR_SNANS (mode))
6321 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6324 /* x <= +Inf is always true, if we don't case about NaNs. */
6325 if (! HONOR_NANS (mode))
6326 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6328 /* x <= +Inf is the same as x == x, i.e. isfinite(x). */
6329 arg0 = save_expr (arg0);
6330 return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg0);
6334 /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX. */
6335 real_maxval (&max, neg, mode);
6336 return fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
6337 arg0, build_real (TREE_TYPE (arg0), max));
6340 /* x < +Inf is always equal to x <= DBL_MAX. */
6341 real_maxval (&max, neg, mode);
6342 return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
6343 arg0, build_real (TREE_TYPE (arg0), max));
6346 /* x != +Inf is always equal to !(x > DBL_MAX). */
6347 real_maxval (&max, neg, mode);
6348 if (! HONOR_NANS (mode))
6349 return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
6350 arg0, build_real (TREE_TYPE (arg0), max));
6352 temp = fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
6353 arg0, build_real (TREE_TYPE (arg0), max));
6354 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type, temp);
6363 /* Subroutine of fold() that optimizes comparisons of a division by
6364 a nonzero integer constant against an integer constant, i.e.
6367 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6368 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6369 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6371 The function returns the constant folded tree if a simplification
6372 can be made, and NULL_TREE otherwise. */
6375 fold_div_compare (location_t loc,
6376 enum tree_code code, tree type, tree arg0, tree arg1)
6378 tree prod, tmp, hi, lo;
6379 tree arg00 = TREE_OPERAND (arg0, 0);
6380 tree arg01 = TREE_OPERAND (arg0, 1);
6381 signop sign = TYPE_SIGN (TREE_TYPE (arg0));
6382 bool neg_overflow = false;
6385 /* We have to do this the hard way to detect unsigned overflow.
6386 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6387 wide_int val = wi::mul (arg01, arg1, sign, &overflow);
6388 prod = force_fit_type (TREE_TYPE (arg00), val, -1, overflow);
6389 neg_overflow = false;
6391 if (sign == UNSIGNED)
6393 tmp = int_const_binop (MINUS_EXPR, arg01,
6394 build_int_cst (TREE_TYPE (arg01), 1));
6397 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6398 val = wi::add (prod, tmp, sign, &overflow);
6399 hi = force_fit_type (TREE_TYPE (arg00), val,
6400 -1, overflow | TREE_OVERFLOW (prod));
6402 else if (tree_int_cst_sgn (arg01) >= 0)
6404 tmp = int_const_binop (MINUS_EXPR, arg01,
6405 build_int_cst (TREE_TYPE (arg01), 1));
6406 switch (tree_int_cst_sgn (arg1))
6409 neg_overflow = true;
6410 lo = int_const_binop (MINUS_EXPR, prod, tmp);
6415 lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6420 hi = int_const_binop (PLUS_EXPR, prod, tmp);
6430 /* A negative divisor reverses the relational operators. */
6431 code = swap_tree_comparison (code);
6433 tmp = int_const_binop (PLUS_EXPR, arg01,
6434 build_int_cst (TREE_TYPE (arg01), 1));
6435 switch (tree_int_cst_sgn (arg1))
6438 hi = int_const_binop (MINUS_EXPR, prod, tmp);
6443 hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6448 neg_overflow = true;
6449 lo = int_const_binop (PLUS_EXPR, prod, tmp);
6461 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6462 return omit_one_operand_loc (loc, type, integer_zero_node, arg00);
6463 if (TREE_OVERFLOW (hi))
6464 return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6465 if (TREE_OVERFLOW (lo))
6466 return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6467 return build_range_check (loc, type, arg00, 1, lo, hi);
6470 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6471 return omit_one_operand_loc (loc, type, integer_one_node, arg00);
6472 if (TREE_OVERFLOW (hi))
6473 return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6474 if (TREE_OVERFLOW (lo))
6475 return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6476 return build_range_check (loc, type, arg00, 0, lo, hi);
6479 if (TREE_OVERFLOW (lo))
6481 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6482 return omit_one_operand_loc (loc, type, tmp, arg00);
6484 return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6487 if (TREE_OVERFLOW (hi))
6489 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6490 return omit_one_operand_loc (loc, type, tmp, arg00);
6492 return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6495 if (TREE_OVERFLOW (hi))
6497 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6498 return omit_one_operand_loc (loc, type, tmp, arg00);
6500 return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6503 if (TREE_OVERFLOW (lo))
6505 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6506 return omit_one_operand_loc (loc, type, tmp, arg00);
6508 return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6518 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6519 equality/inequality test, then return a simplified form of the test
6520 using a sign testing. Otherwise return NULL. TYPE is the desired
6524 fold_single_bit_test_into_sign_test (location_t loc,
6525 enum tree_code code, tree arg0, tree arg1,
6528 /* If this is testing a single bit, we can optimize the test. */
6529 if ((code == NE_EXPR || code == EQ_EXPR)
6530 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6531 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6533 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6534 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6535 tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6537 if (arg00 != NULL_TREE
6538 /* This is only a win if casting to a signed type is cheap,
6539 i.e. when arg00's type is not a partial mode. */
6540 && TYPE_PRECISION (TREE_TYPE (arg00))
6541 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg00))))
6543 tree stype = signed_type_for (TREE_TYPE (arg00));
6544 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6546 fold_convert_loc (loc, stype, arg00),
6547 build_int_cst (stype, 0));
6554 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6555 equality/inequality test, then return a simplified form of
6556 the test using shifts and logical operations. Otherwise return
6557 NULL. TYPE is the desired result type. */
6560 fold_single_bit_test (location_t loc, enum tree_code code,
6561 tree arg0, tree arg1, tree result_type)
6563 /* If this is testing a single bit, we can optimize the test. */
6564 if ((code == NE_EXPR || code == EQ_EXPR)
6565 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6566 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6568 tree inner = TREE_OPERAND (arg0, 0);
6569 tree type = TREE_TYPE (arg0);
6570 int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6571 machine_mode operand_mode = TYPE_MODE (type);
6573 tree signed_type, unsigned_type, intermediate_type;
6576 /* First, see if we can fold the single bit test into a sign-bit
6578 tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1,
6583 /* Otherwise we have (A & C) != 0 where C is a single bit,
6584 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6585 Similarly for (A & C) == 0. */
6587 /* If INNER is a right shift of a constant and it plus BITNUM does
6588 not overflow, adjust BITNUM and INNER. */
6589 if (TREE_CODE (inner) == RSHIFT_EXPR
6590 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6591 && bitnum < TYPE_PRECISION (type)
6592 && wi::ltu_p (TREE_OPERAND (inner, 1),
6593 TYPE_PRECISION (type) - bitnum))
6595 bitnum += tree_to_uhwi (TREE_OPERAND (inner, 1));
6596 inner = TREE_OPERAND (inner, 0);
6599 /* If we are going to be able to omit the AND below, we must do our
6600 operations as unsigned. If we must use the AND, we have a choice.
6601 Normally unsigned is faster, but for some machines signed is. */
6602 #ifdef LOAD_EXTEND_OP
6603 ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6604 && !flag_syntax_only) ? 0 : 1;
6609 signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6610 unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6611 intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6612 inner = fold_convert_loc (loc, intermediate_type, inner);
6615 inner = build2 (RSHIFT_EXPR, intermediate_type,
6616 inner, size_int (bitnum));
6618 one = build_int_cst (intermediate_type, 1);
6620 if (code == EQ_EXPR)
6621 inner = fold_build2_loc (loc, BIT_XOR_EXPR, intermediate_type, inner, one);
6623 /* Put the AND last so it can combine with more things. */
6624 inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
6626 /* Make sure to return the proper type. */
6627 inner = fold_convert_loc (loc, result_type, inner);
6634 /* Check whether we are allowed to reorder operands arg0 and arg1,
6635 such that the evaluation of arg1 occurs before arg0. */
6638 reorder_operands_p (const_tree arg0, const_tree arg1)
6640 if (! flag_evaluation_order)
6642 if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6644 return ! TREE_SIDE_EFFECTS (arg0)
6645 && ! TREE_SIDE_EFFECTS (arg1);
6648 /* Test whether it is preferable two swap two operands, ARG0 and
6649 ARG1, for example because ARG0 is an integer constant and ARG1
6650 isn't. If REORDER is true, only recommend swapping if we can
6651 evaluate the operands in reverse order. */
6654 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
6656 if (CONSTANT_CLASS_P (arg1))
6658 if (CONSTANT_CLASS_P (arg0))
6661 STRIP_SIGN_NOPS (arg0);
6662 STRIP_SIGN_NOPS (arg1);
6664 if (TREE_CONSTANT (arg1))
6666 if (TREE_CONSTANT (arg0))
6669 if (reorder && flag_evaluation_order
6670 && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6673 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6674 for commutative and comparison operators. Ensuring a canonical
6675 form allows the optimizers to find additional redundancies without
6676 having to explicitly check for both orderings. */
6677 if (TREE_CODE (arg0) == SSA_NAME
6678 && TREE_CODE (arg1) == SSA_NAME
6679 && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6682 /* Put SSA_NAMEs last. */
6683 if (TREE_CODE (arg1) == SSA_NAME)
6685 if (TREE_CODE (arg0) == SSA_NAME)
6688 /* Put variables last. */
6697 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6698 ARG0 is extended to a wider type. */
6701 fold_widened_comparison (location_t loc, enum tree_code code,
6702 tree type, tree arg0, tree arg1)
6704 tree arg0_unw = get_unwidened (arg0, NULL_TREE);
6706 tree shorter_type, outer_type;
6710 if (arg0_unw == arg0)
6712 shorter_type = TREE_TYPE (arg0_unw);
6714 #ifdef HAVE_canonicalize_funcptr_for_compare
6715 /* Disable this optimization if we're casting a function pointer
6716 type on targets that require function pointer canonicalization. */
6717 if (HAVE_canonicalize_funcptr_for_compare
6718 && TREE_CODE (shorter_type) == POINTER_TYPE
6719 && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
6723 if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
6726 arg1_unw = get_unwidened (arg1, NULL_TREE);
6728 /* If possible, express the comparison in the shorter mode. */
6729 if ((code == EQ_EXPR || code == NE_EXPR
6730 || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
6731 && (TREE_TYPE (arg1_unw) == shorter_type
6732 || ((TYPE_PRECISION (shorter_type)
6733 >= TYPE_PRECISION (TREE_TYPE (arg1_unw)))
6734 && (TYPE_UNSIGNED (shorter_type)
6735 == TYPE_UNSIGNED (TREE_TYPE (arg1_unw))))
6736 || (TREE_CODE (arg1_unw) == INTEGER_CST
6737 && (TREE_CODE (shorter_type) == INTEGER_TYPE
6738 || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
6739 && int_fits_type_p (arg1_unw, shorter_type))))
6740 return fold_build2_loc (loc, code, type, arg0_unw,
6741 fold_convert_loc (loc, shorter_type, arg1_unw));
6743 if (TREE_CODE (arg1_unw) != INTEGER_CST
6744 || TREE_CODE (shorter_type) != INTEGER_TYPE
6745 || !int_fits_type_p (arg1_unw, shorter_type))
6748 /* If we are comparing with the integer that does not fit into the range
6749 of the shorter type, the result is known. */
6750 outer_type = TREE_TYPE (arg1_unw);
6751 min = lower_bound_in_type (outer_type, shorter_type);
6752 max = upper_bound_in_type (outer_type, shorter_type);
6754 above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6756 below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6763 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6768 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6774 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6776 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6781 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6783 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6792 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6793 ARG0 just the signedness is changed. */
6796 fold_sign_changed_comparison (location_t loc, enum tree_code code, tree type,
6797 tree arg0, tree arg1)
6800 tree inner_type, outer_type;
6802 if (!CONVERT_EXPR_P (arg0))
6805 outer_type = TREE_TYPE (arg0);
6806 arg0_inner = TREE_OPERAND (arg0, 0);
6807 inner_type = TREE_TYPE (arg0_inner);
6809 #ifdef HAVE_canonicalize_funcptr_for_compare
6810 /* Disable this optimization if we're casting a function pointer
6811 type on targets that require function pointer canonicalization. */
6812 if (HAVE_canonicalize_funcptr_for_compare
6813 && TREE_CODE (inner_type) == POINTER_TYPE
6814 && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
6818 if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
6821 if (TREE_CODE (arg1) != INTEGER_CST
6822 && !(CONVERT_EXPR_P (arg1)
6823 && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
6826 if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
6831 if (POINTER_TYPE_P (inner_type) != POINTER_TYPE_P (outer_type))
6834 if (TREE_CODE (arg1) == INTEGER_CST)
6835 arg1 = force_fit_type (inner_type, wi::to_widest (arg1), 0,
6836 TREE_OVERFLOW (arg1));
6838 arg1 = fold_convert_loc (loc, inner_type, arg1);
6840 return fold_build2_loc (loc, code, type, arg0_inner, arg1);
6844 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6845 means A >= Y && A != MAX, but in this case we know that
6846 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6849 fold_to_nonsharp_ineq_using_bound (location_t loc, tree ineq, tree bound)
6851 tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
6853 if (TREE_CODE (bound) == LT_EXPR)
6854 a = TREE_OPERAND (bound, 0);
6855 else if (TREE_CODE (bound) == GT_EXPR)
6856 a = TREE_OPERAND (bound, 1);
6860 typea = TREE_TYPE (a);
6861 if (!INTEGRAL_TYPE_P (typea)
6862 && !POINTER_TYPE_P (typea))
6865 if (TREE_CODE (ineq) == LT_EXPR)
6867 a1 = TREE_OPERAND (ineq, 1);
6868 y = TREE_OPERAND (ineq, 0);
6870 else if (TREE_CODE (ineq) == GT_EXPR)
6872 a1 = TREE_OPERAND (ineq, 0);
6873 y = TREE_OPERAND (ineq, 1);
6878 if (TREE_TYPE (a1) != typea)
6881 if (POINTER_TYPE_P (typea))
6883 /* Convert the pointer types into integer before taking the difference. */
6884 tree ta = fold_convert_loc (loc, ssizetype, a);
6885 tree ta1 = fold_convert_loc (loc, ssizetype, a1);
6886 diff = fold_binary_loc (loc, MINUS_EXPR, ssizetype, ta1, ta);
6889 diff = fold_binary_loc (loc, MINUS_EXPR, typea, a1, a);
6891 if (!diff || !integer_onep (diff))
6894 return fold_build2_loc (loc, GE_EXPR, type, a, y);
6897 /* Fold a sum or difference of at least one multiplication.
6898 Returns the folded tree or NULL if no simplification could be made. */
6901 fold_plusminus_mult_expr (location_t loc, enum tree_code code, tree type,
6902 tree arg0, tree arg1)
6904 tree arg00, arg01, arg10, arg11;
6905 tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6907 /* (A * C) +- (B * C) -> (A+-B) * C.
6908 (A * C) +- A -> A * (C+-1).
6909 We are most concerned about the case where C is a constant,
6910 but other combinations show up during loop reduction. Since
6911 it is not difficult, try all four possibilities. */
6913 if (TREE_CODE (arg0) == MULT_EXPR)
6915 arg00 = TREE_OPERAND (arg0, 0);
6916 arg01 = TREE_OPERAND (arg0, 1);
6918 else if (TREE_CODE (arg0) == INTEGER_CST)
6920 arg00 = build_one_cst (type);
6925 /* We cannot generate constant 1 for fract. */
6926 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
6929 arg01 = build_one_cst (type);
6931 if (TREE_CODE (arg1) == MULT_EXPR)
6933 arg10 = TREE_OPERAND (arg1, 0);
6934 arg11 = TREE_OPERAND (arg1, 1);
6936 else if (TREE_CODE (arg1) == INTEGER_CST)
6938 arg10 = build_one_cst (type);
6939 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6940 the purpose of this canonicalization. */
6941 if (wi::neg_p (arg1, TYPE_SIGN (TREE_TYPE (arg1)))
6942 && negate_expr_p (arg1)
6943 && code == PLUS_EXPR)
6945 arg11 = negate_expr (arg1);
6953 /* We cannot generate constant 1 for fract. */
6954 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
6957 arg11 = build_one_cst (type);
6961 if (operand_equal_p (arg01, arg11, 0))
6962 same = arg01, alt0 = arg00, alt1 = arg10;
6963 else if (operand_equal_p (arg00, arg10, 0))
6964 same = arg00, alt0 = arg01, alt1 = arg11;
6965 else if (operand_equal_p (arg00, arg11, 0))
6966 same = arg00, alt0 = arg01, alt1 = arg10;
6967 else if (operand_equal_p (arg01, arg10, 0))
6968 same = arg01, alt0 = arg00, alt1 = arg11;
6970 /* No identical multiplicands; see if we can find a common
6971 power-of-two factor in non-power-of-two multiplies. This
6972 can help in multi-dimensional array access. */
6973 else if (tree_fits_shwi_p (arg01)
6974 && tree_fits_shwi_p (arg11))
6976 HOST_WIDE_INT int01, int11, tmp;
6979 int01 = tree_to_shwi (arg01);
6980 int11 = tree_to_shwi (arg11);
6982 /* Move min of absolute values to int11. */
6983 if (absu_hwi (int01) < absu_hwi (int11))
6985 tmp = int01, int01 = int11, int11 = tmp;
6986 alt0 = arg00, arg00 = arg10, arg10 = alt0;
6993 if (exact_log2 (absu_hwi (int11)) > 0 && int01 % int11 == 0
6994 /* The remainder should not be a constant, otherwise we
6995 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6996 increased the number of multiplications necessary. */
6997 && TREE_CODE (arg10) != INTEGER_CST)
6999 alt0 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (arg00), arg00,
7000 build_int_cst (TREE_TYPE (arg00),
7005 maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7010 return fold_build2_loc (loc, MULT_EXPR, type,
7011 fold_build2_loc (loc, code, type,
7012 fold_convert_loc (loc, type, alt0),
7013 fold_convert_loc (loc, type, alt1)),
7014 fold_convert_loc (loc, type, same));
7019 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7020 specified by EXPR into the buffer PTR of length LEN bytes.
7021 Return the number of bytes placed in the buffer, or zero
7025 native_encode_int (const_tree expr, unsigned char *ptr, int len, int off)
7027 tree type = TREE_TYPE (expr);
7028 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7029 int byte, offset, word, words;
7030 unsigned char value;
7032 if ((off == -1 && total_bytes > len)
7033 || off >= total_bytes)
7037 words = total_bytes / UNITS_PER_WORD;
7039 for (byte = 0; byte < total_bytes; byte++)
7041 int bitpos = byte * BITS_PER_UNIT;
7042 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7044 value = wi::extract_uhwi (wi::to_widest (expr), bitpos, BITS_PER_UNIT);
7046 if (total_bytes > UNITS_PER_WORD)
7048 word = byte / UNITS_PER_WORD;
7049 if (WORDS_BIG_ENDIAN)
7050 word = (words - 1) - word;
7051 offset = word * UNITS_PER_WORD;
7052 if (BYTES_BIG_ENDIAN)
7053 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7055 offset += byte % UNITS_PER_WORD;
7058 offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7060 && offset - off < len)
7061 ptr[offset - off] = value;
7063 return MIN (len, total_bytes - off);
7067 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7068 specified by EXPR into the buffer PTR of length LEN bytes.
7069 Return the number of bytes placed in the buffer, or zero
7073 native_encode_fixed (const_tree expr, unsigned char *ptr, int len, int off)
7075 tree type = TREE_TYPE (expr);
7076 machine_mode mode = TYPE_MODE (type);
7077 int total_bytes = GET_MODE_SIZE (mode);
7078 FIXED_VALUE_TYPE value;
7079 tree i_value, i_type;
7081 if (total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7084 i_type = lang_hooks.types.type_for_size (GET_MODE_BITSIZE (mode), 1);
7086 if (NULL_TREE == i_type
7087 || TYPE_PRECISION (i_type) != total_bytes)
7090 value = TREE_FIXED_CST (expr);
7091 i_value = double_int_to_tree (i_type, value.data);
7093 return native_encode_int (i_value, ptr, len, off);
7097 /* Subroutine of native_encode_expr. Encode the REAL_CST
7098 specified by EXPR into the buffer PTR of length LEN bytes.
7099 Return the number of bytes placed in the buffer, or zero
7103 native_encode_real (const_tree expr, unsigned char *ptr, int len, int off)
7105 tree type = TREE_TYPE (expr);
7106 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7107 int byte, offset, word, words, bitpos;
7108 unsigned char value;
7110 /* There are always 32 bits in each long, no matter the size of
7111 the hosts long. We handle floating point representations with
7115 if ((off == -1 && total_bytes > len)
7116 || off >= total_bytes)
7120 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7122 real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7124 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7125 bitpos += BITS_PER_UNIT)
7127 byte = (bitpos / BITS_PER_UNIT) & 3;
7128 value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7130 if (UNITS_PER_WORD < 4)
7132 word = byte / UNITS_PER_WORD;
7133 if (WORDS_BIG_ENDIAN)
7134 word = (words - 1) - word;
7135 offset = word * UNITS_PER_WORD;
7136 if (BYTES_BIG_ENDIAN)
7137 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7139 offset += byte % UNITS_PER_WORD;
7142 offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7143 offset = offset + ((bitpos / BITS_PER_UNIT) & ~3);
7145 && offset - off < len)
7146 ptr[offset - off] = value;
7148 return MIN (len, total_bytes - off);
7151 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7152 specified by EXPR into the buffer PTR of length LEN bytes.
7153 Return the number of bytes placed in the buffer, or zero
7157 native_encode_complex (const_tree expr, unsigned char *ptr, int len, int off)
7162 part = TREE_REALPART (expr);
7163 rsize = native_encode_expr (part, ptr, len, off);
7167 part = TREE_IMAGPART (expr);
7169 off = MAX (0, off - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (part))));
7170 isize = native_encode_expr (part, ptr+rsize, len-rsize, off);
7174 return rsize + isize;
7178 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7179 specified by EXPR into the buffer PTR of length LEN bytes.
7180 Return the number of bytes placed in the buffer, or zero
7184 native_encode_vector (const_tree expr, unsigned char *ptr, int len, int off)
7191 count = VECTOR_CST_NELTS (expr);
7192 itype = TREE_TYPE (TREE_TYPE (expr));
7193 size = GET_MODE_SIZE (TYPE_MODE (itype));
7194 for (i = 0; i < count; i++)
7201 elem = VECTOR_CST_ELT (expr, i);
7202 int res = native_encode_expr (elem, ptr+offset, len-offset, off);
7203 if ((off == -1 && res != size)
7216 /* Subroutine of native_encode_expr. Encode the STRING_CST
7217 specified by EXPR into the buffer PTR of length LEN bytes.
7218 Return the number of bytes placed in the buffer, or zero
7222 native_encode_string (const_tree expr, unsigned char *ptr, int len, int off)
7224 tree type = TREE_TYPE (expr);
7225 HOST_WIDE_INT total_bytes;
7227 if (TREE_CODE (type) != ARRAY_TYPE
7228 || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE
7229 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT
7230 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type)))
7232 total_bytes = tree_to_shwi (TYPE_SIZE_UNIT (type));
7233 if ((off == -1 && total_bytes > len)
7234 || off >= total_bytes)
7238 if (TREE_STRING_LENGTH (expr) - off < MIN (total_bytes, len))
7241 if (off < TREE_STRING_LENGTH (expr))
7243 written = MIN (len, TREE_STRING_LENGTH (expr) - off);
7244 memcpy (ptr, TREE_STRING_POINTER (expr) + off, written);
7246 memset (ptr + written, 0,
7247 MIN (total_bytes - written, len - written));
7250 memcpy (ptr, TREE_STRING_POINTER (expr) + off, MIN (total_bytes, len));
7251 return MIN (total_bytes - off, len);
7255 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7256 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7257 buffer PTR of length LEN bytes. If OFF is not -1 then start
7258 the encoding at byte offset OFF and encode at most LEN bytes.
7259 Return the number of bytes placed in the buffer, or zero upon failure. */
7262 native_encode_expr (const_tree expr, unsigned char *ptr, int len, int off)
7264 switch (TREE_CODE (expr))
7267 return native_encode_int (expr, ptr, len, off);
7270 return native_encode_real (expr, ptr, len, off);
7273 return native_encode_fixed (expr, ptr, len, off);
7276 return native_encode_complex (expr, ptr, len, off);
7279 return native_encode_vector (expr, ptr, len, off);
7282 return native_encode_string (expr, ptr, len, off);
7290 /* Subroutine of native_interpret_expr. Interpret the contents of
7291 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7292 If the buffer cannot be interpreted, return NULL_TREE. */
7295 native_interpret_int (tree type, const unsigned char *ptr, int len)
7297 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7299 if (total_bytes > len
7300 || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7303 wide_int result = wi::from_buffer (ptr, total_bytes);
7305 return wide_int_to_tree (type, result);
7309 /* Subroutine of native_interpret_expr. Interpret the contents of
7310 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7311 If the buffer cannot be interpreted, return NULL_TREE. */
7314 native_interpret_fixed (tree type, const unsigned char *ptr, int len)
7316 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7318 FIXED_VALUE_TYPE fixed_value;
7320 if (total_bytes > len
7321 || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7324 result = double_int::from_buffer (ptr, total_bytes);
7325 fixed_value = fixed_from_double_int (result, TYPE_MODE (type));
7327 return build_fixed (type, fixed_value);
7331 /* Subroutine of native_interpret_expr. Interpret the contents of
7332 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7333 If the buffer cannot be interpreted, return NULL_TREE. */
7336 native_interpret_real (tree type, const unsigned char *ptr, int len)
7338 machine_mode mode = TYPE_MODE (type);
7339 int total_bytes = GET_MODE_SIZE (mode);
7340 int byte, offset, word, words, bitpos;
7341 unsigned char value;
7342 /* There are always 32 bits in each long, no matter the size of
7343 the hosts long. We handle floating point representations with
7348 total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7349 if (total_bytes > len || total_bytes > 24)
7351 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7353 memset (tmp, 0, sizeof (tmp));
7354 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7355 bitpos += BITS_PER_UNIT)
7357 byte = (bitpos / BITS_PER_UNIT) & 3;
7358 if (UNITS_PER_WORD < 4)
7360 word = byte / UNITS_PER_WORD;
7361 if (WORDS_BIG_ENDIAN)
7362 word = (words - 1) - word;
7363 offset = word * UNITS_PER_WORD;
7364 if (BYTES_BIG_ENDIAN)
7365 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7367 offset += byte % UNITS_PER_WORD;
7370 offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7371 value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7373 tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7376 real_from_target (&r, tmp, mode);
7377 return build_real (type, r);
7381 /* Subroutine of native_interpret_expr. Interpret the contents of
7382 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7383 If the buffer cannot be interpreted, return NULL_TREE. */
7386 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7388 tree etype, rpart, ipart;
7391 etype = TREE_TYPE (type);
7392 size = GET_MODE_SIZE (TYPE_MODE (etype));
7395 rpart = native_interpret_expr (etype, ptr, size);
7398 ipart = native_interpret_expr (etype, ptr+size, size);
7401 return build_complex (type, rpart, ipart);
7405 /* Subroutine of native_interpret_expr. Interpret the contents of
7406 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7407 If the buffer cannot be interpreted, return NULL_TREE. */
7410 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7416 etype = TREE_TYPE (type);
7417 size = GET_MODE_SIZE (TYPE_MODE (etype));
7418 count = TYPE_VECTOR_SUBPARTS (type);
7419 if (size * count > len)
7422 elements = XALLOCAVEC (tree, count);
7423 for (i = count - 1; i >= 0; i--)
7425 elem = native_interpret_expr (etype, ptr+(i*size), size);
7430 return build_vector (type, elements);
7434 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7435 the buffer PTR of length LEN as a constant of type TYPE. For
7436 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7437 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7438 return NULL_TREE. */
7441 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7443 switch (TREE_CODE (type))
7449 case REFERENCE_TYPE:
7450 return native_interpret_int (type, ptr, len);
7453 return native_interpret_real (type, ptr, len);
7455 case FIXED_POINT_TYPE:
7456 return native_interpret_fixed (type, ptr, len);
7459 return native_interpret_complex (type, ptr, len);
7462 return native_interpret_vector (type, ptr, len);
7469 /* Returns true if we can interpret the contents of a native encoding
7473 can_native_interpret_type_p (tree type)
7475 switch (TREE_CODE (type))
7481 case REFERENCE_TYPE:
7482 case FIXED_POINT_TYPE:
7492 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7493 TYPE at compile-time. If we're unable to perform the conversion
7494 return NULL_TREE. */
7497 fold_view_convert_expr (tree type, tree expr)
7499 /* We support up to 512-bit values (for V8DFmode). */
7500 unsigned char buffer[64];
7503 /* Check that the host and target are sane. */
7504 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7507 len = native_encode_expr (expr, buffer, sizeof (buffer));
7511 return native_interpret_expr (type, buffer, len);
7514 /* Build an expression for the address of T. Folds away INDIRECT_REF
7515 to avoid confusing the gimplify process. */
7518 build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
7520 /* The size of the object is not relevant when talking about its address. */
7521 if (TREE_CODE (t) == WITH_SIZE_EXPR)
7522 t = TREE_OPERAND (t, 0);
7524 if (TREE_CODE (t) == INDIRECT_REF)
7526 t = TREE_OPERAND (t, 0);
7528 if (TREE_TYPE (t) != ptrtype)
7529 t = build1_loc (loc, NOP_EXPR, ptrtype, t);
7531 else if (TREE_CODE (t) == MEM_REF
7532 && integer_zerop (TREE_OPERAND (t, 1)))
7533 return TREE_OPERAND (t, 0);
7534 else if (TREE_CODE (t) == MEM_REF
7535 && TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST)
7536 return fold_binary (POINTER_PLUS_EXPR, ptrtype,
7537 TREE_OPERAND (t, 0),
7538 convert_to_ptrofftype (TREE_OPERAND (t, 1)));
7539 else if (TREE_CODE (t) == VIEW_CONVERT_EXPR)
7541 t = build_fold_addr_expr_loc (loc, TREE_OPERAND (t, 0));
7543 if (TREE_TYPE (t) != ptrtype)
7544 t = fold_convert_loc (loc, ptrtype, t);
7547 t = build1_loc (loc, ADDR_EXPR, ptrtype, t);
7552 /* Build an expression for the address of T. */
7555 build_fold_addr_expr_loc (location_t loc, tree t)
7557 tree ptrtype = build_pointer_type (TREE_TYPE (t));
7559 return build_fold_addr_expr_with_type_loc (loc, t, ptrtype);
7562 static bool vec_cst_ctor_to_array (tree, tree *);
7564 /* Fold a unary expression of code CODE and type TYPE with operand
7565 OP0. Return the folded expression if folding is successful.
7566 Otherwise, return NULL_TREE. */
7569 fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
7573 enum tree_code_class kind = TREE_CODE_CLASS (code);
7575 gcc_assert (IS_EXPR_CODE_CLASS (kind)
7576 && TREE_CODE_LENGTH (code) == 1);
7578 tem = generic_simplify (loc, code, type, op0);
7585 if (CONVERT_EXPR_CODE_P (code)
7586 || code == FLOAT_EXPR || code == ABS_EXPR || code == NEGATE_EXPR)
7588 /* Don't use STRIP_NOPS, because signedness of argument type
7590 STRIP_SIGN_NOPS (arg0);
7594 /* Strip any conversions that don't change the mode. This
7595 is safe for every expression, except for a comparison
7596 expression because its signedness is derived from its
7599 Note that this is done as an internal manipulation within
7600 the constant folder, in order to find the simplest
7601 representation of the arguments so that their form can be
7602 studied. In any cases, the appropriate type conversions
7603 should be put back in the tree that will get out of the
7609 if (TREE_CODE_CLASS (code) == tcc_unary)
7611 if (TREE_CODE (arg0) == COMPOUND_EXPR)
7612 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7613 fold_build1_loc (loc, code, type,
7614 fold_convert_loc (loc, TREE_TYPE (op0),
7615 TREE_OPERAND (arg0, 1))));
7616 else if (TREE_CODE (arg0) == COND_EXPR)
7618 tree arg01 = TREE_OPERAND (arg0, 1);
7619 tree arg02 = TREE_OPERAND (arg0, 2);
7620 if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7621 arg01 = fold_build1_loc (loc, code, type,
7622 fold_convert_loc (loc,
7623 TREE_TYPE (op0), arg01));
7624 if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7625 arg02 = fold_build1_loc (loc, code, type,
7626 fold_convert_loc (loc,
7627 TREE_TYPE (op0), arg02));
7628 tem = fold_build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg0, 0),
7631 /* If this was a conversion, and all we did was to move into
7632 inside the COND_EXPR, bring it back out. But leave it if
7633 it is a conversion from integer to integer and the
7634 result precision is no wider than a word since such a
7635 conversion is cheap and may be optimized away by combine,
7636 while it couldn't if it were outside the COND_EXPR. Then return
7637 so we don't get into an infinite recursion loop taking the
7638 conversion out and then back in. */
7640 if ((CONVERT_EXPR_CODE_P (code)
7641 || code == NON_LVALUE_EXPR)
7642 && TREE_CODE (tem) == COND_EXPR
7643 && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7644 && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7645 && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7646 && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7647 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7648 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7649 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7651 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7652 && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7653 || flag_syntax_only))
7654 tem = build1_loc (loc, code, type,
7656 TREE_TYPE (TREE_OPERAND
7657 (TREE_OPERAND (tem, 1), 0)),
7658 TREE_OPERAND (tem, 0),
7659 TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7660 TREE_OPERAND (TREE_OPERAND (tem, 2),
7668 case NON_LVALUE_EXPR:
7669 if (!maybe_lvalue_p (op0))
7670 return fold_convert_loc (loc, type, op0);
7675 case FIX_TRUNC_EXPR:
7676 if (COMPARISON_CLASS_P (op0))
7678 /* If we have (type) (a CMP b) and type is an integral type, return
7679 new expression involving the new type. Canonicalize
7680 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7682 Do not fold the result as that would not simplify further, also
7683 folding again results in recursions. */
7684 if (TREE_CODE (type) == BOOLEAN_TYPE)
7685 return build2_loc (loc, TREE_CODE (op0), type,
7686 TREE_OPERAND (op0, 0),
7687 TREE_OPERAND (op0, 1));
7688 else if (!INTEGRAL_TYPE_P (type) && !VOID_TYPE_P (type)
7689 && TREE_CODE (type) != VECTOR_TYPE)
7690 return build3_loc (loc, COND_EXPR, type, op0,
7691 constant_boolean_node (true, type),
7692 constant_boolean_node (false, type));
7695 /* Handle cases of two conversions in a row. */
7696 if (CONVERT_EXPR_P (op0))
7698 tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
7699 tree inter_type = TREE_TYPE (op0);
7700 int inside_int = INTEGRAL_TYPE_P (inside_type);
7701 int inside_ptr = POINTER_TYPE_P (inside_type);
7702 int inside_float = FLOAT_TYPE_P (inside_type);
7703 int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
7704 unsigned int inside_prec = TYPE_PRECISION (inside_type);
7705 int inside_unsignedp = TYPE_UNSIGNED (inside_type);
7706 int inter_int = INTEGRAL_TYPE_P (inter_type);
7707 int inter_ptr = POINTER_TYPE_P (inter_type);
7708 int inter_float = FLOAT_TYPE_P (inter_type);
7709 int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
7710 unsigned int inter_prec = TYPE_PRECISION (inter_type);
7711 int inter_unsignedp = TYPE_UNSIGNED (inter_type);
7712 int final_int = INTEGRAL_TYPE_P (type);
7713 int final_ptr = POINTER_TYPE_P (type);
7714 int final_float = FLOAT_TYPE_P (type);
7715 int final_vec = TREE_CODE (type) == VECTOR_TYPE;
7716 unsigned int final_prec = TYPE_PRECISION (type);
7717 int final_unsignedp = TYPE_UNSIGNED (type);
7719 /* In addition to the cases of two conversions in a row
7720 handled below, if we are converting something to its own
7721 type via an object of identical or wider precision, neither
7722 conversion is needed. */
7723 if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
7724 && (((inter_int || inter_ptr) && final_int)
7725 || (inter_float && final_float))
7726 && inter_prec >= final_prec)
7727 return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7729 /* Likewise, if the intermediate and initial types are either both
7730 float or both integer, we don't need the middle conversion if the
7731 former is wider than the latter and doesn't change the signedness
7732 (for integers). Avoid this if the final type is a pointer since
7733 then we sometimes need the middle conversion. Likewise if the
7734 final type has a precision not equal to the size of its mode. */
7735 if (((inter_int && inside_int)
7736 || (inter_float && inside_float)
7737 || (inter_vec && inside_vec))
7738 && inter_prec >= inside_prec
7739 && (inter_float || inter_vec
7740 || inter_unsignedp == inside_unsignedp)
7741 && ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
7742 && TYPE_MODE (type) == TYPE_MODE (inter_type))
7744 && (! final_vec || inter_prec == inside_prec))
7745 return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7747 /* If we have a sign-extension of a zero-extended value, we can
7748 replace that by a single zero-extension. Likewise if the
7749 final conversion does not change precision we can drop the
7750 intermediate conversion. */
7751 if (inside_int && inter_int && final_int
7752 && ((inside_prec < inter_prec && inter_prec < final_prec
7753 && inside_unsignedp && !inter_unsignedp)
7754 || final_prec == inter_prec))
7755 return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7757 /* Two conversions in a row are not needed unless:
7758 - some conversion is floating-point (overstrict for now), or
7759 - some conversion is a vector (overstrict for now), or
7760 - the intermediate type is narrower than both initial and
7762 - the intermediate type and innermost type differ in signedness,
7763 and the outermost type is wider than the intermediate, or
7764 - the initial type is a pointer type and the precisions of the
7765 intermediate and final types differ, or
7766 - the final type is a pointer type and the precisions of the
7767 initial and intermediate types differ. */
7768 if (! inside_float && ! inter_float && ! final_float
7769 && ! inside_vec && ! inter_vec && ! final_vec
7770 && (inter_prec >= inside_prec || inter_prec >= final_prec)
7771 && ! (inside_int && inter_int
7772 && inter_unsignedp != inside_unsignedp
7773 && inter_prec < final_prec)
7774 && ((inter_unsignedp && inter_prec > inside_prec)
7775 == (final_unsignedp && final_prec > inter_prec))
7776 && ! (inside_ptr && inter_prec != final_prec)
7777 && ! (final_ptr && inside_prec != inter_prec)
7778 && ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
7779 && TYPE_MODE (type) == TYPE_MODE (inter_type)))
7780 return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
7783 /* Handle (T *)&A.B.C for A being of type T and B and C
7784 living at offset zero. This occurs frequently in
7785 C++ upcasting and then accessing the base. */
7786 if (TREE_CODE (op0) == ADDR_EXPR
7787 && POINTER_TYPE_P (type)
7788 && handled_component_p (TREE_OPERAND (op0, 0)))
7790 HOST_WIDE_INT bitsize, bitpos;
7793 int unsignedp, volatilep;
7794 tree base = TREE_OPERAND (op0, 0);
7795 base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7796 &mode, &unsignedp, &volatilep, false);
7797 /* If the reference was to a (constant) zero offset, we can use
7798 the address of the base if it has the same base type
7799 as the result type and the pointer type is unqualified. */
7800 if (! offset && bitpos == 0
7801 && (TYPE_MAIN_VARIANT (TREE_TYPE (type))
7802 == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
7803 && TYPE_QUALS (type) == TYPE_UNQUALIFIED)
7804 return fold_convert_loc (loc, type,
7805 build_fold_addr_expr_loc (loc, base));
7808 if (TREE_CODE (op0) == MODIFY_EXPR
7809 && TREE_CONSTANT (TREE_OPERAND (op0, 1))
7810 /* Detect assigning a bitfield. */
7811 && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
7813 (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
7815 /* Don't leave an assignment inside a conversion
7816 unless assigning a bitfield. */
7817 tem = fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 1));
7818 /* First do the assignment, then return converted constant. */
7819 tem = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
7820 TREE_NO_WARNING (tem) = 1;
7821 TREE_USED (tem) = 1;
7825 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7826 constants (if x has signed type, the sign bit cannot be set
7827 in c). This folds extension into the BIT_AND_EXPR.
7828 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7829 very likely don't have maximal range for their precision and this
7830 transformation effectively doesn't preserve non-maximal ranges. */
7831 if (TREE_CODE (type) == INTEGER_TYPE
7832 && TREE_CODE (op0) == BIT_AND_EXPR
7833 && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
7835 tree and_expr = op0;
7836 tree and0 = TREE_OPERAND (and_expr, 0);
7837 tree and1 = TREE_OPERAND (and_expr, 1);
7840 if (TYPE_UNSIGNED (TREE_TYPE (and_expr))
7841 || (TYPE_PRECISION (type)
7842 <= TYPE_PRECISION (TREE_TYPE (and_expr))))
7844 else if (TYPE_PRECISION (TREE_TYPE (and1))
7845 <= HOST_BITS_PER_WIDE_INT
7846 && tree_fits_uhwi_p (and1))
7848 unsigned HOST_WIDE_INT cst;
7850 cst = tree_to_uhwi (and1);
7851 cst &= HOST_WIDE_INT_M1U
7852 << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
7853 change = (cst == 0);
7854 #ifdef LOAD_EXTEND_OP
7856 && !flag_syntax_only
7857 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
7860 tree uns = unsigned_type_for (TREE_TYPE (and0));
7861 and0 = fold_convert_loc (loc, uns, and0);
7862 and1 = fold_convert_loc (loc, uns, and1);
7868 tem = force_fit_type (type, wi::to_widest (and1), 0,
7869 TREE_OVERFLOW (and1));
7870 return fold_build2_loc (loc, BIT_AND_EXPR, type,
7871 fold_convert_loc (loc, type, and0), tem);
7875 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
7876 when one of the new casts will fold away. Conservatively we assume
7877 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
7878 if (POINTER_TYPE_P (type)
7879 && TREE_CODE (arg0) == POINTER_PLUS_EXPR
7880 && (!TYPE_RESTRICT (type) || TYPE_RESTRICT (TREE_TYPE (arg0)))
7881 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7882 || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
7883 || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
7885 tree arg00 = TREE_OPERAND (arg0, 0);
7886 tree arg01 = TREE_OPERAND (arg0, 1);
7888 return fold_build_pointer_plus_loc
7889 (loc, fold_convert_loc (loc, type, arg00), arg01);
7892 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7893 of the same precision, and X is an integer type not narrower than
7894 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7895 if (INTEGRAL_TYPE_P (type)
7896 && TREE_CODE (op0) == BIT_NOT_EXPR
7897 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7898 && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
7899 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
7901 tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
7902 if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7903 && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
7904 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
7905 fold_convert_loc (loc, type, tem));
7908 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7909 type of X and Y (integer types only). */
7910 if (INTEGRAL_TYPE_P (type)
7911 && TREE_CODE (op0) == MULT_EXPR
7912 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7913 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
7915 /* Be careful not to introduce new overflows. */
7917 if (TYPE_OVERFLOW_WRAPS (type))
7920 mult_type = unsigned_type_for (type);
7922 if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
7924 tem = fold_build2_loc (loc, MULT_EXPR, mult_type,
7925 fold_convert_loc (loc, mult_type,
7926 TREE_OPERAND (op0, 0)),
7927 fold_convert_loc (loc, mult_type,
7928 TREE_OPERAND (op0, 1)));
7929 return fold_convert_loc (loc, type, tem);
7933 tem = fold_convert_const (code, type, arg0);
7934 return tem ? tem : NULL_TREE;
7936 case ADDR_SPACE_CONVERT_EXPR:
7937 if (integer_zerop (arg0))
7938 return fold_convert_const (code, type, arg0);
7941 case FIXED_CONVERT_EXPR:
7942 tem = fold_convert_const (code, type, arg0);
7943 return tem ? tem : NULL_TREE;
7945 case VIEW_CONVERT_EXPR:
7946 if (TREE_CODE (op0) == MEM_REF)
7947 return fold_build2_loc (loc, MEM_REF, type,
7948 TREE_OPERAND (op0, 0), TREE_OPERAND (op0, 1));
7950 return fold_view_convert_expr (type, op0);
7953 tem = fold_negate_expr (loc, arg0);
7955 return fold_convert_loc (loc, type, tem);
7959 if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
7960 return fold_abs_const (arg0, type);
7961 /* Convert fabs((double)float) into (double)fabsf(float). */
7962 else if (TREE_CODE (arg0) == NOP_EXPR
7963 && TREE_CODE (type) == REAL_TYPE)
7965 tree targ0 = strip_float_extensions (arg0);
7967 return fold_convert_loc (loc, type,
7968 fold_build1_loc (loc, ABS_EXPR,
7972 /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on. */
7973 else if (TREE_CODE (arg0) == ABS_EXPR)
7976 /* Strip sign ops from argument. */
7977 if (TREE_CODE (type) == REAL_TYPE)
7979 tem = fold_strip_sign_ops (arg0);
7981 return fold_build1_loc (loc, ABS_EXPR, type,
7982 fold_convert_loc (loc, type, tem));
7987 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7988 return fold_convert_loc (loc, type, arg0);
7989 if (TREE_CODE (arg0) == COMPLEX_EXPR)
7991 tree itype = TREE_TYPE (type);
7992 tree rpart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 0));
7993 tree ipart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 1));
7994 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart,
7995 negate_expr (ipart));
7997 if (TREE_CODE (arg0) == COMPLEX_CST)
7999 tree itype = TREE_TYPE (type);
8000 tree rpart = fold_convert_loc (loc, itype, TREE_REALPART (arg0));
8001 tree ipart = fold_convert_loc (loc, itype, TREE_IMAGPART (arg0));
8002 return build_complex (type, rpart, negate_expr (ipart));
8004 if (TREE_CODE (arg0) == CONJ_EXPR)
8005 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
8009 if (TREE_CODE (arg0) == INTEGER_CST)
8010 return fold_not_const (arg0, type);
8011 /* Convert ~ (-A) to A - 1. */
8012 else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
8013 return fold_build2_loc (loc, MINUS_EXPR, type,
8014 fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0)),
8015 build_int_cst (type, 1));
8016 /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
8017 else if (INTEGRAL_TYPE_P (type)
8018 && ((TREE_CODE (arg0) == MINUS_EXPR
8019 && integer_onep (TREE_OPERAND (arg0, 1)))
8020 || (TREE_CODE (arg0) == PLUS_EXPR
8021 && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
8022 return fold_build1_loc (loc, NEGATE_EXPR, type,
8023 fold_convert_loc (loc, type,
8024 TREE_OPERAND (arg0, 0)));
8025 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8026 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8027 && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8028 fold_convert_loc (loc, type,
8029 TREE_OPERAND (arg0, 0)))))
8030 return fold_build2_loc (loc, BIT_XOR_EXPR, type, tem,
8031 fold_convert_loc (loc, type,
8032 TREE_OPERAND (arg0, 1)));
8033 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8034 && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8035 fold_convert_loc (loc, type,
8036 TREE_OPERAND (arg0, 1)))))
8037 return fold_build2_loc (loc, BIT_XOR_EXPR, type,
8038 fold_convert_loc (loc, type,
8039 TREE_OPERAND (arg0, 0)), tem);
8040 /* Perform BIT_NOT_EXPR on each element individually. */
8041 else if (TREE_CODE (arg0) == VECTOR_CST)
8045 unsigned count = VECTOR_CST_NELTS (arg0), i;
8047 elements = XALLOCAVEC (tree, count);
8048 for (i = 0; i < count; i++)
8050 elem = VECTOR_CST_ELT (arg0, i);
8051 elem = fold_unary_loc (loc, BIT_NOT_EXPR, TREE_TYPE (type), elem);
8052 if (elem == NULL_TREE)
8057 return build_vector (type, elements);
8059 else if (COMPARISON_CLASS_P (arg0)
8060 && (VECTOR_TYPE_P (type)
8061 || (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1)))
8063 tree op_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
8064 enum tree_code subcode = invert_tree_comparison (TREE_CODE (arg0),
8065 HONOR_NANS (TYPE_MODE (op_type)));
8066 if (subcode != ERROR_MARK)
8067 return build2_loc (loc, subcode, type, TREE_OPERAND (arg0, 0),
8068 TREE_OPERAND (arg0, 1));
8074 case TRUTH_NOT_EXPR:
8075 /* Note that the operand of this must be an int
8076 and its values must be 0 or 1.
8077 ("true" is a fixed value perhaps depending on the language,
8078 but we don't handle values other than 1 correctly yet.) */
8079 tem = fold_truth_not_expr (loc, arg0);
8082 return fold_convert_loc (loc, type, tem);
8085 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8086 return fold_convert_loc (loc, type, arg0);
8087 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8088 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
8089 TREE_OPERAND (arg0, 1));
8090 if (TREE_CODE (arg0) == COMPLEX_CST)
8091 return fold_convert_loc (loc, type, TREE_REALPART (arg0));
8092 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8094 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8095 tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8096 fold_build1_loc (loc, REALPART_EXPR, itype,
8097 TREE_OPERAND (arg0, 0)),
8098 fold_build1_loc (loc, REALPART_EXPR, itype,
8099 TREE_OPERAND (arg0, 1)));
8100 return fold_convert_loc (loc, type, tem);
8102 if (TREE_CODE (arg0) == CONJ_EXPR)
8104 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8105 tem = fold_build1_loc (loc, REALPART_EXPR, itype,
8106 TREE_OPERAND (arg0, 0));
8107 return fold_convert_loc (loc, type, tem);
8109 if (TREE_CODE (arg0) == CALL_EXPR)
8111 tree fn = get_callee_fndecl (arg0);
8112 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8113 switch (DECL_FUNCTION_CODE (fn))
8115 CASE_FLT_FN (BUILT_IN_CEXPI):
8116 fn = mathfn_built_in (type, BUILT_IN_COS);
8118 return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8128 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8129 return build_zero_cst (type);
8130 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8131 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 1),
8132 TREE_OPERAND (arg0, 0));
8133 if (TREE_CODE (arg0) == COMPLEX_CST)
8134 return fold_convert_loc (loc, type, TREE_IMAGPART (arg0));
8135 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8137 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8138 tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8139 fold_build1_loc (loc, IMAGPART_EXPR, itype,
8140 TREE_OPERAND (arg0, 0)),
8141 fold_build1_loc (loc, IMAGPART_EXPR, itype,
8142 TREE_OPERAND (arg0, 1)));
8143 return fold_convert_loc (loc, type, tem);
8145 if (TREE_CODE (arg0) == CONJ_EXPR)
8147 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8148 tem = fold_build1_loc (loc, IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8149 return fold_convert_loc (loc, type, negate_expr (tem));
8151 if (TREE_CODE (arg0) == CALL_EXPR)
8153 tree fn = get_callee_fndecl (arg0);
8154 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8155 switch (DECL_FUNCTION_CODE (fn))
8157 CASE_FLT_FN (BUILT_IN_CEXPI):
8158 fn = mathfn_built_in (type, BUILT_IN_SIN);
8160 return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8170 /* Fold *&X to X if X is an lvalue. */
8171 if (TREE_CODE (op0) == ADDR_EXPR)
8173 tree op00 = TREE_OPERAND (op0, 0);
8174 if ((TREE_CODE (op00) == VAR_DECL
8175 || TREE_CODE (op00) == PARM_DECL
8176 || TREE_CODE (op00) == RESULT_DECL)
8177 && !TREE_READONLY (op00))
8182 case VEC_UNPACK_LO_EXPR:
8183 case VEC_UNPACK_HI_EXPR:
8184 case VEC_UNPACK_FLOAT_LO_EXPR:
8185 case VEC_UNPACK_FLOAT_HI_EXPR:
8187 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
8189 enum tree_code subcode;
8191 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2);
8192 if (TREE_CODE (arg0) != VECTOR_CST)
8195 elts = XALLOCAVEC (tree, nelts * 2);
8196 if (!vec_cst_ctor_to_array (arg0, elts))
8199 if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_UNPACK_LO_EXPR
8200 || code == VEC_UNPACK_FLOAT_LO_EXPR))
8203 if (code == VEC_UNPACK_LO_EXPR || code == VEC_UNPACK_HI_EXPR)
8206 subcode = FLOAT_EXPR;
8208 for (i = 0; i < nelts; i++)
8210 elts[i] = fold_convert_const (subcode, TREE_TYPE (type), elts[i]);
8211 if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
8215 return build_vector (type, elts);
8218 case REDUC_MIN_EXPR:
8219 case REDUC_MAX_EXPR:
8220 case REDUC_PLUS_EXPR:
8222 unsigned int nelts, i;
8224 enum tree_code subcode;
8226 if (TREE_CODE (op0) != VECTOR_CST)
8228 nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (op0));
8230 elts = XALLOCAVEC (tree, nelts);
8231 if (!vec_cst_ctor_to_array (op0, elts))
8236 case REDUC_MIN_EXPR: subcode = MIN_EXPR; break;
8237 case REDUC_MAX_EXPR: subcode = MAX_EXPR; break;
8238 case REDUC_PLUS_EXPR: subcode = PLUS_EXPR; break;
8239 default: gcc_unreachable ();
8242 for (i = 1; i < nelts; i++)
8244 elts[0] = const_binop (subcode, elts[0], elts[i]);
8245 if (elts[0] == NULL_TREE || !CONSTANT_CLASS_P (elts[0]))
8254 } /* switch (code) */
8258 /* If the operation was a conversion do _not_ mark a resulting constant
8259 with TREE_OVERFLOW if the original constant was not. These conversions
8260 have implementation defined behavior and retaining the TREE_OVERFLOW
8261 flag here would confuse later passes such as VRP. */
8263 fold_unary_ignore_overflow_loc (location_t loc, enum tree_code code,
8264 tree type, tree op0)
8266 tree res = fold_unary_loc (loc, code, type, op0);
8268 && TREE_CODE (res) == INTEGER_CST
8269 && TREE_CODE (op0) == INTEGER_CST
8270 && CONVERT_EXPR_CODE_P (code))
8271 TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
8276 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8277 operands OP0 and OP1. LOC is the location of the resulting expression.
8278 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8279 Return the folded expression if folding is successful. Otherwise,
8280 return NULL_TREE. */
8282 fold_truth_andor (location_t loc, enum tree_code code, tree type,
8283 tree arg0, tree arg1, tree op0, tree op1)
8287 /* We only do these simplifications if we are optimizing. */
8291 /* Check for things like (A || B) && (A || C). We can convert this
8292 to A || (B && C). Note that either operator can be any of the four
8293 truth and/or operations and the transformation will still be
8294 valid. Also note that we only care about order for the
8295 ANDIF and ORIF operators. If B contains side effects, this
8296 might change the truth-value of A. */
8297 if (TREE_CODE (arg0) == TREE_CODE (arg1)
8298 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
8299 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
8300 || TREE_CODE (arg0) == TRUTH_AND_EXPR
8301 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
8302 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
8304 tree a00 = TREE_OPERAND (arg0, 0);
8305 tree a01 = TREE_OPERAND (arg0, 1);
8306 tree a10 = TREE_OPERAND (arg1, 0);
8307 tree a11 = TREE_OPERAND (arg1, 1);
8308 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
8309 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
8310 && (code == TRUTH_AND_EXPR
8311 || code == TRUTH_OR_EXPR));
8313 if (operand_equal_p (a00, a10, 0))
8314 return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8315 fold_build2_loc (loc, code, type, a01, a11));
8316 else if (commutative && operand_equal_p (a00, a11, 0))
8317 return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8318 fold_build2_loc (loc, code, type, a01, a10));
8319 else if (commutative && operand_equal_p (a01, a10, 0))
8320 return fold_build2_loc (loc, TREE_CODE (arg0), type, a01,
8321 fold_build2_loc (loc, code, type, a00, a11));
8323 /* This case if tricky because we must either have commutative
8324 operators or else A10 must not have side-effects. */
8326 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
8327 && operand_equal_p (a01, a11, 0))
8328 return fold_build2_loc (loc, TREE_CODE (arg0), type,
8329 fold_build2_loc (loc, code, type, a00, a10),
8333 /* See if we can build a range comparison. */
8334 if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
8337 if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg0) == TRUTH_ORIF_EXPR)
8338 || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg0) == TRUTH_ANDIF_EXPR))
8340 tem = merge_truthop_with_opposite_arm (loc, arg0, arg1, true);
8342 return fold_build2_loc (loc, code, type, tem, arg1);
8345 if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg1) == TRUTH_ORIF_EXPR)
8346 || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg1) == TRUTH_ANDIF_EXPR))
8348 tem = merge_truthop_with_opposite_arm (loc, arg1, arg0, false);
8350 return fold_build2_loc (loc, code, type, arg0, tem);
8353 /* Check for the possibility of merging component references. If our
8354 lhs is another similar operation, try to merge its rhs with our
8355 rhs. Then try to merge our lhs and rhs. */
8356 if (TREE_CODE (arg0) == code
8357 && 0 != (tem = fold_truth_andor_1 (loc, code, type,
8358 TREE_OPERAND (arg0, 1), arg1)))
8359 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
8361 if ((tem = fold_truth_andor_1 (loc, code, type, arg0, arg1)) != 0)
8364 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8365 && (code == TRUTH_AND_EXPR
8366 || code == TRUTH_ANDIF_EXPR
8367 || code == TRUTH_OR_EXPR
8368 || code == TRUTH_ORIF_EXPR))
8370 enum tree_code ncode, icode;
8372 ncode = (code == TRUTH_ANDIF_EXPR || code == TRUTH_AND_EXPR)
8373 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR;
8374 icode = ncode == TRUTH_AND_EXPR ? TRUTH_ANDIF_EXPR : TRUTH_ORIF_EXPR;
8376 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8377 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8378 We don't want to pack more than two leafs to a non-IF AND/OR
8380 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8381 equal to IF-CODE, then we don't want to add right-hand operand.
8382 If the inner right-hand side of left-hand operand has
8383 side-effects, or isn't simple, then we can't add to it,
8384 as otherwise we might destroy if-sequence. */
8385 if (TREE_CODE (arg0) == icode
8386 && simple_operand_p_2 (arg1)
8387 /* Needed for sequence points to handle trappings, and
8389 && simple_operand_p_2 (TREE_OPERAND (arg0, 1)))
8391 tem = fold_build2_loc (loc, ncode, type, TREE_OPERAND (arg0, 1),
8393 return fold_build2_loc (loc, icode, type, TREE_OPERAND (arg0, 0),
8396 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8397 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8398 else if (TREE_CODE (arg1) == icode
8399 && simple_operand_p_2 (arg0)
8400 /* Needed for sequence points to handle trappings, and
8402 && simple_operand_p_2 (TREE_OPERAND (arg1, 0)))
8404 tem = fold_build2_loc (loc, ncode, type,
8405 arg0, TREE_OPERAND (arg1, 0));
8406 return fold_build2_loc (loc, icode, type, tem,
8407 TREE_OPERAND (arg1, 1));
8409 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8411 For sequence point consistancy, we need to check for trapping,
8412 and side-effects. */
8413 else if (code == icode && simple_operand_p_2 (arg0)
8414 && simple_operand_p_2 (arg1))
8415 return fold_build2_loc (loc, ncode, type, arg0, arg1);
8421 /* Fold a binary expression of code CODE and type TYPE with operands
8422 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8423 Return the folded expression if folding is successful. Otherwise,
8424 return NULL_TREE. */
8427 fold_minmax (location_t loc, enum tree_code code, tree type, tree op0, tree op1)
8429 enum tree_code compl_code;
8431 if (code == MIN_EXPR)
8432 compl_code = MAX_EXPR;
8433 else if (code == MAX_EXPR)
8434 compl_code = MIN_EXPR;
8438 /* MIN (MAX (a, b), b) == b. */
8439 if (TREE_CODE (op0) == compl_code
8440 && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
8441 return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 0));
8443 /* MIN (MAX (b, a), b) == b. */
8444 if (TREE_CODE (op0) == compl_code
8445 && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
8446 && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
8447 return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 1));
8449 /* MIN (a, MAX (a, b)) == a. */
8450 if (TREE_CODE (op1) == compl_code
8451 && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
8452 && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
8453 return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 1));
8455 /* MIN (a, MAX (b, a)) == a. */
8456 if (TREE_CODE (op1) == compl_code
8457 && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
8458 && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
8459 return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 0));
8464 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8465 by changing CODE to reduce the magnitude of constants involved in
8466 ARG0 of the comparison.
8467 Returns a canonicalized comparison tree if a simplification was
8468 possible, otherwise returns NULL_TREE.
8469 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8470 valid if signed overflow is undefined. */
8473 maybe_canonicalize_comparison_1 (location_t loc, enum tree_code code, tree type,
8474 tree arg0, tree arg1,
8475 bool *strict_overflow_p)
8477 enum tree_code code0 = TREE_CODE (arg0);
8478 tree t, cst0 = NULL_TREE;
8482 /* Match A +- CST code arg1 and CST code arg1. We can change the
8483 first form only if overflow is undefined. */
8484 if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8485 /* In principle pointers also have undefined overflow behavior,
8486 but that causes problems elsewhere. */
8487 && !POINTER_TYPE_P (TREE_TYPE (arg0))
8488 && (code0 == MINUS_EXPR
8489 || code0 == PLUS_EXPR)
8490 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8491 || code0 == INTEGER_CST))
8494 /* Identify the constant in arg0 and its sign. */
8495 if (code0 == INTEGER_CST)
8498 cst0 = TREE_OPERAND (arg0, 1);
8499 sgn0 = tree_int_cst_sgn (cst0);
8501 /* Overflowed constants and zero will cause problems. */
8502 if (integer_zerop (cst0)
8503 || TREE_OVERFLOW (cst0))
8506 /* See if we can reduce the magnitude of the constant in
8507 arg0 by changing the comparison code. */
8508 if (code0 == INTEGER_CST)
8510 /* CST <= arg1 -> CST-1 < arg1. */
8511 if (code == LE_EXPR && sgn0 == 1)
8513 /* -CST < arg1 -> -CST-1 <= arg1. */
8514 else if (code == LT_EXPR && sgn0 == -1)
8516 /* CST > arg1 -> CST-1 >= arg1. */
8517 else if (code == GT_EXPR && sgn0 == 1)
8519 /* -CST >= arg1 -> -CST-1 > arg1. */
8520 else if (code == GE_EXPR && sgn0 == -1)
8524 /* arg1 code' CST' might be more canonical. */
8529 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8531 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8533 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8534 else if (code == GT_EXPR
8535 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8537 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8538 else if (code == LE_EXPR
8539 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8541 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8542 else if (code == GE_EXPR
8543 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8547 *strict_overflow_p = true;
8550 /* Now build the constant reduced in magnitude. But not if that
8551 would produce one outside of its types range. */
8552 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8554 && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8555 && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8557 && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8558 && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8559 /* We cannot swap the comparison here as that would cause us to
8560 endlessly recurse. */
8563 t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8564 cst0, build_int_cst (TREE_TYPE (cst0), 1));
8565 if (code0 != INTEGER_CST)
8566 t = fold_build2_loc (loc, code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8567 t = fold_convert (TREE_TYPE (arg1), t);
8569 /* If swapping might yield to a more canonical form, do so. */
8571 return fold_build2_loc (loc, swap_tree_comparison (code), type, arg1, t);
8573 return fold_build2_loc (loc, code, type, t, arg1);
8576 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8577 overflow further. Try to decrease the magnitude of constants involved
8578 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8579 and put sole constants at the second argument position.
8580 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8583 maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
8584 tree arg0, tree arg1)
8587 bool strict_overflow_p;
8588 const char * const warnmsg = G_("assuming signed overflow does not occur "
8589 "when reducing constant in comparison");
8591 /* Try canonicalization by simplifying arg0. */
8592 strict_overflow_p = false;
8593 t = maybe_canonicalize_comparison_1 (loc, code, type, arg0, arg1,
8594 &strict_overflow_p);
8597 if (strict_overflow_p)
8598 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8602 /* Try canonicalization by simplifying arg1 using the swapped
8604 code = swap_tree_comparison (code);
8605 strict_overflow_p = false;
8606 t = maybe_canonicalize_comparison_1 (loc, code, type, arg1, arg0,
8607 &strict_overflow_p);
8608 if (t && strict_overflow_p)
8609 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8613 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8614 space. This is used to avoid issuing overflow warnings for
8615 expressions like &p->x which can not wrap. */
8618 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8620 if (!POINTER_TYPE_P (TREE_TYPE (base)))
8627 int precision = TYPE_PRECISION (TREE_TYPE (base));
8628 if (offset == NULL_TREE)
8629 wi_offset = wi::zero (precision);
8630 else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8636 wide_int units = wi::shwi (bitpos / BITS_PER_UNIT, precision);
8637 wide_int total = wi::add (wi_offset, units, UNSIGNED, &overflow);
8641 if (!wi::fits_uhwi_p (total))
8644 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8648 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8650 if (TREE_CODE (base) == ADDR_EXPR)
8652 HOST_WIDE_INT base_size;
8654 base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8655 if (base_size > 0 && size < base_size)
8659 return total.to_uhwi () > (unsigned HOST_WIDE_INT) size;
8662 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
8663 kind INTEGER_CST. This makes sure to properly sign-extend the
8666 static HOST_WIDE_INT
8667 size_low_cst (const_tree t)
8669 HOST_WIDE_INT w = TREE_INT_CST_ELT (t, 0);
8670 int prec = TYPE_PRECISION (TREE_TYPE (t));
8671 if (prec < HOST_BITS_PER_WIDE_INT)
8672 return sext_hwi (w, prec);
8676 /* Subroutine of fold_binary. This routine performs all of the
8677 transformations that are common to the equality/inequality
8678 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8679 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8680 fold_binary should call fold_binary. Fold a comparison with
8681 tree code CODE and type TYPE with operands OP0 and OP1. Return
8682 the folded comparison or NULL_TREE. */
8685 fold_comparison (location_t loc, enum tree_code code, tree type,
8688 const bool equality_code = (code == EQ_EXPR || code == NE_EXPR);
8689 tree arg0, arg1, tem;
8694 STRIP_SIGN_NOPS (arg0);
8695 STRIP_SIGN_NOPS (arg1);
8697 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8698 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8699 && (equality_code || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0)))
8700 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8701 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8702 && TREE_CODE (arg1) == INTEGER_CST
8703 && !TREE_OVERFLOW (arg1))
8705 const enum tree_code
8706 reverse_op = TREE_CODE (arg0) == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR;
8707 tree const1 = TREE_OPERAND (arg0, 1);
8708 tree const2 = fold_convert_loc (loc, TREE_TYPE (const1), arg1);
8709 tree variable = TREE_OPERAND (arg0, 0);
8710 tree new_const = int_const_binop (reverse_op, const2, const1);
8712 /* If the constant operation overflowed this can be
8713 simplified as a comparison against INT_MAX/INT_MIN. */
8714 if (TREE_OVERFLOW (new_const)
8715 && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
8717 int const1_sgn = tree_int_cst_sgn (const1);
8718 enum tree_code code2 = code;
8720 /* Get the sign of the constant on the lhs if the
8721 operation were VARIABLE + CONST1. */
8722 if (TREE_CODE (arg0) == MINUS_EXPR)
8723 const1_sgn = -const1_sgn;
8725 /* The sign of the constant determines if we overflowed
8726 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8727 Canonicalize to the INT_MIN overflow by swapping the comparison
8729 if (const1_sgn == -1)
8730 code2 = swap_tree_comparison (code);
8732 /* We now can look at the canonicalized case
8733 VARIABLE + 1 CODE2 INT_MIN
8734 and decide on the result. */
8741 omit_one_operand_loc (loc, type, boolean_false_node, variable);
8747 omit_one_operand_loc (loc, type, boolean_true_node, variable);
8756 fold_overflow_warning ("assuming signed overflow does not occur "
8757 "when changing X +- C1 cmp C2 to "
8759 WARN_STRICT_OVERFLOW_COMPARISON);
8760 return fold_build2_loc (loc, code, type, variable, new_const);
8764 /* Transform comparisons of the form X - Y CMP 0 to X CMP Y. */
8765 if (TREE_CODE (arg0) == MINUS_EXPR
8767 && integer_zerop (arg1))
8769 /* ??? The transformation is valid for the other operators if overflow
8770 is undefined for the type, but performing it here badly interacts
8771 with the transformation in fold_cond_expr_with_comparison which
8772 attempts to synthetize ABS_EXPR. */
8774 fold_overflow_warning ("assuming signed overflow does not occur "
8775 "when changing X - Y cmp 0 to X cmp Y",
8776 WARN_STRICT_OVERFLOW_COMPARISON);
8777 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
8778 TREE_OPERAND (arg0, 1));
8781 /* For comparisons of pointers we can decompose it to a compile time
8782 comparison of the base objects and the offsets into the object.
8783 This requires at least one operand being an ADDR_EXPR or a
8784 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8785 if (POINTER_TYPE_P (TREE_TYPE (arg0))
8786 && (TREE_CODE (arg0) == ADDR_EXPR
8787 || TREE_CODE (arg1) == ADDR_EXPR
8788 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
8789 || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
8791 tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
8792 HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
8794 int volatilep, unsignedp;
8795 bool indirect_base0 = false, indirect_base1 = false;
8797 /* Get base and offset for the access. Strip ADDR_EXPR for
8798 get_inner_reference, but put it back by stripping INDIRECT_REF
8799 off the base object if possible. indirect_baseN will be true
8800 if baseN is not an address but refers to the object itself. */
8802 if (TREE_CODE (arg0) == ADDR_EXPR)
8804 base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
8805 &bitsize, &bitpos0, &offset0, &mode,
8806 &unsignedp, &volatilep, false);
8807 if (TREE_CODE (base0) == INDIRECT_REF)
8808 base0 = TREE_OPERAND (base0, 0);
8810 indirect_base0 = true;
8812 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
8814 base0 = TREE_OPERAND (arg0, 0);
8815 STRIP_SIGN_NOPS (base0);
8816 if (TREE_CODE (base0) == ADDR_EXPR)
8818 base0 = TREE_OPERAND (base0, 0);
8819 indirect_base0 = true;
8821 offset0 = TREE_OPERAND (arg0, 1);
8822 if (tree_fits_shwi_p (offset0))
8824 HOST_WIDE_INT off = size_low_cst (offset0);
8825 if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
8827 / BITS_PER_UNIT == (HOST_WIDE_INT) off)
8829 bitpos0 = off * BITS_PER_UNIT;
8830 offset0 = NULL_TREE;
8836 if (TREE_CODE (arg1) == ADDR_EXPR)
8838 base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
8839 &bitsize, &bitpos1, &offset1, &mode,
8840 &unsignedp, &volatilep, false);
8841 if (TREE_CODE (base1) == INDIRECT_REF)
8842 base1 = TREE_OPERAND (base1, 0);
8844 indirect_base1 = true;
8846 else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
8848 base1 = TREE_OPERAND (arg1, 0);
8849 STRIP_SIGN_NOPS (base1);
8850 if (TREE_CODE (base1) == ADDR_EXPR)
8852 base1 = TREE_OPERAND (base1, 0);
8853 indirect_base1 = true;
8855 offset1 = TREE_OPERAND (arg1, 1);
8856 if (tree_fits_shwi_p (offset1))
8858 HOST_WIDE_INT off = size_low_cst (offset1);
8859 if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
8861 / BITS_PER_UNIT == (HOST_WIDE_INT) off)
8863 bitpos1 = off * BITS_PER_UNIT;
8864 offset1 = NULL_TREE;
8869 /* A local variable can never be pointed to by
8870 the default SSA name of an incoming parameter. */
8871 if ((TREE_CODE (arg0) == ADDR_EXPR
8873 && TREE_CODE (base0) == VAR_DECL
8874 && auto_var_in_fn_p (base0, current_function_decl)
8876 && TREE_CODE (base1) == SSA_NAME
8877 && SSA_NAME_IS_DEFAULT_DEF (base1)
8878 && TREE_CODE (SSA_NAME_VAR (base1)) == PARM_DECL)
8879 || (TREE_CODE (arg1) == ADDR_EXPR
8881 && TREE_CODE (base1) == VAR_DECL
8882 && auto_var_in_fn_p (base1, current_function_decl)
8884 && TREE_CODE (base0) == SSA_NAME
8885 && SSA_NAME_IS_DEFAULT_DEF (base0)
8886 && TREE_CODE (SSA_NAME_VAR (base0)) == PARM_DECL))
8888 if (code == NE_EXPR)
8889 return constant_boolean_node (1, type);
8890 else if (code == EQ_EXPR)
8891 return constant_boolean_node (0, type);
8893 /* If we have equivalent bases we might be able to simplify. */
8894 else if (indirect_base0 == indirect_base1
8895 && operand_equal_p (base0, base1, 0))
8897 /* We can fold this expression to a constant if the non-constant
8898 offset parts are equal. */
8899 if ((offset0 == offset1
8900 || (offset0 && offset1
8901 && operand_equal_p (offset0, offset1, 0)))
8904 || (indirect_base0 && DECL_P (base0))
8905 || POINTER_TYPE_OVERFLOW_UNDEFINED))
8909 && bitpos0 != bitpos1
8910 && (pointer_may_wrap_p (base0, offset0, bitpos0)
8911 || pointer_may_wrap_p (base1, offset1, bitpos1)))
8912 fold_overflow_warning (("assuming pointer wraparound does not "
8913 "occur when comparing P +- C1 with "
8915 WARN_STRICT_OVERFLOW_CONDITIONAL);
8920 return constant_boolean_node (bitpos0 == bitpos1, type);
8922 return constant_boolean_node (bitpos0 != bitpos1, type);
8924 return constant_boolean_node (bitpos0 < bitpos1, type);
8926 return constant_boolean_node (bitpos0 <= bitpos1, type);
8928 return constant_boolean_node (bitpos0 >= bitpos1, type);
8930 return constant_boolean_node (bitpos0 > bitpos1, type);
8934 /* We can simplify the comparison to a comparison of the variable
8935 offset parts if the constant offset parts are equal.
8936 Be careful to use signed sizetype here because otherwise we
8937 mess with array offsets in the wrong way. This is possible
8938 because pointer arithmetic is restricted to retain within an
8939 object and overflow on pointer differences is undefined as of
8940 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8941 else if (bitpos0 == bitpos1
8943 || (indirect_base0 && DECL_P (base0))
8944 || POINTER_TYPE_OVERFLOW_UNDEFINED))
8946 /* By converting to signed sizetype we cover middle-end pointer
8947 arithmetic which operates on unsigned pointer types of size
8948 type size and ARRAY_REF offsets which are properly sign or
8949 zero extended from their type in case it is narrower than
8951 if (offset0 == NULL_TREE)
8952 offset0 = build_int_cst (ssizetype, 0);
8954 offset0 = fold_convert_loc (loc, ssizetype, offset0);
8955 if (offset1 == NULL_TREE)
8956 offset1 = build_int_cst (ssizetype, 0);
8958 offset1 = fold_convert_loc (loc, ssizetype, offset1);
8961 && (pointer_may_wrap_p (base0, offset0, bitpos0)
8962 || pointer_may_wrap_p (base1, offset1, bitpos1)))
8963 fold_overflow_warning (("assuming pointer wraparound does not "
8964 "occur when comparing P +- C1 with "
8966 WARN_STRICT_OVERFLOW_COMPARISON);
8968 return fold_build2_loc (loc, code, type, offset0, offset1);
8971 /* For non-equal bases we can simplify if they are addresses
8972 of local binding decls or constants. */
8973 else if (indirect_base0 && indirect_base1
8974 /* We know that !operand_equal_p (base0, base1, 0)
8975 because the if condition was false. But make
8976 sure two decls are not the same. */
8978 && TREE_CODE (arg0) == ADDR_EXPR
8979 && TREE_CODE (arg1) == ADDR_EXPR
8980 && (((TREE_CODE (base0) == VAR_DECL
8981 || TREE_CODE (base0) == PARM_DECL)
8982 && (targetm.binds_local_p (base0)
8983 || CONSTANT_CLASS_P (base1)))
8984 || CONSTANT_CLASS_P (base0))
8985 && (((TREE_CODE (base1) == VAR_DECL
8986 || TREE_CODE (base1) == PARM_DECL)
8987 && (targetm.binds_local_p (base1)
8988 || CONSTANT_CLASS_P (base0)))
8989 || CONSTANT_CLASS_P (base1)))
8991 if (code == EQ_EXPR)
8992 return omit_two_operands_loc (loc, type, boolean_false_node,
8994 else if (code == NE_EXPR)
8995 return omit_two_operands_loc (loc, type, boolean_true_node,
8998 /* For equal offsets we can simplify to a comparison of the
9000 else if (bitpos0 == bitpos1
9002 ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
9004 ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
9005 && ((offset0 == offset1)
9006 || (offset0 && offset1
9007 && operand_equal_p (offset0, offset1, 0))))
9010 base0 = build_fold_addr_expr_loc (loc, base0);
9012 base1 = build_fold_addr_expr_loc (loc, base1);
9013 return fold_build2_loc (loc, code, type, base0, base1);
9017 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9018 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9019 the resulting offset is smaller in absolute value than the
9020 original one and has the same sign. */
9021 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9022 && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9023 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9024 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9025 && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
9026 && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9027 && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
9029 tree const1 = TREE_OPERAND (arg0, 1);
9030 tree const2 = TREE_OPERAND (arg1, 1);
9031 tree variable1 = TREE_OPERAND (arg0, 0);
9032 tree variable2 = TREE_OPERAND (arg1, 0);
9034 const char * const warnmsg = G_("assuming signed overflow does not "
9035 "occur when combining constants around "
9038 /* Put the constant on the side where it doesn't overflow and is
9039 of lower absolute value and of same sign than before. */
9040 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9041 ? MINUS_EXPR : PLUS_EXPR,
9043 if (!TREE_OVERFLOW (cst)
9044 && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2)
9045 && tree_int_cst_sgn (cst) == tree_int_cst_sgn (const2))
9047 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9048 return fold_build2_loc (loc, code, type,
9050 fold_build2_loc (loc, TREE_CODE (arg1),
9055 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9056 ? MINUS_EXPR : PLUS_EXPR,
9058 if (!TREE_OVERFLOW (cst)
9059 && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1)
9060 && tree_int_cst_sgn (cst) == tree_int_cst_sgn (const1))
9062 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9063 return fold_build2_loc (loc, code, type,
9064 fold_build2_loc (loc, TREE_CODE (arg0),
9071 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9072 signed arithmetic case. That form is created by the compiler
9073 often enough for folding it to be of value. One example is in
9074 computing loop trip counts after Operator Strength Reduction. */
9075 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9076 && TREE_CODE (arg0) == MULT_EXPR
9077 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9078 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9079 && integer_zerop (arg1))
9081 tree const1 = TREE_OPERAND (arg0, 1);
9082 tree const2 = arg1; /* zero */
9083 tree variable1 = TREE_OPERAND (arg0, 0);
9084 enum tree_code cmp_code = code;
9086 /* Handle unfolded multiplication by zero. */
9087 if (integer_zerop (const1))
9088 return fold_build2_loc (loc, cmp_code, type, const1, const2);
9090 fold_overflow_warning (("assuming signed overflow does not occur when "
9091 "eliminating multiplication in comparison "
9093 WARN_STRICT_OVERFLOW_COMPARISON);
9095 /* If const1 is negative we swap the sense of the comparison. */
9096 if (tree_int_cst_sgn (const1) < 0)
9097 cmp_code = swap_tree_comparison (cmp_code);
9099 return fold_build2_loc (loc, cmp_code, type, variable1, const2);
9102 tem = maybe_canonicalize_comparison (loc, code, type, arg0, arg1);
9106 if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
9108 tree targ0 = strip_float_extensions (arg0);
9109 tree targ1 = strip_float_extensions (arg1);
9110 tree newtype = TREE_TYPE (targ0);
9112 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
9113 newtype = TREE_TYPE (targ1);
9115 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9116 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
9117 return fold_build2_loc (loc, code, type,
9118 fold_convert_loc (loc, newtype, targ0),
9119 fold_convert_loc (loc, newtype, targ1));
9121 /* (-a) CMP (-b) -> b CMP a */
9122 if (TREE_CODE (arg0) == NEGATE_EXPR
9123 && TREE_CODE (arg1) == NEGATE_EXPR)
9124 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg1, 0),
9125 TREE_OPERAND (arg0, 0));
9127 if (TREE_CODE (arg1) == REAL_CST)
9129 REAL_VALUE_TYPE cst;
9130 cst = TREE_REAL_CST (arg1);
9132 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9133 if (TREE_CODE (arg0) == NEGATE_EXPR)
9134 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9135 TREE_OPERAND (arg0, 0),
9136 build_real (TREE_TYPE (arg1),
9137 real_value_negate (&cst)));
9139 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9140 /* a CMP (-0) -> a CMP 0 */
9141 if (REAL_VALUE_MINUS_ZERO (cst))
9142 return fold_build2_loc (loc, code, type, arg0,
9143 build_real (TREE_TYPE (arg1), dconst0));
9145 /* x != NaN is always true, other ops are always false. */
9146 if (REAL_VALUE_ISNAN (cst)
9147 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
9149 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
9150 return omit_one_operand_loc (loc, type, tem, arg0);
9153 /* Fold comparisons against infinity. */
9154 if (REAL_VALUE_ISINF (cst)
9155 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1))))
9157 tem = fold_inf_compare (loc, code, type, arg0, arg1);
9158 if (tem != NULL_TREE)
9163 /* If this is a comparison of a real constant with a PLUS_EXPR
9164 or a MINUS_EXPR of a real constant, we can convert it into a
9165 comparison with a revised real constant as long as no overflow
9166 occurs when unsafe_math_optimizations are enabled. */
9167 if (flag_unsafe_math_optimizations
9168 && TREE_CODE (arg1) == REAL_CST
9169 && (TREE_CODE (arg0) == PLUS_EXPR
9170 || TREE_CODE (arg0) == MINUS_EXPR)
9171 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
9172 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9173 ? MINUS_EXPR : PLUS_EXPR,
9174 arg1, TREE_OPERAND (arg0, 1)))
9175 && !TREE_OVERFLOW (tem))
9176 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
9178 /* Likewise, we can simplify a comparison of a real constant with
9179 a MINUS_EXPR whose first operand is also a real constant, i.e.
9180 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9181 floating-point types only if -fassociative-math is set. */
9182 if (flag_associative_math
9183 && TREE_CODE (arg1) == REAL_CST
9184 && TREE_CODE (arg0) == MINUS_EXPR
9185 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
9186 && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
9188 && !TREE_OVERFLOW (tem))
9189 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9190 TREE_OPERAND (arg0, 1), tem);
9192 /* Fold comparisons against built-in math functions. */
9193 if (TREE_CODE (arg1) == REAL_CST
9194 && flag_unsafe_math_optimizations
9195 && ! flag_errno_math)
9197 enum built_in_function fcode = builtin_mathfn_code (arg0);
9199 if (fcode != END_BUILTINS)
9201 tem = fold_mathfn_compare (loc, fcode, code, type, arg0, arg1);
9202 if (tem != NULL_TREE)
9208 if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
9209 && CONVERT_EXPR_P (arg0))
9211 /* If we are widening one operand of an integer comparison,
9212 see if the other operand is similarly being widened. Perhaps we
9213 can do the comparison in the narrower type. */
9214 tem = fold_widened_comparison (loc, code, type, arg0, arg1);
9218 /* Or if we are changing signedness. */
9219 tem = fold_sign_changed_comparison (loc, code, type, arg0, arg1);
9224 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9225 constant, we can simplify it. */
9226 if (TREE_CODE (arg1) == INTEGER_CST
9227 && (TREE_CODE (arg0) == MIN_EXPR
9228 || TREE_CODE (arg0) == MAX_EXPR)
9229 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9231 tem = optimize_minmax_comparison (loc, code, type, op0, op1);
9236 /* Simplify comparison of something with itself. (For IEEE
9237 floating-point, we can only do some of these simplifications.) */
9238 if (operand_equal_p (arg0, arg1, 0))
9243 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9244 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9245 return constant_boolean_node (1, type);
9250 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9251 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9252 return constant_boolean_node (1, type);
9253 return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg1);
9256 /* For NE, we can only do this simplification if integer
9257 or we don't honor IEEE floating point NaNs. */
9258 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9259 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9261 /* ... fall through ... */
9264 return constant_boolean_node (0, type);
9270 /* If we are comparing an expression that just has comparisons
9271 of two integer values, arithmetic expressions of those comparisons,
9272 and constants, we can simplify it. There are only three cases
9273 to check: the two values can either be equal, the first can be
9274 greater, or the second can be greater. Fold the expression for
9275 those three values. Since each value must be 0 or 1, we have
9276 eight possibilities, each of which corresponds to the constant 0
9277 or 1 or one of the six possible comparisons.
9279 This handles common cases like (a > b) == 0 but also handles
9280 expressions like ((x > y) - (y > x)) > 0, which supposedly
9281 occur in macroized code. */
9283 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9285 tree cval1 = 0, cval2 = 0;
9288 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9289 /* Don't handle degenerate cases here; they should already
9290 have been handled anyway. */
9291 && cval1 != 0 && cval2 != 0
9292 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9293 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9294 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9295 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9296 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9297 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9298 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9300 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9301 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9303 /* We can't just pass T to eval_subst in case cval1 or cval2
9304 was the same as ARG1. */
9307 = fold_build2_loc (loc, code, type,
9308 eval_subst (loc, arg0, cval1, maxval,
9312 = fold_build2_loc (loc, code, type,
9313 eval_subst (loc, arg0, cval1, maxval,
9317 = fold_build2_loc (loc, code, type,
9318 eval_subst (loc, arg0, cval1, minval,
9322 /* All three of these results should be 0 or 1. Confirm they are.
9323 Then use those values to select the proper code to use. */
9325 if (TREE_CODE (high_result) == INTEGER_CST
9326 && TREE_CODE (equal_result) == INTEGER_CST
9327 && TREE_CODE (low_result) == INTEGER_CST)
9329 /* Make a 3-bit mask with the high-order bit being the
9330 value for `>', the next for '=', and the low for '<'. */
9331 switch ((integer_onep (high_result) * 4)
9332 + (integer_onep (equal_result) * 2)
9333 + integer_onep (low_result))
9337 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
9358 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
9363 tem = save_expr (build2 (code, type, cval1, cval2));
9364 SET_EXPR_LOCATION (tem, loc);
9367 return fold_build2_loc (loc, code, type, cval1, cval2);
9372 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9373 into a single range test. */
9374 if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9375 || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9376 && TREE_CODE (arg1) == INTEGER_CST
9377 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9378 && !integer_zerop (TREE_OPERAND (arg0, 1))
9379 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9380 && !TREE_OVERFLOW (arg1))
9382 tem = fold_div_compare (loc, code, type, arg0, arg1);
9383 if (tem != NULL_TREE)
9387 /* Fold ~X op ~Y as Y op X. */
9388 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9389 && TREE_CODE (arg1) == BIT_NOT_EXPR)
9391 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9392 return fold_build2_loc (loc, code, type,
9393 fold_convert_loc (loc, cmp_type,
9394 TREE_OPERAND (arg1, 0)),
9395 TREE_OPERAND (arg0, 0));
9398 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9399 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9400 && (TREE_CODE (arg1) == INTEGER_CST || TREE_CODE (arg1) == VECTOR_CST))
9402 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9403 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9404 TREE_OPERAND (arg0, 0),
9405 fold_build1_loc (loc, BIT_NOT_EXPR, cmp_type,
9406 fold_convert_loc (loc, cmp_type, arg1)));
9413 /* Subroutine of fold_binary. Optimize complex multiplications of the
9414 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9415 argument EXPR represents the expression "z" of type TYPE. */
9418 fold_mult_zconjz (location_t loc, tree type, tree expr)
9420 tree itype = TREE_TYPE (type);
9421 tree rpart, ipart, tem;
9423 if (TREE_CODE (expr) == COMPLEX_EXPR)
9425 rpart = TREE_OPERAND (expr, 0);
9426 ipart = TREE_OPERAND (expr, 1);
9428 else if (TREE_CODE (expr) == COMPLEX_CST)
9430 rpart = TREE_REALPART (expr);
9431 ipart = TREE_IMAGPART (expr);
9435 expr = save_expr (expr);
9436 rpart = fold_build1_loc (loc, REALPART_EXPR, itype, expr);
9437 ipart = fold_build1_loc (loc, IMAGPART_EXPR, itype, expr);
9440 rpart = save_expr (rpart);
9441 ipart = save_expr (ipart);
9442 tem = fold_build2_loc (loc, PLUS_EXPR, itype,
9443 fold_build2_loc (loc, MULT_EXPR, itype, rpart, rpart),
9444 fold_build2_loc (loc, MULT_EXPR, itype, ipart, ipart));
9445 return fold_build2_loc (loc, COMPLEX_EXPR, type, tem,
9446 build_zero_cst (itype));
9450 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9451 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9452 guarantees that P and N have the same least significant log2(M) bits.
9453 N is not otherwise constrained. In particular, N is not normalized to
9454 0 <= N < M as is common. In general, the precise value of P is unknown.
9455 M is chosen as large as possible such that constant N can be determined.
9457 Returns M and sets *RESIDUE to N.
9459 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9460 account. This is not always possible due to PR 35705.
9463 static unsigned HOST_WIDE_INT
9464 get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue,
9465 bool allow_func_align)
9467 enum tree_code code;
9471 code = TREE_CODE (expr);
9472 if (code == ADDR_EXPR)
9474 unsigned int bitalign;
9475 get_object_alignment_1 (TREE_OPERAND (expr, 0), &bitalign, residue);
9476 *residue /= BITS_PER_UNIT;
9477 return bitalign / BITS_PER_UNIT;
9479 else if (code == POINTER_PLUS_EXPR)
9482 unsigned HOST_WIDE_INT modulus;
9483 enum tree_code inner_code;
9485 op0 = TREE_OPERAND (expr, 0);
9487 modulus = get_pointer_modulus_and_residue (op0, residue,
9490 op1 = TREE_OPERAND (expr, 1);
9492 inner_code = TREE_CODE (op1);
9493 if (inner_code == INTEGER_CST)
9495 *residue += TREE_INT_CST_LOW (op1);
9498 else if (inner_code == MULT_EXPR)
9500 op1 = TREE_OPERAND (op1, 1);
9501 if (TREE_CODE (op1) == INTEGER_CST)
9503 unsigned HOST_WIDE_INT align;
9505 /* Compute the greatest power-of-2 divisor of op1. */
9506 align = TREE_INT_CST_LOW (op1);
9509 /* If align is non-zero and less than *modulus, replace
9510 *modulus with align., If align is 0, then either op1 is 0
9511 or the greatest power-of-2 divisor of op1 doesn't fit in an
9512 unsigned HOST_WIDE_INT. In either case, no additional
9513 constraint is imposed. */
9515 modulus = MIN (modulus, align);
9522 /* If we get here, we were unable to determine anything useful about the
9527 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
9528 CONSTRUCTOR ARG into array ELTS and return true if successful. */
9531 vec_cst_ctor_to_array (tree arg, tree *elts)
9533 unsigned int nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg)), i;
9535 if (TREE_CODE (arg) == VECTOR_CST)
9537 for (i = 0; i < VECTOR_CST_NELTS (arg); ++i)
9538 elts[i] = VECTOR_CST_ELT (arg, i);
9540 else if (TREE_CODE (arg) == CONSTRUCTOR)
9542 constructor_elt *elt;
9544 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg), i, elt)
9545 if (i >= nelts || TREE_CODE (TREE_TYPE (elt->value)) == VECTOR_TYPE)
9548 elts[i] = elt->value;
9552 for (; i < nelts; i++)
9554 = fold_convert (TREE_TYPE (TREE_TYPE (arg)), integer_zero_node);
9558 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
9559 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
9560 NULL_TREE otherwise. */
9563 fold_vec_perm (tree type, tree arg0, tree arg1, const unsigned char *sel)
9565 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
9567 bool need_ctor = false;
9569 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts
9570 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts);
9571 if (TREE_TYPE (TREE_TYPE (arg0)) != TREE_TYPE (type)
9572 || TREE_TYPE (TREE_TYPE (arg1)) != TREE_TYPE (type))
9575 elts = XALLOCAVEC (tree, nelts * 3);
9576 if (!vec_cst_ctor_to_array (arg0, elts)
9577 || !vec_cst_ctor_to_array (arg1, elts + nelts))
9580 for (i = 0; i < nelts; i++)
9582 if (!CONSTANT_CLASS_P (elts[sel[i]]))
9584 elts[i + 2 * nelts] = unshare_expr (elts[sel[i]]);
9589 vec<constructor_elt, va_gc> *v;
9590 vec_alloc (v, nelts);
9591 for (i = 0; i < nelts; i++)
9592 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[2 * nelts + i]);
9593 return build_constructor (type, v);
9596 return build_vector (type, &elts[2 * nelts]);
9599 /* Try to fold a pointer difference of type TYPE two address expressions of
9600 array references AREF0 and AREF1 using location LOC. Return a
9601 simplified expression for the difference or NULL_TREE. */
9604 fold_addr_of_array_ref_difference (location_t loc, tree type,
9605 tree aref0, tree aref1)
9607 tree base0 = TREE_OPERAND (aref0, 0);
9608 tree base1 = TREE_OPERAND (aref1, 0);
9609 tree base_offset = build_int_cst (type, 0);
9611 /* If the bases are array references as well, recurse. If the bases
9612 are pointer indirections compute the difference of the pointers.
9613 If the bases are equal, we are set. */
9614 if ((TREE_CODE (base0) == ARRAY_REF
9615 && TREE_CODE (base1) == ARRAY_REF
9617 = fold_addr_of_array_ref_difference (loc, type, base0, base1)))
9618 || (INDIRECT_REF_P (base0)
9619 && INDIRECT_REF_P (base1)
9620 && (base_offset = fold_binary_loc (loc, MINUS_EXPR, type,
9621 TREE_OPERAND (base0, 0),
9622 TREE_OPERAND (base1, 0))))
9623 || operand_equal_p (base0, base1, 0))
9625 tree op0 = fold_convert_loc (loc, type, TREE_OPERAND (aref0, 1));
9626 tree op1 = fold_convert_loc (loc, type, TREE_OPERAND (aref1, 1));
9627 tree esz = fold_convert_loc (loc, type, array_ref_element_size (aref0));
9628 tree diff = build2 (MINUS_EXPR, type, op0, op1);
9629 return fold_build2_loc (loc, PLUS_EXPR, type,
9631 fold_build2_loc (loc, MULT_EXPR, type,
9637 /* If the real or vector real constant CST of type TYPE has an exact
9638 inverse, return it, else return NULL. */
9641 exact_inverse (tree type, tree cst)
9644 tree unit_type, *elts;
9646 unsigned vec_nelts, i;
9648 switch (TREE_CODE (cst))
9651 r = TREE_REAL_CST (cst);
9653 if (exact_real_inverse (TYPE_MODE (type), &r))
9654 return build_real (type, r);
9659 vec_nelts = VECTOR_CST_NELTS (cst);
9660 elts = XALLOCAVEC (tree, vec_nelts);
9661 unit_type = TREE_TYPE (type);
9662 mode = TYPE_MODE (unit_type);
9664 for (i = 0; i < vec_nelts; i++)
9666 r = TREE_REAL_CST (VECTOR_CST_ELT (cst, i));
9667 if (!exact_real_inverse (mode, &r))
9669 elts[i] = build_real (unit_type, r);
9672 return build_vector (type, elts);
9679 /* Mask out the tz least significant bits of X of type TYPE where
9680 tz is the number of trailing zeroes in Y. */
9682 mask_with_tz (tree type, const wide_int &x, const wide_int &y)
9684 int tz = wi::ctz (y);
9686 return wi::mask (tz, true, TYPE_PRECISION (type)) & x;
9690 /* Return true when T is an address and is known to be nonzero.
9691 For floating point we further ensure that T is not denormal.
9692 Similar logic is present in nonzero_address in rtlanal.h.
9694 If the return value is based on the assumption that signed overflow
9695 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9696 change *STRICT_OVERFLOW_P. */
9699 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
9701 tree type = TREE_TYPE (t);
9702 enum tree_code code;
9704 /* Doing something useful for floating point would need more work. */
9705 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9708 code = TREE_CODE (t);
9709 switch (TREE_CODE_CLASS (code))
9712 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
9715 case tcc_comparison:
9716 return tree_binary_nonzero_warnv_p (code, type,
9717 TREE_OPERAND (t, 0),
9718 TREE_OPERAND (t, 1),
9721 case tcc_declaration:
9723 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
9731 case TRUTH_NOT_EXPR:
9732 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
9735 case TRUTH_AND_EXPR:
9737 case TRUTH_XOR_EXPR:
9738 return tree_binary_nonzero_warnv_p (code, type,
9739 TREE_OPERAND (t, 0),
9740 TREE_OPERAND (t, 1),
9748 case WITH_SIZE_EXPR:
9750 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
9755 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
9759 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
9764 tree fndecl = get_callee_fndecl (t);
9765 if (!fndecl) return false;
9766 if (flag_delete_null_pointer_checks && !flag_check_new
9767 && DECL_IS_OPERATOR_NEW (fndecl)
9768 && !TREE_NOTHROW (fndecl))
9770 if (flag_delete_null_pointer_checks
9771 && lookup_attribute ("returns_nonnull",
9772 TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
9774 return alloca_call_p (t);
9783 /* Return true when T is an address and is known to be nonzero.
9784 Handle warnings about undefined signed overflow. */
9787 tree_expr_nonzero_p (tree t)
9789 bool ret, strict_overflow_p;
9791 strict_overflow_p = false;
9792 ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
9793 if (strict_overflow_p)
9794 fold_overflow_warning (("assuming signed overflow does not occur when "
9795 "determining that expression is always "
9797 WARN_STRICT_OVERFLOW_MISC);
9801 /* Fold a binary expression of code CODE and type TYPE with operands
9802 OP0 and OP1. LOC is the location of the resulting expression.
9803 Return the folded expression if folding is successful. Otherwise,
9804 return NULL_TREE. */
9807 fold_binary_loc (location_t loc,
9808 enum tree_code code, tree type, tree op0, tree op1)
9810 enum tree_code_class kind = TREE_CODE_CLASS (code);
9811 tree arg0, arg1, tem;
9812 tree t1 = NULL_TREE;
9813 bool strict_overflow_p;
9816 gcc_assert (IS_EXPR_CODE_CLASS (kind)
9817 && TREE_CODE_LENGTH (code) == 2
9819 && op1 != NULL_TREE);
9824 /* Strip any conversions that don't change the mode. This is
9825 safe for every expression, except for a comparison expression
9826 because its signedness is derived from its operands. So, in
9827 the latter case, only strip conversions that don't change the
9828 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9831 Note that this is done as an internal manipulation within the
9832 constant folder, in order to find the simplest representation
9833 of the arguments so that their form can be studied. In any
9834 cases, the appropriate type conversions should be put back in
9835 the tree that will get out of the constant folder. */
9837 if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
9839 STRIP_SIGN_NOPS (arg0);
9840 STRIP_SIGN_NOPS (arg1);
9848 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9849 constant but we can't do arithmetic on them. */
9850 if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9851 || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
9852 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == FIXED_CST)
9853 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == INTEGER_CST)
9854 || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
9855 || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
9856 || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == INTEGER_CST))
9858 if (kind == tcc_binary)
9860 /* Make sure type and arg0 have the same saturating flag. */
9861 gcc_assert (TYPE_SATURATING (type)
9862 == TYPE_SATURATING (TREE_TYPE (arg0)));
9863 tem = const_binop (code, arg0, arg1);
9865 else if (kind == tcc_comparison)
9866 tem = fold_relational_const (code, type, arg0, arg1);
9870 if (tem != NULL_TREE)
9872 if (TREE_TYPE (tem) != type)
9873 tem = fold_convert_loc (loc, type, tem);
9878 /* If this is a commutative operation, and ARG0 is a constant, move it
9879 to ARG1 to reduce the number of tests below. */
9880 if (commutative_tree_code (code)
9881 && tree_swap_operands_p (arg0, arg1, true))
9882 return fold_build2_loc (loc, code, type, op1, op0);
9884 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9885 to ARG1 to reduce the number of tests below. */
9886 if (kind == tcc_comparison
9887 && tree_swap_operands_p (arg0, arg1, true))
9888 return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
9890 tem = generic_simplify (loc, code, type, op0, op1);
9894 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9896 First check for cases where an arithmetic operation is applied to a
9897 compound, conditional, or comparison operation. Push the arithmetic
9898 operation inside the compound or conditional to see if any folding
9899 can then be done. Convert comparison to conditional for this purpose.
9900 The also optimizes non-constant cases that used to be done in
9903 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9904 one of the operands is a comparison and the other is a comparison, a
9905 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9906 code below would make the expression more complex. Change it to a
9907 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9908 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9910 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9911 || code == EQ_EXPR || code == NE_EXPR)
9912 && TREE_CODE (type) != VECTOR_TYPE
9913 && ((truth_value_p (TREE_CODE (arg0))
9914 && (truth_value_p (TREE_CODE (arg1))
9915 || (TREE_CODE (arg1) == BIT_AND_EXPR
9916 && integer_onep (TREE_OPERAND (arg1, 1)))))
9917 || (truth_value_p (TREE_CODE (arg1))
9918 && (truth_value_p (TREE_CODE (arg0))
9919 || (TREE_CODE (arg0) == BIT_AND_EXPR
9920 && integer_onep (TREE_OPERAND (arg0, 1)))))))
9922 tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9923 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9926 fold_convert_loc (loc, boolean_type_node, arg0),
9927 fold_convert_loc (loc, boolean_type_node, arg1));
9929 if (code == EQ_EXPR)
9930 tem = invert_truthvalue_loc (loc, tem);
9932 return fold_convert_loc (loc, type, tem);
9935 if (TREE_CODE_CLASS (code) == tcc_binary
9936 || TREE_CODE_CLASS (code) == tcc_comparison)
9938 if (TREE_CODE (arg0) == COMPOUND_EXPR)
9940 tem = fold_build2_loc (loc, code, type,
9941 fold_convert_loc (loc, TREE_TYPE (op0),
9942 TREE_OPERAND (arg0, 1)), op1);
9943 return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9946 if (TREE_CODE (arg1) == COMPOUND_EXPR
9947 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9949 tem = fold_build2_loc (loc, code, type, op0,
9950 fold_convert_loc (loc, TREE_TYPE (op1),
9951 TREE_OPERAND (arg1, 1)));
9952 return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9956 if (TREE_CODE (arg0) == COND_EXPR
9957 || TREE_CODE (arg0) == VEC_COND_EXPR
9958 || COMPARISON_CLASS_P (arg0))
9960 tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9962 /*cond_first_p=*/1);
9963 if (tem != NULL_TREE)
9967 if (TREE_CODE (arg1) == COND_EXPR
9968 || TREE_CODE (arg1) == VEC_COND_EXPR
9969 || COMPARISON_CLASS_P (arg1))
9971 tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9973 /*cond_first_p=*/0);
9974 if (tem != NULL_TREE)
9982 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9983 if (TREE_CODE (arg0) == ADDR_EXPR
9984 && TREE_CODE (TREE_OPERAND (arg0, 0)) == MEM_REF)
9986 tree iref = TREE_OPERAND (arg0, 0);
9987 return fold_build2 (MEM_REF, type,
9988 TREE_OPERAND (iref, 0),
9989 int_const_binop (PLUS_EXPR, arg1,
9990 TREE_OPERAND (iref, 1)));
9993 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9994 if (TREE_CODE (arg0) == ADDR_EXPR
9995 && handled_component_p (TREE_OPERAND (arg0, 0)))
9998 HOST_WIDE_INT coffset;
9999 base = get_addr_base_and_unit_offset (TREE_OPERAND (arg0, 0),
10003 return fold_build2 (MEM_REF, type,
10004 build_fold_addr_expr (base),
10005 int_const_binop (PLUS_EXPR, arg1,
10006 size_int (coffset)));
10011 case POINTER_PLUS_EXPR:
10012 /* 0 +p index -> (type)index */
10013 if (integer_zerop (arg0))
10014 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10016 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
10017 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10018 && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
10019 return fold_convert_loc (loc, type,
10020 fold_build2_loc (loc, PLUS_EXPR, sizetype,
10021 fold_convert_loc (loc, sizetype,
10023 fold_convert_loc (loc, sizetype,
10026 /* (PTR +p B) +p A -> PTR +p (B + A) */
10027 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10030 tree arg01 = fold_convert_loc (loc, sizetype, TREE_OPERAND (arg0, 1));
10031 tree arg00 = TREE_OPERAND (arg0, 0);
10032 inner = fold_build2_loc (loc, PLUS_EXPR, sizetype,
10033 arg01, fold_convert_loc (loc, sizetype, arg1));
10034 return fold_convert_loc (loc, type,
10035 fold_build_pointer_plus_loc (loc,
10039 /* PTR_CST +p CST -> CST1 */
10040 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
10041 return fold_build2_loc (loc, PLUS_EXPR, type, arg0,
10042 fold_convert_loc (loc, type, arg1));
10047 /* A + (-B) -> A - B */
10048 if (TREE_CODE (arg1) == NEGATE_EXPR
10049 && (flag_sanitize & SANITIZE_SI_OVERFLOW) == 0)
10050 return fold_build2_loc (loc, MINUS_EXPR, type,
10051 fold_convert_loc (loc, type, arg0),
10052 fold_convert_loc (loc, type,
10053 TREE_OPERAND (arg1, 0)));
10054 /* (-A) + B -> B - A */
10055 if (TREE_CODE (arg0) == NEGATE_EXPR
10056 && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1)
10057 && (flag_sanitize & SANITIZE_SI_OVERFLOW) == 0)
10058 return fold_build2_loc (loc, MINUS_EXPR, type,
10059 fold_convert_loc (loc, type, arg1),
10060 fold_convert_loc (loc, type,
10061 TREE_OPERAND (arg0, 0)));
10063 if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
10065 /* Convert ~A + 1 to -A. */
10066 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10067 && integer_each_onep (arg1))
10068 return fold_build1_loc (loc, NEGATE_EXPR, type,
10069 fold_convert_loc (loc, type,
10070 TREE_OPERAND (arg0, 0)));
10072 /* ~X + X is -1. */
10073 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10074 && !TYPE_OVERFLOW_TRAPS (type))
10076 tree tem = TREE_OPERAND (arg0, 0);
10079 if (operand_equal_p (tem, arg1, 0))
10081 t1 = build_all_ones_cst (type);
10082 return omit_one_operand_loc (loc, type, t1, arg1);
10086 /* X + ~X is -1. */
10087 if (TREE_CODE (arg1) == BIT_NOT_EXPR
10088 && !TYPE_OVERFLOW_TRAPS (type))
10090 tree tem = TREE_OPERAND (arg1, 0);
10093 if (operand_equal_p (arg0, tem, 0))
10095 t1 = build_all_ones_cst (type);
10096 return omit_one_operand_loc (loc, type, t1, arg0);
10100 /* X + (X / CST) * -CST is X % CST. */
10101 if (TREE_CODE (arg1) == MULT_EXPR
10102 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10103 && operand_equal_p (arg0,
10104 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
10106 tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
10107 tree cst1 = TREE_OPERAND (arg1, 1);
10108 tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (cst1),
10110 if (sum && integer_zerop (sum))
10111 return fold_convert_loc (loc, type,
10112 fold_build2_loc (loc, TRUNC_MOD_EXPR,
10113 TREE_TYPE (arg0), arg0,
10118 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
10119 one. Make sure the type is not saturating and has the signedness of
10120 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10121 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10122 if ((TREE_CODE (arg0) == MULT_EXPR
10123 || TREE_CODE (arg1) == MULT_EXPR)
10124 && !TYPE_SATURATING (type)
10125 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
10126 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
10127 && (!FLOAT_TYPE_P (type) || flag_associative_math))
10129 tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
10134 if (! FLOAT_TYPE_P (type))
10136 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10137 with a constant, and the two constants have no bits in common,
10138 we should treat this as a BIT_IOR_EXPR since this may produce more
10139 simplifications. */
10140 if (TREE_CODE (arg0) == BIT_AND_EXPR
10141 && TREE_CODE (arg1) == BIT_AND_EXPR
10142 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10143 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
10144 && wi::bit_and (TREE_OPERAND (arg0, 1),
10145 TREE_OPERAND (arg1, 1)) == 0)
10147 code = BIT_IOR_EXPR;
10151 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10152 (plus (plus (mult) (mult)) (foo)) so that we can
10153 take advantage of the factoring cases below. */
10154 if (TYPE_OVERFLOW_WRAPS (type)
10155 && (((TREE_CODE (arg0) == PLUS_EXPR
10156 || TREE_CODE (arg0) == MINUS_EXPR)
10157 && TREE_CODE (arg1) == MULT_EXPR)
10158 || ((TREE_CODE (arg1) == PLUS_EXPR
10159 || TREE_CODE (arg1) == MINUS_EXPR)
10160 && TREE_CODE (arg0) == MULT_EXPR)))
10162 tree parg0, parg1, parg, marg;
10163 enum tree_code pcode;
10165 if (TREE_CODE (arg1) == MULT_EXPR)
10166 parg = arg0, marg = arg1;
10168 parg = arg1, marg = arg0;
10169 pcode = TREE_CODE (parg);
10170 parg0 = TREE_OPERAND (parg, 0);
10171 parg1 = TREE_OPERAND (parg, 1);
10172 STRIP_NOPS (parg0);
10173 STRIP_NOPS (parg1);
10175 if (TREE_CODE (parg0) == MULT_EXPR
10176 && TREE_CODE (parg1) != MULT_EXPR)
10177 return fold_build2_loc (loc, pcode, type,
10178 fold_build2_loc (loc, PLUS_EXPR, type,
10179 fold_convert_loc (loc, type,
10181 fold_convert_loc (loc, type,
10183 fold_convert_loc (loc, type, parg1));
10184 if (TREE_CODE (parg0) != MULT_EXPR
10185 && TREE_CODE (parg1) == MULT_EXPR)
10187 fold_build2_loc (loc, PLUS_EXPR, type,
10188 fold_convert_loc (loc, type, parg0),
10189 fold_build2_loc (loc, pcode, type,
10190 fold_convert_loc (loc, type, marg),
10191 fold_convert_loc (loc, type,
10197 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10198 if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
10199 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10201 /* Likewise if the operands are reversed. */
10202 if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10203 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10205 /* Convert X + -C into X - C. */
10206 if (TREE_CODE (arg1) == REAL_CST
10207 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
10209 tem = fold_negate_const (arg1, type);
10210 if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
10211 return fold_build2_loc (loc, MINUS_EXPR, type,
10212 fold_convert_loc (loc, type, arg0),
10213 fold_convert_loc (loc, type, tem));
10216 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10217 to __complex__ ( x, y ). This is not the same for SNaNs or
10218 if signed zeros are involved. */
10219 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10220 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10221 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10223 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10224 tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10225 tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10226 bool arg0rz = false, arg0iz = false;
10227 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10228 || (arg0i && (arg0iz = real_zerop (arg0i))))
10230 tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10231 tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10232 if (arg0rz && arg1i && real_zerop (arg1i))
10234 tree rp = arg1r ? arg1r
10235 : build1 (REALPART_EXPR, rtype, arg1);
10236 tree ip = arg0i ? arg0i
10237 : build1 (IMAGPART_EXPR, rtype, arg0);
10238 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10240 else if (arg0iz && arg1r && real_zerop (arg1r))
10242 tree rp = arg0r ? arg0r
10243 : build1 (REALPART_EXPR, rtype, arg0);
10244 tree ip = arg1i ? arg1i
10245 : build1 (IMAGPART_EXPR, rtype, arg1);
10246 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10251 if (flag_unsafe_math_optimizations
10252 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10253 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10254 && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
10257 /* Convert x+x into x*2.0. */
10258 if (operand_equal_p (arg0, arg1, 0)
10259 && SCALAR_FLOAT_TYPE_P (type))
10260 return fold_build2_loc (loc, MULT_EXPR, type, arg0,
10261 build_real (type, dconst2));
10263 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10264 We associate floats only if the user has specified
10265 -fassociative-math. */
10266 if (flag_associative_math
10267 && TREE_CODE (arg1) == PLUS_EXPR
10268 && TREE_CODE (arg0) != MULT_EXPR)
10270 tree tree10 = TREE_OPERAND (arg1, 0);
10271 tree tree11 = TREE_OPERAND (arg1, 1);
10272 if (TREE_CODE (tree11) == MULT_EXPR
10273 && TREE_CODE (tree10) == MULT_EXPR)
10276 tree0 = fold_build2_loc (loc, PLUS_EXPR, type, arg0, tree10);
10277 return fold_build2_loc (loc, PLUS_EXPR, type, tree0, tree11);
10280 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10281 We associate floats only if the user has specified
10282 -fassociative-math. */
10283 if (flag_associative_math
10284 && TREE_CODE (arg0) == PLUS_EXPR
10285 && TREE_CODE (arg1) != MULT_EXPR)
10287 tree tree00 = TREE_OPERAND (arg0, 0);
10288 tree tree01 = TREE_OPERAND (arg0, 1);
10289 if (TREE_CODE (tree01) == MULT_EXPR
10290 && TREE_CODE (tree00) == MULT_EXPR)
10293 tree0 = fold_build2_loc (loc, PLUS_EXPR, type, tree01, arg1);
10294 return fold_build2_loc (loc, PLUS_EXPR, type, tree00, tree0);
10300 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10301 is a rotate of A by C1 bits. */
10302 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10303 is a rotate of A by B bits. */
10305 enum tree_code code0, code1;
10307 code0 = TREE_CODE (arg0);
10308 code1 = TREE_CODE (arg1);
10309 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
10310 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
10311 && operand_equal_p (TREE_OPERAND (arg0, 0),
10312 TREE_OPERAND (arg1, 0), 0)
10313 && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
10314 TYPE_UNSIGNED (rtype))
10315 /* Only create rotates in complete modes. Other cases are not
10316 expanded properly. */
10317 && (element_precision (rtype)
10318 == element_precision (TYPE_MODE (rtype))))
10320 tree tree01, tree11;
10321 enum tree_code code01, code11;
10323 tree01 = TREE_OPERAND (arg0, 1);
10324 tree11 = TREE_OPERAND (arg1, 1);
10325 STRIP_NOPS (tree01);
10326 STRIP_NOPS (tree11);
10327 code01 = TREE_CODE (tree01);
10328 code11 = TREE_CODE (tree11);
10329 if (code01 == INTEGER_CST
10330 && code11 == INTEGER_CST
10331 && (wi::to_widest (tree01) + wi::to_widest (tree11)
10332 == element_precision (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
10334 tem = build2_loc (loc, LROTATE_EXPR,
10335 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10336 TREE_OPERAND (arg0, 0),
10337 code0 == LSHIFT_EXPR ? tree01 : tree11);
10338 return fold_convert_loc (loc, type, tem);
10340 else if (code11 == MINUS_EXPR)
10342 tree tree110, tree111;
10343 tree110 = TREE_OPERAND (tree11, 0);
10344 tree111 = TREE_OPERAND (tree11, 1);
10345 STRIP_NOPS (tree110);
10346 STRIP_NOPS (tree111);
10347 if (TREE_CODE (tree110) == INTEGER_CST
10348 && 0 == compare_tree_int (tree110,
10350 (TREE_TYPE (TREE_OPERAND
10352 && operand_equal_p (tree01, tree111, 0))
10354 fold_convert_loc (loc, type,
10355 build2 ((code0 == LSHIFT_EXPR
10358 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10359 TREE_OPERAND (arg0, 0), tree01));
10361 else if (code01 == MINUS_EXPR)
10363 tree tree010, tree011;
10364 tree010 = TREE_OPERAND (tree01, 0);
10365 tree011 = TREE_OPERAND (tree01, 1);
10366 STRIP_NOPS (tree010);
10367 STRIP_NOPS (tree011);
10368 if (TREE_CODE (tree010) == INTEGER_CST
10369 && 0 == compare_tree_int (tree010,
10371 (TREE_TYPE (TREE_OPERAND
10373 && operand_equal_p (tree11, tree011, 0))
10374 return fold_convert_loc
10376 build2 ((code0 != LSHIFT_EXPR
10379 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10380 TREE_OPERAND (arg0, 0), tree11));
10386 /* In most languages, can't associate operations on floats through
10387 parentheses. Rather than remember where the parentheses were, we
10388 don't associate floats at all, unless the user has specified
10389 -fassociative-math.
10390 And, we need to make sure type is not saturating. */
10392 if ((! FLOAT_TYPE_P (type) || flag_associative_math)
10393 && !TYPE_SATURATING (type))
10395 tree var0, con0, lit0, minus_lit0;
10396 tree var1, con1, lit1, minus_lit1;
10400 /* Split both trees into variables, constants, and literals. Then
10401 associate each group together, the constants with literals,
10402 then the result with variables. This increases the chances of
10403 literals being recombined later and of generating relocatable
10404 expressions for the sum of a constant and literal. */
10405 var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
10406 var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
10407 code == MINUS_EXPR);
10409 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10410 if (code == MINUS_EXPR)
10413 /* With undefined overflow prefer doing association in a type
10414 which wraps on overflow, if that is one of the operand types. */
10415 if ((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10416 || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
10418 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
10419 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
10420 atype = TREE_TYPE (arg0);
10421 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10422 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
10423 atype = TREE_TYPE (arg1);
10424 gcc_assert (TYPE_PRECISION (atype) == TYPE_PRECISION (type));
10427 /* With undefined overflow we can only associate constants with one
10428 variable, and constants whose association doesn't overflow. */
10429 if ((POINTER_TYPE_P (atype) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10430 || (INTEGRAL_TYPE_P (atype) && !TYPE_OVERFLOW_WRAPS (atype)))
10437 if (TREE_CODE (tmp0) == NEGATE_EXPR)
10438 tmp0 = TREE_OPERAND (tmp0, 0);
10439 if (CONVERT_EXPR_P (tmp0)
10440 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
10441 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
10442 <= TYPE_PRECISION (atype)))
10443 tmp0 = TREE_OPERAND (tmp0, 0);
10444 if (TREE_CODE (tmp1) == NEGATE_EXPR)
10445 tmp1 = TREE_OPERAND (tmp1, 0);
10446 if (CONVERT_EXPR_P (tmp1)
10447 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
10448 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
10449 <= TYPE_PRECISION (atype)))
10450 tmp1 = TREE_OPERAND (tmp1, 0);
10451 /* The only case we can still associate with two variables
10452 is if they are the same, modulo negation and bit-pattern
10453 preserving conversions. */
10454 if (!operand_equal_p (tmp0, tmp1, 0))
10459 /* Only do something if we found more than two objects. Otherwise,
10460 nothing has changed and we risk infinite recursion. */
10462 && (2 < ((var0 != 0) + (var1 != 0)
10463 + (con0 != 0) + (con1 != 0)
10464 + (lit0 != 0) + (lit1 != 0)
10465 + (minus_lit0 != 0) + (minus_lit1 != 0))))
10467 bool any_overflows = false;
10468 if (lit0) any_overflows |= TREE_OVERFLOW (lit0);
10469 if (lit1) any_overflows |= TREE_OVERFLOW (lit1);
10470 if (minus_lit0) any_overflows |= TREE_OVERFLOW (minus_lit0);
10471 if (minus_lit1) any_overflows |= TREE_OVERFLOW (minus_lit1);
10472 var0 = associate_trees (loc, var0, var1, code, atype);
10473 con0 = associate_trees (loc, con0, con1, code, atype);
10474 lit0 = associate_trees (loc, lit0, lit1, code, atype);
10475 minus_lit0 = associate_trees (loc, minus_lit0, minus_lit1,
10478 /* Preserve the MINUS_EXPR if the negative part of the literal is
10479 greater than the positive part. Otherwise, the multiplicative
10480 folding code (i.e extract_muldiv) may be fooled in case
10481 unsigned constants are subtracted, like in the following
10482 example: ((X*2 + 4) - 8U)/2. */
10483 if (minus_lit0 && lit0)
10485 if (TREE_CODE (lit0) == INTEGER_CST
10486 && TREE_CODE (minus_lit0) == INTEGER_CST
10487 && tree_int_cst_lt (lit0, minus_lit0))
10489 minus_lit0 = associate_trees (loc, minus_lit0, lit0,
10490 MINUS_EXPR, atype);
10495 lit0 = associate_trees (loc, lit0, minus_lit0,
10496 MINUS_EXPR, atype);
10501 /* Don't introduce overflows through reassociation. */
10503 && ((lit0 && TREE_OVERFLOW (lit0))
10504 || (minus_lit0 && TREE_OVERFLOW (minus_lit0))))
10511 fold_convert_loc (loc, type,
10512 associate_trees (loc, var0, minus_lit0,
10513 MINUS_EXPR, atype));
10516 con0 = associate_trees (loc, con0, minus_lit0,
10517 MINUS_EXPR, atype);
10519 fold_convert_loc (loc, type,
10520 associate_trees (loc, var0, con0,
10521 PLUS_EXPR, atype));
10525 con0 = associate_trees (loc, con0, lit0, code, atype);
10527 fold_convert_loc (loc, type, associate_trees (loc, var0, con0,
10535 /* Pointer simplifications for subtraction, simple reassociations. */
10536 if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
10538 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10539 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
10540 && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10542 tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10543 tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10544 tree arg10 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10545 tree arg11 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10546 return fold_build2_loc (loc, PLUS_EXPR, type,
10547 fold_build2_loc (loc, MINUS_EXPR, type,
10549 fold_build2_loc (loc, MINUS_EXPR, type,
10552 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10553 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10555 tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10556 tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10557 tree tmp = fold_binary_loc (loc, MINUS_EXPR, type, arg00,
10558 fold_convert_loc (loc, type, arg1));
10560 return fold_build2_loc (loc, PLUS_EXPR, type, tmp, arg01);
10562 /* PTR0 - (PTR1 p+ A) -> (PTR0 - PTR1) - A, assuming PTR0 - PTR1
10564 else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10566 tree arg10 = fold_convert_loc (loc, type,
10567 TREE_OPERAND (arg1, 0));
10568 tree arg11 = fold_convert_loc (loc, type,
10569 TREE_OPERAND (arg1, 1));
10570 tree tmp = fold_binary_loc (loc, MINUS_EXPR, type,
10571 fold_convert_loc (loc, type, arg0),
10574 return fold_build2_loc (loc, MINUS_EXPR, type, tmp, arg11);
10577 /* A - (-B) -> A + B */
10578 if (TREE_CODE (arg1) == NEGATE_EXPR)
10579 return fold_build2_loc (loc, PLUS_EXPR, type, op0,
10580 fold_convert_loc (loc, type,
10581 TREE_OPERAND (arg1, 0)));
10582 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10583 if (TREE_CODE (arg0) == NEGATE_EXPR
10584 && negate_expr_p (arg1)
10585 && reorder_operands_p (arg0, arg1))
10586 return fold_build2_loc (loc, MINUS_EXPR, type,
10587 fold_convert_loc (loc, type,
10588 negate_expr (arg1)),
10589 fold_convert_loc (loc, type,
10590 TREE_OPERAND (arg0, 0)));
10591 /* Convert -A - 1 to ~A. */
10592 if (TREE_CODE (arg0) == NEGATE_EXPR
10593 && integer_each_onep (arg1)
10594 && !TYPE_OVERFLOW_TRAPS (type))
10595 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
10596 fold_convert_loc (loc, type,
10597 TREE_OPERAND (arg0, 0)));
10599 /* Convert -1 - A to ~A. */
10600 if (TREE_CODE (type) != COMPLEX_TYPE
10601 && integer_all_onesp (arg0))
10602 return fold_build1_loc (loc, BIT_NOT_EXPR, type, op1);
10605 /* X - (X / Y) * Y is X % Y. */
10606 if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
10607 && TREE_CODE (arg1) == MULT_EXPR
10608 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10609 && operand_equal_p (arg0,
10610 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
10611 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
10612 TREE_OPERAND (arg1, 1), 0))
10614 fold_convert_loc (loc, type,
10615 fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (arg0),
10616 arg0, TREE_OPERAND (arg1, 1)));
10618 if (! FLOAT_TYPE_P (type))
10620 if (integer_zerop (arg0))
10621 return negate_expr (fold_convert_loc (loc, type, arg1));
10623 /* Fold A - (A & B) into ~B & A. */
10624 if (!TREE_SIDE_EFFECTS (arg0)
10625 && TREE_CODE (arg1) == BIT_AND_EXPR)
10627 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
10629 tree arg10 = fold_convert_loc (loc, type,
10630 TREE_OPERAND (arg1, 0));
10631 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10632 fold_build1_loc (loc, BIT_NOT_EXPR,
10634 fold_convert_loc (loc, type, arg0));
10636 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10638 tree arg11 = fold_convert_loc (loc,
10639 type, TREE_OPERAND (arg1, 1));
10640 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10641 fold_build1_loc (loc, BIT_NOT_EXPR,
10643 fold_convert_loc (loc, type, arg0));
10647 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10648 any power of 2 minus 1. */
10649 if (TREE_CODE (arg0) == BIT_AND_EXPR
10650 && TREE_CODE (arg1) == BIT_AND_EXPR
10651 && operand_equal_p (TREE_OPERAND (arg0, 0),
10652 TREE_OPERAND (arg1, 0), 0))
10654 tree mask0 = TREE_OPERAND (arg0, 1);
10655 tree mask1 = TREE_OPERAND (arg1, 1);
10656 tree tem = fold_build1_loc (loc, BIT_NOT_EXPR, type, mask0);
10658 if (operand_equal_p (tem, mask1, 0))
10660 tem = fold_build2_loc (loc, BIT_XOR_EXPR, type,
10661 TREE_OPERAND (arg0, 0), mask1);
10662 return fold_build2_loc (loc, MINUS_EXPR, type, tem, mask1);
10667 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10668 else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
10669 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10671 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10672 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10673 (-ARG1 + ARG0) reduces to -ARG1. */
10674 else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10675 return negate_expr (fold_convert_loc (loc, type, arg1));
10677 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10678 __complex__ ( x, -y ). This is not the same for SNaNs or if
10679 signed zeros are involved. */
10680 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10681 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10682 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10684 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10685 tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10686 tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10687 bool arg0rz = false, arg0iz = false;
10688 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10689 || (arg0i && (arg0iz = real_zerop (arg0i))))
10691 tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10692 tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10693 if (arg0rz && arg1i && real_zerop (arg1i))
10695 tree rp = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10697 : build1 (REALPART_EXPR, rtype, arg1));
10698 tree ip = arg0i ? arg0i
10699 : build1 (IMAGPART_EXPR, rtype, arg0);
10700 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10702 else if (arg0iz && arg1r && real_zerop (arg1r))
10704 tree rp = arg0r ? arg0r
10705 : build1 (REALPART_EXPR, rtype, arg0);
10706 tree ip = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10708 : build1 (IMAGPART_EXPR, rtype, arg1));
10709 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10714 /* A - B -> A + (-B) if B is easily negatable. */
10715 if (negate_expr_p (arg1)
10716 && ((FLOAT_TYPE_P (type)
10717 /* Avoid this transformation if B is a positive REAL_CST. */
10718 && (TREE_CODE (arg1) != REAL_CST
10719 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
10720 || INTEGRAL_TYPE_P (type)))
10721 return fold_build2_loc (loc, PLUS_EXPR, type,
10722 fold_convert_loc (loc, type, arg0),
10723 fold_convert_loc (loc, type,
10724 negate_expr (arg1)));
10726 /* Try folding difference of addresses. */
10728 HOST_WIDE_INT diff;
10730 if ((TREE_CODE (arg0) == ADDR_EXPR
10731 || TREE_CODE (arg1) == ADDR_EXPR)
10732 && ptr_difference_const (arg0, arg1, &diff))
10733 return build_int_cst_type (type, diff);
10736 /* Fold &a[i] - &a[j] to i-j. */
10737 if (TREE_CODE (arg0) == ADDR_EXPR
10738 && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
10739 && TREE_CODE (arg1) == ADDR_EXPR
10740 && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
10742 tree tem = fold_addr_of_array_ref_difference (loc, type,
10743 TREE_OPERAND (arg0, 0),
10744 TREE_OPERAND (arg1, 0));
10749 if (FLOAT_TYPE_P (type)
10750 && flag_unsafe_math_optimizations
10751 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10752 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10753 && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
10756 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
10757 one. Make sure the type is not saturating and has the signedness of
10758 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10759 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10760 if ((TREE_CODE (arg0) == MULT_EXPR
10761 || TREE_CODE (arg1) == MULT_EXPR)
10762 && !TYPE_SATURATING (type)
10763 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
10764 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
10765 && (!FLOAT_TYPE_P (type) || flag_associative_math))
10767 tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
10775 /* (-A) * (-B) -> A * B */
10776 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10777 return fold_build2_loc (loc, MULT_EXPR, type,
10778 fold_convert_loc (loc, type,
10779 TREE_OPERAND (arg0, 0)),
10780 fold_convert_loc (loc, type,
10781 negate_expr (arg1)));
10782 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10783 return fold_build2_loc (loc, MULT_EXPR, type,
10784 fold_convert_loc (loc, type,
10785 negate_expr (arg0)),
10786 fold_convert_loc (loc, type,
10787 TREE_OPERAND (arg1, 0)));
10789 if (! FLOAT_TYPE_P (type))
10791 /* Transform x * -1 into -x. Make sure to do the negation
10792 on the original operand with conversions not stripped
10793 because we can only strip non-sign-changing conversions. */
10794 if (integer_minus_onep (arg1))
10795 return fold_convert_loc (loc, type, negate_expr (op0));
10796 /* Transform x * -C into -x * C if x is easily negatable. */
10797 if (TREE_CODE (arg1) == INTEGER_CST
10798 && tree_int_cst_sgn (arg1) == -1
10799 && negate_expr_p (arg0)
10800 && (tem = negate_expr (arg1)) != arg1
10801 && !TREE_OVERFLOW (tem))
10802 return fold_build2_loc (loc, MULT_EXPR, type,
10803 fold_convert_loc (loc, type,
10804 negate_expr (arg0)),
10807 /* (a * (1 << b)) is (a << b) */
10808 if (TREE_CODE (arg1) == LSHIFT_EXPR
10809 && integer_onep (TREE_OPERAND (arg1, 0)))
10810 return fold_build2_loc (loc, LSHIFT_EXPR, type, op0,
10811 TREE_OPERAND (arg1, 1));
10812 if (TREE_CODE (arg0) == LSHIFT_EXPR
10813 && integer_onep (TREE_OPERAND (arg0, 0)))
10814 return fold_build2_loc (loc, LSHIFT_EXPR, type, op1,
10815 TREE_OPERAND (arg0, 1));
10817 /* (A + A) * C -> A * 2 * C */
10818 if (TREE_CODE (arg0) == PLUS_EXPR
10819 && TREE_CODE (arg1) == INTEGER_CST
10820 && operand_equal_p (TREE_OPERAND (arg0, 0),
10821 TREE_OPERAND (arg0, 1), 0))
10822 return fold_build2_loc (loc, MULT_EXPR, type,
10823 omit_one_operand_loc (loc, type,
10824 TREE_OPERAND (arg0, 0),
10825 TREE_OPERAND (arg0, 1)),
10826 fold_build2_loc (loc, MULT_EXPR, type,
10827 build_int_cst (type, 2) , arg1));
10829 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
10830 sign-changing only. */
10831 if (TREE_CODE (arg1) == INTEGER_CST
10832 && TREE_CODE (arg0) == EXACT_DIV_EXPR
10833 && operand_equal_p (arg1, TREE_OPERAND (arg0, 1), 0))
10834 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10836 strict_overflow_p = false;
10837 if (TREE_CODE (arg1) == INTEGER_CST
10838 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10839 &strict_overflow_p)))
10841 if (strict_overflow_p)
10842 fold_overflow_warning (("assuming signed overflow does not "
10843 "occur when simplifying "
10845 WARN_STRICT_OVERFLOW_MISC);
10846 return fold_convert_loc (loc, type, tem);
10849 /* Optimize z * conj(z) for integer complex numbers. */
10850 if (TREE_CODE (arg0) == CONJ_EXPR
10851 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10852 return fold_mult_zconjz (loc, type, arg1);
10853 if (TREE_CODE (arg1) == CONJ_EXPR
10854 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10855 return fold_mult_zconjz (loc, type, arg0);
10859 /* Maybe fold x * 0 to 0. The expressions aren't the same
10860 when x is NaN, since x * 0 is also NaN. Nor are they the
10861 same in modes with signed zeros, since multiplying a
10862 negative value by 0 gives -0, not +0. */
10863 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10864 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10865 && real_zerop (arg1))
10866 return omit_one_operand_loc (loc, type, arg1, arg0);
10867 /* In IEEE floating point, x*1 is not equivalent to x for snans.
10868 Likewise for complex arithmetic with signed zeros. */
10869 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10870 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10871 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10872 && real_onep (arg1))
10873 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10875 /* Transform x * -1.0 into -x. */
10876 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10877 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10878 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10879 && real_minus_onep (arg1))
10880 return fold_convert_loc (loc, type, negate_expr (arg0));
10882 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
10883 the result for floating point types due to rounding so it is applied
10884 only if -fassociative-math was specify. */
10885 if (flag_associative_math
10886 && TREE_CODE (arg0) == RDIV_EXPR
10887 && TREE_CODE (arg1) == REAL_CST
10888 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
10890 tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
10893 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
10894 TREE_OPERAND (arg0, 1));
10897 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
10898 if (operand_equal_p (arg0, arg1, 0))
10900 tree tem = fold_strip_sign_ops (arg0);
10901 if (tem != NULL_TREE)
10903 tem = fold_convert_loc (loc, type, tem);
10904 return fold_build2_loc (loc, MULT_EXPR, type, tem, tem);
10908 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10909 This is not the same for NaNs or if signed zeros are
10911 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10912 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10913 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
10914 && TREE_CODE (arg1) == COMPLEX_CST
10915 && real_zerop (TREE_REALPART (arg1)))
10917 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10918 if (real_onep (TREE_IMAGPART (arg1)))
10920 fold_build2_loc (loc, COMPLEX_EXPR, type,
10921 negate_expr (fold_build1_loc (loc, IMAGPART_EXPR,
10923 fold_build1_loc (loc, REALPART_EXPR, rtype, arg0));
10924 else if (real_minus_onep (TREE_IMAGPART (arg1)))
10926 fold_build2_loc (loc, COMPLEX_EXPR, type,
10927 fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0),
10928 negate_expr (fold_build1_loc (loc, REALPART_EXPR,
10932 /* Optimize z * conj(z) for floating point complex numbers.
10933 Guarded by flag_unsafe_math_optimizations as non-finite
10934 imaginary components don't produce scalar results. */
10935 if (flag_unsafe_math_optimizations
10936 && TREE_CODE (arg0) == CONJ_EXPR
10937 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10938 return fold_mult_zconjz (loc, type, arg1);
10939 if (flag_unsafe_math_optimizations
10940 && TREE_CODE (arg1) == CONJ_EXPR
10941 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10942 return fold_mult_zconjz (loc, type, arg0);
10944 if (flag_unsafe_math_optimizations)
10946 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
10947 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
10949 /* Optimizations of root(...)*root(...). */
10950 if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
10953 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10954 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10956 /* Optimize sqrt(x)*sqrt(x) as x. */
10957 if (BUILTIN_SQRT_P (fcode0)
10958 && operand_equal_p (arg00, arg10, 0)
10959 && ! HONOR_SNANS (TYPE_MODE (type)))
10962 /* Optimize root(x)*root(y) as root(x*y). */
10963 rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10964 arg = fold_build2_loc (loc, MULT_EXPR, type, arg00, arg10);
10965 return build_call_expr_loc (loc, rootfn, 1, arg);
10968 /* Optimize expN(x)*expN(y) as expN(x+y). */
10969 if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
10971 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10972 tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
10973 CALL_EXPR_ARG (arg0, 0),
10974 CALL_EXPR_ARG (arg1, 0));
10975 return build_call_expr_loc (loc, expfn, 1, arg);
10978 /* Optimizations of pow(...)*pow(...). */
10979 if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
10980 || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
10981 || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
10983 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10984 tree arg01 = CALL_EXPR_ARG (arg0, 1);
10985 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10986 tree arg11 = CALL_EXPR_ARG (arg1, 1);
10988 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
10989 if (operand_equal_p (arg01, arg11, 0))
10991 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10992 tree arg = fold_build2_loc (loc, MULT_EXPR, type,
10994 return build_call_expr_loc (loc, powfn, 2, arg, arg01);
10997 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
10998 if (operand_equal_p (arg00, arg10, 0))
11000 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11001 tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
11003 return build_call_expr_loc (loc, powfn, 2, arg00, arg);
11007 /* Optimize tan(x)*cos(x) as sin(x). */
11008 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
11009 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
11010 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
11011 || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
11012 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
11013 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
11014 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11015 CALL_EXPR_ARG (arg1, 0), 0))
11017 tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
11019 if (sinfn != NULL_TREE)
11020 return build_call_expr_loc (loc, sinfn, 1,
11021 CALL_EXPR_ARG (arg0, 0));
11024 /* Optimize x*pow(x,c) as pow(x,c+1). */
11025 if (fcode1 == BUILT_IN_POW
11026 || fcode1 == BUILT_IN_POWF
11027 || fcode1 == BUILT_IN_POWL)
11029 tree arg10 = CALL_EXPR_ARG (arg1, 0);
11030 tree arg11 = CALL_EXPR_ARG (arg1, 1);
11031 if (TREE_CODE (arg11) == REAL_CST
11032 && !TREE_OVERFLOW (arg11)
11033 && operand_equal_p (arg0, arg10, 0))
11035 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11039 c = TREE_REAL_CST (arg11);
11040 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
11041 arg = build_real (type, c);
11042 return build_call_expr_loc (loc, powfn, 2, arg0, arg);
11046 /* Optimize pow(x,c)*x as pow(x,c+1). */
11047 if (fcode0 == BUILT_IN_POW
11048 || fcode0 == BUILT_IN_POWF
11049 || fcode0 == BUILT_IN_POWL)
11051 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11052 tree arg01 = CALL_EXPR_ARG (arg0, 1);
11053 if (TREE_CODE (arg01) == REAL_CST
11054 && !TREE_OVERFLOW (arg01)
11055 && operand_equal_p (arg1, arg00, 0))
11057 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11061 c = TREE_REAL_CST (arg01);
11062 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
11063 arg = build_real (type, c);
11064 return build_call_expr_loc (loc, powfn, 2, arg1, arg);
11068 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
11069 if (!in_gimple_form
11071 && operand_equal_p (arg0, arg1, 0))
11073 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
11077 tree arg = build_real (type, dconst2);
11078 return build_call_expr_loc (loc, powfn, 2, arg0, arg);
11087 /* ~X | X is -1. */
11088 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11089 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11091 t1 = build_zero_cst (type);
11092 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11093 return omit_one_operand_loc (loc, type, t1, arg1);
11096 /* X | ~X is -1. */
11097 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11098 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11100 t1 = build_zero_cst (type);
11101 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11102 return omit_one_operand_loc (loc, type, t1, arg0);
11105 /* Canonicalize (X & C1) | C2. */
11106 if (TREE_CODE (arg0) == BIT_AND_EXPR
11107 && TREE_CODE (arg1) == INTEGER_CST
11108 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11110 int width = TYPE_PRECISION (type), w;
11111 wide_int c1 = TREE_OPERAND (arg0, 1);
11112 wide_int c2 = arg1;
11114 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11115 if ((c1 & c2) == c1)
11116 return omit_one_operand_loc (loc, type, arg1,
11117 TREE_OPERAND (arg0, 0));
11119 wide_int msk = wi::mask (width, false,
11120 TYPE_PRECISION (TREE_TYPE (arg1)));
11122 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11123 if (msk.and_not (c1 | c2) == 0)
11124 return fold_build2_loc (loc, BIT_IOR_EXPR, type,
11125 TREE_OPERAND (arg0, 0), arg1);
11127 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11128 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11129 mode which allows further optimizations. */
11132 wide_int c3 = c1.and_not (c2);
11133 for (w = BITS_PER_UNIT; w <= width; w <<= 1)
11135 wide_int mask = wi::mask (w, false,
11136 TYPE_PRECISION (type));
11137 if (((c1 | c2) & mask) == mask && c1.and_not (mask) == 0)
11145 return fold_build2_loc (loc, BIT_IOR_EXPR, type,
11146 fold_build2_loc (loc, BIT_AND_EXPR, type,
11147 TREE_OPERAND (arg0, 0),
11148 wide_int_to_tree (type,
11153 /* (X & ~Y) | (~X & Y) is X ^ Y */
11154 if (TREE_CODE (arg0) == BIT_AND_EXPR
11155 && TREE_CODE (arg1) == BIT_AND_EXPR)
11157 tree a0, a1, l0, l1, n0, n1;
11159 a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11160 a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11162 l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11163 l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11165 n0 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l0);
11166 n1 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l1);
11168 if ((operand_equal_p (n0, a0, 0)
11169 && operand_equal_p (n1, a1, 0))
11170 || (operand_equal_p (n0, a1, 0)
11171 && operand_equal_p (n1, a0, 0)))
11172 return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
11175 t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
11176 if (t1 != NULL_TREE)
11179 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11181 This results in more efficient code for machines without a NAND
11182 instruction. Combine will canonicalize to the first form
11183 which will allow use of NAND instructions provided by the
11184 backend if they exist. */
11185 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11186 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11189 fold_build1_loc (loc, BIT_NOT_EXPR, type,
11190 build2 (BIT_AND_EXPR, type,
11191 fold_convert_loc (loc, type,
11192 TREE_OPERAND (arg0, 0)),
11193 fold_convert_loc (loc, type,
11194 TREE_OPERAND (arg1, 0))));
11197 /* See if this can be simplified into a rotate first. If that
11198 is unsuccessful continue in the association code. */
11202 /* ~X ^ X is -1. */
11203 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11204 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11206 t1 = build_zero_cst (type);
11207 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11208 return omit_one_operand_loc (loc, type, t1, arg1);
11211 /* X ^ ~X is -1. */
11212 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11213 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11215 t1 = build_zero_cst (type);
11216 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11217 return omit_one_operand_loc (loc, type, t1, arg0);
11220 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11221 with a constant, and the two constants have no bits in common,
11222 we should treat this as a BIT_IOR_EXPR since this may produce more
11223 simplifications. */
11224 if (TREE_CODE (arg0) == BIT_AND_EXPR
11225 && TREE_CODE (arg1) == BIT_AND_EXPR
11226 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11227 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
11228 && wi::bit_and (TREE_OPERAND (arg0, 1),
11229 TREE_OPERAND (arg1, 1)) == 0)
11231 code = BIT_IOR_EXPR;
11235 /* (X | Y) ^ X -> Y & ~ X*/
11236 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11237 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11239 tree t2 = TREE_OPERAND (arg0, 1);
11240 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
11242 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11243 fold_convert_loc (loc, type, t2),
11244 fold_convert_loc (loc, type, t1));
11248 /* (Y | X) ^ X -> Y & ~ X*/
11249 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11250 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11252 tree t2 = TREE_OPERAND (arg0, 0);
11253 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
11255 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11256 fold_convert_loc (loc, type, t2),
11257 fold_convert_loc (loc, type, t1));
11261 /* X ^ (X | Y) -> Y & ~ X*/
11262 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11263 && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
11265 tree t2 = TREE_OPERAND (arg1, 1);
11266 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
11268 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11269 fold_convert_loc (loc, type, t2),
11270 fold_convert_loc (loc, type, t1));
11274 /* X ^ (Y | X) -> Y & ~ X*/
11275 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11276 && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
11278 tree t2 = TREE_OPERAND (arg1, 0);
11279 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
11281 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11282 fold_convert_loc (loc, type, t2),
11283 fold_convert_loc (loc, type, t1));
11287 /* Convert ~X ^ ~Y to X ^ Y. */
11288 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11289 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11290 return fold_build2_loc (loc, code, type,
11291 fold_convert_loc (loc, type,
11292 TREE_OPERAND (arg0, 0)),
11293 fold_convert_loc (loc, type,
11294 TREE_OPERAND (arg1, 0)));
11296 /* Convert ~X ^ C to X ^ ~C. */
11297 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11298 && TREE_CODE (arg1) == INTEGER_CST)
11299 return fold_build2_loc (loc, code, type,
11300 fold_convert_loc (loc, type,
11301 TREE_OPERAND (arg0, 0)),
11302 fold_build1_loc (loc, BIT_NOT_EXPR, type, arg1));
11304 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11305 if (TREE_CODE (arg0) == BIT_AND_EXPR
11306 && INTEGRAL_TYPE_P (type)
11307 && integer_onep (TREE_OPERAND (arg0, 1))
11308 && integer_onep (arg1))
11309 return fold_build2_loc (loc, EQ_EXPR, type, arg0,
11310 build_zero_cst (TREE_TYPE (arg0)));
11312 /* Fold (X & Y) ^ Y as ~X & Y. */
11313 if (TREE_CODE (arg0) == BIT_AND_EXPR
11314 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11316 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11317 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11318 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11319 fold_convert_loc (loc, type, arg1));
11321 /* Fold (X & Y) ^ X as ~Y & X. */
11322 if (TREE_CODE (arg0) == BIT_AND_EXPR
11323 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11324 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11326 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11327 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11328 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11329 fold_convert_loc (loc, type, arg1));
11331 /* Fold X ^ (X & Y) as X & ~Y. */
11332 if (TREE_CODE (arg1) == BIT_AND_EXPR
11333 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11335 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11336 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11337 fold_convert_loc (loc, type, arg0),
11338 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
11340 /* Fold X ^ (Y & X) as ~Y & X. */
11341 if (TREE_CODE (arg1) == BIT_AND_EXPR
11342 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11343 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11345 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11346 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11347 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11348 fold_convert_loc (loc, type, arg0));
11351 /* See if this can be simplified into a rotate first. If that
11352 is unsuccessful continue in the association code. */
11356 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
11357 if ((TREE_CODE (arg0) == BIT_NOT_EXPR
11358 || TREE_CODE (arg0) == TRUTH_NOT_EXPR
11359 || (TREE_CODE (arg0) == EQ_EXPR
11360 && integer_zerop (TREE_OPERAND (arg0, 1))))
11361 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11362 return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
11364 /* X & ~X , X & (X == 0), and X & !X are always zero. */
11365 if ((TREE_CODE (arg1) == BIT_NOT_EXPR
11366 || TREE_CODE (arg1) == TRUTH_NOT_EXPR
11367 || (TREE_CODE (arg1) == EQ_EXPR
11368 && integer_zerop (TREE_OPERAND (arg1, 1))))
11369 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11370 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11372 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11373 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11374 && INTEGRAL_TYPE_P (type)
11375 && integer_onep (TREE_OPERAND (arg0, 1))
11376 && integer_onep (arg1))
11379 tem = TREE_OPERAND (arg0, 0);
11380 tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
11381 tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
11383 return fold_build2_loc (loc, EQ_EXPR, type, tem2,
11384 build_zero_cst (TREE_TYPE (tem)));
11386 /* Fold ~X & 1 as (X & 1) == 0. */
11387 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11388 && INTEGRAL_TYPE_P (type)
11389 && integer_onep (arg1))
11392 tem = TREE_OPERAND (arg0, 0);
11393 tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
11394 tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
11396 return fold_build2_loc (loc, EQ_EXPR, type, tem2,
11397 build_zero_cst (TREE_TYPE (tem)));
11399 /* Fold !X & 1 as X == 0. */
11400 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
11401 && integer_onep (arg1))
11403 tem = TREE_OPERAND (arg0, 0);
11404 return fold_build2_loc (loc, EQ_EXPR, type, tem,
11405 build_zero_cst (TREE_TYPE (tem)));
11408 /* Fold (X ^ Y) & Y as ~X & Y. */
11409 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11410 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11412 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11413 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11414 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11415 fold_convert_loc (loc, type, arg1));
11417 /* Fold (X ^ Y) & X as ~Y & X. */
11418 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11419 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11420 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11422 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11423 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11424 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11425 fold_convert_loc (loc, type, arg1));
11427 /* Fold X & (X ^ Y) as X & ~Y. */
11428 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11429 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11431 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11432 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11433 fold_convert_loc (loc, type, arg0),
11434 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
11436 /* Fold X & (Y ^ X) as ~Y & X. */
11437 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11438 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11439 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11441 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11442 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11443 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11444 fold_convert_loc (loc, type, arg0));
11447 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11448 multiple of 1 << CST. */
11449 if (TREE_CODE (arg1) == INTEGER_CST)
11451 wide_int cst1 = arg1;
11452 wide_int ncst1 = -cst1;
11453 if ((cst1 & ncst1) == ncst1
11454 && multiple_of_p (type, arg0,
11455 wide_int_to_tree (TREE_TYPE (arg1), ncst1)))
11456 return fold_convert_loc (loc, type, arg0);
11459 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
11461 if (TREE_CODE (arg1) == INTEGER_CST
11462 && TREE_CODE (arg0) == MULT_EXPR
11463 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11465 wide_int warg1 = arg1;
11466 wide_int masked = mask_with_tz (type, warg1, TREE_OPERAND (arg0, 1));
11469 return omit_two_operands_loc (loc, type, build_zero_cst (type),
11471 else if (masked != warg1)
11473 /* Avoid the transform if arg1 is a mask of some
11474 mode which allows further optimizations. */
11475 int pop = wi::popcount (warg1);
11476 if (!(pop >= BITS_PER_UNIT
11477 && exact_log2 (pop) != -1
11478 && wi::mask (pop, false, warg1.get_precision ()) == warg1))
11479 return fold_build2_loc (loc, code, type, op0,
11480 wide_int_to_tree (type, masked));
11484 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11485 ((A & N) + B) & M -> (A + B) & M
11486 Similarly if (N & M) == 0,
11487 ((A | N) + B) & M -> (A + B) & M
11488 and for - instead of + (or unary - instead of +)
11489 and/or ^ instead of |.
11490 If B is constant and (B & M) == 0, fold into A & M. */
11491 if (TREE_CODE (arg1) == INTEGER_CST)
11493 wide_int cst1 = arg1;
11494 if ((~cst1 != 0) && (cst1 & (cst1 + 1)) == 0
11495 && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
11496 && (TREE_CODE (arg0) == PLUS_EXPR
11497 || TREE_CODE (arg0) == MINUS_EXPR
11498 || TREE_CODE (arg0) == NEGATE_EXPR)
11499 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
11500 || TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE))
11506 /* Now we know that arg0 is (C + D) or (C - D) or
11507 -C and arg1 (M) is == (1LL << cst) - 1.
11508 Store C into PMOP[0] and D into PMOP[1]. */
11509 pmop[0] = TREE_OPERAND (arg0, 0);
11511 if (TREE_CODE (arg0) != NEGATE_EXPR)
11513 pmop[1] = TREE_OPERAND (arg0, 1);
11517 if ((wi::max_value (TREE_TYPE (arg0)) & cst1) != cst1)
11520 for (; which >= 0; which--)
11521 switch (TREE_CODE (pmop[which]))
11526 if (TREE_CODE (TREE_OPERAND (pmop[which], 1))
11529 cst0 = TREE_OPERAND (pmop[which], 1);
11531 if (TREE_CODE (pmop[which]) == BIT_AND_EXPR)
11536 else if (cst0 != 0)
11538 /* If C or D is of the form (A & N) where
11539 (N & M) == M, or of the form (A | N) or
11540 (A ^ N) where (N & M) == 0, replace it with A. */
11541 pmop[which] = TREE_OPERAND (pmop[which], 0);
11544 /* If C or D is a N where (N & M) == 0, it can be
11545 omitted (assumed 0). */
11546 if ((TREE_CODE (arg0) == PLUS_EXPR
11547 || (TREE_CODE (arg0) == MINUS_EXPR && which == 0))
11548 && (cst1 & pmop[which]) == 0)
11549 pmop[which] = NULL;
11555 /* Only build anything new if we optimized one or both arguments
11557 if (pmop[0] != TREE_OPERAND (arg0, 0)
11558 || (TREE_CODE (arg0) != NEGATE_EXPR
11559 && pmop[1] != TREE_OPERAND (arg0, 1)))
11561 tree utype = TREE_TYPE (arg0);
11562 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
11564 /* Perform the operations in a type that has defined
11565 overflow behavior. */
11566 utype = unsigned_type_for (TREE_TYPE (arg0));
11567 if (pmop[0] != NULL)
11568 pmop[0] = fold_convert_loc (loc, utype, pmop[0]);
11569 if (pmop[1] != NULL)
11570 pmop[1] = fold_convert_loc (loc, utype, pmop[1]);
11573 if (TREE_CODE (arg0) == NEGATE_EXPR)
11574 tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[0]);
11575 else if (TREE_CODE (arg0) == PLUS_EXPR)
11577 if (pmop[0] != NULL && pmop[1] != NULL)
11578 tem = fold_build2_loc (loc, PLUS_EXPR, utype,
11580 else if (pmop[0] != NULL)
11582 else if (pmop[1] != NULL)
11585 return build_int_cst (type, 0);
11587 else if (pmop[0] == NULL)
11588 tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[1]);
11590 tem = fold_build2_loc (loc, MINUS_EXPR, utype,
11592 /* TEM is now the new binary +, - or unary - replacement. */
11593 tem = fold_build2_loc (loc, BIT_AND_EXPR, utype, tem,
11594 fold_convert_loc (loc, utype, arg1));
11595 return fold_convert_loc (loc, type, tem);
11600 t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
11601 if (t1 != NULL_TREE)
11603 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11604 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
11605 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
11607 prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
11609 wide_int mask = wide_int::from (arg1, prec, UNSIGNED);
11612 fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11615 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11617 This results in more efficient code for machines without a NOR
11618 instruction. Combine will canonicalize to the first form
11619 which will allow use of NOR instructions provided by the
11620 backend if they exist. */
11621 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11622 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11624 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
11625 build2 (BIT_IOR_EXPR, type,
11626 fold_convert_loc (loc, type,
11627 TREE_OPERAND (arg0, 0)),
11628 fold_convert_loc (loc, type,
11629 TREE_OPERAND (arg1, 0))));
11632 /* If arg0 is derived from the address of an object or function, we may
11633 be able to fold this expression using the object or function's
11635 if (POINTER_TYPE_P (TREE_TYPE (arg0)) && tree_fits_uhwi_p (arg1))
11637 unsigned HOST_WIDE_INT modulus, residue;
11638 unsigned HOST_WIDE_INT low = tree_to_uhwi (arg1);
11640 modulus = get_pointer_modulus_and_residue (arg0, &residue,
11641 integer_onep (arg1));
11643 /* This works because modulus is a power of 2. If this weren't the
11644 case, we'd have to replace it by its greatest power-of-2
11645 divisor: modulus & -modulus. */
11647 return build_int_cst (type, residue & low);
11650 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11651 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11652 if the new mask might be further optimized. */
11653 if ((TREE_CODE (arg0) == LSHIFT_EXPR
11654 || TREE_CODE (arg0) == RSHIFT_EXPR)
11655 && TYPE_PRECISION (TREE_TYPE (arg0)) <= HOST_BITS_PER_WIDE_INT
11656 && TREE_CODE (arg1) == INTEGER_CST
11657 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
11658 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) > 0
11659 && (tree_to_uhwi (TREE_OPERAND (arg0, 1))
11660 < TYPE_PRECISION (TREE_TYPE (arg0))))
11662 unsigned int shiftc = tree_to_uhwi (TREE_OPERAND (arg0, 1));
11663 unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (arg1);
11664 unsigned HOST_WIDE_INT newmask, zerobits = 0;
11665 tree shift_type = TREE_TYPE (arg0);
11667 if (TREE_CODE (arg0) == LSHIFT_EXPR)
11668 zerobits = ((((unsigned HOST_WIDE_INT) 1) << shiftc) - 1);
11669 else if (TREE_CODE (arg0) == RSHIFT_EXPR
11670 && TYPE_PRECISION (TREE_TYPE (arg0))
11671 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg0))))
11673 prec = TYPE_PRECISION (TREE_TYPE (arg0));
11674 tree arg00 = TREE_OPERAND (arg0, 0);
11675 /* See if more bits can be proven as zero because of
11677 if (TREE_CODE (arg00) == NOP_EXPR
11678 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
11680 tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
11681 if (TYPE_PRECISION (inner_type)
11682 == GET_MODE_PRECISION (TYPE_MODE (inner_type))
11683 && TYPE_PRECISION (inner_type) < prec)
11685 prec = TYPE_PRECISION (inner_type);
11686 /* See if we can shorten the right shift. */
11688 shift_type = inner_type;
11689 /* Otherwise X >> C1 is all zeros, so we'll optimize
11690 it into (X, 0) later on by making sure zerobits
11694 zerobits = ~(unsigned HOST_WIDE_INT) 0;
11697 zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
11698 zerobits <<= prec - shiftc;
11700 /* For arithmetic shift if sign bit could be set, zerobits
11701 can contain actually sign bits, so no transformation is
11702 possible, unless MASK masks them all away. In that
11703 case the shift needs to be converted into logical shift. */
11704 if (!TYPE_UNSIGNED (TREE_TYPE (arg0))
11705 && prec == TYPE_PRECISION (TREE_TYPE (arg0)))
11707 if ((mask & zerobits) == 0)
11708 shift_type = unsigned_type_for (TREE_TYPE (arg0));
11714 /* ((X << 16) & 0xff00) is (X, 0). */
11715 if ((mask & zerobits) == mask)
11716 return omit_one_operand_loc (loc, type,
11717 build_int_cst (type, 0), arg0);
11719 newmask = mask | zerobits;
11720 if (newmask != mask && (newmask & (newmask + 1)) == 0)
11722 /* Only do the transformation if NEWMASK is some integer
11724 for (prec = BITS_PER_UNIT;
11725 prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
11726 if (newmask == (((unsigned HOST_WIDE_INT) 1) << prec) - 1)
11728 if (prec < HOST_BITS_PER_WIDE_INT
11729 || newmask == ~(unsigned HOST_WIDE_INT) 0)
11733 if (shift_type != TREE_TYPE (arg0))
11735 tem = fold_build2_loc (loc, TREE_CODE (arg0), shift_type,
11736 fold_convert_loc (loc, shift_type,
11737 TREE_OPERAND (arg0, 0)),
11738 TREE_OPERAND (arg0, 1));
11739 tem = fold_convert_loc (loc, type, tem);
11743 newmaskt = build_int_cst_type (TREE_TYPE (op1), newmask);
11744 if (!tree_int_cst_equal (newmaskt, arg1))
11745 return fold_build2_loc (loc, BIT_AND_EXPR, type, tem, newmaskt);
11753 /* Don't touch a floating-point divide by zero unless the mode
11754 of the constant can represent infinity. */
11755 if (TREE_CODE (arg1) == REAL_CST
11756 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
11757 && real_zerop (arg1))
11760 /* Optimize A / A to 1.0 if we don't care about
11761 NaNs or Infinities. Skip the transformation
11762 for non-real operands. */
11763 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
11764 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11765 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
11766 && operand_equal_p (arg0, arg1, 0))
11768 tree r = build_real (TREE_TYPE (arg0), dconst1);
11770 return omit_two_operands_loc (loc, type, r, arg0, arg1);
11773 /* The complex version of the above A / A optimization. */
11774 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
11775 && operand_equal_p (arg0, arg1, 0))
11777 tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
11778 if (! HONOR_NANS (TYPE_MODE (elem_type))
11779 && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
11781 tree r = build_real (elem_type, dconst1);
11782 /* omit_two_operands will call fold_convert for us. */
11783 return omit_two_operands_loc (loc, type, r, arg0, arg1);
11787 /* (-A) / (-B) -> A / B */
11788 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
11789 return fold_build2_loc (loc, RDIV_EXPR, type,
11790 TREE_OPERAND (arg0, 0),
11791 negate_expr (arg1));
11792 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
11793 return fold_build2_loc (loc, RDIV_EXPR, type,
11794 negate_expr (arg0),
11795 TREE_OPERAND (arg1, 0));
11797 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
11798 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11799 && real_onep (arg1))
11800 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11802 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
11803 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11804 && real_minus_onep (arg1))
11805 return non_lvalue_loc (loc, fold_convert_loc (loc, type,
11806 negate_expr (arg0)));
11808 /* If ARG1 is a constant, we can convert this to a multiply by the
11809 reciprocal. This does not have the same rounding properties,
11810 so only do this if -freciprocal-math. We can actually
11811 always safely do it if ARG1 is a power of two, but it's hard to
11812 tell if it is or not in a portable manner. */
11814 && (TREE_CODE (arg1) == REAL_CST
11815 || (TREE_CODE (arg1) == COMPLEX_CST
11816 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg1)))
11817 || (TREE_CODE (arg1) == VECTOR_CST
11818 && VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg1)))))
11820 if (flag_reciprocal_math
11821 && 0 != (tem = const_binop (code, build_one_cst (type), arg1)))
11822 return fold_build2_loc (loc, MULT_EXPR, type, arg0, tem);
11823 /* Find the reciprocal if optimizing and the result is exact.
11824 TODO: Complex reciprocal not implemented. */
11825 if (TREE_CODE (arg1) != COMPLEX_CST)
11827 tree inverse = exact_inverse (TREE_TYPE (arg0), arg1);
11830 return fold_build2_loc (loc, MULT_EXPR, type, arg0, inverse);
11833 /* Convert A/B/C to A/(B*C). */
11834 if (flag_reciprocal_math
11835 && TREE_CODE (arg0) == RDIV_EXPR)
11836 return fold_build2_loc (loc, RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
11837 fold_build2_loc (loc, MULT_EXPR, type,
11838 TREE_OPERAND (arg0, 1), arg1));
11840 /* Convert A/(B/C) to (A/B)*C. */
11841 if (flag_reciprocal_math
11842 && TREE_CODE (arg1) == RDIV_EXPR)
11843 return fold_build2_loc (loc, MULT_EXPR, type,
11844 fold_build2_loc (loc, RDIV_EXPR, type, arg0,
11845 TREE_OPERAND (arg1, 0)),
11846 TREE_OPERAND (arg1, 1));
11848 /* Convert C1/(X*C2) into (C1/C2)/X. */
11849 if (flag_reciprocal_math
11850 && TREE_CODE (arg1) == MULT_EXPR
11851 && TREE_CODE (arg0) == REAL_CST
11852 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
11854 tree tem = const_binop (RDIV_EXPR, arg0,
11855 TREE_OPERAND (arg1, 1));
11857 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
11858 TREE_OPERAND (arg1, 0));
11861 if (flag_unsafe_math_optimizations)
11863 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
11864 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
11866 /* Optimize sin(x)/cos(x) as tan(x). */
11867 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
11868 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
11869 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
11870 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11871 CALL_EXPR_ARG (arg1, 0), 0))
11873 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11875 if (tanfn != NULL_TREE)
11876 return build_call_expr_loc (loc, tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11879 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
11880 if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
11881 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
11882 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
11883 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11884 CALL_EXPR_ARG (arg1, 0), 0))
11886 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11888 if (tanfn != NULL_TREE)
11890 tree tmp = build_call_expr_loc (loc, tanfn, 1,
11891 CALL_EXPR_ARG (arg0, 0));
11892 return fold_build2_loc (loc, RDIV_EXPR, type,
11893 build_real (type, dconst1), tmp);
11897 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
11898 NaNs or Infinities. */
11899 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
11900 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
11901 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
11903 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11904 tree arg01 = CALL_EXPR_ARG (arg1, 0);
11906 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11907 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11908 && operand_equal_p (arg00, arg01, 0))
11910 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11912 if (cosfn != NULL_TREE)
11913 return build_call_expr_loc (loc, cosfn, 1, arg00);
11917 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
11918 NaNs or Infinities. */
11919 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
11920 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
11921 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
11923 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11924 tree arg01 = CALL_EXPR_ARG (arg1, 0);
11926 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11927 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11928 && operand_equal_p (arg00, arg01, 0))
11930 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11932 if (cosfn != NULL_TREE)
11934 tree tmp = build_call_expr_loc (loc, cosfn, 1, arg00);
11935 return fold_build2_loc (loc, RDIV_EXPR, type,
11936 build_real (type, dconst1),
11942 /* Optimize pow(x,c)/x as pow(x,c-1). */
11943 if (fcode0 == BUILT_IN_POW
11944 || fcode0 == BUILT_IN_POWF
11945 || fcode0 == BUILT_IN_POWL)
11947 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11948 tree arg01 = CALL_EXPR_ARG (arg0, 1);
11949 if (TREE_CODE (arg01) == REAL_CST
11950 && !TREE_OVERFLOW (arg01)
11951 && operand_equal_p (arg1, arg00, 0))
11953 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11957 c = TREE_REAL_CST (arg01);
11958 real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
11959 arg = build_real (type, c);
11960 return build_call_expr_loc (loc, powfn, 2, arg1, arg);
11964 /* Optimize a/root(b/c) into a*root(c/b). */
11965 if (BUILTIN_ROOT_P (fcode1))
11967 tree rootarg = CALL_EXPR_ARG (arg1, 0);
11969 if (TREE_CODE (rootarg) == RDIV_EXPR)
11971 tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11972 tree b = TREE_OPERAND (rootarg, 0);
11973 tree c = TREE_OPERAND (rootarg, 1);
11975 tree tmp = fold_build2_loc (loc, RDIV_EXPR, type, c, b);
11977 tmp = build_call_expr_loc (loc, rootfn, 1, tmp);
11978 return fold_build2_loc (loc, MULT_EXPR, type, arg0, tmp);
11982 /* Optimize x/expN(y) into x*expN(-y). */
11983 if (BUILTIN_EXPONENT_P (fcode1))
11985 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11986 tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
11987 arg1 = build_call_expr_loc (loc,
11989 fold_convert_loc (loc, type, arg));
11990 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
11993 /* Optimize x/pow(y,z) into x*pow(y,-z). */
11994 if (fcode1 == BUILT_IN_POW
11995 || fcode1 == BUILT_IN_POWF
11996 || fcode1 == BUILT_IN_POWL)
11998 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11999 tree arg10 = CALL_EXPR_ARG (arg1, 0);
12000 tree arg11 = CALL_EXPR_ARG (arg1, 1);
12001 tree neg11 = fold_convert_loc (loc, type,
12002 negate_expr (arg11));
12003 arg1 = build_call_expr_loc (loc, powfn, 2, arg10, neg11);
12004 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
12009 case TRUNC_DIV_EXPR:
12010 /* Optimize (X & (-A)) / A where A is a power of 2,
12012 if (TREE_CODE (arg0) == BIT_AND_EXPR
12013 && !TYPE_UNSIGNED (type) && TREE_CODE (arg1) == INTEGER_CST
12014 && integer_pow2p (arg1) && tree_int_cst_sgn (arg1) > 0)
12016 tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (arg1),
12017 arg1, TREE_OPERAND (arg0, 1));
12018 if (sum && integer_zerop (sum)) {
12019 tree pow2 = build_int_cst (integer_type_node,
12020 wi::exact_log2 (arg1));
12021 return fold_build2_loc (loc, RSHIFT_EXPR, type,
12022 TREE_OPERAND (arg0, 0), pow2);
12028 case FLOOR_DIV_EXPR:
12029 /* Simplify A / (B << N) where A and B are positive and B is
12030 a power of 2, to A >> (N + log2(B)). */
12031 strict_overflow_p = false;
12032 if (TREE_CODE (arg1) == LSHIFT_EXPR
12033 && (TYPE_UNSIGNED (type)
12034 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
12036 tree sval = TREE_OPERAND (arg1, 0);
12037 if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
12039 tree sh_cnt = TREE_OPERAND (arg1, 1);
12040 tree pow2 = build_int_cst (TREE_TYPE (sh_cnt),
12041 wi::exact_log2 (sval));
12043 if (strict_overflow_p)
12044 fold_overflow_warning (("assuming signed overflow does not "
12045 "occur when simplifying A / (B << N)"),
12046 WARN_STRICT_OVERFLOW_MISC);
12048 sh_cnt = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (sh_cnt),
12050 return fold_build2_loc (loc, RSHIFT_EXPR, type,
12051 fold_convert_loc (loc, type, arg0), sh_cnt);
12055 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
12056 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
12057 if (INTEGRAL_TYPE_P (type)
12058 && TYPE_UNSIGNED (type)
12059 && code == FLOOR_DIV_EXPR)
12060 return fold_build2_loc (loc, TRUNC_DIV_EXPR, type, op0, op1);
12064 case ROUND_DIV_EXPR:
12065 case CEIL_DIV_EXPR:
12066 case EXACT_DIV_EXPR:
12067 if (integer_zerop (arg1))
12069 /* X / -1 is -X. */
12070 if (!TYPE_UNSIGNED (type)
12071 && TREE_CODE (arg1) == INTEGER_CST
12072 && wi::eq_p (arg1, -1))
12073 return fold_convert_loc (loc, type, negate_expr (arg0));
12075 /* Convert -A / -B to A / B when the type is signed and overflow is
12077 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12078 && TREE_CODE (arg0) == NEGATE_EXPR
12079 && negate_expr_p (arg1))
12081 if (INTEGRAL_TYPE_P (type))
12082 fold_overflow_warning (("assuming signed overflow does not occur "
12083 "when distributing negation across "
12085 WARN_STRICT_OVERFLOW_MISC);
12086 return fold_build2_loc (loc, code, type,
12087 fold_convert_loc (loc, type,
12088 TREE_OPERAND (arg0, 0)),
12089 fold_convert_loc (loc, type,
12090 negate_expr (arg1)));
12092 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12093 && TREE_CODE (arg1) == NEGATE_EXPR
12094 && negate_expr_p (arg0))
12096 if (INTEGRAL_TYPE_P (type))
12097 fold_overflow_warning (("assuming signed overflow does not occur "
12098 "when distributing negation across "
12100 WARN_STRICT_OVERFLOW_MISC);
12101 return fold_build2_loc (loc, code, type,
12102 fold_convert_loc (loc, type,
12103 negate_expr (arg0)),
12104 fold_convert_loc (loc, type,
12105 TREE_OPERAND (arg1, 0)));
12108 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12109 operation, EXACT_DIV_EXPR.
12111 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12112 At one time others generated faster code, it's not clear if they do
12113 after the last round to changes to the DIV code in expmed.c. */
12114 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
12115 && multiple_of_p (type, arg0, arg1))
12116 return fold_build2_loc (loc, EXACT_DIV_EXPR, type, arg0, arg1);
12118 strict_overflow_p = false;
12119 if (TREE_CODE (arg1) == INTEGER_CST
12120 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
12121 &strict_overflow_p)))
12123 if (strict_overflow_p)
12124 fold_overflow_warning (("assuming signed overflow does not occur "
12125 "when simplifying division"),
12126 WARN_STRICT_OVERFLOW_MISC);
12127 return fold_convert_loc (loc, type, tem);
12132 case CEIL_MOD_EXPR:
12133 case FLOOR_MOD_EXPR:
12134 case ROUND_MOD_EXPR:
12135 case TRUNC_MOD_EXPR:
12136 /* X % -1 is zero. */
12137 if (!TYPE_UNSIGNED (type)
12138 && TREE_CODE (arg1) == INTEGER_CST
12139 && wi::eq_p (arg1, -1))
12140 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12142 /* X % -C is the same as X % C. */
12143 if (code == TRUNC_MOD_EXPR
12144 && TYPE_SIGN (type) == SIGNED
12145 && TREE_CODE (arg1) == INTEGER_CST
12146 && !TREE_OVERFLOW (arg1)
12147 && wi::neg_p (arg1)
12148 && !TYPE_OVERFLOW_TRAPS (type)
12149 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
12150 && !sign_bit_p (arg1, arg1))
12151 return fold_build2_loc (loc, code, type,
12152 fold_convert_loc (loc, type, arg0),
12153 fold_convert_loc (loc, type,
12154 negate_expr (arg1)));
12156 /* X % -Y is the same as X % Y. */
12157 if (code == TRUNC_MOD_EXPR
12158 && !TYPE_UNSIGNED (type)
12159 && TREE_CODE (arg1) == NEGATE_EXPR
12160 && !TYPE_OVERFLOW_TRAPS (type))
12161 return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, arg0),
12162 fold_convert_loc (loc, type,
12163 TREE_OPERAND (arg1, 0)));
12165 strict_overflow_p = false;
12166 if (TREE_CODE (arg1) == INTEGER_CST
12167 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
12168 &strict_overflow_p)))
12170 if (strict_overflow_p)
12171 fold_overflow_warning (("assuming signed overflow does not occur "
12172 "when simplifying modulus"),
12173 WARN_STRICT_OVERFLOW_MISC);
12174 return fold_convert_loc (loc, type, tem);
12177 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12178 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
12179 if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
12180 && (TYPE_UNSIGNED (type)
12181 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
12184 /* Also optimize A % (C << N) where C is a power of 2,
12185 to A & ((C << N) - 1). */
12186 if (TREE_CODE (arg1) == LSHIFT_EXPR)
12187 c = TREE_OPERAND (arg1, 0);
12189 if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
12192 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (arg1), arg1,
12193 build_int_cst (TREE_TYPE (arg1), 1));
12194 if (strict_overflow_p)
12195 fold_overflow_warning (("assuming signed overflow does not "
12196 "occur when simplifying "
12197 "X % (power of two)"),
12198 WARN_STRICT_OVERFLOW_MISC);
12199 return fold_build2_loc (loc, BIT_AND_EXPR, type,
12200 fold_convert_loc (loc, type, arg0),
12201 fold_convert_loc (loc, type, mask));
12209 if (integer_all_onesp (arg0))
12210 return omit_one_operand_loc (loc, type, arg0, arg1);
12214 /* Optimize -1 >> x for arithmetic right shifts. */
12215 if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type)
12216 && tree_expr_nonnegative_p (arg1))
12217 return omit_one_operand_loc (loc, type, arg0, arg1);
12218 /* ... fall through ... */
12222 if (integer_zerop (arg1))
12223 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12224 if (integer_zerop (arg0))
12225 return omit_one_operand_loc (loc, type, arg0, arg1);
12227 /* Prefer vector1 << scalar to vector1 << vector2
12228 if vector2 is uniform. */
12229 if (VECTOR_TYPE_P (TREE_TYPE (arg1))
12230 && (tem = uniform_vector_p (arg1)) != NULL_TREE)
12231 return fold_build2_loc (loc, code, type, op0, tem);
12233 /* Since negative shift count is not well-defined,
12234 don't try to compute it in the compiler. */
12235 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
12238 prec = element_precision (type);
12240 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
12241 if (TREE_CODE (op0) == code && tree_fits_uhwi_p (arg1)
12242 && tree_to_uhwi (arg1) < prec
12243 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
12244 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) < prec)
12246 unsigned int low = (tree_to_uhwi (TREE_OPERAND (arg0, 1))
12247 + tree_to_uhwi (arg1));
12249 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12250 being well defined. */
12253 if (code == LROTATE_EXPR || code == RROTATE_EXPR)
12255 else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
12256 return omit_one_operand_loc (loc, type, build_zero_cst (type),
12257 TREE_OPERAND (arg0, 0));
12262 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12263 build_int_cst (TREE_TYPE (arg1), low));
12266 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12267 into x & ((unsigned)-1 >> c) for unsigned types. */
12268 if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
12269 || (TYPE_UNSIGNED (type)
12270 && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
12271 && tree_fits_uhwi_p (arg1)
12272 && tree_to_uhwi (arg1) < prec
12273 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
12274 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) < prec)
12276 HOST_WIDE_INT low0 = tree_to_uhwi (TREE_OPERAND (arg0, 1));
12277 HOST_WIDE_INT low1 = tree_to_uhwi (arg1);
12283 arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12285 lshift = build_minus_one_cst (type);
12286 lshift = const_binop (code, lshift, arg1);
12288 return fold_build2_loc (loc, BIT_AND_EXPR, type, arg00, lshift);
12292 /* Rewrite an LROTATE_EXPR by a constant into an
12293 RROTATE_EXPR by a new constant. */
12294 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
12296 tree tem = build_int_cst (TREE_TYPE (arg1), prec);
12297 tem = const_binop (MINUS_EXPR, tem, arg1);
12298 return fold_build2_loc (loc, RROTATE_EXPR, type, op0, tem);
12301 /* If we have a rotate of a bit operation with the rotate count and
12302 the second operand of the bit operation both constant,
12303 permute the two operations. */
12304 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
12305 && (TREE_CODE (arg0) == BIT_AND_EXPR
12306 || TREE_CODE (arg0) == BIT_IOR_EXPR
12307 || TREE_CODE (arg0) == BIT_XOR_EXPR)
12308 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12309 return fold_build2_loc (loc, TREE_CODE (arg0), type,
12310 fold_build2_loc (loc, code, type,
12311 TREE_OPERAND (arg0, 0), arg1),
12312 fold_build2_loc (loc, code, type,
12313 TREE_OPERAND (arg0, 1), arg1));
12315 /* Two consecutive rotates adding up to the some integer
12316 multiple of the precision of the type can be ignored. */
12317 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
12318 && TREE_CODE (arg0) == RROTATE_EXPR
12319 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12320 && wi::umod_trunc (wi::add (arg1, TREE_OPERAND (arg0, 1)),
12322 return TREE_OPERAND (arg0, 0);
12324 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12325 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12326 if the latter can be further optimized. */
12327 if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
12328 && TREE_CODE (arg0) == BIT_AND_EXPR
12329 && TREE_CODE (arg1) == INTEGER_CST
12330 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12332 tree mask = fold_build2_loc (loc, code, type,
12333 fold_convert_loc (loc, type,
12334 TREE_OPERAND (arg0, 1)),
12336 tree shift = fold_build2_loc (loc, code, type,
12337 fold_convert_loc (loc, type,
12338 TREE_OPERAND (arg0, 0)),
12340 tem = fold_binary_loc (loc, BIT_AND_EXPR, type, shift, mask);
12348 if (operand_equal_p (arg0, arg1, 0))
12349 return omit_one_operand_loc (loc, type, arg0, arg1);
12350 if (INTEGRAL_TYPE_P (type)
12351 && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
12352 return omit_one_operand_loc (loc, type, arg1, arg0);
12353 tem = fold_minmax (loc, MIN_EXPR, type, arg0, arg1);
12359 if (operand_equal_p (arg0, arg1, 0))
12360 return omit_one_operand_loc (loc, type, arg0, arg1);
12361 if (INTEGRAL_TYPE_P (type)
12362 && TYPE_MAX_VALUE (type)
12363 && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
12364 return omit_one_operand_loc (loc, type, arg1, arg0);
12365 tem = fold_minmax (loc, MAX_EXPR, type, arg0, arg1);
12370 case TRUTH_ANDIF_EXPR:
12371 /* Note that the operands of this must be ints
12372 and their values must be 0 or 1.
12373 ("true" is a fixed value perhaps depending on the language.) */
12374 /* If first arg is constant zero, return it. */
12375 if (integer_zerop (arg0))
12376 return fold_convert_loc (loc, type, arg0);
12377 case TRUTH_AND_EXPR:
12378 /* If either arg is constant true, drop it. */
12379 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12380 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12381 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
12382 /* Preserve sequence points. */
12383 && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12384 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12385 /* If second arg is constant zero, result is zero, but first arg
12386 must be evaluated. */
12387 if (integer_zerop (arg1))
12388 return omit_one_operand_loc (loc, type, arg1, arg0);
12389 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12390 case will be handled here. */
12391 if (integer_zerop (arg0))
12392 return omit_one_operand_loc (loc, type, arg0, arg1);
12394 /* !X && X is always false. */
12395 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12396 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12397 return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
12398 /* X && !X is always false. */
12399 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12400 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12401 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12403 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12404 means A >= Y && A != MAX, but in this case we know that
12407 if (!TREE_SIDE_EFFECTS (arg0)
12408 && !TREE_SIDE_EFFECTS (arg1))
12410 tem = fold_to_nonsharp_ineq_using_bound (loc, arg0, arg1);
12411 if (tem && !operand_equal_p (tem, arg0, 0))
12412 return fold_build2_loc (loc, code, type, tem, arg1);
12414 tem = fold_to_nonsharp_ineq_using_bound (loc, arg1, arg0);
12415 if (tem && !operand_equal_p (tem, arg1, 0))
12416 return fold_build2_loc (loc, code, type, arg0, tem);
12419 if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
12425 case TRUTH_ORIF_EXPR:
12426 /* Note that the operands of this must be ints
12427 and their values must be 0 or true.
12428 ("true" is a fixed value perhaps depending on the language.) */
12429 /* If first arg is constant true, return it. */
12430 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12431 return fold_convert_loc (loc, type, arg0);
12432 case TRUTH_OR_EXPR:
12433 /* If either arg is constant zero, drop it. */
12434 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
12435 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12436 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
12437 /* Preserve sequence points. */
12438 && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12439 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12440 /* If second arg is constant true, result is true, but we must
12441 evaluate first arg. */
12442 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
12443 return omit_one_operand_loc (loc, type, arg1, arg0);
12444 /* Likewise for first arg, but note this only occurs here for
12446 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12447 return omit_one_operand_loc (loc, type, arg0, arg1);
12449 /* !X || X is always true. */
12450 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12451 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12452 return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12453 /* X || !X is always true. */
12454 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12455 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12456 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12458 /* (X && !Y) || (!X && Y) is X ^ Y */
12459 if (TREE_CODE (arg0) == TRUTH_AND_EXPR
12460 && TREE_CODE (arg1) == TRUTH_AND_EXPR)
12462 tree a0, a1, l0, l1, n0, n1;
12464 a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
12465 a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
12467 l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12468 l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
12470 n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
12471 n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
12473 if ((operand_equal_p (n0, a0, 0)
12474 && operand_equal_p (n1, a1, 0))
12475 || (operand_equal_p (n0, a1, 0)
12476 && operand_equal_p (n1, a0, 0)))
12477 return fold_build2_loc (loc, TRUTH_XOR_EXPR, type, l0, n1);
12480 if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
12486 case TRUTH_XOR_EXPR:
12487 /* If the second arg is constant zero, drop it. */
12488 if (integer_zerop (arg1))
12489 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12490 /* If the second arg is constant true, this is a logical inversion. */
12491 if (integer_onep (arg1))
12493 tem = invert_truthvalue_loc (loc, arg0);
12494 return non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
12496 /* Identical arguments cancel to zero. */
12497 if (operand_equal_p (arg0, arg1, 0))
12498 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12500 /* !X ^ X is always true. */
12501 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12502 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12503 return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12505 /* X ^ !X is always true. */
12506 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12507 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12508 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12517 tem = fold_comparison (loc, code, type, op0, op1);
12518 if (tem != NULL_TREE)
12521 /* bool_var != 0 becomes bool_var. */
12522 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12523 && code == NE_EXPR)
12524 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12526 /* bool_var == 1 becomes bool_var. */
12527 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12528 && code == EQ_EXPR)
12529 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12531 /* bool_var != 1 becomes !bool_var. */
12532 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12533 && code == NE_EXPR)
12534 return fold_convert_loc (loc, type,
12535 fold_build1_loc (loc, TRUTH_NOT_EXPR,
12536 TREE_TYPE (arg0), arg0));
12538 /* bool_var == 0 becomes !bool_var. */
12539 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12540 && code == EQ_EXPR)
12541 return fold_convert_loc (loc, type,
12542 fold_build1_loc (loc, TRUTH_NOT_EXPR,
12543 TREE_TYPE (arg0), arg0));
12545 /* !exp != 0 becomes !exp */
12546 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR && integer_zerop (arg1)
12547 && code == NE_EXPR)
12548 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12550 /* If this is an equality comparison of the address of two non-weak,
12551 unaliased symbols neither of which are extern (since we do not
12552 have access to attributes for externs), then we know the result. */
12553 if (TREE_CODE (arg0) == ADDR_EXPR
12554 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
12555 && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
12556 && ! lookup_attribute ("alias",
12557 DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
12558 && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
12559 && TREE_CODE (arg1) == ADDR_EXPR
12560 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
12561 && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
12562 && ! lookup_attribute ("alias",
12563 DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
12564 && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
12566 /* We know that we're looking at the address of two
12567 non-weak, unaliased, static _DECL nodes.
12569 It is both wasteful and incorrect to call operand_equal_p
12570 to compare the two ADDR_EXPR nodes. It is wasteful in that
12571 all we need to do is test pointer equality for the arguments
12572 to the two ADDR_EXPR nodes. It is incorrect to use
12573 operand_equal_p as that function is NOT equivalent to a
12574 C equality test. It can in fact return false for two
12575 objects which would test as equal using the C equality
12577 bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
12578 return constant_boolean_node (equal
12579 ? code == EQ_EXPR : code != EQ_EXPR,
12583 /* Similarly for a NEGATE_EXPR. */
12584 if (TREE_CODE (arg0) == NEGATE_EXPR
12585 && TREE_CODE (arg1) == INTEGER_CST
12586 && 0 != (tem = negate_expr (fold_convert_loc (loc, TREE_TYPE (arg0),
12588 && TREE_CODE (tem) == INTEGER_CST
12589 && !TREE_OVERFLOW (tem))
12590 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
12592 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12593 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12594 && TREE_CODE (arg1) == INTEGER_CST
12595 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12596 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12597 fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg0),
12598 fold_convert_loc (loc,
12601 TREE_OPERAND (arg0, 1)));
12603 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12604 if ((TREE_CODE (arg0) == PLUS_EXPR
12605 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
12606 || TREE_CODE (arg0) == MINUS_EXPR)
12607 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
12610 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
12611 || POINTER_TYPE_P (TREE_TYPE (arg0))))
12613 tree val = TREE_OPERAND (arg0, 1);
12614 return omit_two_operands_loc (loc, type,
12615 fold_build2_loc (loc, code, type,
12617 build_int_cst (TREE_TYPE (val),
12619 TREE_OPERAND (arg0, 0), arg1);
12622 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12623 if (TREE_CODE (arg0) == MINUS_EXPR
12624 && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
12625 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
12628 && wi::extract_uhwi (TREE_OPERAND (arg0, 0), 0, 1) == 1)
12630 return omit_two_operands_loc (loc, type,
12632 ? boolean_true_node : boolean_false_node,
12633 TREE_OPERAND (arg0, 1), arg1);
12636 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12637 if (TREE_CODE (arg0) == ABS_EXPR
12638 && (integer_zerop (arg1) || real_zerop (arg1)))
12639 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), arg1);
12641 /* If this is an EQ or NE comparison with zero and ARG0 is
12642 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12643 two operations, but the latter can be done in one less insn
12644 on machines that have only two-operand insns or on which a
12645 constant cannot be the first operand. */
12646 if (TREE_CODE (arg0) == BIT_AND_EXPR
12647 && integer_zerop (arg1))
12649 tree arg00 = TREE_OPERAND (arg0, 0);
12650 tree arg01 = TREE_OPERAND (arg0, 1);
12651 if (TREE_CODE (arg00) == LSHIFT_EXPR
12652 && integer_onep (TREE_OPERAND (arg00, 0)))
12654 tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
12655 arg01, TREE_OPERAND (arg00, 1));
12656 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12657 build_int_cst (TREE_TYPE (arg0), 1));
12658 return fold_build2_loc (loc, code, type,
12659 fold_convert_loc (loc, TREE_TYPE (arg1), tem),
12662 else if (TREE_CODE (arg01) == LSHIFT_EXPR
12663 && integer_onep (TREE_OPERAND (arg01, 0)))
12665 tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
12666 arg00, TREE_OPERAND (arg01, 1));
12667 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12668 build_int_cst (TREE_TYPE (arg0), 1));
12669 return fold_build2_loc (loc, code, type,
12670 fold_convert_loc (loc, TREE_TYPE (arg1), tem),
12675 /* If this is an NE or EQ comparison of zero against the result of a
12676 signed MOD operation whose second operand is a power of 2, make
12677 the MOD operation unsigned since it is simpler and equivalent. */
12678 if (integer_zerop (arg1)
12679 && !TYPE_UNSIGNED (TREE_TYPE (arg0))
12680 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
12681 || TREE_CODE (arg0) == CEIL_MOD_EXPR
12682 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
12683 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
12684 && integer_pow2p (TREE_OPERAND (arg0, 1)))
12686 tree newtype = unsigned_type_for (TREE_TYPE (arg0));
12687 tree newmod = fold_build2_loc (loc, TREE_CODE (arg0), newtype,
12688 fold_convert_loc (loc, newtype,
12689 TREE_OPERAND (arg0, 0)),
12690 fold_convert_loc (loc, newtype,
12691 TREE_OPERAND (arg0, 1)));
12693 return fold_build2_loc (loc, code, type, newmod,
12694 fold_convert_loc (loc, newtype, arg1));
12697 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12698 C1 is a valid shift constant, and C2 is a power of two, i.e.
12700 if (TREE_CODE (arg0) == BIT_AND_EXPR
12701 && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
12702 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
12704 && integer_pow2p (TREE_OPERAND (arg0, 1))
12705 && integer_zerop (arg1))
12707 tree itype = TREE_TYPE (arg0);
12708 tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
12709 prec = TYPE_PRECISION (itype);
12711 /* Check for a valid shift count. */
12712 if (wi::ltu_p (arg001, prec))
12714 tree arg01 = TREE_OPERAND (arg0, 1);
12715 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12716 unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
12717 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12718 can be rewritten as (X & (C2 << C1)) != 0. */
12719 if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
12721 tem = fold_build2_loc (loc, LSHIFT_EXPR, itype, arg01, arg001);
12722 tem = fold_build2_loc (loc, BIT_AND_EXPR, itype, arg000, tem);
12723 return fold_build2_loc (loc, code, type, tem,
12724 fold_convert_loc (loc, itype, arg1));
12726 /* Otherwise, for signed (arithmetic) shifts,
12727 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12728 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
12729 else if (!TYPE_UNSIGNED (itype))
12730 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
12731 arg000, build_int_cst (itype, 0));
12732 /* Otherwise, of unsigned (logical) shifts,
12733 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12734 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
12736 return omit_one_operand_loc (loc, type,
12737 code == EQ_EXPR ? integer_one_node
12738 : integer_zero_node,
12743 /* If we have (A & C) == C where C is a power of 2, convert this into
12744 (A & C) != 0. Similarly for NE_EXPR. */
12745 if (TREE_CODE (arg0) == BIT_AND_EXPR
12746 && integer_pow2p (TREE_OPERAND (arg0, 1))
12747 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12748 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12749 arg0, fold_convert_loc (loc, TREE_TYPE (arg0),
12750 integer_zero_node));
12752 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12753 bit, then fold the expression into A < 0 or A >= 0. */
12754 tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1, type);
12758 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12759 Similarly for NE_EXPR. */
12760 if (TREE_CODE (arg0) == BIT_AND_EXPR
12761 && TREE_CODE (arg1) == INTEGER_CST
12762 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12764 tree notc = fold_build1_loc (loc, BIT_NOT_EXPR,
12765 TREE_TYPE (TREE_OPERAND (arg0, 1)),
12766 TREE_OPERAND (arg0, 1));
12768 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12769 fold_convert_loc (loc, TREE_TYPE (arg0), arg1),
12771 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12772 if (integer_nonzerop (dandnotc))
12773 return omit_one_operand_loc (loc, type, rslt, arg0);
12776 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12777 Similarly for NE_EXPR. */
12778 if (TREE_CODE (arg0) == BIT_IOR_EXPR
12779 && TREE_CODE (arg1) == INTEGER_CST
12780 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12782 tree notd = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
12784 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12785 TREE_OPERAND (arg0, 1),
12786 fold_convert_loc (loc, TREE_TYPE (arg0), notd));
12787 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12788 if (integer_nonzerop (candnotd))
12789 return omit_one_operand_loc (loc, type, rslt, arg0);
12792 /* If this is a comparison of a field, we may be able to simplify it. */
12793 if ((TREE_CODE (arg0) == COMPONENT_REF
12794 || TREE_CODE (arg0) == BIT_FIELD_REF)
12795 /* Handle the constant case even without -O
12796 to make sure the warnings are given. */
12797 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
12799 t1 = optimize_bit_field_compare (loc, code, type, arg0, arg1);
12804 /* Optimize comparisons of strlen vs zero to a compare of the
12805 first character of the string vs zero. To wit,
12806 strlen(ptr) == 0 => *ptr == 0
12807 strlen(ptr) != 0 => *ptr != 0
12808 Other cases should reduce to one of these two (or a constant)
12809 due to the return value of strlen being unsigned. */
12810 if (TREE_CODE (arg0) == CALL_EXPR
12811 && integer_zerop (arg1))
12813 tree fndecl = get_callee_fndecl (arg0);
12816 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
12817 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
12818 && call_expr_nargs (arg0) == 1
12819 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
12821 tree iref = build_fold_indirect_ref_loc (loc,
12822 CALL_EXPR_ARG (arg0, 0));
12823 return fold_build2_loc (loc, code, type, iref,
12824 build_int_cst (TREE_TYPE (iref), 0));
12828 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12829 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12830 if (TREE_CODE (arg0) == RSHIFT_EXPR
12831 && integer_zerop (arg1)
12832 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12834 tree arg00 = TREE_OPERAND (arg0, 0);
12835 tree arg01 = TREE_OPERAND (arg0, 1);
12836 tree itype = TREE_TYPE (arg00);
12837 if (wi::eq_p (arg01, TYPE_PRECISION (itype) - 1))
12839 if (TYPE_UNSIGNED (itype))
12841 itype = signed_type_for (itype);
12842 arg00 = fold_convert_loc (loc, itype, arg00);
12844 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
12845 type, arg00, build_zero_cst (itype));
12849 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
12850 if (integer_zerop (arg1)
12851 && TREE_CODE (arg0) == BIT_XOR_EXPR)
12852 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12853 TREE_OPERAND (arg0, 1));
12855 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
12856 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12857 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12858 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12859 build_zero_cst (TREE_TYPE (arg0)));
12860 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
12861 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12862 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12863 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
12864 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 1),
12865 build_zero_cst (TREE_TYPE (arg0)));
12867 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
12868 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12869 && TREE_CODE (arg1) == INTEGER_CST
12870 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12871 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12872 fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg1),
12873 TREE_OPERAND (arg0, 1), arg1));
12875 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12876 (X & C) == 0 when C is a single bit. */
12877 if (TREE_CODE (arg0) == BIT_AND_EXPR
12878 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
12879 && integer_zerop (arg1)
12880 && integer_pow2p (TREE_OPERAND (arg0, 1)))
12882 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12883 TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
12884 TREE_OPERAND (arg0, 1));
12885 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
12887 fold_convert_loc (loc, TREE_TYPE (arg0),
12891 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12892 constant C is a power of two, i.e. a single bit. */
12893 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12894 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
12895 && integer_zerop (arg1)
12896 && integer_pow2p (TREE_OPERAND (arg0, 1))
12897 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12898 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12900 tree arg00 = TREE_OPERAND (arg0, 0);
12901 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12902 arg00, build_int_cst (TREE_TYPE (arg00), 0));
12905 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12906 when is C is a power of two, i.e. a single bit. */
12907 if (TREE_CODE (arg0) == BIT_AND_EXPR
12908 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
12909 && integer_zerop (arg1)
12910 && integer_pow2p (TREE_OPERAND (arg0, 1))
12911 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12912 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12914 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12915 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg000),
12916 arg000, TREE_OPERAND (arg0, 1));
12917 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12918 tem, build_int_cst (TREE_TYPE (tem), 0));
12921 if (integer_zerop (arg1)
12922 && tree_expr_nonzero_p (arg0))
12924 tree res = constant_boolean_node (code==NE_EXPR, type);
12925 return omit_one_operand_loc (loc, type, res, arg0);
12928 /* Fold -X op -Y as X op Y, where op is eq/ne. */
12929 if (TREE_CODE (arg0) == NEGATE_EXPR
12930 && TREE_CODE (arg1) == NEGATE_EXPR)
12931 return fold_build2_loc (loc, code, type,
12932 TREE_OPERAND (arg0, 0),
12933 fold_convert_loc (loc, TREE_TYPE (arg0),
12934 TREE_OPERAND (arg1, 0)));
12936 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
12937 if (TREE_CODE (arg0) == BIT_AND_EXPR
12938 && TREE_CODE (arg1) == BIT_AND_EXPR)
12940 tree arg00 = TREE_OPERAND (arg0, 0);
12941 tree arg01 = TREE_OPERAND (arg0, 1);
12942 tree arg10 = TREE_OPERAND (arg1, 0);
12943 tree arg11 = TREE_OPERAND (arg1, 1);
12944 tree itype = TREE_TYPE (arg0);
12946 if (operand_equal_p (arg01, arg11, 0))
12947 return fold_build2_loc (loc, code, type,
12948 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12949 fold_build2_loc (loc,
12950 BIT_XOR_EXPR, itype,
12953 build_zero_cst (itype));
12955 if (operand_equal_p (arg01, arg10, 0))
12956 return fold_build2_loc (loc, code, type,
12957 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12958 fold_build2_loc (loc,
12959 BIT_XOR_EXPR, itype,
12962 build_zero_cst (itype));
12964 if (operand_equal_p (arg00, arg11, 0))
12965 return fold_build2_loc (loc, code, type,
12966 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12967 fold_build2_loc (loc,
12968 BIT_XOR_EXPR, itype,
12971 build_zero_cst (itype));
12973 if (operand_equal_p (arg00, arg10, 0))
12974 return fold_build2_loc (loc, code, type,
12975 fold_build2_loc (loc, BIT_AND_EXPR, itype,
12976 fold_build2_loc (loc,
12977 BIT_XOR_EXPR, itype,
12980 build_zero_cst (itype));
12983 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12984 && TREE_CODE (arg1) == BIT_XOR_EXPR)
12986 tree arg00 = TREE_OPERAND (arg0, 0);
12987 tree arg01 = TREE_OPERAND (arg0, 1);
12988 tree arg10 = TREE_OPERAND (arg1, 0);
12989 tree arg11 = TREE_OPERAND (arg1, 1);
12990 tree itype = TREE_TYPE (arg0);
12992 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
12993 operand_equal_p guarantees no side-effects so we don't need
12994 to use omit_one_operand on Z. */
12995 if (operand_equal_p (arg01, arg11, 0))
12996 return fold_build2_loc (loc, code, type, arg00,
12997 fold_convert_loc (loc, TREE_TYPE (arg00),
12999 if (operand_equal_p (arg01, arg10, 0))
13000 return fold_build2_loc (loc, code, type, arg00,
13001 fold_convert_loc (loc, TREE_TYPE (arg00),
13003 if (operand_equal_p (arg00, arg11, 0))
13004 return fold_build2_loc (loc, code, type, arg01,
13005 fold_convert_loc (loc, TREE_TYPE (arg01),
13007 if (operand_equal_p (arg00, arg10, 0))
13008 return fold_build2_loc (loc, code, type, arg01,
13009 fold_convert_loc (loc, TREE_TYPE (arg01),
13012 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
13013 if (TREE_CODE (arg01) == INTEGER_CST
13014 && TREE_CODE (arg11) == INTEGER_CST)
13016 tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg01,
13017 fold_convert_loc (loc, itype, arg11));
13018 tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg00, tem);
13019 return fold_build2_loc (loc, code, type, tem,
13020 fold_convert_loc (loc, itype, arg10));
13024 /* Attempt to simplify equality/inequality comparisons of complex
13025 values. Only lower the comparison if the result is known or
13026 can be simplified to a single scalar comparison. */
13027 if ((TREE_CODE (arg0) == COMPLEX_EXPR
13028 || TREE_CODE (arg0) == COMPLEX_CST)
13029 && (TREE_CODE (arg1) == COMPLEX_EXPR
13030 || TREE_CODE (arg1) == COMPLEX_CST))
13032 tree real0, imag0, real1, imag1;
13035 if (TREE_CODE (arg0) == COMPLEX_EXPR)
13037 real0 = TREE_OPERAND (arg0, 0);
13038 imag0 = TREE_OPERAND (arg0, 1);
13042 real0 = TREE_REALPART (arg0);
13043 imag0 = TREE_IMAGPART (arg0);
13046 if (TREE_CODE (arg1) == COMPLEX_EXPR)
13048 real1 = TREE_OPERAND (arg1, 0);
13049 imag1 = TREE_OPERAND (arg1, 1);
13053 real1 = TREE_REALPART (arg1);
13054 imag1 = TREE_IMAGPART (arg1);
13057 rcond = fold_binary_loc (loc, code, type, real0, real1);
13058 if (rcond && TREE_CODE (rcond) == INTEGER_CST)
13060 if (integer_zerop (rcond))
13062 if (code == EQ_EXPR)
13063 return omit_two_operands_loc (loc, type, boolean_false_node,
13065 return fold_build2_loc (loc, NE_EXPR, type, imag0, imag1);
13069 if (code == NE_EXPR)
13070 return omit_two_operands_loc (loc, type, boolean_true_node,
13072 return fold_build2_loc (loc, EQ_EXPR, type, imag0, imag1);
13076 icond = fold_binary_loc (loc, code, type, imag0, imag1);
13077 if (icond && TREE_CODE (icond) == INTEGER_CST)
13079 if (integer_zerop (icond))
13081 if (code == EQ_EXPR)
13082 return omit_two_operands_loc (loc, type, boolean_false_node,
13084 return fold_build2_loc (loc, NE_EXPR, type, real0, real1);
13088 if (code == NE_EXPR)
13089 return omit_two_operands_loc (loc, type, boolean_true_node,
13091 return fold_build2_loc (loc, EQ_EXPR, type, real0, real1);
13102 tem = fold_comparison (loc, code, type, op0, op1);
13103 if (tem != NULL_TREE)
13106 /* Transform comparisons of the form X +- C CMP X. */
13107 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
13108 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
13109 && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
13110 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
13111 || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
13112 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
13114 tree arg01 = TREE_OPERAND (arg0, 1);
13115 enum tree_code code0 = TREE_CODE (arg0);
13118 if (TREE_CODE (arg01) == REAL_CST)
13119 is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
13121 is_positive = tree_int_cst_sgn (arg01);
13123 /* (X - c) > X becomes false. */
13124 if (code == GT_EXPR
13125 && ((code0 == MINUS_EXPR && is_positive >= 0)
13126 || (code0 == PLUS_EXPR && is_positive <= 0)))
13128 if (TREE_CODE (arg01) == INTEGER_CST
13129 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13130 fold_overflow_warning (("assuming signed overflow does not "
13131 "occur when assuming that (X - c) > X "
13132 "is always false"),
13133 WARN_STRICT_OVERFLOW_ALL);
13134 return constant_boolean_node (0, type);
13137 /* Likewise (X + c) < X becomes false. */
13138 if (code == LT_EXPR
13139 && ((code0 == PLUS_EXPR && is_positive >= 0)
13140 || (code0 == MINUS_EXPR && is_positive <= 0)))
13142 if (TREE_CODE (arg01) == INTEGER_CST
13143 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13144 fold_overflow_warning (("assuming signed overflow does not "
13145 "occur when assuming that "
13146 "(X + c) < X is always false"),
13147 WARN_STRICT_OVERFLOW_ALL);
13148 return constant_boolean_node (0, type);
13151 /* Convert (X - c) <= X to true. */
13152 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
13154 && ((code0 == MINUS_EXPR && is_positive >= 0)
13155 || (code0 == PLUS_EXPR && is_positive <= 0)))
13157 if (TREE_CODE (arg01) == INTEGER_CST
13158 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13159 fold_overflow_warning (("assuming signed overflow does not "
13160 "occur when assuming that "
13161 "(X - c) <= X is always true"),
13162 WARN_STRICT_OVERFLOW_ALL);
13163 return constant_boolean_node (1, type);
13166 /* Convert (X + c) >= X to true. */
13167 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
13169 && ((code0 == PLUS_EXPR && is_positive >= 0)
13170 || (code0 == MINUS_EXPR && is_positive <= 0)))
13172 if (TREE_CODE (arg01) == INTEGER_CST
13173 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13174 fold_overflow_warning (("assuming signed overflow does not "
13175 "occur when assuming that "
13176 "(X + c) >= X is always true"),
13177 WARN_STRICT_OVERFLOW_ALL);
13178 return constant_boolean_node (1, type);
13181 if (TREE_CODE (arg01) == INTEGER_CST)
13183 /* Convert X + c > X and X - c < X to true for integers. */
13184 if (code == GT_EXPR
13185 && ((code0 == PLUS_EXPR && is_positive > 0)
13186 || (code0 == MINUS_EXPR && is_positive < 0)))
13188 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13189 fold_overflow_warning (("assuming signed overflow does "
13190 "not occur when assuming that "
13191 "(X + c) > X is always true"),
13192 WARN_STRICT_OVERFLOW_ALL);
13193 return constant_boolean_node (1, type);
13196 if (code == LT_EXPR
13197 && ((code0 == MINUS_EXPR && is_positive > 0)
13198 || (code0 == PLUS_EXPR && is_positive < 0)))
13200 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13201 fold_overflow_warning (("assuming signed overflow does "
13202 "not occur when assuming that "
13203 "(X - c) < X is always true"),
13204 WARN_STRICT_OVERFLOW_ALL);
13205 return constant_boolean_node (1, type);
13208 /* Convert X + c <= X and X - c >= X to false for integers. */
13209 if (code == LE_EXPR
13210 && ((code0 == PLUS_EXPR && is_positive > 0)
13211 || (code0 == MINUS_EXPR && is_positive < 0)))
13213 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13214 fold_overflow_warning (("assuming signed overflow does "
13215 "not occur when assuming that "
13216 "(X + c) <= X is always false"),
13217 WARN_STRICT_OVERFLOW_ALL);
13218 return constant_boolean_node (0, type);
13221 if (code == GE_EXPR
13222 && ((code0 == MINUS_EXPR && is_positive > 0)
13223 || (code0 == PLUS_EXPR && is_positive < 0)))
13225 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13226 fold_overflow_warning (("assuming signed overflow does "
13227 "not occur when assuming that "
13228 "(X - c) >= X is always false"),
13229 WARN_STRICT_OVERFLOW_ALL);
13230 return constant_boolean_node (0, type);
13235 /* Comparisons with the highest or lowest possible integer of
13236 the specified precision will have known values. */
13238 tree arg1_type = TREE_TYPE (arg1);
13239 unsigned int prec = TYPE_PRECISION (arg1_type);
13241 if (TREE_CODE (arg1) == INTEGER_CST
13242 && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
13244 wide_int max = wi::max_value (arg1_type);
13245 wide_int signed_max = wi::max_value (prec, SIGNED);
13246 wide_int min = wi::min_value (arg1_type);
13248 if (wi::eq_p (arg1, max))
13252 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13255 return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
13258 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13261 return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
13263 /* The GE_EXPR and LT_EXPR cases above are not normally
13264 reached because of previous transformations. */
13269 else if (wi::eq_p (arg1, max - 1))
13273 arg1 = const_binop (PLUS_EXPR, arg1,
13274 build_int_cst (TREE_TYPE (arg1), 1));
13275 return fold_build2_loc (loc, EQ_EXPR, type,
13276 fold_convert_loc (loc,
13277 TREE_TYPE (arg1), arg0),
13280 arg1 = const_binop (PLUS_EXPR, arg1,
13281 build_int_cst (TREE_TYPE (arg1), 1));
13282 return fold_build2_loc (loc, NE_EXPR, type,
13283 fold_convert_loc (loc, TREE_TYPE (arg1),
13289 else if (wi::eq_p (arg1, min))
13293 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13296 return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
13299 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13302 return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
13307 else if (wi::eq_p (arg1, min + 1))
13311 arg1 = const_binop (MINUS_EXPR, arg1,
13312 build_int_cst (TREE_TYPE (arg1), 1));
13313 return fold_build2_loc (loc, NE_EXPR, type,
13314 fold_convert_loc (loc,
13315 TREE_TYPE (arg1), arg0),
13318 arg1 = const_binop (MINUS_EXPR, arg1,
13319 build_int_cst (TREE_TYPE (arg1), 1));
13320 return fold_build2_loc (loc, EQ_EXPR, type,
13321 fold_convert_loc (loc, TREE_TYPE (arg1),
13328 else if (wi::eq_p (arg1, signed_max)
13329 && TYPE_UNSIGNED (arg1_type)
13330 /* We will flip the signedness of the comparison operator
13331 associated with the mode of arg1, so the sign bit is
13332 specified by this mode. Check that arg1 is the signed
13333 max associated with this sign bit. */
13334 && prec == GET_MODE_PRECISION (TYPE_MODE (arg1_type))
13335 /* signed_type does not work on pointer types. */
13336 && INTEGRAL_TYPE_P (arg1_type))
13338 /* The following case also applies to X < signed_max+1
13339 and X >= signed_max+1 because previous transformations. */
13340 if (code == LE_EXPR || code == GT_EXPR)
13342 tree st = signed_type_for (arg1_type);
13343 return fold_build2_loc (loc,
13344 code == LE_EXPR ? GE_EXPR : LT_EXPR,
13345 type, fold_convert_loc (loc, st, arg0),
13346 build_int_cst (st, 0));
13352 /* If we are comparing an ABS_EXPR with a constant, we can
13353 convert all the cases into explicit comparisons, but they may
13354 well not be faster than doing the ABS and one comparison.
13355 But ABS (X) <= C is a range comparison, which becomes a subtraction
13356 and a comparison, and is probably faster. */
13357 if (code == LE_EXPR
13358 && TREE_CODE (arg1) == INTEGER_CST
13359 && TREE_CODE (arg0) == ABS_EXPR
13360 && ! TREE_SIDE_EFFECTS (arg0)
13361 && (0 != (tem = negate_expr (arg1)))
13362 && TREE_CODE (tem) == INTEGER_CST
13363 && !TREE_OVERFLOW (tem))
13364 return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13365 build2 (GE_EXPR, type,
13366 TREE_OPERAND (arg0, 0), tem),
13367 build2 (LE_EXPR, type,
13368 TREE_OPERAND (arg0, 0), arg1));
13370 /* Convert ABS_EXPR<x> >= 0 to true. */
13371 strict_overflow_p = false;
13372 if (code == GE_EXPR
13373 && (integer_zerop (arg1)
13374 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
13375 && real_zerop (arg1)))
13376 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13378 if (strict_overflow_p)
13379 fold_overflow_warning (("assuming signed overflow does not occur "
13380 "when simplifying comparison of "
13381 "absolute value and zero"),
13382 WARN_STRICT_OVERFLOW_CONDITIONAL);
13383 return omit_one_operand_loc (loc, type,
13384 constant_boolean_node (true, type),
13388 /* Convert ABS_EXPR<x> < 0 to false. */
13389 strict_overflow_p = false;
13390 if (code == LT_EXPR
13391 && (integer_zerop (arg1) || real_zerop (arg1))
13392 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13394 if (strict_overflow_p)
13395 fold_overflow_warning (("assuming signed overflow does not occur "
13396 "when simplifying comparison of "
13397 "absolute value and zero"),
13398 WARN_STRICT_OVERFLOW_CONDITIONAL);
13399 return omit_one_operand_loc (loc, type,
13400 constant_boolean_node (false, type),
13404 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13405 and similarly for >= into !=. */
13406 if ((code == LT_EXPR || code == GE_EXPR)
13407 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13408 && TREE_CODE (arg1) == LSHIFT_EXPR
13409 && integer_onep (TREE_OPERAND (arg1, 0)))
13410 return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13411 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13412 TREE_OPERAND (arg1, 1)),
13413 build_zero_cst (TREE_TYPE (arg0)));
13415 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
13416 otherwise Y might be >= # of bits in X's type and thus e.g.
13417 (unsigned char) (1 << Y) for Y 15 might be 0.
13418 If the cast is widening, then 1 << Y should have unsigned type,
13419 otherwise if Y is number of bits in the signed shift type minus 1,
13420 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
13421 31 might be 0xffffffff80000000. */
13422 if ((code == LT_EXPR || code == GE_EXPR)
13423 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13424 && CONVERT_EXPR_P (arg1)
13425 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
13426 && (TYPE_PRECISION (TREE_TYPE (arg1))
13427 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0))))
13428 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0)))
13429 || (TYPE_PRECISION (TREE_TYPE (arg1))
13430 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)))))
13431 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
13433 tem = build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13434 TREE_OPERAND (TREE_OPERAND (arg1, 0), 1));
13435 return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13436 fold_convert_loc (loc, TREE_TYPE (arg0), tem),
13437 build_zero_cst (TREE_TYPE (arg0)));
13442 case UNORDERED_EXPR:
13450 if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
13452 t1 = fold_relational_const (code, type, arg0, arg1);
13453 if (t1 != NULL_TREE)
13457 /* If the first operand is NaN, the result is constant. */
13458 if (TREE_CODE (arg0) == REAL_CST
13459 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
13460 && (code != LTGT_EXPR || ! flag_trapping_math))
13462 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13463 ? integer_zero_node
13464 : integer_one_node;
13465 return omit_one_operand_loc (loc, type, t1, arg1);
13468 /* If the second operand is NaN, the result is constant. */
13469 if (TREE_CODE (arg1) == REAL_CST
13470 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
13471 && (code != LTGT_EXPR || ! flag_trapping_math))
13473 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13474 ? integer_zero_node
13475 : integer_one_node;
13476 return omit_one_operand_loc (loc, type, t1, arg0);
13479 /* Simplify unordered comparison of something with itself. */
13480 if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
13481 && operand_equal_p (arg0, arg1, 0))
13482 return constant_boolean_node (1, type);
13484 if (code == LTGT_EXPR
13485 && !flag_trapping_math
13486 && operand_equal_p (arg0, arg1, 0))
13487 return constant_boolean_node (0, type);
13489 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13491 tree targ0 = strip_float_extensions (arg0);
13492 tree targ1 = strip_float_extensions (arg1);
13493 tree newtype = TREE_TYPE (targ0);
13495 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
13496 newtype = TREE_TYPE (targ1);
13498 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
13499 return fold_build2_loc (loc, code, type,
13500 fold_convert_loc (loc, newtype, targ0),
13501 fold_convert_loc (loc, newtype, targ1));
13506 case COMPOUND_EXPR:
13507 /* When pedantic, a compound expression can be neither an lvalue
13508 nor an integer constant expression. */
13509 if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
13511 /* Don't let (0, 0) be null pointer constant. */
13512 tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
13513 : fold_convert_loc (loc, type, arg1);
13514 return pedantic_non_lvalue_loc (loc, tem);
13517 if ((TREE_CODE (arg0) == REAL_CST
13518 && TREE_CODE (arg1) == REAL_CST)
13519 || (TREE_CODE (arg0) == INTEGER_CST
13520 && TREE_CODE (arg1) == INTEGER_CST))
13521 return build_complex (type, arg0, arg1);
13522 if (TREE_CODE (arg0) == REALPART_EXPR
13523 && TREE_CODE (arg1) == IMAGPART_EXPR
13524 && TREE_TYPE (TREE_OPERAND (arg0, 0)) == type
13525 && operand_equal_p (TREE_OPERAND (arg0, 0),
13526 TREE_OPERAND (arg1, 0), 0))
13527 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
13528 TREE_OPERAND (arg1, 0));
13532 /* An ASSERT_EXPR should never be passed to fold_binary. */
13533 gcc_unreachable ();
13535 case VEC_PACK_TRUNC_EXPR:
13536 case VEC_PACK_FIX_TRUNC_EXPR:
13538 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
13541 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts / 2
13542 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts / 2);
13543 if (TREE_CODE (arg0) != VECTOR_CST || TREE_CODE (arg1) != VECTOR_CST)
13546 elts = XALLOCAVEC (tree, nelts);
13547 if (!vec_cst_ctor_to_array (arg0, elts)
13548 || !vec_cst_ctor_to_array (arg1, elts + nelts / 2))
13551 for (i = 0; i < nelts; i++)
13553 elts[i] = fold_convert_const (code == VEC_PACK_TRUNC_EXPR
13554 ? NOP_EXPR : FIX_TRUNC_EXPR,
13555 TREE_TYPE (type), elts[i]);
13556 if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
13560 return build_vector (type, elts);
13563 case VEC_WIDEN_MULT_LO_EXPR:
13564 case VEC_WIDEN_MULT_HI_EXPR:
13565 case VEC_WIDEN_MULT_EVEN_EXPR:
13566 case VEC_WIDEN_MULT_ODD_EXPR:
13568 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type);
13569 unsigned int out, ofs, scale;
13572 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2
13573 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts * 2);
13574 if (TREE_CODE (arg0) != VECTOR_CST || TREE_CODE (arg1) != VECTOR_CST)
13577 elts = XALLOCAVEC (tree, nelts * 4);
13578 if (!vec_cst_ctor_to_array (arg0, elts)
13579 || !vec_cst_ctor_to_array (arg1, elts + nelts * 2))
13582 if (code == VEC_WIDEN_MULT_LO_EXPR)
13583 scale = 0, ofs = BYTES_BIG_ENDIAN ? nelts : 0;
13584 else if (code == VEC_WIDEN_MULT_HI_EXPR)
13585 scale = 0, ofs = BYTES_BIG_ENDIAN ? 0 : nelts;
13586 else if (code == VEC_WIDEN_MULT_EVEN_EXPR)
13587 scale = 1, ofs = 0;
13588 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
13589 scale = 1, ofs = 1;
13591 for (out = 0; out < nelts; out++)
13593 unsigned int in1 = (out << scale) + ofs;
13594 unsigned int in2 = in1 + nelts * 2;
13597 t1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in1]);
13598 t2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in2]);
13600 if (t1 == NULL_TREE || t2 == NULL_TREE)
13602 elts[out] = const_binop (MULT_EXPR, t1, t2);
13603 if (elts[out] == NULL_TREE || !CONSTANT_CLASS_P (elts[out]))
13607 return build_vector (type, elts);
13612 } /* switch (code) */
13615 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
13616 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
13620 contains_label_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
13622 switch (TREE_CODE (*tp))
13628 *walk_subtrees = 0;
13630 /* ... fall through ... */
13637 /* Return whether the sub-tree ST contains a label which is accessible from
13638 outside the sub-tree. */
13641 contains_label_p (tree st)
13644 (walk_tree_without_duplicates (&st, contains_label_1 , NULL) != NULL_TREE);
13647 /* Fold a ternary expression of code CODE and type TYPE with operands
13648 OP0, OP1, and OP2. Return the folded expression if folding is
13649 successful. Otherwise, return NULL_TREE. */
13652 fold_ternary_loc (location_t loc, enum tree_code code, tree type,
13653 tree op0, tree op1, tree op2)
13656 tree arg0 = NULL_TREE, arg1 = NULL_TREE, arg2 = NULL_TREE;
13657 enum tree_code_class kind = TREE_CODE_CLASS (code);
13659 gcc_assert (IS_EXPR_CODE_CLASS (kind)
13660 && TREE_CODE_LENGTH (code) == 3);
13662 /* If this is a commutative operation, and OP0 is a constant, move it
13663 to OP1 to reduce the number of tests below. */
13664 if (commutative_ternary_tree_code (code)
13665 && tree_swap_operands_p (op0, op1, true))
13666 return fold_build3_loc (loc, code, type, op1, op0, op2);
13668 tem = generic_simplify (loc, code, type, op0, op1, op2);
13672 /* Strip any conversions that don't change the mode. This is safe
13673 for every expression, except for a comparison expression because
13674 its signedness is derived from its operands. So, in the latter
13675 case, only strip conversions that don't change the signedness.
13677 Note that this is done as an internal manipulation within the
13678 constant folder, in order to find the simplest representation of
13679 the arguments so that their form can be studied. In any cases,
13680 the appropriate type conversions should be put back in the tree
13681 that will get out of the constant folder. */
13702 case COMPONENT_REF:
13703 if (TREE_CODE (arg0) == CONSTRUCTOR
13704 && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
13706 unsigned HOST_WIDE_INT idx;
13708 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
13715 case VEC_COND_EXPR:
13716 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13717 so all simple results must be passed through pedantic_non_lvalue. */
13718 if (TREE_CODE (arg0) == INTEGER_CST)
13720 tree unused_op = integer_zerop (arg0) ? op1 : op2;
13721 tem = integer_zerop (arg0) ? op2 : op1;
13722 /* Only optimize constant conditions when the selected branch
13723 has the same type as the COND_EXPR. This avoids optimizing
13724 away "c ? x : throw", where the throw has a void type.
13725 Avoid throwing away that operand which contains label. */
13726 if ((!TREE_SIDE_EFFECTS (unused_op)
13727 || !contains_label_p (unused_op))
13728 && (! VOID_TYPE_P (TREE_TYPE (tem))
13729 || VOID_TYPE_P (type)))
13730 return pedantic_non_lvalue_loc (loc, tem);
13733 else if (TREE_CODE (arg0) == VECTOR_CST)
13735 if (integer_all_onesp (arg0))
13736 return pedantic_omit_one_operand_loc (loc, type, arg1, arg2);
13737 if (integer_zerop (arg0))
13738 return pedantic_omit_one_operand_loc (loc, type, arg2, arg1);
13740 if ((TREE_CODE (arg1) == VECTOR_CST
13741 || TREE_CODE (arg1) == CONSTRUCTOR)
13742 && (TREE_CODE (arg2) == VECTOR_CST
13743 || TREE_CODE (arg2) == CONSTRUCTOR))
13745 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
13746 unsigned char *sel = XALLOCAVEC (unsigned char, nelts);
13747 gcc_assert (nelts == VECTOR_CST_NELTS (arg0));
13748 for (i = 0; i < nelts; i++)
13750 tree val = VECTOR_CST_ELT (arg0, i);
13751 if (integer_all_onesp (val))
13753 else if (integer_zerop (val))
13754 sel[i] = nelts + i;
13755 else /* Currently unreachable. */
13758 tree t = fold_vec_perm (type, arg1, arg2, sel);
13759 if (t != NULL_TREE)
13764 if (operand_equal_p (arg1, op2, 0))
13765 return pedantic_omit_one_operand_loc (loc, type, arg1, arg0);
13767 /* If we have A op B ? A : C, we may be able to convert this to a
13768 simpler expression, depending on the operation and the values
13769 of B and C. Signed zeros prevent all of these transformations,
13770 for reasons given above each one.
13772 Also try swapping the arguments and inverting the conditional. */
13773 if (COMPARISON_CLASS_P (arg0)
13774 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13775 arg1, TREE_OPERAND (arg0, 1))
13776 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
13778 tem = fold_cond_expr_with_comparison (loc, type, arg0, op1, op2);
13783 if (COMPARISON_CLASS_P (arg0)
13784 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13786 TREE_OPERAND (arg0, 1))
13787 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
13789 location_t loc0 = expr_location_or (arg0, loc);
13790 tem = fold_invert_truthvalue (loc0, arg0);
13791 if (tem && COMPARISON_CLASS_P (tem))
13793 tem = fold_cond_expr_with_comparison (loc, type, tem, op2, op1);
13799 /* If the second operand is simpler than the third, swap them
13800 since that produces better jump optimization results. */
13801 if (truth_value_p (TREE_CODE (arg0))
13802 && tree_swap_operands_p (op1, op2, false))
13804 location_t loc0 = expr_location_or (arg0, loc);
13805 /* See if this can be inverted. If it can't, possibly because
13806 it was a floating-point inequality comparison, don't do
13808 tem = fold_invert_truthvalue (loc0, arg0);
13810 return fold_build3_loc (loc, code, type, tem, op2, op1);
13813 /* Convert A ? 1 : 0 to simply A. */
13814 if ((code == VEC_COND_EXPR ? integer_all_onesp (op1)
13815 : (integer_onep (op1)
13816 && !VECTOR_TYPE_P (type)))
13817 && integer_zerop (op2)
13818 /* If we try to convert OP0 to our type, the
13819 call to fold will try to move the conversion inside
13820 a COND, which will recurse. In that case, the COND_EXPR
13821 is probably the best choice, so leave it alone. */
13822 && type == TREE_TYPE (arg0))
13823 return pedantic_non_lvalue_loc (loc, arg0);
13825 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13826 over COND_EXPR in cases such as floating point comparisons. */
13827 if (integer_zerop (op1)
13828 && (code == VEC_COND_EXPR ? integer_all_onesp (op2)
13829 : (integer_onep (op2)
13830 && !VECTOR_TYPE_P (type)))
13831 && truth_value_p (TREE_CODE (arg0)))
13832 return pedantic_non_lvalue_loc (loc,
13833 fold_convert_loc (loc, type,
13834 invert_truthvalue_loc (loc,
13837 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13838 if (TREE_CODE (arg0) == LT_EXPR
13839 && integer_zerop (TREE_OPERAND (arg0, 1))
13840 && integer_zerop (op2)
13841 && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
13843 /* sign_bit_p looks through both zero and sign extensions,
13844 but for this optimization only sign extensions are
13846 tree tem2 = TREE_OPERAND (arg0, 0);
13847 while (tem != tem2)
13849 if (TREE_CODE (tem2) != NOP_EXPR
13850 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2, 0))))
13855 tem2 = TREE_OPERAND (tem2, 0);
13857 /* sign_bit_p only checks ARG1 bits within A's precision.
13858 If <sign bit of A> has wider type than A, bits outside
13859 of A's precision in <sign bit of A> need to be checked.
13860 If they are all 0, this optimization needs to be done
13861 in unsigned A's type, if they are all 1 in signed A's type,
13862 otherwise this can't be done. */
13864 && TYPE_PRECISION (TREE_TYPE (tem))
13865 < TYPE_PRECISION (TREE_TYPE (arg1))
13866 && TYPE_PRECISION (TREE_TYPE (tem))
13867 < TYPE_PRECISION (type))
13869 int inner_width, outer_width;
13872 inner_width = TYPE_PRECISION (TREE_TYPE (tem));
13873 outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
13874 if (outer_width > TYPE_PRECISION (type))
13875 outer_width = TYPE_PRECISION (type);
13877 wide_int mask = wi::shifted_mask
13878 (inner_width, outer_width - inner_width, false,
13879 TYPE_PRECISION (TREE_TYPE (arg1)));
13881 wide_int common = mask & arg1;
13882 if (common == mask)
13884 tem_type = signed_type_for (TREE_TYPE (tem));
13885 tem = fold_convert_loc (loc, tem_type, tem);
13887 else if (common == 0)
13889 tem_type = unsigned_type_for (TREE_TYPE (tem));
13890 tem = fold_convert_loc (loc, tem_type, tem);
13898 fold_convert_loc (loc, type,
13899 fold_build2_loc (loc, BIT_AND_EXPR,
13900 TREE_TYPE (tem), tem,
13901 fold_convert_loc (loc,
13906 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
13907 already handled above. */
13908 if (TREE_CODE (arg0) == BIT_AND_EXPR
13909 && integer_onep (TREE_OPERAND (arg0, 1))
13910 && integer_zerop (op2)
13911 && integer_pow2p (arg1))
13913 tree tem = TREE_OPERAND (arg0, 0);
13915 if (TREE_CODE (tem) == RSHIFT_EXPR
13916 && tree_fits_uhwi_p (TREE_OPERAND (tem, 1))
13917 && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
13918 tree_to_uhwi (TREE_OPERAND (tem, 1)))
13919 return fold_build2_loc (loc, BIT_AND_EXPR, type,
13920 TREE_OPERAND (tem, 0), arg1);
13923 /* A & N ? N : 0 is simply A & N if N is a power of two. This
13924 is probably obsolete because the first operand should be a
13925 truth value (that's why we have the two cases above), but let's
13926 leave it in until we can confirm this for all front-ends. */
13927 if (integer_zerop (op2)
13928 && TREE_CODE (arg0) == NE_EXPR
13929 && integer_zerop (TREE_OPERAND (arg0, 1))
13930 && integer_pow2p (arg1)
13931 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
13932 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13933 arg1, OEP_ONLY_CONST))
13934 return pedantic_non_lvalue_loc (loc,
13935 fold_convert_loc (loc, type,
13936 TREE_OPERAND (arg0, 0)));
13938 /* Disable the transformations below for vectors, since
13939 fold_binary_op_with_conditional_arg may undo them immediately,
13940 yielding an infinite loop. */
13941 if (code == VEC_COND_EXPR)
13944 /* Convert A ? B : 0 into A && B if A and B are truth values. */
13945 if (integer_zerop (op2)
13946 && truth_value_p (TREE_CODE (arg0))
13947 && truth_value_p (TREE_CODE (arg1))
13948 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
13949 return fold_build2_loc (loc, code == VEC_COND_EXPR ? BIT_AND_EXPR
13950 : TRUTH_ANDIF_EXPR,
13951 type, fold_convert_loc (loc, type, arg0), arg1);
13953 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
13954 if (code == VEC_COND_EXPR ? integer_all_onesp (op2) : integer_onep (op2)
13955 && truth_value_p (TREE_CODE (arg0))
13956 && truth_value_p (TREE_CODE (arg1))
13957 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
13959 location_t loc0 = expr_location_or (arg0, loc);
13960 /* Only perform transformation if ARG0 is easily inverted. */
13961 tem = fold_invert_truthvalue (loc0, arg0);
13963 return fold_build2_loc (loc, code == VEC_COND_EXPR
13966 type, fold_convert_loc (loc, type, tem),
13970 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
13971 if (integer_zerop (arg1)
13972 && truth_value_p (TREE_CODE (arg0))
13973 && truth_value_p (TREE_CODE (op2))
13974 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
13976 location_t loc0 = expr_location_or (arg0, loc);
13977 /* Only perform transformation if ARG0 is easily inverted. */
13978 tem = fold_invert_truthvalue (loc0, arg0);
13980 return fold_build2_loc (loc, code == VEC_COND_EXPR
13981 ? BIT_AND_EXPR : TRUTH_ANDIF_EXPR,
13982 type, fold_convert_loc (loc, type, tem),
13986 /* Convert A ? 1 : B into A || B if A and B are truth values. */
13987 if (code == VEC_COND_EXPR ? integer_all_onesp (arg1) : integer_onep (arg1)
13988 && truth_value_p (TREE_CODE (arg0))
13989 && truth_value_p (TREE_CODE (op2))
13990 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
13991 return fold_build2_loc (loc, code == VEC_COND_EXPR
13992 ? BIT_IOR_EXPR : TRUTH_ORIF_EXPR,
13993 type, fold_convert_loc (loc, type, arg0), op2);
13998 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
13999 of fold_ternary on them. */
14000 gcc_unreachable ();
14002 case BIT_FIELD_REF:
14003 if ((TREE_CODE (arg0) == VECTOR_CST
14004 || (TREE_CODE (arg0) == CONSTRUCTOR
14005 && TREE_CODE (TREE_TYPE (arg0)) == VECTOR_TYPE))
14006 && (type == TREE_TYPE (TREE_TYPE (arg0))
14007 || (TREE_CODE (type) == VECTOR_TYPE
14008 && TREE_TYPE (type) == TREE_TYPE (TREE_TYPE (arg0)))))
14010 tree eltype = TREE_TYPE (TREE_TYPE (arg0));
14011 unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
14012 unsigned HOST_WIDE_INT n = tree_to_uhwi (arg1);
14013 unsigned HOST_WIDE_INT idx = tree_to_uhwi (op2);
14016 && (idx % width) == 0
14017 && (n % width) == 0
14018 && ((idx + n) / width) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
14023 if (TREE_CODE (arg0) == VECTOR_CST)
14026 return VECTOR_CST_ELT (arg0, idx);
14028 tree *vals = XALLOCAVEC (tree, n);
14029 for (unsigned i = 0; i < n; ++i)
14030 vals[i] = VECTOR_CST_ELT (arg0, idx + i);
14031 return build_vector (type, vals);
14034 /* Constructor elements can be subvectors. */
14035 unsigned HOST_WIDE_INT k = 1;
14036 if (CONSTRUCTOR_NELTS (arg0) != 0)
14038 tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (arg0, 0)->value);
14039 if (TREE_CODE (cons_elem) == VECTOR_TYPE)
14040 k = TYPE_VECTOR_SUBPARTS (cons_elem);
14043 /* We keep an exact subset of the constructor elements. */
14044 if ((idx % k) == 0 && (n % k) == 0)
14046 if (CONSTRUCTOR_NELTS (arg0) == 0)
14047 return build_constructor (type, NULL);
14052 if (idx < CONSTRUCTOR_NELTS (arg0))
14053 return CONSTRUCTOR_ELT (arg0, idx)->value;
14054 return build_zero_cst (type);
14057 vec<constructor_elt, va_gc> *vals;
14058 vec_alloc (vals, n);
14059 for (unsigned i = 0;
14060 i < n && idx + i < CONSTRUCTOR_NELTS (arg0);
14062 CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE,
14064 (arg0, idx + i)->value);
14065 return build_constructor (type, vals);
14067 /* The bitfield references a single constructor element. */
14068 else if (idx + n <= (idx / k + 1) * k)
14070 if (CONSTRUCTOR_NELTS (arg0) <= idx / k)
14071 return build_zero_cst (type);
14073 return CONSTRUCTOR_ELT (arg0, idx / k)->value;
14075 return fold_build3_loc (loc, code, type,
14076 CONSTRUCTOR_ELT (arg0, idx / k)->value, op1,
14077 build_int_cst (TREE_TYPE (op2), (idx % k) * width));
14082 /* A bit-field-ref that referenced the full argument can be stripped. */
14083 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
14084 && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_to_uhwi (arg1)
14085 && integer_zerop (op2))
14086 return fold_convert_loc (loc, type, arg0);
14088 /* On constants we can use native encode/interpret to constant
14089 fold (nearly) all BIT_FIELD_REFs. */
14090 if (CONSTANT_CLASS_P (arg0)
14091 && can_native_interpret_type_p (type)
14092 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0)))
14093 /* This limitation should not be necessary, we just need to
14094 round this up to mode size. */
14095 && tree_to_uhwi (op1) % BITS_PER_UNIT == 0
14096 /* Need bit-shifting of the buffer to relax the following. */
14097 && tree_to_uhwi (op2) % BITS_PER_UNIT == 0)
14099 unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (op2);
14100 unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (op1);
14101 unsigned HOST_WIDE_INT clen;
14102 clen = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0)));
14103 /* ??? We cannot tell native_encode_expr to start at
14104 some random byte only. So limit us to a reasonable amount
14108 unsigned char *b = XALLOCAVEC (unsigned char, clen);
14109 unsigned HOST_WIDE_INT len = native_encode_expr (arg0, b, clen);
14111 && len * BITS_PER_UNIT >= bitpos + bitsize)
14113 tree v = native_interpret_expr (type,
14114 b + bitpos / BITS_PER_UNIT,
14115 bitsize / BITS_PER_UNIT);
14125 /* For integers we can decompose the FMA if possible. */
14126 if (TREE_CODE (arg0) == INTEGER_CST
14127 && TREE_CODE (arg1) == INTEGER_CST)
14128 return fold_build2_loc (loc, PLUS_EXPR, type,
14129 const_binop (MULT_EXPR, arg0, arg1), arg2);
14130 if (integer_zerop (arg2))
14131 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
14133 return fold_fma (loc, type, arg0, arg1, arg2);
14135 case VEC_PERM_EXPR:
14136 if (TREE_CODE (arg2) == VECTOR_CST)
14138 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i, mask, mask2;
14139 unsigned char *sel = XALLOCAVEC (unsigned char, 2 * nelts);
14140 unsigned char *sel2 = sel + nelts;
14141 bool need_mask_canon = false;
14142 bool need_mask_canon2 = false;
14143 bool all_in_vec0 = true;
14144 bool all_in_vec1 = true;
14145 bool maybe_identity = true;
14146 bool single_arg = (op0 == op1);
14147 bool changed = false;
14149 mask2 = 2 * nelts - 1;
14150 mask = single_arg ? (nelts - 1) : mask2;
14151 gcc_assert (nelts == VECTOR_CST_NELTS (arg2));
14152 for (i = 0; i < nelts; i++)
14154 tree val = VECTOR_CST_ELT (arg2, i);
14155 if (TREE_CODE (val) != INTEGER_CST)
14158 /* Make sure that the perm value is in an acceptable
14161 need_mask_canon |= wi::gtu_p (t, mask);
14162 need_mask_canon2 |= wi::gtu_p (t, mask2);
14163 sel[i] = t.to_uhwi () & mask;
14164 sel2[i] = t.to_uhwi () & mask2;
14166 if (sel[i] < nelts)
14167 all_in_vec1 = false;
14169 all_in_vec0 = false;
14171 if ((sel[i] & (nelts-1)) != i)
14172 maybe_identity = false;
14175 if (maybe_identity)
14185 else if (all_in_vec1)
14188 for (i = 0; i < nelts; i++)
14190 need_mask_canon = true;
14193 if ((TREE_CODE (op0) == VECTOR_CST
14194 || TREE_CODE (op0) == CONSTRUCTOR)
14195 && (TREE_CODE (op1) == VECTOR_CST
14196 || TREE_CODE (op1) == CONSTRUCTOR))
14198 tree t = fold_vec_perm (type, op0, op1, sel);
14199 if (t != NULL_TREE)
14203 if (op0 == op1 && !single_arg)
14206 /* Some targets are deficient and fail to expand a single
14207 argument permutation while still allowing an equivalent
14208 2-argument version. */
14209 if (need_mask_canon && arg2 == op2
14210 && !can_vec_perm_p (TYPE_MODE (type), false, sel)
14211 && can_vec_perm_p (TYPE_MODE (type), false, sel2))
14213 need_mask_canon = need_mask_canon2;
14217 if (need_mask_canon && arg2 == op2)
14219 tree *tsel = XALLOCAVEC (tree, nelts);
14220 tree eltype = TREE_TYPE (TREE_TYPE (arg2));
14221 for (i = 0; i < nelts; i++)
14222 tsel[i] = build_int_cst (eltype, sel[i]);
14223 op2 = build_vector (TREE_TYPE (arg2), tsel);
14228 return build3_loc (loc, VEC_PERM_EXPR, type, op0, op1, op2);
14234 } /* switch (code) */
14237 /* Perform constant folding and related simplification of EXPR.
14238 The related simplifications include x*1 => x, x*0 => 0, etc.,
14239 and application of the associative law.
14240 NOP_EXPR conversions may be removed freely (as long as we
14241 are careful not to change the type of the overall expression).
14242 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14243 but we can constant-fold them if they have constant operands. */
14245 #ifdef ENABLE_FOLD_CHECKING
14246 # define fold(x) fold_1 (x)
14247 static tree fold_1 (tree);
14253 const tree t = expr;
14254 enum tree_code code = TREE_CODE (t);
14255 enum tree_code_class kind = TREE_CODE_CLASS (code);
14257 location_t loc = EXPR_LOCATION (expr);
14259 /* Return right away if a constant. */
14260 if (kind == tcc_constant)
14263 /* CALL_EXPR-like objects with variable numbers of operands are
14264 treated specially. */
14265 if (kind == tcc_vl_exp)
14267 if (code == CALL_EXPR)
14269 tem = fold_call_expr (loc, expr, false);
14270 return tem ? tem : expr;
14275 if (IS_EXPR_CODE_CLASS (kind))
14277 tree type = TREE_TYPE (t);
14278 tree op0, op1, op2;
14280 switch (TREE_CODE_LENGTH (code))
14283 op0 = TREE_OPERAND (t, 0);
14284 tem = fold_unary_loc (loc, code, type, op0);
14285 return tem ? tem : expr;
14287 op0 = TREE_OPERAND (t, 0);
14288 op1 = TREE_OPERAND (t, 1);
14289 tem = fold_binary_loc (loc, code, type, op0, op1);
14290 return tem ? tem : expr;
14292 op0 = TREE_OPERAND (t, 0);
14293 op1 = TREE_OPERAND (t, 1);
14294 op2 = TREE_OPERAND (t, 2);
14295 tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
14296 return tem ? tem : expr;
14306 tree op0 = TREE_OPERAND (t, 0);
14307 tree op1 = TREE_OPERAND (t, 1);
14309 if (TREE_CODE (op1) == INTEGER_CST
14310 && TREE_CODE (op0) == CONSTRUCTOR
14311 && ! type_contains_placeholder_p (TREE_TYPE (op0)))
14313 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (op0);
14314 unsigned HOST_WIDE_INT end = vec_safe_length (elts);
14315 unsigned HOST_WIDE_INT begin = 0;
14317 /* Find a matching index by means of a binary search. */
14318 while (begin != end)
14320 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
14321 tree index = (*elts)[middle].index;
14323 if (TREE_CODE (index) == INTEGER_CST
14324 && tree_int_cst_lt (index, op1))
14325 begin = middle + 1;
14326 else if (TREE_CODE (index) == INTEGER_CST
14327 && tree_int_cst_lt (op1, index))
14329 else if (TREE_CODE (index) == RANGE_EXPR
14330 && tree_int_cst_lt (TREE_OPERAND (index, 1), op1))
14331 begin = middle + 1;
14332 else if (TREE_CODE (index) == RANGE_EXPR
14333 && tree_int_cst_lt (op1, TREE_OPERAND (index, 0)))
14336 return (*elts)[middle].value;
14343 /* Return a VECTOR_CST if possible. */
14346 tree type = TREE_TYPE (t);
14347 if (TREE_CODE (type) != VECTOR_TYPE)
14350 tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
14351 unsigned HOST_WIDE_INT idx, pos = 0;
14354 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, value)
14356 if (!CONSTANT_CLASS_P (value))
14358 if (TREE_CODE (value) == VECTOR_CST)
14360 for (unsigned i = 0; i < VECTOR_CST_NELTS (value); ++i)
14361 vec[pos++] = VECTOR_CST_ELT (value, i);
14364 vec[pos++] = value;
14366 for (; pos < TYPE_VECTOR_SUBPARTS (type); ++pos)
14367 vec[pos] = build_zero_cst (TREE_TYPE (type));
14369 return build_vector (type, vec);
14373 return fold (DECL_INITIAL (t));
14377 } /* switch (code) */
14380 #ifdef ENABLE_FOLD_CHECKING
14383 static void fold_checksum_tree (const_tree, struct md5_ctx *,
14384 hash_table<pointer_hash<const tree_node> > *);
14385 static void fold_check_failed (const_tree, const_tree);
14386 void print_fold_checksum (const_tree);
14388 /* When --enable-checking=fold, compute a digest of expr before
14389 and after actual fold call to see if fold did not accidentally
14390 change original expr. */
14396 struct md5_ctx ctx;
14397 unsigned char checksum_before[16], checksum_after[16];
14398 hash_table<pointer_hash<const tree_node> > ht (32);
14400 md5_init_ctx (&ctx);
14401 fold_checksum_tree (expr, &ctx, &ht);
14402 md5_finish_ctx (&ctx, checksum_before);
14405 ret = fold_1 (expr);
14407 md5_init_ctx (&ctx);
14408 fold_checksum_tree (expr, &ctx, &ht);
14409 md5_finish_ctx (&ctx, checksum_after);
14411 if (memcmp (checksum_before, checksum_after, 16))
14412 fold_check_failed (expr, ret);
14418 print_fold_checksum (const_tree expr)
14420 struct md5_ctx ctx;
14421 unsigned char checksum[16], cnt;
14422 hash_table<pointer_hash<const tree_node> > ht (32);
14424 md5_init_ctx (&ctx);
14425 fold_checksum_tree (expr, &ctx, &ht);
14426 md5_finish_ctx (&ctx, checksum);
14427 for (cnt = 0; cnt < 16; ++cnt)
14428 fprintf (stderr, "%02x", checksum[cnt]);
14429 putc ('\n', stderr);
14433 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
14435 internal_error ("fold check: original tree changed by fold");
14439 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx,
14440 hash_table<pointer_hash <const tree_node> > *ht)
14442 const tree_node **slot;
14443 enum tree_code code;
14444 union tree_node buf;
14450 slot = ht->find_slot (expr, INSERT);
14454 code = TREE_CODE (expr);
14455 if (TREE_CODE_CLASS (code) == tcc_declaration
14456 && DECL_ASSEMBLER_NAME_SET_P (expr))
14458 /* Allow DECL_ASSEMBLER_NAME to be modified. */
14459 memcpy ((char *) &buf, expr, tree_size (expr));
14460 SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
14461 expr = (tree) &buf;
14463 else if (TREE_CODE_CLASS (code) == tcc_type
14464 && (TYPE_POINTER_TO (expr)
14465 || TYPE_REFERENCE_TO (expr)
14466 || TYPE_CACHED_VALUES_P (expr)
14467 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
14468 || TYPE_NEXT_VARIANT (expr)))
14470 /* Allow these fields to be modified. */
14472 memcpy ((char *) &buf, expr, tree_size (expr));
14473 expr = tmp = (tree) &buf;
14474 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
14475 TYPE_POINTER_TO (tmp) = NULL;
14476 TYPE_REFERENCE_TO (tmp) = NULL;
14477 TYPE_NEXT_VARIANT (tmp) = NULL;
14478 if (TYPE_CACHED_VALUES_P (tmp))
14480 TYPE_CACHED_VALUES_P (tmp) = 0;
14481 TYPE_CACHED_VALUES (tmp) = NULL;
14484 md5_process_bytes (expr, tree_size (expr), ctx);
14485 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
14486 fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
14487 if (TREE_CODE_CLASS (code) != tcc_type
14488 && TREE_CODE_CLASS (code) != tcc_declaration
14489 && code != TREE_LIST
14490 && code != SSA_NAME
14491 && CODE_CONTAINS_STRUCT (code, TS_COMMON))
14492 fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
14493 switch (TREE_CODE_CLASS (code))
14499 md5_process_bytes (TREE_STRING_POINTER (expr),
14500 TREE_STRING_LENGTH (expr), ctx);
14503 fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
14504 fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
14507 for (i = 0; i < (int) VECTOR_CST_NELTS (expr); ++i)
14508 fold_checksum_tree (VECTOR_CST_ELT (expr, i), ctx, ht);
14514 case tcc_exceptional:
14518 fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
14519 fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
14520 expr = TREE_CHAIN (expr);
14521 goto recursive_label;
14524 for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
14525 fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
14531 case tcc_expression:
14532 case tcc_reference:
14533 case tcc_comparison:
14536 case tcc_statement:
14538 len = TREE_OPERAND_LENGTH (expr);
14539 for (i = 0; i < len; ++i)
14540 fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
14542 case tcc_declaration:
14543 fold_checksum_tree (DECL_NAME (expr), ctx, ht);
14544 fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
14545 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
14547 fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
14548 fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
14549 fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
14550 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
14551 fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
14554 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
14556 if (TREE_CODE (expr) == FUNCTION_DECL)
14558 fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
14559 fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
14561 fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
14565 if (TREE_CODE (expr) == ENUMERAL_TYPE)
14566 fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
14567 fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
14568 fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
14569 fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
14570 fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
14571 if (INTEGRAL_TYPE_P (expr)
14572 || SCALAR_FLOAT_TYPE_P (expr))
14574 fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
14575 fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
14577 fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
14578 if (TREE_CODE (expr) == RECORD_TYPE
14579 || TREE_CODE (expr) == UNION_TYPE
14580 || TREE_CODE (expr) == QUAL_UNION_TYPE)
14581 fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
14582 fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
14589 /* Helper function for outputting the checksum of a tree T. When
14590 debugging with gdb, you can "define mynext" to be "next" followed
14591 by "call debug_fold_checksum (op0)", then just trace down till the
14594 DEBUG_FUNCTION void
14595 debug_fold_checksum (const_tree t)
14598 unsigned char checksum[16];
14599 struct md5_ctx ctx;
14600 hash_table<pointer_hash<const tree_node> > ht (32);
14602 md5_init_ctx (&ctx);
14603 fold_checksum_tree (t, &ctx, &ht);
14604 md5_finish_ctx (&ctx, checksum);
14607 for (i = 0; i < 16; i++)
14608 fprintf (stderr, "%d ", checksum[i]);
14610 fprintf (stderr, "\n");
14615 /* Fold a unary tree expression with code CODE of type TYPE with an
14616 operand OP0. LOC is the location of the resulting expression.
14617 Return a folded expression if successful. Otherwise, return a tree
14618 expression with code CODE of type TYPE with an operand OP0. */
14621 fold_build1_stat_loc (location_t loc,
14622 enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
14625 #ifdef ENABLE_FOLD_CHECKING
14626 unsigned char checksum_before[16], checksum_after[16];
14627 struct md5_ctx ctx;
14628 hash_table<pointer_hash<const tree_node> > ht (32);
14630 md5_init_ctx (&ctx);
14631 fold_checksum_tree (op0, &ctx, &ht);
14632 md5_finish_ctx (&ctx, checksum_before);
14636 tem = fold_unary_loc (loc, code, type, op0);
14638 tem = build1_stat_loc (loc, code, type, op0 PASS_MEM_STAT);
14640 #ifdef ENABLE_FOLD_CHECKING
14641 md5_init_ctx (&ctx);
14642 fold_checksum_tree (op0, &ctx, &ht);
14643 md5_finish_ctx (&ctx, checksum_after);
14645 if (memcmp (checksum_before, checksum_after, 16))
14646 fold_check_failed (op0, tem);
14651 /* Fold a binary tree expression with code CODE of type TYPE with
14652 operands OP0 and OP1. LOC is the location of the resulting
14653 expression. Return a folded expression if successful. Otherwise,
14654 return a tree expression with code CODE of type TYPE with operands
14658 fold_build2_stat_loc (location_t loc,
14659 enum tree_code code, tree type, tree op0, tree op1
14663 #ifdef ENABLE_FOLD_CHECKING
14664 unsigned char checksum_before_op0[16],
14665 checksum_before_op1[16],
14666 checksum_after_op0[16],
14667 checksum_after_op1[16];
14668 struct md5_ctx ctx;
14669 hash_table<pointer_hash<const tree_node> > ht (32);
14671 md5_init_ctx (&ctx);
14672 fold_checksum_tree (op0, &ctx, &ht);
14673 md5_finish_ctx (&ctx, checksum_before_op0);
14676 md5_init_ctx (&ctx);
14677 fold_checksum_tree (op1, &ctx, &ht);
14678 md5_finish_ctx (&ctx, checksum_before_op1);
14682 tem = fold_binary_loc (loc, code, type, op0, op1);
14684 tem = build2_stat_loc (loc, code, type, op0, op1 PASS_MEM_STAT);
14686 #ifdef ENABLE_FOLD_CHECKING
14687 md5_init_ctx (&ctx);
14688 fold_checksum_tree (op0, &ctx, &ht);
14689 md5_finish_ctx (&ctx, checksum_after_op0);
14692 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14693 fold_check_failed (op0, tem);
14695 md5_init_ctx (&ctx);
14696 fold_checksum_tree (op1, &ctx, &ht);
14697 md5_finish_ctx (&ctx, checksum_after_op1);
14699 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14700 fold_check_failed (op1, tem);
14705 /* Fold a ternary tree expression with code CODE of type TYPE with
14706 operands OP0, OP1, and OP2. Return a folded expression if
14707 successful. Otherwise, return a tree expression with code CODE of
14708 type TYPE with operands OP0, OP1, and OP2. */
14711 fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
14712 tree op0, tree op1, tree op2 MEM_STAT_DECL)
14715 #ifdef ENABLE_FOLD_CHECKING
14716 unsigned char checksum_before_op0[16],
14717 checksum_before_op1[16],
14718 checksum_before_op2[16],
14719 checksum_after_op0[16],
14720 checksum_after_op1[16],
14721 checksum_after_op2[16];
14722 struct md5_ctx ctx;
14723 hash_table<pointer_hash<const tree_node> > ht (32);
14725 md5_init_ctx (&ctx);
14726 fold_checksum_tree (op0, &ctx, &ht);
14727 md5_finish_ctx (&ctx, checksum_before_op0);
14730 md5_init_ctx (&ctx);
14731 fold_checksum_tree (op1, &ctx, &ht);
14732 md5_finish_ctx (&ctx, checksum_before_op1);
14735 md5_init_ctx (&ctx);
14736 fold_checksum_tree (op2, &ctx, &ht);
14737 md5_finish_ctx (&ctx, checksum_before_op2);
14741 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
14742 tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
14744 tem = build3_stat_loc (loc, code, type, op0, op1, op2 PASS_MEM_STAT);
14746 #ifdef ENABLE_FOLD_CHECKING
14747 md5_init_ctx (&ctx);
14748 fold_checksum_tree (op0, &ctx, &ht);
14749 md5_finish_ctx (&ctx, checksum_after_op0);
14752 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14753 fold_check_failed (op0, tem);
14755 md5_init_ctx (&ctx);
14756 fold_checksum_tree (op1, &ctx, &ht);
14757 md5_finish_ctx (&ctx, checksum_after_op1);
14760 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14761 fold_check_failed (op1, tem);
14763 md5_init_ctx (&ctx);
14764 fold_checksum_tree (op2, &ctx, &ht);
14765 md5_finish_ctx (&ctx, checksum_after_op2);
14767 if (memcmp (checksum_before_op2, checksum_after_op2, 16))
14768 fold_check_failed (op2, tem);
14773 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14774 arguments in ARGARRAY, and a null static chain.
14775 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14776 of type TYPE from the given operands as constructed by build_call_array. */
14779 fold_build_call_array_loc (location_t loc, tree type, tree fn,
14780 int nargs, tree *argarray)
14783 #ifdef ENABLE_FOLD_CHECKING
14784 unsigned char checksum_before_fn[16],
14785 checksum_before_arglist[16],
14786 checksum_after_fn[16],
14787 checksum_after_arglist[16];
14788 struct md5_ctx ctx;
14789 hash_table<pointer_hash<const tree_node> > ht (32);
14792 md5_init_ctx (&ctx);
14793 fold_checksum_tree (fn, &ctx, &ht);
14794 md5_finish_ctx (&ctx, checksum_before_fn);
14797 md5_init_ctx (&ctx);
14798 for (i = 0; i < nargs; i++)
14799 fold_checksum_tree (argarray[i], &ctx, &ht);
14800 md5_finish_ctx (&ctx, checksum_before_arglist);
14804 tem = fold_builtin_call_array (loc, type, fn, nargs, argarray);
14806 #ifdef ENABLE_FOLD_CHECKING
14807 md5_init_ctx (&ctx);
14808 fold_checksum_tree (fn, &ctx, &ht);
14809 md5_finish_ctx (&ctx, checksum_after_fn);
14812 if (memcmp (checksum_before_fn, checksum_after_fn, 16))
14813 fold_check_failed (fn, tem);
14815 md5_init_ctx (&ctx);
14816 for (i = 0; i < nargs; i++)
14817 fold_checksum_tree (argarray[i], &ctx, &ht);
14818 md5_finish_ctx (&ctx, checksum_after_arglist);
14820 if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
14821 fold_check_failed (NULL_TREE, tem);
14826 /* Perform constant folding and related simplification of initializer
14827 expression EXPR. These behave identically to "fold_buildN" but ignore
14828 potential run-time traps and exceptions that fold must preserve. */
14830 #define START_FOLD_INIT \
14831 int saved_signaling_nans = flag_signaling_nans;\
14832 int saved_trapping_math = flag_trapping_math;\
14833 int saved_rounding_math = flag_rounding_math;\
14834 int saved_trapv = flag_trapv;\
14835 int saved_folding_initializer = folding_initializer;\
14836 flag_signaling_nans = 0;\
14837 flag_trapping_math = 0;\
14838 flag_rounding_math = 0;\
14840 folding_initializer = 1;
14842 #define END_FOLD_INIT \
14843 flag_signaling_nans = saved_signaling_nans;\
14844 flag_trapping_math = saved_trapping_math;\
14845 flag_rounding_math = saved_rounding_math;\
14846 flag_trapv = saved_trapv;\
14847 folding_initializer = saved_folding_initializer;
14850 fold_build1_initializer_loc (location_t loc, enum tree_code code,
14851 tree type, tree op)
14856 result = fold_build1_loc (loc, code, type, op);
14863 fold_build2_initializer_loc (location_t loc, enum tree_code code,
14864 tree type, tree op0, tree op1)
14869 result = fold_build2_loc (loc, code, type, op0, op1);
14876 fold_build_call_array_initializer_loc (location_t loc, tree type, tree fn,
14877 int nargs, tree *argarray)
14882 result = fold_build_call_array_loc (loc, type, fn, nargs, argarray);
14888 #undef START_FOLD_INIT
14889 #undef END_FOLD_INIT
14891 /* Determine if first argument is a multiple of second argument. Return 0 if
14892 it is not, or we cannot easily determined it to be.
14894 An example of the sort of thing we care about (at this point; this routine
14895 could surely be made more general, and expanded to do what the *_DIV_EXPR's
14896 fold cases do now) is discovering that
14898 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14904 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
14906 This code also handles discovering that
14908 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14910 is a multiple of 8 so we don't have to worry about dealing with a
14911 possible remainder.
14913 Note that we *look* inside a SAVE_EXPR only to determine how it was
14914 calculated; it is not safe for fold to do much of anything else with the
14915 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
14916 at run time. For example, the latter example above *cannot* be implemented
14917 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
14918 evaluation time of the original SAVE_EXPR is not necessarily the same at
14919 the time the new expression is evaluated. The only optimization of this
14920 sort that would be valid is changing
14922 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
14926 SAVE_EXPR (I) * SAVE_EXPR (J)
14928 (where the same SAVE_EXPR (J) is used in the original and the
14929 transformed version). */
14932 multiple_of_p (tree type, const_tree top, const_tree bottom)
14934 if (operand_equal_p (top, bottom, 0))
14937 if (TREE_CODE (type) != INTEGER_TYPE)
14940 switch (TREE_CODE (top))
14943 /* Bitwise and provides a power of two multiple. If the mask is
14944 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
14945 if (!integer_pow2p (bottom))
14950 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14951 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14955 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
14956 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
14959 if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
14963 op1 = TREE_OPERAND (top, 1);
14964 /* const_binop may not detect overflow correctly,
14965 so check for it explicitly here. */
14966 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
14967 && 0 != (t1 = fold_convert (type,
14968 const_binop (LSHIFT_EXPR,
14971 && !TREE_OVERFLOW (t1))
14972 return multiple_of_p (type, t1, bottom);
14977 /* Can't handle conversions from non-integral or wider integral type. */
14978 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
14979 || (TYPE_PRECISION (type)
14980 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
14983 /* .. fall through ... */
14986 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
14989 return (multiple_of_p (type, TREE_OPERAND (top, 1), bottom)
14990 && multiple_of_p (type, TREE_OPERAND (top, 2), bottom));
14993 if (TREE_CODE (bottom) != INTEGER_CST
14994 || integer_zerop (bottom)
14995 || (TYPE_UNSIGNED (type)
14996 && (tree_int_cst_sgn (top) < 0
14997 || tree_int_cst_sgn (bottom) < 0)))
14999 return wi::multiple_of_p (wi::to_widest (top), wi::to_widest (bottom),
15007 /* Return true if CODE or TYPE is known to be non-negative. */
15010 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
15012 if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
15013 && truth_value_p (code))
15014 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15015 have a signed:1 type (where the value is -1 and 0). */
15020 /* Return true if (CODE OP0) is known to be non-negative. If the return
15021 value is based on the assumption that signed overflow is undefined,
15022 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15023 *STRICT_OVERFLOW_P. */
15026 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
15027 bool *strict_overflow_p)
15029 if (TYPE_UNSIGNED (type))
15035 /* We can't return 1 if flag_wrapv is set because
15036 ABS_EXPR<INT_MIN> = INT_MIN. */
15037 if (!INTEGRAL_TYPE_P (type))
15039 if (TYPE_OVERFLOW_UNDEFINED (type))
15041 *strict_overflow_p = true;
15046 case NON_LVALUE_EXPR:
15048 case FIX_TRUNC_EXPR:
15049 return tree_expr_nonnegative_warnv_p (op0,
15050 strict_overflow_p);
15054 tree inner_type = TREE_TYPE (op0);
15055 tree outer_type = type;
15057 if (TREE_CODE (outer_type) == REAL_TYPE)
15059 if (TREE_CODE (inner_type) == REAL_TYPE)
15060 return tree_expr_nonnegative_warnv_p (op0,
15061 strict_overflow_p);
15062 if (INTEGRAL_TYPE_P (inner_type))
15064 if (TYPE_UNSIGNED (inner_type))
15066 return tree_expr_nonnegative_warnv_p (op0,
15067 strict_overflow_p);
15070 else if (INTEGRAL_TYPE_P (outer_type))
15072 if (TREE_CODE (inner_type) == REAL_TYPE)
15073 return tree_expr_nonnegative_warnv_p (op0,
15074 strict_overflow_p);
15075 if (INTEGRAL_TYPE_P (inner_type))
15076 return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
15077 && TYPE_UNSIGNED (inner_type);
15083 return tree_simple_nonnegative_warnv_p (code, type);
15086 /* We don't know sign of `t', so be conservative and return false. */
15090 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
15091 value is based on the assumption that signed overflow is undefined,
15092 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15093 *STRICT_OVERFLOW_P. */
15096 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
15097 tree op1, bool *strict_overflow_p)
15099 if (TYPE_UNSIGNED (type))
15104 case POINTER_PLUS_EXPR:
15106 if (FLOAT_TYPE_P (type))
15107 return (tree_expr_nonnegative_warnv_p (op0,
15109 && tree_expr_nonnegative_warnv_p (op1,
15110 strict_overflow_p));
15112 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
15113 both unsigned and at least 2 bits shorter than the result. */
15114 if (TREE_CODE (type) == INTEGER_TYPE
15115 && TREE_CODE (op0) == NOP_EXPR
15116 && TREE_CODE (op1) == NOP_EXPR)
15118 tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
15119 tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
15120 if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
15121 && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
15123 unsigned int prec = MAX (TYPE_PRECISION (inner1),
15124 TYPE_PRECISION (inner2)) + 1;
15125 return prec < TYPE_PRECISION (type);
15131 if (FLOAT_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
15133 /* x * x is always non-negative for floating point x
15134 or without overflow. */
15135 if (operand_equal_p (op0, op1, 0)
15136 || (tree_expr_nonnegative_warnv_p (op0, strict_overflow_p)
15137 && tree_expr_nonnegative_warnv_p (op1, strict_overflow_p)))
15139 if (TYPE_OVERFLOW_UNDEFINED (type))
15140 *strict_overflow_p = true;
15145 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
15146 both unsigned and their total bits is shorter than the result. */
15147 if (TREE_CODE (type) == INTEGER_TYPE
15148 && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
15149 && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
15151 tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
15152 ? TREE_TYPE (TREE_OPERAND (op0, 0))
15154 tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
15155 ? TREE_TYPE (TREE_OPERAND (op1, 0))
15158 bool unsigned0 = TYPE_UNSIGNED (inner0);
15159 bool unsigned1 = TYPE_UNSIGNED (inner1);
15161 if (TREE_CODE (op0) == INTEGER_CST)
15162 unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
15164 if (TREE_CODE (op1) == INTEGER_CST)
15165 unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
15167 if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
15168 && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
15170 unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
15171 ? tree_int_cst_min_precision (op0, UNSIGNED)
15172 : TYPE_PRECISION (inner0);
15174 unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
15175 ? tree_int_cst_min_precision (op1, UNSIGNED)
15176 : TYPE_PRECISION (inner1);
15178 return precision0 + precision1 < TYPE_PRECISION (type);
15185 return (tree_expr_nonnegative_warnv_p (op0,
15187 || tree_expr_nonnegative_warnv_p (op1,
15188 strict_overflow_p));
15194 case TRUNC_DIV_EXPR:
15195 case CEIL_DIV_EXPR:
15196 case FLOOR_DIV_EXPR:
15197 case ROUND_DIV_EXPR:
15198 return (tree_expr_nonnegative_warnv_p (op0,
15200 && tree_expr_nonnegative_warnv_p (op1,
15201 strict_overflow_p));
15203 case TRUNC_MOD_EXPR:
15204 case CEIL_MOD_EXPR:
15205 case FLOOR_MOD_EXPR:
15206 case ROUND_MOD_EXPR:
15207 return tree_expr_nonnegative_warnv_p (op0,
15208 strict_overflow_p);
15210 return tree_simple_nonnegative_warnv_p (code, type);
15213 /* We don't know sign of `t', so be conservative and return false. */
15217 /* Return true if T is known to be non-negative. If the return
15218 value is based on the assumption that signed overflow is undefined,
15219 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15220 *STRICT_OVERFLOW_P. */
15223 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15225 if (TYPE_UNSIGNED (TREE_TYPE (t)))
15228 switch (TREE_CODE (t))
15231 return tree_int_cst_sgn (t) >= 0;
15234 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
15237 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
15240 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15242 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
15243 strict_overflow_p));
15245 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
15248 /* We don't know sign of `t', so be conservative and return false. */
15252 /* Return true if T is known to be non-negative. If the return
15253 value is based on the assumption that signed overflow is undefined,
15254 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15255 *STRICT_OVERFLOW_P. */
15258 tree_call_nonnegative_warnv_p (tree type, tree fndecl,
15259 tree arg0, tree arg1, bool *strict_overflow_p)
15261 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
15262 switch (DECL_FUNCTION_CODE (fndecl))
15264 CASE_FLT_FN (BUILT_IN_ACOS):
15265 CASE_FLT_FN (BUILT_IN_ACOSH):
15266 CASE_FLT_FN (BUILT_IN_CABS):
15267 CASE_FLT_FN (BUILT_IN_COSH):
15268 CASE_FLT_FN (BUILT_IN_ERFC):
15269 CASE_FLT_FN (BUILT_IN_EXP):
15270 CASE_FLT_FN (BUILT_IN_EXP10):
15271 CASE_FLT_FN (BUILT_IN_EXP2):
15272 CASE_FLT_FN (BUILT_IN_FABS):
15273 CASE_FLT_FN (BUILT_IN_FDIM):
15274 CASE_FLT_FN (BUILT_IN_HYPOT):
15275 CASE_FLT_FN (BUILT_IN_POW10):
15276 CASE_INT_FN (BUILT_IN_FFS):
15277 CASE_INT_FN (BUILT_IN_PARITY):
15278 CASE_INT_FN (BUILT_IN_POPCOUNT):
15279 CASE_INT_FN (BUILT_IN_CLZ):
15280 CASE_INT_FN (BUILT_IN_CLRSB):
15281 case BUILT_IN_BSWAP32:
15282 case BUILT_IN_BSWAP64:
15286 CASE_FLT_FN (BUILT_IN_SQRT):
15287 /* sqrt(-0.0) is -0.0. */
15288 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
15290 return tree_expr_nonnegative_warnv_p (arg0,
15291 strict_overflow_p);
15293 CASE_FLT_FN (BUILT_IN_ASINH):
15294 CASE_FLT_FN (BUILT_IN_ATAN):
15295 CASE_FLT_FN (BUILT_IN_ATANH):
15296 CASE_FLT_FN (BUILT_IN_CBRT):
15297 CASE_FLT_FN (BUILT_IN_CEIL):
15298 CASE_FLT_FN (BUILT_IN_ERF):
15299 CASE_FLT_FN (BUILT_IN_EXPM1):
15300 CASE_FLT_FN (BUILT_IN_FLOOR):
15301 CASE_FLT_FN (BUILT_IN_FMOD):
15302 CASE_FLT_FN (BUILT_IN_FREXP):
15303 CASE_FLT_FN (BUILT_IN_ICEIL):
15304 CASE_FLT_FN (BUILT_IN_IFLOOR):
15305 CASE_FLT_FN (BUILT_IN_IRINT):
15306 CASE_FLT_FN (BUILT_IN_IROUND):
15307 CASE_FLT_FN (BUILT_IN_LCEIL):
15308 CASE_FLT_FN (BUILT_IN_LDEXP):
15309 CASE_FLT_FN (BUILT_IN_LFLOOR):
15310 CASE_FLT_FN (BUILT_IN_LLCEIL):
15311 CASE_FLT_FN (BUILT_IN_LLFLOOR):
15312 CASE_FLT_FN (BUILT_IN_LLRINT):
15313 CASE_FLT_FN (BUILT_IN_LLROUND):
15314 CASE_FLT_FN (BUILT_IN_LRINT):
15315 CASE_FLT_FN (BUILT_IN_LROUND):
15316 CASE_FLT_FN (BUILT_IN_MODF):
15317 CASE_FLT_FN (BUILT_IN_NEARBYINT):
15318 CASE_FLT_FN (BUILT_IN_RINT):
15319 CASE_FLT_FN (BUILT_IN_ROUND):
15320 CASE_FLT_FN (BUILT_IN_SCALB):
15321 CASE_FLT_FN (BUILT_IN_SCALBLN):
15322 CASE_FLT_FN (BUILT_IN_SCALBN):
15323 CASE_FLT_FN (BUILT_IN_SIGNBIT):
15324 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
15325 CASE_FLT_FN (BUILT_IN_SINH):
15326 CASE_FLT_FN (BUILT_IN_TANH):
15327 CASE_FLT_FN (BUILT_IN_TRUNC):
15328 /* True if the 1st argument is nonnegative. */
15329 return tree_expr_nonnegative_warnv_p (arg0,
15330 strict_overflow_p);
15332 CASE_FLT_FN (BUILT_IN_FMAX):
15333 /* True if the 1st OR 2nd arguments are nonnegative. */
15334 return (tree_expr_nonnegative_warnv_p (arg0,
15336 || (tree_expr_nonnegative_warnv_p (arg1,
15337 strict_overflow_p)));
15339 CASE_FLT_FN (BUILT_IN_FMIN):
15340 /* True if the 1st AND 2nd arguments are nonnegative. */
15341 return (tree_expr_nonnegative_warnv_p (arg0,
15343 && (tree_expr_nonnegative_warnv_p (arg1,
15344 strict_overflow_p)));
15346 CASE_FLT_FN (BUILT_IN_COPYSIGN):
15347 /* True if the 2nd argument is nonnegative. */
15348 return tree_expr_nonnegative_warnv_p (arg1,
15349 strict_overflow_p);
15351 CASE_FLT_FN (BUILT_IN_POWI):
15352 /* True if the 1st argument is nonnegative or the second
15353 argument is an even integer. */
15354 if (TREE_CODE (arg1) == INTEGER_CST
15355 && (TREE_INT_CST_LOW (arg1) & 1) == 0)
15357 return tree_expr_nonnegative_warnv_p (arg0,
15358 strict_overflow_p);
15360 CASE_FLT_FN (BUILT_IN_POW):
15361 /* True if the 1st argument is nonnegative or the second
15362 argument is an even integer valued real. */
15363 if (TREE_CODE (arg1) == REAL_CST)
15368 c = TREE_REAL_CST (arg1);
15369 n = real_to_integer (&c);
15372 REAL_VALUE_TYPE cint;
15373 real_from_integer (&cint, VOIDmode, n, SIGNED);
15374 if (real_identical (&c, &cint))
15378 return tree_expr_nonnegative_warnv_p (arg0,
15379 strict_overflow_p);
15384 return tree_simple_nonnegative_warnv_p (CALL_EXPR,
15388 /* Return true if T is known to be non-negative. If the return
15389 value is based on the assumption that signed overflow is undefined,
15390 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15391 *STRICT_OVERFLOW_P. */
15394 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15396 enum tree_code code = TREE_CODE (t);
15397 if (TYPE_UNSIGNED (TREE_TYPE (t)))
15404 tree temp = TARGET_EXPR_SLOT (t);
15405 t = TARGET_EXPR_INITIAL (t);
15407 /* If the initializer is non-void, then it's a normal expression
15408 that will be assigned to the slot. */
15409 if (!VOID_TYPE_P (t))
15410 return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
15412 /* Otherwise, the initializer sets the slot in some way. One common
15413 way is an assignment statement at the end of the initializer. */
15416 if (TREE_CODE (t) == BIND_EXPR)
15417 t = expr_last (BIND_EXPR_BODY (t));
15418 else if (TREE_CODE (t) == TRY_FINALLY_EXPR
15419 || TREE_CODE (t) == TRY_CATCH_EXPR)
15420 t = expr_last (TREE_OPERAND (t, 0));
15421 else if (TREE_CODE (t) == STATEMENT_LIST)
15426 if (TREE_CODE (t) == MODIFY_EXPR
15427 && TREE_OPERAND (t, 0) == temp)
15428 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15429 strict_overflow_p);
15436 tree arg0 = call_expr_nargs (t) > 0 ? CALL_EXPR_ARG (t, 0) : NULL_TREE;
15437 tree arg1 = call_expr_nargs (t) > 1 ? CALL_EXPR_ARG (t, 1) : NULL_TREE;
15439 return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
15440 get_callee_fndecl (t),
15443 strict_overflow_p);
15445 case COMPOUND_EXPR:
15447 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15448 strict_overflow_p);
15450 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
15451 strict_overflow_p);
15453 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
15454 strict_overflow_p);
15457 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
15461 /* We don't know sign of `t', so be conservative and return false. */
15465 /* Return true if T is known to be non-negative. If the return
15466 value is based on the assumption that signed overflow is undefined,
15467 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15468 *STRICT_OVERFLOW_P. */
15471 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15473 enum tree_code code;
15474 if (t == error_mark_node)
15477 code = TREE_CODE (t);
15478 switch (TREE_CODE_CLASS (code))
15481 case tcc_comparison:
15482 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
15484 TREE_OPERAND (t, 0),
15485 TREE_OPERAND (t, 1),
15486 strict_overflow_p);
15489 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
15491 TREE_OPERAND (t, 0),
15492 strict_overflow_p);
15495 case tcc_declaration:
15496 case tcc_reference:
15497 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
15505 case TRUTH_AND_EXPR:
15506 case TRUTH_OR_EXPR:
15507 case TRUTH_XOR_EXPR:
15508 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
15510 TREE_OPERAND (t, 0),
15511 TREE_OPERAND (t, 1),
15512 strict_overflow_p);
15513 case TRUTH_NOT_EXPR:
15514 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
15516 TREE_OPERAND (t, 0),
15517 strict_overflow_p);
15524 case WITH_SIZE_EXPR:
15526 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
15529 return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
15533 /* Return true if `t' is known to be non-negative. Handle warnings
15534 about undefined signed overflow. */
15537 tree_expr_nonnegative_p (tree t)
15539 bool ret, strict_overflow_p;
15541 strict_overflow_p = false;
15542 ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
15543 if (strict_overflow_p)
15544 fold_overflow_warning (("assuming signed overflow does not occur when "
15545 "determining that expression is always "
15547 WARN_STRICT_OVERFLOW_MISC);
15552 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15553 For floating point we further ensure that T is not denormal.
15554 Similar logic is present in nonzero_address in rtlanal.h.
15556 If the return value is based on the assumption that signed overflow
15557 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15558 change *STRICT_OVERFLOW_P. */
15561 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
15562 bool *strict_overflow_p)
15567 return tree_expr_nonzero_warnv_p (op0,
15568 strict_overflow_p);
15572 tree inner_type = TREE_TYPE (op0);
15573 tree outer_type = type;
15575 return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
15576 && tree_expr_nonzero_warnv_p (op0,
15577 strict_overflow_p));
15581 case NON_LVALUE_EXPR:
15582 return tree_expr_nonzero_warnv_p (op0,
15583 strict_overflow_p);
15592 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15593 For floating point we further ensure that T is not denormal.
15594 Similar logic is present in nonzero_address in rtlanal.h.
15596 If the return value is based on the assumption that signed overflow
15597 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15598 change *STRICT_OVERFLOW_P. */
15601 tree_binary_nonzero_warnv_p (enum tree_code code,
15604 tree op1, bool *strict_overflow_p)
15606 bool sub_strict_overflow_p;
15609 case POINTER_PLUS_EXPR:
15611 if (TYPE_OVERFLOW_UNDEFINED (type))
15613 /* With the presence of negative values it is hard
15614 to say something. */
15615 sub_strict_overflow_p = false;
15616 if (!tree_expr_nonnegative_warnv_p (op0,
15617 &sub_strict_overflow_p)
15618 || !tree_expr_nonnegative_warnv_p (op1,
15619 &sub_strict_overflow_p))
15621 /* One of operands must be positive and the other non-negative. */
15622 /* We don't set *STRICT_OVERFLOW_P here: even if this value
15623 overflows, on a twos-complement machine the sum of two
15624 nonnegative numbers can never be zero. */
15625 return (tree_expr_nonzero_warnv_p (op0,
15627 || tree_expr_nonzero_warnv_p (op1,
15628 strict_overflow_p));
15633 if (TYPE_OVERFLOW_UNDEFINED (type))
15635 if (tree_expr_nonzero_warnv_p (op0,
15637 && tree_expr_nonzero_warnv_p (op1,
15638 strict_overflow_p))
15640 *strict_overflow_p = true;
15647 sub_strict_overflow_p = false;
15648 if (tree_expr_nonzero_warnv_p (op0,
15649 &sub_strict_overflow_p)
15650 && tree_expr_nonzero_warnv_p (op1,
15651 &sub_strict_overflow_p))
15653 if (sub_strict_overflow_p)
15654 *strict_overflow_p = true;
15659 sub_strict_overflow_p = false;
15660 if (tree_expr_nonzero_warnv_p (op0,
15661 &sub_strict_overflow_p))
15663 if (sub_strict_overflow_p)
15664 *strict_overflow_p = true;
15666 /* When both operands are nonzero, then MAX must be too. */
15667 if (tree_expr_nonzero_warnv_p (op1,
15668 strict_overflow_p))
15671 /* MAX where operand 0 is positive is positive. */
15672 return tree_expr_nonnegative_warnv_p (op0,
15673 strict_overflow_p);
15675 /* MAX where operand 1 is positive is positive. */
15676 else if (tree_expr_nonzero_warnv_p (op1,
15677 &sub_strict_overflow_p)
15678 && tree_expr_nonnegative_warnv_p (op1,
15679 &sub_strict_overflow_p))
15681 if (sub_strict_overflow_p)
15682 *strict_overflow_p = true;
15688 return (tree_expr_nonzero_warnv_p (op1,
15690 || tree_expr_nonzero_warnv_p (op0,
15691 strict_overflow_p));
15700 /* Return true when T is an address and is known to be nonzero.
15701 For floating point we further ensure that T is not denormal.
15702 Similar logic is present in nonzero_address in rtlanal.h.
15704 If the return value is based on the assumption that signed overflow
15705 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15706 change *STRICT_OVERFLOW_P. */
15709 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15711 bool sub_strict_overflow_p;
15712 switch (TREE_CODE (t))
15715 return !integer_zerop (t);
15719 tree base = TREE_OPERAND (t, 0);
15721 if (!DECL_P (base))
15722 base = get_base_address (base);
15727 /* For objects in symbol table check if we know they are non-zero.
15728 Don't do anything for variables and functions before symtab is built;
15729 it is quite possible that they will be declared weak later. */
15730 if (DECL_P (base) && decl_in_symtab_p (base))
15732 struct symtab_node *symbol;
15734 symbol = symtab_node::get_create (base);
15736 return symbol->nonzero_address ();
15741 /* Function local objects are never NULL. */
15743 && (DECL_CONTEXT (base)
15744 && TREE_CODE (DECL_CONTEXT (base)) == FUNCTION_DECL
15745 && auto_var_in_fn_p (base, DECL_CONTEXT (base))))
15748 /* Constants are never weak. */
15749 if (CONSTANT_CLASS_P (base))
15756 sub_strict_overflow_p = false;
15757 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15758 &sub_strict_overflow_p)
15759 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
15760 &sub_strict_overflow_p))
15762 if (sub_strict_overflow_p)
15763 *strict_overflow_p = true;
15774 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15775 attempt to fold the expression to a constant without modifying TYPE,
15778 If the expression could be simplified to a constant, then return
15779 the constant. If the expression would not be simplified to a
15780 constant, then return NULL_TREE. */
15783 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
15785 tree tem = fold_binary (code, type, op0, op1);
15786 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15789 /* Given the components of a unary expression CODE, TYPE and OP0,
15790 attempt to fold the expression to a constant without modifying
15793 If the expression could be simplified to a constant, then return
15794 the constant. If the expression would not be simplified to a
15795 constant, then return NULL_TREE. */
15798 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
15800 tree tem = fold_unary (code, type, op0);
15801 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15804 /* If EXP represents referencing an element in a constant string
15805 (either via pointer arithmetic or array indexing), return the
15806 tree representing the value accessed, otherwise return NULL. */
15809 fold_read_from_constant_string (tree exp)
15811 if ((TREE_CODE (exp) == INDIRECT_REF
15812 || TREE_CODE (exp) == ARRAY_REF)
15813 && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
15815 tree exp1 = TREE_OPERAND (exp, 0);
15818 location_t loc = EXPR_LOCATION (exp);
15820 if (TREE_CODE (exp) == INDIRECT_REF)
15821 string = string_constant (exp1, &index);
15824 tree low_bound = array_ref_low_bound (exp);
15825 index = fold_convert_loc (loc, sizetype, TREE_OPERAND (exp, 1));
15827 /* Optimize the special-case of a zero lower bound.
15829 We convert the low_bound to sizetype to avoid some problems
15830 with constant folding. (E.g. suppose the lower bound is 1,
15831 and its mode is QI. Without the conversion,l (ARRAY
15832 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15833 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15834 if (! integer_zerop (low_bound))
15835 index = size_diffop_loc (loc, index,
15836 fold_convert_loc (loc, sizetype, low_bound));
15842 && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
15843 && TREE_CODE (string) == STRING_CST
15844 && TREE_CODE (index) == INTEGER_CST
15845 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
15846 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
15848 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
15849 return build_int_cst_type (TREE_TYPE (exp),
15850 (TREE_STRING_POINTER (string)
15851 [TREE_INT_CST_LOW (index)]));
15856 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15857 an integer constant, real, or fixed-point constant.
15859 TYPE is the type of the result. */
15862 fold_negate_const (tree arg0, tree type)
15864 tree t = NULL_TREE;
15866 switch (TREE_CODE (arg0))
15871 wide_int val = wi::neg (arg0, &overflow);
15872 t = force_fit_type (type, val, 1,
15873 (overflow | TREE_OVERFLOW (arg0))
15874 && !TYPE_UNSIGNED (type));
15879 t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
15884 FIXED_VALUE_TYPE f;
15885 bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
15886 &(TREE_FIXED_CST (arg0)), NULL,
15887 TYPE_SATURATING (type));
15888 t = build_fixed (type, f);
15889 /* Propagate overflow flags. */
15890 if (overflow_p | TREE_OVERFLOW (arg0))
15891 TREE_OVERFLOW (t) = 1;
15896 gcc_unreachable ();
15902 /* Return the tree for abs (ARG0) when ARG0 is known to be either
15903 an integer constant or real constant.
15905 TYPE is the type of the result. */
15908 fold_abs_const (tree arg0, tree type)
15910 tree t = NULL_TREE;
15912 switch (TREE_CODE (arg0))
15916 /* If the value is unsigned or non-negative, then the absolute value
15917 is the same as the ordinary value. */
15918 if (!wi::neg_p (arg0, TYPE_SIGN (type)))
15921 /* If the value is negative, then the absolute value is
15926 wide_int val = wi::neg (arg0, &overflow);
15927 t = force_fit_type (type, val, -1,
15928 overflow | TREE_OVERFLOW (arg0));
15934 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
15935 t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
15941 gcc_unreachable ();
15947 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
15948 constant. TYPE is the type of the result. */
15951 fold_not_const (const_tree arg0, tree type)
15953 gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
15955 return force_fit_type (type, wi::bit_not (arg0), 0, TREE_OVERFLOW (arg0));
15958 /* Given CODE, a relational operator, the target type, TYPE and two
15959 constant operands OP0 and OP1, return the result of the
15960 relational operation. If the result is not a compile time
15961 constant, then return NULL_TREE. */
15964 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
15966 int result, invert;
15968 /* From here on, the only cases we handle are when the result is
15969 known to be a constant. */
15971 if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
15973 const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
15974 const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
15976 /* Handle the cases where either operand is a NaN. */
15977 if (real_isnan (c0) || real_isnan (c1))
15987 case UNORDERED_EXPR:
16001 if (flag_trapping_math)
16007 gcc_unreachable ();
16010 return constant_boolean_node (result, type);
16013 return constant_boolean_node (real_compare (code, c0, c1), type);
16016 if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
16018 const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
16019 const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
16020 return constant_boolean_node (fixed_compare (code, c0, c1), type);
16023 /* Handle equality/inequality of complex constants. */
16024 if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
16026 tree rcond = fold_relational_const (code, type,
16027 TREE_REALPART (op0),
16028 TREE_REALPART (op1));
16029 tree icond = fold_relational_const (code, type,
16030 TREE_IMAGPART (op0),
16031 TREE_IMAGPART (op1));
16032 if (code == EQ_EXPR)
16033 return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
16034 else if (code == NE_EXPR)
16035 return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
16040 if (TREE_CODE (op0) == VECTOR_CST && TREE_CODE (op1) == VECTOR_CST)
16042 unsigned count = VECTOR_CST_NELTS (op0);
16043 tree *elts = XALLOCAVEC (tree, count);
16044 gcc_assert (VECTOR_CST_NELTS (op1) == count
16045 && TYPE_VECTOR_SUBPARTS (type) == count);
16047 for (unsigned i = 0; i < count; i++)
16049 tree elem_type = TREE_TYPE (type);
16050 tree elem0 = VECTOR_CST_ELT (op0, i);
16051 tree elem1 = VECTOR_CST_ELT (op1, i);
16053 tree tem = fold_relational_const (code, elem_type,
16056 if (tem == NULL_TREE)
16059 elts[i] = build_int_cst (elem_type, integer_zerop (tem) ? 0 : -1);
16062 return build_vector (type, elts);
16065 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16067 To compute GT, swap the arguments and do LT.
16068 To compute GE, do LT and invert the result.
16069 To compute LE, swap the arguments, do LT and invert the result.
16070 To compute NE, do EQ and invert the result.
16072 Therefore, the code below must handle only EQ and LT. */
16074 if (code == LE_EXPR || code == GT_EXPR)
16079 code = swap_tree_comparison (code);
16082 /* Note that it is safe to invert for real values here because we
16083 have already handled the one case that it matters. */
16086 if (code == NE_EXPR || code == GE_EXPR)
16089 code = invert_tree_comparison (code, false);
16092 /* Compute a result for LT or EQ if args permit;
16093 Otherwise return T. */
16094 if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
16096 if (code == EQ_EXPR)
16097 result = tree_int_cst_equal (op0, op1);
16099 result = tree_int_cst_lt (op0, op1);
16106 return constant_boolean_node (result, type);
16109 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16110 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16114 fold_build_cleanup_point_expr (tree type, tree expr)
16116 /* If the expression does not have side effects then we don't have to wrap
16117 it with a cleanup point expression. */
16118 if (!TREE_SIDE_EFFECTS (expr))
16121 /* If the expression is a return, check to see if the expression inside the
16122 return has no side effects or the right hand side of the modify expression
16123 inside the return. If either don't have side effects set we don't need to
16124 wrap the expression in a cleanup point expression. Note we don't check the
16125 left hand side of the modify because it should always be a return decl. */
16126 if (TREE_CODE (expr) == RETURN_EXPR)
16128 tree op = TREE_OPERAND (expr, 0);
16129 if (!op || !TREE_SIDE_EFFECTS (op))
16131 op = TREE_OPERAND (op, 1);
16132 if (!TREE_SIDE_EFFECTS (op))
16136 return build1 (CLEANUP_POINT_EXPR, type, expr);
16139 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16140 of an indirection through OP0, or NULL_TREE if no simplification is
16144 fold_indirect_ref_1 (location_t loc, tree type, tree op0)
16150 subtype = TREE_TYPE (sub);
16151 if (!POINTER_TYPE_P (subtype))
16154 if (TREE_CODE (sub) == ADDR_EXPR)
16156 tree op = TREE_OPERAND (sub, 0);
16157 tree optype = TREE_TYPE (op);
16158 /* *&CONST_DECL -> to the value of the const decl. */
16159 if (TREE_CODE (op) == CONST_DECL)
16160 return DECL_INITIAL (op);
16161 /* *&p => p; make sure to handle *&"str"[cst] here. */
16162 if (type == optype)
16164 tree fop = fold_read_from_constant_string (op);
16170 /* *(foo *)&fooarray => fooarray[0] */
16171 else if (TREE_CODE (optype) == ARRAY_TYPE
16172 && type == TREE_TYPE (optype)
16173 && (!in_gimple_form
16174 || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
16176 tree type_domain = TYPE_DOMAIN (optype);
16177 tree min_val = size_zero_node;
16178 if (type_domain && TYPE_MIN_VALUE (type_domain))
16179 min_val = TYPE_MIN_VALUE (type_domain);
16181 && TREE_CODE (min_val) != INTEGER_CST)
16183 return build4_loc (loc, ARRAY_REF, type, op, min_val,
16184 NULL_TREE, NULL_TREE);
16186 /* *(foo *)&complexfoo => __real__ complexfoo */
16187 else if (TREE_CODE (optype) == COMPLEX_TYPE
16188 && type == TREE_TYPE (optype))
16189 return fold_build1_loc (loc, REALPART_EXPR, type, op);
16190 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16191 else if (TREE_CODE (optype) == VECTOR_TYPE
16192 && type == TREE_TYPE (optype))
16194 tree part_width = TYPE_SIZE (type);
16195 tree index = bitsize_int (0);
16196 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
16200 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
16201 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
16203 tree op00 = TREE_OPERAND (sub, 0);
16204 tree op01 = TREE_OPERAND (sub, 1);
16207 if (TREE_CODE (op00) == ADDR_EXPR)
16210 op00 = TREE_OPERAND (op00, 0);
16211 op00type = TREE_TYPE (op00);
16213 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16214 if (TREE_CODE (op00type) == VECTOR_TYPE
16215 && type == TREE_TYPE (op00type))
16217 HOST_WIDE_INT offset = tree_to_shwi (op01);
16218 tree part_width = TYPE_SIZE (type);
16219 unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
16220 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
16221 tree index = bitsize_int (indexi);
16223 if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
16224 return fold_build3_loc (loc,
16225 BIT_FIELD_REF, type, op00,
16226 part_width, index);
16229 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16230 else if (TREE_CODE (op00type) == COMPLEX_TYPE
16231 && type == TREE_TYPE (op00type))
16233 tree size = TYPE_SIZE_UNIT (type);
16234 if (tree_int_cst_equal (size, op01))
16235 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
16237 /* ((foo *)&fooarray)[1] => fooarray[1] */
16238 else if (TREE_CODE (op00type) == ARRAY_TYPE
16239 && type == TREE_TYPE (op00type))
16241 tree type_domain = TYPE_DOMAIN (op00type);
16242 tree min_val = size_zero_node;
16243 if (type_domain && TYPE_MIN_VALUE (type_domain))
16244 min_val = TYPE_MIN_VALUE (type_domain);
16245 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
16246 TYPE_SIZE_UNIT (type));
16247 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
16248 return build4_loc (loc, ARRAY_REF, type, op00, op01,
16249 NULL_TREE, NULL_TREE);
16254 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16255 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
16256 && type == TREE_TYPE (TREE_TYPE (subtype))
16257 && (!in_gimple_form
16258 || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
16261 tree min_val = size_zero_node;
16262 sub = build_fold_indirect_ref_loc (loc, sub);
16263 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
16264 if (type_domain && TYPE_MIN_VALUE (type_domain))
16265 min_val = TYPE_MIN_VALUE (type_domain);
16267 && TREE_CODE (min_val) != INTEGER_CST)
16269 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
16276 /* Builds an expression for an indirection through T, simplifying some
16280 build_fold_indirect_ref_loc (location_t loc, tree t)
16282 tree type = TREE_TYPE (TREE_TYPE (t));
16283 tree sub = fold_indirect_ref_1 (loc, type, t);
16288 return build1_loc (loc, INDIRECT_REF, type, t);
16291 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16294 fold_indirect_ref_loc (location_t loc, tree t)
16296 tree sub = fold_indirect_ref_1 (loc, TREE_TYPE (t), TREE_OPERAND (t, 0));
16304 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16305 whose result is ignored. The type of the returned tree need not be
16306 the same as the original expression. */
16309 fold_ignored_result (tree t)
16311 if (!TREE_SIDE_EFFECTS (t))
16312 return integer_zero_node;
16315 switch (TREE_CODE_CLASS (TREE_CODE (t)))
16318 t = TREE_OPERAND (t, 0);
16322 case tcc_comparison:
16323 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
16324 t = TREE_OPERAND (t, 0);
16325 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
16326 t = TREE_OPERAND (t, 1);
16331 case tcc_expression:
16332 switch (TREE_CODE (t))
16334 case COMPOUND_EXPR:
16335 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
16337 t = TREE_OPERAND (t, 0);
16341 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
16342 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
16344 t = TREE_OPERAND (t, 0);
16357 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
16360 round_up_loc (location_t loc, tree value, unsigned int divisor)
16362 tree div = NULL_TREE;
16367 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16368 have to do anything. Only do this when we are not given a const,
16369 because in that case, this check is more expensive than just
16371 if (TREE_CODE (value) != INTEGER_CST)
16373 div = build_int_cst (TREE_TYPE (value), divisor);
16375 if (multiple_of_p (TREE_TYPE (value), value, div))
16379 /* If divisor is a power of two, simplify this to bit manipulation. */
16380 if (divisor == (divisor & -divisor))
16382 if (TREE_CODE (value) == INTEGER_CST)
16384 wide_int val = value;
16387 if ((val & (divisor - 1)) == 0)
16390 overflow_p = TREE_OVERFLOW (value);
16391 val &= ~(divisor - 1);
16396 return force_fit_type (TREE_TYPE (value), val, -1, overflow_p);
16402 t = build_int_cst (TREE_TYPE (value), divisor - 1);
16403 value = size_binop_loc (loc, PLUS_EXPR, value, t);
16404 t = build_int_cst (TREE_TYPE (value), -divisor);
16405 value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
16411 div = build_int_cst (TREE_TYPE (value), divisor);
16412 value = size_binop_loc (loc, CEIL_DIV_EXPR, value, div);
16413 value = size_binop_loc (loc, MULT_EXPR, value, div);
16419 /* Likewise, but round down. */
16422 round_down_loc (location_t loc, tree value, int divisor)
16424 tree div = NULL_TREE;
16426 gcc_assert (divisor > 0);
16430 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16431 have to do anything. Only do this when we are not given a const,
16432 because in that case, this check is more expensive than just
16434 if (TREE_CODE (value) != INTEGER_CST)
16436 div = build_int_cst (TREE_TYPE (value), divisor);
16438 if (multiple_of_p (TREE_TYPE (value), value, div))
16442 /* If divisor is a power of two, simplify this to bit manipulation. */
16443 if (divisor == (divisor & -divisor))
16447 t = build_int_cst (TREE_TYPE (value), -divisor);
16448 value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
16453 div = build_int_cst (TREE_TYPE (value), divisor);
16454 value = size_binop_loc (loc, FLOOR_DIV_EXPR, value, div);
16455 value = size_binop_loc (loc, MULT_EXPR, value, div);
16461 /* Returns the pointer to the base of the object addressed by EXP and
16462 extracts the information about the offset of the access, storing it
16463 to PBITPOS and POFFSET. */
16466 split_address_to_core_and_offset (tree exp,
16467 HOST_WIDE_INT *pbitpos, tree *poffset)
16471 int unsignedp, volatilep;
16472 HOST_WIDE_INT bitsize;
16473 location_t loc = EXPR_LOCATION (exp);
16475 if (TREE_CODE (exp) == ADDR_EXPR)
16477 core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
16478 poffset, &mode, &unsignedp, &volatilep,
16480 core = build_fold_addr_expr_loc (loc, core);
16486 *poffset = NULL_TREE;
16492 /* Returns true if addresses of E1 and E2 differ by a constant, false
16493 otherwise. If they do, E1 - E2 is stored in *DIFF. */
16496 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
16499 HOST_WIDE_INT bitpos1, bitpos2;
16500 tree toffset1, toffset2, tdiff, type;
16502 core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
16503 core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
16505 if (bitpos1 % BITS_PER_UNIT != 0
16506 || bitpos2 % BITS_PER_UNIT != 0
16507 || !operand_equal_p (core1, core2, 0))
16510 if (toffset1 && toffset2)
16512 type = TREE_TYPE (toffset1);
16513 if (type != TREE_TYPE (toffset2))
16514 toffset2 = fold_convert (type, toffset2);
16516 tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
16517 if (!cst_and_fits_in_hwi (tdiff))
16520 *diff = int_cst_value (tdiff);
16522 else if (toffset1 || toffset2)
16524 /* If only one of the offsets is non-constant, the difference cannot
16531 *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
16535 /* Simplify the floating point expression EXP when the sign of the
16536 result is not significant. Return NULL_TREE if no simplification
16540 fold_strip_sign_ops (tree exp)
16543 location_t loc = EXPR_LOCATION (exp);
16545 switch (TREE_CODE (exp))
16549 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
16550 return arg0 ? arg0 : TREE_OPERAND (exp, 0);
16554 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
16556 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
16557 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16558 if (arg0 != NULL_TREE || arg1 != NULL_TREE)
16559 return fold_build2_loc (loc, TREE_CODE (exp), TREE_TYPE (exp),
16560 arg0 ? arg0 : TREE_OPERAND (exp, 0),
16561 arg1 ? arg1 : TREE_OPERAND (exp, 1));
16564 case COMPOUND_EXPR:
16565 arg0 = TREE_OPERAND (exp, 0);
16566 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16568 return fold_build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
16572 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16573 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
16575 return fold_build3_loc (loc,
16576 COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
16577 arg0 ? arg0 : TREE_OPERAND (exp, 1),
16578 arg1 ? arg1 : TREE_OPERAND (exp, 2));
16583 const enum built_in_function fcode = builtin_mathfn_code (exp);
16586 CASE_FLT_FN (BUILT_IN_COPYSIGN):
16587 /* Strip copysign function call, return the 1st argument. */
16588 arg0 = CALL_EXPR_ARG (exp, 0);
16589 arg1 = CALL_EXPR_ARG (exp, 1);
16590 return omit_one_operand_loc (loc, TREE_TYPE (exp), arg0, arg1);
16593 /* Strip sign ops from the argument of "odd" math functions. */
16594 if (negate_mathfn_p (fcode))
16596 arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
16598 return build_call_expr_loc (loc, get_callee_fndecl (exp), 1, arg0);