1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2017 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"
54 #include "tree-ssa-operands.h"
55 #include "optabs-query.h"
57 #include "diagnostic-core.h"
60 #include "fold-const.h"
61 #include "fold-const-call.h"
62 #include "stor-layout.h"
64 #include "tree-iterator.h"
67 #include "langhooks.h"
72 #include "generic-match.h"
73 #include "gimple-fold.h"
75 #include "tree-into-ssa.h"
77 #include "case-cfn-macros.h"
78 #include "stringpool.h"
80 #include "tree-ssanames.h"
83 /* Nonzero if we are folding constants inside an initializer; zero
85 int folding_initializer
= 0;
87 /* The following constants represent a bit based encoding of GCC's
88 comparison operators. This encoding simplifies transformations
89 on relational comparison operators, such as AND and OR. */
90 enum comparison_code
{
109 static bool negate_expr_p (tree
);
110 static tree
negate_expr (tree
);
111 static tree
split_tree (location_t
, tree
, tree
, enum tree_code
,
112 tree
*, tree
*, tree
*, int);
113 static tree
associate_trees (location_t
, tree
, tree
, enum tree_code
, tree
);
114 static enum comparison_code
comparison_to_compcode (enum tree_code
);
115 static enum tree_code
compcode_to_comparison (enum comparison_code
);
116 static int operand_equal_for_comparison_p (tree
, tree
, tree
);
117 static int twoval_comparison_p (tree
, tree
*, tree
*, int *);
118 static tree
eval_subst (location_t
, tree
, tree
, tree
, tree
, tree
);
119 static tree
optimize_bit_field_compare (location_t
, enum tree_code
,
121 static int simple_operand_p (const_tree
);
122 static bool simple_operand_p_2 (tree
);
123 static tree
range_binop (enum tree_code
, tree
, tree
, int, tree
, int);
124 static tree
range_predecessor (tree
);
125 static tree
range_successor (tree
);
126 static tree
fold_range_test (location_t
, enum tree_code
, tree
, tree
, tree
);
127 static tree
fold_cond_expr_with_comparison (location_t
, tree
, tree
, tree
, tree
);
128 static tree
unextend (tree
, int, int, tree
);
129 static tree
extract_muldiv (tree
, tree
, enum tree_code
, tree
, bool *);
130 static tree
extract_muldiv_1 (tree
, tree
, enum tree_code
, tree
, bool *);
131 static tree
fold_binary_op_with_conditional_arg (location_t
,
132 enum tree_code
, tree
,
135 static tree
fold_div_compare (location_t
, enum tree_code
, tree
, tree
, tree
);
136 static tree
fold_negate_const (tree
, tree
);
137 static tree
fold_not_const (const_tree
, tree
);
138 static tree
fold_relational_const (enum tree_code
, tree
, tree
, tree
);
139 static tree
fold_convert_const (enum tree_code
, tree
, tree
);
140 static tree
fold_view_convert_expr (tree
, tree
);
141 static bool vec_cst_ctor_to_array (tree
, tree
*);
144 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
145 Otherwise, return LOC. */
148 expr_location_or (tree t
, location_t loc
)
150 location_t tloc
= EXPR_LOCATION (t
);
151 return tloc
== UNKNOWN_LOCATION
? loc
: tloc
;
154 /* Similar to protected_set_expr_location, but never modify x in place,
155 if location can and needs to be set, unshare it. */
158 protected_set_expr_location_unshare (tree x
, location_t loc
)
160 if (CAN_HAVE_LOCATION_P (x
)
161 && EXPR_LOCATION (x
) != loc
162 && !(TREE_CODE (x
) == SAVE_EXPR
163 || TREE_CODE (x
) == TARGET_EXPR
164 || TREE_CODE (x
) == BIND_EXPR
))
167 SET_EXPR_LOCATION (x
, loc
);
172 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
173 division and returns the quotient. Otherwise returns
177 div_if_zero_remainder (const_tree arg1
, const_tree arg2
)
181 if (wi::multiple_of_p (wi::to_widest (arg1
), wi::to_widest (arg2
),
183 return wide_int_to_tree (TREE_TYPE (arg1
), quo
);
188 /* This is nonzero if we should defer warnings about undefined
189 overflow. This facility exists because these warnings are a
190 special case. The code to estimate loop iterations does not want
191 to issue any warnings, since it works with expressions which do not
192 occur in user code. Various bits of cleanup code call fold(), but
193 only use the result if it has certain characteristics (e.g., is a
194 constant); that code only wants to issue a warning if the result is
197 static int fold_deferring_overflow_warnings
;
199 /* If a warning about undefined overflow is deferred, this is the
200 warning. Note that this may cause us to turn two warnings into
201 one, but that is fine since it is sufficient to only give one
202 warning per expression. */
204 static const char* fold_deferred_overflow_warning
;
206 /* If a warning about undefined overflow is deferred, this is the
207 level at which the warning should be emitted. */
209 static enum warn_strict_overflow_code fold_deferred_overflow_code
;
211 /* Start deferring overflow warnings. We could use a stack here to
212 permit nested calls, but at present it is not necessary. */
215 fold_defer_overflow_warnings (void)
217 ++fold_deferring_overflow_warnings
;
220 /* Stop deferring overflow warnings. If there is a pending warning,
221 and ISSUE is true, then issue the warning if appropriate. STMT is
222 the statement with which the warning should be associated (used for
223 location information); STMT may be NULL. CODE is the level of the
224 warning--a warn_strict_overflow_code value. This function will use
225 the smaller of CODE and the deferred code when deciding whether to
226 issue the warning. CODE may be zero to mean to always use the
230 fold_undefer_overflow_warnings (bool issue
, const gimple
*stmt
, int code
)
235 gcc_assert (fold_deferring_overflow_warnings
> 0);
236 --fold_deferring_overflow_warnings
;
237 if (fold_deferring_overflow_warnings
> 0)
239 if (fold_deferred_overflow_warning
!= NULL
241 && code
< (int) fold_deferred_overflow_code
)
242 fold_deferred_overflow_code
= (enum warn_strict_overflow_code
) code
;
246 warnmsg
= fold_deferred_overflow_warning
;
247 fold_deferred_overflow_warning
= NULL
;
249 if (!issue
|| warnmsg
== NULL
)
252 if (gimple_no_warning_p (stmt
))
255 /* Use the smallest code level when deciding to issue the
257 if (code
== 0 || code
> (int) fold_deferred_overflow_code
)
258 code
= fold_deferred_overflow_code
;
260 if (!issue_strict_overflow_warning (code
))
264 locus
= input_location
;
266 locus
= gimple_location (stmt
);
267 warning_at (locus
, OPT_Wstrict_overflow
, "%s", warnmsg
);
270 /* Stop deferring overflow warnings, ignoring any deferred
274 fold_undefer_and_ignore_overflow_warnings (void)
276 fold_undefer_overflow_warnings (false, NULL
, 0);
279 /* Whether we are deferring overflow warnings. */
282 fold_deferring_overflow_warnings_p (void)
284 return fold_deferring_overflow_warnings
> 0;
287 /* This is called when we fold something based on the fact that signed
288 overflow is undefined. */
291 fold_overflow_warning (const char* gmsgid
, enum warn_strict_overflow_code wc
)
293 if (fold_deferring_overflow_warnings
> 0)
295 if (fold_deferred_overflow_warning
== NULL
296 || wc
< fold_deferred_overflow_code
)
298 fold_deferred_overflow_warning
= gmsgid
;
299 fold_deferred_overflow_code
= wc
;
302 else if (issue_strict_overflow_warning (wc
))
303 warning (OPT_Wstrict_overflow
, gmsgid
);
306 /* Return true if the built-in mathematical function specified by CODE
307 is odd, i.e. -f(x) == f(-x). */
310 negate_mathfn_p (combined_fn fn
)
343 return !flag_rounding_math
;
351 /* Check whether we may negate an integer constant T without causing
355 may_negate_without_overflow_p (const_tree t
)
359 gcc_assert (TREE_CODE (t
) == INTEGER_CST
);
361 type
= TREE_TYPE (t
);
362 if (TYPE_UNSIGNED (type
))
365 return !wi::only_sign_bit_p (t
);
368 /* Determine whether an expression T can be cheaply negated using
369 the function negate_expr without introducing undefined overflow. */
372 negate_expr_p (tree t
)
379 type
= TREE_TYPE (t
);
382 switch (TREE_CODE (t
))
385 if (INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_WRAPS (type
))
388 /* Check that -CST will not overflow type. */
389 return may_negate_without_overflow_p (t
);
391 return (INTEGRAL_TYPE_P (type
)
392 && TYPE_OVERFLOW_WRAPS (type
));
398 return !TYPE_OVERFLOW_SANITIZED (type
);
401 /* We want to canonicalize to positive real constants. Pretend
402 that only negative ones can be easily negated. */
403 return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
406 return negate_expr_p (TREE_REALPART (t
))
407 && negate_expr_p (TREE_IMAGPART (t
));
411 if (FLOAT_TYPE_P (TREE_TYPE (type
)) || TYPE_OVERFLOW_WRAPS (type
))
414 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
416 for (i
= 0; i
< count
; i
++)
417 if (!negate_expr_p (VECTOR_CST_ELT (t
, i
)))
424 return negate_expr_p (TREE_OPERAND (t
, 0))
425 && negate_expr_p (TREE_OPERAND (t
, 1));
428 return negate_expr_p (TREE_OPERAND (t
, 0));
431 if (HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
432 || HONOR_SIGNED_ZEROS (element_mode (type
))
433 || (INTEGRAL_TYPE_P (type
)
434 && ! TYPE_OVERFLOW_WRAPS (type
)))
436 /* -(A + B) -> (-B) - A. */
437 if (negate_expr_p (TREE_OPERAND (t
, 1)))
439 /* -(A + B) -> (-A) - B. */
440 return negate_expr_p (TREE_OPERAND (t
, 0));
443 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
444 return !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
445 && !HONOR_SIGNED_ZEROS (element_mode (type
))
446 && (! INTEGRAL_TYPE_P (type
)
447 || TYPE_OVERFLOW_WRAPS (type
));
450 if (TYPE_UNSIGNED (type
))
452 /* INT_MIN/n * n doesn't overflow while negating one operand it does
453 if n is a (negative) power of two. */
454 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
455 && ! TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
456 && ! ((TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
457 && wi::popcount (wi::abs (TREE_OPERAND (t
, 0))) != 1)
458 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
459 && wi::popcount (wi::abs (TREE_OPERAND (t
, 1))) != 1)))
465 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (TREE_TYPE (t
))))
466 return negate_expr_p (TREE_OPERAND (t
, 1))
467 || negate_expr_p (TREE_OPERAND (t
, 0));
473 if (TYPE_UNSIGNED (type
))
475 if (negate_expr_p (TREE_OPERAND (t
, 0)))
477 /* In general we can't negate B in A / B, because if A is INT_MIN and
478 B is 1, we may turn this into INT_MIN / -1 which is undefined
479 and actually traps on some architectures. */
480 if (! INTEGRAL_TYPE_P (TREE_TYPE (t
))
481 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
482 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
483 && ! integer_onep (TREE_OPERAND (t
, 1))))
484 return negate_expr_p (TREE_OPERAND (t
, 1));
488 /* Negate -((double)float) as (double)(-float). */
489 if (TREE_CODE (type
) == REAL_TYPE
)
491 tree tem
= strip_float_extensions (t
);
493 return negate_expr_p (tem
);
498 /* Negate -f(x) as f(-x). */
499 if (negate_mathfn_p (get_call_combined_fn (t
)))
500 return negate_expr_p (CALL_EXPR_ARG (t
, 0));
504 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
505 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
507 tree op1
= TREE_OPERAND (t
, 1);
508 if (wi::eq_p (op1
, TYPE_PRECISION (type
) - 1))
519 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
520 simplification is possible.
521 If negate_expr_p would return true for T, NULL_TREE will never be
525 fold_negate_expr (location_t loc
, tree t
)
527 tree type
= TREE_TYPE (t
);
530 switch (TREE_CODE (t
))
532 /* Convert - (~A) to A + 1. */
534 if (INTEGRAL_TYPE_P (type
))
535 return fold_build2_loc (loc
, PLUS_EXPR
, type
, TREE_OPERAND (t
, 0),
536 build_one_cst (type
));
540 tem
= fold_negate_const (t
, type
);
541 if (TREE_OVERFLOW (tem
) == TREE_OVERFLOW (t
)
542 || (ANY_INTEGRAL_TYPE_P (type
)
543 && !TYPE_OVERFLOW_TRAPS (type
)
544 && TYPE_OVERFLOW_WRAPS (type
))
545 || (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
550 tem
= fold_negate_const (t
, type
);
554 tem
= fold_negate_const (t
, type
);
559 tree rpart
= fold_negate_expr (loc
, TREE_REALPART (t
));
560 tree ipart
= fold_negate_expr (loc
, TREE_IMAGPART (t
));
562 return build_complex (type
, rpart
, ipart
);
568 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
569 tree
*elts
= XALLOCAVEC (tree
, count
);
571 for (i
= 0; i
< count
; i
++)
573 elts
[i
] = fold_negate_expr (loc
, VECTOR_CST_ELT (t
, i
));
574 if (elts
[i
] == NULL_TREE
)
578 return build_vector (type
, elts
);
582 if (negate_expr_p (t
))
583 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
584 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)),
585 fold_negate_expr (loc
, TREE_OPERAND (t
, 1)));
589 if (negate_expr_p (t
))
590 return fold_build1_loc (loc
, CONJ_EXPR
, type
,
591 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)));
595 if (!TYPE_OVERFLOW_SANITIZED (type
))
596 return TREE_OPERAND (t
, 0);
600 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
601 && !HONOR_SIGNED_ZEROS (element_mode (type
)))
603 /* -(A + B) -> (-B) - A. */
604 if (negate_expr_p (TREE_OPERAND (t
, 1)))
606 tem
= negate_expr (TREE_OPERAND (t
, 1));
607 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
608 tem
, TREE_OPERAND (t
, 0));
611 /* -(A + B) -> (-A) - B. */
612 if (negate_expr_p (TREE_OPERAND (t
, 0)))
614 tem
= negate_expr (TREE_OPERAND (t
, 0));
615 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
616 tem
, TREE_OPERAND (t
, 1));
622 /* - (A - B) -> B - A */
623 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
624 && !HONOR_SIGNED_ZEROS (element_mode (type
)))
625 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
626 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 0));
630 if (TYPE_UNSIGNED (type
))
636 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
)))
638 tem
= TREE_OPERAND (t
, 1);
639 if (negate_expr_p (tem
))
640 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
641 TREE_OPERAND (t
, 0), negate_expr (tem
));
642 tem
= TREE_OPERAND (t
, 0);
643 if (negate_expr_p (tem
))
644 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
645 negate_expr (tem
), TREE_OPERAND (t
, 1));
652 if (TYPE_UNSIGNED (type
))
654 if (negate_expr_p (TREE_OPERAND (t
, 0)))
655 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
656 negate_expr (TREE_OPERAND (t
, 0)),
657 TREE_OPERAND (t
, 1));
658 /* In general we can't negate B in A / B, because if A is INT_MIN and
659 B is 1, we may turn this into INT_MIN / -1 which is undefined
660 and actually traps on some architectures. */
661 if ((! INTEGRAL_TYPE_P (TREE_TYPE (t
))
662 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
663 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
664 && ! integer_onep (TREE_OPERAND (t
, 1))))
665 && negate_expr_p (TREE_OPERAND (t
, 1)))
666 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
668 negate_expr (TREE_OPERAND (t
, 1)));
672 /* Convert -((double)float) into (double)(-float). */
673 if (TREE_CODE (type
) == REAL_TYPE
)
675 tem
= strip_float_extensions (t
);
676 if (tem
!= t
&& negate_expr_p (tem
))
677 return fold_convert_loc (loc
, type
, negate_expr (tem
));
682 /* Negate -f(x) as f(-x). */
683 if (negate_mathfn_p (get_call_combined_fn (t
))
684 && negate_expr_p (CALL_EXPR_ARG (t
, 0)))
688 fndecl
= get_callee_fndecl (t
);
689 arg
= negate_expr (CALL_EXPR_ARG (t
, 0));
690 return build_call_expr_loc (loc
, fndecl
, 1, arg
);
695 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
696 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
698 tree op1
= TREE_OPERAND (t
, 1);
699 if (wi::eq_p (op1
, TYPE_PRECISION (type
) - 1))
701 tree ntype
= TYPE_UNSIGNED (type
)
702 ? signed_type_for (type
)
703 : unsigned_type_for (type
);
704 tree temp
= fold_convert_loc (loc
, ntype
, TREE_OPERAND (t
, 0));
705 temp
= fold_build2_loc (loc
, RSHIFT_EXPR
, ntype
, temp
, op1
);
706 return fold_convert_loc (loc
, type
, temp
);
718 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
719 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
731 loc
= EXPR_LOCATION (t
);
732 type
= TREE_TYPE (t
);
735 tem
= fold_negate_expr (loc
, t
);
737 tem
= build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
738 return fold_convert_loc (loc
, type
, tem
);
741 /* Split a tree IN into a constant, literal and variable parts that could be
742 combined with CODE to make IN. "constant" means an expression with
743 TREE_CONSTANT but that isn't an actual constant. CODE must be a
744 commutative arithmetic operation. Store the constant part into *CONP,
745 the literal in *LITP and return the variable part. If a part isn't
746 present, set it to null. If the tree does not decompose in this way,
747 return the entire tree as the variable part and the other parts as null.
749 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
750 case, we negate an operand that was subtracted. Except if it is a
751 literal for which we use *MINUS_LITP instead.
753 If NEGATE_P is true, we are negating all of IN, again except a literal
754 for which we use *MINUS_LITP instead. If a variable part is of pointer
755 type, it is negated after converting to TYPE. This prevents us from
756 generating illegal MINUS pointer expression. LOC is the location of
757 the converted variable part.
759 If IN is itself a literal or constant, return it as appropriate.
761 Note that we do not guarantee that any of the three values will be the
762 same type as IN, but they will have the same signedness and mode. */
765 split_tree (location_t loc
, tree in
, tree type
, enum tree_code code
,
766 tree
*conp
, tree
*litp
, tree
*minus_litp
, int negate_p
)
774 /* Strip any conversions that don't change the machine mode or signedness. */
775 STRIP_SIGN_NOPS (in
);
777 if (TREE_CODE (in
) == INTEGER_CST
|| TREE_CODE (in
) == REAL_CST
778 || TREE_CODE (in
) == FIXED_CST
)
780 else if (TREE_CODE (in
) == code
781 || ((! FLOAT_TYPE_P (TREE_TYPE (in
)) || flag_associative_math
)
782 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in
))
783 /* We can associate addition and subtraction together (even
784 though the C standard doesn't say so) for integers because
785 the value is not affected. For reals, the value might be
786 affected, so we can't. */
787 && ((code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
788 || (code
== MINUS_EXPR
&& TREE_CODE (in
) == PLUS_EXPR
))))
790 tree op0
= TREE_OPERAND (in
, 0);
791 tree op1
= TREE_OPERAND (in
, 1);
792 int neg1_p
= TREE_CODE (in
) == MINUS_EXPR
;
793 int neg_litp_p
= 0, neg_conp_p
= 0, neg_var_p
= 0;
795 /* First see if either of the operands is a literal, then a constant. */
796 if (TREE_CODE (op0
) == INTEGER_CST
|| TREE_CODE (op0
) == REAL_CST
797 || TREE_CODE (op0
) == FIXED_CST
)
798 *litp
= op0
, op0
= 0;
799 else if (TREE_CODE (op1
) == INTEGER_CST
|| TREE_CODE (op1
) == REAL_CST
800 || TREE_CODE (op1
) == FIXED_CST
)
801 *litp
= op1
, neg_litp_p
= neg1_p
, op1
= 0;
803 if (op0
!= 0 && TREE_CONSTANT (op0
))
804 *conp
= op0
, op0
= 0;
805 else if (op1
!= 0 && TREE_CONSTANT (op1
))
806 *conp
= op1
, neg_conp_p
= neg1_p
, op1
= 0;
808 /* If we haven't dealt with either operand, this is not a case we can
809 decompose. Otherwise, VAR is either of the ones remaining, if any. */
810 if (op0
!= 0 && op1
!= 0)
815 var
= op1
, neg_var_p
= neg1_p
;
817 /* Now do any needed negations. */
819 *minus_litp
= *litp
, *litp
= 0;
821 *conp
= negate_expr (*conp
);
822 if (neg_var_p
&& var
)
824 /* Convert to TYPE before negating. */
825 var
= fold_convert_loc (loc
, type
, var
);
826 var
= negate_expr (var
);
829 else if (TREE_CONSTANT (in
))
831 else if (TREE_CODE (in
) == BIT_NOT_EXPR
832 && code
== PLUS_EXPR
)
834 /* -X - 1 is folded to ~X, undo that here. Do _not_ do this
835 when IN is constant. */
836 *minus_litp
= build_one_cst (TREE_TYPE (in
));
837 var
= negate_expr (TREE_OPERAND (in
, 0));
845 *minus_litp
= *litp
, *litp
= 0;
846 else if (*minus_litp
)
847 *litp
= *minus_litp
, *minus_litp
= 0;
848 *conp
= negate_expr (*conp
);
851 /* Convert to TYPE before negating. */
852 var
= fold_convert_loc (loc
, type
, var
);
853 var
= negate_expr (var
);
860 /* Re-associate trees split by the above function. T1 and T2 are
861 either expressions to associate or null. Return the new
862 expression, if any. LOC is the location of the new expression. If
863 we build an operation, do it in TYPE and with CODE. */
866 associate_trees (location_t loc
, tree t1
, tree t2
, enum tree_code code
, tree type
)
873 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
874 try to fold this since we will have infinite recursion. But do
875 deal with any NEGATE_EXPRs. */
876 if (TREE_CODE (t1
) == code
|| TREE_CODE (t2
) == code
877 || TREE_CODE (t1
) == MINUS_EXPR
|| TREE_CODE (t2
) == MINUS_EXPR
)
879 if (code
== PLUS_EXPR
)
881 if (TREE_CODE (t1
) == NEGATE_EXPR
)
882 return build2_loc (loc
, MINUS_EXPR
, type
,
883 fold_convert_loc (loc
, type
, t2
),
884 fold_convert_loc (loc
, type
,
885 TREE_OPERAND (t1
, 0)));
886 else if (TREE_CODE (t2
) == NEGATE_EXPR
)
887 return build2_loc (loc
, MINUS_EXPR
, type
,
888 fold_convert_loc (loc
, type
, t1
),
889 fold_convert_loc (loc
, type
,
890 TREE_OPERAND (t2
, 0)));
891 else if (integer_zerop (t2
))
892 return fold_convert_loc (loc
, type
, t1
);
894 else if (code
== MINUS_EXPR
)
896 if (integer_zerop (t2
))
897 return fold_convert_loc (loc
, type
, t1
);
900 return build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
901 fold_convert_loc (loc
, type
, t2
));
904 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
905 fold_convert_loc (loc
, type
, t2
));
908 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
909 for use in int_const_binop, size_binop and size_diffop. */
912 int_binop_types_match_p (enum tree_code code
, const_tree type1
, const_tree type2
)
914 if (!INTEGRAL_TYPE_P (type1
) && !POINTER_TYPE_P (type1
))
916 if (!INTEGRAL_TYPE_P (type2
) && !POINTER_TYPE_P (type2
))
931 return TYPE_UNSIGNED (type1
) == TYPE_UNSIGNED (type2
)
932 && TYPE_PRECISION (type1
) == TYPE_PRECISION (type2
)
933 && TYPE_MODE (type1
) == TYPE_MODE (type2
);
937 /* Combine two integer constants ARG1 and ARG2 under operation CODE
938 to produce a new constant. Return NULL_TREE if we don't know how
939 to evaluate CODE at compile-time. */
942 int_const_binop_1 (enum tree_code code
, const_tree arg1
, const_tree parg2
,
947 tree type
= TREE_TYPE (arg1
);
948 signop sign
= TYPE_SIGN (type
);
949 bool overflow
= false;
951 wide_int arg2
= wi::to_wide (parg2
, TYPE_PRECISION (type
));
956 res
= wi::bit_or (arg1
, arg2
);
960 res
= wi::bit_xor (arg1
, arg2
);
964 res
= wi::bit_and (arg1
, arg2
);
969 if (wi::neg_p (arg2
))
972 if (code
== RSHIFT_EXPR
)
978 if (code
== RSHIFT_EXPR
)
979 /* It's unclear from the C standard whether shifts can overflow.
980 The following code ignores overflow; perhaps a C standard
981 interpretation ruling is needed. */
982 res
= wi::rshift (arg1
, arg2
, sign
);
984 res
= wi::lshift (arg1
, arg2
);
989 if (wi::neg_p (arg2
))
992 if (code
== RROTATE_EXPR
)
998 if (code
== RROTATE_EXPR
)
999 res
= wi::rrotate (arg1
, arg2
);
1001 res
= wi::lrotate (arg1
, arg2
);
1005 res
= wi::add (arg1
, arg2
, sign
, &overflow
);
1009 res
= wi::sub (arg1
, arg2
, sign
, &overflow
);
1013 res
= wi::mul (arg1
, arg2
, sign
, &overflow
);
1016 case MULT_HIGHPART_EXPR
:
1017 res
= wi::mul_high (arg1
, arg2
, sign
);
1020 case TRUNC_DIV_EXPR
:
1021 case EXACT_DIV_EXPR
:
1024 res
= wi::div_trunc (arg1
, arg2
, sign
, &overflow
);
1027 case FLOOR_DIV_EXPR
:
1030 res
= wi::div_floor (arg1
, arg2
, sign
, &overflow
);
1036 res
= wi::div_ceil (arg1
, arg2
, sign
, &overflow
);
1039 case ROUND_DIV_EXPR
:
1042 res
= wi::div_round (arg1
, arg2
, sign
, &overflow
);
1045 case TRUNC_MOD_EXPR
:
1048 res
= wi::mod_trunc (arg1
, arg2
, sign
, &overflow
);
1051 case FLOOR_MOD_EXPR
:
1054 res
= wi::mod_floor (arg1
, arg2
, sign
, &overflow
);
1060 res
= wi::mod_ceil (arg1
, arg2
, sign
, &overflow
);
1063 case ROUND_MOD_EXPR
:
1066 res
= wi::mod_round (arg1
, arg2
, sign
, &overflow
);
1070 res
= wi::min (arg1
, arg2
, sign
);
1074 res
= wi::max (arg1
, arg2
, sign
);
1081 t
= force_fit_type (type
, res
, overflowable
,
1082 (((sign
== SIGNED
|| overflowable
== -1)
1084 | TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (parg2
)));
1090 int_const_binop (enum tree_code code
, const_tree arg1
, const_tree arg2
)
1092 return int_const_binop_1 (code
, arg1
, arg2
, 1);
1095 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1096 constant. We assume ARG1 and ARG2 have the same data type, or at least
1097 are the same kind of constant and the same machine mode. Return zero if
1098 combining the constants is not allowed in the current operating mode. */
1101 const_binop (enum tree_code code
, tree arg1
, tree arg2
)
1103 /* Sanity check for the recursive cases. */
1110 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg2
) == INTEGER_CST
)
1112 if (code
== POINTER_PLUS_EXPR
)
1113 return int_const_binop (PLUS_EXPR
,
1114 arg1
, fold_convert (TREE_TYPE (arg1
), arg2
));
1116 return int_const_binop (code
, arg1
, arg2
);
1119 if (TREE_CODE (arg1
) == REAL_CST
&& TREE_CODE (arg2
) == REAL_CST
)
1124 REAL_VALUE_TYPE value
;
1125 REAL_VALUE_TYPE result
;
1129 /* The following codes are handled by real_arithmetic. */
1144 d1
= TREE_REAL_CST (arg1
);
1145 d2
= TREE_REAL_CST (arg2
);
1147 type
= TREE_TYPE (arg1
);
1148 mode
= TYPE_MODE (type
);
1150 /* Don't perform operation if we honor signaling NaNs and
1151 either operand is a signaling NaN. */
1152 if (HONOR_SNANS (mode
)
1153 && (REAL_VALUE_ISSIGNALING_NAN (d1
)
1154 || REAL_VALUE_ISSIGNALING_NAN (d2
)))
1157 /* Don't perform operation if it would raise a division
1158 by zero exception. */
1159 if (code
== RDIV_EXPR
1160 && real_equal (&d2
, &dconst0
)
1161 && (flag_trapping_math
|| ! MODE_HAS_INFINITIES (mode
)))
1164 /* If either operand is a NaN, just return it. Otherwise, set up
1165 for floating-point trap; we return an overflow. */
1166 if (REAL_VALUE_ISNAN (d1
))
1168 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1171 t
= build_real (type
, d1
);
1174 else if (REAL_VALUE_ISNAN (d2
))
1176 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1179 t
= build_real (type
, d2
);
1183 inexact
= real_arithmetic (&value
, code
, &d1
, &d2
);
1184 real_convert (&result
, mode
, &value
);
1186 /* Don't constant fold this floating point operation if
1187 the result has overflowed and flag_trapping_math. */
1188 if (flag_trapping_math
1189 && MODE_HAS_INFINITIES (mode
)
1190 && REAL_VALUE_ISINF (result
)
1191 && !REAL_VALUE_ISINF (d1
)
1192 && !REAL_VALUE_ISINF (d2
))
1195 /* Don't constant fold this floating point operation if the
1196 result may dependent upon the run-time rounding mode and
1197 flag_rounding_math is set, or if GCC's software emulation
1198 is unable to accurately represent the result. */
1199 if ((flag_rounding_math
1200 || (MODE_COMPOSITE_P (mode
) && !flag_unsafe_math_optimizations
))
1201 && (inexact
|| !real_identical (&result
, &value
)))
1204 t
= build_real (type
, result
);
1206 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
);
1210 if (TREE_CODE (arg1
) == FIXED_CST
)
1212 FIXED_VALUE_TYPE f1
;
1213 FIXED_VALUE_TYPE f2
;
1214 FIXED_VALUE_TYPE result
;
1219 /* The following codes are handled by fixed_arithmetic. */
1225 case TRUNC_DIV_EXPR
:
1226 if (TREE_CODE (arg2
) != FIXED_CST
)
1228 f2
= TREE_FIXED_CST (arg2
);
1234 if (TREE_CODE (arg2
) != INTEGER_CST
)
1237 f2
.data
.high
= w2
.elt (1);
1238 f2
.data
.low
= w2
.elt (0);
1247 f1
= TREE_FIXED_CST (arg1
);
1248 type
= TREE_TYPE (arg1
);
1249 sat_p
= TYPE_SATURATING (type
);
1250 overflow_p
= fixed_arithmetic (&result
, code
, &f1
, &f2
, sat_p
);
1251 t
= build_fixed (type
, result
);
1252 /* Propagate overflow flags. */
1253 if (overflow_p
| TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
))
1254 TREE_OVERFLOW (t
) = 1;
1258 if (TREE_CODE (arg1
) == COMPLEX_CST
&& TREE_CODE (arg2
) == COMPLEX_CST
)
1260 tree type
= TREE_TYPE (arg1
);
1261 tree r1
= TREE_REALPART (arg1
);
1262 tree i1
= TREE_IMAGPART (arg1
);
1263 tree r2
= TREE_REALPART (arg2
);
1264 tree i2
= TREE_IMAGPART (arg2
);
1271 real
= const_binop (code
, r1
, r2
);
1272 imag
= const_binop (code
, i1
, i2
);
1276 if (COMPLEX_FLOAT_TYPE_P (type
))
1277 return do_mpc_arg2 (arg1
, arg2
, type
,
1278 /* do_nonfinite= */ folding_initializer
,
1281 real
= const_binop (MINUS_EXPR
,
1282 const_binop (MULT_EXPR
, r1
, r2
),
1283 const_binop (MULT_EXPR
, i1
, i2
));
1284 imag
= const_binop (PLUS_EXPR
,
1285 const_binop (MULT_EXPR
, r1
, i2
),
1286 const_binop (MULT_EXPR
, i1
, r2
));
1290 if (COMPLEX_FLOAT_TYPE_P (type
))
1291 return do_mpc_arg2 (arg1
, arg2
, type
,
1292 /* do_nonfinite= */ folding_initializer
,
1295 case TRUNC_DIV_EXPR
:
1297 case FLOOR_DIV_EXPR
:
1298 case ROUND_DIV_EXPR
:
1299 if (flag_complex_method
== 0)
1301 /* Keep this algorithm in sync with
1302 tree-complex.c:expand_complex_div_straight().
1304 Expand complex division to scalars, straightforward algorithm.
1305 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1309 = const_binop (PLUS_EXPR
,
1310 const_binop (MULT_EXPR
, r2
, r2
),
1311 const_binop (MULT_EXPR
, i2
, i2
));
1313 = const_binop (PLUS_EXPR
,
1314 const_binop (MULT_EXPR
, r1
, r2
),
1315 const_binop (MULT_EXPR
, i1
, i2
));
1317 = const_binop (MINUS_EXPR
,
1318 const_binop (MULT_EXPR
, i1
, r2
),
1319 const_binop (MULT_EXPR
, r1
, i2
));
1321 real
= const_binop (code
, t1
, magsquared
);
1322 imag
= const_binop (code
, t2
, magsquared
);
1326 /* Keep this algorithm in sync with
1327 tree-complex.c:expand_complex_div_wide().
1329 Expand complex division to scalars, modified algorithm to minimize
1330 overflow with wide input ranges. */
1331 tree compare
= fold_build2 (LT_EXPR
, boolean_type_node
,
1332 fold_abs_const (r2
, TREE_TYPE (type
)),
1333 fold_abs_const (i2
, TREE_TYPE (type
)));
1335 if (integer_nonzerop (compare
))
1337 /* In the TRUE branch, we compute
1339 div = (br * ratio) + bi;
1340 tr = (ar * ratio) + ai;
1341 ti = (ai * ratio) - ar;
1344 tree ratio
= const_binop (code
, r2
, i2
);
1345 tree div
= const_binop (PLUS_EXPR
, i2
,
1346 const_binop (MULT_EXPR
, r2
, ratio
));
1347 real
= const_binop (MULT_EXPR
, r1
, ratio
);
1348 real
= const_binop (PLUS_EXPR
, real
, i1
);
1349 real
= const_binop (code
, real
, div
);
1351 imag
= const_binop (MULT_EXPR
, i1
, ratio
);
1352 imag
= const_binop (MINUS_EXPR
, imag
, r1
);
1353 imag
= const_binop (code
, imag
, div
);
1357 /* In the FALSE branch, we compute
1359 divisor = (d * ratio) + c;
1360 tr = (b * ratio) + a;
1361 ti = b - (a * ratio);
1364 tree ratio
= const_binop (code
, i2
, r2
);
1365 tree div
= const_binop (PLUS_EXPR
, r2
,
1366 const_binop (MULT_EXPR
, i2
, ratio
));
1368 real
= const_binop (MULT_EXPR
, i1
, ratio
);
1369 real
= const_binop (PLUS_EXPR
, real
, r1
);
1370 real
= const_binop (code
, real
, div
);
1372 imag
= const_binop (MULT_EXPR
, r1
, ratio
);
1373 imag
= const_binop (MINUS_EXPR
, i1
, imag
);
1374 imag
= const_binop (code
, imag
, div
);
1384 return build_complex (type
, real
, imag
);
1387 if (TREE_CODE (arg1
) == VECTOR_CST
1388 && TREE_CODE (arg2
) == VECTOR_CST
)
1390 tree type
= TREE_TYPE (arg1
);
1391 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1392 tree
*elts
= XALLOCAVEC (tree
, count
);
1394 for (i
= 0; i
< count
; i
++)
1396 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1397 tree elem2
= VECTOR_CST_ELT (arg2
, i
);
1399 elts
[i
] = const_binop (code
, elem1
, elem2
);
1401 /* It is possible that const_binop cannot handle the given
1402 code and return NULL_TREE */
1403 if (elts
[i
] == NULL_TREE
)
1407 return build_vector (type
, elts
);
1410 /* Shifts allow a scalar offset for a vector. */
1411 if (TREE_CODE (arg1
) == VECTOR_CST
1412 && TREE_CODE (arg2
) == INTEGER_CST
)
1414 tree type
= TREE_TYPE (arg1
);
1415 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1416 tree
*elts
= XALLOCAVEC (tree
, count
);
1418 for (i
= 0; i
< count
; i
++)
1420 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1422 elts
[i
] = const_binop (code
, elem1
, arg2
);
1424 /* It is possible that const_binop cannot handle the given
1425 code and return NULL_TREE. */
1426 if (elts
[i
] == NULL_TREE
)
1430 return build_vector (type
, elts
);
1435 /* Overload that adds a TYPE parameter to be able to dispatch
1436 to fold_relational_const. */
1439 const_binop (enum tree_code code
, tree type
, tree arg1
, tree arg2
)
1441 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
1442 return fold_relational_const (code
, type
, arg1
, arg2
);
1444 /* ??? Until we make the const_binop worker take the type of the
1445 result as argument put those cases that need it here. */
1449 if ((TREE_CODE (arg1
) == REAL_CST
1450 && TREE_CODE (arg2
) == REAL_CST
)
1451 || (TREE_CODE (arg1
) == INTEGER_CST
1452 && TREE_CODE (arg2
) == INTEGER_CST
))
1453 return build_complex (type
, arg1
, arg2
);
1456 case VEC_PACK_TRUNC_EXPR
:
1457 case VEC_PACK_FIX_TRUNC_EXPR
:
1459 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
1462 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
/ 2
1463 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2
)) == nelts
/ 2);
1464 if (TREE_CODE (arg1
) != VECTOR_CST
1465 || TREE_CODE (arg2
) != VECTOR_CST
)
1468 elts
= XALLOCAVEC (tree
, nelts
);
1469 if (!vec_cst_ctor_to_array (arg1
, elts
)
1470 || !vec_cst_ctor_to_array (arg2
, elts
+ nelts
/ 2))
1473 for (i
= 0; i
< nelts
; i
++)
1475 elts
[i
] = fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
1476 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
1477 TREE_TYPE (type
), elts
[i
]);
1478 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
1482 return build_vector (type
, elts
);
1485 case VEC_WIDEN_MULT_LO_EXPR
:
1486 case VEC_WIDEN_MULT_HI_EXPR
:
1487 case VEC_WIDEN_MULT_EVEN_EXPR
:
1488 case VEC_WIDEN_MULT_ODD_EXPR
:
1490 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
1491 unsigned int out
, ofs
, scale
;
1494 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
* 2
1495 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2
)) == nelts
* 2);
1496 if (TREE_CODE (arg1
) != VECTOR_CST
|| TREE_CODE (arg2
) != VECTOR_CST
)
1499 elts
= XALLOCAVEC (tree
, nelts
* 4);
1500 if (!vec_cst_ctor_to_array (arg1
, elts
)
1501 || !vec_cst_ctor_to_array (arg2
, elts
+ nelts
* 2))
1504 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
1505 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? nelts
: 0;
1506 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
1507 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : nelts
;
1508 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
1510 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
1513 for (out
= 0; out
< nelts
; out
++)
1515 unsigned int in1
= (out
<< scale
) + ofs
;
1516 unsigned int in2
= in1
+ nelts
* 2;
1519 t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in1
]);
1520 t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in2
]);
1522 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
1524 elts
[out
] = const_binop (MULT_EXPR
, t1
, t2
);
1525 if (elts
[out
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[out
]))
1529 return build_vector (type
, elts
);
1535 if (TREE_CODE_CLASS (code
) != tcc_binary
)
1538 /* Make sure type and arg0 have the same saturating flag. */
1539 gcc_checking_assert (TYPE_SATURATING (type
)
1540 == TYPE_SATURATING (TREE_TYPE (arg1
)));
1542 return const_binop (code
, arg1
, arg2
);
1545 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1546 Return zero if computing the constants is not possible. */
1549 const_unop (enum tree_code code
, tree type
, tree arg0
)
1551 /* Don't perform the operation, other than NEGATE and ABS, if
1552 flag_signaling_nans is on and the operand is a signaling NaN. */
1553 if (TREE_CODE (arg0
) == REAL_CST
1554 && HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
1555 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg0
))
1556 && code
!= NEGATE_EXPR
1557 && code
!= ABS_EXPR
)
1564 case FIX_TRUNC_EXPR
:
1565 case FIXED_CONVERT_EXPR
:
1566 return fold_convert_const (code
, type
, arg0
);
1568 case ADDR_SPACE_CONVERT_EXPR
:
1569 /* If the source address is 0, and the source address space
1570 cannot have a valid object at 0, fold to dest type null. */
1571 if (integer_zerop (arg0
)
1572 && !(targetm
.addr_space
.zero_address_valid
1573 (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
))))))
1574 return fold_convert_const (code
, type
, arg0
);
1577 case VIEW_CONVERT_EXPR
:
1578 return fold_view_convert_expr (type
, arg0
);
1582 /* Can't call fold_negate_const directly here as that doesn't
1583 handle all cases and we might not be able to negate some
1585 tree tem
= fold_negate_expr (UNKNOWN_LOCATION
, arg0
);
1586 if (tem
&& CONSTANT_CLASS_P (tem
))
1592 if (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
)
1593 return fold_abs_const (arg0
, type
);
1597 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1599 tree ipart
= fold_negate_const (TREE_IMAGPART (arg0
),
1601 return build_complex (type
, TREE_REALPART (arg0
), ipart
);
1606 if (TREE_CODE (arg0
) == INTEGER_CST
)
1607 return fold_not_const (arg0
, type
);
1608 /* Perform BIT_NOT_EXPR on each element individually. */
1609 else if (TREE_CODE (arg0
) == VECTOR_CST
)
1613 unsigned count
= VECTOR_CST_NELTS (arg0
), i
;
1615 elements
= XALLOCAVEC (tree
, count
);
1616 for (i
= 0; i
< count
; i
++)
1618 elem
= VECTOR_CST_ELT (arg0
, i
);
1619 elem
= const_unop (BIT_NOT_EXPR
, TREE_TYPE (type
), elem
);
1620 if (elem
== NULL_TREE
)
1625 return build_vector (type
, elements
);
1629 case TRUTH_NOT_EXPR
:
1630 if (TREE_CODE (arg0
) == INTEGER_CST
)
1631 return constant_boolean_node (integer_zerop (arg0
), type
);
1635 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1636 return fold_convert (type
, TREE_REALPART (arg0
));
1640 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1641 return fold_convert (type
, TREE_IMAGPART (arg0
));
1644 case VEC_UNPACK_LO_EXPR
:
1645 case VEC_UNPACK_HI_EXPR
:
1646 case VEC_UNPACK_FLOAT_LO_EXPR
:
1647 case VEC_UNPACK_FLOAT_HI_EXPR
:
1649 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
1651 enum tree_code subcode
;
1653 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2);
1654 if (TREE_CODE (arg0
) != VECTOR_CST
)
1657 elts
= XALLOCAVEC (tree
, nelts
* 2);
1658 if (!vec_cst_ctor_to_array (arg0
, elts
))
1661 if ((!BYTES_BIG_ENDIAN
) ^ (code
== VEC_UNPACK_LO_EXPR
1662 || code
== VEC_UNPACK_FLOAT_LO_EXPR
))
1665 if (code
== VEC_UNPACK_LO_EXPR
|| code
== VEC_UNPACK_HI_EXPR
)
1668 subcode
= FLOAT_EXPR
;
1670 for (i
= 0; i
< nelts
; i
++)
1672 elts
[i
] = fold_convert_const (subcode
, TREE_TYPE (type
), elts
[i
]);
1673 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
1677 return build_vector (type
, elts
);
1680 case REDUC_MIN_EXPR
:
1681 case REDUC_MAX_EXPR
:
1682 case REDUC_PLUS_EXPR
:
1684 unsigned int nelts
, i
;
1686 enum tree_code subcode
;
1688 if (TREE_CODE (arg0
) != VECTOR_CST
)
1690 nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
));
1692 elts
= XALLOCAVEC (tree
, nelts
);
1693 if (!vec_cst_ctor_to_array (arg0
, elts
))
1698 case REDUC_MIN_EXPR
: subcode
= MIN_EXPR
; break;
1699 case REDUC_MAX_EXPR
: subcode
= MAX_EXPR
; break;
1700 case REDUC_PLUS_EXPR
: subcode
= PLUS_EXPR
; break;
1701 default: gcc_unreachable ();
1704 for (i
= 1; i
< nelts
; i
++)
1706 elts
[0] = const_binop (subcode
, elts
[0], elts
[i
]);
1707 if (elts
[0] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[0]))
1721 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1722 indicates which particular sizetype to create. */
1725 size_int_kind (HOST_WIDE_INT number
, enum size_type_kind kind
)
1727 return build_int_cst (sizetype_tab
[(int) kind
], number
);
1730 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1731 is a tree code. The type of the result is taken from the operands.
1732 Both must be equivalent integer types, ala int_binop_types_match_p.
1733 If the operands are constant, so is the result. */
1736 size_binop_loc (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
)
1738 tree type
= TREE_TYPE (arg0
);
1740 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1741 return error_mark_node
;
1743 gcc_assert (int_binop_types_match_p (code
, TREE_TYPE (arg0
),
1746 /* Handle the special case of two integer constants faster. */
1747 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1749 /* And some specific cases even faster than that. */
1750 if (code
== PLUS_EXPR
)
1752 if (integer_zerop (arg0
) && !TREE_OVERFLOW (arg0
))
1754 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1757 else if (code
== MINUS_EXPR
)
1759 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1762 else if (code
== MULT_EXPR
)
1764 if (integer_onep (arg0
) && !TREE_OVERFLOW (arg0
))
1768 /* Handle general case of two integer constants. For sizetype
1769 constant calculations we always want to know about overflow,
1770 even in the unsigned case. */
1771 return int_const_binop_1 (code
, arg0
, arg1
, -1);
1774 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
1777 /* Given two values, either both of sizetype or both of bitsizetype,
1778 compute the difference between the two values. Return the value
1779 in signed type corresponding to the type of the operands. */
1782 size_diffop_loc (location_t loc
, tree arg0
, tree arg1
)
1784 tree type
= TREE_TYPE (arg0
);
1787 gcc_assert (int_binop_types_match_p (MINUS_EXPR
, TREE_TYPE (arg0
),
1790 /* If the type is already signed, just do the simple thing. */
1791 if (!TYPE_UNSIGNED (type
))
1792 return size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
);
1794 if (type
== sizetype
)
1796 else if (type
== bitsizetype
)
1797 ctype
= sbitsizetype
;
1799 ctype
= signed_type_for (type
);
1801 /* If either operand is not a constant, do the conversions to the signed
1802 type and subtract. The hardware will do the right thing with any
1803 overflow in the subtraction. */
1804 if (TREE_CODE (arg0
) != INTEGER_CST
|| TREE_CODE (arg1
) != INTEGER_CST
)
1805 return size_binop_loc (loc
, MINUS_EXPR
,
1806 fold_convert_loc (loc
, ctype
, arg0
),
1807 fold_convert_loc (loc
, ctype
, arg1
));
1809 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1810 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1811 overflow) and negate (which can't either). Special-case a result
1812 of zero while we're here. */
1813 if (tree_int_cst_equal (arg0
, arg1
))
1814 return build_int_cst (ctype
, 0);
1815 else if (tree_int_cst_lt (arg1
, arg0
))
1816 return fold_convert_loc (loc
, ctype
,
1817 size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
));
1819 return size_binop_loc (loc
, MINUS_EXPR
, build_int_cst (ctype
, 0),
1820 fold_convert_loc (loc
, ctype
,
1821 size_binop_loc (loc
,
1826 /* A subroutine of fold_convert_const handling conversions of an
1827 INTEGER_CST to another integer type. */
1830 fold_convert_const_int_from_int (tree type
, const_tree arg1
)
1832 /* Given an integer constant, make new constant with new type,
1833 appropriately sign-extended or truncated. Use widest_int
1834 so that any extension is done according ARG1's type. */
1835 return force_fit_type (type
, wi::to_widest (arg1
),
1836 !POINTER_TYPE_P (TREE_TYPE (arg1
)),
1837 TREE_OVERFLOW (arg1
));
1840 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1841 to an integer type. */
1844 fold_convert_const_int_from_real (enum tree_code code
, tree type
, const_tree arg1
)
1846 bool overflow
= false;
1849 /* The following code implements the floating point to integer
1850 conversion rules required by the Java Language Specification,
1851 that IEEE NaNs are mapped to zero and values that overflow
1852 the target precision saturate, i.e. values greater than
1853 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1854 are mapped to INT_MIN. These semantics are allowed by the
1855 C and C++ standards that simply state that the behavior of
1856 FP-to-integer conversion is unspecified upon overflow. */
1860 REAL_VALUE_TYPE x
= TREE_REAL_CST (arg1
);
1864 case FIX_TRUNC_EXPR
:
1865 real_trunc (&r
, VOIDmode
, &x
);
1872 /* If R is NaN, return zero and show we have an overflow. */
1873 if (REAL_VALUE_ISNAN (r
))
1876 val
= wi::zero (TYPE_PRECISION (type
));
1879 /* See if R is less than the lower bound or greater than the
1884 tree lt
= TYPE_MIN_VALUE (type
);
1885 REAL_VALUE_TYPE l
= real_value_from_int_cst (NULL_TREE
, lt
);
1886 if (real_less (&r
, &l
))
1895 tree ut
= TYPE_MAX_VALUE (type
);
1898 REAL_VALUE_TYPE u
= real_value_from_int_cst (NULL_TREE
, ut
);
1899 if (real_less (&u
, &r
))
1908 val
= real_to_integer (&r
, &overflow
, TYPE_PRECISION (type
));
1910 t
= force_fit_type (type
, val
, -1, overflow
| TREE_OVERFLOW (arg1
));
1914 /* A subroutine of fold_convert_const handling conversions of a
1915 FIXED_CST to an integer type. */
1918 fold_convert_const_int_from_fixed (tree type
, const_tree arg1
)
1921 double_int temp
, temp_trunc
;
1924 /* Right shift FIXED_CST to temp by fbit. */
1925 temp
= TREE_FIXED_CST (arg1
).data
;
1926 mode
= TREE_FIXED_CST (arg1
).mode
;
1927 if (GET_MODE_FBIT (mode
) < HOST_BITS_PER_DOUBLE_INT
)
1929 temp
= temp
.rshift (GET_MODE_FBIT (mode
),
1930 HOST_BITS_PER_DOUBLE_INT
,
1931 SIGNED_FIXED_POINT_MODE_P (mode
));
1933 /* Left shift temp to temp_trunc by fbit. */
1934 temp_trunc
= temp
.lshift (GET_MODE_FBIT (mode
),
1935 HOST_BITS_PER_DOUBLE_INT
,
1936 SIGNED_FIXED_POINT_MODE_P (mode
));
1940 temp
= double_int_zero
;
1941 temp_trunc
= double_int_zero
;
1944 /* If FIXED_CST is negative, we need to round the value toward 0.
1945 By checking if the fractional bits are not zero to add 1 to temp. */
1946 if (SIGNED_FIXED_POINT_MODE_P (mode
)
1947 && temp_trunc
.is_negative ()
1948 && TREE_FIXED_CST (arg1
).data
!= temp_trunc
)
1949 temp
+= double_int_one
;
1951 /* Given a fixed-point constant, make new constant with new type,
1952 appropriately sign-extended or truncated. */
1953 t
= force_fit_type (type
, temp
, -1,
1954 (temp
.is_negative ()
1955 && (TYPE_UNSIGNED (type
)
1956 < TYPE_UNSIGNED (TREE_TYPE (arg1
))))
1957 | TREE_OVERFLOW (arg1
));
1962 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1963 to another floating point type. */
1966 fold_convert_const_real_from_real (tree type
, const_tree arg1
)
1968 REAL_VALUE_TYPE value
;
1971 /* Don't perform the operation if flag_signaling_nans is on
1972 and the operand is a signaling NaN. */
1973 if (HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
)))
1974 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg1
)))
1977 real_convert (&value
, TYPE_MODE (type
), &TREE_REAL_CST (arg1
));
1978 t
= build_real (type
, value
);
1980 /* If converting an infinity or NAN to a representation that doesn't
1981 have one, set the overflow bit so that we can produce some kind of
1982 error message at the appropriate point if necessary. It's not the
1983 most user-friendly message, but it's better than nothing. */
1984 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1
))
1985 && !MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1986 TREE_OVERFLOW (t
) = 1;
1987 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
1988 && !MODE_HAS_NANS (TYPE_MODE (type
)))
1989 TREE_OVERFLOW (t
) = 1;
1990 /* Regular overflow, conversion produced an infinity in a mode that
1991 can't represent them. */
1992 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type
))
1993 && REAL_VALUE_ISINF (value
)
1994 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1
)))
1995 TREE_OVERFLOW (t
) = 1;
1997 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2001 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2002 to a floating point type. */
2005 fold_convert_const_real_from_fixed (tree type
, const_tree arg1
)
2007 REAL_VALUE_TYPE value
;
2010 real_convert_from_fixed (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
));
2011 t
= build_real (type
, value
);
2013 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2017 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2018 to another fixed-point type. */
2021 fold_convert_const_fixed_from_fixed (tree type
, const_tree arg1
)
2023 FIXED_VALUE_TYPE value
;
2027 overflow_p
= fixed_convert (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
),
2028 TYPE_SATURATING (type
));
2029 t
= build_fixed (type
, value
);
2031 /* Propagate overflow flags. */
2032 if (overflow_p
| TREE_OVERFLOW (arg1
))
2033 TREE_OVERFLOW (t
) = 1;
2037 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2038 to a fixed-point type. */
2041 fold_convert_const_fixed_from_int (tree type
, const_tree arg1
)
2043 FIXED_VALUE_TYPE value
;
2048 gcc_assert (TREE_INT_CST_NUNITS (arg1
) <= 2);
2050 di
.low
= TREE_INT_CST_ELT (arg1
, 0);
2051 if (TREE_INT_CST_NUNITS (arg1
) == 1)
2052 di
.high
= (HOST_WIDE_INT
) di
.low
< 0 ? HOST_WIDE_INT_M1
: 0;
2054 di
.high
= TREE_INT_CST_ELT (arg1
, 1);
2056 overflow_p
= fixed_convert_from_int (&value
, TYPE_MODE (type
), di
,
2057 TYPE_UNSIGNED (TREE_TYPE (arg1
)),
2058 TYPE_SATURATING (type
));
2059 t
= build_fixed (type
, value
);
2061 /* Propagate overflow flags. */
2062 if (overflow_p
| TREE_OVERFLOW (arg1
))
2063 TREE_OVERFLOW (t
) = 1;
2067 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2068 to a fixed-point type. */
2071 fold_convert_const_fixed_from_real (tree type
, const_tree arg1
)
2073 FIXED_VALUE_TYPE value
;
2077 overflow_p
= fixed_convert_from_real (&value
, TYPE_MODE (type
),
2078 &TREE_REAL_CST (arg1
),
2079 TYPE_SATURATING (type
));
2080 t
= build_fixed (type
, value
);
2082 /* Propagate overflow flags. */
2083 if (overflow_p
| TREE_OVERFLOW (arg1
))
2084 TREE_OVERFLOW (t
) = 1;
2088 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2089 type TYPE. If no simplification can be done return NULL_TREE. */
2092 fold_convert_const (enum tree_code code
, tree type
, tree arg1
)
2094 if (TREE_TYPE (arg1
) == type
)
2097 if (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
)
2098 || TREE_CODE (type
) == OFFSET_TYPE
)
2100 if (TREE_CODE (arg1
) == INTEGER_CST
)
2101 return fold_convert_const_int_from_int (type
, arg1
);
2102 else if (TREE_CODE (arg1
) == REAL_CST
)
2103 return fold_convert_const_int_from_real (code
, type
, arg1
);
2104 else if (TREE_CODE (arg1
) == FIXED_CST
)
2105 return fold_convert_const_int_from_fixed (type
, arg1
);
2107 else if (TREE_CODE (type
) == REAL_TYPE
)
2109 if (TREE_CODE (arg1
) == INTEGER_CST
)
2110 return build_real_from_int_cst (type
, arg1
);
2111 else if (TREE_CODE (arg1
) == REAL_CST
)
2112 return fold_convert_const_real_from_real (type
, arg1
);
2113 else if (TREE_CODE (arg1
) == FIXED_CST
)
2114 return fold_convert_const_real_from_fixed (type
, arg1
);
2116 else if (TREE_CODE (type
) == FIXED_POINT_TYPE
)
2118 if (TREE_CODE (arg1
) == FIXED_CST
)
2119 return fold_convert_const_fixed_from_fixed (type
, arg1
);
2120 else if (TREE_CODE (arg1
) == INTEGER_CST
)
2121 return fold_convert_const_fixed_from_int (type
, arg1
);
2122 else if (TREE_CODE (arg1
) == REAL_CST
)
2123 return fold_convert_const_fixed_from_real (type
, arg1
);
2125 else if (TREE_CODE (type
) == VECTOR_TYPE
)
2127 if (TREE_CODE (arg1
) == VECTOR_CST
2128 && TYPE_VECTOR_SUBPARTS (type
) == VECTOR_CST_NELTS (arg1
))
2130 int len
= TYPE_VECTOR_SUBPARTS (type
);
2131 tree elttype
= TREE_TYPE (type
);
2132 tree
*v
= XALLOCAVEC (tree
, len
);
2133 for (int i
= 0; i
< len
; ++i
)
2135 tree elt
= VECTOR_CST_ELT (arg1
, i
);
2136 tree cvt
= fold_convert_const (code
, elttype
, elt
);
2137 if (cvt
== NULL_TREE
)
2141 return build_vector (type
, v
);
2147 /* Construct a vector of zero elements of vector type TYPE. */
2150 build_zero_vector (tree type
)
2154 t
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), integer_zero_node
);
2155 return build_vector_from_val (type
, t
);
2158 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2161 fold_convertible_p (const_tree type
, const_tree arg
)
2163 tree orig
= TREE_TYPE (arg
);
2168 if (TREE_CODE (arg
) == ERROR_MARK
2169 || TREE_CODE (type
) == ERROR_MARK
2170 || TREE_CODE (orig
) == ERROR_MARK
)
2173 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2176 switch (TREE_CODE (type
))
2178 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2179 case POINTER_TYPE
: case REFERENCE_TYPE
:
2181 return (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2182 || TREE_CODE (orig
) == OFFSET_TYPE
);
2185 case FIXED_POINT_TYPE
:
2188 return TREE_CODE (type
) == TREE_CODE (orig
);
2195 /* Convert expression ARG to type TYPE. Used by the middle-end for
2196 simple conversions in preference to calling the front-end's convert. */
2199 fold_convert_loc (location_t loc
, tree type
, tree arg
)
2201 tree orig
= TREE_TYPE (arg
);
2207 if (TREE_CODE (arg
) == ERROR_MARK
2208 || TREE_CODE (type
) == ERROR_MARK
2209 || TREE_CODE (orig
) == ERROR_MARK
)
2210 return error_mark_node
;
2212 switch (TREE_CODE (type
))
2215 case REFERENCE_TYPE
:
2216 /* Handle conversions between pointers to different address spaces. */
2217 if (POINTER_TYPE_P (orig
)
2218 && (TYPE_ADDR_SPACE (TREE_TYPE (type
))
2219 != TYPE_ADDR_SPACE (TREE_TYPE (orig
))))
2220 return fold_build1_loc (loc
, ADDR_SPACE_CONVERT_EXPR
, type
, arg
);
2223 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2225 if (TREE_CODE (arg
) == INTEGER_CST
)
2227 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2228 if (tem
!= NULL_TREE
)
2231 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2232 || TREE_CODE (orig
) == OFFSET_TYPE
)
2233 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2234 if (TREE_CODE (orig
) == COMPLEX_TYPE
)
2235 return fold_convert_loc (loc
, type
,
2236 fold_build1_loc (loc
, REALPART_EXPR
,
2237 TREE_TYPE (orig
), arg
));
2238 gcc_assert (TREE_CODE (orig
) == VECTOR_TYPE
2239 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2240 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2243 if (TREE_CODE (arg
) == INTEGER_CST
)
2245 tem
= fold_convert_const (FLOAT_EXPR
, type
, arg
);
2246 if (tem
!= NULL_TREE
)
2249 else if (TREE_CODE (arg
) == REAL_CST
)
2251 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2252 if (tem
!= NULL_TREE
)
2255 else if (TREE_CODE (arg
) == FIXED_CST
)
2257 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2258 if (tem
!= NULL_TREE
)
2262 switch (TREE_CODE (orig
))
2265 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2266 case POINTER_TYPE
: case REFERENCE_TYPE
:
2267 return fold_build1_loc (loc
, FLOAT_EXPR
, type
, arg
);
2270 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2272 case FIXED_POINT_TYPE
:
2273 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2276 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2277 return fold_convert_loc (loc
, type
, tem
);
2283 case FIXED_POINT_TYPE
:
2284 if (TREE_CODE (arg
) == FIXED_CST
|| TREE_CODE (arg
) == INTEGER_CST
2285 || TREE_CODE (arg
) == REAL_CST
)
2287 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2288 if (tem
!= NULL_TREE
)
2289 goto fold_convert_exit
;
2292 switch (TREE_CODE (orig
))
2294 case FIXED_POINT_TYPE
:
2299 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2302 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2303 return fold_convert_loc (loc
, type
, tem
);
2310 switch (TREE_CODE (orig
))
2313 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2314 case POINTER_TYPE
: case REFERENCE_TYPE
:
2316 case FIXED_POINT_TYPE
:
2317 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
2318 fold_convert_loc (loc
, TREE_TYPE (type
), arg
),
2319 fold_convert_loc (loc
, TREE_TYPE (type
),
2320 integer_zero_node
));
2325 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
2327 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2328 TREE_OPERAND (arg
, 0));
2329 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2330 TREE_OPERAND (arg
, 1));
2331 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2334 arg
= save_expr (arg
);
2335 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2336 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, TREE_TYPE (orig
), arg
);
2337 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
), rpart
);
2338 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
), ipart
);
2339 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2347 if (integer_zerop (arg
))
2348 return build_zero_vector (type
);
2349 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2350 gcc_assert (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2351 || TREE_CODE (orig
) == VECTOR_TYPE
);
2352 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2355 tem
= fold_ignored_result (arg
);
2356 return fold_build1_loc (loc
, NOP_EXPR
, type
, tem
);
2359 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2360 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2364 protected_set_expr_location_unshare (tem
, loc
);
2368 /* Return false if expr can be assumed not to be an lvalue, true
2372 maybe_lvalue_p (const_tree x
)
2374 /* We only need to wrap lvalue tree codes. */
2375 switch (TREE_CODE (x
))
2388 case ARRAY_RANGE_REF
:
2394 case PREINCREMENT_EXPR
:
2395 case PREDECREMENT_EXPR
:
2397 case TRY_CATCH_EXPR
:
2398 case WITH_CLEANUP_EXPR
:
2407 /* Assume the worst for front-end tree codes. */
2408 if ((int)TREE_CODE (x
) >= NUM_TREE_CODES
)
2416 /* Return an expr equal to X but certainly not valid as an lvalue. */
2419 non_lvalue_loc (location_t loc
, tree x
)
2421 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2426 if (! maybe_lvalue_p (x
))
2428 return build1_loc (loc
, NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
2431 /* When pedantic, return an expr equal to X but certainly not valid as a
2432 pedantic lvalue. Otherwise, return X. */
2435 pedantic_non_lvalue_loc (location_t loc
, tree x
)
2437 return protected_set_expr_location_unshare (x
, loc
);
2440 /* Given a tree comparison code, return the code that is the logical inverse.
2441 It is generally not safe to do this for floating-point comparisons, except
2442 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2443 ERROR_MARK in this case. */
2446 invert_tree_comparison (enum tree_code code
, bool honor_nans
)
2448 if (honor_nans
&& flag_trapping_math
&& code
!= EQ_EXPR
&& code
!= NE_EXPR
2449 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
)
2459 return honor_nans
? UNLE_EXPR
: LE_EXPR
;
2461 return honor_nans
? UNLT_EXPR
: LT_EXPR
;
2463 return honor_nans
? UNGE_EXPR
: GE_EXPR
;
2465 return honor_nans
? UNGT_EXPR
: GT_EXPR
;
2479 return UNORDERED_EXPR
;
2480 case UNORDERED_EXPR
:
2481 return ORDERED_EXPR
;
2487 /* Similar, but return the comparison that results if the operands are
2488 swapped. This is safe for floating-point. */
2491 swap_tree_comparison (enum tree_code code
)
2498 case UNORDERED_EXPR
:
2524 /* Convert a comparison tree code from an enum tree_code representation
2525 into a compcode bit-based encoding. This function is the inverse of
2526 compcode_to_comparison. */
2528 static enum comparison_code
2529 comparison_to_compcode (enum tree_code code
)
2546 return COMPCODE_ORD
;
2547 case UNORDERED_EXPR
:
2548 return COMPCODE_UNORD
;
2550 return COMPCODE_UNLT
;
2552 return COMPCODE_UNEQ
;
2554 return COMPCODE_UNLE
;
2556 return COMPCODE_UNGT
;
2558 return COMPCODE_LTGT
;
2560 return COMPCODE_UNGE
;
2566 /* Convert a compcode bit-based encoding of a comparison operator back
2567 to GCC's enum tree_code representation. This function is the
2568 inverse of comparison_to_compcode. */
2570 static enum tree_code
2571 compcode_to_comparison (enum comparison_code code
)
2588 return ORDERED_EXPR
;
2589 case COMPCODE_UNORD
:
2590 return UNORDERED_EXPR
;
2608 /* Return a tree for the comparison which is the combination of
2609 doing the AND or OR (depending on CODE) of the two operations LCODE
2610 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2611 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2612 if this makes the transformation invalid. */
2615 combine_comparisons (location_t loc
,
2616 enum tree_code code
, enum tree_code lcode
,
2617 enum tree_code rcode
, tree truth_type
,
2618 tree ll_arg
, tree lr_arg
)
2620 bool honor_nans
= HONOR_NANS (ll_arg
);
2621 enum comparison_code lcompcode
= comparison_to_compcode (lcode
);
2622 enum comparison_code rcompcode
= comparison_to_compcode (rcode
);
2627 case TRUTH_AND_EXPR
: case TRUTH_ANDIF_EXPR
:
2628 compcode
= lcompcode
& rcompcode
;
2631 case TRUTH_OR_EXPR
: case TRUTH_ORIF_EXPR
:
2632 compcode
= lcompcode
| rcompcode
;
2641 /* Eliminate unordered comparisons, as well as LTGT and ORD
2642 which are not used unless the mode has NaNs. */
2643 compcode
&= ~COMPCODE_UNORD
;
2644 if (compcode
== COMPCODE_LTGT
)
2645 compcode
= COMPCODE_NE
;
2646 else if (compcode
== COMPCODE_ORD
)
2647 compcode
= COMPCODE_TRUE
;
2649 else if (flag_trapping_math
)
2651 /* Check that the original operation and the optimized ones will trap
2652 under the same condition. */
2653 bool ltrap
= (lcompcode
& COMPCODE_UNORD
) == 0
2654 && (lcompcode
!= COMPCODE_EQ
)
2655 && (lcompcode
!= COMPCODE_ORD
);
2656 bool rtrap
= (rcompcode
& COMPCODE_UNORD
) == 0
2657 && (rcompcode
!= COMPCODE_EQ
)
2658 && (rcompcode
!= COMPCODE_ORD
);
2659 bool trap
= (compcode
& COMPCODE_UNORD
) == 0
2660 && (compcode
!= COMPCODE_EQ
)
2661 && (compcode
!= COMPCODE_ORD
);
2663 /* In a short-circuited boolean expression the LHS might be
2664 such that the RHS, if evaluated, will never trap. For
2665 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2666 if neither x nor y is NaN. (This is a mixed blessing: for
2667 example, the expression above will never trap, hence
2668 optimizing it to x < y would be invalid). */
2669 if ((code
== TRUTH_ORIF_EXPR
&& (lcompcode
& COMPCODE_UNORD
))
2670 || (code
== TRUTH_ANDIF_EXPR
&& !(lcompcode
& COMPCODE_UNORD
)))
2673 /* If the comparison was short-circuited, and only the RHS
2674 trapped, we may now generate a spurious trap. */
2676 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2679 /* If we changed the conditions that cause a trap, we lose. */
2680 if ((ltrap
|| rtrap
) != trap
)
2684 if (compcode
== COMPCODE_TRUE
)
2685 return constant_boolean_node (true, truth_type
);
2686 else if (compcode
== COMPCODE_FALSE
)
2687 return constant_boolean_node (false, truth_type
);
2690 enum tree_code tcode
;
2692 tcode
= compcode_to_comparison ((enum comparison_code
) compcode
);
2693 return fold_build2_loc (loc
, tcode
, truth_type
, ll_arg
, lr_arg
);
2697 /* Return nonzero if two operands (typically of the same tree node)
2698 are necessarily equal. FLAGS modifies behavior as follows:
2700 If OEP_ONLY_CONST is set, only return nonzero for constants.
2701 This function tests whether the operands are indistinguishable;
2702 it does not test whether they are equal using C's == operation.
2703 The distinction is important for IEEE floating point, because
2704 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2705 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2707 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2708 even though it may hold multiple values during a function.
2709 This is because a GCC tree node guarantees that nothing else is
2710 executed between the evaluation of its "operands" (which may often
2711 be evaluated in arbitrary order). Hence if the operands themselves
2712 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2713 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2714 unset means assuming isochronic (or instantaneous) tree equivalence.
2715 Unless comparing arbitrary expression trees, such as from different
2716 statements, this flag can usually be left unset.
2718 If OEP_PURE_SAME is set, then pure functions with identical arguments
2719 are considered the same. It is used when the caller has other ways
2720 to ensure that global memory is unchanged in between.
2722 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2723 not values of expressions.
2725 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2726 any operand with side effect. This is unnecesarily conservative in the
2727 case we know that arg0 and arg1 are in disjoint code paths (such as in
2728 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2729 addresses with TREE_CONSTANT flag set so we know that &var == &var
2730 even if var is volatile. */
2733 operand_equal_p (const_tree arg0
, const_tree arg1
, unsigned int flags
)
2735 /* When checking, verify at the outermost operand_equal_p call that
2736 if operand_equal_p returns non-zero then ARG0 and ARG1 has the same
2738 if (flag_checking
&& !(flags
& OEP_NO_HASH_CHECK
))
2740 if (operand_equal_p (arg0
, arg1
, flags
| OEP_NO_HASH_CHECK
))
2744 inchash::hash
hstate0 (0), hstate1 (0);
2745 inchash::add_expr (arg0
, hstate0
, flags
| OEP_HASH_CHECK
);
2746 inchash::add_expr (arg1
, hstate1
, flags
| OEP_HASH_CHECK
);
2747 hashval_t h0
= hstate0
.end ();
2748 hashval_t h1
= hstate1
.end ();
2749 gcc_assert (h0
== h1
);
2757 /* If either is ERROR_MARK, they aren't equal. */
2758 if (TREE_CODE (arg0
) == ERROR_MARK
|| TREE_CODE (arg1
) == ERROR_MARK
2759 || TREE_TYPE (arg0
) == error_mark_node
2760 || TREE_TYPE (arg1
) == error_mark_node
)
2763 /* Similar, if either does not have a type (like a released SSA name),
2764 they aren't equal. */
2765 if (!TREE_TYPE (arg0
) || !TREE_TYPE (arg1
))
2768 /* We cannot consider pointers to different address space equal. */
2769 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
2770 && POINTER_TYPE_P (TREE_TYPE (arg1
))
2771 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
)))
2772 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1
)))))
2775 /* Check equality of integer constants before bailing out due to
2776 precision differences. */
2777 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2779 /* Address of INTEGER_CST is not defined; check that we did not forget
2780 to drop the OEP_ADDRESS_OF flags. */
2781 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
2782 return tree_int_cst_equal (arg0
, arg1
);
2785 if (!(flags
& OEP_ADDRESS_OF
))
2787 /* If both types don't have the same signedness, then we can't consider
2788 them equal. We must check this before the STRIP_NOPS calls
2789 because they may change the signedness of the arguments. As pointers
2790 strictly don't have a signedness, require either two pointers or
2791 two non-pointers as well. */
2792 if (TYPE_UNSIGNED (TREE_TYPE (arg0
)) != TYPE_UNSIGNED (TREE_TYPE (arg1
))
2793 || POINTER_TYPE_P (TREE_TYPE (arg0
))
2794 != POINTER_TYPE_P (TREE_TYPE (arg1
)))
2797 /* If both types don't have the same precision, then it is not safe
2799 if (element_precision (TREE_TYPE (arg0
))
2800 != element_precision (TREE_TYPE (arg1
)))
2807 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2808 sanity check once the issue is solved. */
2810 /* Addresses of conversions and SSA_NAMEs (and many other things)
2811 are not defined. Check that we did not forget to drop the
2812 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2813 gcc_checking_assert (!CONVERT_EXPR_P (arg0
) && !CONVERT_EXPR_P (arg1
)
2814 && TREE_CODE (arg0
) != SSA_NAME
);
2817 /* In case both args are comparisons but with different comparison
2818 code, try to swap the comparison operands of one arg to produce
2819 a match and compare that variant. */
2820 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2821 && COMPARISON_CLASS_P (arg0
)
2822 && COMPARISON_CLASS_P (arg1
))
2824 enum tree_code swap_code
= swap_tree_comparison (TREE_CODE (arg1
));
2826 if (TREE_CODE (arg0
) == swap_code
)
2827 return operand_equal_p (TREE_OPERAND (arg0
, 0),
2828 TREE_OPERAND (arg1
, 1), flags
)
2829 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2830 TREE_OPERAND (arg1
, 0), flags
);
2833 if (TREE_CODE (arg0
) != TREE_CODE (arg1
))
2835 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2836 if (CONVERT_EXPR_P (arg0
) && CONVERT_EXPR_P (arg1
))
2838 else if (flags
& OEP_ADDRESS_OF
)
2840 /* If we are interested in comparing addresses ignore
2841 MEM_REF wrappings of the base that can appear just for
2843 if (TREE_CODE (arg0
) == MEM_REF
2845 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ADDR_EXPR
2846 && TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0) == arg1
2847 && integer_zerop (TREE_OPERAND (arg0
, 1)))
2849 else if (TREE_CODE (arg1
) == MEM_REF
2851 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ADDR_EXPR
2852 && TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0) == arg0
2853 && integer_zerop (TREE_OPERAND (arg1
, 1)))
2861 /* When not checking adddresses, this is needed for conversions and for
2862 COMPONENT_REF. Might as well play it safe and always test this. */
2863 if (TREE_CODE (TREE_TYPE (arg0
)) == ERROR_MARK
2864 || TREE_CODE (TREE_TYPE (arg1
)) == ERROR_MARK
2865 || (TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
))
2866 && !(flags
& OEP_ADDRESS_OF
)))
2869 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2870 We don't care about side effects in that case because the SAVE_EXPR
2871 takes care of that for us. In all other cases, two expressions are
2872 equal if they have no side effects. If we have two identical
2873 expressions with side effects that should be treated the same due
2874 to the only side effects being identical SAVE_EXPR's, that will
2875 be detected in the recursive calls below.
2876 If we are taking an invariant address of two identical objects
2877 they are necessarily equal as well. */
2878 if (arg0
== arg1
&& ! (flags
& OEP_ONLY_CONST
)
2879 && (TREE_CODE (arg0
) == SAVE_EXPR
2880 || (flags
& OEP_MATCH_SIDE_EFFECTS
)
2881 || (! TREE_SIDE_EFFECTS (arg0
) && ! TREE_SIDE_EFFECTS (arg1
))))
2884 /* Next handle constant cases, those for which we can return 1 even
2885 if ONLY_CONST is set. */
2886 if (TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
))
2887 switch (TREE_CODE (arg0
))
2890 return tree_int_cst_equal (arg0
, arg1
);
2893 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0
),
2894 TREE_FIXED_CST (arg1
));
2897 if (real_identical (&TREE_REAL_CST (arg0
), &TREE_REAL_CST (arg1
)))
2901 if (!HONOR_SIGNED_ZEROS (arg0
))
2903 /* If we do not distinguish between signed and unsigned zero,
2904 consider them equal. */
2905 if (real_zerop (arg0
) && real_zerop (arg1
))
2914 if (VECTOR_CST_NELTS (arg0
) != VECTOR_CST_NELTS (arg1
))
2917 for (i
= 0; i
< VECTOR_CST_NELTS (arg0
); ++i
)
2919 if (!operand_equal_p (VECTOR_CST_ELT (arg0
, i
),
2920 VECTOR_CST_ELT (arg1
, i
), flags
))
2927 return (operand_equal_p (TREE_REALPART (arg0
), TREE_REALPART (arg1
),
2929 && operand_equal_p (TREE_IMAGPART (arg0
), TREE_IMAGPART (arg1
),
2933 return (TREE_STRING_LENGTH (arg0
) == TREE_STRING_LENGTH (arg1
)
2934 && ! memcmp (TREE_STRING_POINTER (arg0
),
2935 TREE_STRING_POINTER (arg1
),
2936 TREE_STRING_LENGTH (arg0
)));
2939 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
2940 return operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0),
2941 flags
| OEP_ADDRESS_OF
2942 | OEP_MATCH_SIDE_EFFECTS
);
2944 /* In GIMPLE empty constructors are allowed in initializers of
2946 return !CONSTRUCTOR_NELTS (arg0
) && !CONSTRUCTOR_NELTS (arg1
);
2951 if (flags
& OEP_ONLY_CONST
)
2954 /* Define macros to test an operand from arg0 and arg1 for equality and a
2955 variant that allows null and views null as being different from any
2956 non-null value. In the latter case, if either is null, the both
2957 must be; otherwise, do the normal comparison. */
2958 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2959 TREE_OPERAND (arg1, N), flags)
2961 #define OP_SAME_WITH_NULL(N) \
2962 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2963 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2965 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
2968 /* Two conversions are equal only if signedness and modes match. */
2969 switch (TREE_CODE (arg0
))
2972 case FIX_TRUNC_EXPR
:
2973 if (TYPE_UNSIGNED (TREE_TYPE (arg0
))
2974 != TYPE_UNSIGNED (TREE_TYPE (arg1
)))
2984 case tcc_comparison
:
2986 if (OP_SAME (0) && OP_SAME (1))
2989 /* For commutative ops, allow the other order. */
2990 return (commutative_tree_code (TREE_CODE (arg0
))
2991 && operand_equal_p (TREE_OPERAND (arg0
, 0),
2992 TREE_OPERAND (arg1
, 1), flags
)
2993 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2994 TREE_OPERAND (arg1
, 0), flags
));
2997 /* If either of the pointer (or reference) expressions we are
2998 dereferencing contain a side effect, these cannot be equal,
2999 but their addresses can be. */
3000 if ((flags
& OEP_MATCH_SIDE_EFFECTS
) == 0
3001 && (TREE_SIDE_EFFECTS (arg0
)
3002 || TREE_SIDE_EFFECTS (arg1
)))
3005 switch (TREE_CODE (arg0
))
3008 if (!(flags
& OEP_ADDRESS_OF
)
3009 && (TYPE_ALIGN (TREE_TYPE (arg0
))
3010 != TYPE_ALIGN (TREE_TYPE (arg1
))))
3012 flags
&= ~OEP_ADDRESS_OF
;
3016 /* Require the same offset. */
3017 if (!operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3018 TYPE_SIZE (TREE_TYPE (arg1
)),
3019 flags
& ~OEP_ADDRESS_OF
))
3024 case VIEW_CONVERT_EXPR
:
3027 case TARGET_MEM_REF
:
3029 if (!(flags
& OEP_ADDRESS_OF
))
3031 /* Require equal access sizes */
3032 if (TYPE_SIZE (TREE_TYPE (arg0
)) != TYPE_SIZE (TREE_TYPE (arg1
))
3033 && (!TYPE_SIZE (TREE_TYPE (arg0
))
3034 || !TYPE_SIZE (TREE_TYPE (arg1
))
3035 || !operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3036 TYPE_SIZE (TREE_TYPE (arg1
)),
3039 /* Verify that access happens in similar types. */
3040 if (!types_compatible_p (TREE_TYPE (arg0
), TREE_TYPE (arg1
)))
3042 /* Verify that accesses are TBAA compatible. */
3043 if (!alias_ptr_types_compatible_p
3044 (TREE_TYPE (TREE_OPERAND (arg0
, 1)),
3045 TREE_TYPE (TREE_OPERAND (arg1
, 1)))
3046 || (MR_DEPENDENCE_CLIQUE (arg0
)
3047 != MR_DEPENDENCE_CLIQUE (arg1
))
3048 || (MR_DEPENDENCE_BASE (arg0
)
3049 != MR_DEPENDENCE_BASE (arg1
)))
3051 /* Verify that alignment is compatible. */
3052 if (TYPE_ALIGN (TREE_TYPE (arg0
))
3053 != TYPE_ALIGN (TREE_TYPE (arg1
)))
3056 flags
&= ~OEP_ADDRESS_OF
;
3057 return (OP_SAME (0) && OP_SAME (1)
3058 /* TARGET_MEM_REF require equal extra operands. */
3059 && (TREE_CODE (arg0
) != TARGET_MEM_REF
3060 || (OP_SAME_WITH_NULL (2)
3061 && OP_SAME_WITH_NULL (3)
3062 && OP_SAME_WITH_NULL (4))));
3065 case ARRAY_RANGE_REF
:
3068 flags
&= ~OEP_ADDRESS_OF
;
3069 /* Compare the array index by value if it is constant first as we
3070 may have different types but same value here. */
3071 return ((tree_int_cst_equal (TREE_OPERAND (arg0
, 1),
3072 TREE_OPERAND (arg1
, 1))
3074 && OP_SAME_WITH_NULL (2)
3075 && OP_SAME_WITH_NULL (3)
3076 /* Compare low bound and element size as with OEP_ADDRESS_OF
3077 we have to account for the offset of the ref. */
3078 && (TREE_TYPE (TREE_OPERAND (arg0
, 0))
3079 == TREE_TYPE (TREE_OPERAND (arg1
, 0))
3080 || (operand_equal_p (array_ref_low_bound
3081 (CONST_CAST_TREE (arg0
)),
3083 (CONST_CAST_TREE (arg1
)), flags
)
3084 && operand_equal_p (array_ref_element_size
3085 (CONST_CAST_TREE (arg0
)),
3086 array_ref_element_size
3087 (CONST_CAST_TREE (arg1
)),
3091 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3092 may be NULL when we're called to compare MEM_EXPRs. */
3093 if (!OP_SAME_WITH_NULL (0)
3096 flags
&= ~OEP_ADDRESS_OF
;
3097 return OP_SAME_WITH_NULL (2);
3102 flags
&= ~OEP_ADDRESS_OF
;
3103 return OP_SAME (1) && OP_SAME (2);
3109 case tcc_expression
:
3110 switch (TREE_CODE (arg0
))
3113 /* Be sure we pass right ADDRESS_OF flag. */
3114 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
3115 return operand_equal_p (TREE_OPERAND (arg0
, 0),
3116 TREE_OPERAND (arg1
, 0),
3117 flags
| OEP_ADDRESS_OF
);
3119 case TRUTH_NOT_EXPR
:
3122 case TRUTH_ANDIF_EXPR
:
3123 case TRUTH_ORIF_EXPR
:
3124 return OP_SAME (0) && OP_SAME (1);
3127 case WIDEN_MULT_PLUS_EXPR
:
3128 case WIDEN_MULT_MINUS_EXPR
:
3131 /* The multiplcation operands are commutative. */
3134 case TRUTH_AND_EXPR
:
3136 case TRUTH_XOR_EXPR
:
3137 if (OP_SAME (0) && OP_SAME (1))
3140 /* Otherwise take into account this is a commutative operation. */
3141 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
3142 TREE_OPERAND (arg1
, 1), flags
)
3143 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3144 TREE_OPERAND (arg1
, 0), flags
));
3147 if (! OP_SAME (1) || ! OP_SAME (2))
3149 flags
&= ~OEP_ADDRESS_OF
;
3154 case BIT_INSERT_EXPR
:
3155 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3162 switch (TREE_CODE (arg0
))
3165 if ((CALL_EXPR_FN (arg0
) == NULL_TREE
)
3166 != (CALL_EXPR_FN (arg1
) == NULL_TREE
))
3167 /* If not both CALL_EXPRs are either internal or normal function
3168 functions, then they are not equal. */
3170 else if (CALL_EXPR_FN (arg0
) == NULL_TREE
)
3172 /* If the CALL_EXPRs call different internal functions, then they
3174 if (CALL_EXPR_IFN (arg0
) != CALL_EXPR_IFN (arg1
))
3179 /* If the CALL_EXPRs call different functions, then they are not
3181 if (! operand_equal_p (CALL_EXPR_FN (arg0
), CALL_EXPR_FN (arg1
),
3186 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3188 unsigned int cef
= call_expr_flags (arg0
);
3189 if (flags
& OEP_PURE_SAME
)
3190 cef
&= ECF_CONST
| ECF_PURE
;
3197 /* Now see if all the arguments are the same. */
3199 const_call_expr_arg_iterator iter0
, iter1
;
3201 for (a0
= first_const_call_expr_arg (arg0
, &iter0
),
3202 a1
= first_const_call_expr_arg (arg1
, &iter1
);
3204 a0
= next_const_call_expr_arg (&iter0
),
3205 a1
= next_const_call_expr_arg (&iter1
))
3206 if (! operand_equal_p (a0
, a1
, flags
))
3209 /* If we get here and both argument lists are exhausted
3210 then the CALL_EXPRs are equal. */
3211 return ! (a0
|| a1
);
3217 case tcc_declaration
:
3218 /* Consider __builtin_sqrt equal to sqrt. */
3219 return (TREE_CODE (arg0
) == FUNCTION_DECL
3220 && DECL_BUILT_IN (arg0
) && DECL_BUILT_IN (arg1
)
3221 && DECL_BUILT_IN_CLASS (arg0
) == DECL_BUILT_IN_CLASS (arg1
)
3222 && DECL_FUNCTION_CODE (arg0
) == DECL_FUNCTION_CODE (arg1
));
3224 case tcc_exceptional
:
3225 if (TREE_CODE (arg0
) == CONSTRUCTOR
)
3227 /* In GIMPLE constructors are used only to build vectors from
3228 elements. Individual elements in the constructor must be
3229 indexed in increasing order and form an initial sequence.
3231 We make no effort to compare constructors in generic.
3232 (see sem_variable::equals in ipa-icf which can do so for
3234 if (!VECTOR_TYPE_P (TREE_TYPE (arg0
))
3235 || !VECTOR_TYPE_P (TREE_TYPE (arg1
)))
3238 /* Be sure that vectors constructed have the same representation.
3239 We only tested element precision and modes to match.
3240 Vectors may be BLKmode and thus also check that the number of
3242 if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
))
3243 != TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)))
3246 vec
<constructor_elt
, va_gc
> *v0
= CONSTRUCTOR_ELTS (arg0
);
3247 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (arg1
);
3248 unsigned int len
= vec_safe_length (v0
);
3250 if (len
!= vec_safe_length (v1
))
3253 for (unsigned int i
= 0; i
< len
; i
++)
3255 constructor_elt
*c0
= &(*v0
)[i
];
3256 constructor_elt
*c1
= &(*v1
)[i
];
3258 if (!operand_equal_p (c0
->value
, c1
->value
, flags
)
3259 /* In GIMPLE the indexes can be either NULL or matching i.
3260 Double check this so we won't get false
3261 positives for GENERIC. */
3263 && (TREE_CODE (c0
->index
) != INTEGER_CST
3264 || !compare_tree_int (c0
->index
, i
)))
3266 && (TREE_CODE (c1
->index
) != INTEGER_CST
3267 || !compare_tree_int (c1
->index
, i
))))
3279 #undef OP_SAME_WITH_NULL
3282 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3283 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3285 When in doubt, return 0. */
3288 operand_equal_for_comparison_p (tree arg0
, tree arg1
, tree other
)
3290 int unsignedp1
, unsignedpo
;
3291 tree primarg0
, primarg1
, primother
;
3292 unsigned int correct_width
;
3294 if (operand_equal_p (arg0
, arg1
, 0))
3297 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
3298 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
3301 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3302 and see if the inner values are the same. This removes any
3303 signedness comparison, which doesn't matter here. */
3304 primarg0
= arg0
, primarg1
= arg1
;
3305 STRIP_NOPS (primarg0
);
3306 STRIP_NOPS (primarg1
);
3307 if (operand_equal_p (primarg0
, primarg1
, 0))
3310 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3311 actual comparison operand, ARG0.
3313 First throw away any conversions to wider types
3314 already present in the operands. */
3316 primarg1
= get_narrower (arg1
, &unsignedp1
);
3317 primother
= get_narrower (other
, &unsignedpo
);
3319 correct_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
3320 if (unsignedp1
== unsignedpo
3321 && TYPE_PRECISION (TREE_TYPE (primarg1
)) < correct_width
3322 && TYPE_PRECISION (TREE_TYPE (primother
)) < correct_width
)
3324 tree type
= TREE_TYPE (arg0
);
3326 /* Make sure shorter operand is extended the right way
3327 to match the longer operand. */
3328 primarg1
= fold_convert (signed_or_unsigned_type_for
3329 (unsignedp1
, TREE_TYPE (primarg1
)), primarg1
);
3331 if (operand_equal_p (arg0
, fold_convert (type
, primarg1
), 0))
3338 /* See if ARG is an expression that is either a comparison or is performing
3339 arithmetic on comparisons. The comparisons must only be comparing
3340 two different values, which will be stored in *CVAL1 and *CVAL2; if
3341 they are nonzero it means that some operands have already been found.
3342 No variables may be used anywhere else in the expression except in the
3343 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
3344 the expression and save_expr needs to be called with CVAL1 and CVAL2.
3346 If this is true, return 1. Otherwise, return zero. */
3349 twoval_comparison_p (tree arg
, tree
*cval1
, tree
*cval2
, int *save_p
)
3351 enum tree_code code
= TREE_CODE (arg
);
3352 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3354 /* We can handle some of the tcc_expression cases here. */
3355 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3357 else if (tclass
== tcc_expression
3358 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
3359 || code
== COMPOUND_EXPR
))
3360 tclass
= tcc_binary
;
3362 else if (tclass
== tcc_expression
&& code
== SAVE_EXPR
3363 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
3365 /* If we've already found a CVAL1 or CVAL2, this expression is
3366 two complex to handle. */
3367 if (*cval1
|| *cval2
)
3377 return twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
);
3380 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
)
3381 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
3382 cval1
, cval2
, save_p
));
3387 case tcc_expression
:
3388 if (code
== COND_EXPR
)
3389 return (twoval_comparison_p (TREE_OPERAND (arg
, 0),
3390 cval1
, cval2
, save_p
)
3391 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
3392 cval1
, cval2
, save_p
)
3393 && twoval_comparison_p (TREE_OPERAND (arg
, 2),
3394 cval1
, cval2
, save_p
));
3397 case tcc_comparison
:
3398 /* First see if we can handle the first operand, then the second. For
3399 the second operand, we know *CVAL1 can't be zero. It must be that
3400 one side of the comparison is each of the values; test for the
3401 case where this isn't true by failing if the two operands
3404 if (operand_equal_p (TREE_OPERAND (arg
, 0),
3405 TREE_OPERAND (arg
, 1), 0))
3409 *cval1
= TREE_OPERAND (arg
, 0);
3410 else if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 0), 0))
3412 else if (*cval2
== 0)
3413 *cval2
= TREE_OPERAND (arg
, 0);
3414 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 0), 0))
3419 if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 1), 0))
3421 else if (*cval2
== 0)
3422 *cval2
= TREE_OPERAND (arg
, 1);
3423 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 1), 0))
3435 /* ARG is a tree that is known to contain just arithmetic operations and
3436 comparisons. Evaluate the operations in the tree substituting NEW0 for
3437 any occurrence of OLD0 as an operand of a comparison and likewise for
3441 eval_subst (location_t loc
, tree arg
, tree old0
, tree new0
,
3442 tree old1
, tree new1
)
3444 tree type
= TREE_TYPE (arg
);
3445 enum tree_code code
= TREE_CODE (arg
);
3446 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3448 /* We can handle some of the tcc_expression cases here. */
3449 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3451 else if (tclass
== tcc_expression
3452 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
3453 tclass
= tcc_binary
;
3458 return fold_build1_loc (loc
, code
, type
,
3459 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3460 old0
, new0
, old1
, new1
));
3463 return fold_build2_loc (loc
, code
, type
,
3464 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3465 old0
, new0
, old1
, new1
),
3466 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3467 old0
, new0
, old1
, new1
));
3469 case tcc_expression
:
3473 return eval_subst (loc
, TREE_OPERAND (arg
, 0), old0
, new0
,
3477 return eval_subst (loc
, TREE_OPERAND (arg
, 1), old0
, new0
,
3481 return fold_build3_loc (loc
, code
, type
,
3482 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3483 old0
, new0
, old1
, new1
),
3484 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3485 old0
, new0
, old1
, new1
),
3486 eval_subst (loc
, TREE_OPERAND (arg
, 2),
3487 old0
, new0
, old1
, new1
));
3491 /* Fall through - ??? */
3493 case tcc_comparison
:
3495 tree arg0
= TREE_OPERAND (arg
, 0);
3496 tree arg1
= TREE_OPERAND (arg
, 1);
3498 /* We need to check both for exact equality and tree equality. The
3499 former will be true if the operand has a side-effect. In that
3500 case, we know the operand occurred exactly once. */
3502 if (arg0
== old0
|| operand_equal_p (arg0
, old0
, 0))
3504 else if (arg0
== old1
|| operand_equal_p (arg0
, old1
, 0))
3507 if (arg1
== old0
|| operand_equal_p (arg1
, old0
, 0))
3509 else if (arg1
== old1
|| operand_equal_p (arg1
, old1
, 0))
3512 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
3520 /* Return a tree for the case when the result of an expression is RESULT
3521 converted to TYPE and OMITTED was previously an operand of the expression
3522 but is now not needed (e.g., we folded OMITTED * 0).
3524 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3525 the conversion of RESULT to TYPE. */
3528 omit_one_operand_loc (location_t loc
, tree type
, tree result
, tree omitted
)
3530 tree t
= fold_convert_loc (loc
, type
, result
);
3532 /* If the resulting operand is an empty statement, just return the omitted
3533 statement casted to void. */
3534 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
3535 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
3536 fold_ignored_result (omitted
));
3538 if (TREE_SIDE_EFFECTS (omitted
))
3539 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3540 fold_ignored_result (omitted
), t
);
3542 return non_lvalue_loc (loc
, t
);
3545 /* Return a tree for the case when the result of an expression is RESULT
3546 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3547 of the expression but are now not needed.
3549 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3550 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3551 evaluated before OMITTED2. Otherwise, if neither has side effects,
3552 just do the conversion of RESULT to TYPE. */
3555 omit_two_operands_loc (location_t loc
, tree type
, tree result
,
3556 tree omitted1
, tree omitted2
)
3558 tree t
= fold_convert_loc (loc
, type
, result
);
3560 if (TREE_SIDE_EFFECTS (omitted2
))
3561 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted2
, t
);
3562 if (TREE_SIDE_EFFECTS (omitted1
))
3563 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted1
, t
);
3565 return TREE_CODE (t
) != COMPOUND_EXPR
? non_lvalue_loc (loc
, t
) : t
;
3569 /* Return a simplified tree node for the truth-negation of ARG. This
3570 never alters ARG itself. We assume that ARG is an operation that
3571 returns a truth value (0 or 1).
3573 FIXME: one would think we would fold the result, but it causes
3574 problems with the dominator optimizer. */
3577 fold_truth_not_expr (location_t loc
, tree arg
)
3579 tree type
= TREE_TYPE (arg
);
3580 enum tree_code code
= TREE_CODE (arg
);
3581 location_t loc1
, loc2
;
3583 /* If this is a comparison, we can simply invert it, except for
3584 floating-point non-equality comparisons, in which case we just
3585 enclose a TRUTH_NOT_EXPR around what we have. */
3587 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3589 tree op_type
= TREE_TYPE (TREE_OPERAND (arg
, 0));
3590 if (FLOAT_TYPE_P (op_type
)
3591 && flag_trapping_math
3592 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
3593 && code
!= NE_EXPR
&& code
!= EQ_EXPR
)
3596 code
= invert_tree_comparison (code
, HONOR_NANS (op_type
));
3597 if (code
== ERROR_MARK
)
3600 tree ret
= build2_loc (loc
, code
, type
, TREE_OPERAND (arg
, 0),
3601 TREE_OPERAND (arg
, 1));
3602 if (TREE_NO_WARNING (arg
))
3603 TREE_NO_WARNING (ret
) = 1;
3610 return constant_boolean_node (integer_zerop (arg
), type
);
3612 case TRUTH_AND_EXPR
:
3613 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3614 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3615 return build2_loc (loc
, TRUTH_OR_EXPR
, type
,
3616 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3617 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3620 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3621 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3622 return build2_loc (loc
, TRUTH_AND_EXPR
, type
,
3623 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3624 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3626 case TRUTH_XOR_EXPR
:
3627 /* Here we can invert either operand. We invert the first operand
3628 unless the second operand is a TRUTH_NOT_EXPR in which case our
3629 result is the XOR of the first operand with the inside of the
3630 negation of the second operand. */
3632 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == TRUTH_NOT_EXPR
)
3633 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
, TREE_OPERAND (arg
, 0),
3634 TREE_OPERAND (TREE_OPERAND (arg
, 1), 0));
3636 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
,
3637 invert_truthvalue_loc (loc
, TREE_OPERAND (arg
, 0)),
3638 TREE_OPERAND (arg
, 1));
3640 case TRUTH_ANDIF_EXPR
:
3641 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3642 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3643 return build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
3644 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3645 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3647 case TRUTH_ORIF_EXPR
:
3648 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3649 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3650 return build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
3651 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3652 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3654 case TRUTH_NOT_EXPR
:
3655 return TREE_OPERAND (arg
, 0);
3659 tree arg1
= TREE_OPERAND (arg
, 1);
3660 tree arg2
= TREE_OPERAND (arg
, 2);
3662 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3663 loc2
= expr_location_or (TREE_OPERAND (arg
, 2), loc
);
3665 /* A COND_EXPR may have a throw as one operand, which
3666 then has void type. Just leave void operands
3668 return build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
3669 VOID_TYPE_P (TREE_TYPE (arg1
))
3670 ? arg1
: invert_truthvalue_loc (loc1
, arg1
),
3671 VOID_TYPE_P (TREE_TYPE (arg2
))
3672 ? arg2
: invert_truthvalue_loc (loc2
, arg2
));
3676 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3677 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3678 TREE_OPERAND (arg
, 0),
3679 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 1)));
3681 case NON_LVALUE_EXPR
:
3682 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3683 return invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0));
3686 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
3687 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3692 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3693 return build1_loc (loc
, TREE_CODE (arg
), type
,
3694 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3697 if (!integer_onep (TREE_OPERAND (arg
, 1)))
3699 return build2_loc (loc
, EQ_EXPR
, type
, arg
, build_int_cst (type
, 0));
3702 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3704 case CLEANUP_POINT_EXPR
:
3705 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3706 return build1_loc (loc
, CLEANUP_POINT_EXPR
, type
,
3707 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3714 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3715 assume that ARG is an operation that returns a truth value (0 or 1
3716 for scalars, 0 or -1 for vectors). Return the folded expression if
3717 folding is successful. Otherwise, return NULL_TREE. */
3720 fold_invert_truthvalue (location_t loc
, tree arg
)
3722 tree type
= TREE_TYPE (arg
);
3723 return fold_unary_loc (loc
, VECTOR_TYPE_P (type
)
3729 /* Return a simplified tree node for the truth-negation of ARG. This
3730 never alters ARG itself. We assume that ARG is an operation that
3731 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3734 invert_truthvalue_loc (location_t loc
, tree arg
)
3736 if (TREE_CODE (arg
) == ERROR_MARK
)
3739 tree type
= TREE_TYPE (arg
);
3740 return fold_build1_loc (loc
, VECTOR_TYPE_P (type
)
3746 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3747 with code CODE. This optimization is unsafe. */
3749 distribute_real_division (location_t loc
, enum tree_code code
, tree type
,
3750 tree arg0
, tree arg1
)
3752 bool mul0
= TREE_CODE (arg0
) == MULT_EXPR
;
3753 bool mul1
= TREE_CODE (arg1
) == MULT_EXPR
;
3755 /* (A / C) +- (B / C) -> (A +- B) / C. */
3757 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3758 TREE_OPERAND (arg1
, 1), 0))
3759 return fold_build2_loc (loc
, mul0
? MULT_EXPR
: RDIV_EXPR
, type
,
3760 fold_build2_loc (loc
, code
, type
,
3761 TREE_OPERAND (arg0
, 0),
3762 TREE_OPERAND (arg1
, 0)),
3763 TREE_OPERAND (arg0
, 1));
3765 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3766 if (operand_equal_p (TREE_OPERAND (arg0
, 0),
3767 TREE_OPERAND (arg1
, 0), 0)
3768 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
3769 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
3771 REAL_VALUE_TYPE r0
, r1
;
3772 r0
= TREE_REAL_CST (TREE_OPERAND (arg0
, 1));
3773 r1
= TREE_REAL_CST (TREE_OPERAND (arg1
, 1));
3775 real_arithmetic (&r0
, RDIV_EXPR
, &dconst1
, &r0
);
3777 real_arithmetic (&r1
, RDIV_EXPR
, &dconst1
, &r1
);
3778 real_arithmetic (&r0
, code
, &r0
, &r1
);
3779 return fold_build2_loc (loc
, MULT_EXPR
, type
,
3780 TREE_OPERAND (arg0
, 0),
3781 build_real (type
, r0
));
3787 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3788 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3789 and uses reverse storage order if REVERSEP is nonzero. ORIG_INNER
3790 is the original memory reference used to preserve the alias set of
3794 make_bit_field_ref (location_t loc
, tree inner
, tree orig_inner
, tree type
,
3795 HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
,
3796 int unsignedp
, int reversep
)
3798 tree result
, bftype
;
3800 alias_set_type iset
= get_alias_set (orig_inner
);
3801 if (iset
== 0 && get_alias_set (inner
) != iset
)
3802 inner
= fold_build2 (MEM_REF
, TREE_TYPE (inner
),
3803 build_fold_addr_expr (inner
),
3804 build_int_cst (ptr_type_node
, 0));
3806 if (bitpos
== 0 && !reversep
)
3808 tree size
= TYPE_SIZE (TREE_TYPE (inner
));
3809 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner
))
3810 || POINTER_TYPE_P (TREE_TYPE (inner
)))
3811 && tree_fits_shwi_p (size
)
3812 && tree_to_shwi (size
) == bitsize
)
3813 return fold_convert_loc (loc
, type
, inner
);
3817 if (TYPE_PRECISION (bftype
) != bitsize
3818 || TYPE_UNSIGNED (bftype
) == !unsignedp
)
3819 bftype
= build_nonstandard_integer_type (bitsize
, 0);
3821 result
= build3_loc (loc
, BIT_FIELD_REF
, bftype
, inner
,
3822 size_int (bitsize
), bitsize_int (bitpos
));
3823 REF_REVERSE_STORAGE_ORDER (result
) = reversep
;
3826 result
= fold_convert_loc (loc
, type
, result
);
3831 /* Optimize a bit-field compare.
3833 There are two cases: First is a compare against a constant and the
3834 second is a comparison of two items where the fields are at the same
3835 bit position relative to the start of a chunk (byte, halfword, word)
3836 large enough to contain it. In these cases we can avoid the shift
3837 implicit in bitfield extractions.
3839 For constants, we emit a compare of the shifted constant with the
3840 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3841 compared. For two fields at the same position, we do the ANDs with the
3842 similar mask and compare the result of the ANDs.
3844 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3845 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3846 are the left and right operands of the comparison, respectively.
3848 If the optimization described above can be done, we return the resulting
3849 tree. Otherwise we return zero. */
3852 optimize_bit_field_compare (location_t loc
, enum tree_code code
,
3853 tree compare_type
, tree lhs
, tree rhs
)
3855 HOST_WIDE_INT lbitpos
, lbitsize
, rbitpos
, rbitsize
, nbitpos
, nbitsize
;
3856 tree type
= TREE_TYPE (lhs
);
3858 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
3859 machine_mode lmode
, rmode
, nmode
;
3860 int lunsignedp
, runsignedp
;
3861 int lreversep
, rreversep
;
3862 int lvolatilep
= 0, rvolatilep
= 0;
3863 tree linner
, rinner
= NULL_TREE
;
3867 /* Get all the information about the extractions being done. If the bit size
3868 if the same as the size of the underlying object, we aren't doing an
3869 extraction at all and so can do nothing. We also don't want to
3870 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3871 then will no longer be able to replace it. */
3872 linner
= get_inner_reference (lhs
, &lbitsize
, &lbitpos
, &offset
, &lmode
,
3873 &lunsignedp
, &lreversep
, &lvolatilep
);
3874 if (linner
== lhs
|| lbitsize
== GET_MODE_BITSIZE (lmode
) || lbitsize
< 0
3875 || offset
!= 0 || TREE_CODE (linner
) == PLACEHOLDER_EXPR
|| lvolatilep
)
3879 rreversep
= lreversep
;
3882 /* If this is not a constant, we can only do something if bit positions,
3883 sizes, signedness and storage order are the same. */
3885 = get_inner_reference (rhs
, &rbitsize
, &rbitpos
, &offset
, &rmode
,
3886 &runsignedp
, &rreversep
, &rvolatilep
);
3888 if (rinner
== rhs
|| lbitpos
!= rbitpos
|| lbitsize
!= rbitsize
3889 || lunsignedp
!= runsignedp
|| lreversep
!= rreversep
|| offset
!= 0
3890 || TREE_CODE (rinner
) == PLACEHOLDER_EXPR
|| rvolatilep
)
3894 /* Honor the C++ memory model and mimic what RTL expansion does. */
3895 unsigned HOST_WIDE_INT bitstart
= 0;
3896 unsigned HOST_WIDE_INT bitend
= 0;
3897 if (TREE_CODE (lhs
) == COMPONENT_REF
)
3899 get_bit_range (&bitstart
, &bitend
, lhs
, &lbitpos
, &offset
);
3900 if (offset
!= NULL_TREE
)
3904 /* See if we can find a mode to refer to this field. We should be able to,
3905 but fail if we can't. */
3906 nmode
= get_best_mode (lbitsize
, lbitpos
, bitstart
, bitend
,
3907 const_p
? TYPE_ALIGN (TREE_TYPE (linner
))
3908 : MIN (TYPE_ALIGN (TREE_TYPE (linner
)),
3909 TYPE_ALIGN (TREE_TYPE (rinner
))),
3911 if (nmode
== VOIDmode
)
3914 /* Set signed and unsigned types of the precision of this mode for the
3916 unsigned_type
= lang_hooks
.types
.type_for_mode (nmode
, 1);
3918 /* Compute the bit position and size for the new reference and our offset
3919 within it. If the new reference is the same size as the original, we
3920 won't optimize anything, so return zero. */
3921 nbitsize
= GET_MODE_BITSIZE (nmode
);
3922 nbitpos
= lbitpos
& ~ (nbitsize
- 1);
3924 if (nbitsize
== lbitsize
)
3927 if (lreversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
3928 lbitpos
= nbitsize
- lbitsize
- lbitpos
;
3930 /* Make the mask to be used against the extracted field. */
3931 mask
= build_int_cst_type (unsigned_type
, -1);
3932 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (nbitsize
- lbitsize
));
3933 mask
= const_binop (RSHIFT_EXPR
, mask
,
3934 size_int (nbitsize
- lbitsize
- lbitpos
));
3937 /* If not comparing with constant, just rework the comparison
3939 return fold_build2_loc (loc
, code
, compare_type
,
3940 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3941 make_bit_field_ref (loc
, linner
, lhs
,
3946 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3947 make_bit_field_ref (loc
, rinner
, rhs
,
3953 /* Otherwise, we are handling the constant case. See if the constant is too
3954 big for the field. Warn and return a tree for 0 (false) if so. We do
3955 this not only for its own sake, but to avoid having to test for this
3956 error case below. If we didn't, we might generate wrong code.
3958 For unsigned fields, the constant shifted right by the field length should
3959 be all zero. For signed fields, the high-order bits should agree with
3964 if (wi::lrshift (rhs
, lbitsize
) != 0)
3966 warning (0, "comparison is always %d due to width of bit-field",
3968 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3973 wide_int tem
= wi::arshift (rhs
, lbitsize
- 1);
3974 if (tem
!= 0 && tem
!= -1)
3976 warning (0, "comparison is always %d due to width of bit-field",
3978 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3982 /* Single-bit compares should always be against zero. */
3983 if (lbitsize
== 1 && ! integer_zerop (rhs
))
3985 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
3986 rhs
= build_int_cst (type
, 0);
3989 /* Make a new bitfield reference, shift the constant over the
3990 appropriate number of bits and mask it with the computed mask
3991 (in case this was a signed field). If we changed it, make a new one. */
3992 lhs
= make_bit_field_ref (loc
, linner
, lhs
, unsigned_type
,
3993 nbitsize
, nbitpos
, 1, lreversep
);
3995 rhs
= const_binop (BIT_AND_EXPR
,
3996 const_binop (LSHIFT_EXPR
,
3997 fold_convert_loc (loc
, unsigned_type
, rhs
),
3998 size_int (lbitpos
)),
4001 lhs
= build2_loc (loc
, code
, compare_type
,
4002 build2 (BIT_AND_EXPR
, unsigned_type
, lhs
, mask
), rhs
);
4006 /* Subroutine for fold_truth_andor_1: decode a field reference.
4008 If EXP is a comparison reference, we return the innermost reference.
4010 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4011 set to the starting bit number.
4013 If the innermost field can be completely contained in a mode-sized
4014 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4016 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4017 otherwise it is not changed.
4019 *PUNSIGNEDP is set to the signedness of the field.
4021 *PREVERSEP is set to the storage order of the field.
4023 *PMASK is set to the mask used. This is either contained in a
4024 BIT_AND_EXPR or derived from the width of the field.
4026 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4028 Return 0 if this is not a component reference or is one that we can't
4029 do anything with. */
4032 decode_field_reference (location_t loc
, tree
*exp_
, HOST_WIDE_INT
*pbitsize
,
4033 HOST_WIDE_INT
*pbitpos
, machine_mode
*pmode
,
4034 int *punsignedp
, int *preversep
, int *pvolatilep
,
4035 tree
*pmask
, tree
*pand_mask
)
4038 tree outer_type
= 0;
4040 tree mask
, inner
, offset
;
4042 unsigned int precision
;
4044 /* All the optimizations using this function assume integer fields.
4045 There are problems with FP fields since the type_for_size call
4046 below can fail for, e.g., XFmode. */
4047 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp
)))
4050 /* We are interested in the bare arrangement of bits, so strip everything
4051 that doesn't affect the machine mode. However, record the type of the
4052 outermost expression if it may matter below. */
4053 if (CONVERT_EXPR_P (exp
)
4054 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4055 outer_type
= TREE_TYPE (exp
);
4058 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
4060 and_mask
= TREE_OPERAND (exp
, 1);
4061 exp
= TREE_OPERAND (exp
, 0);
4062 STRIP_NOPS (exp
); STRIP_NOPS (and_mask
);
4063 if (TREE_CODE (and_mask
) != INTEGER_CST
)
4067 inner
= get_inner_reference (exp
, pbitsize
, pbitpos
, &offset
, pmode
,
4068 punsignedp
, preversep
, pvolatilep
);
4069 if ((inner
== exp
&& and_mask
== 0)
4070 || *pbitsize
< 0 || offset
!= 0
4071 || TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
4076 /* If the number of bits in the reference is the same as the bitsize of
4077 the outer type, then the outer type gives the signedness. Otherwise
4078 (in case of a small bitfield) the signedness is unchanged. */
4079 if (outer_type
&& *pbitsize
== TYPE_PRECISION (outer_type
))
4080 *punsignedp
= TYPE_UNSIGNED (outer_type
);
4082 /* Compute the mask to access the bitfield. */
4083 unsigned_type
= lang_hooks
.types
.type_for_size (*pbitsize
, 1);
4084 precision
= TYPE_PRECISION (unsigned_type
);
4086 mask
= build_int_cst_type (unsigned_type
, -1);
4088 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4089 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4091 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4093 mask
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
4094 fold_convert_loc (loc
, unsigned_type
, and_mask
), mask
);
4097 *pand_mask
= and_mask
;
4101 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4102 bit positions and MASK is SIGNED. */
4105 all_ones_mask_p (const_tree mask
, unsigned int size
)
4107 tree type
= TREE_TYPE (mask
);
4108 unsigned int precision
= TYPE_PRECISION (type
);
4110 /* If this function returns true when the type of the mask is
4111 UNSIGNED, then there will be errors. In particular see
4112 gcc.c-torture/execute/990326-1.c. There does not appear to be
4113 any documentation paper trail as to why this is so. But the pre
4114 wide-int worked with that restriction and it has been preserved
4116 if (size
> precision
|| TYPE_SIGN (type
) == UNSIGNED
)
4119 return wi::mask (size
, false, precision
) == mask
;
4122 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4123 represents the sign bit of EXP's type. If EXP represents a sign
4124 or zero extension, also test VAL against the unextended type.
4125 The return value is the (sub)expression whose sign bit is VAL,
4126 or NULL_TREE otherwise. */
4129 sign_bit_p (tree exp
, const_tree val
)
4134 /* Tree EXP must have an integral type. */
4135 t
= TREE_TYPE (exp
);
4136 if (! INTEGRAL_TYPE_P (t
))
4139 /* Tree VAL must be an integer constant. */
4140 if (TREE_CODE (val
) != INTEGER_CST
4141 || TREE_OVERFLOW (val
))
4144 width
= TYPE_PRECISION (t
);
4145 if (wi::only_sign_bit_p (val
, width
))
4148 /* Handle extension from a narrower type. */
4149 if (TREE_CODE (exp
) == NOP_EXPR
4150 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))) < width
)
4151 return sign_bit_p (TREE_OPERAND (exp
, 0), val
);
4156 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4157 to be evaluated unconditionally. */
4160 simple_operand_p (const_tree exp
)
4162 /* Strip any conversions that don't change the machine mode. */
4165 return (CONSTANT_CLASS_P (exp
)
4166 || TREE_CODE (exp
) == SSA_NAME
4168 && ! TREE_ADDRESSABLE (exp
)
4169 && ! TREE_THIS_VOLATILE (exp
)
4170 && ! DECL_NONLOCAL (exp
)
4171 /* Don't regard global variables as simple. They may be
4172 allocated in ways unknown to the compiler (shared memory,
4173 #pragma weak, etc). */
4174 && ! TREE_PUBLIC (exp
)
4175 && ! DECL_EXTERNAL (exp
)
4176 /* Weakrefs are not safe to be read, since they can be NULL.
4177 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4178 have DECL_WEAK flag set. */
4179 && (! VAR_OR_FUNCTION_DECL_P (exp
) || ! DECL_WEAK (exp
))
4180 /* Loading a static variable is unduly expensive, but global
4181 registers aren't expensive. */
4182 && (! TREE_STATIC (exp
) || DECL_REGISTER (exp
))));
4185 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4186 to be evaluated unconditionally.
4187 I addition to simple_operand_p, we assume that comparisons, conversions,
4188 and logic-not operations are simple, if their operands are simple, too. */
4191 simple_operand_p_2 (tree exp
)
4193 enum tree_code code
;
4195 if (TREE_SIDE_EFFECTS (exp
)
4196 || tree_could_trap_p (exp
))
4199 while (CONVERT_EXPR_P (exp
))
4200 exp
= TREE_OPERAND (exp
, 0);
4202 code
= TREE_CODE (exp
);
4204 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
4205 return (simple_operand_p (TREE_OPERAND (exp
, 0))
4206 && simple_operand_p (TREE_OPERAND (exp
, 1)));
4208 if (code
== TRUTH_NOT_EXPR
)
4209 return simple_operand_p_2 (TREE_OPERAND (exp
, 0));
4211 return simple_operand_p (exp
);
4215 /* The following functions are subroutines to fold_range_test and allow it to
4216 try to change a logical combination of comparisons into a range test.
4219 X == 2 || X == 3 || X == 4 || X == 5
4223 (unsigned) (X - 2) <= 3
4225 We describe each set of comparisons as being either inside or outside
4226 a range, using a variable named like IN_P, and then describe the
4227 range with a lower and upper bound. If one of the bounds is omitted,
4228 it represents either the highest or lowest value of the type.
4230 In the comments below, we represent a range by two numbers in brackets
4231 preceded by a "+" to designate being inside that range, or a "-" to
4232 designate being outside that range, so the condition can be inverted by
4233 flipping the prefix. An omitted bound is represented by a "-". For
4234 example, "- [-, 10]" means being outside the range starting at the lowest
4235 possible value and ending at 10, in other words, being greater than 10.
4236 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4239 We set up things so that the missing bounds are handled in a consistent
4240 manner so neither a missing bound nor "true" and "false" need to be
4241 handled using a special case. */
4243 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4244 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4245 and UPPER1_P are nonzero if the respective argument is an upper bound
4246 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4247 must be specified for a comparison. ARG1 will be converted to ARG0's
4248 type if both are specified. */
4251 range_binop (enum tree_code code
, tree type
, tree arg0
, int upper0_p
,
4252 tree arg1
, int upper1_p
)
4258 /* If neither arg represents infinity, do the normal operation.
4259 Else, if not a comparison, return infinity. Else handle the special
4260 comparison rules. Note that most of the cases below won't occur, but
4261 are handled for consistency. */
4263 if (arg0
!= 0 && arg1
!= 0)
4265 tem
= fold_build2 (code
, type
!= 0 ? type
: TREE_TYPE (arg0
),
4266 arg0
, fold_convert (TREE_TYPE (arg0
), arg1
));
4268 return TREE_CODE (tem
) == INTEGER_CST
? tem
: 0;
4271 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
4274 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4275 for neither. In real maths, we cannot assume open ended ranges are
4276 the same. But, this is computer arithmetic, where numbers are finite.
4277 We can therefore make the transformation of any unbounded range with
4278 the value Z, Z being greater than any representable number. This permits
4279 us to treat unbounded ranges as equal. */
4280 sgn0
= arg0
!= 0 ? 0 : (upper0_p
? 1 : -1);
4281 sgn1
= arg1
!= 0 ? 0 : (upper1_p
? 1 : -1);
4285 result
= sgn0
== sgn1
;
4288 result
= sgn0
!= sgn1
;
4291 result
= sgn0
< sgn1
;
4294 result
= sgn0
<= sgn1
;
4297 result
= sgn0
> sgn1
;
4300 result
= sgn0
>= sgn1
;
4306 return constant_boolean_node (result
, type
);
4309 /* Helper routine for make_range. Perform one step for it, return
4310 new expression if the loop should continue or NULL_TREE if it should
4314 make_range_step (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
,
4315 tree exp_type
, tree
*p_low
, tree
*p_high
, int *p_in_p
,
4316 bool *strict_overflow_p
)
4318 tree arg0_type
= TREE_TYPE (arg0
);
4319 tree n_low
, n_high
, low
= *p_low
, high
= *p_high
;
4320 int in_p
= *p_in_p
, n_in_p
;
4324 case TRUTH_NOT_EXPR
:
4325 /* We can only do something if the range is testing for zero. */
4326 if (low
== NULL_TREE
|| high
== NULL_TREE
4327 || ! integer_zerop (low
) || ! integer_zerop (high
))
4332 case EQ_EXPR
: case NE_EXPR
:
4333 case LT_EXPR
: case LE_EXPR
: case GE_EXPR
: case GT_EXPR
:
4334 /* We can only do something if the range is testing for zero
4335 and if the second operand is an integer constant. Note that
4336 saying something is "in" the range we make is done by
4337 complementing IN_P since it will set in the initial case of
4338 being not equal to zero; "out" is leaving it alone. */
4339 if (low
== NULL_TREE
|| high
== NULL_TREE
4340 || ! integer_zerop (low
) || ! integer_zerop (high
)
4341 || TREE_CODE (arg1
) != INTEGER_CST
)
4346 case NE_EXPR
: /* - [c, c] */
4349 case EQ_EXPR
: /* + [c, c] */
4350 in_p
= ! in_p
, low
= high
= arg1
;
4352 case GT_EXPR
: /* - [-, c] */
4353 low
= 0, high
= arg1
;
4355 case GE_EXPR
: /* + [c, -] */
4356 in_p
= ! in_p
, low
= arg1
, high
= 0;
4358 case LT_EXPR
: /* - [c, -] */
4359 low
= arg1
, high
= 0;
4361 case LE_EXPR
: /* + [-, c] */
4362 in_p
= ! in_p
, low
= 0, high
= arg1
;
4368 /* If this is an unsigned comparison, we also know that EXP is
4369 greater than or equal to zero. We base the range tests we make
4370 on that fact, so we record it here so we can parse existing
4371 range tests. We test arg0_type since often the return type
4372 of, e.g. EQ_EXPR, is boolean. */
4373 if (TYPE_UNSIGNED (arg0_type
) && (low
== 0 || high
== 0))
4375 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
4377 build_int_cst (arg0_type
, 0),
4381 in_p
= n_in_p
, low
= n_low
, high
= n_high
;
4383 /* If the high bound is missing, but we have a nonzero low
4384 bound, reverse the range so it goes from zero to the low bound
4386 if (high
== 0 && low
&& ! integer_zerop (low
))
4389 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low
, 0,
4390 build_int_cst (TREE_TYPE (low
), 1), 0);
4391 low
= build_int_cst (arg0_type
, 0);
4401 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4402 low and high are non-NULL, then normalize will DTRT. */
4403 if (!TYPE_UNSIGNED (arg0_type
)
4404 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4406 if (low
== NULL_TREE
)
4407 low
= TYPE_MIN_VALUE (arg0_type
);
4408 if (high
== NULL_TREE
)
4409 high
= TYPE_MAX_VALUE (arg0_type
);
4412 /* (-x) IN [a,b] -> x in [-b, -a] */
4413 n_low
= range_binop (MINUS_EXPR
, exp_type
,
4414 build_int_cst (exp_type
, 0),
4416 n_high
= range_binop (MINUS_EXPR
, exp_type
,
4417 build_int_cst (exp_type
, 0),
4419 if (n_high
!= 0 && TREE_OVERFLOW (n_high
))
4425 return build2_loc (loc
, MINUS_EXPR
, exp_type
, negate_expr (arg0
),
4426 build_int_cst (exp_type
, 1));
4430 if (TREE_CODE (arg1
) != INTEGER_CST
)
4433 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4434 move a constant to the other side. */
4435 if (!TYPE_UNSIGNED (arg0_type
)
4436 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4439 /* If EXP is signed, any overflow in the computation is undefined,
4440 so we don't worry about it so long as our computations on
4441 the bounds don't overflow. For unsigned, overflow is defined
4442 and this is exactly the right thing. */
4443 n_low
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4444 arg0_type
, low
, 0, arg1
, 0);
4445 n_high
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4446 arg0_type
, high
, 1, arg1
, 0);
4447 if ((n_low
!= 0 && TREE_OVERFLOW (n_low
))
4448 || (n_high
!= 0 && TREE_OVERFLOW (n_high
)))
4451 if (TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4452 *strict_overflow_p
= true;
4455 /* Check for an unsigned range which has wrapped around the maximum
4456 value thus making n_high < n_low, and normalize it. */
4457 if (n_low
&& n_high
&& tree_int_cst_lt (n_high
, n_low
))
4459 low
= range_binop (PLUS_EXPR
, arg0_type
, n_high
, 0,
4460 build_int_cst (TREE_TYPE (n_high
), 1), 0);
4461 high
= range_binop (MINUS_EXPR
, arg0_type
, n_low
, 0,
4462 build_int_cst (TREE_TYPE (n_low
), 1), 0);
4464 /* If the range is of the form +/- [ x+1, x ], we won't
4465 be able to normalize it. But then, it represents the
4466 whole range or the empty set, so make it
4468 if (tree_int_cst_equal (n_low
, low
)
4469 && tree_int_cst_equal (n_high
, high
))
4475 low
= n_low
, high
= n_high
;
4483 case NON_LVALUE_EXPR
:
4484 if (TYPE_PRECISION (arg0_type
) > TYPE_PRECISION (exp_type
))
4487 if (! INTEGRAL_TYPE_P (arg0_type
)
4488 || (low
!= 0 && ! int_fits_type_p (low
, arg0_type
))
4489 || (high
!= 0 && ! int_fits_type_p (high
, arg0_type
)))
4492 n_low
= low
, n_high
= high
;
4495 n_low
= fold_convert_loc (loc
, arg0_type
, n_low
);
4498 n_high
= fold_convert_loc (loc
, arg0_type
, n_high
);
4500 /* If we're converting arg0 from an unsigned type, to exp,
4501 a signed type, we will be doing the comparison as unsigned.
4502 The tests above have already verified that LOW and HIGH
4505 So we have to ensure that we will handle large unsigned
4506 values the same way that the current signed bounds treat
4509 if (!TYPE_UNSIGNED (exp_type
) && TYPE_UNSIGNED (arg0_type
))
4513 /* For fixed-point modes, we need to pass the saturating flag
4514 as the 2nd parameter. */
4515 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type
)))
4517 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
),
4518 TYPE_SATURATING (arg0_type
));
4521 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
), 1);
4523 /* A range without an upper bound is, naturally, unbounded.
4524 Since convert would have cropped a very large value, use
4525 the max value for the destination type. */
4527 = TYPE_MAX_VALUE (equiv_type
) ? TYPE_MAX_VALUE (equiv_type
)
4528 : TYPE_MAX_VALUE (arg0_type
);
4530 if (TYPE_PRECISION (exp_type
) == TYPE_PRECISION (arg0_type
))
4531 high_positive
= fold_build2_loc (loc
, RSHIFT_EXPR
, arg0_type
,
4532 fold_convert_loc (loc
, arg0_type
,
4534 build_int_cst (arg0_type
, 1));
4536 /* If the low bound is specified, "and" the range with the
4537 range for which the original unsigned value will be
4541 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 1, n_low
, n_high
,
4542 1, fold_convert_loc (loc
, arg0_type
,
4547 in_p
= (n_in_p
== in_p
);
4551 /* Otherwise, "or" the range with the range of the input
4552 that will be interpreted as negative. */
4553 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 0, n_low
, n_high
,
4554 1, fold_convert_loc (loc
, arg0_type
,
4559 in_p
= (in_p
!= n_in_p
);
4573 /* Given EXP, a logical expression, set the range it is testing into
4574 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4575 actually being tested. *PLOW and *PHIGH will be made of the same
4576 type as the returned expression. If EXP is not a comparison, we
4577 will most likely not be returning a useful value and range. Set
4578 *STRICT_OVERFLOW_P to true if the return value is only valid
4579 because signed overflow is undefined; otherwise, do not change
4580 *STRICT_OVERFLOW_P. */
4583 make_range (tree exp
, int *pin_p
, tree
*plow
, tree
*phigh
,
4584 bool *strict_overflow_p
)
4586 enum tree_code code
;
4587 tree arg0
, arg1
= NULL_TREE
;
4588 tree exp_type
, nexp
;
4591 location_t loc
= EXPR_LOCATION (exp
);
4593 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4594 and see if we can refine the range. Some of the cases below may not
4595 happen, but it doesn't seem worth worrying about this. We "continue"
4596 the outer loop when we've changed something; otherwise we "break"
4597 the switch, which will "break" the while. */
4600 low
= high
= build_int_cst (TREE_TYPE (exp
), 0);
4604 code
= TREE_CODE (exp
);
4605 exp_type
= TREE_TYPE (exp
);
4608 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
4610 if (TREE_OPERAND_LENGTH (exp
) > 0)
4611 arg0
= TREE_OPERAND (exp
, 0);
4612 if (TREE_CODE_CLASS (code
) == tcc_binary
4613 || TREE_CODE_CLASS (code
) == tcc_comparison
4614 || (TREE_CODE_CLASS (code
) == tcc_expression
4615 && TREE_OPERAND_LENGTH (exp
) > 1))
4616 arg1
= TREE_OPERAND (exp
, 1);
4618 if (arg0
== NULL_TREE
)
4621 nexp
= make_range_step (loc
, code
, arg0
, arg1
, exp_type
, &low
,
4622 &high
, &in_p
, strict_overflow_p
);
4623 if (nexp
== NULL_TREE
)
4628 /* If EXP is a constant, we can evaluate whether this is true or false. */
4629 if (TREE_CODE (exp
) == INTEGER_CST
)
4631 in_p
= in_p
== (integer_onep (range_binop (GE_EXPR
, integer_type_node
,
4633 && integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4639 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4643 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4644 type, TYPE, return an expression to test if EXP is in (or out of, depending
4645 on IN_P) the range. Return 0 if the test couldn't be created. */
4648 build_range_check (location_t loc
, tree type
, tree exp
, int in_p
,
4649 tree low
, tree high
)
4651 tree etype
= TREE_TYPE (exp
), value
;
4653 /* Disable this optimization for function pointer expressions
4654 on targets that require function pointer canonicalization. */
4655 if (targetm
.have_canonicalize_funcptr_for_compare ()
4656 && TREE_CODE (etype
) == POINTER_TYPE
4657 && TREE_CODE (TREE_TYPE (etype
)) == FUNCTION_TYPE
)
4662 value
= build_range_check (loc
, type
, exp
, 1, low
, high
);
4664 return invert_truthvalue_loc (loc
, value
);
4669 if (low
== 0 && high
== 0)
4670 return omit_one_operand_loc (loc
, type
, build_int_cst (type
, 1), exp
);
4673 return fold_build2_loc (loc
, LE_EXPR
, type
, exp
,
4674 fold_convert_loc (loc
, etype
, high
));
4677 return fold_build2_loc (loc
, GE_EXPR
, type
, exp
,
4678 fold_convert_loc (loc
, etype
, low
));
4680 if (operand_equal_p (low
, high
, 0))
4681 return fold_build2_loc (loc
, EQ_EXPR
, type
, exp
,
4682 fold_convert_loc (loc
, etype
, low
));
4684 if (integer_zerop (low
))
4686 if (! TYPE_UNSIGNED (etype
))
4688 etype
= unsigned_type_for (etype
);
4689 high
= fold_convert_loc (loc
, etype
, high
);
4690 exp
= fold_convert_loc (loc
, etype
, exp
);
4692 return build_range_check (loc
, type
, exp
, 1, 0, high
);
4695 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4696 if (integer_onep (low
) && TREE_CODE (high
) == INTEGER_CST
)
4698 int prec
= TYPE_PRECISION (etype
);
4700 if (wi::mask (prec
- 1, false, prec
) == high
)
4702 if (TYPE_UNSIGNED (etype
))
4704 tree signed_etype
= signed_type_for (etype
);
4705 if (TYPE_PRECISION (signed_etype
) != TYPE_PRECISION (etype
))
4707 = build_nonstandard_integer_type (TYPE_PRECISION (etype
), 0);
4709 etype
= signed_etype
;
4710 exp
= fold_convert_loc (loc
, etype
, exp
);
4712 return fold_build2_loc (loc
, GT_EXPR
, type
, exp
,
4713 build_int_cst (etype
, 0));
4717 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4718 This requires wrap-around arithmetics for the type of the expression.
4719 First make sure that arithmetics in this type is valid, then make sure
4720 that it wraps around. */
4721 if (TREE_CODE (etype
) == ENUMERAL_TYPE
|| TREE_CODE (etype
) == BOOLEAN_TYPE
)
4722 etype
= lang_hooks
.types
.type_for_size (TYPE_PRECISION (etype
),
4723 TYPE_UNSIGNED (etype
));
4725 if (TREE_CODE (etype
) == INTEGER_TYPE
&& !TYPE_OVERFLOW_WRAPS (etype
))
4727 tree utype
, minv
, maxv
;
4729 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4730 for the type in question, as we rely on this here. */
4731 utype
= unsigned_type_for (etype
);
4732 maxv
= fold_convert_loc (loc
, utype
, TYPE_MAX_VALUE (etype
));
4733 maxv
= range_binop (PLUS_EXPR
, NULL_TREE
, maxv
, 1,
4734 build_int_cst (TREE_TYPE (maxv
), 1), 1);
4735 minv
= fold_convert_loc (loc
, utype
, TYPE_MIN_VALUE (etype
));
4737 if (integer_zerop (range_binop (NE_EXPR
, integer_type_node
,
4744 high
= fold_convert_loc (loc
, etype
, high
);
4745 low
= fold_convert_loc (loc
, etype
, low
);
4746 exp
= fold_convert_loc (loc
, etype
, exp
);
4748 value
= const_binop (MINUS_EXPR
, high
, low
);
4751 if (POINTER_TYPE_P (etype
))
4753 if (value
!= 0 && !TREE_OVERFLOW (value
))
4755 low
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (low
), low
);
4756 return build_range_check (loc
, type
,
4757 fold_build_pointer_plus_loc (loc
, exp
, low
),
4758 1, build_int_cst (etype
, 0), value
);
4763 if (value
!= 0 && !TREE_OVERFLOW (value
))
4764 return build_range_check (loc
, type
,
4765 fold_build2_loc (loc
, MINUS_EXPR
, etype
, exp
, low
),
4766 1, build_int_cst (etype
, 0), value
);
4771 /* Return the predecessor of VAL in its type, handling the infinite case. */
4774 range_predecessor (tree val
)
4776 tree type
= TREE_TYPE (val
);
4778 if (INTEGRAL_TYPE_P (type
)
4779 && operand_equal_p (val
, TYPE_MIN_VALUE (type
), 0))
4782 return range_binop (MINUS_EXPR
, NULL_TREE
, val
, 0,
4783 build_int_cst (TREE_TYPE (val
), 1), 0);
4786 /* Return the successor of VAL in its type, handling the infinite case. */
4789 range_successor (tree val
)
4791 tree type
= TREE_TYPE (val
);
4793 if (INTEGRAL_TYPE_P (type
)
4794 && operand_equal_p (val
, TYPE_MAX_VALUE (type
), 0))
4797 return range_binop (PLUS_EXPR
, NULL_TREE
, val
, 0,
4798 build_int_cst (TREE_TYPE (val
), 1), 0);
4801 /* Given two ranges, see if we can merge them into one. Return 1 if we
4802 can, 0 if we can't. Set the output range into the specified parameters. */
4805 merge_ranges (int *pin_p
, tree
*plow
, tree
*phigh
, int in0_p
, tree low0
,
4806 tree high0
, int in1_p
, tree low1
, tree high1
)
4814 int lowequal
= ((low0
== 0 && low1
== 0)
4815 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4816 low0
, 0, low1
, 0)));
4817 int highequal
= ((high0
== 0 && high1
== 0)
4818 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4819 high0
, 1, high1
, 1)));
4821 /* Make range 0 be the range that starts first, or ends last if they
4822 start at the same value. Swap them if it isn't. */
4823 if (integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4826 && integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4827 high1
, 1, high0
, 1))))
4829 temp
= in0_p
, in0_p
= in1_p
, in1_p
= temp
;
4830 tem
= low0
, low0
= low1
, low1
= tem
;
4831 tem
= high0
, high0
= high1
, high1
= tem
;
4834 /* Now flag two cases, whether the ranges are disjoint or whether the
4835 second range is totally subsumed in the first. Note that the tests
4836 below are simplified by the ones above. */
4837 no_overlap
= integer_onep (range_binop (LT_EXPR
, integer_type_node
,
4838 high0
, 1, low1
, 0));
4839 subset
= integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4840 high1
, 1, high0
, 1));
4842 /* We now have four cases, depending on whether we are including or
4843 excluding the two ranges. */
4846 /* If they don't overlap, the result is false. If the second range
4847 is a subset it is the result. Otherwise, the range is from the start
4848 of the second to the end of the first. */
4850 in_p
= 0, low
= high
= 0;
4852 in_p
= 1, low
= low1
, high
= high1
;
4854 in_p
= 1, low
= low1
, high
= high0
;
4857 else if (in0_p
&& ! in1_p
)
4859 /* If they don't overlap, the result is the first range. If they are
4860 equal, the result is false. If the second range is a subset of the
4861 first, and the ranges begin at the same place, we go from just after
4862 the end of the second range to the end of the first. If the second
4863 range is not a subset of the first, or if it is a subset and both
4864 ranges end at the same place, the range starts at the start of the
4865 first range and ends just before the second range.
4866 Otherwise, we can't describe this as a single range. */
4868 in_p
= 1, low
= low0
, high
= high0
;
4869 else if (lowequal
&& highequal
)
4870 in_p
= 0, low
= high
= 0;
4871 else if (subset
&& lowequal
)
4873 low
= range_successor (high1
);
4878 /* We are in the weird situation where high0 > high1 but
4879 high1 has no successor. Punt. */
4883 else if (! subset
|| highequal
)
4886 high
= range_predecessor (low1
);
4890 /* low0 < low1 but low1 has no predecessor. Punt. */
4898 else if (! in0_p
&& in1_p
)
4900 /* If they don't overlap, the result is the second range. If the second
4901 is a subset of the first, the result is false. Otherwise,
4902 the range starts just after the first range and ends at the
4903 end of the second. */
4905 in_p
= 1, low
= low1
, high
= high1
;
4906 else if (subset
|| highequal
)
4907 in_p
= 0, low
= high
= 0;
4910 low
= range_successor (high0
);
4915 /* high1 > high0 but high0 has no successor. Punt. */
4923 /* The case where we are excluding both ranges. Here the complex case
4924 is if they don't overlap. In that case, the only time we have a
4925 range is if they are adjacent. If the second is a subset of the
4926 first, the result is the first. Otherwise, the range to exclude
4927 starts at the beginning of the first range and ends at the end of the
4931 if (integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4932 range_successor (high0
),
4934 in_p
= 0, low
= low0
, high
= high1
;
4937 /* Canonicalize - [min, x] into - [-, x]. */
4938 if (low0
&& TREE_CODE (low0
) == INTEGER_CST
)
4939 switch (TREE_CODE (TREE_TYPE (low0
)))
4942 if (TYPE_PRECISION (TREE_TYPE (low0
))
4943 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0
))))
4947 if (tree_int_cst_equal (low0
,
4948 TYPE_MIN_VALUE (TREE_TYPE (low0
))))
4952 if (TYPE_UNSIGNED (TREE_TYPE (low0
))
4953 && integer_zerop (low0
))
4960 /* Canonicalize - [x, max] into - [x, -]. */
4961 if (high1
&& TREE_CODE (high1
) == INTEGER_CST
)
4962 switch (TREE_CODE (TREE_TYPE (high1
)))
4965 if (TYPE_PRECISION (TREE_TYPE (high1
))
4966 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1
))))
4970 if (tree_int_cst_equal (high1
,
4971 TYPE_MAX_VALUE (TREE_TYPE (high1
))))
4975 if (TYPE_UNSIGNED (TREE_TYPE (high1
))
4976 && integer_zerop (range_binop (PLUS_EXPR
, NULL_TREE
,
4978 build_int_cst (TREE_TYPE (high1
), 1),
4986 /* The ranges might be also adjacent between the maximum and
4987 minimum values of the given type. For
4988 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4989 return + [x + 1, y - 1]. */
4990 if (low0
== 0 && high1
== 0)
4992 low
= range_successor (high0
);
4993 high
= range_predecessor (low1
);
4994 if (low
== 0 || high
== 0)
5004 in_p
= 0, low
= low0
, high
= high0
;
5006 in_p
= 0, low
= low0
, high
= high1
;
5009 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
5014 /* Subroutine of fold, looking inside expressions of the form
5015 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5016 of the COND_EXPR. This function is being used also to optimize
5017 A op B ? C : A, by reversing the comparison first.
5019 Return a folded expression whose code is not a COND_EXPR
5020 anymore, or NULL_TREE if no folding opportunity is found. */
5023 fold_cond_expr_with_comparison (location_t loc
, tree type
,
5024 tree arg0
, tree arg1
, tree arg2
)
5026 enum tree_code comp_code
= TREE_CODE (arg0
);
5027 tree arg00
= TREE_OPERAND (arg0
, 0);
5028 tree arg01
= TREE_OPERAND (arg0
, 1);
5029 tree arg1_type
= TREE_TYPE (arg1
);
5035 /* If we have A op 0 ? A : -A, consider applying the following
5038 A == 0? A : -A same as -A
5039 A != 0? A : -A same as A
5040 A >= 0? A : -A same as abs (A)
5041 A > 0? A : -A same as abs (A)
5042 A <= 0? A : -A same as -abs (A)
5043 A < 0? A : -A same as -abs (A)
5045 None of these transformations work for modes with signed
5046 zeros. If A is +/-0, the first two transformations will
5047 change the sign of the result (from +0 to -0, or vice
5048 versa). The last four will fix the sign of the result,
5049 even though the original expressions could be positive or
5050 negative, depending on the sign of A.
5052 Note that all these transformations are correct if A is
5053 NaN, since the two alternatives (A and -A) are also NaNs. */
5054 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5055 && (FLOAT_TYPE_P (TREE_TYPE (arg01
))
5056 ? real_zerop (arg01
)
5057 : integer_zerop (arg01
))
5058 && ((TREE_CODE (arg2
) == NEGATE_EXPR
5059 && operand_equal_p (TREE_OPERAND (arg2
, 0), arg1
, 0))
5060 /* In the case that A is of the form X-Y, '-A' (arg2) may
5061 have already been folded to Y-X, check for that. */
5062 || (TREE_CODE (arg1
) == MINUS_EXPR
5063 && TREE_CODE (arg2
) == MINUS_EXPR
5064 && operand_equal_p (TREE_OPERAND (arg1
, 0),
5065 TREE_OPERAND (arg2
, 1), 0)
5066 && operand_equal_p (TREE_OPERAND (arg1
, 1),
5067 TREE_OPERAND (arg2
, 0), 0))))
5072 tem
= fold_convert_loc (loc
, arg1_type
, arg1
);
5073 return fold_convert_loc (loc
, type
, negate_expr (tem
));
5076 return fold_convert_loc (loc
, type
, arg1
);
5079 if (flag_trapping_math
)
5084 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5086 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5087 return fold_convert_loc (loc
, type
, tem
);
5090 if (flag_trapping_math
)
5095 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5097 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5098 return negate_expr (fold_convert_loc (loc
, type
, tem
));
5100 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5104 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5105 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5106 both transformations are correct when A is NaN: A != 0
5107 is then true, and A == 0 is false. */
5109 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5110 && integer_zerop (arg01
) && integer_zerop (arg2
))
5112 if (comp_code
== NE_EXPR
)
5113 return fold_convert_loc (loc
, type
, arg1
);
5114 else if (comp_code
== EQ_EXPR
)
5115 return build_zero_cst (type
);
5118 /* Try some transformations of A op B ? A : B.
5120 A == B? A : B same as B
5121 A != B? A : B same as A
5122 A >= B? A : B same as max (A, B)
5123 A > B? A : B same as max (B, A)
5124 A <= B? A : B same as min (A, B)
5125 A < B? A : B same as min (B, A)
5127 As above, these transformations don't work in the presence
5128 of signed zeros. For example, if A and B are zeros of
5129 opposite sign, the first two transformations will change
5130 the sign of the result. In the last four, the original
5131 expressions give different results for (A=+0, B=-0) and
5132 (A=-0, B=+0), but the transformed expressions do not.
5134 The first two transformations are correct if either A or B
5135 is a NaN. In the first transformation, the condition will
5136 be false, and B will indeed be chosen. In the case of the
5137 second transformation, the condition A != B will be true,
5138 and A will be chosen.
5140 The conversions to max() and min() are not correct if B is
5141 a number and A is not. The conditions in the original
5142 expressions will be false, so all four give B. The min()
5143 and max() versions would give a NaN instead. */
5144 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5145 && operand_equal_for_comparison_p (arg01
, arg2
, arg00
)
5146 /* Avoid these transformations if the COND_EXPR may be used
5147 as an lvalue in the C++ front-end. PR c++/19199. */
5149 || VECTOR_TYPE_P (type
)
5150 || (! lang_GNU_CXX ()
5151 && strcmp (lang_hooks
.name
, "GNU Objective-C++") != 0)
5152 || ! maybe_lvalue_p (arg1
)
5153 || ! maybe_lvalue_p (arg2
)))
5155 tree comp_op0
= arg00
;
5156 tree comp_op1
= arg01
;
5157 tree comp_type
= TREE_TYPE (comp_op0
);
5162 return fold_convert_loc (loc
, type
, arg2
);
5164 return fold_convert_loc (loc
, type
, arg1
);
5169 /* In C++ a ?: expression can be an lvalue, so put the
5170 operand which will be used if they are equal first
5171 so that we can convert this back to the
5172 corresponding COND_EXPR. */
5173 if (!HONOR_NANS (arg1
))
5175 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5176 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5177 tem
= (comp_code
== LE_EXPR
|| comp_code
== UNLE_EXPR
)
5178 ? fold_build2_loc (loc
, MIN_EXPR
, comp_type
, comp_op0
, comp_op1
)
5179 : fold_build2_loc (loc
, MIN_EXPR
, comp_type
,
5180 comp_op1
, comp_op0
);
5181 return fold_convert_loc (loc
, type
, tem
);
5188 if (!HONOR_NANS (arg1
))
5190 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5191 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5192 tem
= (comp_code
== GE_EXPR
|| comp_code
== UNGE_EXPR
)
5193 ? fold_build2_loc (loc
, MAX_EXPR
, comp_type
, comp_op0
, comp_op1
)
5194 : fold_build2_loc (loc
, MAX_EXPR
, comp_type
,
5195 comp_op1
, comp_op0
);
5196 return fold_convert_loc (loc
, type
, tem
);
5200 if (!HONOR_NANS (arg1
))
5201 return fold_convert_loc (loc
, type
, arg2
);
5204 if (!HONOR_NANS (arg1
))
5205 return fold_convert_loc (loc
, type
, arg1
);
5208 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5218 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5219 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5220 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5224 /* EXP is some logical combination of boolean tests. See if we can
5225 merge it into some range test. Return the new tree if so. */
5228 fold_range_test (location_t loc
, enum tree_code code
, tree type
,
5231 int or_op
= (code
== TRUTH_ORIF_EXPR
5232 || code
== TRUTH_OR_EXPR
);
5233 int in0_p
, in1_p
, in_p
;
5234 tree low0
, low1
, low
, high0
, high1
, high
;
5235 bool strict_overflow_p
= false;
5237 const char * const warnmsg
= G_("assuming signed overflow does not occur "
5238 "when simplifying range test");
5240 if (!INTEGRAL_TYPE_P (type
))
5243 lhs
= make_range (op0
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
5244 rhs
= make_range (op1
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
5246 /* If this is an OR operation, invert both sides; we will invert
5247 again at the end. */
5249 in0_p
= ! in0_p
, in1_p
= ! in1_p
;
5251 /* If both expressions are the same, if we can merge the ranges, and we
5252 can build the range test, return it or it inverted. If one of the
5253 ranges is always true or always false, consider it to be the same
5254 expression as the other. */
5255 if ((lhs
== 0 || rhs
== 0 || operand_equal_p (lhs
, rhs
, 0))
5256 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
5258 && 0 != (tem
= (build_range_check (loc
, type
,
5260 : rhs
!= 0 ? rhs
: integer_zero_node
,
5263 if (strict_overflow_p
)
5264 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
5265 return or_op
? invert_truthvalue_loc (loc
, tem
) : tem
;
5268 /* On machines where the branch cost is expensive, if this is a
5269 short-circuited branch and the underlying object on both sides
5270 is the same, make a non-short-circuit operation. */
5271 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5272 && lhs
!= 0 && rhs
!= 0
5273 && (code
== TRUTH_ANDIF_EXPR
5274 || code
== TRUTH_ORIF_EXPR
)
5275 && operand_equal_p (lhs
, rhs
, 0))
5277 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5278 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5279 which cases we can't do this. */
5280 if (simple_operand_p (lhs
))
5281 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5282 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5285 else if (!lang_hooks
.decls
.global_bindings_p ()
5286 && !CONTAINS_PLACEHOLDER_P (lhs
))
5288 tree common
= save_expr (lhs
);
5290 if (0 != (lhs
= build_range_check (loc
, type
, common
,
5291 or_op
? ! in0_p
: in0_p
,
5293 && (0 != (rhs
= build_range_check (loc
, type
, common
,
5294 or_op
? ! in1_p
: in1_p
,
5297 if (strict_overflow_p
)
5298 fold_overflow_warning (warnmsg
,
5299 WARN_STRICT_OVERFLOW_COMPARISON
);
5300 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5301 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5310 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5311 bit value. Arrange things so the extra bits will be set to zero if and
5312 only if C is signed-extended to its full width. If MASK is nonzero,
5313 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5316 unextend (tree c
, int p
, int unsignedp
, tree mask
)
5318 tree type
= TREE_TYPE (c
);
5319 int modesize
= GET_MODE_BITSIZE (TYPE_MODE (type
));
5322 if (p
== modesize
|| unsignedp
)
5325 /* We work by getting just the sign bit into the low-order bit, then
5326 into the high-order bit, then sign-extend. We then XOR that value
5328 temp
= build_int_cst (TREE_TYPE (c
), wi::extract_uhwi (c
, p
- 1, 1));
5330 /* We must use a signed type in order to get an arithmetic right shift.
5331 However, we must also avoid introducing accidental overflows, so that
5332 a subsequent call to integer_zerop will work. Hence we must
5333 do the type conversion here. At this point, the constant is either
5334 zero or one, and the conversion to a signed type can never overflow.
5335 We could get an overflow if this conversion is done anywhere else. */
5336 if (TYPE_UNSIGNED (type
))
5337 temp
= fold_convert (signed_type_for (type
), temp
);
5339 temp
= const_binop (LSHIFT_EXPR
, temp
, size_int (modesize
- 1));
5340 temp
= const_binop (RSHIFT_EXPR
, temp
, size_int (modesize
- p
- 1));
5342 temp
= const_binop (BIT_AND_EXPR
, temp
,
5343 fold_convert (TREE_TYPE (c
), mask
));
5344 /* If necessary, convert the type back to match the type of C. */
5345 if (TYPE_UNSIGNED (type
))
5346 temp
= fold_convert (type
, temp
);
5348 return fold_convert (type
, const_binop (BIT_XOR_EXPR
, c
, temp
));
5351 /* For an expression that has the form
5355 we can drop one of the inner expressions and simplify to
5359 LOC is the location of the resulting expression. OP is the inner
5360 logical operation; the left-hand side in the examples above, while CMPOP
5361 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5362 removing a condition that guards another, as in
5363 (A != NULL && A->...) || A == NULL
5364 which we must not transform. If RHS_ONLY is true, only eliminate the
5365 right-most operand of the inner logical operation. */
5368 merge_truthop_with_opposite_arm (location_t loc
, tree op
, tree cmpop
,
5371 tree type
= TREE_TYPE (cmpop
);
5372 enum tree_code code
= TREE_CODE (cmpop
);
5373 enum tree_code truthop_code
= TREE_CODE (op
);
5374 tree lhs
= TREE_OPERAND (op
, 0);
5375 tree rhs
= TREE_OPERAND (op
, 1);
5376 tree orig_lhs
= lhs
, orig_rhs
= rhs
;
5377 enum tree_code rhs_code
= TREE_CODE (rhs
);
5378 enum tree_code lhs_code
= TREE_CODE (lhs
);
5379 enum tree_code inv_code
;
5381 if (TREE_SIDE_EFFECTS (op
) || TREE_SIDE_EFFECTS (cmpop
))
5384 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
5387 if (rhs_code
== truthop_code
)
5389 tree newrhs
= merge_truthop_with_opposite_arm (loc
, rhs
, cmpop
, rhs_only
);
5390 if (newrhs
!= NULL_TREE
)
5393 rhs_code
= TREE_CODE (rhs
);
5396 if (lhs_code
== truthop_code
&& !rhs_only
)
5398 tree newlhs
= merge_truthop_with_opposite_arm (loc
, lhs
, cmpop
, false);
5399 if (newlhs
!= NULL_TREE
)
5402 lhs_code
= TREE_CODE (lhs
);
5406 inv_code
= invert_tree_comparison (code
, HONOR_NANS (type
));
5407 if (inv_code
== rhs_code
5408 && operand_equal_p (TREE_OPERAND (rhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5409 && operand_equal_p (TREE_OPERAND (rhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5411 if (!rhs_only
&& inv_code
== lhs_code
5412 && operand_equal_p (TREE_OPERAND (lhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5413 && operand_equal_p (TREE_OPERAND (lhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5415 if (rhs
!= orig_rhs
|| lhs
!= orig_lhs
)
5416 return fold_build2_loc (loc
, truthop_code
, TREE_TYPE (cmpop
),
5421 /* Find ways of folding logical expressions of LHS and RHS:
5422 Try to merge two comparisons to the same innermost item.
5423 Look for range tests like "ch >= '0' && ch <= '9'".
5424 Look for combinations of simple terms on machines with expensive branches
5425 and evaluate the RHS unconditionally.
5427 For example, if we have p->a == 2 && p->b == 4 and we can make an
5428 object large enough to span both A and B, we can do this with a comparison
5429 against the object ANDed with the a mask.
5431 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5432 operations to do this with one comparison.
5434 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5435 function and the one above.
5437 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5438 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5440 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5443 We return the simplified tree or 0 if no optimization is possible. */
5446 fold_truth_andor_1 (location_t loc
, enum tree_code code
, tree truth_type
,
5449 /* If this is the "or" of two comparisons, we can do something if
5450 the comparisons are NE_EXPR. If this is the "and", we can do something
5451 if the comparisons are EQ_EXPR. I.e.,
5452 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5454 WANTED_CODE is this operation code. For single bit fields, we can
5455 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5456 comparison for one-bit fields. */
5458 enum tree_code wanted_code
;
5459 enum tree_code lcode
, rcode
;
5460 tree ll_arg
, lr_arg
, rl_arg
, rr_arg
;
5461 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
5462 HOST_WIDE_INT ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
5463 HOST_WIDE_INT rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
5464 HOST_WIDE_INT xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
5465 HOST_WIDE_INT lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
5466 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
5467 int ll_reversep
, lr_reversep
, rl_reversep
, rr_reversep
;
5468 machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
5469 machine_mode lnmode
, rnmode
;
5470 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
5471 tree ll_and_mask
, lr_and_mask
, rl_and_mask
, rr_and_mask
;
5472 tree l_const
, r_const
;
5473 tree lntype
, rntype
, result
;
5474 HOST_WIDE_INT first_bit
, end_bit
;
5477 /* Start by getting the comparison codes. Fail if anything is volatile.
5478 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5479 it were surrounded with a NE_EXPR. */
5481 if (TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
5484 lcode
= TREE_CODE (lhs
);
5485 rcode
= TREE_CODE (rhs
);
5487 if (lcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (lhs
, 1)))
5489 lhs
= build2 (NE_EXPR
, truth_type
, lhs
,
5490 build_int_cst (TREE_TYPE (lhs
), 0));
5494 if (rcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (rhs
, 1)))
5496 rhs
= build2 (NE_EXPR
, truth_type
, rhs
,
5497 build_int_cst (TREE_TYPE (rhs
), 0));
5501 if (TREE_CODE_CLASS (lcode
) != tcc_comparison
5502 || TREE_CODE_CLASS (rcode
) != tcc_comparison
)
5505 ll_arg
= TREE_OPERAND (lhs
, 0);
5506 lr_arg
= TREE_OPERAND (lhs
, 1);
5507 rl_arg
= TREE_OPERAND (rhs
, 0);
5508 rr_arg
= TREE_OPERAND (rhs
, 1);
5510 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5511 if (simple_operand_p (ll_arg
)
5512 && simple_operand_p (lr_arg
))
5514 if (operand_equal_p (ll_arg
, rl_arg
, 0)
5515 && operand_equal_p (lr_arg
, rr_arg
, 0))
5517 result
= combine_comparisons (loc
, code
, lcode
, rcode
,
5518 truth_type
, ll_arg
, lr_arg
);
5522 else if (operand_equal_p (ll_arg
, rr_arg
, 0)
5523 && operand_equal_p (lr_arg
, rl_arg
, 0))
5525 result
= combine_comparisons (loc
, code
, lcode
,
5526 swap_tree_comparison (rcode
),
5527 truth_type
, ll_arg
, lr_arg
);
5533 code
= ((code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
)
5534 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
);
5536 /* If the RHS can be evaluated unconditionally and its operands are
5537 simple, it wins to evaluate the RHS unconditionally on machines
5538 with expensive branches. In this case, this isn't a comparison
5539 that can be merged. */
5541 if (BRANCH_COST (optimize_function_for_speed_p (cfun
),
5543 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg
))
5544 && simple_operand_p (rl_arg
)
5545 && simple_operand_p (rr_arg
))
5547 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5548 if (code
== TRUTH_OR_EXPR
5549 && lcode
== NE_EXPR
&& integer_zerop (lr_arg
)
5550 && rcode
== NE_EXPR
&& integer_zerop (rr_arg
)
5551 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5552 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5553 return build2_loc (loc
, NE_EXPR
, truth_type
,
5554 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5556 build_int_cst (TREE_TYPE (ll_arg
), 0));
5558 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5559 if (code
== TRUTH_AND_EXPR
5560 && lcode
== EQ_EXPR
&& integer_zerop (lr_arg
)
5561 && rcode
== EQ_EXPR
&& integer_zerop (rr_arg
)
5562 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5563 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5564 return build2_loc (loc
, EQ_EXPR
, truth_type
,
5565 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5567 build_int_cst (TREE_TYPE (ll_arg
), 0));
5570 /* See if the comparisons can be merged. Then get all the parameters for
5573 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
5574 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
))
5577 ll_reversep
= lr_reversep
= rl_reversep
= rr_reversep
= 0;
5579 ll_inner
= decode_field_reference (loc
, &ll_arg
,
5580 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
5581 &ll_unsignedp
, &ll_reversep
, &volatilep
,
5582 &ll_mask
, &ll_and_mask
);
5583 lr_inner
= decode_field_reference (loc
, &lr_arg
,
5584 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
5585 &lr_unsignedp
, &lr_reversep
, &volatilep
,
5586 &lr_mask
, &lr_and_mask
);
5587 rl_inner
= decode_field_reference (loc
, &rl_arg
,
5588 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
5589 &rl_unsignedp
, &rl_reversep
, &volatilep
,
5590 &rl_mask
, &rl_and_mask
);
5591 rr_inner
= decode_field_reference (loc
, &rr_arg
,
5592 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
5593 &rr_unsignedp
, &rr_reversep
, &volatilep
,
5594 &rr_mask
, &rr_and_mask
);
5596 /* It must be true that the inner operation on the lhs of each
5597 comparison must be the same if we are to be able to do anything.
5598 Then see if we have constants. If not, the same must be true for
5601 || ll_reversep
!= rl_reversep
5602 || ll_inner
== 0 || rl_inner
== 0
5603 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
5606 if (TREE_CODE (lr_arg
) == INTEGER_CST
5607 && TREE_CODE (rr_arg
) == INTEGER_CST
)
5609 l_const
= lr_arg
, r_const
= rr_arg
;
5610 lr_reversep
= ll_reversep
;
5612 else if (lr_reversep
!= rr_reversep
5613 || lr_inner
== 0 || rr_inner
== 0
5614 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
5617 l_const
= r_const
= 0;
5619 /* If either comparison code is not correct for our logical operation,
5620 fail. However, we can convert a one-bit comparison against zero into
5621 the opposite comparison against that bit being set in the field. */
5623 wanted_code
= (code
== TRUTH_AND_EXPR
? EQ_EXPR
: NE_EXPR
);
5624 if (lcode
!= wanted_code
)
5626 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
5628 /* Make the left operand unsigned, since we are only interested
5629 in the value of one bit. Otherwise we are doing the wrong
5638 /* This is analogous to the code for l_const above. */
5639 if (rcode
!= wanted_code
)
5641 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
5650 /* See if we can find a mode that contains both fields being compared on
5651 the left. If we can't, fail. Otherwise, update all constants and masks
5652 to be relative to a field of that size. */
5653 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
5654 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
5655 lnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5656 TYPE_ALIGN (TREE_TYPE (ll_inner
)), word_mode
,
5658 if (lnmode
== VOIDmode
)
5661 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
5662 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
5663 lntype
= lang_hooks
.types
.type_for_size (lnbitsize
, 1);
5664 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
5666 if (ll_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5668 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
5669 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
5672 ll_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, ll_mask
),
5673 size_int (xll_bitpos
));
5674 rl_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, rl_mask
),
5675 size_int (xrl_bitpos
));
5679 l_const
= fold_convert_loc (loc
, lntype
, l_const
);
5680 l_const
= unextend (l_const
, ll_bitsize
, ll_unsignedp
, ll_and_mask
);
5681 l_const
= const_binop (LSHIFT_EXPR
, l_const
, size_int (xll_bitpos
));
5682 if (! integer_zerop (const_binop (BIT_AND_EXPR
, l_const
,
5683 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5686 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5688 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5693 r_const
= fold_convert_loc (loc
, lntype
, r_const
);
5694 r_const
= unextend (r_const
, rl_bitsize
, rl_unsignedp
, rl_and_mask
);
5695 r_const
= const_binop (LSHIFT_EXPR
, r_const
, size_int (xrl_bitpos
));
5696 if (! integer_zerop (const_binop (BIT_AND_EXPR
, r_const
,
5697 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5700 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5702 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5706 /* If the right sides are not constant, do the same for it. Also,
5707 disallow this optimization if a size or signedness mismatch occurs
5708 between the left and right sides. */
5711 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
5712 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
5713 /* Make sure the two fields on the right
5714 correspond to the left without being swapped. */
5715 || ll_bitpos
- rl_bitpos
!= lr_bitpos
- rr_bitpos
)
5718 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
5719 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
5720 rnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5721 TYPE_ALIGN (TREE_TYPE (lr_inner
)), word_mode
,
5723 if (rnmode
== VOIDmode
)
5726 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
5727 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
5728 rntype
= lang_hooks
.types
.type_for_size (rnbitsize
, 1);
5729 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
5731 if (lr_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5733 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
5734 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
5737 lr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5739 size_int (xlr_bitpos
));
5740 rr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5742 size_int (xrr_bitpos
));
5744 /* Make a mask that corresponds to both fields being compared.
5745 Do this for both items being compared. If the operands are the
5746 same size and the bits being compared are in the same position
5747 then we can do this by masking both and comparing the masked
5749 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5750 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
);
5751 if (lnbitsize
== rnbitsize
&& xll_bitpos
== xlr_bitpos
)
5753 lhs
= make_bit_field_ref (loc
, ll_inner
, ll_arg
,
5754 lntype
, lnbitsize
, lnbitpos
,
5755 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
5756 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5757 lhs
= build2 (BIT_AND_EXPR
, lntype
, lhs
, ll_mask
);
5759 rhs
= make_bit_field_ref (loc
, lr_inner
, lr_arg
,
5760 rntype
, rnbitsize
, rnbitpos
,
5761 lr_unsignedp
|| rr_unsignedp
, lr_reversep
);
5762 if (! all_ones_mask_p (lr_mask
, rnbitsize
))
5763 rhs
= build2 (BIT_AND_EXPR
, rntype
, rhs
, lr_mask
);
5765 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5768 /* There is still another way we can do something: If both pairs of
5769 fields being compared are adjacent, we may be able to make a wider
5770 field containing them both.
5772 Note that we still must mask the lhs/rhs expressions. Furthermore,
5773 the mask must be shifted to account for the shift done by
5774 make_bit_field_ref. */
5775 if ((ll_bitsize
+ ll_bitpos
== rl_bitpos
5776 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
5777 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
5778 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
5782 lhs
= make_bit_field_ref (loc
, ll_inner
, ll_arg
, lntype
,
5783 ll_bitsize
+ rl_bitsize
,
5784 MIN (ll_bitpos
, rl_bitpos
),
5785 ll_unsignedp
, ll_reversep
);
5786 rhs
= make_bit_field_ref (loc
, lr_inner
, lr_arg
, rntype
,
5787 lr_bitsize
+ rr_bitsize
,
5788 MIN (lr_bitpos
, rr_bitpos
),
5789 lr_unsignedp
, lr_reversep
);
5791 ll_mask
= const_binop (RSHIFT_EXPR
, ll_mask
,
5792 size_int (MIN (xll_bitpos
, xrl_bitpos
)));
5793 lr_mask
= const_binop (RSHIFT_EXPR
, lr_mask
,
5794 size_int (MIN (xlr_bitpos
, xrr_bitpos
)));
5796 /* Convert to the smaller type before masking out unwanted bits. */
5798 if (lntype
!= rntype
)
5800 if (lnbitsize
> rnbitsize
)
5802 lhs
= fold_convert_loc (loc
, rntype
, lhs
);
5803 ll_mask
= fold_convert_loc (loc
, rntype
, ll_mask
);
5806 else if (lnbitsize
< rnbitsize
)
5808 rhs
= fold_convert_loc (loc
, lntype
, rhs
);
5809 lr_mask
= fold_convert_loc (loc
, lntype
, lr_mask
);
5814 if (! all_ones_mask_p (ll_mask
, ll_bitsize
+ rl_bitsize
))
5815 lhs
= build2 (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
5817 if (! all_ones_mask_p (lr_mask
, lr_bitsize
+ rr_bitsize
))
5818 rhs
= build2 (BIT_AND_EXPR
, type
, rhs
, lr_mask
);
5820 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5826 /* Handle the case of comparisons with constants. If there is something in
5827 common between the masks, those bits of the constants must be the same.
5828 If not, the condition is always false. Test for this to avoid generating
5829 incorrect code below. */
5830 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
);
5831 if (! integer_zerop (result
)
5832 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
),
5833 const_binop (BIT_AND_EXPR
, result
, r_const
)) != 1)
5835 if (wanted_code
== NE_EXPR
)
5837 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5838 return constant_boolean_node (true, truth_type
);
5842 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5843 return constant_boolean_node (false, truth_type
);
5847 /* Construct the expression we will return. First get the component
5848 reference we will make. Unless the mask is all ones the width of
5849 that field, perform the mask operation. Then compare with the
5851 result
= make_bit_field_ref (loc
, ll_inner
, ll_arg
,
5852 lntype
, lnbitsize
, lnbitpos
,
5853 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
5855 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5856 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5857 result
= build2_loc (loc
, BIT_AND_EXPR
, lntype
, result
, ll_mask
);
5859 return build2_loc (loc
, wanted_code
, truth_type
, result
,
5860 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
5863 /* T is an integer expression that is being multiplied, divided, or taken a
5864 modulus (CODE says which and what kind of divide or modulus) by a
5865 constant C. See if we can eliminate that operation by folding it with
5866 other operations already in T. WIDE_TYPE, if non-null, is a type that
5867 should be used for the computation if wider than our type.
5869 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5870 (X * 2) + (Y * 4). We must, however, be assured that either the original
5871 expression would not overflow or that overflow is undefined for the type
5872 in the language in question.
5874 If we return a non-null expression, it is an equivalent form of the
5875 original computation, but need not be in the original type.
5877 We set *STRICT_OVERFLOW_P to true if the return values depends on
5878 signed overflow being undefined. Otherwise we do not change
5879 *STRICT_OVERFLOW_P. */
5882 extract_muldiv (tree t
, tree c
, enum tree_code code
, tree wide_type
,
5883 bool *strict_overflow_p
)
5885 /* To avoid exponential search depth, refuse to allow recursion past
5886 three levels. Beyond that (1) it's highly unlikely that we'll find
5887 something interesting and (2) we've probably processed it before
5888 when we built the inner expression. */
5897 ret
= extract_muldiv_1 (t
, c
, code
, wide_type
, strict_overflow_p
);
5904 extract_muldiv_1 (tree t
, tree c
, enum tree_code code
, tree wide_type
,
5905 bool *strict_overflow_p
)
5907 tree type
= TREE_TYPE (t
);
5908 enum tree_code tcode
= TREE_CODE (t
);
5909 tree ctype
= (wide_type
!= 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type
))
5910 > GET_MODE_SIZE (TYPE_MODE (type
)))
5911 ? wide_type
: type
);
5913 int same_p
= tcode
== code
;
5914 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
5915 bool sub_strict_overflow_p
;
5917 /* Don't deal with constants of zero here; they confuse the code below. */
5918 if (integer_zerop (c
))
5921 if (TREE_CODE_CLASS (tcode
) == tcc_unary
)
5922 op0
= TREE_OPERAND (t
, 0);
5924 if (TREE_CODE_CLASS (tcode
) == tcc_binary
)
5925 op0
= TREE_OPERAND (t
, 0), op1
= TREE_OPERAND (t
, 1);
5927 /* Note that we need not handle conditional operations here since fold
5928 already handles those cases. So just do arithmetic here. */
5932 /* For a constant, we can always simplify if we are a multiply
5933 or (for divide and modulus) if it is a multiple of our constant. */
5934 if (code
== MULT_EXPR
5935 || wi::multiple_of_p (t
, c
, TYPE_SIGN (type
)))
5937 tree tem
= const_binop (code
, fold_convert (ctype
, t
),
5938 fold_convert (ctype
, c
));
5939 /* If the multiplication overflowed, we lost information on it.
5940 See PR68142 and PR69845. */
5941 if (TREE_OVERFLOW (tem
))
5947 CASE_CONVERT
: case NON_LVALUE_EXPR
:
5948 /* If op0 is an expression ... */
5949 if ((COMPARISON_CLASS_P (op0
)
5950 || UNARY_CLASS_P (op0
)
5951 || BINARY_CLASS_P (op0
)
5952 || VL_EXP_CLASS_P (op0
)
5953 || EXPRESSION_CLASS_P (op0
))
5954 /* ... and has wrapping overflow, and its type is smaller
5955 than ctype, then we cannot pass through as widening. */
5956 && (((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
5957 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0
)))
5958 && (TYPE_PRECISION (ctype
)
5959 > TYPE_PRECISION (TREE_TYPE (op0
))))
5960 /* ... or this is a truncation (t is narrower than op0),
5961 then we cannot pass through this narrowing. */
5962 || (TYPE_PRECISION (type
)
5963 < TYPE_PRECISION (TREE_TYPE (op0
)))
5964 /* ... or signedness changes for division or modulus,
5965 then we cannot pass through this conversion. */
5966 || (code
!= MULT_EXPR
5967 && (TYPE_UNSIGNED (ctype
)
5968 != TYPE_UNSIGNED (TREE_TYPE (op0
))))
5969 /* ... or has undefined overflow while the converted to
5970 type has not, we cannot do the operation in the inner type
5971 as that would introduce undefined overflow. */
5972 || ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
5973 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0
)))
5974 && !TYPE_OVERFLOW_UNDEFINED (type
))))
5977 /* Pass the constant down and see if we can make a simplification. If
5978 we can, replace this expression with the inner simplification for
5979 possible later conversion to our or some other type. */
5980 if ((t2
= fold_convert (TREE_TYPE (op0
), c
)) != 0
5981 && TREE_CODE (t2
) == INTEGER_CST
5982 && !TREE_OVERFLOW (t2
)
5983 && (0 != (t1
= extract_muldiv (op0
, t2
, code
,
5985 ? ctype
: NULL_TREE
,
5986 strict_overflow_p
))))
5991 /* If widening the type changes it from signed to unsigned, then we
5992 must avoid building ABS_EXPR itself as unsigned. */
5993 if (TYPE_UNSIGNED (ctype
) && !TYPE_UNSIGNED (type
))
5995 tree cstype
= (*signed_type_for
) (ctype
);
5996 if ((t1
= extract_muldiv (op0
, c
, code
, cstype
, strict_overflow_p
))
5999 t1
= fold_build1 (tcode
, cstype
, fold_convert (cstype
, t1
));
6000 return fold_convert (ctype
, t1
);
6004 /* If the constant is negative, we cannot simplify this. */
6005 if (tree_int_cst_sgn (c
) == -1)
6009 /* For division and modulus, type can't be unsigned, as e.g.
6010 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6011 For signed types, even with wrapping overflow, this is fine. */
6012 if (code
!= MULT_EXPR
&& TYPE_UNSIGNED (type
))
6014 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
, strict_overflow_p
))
6016 return fold_build1 (tcode
, ctype
, fold_convert (ctype
, t1
));
6019 case MIN_EXPR
: case MAX_EXPR
:
6020 /* If widening the type changes the signedness, then we can't perform
6021 this optimization as that changes the result. */
6022 if (TYPE_UNSIGNED (ctype
) != TYPE_UNSIGNED (type
))
6025 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6026 sub_strict_overflow_p
= false;
6027 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6028 &sub_strict_overflow_p
)) != 0
6029 && (t2
= extract_muldiv (op1
, c
, code
, wide_type
,
6030 &sub_strict_overflow_p
)) != 0)
6032 if (tree_int_cst_sgn (c
) < 0)
6033 tcode
= (tcode
== MIN_EXPR
? MAX_EXPR
: MIN_EXPR
);
6034 if (sub_strict_overflow_p
)
6035 *strict_overflow_p
= true;
6036 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6037 fold_convert (ctype
, t2
));
6041 case LSHIFT_EXPR
: case RSHIFT_EXPR
:
6042 /* If the second operand is constant, this is a multiplication
6043 or floor division, by a power of two, so we can treat it that
6044 way unless the multiplier or divisor overflows. Signed
6045 left-shift overflow is implementation-defined rather than
6046 undefined in C90, so do not convert signed left shift into
6048 if (TREE_CODE (op1
) == INTEGER_CST
6049 && (tcode
== RSHIFT_EXPR
|| TYPE_UNSIGNED (TREE_TYPE (op0
)))
6050 /* const_binop may not detect overflow correctly,
6051 so check for it explicitly here. */
6052 && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
6053 && 0 != (t1
= fold_convert (ctype
,
6054 const_binop (LSHIFT_EXPR
,
6057 && !TREE_OVERFLOW (t1
))
6058 return extract_muldiv (build2 (tcode
== LSHIFT_EXPR
6059 ? MULT_EXPR
: FLOOR_DIV_EXPR
,
6061 fold_convert (ctype
, op0
),
6063 c
, code
, wide_type
, strict_overflow_p
);
6066 case PLUS_EXPR
: case MINUS_EXPR
:
6067 /* See if we can eliminate the operation on both sides. If we can, we
6068 can return a new PLUS or MINUS. If we can't, the only remaining
6069 cases where we can do anything are if the second operand is a
6071 sub_strict_overflow_p
= false;
6072 t1
= extract_muldiv (op0
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6073 t2
= extract_muldiv (op1
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6074 if (t1
!= 0 && t2
!= 0
6075 && (code
== MULT_EXPR
6076 /* If not multiplication, we can only do this if both operands
6077 are divisible by c. */
6078 || (multiple_of_p (ctype
, op0
, c
)
6079 && multiple_of_p (ctype
, op1
, c
))))
6081 if (sub_strict_overflow_p
)
6082 *strict_overflow_p
= true;
6083 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6084 fold_convert (ctype
, t2
));
6087 /* If this was a subtraction, negate OP1 and set it to be an addition.
6088 This simplifies the logic below. */
6089 if (tcode
== MINUS_EXPR
)
6091 tcode
= PLUS_EXPR
, op1
= negate_expr (op1
);
6092 /* If OP1 was not easily negatable, the constant may be OP0. */
6093 if (TREE_CODE (op0
) == INTEGER_CST
)
6095 std::swap (op0
, op1
);
6100 if (TREE_CODE (op1
) != INTEGER_CST
)
6103 /* If either OP1 or C are negative, this optimization is not safe for
6104 some of the division and remainder types while for others we need
6105 to change the code. */
6106 if (tree_int_cst_sgn (op1
) < 0 || tree_int_cst_sgn (c
) < 0)
6108 if (code
== CEIL_DIV_EXPR
)
6109 code
= FLOOR_DIV_EXPR
;
6110 else if (code
== FLOOR_DIV_EXPR
)
6111 code
= CEIL_DIV_EXPR
;
6112 else if (code
!= MULT_EXPR
6113 && code
!= CEIL_MOD_EXPR
&& code
!= FLOOR_MOD_EXPR
)
6117 /* If it's a multiply or a division/modulus operation of a multiple
6118 of our constant, do the operation and verify it doesn't overflow. */
6119 if (code
== MULT_EXPR
6120 || wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6122 op1
= const_binop (code
, fold_convert (ctype
, op1
),
6123 fold_convert (ctype
, c
));
6124 /* We allow the constant to overflow with wrapping semantics. */
6126 || (TREE_OVERFLOW (op1
) && !TYPE_OVERFLOW_WRAPS (ctype
)))
6132 /* If we have an unsigned type, we cannot widen the operation since it
6133 will change the result if the original computation overflowed. */
6134 if (TYPE_UNSIGNED (ctype
) && ctype
!= type
)
6137 /* If we were able to eliminate our operation from the first side,
6138 apply our operation to the second side and reform the PLUS. */
6139 if (t1
!= 0 && (TREE_CODE (t1
) != code
|| code
== MULT_EXPR
))
6140 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
), op1
);
6142 /* The last case is if we are a multiply. In that case, we can
6143 apply the distributive law to commute the multiply and addition
6144 if the multiplication of the constants doesn't overflow
6145 and overflow is defined. With undefined overflow
6146 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6147 if (code
== MULT_EXPR
&& TYPE_OVERFLOW_WRAPS (ctype
))
6148 return fold_build2 (tcode
, ctype
,
6149 fold_build2 (code
, ctype
,
6150 fold_convert (ctype
, op0
),
6151 fold_convert (ctype
, c
)),
6157 /* We have a special case here if we are doing something like
6158 (C * 8) % 4 since we know that's zero. */
6159 if ((code
== TRUNC_MOD_EXPR
|| code
== CEIL_MOD_EXPR
6160 || code
== FLOOR_MOD_EXPR
|| code
== ROUND_MOD_EXPR
)
6161 /* If the multiplication can overflow we cannot optimize this. */
6162 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
))
6163 && TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
6164 && wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6166 *strict_overflow_p
= true;
6167 return omit_one_operand (type
, integer_zero_node
, op0
);
6170 /* ... fall through ... */
6172 case TRUNC_DIV_EXPR
: case CEIL_DIV_EXPR
: case FLOOR_DIV_EXPR
:
6173 case ROUND_DIV_EXPR
: case EXACT_DIV_EXPR
:
6174 /* If we can extract our operation from the LHS, do so and return a
6175 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6176 do something only if the second operand is a constant. */
6178 && (t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6179 strict_overflow_p
)) != 0)
6180 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6181 fold_convert (ctype
, op1
));
6182 else if (tcode
== MULT_EXPR
&& code
== MULT_EXPR
6183 && (t1
= extract_muldiv (op1
, c
, code
, wide_type
,
6184 strict_overflow_p
)) != 0)
6185 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6186 fold_convert (ctype
, t1
));
6187 else if (TREE_CODE (op1
) != INTEGER_CST
)
6190 /* If these are the same operation types, we can associate them
6191 assuming no overflow. */
6194 bool overflow_p
= false;
6195 bool overflow_mul_p
;
6196 signop sign
= TYPE_SIGN (ctype
);
6197 unsigned prec
= TYPE_PRECISION (ctype
);
6198 wide_int mul
= wi::mul (wi::to_wide (op1
, prec
),
6199 wi::to_wide (c
, prec
),
6200 sign
, &overflow_mul_p
);
6201 overflow_p
= TREE_OVERFLOW (c
) | TREE_OVERFLOW (op1
);
6203 && ((sign
== UNSIGNED
&& tcode
!= MULT_EXPR
) || sign
== SIGNED
))
6206 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6207 wide_int_to_tree (ctype
, mul
));
6210 /* If these operations "cancel" each other, we have the main
6211 optimizations of this pass, which occur when either constant is a
6212 multiple of the other, in which case we replace this with either an
6213 operation or CODE or TCODE.
6215 If we have an unsigned type, we cannot do this since it will change
6216 the result if the original computation overflowed. */
6217 if (TYPE_OVERFLOW_UNDEFINED (ctype
)
6218 && ((code
== MULT_EXPR
&& tcode
== EXACT_DIV_EXPR
)
6219 || (tcode
== MULT_EXPR
6220 && code
!= TRUNC_MOD_EXPR
&& code
!= CEIL_MOD_EXPR
6221 && code
!= FLOOR_MOD_EXPR
&& code
!= ROUND_MOD_EXPR
6222 && code
!= MULT_EXPR
)))
6224 if (wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
6226 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6227 *strict_overflow_p
= true;
6228 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6229 fold_convert (ctype
,
6230 const_binop (TRUNC_DIV_EXPR
,
6233 else if (wi::multiple_of_p (c
, op1
, TYPE_SIGN (type
)))
6235 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6236 *strict_overflow_p
= true;
6237 return fold_build2 (code
, ctype
, fold_convert (ctype
, op0
),
6238 fold_convert (ctype
,
6239 const_binop (TRUNC_DIV_EXPR
,
6252 /* Return a node which has the indicated constant VALUE (either 0 or
6253 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6254 and is of the indicated TYPE. */
6257 constant_boolean_node (bool value
, tree type
)
6259 if (type
== integer_type_node
)
6260 return value
? integer_one_node
: integer_zero_node
;
6261 else if (type
== boolean_type_node
)
6262 return value
? boolean_true_node
: boolean_false_node
;
6263 else if (TREE_CODE (type
) == VECTOR_TYPE
)
6264 return build_vector_from_val (type
,
6265 build_int_cst (TREE_TYPE (type
),
6268 return fold_convert (type
, value
? integer_one_node
: integer_zero_node
);
6272 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6273 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6274 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6275 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6276 COND is the first argument to CODE; otherwise (as in the example
6277 given here), it is the second argument. TYPE is the type of the
6278 original expression. Return NULL_TREE if no simplification is
6282 fold_binary_op_with_conditional_arg (location_t loc
,
6283 enum tree_code code
,
6284 tree type
, tree op0
, tree op1
,
6285 tree cond
, tree arg
, int cond_first_p
)
6287 tree cond_type
= cond_first_p
? TREE_TYPE (op0
) : TREE_TYPE (op1
);
6288 tree arg_type
= cond_first_p
? TREE_TYPE (op1
) : TREE_TYPE (op0
);
6289 tree test
, true_value
, false_value
;
6290 tree lhs
= NULL_TREE
;
6291 tree rhs
= NULL_TREE
;
6292 enum tree_code cond_code
= COND_EXPR
;
6294 if (TREE_CODE (cond
) == COND_EXPR
6295 || TREE_CODE (cond
) == VEC_COND_EXPR
)
6297 test
= TREE_OPERAND (cond
, 0);
6298 true_value
= TREE_OPERAND (cond
, 1);
6299 false_value
= TREE_OPERAND (cond
, 2);
6300 /* If this operand throws an expression, then it does not make
6301 sense to try to perform a logical or arithmetic operation
6303 if (VOID_TYPE_P (TREE_TYPE (true_value
)))
6305 if (VOID_TYPE_P (TREE_TYPE (false_value
)))
6308 else if (!(TREE_CODE (type
) != VECTOR_TYPE
6309 && TREE_CODE (TREE_TYPE (cond
)) == VECTOR_TYPE
))
6311 tree testtype
= TREE_TYPE (cond
);
6313 true_value
= constant_boolean_node (true, testtype
);
6314 false_value
= constant_boolean_node (false, testtype
);
6317 /* Detect the case of mixing vector and scalar types - bail out. */
6320 if (TREE_CODE (TREE_TYPE (test
)) == VECTOR_TYPE
)
6321 cond_code
= VEC_COND_EXPR
;
6323 /* This transformation is only worthwhile if we don't have to wrap ARG
6324 in a SAVE_EXPR and the operation can be simplified without recursing
6325 on at least one of the branches once its pushed inside the COND_EXPR. */
6326 if (!TREE_CONSTANT (arg
)
6327 && (TREE_SIDE_EFFECTS (arg
)
6328 || TREE_CODE (arg
) == COND_EXPR
|| TREE_CODE (arg
) == VEC_COND_EXPR
6329 || TREE_CONSTANT (true_value
) || TREE_CONSTANT (false_value
)))
6332 arg
= fold_convert_loc (loc
, arg_type
, arg
);
6335 true_value
= fold_convert_loc (loc
, cond_type
, true_value
);
6337 lhs
= fold_build2_loc (loc
, code
, type
, true_value
, arg
);
6339 lhs
= fold_build2_loc (loc
, code
, type
, arg
, true_value
);
6343 false_value
= fold_convert_loc (loc
, cond_type
, false_value
);
6345 rhs
= fold_build2_loc (loc
, code
, type
, false_value
, arg
);
6347 rhs
= fold_build2_loc (loc
, code
, type
, arg
, false_value
);
6350 /* Check that we have simplified at least one of the branches. */
6351 if (!TREE_CONSTANT (arg
) && !TREE_CONSTANT (lhs
) && !TREE_CONSTANT (rhs
))
6354 return fold_build3_loc (loc
, cond_code
, type
, test
, lhs
, rhs
);
6358 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6360 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6361 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6362 ADDEND is the same as X.
6364 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6365 and finite. The problematic cases are when X is zero, and its mode
6366 has signed zeros. In the case of rounding towards -infinity,
6367 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6368 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6371 fold_real_zero_addition_p (const_tree type
, const_tree addend
, int negate
)
6373 if (!real_zerop (addend
))
6376 /* Don't allow the fold with -fsignaling-nans. */
6377 if (HONOR_SNANS (element_mode (type
)))
6380 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6381 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
6384 /* In a vector or complex, we would need to check the sign of all zeros. */
6385 if (TREE_CODE (addend
) != REAL_CST
)
6388 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6389 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend
)))
6392 /* The mode has signed zeros, and we have to honor their sign.
6393 In this situation, there is only one case we can return true for.
6394 X - 0 is the same as X unless rounding towards -infinity is
6396 return negate
&& !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
));
6399 /* Subroutine of fold() that optimizes comparisons of a division by
6400 a nonzero integer constant against an integer constant, i.e.
6403 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6404 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6405 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6407 The function returns the constant folded tree if a simplification
6408 can be made, and NULL_TREE otherwise. */
6411 fold_div_compare (location_t loc
,
6412 enum tree_code code
, tree type
, tree arg0
, tree arg1
)
6414 tree prod
, tmp
, hi
, lo
;
6415 tree arg00
= TREE_OPERAND (arg0
, 0);
6416 tree arg01
= TREE_OPERAND (arg0
, 1);
6417 signop sign
= TYPE_SIGN (TREE_TYPE (arg0
));
6418 bool neg_overflow
= false;
6421 /* We have to do this the hard way to detect unsigned overflow.
6422 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6423 wide_int val
= wi::mul (arg01
, arg1
, sign
, &overflow
);
6424 prod
= force_fit_type (TREE_TYPE (arg00
), val
, -1, overflow
);
6425 neg_overflow
= false;
6427 if (sign
== UNSIGNED
)
6429 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6430 build_int_cst (TREE_TYPE (arg01
), 1));
6433 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6434 val
= wi::add (prod
, tmp
, sign
, &overflow
);
6435 hi
= force_fit_type (TREE_TYPE (arg00
), val
,
6436 -1, overflow
| TREE_OVERFLOW (prod
));
6438 else if (tree_int_cst_sgn (arg01
) >= 0)
6440 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6441 build_int_cst (TREE_TYPE (arg01
), 1));
6442 switch (tree_int_cst_sgn (arg1
))
6445 neg_overflow
= true;
6446 lo
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6451 lo
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6456 hi
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6466 /* A negative divisor reverses the relational operators. */
6467 code
= swap_tree_comparison (code
);
6469 tmp
= int_const_binop (PLUS_EXPR
, arg01
,
6470 build_int_cst (TREE_TYPE (arg01
), 1));
6471 switch (tree_int_cst_sgn (arg1
))
6474 hi
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6479 hi
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6484 neg_overflow
= true;
6485 lo
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6497 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6498 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg00
);
6499 if (TREE_OVERFLOW (hi
))
6500 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6501 if (TREE_OVERFLOW (lo
))
6502 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6503 return build_range_check (loc
, type
, arg00
, 1, lo
, hi
);
6506 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6507 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg00
);
6508 if (TREE_OVERFLOW (hi
))
6509 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6510 if (TREE_OVERFLOW (lo
))
6511 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6512 return build_range_check (loc
, type
, arg00
, 0, lo
, hi
);
6515 if (TREE_OVERFLOW (lo
))
6517 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6518 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6520 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6523 if (TREE_OVERFLOW (hi
))
6525 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6526 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6528 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6531 if (TREE_OVERFLOW (hi
))
6533 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6534 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6536 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6539 if (TREE_OVERFLOW (lo
))
6541 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6542 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6544 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6554 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6555 equality/inequality test, then return a simplified form of the test
6556 using a sign testing. Otherwise return NULL. TYPE is the desired
6560 fold_single_bit_test_into_sign_test (location_t loc
,
6561 enum tree_code code
, tree arg0
, tree arg1
,
6564 /* If this is testing a single bit, we can optimize the test. */
6565 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6566 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6567 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6569 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6570 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6571 tree arg00
= sign_bit_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1));
6573 if (arg00
!= NULL_TREE
6574 /* This is only a win if casting to a signed type is cheap,
6575 i.e. when arg00's type is not a partial mode. */
6576 && TYPE_PRECISION (TREE_TYPE (arg00
))
6577 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg00
))))
6579 tree stype
= signed_type_for (TREE_TYPE (arg00
));
6580 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
6582 fold_convert_loc (loc
, stype
, arg00
),
6583 build_int_cst (stype
, 0));
6590 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6591 equality/inequality test, then return a simplified form of
6592 the test using shifts and logical operations. Otherwise return
6593 NULL. TYPE is the desired result type. */
6596 fold_single_bit_test (location_t loc
, enum tree_code code
,
6597 tree arg0
, tree arg1
, tree result_type
)
6599 /* If this is testing a single bit, we can optimize the test. */
6600 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6601 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6602 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6604 tree inner
= TREE_OPERAND (arg0
, 0);
6605 tree type
= TREE_TYPE (arg0
);
6606 int bitnum
= tree_log2 (TREE_OPERAND (arg0
, 1));
6607 machine_mode operand_mode
= TYPE_MODE (type
);
6609 tree signed_type
, unsigned_type
, intermediate_type
;
6612 /* First, see if we can fold the single bit test into a sign-bit
6614 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
,
6619 /* Otherwise we have (A & C) != 0 where C is a single bit,
6620 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6621 Similarly for (A & C) == 0. */
6623 /* If INNER is a right shift of a constant and it plus BITNUM does
6624 not overflow, adjust BITNUM and INNER. */
6625 if (TREE_CODE (inner
) == RSHIFT_EXPR
6626 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
6627 && bitnum
< TYPE_PRECISION (type
)
6628 && wi::ltu_p (TREE_OPERAND (inner
, 1),
6629 TYPE_PRECISION (type
) - bitnum
))
6631 bitnum
+= tree_to_uhwi (TREE_OPERAND (inner
, 1));
6632 inner
= TREE_OPERAND (inner
, 0);
6635 /* If we are going to be able to omit the AND below, we must do our
6636 operations as unsigned. If we must use the AND, we have a choice.
6637 Normally unsigned is faster, but for some machines signed is. */
6638 ops_unsigned
= (load_extend_op (operand_mode
) == SIGN_EXTEND
6639 && !flag_syntax_only
) ? 0 : 1;
6641 signed_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 0);
6642 unsigned_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 1);
6643 intermediate_type
= ops_unsigned
? unsigned_type
: signed_type
;
6644 inner
= fold_convert_loc (loc
, intermediate_type
, inner
);
6647 inner
= build2 (RSHIFT_EXPR
, intermediate_type
,
6648 inner
, size_int (bitnum
));
6650 one
= build_int_cst (intermediate_type
, 1);
6652 if (code
== EQ_EXPR
)
6653 inner
= fold_build2_loc (loc
, BIT_XOR_EXPR
, intermediate_type
, inner
, one
);
6655 /* Put the AND last so it can combine with more things. */
6656 inner
= build2 (BIT_AND_EXPR
, intermediate_type
, inner
, one
);
6658 /* Make sure to return the proper type. */
6659 inner
= fold_convert_loc (loc
, result_type
, inner
);
6666 /* Test whether it is preferable two swap two operands, ARG0 and
6667 ARG1, for example because ARG0 is an integer constant and ARG1
6671 tree_swap_operands_p (const_tree arg0
, const_tree arg1
)
6673 if (CONSTANT_CLASS_P (arg1
))
6675 if (CONSTANT_CLASS_P (arg0
))
6681 if (TREE_CONSTANT (arg1
))
6683 if (TREE_CONSTANT (arg0
))
6686 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6687 for commutative and comparison operators. Ensuring a canonical
6688 form allows the optimizers to find additional redundancies without
6689 having to explicitly check for both orderings. */
6690 if (TREE_CODE (arg0
) == SSA_NAME
6691 && TREE_CODE (arg1
) == SSA_NAME
6692 && SSA_NAME_VERSION (arg0
) > SSA_NAME_VERSION (arg1
))
6695 /* Put SSA_NAMEs last. */
6696 if (TREE_CODE (arg1
) == SSA_NAME
)
6698 if (TREE_CODE (arg0
) == SSA_NAME
)
6701 /* Put variables last. */
6711 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6712 means A >= Y && A != MAX, but in this case we know that
6713 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6716 fold_to_nonsharp_ineq_using_bound (location_t loc
, tree ineq
, tree bound
)
6718 tree a
, typea
, type
= TREE_TYPE (ineq
), a1
, diff
, y
;
6720 if (TREE_CODE (bound
) == LT_EXPR
)
6721 a
= TREE_OPERAND (bound
, 0);
6722 else if (TREE_CODE (bound
) == GT_EXPR
)
6723 a
= TREE_OPERAND (bound
, 1);
6727 typea
= TREE_TYPE (a
);
6728 if (!INTEGRAL_TYPE_P (typea
)
6729 && !POINTER_TYPE_P (typea
))
6732 if (TREE_CODE (ineq
) == LT_EXPR
)
6734 a1
= TREE_OPERAND (ineq
, 1);
6735 y
= TREE_OPERAND (ineq
, 0);
6737 else if (TREE_CODE (ineq
) == GT_EXPR
)
6739 a1
= TREE_OPERAND (ineq
, 0);
6740 y
= TREE_OPERAND (ineq
, 1);
6745 if (TREE_TYPE (a1
) != typea
)
6748 if (POINTER_TYPE_P (typea
))
6750 /* Convert the pointer types into integer before taking the difference. */
6751 tree ta
= fold_convert_loc (loc
, ssizetype
, a
);
6752 tree ta1
= fold_convert_loc (loc
, ssizetype
, a1
);
6753 diff
= fold_binary_loc (loc
, MINUS_EXPR
, ssizetype
, ta1
, ta
);
6756 diff
= fold_binary_loc (loc
, MINUS_EXPR
, typea
, a1
, a
);
6758 if (!diff
|| !integer_onep (diff
))
6761 return fold_build2_loc (loc
, GE_EXPR
, type
, a
, y
);
6764 /* Fold a sum or difference of at least one multiplication.
6765 Returns the folded tree or NULL if no simplification could be made. */
6768 fold_plusminus_mult_expr (location_t loc
, enum tree_code code
, tree type
,
6769 tree arg0
, tree arg1
)
6771 tree arg00
, arg01
, arg10
, arg11
;
6772 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
6774 /* (A * C) +- (B * C) -> (A+-B) * C.
6775 (A * C) +- A -> A * (C+-1).
6776 We are most concerned about the case where C is a constant,
6777 but other combinations show up during loop reduction. Since
6778 it is not difficult, try all four possibilities. */
6780 if (TREE_CODE (arg0
) == MULT_EXPR
)
6782 arg00
= TREE_OPERAND (arg0
, 0);
6783 arg01
= TREE_OPERAND (arg0
, 1);
6785 else if (TREE_CODE (arg0
) == INTEGER_CST
)
6787 arg00
= build_one_cst (type
);
6792 /* We cannot generate constant 1 for fract. */
6793 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
6796 arg01
= build_one_cst (type
);
6798 if (TREE_CODE (arg1
) == MULT_EXPR
)
6800 arg10
= TREE_OPERAND (arg1
, 0);
6801 arg11
= TREE_OPERAND (arg1
, 1);
6803 else if (TREE_CODE (arg1
) == INTEGER_CST
)
6805 arg10
= build_one_cst (type
);
6806 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6807 the purpose of this canonicalization. */
6808 if (wi::neg_p (arg1
, TYPE_SIGN (TREE_TYPE (arg1
)))
6809 && negate_expr_p (arg1
)
6810 && code
== PLUS_EXPR
)
6812 arg11
= negate_expr (arg1
);
6820 /* We cannot generate constant 1 for fract. */
6821 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
6824 arg11
= build_one_cst (type
);
6828 if (operand_equal_p (arg01
, arg11
, 0))
6829 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
6830 else if (operand_equal_p (arg00
, arg10
, 0))
6831 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
6832 else if (operand_equal_p (arg00
, arg11
, 0))
6833 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
6834 else if (operand_equal_p (arg01
, arg10
, 0))
6835 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
6837 /* No identical multiplicands; see if we can find a common
6838 power-of-two factor in non-power-of-two multiplies. This
6839 can help in multi-dimensional array access. */
6840 else if (tree_fits_shwi_p (arg01
)
6841 && tree_fits_shwi_p (arg11
))
6843 HOST_WIDE_INT int01
, int11
, tmp
;
6846 int01
= tree_to_shwi (arg01
);
6847 int11
= tree_to_shwi (arg11
);
6849 /* Move min of absolute values to int11. */
6850 if (absu_hwi (int01
) < absu_hwi (int11
))
6852 tmp
= int01
, int01
= int11
, int11
= tmp
;
6853 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
6860 if (exact_log2 (absu_hwi (int11
)) > 0 && int01
% int11
== 0
6861 /* The remainder should not be a constant, otherwise we
6862 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6863 increased the number of multiplications necessary. */
6864 && TREE_CODE (arg10
) != INTEGER_CST
)
6866 alt0
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (arg00
), arg00
,
6867 build_int_cst (TREE_TYPE (arg00
),
6872 maybe_same
= alt0
, alt0
= alt1
, alt1
= maybe_same
;
6877 return fold_build2_loc (loc
, MULT_EXPR
, type
,
6878 fold_build2_loc (loc
, code
, type
,
6879 fold_convert_loc (loc
, type
, alt0
),
6880 fold_convert_loc (loc
, type
, alt1
)),
6881 fold_convert_loc (loc
, type
, same
));
6886 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
6887 specified by EXPR into the buffer PTR of length LEN bytes.
6888 Return the number of bytes placed in the buffer, or zero
6892 native_encode_int (const_tree expr
, unsigned char *ptr
, int len
, int off
)
6894 tree type
= TREE_TYPE (expr
);
6895 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
6896 int byte
, offset
, word
, words
;
6897 unsigned char value
;
6899 if ((off
== -1 && total_bytes
> len
)
6900 || off
>= total_bytes
)
6904 words
= total_bytes
/ UNITS_PER_WORD
;
6906 for (byte
= 0; byte
< total_bytes
; byte
++)
6908 int bitpos
= byte
* BITS_PER_UNIT
;
6909 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
6911 value
= wi::extract_uhwi (wi::to_widest (expr
), bitpos
, BITS_PER_UNIT
);
6913 if (total_bytes
> UNITS_PER_WORD
)
6915 word
= byte
/ UNITS_PER_WORD
;
6916 if (WORDS_BIG_ENDIAN
)
6917 word
= (words
- 1) - word
;
6918 offset
= word
* UNITS_PER_WORD
;
6919 if (BYTES_BIG_ENDIAN
)
6920 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
6922 offset
+= byte
% UNITS_PER_WORD
;
6925 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
6927 && offset
- off
< len
)
6928 ptr
[offset
- off
] = value
;
6930 return MIN (len
, total_bytes
- off
);
6934 /* Subroutine of native_encode_expr. Encode the FIXED_CST
6935 specified by EXPR into the buffer PTR of length LEN bytes.
6936 Return the number of bytes placed in the buffer, or zero
6940 native_encode_fixed (const_tree expr
, unsigned char *ptr
, int len
, int off
)
6942 tree type
= TREE_TYPE (expr
);
6943 machine_mode mode
= TYPE_MODE (type
);
6944 int total_bytes
= GET_MODE_SIZE (mode
);
6945 FIXED_VALUE_TYPE value
;
6946 tree i_value
, i_type
;
6948 if (total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
6951 i_type
= lang_hooks
.types
.type_for_size (GET_MODE_BITSIZE (mode
), 1);
6953 if (NULL_TREE
== i_type
6954 || TYPE_PRECISION (i_type
) != total_bytes
)
6957 value
= TREE_FIXED_CST (expr
);
6958 i_value
= double_int_to_tree (i_type
, value
.data
);
6960 return native_encode_int (i_value
, ptr
, len
, off
);
6964 /* Subroutine of native_encode_expr. Encode the REAL_CST
6965 specified by EXPR into the buffer PTR of length LEN bytes.
6966 Return the number of bytes placed in the buffer, or zero
6970 native_encode_real (const_tree expr
, unsigned char *ptr
, int len
, int off
)
6972 tree type
= TREE_TYPE (expr
);
6973 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
6974 int byte
, offset
, word
, words
, bitpos
;
6975 unsigned char value
;
6977 /* There are always 32 bits in each long, no matter the size of
6978 the hosts long. We handle floating point representations with
6982 if ((off
== -1 && total_bytes
> len
)
6983 || off
>= total_bytes
)
6987 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
6989 real_to_target (tmp
, TREE_REAL_CST_PTR (expr
), TYPE_MODE (type
));
6991 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
6992 bitpos
+= BITS_PER_UNIT
)
6994 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
6995 value
= (unsigned char) (tmp
[bitpos
/ 32] >> (bitpos
& 31));
6997 if (UNITS_PER_WORD
< 4)
6999 word
= byte
/ UNITS_PER_WORD
;
7000 if (WORDS_BIG_ENDIAN
)
7001 word
= (words
- 1) - word
;
7002 offset
= word
* UNITS_PER_WORD
;
7003 if (BYTES_BIG_ENDIAN
)
7004 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7006 offset
+= byte
% UNITS_PER_WORD
;
7011 if (BYTES_BIG_ENDIAN
)
7013 /* Reverse bytes within each long, or within the entire float
7014 if it's smaller than a long (for HFmode). */
7015 offset
= MIN (3, total_bytes
- 1) - offset
;
7016 gcc_assert (offset
>= 0);
7019 offset
= offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3);
7021 && offset
- off
< len
)
7022 ptr
[offset
- off
] = value
;
7024 return MIN (len
, total_bytes
- off
);
7027 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7028 specified by EXPR into the buffer PTR of length LEN bytes.
7029 Return the number of bytes placed in the buffer, or zero
7033 native_encode_complex (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7038 part
= TREE_REALPART (expr
);
7039 rsize
= native_encode_expr (part
, ptr
, len
, off
);
7043 part
= TREE_IMAGPART (expr
);
7045 off
= MAX (0, off
- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (part
))));
7046 isize
= native_encode_expr (part
, ptr
+rsize
, len
-rsize
, off
);
7050 return rsize
+ isize
;
7054 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7055 specified by EXPR into the buffer PTR of length LEN bytes.
7056 Return the number of bytes placed in the buffer, or zero
7060 native_encode_vector (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7067 count
= VECTOR_CST_NELTS (expr
);
7068 itype
= TREE_TYPE (TREE_TYPE (expr
));
7069 size
= GET_MODE_SIZE (TYPE_MODE (itype
));
7070 for (i
= 0; i
< count
; i
++)
7077 elem
= VECTOR_CST_ELT (expr
, i
);
7078 int res
= native_encode_expr (elem
, ptr
+offset
, len
-offset
, off
);
7079 if ((off
== -1 && res
!= size
)
7092 /* Subroutine of native_encode_expr. Encode the STRING_CST
7093 specified by EXPR into the buffer PTR of length LEN bytes.
7094 Return the number of bytes placed in the buffer, or zero
7098 native_encode_string (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7100 tree type
= TREE_TYPE (expr
);
7101 HOST_WIDE_INT total_bytes
;
7103 if (TREE_CODE (type
) != ARRAY_TYPE
7104 || TREE_CODE (TREE_TYPE (type
)) != INTEGER_TYPE
7105 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))) != BITS_PER_UNIT
7106 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type
)))
7108 total_bytes
= tree_to_shwi (TYPE_SIZE_UNIT (type
));
7109 if ((off
== -1 && total_bytes
> len
)
7110 || off
>= total_bytes
)
7114 if (TREE_STRING_LENGTH (expr
) - off
< MIN (total_bytes
, len
))
7117 if (off
< TREE_STRING_LENGTH (expr
))
7119 written
= MIN (len
, TREE_STRING_LENGTH (expr
) - off
);
7120 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, written
);
7122 memset (ptr
+ written
, 0,
7123 MIN (total_bytes
- written
, len
- written
));
7126 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, MIN (total_bytes
, len
));
7127 return MIN (total_bytes
- off
, len
);
7131 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7132 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7133 buffer PTR of length LEN bytes. If OFF is not -1 then start
7134 the encoding at byte offset OFF and encode at most LEN bytes.
7135 Return the number of bytes placed in the buffer, or zero upon failure. */
7138 native_encode_expr (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7140 /* We don't support starting at negative offset and -1 is special. */
7144 switch (TREE_CODE (expr
))
7147 return native_encode_int (expr
, ptr
, len
, off
);
7150 return native_encode_real (expr
, ptr
, len
, off
);
7153 return native_encode_fixed (expr
, ptr
, len
, off
);
7156 return native_encode_complex (expr
, ptr
, len
, off
);
7159 return native_encode_vector (expr
, ptr
, len
, off
);
7162 return native_encode_string (expr
, ptr
, len
, off
);
7170 /* Subroutine of native_interpret_expr. Interpret the contents of
7171 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7172 If the buffer cannot be interpreted, return NULL_TREE. */
7175 native_interpret_int (tree type
, const unsigned char *ptr
, int len
)
7177 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7179 if (total_bytes
> len
7180 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7183 wide_int result
= wi::from_buffer (ptr
, total_bytes
);
7185 return wide_int_to_tree (type
, result
);
7189 /* Subroutine of native_interpret_expr. Interpret the contents of
7190 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7191 If the buffer cannot be interpreted, return NULL_TREE. */
7194 native_interpret_fixed (tree type
, const unsigned char *ptr
, int len
)
7196 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7198 FIXED_VALUE_TYPE fixed_value
;
7200 if (total_bytes
> len
7201 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7204 result
= double_int::from_buffer (ptr
, total_bytes
);
7205 fixed_value
= fixed_from_double_int (result
, TYPE_MODE (type
));
7207 return build_fixed (type
, fixed_value
);
7211 /* Subroutine of native_interpret_expr. Interpret the contents of
7212 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7213 If the buffer cannot be interpreted, return NULL_TREE. */
7216 native_interpret_real (tree type
, const unsigned char *ptr
, int len
)
7218 machine_mode mode
= TYPE_MODE (type
);
7219 int total_bytes
= GET_MODE_SIZE (mode
);
7220 unsigned char value
;
7221 /* There are always 32 bits in each long, no matter the size of
7222 the hosts long. We handle floating point representations with
7227 total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7228 if (total_bytes
> len
|| total_bytes
> 24)
7230 int words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7232 memset (tmp
, 0, sizeof (tmp
));
7233 for (int bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7234 bitpos
+= BITS_PER_UNIT
)
7236 /* Both OFFSET and BYTE index within a long;
7237 bitpos indexes the whole float. */
7238 int offset
, byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7239 if (UNITS_PER_WORD
< 4)
7241 int word
= byte
/ UNITS_PER_WORD
;
7242 if (WORDS_BIG_ENDIAN
)
7243 word
= (words
- 1) - word
;
7244 offset
= word
* UNITS_PER_WORD
;
7245 if (BYTES_BIG_ENDIAN
)
7246 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7248 offset
+= byte
% UNITS_PER_WORD
;
7253 if (BYTES_BIG_ENDIAN
)
7255 /* Reverse bytes within each long, or within the entire float
7256 if it's smaller than a long (for HFmode). */
7257 offset
= MIN (3, total_bytes
- 1) - offset
;
7258 gcc_assert (offset
>= 0);
7261 value
= ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)];
7263 tmp
[bitpos
/ 32] |= (unsigned long)value
<< (bitpos
& 31);
7266 real_from_target (&r
, tmp
, mode
);
7267 return build_real (type
, r
);
7271 /* Subroutine of native_interpret_expr. Interpret the contents of
7272 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7273 If the buffer cannot be interpreted, return NULL_TREE. */
7276 native_interpret_complex (tree type
, const unsigned char *ptr
, int len
)
7278 tree etype
, rpart
, ipart
;
7281 etype
= TREE_TYPE (type
);
7282 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7285 rpart
= native_interpret_expr (etype
, ptr
, size
);
7288 ipart
= native_interpret_expr (etype
, ptr
+size
, size
);
7291 return build_complex (type
, rpart
, ipart
);
7295 /* Subroutine of native_interpret_expr. Interpret the contents of
7296 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7297 If the buffer cannot be interpreted, return NULL_TREE. */
7300 native_interpret_vector (tree type
, const unsigned char *ptr
, int len
)
7306 etype
= TREE_TYPE (type
);
7307 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7308 count
= TYPE_VECTOR_SUBPARTS (type
);
7309 if (size
* count
> len
)
7312 elements
= XALLOCAVEC (tree
, count
);
7313 for (i
= count
- 1; i
>= 0; i
--)
7315 elem
= native_interpret_expr (etype
, ptr
+(i
*size
), size
);
7320 return build_vector (type
, elements
);
7324 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7325 the buffer PTR of length LEN as a constant of type TYPE. For
7326 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7327 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7328 return NULL_TREE. */
7331 native_interpret_expr (tree type
, const unsigned char *ptr
, int len
)
7333 switch (TREE_CODE (type
))
7339 case REFERENCE_TYPE
:
7340 return native_interpret_int (type
, ptr
, len
);
7343 return native_interpret_real (type
, ptr
, len
);
7345 case FIXED_POINT_TYPE
:
7346 return native_interpret_fixed (type
, ptr
, len
);
7349 return native_interpret_complex (type
, ptr
, len
);
7352 return native_interpret_vector (type
, ptr
, len
);
7359 /* Returns true if we can interpret the contents of a native encoding
7363 can_native_interpret_type_p (tree type
)
7365 switch (TREE_CODE (type
))
7371 case REFERENCE_TYPE
:
7372 case FIXED_POINT_TYPE
:
7382 /* Return true iff a constant of type TYPE is accepted by
7383 native_encode_expr. */
7386 can_native_encode_type_p (tree type
)
7388 switch (TREE_CODE (type
))
7392 case FIXED_POINT_TYPE
:
7402 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7403 TYPE at compile-time. If we're unable to perform the conversion
7404 return NULL_TREE. */
7407 fold_view_convert_expr (tree type
, tree expr
)
7409 /* We support up to 512-bit values (for V8DFmode). */
7410 unsigned char buffer
[64];
7413 /* Check that the host and target are sane. */
7414 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
7417 len
= native_encode_expr (expr
, buffer
, sizeof (buffer
));
7421 return native_interpret_expr (type
, buffer
, len
);
7424 /* Build an expression for the address of T. Folds away INDIRECT_REF
7425 to avoid confusing the gimplify process. */
7428 build_fold_addr_expr_with_type_loc (location_t loc
, tree t
, tree ptrtype
)
7430 /* The size of the object is not relevant when talking about its address. */
7431 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
7432 t
= TREE_OPERAND (t
, 0);
7434 if (TREE_CODE (t
) == INDIRECT_REF
)
7436 t
= TREE_OPERAND (t
, 0);
7438 if (TREE_TYPE (t
) != ptrtype
)
7439 t
= build1_loc (loc
, NOP_EXPR
, ptrtype
, t
);
7441 else if (TREE_CODE (t
) == MEM_REF
7442 && integer_zerop (TREE_OPERAND (t
, 1)))
7443 return TREE_OPERAND (t
, 0);
7444 else if (TREE_CODE (t
) == MEM_REF
7445 && TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
7446 return fold_binary (POINTER_PLUS_EXPR
, ptrtype
,
7447 TREE_OPERAND (t
, 0),
7448 convert_to_ptrofftype (TREE_OPERAND (t
, 1)));
7449 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
7451 t
= build_fold_addr_expr_loc (loc
, TREE_OPERAND (t
, 0));
7453 if (TREE_TYPE (t
) != ptrtype
)
7454 t
= fold_convert_loc (loc
, ptrtype
, t
);
7457 t
= build1_loc (loc
, ADDR_EXPR
, ptrtype
, t
);
7462 /* Build an expression for the address of T. */
7465 build_fold_addr_expr_loc (location_t loc
, tree t
)
7467 tree ptrtype
= build_pointer_type (TREE_TYPE (t
));
7469 return build_fold_addr_expr_with_type_loc (loc
, t
, ptrtype
);
7472 /* Fold a unary expression of code CODE and type TYPE with operand
7473 OP0. Return the folded expression if folding is successful.
7474 Otherwise, return NULL_TREE. */
7477 fold_unary_loc (location_t loc
, enum tree_code code
, tree type
, tree op0
)
7481 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
7483 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
7484 && TREE_CODE_LENGTH (code
) == 1);
7489 if (CONVERT_EXPR_CODE_P (code
)
7490 || code
== FLOAT_EXPR
|| code
== ABS_EXPR
|| code
== NEGATE_EXPR
)
7492 /* Don't use STRIP_NOPS, because signedness of argument type
7494 STRIP_SIGN_NOPS (arg0
);
7498 /* Strip any conversions that don't change the mode. This
7499 is safe for every expression, except for a comparison
7500 expression because its signedness is derived from its
7503 Note that this is done as an internal manipulation within
7504 the constant folder, in order to find the simplest
7505 representation of the arguments so that their form can be
7506 studied. In any cases, the appropriate type conversions
7507 should be put back in the tree that will get out of the
7512 if (CONSTANT_CLASS_P (arg0
))
7514 tree tem
= const_unop (code
, type
, arg0
);
7517 if (TREE_TYPE (tem
) != type
)
7518 tem
= fold_convert_loc (loc
, type
, tem
);
7524 tem
= generic_simplify (loc
, code
, type
, op0
);
7528 if (TREE_CODE_CLASS (code
) == tcc_unary
)
7530 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
7531 return build2 (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7532 fold_build1_loc (loc
, code
, type
,
7533 fold_convert_loc (loc
, TREE_TYPE (op0
),
7534 TREE_OPERAND (arg0
, 1))));
7535 else if (TREE_CODE (arg0
) == COND_EXPR
)
7537 tree arg01
= TREE_OPERAND (arg0
, 1);
7538 tree arg02
= TREE_OPERAND (arg0
, 2);
7539 if (! VOID_TYPE_P (TREE_TYPE (arg01
)))
7540 arg01
= fold_build1_loc (loc
, code
, type
,
7541 fold_convert_loc (loc
,
7542 TREE_TYPE (op0
), arg01
));
7543 if (! VOID_TYPE_P (TREE_TYPE (arg02
)))
7544 arg02
= fold_build1_loc (loc
, code
, type
,
7545 fold_convert_loc (loc
,
7546 TREE_TYPE (op0
), arg02
));
7547 tem
= fold_build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7550 /* If this was a conversion, and all we did was to move into
7551 inside the COND_EXPR, bring it back out. But leave it if
7552 it is a conversion from integer to integer and the
7553 result precision is no wider than a word since such a
7554 conversion is cheap and may be optimized away by combine,
7555 while it couldn't if it were outside the COND_EXPR. Then return
7556 so we don't get into an infinite recursion loop taking the
7557 conversion out and then back in. */
7559 if ((CONVERT_EXPR_CODE_P (code
)
7560 || code
== NON_LVALUE_EXPR
)
7561 && TREE_CODE (tem
) == COND_EXPR
7562 && TREE_CODE (TREE_OPERAND (tem
, 1)) == code
7563 && TREE_CODE (TREE_OPERAND (tem
, 2)) == code
7564 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 1))
7565 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 2))
7566 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))
7567 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 2), 0)))
7568 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7570 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))))
7571 && TYPE_PRECISION (TREE_TYPE (tem
)) <= BITS_PER_WORD
)
7572 || flag_syntax_only
))
7573 tem
= build1_loc (loc
, code
, type
,
7575 TREE_TYPE (TREE_OPERAND
7576 (TREE_OPERAND (tem
, 1), 0)),
7577 TREE_OPERAND (tem
, 0),
7578 TREE_OPERAND (TREE_OPERAND (tem
, 1), 0),
7579 TREE_OPERAND (TREE_OPERAND (tem
, 2),
7587 case NON_LVALUE_EXPR
:
7588 if (!maybe_lvalue_p (op0
))
7589 return fold_convert_loc (loc
, type
, op0
);
7594 case FIX_TRUNC_EXPR
:
7595 if (COMPARISON_CLASS_P (op0
))
7597 /* If we have (type) (a CMP b) and type is an integral type, return
7598 new expression involving the new type. Canonicalize
7599 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7601 Do not fold the result as that would not simplify further, also
7602 folding again results in recursions. */
7603 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
7604 return build2_loc (loc
, TREE_CODE (op0
), type
,
7605 TREE_OPERAND (op0
, 0),
7606 TREE_OPERAND (op0
, 1));
7607 else if (!INTEGRAL_TYPE_P (type
) && !VOID_TYPE_P (type
)
7608 && TREE_CODE (type
) != VECTOR_TYPE
)
7609 return build3_loc (loc
, COND_EXPR
, type
, op0
,
7610 constant_boolean_node (true, type
),
7611 constant_boolean_node (false, type
));
7614 /* Handle (T *)&A.B.C for A being of type T and B and C
7615 living at offset zero. This occurs frequently in
7616 C++ upcasting and then accessing the base. */
7617 if (TREE_CODE (op0
) == ADDR_EXPR
7618 && POINTER_TYPE_P (type
)
7619 && handled_component_p (TREE_OPERAND (op0
, 0)))
7621 HOST_WIDE_INT bitsize
, bitpos
;
7624 int unsignedp
, reversep
, volatilep
;
7626 = get_inner_reference (TREE_OPERAND (op0
, 0), &bitsize
, &bitpos
,
7627 &offset
, &mode
, &unsignedp
, &reversep
,
7629 /* If the reference was to a (constant) zero offset, we can use
7630 the address of the base if it has the same base type
7631 as the result type and the pointer type is unqualified. */
7632 if (! offset
&& bitpos
== 0
7633 && (TYPE_MAIN_VARIANT (TREE_TYPE (type
))
7634 == TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
7635 && TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
7636 return fold_convert_loc (loc
, type
,
7637 build_fold_addr_expr_loc (loc
, base
));
7640 if (TREE_CODE (op0
) == MODIFY_EXPR
7641 && TREE_CONSTANT (TREE_OPERAND (op0
, 1))
7642 /* Detect assigning a bitfield. */
7643 && !(TREE_CODE (TREE_OPERAND (op0
, 0)) == COMPONENT_REF
7645 (TREE_OPERAND (TREE_OPERAND (op0
, 0), 1))))
7647 /* Don't leave an assignment inside a conversion
7648 unless assigning a bitfield. */
7649 tem
= fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 1));
7650 /* First do the assignment, then return converted constant. */
7651 tem
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (tem
), op0
, tem
);
7652 TREE_NO_WARNING (tem
) = 1;
7653 TREE_USED (tem
) = 1;
7657 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7658 constants (if x has signed type, the sign bit cannot be set
7659 in c). This folds extension into the BIT_AND_EXPR.
7660 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7661 very likely don't have maximal range for their precision and this
7662 transformation effectively doesn't preserve non-maximal ranges. */
7663 if (TREE_CODE (type
) == INTEGER_TYPE
7664 && TREE_CODE (op0
) == BIT_AND_EXPR
7665 && TREE_CODE (TREE_OPERAND (op0
, 1)) == INTEGER_CST
)
7667 tree and_expr
= op0
;
7668 tree and0
= TREE_OPERAND (and_expr
, 0);
7669 tree and1
= TREE_OPERAND (and_expr
, 1);
7672 if (TYPE_UNSIGNED (TREE_TYPE (and_expr
))
7673 || (TYPE_PRECISION (type
)
7674 <= TYPE_PRECISION (TREE_TYPE (and_expr
))))
7676 else if (TYPE_PRECISION (TREE_TYPE (and1
))
7677 <= HOST_BITS_PER_WIDE_INT
7678 && tree_fits_uhwi_p (and1
))
7680 unsigned HOST_WIDE_INT cst
;
7682 cst
= tree_to_uhwi (and1
);
7683 cst
&= HOST_WIDE_INT_M1U
7684 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
7685 change
= (cst
== 0);
7687 && !flag_syntax_only
7688 && (load_extend_op (TYPE_MODE (TREE_TYPE (and0
)))
7691 tree uns
= unsigned_type_for (TREE_TYPE (and0
));
7692 and0
= fold_convert_loc (loc
, uns
, and0
);
7693 and1
= fold_convert_loc (loc
, uns
, and1
);
7698 tem
= force_fit_type (type
, wi::to_widest (and1
), 0,
7699 TREE_OVERFLOW (and1
));
7700 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
7701 fold_convert_loc (loc
, type
, and0
), tem
);
7705 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7706 cast (T1)X will fold away. We assume that this happens when X itself
7708 if (POINTER_TYPE_P (type
)
7709 && TREE_CODE (arg0
) == POINTER_PLUS_EXPR
7710 && CONVERT_EXPR_P (TREE_OPERAND (arg0
, 0)))
7712 tree arg00
= TREE_OPERAND (arg0
, 0);
7713 tree arg01
= TREE_OPERAND (arg0
, 1);
7715 return fold_build_pointer_plus_loc
7716 (loc
, fold_convert_loc (loc
, type
, arg00
), arg01
);
7719 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7720 of the same precision, and X is an integer type not narrower than
7721 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7722 if (INTEGRAL_TYPE_P (type
)
7723 && TREE_CODE (op0
) == BIT_NOT_EXPR
7724 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7725 && CONVERT_EXPR_P (TREE_OPERAND (op0
, 0))
7726 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
7728 tem
= TREE_OPERAND (TREE_OPERAND (op0
, 0), 0);
7729 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7730 && TYPE_PRECISION (type
) <= TYPE_PRECISION (TREE_TYPE (tem
)))
7731 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
7732 fold_convert_loc (loc
, type
, tem
));
7735 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7736 type of X and Y (integer types only). */
7737 if (INTEGRAL_TYPE_P (type
)
7738 && TREE_CODE (op0
) == MULT_EXPR
7739 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7740 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7742 /* Be careful not to introduce new overflows. */
7744 if (TYPE_OVERFLOW_WRAPS (type
))
7747 mult_type
= unsigned_type_for (type
);
7749 if (TYPE_PRECISION (mult_type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7751 tem
= fold_build2_loc (loc
, MULT_EXPR
, mult_type
,
7752 fold_convert_loc (loc
, mult_type
,
7753 TREE_OPERAND (op0
, 0)),
7754 fold_convert_loc (loc
, mult_type
,
7755 TREE_OPERAND (op0
, 1)));
7756 return fold_convert_loc (loc
, type
, tem
);
7762 case VIEW_CONVERT_EXPR
:
7763 if (TREE_CODE (op0
) == MEM_REF
)
7765 if (TYPE_ALIGN (TREE_TYPE (op0
)) != TYPE_ALIGN (type
))
7766 type
= build_aligned_type (type
, TYPE_ALIGN (TREE_TYPE (op0
)));
7767 tem
= fold_build2_loc (loc
, MEM_REF
, type
,
7768 TREE_OPERAND (op0
, 0), TREE_OPERAND (op0
, 1));
7769 REF_REVERSE_STORAGE_ORDER (tem
) = REF_REVERSE_STORAGE_ORDER (op0
);
7776 tem
= fold_negate_expr (loc
, arg0
);
7778 return fold_convert_loc (loc
, type
, tem
);
7782 /* Convert fabs((double)float) into (double)fabsf(float). */
7783 if (TREE_CODE (arg0
) == NOP_EXPR
7784 && TREE_CODE (type
) == REAL_TYPE
)
7786 tree targ0
= strip_float_extensions (arg0
);
7788 return fold_convert_loc (loc
, type
,
7789 fold_build1_loc (loc
, ABS_EXPR
,
7796 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
7797 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
7798 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
7799 fold_convert_loc (loc
, type
,
7800 TREE_OPERAND (arg0
, 0)))))
7801 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, tem
,
7802 fold_convert_loc (loc
, type
,
7803 TREE_OPERAND (arg0
, 1)));
7804 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
7805 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
7806 fold_convert_loc (loc
, type
,
7807 TREE_OPERAND (arg0
, 1)))))
7808 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
7809 fold_convert_loc (loc
, type
,
7810 TREE_OPERAND (arg0
, 0)), tem
);
7814 case TRUTH_NOT_EXPR
:
7815 /* Note that the operand of this must be an int
7816 and its values must be 0 or 1.
7817 ("true" is a fixed value perhaps depending on the language,
7818 but we don't handle values other than 1 correctly yet.) */
7819 tem
= fold_truth_not_expr (loc
, arg0
);
7822 return fold_convert_loc (loc
, type
, tem
);
7825 /* Fold *&X to X if X is an lvalue. */
7826 if (TREE_CODE (op0
) == ADDR_EXPR
)
7828 tree op00
= TREE_OPERAND (op0
, 0);
7830 || TREE_CODE (op00
) == PARM_DECL
7831 || TREE_CODE (op00
) == RESULT_DECL
)
7832 && !TREE_READONLY (op00
))
7839 } /* switch (code) */
7843 /* If the operation was a conversion do _not_ mark a resulting constant
7844 with TREE_OVERFLOW if the original constant was not. These conversions
7845 have implementation defined behavior and retaining the TREE_OVERFLOW
7846 flag here would confuse later passes such as VRP. */
7848 fold_unary_ignore_overflow_loc (location_t loc
, enum tree_code code
,
7849 tree type
, tree op0
)
7851 tree res
= fold_unary_loc (loc
, code
, type
, op0
);
7853 && TREE_CODE (res
) == INTEGER_CST
7854 && TREE_CODE (op0
) == INTEGER_CST
7855 && CONVERT_EXPR_CODE_P (code
))
7856 TREE_OVERFLOW (res
) = TREE_OVERFLOW (op0
);
7861 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
7862 operands OP0 and OP1. LOC is the location of the resulting expression.
7863 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
7864 Return the folded expression if folding is successful. Otherwise,
7865 return NULL_TREE. */
7867 fold_truth_andor (location_t loc
, enum tree_code code
, tree type
,
7868 tree arg0
, tree arg1
, tree op0
, tree op1
)
7872 /* We only do these simplifications if we are optimizing. */
7876 /* Check for things like (A || B) && (A || C). We can convert this
7877 to A || (B && C). Note that either operator can be any of the four
7878 truth and/or operations and the transformation will still be
7879 valid. Also note that we only care about order for the
7880 ANDIF and ORIF operators. If B contains side effects, this
7881 might change the truth-value of A. */
7882 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
7883 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
7884 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
7885 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
7886 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
7887 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
7889 tree a00
= TREE_OPERAND (arg0
, 0);
7890 tree a01
= TREE_OPERAND (arg0
, 1);
7891 tree a10
= TREE_OPERAND (arg1
, 0);
7892 tree a11
= TREE_OPERAND (arg1
, 1);
7893 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
7894 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
7895 && (code
== TRUTH_AND_EXPR
7896 || code
== TRUTH_OR_EXPR
));
7898 if (operand_equal_p (a00
, a10
, 0))
7899 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
7900 fold_build2_loc (loc
, code
, type
, a01
, a11
));
7901 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
7902 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
7903 fold_build2_loc (loc
, code
, type
, a01
, a10
));
7904 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
7905 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a01
,
7906 fold_build2_loc (loc
, code
, type
, a00
, a11
));
7908 /* This case if tricky because we must either have commutative
7909 operators or else A10 must not have side-effects. */
7911 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
7912 && operand_equal_p (a01
, a11
, 0))
7913 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
7914 fold_build2_loc (loc
, code
, type
, a00
, a10
),
7918 /* See if we can build a range comparison. */
7919 if (0 != (tem
= fold_range_test (loc
, code
, type
, op0
, op1
)))
7922 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
)
7923 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
))
7925 tem
= merge_truthop_with_opposite_arm (loc
, arg0
, arg1
, true);
7927 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
7930 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ORIF_EXPR
)
7931 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ANDIF_EXPR
))
7933 tem
= merge_truthop_with_opposite_arm (loc
, arg1
, arg0
, false);
7935 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
7938 /* Check for the possibility of merging component references. If our
7939 lhs is another similar operation, try to merge its rhs with our
7940 rhs. Then try to merge our lhs and rhs. */
7941 if (TREE_CODE (arg0
) == code
7942 && 0 != (tem
= fold_truth_andor_1 (loc
, code
, type
,
7943 TREE_OPERAND (arg0
, 1), arg1
)))
7944 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
7946 if ((tem
= fold_truth_andor_1 (loc
, code
, type
, arg0
, arg1
)) != 0)
7949 if (LOGICAL_OP_NON_SHORT_CIRCUIT
7950 && (code
== TRUTH_AND_EXPR
7951 || code
== TRUTH_ANDIF_EXPR
7952 || code
== TRUTH_OR_EXPR
7953 || code
== TRUTH_ORIF_EXPR
))
7955 enum tree_code ncode
, icode
;
7957 ncode
= (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_AND_EXPR
)
7958 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
;
7959 icode
= ncode
== TRUTH_AND_EXPR
? TRUTH_ANDIF_EXPR
: TRUTH_ORIF_EXPR
;
7961 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
7962 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
7963 We don't want to pack more than two leafs to a non-IF AND/OR
7965 If tree-code of left-hand operand isn't an AND/OR-IF code and not
7966 equal to IF-CODE, then we don't want to add right-hand operand.
7967 If the inner right-hand side of left-hand operand has
7968 side-effects, or isn't simple, then we can't add to it,
7969 as otherwise we might destroy if-sequence. */
7970 if (TREE_CODE (arg0
) == icode
7971 && simple_operand_p_2 (arg1
)
7972 /* Needed for sequence points to handle trappings, and
7974 && simple_operand_p_2 (TREE_OPERAND (arg0
, 1)))
7976 tem
= fold_build2_loc (loc
, ncode
, type
, TREE_OPERAND (arg0
, 1),
7978 return fold_build2_loc (loc
, icode
, type
, TREE_OPERAND (arg0
, 0),
7981 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
7982 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
7983 else if (TREE_CODE (arg1
) == icode
7984 && simple_operand_p_2 (arg0
)
7985 /* Needed for sequence points to handle trappings, and
7987 && simple_operand_p_2 (TREE_OPERAND (arg1
, 0)))
7989 tem
= fold_build2_loc (loc
, ncode
, type
,
7990 arg0
, TREE_OPERAND (arg1
, 0));
7991 return fold_build2_loc (loc
, icode
, type
, tem
,
7992 TREE_OPERAND (arg1
, 1));
7994 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
7996 For sequence point consistancy, we need to check for trapping,
7997 and side-effects. */
7998 else if (code
== icode
&& simple_operand_p_2 (arg0
)
7999 && simple_operand_p_2 (arg1
))
8000 return fold_build2_loc (loc
, ncode
, type
, arg0
, arg1
);
8006 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8007 by changing CODE to reduce the magnitude of constants involved in
8008 ARG0 of the comparison.
8009 Returns a canonicalized comparison tree if a simplification was
8010 possible, otherwise returns NULL_TREE.
8011 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8012 valid if signed overflow is undefined. */
8015 maybe_canonicalize_comparison_1 (location_t loc
, enum tree_code code
, tree type
,
8016 tree arg0
, tree arg1
,
8017 bool *strict_overflow_p
)
8019 enum tree_code code0
= TREE_CODE (arg0
);
8020 tree t
, cst0
= NULL_TREE
;
8023 /* Match A +- CST code arg1. We can change this only if overflow
8025 if (!((ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8026 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8027 /* In principle pointers also have undefined overflow behavior,
8028 but that causes problems elsewhere. */
8029 && !POINTER_TYPE_P (TREE_TYPE (arg0
))
8030 && (code0
== MINUS_EXPR
8031 || code0
== PLUS_EXPR
)
8032 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
))
8035 /* Identify the constant in arg0 and its sign. */
8036 cst0
= TREE_OPERAND (arg0
, 1);
8037 sgn0
= tree_int_cst_sgn (cst0
);
8039 /* Overflowed constants and zero will cause problems. */
8040 if (integer_zerop (cst0
)
8041 || TREE_OVERFLOW (cst0
))
8044 /* See if we can reduce the magnitude of the constant in
8045 arg0 by changing the comparison code. */
8046 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8048 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8050 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8051 else if (code
== GT_EXPR
8052 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8054 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8055 else if (code
== LE_EXPR
8056 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8058 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8059 else if (code
== GE_EXPR
8060 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8064 *strict_overflow_p
= true;
8066 /* Now build the constant reduced in magnitude. But not if that
8067 would produce one outside of its types range. */
8068 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0
))
8070 && TYPE_MIN_VALUE (TREE_TYPE (cst0
))
8071 && tree_int_cst_equal (cst0
, TYPE_MIN_VALUE (TREE_TYPE (cst0
))))
8073 && TYPE_MAX_VALUE (TREE_TYPE (cst0
))
8074 && tree_int_cst_equal (cst0
, TYPE_MAX_VALUE (TREE_TYPE (cst0
))))))
8077 t
= int_const_binop (sgn0
== -1 ? PLUS_EXPR
: MINUS_EXPR
,
8078 cst0
, build_int_cst (TREE_TYPE (cst0
), 1));
8079 t
= fold_build2_loc (loc
, code0
, TREE_TYPE (arg0
), TREE_OPERAND (arg0
, 0), t
);
8080 t
= fold_convert (TREE_TYPE (arg1
), t
);
8082 return fold_build2_loc (loc
, code
, type
, t
, arg1
);
8085 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8086 overflow further. Try to decrease the magnitude of constants involved
8087 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8088 and put sole constants at the second argument position.
8089 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8092 maybe_canonicalize_comparison (location_t loc
, enum tree_code code
, tree type
,
8093 tree arg0
, tree arg1
)
8096 bool strict_overflow_p
;
8097 const char * const warnmsg
= G_("assuming signed overflow does not occur "
8098 "when reducing constant in comparison");
8100 /* Try canonicalization by simplifying arg0. */
8101 strict_overflow_p
= false;
8102 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg0
, arg1
,
8103 &strict_overflow_p
);
8106 if (strict_overflow_p
)
8107 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8111 /* Try canonicalization by simplifying arg1 using the swapped
8113 code
= swap_tree_comparison (code
);
8114 strict_overflow_p
= false;
8115 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg1
, arg0
,
8116 &strict_overflow_p
);
8117 if (t
&& strict_overflow_p
)
8118 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8122 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8123 space. This is used to avoid issuing overflow warnings for
8124 expressions like &p->x which can not wrap. */
8127 pointer_may_wrap_p (tree base
, tree offset
, HOST_WIDE_INT bitpos
)
8129 if (!POINTER_TYPE_P (TREE_TYPE (base
)))
8136 int precision
= TYPE_PRECISION (TREE_TYPE (base
));
8137 if (offset
== NULL_TREE
)
8138 wi_offset
= wi::zero (precision
);
8139 else if (TREE_CODE (offset
) != INTEGER_CST
|| TREE_OVERFLOW (offset
))
8145 wide_int units
= wi::shwi (bitpos
/ BITS_PER_UNIT
, precision
);
8146 wide_int total
= wi::add (wi_offset
, units
, UNSIGNED
, &overflow
);
8150 if (!wi::fits_uhwi_p (total
))
8153 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (TREE_TYPE (base
)));
8157 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8159 if (TREE_CODE (base
) == ADDR_EXPR
)
8161 HOST_WIDE_INT base_size
;
8163 base_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base
, 0)));
8164 if (base_size
> 0 && size
< base_size
)
8168 return total
.to_uhwi () > (unsigned HOST_WIDE_INT
) size
;
8171 /* Return a positive integer when the symbol DECL is known to have
8172 a nonzero address, zero when it's known not to (e.g., it's a weak
8173 symbol), and a negative integer when the symbol is not yet in the
8174 symbol table and so whether or not its address is zero is unknown.
8175 For function local objects always return positive integer. */
8177 maybe_nonzero_address (tree decl
)
8179 if (DECL_P (decl
) && decl_in_symtab_p (decl
))
8180 if (struct symtab_node
*symbol
= symtab_node::get_create (decl
))
8181 return symbol
->nonzero_address ();
8183 /* Function local objects are never NULL. */
8185 && (DECL_CONTEXT (decl
)
8186 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
8187 && auto_var_in_fn_p (decl
, DECL_CONTEXT (decl
))))
8193 /* Subroutine of fold_binary. This routine performs all of the
8194 transformations that are common to the equality/inequality
8195 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8196 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8197 fold_binary should call fold_binary. Fold a comparison with
8198 tree code CODE and type TYPE with operands OP0 and OP1. Return
8199 the folded comparison or NULL_TREE. */
8202 fold_comparison (location_t loc
, enum tree_code code
, tree type
,
8205 const bool equality_code
= (code
== EQ_EXPR
|| code
== NE_EXPR
);
8206 tree arg0
, arg1
, tem
;
8211 STRIP_SIGN_NOPS (arg0
);
8212 STRIP_SIGN_NOPS (arg1
);
8214 /* For comparisons of pointers we can decompose it to a compile time
8215 comparison of the base objects and the offsets into the object.
8216 This requires at least one operand being an ADDR_EXPR or a
8217 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8218 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
8219 && (TREE_CODE (arg0
) == ADDR_EXPR
8220 || TREE_CODE (arg1
) == ADDR_EXPR
8221 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8222 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
8224 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
8225 HOST_WIDE_INT bitsize
, bitpos0
= 0, bitpos1
= 0;
8227 int volatilep
, reversep
, unsignedp
;
8228 bool indirect_base0
= false, indirect_base1
= false;
8230 /* Get base and offset for the access. Strip ADDR_EXPR for
8231 get_inner_reference, but put it back by stripping INDIRECT_REF
8232 off the base object if possible. indirect_baseN will be true
8233 if baseN is not an address but refers to the object itself. */
8235 if (TREE_CODE (arg0
) == ADDR_EXPR
)
8238 = get_inner_reference (TREE_OPERAND (arg0
, 0),
8239 &bitsize
, &bitpos0
, &offset0
, &mode
,
8240 &unsignedp
, &reversep
, &volatilep
);
8241 if (TREE_CODE (base0
) == INDIRECT_REF
)
8242 base0
= TREE_OPERAND (base0
, 0);
8244 indirect_base0
= true;
8246 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
8248 base0
= TREE_OPERAND (arg0
, 0);
8249 STRIP_SIGN_NOPS (base0
);
8250 if (TREE_CODE (base0
) == ADDR_EXPR
)
8253 = get_inner_reference (TREE_OPERAND (base0
, 0),
8254 &bitsize
, &bitpos0
, &offset0
, &mode
,
8255 &unsignedp
, &reversep
, &volatilep
);
8256 if (TREE_CODE (base0
) == INDIRECT_REF
)
8257 base0
= TREE_OPERAND (base0
, 0);
8259 indirect_base0
= true;
8261 if (offset0
== NULL_TREE
|| integer_zerop (offset0
))
8262 offset0
= TREE_OPERAND (arg0
, 1);
8264 offset0
= size_binop (PLUS_EXPR
, offset0
,
8265 TREE_OPERAND (arg0
, 1));
8266 if (TREE_CODE (offset0
) == INTEGER_CST
)
8268 offset_int tem
= wi::sext (wi::to_offset (offset0
),
8269 TYPE_PRECISION (sizetype
));
8270 tem
<<= LOG2_BITS_PER_UNIT
;
8272 if (wi::fits_shwi_p (tem
))
8274 bitpos0
= tem
.to_shwi ();
8275 offset0
= NULL_TREE
;
8281 if (TREE_CODE (arg1
) == ADDR_EXPR
)
8284 = get_inner_reference (TREE_OPERAND (arg1
, 0),
8285 &bitsize
, &bitpos1
, &offset1
, &mode
,
8286 &unsignedp
, &reversep
, &volatilep
);
8287 if (TREE_CODE (base1
) == INDIRECT_REF
)
8288 base1
= TREE_OPERAND (base1
, 0);
8290 indirect_base1
= true;
8292 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
8294 base1
= TREE_OPERAND (arg1
, 0);
8295 STRIP_SIGN_NOPS (base1
);
8296 if (TREE_CODE (base1
) == ADDR_EXPR
)
8299 = get_inner_reference (TREE_OPERAND (base1
, 0),
8300 &bitsize
, &bitpos1
, &offset1
, &mode
,
8301 &unsignedp
, &reversep
, &volatilep
);
8302 if (TREE_CODE (base1
) == INDIRECT_REF
)
8303 base1
= TREE_OPERAND (base1
, 0);
8305 indirect_base1
= true;
8307 if (offset1
== NULL_TREE
|| integer_zerop (offset1
))
8308 offset1
= TREE_OPERAND (arg1
, 1);
8310 offset1
= size_binop (PLUS_EXPR
, offset1
,
8311 TREE_OPERAND (arg1
, 1));
8312 if (TREE_CODE (offset1
) == INTEGER_CST
)
8314 offset_int tem
= wi::sext (wi::to_offset (offset1
),
8315 TYPE_PRECISION (sizetype
));
8316 tem
<<= LOG2_BITS_PER_UNIT
;
8318 if (wi::fits_shwi_p (tem
))
8320 bitpos1
= tem
.to_shwi ();
8321 offset1
= NULL_TREE
;
8326 /* If we have equivalent bases we might be able to simplify. */
8327 if (indirect_base0
== indirect_base1
8328 && operand_equal_p (base0
, base1
,
8329 indirect_base0
? OEP_ADDRESS_OF
: 0))
8331 /* We can fold this expression to a constant if the non-constant
8332 offset parts are equal. */
8333 if ((offset0
== offset1
8334 || (offset0
&& offset1
8335 && operand_equal_p (offset0
, offset1
, 0)))
8338 && (DECL_P (base0
) || CONSTANT_CLASS_P (base0
)))
8339 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8343 && bitpos0
!= bitpos1
8344 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8345 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8346 fold_overflow_warning (("assuming pointer wraparound does not "
8347 "occur when comparing P +- C1 with "
8349 WARN_STRICT_OVERFLOW_CONDITIONAL
);
8354 return constant_boolean_node (bitpos0
== bitpos1
, type
);
8356 return constant_boolean_node (bitpos0
!= bitpos1
, type
);
8358 return constant_boolean_node (bitpos0
< bitpos1
, type
);
8360 return constant_boolean_node (bitpos0
<= bitpos1
, type
);
8362 return constant_boolean_node (bitpos0
>= bitpos1
, type
);
8364 return constant_boolean_node (bitpos0
> bitpos1
, type
);
8368 /* We can simplify the comparison to a comparison of the variable
8369 offset parts if the constant offset parts are equal.
8370 Be careful to use signed sizetype here because otherwise we
8371 mess with array offsets in the wrong way. This is possible
8372 because pointer arithmetic is restricted to retain within an
8373 object and overflow on pointer differences is undefined as of
8374 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8375 else if (bitpos0
== bitpos1
8378 && (DECL_P (base0
) || CONSTANT_CLASS_P (base0
)))
8379 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8381 /* By converting to signed sizetype we cover middle-end pointer
8382 arithmetic which operates on unsigned pointer types of size
8383 type size and ARRAY_REF offsets which are properly sign or
8384 zero extended from their type in case it is narrower than
8386 if (offset0
== NULL_TREE
)
8387 offset0
= build_int_cst (ssizetype
, 0);
8389 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
8390 if (offset1
== NULL_TREE
)
8391 offset1
= build_int_cst (ssizetype
, 0);
8393 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
8396 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8397 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8398 fold_overflow_warning (("assuming pointer wraparound does not "
8399 "occur when comparing P +- C1 with "
8401 WARN_STRICT_OVERFLOW_COMPARISON
);
8403 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
8406 /* For equal offsets we can simplify to a comparison of the
8408 else if (bitpos0
== bitpos1
8410 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
8412 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
8413 && ((offset0
== offset1
)
8414 || (offset0
&& offset1
8415 && operand_equal_p (offset0
, offset1
, 0))))
8418 base0
= build_fold_addr_expr_loc (loc
, base0
);
8420 base1
= build_fold_addr_expr_loc (loc
, base1
);
8421 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
8423 /* Comparison between an ordinary (non-weak) symbol and a null
8424 pointer can be eliminated since such symbols must have a non
8425 null address. In C, relational expressions between pointers
8426 to objects and null pointers are undefined. The results
8427 below follow the C++ rules with the additional property that
8428 every object pointer compares greater than a null pointer.
8430 else if (((DECL_P (base0
)
8431 && maybe_nonzero_address (base0
) > 0
8432 /* Avoid folding references to struct members at offset 0 to
8433 prevent tests like '&ptr->firstmember == 0' from getting
8434 eliminated. When ptr is null, although the -> expression
8435 is strictly speaking invalid, GCC retains it as a matter
8436 of QoI. See PR c/44555. */
8437 && (offset0
== NULL_TREE
&& bitpos0
!= 0))
8438 || CONSTANT_CLASS_P (base0
))
8440 /* The caller guarantees that when one of the arguments is
8441 constant (i.e., null in this case) it is second. */
8442 && integer_zerop (arg1
))
8449 return constant_boolean_node (false, type
);
8453 return constant_boolean_node (true, type
);
8460 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8461 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8462 the resulting offset is smaller in absolute value than the
8463 original one and has the same sign. */
8464 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8465 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
8466 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8467 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8468 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
8469 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
8470 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
8471 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
8473 tree const1
= TREE_OPERAND (arg0
, 1);
8474 tree const2
= TREE_OPERAND (arg1
, 1);
8475 tree variable1
= TREE_OPERAND (arg0
, 0);
8476 tree variable2
= TREE_OPERAND (arg1
, 0);
8478 const char * const warnmsg
= G_("assuming signed overflow does not "
8479 "occur when combining constants around "
8482 /* Put the constant on the side where it doesn't overflow and is
8483 of lower absolute value and of same sign than before. */
8484 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8485 ? MINUS_EXPR
: PLUS_EXPR
,
8487 if (!TREE_OVERFLOW (cst
)
8488 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
)
8489 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const2
))
8491 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8492 return fold_build2_loc (loc
, code
, type
,
8494 fold_build2_loc (loc
, TREE_CODE (arg1
),
8499 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8500 ? MINUS_EXPR
: PLUS_EXPR
,
8502 if (!TREE_OVERFLOW (cst
)
8503 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
)
8504 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const1
))
8506 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8507 return fold_build2_loc (loc
, code
, type
,
8508 fold_build2_loc (loc
, TREE_CODE (arg0
),
8515 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
8519 /* If we are comparing an expression that just has comparisons
8520 of two integer values, arithmetic expressions of those comparisons,
8521 and constants, we can simplify it. There are only three cases
8522 to check: the two values can either be equal, the first can be
8523 greater, or the second can be greater. Fold the expression for
8524 those three values. Since each value must be 0 or 1, we have
8525 eight possibilities, each of which corresponds to the constant 0
8526 or 1 or one of the six possible comparisons.
8528 This handles common cases like (a > b) == 0 but also handles
8529 expressions like ((x > y) - (y > x)) > 0, which supposedly
8530 occur in macroized code. */
8532 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
8534 tree cval1
= 0, cval2
= 0;
8537 if (twoval_comparison_p (arg0
, &cval1
, &cval2
, &save_p
)
8538 /* Don't handle degenerate cases here; they should already
8539 have been handled anyway. */
8540 && cval1
!= 0 && cval2
!= 0
8541 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
8542 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
8543 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
8544 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
8545 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
8546 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
8547 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
8549 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
8550 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
8552 /* We can't just pass T to eval_subst in case cval1 or cval2
8553 was the same as ARG1. */
8556 = fold_build2_loc (loc
, code
, type
,
8557 eval_subst (loc
, arg0
, cval1
, maxval
,
8561 = fold_build2_loc (loc
, code
, type
,
8562 eval_subst (loc
, arg0
, cval1
, maxval
,
8566 = fold_build2_loc (loc
, code
, type
,
8567 eval_subst (loc
, arg0
, cval1
, minval
,
8571 /* All three of these results should be 0 or 1. Confirm they are.
8572 Then use those values to select the proper code to use. */
8574 if (TREE_CODE (high_result
) == INTEGER_CST
8575 && TREE_CODE (equal_result
) == INTEGER_CST
8576 && TREE_CODE (low_result
) == INTEGER_CST
)
8578 /* Make a 3-bit mask with the high-order bit being the
8579 value for `>', the next for '=', and the low for '<'. */
8580 switch ((integer_onep (high_result
) * 4)
8581 + (integer_onep (equal_result
) * 2)
8582 + integer_onep (low_result
))
8586 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
8607 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
8612 tem
= save_expr (build2 (code
, type
, cval1
, cval2
));
8613 SET_EXPR_LOCATION (tem
, loc
);
8616 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
8621 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8622 into a single range test. */
8623 if (TREE_CODE (arg0
) == TRUNC_DIV_EXPR
8624 && TREE_CODE (arg1
) == INTEGER_CST
8625 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8626 && !integer_zerop (TREE_OPERAND (arg0
, 1))
8627 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
8628 && !TREE_OVERFLOW (arg1
))
8630 tem
= fold_div_compare (loc
, code
, type
, arg0
, arg1
);
8631 if (tem
!= NULL_TREE
)
8639 /* Subroutine of fold_binary. Optimize complex multiplications of the
8640 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8641 argument EXPR represents the expression "z" of type TYPE. */
8644 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
8646 tree itype
= TREE_TYPE (type
);
8647 tree rpart
, ipart
, tem
;
8649 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
8651 rpart
= TREE_OPERAND (expr
, 0);
8652 ipart
= TREE_OPERAND (expr
, 1);
8654 else if (TREE_CODE (expr
) == COMPLEX_CST
)
8656 rpart
= TREE_REALPART (expr
);
8657 ipart
= TREE_IMAGPART (expr
);
8661 expr
= save_expr (expr
);
8662 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
8663 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
8666 rpart
= save_expr (rpart
);
8667 ipart
= save_expr (ipart
);
8668 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
8669 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
8670 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
8671 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
8672 build_zero_cst (itype
));
8676 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8677 CONSTRUCTOR ARG into array ELTS and return true if successful. */
8680 vec_cst_ctor_to_array (tree arg
, tree
*elts
)
8682 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg
)), i
;
8684 if (TREE_CODE (arg
) == VECTOR_CST
)
8686 for (i
= 0; i
< VECTOR_CST_NELTS (arg
); ++i
)
8687 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
8689 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
8691 constructor_elt
*elt
;
8693 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
8694 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
8697 elts
[i
] = elt
->value
;
8701 for (; i
< nelts
; i
++)
8703 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
8707 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8708 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8709 NULL_TREE otherwise. */
8712 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const unsigned char *sel
)
8714 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8716 bool need_ctor
= false;
8718 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
8719 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
);
8720 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
8721 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
8724 elts
= XALLOCAVEC (tree
, nelts
* 3);
8725 if (!vec_cst_ctor_to_array (arg0
, elts
)
8726 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
))
8729 for (i
= 0; i
< nelts
; i
++)
8731 if (!CONSTANT_CLASS_P (elts
[sel
[i
]]))
8733 elts
[i
+ 2 * nelts
] = unshare_expr (elts
[sel
[i
]]);
8738 vec
<constructor_elt
, va_gc
> *v
;
8739 vec_alloc (v
, nelts
);
8740 for (i
= 0; i
< nelts
; i
++)
8741 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, elts
[2 * nelts
+ i
]);
8742 return build_constructor (type
, v
);
8745 return build_vector (type
, &elts
[2 * nelts
]);
8748 /* Try to fold a pointer difference of type TYPE two address expressions of
8749 array references AREF0 and AREF1 using location LOC. Return a
8750 simplified expression for the difference or NULL_TREE. */
8753 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
8754 tree aref0
, tree aref1
)
8756 tree base0
= TREE_OPERAND (aref0
, 0);
8757 tree base1
= TREE_OPERAND (aref1
, 0);
8758 tree base_offset
= build_int_cst (type
, 0);
8760 /* If the bases are array references as well, recurse. If the bases
8761 are pointer indirections compute the difference of the pointers.
8762 If the bases are equal, we are set. */
8763 if ((TREE_CODE (base0
) == ARRAY_REF
8764 && TREE_CODE (base1
) == ARRAY_REF
8766 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
)))
8767 || (INDIRECT_REF_P (base0
)
8768 && INDIRECT_REF_P (base1
)
8770 = fold_binary_loc (loc
, MINUS_EXPR
, type
,
8771 fold_convert (type
, TREE_OPERAND (base0
, 0)),
8773 TREE_OPERAND (base1
, 0)))))
8774 || operand_equal_p (base0
, base1
, OEP_ADDRESS_OF
))
8776 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
8777 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
8778 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
8779 tree diff
= build2 (MINUS_EXPR
, type
, op0
, op1
);
8780 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
8782 fold_build2_loc (loc
, MULT_EXPR
, type
,
8788 /* If the real or vector real constant CST of type TYPE has an exact
8789 inverse, return it, else return NULL. */
8792 exact_inverse (tree type
, tree cst
)
8795 tree unit_type
, *elts
;
8797 unsigned vec_nelts
, i
;
8799 switch (TREE_CODE (cst
))
8802 r
= TREE_REAL_CST (cst
);
8804 if (exact_real_inverse (TYPE_MODE (type
), &r
))
8805 return build_real (type
, r
);
8810 vec_nelts
= VECTOR_CST_NELTS (cst
);
8811 elts
= XALLOCAVEC (tree
, vec_nelts
);
8812 unit_type
= TREE_TYPE (type
);
8813 mode
= TYPE_MODE (unit_type
);
8815 for (i
= 0; i
< vec_nelts
; i
++)
8817 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
8818 if (!exact_real_inverse (mode
, &r
))
8820 elts
[i
] = build_real (unit_type
, r
);
8823 return build_vector (type
, elts
);
8830 /* Mask out the tz least significant bits of X of type TYPE where
8831 tz is the number of trailing zeroes in Y. */
8833 mask_with_tz (tree type
, const wide_int
&x
, const wide_int
&y
)
8835 int tz
= wi::ctz (y
);
8837 return wi::mask (tz
, true, TYPE_PRECISION (type
)) & x
;
8841 /* Return true when T is an address and is known to be nonzero.
8842 For floating point we further ensure that T is not denormal.
8843 Similar logic is present in nonzero_address in rtlanal.h.
8845 If the return value is based on the assumption that signed overflow
8846 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
8847 change *STRICT_OVERFLOW_P. */
8850 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
8852 tree type
= TREE_TYPE (t
);
8853 enum tree_code code
;
8855 /* Doing something useful for floating point would need more work. */
8856 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
8859 code
= TREE_CODE (t
);
8860 switch (TREE_CODE_CLASS (code
))
8863 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
8866 case tcc_comparison
:
8867 return tree_binary_nonzero_warnv_p (code
, type
,
8868 TREE_OPERAND (t
, 0),
8869 TREE_OPERAND (t
, 1),
8872 case tcc_declaration
:
8874 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
8882 case TRUTH_NOT_EXPR
:
8883 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
8886 case TRUTH_AND_EXPR
:
8888 case TRUTH_XOR_EXPR
:
8889 return tree_binary_nonzero_warnv_p (code
, type
,
8890 TREE_OPERAND (t
, 0),
8891 TREE_OPERAND (t
, 1),
8899 case WITH_SIZE_EXPR
:
8901 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
8906 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
8910 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
8915 tree fndecl
= get_callee_fndecl (t
);
8916 if (!fndecl
) return false;
8917 if (flag_delete_null_pointer_checks
&& !flag_check_new
8918 && DECL_IS_OPERATOR_NEW (fndecl
)
8919 && !TREE_NOTHROW (fndecl
))
8921 if (flag_delete_null_pointer_checks
8922 && lookup_attribute ("returns_nonnull",
8923 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
8925 return alloca_call_p (t
);
8934 /* Return true when T is an address and is known to be nonzero.
8935 Handle warnings about undefined signed overflow. */
8938 tree_expr_nonzero_p (tree t
)
8940 bool ret
, strict_overflow_p
;
8942 strict_overflow_p
= false;
8943 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
8944 if (strict_overflow_p
)
8945 fold_overflow_warning (("assuming signed overflow does not occur when "
8946 "determining that expression is always "
8948 WARN_STRICT_OVERFLOW_MISC
);
8952 /* Return true if T is known not to be equal to an integer W. */
8955 expr_not_equal_to (tree t
, const wide_int
&w
)
8957 wide_int min
, max
, nz
;
8958 value_range_type rtype
;
8959 switch (TREE_CODE (t
))
8962 return wi::ne_p (t
, w
);
8965 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
8967 rtype
= get_range_info (t
, &min
, &max
);
8968 if (rtype
== VR_RANGE
)
8970 if (wi::lt_p (max
, w
, TYPE_SIGN (TREE_TYPE (t
))))
8972 if (wi::lt_p (w
, min
, TYPE_SIGN (TREE_TYPE (t
))))
8975 else if (rtype
== VR_ANTI_RANGE
8976 && wi::le_p (min
, w
, TYPE_SIGN (TREE_TYPE (t
)))
8977 && wi::le_p (w
, max
, TYPE_SIGN (TREE_TYPE (t
))))
8979 /* If T has some known zero bits and W has any of those bits set,
8980 then T is known not to be equal to W. */
8981 if (wi::ne_p (wi::zext (wi::bit_and_not (w
, get_nonzero_bits (t
)),
8982 TYPE_PRECISION (TREE_TYPE (t
))), 0))
8991 /* Fold a binary expression of code CODE and type TYPE with operands
8992 OP0 and OP1. LOC is the location of the resulting expression.
8993 Return the folded expression if folding is successful. Otherwise,
8994 return NULL_TREE. */
8997 fold_binary_loc (location_t loc
,
8998 enum tree_code code
, tree type
, tree op0
, tree op1
)
9000 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
9001 tree arg0
, arg1
, tem
;
9002 tree t1
= NULL_TREE
;
9003 bool strict_overflow_p
;
9006 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
9007 && TREE_CODE_LENGTH (code
) == 2
9009 && op1
!= NULL_TREE
);
9014 /* Strip any conversions that don't change the mode. This is
9015 safe for every expression, except for a comparison expression
9016 because its signedness is derived from its operands. So, in
9017 the latter case, only strip conversions that don't change the
9018 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9021 Note that this is done as an internal manipulation within the
9022 constant folder, in order to find the simplest representation
9023 of the arguments so that their form can be studied. In any
9024 cases, the appropriate type conversions should be put back in
9025 the tree that will get out of the constant folder. */
9027 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
9029 STRIP_SIGN_NOPS (arg0
);
9030 STRIP_SIGN_NOPS (arg1
);
9038 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9039 constant but we can't do arithmetic on them. */
9040 if (CONSTANT_CLASS_P (arg0
) && CONSTANT_CLASS_P (arg1
))
9042 tem
= const_binop (code
, type
, arg0
, arg1
);
9043 if (tem
!= NULL_TREE
)
9045 if (TREE_TYPE (tem
) != type
)
9046 tem
= fold_convert_loc (loc
, type
, tem
);
9051 /* If this is a commutative operation, and ARG0 is a constant, move it
9052 to ARG1 to reduce the number of tests below. */
9053 if (commutative_tree_code (code
)
9054 && tree_swap_operands_p (arg0
, arg1
))
9055 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
9057 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9058 to ARG1 to reduce the number of tests below. */
9059 if (kind
== tcc_comparison
9060 && tree_swap_operands_p (arg0
, arg1
))
9061 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
9063 tem
= generic_simplify (loc
, code
, type
, op0
, op1
);
9067 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9069 First check for cases where an arithmetic operation is applied to a
9070 compound, conditional, or comparison operation. Push the arithmetic
9071 operation inside the compound or conditional to see if any folding
9072 can then be done. Convert comparison to conditional for this purpose.
9073 The also optimizes non-constant cases that used to be done in
9076 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9077 one of the operands is a comparison and the other is a comparison, a
9078 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9079 code below would make the expression more complex. Change it to a
9080 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9081 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9083 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
9084 || code
== EQ_EXPR
|| code
== NE_EXPR
)
9085 && TREE_CODE (type
) != VECTOR_TYPE
9086 && ((truth_value_p (TREE_CODE (arg0
))
9087 && (truth_value_p (TREE_CODE (arg1
))
9088 || (TREE_CODE (arg1
) == BIT_AND_EXPR
9089 && integer_onep (TREE_OPERAND (arg1
, 1)))))
9090 || (truth_value_p (TREE_CODE (arg1
))
9091 && (truth_value_p (TREE_CODE (arg0
))
9092 || (TREE_CODE (arg0
) == BIT_AND_EXPR
9093 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
9095 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
9096 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
9099 fold_convert_loc (loc
, boolean_type_node
, arg0
),
9100 fold_convert_loc (loc
, boolean_type_node
, arg1
));
9102 if (code
== EQ_EXPR
)
9103 tem
= invert_truthvalue_loc (loc
, tem
);
9105 return fold_convert_loc (loc
, type
, tem
);
9108 if (TREE_CODE_CLASS (code
) == tcc_binary
9109 || TREE_CODE_CLASS (code
) == tcc_comparison
)
9111 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
9113 tem
= fold_build2_loc (loc
, code
, type
,
9114 fold_convert_loc (loc
, TREE_TYPE (op0
),
9115 TREE_OPERAND (arg0
, 1)), op1
);
9116 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
9119 if (TREE_CODE (arg1
) == COMPOUND_EXPR
)
9121 tem
= fold_build2_loc (loc
, code
, type
, op0
,
9122 fold_convert_loc (loc
, TREE_TYPE (op1
),
9123 TREE_OPERAND (arg1
, 1)));
9124 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
9128 if (TREE_CODE (arg0
) == COND_EXPR
9129 || TREE_CODE (arg0
) == VEC_COND_EXPR
9130 || COMPARISON_CLASS_P (arg0
))
9132 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9134 /*cond_first_p=*/1);
9135 if (tem
!= NULL_TREE
)
9139 if (TREE_CODE (arg1
) == COND_EXPR
9140 || TREE_CODE (arg1
) == VEC_COND_EXPR
9141 || COMPARISON_CLASS_P (arg1
))
9143 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9145 /*cond_first_p=*/0);
9146 if (tem
!= NULL_TREE
)
9154 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9155 if (TREE_CODE (arg0
) == ADDR_EXPR
9156 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
9158 tree iref
= TREE_OPERAND (arg0
, 0);
9159 return fold_build2 (MEM_REF
, type
,
9160 TREE_OPERAND (iref
, 0),
9161 int_const_binop (PLUS_EXPR
, arg1
,
9162 TREE_OPERAND (iref
, 1)));
9165 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9166 if (TREE_CODE (arg0
) == ADDR_EXPR
9167 && handled_component_p (TREE_OPERAND (arg0
, 0)))
9170 HOST_WIDE_INT coffset
;
9171 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
9175 return fold_build2 (MEM_REF
, type
,
9176 build_fold_addr_expr (base
),
9177 int_const_binop (PLUS_EXPR
, arg1
,
9178 size_int (coffset
)));
9183 case POINTER_PLUS_EXPR
:
9184 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9185 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9186 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
9187 return fold_convert_loc (loc
, type
,
9188 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
9189 fold_convert_loc (loc
, sizetype
,
9191 fold_convert_loc (loc
, sizetype
,
9197 if (INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
9199 /* X + (X / CST) * -CST is X % CST. */
9200 if (TREE_CODE (arg1
) == MULT_EXPR
9201 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
9202 && operand_equal_p (arg0
,
9203 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
9205 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
9206 tree cst1
= TREE_OPERAND (arg1
, 1);
9207 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
9209 if (sum
&& integer_zerop (sum
))
9210 return fold_convert_loc (loc
, type
,
9211 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
9212 TREE_TYPE (arg0
), arg0
,
9217 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9218 one. Make sure the type is not saturating and has the signedness of
9219 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9220 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9221 if ((TREE_CODE (arg0
) == MULT_EXPR
9222 || TREE_CODE (arg1
) == MULT_EXPR
)
9223 && !TYPE_SATURATING (type
)
9224 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9225 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9226 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9228 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9233 if (! FLOAT_TYPE_P (type
))
9235 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9236 (plus (plus (mult) (mult)) (foo)) so that we can
9237 take advantage of the factoring cases below. */
9238 if (ANY_INTEGRAL_TYPE_P (type
)
9239 && TYPE_OVERFLOW_WRAPS (type
)
9240 && (((TREE_CODE (arg0
) == PLUS_EXPR
9241 || TREE_CODE (arg0
) == MINUS_EXPR
)
9242 && TREE_CODE (arg1
) == MULT_EXPR
)
9243 || ((TREE_CODE (arg1
) == PLUS_EXPR
9244 || TREE_CODE (arg1
) == MINUS_EXPR
)
9245 && TREE_CODE (arg0
) == MULT_EXPR
)))
9247 tree parg0
, parg1
, parg
, marg
;
9248 enum tree_code pcode
;
9250 if (TREE_CODE (arg1
) == MULT_EXPR
)
9251 parg
= arg0
, marg
= arg1
;
9253 parg
= arg1
, marg
= arg0
;
9254 pcode
= TREE_CODE (parg
);
9255 parg0
= TREE_OPERAND (parg
, 0);
9256 parg1
= TREE_OPERAND (parg
, 1);
9260 if (TREE_CODE (parg0
) == MULT_EXPR
9261 && TREE_CODE (parg1
) != MULT_EXPR
)
9262 return fold_build2_loc (loc
, pcode
, type
,
9263 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9264 fold_convert_loc (loc
, type
,
9266 fold_convert_loc (loc
, type
,
9268 fold_convert_loc (loc
, type
, parg1
));
9269 if (TREE_CODE (parg0
) != MULT_EXPR
9270 && TREE_CODE (parg1
) == MULT_EXPR
)
9272 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9273 fold_convert_loc (loc
, type
, parg0
),
9274 fold_build2_loc (loc
, pcode
, type
,
9275 fold_convert_loc (loc
, type
, marg
),
9276 fold_convert_loc (loc
, type
,
9282 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9283 to __complex__ ( x, y ). This is not the same for SNaNs or
9284 if signed zeros are involved. */
9285 if (!HONOR_SNANS (element_mode (arg0
))
9286 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9287 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9289 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9290 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9291 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9292 bool arg0rz
= false, arg0iz
= false;
9293 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9294 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9296 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9297 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9298 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9300 tree rp
= arg1r
? arg1r
9301 : build1 (REALPART_EXPR
, rtype
, arg1
);
9302 tree ip
= arg0i
? arg0i
9303 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9304 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9306 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9308 tree rp
= arg0r
? arg0r
9309 : build1 (REALPART_EXPR
, rtype
, arg0
);
9310 tree ip
= arg1i
? arg1i
9311 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
9312 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9317 if (flag_unsafe_math_optimizations
9318 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
9319 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
9320 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
9323 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9324 We associate floats only if the user has specified
9325 -fassociative-math. */
9326 if (flag_associative_math
9327 && TREE_CODE (arg1
) == PLUS_EXPR
9328 && TREE_CODE (arg0
) != MULT_EXPR
)
9330 tree tree10
= TREE_OPERAND (arg1
, 0);
9331 tree tree11
= TREE_OPERAND (arg1
, 1);
9332 if (TREE_CODE (tree11
) == MULT_EXPR
9333 && TREE_CODE (tree10
) == MULT_EXPR
)
9336 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
9337 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
9340 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9341 We associate floats only if the user has specified
9342 -fassociative-math. */
9343 if (flag_associative_math
9344 && TREE_CODE (arg0
) == PLUS_EXPR
9345 && TREE_CODE (arg1
) != MULT_EXPR
)
9347 tree tree00
= TREE_OPERAND (arg0
, 0);
9348 tree tree01
= TREE_OPERAND (arg0
, 1);
9349 if (TREE_CODE (tree01
) == MULT_EXPR
9350 && TREE_CODE (tree00
) == MULT_EXPR
)
9353 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
9354 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
9360 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9361 is a rotate of A by C1 bits. */
9362 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9363 is a rotate of A by B bits. */
9365 enum tree_code code0
, code1
;
9367 code0
= TREE_CODE (arg0
);
9368 code1
= TREE_CODE (arg1
);
9369 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
9370 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
9371 && operand_equal_p (TREE_OPERAND (arg0
, 0),
9372 TREE_OPERAND (arg1
, 0), 0)
9373 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9374 TYPE_UNSIGNED (rtype
))
9375 /* Only create rotates in complete modes. Other cases are not
9376 expanded properly. */
9377 && (element_precision (rtype
)
9378 == GET_MODE_UNIT_PRECISION (TYPE_MODE (rtype
))))
9380 tree tree01
, tree11
;
9381 enum tree_code code01
, code11
;
9383 tree01
= TREE_OPERAND (arg0
, 1);
9384 tree11
= TREE_OPERAND (arg1
, 1);
9385 STRIP_NOPS (tree01
);
9386 STRIP_NOPS (tree11
);
9387 code01
= TREE_CODE (tree01
);
9388 code11
= TREE_CODE (tree11
);
9389 if (code01
== INTEGER_CST
9390 && code11
== INTEGER_CST
9391 && (wi::to_widest (tree01
) + wi::to_widest (tree11
)
9392 == element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)))))
9394 tem
= build2_loc (loc
, LROTATE_EXPR
,
9395 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9396 TREE_OPERAND (arg0
, 0),
9397 code0
== LSHIFT_EXPR
9398 ? TREE_OPERAND (arg0
, 1)
9399 : TREE_OPERAND (arg1
, 1));
9400 return fold_convert_loc (loc
, type
, tem
);
9402 else if (code11
== MINUS_EXPR
)
9404 tree tree110
, tree111
;
9405 tree110
= TREE_OPERAND (tree11
, 0);
9406 tree111
= TREE_OPERAND (tree11
, 1);
9407 STRIP_NOPS (tree110
);
9408 STRIP_NOPS (tree111
);
9409 if (TREE_CODE (tree110
) == INTEGER_CST
9410 && 0 == compare_tree_int (tree110
,
9412 (TREE_TYPE (TREE_OPERAND
9414 && operand_equal_p (tree01
, tree111
, 0))
9416 fold_convert_loc (loc
, type
,
9417 build2 ((code0
== LSHIFT_EXPR
9420 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9421 TREE_OPERAND (arg0
, 0),
9422 TREE_OPERAND (arg0
, 1)));
9424 else if (code01
== MINUS_EXPR
)
9426 tree tree010
, tree011
;
9427 tree010
= TREE_OPERAND (tree01
, 0);
9428 tree011
= TREE_OPERAND (tree01
, 1);
9429 STRIP_NOPS (tree010
);
9430 STRIP_NOPS (tree011
);
9431 if (TREE_CODE (tree010
) == INTEGER_CST
9432 && 0 == compare_tree_int (tree010
,
9434 (TREE_TYPE (TREE_OPERAND
9436 && operand_equal_p (tree11
, tree011
, 0))
9437 return fold_convert_loc
9439 build2 ((code0
!= LSHIFT_EXPR
9442 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9443 TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 1)));
9449 /* In most languages, can't associate operations on floats through
9450 parentheses. Rather than remember where the parentheses were, we
9451 don't associate floats at all, unless the user has specified
9453 And, we need to make sure type is not saturating. */
9455 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
9456 && !TYPE_SATURATING (type
))
9458 tree var0
, con0
, lit0
, minus_lit0
;
9459 tree var1
, con1
, lit1
, minus_lit1
;
9463 /* Split both trees into variables, constants, and literals. Then
9464 associate each group together, the constants with literals,
9465 then the result with variables. This increases the chances of
9466 literals being recombined later and of generating relocatable
9467 expressions for the sum of a constant and literal. */
9468 var0
= split_tree (loc
, arg0
, type
, code
,
9469 &con0
, &lit0
, &minus_lit0
, 0);
9470 var1
= split_tree (loc
, arg1
, type
, code
,
9471 &con1
, &lit1
, &minus_lit1
, code
== MINUS_EXPR
);
9473 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9474 if (code
== MINUS_EXPR
)
9477 /* With undefined overflow prefer doing association in a type
9478 which wraps on overflow, if that is one of the operand types. */
9479 if ((POINTER_TYPE_P (type
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
9480 || (INTEGRAL_TYPE_P (type
) && !TYPE_OVERFLOW_WRAPS (type
)))
9482 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
9483 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
9484 atype
= TREE_TYPE (arg0
);
9485 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9486 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
9487 atype
= TREE_TYPE (arg1
);
9488 gcc_assert (TYPE_PRECISION (atype
) == TYPE_PRECISION (type
));
9491 /* With undefined overflow we can only associate constants with one
9492 variable, and constants whose association doesn't overflow. */
9493 if ((POINTER_TYPE_P (atype
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
9494 || (INTEGRAL_TYPE_P (atype
) && !TYPE_OVERFLOW_WRAPS (atype
)))
9500 bool one_neg
= false;
9502 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
9504 tmp0
= TREE_OPERAND (tmp0
, 0);
9507 if (CONVERT_EXPR_P (tmp0
)
9508 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9509 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9510 <= TYPE_PRECISION (atype
)))
9511 tmp0
= TREE_OPERAND (tmp0
, 0);
9512 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
9514 tmp1
= TREE_OPERAND (tmp1
, 0);
9517 if (CONVERT_EXPR_P (tmp1
)
9518 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9519 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9520 <= TYPE_PRECISION (atype
)))
9521 tmp1
= TREE_OPERAND (tmp1
, 0);
9522 /* The only case we can still associate with two variables
9523 is if they cancel out. */
9525 || !operand_equal_p (tmp0
, tmp1
, 0))
9530 /* Only do something if we found more than two objects. Otherwise,
9531 nothing has changed and we risk infinite recursion. */
9533 && (2 < ((var0
!= 0) + (var1
!= 0)
9534 + (con0
!= 0) + (con1
!= 0)
9535 + (lit0
!= 0) + (lit1
!= 0)
9536 + (minus_lit0
!= 0) + (minus_lit1
!= 0))))
9538 bool any_overflows
= false;
9539 if (lit0
) any_overflows
|= TREE_OVERFLOW (lit0
);
9540 if (lit1
) any_overflows
|= TREE_OVERFLOW (lit1
);
9541 if (minus_lit0
) any_overflows
|= TREE_OVERFLOW (minus_lit0
);
9542 if (minus_lit1
) any_overflows
|= TREE_OVERFLOW (minus_lit1
);
9543 var0
= associate_trees (loc
, var0
, var1
, code
, atype
);
9544 con0
= associate_trees (loc
, con0
, con1
, code
, atype
);
9545 lit0
= associate_trees (loc
, lit0
, lit1
, code
, atype
);
9546 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
,
9549 /* Preserve the MINUS_EXPR if the negative part of the literal is
9550 greater than the positive part. Otherwise, the multiplicative
9551 folding code (i.e extract_muldiv) may be fooled in case
9552 unsigned constants are subtracted, like in the following
9553 example: ((X*2 + 4) - 8U)/2. */
9554 if (minus_lit0
&& lit0
)
9556 if (TREE_CODE (lit0
) == INTEGER_CST
9557 && TREE_CODE (minus_lit0
) == INTEGER_CST
9558 && tree_int_cst_lt (lit0
, minus_lit0
))
9560 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
9566 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
9572 /* Don't introduce overflows through reassociation. */
9574 && ((lit0
&& TREE_OVERFLOW_P (lit0
))
9575 || (minus_lit0
&& TREE_OVERFLOW_P (minus_lit0
))))
9582 fold_convert_loc (loc
, type
,
9583 associate_trees (loc
, var0
, minus_lit0
,
9584 MINUS_EXPR
, atype
));
9587 con0
= associate_trees (loc
, con0
, minus_lit0
,
9590 fold_convert_loc (loc
, type
,
9591 associate_trees (loc
, var0
, con0
,
9596 con0
= associate_trees (loc
, con0
, lit0
, code
, atype
);
9598 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
9606 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9607 if (TREE_CODE (arg0
) == NEGATE_EXPR
9608 && negate_expr_p (op1
))
9609 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
9611 fold_convert_loc (loc
, type
,
9612 TREE_OPERAND (arg0
, 0)));
9614 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9615 __complex__ ( x, -y ). This is not the same for SNaNs or if
9616 signed zeros are involved. */
9617 if (!HONOR_SNANS (element_mode (arg0
))
9618 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9619 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9621 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9622 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9623 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9624 bool arg0rz
= false, arg0iz
= false;
9625 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9626 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9628 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9629 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9630 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9632 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9634 : build1 (REALPART_EXPR
, rtype
, arg1
));
9635 tree ip
= arg0i
? arg0i
9636 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9637 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9639 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9641 tree rp
= arg0r
? arg0r
9642 : build1 (REALPART_EXPR
, rtype
, arg0
);
9643 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9645 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
9646 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9651 /* A - B -> A + (-B) if B is easily negatable. */
9652 if (negate_expr_p (op1
)
9653 && ! TYPE_OVERFLOW_SANITIZED (type
)
9654 && ((FLOAT_TYPE_P (type
)
9655 /* Avoid this transformation if B is a positive REAL_CST. */
9656 && (TREE_CODE (op1
) != REAL_CST
9657 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (op1
))))
9658 || INTEGRAL_TYPE_P (type
)))
9659 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9660 fold_convert_loc (loc
, type
, arg0
),
9663 /* Fold &a[i] - &a[j] to i-j. */
9664 if (TREE_CODE (arg0
) == ADDR_EXPR
9665 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
9666 && TREE_CODE (arg1
) == ADDR_EXPR
9667 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
9669 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
9670 TREE_OPERAND (arg0
, 0),
9671 TREE_OPERAND (arg1
, 0));
9676 if (FLOAT_TYPE_P (type
)
9677 && flag_unsafe_math_optimizations
9678 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
9679 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
9680 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
9683 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9684 one. Make sure the type is not saturating and has the signedness of
9685 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9686 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9687 if ((TREE_CODE (arg0
) == MULT_EXPR
9688 || TREE_CODE (arg1
) == MULT_EXPR
)
9689 && !TYPE_SATURATING (type
)
9690 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9691 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9692 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9694 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9702 if (! FLOAT_TYPE_P (type
))
9704 /* Transform x * -C into -x * C if x is easily negatable. */
9705 if (TREE_CODE (op1
) == INTEGER_CST
9706 && tree_int_cst_sgn (op1
) == -1
9707 && negate_expr_p (op0
)
9708 && (tem
= negate_expr (op1
)) != op1
9709 && ! TREE_OVERFLOW (tem
))
9710 return fold_build2_loc (loc
, MULT_EXPR
, type
,
9711 fold_convert_loc (loc
, type
,
9712 negate_expr (op0
)), tem
);
9714 strict_overflow_p
= false;
9715 if (TREE_CODE (arg1
) == INTEGER_CST
9716 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
9717 &strict_overflow_p
)))
9719 if (strict_overflow_p
)
9720 fold_overflow_warning (("assuming signed overflow does not "
9721 "occur when simplifying "
9723 WARN_STRICT_OVERFLOW_MISC
);
9724 return fold_convert_loc (loc
, type
, tem
);
9727 /* Optimize z * conj(z) for integer complex numbers. */
9728 if (TREE_CODE (arg0
) == CONJ_EXPR
9729 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
9730 return fold_mult_zconjz (loc
, type
, arg1
);
9731 if (TREE_CODE (arg1
) == CONJ_EXPR
9732 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
9733 return fold_mult_zconjz (loc
, type
, arg0
);
9737 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
9738 This is not the same for NaNs or if signed zeros are
9740 if (!HONOR_NANS (arg0
)
9741 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9742 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
9743 && TREE_CODE (arg1
) == COMPLEX_CST
9744 && real_zerop (TREE_REALPART (arg1
)))
9746 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9747 if (real_onep (TREE_IMAGPART (arg1
)))
9749 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
9750 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
9752 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
9753 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
9755 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
9756 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
9757 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
9761 /* Optimize z * conj(z) for floating point complex numbers.
9762 Guarded by flag_unsafe_math_optimizations as non-finite
9763 imaginary components don't produce scalar results. */
9764 if (flag_unsafe_math_optimizations
9765 && TREE_CODE (arg0
) == CONJ_EXPR
9766 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
9767 return fold_mult_zconjz (loc
, type
, arg1
);
9768 if (flag_unsafe_math_optimizations
9769 && TREE_CODE (arg1
) == CONJ_EXPR
9770 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
9771 return fold_mult_zconjz (loc
, type
, arg0
);
9776 /* Canonicalize (X & C1) | C2. */
9777 if (TREE_CODE (arg0
) == BIT_AND_EXPR
9778 && TREE_CODE (arg1
) == INTEGER_CST
9779 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
9781 int width
= TYPE_PRECISION (type
), w
;
9782 wide_int c1
= TREE_OPERAND (arg0
, 1);
9785 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
9786 if ((c1
& c2
) == c1
)
9787 return omit_one_operand_loc (loc
, type
, arg1
,
9788 TREE_OPERAND (arg0
, 0));
9790 wide_int msk
= wi::mask (width
, false,
9791 TYPE_PRECISION (TREE_TYPE (arg1
)));
9793 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
9794 if (msk
.and_not (c1
| c2
) == 0)
9795 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
9796 TREE_OPERAND (arg0
, 0), arg1
);
9798 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
9799 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
9800 mode which allows further optimizations. */
9803 wide_int c3
= c1
.and_not (c2
);
9804 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
9806 wide_int mask
= wi::mask (w
, false,
9807 TYPE_PRECISION (type
));
9808 if (((c1
| c2
) & mask
) == mask
&& c1
.and_not (mask
) == 0)
9816 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
9817 fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
9818 TREE_OPERAND (arg0
, 0),
9819 wide_int_to_tree (type
,
9824 /* See if this can be simplified into a rotate first. If that
9825 is unsuccessful continue in the association code. */
9829 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
9830 if (TREE_CODE (arg0
) == BIT_AND_EXPR
9831 && INTEGRAL_TYPE_P (type
)
9832 && integer_onep (TREE_OPERAND (arg0
, 1))
9833 && integer_onep (arg1
))
9834 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
9835 build_zero_cst (TREE_TYPE (arg0
)));
9837 /* See if this can be simplified into a rotate first. If that
9838 is unsuccessful continue in the association code. */
9842 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
9843 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
9844 && INTEGRAL_TYPE_P (type
)
9845 && integer_onep (TREE_OPERAND (arg0
, 1))
9846 && integer_onep (arg1
))
9849 tem
= TREE_OPERAND (arg0
, 0);
9850 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
9851 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
9853 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
9854 build_zero_cst (TREE_TYPE (tem
)));
9856 /* Fold ~X & 1 as (X & 1) == 0. */
9857 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9858 && INTEGRAL_TYPE_P (type
)
9859 && integer_onep (arg1
))
9862 tem
= TREE_OPERAND (arg0
, 0);
9863 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
9864 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
9866 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
9867 build_zero_cst (TREE_TYPE (tem
)));
9869 /* Fold !X & 1 as X == 0. */
9870 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
9871 && integer_onep (arg1
))
9873 tem
= TREE_OPERAND (arg0
, 0);
9874 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
9875 build_zero_cst (TREE_TYPE (tem
)));
9878 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
9879 multiple of 1 << CST. */
9880 if (TREE_CODE (arg1
) == INTEGER_CST
)
9882 wide_int cst1
= arg1
;
9883 wide_int ncst1
= -cst1
;
9884 if ((cst1
& ncst1
) == ncst1
9885 && multiple_of_p (type
, arg0
,
9886 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
9887 return fold_convert_loc (loc
, type
, arg0
);
9890 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
9892 if (TREE_CODE (arg1
) == INTEGER_CST
9893 && TREE_CODE (arg0
) == MULT_EXPR
9894 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
9896 wide_int warg1
= arg1
;
9897 wide_int masked
= mask_with_tz (type
, warg1
, TREE_OPERAND (arg0
, 1));
9900 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
9902 else if (masked
!= warg1
)
9904 /* Avoid the transform if arg1 is a mask of some
9905 mode which allows further optimizations. */
9906 int pop
= wi::popcount (warg1
);
9907 if (!(pop
>= BITS_PER_UNIT
9909 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
9910 return fold_build2_loc (loc
, code
, type
, op0
,
9911 wide_int_to_tree (type
, masked
));
9915 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
9916 ((A & N) + B) & M -> (A + B) & M
9917 Similarly if (N & M) == 0,
9918 ((A | N) + B) & M -> (A + B) & M
9919 and for - instead of + (or unary - instead of +)
9920 and/or ^ instead of |.
9921 If B is constant and (B & M) == 0, fold into A & M. */
9922 if (TREE_CODE (arg1
) == INTEGER_CST
)
9924 wide_int cst1
= arg1
;
9925 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
9926 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
9927 && (TREE_CODE (arg0
) == PLUS_EXPR
9928 || TREE_CODE (arg0
) == MINUS_EXPR
9929 || TREE_CODE (arg0
) == NEGATE_EXPR
)
9930 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
9931 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
9937 /* Now we know that arg0 is (C + D) or (C - D) or
9938 -C and arg1 (M) is == (1LL << cst) - 1.
9939 Store C into PMOP[0] and D into PMOP[1]. */
9940 pmop
[0] = TREE_OPERAND (arg0
, 0);
9942 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
9944 pmop
[1] = TREE_OPERAND (arg0
, 1);
9948 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
9951 for (; which
>= 0; which
--)
9952 switch (TREE_CODE (pmop
[which
]))
9957 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
9960 cst0
= TREE_OPERAND (pmop
[which
], 1);
9962 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
9969 /* If C or D is of the form (A & N) where
9970 (N & M) == M, or of the form (A | N) or
9971 (A ^ N) where (N & M) == 0, replace it with A. */
9972 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
9975 /* If C or D is a N where (N & M) == 0, it can be
9976 omitted (assumed 0). */
9977 if ((TREE_CODE (arg0
) == PLUS_EXPR
9978 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
9979 && (cst1
& pmop
[which
]) == 0)
9986 /* Only build anything new if we optimized one or both arguments
9988 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
9989 || (TREE_CODE (arg0
) != NEGATE_EXPR
9990 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
9992 tree utype
= TREE_TYPE (arg0
);
9993 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
9995 /* Perform the operations in a type that has defined
9996 overflow behavior. */
9997 utype
= unsigned_type_for (TREE_TYPE (arg0
));
9998 if (pmop
[0] != NULL
)
9999 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
10000 if (pmop
[1] != NULL
)
10001 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
10004 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
10005 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
10006 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
10008 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
10009 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
10011 else if (pmop
[0] != NULL
)
10013 else if (pmop
[1] != NULL
)
10016 return build_int_cst (type
, 0);
10018 else if (pmop
[0] == NULL
)
10019 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
10021 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
10023 /* TEM is now the new binary +, - or unary - replacement. */
10024 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
10025 fold_convert_loc (loc
, utype
, arg1
));
10026 return fold_convert_loc (loc
, type
, tem
);
10031 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10032 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
10033 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
10035 prec
= element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
10037 wide_int mask
= wide_int::from (arg1
, prec
, UNSIGNED
);
10040 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10046 /* Don't touch a floating-point divide by zero unless the mode
10047 of the constant can represent infinity. */
10048 if (TREE_CODE (arg1
) == REAL_CST
10049 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
10050 && real_zerop (arg1
))
10053 /* (-A) / (-B) -> A / B */
10054 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10055 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10056 TREE_OPERAND (arg0
, 0),
10057 negate_expr (arg1
));
10058 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10059 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10060 negate_expr (arg0
),
10061 TREE_OPERAND (arg1
, 0));
10064 case TRUNC_DIV_EXPR
:
10067 case FLOOR_DIV_EXPR
:
10068 /* Simplify A / (B << N) where A and B are positive and B is
10069 a power of 2, to A >> (N + log2(B)). */
10070 strict_overflow_p
= false;
10071 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10072 && (TYPE_UNSIGNED (type
)
10073 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
10075 tree sval
= TREE_OPERAND (arg1
, 0);
10076 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
10078 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
10079 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
10080 wi::exact_log2 (sval
));
10082 if (strict_overflow_p
)
10083 fold_overflow_warning (("assuming signed overflow does not "
10084 "occur when simplifying A / (B << N)"),
10085 WARN_STRICT_OVERFLOW_MISC
);
10087 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
10089 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
10090 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
10096 case ROUND_DIV_EXPR
:
10097 case CEIL_DIV_EXPR
:
10098 case EXACT_DIV_EXPR
:
10099 if (integer_zerop (arg1
))
10102 /* Convert -A / -B to A / B when the type is signed and overflow is
10104 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10105 && TREE_CODE (arg0
) == NEGATE_EXPR
10106 && negate_expr_p (op1
))
10108 if (INTEGRAL_TYPE_P (type
))
10109 fold_overflow_warning (("assuming signed overflow does not occur "
10110 "when distributing negation across "
10112 WARN_STRICT_OVERFLOW_MISC
);
10113 return fold_build2_loc (loc
, code
, type
,
10114 fold_convert_loc (loc
, type
,
10115 TREE_OPERAND (arg0
, 0)),
10116 negate_expr (op1
));
10118 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10119 && TREE_CODE (arg1
) == NEGATE_EXPR
10120 && negate_expr_p (op0
))
10122 if (INTEGRAL_TYPE_P (type
))
10123 fold_overflow_warning (("assuming signed overflow does not occur "
10124 "when distributing negation across "
10126 WARN_STRICT_OVERFLOW_MISC
);
10127 return fold_build2_loc (loc
, code
, type
,
10129 fold_convert_loc (loc
, type
,
10130 TREE_OPERAND (arg1
, 0)));
10133 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10134 operation, EXACT_DIV_EXPR.
10136 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10137 At one time others generated faster code, it's not clear if they do
10138 after the last round to changes to the DIV code in expmed.c. */
10139 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
10140 && multiple_of_p (type
, arg0
, arg1
))
10141 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
,
10142 fold_convert (type
, arg0
),
10143 fold_convert (type
, arg1
));
10145 strict_overflow_p
= false;
10146 if (TREE_CODE (arg1
) == INTEGER_CST
10147 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10148 &strict_overflow_p
)))
10150 if (strict_overflow_p
)
10151 fold_overflow_warning (("assuming signed overflow does not occur "
10152 "when simplifying division"),
10153 WARN_STRICT_OVERFLOW_MISC
);
10154 return fold_convert_loc (loc
, type
, tem
);
10159 case CEIL_MOD_EXPR
:
10160 case FLOOR_MOD_EXPR
:
10161 case ROUND_MOD_EXPR
:
10162 case TRUNC_MOD_EXPR
:
10163 strict_overflow_p
= false;
10164 if (TREE_CODE (arg1
) == INTEGER_CST
10165 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10166 &strict_overflow_p
)))
10168 if (strict_overflow_p
)
10169 fold_overflow_warning (("assuming signed overflow does not occur "
10170 "when simplifying modulus"),
10171 WARN_STRICT_OVERFLOW_MISC
);
10172 return fold_convert_loc (loc
, type
, tem
);
10181 /* Since negative shift count is not well-defined,
10182 don't try to compute it in the compiler. */
10183 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
10186 prec
= element_precision (type
);
10188 /* If we have a rotate of a bit operation with the rotate count and
10189 the second operand of the bit operation both constant,
10190 permute the two operations. */
10191 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10192 && (TREE_CODE (arg0
) == BIT_AND_EXPR
10193 || TREE_CODE (arg0
) == BIT_IOR_EXPR
10194 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
10195 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10197 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10198 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10199 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
10200 fold_build2_loc (loc
, code
, type
,
10202 fold_build2_loc (loc
, code
, type
,
10206 /* Two consecutive rotates adding up to the some integer
10207 multiple of the precision of the type can be ignored. */
10208 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10209 && TREE_CODE (arg0
) == RROTATE_EXPR
10210 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10211 && wi::umod_trunc (wi::add (arg1
, TREE_OPERAND (arg0
, 1)),
10213 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10221 case TRUTH_ANDIF_EXPR
:
10222 /* Note that the operands of this must be ints
10223 and their values must be 0 or 1.
10224 ("true" is a fixed value perhaps depending on the language.) */
10225 /* If first arg is constant zero, return it. */
10226 if (integer_zerop (arg0
))
10227 return fold_convert_loc (loc
, type
, arg0
);
10229 case TRUTH_AND_EXPR
:
10230 /* If either arg is constant true, drop it. */
10231 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10232 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10233 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
10234 /* Preserve sequence points. */
10235 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10236 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10237 /* If second arg is constant zero, result is zero, but first arg
10238 must be evaluated. */
10239 if (integer_zerop (arg1
))
10240 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10241 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10242 case will be handled here. */
10243 if (integer_zerop (arg0
))
10244 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10246 /* !X && X is always false. */
10247 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10248 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10249 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
10250 /* X && !X is always false. */
10251 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10252 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10253 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10255 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10256 means A >= Y && A != MAX, but in this case we know that
10259 if (!TREE_SIDE_EFFECTS (arg0
)
10260 && !TREE_SIDE_EFFECTS (arg1
))
10262 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
10263 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
10264 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
10266 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
10267 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
10268 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
10271 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10277 case TRUTH_ORIF_EXPR
:
10278 /* Note that the operands of this must be ints
10279 and their values must be 0 or true.
10280 ("true" is a fixed value perhaps depending on the language.) */
10281 /* If first arg is constant true, return it. */
10282 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10283 return fold_convert_loc (loc
, type
, arg0
);
10285 case TRUTH_OR_EXPR
:
10286 /* If either arg is constant zero, drop it. */
10287 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
10288 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10289 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
10290 /* Preserve sequence points. */
10291 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10292 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10293 /* If second arg is constant true, result is true, but we must
10294 evaluate first arg. */
10295 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
10296 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10297 /* Likewise for first arg, but note this only occurs here for
10299 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10300 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10302 /* !X || X is always true. */
10303 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10304 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10305 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10306 /* X || !X is always true. */
10307 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10308 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10309 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10311 /* (X && !Y) || (!X && Y) is X ^ Y */
10312 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
10313 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
10315 tree a0
, a1
, l0
, l1
, n0
, n1
;
10317 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10318 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10320 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10321 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10323 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
10324 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
10326 if ((operand_equal_p (n0
, a0
, 0)
10327 && operand_equal_p (n1
, a1
, 0))
10328 || (operand_equal_p (n0
, a1
, 0)
10329 && operand_equal_p (n1
, a0
, 0)))
10330 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
10333 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10339 case TRUTH_XOR_EXPR
:
10340 /* If the second arg is constant zero, drop it. */
10341 if (integer_zerop (arg1
))
10342 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10343 /* If the second arg is constant true, this is a logical inversion. */
10344 if (integer_onep (arg1
))
10346 tem
= invert_truthvalue_loc (loc
, arg0
);
10347 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
10349 /* Identical arguments cancel to zero. */
10350 if (operand_equal_p (arg0
, arg1
, 0))
10351 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10353 /* !X ^ X is always true. */
10354 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10355 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10356 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10358 /* X ^ !X is always true. */
10359 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10360 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10361 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10370 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
10371 if (tem
!= NULL_TREE
)
10374 /* bool_var != 1 becomes !bool_var. */
10375 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
10376 && code
== NE_EXPR
)
10377 return fold_convert_loc (loc
, type
,
10378 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10379 TREE_TYPE (arg0
), arg0
));
10381 /* bool_var == 0 becomes !bool_var. */
10382 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
10383 && code
== EQ_EXPR
)
10384 return fold_convert_loc (loc
, type
,
10385 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10386 TREE_TYPE (arg0
), arg0
));
10388 /* !exp != 0 becomes !exp */
10389 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
10390 && code
== NE_EXPR
)
10391 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10393 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
10394 if ((TREE_CODE (arg0
) == PLUS_EXPR
10395 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
10396 || TREE_CODE (arg0
) == MINUS_EXPR
)
10397 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
10400 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10401 || POINTER_TYPE_P (TREE_TYPE (arg0
))))
10403 tree val
= TREE_OPERAND (arg0
, 1);
10404 val
= fold_build2_loc (loc
, code
, type
, val
,
10405 build_int_cst (TREE_TYPE (val
), 0));
10406 return omit_two_operands_loc (loc
, type
, val
,
10407 TREE_OPERAND (arg0
, 0), arg1
);
10410 /* Transform comparisons of the form X CMP X +- Y to Y CMP 0. */
10411 if ((TREE_CODE (arg1
) == PLUS_EXPR
10412 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
10413 || TREE_CODE (arg1
) == MINUS_EXPR
)
10414 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1
,
10417 && (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10418 || POINTER_TYPE_P (TREE_TYPE (arg1
))))
10420 tree val
= TREE_OPERAND (arg1
, 1);
10421 val
= fold_build2_loc (loc
, code
, type
, val
,
10422 build_int_cst (TREE_TYPE (val
), 0));
10423 return omit_two_operands_loc (loc
, type
, val
,
10424 TREE_OPERAND (arg1
, 0), arg0
);
10427 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
10428 if (TREE_CODE (arg0
) == MINUS_EXPR
10429 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == INTEGER_CST
10430 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
10433 && wi::extract_uhwi (TREE_OPERAND (arg0
, 0), 0, 1) == 1)
10434 return omit_two_operands_loc (loc
, type
,
10436 ? boolean_true_node
: boolean_false_node
,
10437 TREE_OPERAND (arg0
, 1), arg1
);
10439 /* Transform comparisons of the form X CMP C - X if C % 2 == 1. */
10440 if (TREE_CODE (arg1
) == MINUS_EXPR
10441 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == INTEGER_CST
10442 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg1
,
10445 && wi::extract_uhwi (TREE_OPERAND (arg1
, 0), 0, 1) == 1)
10446 return omit_two_operands_loc (loc
, type
,
10448 ? boolean_true_node
: boolean_false_node
,
10449 TREE_OPERAND (arg1
, 1), arg0
);
10451 /* If this is an EQ or NE comparison with zero and ARG0 is
10452 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10453 two operations, but the latter can be done in one less insn
10454 on machines that have only two-operand insns or on which a
10455 constant cannot be the first operand. */
10456 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10457 && integer_zerop (arg1
))
10459 tree arg00
= TREE_OPERAND (arg0
, 0);
10460 tree arg01
= TREE_OPERAND (arg0
, 1);
10461 if (TREE_CODE (arg00
) == LSHIFT_EXPR
10462 && integer_onep (TREE_OPERAND (arg00
, 0)))
10464 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
10465 arg01
, TREE_OPERAND (arg00
, 1));
10466 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10467 build_int_cst (TREE_TYPE (arg0
), 1));
10468 return fold_build2_loc (loc
, code
, type
,
10469 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10472 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
10473 && integer_onep (TREE_OPERAND (arg01
, 0)))
10475 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
10476 arg00
, TREE_OPERAND (arg01
, 1));
10477 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10478 build_int_cst (TREE_TYPE (arg0
), 1));
10479 return fold_build2_loc (loc
, code
, type
,
10480 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10485 /* If this is an NE or EQ comparison of zero against the result of a
10486 signed MOD operation whose second operand is a power of 2, make
10487 the MOD operation unsigned since it is simpler and equivalent. */
10488 if (integer_zerop (arg1
)
10489 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
10490 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
10491 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
10492 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
10493 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
10494 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10496 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
10497 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
10498 fold_convert_loc (loc
, newtype
,
10499 TREE_OPERAND (arg0
, 0)),
10500 fold_convert_loc (loc
, newtype
,
10501 TREE_OPERAND (arg0
, 1)));
10503 return fold_build2_loc (loc
, code
, type
, newmod
,
10504 fold_convert_loc (loc
, newtype
, arg1
));
10507 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10508 C1 is a valid shift constant, and C2 is a power of two, i.e.
10510 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10511 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
10512 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
10514 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10515 && integer_zerop (arg1
))
10517 tree itype
= TREE_TYPE (arg0
);
10518 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
10519 prec
= TYPE_PRECISION (itype
);
10521 /* Check for a valid shift count. */
10522 if (wi::ltu_p (arg001
, prec
))
10524 tree arg01
= TREE_OPERAND (arg0
, 1);
10525 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10526 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
10527 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10528 can be rewritten as (X & (C2 << C1)) != 0. */
10529 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
10531 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
10532 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
10533 return fold_build2_loc (loc
, code
, type
, tem
,
10534 fold_convert_loc (loc
, itype
, arg1
));
10536 /* Otherwise, for signed (arithmetic) shifts,
10537 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10538 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10539 else if (!TYPE_UNSIGNED (itype
))
10540 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
10541 arg000
, build_int_cst (itype
, 0));
10542 /* Otherwise, of unsigned (logical) shifts,
10543 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10544 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10546 return omit_one_operand_loc (loc
, type
,
10547 code
== EQ_EXPR
? integer_one_node
10548 : integer_zero_node
,
10553 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10554 Similarly for NE_EXPR. */
10555 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10556 && TREE_CODE (arg1
) == INTEGER_CST
10557 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10559 tree notc
= fold_build1_loc (loc
, BIT_NOT_EXPR
,
10560 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
10561 TREE_OPERAND (arg0
, 1));
10563 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
10564 fold_convert_loc (loc
, TREE_TYPE (arg0
), arg1
),
10566 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
10567 if (integer_nonzerop (dandnotc
))
10568 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
10571 /* If this is a comparison of a field, we may be able to simplify it. */
10572 if ((TREE_CODE (arg0
) == COMPONENT_REF
10573 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
10574 /* Handle the constant case even without -O
10575 to make sure the warnings are given. */
10576 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
10578 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
10583 /* Optimize comparisons of strlen vs zero to a compare of the
10584 first character of the string vs zero. To wit,
10585 strlen(ptr) == 0 => *ptr == 0
10586 strlen(ptr) != 0 => *ptr != 0
10587 Other cases should reduce to one of these two (or a constant)
10588 due to the return value of strlen being unsigned. */
10589 if (TREE_CODE (arg0
) == CALL_EXPR
10590 && integer_zerop (arg1
))
10592 tree fndecl
= get_callee_fndecl (arg0
);
10595 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
10596 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
10597 && call_expr_nargs (arg0
) == 1
10598 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
10600 tree iref
= build_fold_indirect_ref_loc (loc
,
10601 CALL_EXPR_ARG (arg0
, 0));
10602 return fold_build2_loc (loc
, code
, type
, iref
,
10603 build_int_cst (TREE_TYPE (iref
), 0));
10607 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10608 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10609 if (TREE_CODE (arg0
) == RSHIFT_EXPR
10610 && integer_zerop (arg1
)
10611 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10613 tree arg00
= TREE_OPERAND (arg0
, 0);
10614 tree arg01
= TREE_OPERAND (arg0
, 1);
10615 tree itype
= TREE_TYPE (arg00
);
10616 if (wi::eq_p (arg01
, element_precision (itype
) - 1))
10618 if (TYPE_UNSIGNED (itype
))
10620 itype
= signed_type_for (itype
);
10621 arg00
= fold_convert_loc (loc
, itype
, arg00
);
10623 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
10624 type
, arg00
, build_zero_cst (itype
));
10628 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10629 (X & C) == 0 when C is a single bit. */
10630 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10631 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
10632 && integer_zerop (arg1
)
10633 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10635 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
10636 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
10637 TREE_OPERAND (arg0
, 1));
10638 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
10640 fold_convert_loc (loc
, TREE_TYPE (arg0
),
10644 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10645 constant C is a power of two, i.e. a single bit. */
10646 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10647 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
10648 && integer_zerop (arg1
)
10649 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10650 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10651 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10653 tree arg00
= TREE_OPERAND (arg0
, 0);
10654 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10655 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
10658 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10659 when is C is a power of two, i.e. a single bit. */
10660 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10661 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
10662 && integer_zerop (arg1
)
10663 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10664 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10665 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10667 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10668 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
10669 arg000
, TREE_OPERAND (arg0
, 1));
10670 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10671 tem
, build_int_cst (TREE_TYPE (tem
), 0));
10674 if (integer_zerop (arg1
)
10675 && tree_expr_nonzero_p (arg0
))
10677 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
10678 return omit_one_operand_loc (loc
, type
, res
, arg0
);
10681 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10682 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10683 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10685 tree arg00
= TREE_OPERAND (arg0
, 0);
10686 tree arg01
= TREE_OPERAND (arg0
, 1);
10687 tree arg10
= TREE_OPERAND (arg1
, 0);
10688 tree arg11
= TREE_OPERAND (arg1
, 1);
10689 tree itype
= TREE_TYPE (arg0
);
10691 if (operand_equal_p (arg01
, arg11
, 0))
10692 return fold_build2_loc (loc
, code
, type
,
10693 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10694 fold_build2_loc (loc
,
10695 BIT_XOR_EXPR
, itype
,
10698 build_zero_cst (itype
));
10700 if (operand_equal_p (arg01
, arg10
, 0))
10701 return fold_build2_loc (loc
, code
, type
,
10702 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10703 fold_build2_loc (loc
,
10704 BIT_XOR_EXPR
, itype
,
10707 build_zero_cst (itype
));
10709 if (operand_equal_p (arg00
, arg11
, 0))
10710 return fold_build2_loc (loc
, code
, type
,
10711 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10712 fold_build2_loc (loc
,
10713 BIT_XOR_EXPR
, itype
,
10716 build_zero_cst (itype
));
10718 if (operand_equal_p (arg00
, arg10
, 0))
10719 return fold_build2_loc (loc
, code
, type
,
10720 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
10721 fold_build2_loc (loc
,
10722 BIT_XOR_EXPR
, itype
,
10725 build_zero_cst (itype
));
10728 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10729 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
10731 tree arg00
= TREE_OPERAND (arg0
, 0);
10732 tree arg01
= TREE_OPERAND (arg0
, 1);
10733 tree arg10
= TREE_OPERAND (arg1
, 0);
10734 tree arg11
= TREE_OPERAND (arg1
, 1);
10735 tree itype
= TREE_TYPE (arg0
);
10737 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10738 operand_equal_p guarantees no side-effects so we don't need
10739 to use omit_one_operand on Z. */
10740 if (operand_equal_p (arg01
, arg11
, 0))
10741 return fold_build2_loc (loc
, code
, type
, arg00
,
10742 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10744 if (operand_equal_p (arg01
, arg10
, 0))
10745 return fold_build2_loc (loc
, code
, type
, arg00
,
10746 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10748 if (operand_equal_p (arg00
, arg11
, 0))
10749 return fold_build2_loc (loc
, code
, type
, arg01
,
10750 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10752 if (operand_equal_p (arg00
, arg10
, 0))
10753 return fold_build2_loc (loc
, code
, type
, arg01
,
10754 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10757 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
10758 if (TREE_CODE (arg01
) == INTEGER_CST
10759 && TREE_CODE (arg11
) == INTEGER_CST
)
10761 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
10762 fold_convert_loc (loc
, itype
, arg11
));
10763 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
10764 return fold_build2_loc (loc
, code
, type
, tem
,
10765 fold_convert_loc (loc
, itype
, arg10
));
10769 /* Attempt to simplify equality/inequality comparisons of complex
10770 values. Only lower the comparison if the result is known or
10771 can be simplified to a single scalar comparison. */
10772 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
10773 || TREE_CODE (arg0
) == COMPLEX_CST
)
10774 && (TREE_CODE (arg1
) == COMPLEX_EXPR
10775 || TREE_CODE (arg1
) == COMPLEX_CST
))
10777 tree real0
, imag0
, real1
, imag1
;
10780 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
10782 real0
= TREE_OPERAND (arg0
, 0);
10783 imag0
= TREE_OPERAND (arg0
, 1);
10787 real0
= TREE_REALPART (arg0
);
10788 imag0
= TREE_IMAGPART (arg0
);
10791 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
10793 real1
= TREE_OPERAND (arg1
, 0);
10794 imag1
= TREE_OPERAND (arg1
, 1);
10798 real1
= TREE_REALPART (arg1
);
10799 imag1
= TREE_IMAGPART (arg1
);
10802 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
10803 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
10805 if (integer_zerop (rcond
))
10807 if (code
== EQ_EXPR
)
10808 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
10810 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
10814 if (code
== NE_EXPR
)
10815 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
10817 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
10821 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
10822 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
10824 if (integer_zerop (icond
))
10826 if (code
== EQ_EXPR
)
10827 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
10829 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
10833 if (code
== NE_EXPR
)
10834 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
10836 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
10847 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
10848 if (tem
!= NULL_TREE
)
10851 /* Transform comparisons of the form X +- C CMP X. */
10852 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
10853 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
10854 && ((TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
10855 && !HONOR_SNANS (arg0
))
10856 || (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10857 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))))
10859 tree arg01
= TREE_OPERAND (arg0
, 1);
10860 enum tree_code code0
= TREE_CODE (arg0
);
10863 if (TREE_CODE (arg01
) == REAL_CST
)
10864 is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
10866 is_positive
= tree_int_cst_sgn (arg01
);
10868 /* (X - c) > X becomes false. */
10869 if (code
== GT_EXPR
10870 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
10871 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
10873 if (TREE_CODE (arg01
) == INTEGER_CST
10874 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10875 fold_overflow_warning (("assuming signed overflow does not "
10876 "occur when assuming that (X - c) > X "
10877 "is always false"),
10878 WARN_STRICT_OVERFLOW_ALL
);
10879 return constant_boolean_node (0, type
);
10882 /* Likewise (X + c) < X becomes false. */
10883 if (code
== LT_EXPR
10884 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
10885 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
10887 if (TREE_CODE (arg01
) == INTEGER_CST
10888 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10889 fold_overflow_warning (("assuming signed overflow does not "
10890 "occur when assuming that "
10891 "(X + c) < X is always false"),
10892 WARN_STRICT_OVERFLOW_ALL
);
10893 return constant_boolean_node (0, type
);
10896 /* Convert (X - c) <= X to true. */
10897 if (!HONOR_NANS (arg1
)
10899 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
10900 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
10902 if (TREE_CODE (arg01
) == INTEGER_CST
10903 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10904 fold_overflow_warning (("assuming signed overflow does not "
10905 "occur when assuming that "
10906 "(X - c) <= X is always true"),
10907 WARN_STRICT_OVERFLOW_ALL
);
10908 return constant_boolean_node (1, type
);
10911 /* Convert (X + c) >= X to true. */
10912 if (!HONOR_NANS (arg1
)
10914 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
10915 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
10917 if (TREE_CODE (arg01
) == INTEGER_CST
10918 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10919 fold_overflow_warning (("assuming signed overflow does not "
10920 "occur when assuming that "
10921 "(X + c) >= X is always true"),
10922 WARN_STRICT_OVERFLOW_ALL
);
10923 return constant_boolean_node (1, type
);
10926 if (TREE_CODE (arg01
) == INTEGER_CST
)
10928 /* Convert X + c > X and X - c < X to true for integers. */
10929 if (code
== GT_EXPR
10930 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
10931 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
10933 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10934 fold_overflow_warning (("assuming signed overflow does "
10935 "not occur when assuming that "
10936 "(X + c) > X is always true"),
10937 WARN_STRICT_OVERFLOW_ALL
);
10938 return constant_boolean_node (1, type
);
10941 if (code
== LT_EXPR
10942 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
10943 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
10945 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10946 fold_overflow_warning (("assuming signed overflow does "
10947 "not occur when assuming that "
10948 "(X - c) < X is always true"),
10949 WARN_STRICT_OVERFLOW_ALL
);
10950 return constant_boolean_node (1, type
);
10953 /* Convert X + c <= X and X - c >= X to false for integers. */
10954 if (code
== LE_EXPR
10955 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
10956 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
10958 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10959 fold_overflow_warning (("assuming signed overflow does "
10960 "not occur when assuming that "
10961 "(X + c) <= X is always false"),
10962 WARN_STRICT_OVERFLOW_ALL
);
10963 return constant_boolean_node (0, type
);
10966 if (code
== GE_EXPR
10967 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
10968 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
10970 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
10971 fold_overflow_warning (("assuming signed overflow does "
10972 "not occur when assuming that "
10973 "(X - c) >= X is always false"),
10974 WARN_STRICT_OVERFLOW_ALL
);
10975 return constant_boolean_node (0, type
);
10980 /* If we are comparing an ABS_EXPR with a constant, we can
10981 convert all the cases into explicit comparisons, but they may
10982 well not be faster than doing the ABS and one comparison.
10983 But ABS (X) <= C is a range comparison, which becomes a subtraction
10984 and a comparison, and is probably faster. */
10985 if (code
== LE_EXPR
10986 && TREE_CODE (arg1
) == INTEGER_CST
10987 && TREE_CODE (arg0
) == ABS_EXPR
10988 && ! TREE_SIDE_EFFECTS (arg0
)
10989 && (0 != (tem
= negate_expr (arg1
)))
10990 && TREE_CODE (tem
) == INTEGER_CST
10991 && !TREE_OVERFLOW (tem
))
10992 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
10993 build2 (GE_EXPR
, type
,
10994 TREE_OPERAND (arg0
, 0), tem
),
10995 build2 (LE_EXPR
, type
,
10996 TREE_OPERAND (arg0
, 0), arg1
));
10998 /* Convert ABS_EXPR<x> >= 0 to true. */
10999 strict_overflow_p
= false;
11000 if (code
== GE_EXPR
11001 && (integer_zerop (arg1
)
11002 || (! HONOR_NANS (arg0
)
11003 && real_zerop (arg1
)))
11004 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11006 if (strict_overflow_p
)
11007 fold_overflow_warning (("assuming signed overflow does not occur "
11008 "when simplifying comparison of "
11009 "absolute value and zero"),
11010 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11011 return omit_one_operand_loc (loc
, type
,
11012 constant_boolean_node (true, type
),
11016 /* Convert ABS_EXPR<x> < 0 to false. */
11017 strict_overflow_p
= false;
11018 if (code
== LT_EXPR
11019 && (integer_zerop (arg1
) || real_zerop (arg1
))
11020 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11022 if (strict_overflow_p
)
11023 fold_overflow_warning (("assuming signed overflow does not occur "
11024 "when simplifying comparison of "
11025 "absolute value and zero"),
11026 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11027 return omit_one_operand_loc (loc
, type
,
11028 constant_boolean_node (false, type
),
11032 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11033 and similarly for >= into !=. */
11034 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11035 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11036 && TREE_CODE (arg1
) == LSHIFT_EXPR
11037 && integer_onep (TREE_OPERAND (arg1
, 0)))
11038 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11039 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11040 TREE_OPERAND (arg1
, 1)),
11041 build_zero_cst (TREE_TYPE (arg0
)));
11043 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11044 otherwise Y might be >= # of bits in X's type and thus e.g.
11045 (unsigned char) (1 << Y) for Y 15 might be 0.
11046 If the cast is widening, then 1 << Y should have unsigned type,
11047 otherwise if Y is number of bits in the signed shift type minus 1,
11048 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11049 31 might be 0xffffffff80000000. */
11050 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11051 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11052 && CONVERT_EXPR_P (arg1
)
11053 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
11054 && (element_precision (TREE_TYPE (arg1
))
11055 >= element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
11056 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
11057 || (element_precision (TREE_TYPE (arg1
))
11058 == element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
11059 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
11061 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11062 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
11063 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11064 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
11065 build_zero_cst (TREE_TYPE (arg0
)));
11070 case UNORDERED_EXPR
:
11078 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11080 tree targ0
= strip_float_extensions (arg0
);
11081 tree targ1
= strip_float_extensions (arg1
);
11082 tree newtype
= TREE_TYPE (targ0
);
11084 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
11085 newtype
= TREE_TYPE (targ1
);
11087 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
11088 return fold_build2_loc (loc
, code
, type
,
11089 fold_convert_loc (loc
, newtype
, targ0
),
11090 fold_convert_loc (loc
, newtype
, targ1
));
11095 case COMPOUND_EXPR
:
11096 /* When pedantic, a compound expression can be neither an lvalue
11097 nor an integer constant expression. */
11098 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
11100 /* Don't let (0, 0) be null pointer constant. */
11101 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
11102 : fold_convert_loc (loc
, type
, arg1
);
11103 return pedantic_non_lvalue_loc (loc
, tem
);
11106 /* An ASSERT_EXPR should never be passed to fold_binary. */
11107 gcc_unreachable ();
11111 } /* switch (code) */
11114 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11115 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
11119 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
11121 switch (TREE_CODE (*tp
))
11127 *walk_subtrees
= 0;
11136 /* Return whether the sub-tree ST contains a label which is accessible from
11137 outside the sub-tree. */
11140 contains_label_p (tree st
)
11143 (walk_tree_without_duplicates (&st
, contains_label_1
, NULL
) != NULL_TREE
);
11146 /* Fold a ternary expression of code CODE and type TYPE with operands
11147 OP0, OP1, and OP2. Return the folded expression if folding is
11148 successful. Otherwise, return NULL_TREE. */
11151 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
11152 tree op0
, tree op1
, tree op2
)
11155 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
11156 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11158 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
11159 && TREE_CODE_LENGTH (code
) == 3);
11161 /* If this is a commutative operation, and OP0 is a constant, move it
11162 to OP1 to reduce the number of tests below. */
11163 if (commutative_ternary_tree_code (code
)
11164 && tree_swap_operands_p (op0
, op1
))
11165 return fold_build3_loc (loc
, code
, type
, op1
, op0
, op2
);
11167 tem
= generic_simplify (loc
, code
, type
, op0
, op1
, op2
);
11171 /* Strip any conversions that don't change the mode. This is safe
11172 for every expression, except for a comparison expression because
11173 its signedness is derived from its operands. So, in the latter
11174 case, only strip conversions that don't change the signedness.
11176 Note that this is done as an internal manipulation within the
11177 constant folder, in order to find the simplest representation of
11178 the arguments so that their form can be studied. In any cases,
11179 the appropriate type conversions should be put back in the tree
11180 that will get out of the constant folder. */
11201 case COMPONENT_REF
:
11202 if (TREE_CODE (arg0
) == CONSTRUCTOR
11203 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
11205 unsigned HOST_WIDE_INT idx
;
11207 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
11214 case VEC_COND_EXPR
:
11215 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11216 so all simple results must be passed through pedantic_non_lvalue. */
11217 if (TREE_CODE (arg0
) == INTEGER_CST
)
11219 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
11220 tem
= integer_zerop (arg0
) ? op2
: op1
;
11221 /* Only optimize constant conditions when the selected branch
11222 has the same type as the COND_EXPR. This avoids optimizing
11223 away "c ? x : throw", where the throw has a void type.
11224 Avoid throwing away that operand which contains label. */
11225 if ((!TREE_SIDE_EFFECTS (unused_op
)
11226 || !contains_label_p (unused_op
))
11227 && (! VOID_TYPE_P (TREE_TYPE (tem
))
11228 || VOID_TYPE_P (type
)))
11229 return pedantic_non_lvalue_loc (loc
, tem
);
11232 else if (TREE_CODE (arg0
) == VECTOR_CST
)
11234 if ((TREE_CODE (arg1
) == VECTOR_CST
11235 || TREE_CODE (arg1
) == CONSTRUCTOR
)
11236 && (TREE_CODE (arg2
) == VECTOR_CST
11237 || TREE_CODE (arg2
) == CONSTRUCTOR
))
11239 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
11240 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
11241 gcc_assert (nelts
== VECTOR_CST_NELTS (arg0
));
11242 for (i
= 0; i
< nelts
; i
++)
11244 tree val
= VECTOR_CST_ELT (arg0
, i
);
11245 if (integer_all_onesp (val
))
11247 else if (integer_zerop (val
))
11248 sel
[i
] = nelts
+ i
;
11249 else /* Currently unreachable. */
11252 tree t
= fold_vec_perm (type
, arg1
, arg2
, sel
);
11253 if (t
!= NULL_TREE
)
11258 /* If we have A op B ? A : C, we may be able to convert this to a
11259 simpler expression, depending on the operation and the values
11260 of B and C. Signed zeros prevent all of these transformations,
11261 for reasons given above each one.
11263 Also try swapping the arguments and inverting the conditional. */
11264 if (COMPARISON_CLASS_P (arg0
)
11265 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
11266 arg1
, TREE_OPERAND (arg0
, 1))
11267 && !HONOR_SIGNED_ZEROS (element_mode (arg1
)))
11269 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
11274 if (COMPARISON_CLASS_P (arg0
)
11275 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
11277 TREE_OPERAND (arg0
, 1))
11278 && !HONOR_SIGNED_ZEROS (element_mode (op2
)))
11280 location_t loc0
= expr_location_or (arg0
, loc
);
11281 tem
= fold_invert_truthvalue (loc0
, arg0
);
11282 if (tem
&& COMPARISON_CLASS_P (tem
))
11284 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
11290 /* If the second operand is simpler than the third, swap them
11291 since that produces better jump optimization results. */
11292 if (truth_value_p (TREE_CODE (arg0
))
11293 && tree_swap_operands_p (op1
, op2
))
11295 location_t loc0
= expr_location_or (arg0
, loc
);
11296 /* See if this can be inverted. If it can't, possibly because
11297 it was a floating-point inequality comparison, don't do
11299 tem
= fold_invert_truthvalue (loc0
, arg0
);
11301 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
11304 /* Convert A ? 1 : 0 to simply A. */
11305 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
11306 : (integer_onep (op1
)
11307 && !VECTOR_TYPE_P (type
)))
11308 && integer_zerop (op2
)
11309 /* If we try to convert OP0 to our type, the
11310 call to fold will try to move the conversion inside
11311 a COND, which will recurse. In that case, the COND_EXPR
11312 is probably the best choice, so leave it alone. */
11313 && type
== TREE_TYPE (arg0
))
11314 return pedantic_non_lvalue_loc (loc
, arg0
);
11316 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11317 over COND_EXPR in cases such as floating point comparisons. */
11318 if (integer_zerop (op1
)
11319 && code
== COND_EXPR
11320 && integer_onep (op2
)
11321 && !VECTOR_TYPE_P (type
)
11322 && truth_value_p (TREE_CODE (arg0
)))
11323 return pedantic_non_lvalue_loc (loc
,
11324 fold_convert_loc (loc
, type
,
11325 invert_truthvalue_loc (loc
,
11328 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11329 if (TREE_CODE (arg0
) == LT_EXPR
11330 && integer_zerop (TREE_OPERAND (arg0
, 1))
11331 && integer_zerop (op2
)
11332 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
11334 /* sign_bit_p looks through both zero and sign extensions,
11335 but for this optimization only sign extensions are
11337 tree tem2
= TREE_OPERAND (arg0
, 0);
11338 while (tem
!= tem2
)
11340 if (TREE_CODE (tem2
) != NOP_EXPR
11341 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
11346 tem2
= TREE_OPERAND (tem2
, 0);
11348 /* sign_bit_p only checks ARG1 bits within A's precision.
11349 If <sign bit of A> has wider type than A, bits outside
11350 of A's precision in <sign bit of A> need to be checked.
11351 If they are all 0, this optimization needs to be done
11352 in unsigned A's type, if they are all 1 in signed A's type,
11353 otherwise this can't be done. */
11355 && TYPE_PRECISION (TREE_TYPE (tem
))
11356 < TYPE_PRECISION (TREE_TYPE (arg1
))
11357 && TYPE_PRECISION (TREE_TYPE (tem
))
11358 < TYPE_PRECISION (type
))
11360 int inner_width
, outer_width
;
11363 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
11364 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
11365 if (outer_width
> TYPE_PRECISION (type
))
11366 outer_width
= TYPE_PRECISION (type
);
11368 wide_int mask
= wi::shifted_mask
11369 (inner_width
, outer_width
- inner_width
, false,
11370 TYPE_PRECISION (TREE_TYPE (arg1
)));
11372 wide_int common
= mask
& arg1
;
11373 if (common
== mask
)
11375 tem_type
= signed_type_for (TREE_TYPE (tem
));
11376 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11378 else if (common
== 0)
11380 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
11381 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11389 fold_convert_loc (loc
, type
,
11390 fold_build2_loc (loc
, BIT_AND_EXPR
,
11391 TREE_TYPE (tem
), tem
,
11392 fold_convert_loc (loc
,
11397 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11398 already handled above. */
11399 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11400 && integer_onep (TREE_OPERAND (arg0
, 1))
11401 && integer_zerop (op2
)
11402 && integer_pow2p (arg1
))
11404 tree tem
= TREE_OPERAND (arg0
, 0);
11406 if (TREE_CODE (tem
) == RSHIFT_EXPR
11407 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
11408 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
) ==
11409 tree_to_uhwi (TREE_OPERAND (tem
, 1)))
11410 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11411 TREE_OPERAND (tem
, 0), arg1
);
11414 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11415 is probably obsolete because the first operand should be a
11416 truth value (that's why we have the two cases above), but let's
11417 leave it in until we can confirm this for all front-ends. */
11418 if (integer_zerop (op2
)
11419 && TREE_CODE (arg0
) == NE_EXPR
11420 && integer_zerop (TREE_OPERAND (arg0
, 1))
11421 && integer_pow2p (arg1
)
11422 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
11423 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
11424 arg1
, OEP_ONLY_CONST
))
11425 return pedantic_non_lvalue_loc (loc
,
11426 fold_convert_loc (loc
, type
,
11427 TREE_OPERAND (arg0
, 0)));
11429 /* Disable the transformations below for vectors, since
11430 fold_binary_op_with_conditional_arg may undo them immediately,
11431 yielding an infinite loop. */
11432 if (code
== VEC_COND_EXPR
)
11435 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11436 if (integer_zerop (op2
)
11437 && truth_value_p (TREE_CODE (arg0
))
11438 && truth_value_p (TREE_CODE (arg1
))
11439 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11440 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
11441 : TRUTH_ANDIF_EXPR
,
11442 type
, fold_convert_loc (loc
, type
, arg0
), arg1
);
11444 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11445 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
11446 && truth_value_p (TREE_CODE (arg0
))
11447 && truth_value_p (TREE_CODE (arg1
))
11448 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11450 location_t loc0
= expr_location_or (arg0
, loc
);
11451 /* Only perform transformation if ARG0 is easily inverted. */
11452 tem
= fold_invert_truthvalue (loc0
, arg0
);
11454 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11457 type
, fold_convert_loc (loc
, type
, tem
),
11461 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11462 if (integer_zerop (arg1
)
11463 && truth_value_p (TREE_CODE (arg0
))
11464 && truth_value_p (TREE_CODE (op2
))
11465 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11467 location_t loc0
= expr_location_or (arg0
, loc
);
11468 /* Only perform transformation if ARG0 is easily inverted. */
11469 tem
= fold_invert_truthvalue (loc0
, arg0
);
11471 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11472 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
11473 type
, fold_convert_loc (loc
, type
, tem
),
11477 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11478 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
11479 && truth_value_p (TREE_CODE (arg0
))
11480 && truth_value_p (TREE_CODE (op2
))
11481 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11482 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11483 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
11484 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
11489 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11490 of fold_ternary on them. */
11491 gcc_unreachable ();
11493 case BIT_FIELD_REF
:
11494 if (TREE_CODE (arg0
) == VECTOR_CST
11495 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
11496 || (TREE_CODE (type
) == VECTOR_TYPE
11497 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
)))))
11499 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
11500 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
11501 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
11502 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
11505 && (idx
% width
) == 0
11506 && (n
% width
) == 0
11507 && ((idx
+ n
) / width
) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)))
11512 if (TREE_CODE (arg0
) == VECTOR_CST
)
11515 return VECTOR_CST_ELT (arg0
, idx
);
11517 tree
*vals
= XALLOCAVEC (tree
, n
);
11518 for (unsigned i
= 0; i
< n
; ++i
)
11519 vals
[i
] = VECTOR_CST_ELT (arg0
, idx
+ i
);
11520 return build_vector (type
, vals
);
11525 /* On constants we can use native encode/interpret to constant
11526 fold (nearly) all BIT_FIELD_REFs. */
11527 if (CONSTANT_CLASS_P (arg0
)
11528 && can_native_interpret_type_p (type
)
11529 && BITS_PER_UNIT
== 8)
11531 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11532 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
11533 /* Limit us to a reasonable amount of work. To relax the
11534 other limitations we need bit-shifting of the buffer
11535 and rounding up the size. */
11536 if (bitpos
% BITS_PER_UNIT
== 0
11537 && bitsize
% BITS_PER_UNIT
== 0
11538 && bitsize
<= MAX_BITSIZE_MODE_ANY_MODE
)
11540 unsigned char b
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
11541 unsigned HOST_WIDE_INT len
11542 = native_encode_expr (arg0
, b
, bitsize
/ BITS_PER_UNIT
,
11543 bitpos
/ BITS_PER_UNIT
);
11545 && len
* BITS_PER_UNIT
>= bitsize
)
11547 tree v
= native_interpret_expr (type
, b
,
11548 bitsize
/ BITS_PER_UNIT
);
11558 /* For integers we can decompose the FMA if possible. */
11559 if (TREE_CODE (arg0
) == INTEGER_CST
11560 && TREE_CODE (arg1
) == INTEGER_CST
)
11561 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
11562 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
11563 if (integer_zerop (arg2
))
11564 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
11566 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
11568 case VEC_PERM_EXPR
:
11569 if (TREE_CODE (arg2
) == VECTOR_CST
)
11571 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
, mask
, mask2
;
11572 unsigned char *sel
= XALLOCAVEC (unsigned char, 2 * nelts
);
11573 unsigned char *sel2
= sel
+ nelts
;
11574 bool need_mask_canon
= false;
11575 bool need_mask_canon2
= false;
11576 bool all_in_vec0
= true;
11577 bool all_in_vec1
= true;
11578 bool maybe_identity
= true;
11579 bool single_arg
= (op0
== op1
);
11580 bool changed
= false;
11582 mask2
= 2 * nelts
- 1;
11583 mask
= single_arg
? (nelts
- 1) : mask2
;
11584 gcc_assert (nelts
== VECTOR_CST_NELTS (arg2
));
11585 for (i
= 0; i
< nelts
; i
++)
11587 tree val
= VECTOR_CST_ELT (arg2
, i
);
11588 if (TREE_CODE (val
) != INTEGER_CST
)
11591 /* Make sure that the perm value is in an acceptable
11594 need_mask_canon
|= wi::gtu_p (t
, mask
);
11595 need_mask_canon2
|= wi::gtu_p (t
, mask2
);
11596 sel
[i
] = t
.to_uhwi () & mask
;
11597 sel2
[i
] = t
.to_uhwi () & mask2
;
11599 if (sel
[i
] < nelts
)
11600 all_in_vec1
= false;
11602 all_in_vec0
= false;
11604 if ((sel
[i
] & (nelts
-1)) != i
)
11605 maybe_identity
= false;
11608 if (maybe_identity
)
11618 else if (all_in_vec1
)
11621 for (i
= 0; i
< nelts
; i
++)
11623 need_mask_canon
= true;
11626 if ((TREE_CODE (op0
) == VECTOR_CST
11627 || TREE_CODE (op0
) == CONSTRUCTOR
)
11628 && (TREE_CODE (op1
) == VECTOR_CST
11629 || TREE_CODE (op1
) == CONSTRUCTOR
))
11631 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
11632 if (t
!= NULL_TREE
)
11636 if (op0
== op1
&& !single_arg
)
11639 /* Some targets are deficient and fail to expand a single
11640 argument permutation while still allowing an equivalent
11641 2-argument version. */
11642 if (need_mask_canon
&& arg2
== op2
11643 && !can_vec_perm_p (TYPE_MODE (type
), false, sel
)
11644 && can_vec_perm_p (TYPE_MODE (type
), false, sel2
))
11646 need_mask_canon
= need_mask_canon2
;
11650 if (need_mask_canon
&& arg2
== op2
)
11652 tree
*tsel
= XALLOCAVEC (tree
, nelts
);
11653 tree eltype
= TREE_TYPE (TREE_TYPE (arg2
));
11654 for (i
= 0; i
< nelts
; i
++)
11655 tsel
[i
] = build_int_cst (eltype
, sel
[i
]);
11656 op2
= build_vector (TREE_TYPE (arg2
), tsel
);
11661 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
11665 case BIT_INSERT_EXPR
:
11666 /* Perform (partial) constant folding of BIT_INSERT_EXPR. */
11667 if (TREE_CODE (arg0
) == INTEGER_CST
11668 && TREE_CODE (arg1
) == INTEGER_CST
)
11670 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11671 unsigned bitsize
= TYPE_PRECISION (TREE_TYPE (arg1
));
11672 wide_int tem
= wi::bit_and (arg0
,
11673 wi::shifted_mask (bitpos
, bitsize
, true,
11674 TYPE_PRECISION (type
)));
11676 = wi::lshift (wi::zext (wi::to_wide (arg1
, TYPE_PRECISION (type
)),
11678 return wide_int_to_tree (type
, wi::bit_or (tem
, tem2
));
11680 else if (TREE_CODE (arg0
) == VECTOR_CST
11681 && CONSTANT_CLASS_P (arg1
)
11682 && types_compatible_p (TREE_TYPE (TREE_TYPE (arg0
)),
11685 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11686 unsigned HOST_WIDE_INT elsize
11687 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (arg1
)));
11688 if (bitpos
% elsize
== 0)
11690 unsigned k
= bitpos
/ elsize
;
11691 if (operand_equal_p (VECTOR_CST_ELT (arg0
, k
), arg1
, 0))
11695 tree
*elts
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
11696 memcpy (elts
, VECTOR_CST_ELTS (arg0
),
11697 sizeof (tree
) * TYPE_VECTOR_SUBPARTS (type
));
11699 return build_vector (type
, elts
);
11707 } /* switch (code) */
11710 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
11711 of an array (or vector). */
11714 get_array_ctor_element_at_index (tree ctor
, offset_int access_index
)
11716 tree index_type
= NULL_TREE
;
11717 offset_int low_bound
= 0;
11719 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
11721 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
11722 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
11724 /* Static constructors for variably sized objects makes no sense. */
11725 gcc_assert (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) == INTEGER_CST
);
11726 index_type
= TREE_TYPE (TYPE_MIN_VALUE (domain_type
));
11727 low_bound
= wi::to_offset (TYPE_MIN_VALUE (domain_type
));
11732 access_index
= wi::ext (access_index
, TYPE_PRECISION (index_type
),
11733 TYPE_SIGN (index_type
));
11735 offset_int index
= low_bound
- 1;
11737 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11738 TYPE_SIGN (index_type
));
11740 offset_int max_index
;
11741 unsigned HOST_WIDE_INT cnt
;
11744 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
, cval
)
11746 /* Array constructor might explicitly set index, or specify a range,
11747 or leave index NULL meaning that it is next index after previous
11751 if (TREE_CODE (cfield
) == INTEGER_CST
)
11752 max_index
= index
= wi::to_offset (cfield
);
11755 gcc_assert (TREE_CODE (cfield
) == RANGE_EXPR
);
11756 index
= wi::to_offset (TREE_OPERAND (cfield
, 0));
11757 max_index
= wi::to_offset (TREE_OPERAND (cfield
, 1));
11764 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11765 TYPE_SIGN (index_type
));
11769 /* Do we have match? */
11770 if (wi::cmpu (access_index
, index
) >= 0
11771 && wi::cmpu (access_index
, max_index
) <= 0)
11777 /* Perform constant folding and related simplification of EXPR.
11778 The related simplifications include x*1 => x, x*0 => 0, etc.,
11779 and application of the associative law.
11780 NOP_EXPR conversions may be removed freely (as long as we
11781 are careful not to change the type of the overall expression).
11782 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11783 but we can constant-fold them if they have constant operands. */
11785 #ifdef ENABLE_FOLD_CHECKING
11786 # define fold(x) fold_1 (x)
11787 static tree
fold_1 (tree
);
11793 const tree t
= expr
;
11794 enum tree_code code
= TREE_CODE (t
);
11795 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11797 location_t loc
= EXPR_LOCATION (expr
);
11799 /* Return right away if a constant. */
11800 if (kind
== tcc_constant
)
11803 /* CALL_EXPR-like objects with variable numbers of operands are
11804 treated specially. */
11805 if (kind
== tcc_vl_exp
)
11807 if (code
== CALL_EXPR
)
11809 tem
= fold_call_expr (loc
, expr
, false);
11810 return tem
? tem
: expr
;
11815 if (IS_EXPR_CODE_CLASS (kind
))
11817 tree type
= TREE_TYPE (t
);
11818 tree op0
, op1
, op2
;
11820 switch (TREE_CODE_LENGTH (code
))
11823 op0
= TREE_OPERAND (t
, 0);
11824 tem
= fold_unary_loc (loc
, code
, type
, op0
);
11825 return tem
? tem
: expr
;
11827 op0
= TREE_OPERAND (t
, 0);
11828 op1
= TREE_OPERAND (t
, 1);
11829 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
11830 return tem
? tem
: expr
;
11832 op0
= TREE_OPERAND (t
, 0);
11833 op1
= TREE_OPERAND (t
, 1);
11834 op2
= TREE_OPERAND (t
, 2);
11835 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
11836 return tem
? tem
: expr
;
11846 tree op0
= TREE_OPERAND (t
, 0);
11847 tree op1
= TREE_OPERAND (t
, 1);
11849 if (TREE_CODE (op1
) == INTEGER_CST
11850 && TREE_CODE (op0
) == CONSTRUCTOR
11851 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
11853 tree val
= get_array_ctor_element_at_index (op0
,
11854 wi::to_offset (op1
));
11862 /* Return a VECTOR_CST if possible. */
11865 tree type
= TREE_TYPE (t
);
11866 if (TREE_CODE (type
) != VECTOR_TYPE
)
11871 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
11872 if (! CONSTANT_CLASS_P (val
))
11875 return build_vector_from_ctor (type
, CONSTRUCTOR_ELTS (t
));
11879 return fold (DECL_INITIAL (t
));
11883 } /* switch (code) */
11886 #ifdef ENABLE_FOLD_CHECKING
11889 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
11890 hash_table
<nofree_ptr_hash
<const tree_node
> > *);
11891 static void fold_check_failed (const_tree
, const_tree
);
11892 void print_fold_checksum (const_tree
);
11894 /* When --enable-checking=fold, compute a digest of expr before
11895 and after actual fold call to see if fold did not accidentally
11896 change original expr. */
11902 struct md5_ctx ctx
;
11903 unsigned char checksum_before
[16], checksum_after
[16];
11904 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
11906 md5_init_ctx (&ctx
);
11907 fold_checksum_tree (expr
, &ctx
, &ht
);
11908 md5_finish_ctx (&ctx
, checksum_before
);
11911 ret
= fold_1 (expr
);
11913 md5_init_ctx (&ctx
);
11914 fold_checksum_tree (expr
, &ctx
, &ht
);
11915 md5_finish_ctx (&ctx
, checksum_after
);
11917 if (memcmp (checksum_before
, checksum_after
, 16))
11918 fold_check_failed (expr
, ret
);
11924 print_fold_checksum (const_tree expr
)
11926 struct md5_ctx ctx
;
11927 unsigned char checksum
[16], cnt
;
11928 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
11930 md5_init_ctx (&ctx
);
11931 fold_checksum_tree (expr
, &ctx
, &ht
);
11932 md5_finish_ctx (&ctx
, checksum
);
11933 for (cnt
= 0; cnt
< 16; ++cnt
)
11934 fprintf (stderr
, "%02x", checksum
[cnt
]);
11935 putc ('\n', stderr
);
11939 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
11941 internal_error ("fold check: original tree changed by fold");
11945 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
11946 hash_table
<nofree_ptr_hash
<const tree_node
> > *ht
)
11948 const tree_node
**slot
;
11949 enum tree_code code
;
11950 union tree_node buf
;
11956 slot
= ht
->find_slot (expr
, INSERT
);
11960 code
= TREE_CODE (expr
);
11961 if (TREE_CODE_CLASS (code
) == tcc_declaration
11962 && HAS_DECL_ASSEMBLER_NAME_P (expr
))
11964 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
11965 memcpy ((char *) &buf
, expr
, tree_size (expr
));
11966 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
11967 buf
.decl_with_vis
.symtab_node
= NULL
;
11968 expr
= (tree
) &buf
;
11970 else if (TREE_CODE_CLASS (code
) == tcc_type
11971 && (TYPE_POINTER_TO (expr
)
11972 || TYPE_REFERENCE_TO (expr
)
11973 || TYPE_CACHED_VALUES_P (expr
)
11974 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
11975 || TYPE_NEXT_VARIANT (expr
)
11976 || TYPE_ALIAS_SET_KNOWN_P (expr
)))
11978 /* Allow these fields to be modified. */
11980 memcpy ((char *) &buf
, expr
, tree_size (expr
));
11981 expr
= tmp
= (tree
) &buf
;
11982 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
11983 TYPE_POINTER_TO (tmp
) = NULL
;
11984 TYPE_REFERENCE_TO (tmp
) = NULL
;
11985 TYPE_NEXT_VARIANT (tmp
) = NULL
;
11986 TYPE_ALIAS_SET (tmp
) = -1;
11987 if (TYPE_CACHED_VALUES_P (tmp
))
11989 TYPE_CACHED_VALUES_P (tmp
) = 0;
11990 TYPE_CACHED_VALUES (tmp
) = NULL
;
11993 md5_process_bytes (expr
, tree_size (expr
), ctx
);
11994 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
11995 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
11996 if (TREE_CODE_CLASS (code
) != tcc_type
11997 && TREE_CODE_CLASS (code
) != tcc_declaration
11998 && code
!= TREE_LIST
11999 && code
!= SSA_NAME
12000 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
12001 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
12002 switch (TREE_CODE_CLASS (code
))
12008 md5_process_bytes (TREE_STRING_POINTER (expr
),
12009 TREE_STRING_LENGTH (expr
), ctx
);
12012 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
12013 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
12016 for (i
= 0; i
< (int) VECTOR_CST_NELTS (expr
); ++i
)
12017 fold_checksum_tree (VECTOR_CST_ELT (expr
, i
), ctx
, ht
);
12023 case tcc_exceptional
:
12027 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
12028 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
12029 expr
= TREE_CHAIN (expr
);
12030 goto recursive_label
;
12033 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
12034 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
12040 case tcc_expression
:
12041 case tcc_reference
:
12042 case tcc_comparison
:
12045 case tcc_statement
:
12047 len
= TREE_OPERAND_LENGTH (expr
);
12048 for (i
= 0; i
< len
; ++i
)
12049 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
12051 case tcc_declaration
:
12052 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
12053 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
12054 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
12056 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
12057 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
12058 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
12059 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
12060 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
12063 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
12065 if (TREE_CODE (expr
) == FUNCTION_DECL
)
12067 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
12068 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
12070 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
12074 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
12075 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
12076 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
12077 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
12078 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
12079 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
12080 if (INTEGRAL_TYPE_P (expr
)
12081 || SCALAR_FLOAT_TYPE_P (expr
))
12083 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
12084 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
12086 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
12087 if (TREE_CODE (expr
) == RECORD_TYPE
12088 || TREE_CODE (expr
) == UNION_TYPE
12089 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
12090 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
12091 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
12098 /* Helper function for outputting the checksum of a tree T. When
12099 debugging with gdb, you can "define mynext" to be "next" followed
12100 by "call debug_fold_checksum (op0)", then just trace down till the
12103 DEBUG_FUNCTION
void
12104 debug_fold_checksum (const_tree t
)
12107 unsigned char checksum
[16];
12108 struct md5_ctx ctx
;
12109 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12111 md5_init_ctx (&ctx
);
12112 fold_checksum_tree (t
, &ctx
, &ht
);
12113 md5_finish_ctx (&ctx
, checksum
);
12116 for (i
= 0; i
< 16; i
++)
12117 fprintf (stderr
, "%d ", checksum
[i
]);
12119 fprintf (stderr
, "\n");
12124 /* Fold a unary tree expression with code CODE of type TYPE with an
12125 operand OP0. LOC is the location of the resulting expression.
12126 Return a folded expression if successful. Otherwise, return a tree
12127 expression with code CODE of type TYPE with an operand OP0. */
12130 fold_build1_stat_loc (location_t loc
,
12131 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
12134 #ifdef ENABLE_FOLD_CHECKING
12135 unsigned char checksum_before
[16], checksum_after
[16];
12136 struct md5_ctx ctx
;
12137 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12139 md5_init_ctx (&ctx
);
12140 fold_checksum_tree (op0
, &ctx
, &ht
);
12141 md5_finish_ctx (&ctx
, checksum_before
);
12145 tem
= fold_unary_loc (loc
, code
, type
, op0
);
12147 tem
= build1_stat_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
12149 #ifdef ENABLE_FOLD_CHECKING
12150 md5_init_ctx (&ctx
);
12151 fold_checksum_tree (op0
, &ctx
, &ht
);
12152 md5_finish_ctx (&ctx
, checksum_after
);
12154 if (memcmp (checksum_before
, checksum_after
, 16))
12155 fold_check_failed (op0
, tem
);
12160 /* Fold a binary tree expression with code CODE of type TYPE with
12161 operands OP0 and OP1. LOC is the location of the resulting
12162 expression. Return a folded expression if successful. Otherwise,
12163 return a tree expression with code CODE of type TYPE with operands
12167 fold_build2_stat_loc (location_t loc
,
12168 enum tree_code code
, tree type
, tree op0
, tree op1
12172 #ifdef ENABLE_FOLD_CHECKING
12173 unsigned char checksum_before_op0
[16],
12174 checksum_before_op1
[16],
12175 checksum_after_op0
[16],
12176 checksum_after_op1
[16];
12177 struct md5_ctx ctx
;
12178 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12180 md5_init_ctx (&ctx
);
12181 fold_checksum_tree (op0
, &ctx
, &ht
);
12182 md5_finish_ctx (&ctx
, checksum_before_op0
);
12185 md5_init_ctx (&ctx
);
12186 fold_checksum_tree (op1
, &ctx
, &ht
);
12187 md5_finish_ctx (&ctx
, checksum_before_op1
);
12191 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
12193 tem
= build2_stat_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
12195 #ifdef ENABLE_FOLD_CHECKING
12196 md5_init_ctx (&ctx
);
12197 fold_checksum_tree (op0
, &ctx
, &ht
);
12198 md5_finish_ctx (&ctx
, checksum_after_op0
);
12201 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12202 fold_check_failed (op0
, tem
);
12204 md5_init_ctx (&ctx
);
12205 fold_checksum_tree (op1
, &ctx
, &ht
);
12206 md5_finish_ctx (&ctx
, checksum_after_op1
);
12208 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12209 fold_check_failed (op1
, tem
);
12214 /* Fold a ternary tree expression with code CODE of type TYPE with
12215 operands OP0, OP1, and OP2. Return a folded expression if
12216 successful. Otherwise, return a tree expression with code CODE of
12217 type TYPE with operands OP0, OP1, and OP2. */
12220 fold_build3_stat_loc (location_t loc
, enum tree_code code
, tree type
,
12221 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
12224 #ifdef ENABLE_FOLD_CHECKING
12225 unsigned char checksum_before_op0
[16],
12226 checksum_before_op1
[16],
12227 checksum_before_op2
[16],
12228 checksum_after_op0
[16],
12229 checksum_after_op1
[16],
12230 checksum_after_op2
[16];
12231 struct md5_ctx ctx
;
12232 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12234 md5_init_ctx (&ctx
);
12235 fold_checksum_tree (op0
, &ctx
, &ht
);
12236 md5_finish_ctx (&ctx
, checksum_before_op0
);
12239 md5_init_ctx (&ctx
);
12240 fold_checksum_tree (op1
, &ctx
, &ht
);
12241 md5_finish_ctx (&ctx
, checksum_before_op1
);
12244 md5_init_ctx (&ctx
);
12245 fold_checksum_tree (op2
, &ctx
, &ht
);
12246 md5_finish_ctx (&ctx
, checksum_before_op2
);
12250 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
12251 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
12253 tem
= build3_stat_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
12255 #ifdef ENABLE_FOLD_CHECKING
12256 md5_init_ctx (&ctx
);
12257 fold_checksum_tree (op0
, &ctx
, &ht
);
12258 md5_finish_ctx (&ctx
, checksum_after_op0
);
12261 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12262 fold_check_failed (op0
, tem
);
12264 md5_init_ctx (&ctx
);
12265 fold_checksum_tree (op1
, &ctx
, &ht
);
12266 md5_finish_ctx (&ctx
, checksum_after_op1
);
12269 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12270 fold_check_failed (op1
, tem
);
12272 md5_init_ctx (&ctx
);
12273 fold_checksum_tree (op2
, &ctx
, &ht
);
12274 md5_finish_ctx (&ctx
, checksum_after_op2
);
12276 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
12277 fold_check_failed (op2
, tem
);
12282 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12283 arguments in ARGARRAY, and a null static chain.
12284 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12285 of type TYPE from the given operands as constructed by build_call_array. */
12288 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
12289 int nargs
, tree
*argarray
)
12292 #ifdef ENABLE_FOLD_CHECKING
12293 unsigned char checksum_before_fn
[16],
12294 checksum_before_arglist
[16],
12295 checksum_after_fn
[16],
12296 checksum_after_arglist
[16];
12297 struct md5_ctx ctx
;
12298 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12301 md5_init_ctx (&ctx
);
12302 fold_checksum_tree (fn
, &ctx
, &ht
);
12303 md5_finish_ctx (&ctx
, checksum_before_fn
);
12306 md5_init_ctx (&ctx
);
12307 for (i
= 0; i
< nargs
; i
++)
12308 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12309 md5_finish_ctx (&ctx
, checksum_before_arglist
);
12313 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
12315 tem
= build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12317 #ifdef ENABLE_FOLD_CHECKING
12318 md5_init_ctx (&ctx
);
12319 fold_checksum_tree (fn
, &ctx
, &ht
);
12320 md5_finish_ctx (&ctx
, checksum_after_fn
);
12323 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
12324 fold_check_failed (fn
, tem
);
12326 md5_init_ctx (&ctx
);
12327 for (i
= 0; i
< nargs
; i
++)
12328 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12329 md5_finish_ctx (&ctx
, checksum_after_arglist
);
12331 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
12332 fold_check_failed (NULL_TREE
, tem
);
12337 /* Perform constant folding and related simplification of initializer
12338 expression EXPR. These behave identically to "fold_buildN" but ignore
12339 potential run-time traps and exceptions that fold must preserve. */
12341 #define START_FOLD_INIT \
12342 int saved_signaling_nans = flag_signaling_nans;\
12343 int saved_trapping_math = flag_trapping_math;\
12344 int saved_rounding_math = flag_rounding_math;\
12345 int saved_trapv = flag_trapv;\
12346 int saved_folding_initializer = folding_initializer;\
12347 flag_signaling_nans = 0;\
12348 flag_trapping_math = 0;\
12349 flag_rounding_math = 0;\
12351 folding_initializer = 1;
12353 #define END_FOLD_INIT \
12354 flag_signaling_nans = saved_signaling_nans;\
12355 flag_trapping_math = saved_trapping_math;\
12356 flag_rounding_math = saved_rounding_math;\
12357 flag_trapv = saved_trapv;\
12358 folding_initializer = saved_folding_initializer;
12361 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
12362 tree type
, tree op
)
12367 result
= fold_build1_loc (loc
, code
, type
, op
);
12374 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
12375 tree type
, tree op0
, tree op1
)
12380 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
12387 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
12388 int nargs
, tree
*argarray
)
12393 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12399 #undef START_FOLD_INIT
12400 #undef END_FOLD_INIT
12402 /* Determine if first argument is a multiple of second argument. Return 0 if
12403 it is not, or we cannot easily determined it to be.
12405 An example of the sort of thing we care about (at this point; this routine
12406 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12407 fold cases do now) is discovering that
12409 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12415 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12417 This code also handles discovering that
12419 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12421 is a multiple of 8 so we don't have to worry about dealing with a
12422 possible remainder.
12424 Note that we *look* inside a SAVE_EXPR only to determine how it was
12425 calculated; it is not safe for fold to do much of anything else with the
12426 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12427 at run time. For example, the latter example above *cannot* be implemented
12428 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12429 evaluation time of the original SAVE_EXPR is not necessarily the same at
12430 the time the new expression is evaluated. The only optimization of this
12431 sort that would be valid is changing
12433 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12437 SAVE_EXPR (I) * SAVE_EXPR (J)
12439 (where the same SAVE_EXPR (J) is used in the original and the
12440 transformed version). */
12443 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
12448 if (operand_equal_p (top
, bottom
, 0))
12451 if (TREE_CODE (type
) != INTEGER_TYPE
)
12454 switch (TREE_CODE (top
))
12457 /* Bitwise and provides a power of two multiple. If the mask is
12458 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12459 if (!integer_pow2p (bottom
))
12464 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12465 || multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12468 /* It is impossible to prove if op0 - op1 is multiple of bottom
12469 precisely, so be conservative here checking if both op0 and op1
12470 are multiple of bottom. Note we check the second operand first
12471 since it's usually simpler. */
12472 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12473 && multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12476 /* The same as MINUS_EXPR, but handle cases like op0 + 0xfffffffd
12477 as op0 - 3 if the expression has unsigned type. For example,
12478 (X / 3) + 0xfffffffd is multiple of 3, but 0xfffffffd is not. */
12479 op1
= TREE_OPERAND (top
, 1);
12480 if (TYPE_UNSIGNED (type
)
12481 && TREE_CODE (op1
) == INTEGER_CST
&& tree_int_cst_sign_bit (op1
))
12482 op1
= fold_build1 (NEGATE_EXPR
, type
, op1
);
12483 return (multiple_of_p (type
, op1
, bottom
)
12484 && multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12487 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
12489 op1
= TREE_OPERAND (top
, 1);
12490 /* const_binop may not detect overflow correctly,
12491 so check for it explicitly here. */
12492 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
12493 && 0 != (t1
= fold_convert (type
,
12494 const_binop (LSHIFT_EXPR
,
12497 && !TREE_OVERFLOW (t1
))
12498 return multiple_of_p (type
, t1
, bottom
);
12503 /* Can't handle conversions from non-integral or wider integral type. */
12504 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
12505 || (TYPE_PRECISION (type
)
12506 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
12512 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
12515 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12516 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
12519 if (TREE_CODE (bottom
) != INTEGER_CST
12520 || integer_zerop (bottom
)
12521 || (TYPE_UNSIGNED (type
)
12522 && (tree_int_cst_sgn (top
) < 0
12523 || tree_int_cst_sgn (bottom
) < 0)))
12525 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
12529 if (TREE_CODE (bottom
) == INTEGER_CST
12530 && (stmt
= SSA_NAME_DEF_STMT (top
)) != NULL
12531 && gimple_code (stmt
) == GIMPLE_ASSIGN
)
12533 enum tree_code code
= gimple_assign_rhs_code (stmt
);
12535 /* Check for special cases to see if top is defined as multiple
12538 top = (X & ~(bottom - 1) ; bottom is power of 2
12544 if (code
== BIT_AND_EXPR
12545 && (op2
= gimple_assign_rhs2 (stmt
)) != NULL_TREE
12546 && TREE_CODE (op2
) == INTEGER_CST
12547 && integer_pow2p (bottom
)
12548 && wi::multiple_of_p (wi::to_widest (op2
),
12549 wi::to_widest (bottom
), UNSIGNED
))
12552 op1
= gimple_assign_rhs1 (stmt
);
12553 if (code
== MINUS_EXPR
12554 && (op2
= gimple_assign_rhs2 (stmt
)) != NULL_TREE
12555 && TREE_CODE (op2
) == SSA_NAME
12556 && (stmt
= SSA_NAME_DEF_STMT (op2
)) != NULL
12557 && gimple_code (stmt
) == GIMPLE_ASSIGN
12558 && (code
= gimple_assign_rhs_code (stmt
)) == TRUNC_MOD_EXPR
12559 && operand_equal_p (op1
, gimple_assign_rhs1 (stmt
), 0)
12560 && operand_equal_p (bottom
, gimple_assign_rhs2 (stmt
), 0))
12571 #define tree_expr_nonnegative_warnv_p(X, Y) \
12572 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
12574 #define RECURSE(X) \
12575 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12577 /* Return true if CODE or TYPE is known to be non-negative. */
12580 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
12582 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
12583 && truth_value_p (code
))
12584 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12585 have a signed:1 type (where the value is -1 and 0). */
12590 /* Return true if (CODE OP0) is known to be non-negative. If the return
12591 value is based on the assumption that signed overflow is undefined,
12592 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12593 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12596 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12597 bool *strict_overflow_p
, int depth
)
12599 if (TYPE_UNSIGNED (type
))
12605 /* We can't return 1 if flag_wrapv is set because
12606 ABS_EXPR<INT_MIN> = INT_MIN. */
12607 if (!ANY_INTEGRAL_TYPE_P (type
))
12609 if (TYPE_OVERFLOW_UNDEFINED (type
))
12611 *strict_overflow_p
= true;
12616 case NON_LVALUE_EXPR
:
12618 case FIX_TRUNC_EXPR
:
12619 return RECURSE (op0
);
12623 tree inner_type
= TREE_TYPE (op0
);
12624 tree outer_type
= type
;
12626 if (TREE_CODE (outer_type
) == REAL_TYPE
)
12628 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12629 return RECURSE (op0
);
12630 if (INTEGRAL_TYPE_P (inner_type
))
12632 if (TYPE_UNSIGNED (inner_type
))
12634 return RECURSE (op0
);
12637 else if (INTEGRAL_TYPE_P (outer_type
))
12639 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12640 return RECURSE (op0
);
12641 if (INTEGRAL_TYPE_P (inner_type
))
12642 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
12643 && TYPE_UNSIGNED (inner_type
);
12649 return tree_simple_nonnegative_warnv_p (code
, type
);
12652 /* We don't know sign of `t', so be conservative and return false. */
12656 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12657 value is based on the assumption that signed overflow is undefined,
12658 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12659 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12662 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12663 tree op1
, bool *strict_overflow_p
,
12666 if (TYPE_UNSIGNED (type
))
12671 case POINTER_PLUS_EXPR
:
12673 if (FLOAT_TYPE_P (type
))
12674 return RECURSE (op0
) && RECURSE (op1
);
12676 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12677 both unsigned and at least 2 bits shorter than the result. */
12678 if (TREE_CODE (type
) == INTEGER_TYPE
12679 && TREE_CODE (op0
) == NOP_EXPR
12680 && TREE_CODE (op1
) == NOP_EXPR
)
12682 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
12683 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
12684 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
12685 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
12687 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
12688 TYPE_PRECISION (inner2
)) + 1;
12689 return prec
< TYPE_PRECISION (type
);
12695 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12697 /* x * x is always non-negative for floating point x
12698 or without overflow. */
12699 if (operand_equal_p (op0
, op1
, 0)
12700 || (RECURSE (op0
) && RECURSE (op1
)))
12702 if (ANY_INTEGRAL_TYPE_P (type
)
12703 && TYPE_OVERFLOW_UNDEFINED (type
))
12704 *strict_overflow_p
= true;
12709 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12710 both unsigned and their total bits is shorter than the result. */
12711 if (TREE_CODE (type
) == INTEGER_TYPE
12712 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
12713 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
12715 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
12716 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
12718 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
12719 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
12722 bool unsigned0
= TYPE_UNSIGNED (inner0
);
12723 bool unsigned1
= TYPE_UNSIGNED (inner1
);
12725 if (TREE_CODE (op0
) == INTEGER_CST
)
12726 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
12728 if (TREE_CODE (op1
) == INTEGER_CST
)
12729 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
12731 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
12732 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
12734 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
12735 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
12736 : TYPE_PRECISION (inner0
);
12738 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
12739 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
12740 : TYPE_PRECISION (inner1
);
12742 return precision0
+ precision1
< TYPE_PRECISION (type
);
12749 return RECURSE (op0
) || RECURSE (op1
);
12755 case TRUNC_DIV_EXPR
:
12756 case CEIL_DIV_EXPR
:
12757 case FLOOR_DIV_EXPR
:
12758 case ROUND_DIV_EXPR
:
12759 return RECURSE (op0
) && RECURSE (op1
);
12761 case TRUNC_MOD_EXPR
:
12762 return RECURSE (op0
);
12764 case FLOOR_MOD_EXPR
:
12765 return RECURSE (op1
);
12767 case CEIL_MOD_EXPR
:
12768 case ROUND_MOD_EXPR
:
12770 return tree_simple_nonnegative_warnv_p (code
, type
);
12773 /* We don't know sign of `t', so be conservative and return false. */
12777 /* Return true if T is known to be non-negative. If the return
12778 value is based on the assumption that signed overflow is undefined,
12779 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12780 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12783 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
12785 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
12788 switch (TREE_CODE (t
))
12791 return tree_int_cst_sgn (t
) >= 0;
12794 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
12797 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
12800 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
12803 /* Limit the depth of recursion to avoid quadratic behavior.
12804 This is expected to catch almost all occurrences in practice.
12805 If this code misses important cases that unbounded recursion
12806 would not, passes that need this information could be revised
12807 to provide it through dataflow propagation. */
12808 return (!name_registered_for_update_p (t
)
12809 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
12810 && gimple_stmt_nonnegative_warnv_p (SSA_NAME_DEF_STMT (t
),
12811 strict_overflow_p
, depth
));
12814 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
12818 /* Return true if T is known to be non-negative. If the return
12819 value is based on the assumption that signed overflow is undefined,
12820 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12821 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12824 tree_call_nonnegative_warnv_p (tree type
, combined_fn fn
, tree arg0
, tree arg1
,
12825 bool *strict_overflow_p
, int depth
)
12846 case CFN_BUILT_IN_BSWAP32
:
12847 case CFN_BUILT_IN_BSWAP64
:
12852 /* sqrt(-0.0) is -0.0. */
12853 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
12855 return RECURSE (arg0
);
12881 CASE_CFN_NEARBYINT
:
12888 CASE_CFN_SIGNIFICAND
:
12892 /* True if the 1st argument is nonnegative. */
12893 return RECURSE (arg0
);
12896 /* True if the 1st OR 2nd arguments are nonnegative. */
12897 return RECURSE (arg0
) || RECURSE (arg1
);
12900 /* True if the 1st AND 2nd arguments are nonnegative. */
12901 return RECURSE (arg0
) && RECURSE (arg1
);
12904 /* True if the 2nd argument is nonnegative. */
12905 return RECURSE (arg1
);
12908 /* True if the 1st argument is nonnegative or the second
12909 argument is an even integer. */
12910 if (TREE_CODE (arg1
) == INTEGER_CST
12911 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
12913 return RECURSE (arg0
);
12916 /* True if the 1st argument is nonnegative or the second
12917 argument is an even integer valued real. */
12918 if (TREE_CODE (arg1
) == REAL_CST
)
12923 c
= TREE_REAL_CST (arg1
);
12924 n
= real_to_integer (&c
);
12927 REAL_VALUE_TYPE cint
;
12928 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
12929 if (real_identical (&c
, &cint
))
12933 return RECURSE (arg0
);
12938 return tree_simple_nonnegative_warnv_p (CALL_EXPR
, type
);
12941 /* Return true if T is known to be non-negative. If the return
12942 value is based on the assumption that signed overflow is undefined,
12943 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12944 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12947 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
12949 enum tree_code code
= TREE_CODE (t
);
12950 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
12957 tree temp
= TARGET_EXPR_SLOT (t
);
12958 t
= TARGET_EXPR_INITIAL (t
);
12960 /* If the initializer is non-void, then it's a normal expression
12961 that will be assigned to the slot. */
12962 if (!VOID_TYPE_P (t
))
12963 return RECURSE (t
);
12965 /* Otherwise, the initializer sets the slot in some way. One common
12966 way is an assignment statement at the end of the initializer. */
12969 if (TREE_CODE (t
) == BIND_EXPR
)
12970 t
= expr_last (BIND_EXPR_BODY (t
));
12971 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
12972 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
12973 t
= expr_last (TREE_OPERAND (t
, 0));
12974 else if (TREE_CODE (t
) == STATEMENT_LIST
)
12979 if (TREE_CODE (t
) == MODIFY_EXPR
12980 && TREE_OPERAND (t
, 0) == temp
)
12981 return RECURSE (TREE_OPERAND (t
, 1));
12988 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
12989 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
12991 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
12992 get_call_combined_fn (t
),
12995 strict_overflow_p
, depth
);
12997 case COMPOUND_EXPR
:
12999 return RECURSE (TREE_OPERAND (t
, 1));
13002 return RECURSE (expr_last (TREE_OPERAND (t
, 1)));
13005 return RECURSE (TREE_OPERAND (t
, 0));
13008 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
13013 #undef tree_expr_nonnegative_warnv_p
13015 /* Return true if T is known to be non-negative. If the return
13016 value is based on the assumption that signed overflow is undefined,
13017 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13018 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13021 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13023 enum tree_code code
;
13024 if (t
== error_mark_node
)
13027 code
= TREE_CODE (t
);
13028 switch (TREE_CODE_CLASS (code
))
13031 case tcc_comparison
:
13032 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13034 TREE_OPERAND (t
, 0),
13035 TREE_OPERAND (t
, 1),
13036 strict_overflow_p
, depth
);
13039 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13041 TREE_OPERAND (t
, 0),
13042 strict_overflow_p
, depth
);
13045 case tcc_declaration
:
13046 case tcc_reference
:
13047 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13055 case TRUTH_AND_EXPR
:
13056 case TRUTH_OR_EXPR
:
13057 case TRUTH_XOR_EXPR
:
13058 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13060 TREE_OPERAND (t
, 0),
13061 TREE_OPERAND (t
, 1),
13062 strict_overflow_p
, depth
);
13063 case TRUTH_NOT_EXPR
:
13064 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13066 TREE_OPERAND (t
, 0),
13067 strict_overflow_p
, depth
);
13074 case WITH_SIZE_EXPR
:
13076 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13079 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13083 /* Return true if `t' is known to be non-negative. Handle warnings
13084 about undefined signed overflow. */
13087 tree_expr_nonnegative_p (tree t
)
13089 bool ret
, strict_overflow_p
;
13091 strict_overflow_p
= false;
13092 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
13093 if (strict_overflow_p
)
13094 fold_overflow_warning (("assuming signed overflow does not occur when "
13095 "determining that expression is always "
13097 WARN_STRICT_OVERFLOW_MISC
);
13102 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13103 For floating point we further ensure that T is not denormal.
13104 Similar logic is present in nonzero_address in rtlanal.h.
13106 If the return value is based on the assumption that signed overflow
13107 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13108 change *STRICT_OVERFLOW_P. */
13111 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
13112 bool *strict_overflow_p
)
13117 return tree_expr_nonzero_warnv_p (op0
,
13118 strict_overflow_p
);
13122 tree inner_type
= TREE_TYPE (op0
);
13123 tree outer_type
= type
;
13125 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
13126 && tree_expr_nonzero_warnv_p (op0
,
13127 strict_overflow_p
));
13131 case NON_LVALUE_EXPR
:
13132 return tree_expr_nonzero_warnv_p (op0
,
13133 strict_overflow_p
);
13142 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13143 For floating point we further ensure that T is not denormal.
13144 Similar logic is present in nonzero_address in rtlanal.h.
13146 If the return value is based on the assumption that signed overflow
13147 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13148 change *STRICT_OVERFLOW_P. */
13151 tree_binary_nonzero_warnv_p (enum tree_code code
,
13154 tree op1
, bool *strict_overflow_p
)
13156 bool sub_strict_overflow_p
;
13159 case POINTER_PLUS_EXPR
:
13161 if (ANY_INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_UNDEFINED (type
))
13163 /* With the presence of negative values it is hard
13164 to say something. */
13165 sub_strict_overflow_p
= false;
13166 if (!tree_expr_nonnegative_warnv_p (op0
,
13167 &sub_strict_overflow_p
)
13168 || !tree_expr_nonnegative_warnv_p (op1
,
13169 &sub_strict_overflow_p
))
13171 /* One of operands must be positive and the other non-negative. */
13172 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13173 overflows, on a twos-complement machine the sum of two
13174 nonnegative numbers can never be zero. */
13175 return (tree_expr_nonzero_warnv_p (op0
,
13177 || tree_expr_nonzero_warnv_p (op1
,
13178 strict_overflow_p
));
13183 if (TYPE_OVERFLOW_UNDEFINED (type
))
13185 if (tree_expr_nonzero_warnv_p (op0
,
13187 && tree_expr_nonzero_warnv_p (op1
,
13188 strict_overflow_p
))
13190 *strict_overflow_p
= true;
13197 sub_strict_overflow_p
= false;
13198 if (tree_expr_nonzero_warnv_p (op0
,
13199 &sub_strict_overflow_p
)
13200 && tree_expr_nonzero_warnv_p (op1
,
13201 &sub_strict_overflow_p
))
13203 if (sub_strict_overflow_p
)
13204 *strict_overflow_p
= true;
13209 sub_strict_overflow_p
= false;
13210 if (tree_expr_nonzero_warnv_p (op0
,
13211 &sub_strict_overflow_p
))
13213 if (sub_strict_overflow_p
)
13214 *strict_overflow_p
= true;
13216 /* When both operands are nonzero, then MAX must be too. */
13217 if (tree_expr_nonzero_warnv_p (op1
,
13218 strict_overflow_p
))
13221 /* MAX where operand 0 is positive is positive. */
13222 return tree_expr_nonnegative_warnv_p (op0
,
13223 strict_overflow_p
);
13225 /* MAX where operand 1 is positive is positive. */
13226 else if (tree_expr_nonzero_warnv_p (op1
,
13227 &sub_strict_overflow_p
)
13228 && tree_expr_nonnegative_warnv_p (op1
,
13229 &sub_strict_overflow_p
))
13231 if (sub_strict_overflow_p
)
13232 *strict_overflow_p
= true;
13238 return (tree_expr_nonzero_warnv_p (op1
,
13240 || tree_expr_nonzero_warnv_p (op0
,
13241 strict_overflow_p
));
13250 /* Return true when T is an address and is known to be nonzero.
13251 For floating point we further ensure that T is not denormal.
13252 Similar logic is present in nonzero_address in rtlanal.h.
13254 If the return value is based on the assumption that signed overflow
13255 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13256 change *STRICT_OVERFLOW_P. */
13259 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
13261 bool sub_strict_overflow_p
;
13262 switch (TREE_CODE (t
))
13265 return !integer_zerop (t
);
13269 tree base
= TREE_OPERAND (t
, 0);
13271 if (!DECL_P (base
))
13272 base
= get_base_address (base
);
13274 if (base
&& TREE_CODE (base
) == TARGET_EXPR
)
13275 base
= TARGET_EXPR_SLOT (base
);
13280 /* For objects in symbol table check if we know they are non-zero.
13281 Don't do anything for variables and functions before symtab is built;
13282 it is quite possible that they will be declared weak later. */
13283 int nonzero_addr
= maybe_nonzero_address (base
);
13284 if (nonzero_addr
>= 0)
13285 return nonzero_addr
;
13287 /* Constants are never weak. */
13288 if (CONSTANT_CLASS_P (base
))
13295 sub_strict_overflow_p
= false;
13296 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
13297 &sub_strict_overflow_p
)
13298 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
13299 &sub_strict_overflow_p
))
13301 if (sub_strict_overflow_p
)
13302 *strict_overflow_p
= true;
13313 #define integer_valued_real_p(X) \
13314 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
13316 #define RECURSE(X) \
13317 ((integer_valued_real_p) (X, depth + 1))
13319 /* Return true if the floating point result of (CODE OP0) has an
13320 integer value. We also allow +Inf, -Inf and NaN to be considered
13321 integer values. Return false for signaling NaN.
13323 DEPTH is the current nesting depth of the query. */
13326 integer_valued_real_unary_p (tree_code code
, tree op0
, int depth
)
13334 return RECURSE (op0
);
13338 tree type
= TREE_TYPE (op0
);
13339 if (TREE_CODE (type
) == INTEGER_TYPE
)
13341 if (TREE_CODE (type
) == REAL_TYPE
)
13342 return RECURSE (op0
);
13352 /* Return true if the floating point result of (CODE OP0 OP1) has an
13353 integer value. We also allow +Inf, -Inf and NaN to be considered
13354 integer values. Return false for signaling NaN.
13356 DEPTH is the current nesting depth of the query. */
13359 integer_valued_real_binary_p (tree_code code
, tree op0
, tree op1
, int depth
)
13368 return RECURSE (op0
) && RECURSE (op1
);
13376 /* Return true if the floating point result of calling FNDECL with arguments
13377 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13378 considered integer values. Return false for signaling NaN. If FNDECL
13379 takes fewer than 2 arguments, the remaining ARGn are null.
13381 DEPTH is the current nesting depth of the query. */
13384 integer_valued_real_call_p (combined_fn fn
, tree arg0
, tree arg1
, int depth
)
13390 CASE_CFN_NEARBYINT
:
13398 return RECURSE (arg0
) && RECURSE (arg1
);
13406 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13407 has an integer value. We also allow +Inf, -Inf and NaN to be
13408 considered integer values. Return false for signaling NaN.
13410 DEPTH is the current nesting depth of the query. */
13413 integer_valued_real_single_p (tree t
, int depth
)
13415 switch (TREE_CODE (t
))
13418 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
13421 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
13424 /* Limit the depth of recursion to avoid quadratic behavior.
13425 This is expected to catch almost all occurrences in practice.
13426 If this code misses important cases that unbounded recursion
13427 would not, passes that need this information could be revised
13428 to provide it through dataflow propagation. */
13429 return (!name_registered_for_update_p (t
)
13430 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
13431 && gimple_stmt_integer_valued_real_p (SSA_NAME_DEF_STMT (t
),
13440 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13441 has an integer value. We also allow +Inf, -Inf and NaN to be
13442 considered integer values. Return false for signaling NaN.
13444 DEPTH is the current nesting depth of the query. */
13447 integer_valued_real_invalid_p (tree t
, int depth
)
13449 switch (TREE_CODE (t
))
13451 case COMPOUND_EXPR
:
13454 return RECURSE (TREE_OPERAND (t
, 1));
13457 return RECURSE (TREE_OPERAND (t
, 0));
13466 #undef integer_valued_real_p
13468 /* Return true if the floating point expression T has an integer value.
13469 We also allow +Inf, -Inf and NaN to be considered integer values.
13470 Return false for signaling NaN.
13472 DEPTH is the current nesting depth of the query. */
13475 integer_valued_real_p (tree t
, int depth
)
13477 if (t
== error_mark_node
)
13480 tree_code code
= TREE_CODE (t
);
13481 switch (TREE_CODE_CLASS (code
))
13484 case tcc_comparison
:
13485 return integer_valued_real_binary_p (code
, TREE_OPERAND (t
, 0),
13486 TREE_OPERAND (t
, 1), depth
);
13489 return integer_valued_real_unary_p (code
, TREE_OPERAND (t
, 0), depth
);
13492 case tcc_declaration
:
13493 case tcc_reference
:
13494 return integer_valued_real_single_p (t
, depth
);
13504 return integer_valued_real_single_p (t
, depth
);
13508 tree arg0
= (call_expr_nargs (t
) > 0
13509 ? CALL_EXPR_ARG (t
, 0)
13511 tree arg1
= (call_expr_nargs (t
) > 1
13512 ? CALL_EXPR_ARG (t
, 1)
13514 return integer_valued_real_call_p (get_call_combined_fn (t
),
13515 arg0
, arg1
, depth
);
13519 return integer_valued_real_invalid_p (t
, depth
);
13523 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13524 attempt to fold the expression to a constant without modifying TYPE,
13527 If the expression could be simplified to a constant, then return
13528 the constant. If the expression would not be simplified to a
13529 constant, then return NULL_TREE. */
13532 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
13534 tree tem
= fold_binary (code
, type
, op0
, op1
);
13535 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13538 /* Given the components of a unary expression CODE, TYPE and OP0,
13539 attempt to fold the expression to a constant without modifying
13542 If the expression could be simplified to a constant, then return
13543 the constant. If the expression would not be simplified to a
13544 constant, then return NULL_TREE. */
13547 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
13549 tree tem
= fold_unary (code
, type
, op0
);
13550 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13553 /* If EXP represents referencing an element in a constant string
13554 (either via pointer arithmetic or array indexing), return the
13555 tree representing the value accessed, otherwise return NULL. */
13558 fold_read_from_constant_string (tree exp
)
13560 if ((TREE_CODE (exp
) == INDIRECT_REF
13561 || TREE_CODE (exp
) == ARRAY_REF
)
13562 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
13564 tree exp1
= TREE_OPERAND (exp
, 0);
13567 location_t loc
= EXPR_LOCATION (exp
);
13569 if (TREE_CODE (exp
) == INDIRECT_REF
)
13570 string
= string_constant (exp1
, &index
);
13573 tree low_bound
= array_ref_low_bound (exp
);
13574 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
13576 /* Optimize the special-case of a zero lower bound.
13578 We convert the low_bound to sizetype to avoid some problems
13579 with constant folding. (E.g. suppose the lower bound is 1,
13580 and its mode is QI. Without the conversion,l (ARRAY
13581 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13582 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13583 if (! integer_zerop (low_bound
))
13584 index
= size_diffop_loc (loc
, index
,
13585 fold_convert_loc (loc
, sizetype
, low_bound
));
13591 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
13592 && TREE_CODE (string
) == STRING_CST
13593 && TREE_CODE (index
) == INTEGER_CST
13594 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
13595 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))))
13597 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))) == 1))
13598 return build_int_cst_type (TREE_TYPE (exp
),
13599 (TREE_STRING_POINTER (string
)
13600 [TREE_INT_CST_LOW (index
)]));
13605 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13606 an integer constant, real, or fixed-point constant.
13608 TYPE is the type of the result. */
13611 fold_negate_const (tree arg0
, tree type
)
13613 tree t
= NULL_TREE
;
13615 switch (TREE_CODE (arg0
))
13620 wide_int val
= wi::neg (arg0
, &overflow
);
13621 t
= force_fit_type (type
, val
, 1,
13622 (overflow
| TREE_OVERFLOW (arg0
))
13623 && !TYPE_UNSIGNED (type
));
13628 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13633 FIXED_VALUE_TYPE f
;
13634 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
13635 &(TREE_FIXED_CST (arg0
)), NULL
,
13636 TYPE_SATURATING (type
));
13637 t
= build_fixed (type
, f
);
13638 /* Propagate overflow flags. */
13639 if (overflow_p
| TREE_OVERFLOW (arg0
))
13640 TREE_OVERFLOW (t
) = 1;
13645 gcc_unreachable ();
13651 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13652 an integer constant or real constant.
13654 TYPE is the type of the result. */
13657 fold_abs_const (tree arg0
, tree type
)
13659 tree t
= NULL_TREE
;
13661 switch (TREE_CODE (arg0
))
13665 /* If the value is unsigned or non-negative, then the absolute value
13666 is the same as the ordinary value. */
13667 if (!wi::neg_p (arg0
, TYPE_SIGN (type
)))
13670 /* If the value is negative, then the absolute value is
13675 wide_int val
= wi::neg (arg0
, &overflow
);
13676 t
= force_fit_type (type
, val
, -1,
13677 overflow
| TREE_OVERFLOW (arg0
));
13683 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
13684 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13690 gcc_unreachable ();
13696 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13697 constant. TYPE is the type of the result. */
13700 fold_not_const (const_tree arg0
, tree type
)
13702 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
13704 return force_fit_type (type
, wi::bit_not (arg0
), 0, TREE_OVERFLOW (arg0
));
13707 /* Given CODE, a relational operator, the target type, TYPE and two
13708 constant operands OP0 and OP1, return the result of the
13709 relational operation. If the result is not a compile time
13710 constant, then return NULL_TREE. */
13713 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
13715 int result
, invert
;
13717 /* From here on, the only cases we handle are when the result is
13718 known to be a constant. */
13720 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
13722 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
13723 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
13725 /* Handle the cases where either operand is a NaN. */
13726 if (real_isnan (c0
) || real_isnan (c1
))
13736 case UNORDERED_EXPR
:
13750 if (flag_trapping_math
)
13756 gcc_unreachable ();
13759 return constant_boolean_node (result
, type
);
13762 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
13765 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
13767 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
13768 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
13769 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
13772 /* Handle equality/inequality of complex constants. */
13773 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
13775 tree rcond
= fold_relational_const (code
, type
,
13776 TREE_REALPART (op0
),
13777 TREE_REALPART (op1
));
13778 tree icond
= fold_relational_const (code
, type
,
13779 TREE_IMAGPART (op0
),
13780 TREE_IMAGPART (op1
));
13781 if (code
== EQ_EXPR
)
13782 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
13783 else if (code
== NE_EXPR
)
13784 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
13789 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
13791 if (!VECTOR_TYPE_P (type
))
13793 /* Have vector comparison with scalar boolean result. */
13794 gcc_assert ((code
== EQ_EXPR
|| code
== NE_EXPR
)
13795 && VECTOR_CST_NELTS (op0
) == VECTOR_CST_NELTS (op1
));
13796 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (op0
); i
++)
13798 tree elem0
= VECTOR_CST_ELT (op0
, i
);
13799 tree elem1
= VECTOR_CST_ELT (op1
, i
);
13800 tree tmp
= fold_relational_const (code
, type
, elem0
, elem1
);
13801 if (tmp
== NULL_TREE
)
13803 if (integer_zerop (tmp
))
13804 return constant_boolean_node (false, type
);
13806 return constant_boolean_node (true, type
);
13808 unsigned count
= VECTOR_CST_NELTS (op0
);
13809 tree
*elts
= XALLOCAVEC (tree
, count
);
13810 gcc_assert (VECTOR_CST_NELTS (op1
) == count
13811 && TYPE_VECTOR_SUBPARTS (type
) == count
);
13813 for (unsigned i
= 0; i
< count
; i
++)
13815 tree elem_type
= TREE_TYPE (type
);
13816 tree elem0
= VECTOR_CST_ELT (op0
, i
);
13817 tree elem1
= VECTOR_CST_ELT (op1
, i
);
13819 tree tem
= fold_relational_const (code
, elem_type
,
13822 if (tem
== NULL_TREE
)
13825 elts
[i
] = build_int_cst (elem_type
, integer_zerop (tem
) ? 0 : -1);
13828 return build_vector (type
, elts
);
13831 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
13833 To compute GT, swap the arguments and do LT.
13834 To compute GE, do LT and invert the result.
13835 To compute LE, swap the arguments, do LT and invert the result.
13836 To compute NE, do EQ and invert the result.
13838 Therefore, the code below must handle only EQ and LT. */
13840 if (code
== LE_EXPR
|| code
== GT_EXPR
)
13842 std::swap (op0
, op1
);
13843 code
= swap_tree_comparison (code
);
13846 /* Note that it is safe to invert for real values here because we
13847 have already handled the one case that it matters. */
13850 if (code
== NE_EXPR
|| code
== GE_EXPR
)
13853 code
= invert_tree_comparison (code
, false);
13856 /* Compute a result for LT or EQ if args permit;
13857 Otherwise return T. */
13858 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
13860 if (code
== EQ_EXPR
)
13861 result
= tree_int_cst_equal (op0
, op1
);
13863 result
= tree_int_cst_lt (op0
, op1
);
13870 return constant_boolean_node (result
, type
);
13873 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
13874 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
13878 fold_build_cleanup_point_expr (tree type
, tree expr
)
13880 /* If the expression does not have side effects then we don't have to wrap
13881 it with a cleanup point expression. */
13882 if (!TREE_SIDE_EFFECTS (expr
))
13885 /* If the expression is a return, check to see if the expression inside the
13886 return has no side effects or the right hand side of the modify expression
13887 inside the return. If either don't have side effects set we don't need to
13888 wrap the expression in a cleanup point expression. Note we don't check the
13889 left hand side of the modify because it should always be a return decl. */
13890 if (TREE_CODE (expr
) == RETURN_EXPR
)
13892 tree op
= TREE_OPERAND (expr
, 0);
13893 if (!op
|| !TREE_SIDE_EFFECTS (op
))
13895 op
= TREE_OPERAND (op
, 1);
13896 if (!TREE_SIDE_EFFECTS (op
))
13900 return build1 (CLEANUP_POINT_EXPR
, type
, expr
);
13903 /* Given a pointer value OP0 and a type TYPE, return a simplified version
13904 of an indirection through OP0, or NULL_TREE if no simplification is
13908 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
13914 subtype
= TREE_TYPE (sub
);
13915 if (!POINTER_TYPE_P (subtype
))
13918 if (TREE_CODE (sub
) == ADDR_EXPR
)
13920 tree op
= TREE_OPERAND (sub
, 0);
13921 tree optype
= TREE_TYPE (op
);
13922 /* *&CONST_DECL -> to the value of the const decl. */
13923 if (TREE_CODE (op
) == CONST_DECL
)
13924 return DECL_INITIAL (op
);
13925 /* *&p => p; make sure to handle *&"str"[cst] here. */
13926 if (type
== optype
)
13928 tree fop
= fold_read_from_constant_string (op
);
13934 /* *(foo *)&fooarray => fooarray[0] */
13935 else if (TREE_CODE (optype
) == ARRAY_TYPE
13936 && type
== TREE_TYPE (optype
)
13937 && (!in_gimple_form
13938 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
13940 tree type_domain
= TYPE_DOMAIN (optype
);
13941 tree min_val
= size_zero_node
;
13942 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
13943 min_val
= TYPE_MIN_VALUE (type_domain
);
13945 && TREE_CODE (min_val
) != INTEGER_CST
)
13947 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
13948 NULL_TREE
, NULL_TREE
);
13950 /* *(foo *)&complexfoo => __real__ complexfoo */
13951 else if (TREE_CODE (optype
) == COMPLEX_TYPE
13952 && type
== TREE_TYPE (optype
))
13953 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
13954 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
13955 else if (TREE_CODE (optype
) == VECTOR_TYPE
13956 && type
== TREE_TYPE (optype
))
13958 tree part_width
= TYPE_SIZE (type
);
13959 tree index
= bitsize_int (0);
13960 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
13964 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
13965 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
13967 tree op00
= TREE_OPERAND (sub
, 0);
13968 tree op01
= TREE_OPERAND (sub
, 1);
13971 if (TREE_CODE (op00
) == ADDR_EXPR
)
13974 op00
= TREE_OPERAND (op00
, 0);
13975 op00type
= TREE_TYPE (op00
);
13977 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
13978 if (TREE_CODE (op00type
) == VECTOR_TYPE
13979 && type
== TREE_TYPE (op00type
))
13981 tree part_width
= TYPE_SIZE (type
);
13982 unsigned HOST_WIDE_INT max_offset
13983 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
13984 * TYPE_VECTOR_SUBPARTS (op00type
));
13985 if (tree_int_cst_sign_bit (op01
) == 0
13986 && compare_tree_int (op01
, max_offset
) == -1)
13988 unsigned HOST_WIDE_INT offset
= tree_to_uhwi (op01
);
13989 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
13990 tree index
= bitsize_int (indexi
);
13991 return fold_build3_loc (loc
,
13992 BIT_FIELD_REF
, type
, op00
,
13993 part_width
, index
);
13996 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
13997 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
13998 && type
== TREE_TYPE (op00type
))
14000 tree size
= TYPE_SIZE_UNIT (type
);
14001 if (tree_int_cst_equal (size
, op01
))
14002 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
14004 /* ((foo *)&fooarray)[1] => fooarray[1] */
14005 else if (TREE_CODE (op00type
) == ARRAY_TYPE
14006 && type
== TREE_TYPE (op00type
))
14008 tree type_domain
= TYPE_DOMAIN (op00type
);
14009 tree min_val
= size_zero_node
;
14010 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14011 min_val
= TYPE_MIN_VALUE (type_domain
);
14012 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
14013 TYPE_SIZE_UNIT (type
));
14014 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
14015 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
14016 NULL_TREE
, NULL_TREE
);
14021 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14022 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
14023 && type
== TREE_TYPE (TREE_TYPE (subtype
))
14024 && (!in_gimple_form
14025 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14028 tree min_val
= size_zero_node
;
14029 sub
= build_fold_indirect_ref_loc (loc
, sub
);
14030 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
14031 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14032 min_val
= TYPE_MIN_VALUE (type_domain
);
14034 && TREE_CODE (min_val
) != INTEGER_CST
)
14036 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
14043 /* Builds an expression for an indirection through T, simplifying some
14047 build_fold_indirect_ref_loc (location_t loc
, tree t
)
14049 tree type
= TREE_TYPE (TREE_TYPE (t
));
14050 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
14055 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
14058 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14061 fold_indirect_ref_loc (location_t loc
, tree t
)
14063 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
14071 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14072 whose result is ignored. The type of the returned tree need not be
14073 the same as the original expression. */
14076 fold_ignored_result (tree t
)
14078 if (!TREE_SIDE_EFFECTS (t
))
14079 return integer_zero_node
;
14082 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
14085 t
= TREE_OPERAND (t
, 0);
14089 case tcc_comparison
:
14090 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14091 t
= TREE_OPERAND (t
, 0);
14092 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
14093 t
= TREE_OPERAND (t
, 1);
14098 case tcc_expression
:
14099 switch (TREE_CODE (t
))
14101 case COMPOUND_EXPR
:
14102 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14104 t
= TREE_OPERAND (t
, 0);
14108 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
14109 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
14111 t
= TREE_OPERAND (t
, 0);
14124 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14127 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
14129 tree div
= NULL_TREE
;
14134 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14135 have to do anything. Only do this when we are not given a const,
14136 because in that case, this check is more expensive than just
14138 if (TREE_CODE (value
) != INTEGER_CST
)
14140 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14142 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14146 /* If divisor is a power of two, simplify this to bit manipulation. */
14147 if (pow2_or_zerop (divisor
))
14149 if (TREE_CODE (value
) == INTEGER_CST
)
14151 wide_int val
= value
;
14154 if ((val
& (divisor
- 1)) == 0)
14157 overflow_p
= TREE_OVERFLOW (value
);
14158 val
+= divisor
- 1;
14159 val
&= - (int) divisor
;
14163 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
14169 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
14170 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
14171 t
= build_int_cst (TREE_TYPE (value
), - (int) divisor
);
14172 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14178 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14179 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
14180 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14186 /* Likewise, but round down. */
14189 round_down_loc (location_t loc
, tree value
, int divisor
)
14191 tree div
= NULL_TREE
;
14193 gcc_assert (divisor
> 0);
14197 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14198 have to do anything. Only do this when we are not given a const,
14199 because in that case, this check is more expensive than just
14201 if (TREE_CODE (value
) != INTEGER_CST
)
14203 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14205 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14209 /* If divisor is a power of two, simplify this to bit manipulation. */
14210 if (pow2_or_zerop (divisor
))
14214 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
14215 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14220 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14221 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
14222 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14228 /* Returns the pointer to the base of the object addressed by EXP and
14229 extracts the information about the offset of the access, storing it
14230 to PBITPOS and POFFSET. */
14233 split_address_to_core_and_offset (tree exp
,
14234 HOST_WIDE_INT
*pbitpos
, tree
*poffset
)
14238 int unsignedp
, reversep
, volatilep
;
14239 HOST_WIDE_INT bitsize
;
14240 location_t loc
= EXPR_LOCATION (exp
);
14242 if (TREE_CODE (exp
) == ADDR_EXPR
)
14244 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
14245 poffset
, &mode
, &unsignedp
, &reversep
,
14247 core
= build_fold_addr_expr_loc (loc
, core
);
14253 *poffset
= NULL_TREE
;
14259 /* Returns true if addresses of E1 and E2 differ by a constant, false
14260 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14263 ptr_difference_const (tree e1
, tree e2
, HOST_WIDE_INT
*diff
)
14266 HOST_WIDE_INT bitpos1
, bitpos2
;
14267 tree toffset1
, toffset2
, tdiff
, type
;
14269 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
14270 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
14272 if (bitpos1
% BITS_PER_UNIT
!= 0
14273 || bitpos2
% BITS_PER_UNIT
!= 0
14274 || !operand_equal_p (core1
, core2
, 0))
14277 if (toffset1
&& toffset2
)
14279 type
= TREE_TYPE (toffset1
);
14280 if (type
!= TREE_TYPE (toffset2
))
14281 toffset2
= fold_convert (type
, toffset2
);
14283 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
14284 if (!cst_and_fits_in_hwi (tdiff
))
14287 *diff
= int_cst_value (tdiff
);
14289 else if (toffset1
|| toffset2
)
14291 /* If only one of the offsets is non-constant, the difference cannot
14298 *diff
+= (bitpos1
- bitpos2
) / BITS_PER_UNIT
;
14302 /* Return OFF converted to a pointer offset type suitable as offset for
14303 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14305 convert_to_ptrofftype_loc (location_t loc
, tree off
)
14307 return fold_convert_loc (loc
, sizetype
, off
);
14310 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14312 fold_build_pointer_plus_loc (location_t loc
, tree ptr
, tree off
)
14314 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14315 ptr
, convert_to_ptrofftype_loc (loc
, off
));
14318 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14320 fold_build_pointer_plus_hwi_loc (location_t loc
, tree ptr
, HOST_WIDE_INT off
)
14322 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14323 ptr
, size_int (off
));
14326 /* Return a char pointer for a C string if it is a string constant
14327 or sum of string constant and integer constant. We only support
14328 string constants properly terminated with '\0' character.
14329 If STRLEN is a valid pointer, length (including terminating character)
14330 of returned string is stored to the argument. */
14333 c_getstr (tree src
, unsigned HOST_WIDE_INT
*strlen
)
14340 src
= string_constant (src
, &offset_node
);
14344 unsigned HOST_WIDE_INT offset
= 0;
14345 if (offset_node
!= NULL_TREE
)
14347 if (!tree_fits_uhwi_p (offset_node
))
14350 offset
= tree_to_uhwi (offset_node
);
14353 unsigned HOST_WIDE_INT string_length
= TREE_STRING_LENGTH (src
);
14354 const char *string
= TREE_STRING_POINTER (src
);
14356 /* Support only properly null-terminated strings. */
14357 if (string_length
== 0
14358 || string
[string_length
- 1] != '\0'
14359 || offset
>= string_length
)
14363 *strlen
= string_length
- offset
;
14364 return string
+ offset
;
14369 namespace selftest
{
14371 /* Helper functions for writing tests of folding trees. */
14373 /* Verify that the binary op (LHS CODE RHS) folds to CONSTANT. */
14376 assert_binop_folds_to_const (tree lhs
, enum tree_code code
, tree rhs
,
14379 ASSERT_EQ (constant
, fold_build2 (code
, TREE_TYPE (lhs
), lhs
, rhs
));
14382 /* Verify that the binary op (LHS CODE RHS) folds to an NON_LVALUE_EXPR
14383 wrapping WRAPPED_EXPR. */
14386 assert_binop_folds_to_nonlvalue (tree lhs
, enum tree_code code
, tree rhs
,
14389 tree result
= fold_build2 (code
, TREE_TYPE (lhs
), lhs
, rhs
);
14390 ASSERT_NE (wrapped_expr
, result
);
14391 ASSERT_EQ (NON_LVALUE_EXPR
, TREE_CODE (result
));
14392 ASSERT_EQ (wrapped_expr
, TREE_OPERAND (result
, 0));
14395 /* Verify that various arithmetic binary operations are folded
14399 test_arithmetic_folding ()
14401 tree type
= integer_type_node
;
14402 tree x
= create_tmp_var_raw (type
, "x");
14403 tree zero
= build_zero_cst (type
);
14404 tree one
= build_int_cst (type
, 1);
14407 /* 1 <-- (0 + 1) */
14408 assert_binop_folds_to_const (zero
, PLUS_EXPR
, one
,
14410 assert_binop_folds_to_const (one
, PLUS_EXPR
, zero
,
14413 /* (nonlvalue)x <-- (x + 0) */
14414 assert_binop_folds_to_nonlvalue (x
, PLUS_EXPR
, zero
,
14418 /* 0 <-- (x - x) */
14419 assert_binop_folds_to_const (x
, MINUS_EXPR
, x
,
14421 assert_binop_folds_to_nonlvalue (x
, MINUS_EXPR
, zero
,
14424 /* Multiplication. */
14425 /* 0 <-- (x * 0) */
14426 assert_binop_folds_to_const (x
, MULT_EXPR
, zero
,
14429 /* (nonlvalue)x <-- (x * 1) */
14430 assert_binop_folds_to_nonlvalue (x
, MULT_EXPR
, one
,
14434 /* Verify that various binary operations on vectors are folded
14438 test_vector_folding ()
14440 tree inner_type
= integer_type_node
;
14441 tree type
= build_vector_type (inner_type
, 4);
14442 tree zero
= build_zero_cst (type
);
14443 tree one
= build_one_cst (type
);
14445 /* Verify equality tests that return a scalar boolean result. */
14446 tree res_type
= boolean_type_node
;
14447 ASSERT_FALSE (integer_nonzerop (fold_build2 (EQ_EXPR
, res_type
, zero
, one
)));
14448 ASSERT_TRUE (integer_nonzerop (fold_build2 (EQ_EXPR
, res_type
, zero
, zero
)));
14449 ASSERT_TRUE (integer_nonzerop (fold_build2 (NE_EXPR
, res_type
, zero
, one
)));
14450 ASSERT_FALSE (integer_nonzerop (fold_build2 (NE_EXPR
, res_type
, one
, one
)));
14453 /* Run all of the selftests within this file. */
14456 fold_const_c_tests ()
14458 test_arithmetic_folding ();
14459 test_vector_folding ();
14462 } // namespace selftest
14464 #endif /* CHECKING_P */