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 else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
8012 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
8013 /* Convert ~ (-A) to A - 1. */
8014 else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
8015 return fold_build2_loc (loc, MINUS_EXPR, type,
8016 fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0)),
8017 build_int_cst (type, 1));
8018 /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
8019 else if (INTEGRAL_TYPE_P (type)
8020 && ((TREE_CODE (arg0) == MINUS_EXPR
8021 && integer_onep (TREE_OPERAND (arg0, 1)))
8022 || (TREE_CODE (arg0) == PLUS_EXPR
8023 && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
8024 return fold_build1_loc (loc, NEGATE_EXPR, type,
8025 fold_convert_loc (loc, type,
8026 TREE_OPERAND (arg0, 0)));
8027 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8028 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8029 && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8030 fold_convert_loc (loc, type,
8031 TREE_OPERAND (arg0, 0)))))
8032 return fold_build2_loc (loc, BIT_XOR_EXPR, type, tem,
8033 fold_convert_loc (loc, type,
8034 TREE_OPERAND (arg0, 1)));
8035 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8036 && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8037 fold_convert_loc (loc, type,
8038 TREE_OPERAND (arg0, 1)))))
8039 return fold_build2_loc (loc, BIT_XOR_EXPR, type,
8040 fold_convert_loc (loc, type,
8041 TREE_OPERAND (arg0, 0)), tem);
8042 /* Perform BIT_NOT_EXPR on each element individually. */
8043 else if (TREE_CODE (arg0) == VECTOR_CST)
8047 unsigned count = VECTOR_CST_NELTS (arg0), i;
8049 elements = XALLOCAVEC (tree, count);
8050 for (i = 0; i < count; i++)
8052 elem = VECTOR_CST_ELT (arg0, i);
8053 elem = fold_unary_loc (loc, BIT_NOT_EXPR, TREE_TYPE (type), elem);
8054 if (elem == NULL_TREE)
8059 return build_vector (type, elements);
8061 else if (COMPARISON_CLASS_P (arg0)
8062 && (VECTOR_TYPE_P (type)
8063 || (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1)))
8065 tree op_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
8066 enum tree_code subcode = invert_tree_comparison (TREE_CODE (arg0),
8067 HONOR_NANS (TYPE_MODE (op_type)));
8068 if (subcode != ERROR_MARK)
8069 return build2_loc (loc, subcode, type, TREE_OPERAND (arg0, 0),
8070 TREE_OPERAND (arg0, 1));
8076 case TRUTH_NOT_EXPR:
8077 /* Note that the operand of this must be an int
8078 and its values must be 0 or 1.
8079 ("true" is a fixed value perhaps depending on the language,
8080 but we don't handle values other than 1 correctly yet.) */
8081 tem = fold_truth_not_expr (loc, arg0);
8084 return fold_convert_loc (loc, type, tem);
8087 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8088 return fold_convert_loc (loc, type, arg0);
8089 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8090 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
8091 TREE_OPERAND (arg0, 1));
8092 if (TREE_CODE (arg0) == COMPLEX_CST)
8093 return fold_convert_loc (loc, type, TREE_REALPART (arg0));
8094 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8096 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8097 tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8098 fold_build1_loc (loc, REALPART_EXPR, itype,
8099 TREE_OPERAND (arg0, 0)),
8100 fold_build1_loc (loc, REALPART_EXPR, itype,
8101 TREE_OPERAND (arg0, 1)));
8102 return fold_convert_loc (loc, type, tem);
8104 if (TREE_CODE (arg0) == CONJ_EXPR)
8106 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8107 tem = fold_build1_loc (loc, REALPART_EXPR, itype,
8108 TREE_OPERAND (arg0, 0));
8109 return fold_convert_loc (loc, type, tem);
8111 if (TREE_CODE (arg0) == CALL_EXPR)
8113 tree fn = get_callee_fndecl (arg0);
8114 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8115 switch (DECL_FUNCTION_CODE (fn))
8117 CASE_FLT_FN (BUILT_IN_CEXPI):
8118 fn = mathfn_built_in (type, BUILT_IN_COS);
8120 return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8130 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8131 return build_zero_cst (type);
8132 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8133 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 1),
8134 TREE_OPERAND (arg0, 0));
8135 if (TREE_CODE (arg0) == COMPLEX_CST)
8136 return fold_convert_loc (loc, type, TREE_IMAGPART (arg0));
8137 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8139 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8140 tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8141 fold_build1_loc (loc, IMAGPART_EXPR, itype,
8142 TREE_OPERAND (arg0, 0)),
8143 fold_build1_loc (loc, IMAGPART_EXPR, itype,
8144 TREE_OPERAND (arg0, 1)));
8145 return fold_convert_loc (loc, type, tem);
8147 if (TREE_CODE (arg0) == CONJ_EXPR)
8149 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8150 tem = fold_build1_loc (loc, IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8151 return fold_convert_loc (loc, type, negate_expr (tem));
8153 if (TREE_CODE (arg0) == CALL_EXPR)
8155 tree fn = get_callee_fndecl (arg0);
8156 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8157 switch (DECL_FUNCTION_CODE (fn))
8159 CASE_FLT_FN (BUILT_IN_CEXPI):
8160 fn = mathfn_built_in (type, BUILT_IN_SIN);
8162 return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8172 /* Fold *&X to X if X is an lvalue. */
8173 if (TREE_CODE (op0) == ADDR_EXPR)
8175 tree op00 = TREE_OPERAND (op0, 0);
8176 if ((TREE_CODE (op00) == VAR_DECL
8177 || TREE_CODE (op00) == PARM_DECL
8178 || TREE_CODE (op00) == RESULT_DECL)
8179 && !TREE_READONLY (op00))
8184 case VEC_UNPACK_LO_EXPR:
8185 case VEC_UNPACK_HI_EXPR:
8186 case VEC_UNPACK_FLOAT_LO_EXPR:
8187 case VEC_UNPACK_FLOAT_HI_EXPR:
8189 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
8191 enum tree_code subcode;
8193 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2);
8194 if (TREE_CODE (arg0) != VECTOR_CST)
8197 elts = XALLOCAVEC (tree, nelts * 2);
8198 if (!vec_cst_ctor_to_array (arg0, elts))
8201 if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_UNPACK_LO_EXPR
8202 || code == VEC_UNPACK_FLOAT_LO_EXPR))
8205 if (code == VEC_UNPACK_LO_EXPR || code == VEC_UNPACK_HI_EXPR)
8208 subcode = FLOAT_EXPR;
8210 for (i = 0; i < nelts; i++)
8212 elts[i] = fold_convert_const (subcode, TREE_TYPE (type), elts[i]);
8213 if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
8217 return build_vector (type, elts);
8220 case REDUC_MIN_EXPR:
8221 case REDUC_MAX_EXPR:
8222 case REDUC_PLUS_EXPR:
8224 unsigned int nelts, i;
8226 enum tree_code subcode;
8228 if (TREE_CODE (op0) != VECTOR_CST)
8230 nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (op0));
8232 elts = XALLOCAVEC (tree, nelts);
8233 if (!vec_cst_ctor_to_array (op0, elts))
8238 case REDUC_MIN_EXPR: subcode = MIN_EXPR; break;
8239 case REDUC_MAX_EXPR: subcode = MAX_EXPR; break;
8240 case REDUC_PLUS_EXPR: subcode = PLUS_EXPR; break;
8241 default: gcc_unreachable ();
8244 for (i = 1; i < nelts; i++)
8246 elts[0] = const_binop (subcode, elts[0], elts[i]);
8247 if (elts[0] == NULL_TREE || !CONSTANT_CLASS_P (elts[0]))
8256 } /* switch (code) */
8260 /* If the operation was a conversion do _not_ mark a resulting constant
8261 with TREE_OVERFLOW if the original constant was not. These conversions
8262 have implementation defined behavior and retaining the TREE_OVERFLOW
8263 flag here would confuse later passes such as VRP. */
8265 fold_unary_ignore_overflow_loc (location_t loc, enum tree_code code,
8266 tree type, tree op0)
8268 tree res = fold_unary_loc (loc, code, type, op0);
8270 && TREE_CODE (res) == INTEGER_CST
8271 && TREE_CODE (op0) == INTEGER_CST
8272 && CONVERT_EXPR_CODE_P (code))
8273 TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
8278 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8279 operands OP0 and OP1. LOC is the location of the resulting expression.
8280 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8281 Return the folded expression if folding is successful. Otherwise,
8282 return NULL_TREE. */
8284 fold_truth_andor (location_t loc, enum tree_code code, tree type,
8285 tree arg0, tree arg1, tree op0, tree op1)
8289 /* We only do these simplifications if we are optimizing. */
8293 /* Check for things like (A || B) && (A || C). We can convert this
8294 to A || (B && C). Note that either operator can be any of the four
8295 truth and/or operations and the transformation will still be
8296 valid. Also note that we only care about order for the
8297 ANDIF and ORIF operators. If B contains side effects, this
8298 might change the truth-value of A. */
8299 if (TREE_CODE (arg0) == TREE_CODE (arg1)
8300 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
8301 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
8302 || TREE_CODE (arg0) == TRUTH_AND_EXPR
8303 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
8304 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
8306 tree a00 = TREE_OPERAND (arg0, 0);
8307 tree a01 = TREE_OPERAND (arg0, 1);
8308 tree a10 = TREE_OPERAND (arg1, 0);
8309 tree a11 = TREE_OPERAND (arg1, 1);
8310 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
8311 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
8312 && (code == TRUTH_AND_EXPR
8313 || code == TRUTH_OR_EXPR));
8315 if (operand_equal_p (a00, a10, 0))
8316 return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8317 fold_build2_loc (loc, code, type, a01, a11));
8318 else if (commutative && operand_equal_p (a00, a11, 0))
8319 return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8320 fold_build2_loc (loc, code, type, a01, a10));
8321 else if (commutative && operand_equal_p (a01, a10, 0))
8322 return fold_build2_loc (loc, TREE_CODE (arg0), type, a01,
8323 fold_build2_loc (loc, code, type, a00, a11));
8325 /* This case if tricky because we must either have commutative
8326 operators or else A10 must not have side-effects. */
8328 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
8329 && operand_equal_p (a01, a11, 0))
8330 return fold_build2_loc (loc, TREE_CODE (arg0), type,
8331 fold_build2_loc (loc, code, type, a00, a10),
8335 /* See if we can build a range comparison. */
8336 if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
8339 if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg0) == TRUTH_ORIF_EXPR)
8340 || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg0) == TRUTH_ANDIF_EXPR))
8342 tem = merge_truthop_with_opposite_arm (loc, arg0, arg1, true);
8344 return fold_build2_loc (loc, code, type, tem, arg1);
8347 if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg1) == TRUTH_ORIF_EXPR)
8348 || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg1) == TRUTH_ANDIF_EXPR))
8350 tem = merge_truthop_with_opposite_arm (loc, arg1, arg0, false);
8352 return fold_build2_loc (loc, code, type, arg0, tem);
8355 /* Check for the possibility of merging component references. If our
8356 lhs is another similar operation, try to merge its rhs with our
8357 rhs. Then try to merge our lhs and rhs. */
8358 if (TREE_CODE (arg0) == code
8359 && 0 != (tem = fold_truth_andor_1 (loc, code, type,
8360 TREE_OPERAND (arg0, 1), arg1)))
8361 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
8363 if ((tem = fold_truth_andor_1 (loc, code, type, arg0, arg1)) != 0)
8366 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8367 && (code == TRUTH_AND_EXPR
8368 || code == TRUTH_ANDIF_EXPR
8369 || code == TRUTH_OR_EXPR
8370 || code == TRUTH_ORIF_EXPR))
8372 enum tree_code ncode, icode;
8374 ncode = (code == TRUTH_ANDIF_EXPR || code == TRUTH_AND_EXPR)
8375 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR;
8376 icode = ncode == TRUTH_AND_EXPR ? TRUTH_ANDIF_EXPR : TRUTH_ORIF_EXPR;
8378 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8379 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8380 We don't want to pack more than two leafs to a non-IF AND/OR
8382 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8383 equal to IF-CODE, then we don't want to add right-hand operand.
8384 If the inner right-hand side of left-hand operand has
8385 side-effects, or isn't simple, then we can't add to it,
8386 as otherwise we might destroy if-sequence. */
8387 if (TREE_CODE (arg0) == icode
8388 && simple_operand_p_2 (arg1)
8389 /* Needed for sequence points to handle trappings, and
8391 && simple_operand_p_2 (TREE_OPERAND (arg0, 1)))
8393 tem = fold_build2_loc (loc, ncode, type, TREE_OPERAND (arg0, 1),
8395 return fold_build2_loc (loc, icode, type, TREE_OPERAND (arg0, 0),
8398 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8399 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8400 else if (TREE_CODE (arg1) == icode
8401 && simple_operand_p_2 (arg0)
8402 /* Needed for sequence points to handle trappings, and
8404 && simple_operand_p_2 (TREE_OPERAND (arg1, 0)))
8406 tem = fold_build2_loc (loc, ncode, type,
8407 arg0, TREE_OPERAND (arg1, 0));
8408 return fold_build2_loc (loc, icode, type, tem,
8409 TREE_OPERAND (arg1, 1));
8411 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8413 For sequence point consistancy, we need to check for trapping,
8414 and side-effects. */
8415 else if (code == icode && simple_operand_p_2 (arg0)
8416 && simple_operand_p_2 (arg1))
8417 return fold_build2_loc (loc, ncode, type, arg0, arg1);
8423 /* Fold a binary expression of code CODE and type TYPE with operands
8424 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8425 Return the folded expression if folding is successful. Otherwise,
8426 return NULL_TREE. */
8429 fold_minmax (location_t loc, enum tree_code code, tree type, tree op0, tree op1)
8431 enum tree_code compl_code;
8433 if (code == MIN_EXPR)
8434 compl_code = MAX_EXPR;
8435 else if (code == MAX_EXPR)
8436 compl_code = MIN_EXPR;
8440 /* MIN (MAX (a, b), b) == b. */
8441 if (TREE_CODE (op0) == compl_code
8442 && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
8443 return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 0));
8445 /* MIN (MAX (b, a), b) == b. */
8446 if (TREE_CODE (op0) == compl_code
8447 && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
8448 && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
8449 return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 1));
8451 /* MIN (a, MAX (a, b)) == a. */
8452 if (TREE_CODE (op1) == compl_code
8453 && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
8454 && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
8455 return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 1));
8457 /* MIN (a, MAX (b, a)) == a. */
8458 if (TREE_CODE (op1) == compl_code
8459 && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
8460 && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
8461 return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 0));
8466 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8467 by changing CODE to reduce the magnitude of constants involved in
8468 ARG0 of the comparison.
8469 Returns a canonicalized comparison tree if a simplification was
8470 possible, otherwise returns NULL_TREE.
8471 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8472 valid if signed overflow is undefined. */
8475 maybe_canonicalize_comparison_1 (location_t loc, enum tree_code code, tree type,
8476 tree arg0, tree arg1,
8477 bool *strict_overflow_p)
8479 enum tree_code code0 = TREE_CODE (arg0);
8480 tree t, cst0 = NULL_TREE;
8484 /* Match A +- CST code arg1 and CST code arg1. We can change the
8485 first form only if overflow is undefined. */
8486 if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8487 /* In principle pointers also have undefined overflow behavior,
8488 but that causes problems elsewhere. */
8489 && !POINTER_TYPE_P (TREE_TYPE (arg0))
8490 && (code0 == MINUS_EXPR
8491 || code0 == PLUS_EXPR)
8492 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8493 || code0 == INTEGER_CST))
8496 /* Identify the constant in arg0 and its sign. */
8497 if (code0 == INTEGER_CST)
8500 cst0 = TREE_OPERAND (arg0, 1);
8501 sgn0 = tree_int_cst_sgn (cst0);
8503 /* Overflowed constants and zero will cause problems. */
8504 if (integer_zerop (cst0)
8505 || TREE_OVERFLOW (cst0))
8508 /* See if we can reduce the magnitude of the constant in
8509 arg0 by changing the comparison code. */
8510 if (code0 == INTEGER_CST)
8512 /* CST <= arg1 -> CST-1 < arg1. */
8513 if (code == LE_EXPR && sgn0 == 1)
8515 /* -CST < arg1 -> -CST-1 <= arg1. */
8516 else if (code == LT_EXPR && sgn0 == -1)
8518 /* CST > arg1 -> CST-1 >= arg1. */
8519 else if (code == GT_EXPR && sgn0 == 1)
8521 /* -CST >= arg1 -> -CST-1 > arg1. */
8522 else if (code == GE_EXPR && sgn0 == -1)
8526 /* arg1 code' CST' might be more canonical. */
8531 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8533 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8535 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8536 else if (code == GT_EXPR
8537 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8539 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8540 else if (code == LE_EXPR
8541 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8543 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8544 else if (code == GE_EXPR
8545 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8549 *strict_overflow_p = true;
8552 /* Now build the constant reduced in magnitude. But not if that
8553 would produce one outside of its types range. */
8554 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8556 && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8557 && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8559 && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8560 && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8561 /* We cannot swap the comparison here as that would cause us to
8562 endlessly recurse. */
8565 t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8566 cst0, build_int_cst (TREE_TYPE (cst0), 1));
8567 if (code0 != INTEGER_CST)
8568 t = fold_build2_loc (loc, code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8569 t = fold_convert (TREE_TYPE (arg1), t);
8571 /* If swapping might yield to a more canonical form, do so. */
8573 return fold_build2_loc (loc, swap_tree_comparison (code), type, arg1, t);
8575 return fold_build2_loc (loc, code, type, t, arg1);
8578 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8579 overflow further. Try to decrease the magnitude of constants involved
8580 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8581 and put sole constants at the second argument position.
8582 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8585 maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
8586 tree arg0, tree arg1)
8589 bool strict_overflow_p;
8590 const char * const warnmsg = G_("assuming signed overflow does not occur "
8591 "when reducing constant in comparison");
8593 /* Try canonicalization by simplifying arg0. */
8594 strict_overflow_p = false;
8595 t = maybe_canonicalize_comparison_1 (loc, code, type, arg0, arg1,
8596 &strict_overflow_p);
8599 if (strict_overflow_p)
8600 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8604 /* Try canonicalization by simplifying arg1 using the swapped
8606 code = swap_tree_comparison (code);
8607 strict_overflow_p = false;
8608 t = maybe_canonicalize_comparison_1 (loc, code, type, arg1, arg0,
8609 &strict_overflow_p);
8610 if (t && strict_overflow_p)
8611 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8615 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8616 space. This is used to avoid issuing overflow warnings for
8617 expressions like &p->x which can not wrap. */
8620 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8622 if (!POINTER_TYPE_P (TREE_TYPE (base)))
8629 int precision = TYPE_PRECISION (TREE_TYPE (base));
8630 if (offset == NULL_TREE)
8631 wi_offset = wi::zero (precision);
8632 else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8638 wide_int units = wi::shwi (bitpos / BITS_PER_UNIT, precision);
8639 wide_int total = wi::add (wi_offset, units, UNSIGNED, &overflow);
8643 if (!wi::fits_uhwi_p (total))
8646 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8650 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8652 if (TREE_CODE (base) == ADDR_EXPR)
8654 HOST_WIDE_INT base_size;
8656 base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8657 if (base_size > 0 && size < base_size)
8661 return total.to_uhwi () > (unsigned HOST_WIDE_INT) size;
8664 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
8665 kind INTEGER_CST. This makes sure to properly sign-extend the
8668 static HOST_WIDE_INT
8669 size_low_cst (const_tree t)
8671 HOST_WIDE_INT w = TREE_INT_CST_ELT (t, 0);
8672 int prec = TYPE_PRECISION (TREE_TYPE (t));
8673 if (prec < HOST_BITS_PER_WIDE_INT)
8674 return sext_hwi (w, prec);
8678 /* Subroutine of fold_binary. This routine performs all of the
8679 transformations that are common to the equality/inequality
8680 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8681 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8682 fold_binary should call fold_binary. Fold a comparison with
8683 tree code CODE and type TYPE with operands OP0 and OP1. Return
8684 the folded comparison or NULL_TREE. */
8687 fold_comparison (location_t loc, enum tree_code code, tree type,
8690 const bool equality_code = (code == EQ_EXPR || code == NE_EXPR);
8691 tree arg0, arg1, tem;
8696 STRIP_SIGN_NOPS (arg0);
8697 STRIP_SIGN_NOPS (arg1);
8699 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8700 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8701 && (equality_code || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0)))
8702 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8703 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8704 && TREE_CODE (arg1) == INTEGER_CST
8705 && !TREE_OVERFLOW (arg1))
8707 const enum tree_code
8708 reverse_op = TREE_CODE (arg0) == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR;
8709 tree const1 = TREE_OPERAND (arg0, 1);
8710 tree const2 = fold_convert_loc (loc, TREE_TYPE (const1), arg1);
8711 tree variable = TREE_OPERAND (arg0, 0);
8712 tree new_const = int_const_binop (reverse_op, const2, const1);
8714 /* If the constant operation overflowed this can be
8715 simplified as a comparison against INT_MAX/INT_MIN. */
8716 if (TREE_OVERFLOW (new_const)
8717 && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
8719 int const1_sgn = tree_int_cst_sgn (const1);
8720 enum tree_code code2 = code;
8722 /* Get the sign of the constant on the lhs if the
8723 operation were VARIABLE + CONST1. */
8724 if (TREE_CODE (arg0) == MINUS_EXPR)
8725 const1_sgn = -const1_sgn;
8727 /* The sign of the constant determines if we overflowed
8728 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8729 Canonicalize to the INT_MIN overflow by swapping the comparison
8731 if (const1_sgn == -1)
8732 code2 = swap_tree_comparison (code);
8734 /* We now can look at the canonicalized case
8735 VARIABLE + 1 CODE2 INT_MIN
8736 and decide on the result. */
8743 omit_one_operand_loc (loc, type, boolean_false_node, variable);
8749 omit_one_operand_loc (loc, type, boolean_true_node, variable);
8758 fold_overflow_warning ("assuming signed overflow does not occur "
8759 "when changing X +- C1 cmp C2 to "
8761 WARN_STRICT_OVERFLOW_COMPARISON);
8762 return fold_build2_loc (loc, code, type, variable, new_const);
8766 /* Transform comparisons of the form X - Y CMP 0 to X CMP Y. */
8767 if (TREE_CODE (arg0) == MINUS_EXPR
8769 && integer_zerop (arg1))
8771 /* ??? The transformation is valid for the other operators if overflow
8772 is undefined for the type, but performing it here badly interacts
8773 with the transformation in fold_cond_expr_with_comparison which
8774 attempts to synthetize ABS_EXPR. */
8776 fold_overflow_warning ("assuming signed overflow does not occur "
8777 "when changing X - Y cmp 0 to X cmp Y",
8778 WARN_STRICT_OVERFLOW_COMPARISON);
8779 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
8780 TREE_OPERAND (arg0, 1));
8783 /* For comparisons of pointers we can decompose it to a compile time
8784 comparison of the base objects and the offsets into the object.
8785 This requires at least one operand being an ADDR_EXPR or a
8786 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8787 if (POINTER_TYPE_P (TREE_TYPE (arg0))
8788 && (TREE_CODE (arg0) == ADDR_EXPR
8789 || TREE_CODE (arg1) == ADDR_EXPR
8790 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
8791 || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
8793 tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
8794 HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
8796 int volatilep, unsignedp;
8797 bool indirect_base0 = false, indirect_base1 = false;
8799 /* Get base and offset for the access. Strip ADDR_EXPR for
8800 get_inner_reference, but put it back by stripping INDIRECT_REF
8801 off the base object if possible. indirect_baseN will be true
8802 if baseN is not an address but refers to the object itself. */
8804 if (TREE_CODE (arg0) == ADDR_EXPR)
8806 base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
8807 &bitsize, &bitpos0, &offset0, &mode,
8808 &unsignedp, &volatilep, false);
8809 if (TREE_CODE (base0) == INDIRECT_REF)
8810 base0 = TREE_OPERAND (base0, 0);
8812 indirect_base0 = true;
8814 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
8816 base0 = TREE_OPERAND (arg0, 0);
8817 STRIP_SIGN_NOPS (base0);
8818 if (TREE_CODE (base0) == ADDR_EXPR)
8820 base0 = TREE_OPERAND (base0, 0);
8821 indirect_base0 = true;
8823 offset0 = TREE_OPERAND (arg0, 1);
8824 if (tree_fits_shwi_p (offset0))
8826 HOST_WIDE_INT off = size_low_cst (offset0);
8827 if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
8829 / BITS_PER_UNIT == (HOST_WIDE_INT) off)
8831 bitpos0 = off * BITS_PER_UNIT;
8832 offset0 = NULL_TREE;
8838 if (TREE_CODE (arg1) == ADDR_EXPR)
8840 base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
8841 &bitsize, &bitpos1, &offset1, &mode,
8842 &unsignedp, &volatilep, false);
8843 if (TREE_CODE (base1) == INDIRECT_REF)
8844 base1 = TREE_OPERAND (base1, 0);
8846 indirect_base1 = true;
8848 else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
8850 base1 = TREE_OPERAND (arg1, 0);
8851 STRIP_SIGN_NOPS (base1);
8852 if (TREE_CODE (base1) == ADDR_EXPR)
8854 base1 = TREE_OPERAND (base1, 0);
8855 indirect_base1 = true;
8857 offset1 = TREE_OPERAND (arg1, 1);
8858 if (tree_fits_shwi_p (offset1))
8860 HOST_WIDE_INT off = size_low_cst (offset1);
8861 if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
8863 / BITS_PER_UNIT == (HOST_WIDE_INT) off)
8865 bitpos1 = off * BITS_PER_UNIT;
8866 offset1 = NULL_TREE;
8871 /* A local variable can never be pointed to by
8872 the default SSA name of an incoming parameter. */
8873 if ((TREE_CODE (arg0) == ADDR_EXPR
8875 && TREE_CODE (base0) == VAR_DECL
8876 && auto_var_in_fn_p (base0, current_function_decl)
8878 && TREE_CODE (base1) == SSA_NAME
8879 && SSA_NAME_IS_DEFAULT_DEF (base1)
8880 && TREE_CODE (SSA_NAME_VAR (base1)) == PARM_DECL)
8881 || (TREE_CODE (arg1) == ADDR_EXPR
8883 && TREE_CODE (base1) == VAR_DECL
8884 && auto_var_in_fn_p (base1, current_function_decl)
8886 && TREE_CODE (base0) == SSA_NAME
8887 && SSA_NAME_IS_DEFAULT_DEF (base0)
8888 && TREE_CODE (SSA_NAME_VAR (base0)) == PARM_DECL))
8890 if (code == NE_EXPR)
8891 return constant_boolean_node (1, type);
8892 else if (code == EQ_EXPR)
8893 return constant_boolean_node (0, type);
8895 /* If we have equivalent bases we might be able to simplify. */
8896 else if (indirect_base0 == indirect_base1
8897 && operand_equal_p (base0, base1, 0))
8899 /* We can fold this expression to a constant if the non-constant
8900 offset parts are equal. */
8901 if ((offset0 == offset1
8902 || (offset0 && offset1
8903 && operand_equal_p (offset0, offset1, 0)))
8906 || (indirect_base0 && DECL_P (base0))
8907 || POINTER_TYPE_OVERFLOW_UNDEFINED))
8911 && bitpos0 != bitpos1
8912 && (pointer_may_wrap_p (base0, offset0, bitpos0)
8913 || pointer_may_wrap_p (base1, offset1, bitpos1)))
8914 fold_overflow_warning (("assuming pointer wraparound does not "
8915 "occur when comparing P +- C1 with "
8917 WARN_STRICT_OVERFLOW_CONDITIONAL);
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);
8932 return constant_boolean_node (bitpos0 > bitpos1, type);
8936 /* We can simplify the comparison to a comparison of the variable
8937 offset parts if the constant offset parts are equal.
8938 Be careful to use signed sizetype here because otherwise we
8939 mess with array offsets in the wrong way. This is possible
8940 because pointer arithmetic is restricted to retain within an
8941 object and overflow on pointer differences is undefined as of
8942 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8943 else if (bitpos0 == bitpos1
8945 || (indirect_base0 && DECL_P (base0))
8946 || POINTER_TYPE_OVERFLOW_UNDEFINED))
8948 /* By converting to signed sizetype we cover middle-end pointer
8949 arithmetic which operates on unsigned pointer types of size
8950 type size and ARRAY_REF offsets which are properly sign or
8951 zero extended from their type in case it is narrower than
8953 if (offset0 == NULL_TREE)
8954 offset0 = build_int_cst (ssizetype, 0);
8956 offset0 = fold_convert_loc (loc, ssizetype, offset0);
8957 if (offset1 == NULL_TREE)
8958 offset1 = build_int_cst (ssizetype, 0);
8960 offset1 = fold_convert_loc (loc, ssizetype, offset1);
8963 && (pointer_may_wrap_p (base0, offset0, bitpos0)
8964 || pointer_may_wrap_p (base1, offset1, bitpos1)))
8965 fold_overflow_warning (("assuming pointer wraparound does not "
8966 "occur when comparing P +- C1 with "
8968 WARN_STRICT_OVERFLOW_COMPARISON);
8970 return fold_build2_loc (loc, code, type, offset0, offset1);
8973 /* For non-equal bases we can simplify if they are addresses
8974 of local binding decls or constants. */
8975 else if (indirect_base0 && indirect_base1
8976 /* We know that !operand_equal_p (base0, base1, 0)
8977 because the if condition was false. But make
8978 sure two decls are not the same. */
8980 && TREE_CODE (arg0) == ADDR_EXPR
8981 && TREE_CODE (arg1) == ADDR_EXPR
8982 && (((TREE_CODE (base0) == VAR_DECL
8983 || TREE_CODE (base0) == PARM_DECL)
8984 && (targetm.binds_local_p (base0)
8985 || CONSTANT_CLASS_P (base1)))
8986 || CONSTANT_CLASS_P (base0))
8987 && (((TREE_CODE (base1) == VAR_DECL
8988 || TREE_CODE (base1) == PARM_DECL)
8989 && (targetm.binds_local_p (base1)
8990 || CONSTANT_CLASS_P (base0)))
8991 || CONSTANT_CLASS_P (base1)))
8993 if (code == EQ_EXPR)
8994 return omit_two_operands_loc (loc, type, boolean_false_node,
8996 else if (code == NE_EXPR)
8997 return omit_two_operands_loc (loc, type, boolean_true_node,
9000 /* For equal offsets we can simplify to a comparison of the
9002 else if (bitpos0 == bitpos1
9004 ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
9006 ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
9007 && ((offset0 == offset1)
9008 || (offset0 && offset1
9009 && operand_equal_p (offset0, offset1, 0))))
9012 base0 = build_fold_addr_expr_loc (loc, base0);
9014 base1 = build_fold_addr_expr_loc (loc, base1);
9015 return fold_build2_loc (loc, code, type, base0, base1);
9019 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9020 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9021 the resulting offset is smaller in absolute value than the
9022 original one and has the same sign. */
9023 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9024 && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9025 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9026 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9027 && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
9028 && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9029 && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
9031 tree const1 = TREE_OPERAND (arg0, 1);
9032 tree const2 = TREE_OPERAND (arg1, 1);
9033 tree variable1 = TREE_OPERAND (arg0, 0);
9034 tree variable2 = TREE_OPERAND (arg1, 0);
9036 const char * const warnmsg = G_("assuming signed overflow does not "
9037 "occur when combining constants around "
9040 /* Put the constant on the side where it doesn't overflow and is
9041 of lower absolute value and of same sign than before. */
9042 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9043 ? MINUS_EXPR : PLUS_EXPR,
9045 if (!TREE_OVERFLOW (cst)
9046 && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2)
9047 && tree_int_cst_sgn (cst) == tree_int_cst_sgn (const2))
9049 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9050 return fold_build2_loc (loc, code, type,
9052 fold_build2_loc (loc, TREE_CODE (arg1),
9057 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9058 ? MINUS_EXPR : PLUS_EXPR,
9060 if (!TREE_OVERFLOW (cst)
9061 && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1)
9062 && tree_int_cst_sgn (cst) == tree_int_cst_sgn (const1))
9064 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9065 return fold_build2_loc (loc, code, type,
9066 fold_build2_loc (loc, TREE_CODE (arg0),
9073 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9074 signed arithmetic case. That form is created by the compiler
9075 often enough for folding it to be of value. One example is in
9076 computing loop trip counts after Operator Strength Reduction. */
9077 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9078 && TREE_CODE (arg0) == MULT_EXPR
9079 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9080 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9081 && integer_zerop (arg1))
9083 tree const1 = TREE_OPERAND (arg0, 1);
9084 tree const2 = arg1; /* zero */
9085 tree variable1 = TREE_OPERAND (arg0, 0);
9086 enum tree_code cmp_code = code;
9088 /* Handle unfolded multiplication by zero. */
9089 if (integer_zerop (const1))
9090 return fold_build2_loc (loc, cmp_code, type, const1, const2);
9092 fold_overflow_warning (("assuming signed overflow does not occur when "
9093 "eliminating multiplication in comparison "
9095 WARN_STRICT_OVERFLOW_COMPARISON);
9097 /* If const1 is negative we swap the sense of the comparison. */
9098 if (tree_int_cst_sgn (const1) < 0)
9099 cmp_code = swap_tree_comparison (cmp_code);
9101 return fold_build2_loc (loc, cmp_code, type, variable1, const2);
9104 tem = maybe_canonicalize_comparison (loc, code, type, arg0, arg1);
9108 if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
9110 tree targ0 = strip_float_extensions (arg0);
9111 tree targ1 = strip_float_extensions (arg1);
9112 tree newtype = TREE_TYPE (targ0);
9114 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
9115 newtype = TREE_TYPE (targ1);
9117 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9118 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
9119 return fold_build2_loc (loc, code, type,
9120 fold_convert_loc (loc, newtype, targ0),
9121 fold_convert_loc (loc, newtype, targ1));
9123 /* (-a) CMP (-b) -> b CMP a */
9124 if (TREE_CODE (arg0) == NEGATE_EXPR
9125 && TREE_CODE (arg1) == NEGATE_EXPR)
9126 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg1, 0),
9127 TREE_OPERAND (arg0, 0));
9129 if (TREE_CODE (arg1) == REAL_CST)
9131 REAL_VALUE_TYPE cst;
9132 cst = TREE_REAL_CST (arg1);
9134 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9135 if (TREE_CODE (arg0) == NEGATE_EXPR)
9136 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9137 TREE_OPERAND (arg0, 0),
9138 build_real (TREE_TYPE (arg1),
9139 real_value_negate (&cst)));
9141 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9142 /* a CMP (-0) -> a CMP 0 */
9143 if (REAL_VALUE_MINUS_ZERO (cst))
9144 return fold_build2_loc (loc, code, type, arg0,
9145 build_real (TREE_TYPE (arg1), dconst0));
9147 /* x != NaN is always true, other ops are always false. */
9148 if (REAL_VALUE_ISNAN (cst)
9149 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
9151 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
9152 return omit_one_operand_loc (loc, type, tem, arg0);
9155 /* Fold comparisons against infinity. */
9156 if (REAL_VALUE_ISINF (cst)
9157 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1))))
9159 tem = fold_inf_compare (loc, code, type, arg0, arg1);
9160 if (tem != NULL_TREE)
9165 /* If this is a comparison of a real constant with a PLUS_EXPR
9166 or a MINUS_EXPR of a real constant, we can convert it into a
9167 comparison with a revised real constant as long as no overflow
9168 occurs when unsafe_math_optimizations are enabled. */
9169 if (flag_unsafe_math_optimizations
9170 && TREE_CODE (arg1) == REAL_CST
9171 && (TREE_CODE (arg0) == PLUS_EXPR
9172 || TREE_CODE (arg0) == MINUS_EXPR)
9173 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
9174 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9175 ? MINUS_EXPR : PLUS_EXPR,
9176 arg1, TREE_OPERAND (arg0, 1)))
9177 && !TREE_OVERFLOW (tem))
9178 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
9180 /* Likewise, we can simplify a comparison of a real constant with
9181 a MINUS_EXPR whose first operand is also a real constant, i.e.
9182 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9183 floating-point types only if -fassociative-math is set. */
9184 if (flag_associative_math
9185 && TREE_CODE (arg1) == REAL_CST
9186 && TREE_CODE (arg0) == MINUS_EXPR
9187 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
9188 && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
9190 && !TREE_OVERFLOW (tem))
9191 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9192 TREE_OPERAND (arg0, 1), tem);
9194 /* Fold comparisons against built-in math functions. */
9195 if (TREE_CODE (arg1) == REAL_CST
9196 && flag_unsafe_math_optimizations
9197 && ! flag_errno_math)
9199 enum built_in_function fcode = builtin_mathfn_code (arg0);
9201 if (fcode != END_BUILTINS)
9203 tem = fold_mathfn_compare (loc, fcode, code, type, arg0, arg1);
9204 if (tem != NULL_TREE)
9210 if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
9211 && CONVERT_EXPR_P (arg0))
9213 /* If we are widening one operand of an integer comparison,
9214 see if the other operand is similarly being widened. Perhaps we
9215 can do the comparison in the narrower type. */
9216 tem = fold_widened_comparison (loc, code, type, arg0, arg1);
9220 /* Or if we are changing signedness. */
9221 tem = fold_sign_changed_comparison (loc, code, type, arg0, arg1);
9226 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9227 constant, we can simplify it. */
9228 if (TREE_CODE (arg1) == INTEGER_CST
9229 && (TREE_CODE (arg0) == MIN_EXPR
9230 || TREE_CODE (arg0) == MAX_EXPR)
9231 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9233 tem = optimize_minmax_comparison (loc, code, type, op0, op1);
9238 /* Simplify comparison of something with itself. (For IEEE
9239 floating-point, we can only do some of these simplifications.) */
9240 if (operand_equal_p (arg0, arg1, 0))
9245 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9246 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9247 return constant_boolean_node (1, type);
9252 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9253 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9254 return constant_boolean_node (1, type);
9255 return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg1);
9258 /* For NE, we can only do this simplification if integer
9259 or we don't honor IEEE floating point NaNs. */
9260 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9261 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9263 /* ... fall through ... */
9266 return constant_boolean_node (0, type);
9272 /* If we are comparing an expression that just has comparisons
9273 of two integer values, arithmetic expressions of those comparisons,
9274 and constants, we can simplify it. There are only three cases
9275 to check: the two values can either be equal, the first can be
9276 greater, or the second can be greater. Fold the expression for
9277 those three values. Since each value must be 0 or 1, we have
9278 eight possibilities, each of which corresponds to the constant 0
9279 or 1 or one of the six possible comparisons.
9281 This handles common cases like (a > b) == 0 but also handles
9282 expressions like ((x > y) - (y > x)) > 0, which supposedly
9283 occur in macroized code. */
9285 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9287 tree cval1 = 0, cval2 = 0;
9290 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9291 /* Don't handle degenerate cases here; they should already
9292 have been handled anyway. */
9293 && cval1 != 0 && cval2 != 0
9294 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9295 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9296 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9297 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9298 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9299 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9300 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9302 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9303 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9305 /* We can't just pass T to eval_subst in case cval1 or cval2
9306 was the same as ARG1. */
9309 = fold_build2_loc (loc, code, type,
9310 eval_subst (loc, arg0, cval1, maxval,
9314 = fold_build2_loc (loc, code, type,
9315 eval_subst (loc, arg0, cval1, maxval,
9319 = fold_build2_loc (loc, code, type,
9320 eval_subst (loc, arg0, cval1, minval,
9324 /* All three of these results should be 0 or 1. Confirm they are.
9325 Then use those values to select the proper code to use. */
9327 if (TREE_CODE (high_result) == INTEGER_CST
9328 && TREE_CODE (equal_result) == INTEGER_CST
9329 && TREE_CODE (low_result) == INTEGER_CST)
9331 /* Make a 3-bit mask with the high-order bit being the
9332 value for `>', the next for '=', and the low for '<'. */
9333 switch ((integer_onep (high_result) * 4)
9334 + (integer_onep (equal_result) * 2)
9335 + integer_onep (low_result))
9339 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
9360 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
9365 tem = save_expr (build2 (code, type, cval1, cval2));
9366 SET_EXPR_LOCATION (tem, loc);
9369 return fold_build2_loc (loc, code, type, cval1, cval2);
9374 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9375 into a single range test. */
9376 if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9377 || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9378 && TREE_CODE (arg1) == INTEGER_CST
9379 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9380 && !integer_zerop (TREE_OPERAND (arg0, 1))
9381 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9382 && !TREE_OVERFLOW (arg1))
9384 tem = fold_div_compare (loc, code, type, arg0, arg1);
9385 if (tem != NULL_TREE)
9389 /* Fold ~X op ~Y as Y op X. */
9390 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9391 && TREE_CODE (arg1) == BIT_NOT_EXPR)
9393 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9394 return fold_build2_loc (loc, code, type,
9395 fold_convert_loc (loc, cmp_type,
9396 TREE_OPERAND (arg1, 0)),
9397 TREE_OPERAND (arg0, 0));
9400 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9401 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9402 && (TREE_CODE (arg1) == INTEGER_CST || TREE_CODE (arg1) == VECTOR_CST))
9404 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9405 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9406 TREE_OPERAND (arg0, 0),
9407 fold_build1_loc (loc, BIT_NOT_EXPR, cmp_type,
9408 fold_convert_loc (loc, cmp_type, arg1)));
9415 /* Subroutine of fold_binary. Optimize complex multiplications of the
9416 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9417 argument EXPR represents the expression "z" of type TYPE. */
9420 fold_mult_zconjz (location_t loc, tree type, tree expr)
9422 tree itype = TREE_TYPE (type);
9423 tree rpart, ipart, tem;
9425 if (TREE_CODE (expr) == COMPLEX_EXPR)
9427 rpart = TREE_OPERAND (expr, 0);
9428 ipart = TREE_OPERAND (expr, 1);
9430 else if (TREE_CODE (expr) == COMPLEX_CST)
9432 rpart = TREE_REALPART (expr);
9433 ipart = TREE_IMAGPART (expr);
9437 expr = save_expr (expr);
9438 rpart = fold_build1_loc (loc, REALPART_EXPR, itype, expr);
9439 ipart = fold_build1_loc (loc, IMAGPART_EXPR, itype, expr);
9442 rpart = save_expr (rpart);
9443 ipart = save_expr (ipart);
9444 tem = fold_build2_loc (loc, PLUS_EXPR, itype,
9445 fold_build2_loc (loc, MULT_EXPR, itype, rpart, rpart),
9446 fold_build2_loc (loc, MULT_EXPR, itype, ipart, ipart));
9447 return fold_build2_loc (loc, COMPLEX_EXPR, type, tem,
9448 build_zero_cst (itype));
9452 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9453 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9454 guarantees that P and N have the same least significant log2(M) bits.
9455 N is not otherwise constrained. In particular, N is not normalized to
9456 0 <= N < M as is common. In general, the precise value of P is unknown.
9457 M is chosen as large as possible such that constant N can be determined.
9459 Returns M and sets *RESIDUE to N.
9461 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9462 account. This is not always possible due to PR 35705.
9465 static unsigned HOST_WIDE_INT
9466 get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue,
9467 bool allow_func_align)
9469 enum tree_code code;
9473 code = TREE_CODE (expr);
9474 if (code == ADDR_EXPR)
9476 unsigned int bitalign;
9477 get_object_alignment_1 (TREE_OPERAND (expr, 0), &bitalign, residue);
9478 *residue /= BITS_PER_UNIT;
9479 return bitalign / BITS_PER_UNIT;
9481 else if (code == POINTER_PLUS_EXPR)
9484 unsigned HOST_WIDE_INT modulus;
9485 enum tree_code inner_code;
9487 op0 = TREE_OPERAND (expr, 0);
9489 modulus = get_pointer_modulus_and_residue (op0, residue,
9492 op1 = TREE_OPERAND (expr, 1);
9494 inner_code = TREE_CODE (op1);
9495 if (inner_code == INTEGER_CST)
9497 *residue += TREE_INT_CST_LOW (op1);
9500 else if (inner_code == MULT_EXPR)
9502 op1 = TREE_OPERAND (op1, 1);
9503 if (TREE_CODE (op1) == INTEGER_CST)
9505 unsigned HOST_WIDE_INT align;
9507 /* Compute the greatest power-of-2 divisor of op1. */
9508 align = TREE_INT_CST_LOW (op1);
9511 /* If align is non-zero and less than *modulus, replace
9512 *modulus with align., If align is 0, then either op1 is 0
9513 or the greatest power-of-2 divisor of op1 doesn't fit in an
9514 unsigned HOST_WIDE_INT. In either case, no additional
9515 constraint is imposed. */
9517 modulus = MIN (modulus, align);
9524 /* If we get here, we were unable to determine anything useful about the
9529 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
9530 CONSTRUCTOR ARG into array ELTS and return true if successful. */
9533 vec_cst_ctor_to_array (tree arg, tree *elts)
9535 unsigned int nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg)), i;
9537 if (TREE_CODE (arg) == VECTOR_CST)
9539 for (i = 0; i < VECTOR_CST_NELTS (arg); ++i)
9540 elts[i] = VECTOR_CST_ELT (arg, i);
9542 else if (TREE_CODE (arg) == CONSTRUCTOR)
9544 constructor_elt *elt;
9546 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg), i, elt)
9547 if (i >= nelts || TREE_CODE (TREE_TYPE (elt->value)) == VECTOR_TYPE)
9550 elts[i] = elt->value;
9554 for (; i < nelts; i++)
9556 = fold_convert (TREE_TYPE (TREE_TYPE (arg)), integer_zero_node);
9560 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
9561 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
9562 NULL_TREE otherwise. */
9565 fold_vec_perm (tree type, tree arg0, tree arg1, const unsigned char *sel)
9567 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
9569 bool need_ctor = false;
9571 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts
9572 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts);
9573 if (TREE_TYPE (TREE_TYPE (arg0)) != TREE_TYPE (type)
9574 || TREE_TYPE (TREE_TYPE (arg1)) != TREE_TYPE (type))
9577 elts = XALLOCAVEC (tree, nelts * 3);
9578 if (!vec_cst_ctor_to_array (arg0, elts)
9579 || !vec_cst_ctor_to_array (arg1, elts + nelts))
9582 for (i = 0; i < nelts; i++)
9584 if (!CONSTANT_CLASS_P (elts[sel[i]]))
9586 elts[i + 2 * nelts] = unshare_expr (elts[sel[i]]);
9591 vec<constructor_elt, va_gc> *v;
9592 vec_alloc (v, nelts);
9593 for (i = 0; i < nelts; i++)
9594 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[2 * nelts + i]);
9595 return build_constructor (type, v);
9598 return build_vector (type, &elts[2 * nelts]);
9601 /* Try to fold a pointer difference of type TYPE two address expressions of
9602 array references AREF0 and AREF1 using location LOC. Return a
9603 simplified expression for the difference or NULL_TREE. */
9606 fold_addr_of_array_ref_difference (location_t loc, tree type,
9607 tree aref0, tree aref1)
9609 tree base0 = TREE_OPERAND (aref0, 0);
9610 tree base1 = TREE_OPERAND (aref1, 0);
9611 tree base_offset = build_int_cst (type, 0);
9613 /* If the bases are array references as well, recurse. If the bases
9614 are pointer indirections compute the difference of the pointers.
9615 If the bases are equal, we are set. */
9616 if ((TREE_CODE (base0) == ARRAY_REF
9617 && TREE_CODE (base1) == ARRAY_REF
9619 = fold_addr_of_array_ref_difference (loc, type, base0, base1)))
9620 || (INDIRECT_REF_P (base0)
9621 && INDIRECT_REF_P (base1)
9622 && (base_offset = fold_binary_loc (loc, MINUS_EXPR, type,
9623 TREE_OPERAND (base0, 0),
9624 TREE_OPERAND (base1, 0))))
9625 || operand_equal_p (base0, base1, 0))
9627 tree op0 = fold_convert_loc (loc, type, TREE_OPERAND (aref0, 1));
9628 tree op1 = fold_convert_loc (loc, type, TREE_OPERAND (aref1, 1));
9629 tree esz = fold_convert_loc (loc, type, array_ref_element_size (aref0));
9630 tree diff = build2 (MINUS_EXPR, type, op0, op1);
9631 return fold_build2_loc (loc, PLUS_EXPR, type,
9633 fold_build2_loc (loc, MULT_EXPR, type,
9639 /* If the real or vector real constant CST of type TYPE has an exact
9640 inverse, return it, else return NULL. */
9643 exact_inverse (tree type, tree cst)
9646 tree unit_type, *elts;
9648 unsigned vec_nelts, i;
9650 switch (TREE_CODE (cst))
9653 r = TREE_REAL_CST (cst);
9655 if (exact_real_inverse (TYPE_MODE (type), &r))
9656 return build_real (type, r);
9661 vec_nelts = VECTOR_CST_NELTS (cst);
9662 elts = XALLOCAVEC (tree, vec_nelts);
9663 unit_type = TREE_TYPE (type);
9664 mode = TYPE_MODE (unit_type);
9666 for (i = 0; i < vec_nelts; i++)
9668 r = TREE_REAL_CST (VECTOR_CST_ELT (cst, i));
9669 if (!exact_real_inverse (mode, &r))
9671 elts[i] = build_real (unit_type, r);
9674 return build_vector (type, elts);
9681 /* Mask out the tz least significant bits of X of type TYPE where
9682 tz is the number of trailing zeroes in Y. */
9684 mask_with_tz (tree type, const wide_int &x, const wide_int &y)
9686 int tz = wi::ctz (y);
9688 return wi::mask (tz, true, TYPE_PRECISION (type)) & x;
9692 /* Return true when T is an address and is known to be nonzero.
9693 For floating point we further ensure that T is not denormal.
9694 Similar logic is present in nonzero_address in rtlanal.h.
9696 If the return value is based on the assumption that signed overflow
9697 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9698 change *STRICT_OVERFLOW_P. */
9701 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
9703 tree type = TREE_TYPE (t);
9704 enum tree_code code;
9706 /* Doing something useful for floating point would need more work. */
9707 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
9710 code = TREE_CODE (t);
9711 switch (TREE_CODE_CLASS (code))
9714 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
9717 case tcc_comparison:
9718 return tree_binary_nonzero_warnv_p (code, type,
9719 TREE_OPERAND (t, 0),
9720 TREE_OPERAND (t, 1),
9723 case tcc_declaration:
9725 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
9733 case TRUTH_NOT_EXPR:
9734 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
9737 case TRUTH_AND_EXPR:
9739 case TRUTH_XOR_EXPR:
9740 return tree_binary_nonzero_warnv_p (code, type,
9741 TREE_OPERAND (t, 0),
9742 TREE_OPERAND (t, 1),
9750 case WITH_SIZE_EXPR:
9752 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
9757 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
9761 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
9766 tree fndecl = get_callee_fndecl (t);
9767 if (!fndecl) return false;
9768 if (flag_delete_null_pointer_checks && !flag_check_new
9769 && DECL_IS_OPERATOR_NEW (fndecl)
9770 && !TREE_NOTHROW (fndecl))
9772 if (flag_delete_null_pointer_checks
9773 && lookup_attribute ("returns_nonnull",
9774 TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
9776 return alloca_call_p (t);
9785 /* Return true when T is an address and is known to be nonzero.
9786 Handle warnings about undefined signed overflow. */
9789 tree_expr_nonzero_p (tree t)
9791 bool ret, strict_overflow_p;
9793 strict_overflow_p = false;
9794 ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
9795 if (strict_overflow_p)
9796 fold_overflow_warning (("assuming signed overflow does not occur when "
9797 "determining that expression is always "
9799 WARN_STRICT_OVERFLOW_MISC);
9803 /* Fold a binary expression of code CODE and type TYPE with operands
9804 OP0 and OP1. LOC is the location of the resulting expression.
9805 Return the folded expression if folding is successful. Otherwise,
9806 return NULL_TREE. */
9809 fold_binary_loc (location_t loc,
9810 enum tree_code code, tree type, tree op0, tree op1)
9812 enum tree_code_class kind = TREE_CODE_CLASS (code);
9813 tree arg0, arg1, tem;
9814 tree t1 = NULL_TREE;
9815 bool strict_overflow_p;
9818 gcc_assert (IS_EXPR_CODE_CLASS (kind)
9819 && TREE_CODE_LENGTH (code) == 2
9821 && op1 != NULL_TREE);
9826 /* Strip any conversions that don't change the mode. This is
9827 safe for every expression, except for a comparison expression
9828 because its signedness is derived from its operands. So, in
9829 the latter case, only strip conversions that don't change the
9830 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9833 Note that this is done as an internal manipulation within the
9834 constant folder, in order to find the simplest representation
9835 of the arguments so that their form can be studied. In any
9836 cases, the appropriate type conversions should be put back in
9837 the tree that will get out of the constant folder. */
9839 if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
9841 STRIP_SIGN_NOPS (arg0);
9842 STRIP_SIGN_NOPS (arg1);
9850 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9851 constant but we can't do arithmetic on them. */
9852 if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9853 || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
9854 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == FIXED_CST)
9855 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == INTEGER_CST)
9856 || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
9857 || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
9858 || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == INTEGER_CST))
9860 if (kind == tcc_binary)
9862 /* Make sure type and arg0 have the same saturating flag. */
9863 gcc_assert (TYPE_SATURATING (type)
9864 == TYPE_SATURATING (TREE_TYPE (arg0)));
9865 tem = const_binop (code, arg0, arg1);
9867 else if (kind == tcc_comparison)
9868 tem = fold_relational_const (code, type, arg0, arg1);
9872 if (tem != NULL_TREE)
9874 if (TREE_TYPE (tem) != type)
9875 tem = fold_convert_loc (loc, type, tem);
9880 /* If this is a commutative operation, and ARG0 is a constant, move it
9881 to ARG1 to reduce the number of tests below. */
9882 if (commutative_tree_code (code)
9883 && tree_swap_operands_p (arg0, arg1, true))
9884 return fold_build2_loc (loc, code, type, op1, op0);
9886 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9887 to ARG1 to reduce the number of tests below. */
9888 if (kind == tcc_comparison
9889 && tree_swap_operands_p (arg0, arg1, true))
9890 return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
9892 tem = generic_simplify (loc, code, type, op0, op1);
9896 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9898 First check for cases where an arithmetic operation is applied to a
9899 compound, conditional, or comparison operation. Push the arithmetic
9900 operation inside the compound or conditional to see if any folding
9901 can then be done. Convert comparison to conditional for this purpose.
9902 The also optimizes non-constant cases that used to be done in
9905 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9906 one of the operands is a comparison and the other is a comparison, a
9907 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9908 code below would make the expression more complex. Change it to a
9909 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9910 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9912 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9913 || code == EQ_EXPR || code == NE_EXPR)
9914 && TREE_CODE (type) != VECTOR_TYPE
9915 && ((truth_value_p (TREE_CODE (arg0))
9916 && (truth_value_p (TREE_CODE (arg1))
9917 || (TREE_CODE (arg1) == BIT_AND_EXPR
9918 && integer_onep (TREE_OPERAND (arg1, 1)))))
9919 || (truth_value_p (TREE_CODE (arg1))
9920 && (truth_value_p (TREE_CODE (arg0))
9921 || (TREE_CODE (arg0) == BIT_AND_EXPR
9922 && integer_onep (TREE_OPERAND (arg0, 1)))))))
9924 tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9925 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9928 fold_convert_loc (loc, boolean_type_node, arg0),
9929 fold_convert_loc (loc, boolean_type_node, arg1));
9931 if (code == EQ_EXPR)
9932 tem = invert_truthvalue_loc (loc, tem);
9934 return fold_convert_loc (loc, type, tem);
9937 if (TREE_CODE_CLASS (code) == tcc_binary
9938 || TREE_CODE_CLASS (code) == tcc_comparison)
9940 if (TREE_CODE (arg0) == COMPOUND_EXPR)
9942 tem = fold_build2_loc (loc, code, type,
9943 fold_convert_loc (loc, TREE_TYPE (op0),
9944 TREE_OPERAND (arg0, 1)), op1);
9945 return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9948 if (TREE_CODE (arg1) == COMPOUND_EXPR
9949 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9951 tem = fold_build2_loc (loc, code, type, op0,
9952 fold_convert_loc (loc, TREE_TYPE (op1),
9953 TREE_OPERAND (arg1, 1)));
9954 return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9958 if (TREE_CODE (arg0) == COND_EXPR
9959 || TREE_CODE (arg0) == VEC_COND_EXPR
9960 || COMPARISON_CLASS_P (arg0))
9962 tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9964 /*cond_first_p=*/1);
9965 if (tem != NULL_TREE)
9969 if (TREE_CODE (arg1) == COND_EXPR
9970 || TREE_CODE (arg1) == VEC_COND_EXPR
9971 || COMPARISON_CLASS_P (arg1))
9973 tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
9975 /*cond_first_p=*/0);
9976 if (tem != NULL_TREE)
9984 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9985 if (TREE_CODE (arg0) == ADDR_EXPR
9986 && TREE_CODE (TREE_OPERAND (arg0, 0)) == MEM_REF)
9988 tree iref = TREE_OPERAND (arg0, 0);
9989 return fold_build2 (MEM_REF, type,
9990 TREE_OPERAND (iref, 0),
9991 int_const_binop (PLUS_EXPR, arg1,
9992 TREE_OPERAND (iref, 1)));
9995 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9996 if (TREE_CODE (arg0) == ADDR_EXPR
9997 && handled_component_p (TREE_OPERAND (arg0, 0)))
10000 HOST_WIDE_INT coffset;
10001 base = get_addr_base_and_unit_offset (TREE_OPERAND (arg0, 0),
10005 return fold_build2 (MEM_REF, type,
10006 build_fold_addr_expr (base),
10007 int_const_binop (PLUS_EXPR, arg1,
10008 size_int (coffset)));
10013 case POINTER_PLUS_EXPR:
10014 /* 0 +p index -> (type)index */
10015 if (integer_zerop (arg0))
10016 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10018 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
10019 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10020 && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
10021 return fold_convert_loc (loc, type,
10022 fold_build2_loc (loc, PLUS_EXPR, sizetype,
10023 fold_convert_loc (loc, sizetype,
10025 fold_convert_loc (loc, sizetype,
10028 /* (PTR +p B) +p A -> PTR +p (B + A) */
10029 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10032 tree arg01 = fold_convert_loc (loc, sizetype, TREE_OPERAND (arg0, 1));
10033 tree arg00 = TREE_OPERAND (arg0, 0);
10034 inner = fold_build2_loc (loc, PLUS_EXPR, sizetype,
10035 arg01, fold_convert_loc (loc, sizetype, arg1));
10036 return fold_convert_loc (loc, type,
10037 fold_build_pointer_plus_loc (loc,
10041 /* PTR_CST +p CST -> CST1 */
10042 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
10043 return fold_build2_loc (loc, PLUS_EXPR, type, arg0,
10044 fold_convert_loc (loc, type, arg1));
10049 /* A + (-B) -> A - B */
10050 if (TREE_CODE (arg1) == NEGATE_EXPR
10051 && (flag_sanitize & SANITIZE_SI_OVERFLOW) == 0)
10052 return fold_build2_loc (loc, MINUS_EXPR, type,
10053 fold_convert_loc (loc, type, arg0),
10054 fold_convert_loc (loc, type,
10055 TREE_OPERAND (arg1, 0)));
10056 /* (-A) + B -> B - A */
10057 if (TREE_CODE (arg0) == NEGATE_EXPR
10058 && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1)
10059 && (flag_sanitize & SANITIZE_SI_OVERFLOW) == 0)
10060 return fold_build2_loc (loc, MINUS_EXPR, type,
10061 fold_convert_loc (loc, type, arg1),
10062 fold_convert_loc (loc, type,
10063 TREE_OPERAND (arg0, 0)));
10065 if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
10067 /* Convert ~A + 1 to -A. */
10068 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10069 && integer_each_onep (arg1))
10070 return fold_build1_loc (loc, NEGATE_EXPR, type,
10071 fold_convert_loc (loc, type,
10072 TREE_OPERAND (arg0, 0)));
10074 /* ~X + X is -1. */
10075 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10076 && !TYPE_OVERFLOW_TRAPS (type))
10078 tree tem = TREE_OPERAND (arg0, 0);
10081 if (operand_equal_p (tem, arg1, 0))
10083 t1 = build_all_ones_cst (type);
10084 return omit_one_operand_loc (loc, type, t1, arg1);
10088 /* X + ~X is -1. */
10089 if (TREE_CODE (arg1) == BIT_NOT_EXPR
10090 && !TYPE_OVERFLOW_TRAPS (type))
10092 tree tem = TREE_OPERAND (arg1, 0);
10095 if (operand_equal_p (arg0, tem, 0))
10097 t1 = build_all_ones_cst (type);
10098 return omit_one_operand_loc (loc, type, t1, arg0);
10102 /* X + (X / CST) * -CST is X % CST. */
10103 if (TREE_CODE (arg1) == MULT_EXPR
10104 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10105 && operand_equal_p (arg0,
10106 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
10108 tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
10109 tree cst1 = TREE_OPERAND (arg1, 1);
10110 tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (cst1),
10112 if (sum && integer_zerop (sum))
10113 return fold_convert_loc (loc, type,
10114 fold_build2_loc (loc, TRUNC_MOD_EXPR,
10115 TREE_TYPE (arg0), arg0,
10120 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
10121 one. Make sure the type is not saturating and has the signedness of
10122 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10123 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10124 if ((TREE_CODE (arg0) == MULT_EXPR
10125 || TREE_CODE (arg1) == MULT_EXPR)
10126 && !TYPE_SATURATING (type)
10127 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
10128 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
10129 && (!FLOAT_TYPE_P (type) || flag_associative_math))
10131 tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
10136 if (! FLOAT_TYPE_P (type))
10138 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10139 with a constant, and the two constants have no bits in common,
10140 we should treat this as a BIT_IOR_EXPR since this may produce more
10141 simplifications. */
10142 if (TREE_CODE (arg0) == BIT_AND_EXPR
10143 && TREE_CODE (arg1) == BIT_AND_EXPR
10144 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10145 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
10146 && wi::bit_and (TREE_OPERAND (arg0, 1),
10147 TREE_OPERAND (arg1, 1)) == 0)
10149 code = BIT_IOR_EXPR;
10153 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10154 (plus (plus (mult) (mult)) (foo)) so that we can
10155 take advantage of the factoring cases below. */
10156 if (TYPE_OVERFLOW_WRAPS (type)
10157 && (((TREE_CODE (arg0) == PLUS_EXPR
10158 || TREE_CODE (arg0) == MINUS_EXPR)
10159 && TREE_CODE (arg1) == MULT_EXPR)
10160 || ((TREE_CODE (arg1) == PLUS_EXPR
10161 || TREE_CODE (arg1) == MINUS_EXPR)
10162 && TREE_CODE (arg0) == MULT_EXPR)))
10164 tree parg0, parg1, parg, marg;
10165 enum tree_code pcode;
10167 if (TREE_CODE (arg1) == MULT_EXPR)
10168 parg = arg0, marg = arg1;
10170 parg = arg1, marg = arg0;
10171 pcode = TREE_CODE (parg);
10172 parg0 = TREE_OPERAND (parg, 0);
10173 parg1 = TREE_OPERAND (parg, 1);
10174 STRIP_NOPS (parg0);
10175 STRIP_NOPS (parg1);
10177 if (TREE_CODE (parg0) == MULT_EXPR
10178 && TREE_CODE (parg1) != MULT_EXPR)
10179 return fold_build2_loc (loc, pcode, type,
10180 fold_build2_loc (loc, PLUS_EXPR, type,
10181 fold_convert_loc (loc, type,
10183 fold_convert_loc (loc, type,
10185 fold_convert_loc (loc, type, parg1));
10186 if (TREE_CODE (parg0) != MULT_EXPR
10187 && TREE_CODE (parg1) == MULT_EXPR)
10189 fold_build2_loc (loc, PLUS_EXPR, type,
10190 fold_convert_loc (loc, type, parg0),
10191 fold_build2_loc (loc, pcode, type,
10192 fold_convert_loc (loc, type, marg),
10193 fold_convert_loc (loc, type,
10199 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10200 if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
10201 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10203 /* Likewise if the operands are reversed. */
10204 if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10205 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10207 /* Convert X + -C into X - C. */
10208 if (TREE_CODE (arg1) == REAL_CST
10209 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
10211 tem = fold_negate_const (arg1, type);
10212 if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
10213 return fold_build2_loc (loc, MINUS_EXPR, type,
10214 fold_convert_loc (loc, type, arg0),
10215 fold_convert_loc (loc, type, tem));
10218 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10219 to __complex__ ( x, y ). This is not the same for SNaNs or
10220 if signed zeros are involved. */
10221 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10222 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10223 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10225 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10226 tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10227 tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10228 bool arg0rz = false, arg0iz = false;
10229 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10230 || (arg0i && (arg0iz = real_zerop (arg0i))))
10232 tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10233 tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10234 if (arg0rz && arg1i && real_zerop (arg1i))
10236 tree rp = arg1r ? arg1r
10237 : build1 (REALPART_EXPR, rtype, arg1);
10238 tree ip = arg0i ? arg0i
10239 : build1 (IMAGPART_EXPR, rtype, arg0);
10240 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10242 else if (arg0iz && arg1r && real_zerop (arg1r))
10244 tree rp = arg0r ? arg0r
10245 : build1 (REALPART_EXPR, rtype, arg0);
10246 tree ip = arg1i ? arg1i
10247 : build1 (IMAGPART_EXPR, rtype, arg1);
10248 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10253 if (flag_unsafe_math_optimizations
10254 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10255 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10256 && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
10259 /* Convert x+x into x*2.0. */
10260 if (operand_equal_p (arg0, arg1, 0)
10261 && SCALAR_FLOAT_TYPE_P (type))
10262 return fold_build2_loc (loc, MULT_EXPR, type, arg0,
10263 build_real (type, dconst2));
10265 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10266 We associate floats only if the user has specified
10267 -fassociative-math. */
10268 if (flag_associative_math
10269 && TREE_CODE (arg1) == PLUS_EXPR
10270 && TREE_CODE (arg0) != MULT_EXPR)
10272 tree tree10 = TREE_OPERAND (arg1, 0);
10273 tree tree11 = TREE_OPERAND (arg1, 1);
10274 if (TREE_CODE (tree11) == MULT_EXPR
10275 && TREE_CODE (tree10) == MULT_EXPR)
10278 tree0 = fold_build2_loc (loc, PLUS_EXPR, type, arg0, tree10);
10279 return fold_build2_loc (loc, PLUS_EXPR, type, tree0, tree11);
10282 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10283 We associate floats only if the user has specified
10284 -fassociative-math. */
10285 if (flag_associative_math
10286 && TREE_CODE (arg0) == PLUS_EXPR
10287 && TREE_CODE (arg1) != MULT_EXPR)
10289 tree tree00 = TREE_OPERAND (arg0, 0);
10290 tree tree01 = TREE_OPERAND (arg0, 1);
10291 if (TREE_CODE (tree01) == MULT_EXPR
10292 && TREE_CODE (tree00) == MULT_EXPR)
10295 tree0 = fold_build2_loc (loc, PLUS_EXPR, type, tree01, arg1);
10296 return fold_build2_loc (loc, PLUS_EXPR, type, tree00, tree0);
10302 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10303 is a rotate of A by C1 bits. */
10304 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10305 is a rotate of A by B bits. */
10307 enum tree_code code0, code1;
10309 code0 = TREE_CODE (arg0);
10310 code1 = TREE_CODE (arg1);
10311 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
10312 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
10313 && operand_equal_p (TREE_OPERAND (arg0, 0),
10314 TREE_OPERAND (arg1, 0), 0)
10315 && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
10316 TYPE_UNSIGNED (rtype))
10317 /* Only create rotates in complete modes. Other cases are not
10318 expanded properly. */
10319 && (element_precision (rtype)
10320 == element_precision (TYPE_MODE (rtype))))
10322 tree tree01, tree11;
10323 enum tree_code code01, code11;
10325 tree01 = TREE_OPERAND (arg0, 1);
10326 tree11 = TREE_OPERAND (arg1, 1);
10327 STRIP_NOPS (tree01);
10328 STRIP_NOPS (tree11);
10329 code01 = TREE_CODE (tree01);
10330 code11 = TREE_CODE (tree11);
10331 if (code01 == INTEGER_CST
10332 && code11 == INTEGER_CST
10333 && (wi::to_widest (tree01) + wi::to_widest (tree11)
10334 == element_precision (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
10336 tem = build2_loc (loc, LROTATE_EXPR,
10337 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10338 TREE_OPERAND (arg0, 0),
10339 code0 == LSHIFT_EXPR ? tree01 : tree11);
10340 return fold_convert_loc (loc, type, tem);
10342 else if (code11 == MINUS_EXPR)
10344 tree tree110, tree111;
10345 tree110 = TREE_OPERAND (tree11, 0);
10346 tree111 = TREE_OPERAND (tree11, 1);
10347 STRIP_NOPS (tree110);
10348 STRIP_NOPS (tree111);
10349 if (TREE_CODE (tree110) == INTEGER_CST
10350 && 0 == compare_tree_int (tree110,
10352 (TREE_TYPE (TREE_OPERAND
10354 && operand_equal_p (tree01, tree111, 0))
10356 fold_convert_loc (loc, type,
10357 build2 ((code0 == LSHIFT_EXPR
10360 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10361 TREE_OPERAND (arg0, 0), tree01));
10363 else if (code01 == MINUS_EXPR)
10365 tree tree010, tree011;
10366 tree010 = TREE_OPERAND (tree01, 0);
10367 tree011 = TREE_OPERAND (tree01, 1);
10368 STRIP_NOPS (tree010);
10369 STRIP_NOPS (tree011);
10370 if (TREE_CODE (tree010) == INTEGER_CST
10371 && 0 == compare_tree_int (tree010,
10373 (TREE_TYPE (TREE_OPERAND
10375 && operand_equal_p (tree11, tree011, 0))
10376 return fold_convert_loc
10378 build2 ((code0 != LSHIFT_EXPR
10381 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10382 TREE_OPERAND (arg0, 0), tree11));
10388 /* In most languages, can't associate operations on floats through
10389 parentheses. Rather than remember where the parentheses were, we
10390 don't associate floats at all, unless the user has specified
10391 -fassociative-math.
10392 And, we need to make sure type is not saturating. */
10394 if ((! FLOAT_TYPE_P (type) || flag_associative_math)
10395 && !TYPE_SATURATING (type))
10397 tree var0, con0, lit0, minus_lit0;
10398 tree var1, con1, lit1, minus_lit1;
10402 /* Split both trees into variables, constants, and literals. Then
10403 associate each group together, the constants with literals,
10404 then the result with variables. This increases the chances of
10405 literals being recombined later and of generating relocatable
10406 expressions for the sum of a constant and literal. */
10407 var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
10408 var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
10409 code == MINUS_EXPR);
10411 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10412 if (code == MINUS_EXPR)
10415 /* With undefined overflow prefer doing association in a type
10416 which wraps on overflow, if that is one of the operand types. */
10417 if ((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10418 || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
10420 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
10421 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
10422 atype = TREE_TYPE (arg0);
10423 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10424 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
10425 atype = TREE_TYPE (arg1);
10426 gcc_assert (TYPE_PRECISION (atype) == TYPE_PRECISION (type));
10429 /* With undefined overflow we can only associate constants with one
10430 variable, and constants whose association doesn't overflow. */
10431 if ((POINTER_TYPE_P (atype) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10432 || (INTEGRAL_TYPE_P (atype) && !TYPE_OVERFLOW_WRAPS (atype)))
10439 if (TREE_CODE (tmp0) == NEGATE_EXPR)
10440 tmp0 = TREE_OPERAND (tmp0, 0);
10441 if (CONVERT_EXPR_P (tmp0)
10442 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
10443 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
10444 <= TYPE_PRECISION (atype)))
10445 tmp0 = TREE_OPERAND (tmp0, 0);
10446 if (TREE_CODE (tmp1) == NEGATE_EXPR)
10447 tmp1 = TREE_OPERAND (tmp1, 0);
10448 if (CONVERT_EXPR_P (tmp1)
10449 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
10450 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
10451 <= TYPE_PRECISION (atype)))
10452 tmp1 = TREE_OPERAND (tmp1, 0);
10453 /* The only case we can still associate with two variables
10454 is if they are the same, modulo negation and bit-pattern
10455 preserving conversions. */
10456 if (!operand_equal_p (tmp0, tmp1, 0))
10461 /* Only do something if we found more than two objects. Otherwise,
10462 nothing has changed and we risk infinite recursion. */
10464 && (2 < ((var0 != 0) + (var1 != 0)
10465 + (con0 != 0) + (con1 != 0)
10466 + (lit0 != 0) + (lit1 != 0)
10467 + (minus_lit0 != 0) + (minus_lit1 != 0))))
10469 bool any_overflows = false;
10470 if (lit0) any_overflows |= TREE_OVERFLOW (lit0);
10471 if (lit1) any_overflows |= TREE_OVERFLOW (lit1);
10472 if (minus_lit0) any_overflows |= TREE_OVERFLOW (minus_lit0);
10473 if (minus_lit1) any_overflows |= TREE_OVERFLOW (minus_lit1);
10474 var0 = associate_trees (loc, var0, var1, code, atype);
10475 con0 = associate_trees (loc, con0, con1, code, atype);
10476 lit0 = associate_trees (loc, lit0, lit1, code, atype);
10477 minus_lit0 = associate_trees (loc, minus_lit0, minus_lit1,
10480 /* Preserve the MINUS_EXPR if the negative part of the literal is
10481 greater than the positive part. Otherwise, the multiplicative
10482 folding code (i.e extract_muldiv) may be fooled in case
10483 unsigned constants are subtracted, like in the following
10484 example: ((X*2 + 4) - 8U)/2. */
10485 if (minus_lit0 && lit0)
10487 if (TREE_CODE (lit0) == INTEGER_CST
10488 && TREE_CODE (minus_lit0) == INTEGER_CST
10489 && tree_int_cst_lt (lit0, minus_lit0))
10491 minus_lit0 = associate_trees (loc, minus_lit0, lit0,
10492 MINUS_EXPR, atype);
10497 lit0 = associate_trees (loc, lit0, minus_lit0,
10498 MINUS_EXPR, atype);
10503 /* Don't introduce overflows through reassociation. */
10505 && ((lit0 && TREE_OVERFLOW (lit0))
10506 || (minus_lit0 && TREE_OVERFLOW (minus_lit0))))
10513 fold_convert_loc (loc, type,
10514 associate_trees (loc, var0, minus_lit0,
10515 MINUS_EXPR, atype));
10518 con0 = associate_trees (loc, con0, minus_lit0,
10519 MINUS_EXPR, atype);
10521 fold_convert_loc (loc, type,
10522 associate_trees (loc, var0, con0,
10523 PLUS_EXPR, atype));
10527 con0 = associate_trees (loc, con0, lit0, code, atype);
10529 fold_convert_loc (loc, type, associate_trees (loc, var0, con0,
10537 /* Pointer simplifications for subtraction, simple reassociations. */
10538 if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
10540 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10541 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
10542 && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10544 tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10545 tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10546 tree arg10 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10547 tree arg11 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10548 return fold_build2_loc (loc, PLUS_EXPR, type,
10549 fold_build2_loc (loc, MINUS_EXPR, type,
10551 fold_build2_loc (loc, MINUS_EXPR, type,
10554 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10555 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10557 tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10558 tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10559 tree tmp = fold_binary_loc (loc, MINUS_EXPR, type, arg00,
10560 fold_convert_loc (loc, type, arg1));
10562 return fold_build2_loc (loc, PLUS_EXPR, type, tmp, arg01);
10564 /* PTR0 - (PTR1 p+ A) -> (PTR0 - PTR1) - A, assuming PTR0 - PTR1
10566 else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10568 tree arg10 = fold_convert_loc (loc, type,
10569 TREE_OPERAND (arg1, 0));
10570 tree arg11 = fold_convert_loc (loc, type,
10571 TREE_OPERAND (arg1, 1));
10572 tree tmp = fold_binary_loc (loc, MINUS_EXPR, type,
10573 fold_convert_loc (loc, type, arg0),
10576 return fold_build2_loc (loc, MINUS_EXPR, type, tmp, arg11);
10579 /* A - (-B) -> A + B */
10580 if (TREE_CODE (arg1) == NEGATE_EXPR)
10581 return fold_build2_loc (loc, PLUS_EXPR, type, op0,
10582 fold_convert_loc (loc, type,
10583 TREE_OPERAND (arg1, 0)));
10584 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10585 if (TREE_CODE (arg0) == NEGATE_EXPR
10586 && negate_expr_p (arg1)
10587 && reorder_operands_p (arg0, arg1))
10588 return fold_build2_loc (loc, MINUS_EXPR, type,
10589 fold_convert_loc (loc, type,
10590 negate_expr (arg1)),
10591 fold_convert_loc (loc, type,
10592 TREE_OPERAND (arg0, 0)));
10593 /* Convert -A - 1 to ~A. */
10594 if (TREE_CODE (arg0) == NEGATE_EXPR
10595 && integer_each_onep (arg1)
10596 && !TYPE_OVERFLOW_TRAPS (type))
10597 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
10598 fold_convert_loc (loc, type,
10599 TREE_OPERAND (arg0, 0)));
10601 /* Convert -1 - A to ~A. */
10602 if (TREE_CODE (type) != COMPLEX_TYPE
10603 && integer_all_onesp (arg0))
10604 return fold_build1_loc (loc, BIT_NOT_EXPR, type, op1);
10607 /* X - (X / Y) * Y is X % Y. */
10608 if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
10609 && TREE_CODE (arg1) == MULT_EXPR
10610 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10611 && operand_equal_p (arg0,
10612 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
10613 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
10614 TREE_OPERAND (arg1, 1), 0))
10616 fold_convert_loc (loc, type,
10617 fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (arg0),
10618 arg0, TREE_OPERAND (arg1, 1)));
10620 if (! FLOAT_TYPE_P (type))
10622 if (integer_zerop (arg0))
10623 return negate_expr (fold_convert_loc (loc, type, arg1));
10625 /* Fold A - (A & B) into ~B & A. */
10626 if (!TREE_SIDE_EFFECTS (arg0)
10627 && TREE_CODE (arg1) == BIT_AND_EXPR)
10629 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
10631 tree arg10 = fold_convert_loc (loc, type,
10632 TREE_OPERAND (arg1, 0));
10633 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10634 fold_build1_loc (loc, BIT_NOT_EXPR,
10636 fold_convert_loc (loc, type, arg0));
10638 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10640 tree arg11 = fold_convert_loc (loc,
10641 type, TREE_OPERAND (arg1, 1));
10642 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10643 fold_build1_loc (loc, BIT_NOT_EXPR,
10645 fold_convert_loc (loc, type, arg0));
10649 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10650 any power of 2 minus 1. */
10651 if (TREE_CODE (arg0) == BIT_AND_EXPR
10652 && TREE_CODE (arg1) == BIT_AND_EXPR
10653 && operand_equal_p (TREE_OPERAND (arg0, 0),
10654 TREE_OPERAND (arg1, 0), 0))
10656 tree mask0 = TREE_OPERAND (arg0, 1);
10657 tree mask1 = TREE_OPERAND (arg1, 1);
10658 tree tem = fold_build1_loc (loc, BIT_NOT_EXPR, type, mask0);
10660 if (operand_equal_p (tem, mask1, 0))
10662 tem = fold_build2_loc (loc, BIT_XOR_EXPR, type,
10663 TREE_OPERAND (arg0, 0), mask1);
10664 return fold_build2_loc (loc, MINUS_EXPR, type, tem, mask1);
10669 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10670 else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
10671 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10673 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10674 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10675 (-ARG1 + ARG0) reduces to -ARG1. */
10676 else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10677 return negate_expr (fold_convert_loc (loc, type, arg1));
10679 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10680 __complex__ ( x, -y ). This is not the same for SNaNs or if
10681 signed zeros are involved. */
10682 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10683 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10684 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10686 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10687 tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10688 tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10689 bool arg0rz = false, arg0iz = false;
10690 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10691 || (arg0i && (arg0iz = real_zerop (arg0i))))
10693 tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10694 tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10695 if (arg0rz && arg1i && real_zerop (arg1i))
10697 tree rp = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10699 : build1 (REALPART_EXPR, rtype, arg1));
10700 tree ip = arg0i ? arg0i
10701 : build1 (IMAGPART_EXPR, rtype, arg0);
10702 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10704 else if (arg0iz && arg1r && real_zerop (arg1r))
10706 tree rp = arg0r ? arg0r
10707 : build1 (REALPART_EXPR, rtype, arg0);
10708 tree ip = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10710 : build1 (IMAGPART_EXPR, rtype, arg1));
10711 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10716 /* A - B -> A + (-B) if B is easily negatable. */
10717 if (negate_expr_p (arg1)
10718 && ((FLOAT_TYPE_P (type)
10719 /* Avoid this transformation if B is a positive REAL_CST. */
10720 && (TREE_CODE (arg1) != REAL_CST
10721 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
10722 || INTEGRAL_TYPE_P (type)))
10723 return fold_build2_loc (loc, PLUS_EXPR, type,
10724 fold_convert_loc (loc, type, arg0),
10725 fold_convert_loc (loc, type,
10726 negate_expr (arg1)));
10728 /* Try folding difference of addresses. */
10730 HOST_WIDE_INT diff;
10732 if ((TREE_CODE (arg0) == ADDR_EXPR
10733 || TREE_CODE (arg1) == ADDR_EXPR)
10734 && ptr_difference_const (arg0, arg1, &diff))
10735 return build_int_cst_type (type, diff);
10738 /* Fold &a[i] - &a[j] to i-j. */
10739 if (TREE_CODE (arg0) == ADDR_EXPR
10740 && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
10741 && TREE_CODE (arg1) == ADDR_EXPR
10742 && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
10744 tree tem = fold_addr_of_array_ref_difference (loc, type,
10745 TREE_OPERAND (arg0, 0),
10746 TREE_OPERAND (arg1, 0));
10751 if (FLOAT_TYPE_P (type)
10752 && flag_unsafe_math_optimizations
10753 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10754 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10755 && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
10758 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
10759 one. Make sure the type is not saturating and has the signedness of
10760 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10761 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10762 if ((TREE_CODE (arg0) == MULT_EXPR
10763 || TREE_CODE (arg1) == MULT_EXPR)
10764 && !TYPE_SATURATING (type)
10765 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
10766 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
10767 && (!FLOAT_TYPE_P (type) || flag_associative_math))
10769 tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
10777 /* (-A) * (-B) -> A * B */
10778 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10779 return fold_build2_loc (loc, MULT_EXPR, type,
10780 fold_convert_loc (loc, type,
10781 TREE_OPERAND (arg0, 0)),
10782 fold_convert_loc (loc, type,
10783 negate_expr (arg1)));
10784 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10785 return fold_build2_loc (loc, MULT_EXPR, type,
10786 fold_convert_loc (loc, type,
10787 negate_expr (arg0)),
10788 fold_convert_loc (loc, type,
10789 TREE_OPERAND (arg1, 0)));
10791 if (! FLOAT_TYPE_P (type))
10793 /* Transform x * -1 into -x. Make sure to do the negation
10794 on the original operand with conversions not stripped
10795 because we can only strip non-sign-changing conversions. */
10796 if (integer_minus_onep (arg1))
10797 return fold_convert_loc (loc, type, negate_expr (op0));
10798 /* Transform x * -C into -x * C if x is easily negatable. */
10799 if (TREE_CODE (arg1) == INTEGER_CST
10800 && tree_int_cst_sgn (arg1) == -1
10801 && negate_expr_p (arg0)
10802 && (tem = negate_expr (arg1)) != arg1
10803 && !TREE_OVERFLOW (tem))
10804 return fold_build2_loc (loc, MULT_EXPR, type,
10805 fold_convert_loc (loc, type,
10806 negate_expr (arg0)),
10809 /* (a * (1 << b)) is (a << b) */
10810 if (TREE_CODE (arg1) == LSHIFT_EXPR
10811 && integer_onep (TREE_OPERAND (arg1, 0)))
10812 return fold_build2_loc (loc, LSHIFT_EXPR, type, op0,
10813 TREE_OPERAND (arg1, 1));
10814 if (TREE_CODE (arg0) == LSHIFT_EXPR
10815 && integer_onep (TREE_OPERAND (arg0, 0)))
10816 return fold_build2_loc (loc, LSHIFT_EXPR, type, op1,
10817 TREE_OPERAND (arg0, 1));
10819 /* (A + A) * C -> A * 2 * C */
10820 if (TREE_CODE (arg0) == PLUS_EXPR
10821 && TREE_CODE (arg1) == INTEGER_CST
10822 && operand_equal_p (TREE_OPERAND (arg0, 0),
10823 TREE_OPERAND (arg0, 1), 0))
10824 return fold_build2_loc (loc, MULT_EXPR, type,
10825 omit_one_operand_loc (loc, type,
10826 TREE_OPERAND (arg0, 0),
10827 TREE_OPERAND (arg0, 1)),
10828 fold_build2_loc (loc, MULT_EXPR, type,
10829 build_int_cst (type, 2) , arg1));
10831 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
10832 sign-changing only. */
10833 if (TREE_CODE (arg1) == INTEGER_CST
10834 && TREE_CODE (arg0) == EXACT_DIV_EXPR
10835 && operand_equal_p (arg1, TREE_OPERAND (arg0, 1), 0))
10836 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10838 strict_overflow_p = false;
10839 if (TREE_CODE (arg1) == INTEGER_CST
10840 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10841 &strict_overflow_p)))
10843 if (strict_overflow_p)
10844 fold_overflow_warning (("assuming signed overflow does not "
10845 "occur when simplifying "
10847 WARN_STRICT_OVERFLOW_MISC);
10848 return fold_convert_loc (loc, type, tem);
10851 /* Optimize z * conj(z) for integer complex numbers. */
10852 if (TREE_CODE (arg0) == CONJ_EXPR
10853 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10854 return fold_mult_zconjz (loc, type, arg1);
10855 if (TREE_CODE (arg1) == CONJ_EXPR
10856 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10857 return fold_mult_zconjz (loc, type, arg0);
10861 /* Maybe fold x * 0 to 0. The expressions aren't the same
10862 when x is NaN, since x * 0 is also NaN. Nor are they the
10863 same in modes with signed zeros, since multiplying a
10864 negative value by 0 gives -0, not +0. */
10865 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10866 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10867 && real_zerop (arg1))
10868 return omit_one_operand_loc (loc, type, arg1, arg0);
10869 /* In IEEE floating point, x*1 is not equivalent to x for snans.
10870 Likewise for complex arithmetic with signed zeros. */
10871 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10872 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10873 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10874 && real_onep (arg1))
10875 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10877 /* Transform x * -1.0 into -x. */
10878 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10879 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10880 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10881 && real_minus_onep (arg1))
10882 return fold_convert_loc (loc, type, negate_expr (arg0));
10884 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
10885 the result for floating point types due to rounding so it is applied
10886 only if -fassociative-math was specify. */
10887 if (flag_associative_math
10888 && TREE_CODE (arg0) == RDIV_EXPR
10889 && TREE_CODE (arg1) == REAL_CST
10890 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
10892 tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
10895 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
10896 TREE_OPERAND (arg0, 1));
10899 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
10900 if (operand_equal_p (arg0, arg1, 0))
10902 tree tem = fold_strip_sign_ops (arg0);
10903 if (tem != NULL_TREE)
10905 tem = fold_convert_loc (loc, type, tem);
10906 return fold_build2_loc (loc, MULT_EXPR, type, tem, tem);
10910 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10911 This is not the same for NaNs or if signed zeros are
10913 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10914 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10915 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
10916 && TREE_CODE (arg1) == COMPLEX_CST
10917 && real_zerop (TREE_REALPART (arg1)))
10919 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10920 if (real_onep (TREE_IMAGPART (arg1)))
10922 fold_build2_loc (loc, COMPLEX_EXPR, type,
10923 negate_expr (fold_build1_loc (loc, IMAGPART_EXPR,
10925 fold_build1_loc (loc, REALPART_EXPR, rtype, arg0));
10926 else if (real_minus_onep (TREE_IMAGPART (arg1)))
10928 fold_build2_loc (loc, COMPLEX_EXPR, type,
10929 fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0),
10930 negate_expr (fold_build1_loc (loc, REALPART_EXPR,
10934 /* Optimize z * conj(z) for floating point complex numbers.
10935 Guarded by flag_unsafe_math_optimizations as non-finite
10936 imaginary components don't produce scalar results. */
10937 if (flag_unsafe_math_optimizations
10938 && TREE_CODE (arg0) == CONJ_EXPR
10939 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10940 return fold_mult_zconjz (loc, type, arg1);
10941 if (flag_unsafe_math_optimizations
10942 && TREE_CODE (arg1) == CONJ_EXPR
10943 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10944 return fold_mult_zconjz (loc, type, arg0);
10946 if (flag_unsafe_math_optimizations)
10948 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
10949 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
10951 /* Optimizations of root(...)*root(...). */
10952 if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
10955 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10956 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10958 /* Optimize sqrt(x)*sqrt(x) as x. */
10959 if (BUILTIN_SQRT_P (fcode0)
10960 && operand_equal_p (arg00, arg10, 0)
10961 && ! HONOR_SNANS (TYPE_MODE (type)))
10964 /* Optimize root(x)*root(y) as root(x*y). */
10965 rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10966 arg = fold_build2_loc (loc, MULT_EXPR, type, arg00, arg10);
10967 return build_call_expr_loc (loc, rootfn, 1, arg);
10970 /* Optimize expN(x)*expN(y) as expN(x+y). */
10971 if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
10973 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10974 tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
10975 CALL_EXPR_ARG (arg0, 0),
10976 CALL_EXPR_ARG (arg1, 0));
10977 return build_call_expr_loc (loc, expfn, 1, arg);
10980 /* Optimizations of pow(...)*pow(...). */
10981 if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
10982 || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
10983 || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
10985 tree arg00 = CALL_EXPR_ARG (arg0, 0);
10986 tree arg01 = CALL_EXPR_ARG (arg0, 1);
10987 tree arg10 = CALL_EXPR_ARG (arg1, 0);
10988 tree arg11 = CALL_EXPR_ARG (arg1, 1);
10990 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
10991 if (operand_equal_p (arg01, arg11, 0))
10993 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10994 tree arg = fold_build2_loc (loc, MULT_EXPR, type,
10996 return build_call_expr_loc (loc, powfn, 2, arg, arg01);
10999 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
11000 if (operand_equal_p (arg00, arg10, 0))
11002 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11003 tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
11005 return build_call_expr_loc (loc, powfn, 2, arg00, arg);
11009 /* Optimize tan(x)*cos(x) as sin(x). */
11010 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
11011 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
11012 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
11013 || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
11014 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
11015 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
11016 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11017 CALL_EXPR_ARG (arg1, 0), 0))
11019 tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
11021 if (sinfn != NULL_TREE)
11022 return build_call_expr_loc (loc, sinfn, 1,
11023 CALL_EXPR_ARG (arg0, 0));
11026 /* Optimize x*pow(x,c) as pow(x,c+1). */
11027 if (fcode1 == BUILT_IN_POW
11028 || fcode1 == BUILT_IN_POWF
11029 || fcode1 == BUILT_IN_POWL)
11031 tree arg10 = CALL_EXPR_ARG (arg1, 0);
11032 tree arg11 = CALL_EXPR_ARG (arg1, 1);
11033 if (TREE_CODE (arg11) == REAL_CST
11034 && !TREE_OVERFLOW (arg11)
11035 && operand_equal_p (arg0, arg10, 0))
11037 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11041 c = TREE_REAL_CST (arg11);
11042 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
11043 arg = build_real (type, c);
11044 return build_call_expr_loc (loc, powfn, 2, arg0, arg);
11048 /* Optimize pow(x,c)*x as pow(x,c+1). */
11049 if (fcode0 == BUILT_IN_POW
11050 || fcode0 == BUILT_IN_POWF
11051 || fcode0 == BUILT_IN_POWL)
11053 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11054 tree arg01 = CALL_EXPR_ARG (arg0, 1);
11055 if (TREE_CODE (arg01) == REAL_CST
11056 && !TREE_OVERFLOW (arg01)
11057 && operand_equal_p (arg1, arg00, 0))
11059 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11063 c = TREE_REAL_CST (arg01);
11064 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
11065 arg = build_real (type, c);
11066 return build_call_expr_loc (loc, powfn, 2, arg1, arg);
11070 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
11071 if (!in_gimple_form
11073 && operand_equal_p (arg0, arg1, 0))
11075 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
11079 tree arg = build_real (type, dconst2);
11080 return build_call_expr_loc (loc, powfn, 2, arg0, arg);
11089 /* ~X | X is -1. */
11090 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11091 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11093 t1 = build_zero_cst (type);
11094 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11095 return omit_one_operand_loc (loc, type, t1, arg1);
11098 /* X | ~X is -1. */
11099 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11100 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11102 t1 = build_zero_cst (type);
11103 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11104 return omit_one_operand_loc (loc, type, t1, arg0);
11107 /* Canonicalize (X & C1) | C2. */
11108 if (TREE_CODE (arg0) == BIT_AND_EXPR
11109 && TREE_CODE (arg1) == INTEGER_CST
11110 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11112 int width = TYPE_PRECISION (type), w;
11113 wide_int c1 = TREE_OPERAND (arg0, 1);
11114 wide_int c2 = arg1;
11116 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11117 if ((c1 & c2) == c1)
11118 return omit_one_operand_loc (loc, type, arg1,
11119 TREE_OPERAND (arg0, 0));
11121 wide_int msk = wi::mask (width, false,
11122 TYPE_PRECISION (TREE_TYPE (arg1)));
11124 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11125 if (msk.and_not (c1 | c2) == 0)
11126 return fold_build2_loc (loc, BIT_IOR_EXPR, type,
11127 TREE_OPERAND (arg0, 0), arg1);
11129 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11130 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11131 mode which allows further optimizations. */
11134 wide_int c3 = c1.and_not (c2);
11135 for (w = BITS_PER_UNIT; w <= width; w <<= 1)
11137 wide_int mask = wi::mask (w, false,
11138 TYPE_PRECISION (type));
11139 if (((c1 | c2) & mask) == mask && c1.and_not (mask) == 0)
11147 return fold_build2_loc (loc, BIT_IOR_EXPR, type,
11148 fold_build2_loc (loc, BIT_AND_EXPR, type,
11149 TREE_OPERAND (arg0, 0),
11150 wide_int_to_tree (type,
11155 /* (X & Y) | Y is (X, Y). */
11156 if (TREE_CODE (arg0) == BIT_AND_EXPR
11157 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11158 return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
11159 /* (X & Y) | X is (Y, X). */
11160 if (TREE_CODE (arg0) == BIT_AND_EXPR
11161 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11162 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11163 return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
11164 /* X | (X & Y) is (Y, X). */
11165 if (TREE_CODE (arg1) == BIT_AND_EXPR
11166 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
11167 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
11168 return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
11169 /* X | (Y & X) is (Y, X). */
11170 if (TREE_CODE (arg1) == BIT_AND_EXPR
11171 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11172 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11173 return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
11175 /* (X & ~Y) | (~X & Y) is X ^ Y */
11176 if (TREE_CODE (arg0) == BIT_AND_EXPR
11177 && TREE_CODE (arg1) == BIT_AND_EXPR)
11179 tree a0, a1, l0, l1, n0, n1;
11181 a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11182 a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11184 l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11185 l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11187 n0 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l0);
11188 n1 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l1);
11190 if ((operand_equal_p (n0, a0, 0)
11191 && operand_equal_p (n1, a1, 0))
11192 || (operand_equal_p (n0, a1, 0)
11193 && operand_equal_p (n1, a0, 0)))
11194 return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
11197 t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
11198 if (t1 != NULL_TREE)
11201 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11203 This results in more efficient code for machines without a NAND
11204 instruction. Combine will canonicalize to the first form
11205 which will allow use of NAND instructions provided by the
11206 backend if they exist. */
11207 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11208 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11211 fold_build1_loc (loc, BIT_NOT_EXPR, type,
11212 build2 (BIT_AND_EXPR, type,
11213 fold_convert_loc (loc, type,
11214 TREE_OPERAND (arg0, 0)),
11215 fold_convert_loc (loc, type,
11216 TREE_OPERAND (arg1, 0))));
11219 /* See if this can be simplified into a rotate first. If that
11220 is unsuccessful continue in the association code. */
11224 /* ~X ^ X is -1. */
11225 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11226 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11228 t1 = build_zero_cst (type);
11229 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11230 return omit_one_operand_loc (loc, type, t1, arg1);
11233 /* X ^ ~X is -1. */
11234 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11235 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11237 t1 = build_zero_cst (type);
11238 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11239 return omit_one_operand_loc (loc, type, t1, arg0);
11242 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11243 with a constant, and the two constants have no bits in common,
11244 we should treat this as a BIT_IOR_EXPR since this may produce more
11245 simplifications. */
11246 if (TREE_CODE (arg0) == BIT_AND_EXPR
11247 && TREE_CODE (arg1) == BIT_AND_EXPR
11248 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11249 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
11250 && wi::bit_and (TREE_OPERAND (arg0, 1),
11251 TREE_OPERAND (arg1, 1)) == 0)
11253 code = BIT_IOR_EXPR;
11257 /* (X | Y) ^ X -> Y & ~ X*/
11258 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11259 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11261 tree t2 = TREE_OPERAND (arg0, 1);
11262 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
11264 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11265 fold_convert_loc (loc, type, t2),
11266 fold_convert_loc (loc, type, t1));
11270 /* (Y | X) ^ X -> Y & ~ X*/
11271 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11272 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11274 tree t2 = TREE_OPERAND (arg0, 0);
11275 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
11277 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11278 fold_convert_loc (loc, type, t2),
11279 fold_convert_loc (loc, type, t1));
11283 /* X ^ (X | Y) -> Y & ~ X*/
11284 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11285 && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
11287 tree t2 = TREE_OPERAND (arg1, 1);
11288 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
11290 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11291 fold_convert_loc (loc, type, t2),
11292 fold_convert_loc (loc, type, t1));
11296 /* X ^ (Y | X) -> Y & ~ X*/
11297 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11298 && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
11300 tree t2 = TREE_OPERAND (arg1, 0);
11301 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
11303 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11304 fold_convert_loc (loc, type, t2),
11305 fold_convert_loc (loc, type, t1));
11309 /* Convert ~X ^ ~Y to X ^ Y. */
11310 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11311 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11312 return fold_build2_loc (loc, code, type,
11313 fold_convert_loc (loc, type,
11314 TREE_OPERAND (arg0, 0)),
11315 fold_convert_loc (loc, type,
11316 TREE_OPERAND (arg1, 0)));
11318 /* Convert ~X ^ C to X ^ ~C. */
11319 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11320 && TREE_CODE (arg1) == INTEGER_CST)
11321 return fold_build2_loc (loc, code, type,
11322 fold_convert_loc (loc, type,
11323 TREE_OPERAND (arg0, 0)),
11324 fold_build1_loc (loc, BIT_NOT_EXPR, type, arg1));
11326 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11327 if (TREE_CODE (arg0) == BIT_AND_EXPR
11328 && INTEGRAL_TYPE_P (type)
11329 && integer_onep (TREE_OPERAND (arg0, 1))
11330 && integer_onep (arg1))
11331 return fold_build2_loc (loc, EQ_EXPR, type, arg0,
11332 build_zero_cst (TREE_TYPE (arg0)));
11334 /* Fold (X & Y) ^ Y as ~X & Y. */
11335 if (TREE_CODE (arg0) == BIT_AND_EXPR
11336 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11338 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11339 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11340 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11341 fold_convert_loc (loc, type, arg1));
11343 /* Fold (X & Y) ^ X as ~Y & X. */
11344 if (TREE_CODE (arg0) == BIT_AND_EXPR
11345 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11346 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11348 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11349 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11350 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11351 fold_convert_loc (loc, type, arg1));
11353 /* Fold X ^ (X & Y) as X & ~Y. */
11354 if (TREE_CODE (arg1) == BIT_AND_EXPR
11355 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11357 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11358 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11359 fold_convert_loc (loc, type, arg0),
11360 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
11362 /* Fold X ^ (Y & X) as ~Y & X. */
11363 if (TREE_CODE (arg1) == BIT_AND_EXPR
11364 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11365 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11367 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11368 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11369 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11370 fold_convert_loc (loc, type, arg0));
11373 /* See if this can be simplified into a rotate first. If that
11374 is unsuccessful continue in the association code. */
11378 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
11379 if ((TREE_CODE (arg0) == BIT_NOT_EXPR
11380 || TREE_CODE (arg0) == TRUTH_NOT_EXPR
11381 || (TREE_CODE (arg0) == EQ_EXPR
11382 && integer_zerop (TREE_OPERAND (arg0, 1))))
11383 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11384 return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
11386 /* X & ~X , X & (X == 0), and X & !X are always zero. */
11387 if ((TREE_CODE (arg1) == BIT_NOT_EXPR
11388 || TREE_CODE (arg1) == TRUTH_NOT_EXPR
11389 || (TREE_CODE (arg1) == EQ_EXPR
11390 && integer_zerop (TREE_OPERAND (arg1, 1))))
11391 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11392 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11394 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11395 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11396 && TREE_CODE (arg1) == INTEGER_CST
11397 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11399 tree tmp1 = fold_convert_loc (loc, type, arg1);
11400 tree tmp2 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11401 tree tmp3 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11402 tmp2 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp2, tmp1);
11403 tmp3 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp3, tmp1);
11405 fold_convert_loc (loc, type,
11406 fold_build2_loc (loc, BIT_IOR_EXPR,
11407 type, tmp2, tmp3));
11410 /* (X | Y) & Y is (X, Y). */
11411 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11412 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11413 return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
11414 /* (X | Y) & X is (Y, X). */
11415 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11416 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11417 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11418 return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
11419 /* X & (X | Y) is (Y, X). */
11420 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11421 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
11422 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
11423 return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
11424 /* X & (Y | X) is (Y, X). */
11425 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11426 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11427 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11428 return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
11430 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11431 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11432 && INTEGRAL_TYPE_P (type)
11433 && integer_onep (TREE_OPERAND (arg0, 1))
11434 && integer_onep (arg1))
11437 tem = TREE_OPERAND (arg0, 0);
11438 tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
11439 tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
11441 return fold_build2_loc (loc, EQ_EXPR, type, tem2,
11442 build_zero_cst (TREE_TYPE (tem)));
11444 /* Fold ~X & 1 as (X & 1) == 0. */
11445 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11446 && INTEGRAL_TYPE_P (type)
11447 && integer_onep (arg1))
11450 tem = TREE_OPERAND (arg0, 0);
11451 tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
11452 tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
11454 return fold_build2_loc (loc, EQ_EXPR, type, tem2,
11455 build_zero_cst (TREE_TYPE (tem)));
11457 /* Fold !X & 1 as X == 0. */
11458 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
11459 && integer_onep (arg1))
11461 tem = TREE_OPERAND (arg0, 0);
11462 return fold_build2_loc (loc, EQ_EXPR, type, tem,
11463 build_zero_cst (TREE_TYPE (tem)));
11466 /* Fold (X ^ Y) & Y as ~X & Y. */
11467 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11468 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11470 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11471 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11472 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11473 fold_convert_loc (loc, type, arg1));
11475 /* Fold (X ^ Y) & X as ~Y & X. */
11476 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11477 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11478 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11480 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11481 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11482 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11483 fold_convert_loc (loc, type, arg1));
11485 /* Fold X & (X ^ Y) as X & ~Y. */
11486 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11487 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11489 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11490 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11491 fold_convert_loc (loc, type, arg0),
11492 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
11494 /* Fold X & (Y ^ X) as ~Y & X. */
11495 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11496 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11497 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11499 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11500 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11501 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11502 fold_convert_loc (loc, type, arg0));
11505 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11506 multiple of 1 << CST. */
11507 if (TREE_CODE (arg1) == INTEGER_CST)
11509 wide_int cst1 = arg1;
11510 wide_int ncst1 = -cst1;
11511 if ((cst1 & ncst1) == ncst1
11512 && multiple_of_p (type, arg0,
11513 wide_int_to_tree (TREE_TYPE (arg1), ncst1)))
11514 return fold_convert_loc (loc, type, arg0);
11517 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
11519 if (TREE_CODE (arg1) == INTEGER_CST
11520 && TREE_CODE (arg0) == MULT_EXPR
11521 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11523 wide_int warg1 = arg1;
11524 wide_int masked = mask_with_tz (type, warg1, TREE_OPERAND (arg0, 1));
11527 return omit_two_operands_loc (loc, type, build_zero_cst (type),
11529 else if (masked != warg1)
11531 /* Avoid the transform if arg1 is a mask of some
11532 mode which allows further optimizations. */
11533 int pop = wi::popcount (warg1);
11534 if (!(pop >= BITS_PER_UNIT
11535 && exact_log2 (pop) != -1
11536 && wi::mask (pop, false, warg1.get_precision ()) == warg1))
11537 return fold_build2_loc (loc, code, type, op0,
11538 wide_int_to_tree (type, masked));
11542 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11543 ((A & N) + B) & M -> (A + B) & M
11544 Similarly if (N & M) == 0,
11545 ((A | N) + B) & M -> (A + B) & M
11546 and for - instead of + (or unary - instead of +)
11547 and/or ^ instead of |.
11548 If B is constant and (B & M) == 0, fold into A & M. */
11549 if (TREE_CODE (arg1) == INTEGER_CST)
11551 wide_int cst1 = arg1;
11552 if ((~cst1 != 0) && (cst1 & (cst1 + 1)) == 0
11553 && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
11554 && (TREE_CODE (arg0) == PLUS_EXPR
11555 || TREE_CODE (arg0) == MINUS_EXPR
11556 || TREE_CODE (arg0) == NEGATE_EXPR)
11557 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
11558 || TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE))
11564 /* Now we know that arg0 is (C + D) or (C - D) or
11565 -C and arg1 (M) is == (1LL << cst) - 1.
11566 Store C into PMOP[0] and D into PMOP[1]. */
11567 pmop[0] = TREE_OPERAND (arg0, 0);
11569 if (TREE_CODE (arg0) != NEGATE_EXPR)
11571 pmop[1] = TREE_OPERAND (arg0, 1);
11575 if ((wi::max_value (TREE_TYPE (arg0)) & cst1) != cst1)
11578 for (; which >= 0; which--)
11579 switch (TREE_CODE (pmop[which]))
11584 if (TREE_CODE (TREE_OPERAND (pmop[which], 1))
11587 cst0 = TREE_OPERAND (pmop[which], 1);
11589 if (TREE_CODE (pmop[which]) == BIT_AND_EXPR)
11594 else if (cst0 != 0)
11596 /* If C or D is of the form (A & N) where
11597 (N & M) == M, or of the form (A | N) or
11598 (A ^ N) where (N & M) == 0, replace it with A. */
11599 pmop[which] = TREE_OPERAND (pmop[which], 0);
11602 /* If C or D is a N where (N & M) == 0, it can be
11603 omitted (assumed 0). */
11604 if ((TREE_CODE (arg0) == PLUS_EXPR
11605 || (TREE_CODE (arg0) == MINUS_EXPR && which == 0))
11606 && (cst1 & pmop[which]) == 0)
11607 pmop[which] = NULL;
11613 /* Only build anything new if we optimized one or both arguments
11615 if (pmop[0] != TREE_OPERAND (arg0, 0)
11616 || (TREE_CODE (arg0) != NEGATE_EXPR
11617 && pmop[1] != TREE_OPERAND (arg0, 1)))
11619 tree utype = TREE_TYPE (arg0);
11620 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
11622 /* Perform the operations in a type that has defined
11623 overflow behavior. */
11624 utype = unsigned_type_for (TREE_TYPE (arg0));
11625 if (pmop[0] != NULL)
11626 pmop[0] = fold_convert_loc (loc, utype, pmop[0]);
11627 if (pmop[1] != NULL)
11628 pmop[1] = fold_convert_loc (loc, utype, pmop[1]);
11631 if (TREE_CODE (arg0) == NEGATE_EXPR)
11632 tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[0]);
11633 else if (TREE_CODE (arg0) == PLUS_EXPR)
11635 if (pmop[0] != NULL && pmop[1] != NULL)
11636 tem = fold_build2_loc (loc, PLUS_EXPR, utype,
11638 else if (pmop[0] != NULL)
11640 else if (pmop[1] != NULL)
11643 return build_int_cst (type, 0);
11645 else if (pmop[0] == NULL)
11646 tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[1]);
11648 tem = fold_build2_loc (loc, MINUS_EXPR, utype,
11650 /* TEM is now the new binary +, - or unary - replacement. */
11651 tem = fold_build2_loc (loc, BIT_AND_EXPR, utype, tem,
11652 fold_convert_loc (loc, utype, arg1));
11653 return fold_convert_loc (loc, type, tem);
11658 t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
11659 if (t1 != NULL_TREE)
11661 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11662 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
11663 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
11665 prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
11667 wide_int mask = wide_int::from (arg1, prec, UNSIGNED);
11670 fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11673 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11675 This results in more efficient code for machines without a NOR
11676 instruction. Combine will canonicalize to the first form
11677 which will allow use of NOR instructions provided by the
11678 backend if they exist. */
11679 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11680 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11682 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
11683 build2 (BIT_IOR_EXPR, type,
11684 fold_convert_loc (loc, type,
11685 TREE_OPERAND (arg0, 0)),
11686 fold_convert_loc (loc, type,
11687 TREE_OPERAND (arg1, 0))));
11690 /* If arg0 is derived from the address of an object or function, we may
11691 be able to fold this expression using the object or function's
11693 if (POINTER_TYPE_P (TREE_TYPE (arg0)) && tree_fits_uhwi_p (arg1))
11695 unsigned HOST_WIDE_INT modulus, residue;
11696 unsigned HOST_WIDE_INT low = tree_to_uhwi (arg1);
11698 modulus = get_pointer_modulus_and_residue (arg0, &residue,
11699 integer_onep (arg1));
11701 /* This works because modulus is a power of 2. If this weren't the
11702 case, we'd have to replace it by its greatest power-of-2
11703 divisor: modulus & -modulus. */
11705 return build_int_cst (type, residue & low);
11708 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11709 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11710 if the new mask might be further optimized. */
11711 if ((TREE_CODE (arg0) == LSHIFT_EXPR
11712 || TREE_CODE (arg0) == RSHIFT_EXPR)
11713 && TYPE_PRECISION (TREE_TYPE (arg0)) <= HOST_BITS_PER_WIDE_INT
11714 && TREE_CODE (arg1) == INTEGER_CST
11715 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
11716 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) > 0
11717 && (tree_to_uhwi (TREE_OPERAND (arg0, 1))
11718 < TYPE_PRECISION (TREE_TYPE (arg0))))
11720 unsigned int shiftc = tree_to_uhwi (TREE_OPERAND (arg0, 1));
11721 unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (arg1);
11722 unsigned HOST_WIDE_INT newmask, zerobits = 0;
11723 tree shift_type = TREE_TYPE (arg0);
11725 if (TREE_CODE (arg0) == LSHIFT_EXPR)
11726 zerobits = ((((unsigned HOST_WIDE_INT) 1) << shiftc) - 1);
11727 else if (TREE_CODE (arg0) == RSHIFT_EXPR
11728 && TYPE_PRECISION (TREE_TYPE (arg0))
11729 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg0))))
11731 prec = TYPE_PRECISION (TREE_TYPE (arg0));
11732 tree arg00 = TREE_OPERAND (arg0, 0);
11733 /* See if more bits can be proven as zero because of
11735 if (TREE_CODE (arg00) == NOP_EXPR
11736 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
11738 tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
11739 if (TYPE_PRECISION (inner_type)
11740 == GET_MODE_PRECISION (TYPE_MODE (inner_type))
11741 && TYPE_PRECISION (inner_type) < prec)
11743 prec = TYPE_PRECISION (inner_type);
11744 /* See if we can shorten the right shift. */
11746 shift_type = inner_type;
11747 /* Otherwise X >> C1 is all zeros, so we'll optimize
11748 it into (X, 0) later on by making sure zerobits
11752 zerobits = ~(unsigned HOST_WIDE_INT) 0;
11755 zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
11756 zerobits <<= prec - shiftc;
11758 /* For arithmetic shift if sign bit could be set, zerobits
11759 can contain actually sign bits, so no transformation is
11760 possible, unless MASK masks them all away. In that
11761 case the shift needs to be converted into logical shift. */
11762 if (!TYPE_UNSIGNED (TREE_TYPE (arg0))
11763 && prec == TYPE_PRECISION (TREE_TYPE (arg0)))
11765 if ((mask & zerobits) == 0)
11766 shift_type = unsigned_type_for (TREE_TYPE (arg0));
11772 /* ((X << 16) & 0xff00) is (X, 0). */
11773 if ((mask & zerobits) == mask)
11774 return omit_one_operand_loc (loc, type,
11775 build_int_cst (type, 0), arg0);
11777 newmask = mask | zerobits;
11778 if (newmask != mask && (newmask & (newmask + 1)) == 0)
11780 /* Only do the transformation if NEWMASK is some integer
11782 for (prec = BITS_PER_UNIT;
11783 prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
11784 if (newmask == (((unsigned HOST_WIDE_INT) 1) << prec) - 1)
11786 if (prec < HOST_BITS_PER_WIDE_INT
11787 || newmask == ~(unsigned HOST_WIDE_INT) 0)
11791 if (shift_type != TREE_TYPE (arg0))
11793 tem = fold_build2_loc (loc, TREE_CODE (arg0), shift_type,
11794 fold_convert_loc (loc, shift_type,
11795 TREE_OPERAND (arg0, 0)),
11796 TREE_OPERAND (arg0, 1));
11797 tem = fold_convert_loc (loc, type, tem);
11801 newmaskt = build_int_cst_type (TREE_TYPE (op1), newmask);
11802 if (!tree_int_cst_equal (newmaskt, arg1))
11803 return fold_build2_loc (loc, BIT_AND_EXPR, type, tem, newmaskt);
11811 /* Don't touch a floating-point divide by zero unless the mode
11812 of the constant can represent infinity. */
11813 if (TREE_CODE (arg1) == REAL_CST
11814 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
11815 && real_zerop (arg1))
11818 /* Optimize A / A to 1.0 if we don't care about
11819 NaNs or Infinities. Skip the transformation
11820 for non-real operands. */
11821 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
11822 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11823 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
11824 && operand_equal_p (arg0, arg1, 0))
11826 tree r = build_real (TREE_TYPE (arg0), dconst1);
11828 return omit_two_operands_loc (loc, type, r, arg0, arg1);
11831 /* The complex version of the above A / A optimization. */
11832 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
11833 && operand_equal_p (arg0, arg1, 0))
11835 tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
11836 if (! HONOR_NANS (TYPE_MODE (elem_type))
11837 && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
11839 tree r = build_real (elem_type, dconst1);
11840 /* omit_two_operands will call fold_convert for us. */
11841 return omit_two_operands_loc (loc, type, r, arg0, arg1);
11845 /* (-A) / (-B) -> A / B */
11846 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
11847 return fold_build2_loc (loc, RDIV_EXPR, type,
11848 TREE_OPERAND (arg0, 0),
11849 negate_expr (arg1));
11850 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
11851 return fold_build2_loc (loc, RDIV_EXPR, type,
11852 negate_expr (arg0),
11853 TREE_OPERAND (arg1, 0));
11855 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
11856 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11857 && real_onep (arg1))
11858 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11860 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
11861 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11862 && real_minus_onep (arg1))
11863 return non_lvalue_loc (loc, fold_convert_loc (loc, type,
11864 negate_expr (arg0)));
11866 /* If ARG1 is a constant, we can convert this to a multiply by the
11867 reciprocal. This does not have the same rounding properties,
11868 so only do this if -freciprocal-math. We can actually
11869 always safely do it if ARG1 is a power of two, but it's hard to
11870 tell if it is or not in a portable manner. */
11872 && (TREE_CODE (arg1) == REAL_CST
11873 || (TREE_CODE (arg1) == COMPLEX_CST
11874 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg1)))
11875 || (TREE_CODE (arg1) == VECTOR_CST
11876 && VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg1)))))
11878 if (flag_reciprocal_math
11879 && 0 != (tem = const_binop (code, build_one_cst (type), arg1)))
11880 return fold_build2_loc (loc, MULT_EXPR, type, arg0, tem);
11881 /* Find the reciprocal if optimizing and the result is exact.
11882 TODO: Complex reciprocal not implemented. */
11883 if (TREE_CODE (arg1) != COMPLEX_CST)
11885 tree inverse = exact_inverse (TREE_TYPE (arg0), arg1);
11888 return fold_build2_loc (loc, MULT_EXPR, type, arg0, inverse);
11891 /* Convert A/B/C to A/(B*C). */
11892 if (flag_reciprocal_math
11893 && TREE_CODE (arg0) == RDIV_EXPR)
11894 return fold_build2_loc (loc, RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
11895 fold_build2_loc (loc, MULT_EXPR, type,
11896 TREE_OPERAND (arg0, 1), arg1));
11898 /* Convert A/(B/C) to (A/B)*C. */
11899 if (flag_reciprocal_math
11900 && TREE_CODE (arg1) == RDIV_EXPR)
11901 return fold_build2_loc (loc, MULT_EXPR, type,
11902 fold_build2_loc (loc, RDIV_EXPR, type, arg0,
11903 TREE_OPERAND (arg1, 0)),
11904 TREE_OPERAND (arg1, 1));
11906 /* Convert C1/(X*C2) into (C1/C2)/X. */
11907 if (flag_reciprocal_math
11908 && TREE_CODE (arg1) == MULT_EXPR
11909 && TREE_CODE (arg0) == REAL_CST
11910 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
11912 tree tem = const_binop (RDIV_EXPR, arg0,
11913 TREE_OPERAND (arg1, 1));
11915 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
11916 TREE_OPERAND (arg1, 0));
11919 if (flag_unsafe_math_optimizations)
11921 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
11922 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
11924 /* Optimize sin(x)/cos(x) as tan(x). */
11925 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
11926 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
11927 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
11928 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11929 CALL_EXPR_ARG (arg1, 0), 0))
11931 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11933 if (tanfn != NULL_TREE)
11934 return build_call_expr_loc (loc, tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11937 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
11938 if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
11939 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
11940 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
11941 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11942 CALL_EXPR_ARG (arg1, 0), 0))
11944 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11946 if (tanfn != NULL_TREE)
11948 tree tmp = build_call_expr_loc (loc, tanfn, 1,
11949 CALL_EXPR_ARG (arg0, 0));
11950 return fold_build2_loc (loc, RDIV_EXPR, type,
11951 build_real (type, dconst1), tmp);
11955 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
11956 NaNs or Infinities. */
11957 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
11958 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
11959 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
11961 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11962 tree arg01 = CALL_EXPR_ARG (arg1, 0);
11964 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11965 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11966 && operand_equal_p (arg00, arg01, 0))
11968 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11970 if (cosfn != NULL_TREE)
11971 return build_call_expr_loc (loc, cosfn, 1, arg00);
11975 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
11976 NaNs or Infinities. */
11977 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
11978 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
11979 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
11981 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11982 tree arg01 = CALL_EXPR_ARG (arg1, 0);
11984 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11985 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11986 && operand_equal_p (arg00, arg01, 0))
11988 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11990 if (cosfn != NULL_TREE)
11992 tree tmp = build_call_expr_loc (loc, cosfn, 1, arg00);
11993 return fold_build2_loc (loc, RDIV_EXPR, type,
11994 build_real (type, dconst1),
12000 /* Optimize pow(x,c)/x as pow(x,c-1). */
12001 if (fcode0 == BUILT_IN_POW
12002 || fcode0 == BUILT_IN_POWF
12003 || fcode0 == BUILT_IN_POWL)
12005 tree arg00 = CALL_EXPR_ARG (arg0, 0);
12006 tree arg01 = CALL_EXPR_ARG (arg0, 1);
12007 if (TREE_CODE (arg01) == REAL_CST
12008 && !TREE_OVERFLOW (arg01)
12009 && operand_equal_p (arg1, arg00, 0))
12011 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
12015 c = TREE_REAL_CST (arg01);
12016 real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
12017 arg = build_real (type, c);
12018 return build_call_expr_loc (loc, powfn, 2, arg1, arg);
12022 /* Optimize a/root(b/c) into a*root(c/b). */
12023 if (BUILTIN_ROOT_P (fcode1))
12025 tree rootarg = CALL_EXPR_ARG (arg1, 0);
12027 if (TREE_CODE (rootarg) == RDIV_EXPR)
12029 tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
12030 tree b = TREE_OPERAND (rootarg, 0);
12031 tree c = TREE_OPERAND (rootarg, 1);
12033 tree tmp = fold_build2_loc (loc, RDIV_EXPR, type, c, b);
12035 tmp = build_call_expr_loc (loc, rootfn, 1, tmp);
12036 return fold_build2_loc (loc, MULT_EXPR, type, arg0, tmp);
12040 /* Optimize x/expN(y) into x*expN(-y). */
12041 if (BUILTIN_EXPONENT_P (fcode1))
12043 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
12044 tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
12045 arg1 = build_call_expr_loc (loc,
12047 fold_convert_loc (loc, type, arg));
12048 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
12051 /* Optimize x/pow(y,z) into x*pow(y,-z). */
12052 if (fcode1 == BUILT_IN_POW
12053 || fcode1 == BUILT_IN_POWF
12054 || fcode1 == BUILT_IN_POWL)
12056 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
12057 tree arg10 = CALL_EXPR_ARG (arg1, 0);
12058 tree arg11 = CALL_EXPR_ARG (arg1, 1);
12059 tree neg11 = fold_convert_loc (loc, type,
12060 negate_expr (arg11));
12061 arg1 = build_call_expr_loc (loc, powfn, 2, arg10, neg11);
12062 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
12067 case TRUNC_DIV_EXPR:
12068 /* Optimize (X & (-A)) / A where A is a power of 2,
12070 if (TREE_CODE (arg0) == BIT_AND_EXPR
12071 && !TYPE_UNSIGNED (type) && TREE_CODE (arg1) == INTEGER_CST
12072 && integer_pow2p (arg1) && tree_int_cst_sgn (arg1) > 0)
12074 tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (arg1),
12075 arg1, TREE_OPERAND (arg0, 1));
12076 if (sum && integer_zerop (sum)) {
12077 tree pow2 = build_int_cst (integer_type_node,
12078 wi::exact_log2 (arg1));
12079 return fold_build2_loc (loc, RSHIFT_EXPR, type,
12080 TREE_OPERAND (arg0, 0), pow2);
12086 case FLOOR_DIV_EXPR:
12087 /* Simplify A / (B << N) where A and B are positive and B is
12088 a power of 2, to A >> (N + log2(B)). */
12089 strict_overflow_p = false;
12090 if (TREE_CODE (arg1) == LSHIFT_EXPR
12091 && (TYPE_UNSIGNED (type)
12092 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
12094 tree sval = TREE_OPERAND (arg1, 0);
12095 if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
12097 tree sh_cnt = TREE_OPERAND (arg1, 1);
12098 tree pow2 = build_int_cst (TREE_TYPE (sh_cnt),
12099 wi::exact_log2 (sval));
12101 if (strict_overflow_p)
12102 fold_overflow_warning (("assuming signed overflow does not "
12103 "occur when simplifying A / (B << N)"),
12104 WARN_STRICT_OVERFLOW_MISC);
12106 sh_cnt = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (sh_cnt),
12108 return fold_build2_loc (loc, RSHIFT_EXPR, type,
12109 fold_convert_loc (loc, type, arg0), sh_cnt);
12113 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
12114 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
12115 if (INTEGRAL_TYPE_P (type)
12116 && TYPE_UNSIGNED (type)
12117 && code == FLOOR_DIV_EXPR)
12118 return fold_build2_loc (loc, TRUNC_DIV_EXPR, type, op0, op1);
12122 case ROUND_DIV_EXPR:
12123 case CEIL_DIV_EXPR:
12124 case EXACT_DIV_EXPR:
12125 if (integer_zerop (arg1))
12127 /* X / -1 is -X. */
12128 if (!TYPE_UNSIGNED (type)
12129 && TREE_CODE (arg1) == INTEGER_CST
12130 && wi::eq_p (arg1, -1))
12131 return fold_convert_loc (loc, type, negate_expr (arg0));
12133 /* Convert -A / -B to A / B when the type is signed and overflow is
12135 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12136 && TREE_CODE (arg0) == NEGATE_EXPR
12137 && negate_expr_p (arg1))
12139 if (INTEGRAL_TYPE_P (type))
12140 fold_overflow_warning (("assuming signed overflow does not occur "
12141 "when distributing negation across "
12143 WARN_STRICT_OVERFLOW_MISC);
12144 return fold_build2_loc (loc, code, type,
12145 fold_convert_loc (loc, type,
12146 TREE_OPERAND (arg0, 0)),
12147 fold_convert_loc (loc, type,
12148 negate_expr (arg1)));
12150 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12151 && TREE_CODE (arg1) == NEGATE_EXPR
12152 && negate_expr_p (arg0))
12154 if (INTEGRAL_TYPE_P (type))
12155 fold_overflow_warning (("assuming signed overflow does not occur "
12156 "when distributing negation across "
12158 WARN_STRICT_OVERFLOW_MISC);
12159 return fold_build2_loc (loc, code, type,
12160 fold_convert_loc (loc, type,
12161 negate_expr (arg0)),
12162 fold_convert_loc (loc, type,
12163 TREE_OPERAND (arg1, 0)));
12166 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12167 operation, EXACT_DIV_EXPR.
12169 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12170 At one time others generated faster code, it's not clear if they do
12171 after the last round to changes to the DIV code in expmed.c. */
12172 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
12173 && multiple_of_p (type, arg0, arg1))
12174 return fold_build2_loc (loc, EXACT_DIV_EXPR, type, arg0, arg1);
12176 strict_overflow_p = false;
12177 if (TREE_CODE (arg1) == INTEGER_CST
12178 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
12179 &strict_overflow_p)))
12181 if (strict_overflow_p)
12182 fold_overflow_warning (("assuming signed overflow does not occur "
12183 "when simplifying division"),
12184 WARN_STRICT_OVERFLOW_MISC);
12185 return fold_convert_loc (loc, type, tem);
12190 case CEIL_MOD_EXPR:
12191 case FLOOR_MOD_EXPR:
12192 case ROUND_MOD_EXPR:
12193 case TRUNC_MOD_EXPR:
12194 /* X % -1 is zero. */
12195 if (!TYPE_UNSIGNED (type)
12196 && TREE_CODE (arg1) == INTEGER_CST
12197 && wi::eq_p (arg1, -1))
12198 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12200 /* X % -C is the same as X % C. */
12201 if (code == TRUNC_MOD_EXPR
12202 && TYPE_SIGN (type) == SIGNED
12203 && TREE_CODE (arg1) == INTEGER_CST
12204 && !TREE_OVERFLOW (arg1)
12205 && wi::neg_p (arg1)
12206 && !TYPE_OVERFLOW_TRAPS (type)
12207 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
12208 && !sign_bit_p (arg1, arg1))
12209 return fold_build2_loc (loc, code, type,
12210 fold_convert_loc (loc, type, arg0),
12211 fold_convert_loc (loc, type,
12212 negate_expr (arg1)));
12214 /* X % -Y is the same as X % Y. */
12215 if (code == TRUNC_MOD_EXPR
12216 && !TYPE_UNSIGNED (type)
12217 && TREE_CODE (arg1) == NEGATE_EXPR
12218 && !TYPE_OVERFLOW_TRAPS (type))
12219 return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, arg0),
12220 fold_convert_loc (loc, type,
12221 TREE_OPERAND (arg1, 0)));
12223 strict_overflow_p = false;
12224 if (TREE_CODE (arg1) == INTEGER_CST
12225 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
12226 &strict_overflow_p)))
12228 if (strict_overflow_p)
12229 fold_overflow_warning (("assuming signed overflow does not occur "
12230 "when simplifying modulus"),
12231 WARN_STRICT_OVERFLOW_MISC);
12232 return fold_convert_loc (loc, type, tem);
12235 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12236 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
12237 if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
12238 && (TYPE_UNSIGNED (type)
12239 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
12242 /* Also optimize A % (C << N) where C is a power of 2,
12243 to A & ((C << N) - 1). */
12244 if (TREE_CODE (arg1) == LSHIFT_EXPR)
12245 c = TREE_OPERAND (arg1, 0);
12247 if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
12250 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (arg1), arg1,
12251 build_int_cst (TREE_TYPE (arg1), 1));
12252 if (strict_overflow_p)
12253 fold_overflow_warning (("assuming signed overflow does not "
12254 "occur when simplifying "
12255 "X % (power of two)"),
12256 WARN_STRICT_OVERFLOW_MISC);
12257 return fold_build2_loc (loc, BIT_AND_EXPR, type,
12258 fold_convert_loc (loc, type, arg0),
12259 fold_convert_loc (loc, type, mask));
12267 if (integer_all_onesp (arg0))
12268 return omit_one_operand_loc (loc, type, arg0, arg1);
12272 /* Optimize -1 >> x for arithmetic right shifts. */
12273 if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type)
12274 && tree_expr_nonnegative_p (arg1))
12275 return omit_one_operand_loc (loc, type, arg0, arg1);
12276 /* ... fall through ... */
12280 if (integer_zerop (arg1))
12281 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12282 if (integer_zerop (arg0))
12283 return omit_one_operand_loc (loc, type, arg0, arg1);
12285 /* Prefer vector1 << scalar to vector1 << vector2
12286 if vector2 is uniform. */
12287 if (VECTOR_TYPE_P (TREE_TYPE (arg1))
12288 && (tem = uniform_vector_p (arg1)) != NULL_TREE)
12289 return fold_build2_loc (loc, code, type, op0, tem);
12291 /* Since negative shift count is not well-defined,
12292 don't try to compute it in the compiler. */
12293 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
12296 prec = element_precision (type);
12298 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
12299 if (TREE_CODE (op0) == code && tree_fits_uhwi_p (arg1)
12300 && tree_to_uhwi (arg1) < prec
12301 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
12302 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) < prec)
12304 unsigned int low = (tree_to_uhwi (TREE_OPERAND (arg0, 1))
12305 + tree_to_uhwi (arg1));
12307 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12308 being well defined. */
12311 if (code == LROTATE_EXPR || code == RROTATE_EXPR)
12313 else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
12314 return omit_one_operand_loc (loc, type, build_zero_cst (type),
12315 TREE_OPERAND (arg0, 0));
12320 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12321 build_int_cst (TREE_TYPE (arg1), low));
12324 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12325 into x & ((unsigned)-1 >> c) for unsigned types. */
12326 if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
12327 || (TYPE_UNSIGNED (type)
12328 && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
12329 && tree_fits_uhwi_p (arg1)
12330 && tree_to_uhwi (arg1) < prec
12331 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
12332 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) < prec)
12334 HOST_WIDE_INT low0 = tree_to_uhwi (TREE_OPERAND (arg0, 1));
12335 HOST_WIDE_INT low1 = tree_to_uhwi (arg1);
12341 arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12343 lshift = build_minus_one_cst (type);
12344 lshift = const_binop (code, lshift, arg1);
12346 return fold_build2_loc (loc, BIT_AND_EXPR, type, arg00, lshift);
12350 /* Rewrite an LROTATE_EXPR by a constant into an
12351 RROTATE_EXPR by a new constant. */
12352 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
12354 tree tem = build_int_cst (TREE_TYPE (arg1), prec);
12355 tem = const_binop (MINUS_EXPR, tem, arg1);
12356 return fold_build2_loc (loc, RROTATE_EXPR, type, op0, tem);
12359 /* If we have a rotate of a bit operation with the rotate count and
12360 the second operand of the bit operation both constant,
12361 permute the two operations. */
12362 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
12363 && (TREE_CODE (arg0) == BIT_AND_EXPR
12364 || TREE_CODE (arg0) == BIT_IOR_EXPR
12365 || TREE_CODE (arg0) == BIT_XOR_EXPR)
12366 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12367 return fold_build2_loc (loc, TREE_CODE (arg0), type,
12368 fold_build2_loc (loc, code, type,
12369 TREE_OPERAND (arg0, 0), arg1),
12370 fold_build2_loc (loc, code, type,
12371 TREE_OPERAND (arg0, 1), arg1));
12373 /* Two consecutive rotates adding up to the some integer
12374 multiple of the precision of the type can be ignored. */
12375 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
12376 && TREE_CODE (arg0) == RROTATE_EXPR
12377 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12378 && wi::umod_trunc (wi::add (arg1, TREE_OPERAND (arg0, 1)),
12380 return TREE_OPERAND (arg0, 0);
12382 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12383 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12384 if the latter can be further optimized. */
12385 if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
12386 && TREE_CODE (arg0) == BIT_AND_EXPR
12387 && TREE_CODE (arg1) == INTEGER_CST
12388 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12390 tree mask = fold_build2_loc (loc, code, type,
12391 fold_convert_loc (loc, type,
12392 TREE_OPERAND (arg0, 1)),
12394 tree shift = fold_build2_loc (loc, code, type,
12395 fold_convert_loc (loc, type,
12396 TREE_OPERAND (arg0, 0)),
12398 tem = fold_binary_loc (loc, BIT_AND_EXPR, type, shift, mask);
12406 if (operand_equal_p (arg0, arg1, 0))
12407 return omit_one_operand_loc (loc, type, arg0, arg1);
12408 if (INTEGRAL_TYPE_P (type)
12409 && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
12410 return omit_one_operand_loc (loc, type, arg1, arg0);
12411 tem = fold_minmax (loc, MIN_EXPR, type, arg0, arg1);
12417 if (operand_equal_p (arg0, arg1, 0))
12418 return omit_one_operand_loc (loc, type, arg0, arg1);
12419 if (INTEGRAL_TYPE_P (type)
12420 && TYPE_MAX_VALUE (type)
12421 && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
12422 return omit_one_operand_loc (loc, type, arg1, arg0);
12423 tem = fold_minmax (loc, MAX_EXPR, type, arg0, arg1);
12428 case TRUTH_ANDIF_EXPR:
12429 /* Note that the operands of this must be ints
12430 and their values must be 0 or 1.
12431 ("true" is a fixed value perhaps depending on the language.) */
12432 /* If first arg is constant zero, return it. */
12433 if (integer_zerop (arg0))
12434 return fold_convert_loc (loc, type, arg0);
12435 case TRUTH_AND_EXPR:
12436 /* If either arg is constant true, drop it. */
12437 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12438 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12439 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
12440 /* Preserve sequence points. */
12441 && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12442 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12443 /* If second arg is constant zero, result is zero, but first arg
12444 must be evaluated. */
12445 if (integer_zerop (arg1))
12446 return omit_one_operand_loc (loc, type, arg1, arg0);
12447 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12448 case will be handled here. */
12449 if (integer_zerop (arg0))
12450 return omit_one_operand_loc (loc, type, arg0, arg1);
12452 /* !X && X is always false. */
12453 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12454 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12455 return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
12456 /* X && !X is always false. */
12457 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12458 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12459 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12461 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12462 means A >= Y && A != MAX, but in this case we know that
12465 if (!TREE_SIDE_EFFECTS (arg0)
12466 && !TREE_SIDE_EFFECTS (arg1))
12468 tem = fold_to_nonsharp_ineq_using_bound (loc, arg0, arg1);
12469 if (tem && !operand_equal_p (tem, arg0, 0))
12470 return fold_build2_loc (loc, code, type, tem, arg1);
12472 tem = fold_to_nonsharp_ineq_using_bound (loc, arg1, arg0);
12473 if (tem && !operand_equal_p (tem, arg1, 0))
12474 return fold_build2_loc (loc, code, type, arg0, tem);
12477 if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
12483 case TRUTH_ORIF_EXPR:
12484 /* Note that the operands of this must be ints
12485 and their values must be 0 or true.
12486 ("true" is a fixed value perhaps depending on the language.) */
12487 /* If first arg is constant true, return it. */
12488 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12489 return fold_convert_loc (loc, type, arg0);
12490 case TRUTH_OR_EXPR:
12491 /* If either arg is constant zero, drop it. */
12492 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
12493 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12494 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
12495 /* Preserve sequence points. */
12496 && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12497 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12498 /* If second arg is constant true, result is true, but we must
12499 evaluate first arg. */
12500 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
12501 return omit_one_operand_loc (loc, type, arg1, arg0);
12502 /* Likewise for first arg, but note this only occurs here for
12504 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12505 return omit_one_operand_loc (loc, type, arg0, arg1);
12507 /* !X || X is always true. */
12508 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12509 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12510 return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12511 /* X || !X is always true. */
12512 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12513 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12514 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12516 /* (X && !Y) || (!X && Y) is X ^ Y */
12517 if (TREE_CODE (arg0) == TRUTH_AND_EXPR
12518 && TREE_CODE (arg1) == TRUTH_AND_EXPR)
12520 tree a0, a1, l0, l1, n0, n1;
12522 a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
12523 a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
12525 l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12526 l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
12528 n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
12529 n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
12531 if ((operand_equal_p (n0, a0, 0)
12532 && operand_equal_p (n1, a1, 0))
12533 || (operand_equal_p (n0, a1, 0)
12534 && operand_equal_p (n1, a0, 0)))
12535 return fold_build2_loc (loc, TRUTH_XOR_EXPR, type, l0, n1);
12538 if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
12544 case TRUTH_XOR_EXPR:
12545 /* If the second arg is constant zero, drop it. */
12546 if (integer_zerop (arg1))
12547 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12548 /* If the second arg is constant true, this is a logical inversion. */
12549 if (integer_onep (arg1))
12551 tem = invert_truthvalue_loc (loc, arg0);
12552 return non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
12554 /* Identical arguments cancel to zero. */
12555 if (operand_equal_p (arg0, arg1, 0))
12556 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12558 /* !X ^ X is always true. */
12559 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12560 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12561 return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12563 /* X ^ !X is always true. */
12564 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12565 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12566 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12575 tem = fold_comparison (loc, code, type, op0, op1);
12576 if (tem != NULL_TREE)
12579 /* bool_var != 0 becomes bool_var. */
12580 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12581 && code == NE_EXPR)
12582 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12584 /* bool_var == 1 becomes bool_var. */
12585 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12586 && code == EQ_EXPR)
12587 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12589 /* bool_var != 1 becomes !bool_var. */
12590 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12591 && code == NE_EXPR)
12592 return fold_convert_loc (loc, type,
12593 fold_build1_loc (loc, TRUTH_NOT_EXPR,
12594 TREE_TYPE (arg0), arg0));
12596 /* bool_var == 0 becomes !bool_var. */
12597 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12598 && code == EQ_EXPR)
12599 return fold_convert_loc (loc, type,
12600 fold_build1_loc (loc, TRUTH_NOT_EXPR,
12601 TREE_TYPE (arg0), arg0));
12603 /* !exp != 0 becomes !exp */
12604 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR && integer_zerop (arg1)
12605 && code == NE_EXPR)
12606 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12608 /* If this is an equality comparison of the address of two non-weak,
12609 unaliased symbols neither of which are extern (since we do not
12610 have access to attributes for externs), then we know the result. */
12611 if (TREE_CODE (arg0) == ADDR_EXPR
12612 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
12613 && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
12614 && ! lookup_attribute ("alias",
12615 DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
12616 && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
12617 && TREE_CODE (arg1) == ADDR_EXPR
12618 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
12619 && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
12620 && ! lookup_attribute ("alias",
12621 DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
12622 && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
12624 /* We know that we're looking at the address of two
12625 non-weak, unaliased, static _DECL nodes.
12627 It is both wasteful and incorrect to call operand_equal_p
12628 to compare the two ADDR_EXPR nodes. It is wasteful in that
12629 all we need to do is test pointer equality for the arguments
12630 to the two ADDR_EXPR nodes. It is incorrect to use
12631 operand_equal_p as that function is NOT equivalent to a
12632 C equality test. It can in fact return false for two
12633 objects which would test as equal using the C equality
12635 bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
12636 return constant_boolean_node (equal
12637 ? code == EQ_EXPR : code != EQ_EXPR,
12641 /* Similarly for a NEGATE_EXPR. */
12642 if (TREE_CODE (arg0) == NEGATE_EXPR
12643 && TREE_CODE (arg1) == INTEGER_CST
12644 && 0 != (tem = negate_expr (fold_convert_loc (loc, TREE_TYPE (arg0),
12646 && TREE_CODE (tem) == INTEGER_CST
12647 && !TREE_OVERFLOW (tem))
12648 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
12650 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12651 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12652 && TREE_CODE (arg1) == INTEGER_CST
12653 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12654 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12655 fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg0),
12656 fold_convert_loc (loc,
12659 TREE_OPERAND (arg0, 1)));
12661 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12662 if ((TREE_CODE (arg0) == PLUS_EXPR
12663 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
12664 || TREE_CODE (arg0) == MINUS_EXPR)
12665 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
12668 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
12669 || POINTER_TYPE_P (TREE_TYPE (arg0))))
12671 tree val = TREE_OPERAND (arg0, 1);
12672 return omit_two_operands_loc (loc, type,
12673 fold_build2_loc (loc, code, type,
12675 build_int_cst (TREE_TYPE (val),
12677 TREE_OPERAND (arg0, 0), arg1);
12680 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12681 if (TREE_CODE (arg0) == MINUS_EXPR
12682 && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
12683 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
12686 && wi::extract_uhwi (TREE_OPERAND (arg0, 0), 0, 1) == 1)
12688 return omit_two_operands_loc (loc, type,
12690 ? boolean_true_node : boolean_false_node,
12691 TREE_OPERAND (arg0, 1), arg1);
12694 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12695 if (TREE_CODE (arg0) == ABS_EXPR
12696 && (integer_zerop (arg1) || real_zerop (arg1)))
12697 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), arg1);
12699 /* If this is an EQ or NE comparison with zero and ARG0 is
12700 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12701 two operations, but the latter can be done in one less insn
12702 on machines that have only two-operand insns or on which a
12703 constant cannot be the first operand. */
12704 if (TREE_CODE (arg0) == BIT_AND_EXPR
12705 && integer_zerop (arg1))
12707 tree arg00 = TREE_OPERAND (arg0, 0);
12708 tree arg01 = TREE_OPERAND (arg0, 1);
12709 if (TREE_CODE (arg00) == LSHIFT_EXPR
12710 && integer_onep (TREE_OPERAND (arg00, 0)))
12712 tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
12713 arg01, TREE_OPERAND (arg00, 1));
12714 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12715 build_int_cst (TREE_TYPE (arg0), 1));
12716 return fold_build2_loc (loc, code, type,
12717 fold_convert_loc (loc, TREE_TYPE (arg1), tem),
12720 else if (TREE_CODE (arg01) == LSHIFT_EXPR
12721 && integer_onep (TREE_OPERAND (arg01, 0)))
12723 tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
12724 arg00, TREE_OPERAND (arg01, 1));
12725 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12726 build_int_cst (TREE_TYPE (arg0), 1));
12727 return fold_build2_loc (loc, code, type,
12728 fold_convert_loc (loc, TREE_TYPE (arg1), tem),
12733 /* If this is an NE or EQ comparison of zero against the result of a
12734 signed MOD operation whose second operand is a power of 2, make
12735 the MOD operation unsigned since it is simpler and equivalent. */
12736 if (integer_zerop (arg1)
12737 && !TYPE_UNSIGNED (TREE_TYPE (arg0))
12738 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
12739 || TREE_CODE (arg0) == CEIL_MOD_EXPR
12740 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
12741 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
12742 && integer_pow2p (TREE_OPERAND (arg0, 1)))
12744 tree newtype = unsigned_type_for (TREE_TYPE (arg0));
12745 tree newmod = fold_build2_loc (loc, TREE_CODE (arg0), newtype,
12746 fold_convert_loc (loc, newtype,
12747 TREE_OPERAND (arg0, 0)),
12748 fold_convert_loc (loc, newtype,
12749 TREE_OPERAND (arg0, 1)));
12751 return fold_build2_loc (loc, code, type, newmod,
12752 fold_convert_loc (loc, newtype, arg1));
12755 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12756 C1 is a valid shift constant, and C2 is a power of two, i.e.
12758 if (TREE_CODE (arg0) == BIT_AND_EXPR
12759 && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
12760 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
12762 && integer_pow2p (TREE_OPERAND (arg0, 1))
12763 && integer_zerop (arg1))
12765 tree itype = TREE_TYPE (arg0);
12766 tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
12767 prec = TYPE_PRECISION (itype);
12769 /* Check for a valid shift count. */
12770 if (wi::ltu_p (arg001, prec))
12772 tree arg01 = TREE_OPERAND (arg0, 1);
12773 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12774 unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
12775 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12776 can be rewritten as (X & (C2 << C1)) != 0. */
12777 if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
12779 tem = fold_build2_loc (loc, LSHIFT_EXPR, itype, arg01, arg001);
12780 tem = fold_build2_loc (loc, BIT_AND_EXPR, itype, arg000, tem);
12781 return fold_build2_loc (loc, code, type, tem,
12782 fold_convert_loc (loc, itype, arg1));
12784 /* Otherwise, for signed (arithmetic) shifts,
12785 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12786 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
12787 else if (!TYPE_UNSIGNED (itype))
12788 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
12789 arg000, build_int_cst (itype, 0));
12790 /* Otherwise, of unsigned (logical) shifts,
12791 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12792 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
12794 return omit_one_operand_loc (loc, type,
12795 code == EQ_EXPR ? integer_one_node
12796 : integer_zero_node,
12801 /* If we have (A & C) == C where C is a power of 2, convert this into
12802 (A & C) != 0. Similarly for NE_EXPR. */
12803 if (TREE_CODE (arg0) == BIT_AND_EXPR
12804 && integer_pow2p (TREE_OPERAND (arg0, 1))
12805 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12806 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12807 arg0, fold_convert_loc (loc, TREE_TYPE (arg0),
12808 integer_zero_node));
12810 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12811 bit, then fold the expression into A < 0 or A >= 0. */
12812 tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1, type);
12816 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12817 Similarly for NE_EXPR. */
12818 if (TREE_CODE (arg0) == BIT_AND_EXPR
12819 && TREE_CODE (arg1) == INTEGER_CST
12820 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12822 tree notc = fold_build1_loc (loc, BIT_NOT_EXPR,
12823 TREE_TYPE (TREE_OPERAND (arg0, 1)),
12824 TREE_OPERAND (arg0, 1));
12826 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12827 fold_convert_loc (loc, TREE_TYPE (arg0), arg1),
12829 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12830 if (integer_nonzerop (dandnotc))
12831 return omit_one_operand_loc (loc, type, rslt, arg0);
12834 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12835 Similarly for NE_EXPR. */
12836 if (TREE_CODE (arg0) == BIT_IOR_EXPR
12837 && TREE_CODE (arg1) == INTEGER_CST
12838 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12840 tree notd = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
12842 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12843 TREE_OPERAND (arg0, 1),
12844 fold_convert_loc (loc, TREE_TYPE (arg0), notd));
12845 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12846 if (integer_nonzerop (candnotd))
12847 return omit_one_operand_loc (loc, type, rslt, arg0);
12850 /* If this is a comparison of a field, we may be able to simplify it. */
12851 if ((TREE_CODE (arg0) == COMPONENT_REF
12852 || TREE_CODE (arg0) == BIT_FIELD_REF)
12853 /* Handle the constant case even without -O
12854 to make sure the warnings are given. */
12855 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
12857 t1 = optimize_bit_field_compare (loc, code, type, arg0, arg1);
12862 /* Optimize comparisons of strlen vs zero to a compare of the
12863 first character of the string vs zero. To wit,
12864 strlen(ptr) == 0 => *ptr == 0
12865 strlen(ptr) != 0 => *ptr != 0
12866 Other cases should reduce to one of these two (or a constant)
12867 due to the return value of strlen being unsigned. */
12868 if (TREE_CODE (arg0) == CALL_EXPR
12869 && integer_zerop (arg1))
12871 tree fndecl = get_callee_fndecl (arg0);
12874 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
12875 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
12876 && call_expr_nargs (arg0) == 1
12877 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
12879 tree iref = build_fold_indirect_ref_loc (loc,
12880 CALL_EXPR_ARG (arg0, 0));
12881 return fold_build2_loc (loc, code, type, iref,
12882 build_int_cst (TREE_TYPE (iref), 0));
12886 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12887 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12888 if (TREE_CODE (arg0) == RSHIFT_EXPR
12889 && integer_zerop (arg1)
12890 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12892 tree arg00 = TREE_OPERAND (arg0, 0);
12893 tree arg01 = TREE_OPERAND (arg0, 1);
12894 tree itype = TREE_TYPE (arg00);
12895 if (wi::eq_p (arg01, TYPE_PRECISION (itype) - 1))
12897 if (TYPE_UNSIGNED (itype))
12899 itype = signed_type_for (itype);
12900 arg00 = fold_convert_loc (loc, itype, arg00);
12902 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
12903 type, arg00, build_zero_cst (itype));
12907 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
12908 if (integer_zerop (arg1)
12909 && TREE_CODE (arg0) == BIT_XOR_EXPR)
12910 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12911 TREE_OPERAND (arg0, 1));
12913 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
12914 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12915 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12916 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12917 build_zero_cst (TREE_TYPE (arg0)));
12918 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
12919 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12920 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12921 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
12922 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 1),
12923 build_zero_cst (TREE_TYPE (arg0)));
12925 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
12926 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12927 && TREE_CODE (arg1) == INTEGER_CST
12928 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12929 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12930 fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg1),
12931 TREE_OPERAND (arg0, 1), arg1));
12933 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12934 (X & C) == 0 when C is a single bit. */
12935 if (TREE_CODE (arg0) == BIT_AND_EXPR
12936 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
12937 && integer_zerop (arg1)
12938 && integer_pow2p (TREE_OPERAND (arg0, 1)))
12940 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
12941 TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
12942 TREE_OPERAND (arg0, 1));
12943 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
12945 fold_convert_loc (loc, TREE_TYPE (arg0),
12949 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12950 constant C is a power of two, i.e. a single bit. */
12951 if (TREE_CODE (arg0) == BIT_XOR_EXPR
12952 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
12953 && integer_zerop (arg1)
12954 && integer_pow2p (TREE_OPERAND (arg0, 1))
12955 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12956 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12958 tree arg00 = TREE_OPERAND (arg0, 0);
12959 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12960 arg00, build_int_cst (TREE_TYPE (arg00), 0));
12963 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12964 when is C is a power of two, i.e. a single bit. */
12965 if (TREE_CODE (arg0) == BIT_AND_EXPR
12966 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
12967 && integer_zerop (arg1)
12968 && integer_pow2p (TREE_OPERAND (arg0, 1))
12969 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12970 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12972 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12973 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg000),
12974 arg000, TREE_OPERAND (arg0, 1));
12975 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12976 tem, build_int_cst (TREE_TYPE (tem), 0));
12979 if (integer_zerop (arg1)
12980 && tree_expr_nonzero_p (arg0))
12982 tree res = constant_boolean_node (code==NE_EXPR, type);
12983 return omit_one_operand_loc (loc, type, res, arg0);
12986 /* Fold -X op -Y as X op Y, where op is eq/ne. */
12987 if (TREE_CODE (arg0) == NEGATE_EXPR
12988 && TREE_CODE (arg1) == NEGATE_EXPR)
12989 return fold_build2_loc (loc, code, type,
12990 TREE_OPERAND (arg0, 0),
12991 fold_convert_loc (loc, TREE_TYPE (arg0),
12992 TREE_OPERAND (arg1, 0)));
12994 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
12995 if (TREE_CODE (arg0) == BIT_AND_EXPR
12996 && TREE_CODE (arg1) == BIT_AND_EXPR)
12998 tree arg00 = TREE_OPERAND (arg0, 0);
12999 tree arg01 = TREE_OPERAND (arg0, 1);
13000 tree arg10 = TREE_OPERAND (arg1, 0);
13001 tree arg11 = TREE_OPERAND (arg1, 1);
13002 tree itype = TREE_TYPE (arg0);
13004 if (operand_equal_p (arg01, arg11, 0))
13005 return fold_build2_loc (loc, code, type,
13006 fold_build2_loc (loc, BIT_AND_EXPR, itype,
13007 fold_build2_loc (loc,
13008 BIT_XOR_EXPR, itype,
13011 build_zero_cst (itype));
13013 if (operand_equal_p (arg01, arg10, 0))
13014 return fold_build2_loc (loc, code, type,
13015 fold_build2_loc (loc, BIT_AND_EXPR, itype,
13016 fold_build2_loc (loc,
13017 BIT_XOR_EXPR, itype,
13020 build_zero_cst (itype));
13022 if (operand_equal_p (arg00, arg11, 0))
13023 return fold_build2_loc (loc, code, type,
13024 fold_build2_loc (loc, BIT_AND_EXPR, itype,
13025 fold_build2_loc (loc,
13026 BIT_XOR_EXPR, itype,
13029 build_zero_cst (itype));
13031 if (operand_equal_p (arg00, arg10, 0))
13032 return fold_build2_loc (loc, code, type,
13033 fold_build2_loc (loc, BIT_AND_EXPR, itype,
13034 fold_build2_loc (loc,
13035 BIT_XOR_EXPR, itype,
13038 build_zero_cst (itype));
13041 if (TREE_CODE (arg0) == BIT_XOR_EXPR
13042 && TREE_CODE (arg1) == BIT_XOR_EXPR)
13044 tree arg00 = TREE_OPERAND (arg0, 0);
13045 tree arg01 = TREE_OPERAND (arg0, 1);
13046 tree arg10 = TREE_OPERAND (arg1, 0);
13047 tree arg11 = TREE_OPERAND (arg1, 1);
13048 tree itype = TREE_TYPE (arg0);
13050 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
13051 operand_equal_p guarantees no side-effects so we don't need
13052 to use omit_one_operand on Z. */
13053 if (operand_equal_p (arg01, arg11, 0))
13054 return fold_build2_loc (loc, code, type, arg00,
13055 fold_convert_loc (loc, TREE_TYPE (arg00),
13057 if (operand_equal_p (arg01, arg10, 0))
13058 return fold_build2_loc (loc, code, type, arg00,
13059 fold_convert_loc (loc, TREE_TYPE (arg00),
13061 if (operand_equal_p (arg00, arg11, 0))
13062 return fold_build2_loc (loc, code, type, arg01,
13063 fold_convert_loc (loc, TREE_TYPE (arg01),
13065 if (operand_equal_p (arg00, arg10, 0))
13066 return fold_build2_loc (loc, code, type, arg01,
13067 fold_convert_loc (loc, TREE_TYPE (arg01),
13070 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
13071 if (TREE_CODE (arg01) == INTEGER_CST
13072 && TREE_CODE (arg11) == INTEGER_CST)
13074 tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg01,
13075 fold_convert_loc (loc, itype, arg11));
13076 tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg00, tem);
13077 return fold_build2_loc (loc, code, type, tem,
13078 fold_convert_loc (loc, itype, arg10));
13082 /* Attempt to simplify equality/inequality comparisons of complex
13083 values. Only lower the comparison if the result is known or
13084 can be simplified to a single scalar comparison. */
13085 if ((TREE_CODE (arg0) == COMPLEX_EXPR
13086 || TREE_CODE (arg0) == COMPLEX_CST)
13087 && (TREE_CODE (arg1) == COMPLEX_EXPR
13088 || TREE_CODE (arg1) == COMPLEX_CST))
13090 tree real0, imag0, real1, imag1;
13093 if (TREE_CODE (arg0) == COMPLEX_EXPR)
13095 real0 = TREE_OPERAND (arg0, 0);
13096 imag0 = TREE_OPERAND (arg0, 1);
13100 real0 = TREE_REALPART (arg0);
13101 imag0 = TREE_IMAGPART (arg0);
13104 if (TREE_CODE (arg1) == COMPLEX_EXPR)
13106 real1 = TREE_OPERAND (arg1, 0);
13107 imag1 = TREE_OPERAND (arg1, 1);
13111 real1 = TREE_REALPART (arg1);
13112 imag1 = TREE_IMAGPART (arg1);
13115 rcond = fold_binary_loc (loc, code, type, real0, real1);
13116 if (rcond && TREE_CODE (rcond) == INTEGER_CST)
13118 if (integer_zerop (rcond))
13120 if (code == EQ_EXPR)
13121 return omit_two_operands_loc (loc, type, boolean_false_node,
13123 return fold_build2_loc (loc, NE_EXPR, type, imag0, imag1);
13127 if (code == NE_EXPR)
13128 return omit_two_operands_loc (loc, type, boolean_true_node,
13130 return fold_build2_loc (loc, EQ_EXPR, type, imag0, imag1);
13134 icond = fold_binary_loc (loc, code, type, imag0, imag1);
13135 if (icond && TREE_CODE (icond) == INTEGER_CST)
13137 if (integer_zerop (icond))
13139 if (code == EQ_EXPR)
13140 return omit_two_operands_loc (loc, type, boolean_false_node,
13142 return fold_build2_loc (loc, NE_EXPR, type, real0, real1);
13146 if (code == NE_EXPR)
13147 return omit_two_operands_loc (loc, type, boolean_true_node,
13149 return fold_build2_loc (loc, EQ_EXPR, type, real0, real1);
13160 tem = fold_comparison (loc, code, type, op0, op1);
13161 if (tem != NULL_TREE)
13164 /* Transform comparisons of the form X +- C CMP X. */
13165 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
13166 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
13167 && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
13168 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
13169 || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
13170 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
13172 tree arg01 = TREE_OPERAND (arg0, 1);
13173 enum tree_code code0 = TREE_CODE (arg0);
13176 if (TREE_CODE (arg01) == REAL_CST)
13177 is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
13179 is_positive = tree_int_cst_sgn (arg01);
13181 /* (X - c) > X becomes false. */
13182 if (code == GT_EXPR
13183 && ((code0 == MINUS_EXPR && is_positive >= 0)
13184 || (code0 == PLUS_EXPR && is_positive <= 0)))
13186 if (TREE_CODE (arg01) == INTEGER_CST
13187 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13188 fold_overflow_warning (("assuming signed overflow does not "
13189 "occur when assuming that (X - c) > X "
13190 "is always false"),
13191 WARN_STRICT_OVERFLOW_ALL);
13192 return constant_boolean_node (0, type);
13195 /* Likewise (X + c) < X becomes false. */
13196 if (code == LT_EXPR
13197 && ((code0 == PLUS_EXPR && is_positive >= 0)
13198 || (code0 == MINUS_EXPR && is_positive <= 0)))
13200 if (TREE_CODE (arg01) == INTEGER_CST
13201 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13202 fold_overflow_warning (("assuming signed overflow does not "
13203 "occur when assuming that "
13204 "(X + c) < X is always false"),
13205 WARN_STRICT_OVERFLOW_ALL);
13206 return constant_boolean_node (0, type);
13209 /* Convert (X - c) <= X to true. */
13210 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
13212 && ((code0 == MINUS_EXPR && is_positive >= 0)
13213 || (code0 == PLUS_EXPR && is_positive <= 0)))
13215 if (TREE_CODE (arg01) == INTEGER_CST
13216 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13217 fold_overflow_warning (("assuming signed overflow does not "
13218 "occur when assuming that "
13219 "(X - c) <= X is always true"),
13220 WARN_STRICT_OVERFLOW_ALL);
13221 return constant_boolean_node (1, type);
13224 /* Convert (X + c) >= X to true. */
13225 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
13227 && ((code0 == PLUS_EXPR && is_positive >= 0)
13228 || (code0 == MINUS_EXPR && is_positive <= 0)))
13230 if (TREE_CODE (arg01) == INTEGER_CST
13231 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13232 fold_overflow_warning (("assuming signed overflow does not "
13233 "occur when assuming that "
13234 "(X + c) >= X is always true"),
13235 WARN_STRICT_OVERFLOW_ALL);
13236 return constant_boolean_node (1, type);
13239 if (TREE_CODE (arg01) == INTEGER_CST)
13241 /* Convert X + c > X and X - c < X to true for integers. */
13242 if (code == GT_EXPR
13243 && ((code0 == PLUS_EXPR && is_positive > 0)
13244 || (code0 == MINUS_EXPR && is_positive < 0)))
13246 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13247 fold_overflow_warning (("assuming signed overflow does "
13248 "not occur when assuming that "
13249 "(X + c) > X is always true"),
13250 WARN_STRICT_OVERFLOW_ALL);
13251 return constant_boolean_node (1, type);
13254 if (code == LT_EXPR
13255 && ((code0 == MINUS_EXPR && is_positive > 0)
13256 || (code0 == PLUS_EXPR && is_positive < 0)))
13258 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13259 fold_overflow_warning (("assuming signed overflow does "
13260 "not occur when assuming that "
13261 "(X - c) < X is always true"),
13262 WARN_STRICT_OVERFLOW_ALL);
13263 return constant_boolean_node (1, type);
13266 /* Convert X + c <= X and X - c >= X to false for integers. */
13267 if (code == LE_EXPR
13268 && ((code0 == PLUS_EXPR && is_positive > 0)
13269 || (code0 == MINUS_EXPR && is_positive < 0)))
13271 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13272 fold_overflow_warning (("assuming signed overflow does "
13273 "not occur when assuming that "
13274 "(X + c) <= X is always false"),
13275 WARN_STRICT_OVERFLOW_ALL);
13276 return constant_boolean_node (0, type);
13279 if (code == GE_EXPR
13280 && ((code0 == MINUS_EXPR && is_positive > 0)
13281 || (code0 == PLUS_EXPR && is_positive < 0)))
13283 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13284 fold_overflow_warning (("assuming signed overflow does "
13285 "not occur when assuming that "
13286 "(X - c) >= X is always false"),
13287 WARN_STRICT_OVERFLOW_ALL);
13288 return constant_boolean_node (0, type);
13293 /* Comparisons with the highest or lowest possible integer of
13294 the specified precision will have known values. */
13296 tree arg1_type = TREE_TYPE (arg1);
13297 unsigned int prec = TYPE_PRECISION (arg1_type);
13299 if (TREE_CODE (arg1) == INTEGER_CST
13300 && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
13302 wide_int max = wi::max_value (arg1_type);
13303 wide_int signed_max = wi::max_value (prec, SIGNED);
13304 wide_int min = wi::min_value (arg1_type);
13306 if (wi::eq_p (arg1, max))
13310 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13313 return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
13316 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13319 return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
13321 /* The GE_EXPR and LT_EXPR cases above are not normally
13322 reached because of previous transformations. */
13327 else if (wi::eq_p (arg1, max - 1))
13331 arg1 = const_binop (PLUS_EXPR, arg1,
13332 build_int_cst (TREE_TYPE (arg1), 1));
13333 return fold_build2_loc (loc, EQ_EXPR, type,
13334 fold_convert_loc (loc,
13335 TREE_TYPE (arg1), arg0),
13338 arg1 = const_binop (PLUS_EXPR, arg1,
13339 build_int_cst (TREE_TYPE (arg1), 1));
13340 return fold_build2_loc (loc, NE_EXPR, type,
13341 fold_convert_loc (loc, TREE_TYPE (arg1),
13347 else if (wi::eq_p (arg1, min))
13351 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13354 return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
13357 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13360 return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
13365 else if (wi::eq_p (arg1, min + 1))
13369 arg1 = const_binop (MINUS_EXPR, arg1,
13370 build_int_cst (TREE_TYPE (arg1), 1));
13371 return fold_build2_loc (loc, NE_EXPR, type,
13372 fold_convert_loc (loc,
13373 TREE_TYPE (arg1), arg0),
13376 arg1 = const_binop (MINUS_EXPR, arg1,
13377 build_int_cst (TREE_TYPE (arg1), 1));
13378 return fold_build2_loc (loc, EQ_EXPR, type,
13379 fold_convert_loc (loc, TREE_TYPE (arg1),
13386 else if (wi::eq_p (arg1, signed_max)
13387 && TYPE_UNSIGNED (arg1_type)
13388 /* We will flip the signedness of the comparison operator
13389 associated with the mode of arg1, so the sign bit is
13390 specified by this mode. Check that arg1 is the signed
13391 max associated with this sign bit. */
13392 && prec == GET_MODE_PRECISION (TYPE_MODE (arg1_type))
13393 /* signed_type does not work on pointer types. */
13394 && INTEGRAL_TYPE_P (arg1_type))
13396 /* The following case also applies to X < signed_max+1
13397 and X >= signed_max+1 because previous transformations. */
13398 if (code == LE_EXPR || code == GT_EXPR)
13400 tree st = signed_type_for (arg1_type);
13401 return fold_build2_loc (loc,
13402 code == LE_EXPR ? GE_EXPR : LT_EXPR,
13403 type, fold_convert_loc (loc, st, arg0),
13404 build_int_cst (st, 0));
13410 /* If we are comparing an ABS_EXPR with a constant, we can
13411 convert all the cases into explicit comparisons, but they may
13412 well not be faster than doing the ABS and one comparison.
13413 But ABS (X) <= C is a range comparison, which becomes a subtraction
13414 and a comparison, and is probably faster. */
13415 if (code == LE_EXPR
13416 && TREE_CODE (arg1) == INTEGER_CST
13417 && TREE_CODE (arg0) == ABS_EXPR
13418 && ! TREE_SIDE_EFFECTS (arg0)
13419 && (0 != (tem = negate_expr (arg1)))
13420 && TREE_CODE (tem) == INTEGER_CST
13421 && !TREE_OVERFLOW (tem))
13422 return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13423 build2 (GE_EXPR, type,
13424 TREE_OPERAND (arg0, 0), tem),
13425 build2 (LE_EXPR, type,
13426 TREE_OPERAND (arg0, 0), arg1));
13428 /* Convert ABS_EXPR<x> >= 0 to true. */
13429 strict_overflow_p = false;
13430 if (code == GE_EXPR
13431 && (integer_zerop (arg1)
13432 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
13433 && real_zerop (arg1)))
13434 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13436 if (strict_overflow_p)
13437 fold_overflow_warning (("assuming signed overflow does not occur "
13438 "when simplifying comparison of "
13439 "absolute value and zero"),
13440 WARN_STRICT_OVERFLOW_CONDITIONAL);
13441 return omit_one_operand_loc (loc, type,
13442 constant_boolean_node (true, type),
13446 /* Convert ABS_EXPR<x> < 0 to false. */
13447 strict_overflow_p = false;
13448 if (code == LT_EXPR
13449 && (integer_zerop (arg1) || real_zerop (arg1))
13450 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13452 if (strict_overflow_p)
13453 fold_overflow_warning (("assuming signed overflow does not occur "
13454 "when simplifying comparison of "
13455 "absolute value and zero"),
13456 WARN_STRICT_OVERFLOW_CONDITIONAL);
13457 return omit_one_operand_loc (loc, type,
13458 constant_boolean_node (false, type),
13462 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13463 and similarly for >= into !=. */
13464 if ((code == LT_EXPR || code == GE_EXPR)
13465 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13466 && TREE_CODE (arg1) == LSHIFT_EXPR
13467 && integer_onep (TREE_OPERAND (arg1, 0)))
13468 return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13469 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13470 TREE_OPERAND (arg1, 1)),
13471 build_zero_cst (TREE_TYPE (arg0)));
13473 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
13474 otherwise Y might be >= # of bits in X's type and thus e.g.
13475 (unsigned char) (1 << Y) for Y 15 might be 0.
13476 If the cast is widening, then 1 << Y should have unsigned type,
13477 otherwise if Y is number of bits in the signed shift type minus 1,
13478 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
13479 31 might be 0xffffffff80000000. */
13480 if ((code == LT_EXPR || code == GE_EXPR)
13481 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13482 && CONVERT_EXPR_P (arg1)
13483 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
13484 && (TYPE_PRECISION (TREE_TYPE (arg1))
13485 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0))))
13486 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0)))
13487 || (TYPE_PRECISION (TREE_TYPE (arg1))
13488 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)))))
13489 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
13491 tem = build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13492 TREE_OPERAND (TREE_OPERAND (arg1, 0), 1));
13493 return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13494 fold_convert_loc (loc, TREE_TYPE (arg0), tem),
13495 build_zero_cst (TREE_TYPE (arg0)));
13500 case UNORDERED_EXPR:
13508 if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
13510 t1 = fold_relational_const (code, type, arg0, arg1);
13511 if (t1 != NULL_TREE)
13515 /* If the first operand is NaN, the result is constant. */
13516 if (TREE_CODE (arg0) == REAL_CST
13517 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
13518 && (code != LTGT_EXPR || ! flag_trapping_math))
13520 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13521 ? integer_zero_node
13522 : integer_one_node;
13523 return omit_one_operand_loc (loc, type, t1, arg1);
13526 /* If the second operand is NaN, the result is constant. */
13527 if (TREE_CODE (arg1) == REAL_CST
13528 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
13529 && (code != LTGT_EXPR || ! flag_trapping_math))
13531 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13532 ? integer_zero_node
13533 : integer_one_node;
13534 return omit_one_operand_loc (loc, type, t1, arg0);
13537 /* Simplify unordered comparison of something with itself. */
13538 if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
13539 && operand_equal_p (arg0, arg1, 0))
13540 return constant_boolean_node (1, type);
13542 if (code == LTGT_EXPR
13543 && !flag_trapping_math
13544 && operand_equal_p (arg0, arg1, 0))
13545 return constant_boolean_node (0, type);
13547 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13549 tree targ0 = strip_float_extensions (arg0);
13550 tree targ1 = strip_float_extensions (arg1);
13551 tree newtype = TREE_TYPE (targ0);
13553 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
13554 newtype = TREE_TYPE (targ1);
13556 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
13557 return fold_build2_loc (loc, code, type,
13558 fold_convert_loc (loc, newtype, targ0),
13559 fold_convert_loc (loc, newtype, targ1));
13564 case COMPOUND_EXPR:
13565 /* When pedantic, a compound expression can be neither an lvalue
13566 nor an integer constant expression. */
13567 if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
13569 /* Don't let (0, 0) be null pointer constant. */
13570 tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
13571 : fold_convert_loc (loc, type, arg1);
13572 return pedantic_non_lvalue_loc (loc, tem);
13575 if ((TREE_CODE (arg0) == REAL_CST
13576 && TREE_CODE (arg1) == REAL_CST)
13577 || (TREE_CODE (arg0) == INTEGER_CST
13578 && TREE_CODE (arg1) == INTEGER_CST))
13579 return build_complex (type, arg0, arg1);
13580 if (TREE_CODE (arg0) == REALPART_EXPR
13581 && TREE_CODE (arg1) == IMAGPART_EXPR
13582 && TREE_TYPE (TREE_OPERAND (arg0, 0)) == type
13583 && operand_equal_p (TREE_OPERAND (arg0, 0),
13584 TREE_OPERAND (arg1, 0), 0))
13585 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
13586 TREE_OPERAND (arg1, 0));
13590 /* An ASSERT_EXPR should never be passed to fold_binary. */
13591 gcc_unreachable ();
13593 case VEC_PACK_TRUNC_EXPR:
13594 case VEC_PACK_FIX_TRUNC_EXPR:
13596 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
13599 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts / 2
13600 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts / 2);
13601 if (TREE_CODE (arg0) != VECTOR_CST || TREE_CODE (arg1) != VECTOR_CST)
13604 elts = XALLOCAVEC (tree, nelts);
13605 if (!vec_cst_ctor_to_array (arg0, elts)
13606 || !vec_cst_ctor_to_array (arg1, elts + nelts / 2))
13609 for (i = 0; i < nelts; i++)
13611 elts[i] = fold_convert_const (code == VEC_PACK_TRUNC_EXPR
13612 ? NOP_EXPR : FIX_TRUNC_EXPR,
13613 TREE_TYPE (type), elts[i]);
13614 if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
13618 return build_vector (type, elts);
13621 case VEC_WIDEN_MULT_LO_EXPR:
13622 case VEC_WIDEN_MULT_HI_EXPR:
13623 case VEC_WIDEN_MULT_EVEN_EXPR:
13624 case VEC_WIDEN_MULT_ODD_EXPR:
13626 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type);
13627 unsigned int out, ofs, scale;
13630 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2
13631 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts * 2);
13632 if (TREE_CODE (arg0) != VECTOR_CST || TREE_CODE (arg1) != VECTOR_CST)
13635 elts = XALLOCAVEC (tree, nelts * 4);
13636 if (!vec_cst_ctor_to_array (arg0, elts)
13637 || !vec_cst_ctor_to_array (arg1, elts + nelts * 2))
13640 if (code == VEC_WIDEN_MULT_LO_EXPR)
13641 scale = 0, ofs = BYTES_BIG_ENDIAN ? nelts : 0;
13642 else if (code == VEC_WIDEN_MULT_HI_EXPR)
13643 scale = 0, ofs = BYTES_BIG_ENDIAN ? 0 : nelts;
13644 else if (code == VEC_WIDEN_MULT_EVEN_EXPR)
13645 scale = 1, ofs = 0;
13646 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
13647 scale = 1, ofs = 1;
13649 for (out = 0; out < nelts; out++)
13651 unsigned int in1 = (out << scale) + ofs;
13652 unsigned int in2 = in1 + nelts * 2;
13655 t1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in1]);
13656 t2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in2]);
13658 if (t1 == NULL_TREE || t2 == NULL_TREE)
13660 elts[out] = const_binop (MULT_EXPR, t1, t2);
13661 if (elts[out] == NULL_TREE || !CONSTANT_CLASS_P (elts[out]))
13665 return build_vector (type, elts);
13670 } /* switch (code) */
13673 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
13674 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
13678 contains_label_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
13680 switch (TREE_CODE (*tp))
13686 *walk_subtrees = 0;
13688 /* ... fall through ... */
13695 /* Return whether the sub-tree ST contains a label which is accessible from
13696 outside the sub-tree. */
13699 contains_label_p (tree st)
13702 (walk_tree_without_duplicates (&st, contains_label_1 , NULL) != NULL_TREE);
13705 /* Fold a ternary expression of code CODE and type TYPE with operands
13706 OP0, OP1, and OP2. Return the folded expression if folding is
13707 successful. Otherwise, return NULL_TREE. */
13710 fold_ternary_loc (location_t loc, enum tree_code code, tree type,
13711 tree op0, tree op1, tree op2)
13714 tree arg0 = NULL_TREE, arg1 = NULL_TREE, arg2 = NULL_TREE;
13715 enum tree_code_class kind = TREE_CODE_CLASS (code);
13717 gcc_assert (IS_EXPR_CODE_CLASS (kind)
13718 && TREE_CODE_LENGTH (code) == 3);
13720 /* If this is a commutative operation, and OP0 is a constant, move it
13721 to OP1 to reduce the number of tests below. */
13722 if (commutative_ternary_tree_code (code)
13723 && tree_swap_operands_p (op0, op1, true))
13724 return fold_build3_loc (loc, code, type, op1, op0, op2);
13726 tem = generic_simplify (loc, code, type, op0, op1, op2);
13730 /* Strip any conversions that don't change the mode. This is safe
13731 for every expression, except for a comparison expression because
13732 its signedness is derived from its operands. So, in the latter
13733 case, only strip conversions that don't change the signedness.
13735 Note that this is done as an internal manipulation within the
13736 constant folder, in order to find the simplest representation of
13737 the arguments so that their form can be studied. In any cases,
13738 the appropriate type conversions should be put back in the tree
13739 that will get out of the constant folder. */
13760 case COMPONENT_REF:
13761 if (TREE_CODE (arg0) == CONSTRUCTOR
13762 && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
13764 unsigned HOST_WIDE_INT idx;
13766 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
13773 case VEC_COND_EXPR:
13774 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13775 so all simple results must be passed through pedantic_non_lvalue. */
13776 if (TREE_CODE (arg0) == INTEGER_CST)
13778 tree unused_op = integer_zerop (arg0) ? op1 : op2;
13779 tem = integer_zerop (arg0) ? op2 : op1;
13780 /* Only optimize constant conditions when the selected branch
13781 has the same type as the COND_EXPR. This avoids optimizing
13782 away "c ? x : throw", where the throw has a void type.
13783 Avoid throwing away that operand which contains label. */
13784 if ((!TREE_SIDE_EFFECTS (unused_op)
13785 || !contains_label_p (unused_op))
13786 && (! VOID_TYPE_P (TREE_TYPE (tem))
13787 || VOID_TYPE_P (type)))
13788 return pedantic_non_lvalue_loc (loc, tem);
13791 else if (TREE_CODE (arg0) == VECTOR_CST)
13793 if (integer_all_onesp (arg0))
13794 return pedantic_omit_one_operand_loc (loc, type, arg1, arg2);
13795 if (integer_zerop (arg0))
13796 return pedantic_omit_one_operand_loc (loc, type, arg2, arg1);
13798 if ((TREE_CODE (arg1) == VECTOR_CST
13799 || TREE_CODE (arg1) == CONSTRUCTOR)
13800 && (TREE_CODE (arg2) == VECTOR_CST
13801 || TREE_CODE (arg2) == CONSTRUCTOR))
13803 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
13804 unsigned char *sel = XALLOCAVEC (unsigned char, nelts);
13805 gcc_assert (nelts == VECTOR_CST_NELTS (arg0));
13806 for (i = 0; i < nelts; i++)
13808 tree val = VECTOR_CST_ELT (arg0, i);
13809 if (integer_all_onesp (val))
13811 else if (integer_zerop (val))
13812 sel[i] = nelts + i;
13813 else /* Currently unreachable. */
13816 tree t = fold_vec_perm (type, arg1, arg2, sel);
13817 if (t != NULL_TREE)
13822 if (operand_equal_p (arg1, op2, 0))
13823 return pedantic_omit_one_operand_loc (loc, type, arg1, arg0);
13825 /* If we have A op B ? A : C, we may be able to convert this to a
13826 simpler expression, depending on the operation and the values
13827 of B and C. Signed zeros prevent all of these transformations,
13828 for reasons given above each one.
13830 Also try swapping the arguments and inverting the conditional. */
13831 if (COMPARISON_CLASS_P (arg0)
13832 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13833 arg1, TREE_OPERAND (arg0, 1))
13834 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
13836 tem = fold_cond_expr_with_comparison (loc, type, arg0, op1, op2);
13841 if (COMPARISON_CLASS_P (arg0)
13842 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13844 TREE_OPERAND (arg0, 1))
13845 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
13847 location_t loc0 = expr_location_or (arg0, loc);
13848 tem = fold_invert_truthvalue (loc0, arg0);
13849 if (tem && COMPARISON_CLASS_P (tem))
13851 tem = fold_cond_expr_with_comparison (loc, type, tem, op2, op1);
13857 /* If the second operand is simpler than the third, swap them
13858 since that produces better jump optimization results. */
13859 if (truth_value_p (TREE_CODE (arg0))
13860 && tree_swap_operands_p (op1, op2, false))
13862 location_t loc0 = expr_location_or (arg0, loc);
13863 /* See if this can be inverted. If it can't, possibly because
13864 it was a floating-point inequality comparison, don't do
13866 tem = fold_invert_truthvalue (loc0, arg0);
13868 return fold_build3_loc (loc, code, type, tem, op2, op1);
13871 /* Convert A ? 1 : 0 to simply A. */
13872 if ((code == VEC_COND_EXPR ? integer_all_onesp (op1)
13873 : (integer_onep (op1)
13874 && !VECTOR_TYPE_P (type)))
13875 && integer_zerop (op2)
13876 /* If we try to convert OP0 to our type, the
13877 call to fold will try to move the conversion inside
13878 a COND, which will recurse. In that case, the COND_EXPR
13879 is probably the best choice, so leave it alone. */
13880 && type == TREE_TYPE (arg0))
13881 return pedantic_non_lvalue_loc (loc, arg0);
13883 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13884 over COND_EXPR in cases such as floating point comparisons. */
13885 if (integer_zerop (op1)
13886 && (code == VEC_COND_EXPR ? integer_all_onesp (op2)
13887 : (integer_onep (op2)
13888 && !VECTOR_TYPE_P (type)))
13889 && truth_value_p (TREE_CODE (arg0)))
13890 return pedantic_non_lvalue_loc (loc,
13891 fold_convert_loc (loc, type,
13892 invert_truthvalue_loc (loc,
13895 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13896 if (TREE_CODE (arg0) == LT_EXPR
13897 && integer_zerop (TREE_OPERAND (arg0, 1))
13898 && integer_zerop (op2)
13899 && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
13901 /* sign_bit_p looks through both zero and sign extensions,
13902 but for this optimization only sign extensions are
13904 tree tem2 = TREE_OPERAND (arg0, 0);
13905 while (tem != tem2)
13907 if (TREE_CODE (tem2) != NOP_EXPR
13908 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2, 0))))
13913 tem2 = TREE_OPERAND (tem2, 0);
13915 /* sign_bit_p only checks ARG1 bits within A's precision.
13916 If <sign bit of A> has wider type than A, bits outside
13917 of A's precision in <sign bit of A> need to be checked.
13918 If they are all 0, this optimization needs to be done
13919 in unsigned A's type, if they are all 1 in signed A's type,
13920 otherwise this can't be done. */
13922 && TYPE_PRECISION (TREE_TYPE (tem))
13923 < TYPE_PRECISION (TREE_TYPE (arg1))
13924 && TYPE_PRECISION (TREE_TYPE (tem))
13925 < TYPE_PRECISION (type))
13927 int inner_width, outer_width;
13930 inner_width = TYPE_PRECISION (TREE_TYPE (tem));
13931 outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
13932 if (outer_width > TYPE_PRECISION (type))
13933 outer_width = TYPE_PRECISION (type);
13935 wide_int mask = wi::shifted_mask
13936 (inner_width, outer_width - inner_width, false,
13937 TYPE_PRECISION (TREE_TYPE (arg1)));
13939 wide_int common = mask & arg1;
13940 if (common == mask)
13942 tem_type = signed_type_for (TREE_TYPE (tem));
13943 tem = fold_convert_loc (loc, tem_type, tem);
13945 else if (common == 0)
13947 tem_type = unsigned_type_for (TREE_TYPE (tem));
13948 tem = fold_convert_loc (loc, tem_type, tem);
13956 fold_convert_loc (loc, type,
13957 fold_build2_loc (loc, BIT_AND_EXPR,
13958 TREE_TYPE (tem), tem,
13959 fold_convert_loc (loc,
13964 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
13965 already handled above. */
13966 if (TREE_CODE (arg0) == BIT_AND_EXPR
13967 && integer_onep (TREE_OPERAND (arg0, 1))
13968 && integer_zerop (op2)
13969 && integer_pow2p (arg1))
13971 tree tem = TREE_OPERAND (arg0, 0);
13973 if (TREE_CODE (tem) == RSHIFT_EXPR
13974 && tree_fits_uhwi_p (TREE_OPERAND (tem, 1))
13975 && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
13976 tree_to_uhwi (TREE_OPERAND (tem, 1)))
13977 return fold_build2_loc (loc, BIT_AND_EXPR, type,
13978 TREE_OPERAND (tem, 0), arg1);
13981 /* A & N ? N : 0 is simply A & N if N is a power of two. This
13982 is probably obsolete because the first operand should be a
13983 truth value (that's why we have the two cases above), but let's
13984 leave it in until we can confirm this for all front-ends. */
13985 if (integer_zerop (op2)
13986 && TREE_CODE (arg0) == NE_EXPR
13987 && integer_zerop (TREE_OPERAND (arg0, 1))
13988 && integer_pow2p (arg1)
13989 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
13990 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13991 arg1, OEP_ONLY_CONST))
13992 return pedantic_non_lvalue_loc (loc,
13993 fold_convert_loc (loc, type,
13994 TREE_OPERAND (arg0, 0)));
13996 /* Disable the transformations below for vectors, since
13997 fold_binary_op_with_conditional_arg may undo them immediately,
13998 yielding an infinite loop. */
13999 if (code == VEC_COND_EXPR)
14002 /* Convert A ? B : 0 into A && B if A and B are truth values. */
14003 if (integer_zerop (op2)
14004 && truth_value_p (TREE_CODE (arg0))
14005 && truth_value_p (TREE_CODE (arg1))
14006 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
14007 return fold_build2_loc (loc, code == VEC_COND_EXPR ? BIT_AND_EXPR
14008 : TRUTH_ANDIF_EXPR,
14009 type, fold_convert_loc (loc, type, arg0), arg1);
14011 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
14012 if (code == VEC_COND_EXPR ? integer_all_onesp (op2) : integer_onep (op2)
14013 && truth_value_p (TREE_CODE (arg0))
14014 && truth_value_p (TREE_CODE (arg1))
14015 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
14017 location_t loc0 = expr_location_or (arg0, loc);
14018 /* Only perform transformation if ARG0 is easily inverted. */
14019 tem = fold_invert_truthvalue (loc0, arg0);
14021 return fold_build2_loc (loc, code == VEC_COND_EXPR
14024 type, fold_convert_loc (loc, type, tem),
14028 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
14029 if (integer_zerop (arg1)
14030 && truth_value_p (TREE_CODE (arg0))
14031 && truth_value_p (TREE_CODE (op2))
14032 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
14034 location_t loc0 = expr_location_or (arg0, loc);
14035 /* Only perform transformation if ARG0 is easily inverted. */
14036 tem = fold_invert_truthvalue (loc0, arg0);
14038 return fold_build2_loc (loc, code == VEC_COND_EXPR
14039 ? BIT_AND_EXPR : TRUTH_ANDIF_EXPR,
14040 type, fold_convert_loc (loc, type, tem),
14044 /* Convert A ? 1 : B into A || B if A and B are truth values. */
14045 if (code == VEC_COND_EXPR ? integer_all_onesp (arg1) : integer_onep (arg1)
14046 && truth_value_p (TREE_CODE (arg0))
14047 && truth_value_p (TREE_CODE (op2))
14048 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
14049 return fold_build2_loc (loc, code == VEC_COND_EXPR
14050 ? BIT_IOR_EXPR : TRUTH_ORIF_EXPR,
14051 type, fold_convert_loc (loc, type, arg0), op2);
14056 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
14057 of fold_ternary on them. */
14058 gcc_unreachable ();
14060 case BIT_FIELD_REF:
14061 if ((TREE_CODE (arg0) == VECTOR_CST
14062 || (TREE_CODE (arg0) == CONSTRUCTOR
14063 && TREE_CODE (TREE_TYPE (arg0)) == VECTOR_TYPE))
14064 && (type == TREE_TYPE (TREE_TYPE (arg0))
14065 || (TREE_CODE (type) == VECTOR_TYPE
14066 && TREE_TYPE (type) == TREE_TYPE (TREE_TYPE (arg0)))))
14068 tree eltype = TREE_TYPE (TREE_TYPE (arg0));
14069 unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
14070 unsigned HOST_WIDE_INT n = tree_to_uhwi (arg1);
14071 unsigned HOST_WIDE_INT idx = tree_to_uhwi (op2);
14074 && (idx % width) == 0
14075 && (n % width) == 0
14076 && ((idx + n) / width) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
14081 if (TREE_CODE (arg0) == VECTOR_CST)
14084 return VECTOR_CST_ELT (arg0, idx);
14086 tree *vals = XALLOCAVEC (tree, n);
14087 for (unsigned i = 0; i < n; ++i)
14088 vals[i] = VECTOR_CST_ELT (arg0, idx + i);
14089 return build_vector (type, vals);
14092 /* Constructor elements can be subvectors. */
14093 unsigned HOST_WIDE_INT k = 1;
14094 if (CONSTRUCTOR_NELTS (arg0) != 0)
14096 tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (arg0, 0)->value);
14097 if (TREE_CODE (cons_elem) == VECTOR_TYPE)
14098 k = TYPE_VECTOR_SUBPARTS (cons_elem);
14101 /* We keep an exact subset of the constructor elements. */
14102 if ((idx % k) == 0 && (n % k) == 0)
14104 if (CONSTRUCTOR_NELTS (arg0) == 0)
14105 return build_constructor (type, NULL);
14110 if (idx < CONSTRUCTOR_NELTS (arg0))
14111 return CONSTRUCTOR_ELT (arg0, idx)->value;
14112 return build_zero_cst (type);
14115 vec<constructor_elt, va_gc> *vals;
14116 vec_alloc (vals, n);
14117 for (unsigned i = 0;
14118 i < n && idx + i < CONSTRUCTOR_NELTS (arg0);
14120 CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE,
14122 (arg0, idx + i)->value);
14123 return build_constructor (type, vals);
14125 /* The bitfield references a single constructor element. */
14126 else if (idx + n <= (idx / k + 1) * k)
14128 if (CONSTRUCTOR_NELTS (arg0) <= idx / k)
14129 return build_zero_cst (type);
14131 return CONSTRUCTOR_ELT (arg0, idx / k)->value;
14133 return fold_build3_loc (loc, code, type,
14134 CONSTRUCTOR_ELT (arg0, idx / k)->value, op1,
14135 build_int_cst (TREE_TYPE (op2), (idx % k) * width));
14140 /* A bit-field-ref that referenced the full argument can be stripped. */
14141 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
14142 && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_to_uhwi (arg1)
14143 && integer_zerop (op2))
14144 return fold_convert_loc (loc, type, arg0);
14146 /* On constants we can use native encode/interpret to constant
14147 fold (nearly) all BIT_FIELD_REFs. */
14148 if (CONSTANT_CLASS_P (arg0)
14149 && can_native_interpret_type_p (type)
14150 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0)))
14151 /* This limitation should not be necessary, we just need to
14152 round this up to mode size. */
14153 && tree_to_uhwi (op1) % BITS_PER_UNIT == 0
14154 /* Need bit-shifting of the buffer to relax the following. */
14155 && tree_to_uhwi (op2) % BITS_PER_UNIT == 0)
14157 unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (op2);
14158 unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (op1);
14159 unsigned HOST_WIDE_INT clen;
14160 clen = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0)));
14161 /* ??? We cannot tell native_encode_expr to start at
14162 some random byte only. So limit us to a reasonable amount
14166 unsigned char *b = XALLOCAVEC (unsigned char, clen);
14167 unsigned HOST_WIDE_INT len = native_encode_expr (arg0, b, clen);
14169 && len * BITS_PER_UNIT >= bitpos + bitsize)
14171 tree v = native_interpret_expr (type,
14172 b + bitpos / BITS_PER_UNIT,
14173 bitsize / BITS_PER_UNIT);
14183 /* For integers we can decompose the FMA if possible. */
14184 if (TREE_CODE (arg0) == INTEGER_CST
14185 && TREE_CODE (arg1) == INTEGER_CST)
14186 return fold_build2_loc (loc, PLUS_EXPR, type,
14187 const_binop (MULT_EXPR, arg0, arg1), arg2);
14188 if (integer_zerop (arg2))
14189 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
14191 return fold_fma (loc, type, arg0, arg1, arg2);
14193 case VEC_PERM_EXPR:
14194 if (TREE_CODE (arg2) == VECTOR_CST)
14196 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i, mask, mask2;
14197 unsigned char *sel = XALLOCAVEC (unsigned char, 2 * nelts);
14198 unsigned char *sel2 = sel + nelts;
14199 bool need_mask_canon = false;
14200 bool need_mask_canon2 = false;
14201 bool all_in_vec0 = true;
14202 bool all_in_vec1 = true;
14203 bool maybe_identity = true;
14204 bool single_arg = (op0 == op1);
14205 bool changed = false;
14207 mask2 = 2 * nelts - 1;
14208 mask = single_arg ? (nelts - 1) : mask2;
14209 gcc_assert (nelts == VECTOR_CST_NELTS (arg2));
14210 for (i = 0; i < nelts; i++)
14212 tree val = VECTOR_CST_ELT (arg2, i);
14213 if (TREE_CODE (val) != INTEGER_CST)
14216 /* Make sure that the perm value is in an acceptable
14219 need_mask_canon |= wi::gtu_p (t, mask);
14220 need_mask_canon2 |= wi::gtu_p (t, mask2);
14221 sel[i] = t.to_uhwi () & mask;
14222 sel2[i] = t.to_uhwi () & mask2;
14224 if (sel[i] < nelts)
14225 all_in_vec1 = false;
14227 all_in_vec0 = false;
14229 if ((sel[i] & (nelts-1)) != i)
14230 maybe_identity = false;
14233 if (maybe_identity)
14243 else if (all_in_vec1)
14246 for (i = 0; i < nelts; i++)
14248 need_mask_canon = true;
14251 if ((TREE_CODE (op0) == VECTOR_CST
14252 || TREE_CODE (op0) == CONSTRUCTOR)
14253 && (TREE_CODE (op1) == VECTOR_CST
14254 || TREE_CODE (op1) == CONSTRUCTOR))
14256 tree t = fold_vec_perm (type, op0, op1, sel);
14257 if (t != NULL_TREE)
14261 if (op0 == op1 && !single_arg)
14264 /* Some targets are deficient and fail to expand a single
14265 argument permutation while still allowing an equivalent
14266 2-argument version. */
14267 if (need_mask_canon && arg2 == op2
14268 && !can_vec_perm_p (TYPE_MODE (type), false, sel)
14269 && can_vec_perm_p (TYPE_MODE (type), false, sel2))
14271 need_mask_canon = need_mask_canon2;
14275 if (need_mask_canon && arg2 == op2)
14277 tree *tsel = XALLOCAVEC (tree, nelts);
14278 tree eltype = TREE_TYPE (TREE_TYPE (arg2));
14279 for (i = 0; i < nelts; i++)
14280 tsel[i] = build_int_cst (eltype, sel[i]);
14281 op2 = build_vector (TREE_TYPE (arg2), tsel);
14286 return build3_loc (loc, VEC_PERM_EXPR, type, op0, op1, op2);
14292 } /* switch (code) */
14295 /* Perform constant folding and related simplification of EXPR.
14296 The related simplifications include x*1 => x, x*0 => 0, etc.,
14297 and application of the associative law.
14298 NOP_EXPR conversions may be removed freely (as long as we
14299 are careful not to change the type of the overall expression).
14300 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14301 but we can constant-fold them if they have constant operands. */
14303 #ifdef ENABLE_FOLD_CHECKING
14304 # define fold(x) fold_1 (x)
14305 static tree fold_1 (tree);
14311 const tree t = expr;
14312 enum tree_code code = TREE_CODE (t);
14313 enum tree_code_class kind = TREE_CODE_CLASS (code);
14315 location_t loc = EXPR_LOCATION (expr);
14317 /* Return right away if a constant. */
14318 if (kind == tcc_constant)
14321 /* CALL_EXPR-like objects with variable numbers of operands are
14322 treated specially. */
14323 if (kind == tcc_vl_exp)
14325 if (code == CALL_EXPR)
14327 tem = fold_call_expr (loc, expr, false);
14328 return tem ? tem : expr;
14333 if (IS_EXPR_CODE_CLASS (kind))
14335 tree type = TREE_TYPE (t);
14336 tree op0, op1, op2;
14338 switch (TREE_CODE_LENGTH (code))
14341 op0 = TREE_OPERAND (t, 0);
14342 tem = fold_unary_loc (loc, code, type, op0);
14343 return tem ? tem : expr;
14345 op0 = TREE_OPERAND (t, 0);
14346 op1 = TREE_OPERAND (t, 1);
14347 tem = fold_binary_loc (loc, code, type, op0, op1);
14348 return tem ? tem : expr;
14350 op0 = TREE_OPERAND (t, 0);
14351 op1 = TREE_OPERAND (t, 1);
14352 op2 = TREE_OPERAND (t, 2);
14353 tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
14354 return tem ? tem : expr;
14364 tree op0 = TREE_OPERAND (t, 0);
14365 tree op1 = TREE_OPERAND (t, 1);
14367 if (TREE_CODE (op1) == INTEGER_CST
14368 && TREE_CODE (op0) == CONSTRUCTOR
14369 && ! type_contains_placeholder_p (TREE_TYPE (op0)))
14371 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (op0);
14372 unsigned HOST_WIDE_INT end = vec_safe_length (elts);
14373 unsigned HOST_WIDE_INT begin = 0;
14375 /* Find a matching index by means of a binary search. */
14376 while (begin != end)
14378 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
14379 tree index = (*elts)[middle].index;
14381 if (TREE_CODE (index) == INTEGER_CST
14382 && tree_int_cst_lt (index, op1))
14383 begin = middle + 1;
14384 else if (TREE_CODE (index) == INTEGER_CST
14385 && tree_int_cst_lt (op1, index))
14387 else if (TREE_CODE (index) == RANGE_EXPR
14388 && tree_int_cst_lt (TREE_OPERAND (index, 1), op1))
14389 begin = middle + 1;
14390 else if (TREE_CODE (index) == RANGE_EXPR
14391 && tree_int_cst_lt (op1, TREE_OPERAND (index, 0)))
14394 return (*elts)[middle].value;
14401 /* Return a VECTOR_CST if possible. */
14404 tree type = TREE_TYPE (t);
14405 if (TREE_CODE (type) != VECTOR_TYPE)
14408 tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
14409 unsigned HOST_WIDE_INT idx, pos = 0;
14412 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, value)
14414 if (!CONSTANT_CLASS_P (value))
14416 if (TREE_CODE (value) == VECTOR_CST)
14418 for (unsigned i = 0; i < VECTOR_CST_NELTS (value); ++i)
14419 vec[pos++] = VECTOR_CST_ELT (value, i);
14422 vec[pos++] = value;
14424 for (; pos < TYPE_VECTOR_SUBPARTS (type); ++pos)
14425 vec[pos] = build_zero_cst (TREE_TYPE (type));
14427 return build_vector (type, vec);
14431 return fold (DECL_INITIAL (t));
14435 } /* switch (code) */
14438 #ifdef ENABLE_FOLD_CHECKING
14441 static void fold_checksum_tree (const_tree, struct md5_ctx *,
14442 hash_table<pointer_hash<const tree_node> > *);
14443 static void fold_check_failed (const_tree, const_tree);
14444 void print_fold_checksum (const_tree);
14446 /* When --enable-checking=fold, compute a digest of expr before
14447 and after actual fold call to see if fold did not accidentally
14448 change original expr. */
14454 struct md5_ctx ctx;
14455 unsigned char checksum_before[16], checksum_after[16];
14456 hash_table<pointer_hash<const tree_node> > ht (32);
14458 md5_init_ctx (&ctx);
14459 fold_checksum_tree (expr, &ctx, &ht);
14460 md5_finish_ctx (&ctx, checksum_before);
14463 ret = fold_1 (expr);
14465 md5_init_ctx (&ctx);
14466 fold_checksum_tree (expr, &ctx, &ht);
14467 md5_finish_ctx (&ctx, checksum_after);
14469 if (memcmp (checksum_before, checksum_after, 16))
14470 fold_check_failed (expr, ret);
14476 print_fold_checksum (const_tree expr)
14478 struct md5_ctx ctx;
14479 unsigned char checksum[16], cnt;
14480 hash_table<pointer_hash<const tree_node> > ht (32);
14482 md5_init_ctx (&ctx);
14483 fold_checksum_tree (expr, &ctx, &ht);
14484 md5_finish_ctx (&ctx, checksum);
14485 for (cnt = 0; cnt < 16; ++cnt)
14486 fprintf (stderr, "%02x", checksum[cnt]);
14487 putc ('\n', stderr);
14491 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
14493 internal_error ("fold check: original tree changed by fold");
14497 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx,
14498 hash_table<pointer_hash <const tree_node> > *ht)
14500 const tree_node **slot;
14501 enum tree_code code;
14502 union tree_node buf;
14508 slot = ht->find_slot (expr, INSERT);
14512 code = TREE_CODE (expr);
14513 if (TREE_CODE_CLASS (code) == tcc_declaration
14514 && DECL_ASSEMBLER_NAME_SET_P (expr))
14516 /* Allow DECL_ASSEMBLER_NAME to be modified. */
14517 memcpy ((char *) &buf, expr, tree_size (expr));
14518 SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
14519 expr = (tree) &buf;
14521 else if (TREE_CODE_CLASS (code) == tcc_type
14522 && (TYPE_POINTER_TO (expr)
14523 || TYPE_REFERENCE_TO (expr)
14524 || TYPE_CACHED_VALUES_P (expr)
14525 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
14526 || TYPE_NEXT_VARIANT (expr)))
14528 /* Allow these fields to be modified. */
14530 memcpy ((char *) &buf, expr, tree_size (expr));
14531 expr = tmp = (tree) &buf;
14532 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
14533 TYPE_POINTER_TO (tmp) = NULL;
14534 TYPE_REFERENCE_TO (tmp) = NULL;
14535 TYPE_NEXT_VARIANT (tmp) = NULL;
14536 if (TYPE_CACHED_VALUES_P (tmp))
14538 TYPE_CACHED_VALUES_P (tmp) = 0;
14539 TYPE_CACHED_VALUES (tmp) = NULL;
14542 md5_process_bytes (expr, tree_size (expr), ctx);
14543 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
14544 fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
14545 if (TREE_CODE_CLASS (code) != tcc_type
14546 && TREE_CODE_CLASS (code) != tcc_declaration
14547 && code != TREE_LIST
14548 && code != SSA_NAME
14549 && CODE_CONTAINS_STRUCT (code, TS_COMMON))
14550 fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
14551 switch (TREE_CODE_CLASS (code))
14557 md5_process_bytes (TREE_STRING_POINTER (expr),
14558 TREE_STRING_LENGTH (expr), ctx);
14561 fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
14562 fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
14565 for (i = 0; i < (int) VECTOR_CST_NELTS (expr); ++i)
14566 fold_checksum_tree (VECTOR_CST_ELT (expr, i), ctx, ht);
14572 case tcc_exceptional:
14576 fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
14577 fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
14578 expr = TREE_CHAIN (expr);
14579 goto recursive_label;
14582 for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
14583 fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
14589 case tcc_expression:
14590 case tcc_reference:
14591 case tcc_comparison:
14594 case tcc_statement:
14596 len = TREE_OPERAND_LENGTH (expr);
14597 for (i = 0; i < len; ++i)
14598 fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
14600 case tcc_declaration:
14601 fold_checksum_tree (DECL_NAME (expr), ctx, ht);
14602 fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
14603 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
14605 fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
14606 fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
14607 fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
14608 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
14609 fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
14612 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
14614 if (TREE_CODE (expr) == FUNCTION_DECL)
14616 fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
14617 fold_checksum_tree (DECL_ARGUMENTS (expr), ctx, ht);
14619 fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
14623 if (TREE_CODE (expr) == ENUMERAL_TYPE)
14624 fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
14625 fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
14626 fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
14627 fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
14628 fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
14629 if (INTEGRAL_TYPE_P (expr)
14630 || SCALAR_FLOAT_TYPE_P (expr))
14632 fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
14633 fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
14635 fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
14636 if (TREE_CODE (expr) == RECORD_TYPE
14637 || TREE_CODE (expr) == UNION_TYPE
14638 || TREE_CODE (expr) == QUAL_UNION_TYPE)
14639 fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
14640 fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
14647 /* Helper function for outputting the checksum of a tree T. When
14648 debugging with gdb, you can "define mynext" to be "next" followed
14649 by "call debug_fold_checksum (op0)", then just trace down till the
14652 DEBUG_FUNCTION void
14653 debug_fold_checksum (const_tree t)
14656 unsigned char checksum[16];
14657 struct md5_ctx ctx;
14658 hash_table<pointer_hash<const tree_node> > ht (32);
14660 md5_init_ctx (&ctx);
14661 fold_checksum_tree (t, &ctx, &ht);
14662 md5_finish_ctx (&ctx, checksum);
14665 for (i = 0; i < 16; i++)
14666 fprintf (stderr, "%d ", checksum[i]);
14668 fprintf (stderr, "\n");
14673 /* Fold a unary tree expression with code CODE of type TYPE with an
14674 operand OP0. LOC is the location of the resulting expression.
14675 Return a folded expression if successful. Otherwise, return a tree
14676 expression with code CODE of type TYPE with an operand OP0. */
14679 fold_build1_stat_loc (location_t loc,
14680 enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
14683 #ifdef ENABLE_FOLD_CHECKING
14684 unsigned char checksum_before[16], checksum_after[16];
14685 struct md5_ctx ctx;
14686 hash_table<pointer_hash<const tree_node> > ht (32);
14688 md5_init_ctx (&ctx);
14689 fold_checksum_tree (op0, &ctx, &ht);
14690 md5_finish_ctx (&ctx, checksum_before);
14694 tem = fold_unary_loc (loc, code, type, op0);
14696 tem = build1_stat_loc (loc, code, type, op0 PASS_MEM_STAT);
14698 #ifdef ENABLE_FOLD_CHECKING
14699 md5_init_ctx (&ctx);
14700 fold_checksum_tree (op0, &ctx, &ht);
14701 md5_finish_ctx (&ctx, checksum_after);
14703 if (memcmp (checksum_before, checksum_after, 16))
14704 fold_check_failed (op0, tem);
14709 /* Fold a binary tree expression with code CODE of type TYPE with
14710 operands OP0 and OP1. LOC is the location of the resulting
14711 expression. Return a folded expression if successful. Otherwise,
14712 return a tree expression with code CODE of type TYPE with operands
14716 fold_build2_stat_loc (location_t loc,
14717 enum tree_code code, tree type, tree op0, tree op1
14721 #ifdef ENABLE_FOLD_CHECKING
14722 unsigned char checksum_before_op0[16],
14723 checksum_before_op1[16],
14724 checksum_after_op0[16],
14725 checksum_after_op1[16];
14726 struct md5_ctx ctx;
14727 hash_table<pointer_hash<const tree_node> > ht (32);
14729 md5_init_ctx (&ctx);
14730 fold_checksum_tree (op0, &ctx, &ht);
14731 md5_finish_ctx (&ctx, checksum_before_op0);
14734 md5_init_ctx (&ctx);
14735 fold_checksum_tree (op1, &ctx, &ht);
14736 md5_finish_ctx (&ctx, checksum_before_op1);
14740 tem = fold_binary_loc (loc, code, type, op0, op1);
14742 tem = build2_stat_loc (loc, code, type, op0, op1 PASS_MEM_STAT);
14744 #ifdef ENABLE_FOLD_CHECKING
14745 md5_init_ctx (&ctx);
14746 fold_checksum_tree (op0, &ctx, &ht);
14747 md5_finish_ctx (&ctx, checksum_after_op0);
14750 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14751 fold_check_failed (op0, tem);
14753 md5_init_ctx (&ctx);
14754 fold_checksum_tree (op1, &ctx, &ht);
14755 md5_finish_ctx (&ctx, checksum_after_op1);
14757 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14758 fold_check_failed (op1, tem);
14763 /* Fold a ternary tree expression with code CODE of type TYPE with
14764 operands OP0, OP1, and OP2. Return a folded expression if
14765 successful. Otherwise, return a tree expression with code CODE of
14766 type TYPE with operands OP0, OP1, and OP2. */
14769 fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
14770 tree op0, tree op1, tree op2 MEM_STAT_DECL)
14773 #ifdef ENABLE_FOLD_CHECKING
14774 unsigned char checksum_before_op0[16],
14775 checksum_before_op1[16],
14776 checksum_before_op2[16],
14777 checksum_after_op0[16],
14778 checksum_after_op1[16],
14779 checksum_after_op2[16];
14780 struct md5_ctx ctx;
14781 hash_table<pointer_hash<const tree_node> > ht (32);
14783 md5_init_ctx (&ctx);
14784 fold_checksum_tree (op0, &ctx, &ht);
14785 md5_finish_ctx (&ctx, checksum_before_op0);
14788 md5_init_ctx (&ctx);
14789 fold_checksum_tree (op1, &ctx, &ht);
14790 md5_finish_ctx (&ctx, checksum_before_op1);
14793 md5_init_ctx (&ctx);
14794 fold_checksum_tree (op2, &ctx, &ht);
14795 md5_finish_ctx (&ctx, checksum_before_op2);
14799 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
14800 tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
14802 tem = build3_stat_loc (loc, code, type, op0, op1, op2 PASS_MEM_STAT);
14804 #ifdef ENABLE_FOLD_CHECKING
14805 md5_init_ctx (&ctx);
14806 fold_checksum_tree (op0, &ctx, &ht);
14807 md5_finish_ctx (&ctx, checksum_after_op0);
14810 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
14811 fold_check_failed (op0, tem);
14813 md5_init_ctx (&ctx);
14814 fold_checksum_tree (op1, &ctx, &ht);
14815 md5_finish_ctx (&ctx, checksum_after_op1);
14818 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
14819 fold_check_failed (op1, tem);
14821 md5_init_ctx (&ctx);
14822 fold_checksum_tree (op2, &ctx, &ht);
14823 md5_finish_ctx (&ctx, checksum_after_op2);
14825 if (memcmp (checksum_before_op2, checksum_after_op2, 16))
14826 fold_check_failed (op2, tem);
14831 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14832 arguments in ARGARRAY, and a null static chain.
14833 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14834 of type TYPE from the given operands as constructed by build_call_array. */
14837 fold_build_call_array_loc (location_t loc, tree type, tree fn,
14838 int nargs, tree *argarray)
14841 #ifdef ENABLE_FOLD_CHECKING
14842 unsigned char checksum_before_fn[16],
14843 checksum_before_arglist[16],
14844 checksum_after_fn[16],
14845 checksum_after_arglist[16];
14846 struct md5_ctx ctx;
14847 hash_table<pointer_hash<const tree_node> > ht (32);
14850 md5_init_ctx (&ctx);
14851 fold_checksum_tree (fn, &ctx, &ht);
14852 md5_finish_ctx (&ctx, checksum_before_fn);
14855 md5_init_ctx (&ctx);
14856 for (i = 0; i < nargs; i++)
14857 fold_checksum_tree (argarray[i], &ctx, &ht);
14858 md5_finish_ctx (&ctx, checksum_before_arglist);
14862 tem = fold_builtin_call_array (loc, type, fn, nargs, argarray);
14864 #ifdef ENABLE_FOLD_CHECKING
14865 md5_init_ctx (&ctx);
14866 fold_checksum_tree (fn, &ctx, &ht);
14867 md5_finish_ctx (&ctx, checksum_after_fn);
14870 if (memcmp (checksum_before_fn, checksum_after_fn, 16))
14871 fold_check_failed (fn, tem);
14873 md5_init_ctx (&ctx);
14874 for (i = 0; i < nargs; i++)
14875 fold_checksum_tree (argarray[i], &ctx, &ht);
14876 md5_finish_ctx (&ctx, checksum_after_arglist);
14878 if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
14879 fold_check_failed (NULL_TREE, tem);
14884 /* Perform constant folding and related simplification of initializer
14885 expression EXPR. These behave identically to "fold_buildN" but ignore
14886 potential run-time traps and exceptions that fold must preserve. */
14888 #define START_FOLD_INIT \
14889 int saved_signaling_nans = flag_signaling_nans;\
14890 int saved_trapping_math = flag_trapping_math;\
14891 int saved_rounding_math = flag_rounding_math;\
14892 int saved_trapv = flag_trapv;\
14893 int saved_folding_initializer = folding_initializer;\
14894 flag_signaling_nans = 0;\
14895 flag_trapping_math = 0;\
14896 flag_rounding_math = 0;\
14898 folding_initializer = 1;
14900 #define END_FOLD_INIT \
14901 flag_signaling_nans = saved_signaling_nans;\
14902 flag_trapping_math = saved_trapping_math;\
14903 flag_rounding_math = saved_rounding_math;\
14904 flag_trapv = saved_trapv;\
14905 folding_initializer = saved_folding_initializer;
14908 fold_build1_initializer_loc (location_t loc, enum tree_code code,
14909 tree type, tree op)
14914 result = fold_build1_loc (loc, code, type, op);
14921 fold_build2_initializer_loc (location_t loc, enum tree_code code,
14922 tree type, tree op0, tree op1)
14927 result = fold_build2_loc (loc, code, type, op0, op1);
14934 fold_build_call_array_initializer_loc (location_t loc, tree type, tree fn,
14935 int nargs, tree *argarray)
14940 result = fold_build_call_array_loc (loc, type, fn, nargs, argarray);
14946 #undef START_FOLD_INIT
14947 #undef END_FOLD_INIT
14949 /* Determine if first argument is a multiple of second argument. Return 0 if
14950 it is not, or we cannot easily determined it to be.
14952 An example of the sort of thing we care about (at this point; this routine
14953 could surely be made more general, and expanded to do what the *_DIV_EXPR's
14954 fold cases do now) is discovering that
14956 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14962 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
14964 This code also handles discovering that
14966 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14968 is a multiple of 8 so we don't have to worry about dealing with a
14969 possible remainder.
14971 Note that we *look* inside a SAVE_EXPR only to determine how it was
14972 calculated; it is not safe for fold to do much of anything else with the
14973 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
14974 at run time. For example, the latter example above *cannot* be implemented
14975 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
14976 evaluation time of the original SAVE_EXPR is not necessarily the same at
14977 the time the new expression is evaluated. The only optimization of this
14978 sort that would be valid is changing
14980 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
14984 SAVE_EXPR (I) * SAVE_EXPR (J)
14986 (where the same SAVE_EXPR (J) is used in the original and the
14987 transformed version). */
14990 multiple_of_p (tree type, const_tree top, const_tree bottom)
14992 if (operand_equal_p (top, bottom, 0))
14995 if (TREE_CODE (type) != INTEGER_TYPE)
14998 switch (TREE_CODE (top))
15001 /* Bitwise and provides a power of two multiple. If the mask is
15002 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
15003 if (!integer_pow2p (bottom))
15008 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
15009 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
15013 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
15014 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
15017 if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
15021 op1 = TREE_OPERAND (top, 1);
15022 /* const_binop may not detect overflow correctly,
15023 so check for it explicitly here. */
15024 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node)), op1)
15025 && 0 != (t1 = fold_convert (type,
15026 const_binop (LSHIFT_EXPR,
15029 && !TREE_OVERFLOW (t1))
15030 return multiple_of_p (type, t1, bottom);
15035 /* Can't handle conversions from non-integral or wider integral type. */
15036 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
15037 || (TYPE_PRECISION (type)
15038 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
15041 /* .. fall through ... */
15044 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
15047 return (multiple_of_p (type, TREE_OPERAND (top, 1), bottom)
15048 && multiple_of_p (type, TREE_OPERAND (top, 2), bottom));
15051 if (TREE_CODE (bottom) != INTEGER_CST
15052 || integer_zerop (bottom)
15053 || (TYPE_UNSIGNED (type)
15054 && (tree_int_cst_sgn (top) < 0
15055 || tree_int_cst_sgn (bottom) < 0)))
15057 return wi::multiple_of_p (wi::to_widest (top), wi::to_widest (bottom),
15065 /* Return true if CODE or TYPE is known to be non-negative. */
15068 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
15070 if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
15071 && truth_value_p (code))
15072 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15073 have a signed:1 type (where the value is -1 and 0). */
15078 /* Return true if (CODE OP0) is known to be non-negative. If the return
15079 value is based on the assumption that signed overflow is undefined,
15080 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15081 *STRICT_OVERFLOW_P. */
15084 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
15085 bool *strict_overflow_p)
15087 if (TYPE_UNSIGNED (type))
15093 /* We can't return 1 if flag_wrapv is set because
15094 ABS_EXPR<INT_MIN> = INT_MIN. */
15095 if (!INTEGRAL_TYPE_P (type))
15097 if (TYPE_OVERFLOW_UNDEFINED (type))
15099 *strict_overflow_p = true;
15104 case NON_LVALUE_EXPR:
15106 case FIX_TRUNC_EXPR:
15107 return tree_expr_nonnegative_warnv_p (op0,
15108 strict_overflow_p);
15112 tree inner_type = TREE_TYPE (op0);
15113 tree outer_type = type;
15115 if (TREE_CODE (outer_type) == REAL_TYPE)
15117 if (TREE_CODE (inner_type) == REAL_TYPE)
15118 return tree_expr_nonnegative_warnv_p (op0,
15119 strict_overflow_p);
15120 if (INTEGRAL_TYPE_P (inner_type))
15122 if (TYPE_UNSIGNED (inner_type))
15124 return tree_expr_nonnegative_warnv_p (op0,
15125 strict_overflow_p);
15128 else if (INTEGRAL_TYPE_P (outer_type))
15130 if (TREE_CODE (inner_type) == REAL_TYPE)
15131 return tree_expr_nonnegative_warnv_p (op0,
15132 strict_overflow_p);
15133 if (INTEGRAL_TYPE_P (inner_type))
15134 return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
15135 && TYPE_UNSIGNED (inner_type);
15141 return tree_simple_nonnegative_warnv_p (code, type);
15144 /* We don't know sign of `t', so be conservative and return false. */
15148 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
15149 value is based on the assumption that signed overflow is undefined,
15150 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15151 *STRICT_OVERFLOW_P. */
15154 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
15155 tree op1, bool *strict_overflow_p)
15157 if (TYPE_UNSIGNED (type))
15162 case POINTER_PLUS_EXPR:
15164 if (FLOAT_TYPE_P (type))
15165 return (tree_expr_nonnegative_warnv_p (op0,
15167 && tree_expr_nonnegative_warnv_p (op1,
15168 strict_overflow_p));
15170 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
15171 both unsigned and at least 2 bits shorter than the result. */
15172 if (TREE_CODE (type) == INTEGER_TYPE
15173 && TREE_CODE (op0) == NOP_EXPR
15174 && TREE_CODE (op1) == NOP_EXPR)
15176 tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
15177 tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
15178 if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
15179 && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
15181 unsigned int prec = MAX (TYPE_PRECISION (inner1),
15182 TYPE_PRECISION (inner2)) + 1;
15183 return prec < TYPE_PRECISION (type);
15189 if (FLOAT_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
15191 /* x * x is always non-negative for floating point x
15192 or without overflow. */
15193 if (operand_equal_p (op0, op1, 0)
15194 || (tree_expr_nonnegative_warnv_p (op0, strict_overflow_p)
15195 && tree_expr_nonnegative_warnv_p (op1, strict_overflow_p)))
15197 if (TYPE_OVERFLOW_UNDEFINED (type))
15198 *strict_overflow_p = true;
15203 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
15204 both unsigned and their total bits is shorter than the result. */
15205 if (TREE_CODE (type) == INTEGER_TYPE
15206 && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
15207 && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
15209 tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
15210 ? TREE_TYPE (TREE_OPERAND (op0, 0))
15212 tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
15213 ? TREE_TYPE (TREE_OPERAND (op1, 0))
15216 bool unsigned0 = TYPE_UNSIGNED (inner0);
15217 bool unsigned1 = TYPE_UNSIGNED (inner1);
15219 if (TREE_CODE (op0) == INTEGER_CST)
15220 unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
15222 if (TREE_CODE (op1) == INTEGER_CST)
15223 unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
15225 if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
15226 && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
15228 unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
15229 ? tree_int_cst_min_precision (op0, UNSIGNED)
15230 : TYPE_PRECISION (inner0);
15232 unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
15233 ? tree_int_cst_min_precision (op1, UNSIGNED)
15234 : TYPE_PRECISION (inner1);
15236 return precision0 + precision1 < TYPE_PRECISION (type);
15243 return (tree_expr_nonnegative_warnv_p (op0,
15245 || tree_expr_nonnegative_warnv_p (op1,
15246 strict_overflow_p));
15252 case TRUNC_DIV_EXPR:
15253 case CEIL_DIV_EXPR:
15254 case FLOOR_DIV_EXPR:
15255 case ROUND_DIV_EXPR:
15256 return (tree_expr_nonnegative_warnv_p (op0,
15258 && tree_expr_nonnegative_warnv_p (op1,
15259 strict_overflow_p));
15261 case TRUNC_MOD_EXPR:
15262 case CEIL_MOD_EXPR:
15263 case FLOOR_MOD_EXPR:
15264 case ROUND_MOD_EXPR:
15265 return tree_expr_nonnegative_warnv_p (op0,
15266 strict_overflow_p);
15268 return tree_simple_nonnegative_warnv_p (code, type);
15271 /* We don't know sign of `t', so be conservative and return false. */
15275 /* Return true if T is known to be non-negative. If the return
15276 value is based on the assumption that signed overflow is undefined,
15277 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15278 *STRICT_OVERFLOW_P. */
15281 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15283 if (TYPE_UNSIGNED (TREE_TYPE (t)))
15286 switch (TREE_CODE (t))
15289 return tree_int_cst_sgn (t) >= 0;
15292 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
15295 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
15298 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15300 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
15301 strict_overflow_p));
15303 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
15306 /* We don't know sign of `t', so be conservative and return false. */
15310 /* Return true if T is known to be non-negative. If the return
15311 value is based on the assumption that signed overflow is undefined,
15312 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15313 *STRICT_OVERFLOW_P. */
15316 tree_call_nonnegative_warnv_p (tree type, tree fndecl,
15317 tree arg0, tree arg1, bool *strict_overflow_p)
15319 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
15320 switch (DECL_FUNCTION_CODE (fndecl))
15322 CASE_FLT_FN (BUILT_IN_ACOS):
15323 CASE_FLT_FN (BUILT_IN_ACOSH):
15324 CASE_FLT_FN (BUILT_IN_CABS):
15325 CASE_FLT_FN (BUILT_IN_COSH):
15326 CASE_FLT_FN (BUILT_IN_ERFC):
15327 CASE_FLT_FN (BUILT_IN_EXP):
15328 CASE_FLT_FN (BUILT_IN_EXP10):
15329 CASE_FLT_FN (BUILT_IN_EXP2):
15330 CASE_FLT_FN (BUILT_IN_FABS):
15331 CASE_FLT_FN (BUILT_IN_FDIM):
15332 CASE_FLT_FN (BUILT_IN_HYPOT):
15333 CASE_FLT_FN (BUILT_IN_POW10):
15334 CASE_INT_FN (BUILT_IN_FFS):
15335 CASE_INT_FN (BUILT_IN_PARITY):
15336 CASE_INT_FN (BUILT_IN_POPCOUNT):
15337 CASE_INT_FN (BUILT_IN_CLZ):
15338 CASE_INT_FN (BUILT_IN_CLRSB):
15339 case BUILT_IN_BSWAP32:
15340 case BUILT_IN_BSWAP64:
15344 CASE_FLT_FN (BUILT_IN_SQRT):
15345 /* sqrt(-0.0) is -0.0. */
15346 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
15348 return tree_expr_nonnegative_warnv_p (arg0,
15349 strict_overflow_p);
15351 CASE_FLT_FN (BUILT_IN_ASINH):
15352 CASE_FLT_FN (BUILT_IN_ATAN):
15353 CASE_FLT_FN (BUILT_IN_ATANH):
15354 CASE_FLT_FN (BUILT_IN_CBRT):
15355 CASE_FLT_FN (BUILT_IN_CEIL):
15356 CASE_FLT_FN (BUILT_IN_ERF):
15357 CASE_FLT_FN (BUILT_IN_EXPM1):
15358 CASE_FLT_FN (BUILT_IN_FLOOR):
15359 CASE_FLT_FN (BUILT_IN_FMOD):
15360 CASE_FLT_FN (BUILT_IN_FREXP):
15361 CASE_FLT_FN (BUILT_IN_ICEIL):
15362 CASE_FLT_FN (BUILT_IN_IFLOOR):
15363 CASE_FLT_FN (BUILT_IN_IRINT):
15364 CASE_FLT_FN (BUILT_IN_IROUND):
15365 CASE_FLT_FN (BUILT_IN_LCEIL):
15366 CASE_FLT_FN (BUILT_IN_LDEXP):
15367 CASE_FLT_FN (BUILT_IN_LFLOOR):
15368 CASE_FLT_FN (BUILT_IN_LLCEIL):
15369 CASE_FLT_FN (BUILT_IN_LLFLOOR):
15370 CASE_FLT_FN (BUILT_IN_LLRINT):
15371 CASE_FLT_FN (BUILT_IN_LLROUND):
15372 CASE_FLT_FN (BUILT_IN_LRINT):
15373 CASE_FLT_FN (BUILT_IN_LROUND):
15374 CASE_FLT_FN (BUILT_IN_MODF):
15375 CASE_FLT_FN (BUILT_IN_NEARBYINT):
15376 CASE_FLT_FN (BUILT_IN_RINT):
15377 CASE_FLT_FN (BUILT_IN_ROUND):
15378 CASE_FLT_FN (BUILT_IN_SCALB):
15379 CASE_FLT_FN (BUILT_IN_SCALBLN):
15380 CASE_FLT_FN (BUILT_IN_SCALBN):
15381 CASE_FLT_FN (BUILT_IN_SIGNBIT):
15382 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
15383 CASE_FLT_FN (BUILT_IN_SINH):
15384 CASE_FLT_FN (BUILT_IN_TANH):
15385 CASE_FLT_FN (BUILT_IN_TRUNC):
15386 /* True if the 1st argument is nonnegative. */
15387 return tree_expr_nonnegative_warnv_p (arg0,
15388 strict_overflow_p);
15390 CASE_FLT_FN (BUILT_IN_FMAX):
15391 /* True if the 1st OR 2nd arguments are nonnegative. */
15392 return (tree_expr_nonnegative_warnv_p (arg0,
15394 || (tree_expr_nonnegative_warnv_p (arg1,
15395 strict_overflow_p)));
15397 CASE_FLT_FN (BUILT_IN_FMIN):
15398 /* True if the 1st AND 2nd arguments are nonnegative. */
15399 return (tree_expr_nonnegative_warnv_p (arg0,
15401 && (tree_expr_nonnegative_warnv_p (arg1,
15402 strict_overflow_p)));
15404 CASE_FLT_FN (BUILT_IN_COPYSIGN):
15405 /* True if the 2nd argument is nonnegative. */
15406 return tree_expr_nonnegative_warnv_p (arg1,
15407 strict_overflow_p);
15409 CASE_FLT_FN (BUILT_IN_POWI):
15410 /* True if the 1st argument is nonnegative or the second
15411 argument is an even integer. */
15412 if (TREE_CODE (arg1) == INTEGER_CST
15413 && (TREE_INT_CST_LOW (arg1) & 1) == 0)
15415 return tree_expr_nonnegative_warnv_p (arg0,
15416 strict_overflow_p);
15418 CASE_FLT_FN (BUILT_IN_POW):
15419 /* True if the 1st argument is nonnegative or the second
15420 argument is an even integer valued real. */
15421 if (TREE_CODE (arg1) == REAL_CST)
15426 c = TREE_REAL_CST (arg1);
15427 n = real_to_integer (&c);
15430 REAL_VALUE_TYPE cint;
15431 real_from_integer (&cint, VOIDmode, n, SIGNED);
15432 if (real_identical (&c, &cint))
15436 return tree_expr_nonnegative_warnv_p (arg0,
15437 strict_overflow_p);
15442 return tree_simple_nonnegative_warnv_p (CALL_EXPR,
15446 /* Return true if T is known to be non-negative. If the return
15447 value is based on the assumption that signed overflow is undefined,
15448 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15449 *STRICT_OVERFLOW_P. */
15452 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15454 enum tree_code code = TREE_CODE (t);
15455 if (TYPE_UNSIGNED (TREE_TYPE (t)))
15462 tree temp = TARGET_EXPR_SLOT (t);
15463 t = TARGET_EXPR_INITIAL (t);
15465 /* If the initializer is non-void, then it's a normal expression
15466 that will be assigned to the slot. */
15467 if (!VOID_TYPE_P (t))
15468 return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
15470 /* Otherwise, the initializer sets the slot in some way. One common
15471 way is an assignment statement at the end of the initializer. */
15474 if (TREE_CODE (t) == BIND_EXPR)
15475 t = expr_last (BIND_EXPR_BODY (t));
15476 else if (TREE_CODE (t) == TRY_FINALLY_EXPR
15477 || TREE_CODE (t) == TRY_CATCH_EXPR)
15478 t = expr_last (TREE_OPERAND (t, 0));
15479 else if (TREE_CODE (t) == STATEMENT_LIST)
15484 if (TREE_CODE (t) == MODIFY_EXPR
15485 && TREE_OPERAND (t, 0) == temp)
15486 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15487 strict_overflow_p);
15494 tree arg0 = call_expr_nargs (t) > 0 ? CALL_EXPR_ARG (t, 0) : NULL_TREE;
15495 tree arg1 = call_expr_nargs (t) > 1 ? CALL_EXPR_ARG (t, 1) : NULL_TREE;
15497 return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
15498 get_callee_fndecl (t),
15501 strict_overflow_p);
15503 case COMPOUND_EXPR:
15505 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15506 strict_overflow_p);
15508 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
15509 strict_overflow_p);
15511 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
15512 strict_overflow_p);
15515 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
15519 /* We don't know sign of `t', so be conservative and return false. */
15523 /* Return true if T is known to be non-negative. If the return
15524 value is based on the assumption that signed overflow is undefined,
15525 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15526 *STRICT_OVERFLOW_P. */
15529 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15531 enum tree_code code;
15532 if (t == error_mark_node)
15535 code = TREE_CODE (t);
15536 switch (TREE_CODE_CLASS (code))
15539 case tcc_comparison:
15540 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
15542 TREE_OPERAND (t, 0),
15543 TREE_OPERAND (t, 1),
15544 strict_overflow_p);
15547 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
15549 TREE_OPERAND (t, 0),
15550 strict_overflow_p);
15553 case tcc_declaration:
15554 case tcc_reference:
15555 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
15563 case TRUTH_AND_EXPR:
15564 case TRUTH_OR_EXPR:
15565 case TRUTH_XOR_EXPR:
15566 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
15568 TREE_OPERAND (t, 0),
15569 TREE_OPERAND (t, 1),
15570 strict_overflow_p);
15571 case TRUTH_NOT_EXPR:
15572 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
15574 TREE_OPERAND (t, 0),
15575 strict_overflow_p);
15582 case WITH_SIZE_EXPR:
15584 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
15587 return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
15591 /* Return true if `t' is known to be non-negative. Handle warnings
15592 about undefined signed overflow. */
15595 tree_expr_nonnegative_p (tree t)
15597 bool ret, strict_overflow_p;
15599 strict_overflow_p = false;
15600 ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
15601 if (strict_overflow_p)
15602 fold_overflow_warning (("assuming signed overflow does not occur when "
15603 "determining that expression is always "
15605 WARN_STRICT_OVERFLOW_MISC);
15610 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15611 For floating point we further ensure that T is not denormal.
15612 Similar logic is present in nonzero_address in rtlanal.h.
15614 If the return value is based on the assumption that signed overflow
15615 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15616 change *STRICT_OVERFLOW_P. */
15619 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
15620 bool *strict_overflow_p)
15625 return tree_expr_nonzero_warnv_p (op0,
15626 strict_overflow_p);
15630 tree inner_type = TREE_TYPE (op0);
15631 tree outer_type = type;
15633 return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
15634 && tree_expr_nonzero_warnv_p (op0,
15635 strict_overflow_p));
15639 case NON_LVALUE_EXPR:
15640 return tree_expr_nonzero_warnv_p (op0,
15641 strict_overflow_p);
15650 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15651 For floating point we further ensure that T is not denormal.
15652 Similar logic is present in nonzero_address in rtlanal.h.
15654 If the return value is based on the assumption that signed overflow
15655 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15656 change *STRICT_OVERFLOW_P. */
15659 tree_binary_nonzero_warnv_p (enum tree_code code,
15662 tree op1, bool *strict_overflow_p)
15664 bool sub_strict_overflow_p;
15667 case POINTER_PLUS_EXPR:
15669 if (TYPE_OVERFLOW_UNDEFINED (type))
15671 /* With the presence of negative values it is hard
15672 to say something. */
15673 sub_strict_overflow_p = false;
15674 if (!tree_expr_nonnegative_warnv_p (op0,
15675 &sub_strict_overflow_p)
15676 || !tree_expr_nonnegative_warnv_p (op1,
15677 &sub_strict_overflow_p))
15679 /* One of operands must be positive and the other non-negative. */
15680 /* We don't set *STRICT_OVERFLOW_P here: even if this value
15681 overflows, on a twos-complement machine the sum of two
15682 nonnegative numbers can never be zero. */
15683 return (tree_expr_nonzero_warnv_p (op0,
15685 || tree_expr_nonzero_warnv_p (op1,
15686 strict_overflow_p));
15691 if (TYPE_OVERFLOW_UNDEFINED (type))
15693 if (tree_expr_nonzero_warnv_p (op0,
15695 && tree_expr_nonzero_warnv_p (op1,
15696 strict_overflow_p))
15698 *strict_overflow_p = true;
15705 sub_strict_overflow_p = false;
15706 if (tree_expr_nonzero_warnv_p (op0,
15707 &sub_strict_overflow_p)
15708 && tree_expr_nonzero_warnv_p (op1,
15709 &sub_strict_overflow_p))
15711 if (sub_strict_overflow_p)
15712 *strict_overflow_p = true;
15717 sub_strict_overflow_p = false;
15718 if (tree_expr_nonzero_warnv_p (op0,
15719 &sub_strict_overflow_p))
15721 if (sub_strict_overflow_p)
15722 *strict_overflow_p = true;
15724 /* When both operands are nonzero, then MAX must be too. */
15725 if (tree_expr_nonzero_warnv_p (op1,
15726 strict_overflow_p))
15729 /* MAX where operand 0 is positive is positive. */
15730 return tree_expr_nonnegative_warnv_p (op0,
15731 strict_overflow_p);
15733 /* MAX where operand 1 is positive is positive. */
15734 else if (tree_expr_nonzero_warnv_p (op1,
15735 &sub_strict_overflow_p)
15736 && tree_expr_nonnegative_warnv_p (op1,
15737 &sub_strict_overflow_p))
15739 if (sub_strict_overflow_p)
15740 *strict_overflow_p = true;
15746 return (tree_expr_nonzero_warnv_p (op1,
15748 || tree_expr_nonzero_warnv_p (op0,
15749 strict_overflow_p));
15758 /* Return true when T is an address and is known to be nonzero.
15759 For floating point we further ensure that T is not denormal.
15760 Similar logic is present in nonzero_address in rtlanal.h.
15762 If the return value is based on the assumption that signed overflow
15763 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15764 change *STRICT_OVERFLOW_P. */
15767 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
15769 bool sub_strict_overflow_p;
15770 switch (TREE_CODE (t))
15773 return !integer_zerop (t);
15777 tree base = TREE_OPERAND (t, 0);
15779 if (!DECL_P (base))
15780 base = get_base_address (base);
15785 /* For objects in symbol table check if we know they are non-zero.
15786 Don't do anything for variables and functions before symtab is built;
15787 it is quite possible that they will be declared weak later. */
15788 if (DECL_P (base) && decl_in_symtab_p (base))
15790 struct symtab_node *symbol;
15792 symbol = symtab_node::get_create (base);
15794 return symbol->nonzero_address ();
15799 /* Function local objects are never NULL. */
15801 && (DECL_CONTEXT (base)
15802 && TREE_CODE (DECL_CONTEXT (base)) == FUNCTION_DECL
15803 && auto_var_in_fn_p (base, DECL_CONTEXT (base))))
15806 /* Constants are never weak. */
15807 if (CONSTANT_CLASS_P (base))
15814 sub_strict_overflow_p = false;
15815 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
15816 &sub_strict_overflow_p)
15817 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
15818 &sub_strict_overflow_p))
15820 if (sub_strict_overflow_p)
15821 *strict_overflow_p = true;
15832 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15833 attempt to fold the expression to a constant without modifying TYPE,
15836 If the expression could be simplified to a constant, then return
15837 the constant. If the expression would not be simplified to a
15838 constant, then return NULL_TREE. */
15841 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
15843 tree tem = fold_binary (code, type, op0, op1);
15844 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15847 /* Given the components of a unary expression CODE, TYPE and OP0,
15848 attempt to fold the expression to a constant without modifying
15851 If the expression could be simplified to a constant, then return
15852 the constant. If the expression would not be simplified to a
15853 constant, then return NULL_TREE. */
15856 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
15858 tree tem = fold_unary (code, type, op0);
15859 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
15862 /* If EXP represents referencing an element in a constant string
15863 (either via pointer arithmetic or array indexing), return the
15864 tree representing the value accessed, otherwise return NULL. */
15867 fold_read_from_constant_string (tree exp)
15869 if ((TREE_CODE (exp) == INDIRECT_REF
15870 || TREE_CODE (exp) == ARRAY_REF)
15871 && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
15873 tree exp1 = TREE_OPERAND (exp, 0);
15876 location_t loc = EXPR_LOCATION (exp);
15878 if (TREE_CODE (exp) == INDIRECT_REF)
15879 string = string_constant (exp1, &index);
15882 tree low_bound = array_ref_low_bound (exp);
15883 index = fold_convert_loc (loc, sizetype, TREE_OPERAND (exp, 1));
15885 /* Optimize the special-case of a zero lower bound.
15887 We convert the low_bound to sizetype to avoid some problems
15888 with constant folding. (E.g. suppose the lower bound is 1,
15889 and its mode is QI. Without the conversion,l (ARRAY
15890 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15891 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15892 if (! integer_zerop (low_bound))
15893 index = size_diffop_loc (loc, index,
15894 fold_convert_loc (loc, sizetype, low_bound));
15900 && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
15901 && TREE_CODE (string) == STRING_CST
15902 && TREE_CODE (index) == INTEGER_CST
15903 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
15904 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
15906 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
15907 return build_int_cst_type (TREE_TYPE (exp),
15908 (TREE_STRING_POINTER (string)
15909 [TREE_INT_CST_LOW (index)]));
15914 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15915 an integer constant, real, or fixed-point constant.
15917 TYPE is the type of the result. */
15920 fold_negate_const (tree arg0, tree type)
15922 tree t = NULL_TREE;
15924 switch (TREE_CODE (arg0))
15929 wide_int val = wi::neg (arg0, &overflow);
15930 t = force_fit_type (type, val, 1,
15931 (overflow | TREE_OVERFLOW (arg0))
15932 && !TYPE_UNSIGNED (type));
15937 t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
15942 FIXED_VALUE_TYPE f;
15943 bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
15944 &(TREE_FIXED_CST (arg0)), NULL,
15945 TYPE_SATURATING (type));
15946 t = build_fixed (type, f);
15947 /* Propagate overflow flags. */
15948 if (overflow_p | TREE_OVERFLOW (arg0))
15949 TREE_OVERFLOW (t) = 1;
15954 gcc_unreachable ();
15960 /* Return the tree for abs (ARG0) when ARG0 is known to be either
15961 an integer constant or real constant.
15963 TYPE is the type of the result. */
15966 fold_abs_const (tree arg0, tree type)
15968 tree t = NULL_TREE;
15970 switch (TREE_CODE (arg0))
15974 /* If the value is unsigned or non-negative, then the absolute value
15975 is the same as the ordinary value. */
15976 if (!wi::neg_p (arg0, TYPE_SIGN (type)))
15979 /* If the value is negative, then the absolute value is
15984 wide_int val = wi::neg (arg0, &overflow);
15985 t = force_fit_type (type, val, -1,
15986 overflow | TREE_OVERFLOW (arg0));
15992 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
15993 t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
15999 gcc_unreachable ();
16005 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
16006 constant. TYPE is the type of the result. */
16009 fold_not_const (const_tree arg0, tree type)
16011 gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
16013 return force_fit_type (type, wi::bit_not (arg0), 0, TREE_OVERFLOW (arg0));
16016 /* Given CODE, a relational operator, the target type, TYPE and two
16017 constant operands OP0 and OP1, return the result of the
16018 relational operation. If the result is not a compile time
16019 constant, then return NULL_TREE. */
16022 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
16024 int result, invert;
16026 /* From here on, the only cases we handle are when the result is
16027 known to be a constant. */
16029 if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
16031 const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
16032 const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
16034 /* Handle the cases where either operand is a NaN. */
16035 if (real_isnan (c0) || real_isnan (c1))
16045 case UNORDERED_EXPR:
16059 if (flag_trapping_math)
16065 gcc_unreachable ();
16068 return constant_boolean_node (result, type);
16071 return constant_boolean_node (real_compare (code, c0, c1), type);
16074 if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
16076 const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
16077 const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
16078 return constant_boolean_node (fixed_compare (code, c0, c1), type);
16081 /* Handle equality/inequality of complex constants. */
16082 if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
16084 tree rcond = fold_relational_const (code, type,
16085 TREE_REALPART (op0),
16086 TREE_REALPART (op1));
16087 tree icond = fold_relational_const (code, type,
16088 TREE_IMAGPART (op0),
16089 TREE_IMAGPART (op1));
16090 if (code == EQ_EXPR)
16091 return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
16092 else if (code == NE_EXPR)
16093 return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
16098 if (TREE_CODE (op0) == VECTOR_CST && TREE_CODE (op1) == VECTOR_CST)
16100 unsigned count = VECTOR_CST_NELTS (op0);
16101 tree *elts = XALLOCAVEC (tree, count);
16102 gcc_assert (VECTOR_CST_NELTS (op1) == count
16103 && TYPE_VECTOR_SUBPARTS (type) == count);
16105 for (unsigned i = 0; i < count; i++)
16107 tree elem_type = TREE_TYPE (type);
16108 tree elem0 = VECTOR_CST_ELT (op0, i);
16109 tree elem1 = VECTOR_CST_ELT (op1, i);
16111 tree tem = fold_relational_const (code, elem_type,
16114 if (tem == NULL_TREE)
16117 elts[i] = build_int_cst (elem_type, integer_zerop (tem) ? 0 : -1);
16120 return build_vector (type, elts);
16123 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16125 To compute GT, swap the arguments and do LT.
16126 To compute GE, do LT and invert the result.
16127 To compute LE, swap the arguments, do LT and invert the result.
16128 To compute NE, do EQ and invert the result.
16130 Therefore, the code below must handle only EQ and LT. */
16132 if (code == LE_EXPR || code == GT_EXPR)
16137 code = swap_tree_comparison (code);
16140 /* Note that it is safe to invert for real values here because we
16141 have already handled the one case that it matters. */
16144 if (code == NE_EXPR || code == GE_EXPR)
16147 code = invert_tree_comparison (code, false);
16150 /* Compute a result for LT or EQ if args permit;
16151 Otherwise return T. */
16152 if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
16154 if (code == EQ_EXPR)
16155 result = tree_int_cst_equal (op0, op1);
16157 result = tree_int_cst_lt (op0, op1);
16164 return constant_boolean_node (result, type);
16167 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16168 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16172 fold_build_cleanup_point_expr (tree type, tree expr)
16174 /* If the expression does not have side effects then we don't have to wrap
16175 it with a cleanup point expression. */
16176 if (!TREE_SIDE_EFFECTS (expr))
16179 /* If the expression is a return, check to see if the expression inside the
16180 return has no side effects or the right hand side of the modify expression
16181 inside the return. If either don't have side effects set we don't need to
16182 wrap the expression in a cleanup point expression. Note we don't check the
16183 left hand side of the modify because it should always be a return decl. */
16184 if (TREE_CODE (expr) == RETURN_EXPR)
16186 tree op = TREE_OPERAND (expr, 0);
16187 if (!op || !TREE_SIDE_EFFECTS (op))
16189 op = TREE_OPERAND (op, 1);
16190 if (!TREE_SIDE_EFFECTS (op))
16194 return build1 (CLEANUP_POINT_EXPR, type, expr);
16197 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16198 of an indirection through OP0, or NULL_TREE if no simplification is
16202 fold_indirect_ref_1 (location_t loc, tree type, tree op0)
16208 subtype = TREE_TYPE (sub);
16209 if (!POINTER_TYPE_P (subtype))
16212 if (TREE_CODE (sub) == ADDR_EXPR)
16214 tree op = TREE_OPERAND (sub, 0);
16215 tree optype = TREE_TYPE (op);
16216 /* *&CONST_DECL -> to the value of the const decl. */
16217 if (TREE_CODE (op) == CONST_DECL)
16218 return DECL_INITIAL (op);
16219 /* *&p => p; make sure to handle *&"str"[cst] here. */
16220 if (type == optype)
16222 tree fop = fold_read_from_constant_string (op);
16228 /* *(foo *)&fooarray => fooarray[0] */
16229 else if (TREE_CODE (optype) == ARRAY_TYPE
16230 && type == TREE_TYPE (optype)
16231 && (!in_gimple_form
16232 || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
16234 tree type_domain = TYPE_DOMAIN (optype);
16235 tree min_val = size_zero_node;
16236 if (type_domain && TYPE_MIN_VALUE (type_domain))
16237 min_val = TYPE_MIN_VALUE (type_domain);
16239 && TREE_CODE (min_val) != INTEGER_CST)
16241 return build4_loc (loc, ARRAY_REF, type, op, min_val,
16242 NULL_TREE, NULL_TREE);
16244 /* *(foo *)&complexfoo => __real__ complexfoo */
16245 else if (TREE_CODE (optype) == COMPLEX_TYPE
16246 && type == TREE_TYPE (optype))
16247 return fold_build1_loc (loc, REALPART_EXPR, type, op);
16248 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16249 else if (TREE_CODE (optype) == VECTOR_TYPE
16250 && type == TREE_TYPE (optype))
16252 tree part_width = TYPE_SIZE (type);
16253 tree index = bitsize_int (0);
16254 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
16258 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
16259 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
16261 tree op00 = TREE_OPERAND (sub, 0);
16262 tree op01 = TREE_OPERAND (sub, 1);
16265 if (TREE_CODE (op00) == ADDR_EXPR)
16268 op00 = TREE_OPERAND (op00, 0);
16269 op00type = TREE_TYPE (op00);
16271 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16272 if (TREE_CODE (op00type) == VECTOR_TYPE
16273 && type == TREE_TYPE (op00type))
16275 HOST_WIDE_INT offset = tree_to_shwi (op01);
16276 tree part_width = TYPE_SIZE (type);
16277 unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
16278 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
16279 tree index = bitsize_int (indexi);
16281 if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
16282 return fold_build3_loc (loc,
16283 BIT_FIELD_REF, type, op00,
16284 part_width, index);
16287 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16288 else if (TREE_CODE (op00type) == COMPLEX_TYPE
16289 && type == TREE_TYPE (op00type))
16291 tree size = TYPE_SIZE_UNIT (type);
16292 if (tree_int_cst_equal (size, op01))
16293 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
16295 /* ((foo *)&fooarray)[1] => fooarray[1] */
16296 else if (TREE_CODE (op00type) == ARRAY_TYPE
16297 && type == TREE_TYPE (op00type))
16299 tree type_domain = TYPE_DOMAIN (op00type);
16300 tree min_val = size_zero_node;
16301 if (type_domain && TYPE_MIN_VALUE (type_domain))
16302 min_val = TYPE_MIN_VALUE (type_domain);
16303 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
16304 TYPE_SIZE_UNIT (type));
16305 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
16306 return build4_loc (loc, ARRAY_REF, type, op00, op01,
16307 NULL_TREE, NULL_TREE);
16312 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16313 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
16314 && type == TREE_TYPE (TREE_TYPE (subtype))
16315 && (!in_gimple_form
16316 || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
16319 tree min_val = size_zero_node;
16320 sub = build_fold_indirect_ref_loc (loc, sub);
16321 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
16322 if (type_domain && TYPE_MIN_VALUE (type_domain))
16323 min_val = TYPE_MIN_VALUE (type_domain);
16325 && TREE_CODE (min_val) != INTEGER_CST)
16327 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
16334 /* Builds an expression for an indirection through T, simplifying some
16338 build_fold_indirect_ref_loc (location_t loc, tree t)
16340 tree type = TREE_TYPE (TREE_TYPE (t));
16341 tree sub = fold_indirect_ref_1 (loc, type, t);
16346 return build1_loc (loc, INDIRECT_REF, type, t);
16349 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16352 fold_indirect_ref_loc (location_t loc, tree t)
16354 tree sub = fold_indirect_ref_1 (loc, TREE_TYPE (t), TREE_OPERAND (t, 0));
16362 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16363 whose result is ignored. The type of the returned tree need not be
16364 the same as the original expression. */
16367 fold_ignored_result (tree t)
16369 if (!TREE_SIDE_EFFECTS (t))
16370 return integer_zero_node;
16373 switch (TREE_CODE_CLASS (TREE_CODE (t)))
16376 t = TREE_OPERAND (t, 0);
16380 case tcc_comparison:
16381 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
16382 t = TREE_OPERAND (t, 0);
16383 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
16384 t = TREE_OPERAND (t, 1);
16389 case tcc_expression:
16390 switch (TREE_CODE (t))
16392 case COMPOUND_EXPR:
16393 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
16395 t = TREE_OPERAND (t, 0);
16399 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
16400 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
16402 t = TREE_OPERAND (t, 0);
16415 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
16418 round_up_loc (location_t loc, tree value, unsigned int divisor)
16420 tree div = NULL_TREE;
16425 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16426 have to do anything. Only do this when we are not given a const,
16427 because in that case, this check is more expensive than just
16429 if (TREE_CODE (value) != INTEGER_CST)
16431 div = build_int_cst (TREE_TYPE (value), divisor);
16433 if (multiple_of_p (TREE_TYPE (value), value, div))
16437 /* If divisor is a power of two, simplify this to bit manipulation. */
16438 if (divisor == (divisor & -divisor))
16440 if (TREE_CODE (value) == INTEGER_CST)
16442 wide_int val = value;
16445 if ((val & (divisor - 1)) == 0)
16448 overflow_p = TREE_OVERFLOW (value);
16449 val &= ~(divisor - 1);
16454 return force_fit_type (TREE_TYPE (value), val, -1, overflow_p);
16460 t = build_int_cst (TREE_TYPE (value), divisor - 1);
16461 value = size_binop_loc (loc, PLUS_EXPR, value, t);
16462 t = build_int_cst (TREE_TYPE (value), -divisor);
16463 value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
16469 div = build_int_cst (TREE_TYPE (value), divisor);
16470 value = size_binop_loc (loc, CEIL_DIV_EXPR, value, div);
16471 value = size_binop_loc (loc, MULT_EXPR, value, div);
16477 /* Likewise, but round down. */
16480 round_down_loc (location_t loc, tree value, int divisor)
16482 tree div = NULL_TREE;
16484 gcc_assert (divisor > 0);
16488 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16489 have to do anything. Only do this when we are not given a const,
16490 because in that case, this check is more expensive than just
16492 if (TREE_CODE (value) != INTEGER_CST)
16494 div = build_int_cst (TREE_TYPE (value), divisor);
16496 if (multiple_of_p (TREE_TYPE (value), value, div))
16500 /* If divisor is a power of two, simplify this to bit manipulation. */
16501 if (divisor == (divisor & -divisor))
16505 t = build_int_cst (TREE_TYPE (value), -divisor);
16506 value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
16511 div = build_int_cst (TREE_TYPE (value), divisor);
16512 value = size_binop_loc (loc, FLOOR_DIV_EXPR, value, div);
16513 value = size_binop_loc (loc, MULT_EXPR, value, div);
16519 /* Returns the pointer to the base of the object addressed by EXP and
16520 extracts the information about the offset of the access, storing it
16521 to PBITPOS and POFFSET. */
16524 split_address_to_core_and_offset (tree exp,
16525 HOST_WIDE_INT *pbitpos, tree *poffset)
16529 int unsignedp, volatilep;
16530 HOST_WIDE_INT bitsize;
16531 location_t loc = EXPR_LOCATION (exp);
16533 if (TREE_CODE (exp) == ADDR_EXPR)
16535 core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
16536 poffset, &mode, &unsignedp, &volatilep,
16538 core = build_fold_addr_expr_loc (loc, core);
16544 *poffset = NULL_TREE;
16550 /* Returns true if addresses of E1 and E2 differ by a constant, false
16551 otherwise. If they do, E1 - E2 is stored in *DIFF. */
16554 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
16557 HOST_WIDE_INT bitpos1, bitpos2;
16558 tree toffset1, toffset2, tdiff, type;
16560 core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
16561 core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
16563 if (bitpos1 % BITS_PER_UNIT != 0
16564 || bitpos2 % BITS_PER_UNIT != 0
16565 || !operand_equal_p (core1, core2, 0))
16568 if (toffset1 && toffset2)
16570 type = TREE_TYPE (toffset1);
16571 if (type != TREE_TYPE (toffset2))
16572 toffset2 = fold_convert (type, toffset2);
16574 tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
16575 if (!cst_and_fits_in_hwi (tdiff))
16578 *diff = int_cst_value (tdiff);
16580 else if (toffset1 || toffset2)
16582 /* If only one of the offsets is non-constant, the difference cannot
16589 *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
16593 /* Simplify the floating point expression EXP when the sign of the
16594 result is not significant. Return NULL_TREE if no simplification
16598 fold_strip_sign_ops (tree exp)
16601 location_t loc = EXPR_LOCATION (exp);
16603 switch (TREE_CODE (exp))
16607 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
16608 return arg0 ? arg0 : TREE_OPERAND (exp, 0);
16612 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
16614 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
16615 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16616 if (arg0 != NULL_TREE || arg1 != NULL_TREE)
16617 return fold_build2_loc (loc, TREE_CODE (exp), TREE_TYPE (exp),
16618 arg0 ? arg0 : TREE_OPERAND (exp, 0),
16619 arg1 ? arg1 : TREE_OPERAND (exp, 1));
16622 case COMPOUND_EXPR:
16623 arg0 = TREE_OPERAND (exp, 0);
16624 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16626 return fold_build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
16630 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
16631 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
16633 return fold_build3_loc (loc,
16634 COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
16635 arg0 ? arg0 : TREE_OPERAND (exp, 1),
16636 arg1 ? arg1 : TREE_OPERAND (exp, 2));
16641 const enum built_in_function fcode = builtin_mathfn_code (exp);
16644 CASE_FLT_FN (BUILT_IN_COPYSIGN):
16645 /* Strip copysign function call, return the 1st argument. */
16646 arg0 = CALL_EXPR_ARG (exp, 0);
16647 arg1 = CALL_EXPR_ARG (exp, 1);
16648 return omit_one_operand_loc (loc, TREE_TYPE (exp), arg0, arg1);
16651 /* Strip sign ops from the argument of "odd" math functions. */
16652 if (negate_mathfn_p (fcode))
16654 arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
16656 return build_call_expr_loc (loc, get_callee_fndecl (exp), 1, arg0);