1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2018 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"
82 #include "stringpool.h"
84 #include "tree-vector-builder.h"
85 #include "vec-perm-indices.h"
87 /* Nonzero if we are folding constants inside an initializer; zero
89 int folding_initializer
= 0;
91 /* The following constants represent a bit based encoding of GCC's
92 comparison operators. This encoding simplifies transformations
93 on relational comparison operators, such as AND and OR. */
94 enum comparison_code
{
113 static bool negate_expr_p (tree
);
114 static tree
negate_expr (tree
);
115 static tree
associate_trees (location_t
, tree
, tree
, enum tree_code
, tree
);
116 static enum comparison_code
comparison_to_compcode (enum tree_code
);
117 static enum tree_code
compcode_to_comparison (enum comparison_code
);
118 static int twoval_comparison_p (tree
, tree
*, tree
*);
119 static tree
eval_subst (location_t
, tree
, tree
, tree
, tree
, tree
);
120 static tree
optimize_bit_field_compare (location_t
, enum tree_code
,
122 static int simple_operand_p (const_tree
);
123 static bool simple_operand_p_2 (tree
);
124 static tree
range_binop (enum tree_code
, tree
, tree
, int, tree
, int);
125 static tree
range_predecessor (tree
);
126 static tree
range_successor (tree
);
127 static tree
fold_range_test (location_t
, enum tree_code
, tree
, tree
, tree
);
128 static tree
fold_cond_expr_with_comparison (location_t
, tree
, tree
, tree
, tree
);
129 static tree
unextend (tree
, int, int, tree
);
130 static tree
extract_muldiv (tree
, tree
, enum tree_code
, tree
, bool *);
131 static tree
extract_muldiv_1 (tree
, tree
, enum tree_code
, tree
, bool *);
132 static tree
fold_binary_op_with_conditional_arg (location_t
,
133 enum tree_code
, 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 tree
fold_negate_expr (location_t
, 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 (wi::to_wide (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_UNSIGNED (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 /* Steps don't prevent negation. */
415 unsigned int count
= vector_cst_encoded_nelts (t
);
416 for (unsigned int i
= 0; i
< count
; ++i
)
417 if (!negate_expr_p (VECTOR_CST_ENCODED_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 || (ANY_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 && (! ANY_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
458 (wi::abs (wi::to_wide (TREE_OPERAND (t
, 0))))) != 1)
459 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
461 (wi::abs (wi::to_wide (TREE_OPERAND (t
, 1))))) != 1)))
467 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (TREE_TYPE (t
))))
468 return negate_expr_p (TREE_OPERAND (t
, 1))
469 || negate_expr_p (TREE_OPERAND (t
, 0));
475 if (TYPE_UNSIGNED (type
))
477 /* In general we can't negate A in A / B, because if A is INT_MIN and
478 B is not 1 we change the sign of the result. */
479 if (TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
480 && negate_expr_p (TREE_OPERAND (t
, 0)))
482 /* In general we can't negate B in A / B, because if A is INT_MIN and
483 B is 1, we may turn this into INT_MIN / -1 which is undefined
484 and actually traps on some architectures. */
485 if (! ANY_INTEGRAL_TYPE_P (TREE_TYPE (t
))
486 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
487 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
488 && ! integer_onep (TREE_OPERAND (t
, 1))))
489 return negate_expr_p (TREE_OPERAND (t
, 1));
493 /* Negate -((double)float) as (double)(-float). */
494 if (TREE_CODE (type
) == REAL_TYPE
)
496 tree tem
= strip_float_extensions (t
);
498 return negate_expr_p (tem
);
503 /* Negate -f(x) as f(-x). */
504 if (negate_mathfn_p (get_call_combined_fn (t
)))
505 return negate_expr_p (CALL_EXPR_ARG (t
, 0));
509 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
510 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
512 tree op1
= TREE_OPERAND (t
, 1);
513 if (wi::to_wide (op1
) == TYPE_PRECISION (type
) - 1)
524 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
525 simplification is possible.
526 If negate_expr_p would return true for T, NULL_TREE will never be
530 fold_negate_expr_1 (location_t loc
, tree t
)
532 tree type
= TREE_TYPE (t
);
535 switch (TREE_CODE (t
))
537 /* Convert - (~A) to A + 1. */
539 if (INTEGRAL_TYPE_P (type
))
540 return fold_build2_loc (loc
, PLUS_EXPR
, type
, TREE_OPERAND (t
, 0),
541 build_one_cst (type
));
545 tem
= fold_negate_const (t
, type
);
546 if (TREE_OVERFLOW (tem
) == TREE_OVERFLOW (t
)
547 || (ANY_INTEGRAL_TYPE_P (type
)
548 && !TYPE_OVERFLOW_TRAPS (type
)
549 && TYPE_OVERFLOW_WRAPS (type
))
550 || (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
557 tem
= fold_negate_const (t
, type
);
562 tree rpart
= fold_negate_expr (loc
, TREE_REALPART (t
));
563 tree ipart
= fold_negate_expr (loc
, TREE_IMAGPART (t
));
565 return build_complex (type
, rpart
, ipart
);
571 tree_vector_builder elts
;
572 elts
.new_unary_operation (type
, t
, true);
573 unsigned int count
= elts
.encoded_nelts ();
574 for (unsigned int i
= 0; i
< count
; ++i
)
576 tree elt
= fold_negate_expr (loc
, VECTOR_CST_ELT (t
, i
));
577 if (elt
== NULL_TREE
)
579 elts
.quick_push (elt
);
582 return elts
.build ();
586 if (negate_expr_p (t
))
587 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
588 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)),
589 fold_negate_expr (loc
, TREE_OPERAND (t
, 1)));
593 if (negate_expr_p (t
))
594 return fold_build1_loc (loc
, CONJ_EXPR
, type
,
595 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)));
599 if (!TYPE_OVERFLOW_SANITIZED (type
))
600 return TREE_OPERAND (t
, 0);
604 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
605 && !HONOR_SIGNED_ZEROS (element_mode (type
)))
607 /* -(A + B) -> (-B) - A. */
608 if (negate_expr_p (TREE_OPERAND (t
, 1)))
610 tem
= negate_expr (TREE_OPERAND (t
, 1));
611 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
612 tem
, TREE_OPERAND (t
, 0));
615 /* -(A + B) -> (-A) - B. */
616 if (negate_expr_p (TREE_OPERAND (t
, 0)))
618 tem
= negate_expr (TREE_OPERAND (t
, 0));
619 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
620 tem
, TREE_OPERAND (t
, 1));
626 /* - (A - B) -> B - A */
627 if (!HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
))
628 && !HONOR_SIGNED_ZEROS (element_mode (type
)))
629 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
630 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 0));
634 if (TYPE_UNSIGNED (type
))
640 if (! HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
)))
642 tem
= TREE_OPERAND (t
, 1);
643 if (negate_expr_p (tem
))
644 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
645 TREE_OPERAND (t
, 0), negate_expr (tem
));
646 tem
= TREE_OPERAND (t
, 0);
647 if (negate_expr_p (tem
))
648 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
649 negate_expr (tem
), TREE_OPERAND (t
, 1));
656 if (TYPE_UNSIGNED (type
))
658 /* In general we can't negate A in A / B, because if A is INT_MIN and
659 B is not 1 we change the sign of the result. */
660 if (TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
661 && negate_expr_p (TREE_OPERAND (t
, 0)))
662 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
663 negate_expr (TREE_OPERAND (t
, 0)),
664 TREE_OPERAND (t
, 1));
665 /* In general we can't negate B in A / B, because if A is INT_MIN and
666 B is 1, we may turn this into INT_MIN / -1 which is undefined
667 and actually traps on some architectures. */
668 if ((! ANY_INTEGRAL_TYPE_P (TREE_TYPE (t
))
669 || TYPE_OVERFLOW_WRAPS (TREE_TYPE (t
))
670 || (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
671 && ! integer_onep (TREE_OPERAND (t
, 1))))
672 && negate_expr_p (TREE_OPERAND (t
, 1)))
673 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
675 negate_expr (TREE_OPERAND (t
, 1)));
679 /* Convert -((double)float) into (double)(-float). */
680 if (TREE_CODE (type
) == REAL_TYPE
)
682 tem
= strip_float_extensions (t
);
683 if (tem
!= t
&& negate_expr_p (tem
))
684 return fold_convert_loc (loc
, type
, negate_expr (tem
));
689 /* Negate -f(x) as f(-x). */
690 if (negate_mathfn_p (get_call_combined_fn (t
))
691 && negate_expr_p (CALL_EXPR_ARG (t
, 0)))
695 fndecl
= get_callee_fndecl (t
);
696 arg
= negate_expr (CALL_EXPR_ARG (t
, 0));
697 return build_call_expr_loc (loc
, fndecl
, 1, arg
);
702 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
703 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
705 tree op1
= TREE_OPERAND (t
, 1);
706 if (wi::to_wide (op1
) == TYPE_PRECISION (type
) - 1)
708 tree ntype
= TYPE_UNSIGNED (type
)
709 ? signed_type_for (type
)
710 : unsigned_type_for (type
);
711 tree temp
= fold_convert_loc (loc
, ntype
, TREE_OPERAND (t
, 0));
712 temp
= fold_build2_loc (loc
, RSHIFT_EXPR
, ntype
, temp
, op1
);
713 return fold_convert_loc (loc
, type
, temp
);
725 /* A wrapper for fold_negate_expr_1. */
728 fold_negate_expr (location_t loc
, tree t
)
730 tree type
= TREE_TYPE (t
);
732 tree tem
= fold_negate_expr_1 (loc
, t
);
733 if (tem
== NULL_TREE
)
735 return fold_convert_loc (loc
, type
, tem
);
738 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
739 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
751 loc
= EXPR_LOCATION (t
);
752 type
= TREE_TYPE (t
);
755 tem
= fold_negate_expr (loc
, t
);
757 tem
= build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
758 return fold_convert_loc (loc
, type
, tem
);
761 /* Split a tree IN into a constant, literal and variable parts that could be
762 combined with CODE to make IN. "constant" means an expression with
763 TREE_CONSTANT but that isn't an actual constant. CODE must be a
764 commutative arithmetic operation. Store the constant part into *CONP,
765 the literal in *LITP and return the variable part. If a part isn't
766 present, set it to null. If the tree does not decompose in this way,
767 return the entire tree as the variable part and the other parts as null.
769 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
770 case, we negate an operand that was subtracted. Except if it is a
771 literal for which we use *MINUS_LITP instead.
773 If NEGATE_P is true, we are negating all of IN, again except a literal
774 for which we use *MINUS_LITP instead. If a variable part is of pointer
775 type, it is negated after converting to TYPE. This prevents us from
776 generating illegal MINUS pointer expression. LOC is the location of
777 the converted variable part.
779 If IN is itself a literal or constant, return it as appropriate.
781 Note that we do not guarantee that any of the three values will be the
782 same type as IN, but they will have the same signedness and mode. */
785 split_tree (tree in
, tree type
, enum tree_code code
,
786 tree
*minus_varp
, tree
*conp
, tree
*minus_conp
,
787 tree
*litp
, tree
*minus_litp
, int negate_p
)
796 /* Strip any conversions that don't change the machine mode or signedness. */
797 STRIP_SIGN_NOPS (in
);
799 if (TREE_CODE (in
) == INTEGER_CST
|| TREE_CODE (in
) == REAL_CST
800 || TREE_CODE (in
) == FIXED_CST
)
802 else if (TREE_CODE (in
) == code
803 || ((! FLOAT_TYPE_P (TREE_TYPE (in
)) || flag_associative_math
)
804 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in
))
805 /* We can associate addition and subtraction together (even
806 though the C standard doesn't say so) for integers because
807 the value is not affected. For reals, the value might be
808 affected, so we can't. */
809 && ((code
== PLUS_EXPR
&& TREE_CODE (in
) == POINTER_PLUS_EXPR
)
810 || (code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
811 || (code
== MINUS_EXPR
812 && (TREE_CODE (in
) == PLUS_EXPR
813 || TREE_CODE (in
) == POINTER_PLUS_EXPR
)))))
815 tree op0
= TREE_OPERAND (in
, 0);
816 tree op1
= TREE_OPERAND (in
, 1);
817 int neg1_p
= TREE_CODE (in
) == MINUS_EXPR
;
818 int neg_litp_p
= 0, neg_conp_p
= 0, neg_var_p
= 0;
820 /* First see if either of the operands is a literal, then a constant. */
821 if (TREE_CODE (op0
) == INTEGER_CST
|| TREE_CODE (op0
) == REAL_CST
822 || TREE_CODE (op0
) == FIXED_CST
)
823 *litp
= op0
, op0
= 0;
824 else if (TREE_CODE (op1
) == INTEGER_CST
|| TREE_CODE (op1
) == REAL_CST
825 || TREE_CODE (op1
) == FIXED_CST
)
826 *litp
= op1
, neg_litp_p
= neg1_p
, op1
= 0;
828 if (op0
!= 0 && TREE_CONSTANT (op0
))
829 *conp
= op0
, op0
= 0;
830 else if (op1
!= 0 && TREE_CONSTANT (op1
))
831 *conp
= op1
, neg_conp_p
= neg1_p
, op1
= 0;
833 /* If we haven't dealt with either operand, this is not a case we can
834 decompose. Otherwise, VAR is either of the ones remaining, if any. */
835 if (op0
!= 0 && op1
!= 0)
840 var
= op1
, neg_var_p
= neg1_p
;
842 /* Now do any needed negations. */
844 *minus_litp
= *litp
, *litp
= 0;
845 if (neg_conp_p
&& *conp
)
846 *minus_conp
= *conp
, *conp
= 0;
847 if (neg_var_p
&& var
)
848 *minus_varp
= var
, var
= 0;
850 else if (TREE_CONSTANT (in
))
852 else if (TREE_CODE (in
) == BIT_NOT_EXPR
853 && code
== PLUS_EXPR
)
855 /* -1 - X is folded to ~X, undo that here. Do _not_ do this
856 when IN is constant. */
857 *litp
= build_minus_one_cst (type
);
858 *minus_varp
= TREE_OPERAND (in
, 0);
866 *minus_litp
= *litp
, *litp
= 0;
867 else if (*minus_litp
)
868 *litp
= *minus_litp
, *minus_litp
= 0;
870 *minus_conp
= *conp
, *conp
= 0;
871 else if (*minus_conp
)
872 *conp
= *minus_conp
, *minus_conp
= 0;
874 *minus_varp
= var
, var
= 0;
875 else if (*minus_varp
)
876 var
= *minus_varp
, *minus_varp
= 0;
880 && TREE_OVERFLOW_P (*litp
))
881 *litp
= drop_tree_overflow (*litp
);
883 && TREE_OVERFLOW_P (*minus_litp
))
884 *minus_litp
= drop_tree_overflow (*minus_litp
);
889 /* Re-associate trees split by the above function. T1 and T2 are
890 either expressions to associate or null. Return the new
891 expression, if any. LOC is the location of the new expression. If
892 we build an operation, do it in TYPE and with CODE. */
895 associate_trees (location_t loc
, tree t1
, tree t2
, enum tree_code code
, tree type
)
899 gcc_assert (t2
== 0 || code
!= MINUS_EXPR
);
905 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
906 try to fold this since we will have infinite recursion. But do
907 deal with any NEGATE_EXPRs. */
908 if (TREE_CODE (t1
) == code
|| TREE_CODE (t2
) == code
909 || TREE_CODE (t1
) == PLUS_EXPR
|| TREE_CODE (t2
) == PLUS_EXPR
910 || TREE_CODE (t1
) == MINUS_EXPR
|| TREE_CODE (t2
) == MINUS_EXPR
)
912 if (code
== PLUS_EXPR
)
914 if (TREE_CODE (t1
) == NEGATE_EXPR
)
915 return build2_loc (loc
, MINUS_EXPR
, type
,
916 fold_convert_loc (loc
, type
, t2
),
917 fold_convert_loc (loc
, type
,
918 TREE_OPERAND (t1
, 0)));
919 else if (TREE_CODE (t2
) == NEGATE_EXPR
)
920 return build2_loc (loc
, MINUS_EXPR
, type
,
921 fold_convert_loc (loc
, type
, t1
),
922 fold_convert_loc (loc
, type
,
923 TREE_OPERAND (t2
, 0)));
924 else if (integer_zerop (t2
))
925 return fold_convert_loc (loc
, type
, t1
);
927 else if (code
== MINUS_EXPR
)
929 if (integer_zerop (t2
))
930 return fold_convert_loc (loc
, type
, t1
);
933 return build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
934 fold_convert_loc (loc
, type
, t2
));
937 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
938 fold_convert_loc (loc
, type
, t2
));
941 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
942 for use in int_const_binop, size_binop and size_diffop. */
945 int_binop_types_match_p (enum tree_code code
, const_tree type1
, const_tree type2
)
947 if (!INTEGRAL_TYPE_P (type1
) && !POINTER_TYPE_P (type1
))
949 if (!INTEGRAL_TYPE_P (type2
) && !POINTER_TYPE_P (type2
))
964 return TYPE_UNSIGNED (type1
) == TYPE_UNSIGNED (type2
)
965 && TYPE_PRECISION (type1
) == TYPE_PRECISION (type2
)
966 && TYPE_MODE (type1
) == TYPE_MODE (type2
);
969 /* Subroutine of int_const_binop_1 that handles two INTEGER_CSTs. */
972 int_const_binop_2 (enum tree_code code
, const_tree parg1
, const_tree parg2
,
977 tree type
= TREE_TYPE (parg1
);
978 signop sign
= TYPE_SIGN (type
);
979 bool overflow
= false;
981 wi::tree_to_wide_ref arg1
= wi::to_wide (parg1
);
982 wide_int arg2
= wi::to_wide (parg2
, TYPE_PRECISION (type
));
987 res
= wi::bit_or (arg1
, arg2
);
991 res
= wi::bit_xor (arg1
, arg2
);
995 res
= wi::bit_and (arg1
, arg2
);
1000 if (wi::neg_p (arg2
))
1003 if (code
== RSHIFT_EXPR
)
1009 if (code
== RSHIFT_EXPR
)
1010 /* It's unclear from the C standard whether shifts can overflow.
1011 The following code ignores overflow; perhaps a C standard
1012 interpretation ruling is needed. */
1013 res
= wi::rshift (arg1
, arg2
, sign
);
1015 res
= wi::lshift (arg1
, arg2
);
1020 if (wi::neg_p (arg2
))
1023 if (code
== RROTATE_EXPR
)
1024 code
= LROTATE_EXPR
;
1026 code
= RROTATE_EXPR
;
1029 if (code
== RROTATE_EXPR
)
1030 res
= wi::rrotate (arg1
, arg2
);
1032 res
= wi::lrotate (arg1
, arg2
);
1036 res
= wi::add (arg1
, arg2
, sign
, &overflow
);
1040 res
= wi::sub (arg1
, arg2
, sign
, &overflow
);
1044 res
= wi::mul (arg1
, arg2
, sign
, &overflow
);
1047 case MULT_HIGHPART_EXPR
:
1048 res
= wi::mul_high (arg1
, arg2
, sign
);
1051 case TRUNC_DIV_EXPR
:
1052 case EXACT_DIV_EXPR
:
1055 res
= wi::div_trunc (arg1
, arg2
, sign
, &overflow
);
1058 case FLOOR_DIV_EXPR
:
1061 res
= wi::div_floor (arg1
, arg2
, sign
, &overflow
);
1067 res
= wi::div_ceil (arg1
, arg2
, sign
, &overflow
);
1070 case ROUND_DIV_EXPR
:
1073 res
= wi::div_round (arg1
, arg2
, sign
, &overflow
);
1076 case TRUNC_MOD_EXPR
:
1079 res
= wi::mod_trunc (arg1
, arg2
, sign
, &overflow
);
1082 case FLOOR_MOD_EXPR
:
1085 res
= wi::mod_floor (arg1
, arg2
, sign
, &overflow
);
1091 res
= wi::mod_ceil (arg1
, arg2
, sign
, &overflow
);
1094 case ROUND_MOD_EXPR
:
1097 res
= wi::mod_round (arg1
, arg2
, sign
, &overflow
);
1101 res
= wi::min (arg1
, arg2
, sign
);
1105 res
= wi::max (arg1
, arg2
, sign
);
1112 t
= force_fit_type (type
, res
, overflowable
,
1113 (((sign
== SIGNED
|| overflowable
== -1)
1115 | TREE_OVERFLOW (parg1
) | TREE_OVERFLOW (parg2
)));
1120 /* Combine two integer constants PARG1 and PARG2 under operation CODE
1121 to produce a new constant. Return NULL_TREE if we don't know how
1122 to evaluate CODE at compile-time. */
1125 int_const_binop_1 (enum tree_code code
, const_tree arg1
, const_tree arg2
,
1128 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg2
) == INTEGER_CST
)
1129 return int_const_binop_2 (code
, arg1
, arg2
, overflowable
);
1131 gcc_assert (NUM_POLY_INT_COEFFS
!= 1);
1133 if (poly_int_tree_p (arg1
) && poly_int_tree_p (arg2
))
1137 tree type
= TREE_TYPE (arg1
);
1138 signop sign
= TYPE_SIGN (type
);
1142 res
= wi::add (wi::to_poly_wide (arg1
),
1143 wi::to_poly_wide (arg2
), sign
, &overflow
);
1147 res
= wi::sub (wi::to_poly_wide (arg1
),
1148 wi::to_poly_wide (arg2
), sign
, &overflow
);
1152 if (TREE_CODE (arg2
) == INTEGER_CST
)
1153 res
= wi::mul (wi::to_poly_wide (arg1
),
1154 wi::to_wide (arg2
), sign
, &overflow
);
1155 else if (TREE_CODE (arg1
) == INTEGER_CST
)
1156 res
= wi::mul (wi::to_poly_wide (arg2
),
1157 wi::to_wide (arg1
), sign
, &overflow
);
1163 if (TREE_CODE (arg2
) == INTEGER_CST
)
1164 res
= wi::to_poly_wide (arg1
) << wi::to_wide (arg2
);
1170 if (TREE_CODE (arg2
) != INTEGER_CST
1171 || !can_ior_p (wi::to_poly_wide (arg1
), wi::to_wide (arg2
),
1179 return force_fit_type (type
, res
, overflowable
,
1180 (((sign
== SIGNED
|| overflowable
== -1)
1182 | TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
)));
1189 int_const_binop (enum tree_code code
, const_tree arg1
, const_tree arg2
)
1191 return int_const_binop_1 (code
, arg1
, arg2
, 1);
1194 /* Return true if binary operation OP distributes over addition in operand
1195 OPNO, with the other operand being held constant. OPNO counts from 1. */
1198 distributes_over_addition_p (tree_code op
, int opno
)
1215 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1216 constant. We assume ARG1 and ARG2 have the same data type, or at least
1217 are the same kind of constant and the same machine mode. Return zero if
1218 combining the constants is not allowed in the current operating mode. */
1221 const_binop (enum tree_code code
, tree arg1
, tree arg2
)
1223 /* Sanity check for the recursive cases. */
1230 if (poly_int_tree_p (arg1
) && poly_int_tree_p (arg2
))
1232 if (code
== POINTER_PLUS_EXPR
)
1233 return int_const_binop (PLUS_EXPR
,
1234 arg1
, fold_convert (TREE_TYPE (arg1
), arg2
));
1236 return int_const_binop (code
, arg1
, arg2
);
1239 if (TREE_CODE (arg1
) == REAL_CST
&& TREE_CODE (arg2
) == REAL_CST
)
1244 REAL_VALUE_TYPE value
;
1245 REAL_VALUE_TYPE result
;
1249 /* The following codes are handled by real_arithmetic. */
1264 d1
= TREE_REAL_CST (arg1
);
1265 d2
= TREE_REAL_CST (arg2
);
1267 type
= TREE_TYPE (arg1
);
1268 mode
= TYPE_MODE (type
);
1270 /* Don't perform operation if we honor signaling NaNs and
1271 either operand is a signaling NaN. */
1272 if (HONOR_SNANS (mode
)
1273 && (REAL_VALUE_ISSIGNALING_NAN (d1
)
1274 || REAL_VALUE_ISSIGNALING_NAN (d2
)))
1277 /* Don't perform operation if it would raise a division
1278 by zero exception. */
1279 if (code
== RDIV_EXPR
1280 && real_equal (&d2
, &dconst0
)
1281 && (flag_trapping_math
|| ! MODE_HAS_INFINITIES (mode
)))
1284 /* If either operand is a NaN, just return it. Otherwise, set up
1285 for floating-point trap; we return an overflow. */
1286 if (REAL_VALUE_ISNAN (d1
))
1288 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1291 t
= build_real (type
, d1
);
1294 else if (REAL_VALUE_ISNAN (d2
))
1296 /* Make resulting NaN value to be qNaN when flag_signaling_nans
1299 t
= build_real (type
, d2
);
1303 inexact
= real_arithmetic (&value
, code
, &d1
, &d2
);
1304 real_convert (&result
, mode
, &value
);
1306 /* Don't constant fold this floating point operation if
1307 the result has overflowed and flag_trapping_math. */
1308 if (flag_trapping_math
1309 && MODE_HAS_INFINITIES (mode
)
1310 && REAL_VALUE_ISINF (result
)
1311 && !REAL_VALUE_ISINF (d1
)
1312 && !REAL_VALUE_ISINF (d2
))
1315 /* Don't constant fold this floating point operation if the
1316 result may dependent upon the run-time rounding mode and
1317 flag_rounding_math is set, or if GCC's software emulation
1318 is unable to accurately represent the result. */
1319 if ((flag_rounding_math
1320 || (MODE_COMPOSITE_P (mode
) && !flag_unsafe_math_optimizations
))
1321 && (inexact
|| !real_identical (&result
, &value
)))
1324 t
= build_real (type
, result
);
1326 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
);
1330 if (TREE_CODE (arg1
) == FIXED_CST
)
1332 FIXED_VALUE_TYPE f1
;
1333 FIXED_VALUE_TYPE f2
;
1334 FIXED_VALUE_TYPE result
;
1339 /* The following codes are handled by fixed_arithmetic. */
1345 case TRUNC_DIV_EXPR
:
1346 if (TREE_CODE (arg2
) != FIXED_CST
)
1348 f2
= TREE_FIXED_CST (arg2
);
1354 if (TREE_CODE (arg2
) != INTEGER_CST
)
1356 wi::tree_to_wide_ref w2
= wi::to_wide (arg2
);
1357 f2
.data
.high
= w2
.elt (1);
1358 f2
.data
.low
= w2
.ulow ();
1367 f1
= TREE_FIXED_CST (arg1
);
1368 type
= TREE_TYPE (arg1
);
1369 sat_p
= TYPE_SATURATING (type
);
1370 overflow_p
= fixed_arithmetic (&result
, code
, &f1
, &f2
, sat_p
);
1371 t
= build_fixed (type
, result
);
1372 /* Propagate overflow flags. */
1373 if (overflow_p
| TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
))
1374 TREE_OVERFLOW (t
) = 1;
1378 if (TREE_CODE (arg1
) == COMPLEX_CST
&& TREE_CODE (arg2
) == COMPLEX_CST
)
1380 tree type
= TREE_TYPE (arg1
);
1381 tree r1
= TREE_REALPART (arg1
);
1382 tree i1
= TREE_IMAGPART (arg1
);
1383 tree r2
= TREE_REALPART (arg2
);
1384 tree i2
= TREE_IMAGPART (arg2
);
1391 real
= const_binop (code
, r1
, r2
);
1392 imag
= const_binop (code
, i1
, i2
);
1396 if (COMPLEX_FLOAT_TYPE_P (type
))
1397 return do_mpc_arg2 (arg1
, arg2
, type
,
1398 /* do_nonfinite= */ folding_initializer
,
1401 real
= const_binop (MINUS_EXPR
,
1402 const_binop (MULT_EXPR
, r1
, r2
),
1403 const_binop (MULT_EXPR
, i1
, i2
));
1404 imag
= const_binop (PLUS_EXPR
,
1405 const_binop (MULT_EXPR
, r1
, i2
),
1406 const_binop (MULT_EXPR
, i1
, r2
));
1410 if (COMPLEX_FLOAT_TYPE_P (type
))
1411 return do_mpc_arg2 (arg1
, arg2
, type
,
1412 /* do_nonfinite= */ folding_initializer
,
1415 case TRUNC_DIV_EXPR
:
1417 case FLOOR_DIV_EXPR
:
1418 case ROUND_DIV_EXPR
:
1419 if (flag_complex_method
== 0)
1421 /* Keep this algorithm in sync with
1422 tree-complex.c:expand_complex_div_straight().
1424 Expand complex division to scalars, straightforward algorithm.
1425 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1429 = const_binop (PLUS_EXPR
,
1430 const_binop (MULT_EXPR
, r2
, r2
),
1431 const_binop (MULT_EXPR
, i2
, i2
));
1433 = const_binop (PLUS_EXPR
,
1434 const_binop (MULT_EXPR
, r1
, r2
),
1435 const_binop (MULT_EXPR
, i1
, i2
));
1437 = const_binop (MINUS_EXPR
,
1438 const_binop (MULT_EXPR
, i1
, r2
),
1439 const_binop (MULT_EXPR
, r1
, i2
));
1441 real
= const_binop (code
, t1
, magsquared
);
1442 imag
= const_binop (code
, t2
, magsquared
);
1446 /* Keep this algorithm in sync with
1447 tree-complex.c:expand_complex_div_wide().
1449 Expand complex division to scalars, modified algorithm to minimize
1450 overflow with wide input ranges. */
1451 tree compare
= fold_build2 (LT_EXPR
, boolean_type_node
,
1452 fold_abs_const (r2
, TREE_TYPE (type
)),
1453 fold_abs_const (i2
, TREE_TYPE (type
)));
1455 if (integer_nonzerop (compare
))
1457 /* In the TRUE branch, we compute
1459 div = (br * ratio) + bi;
1460 tr = (ar * ratio) + ai;
1461 ti = (ai * ratio) - ar;
1464 tree ratio
= const_binop (code
, r2
, i2
);
1465 tree div
= const_binop (PLUS_EXPR
, i2
,
1466 const_binop (MULT_EXPR
, r2
, ratio
));
1467 real
= const_binop (MULT_EXPR
, r1
, ratio
);
1468 real
= const_binop (PLUS_EXPR
, real
, i1
);
1469 real
= const_binop (code
, real
, div
);
1471 imag
= const_binop (MULT_EXPR
, i1
, ratio
);
1472 imag
= const_binop (MINUS_EXPR
, imag
, r1
);
1473 imag
= const_binop (code
, imag
, div
);
1477 /* In the FALSE branch, we compute
1479 divisor = (d * ratio) + c;
1480 tr = (b * ratio) + a;
1481 ti = b - (a * ratio);
1484 tree ratio
= const_binop (code
, i2
, r2
);
1485 tree div
= const_binop (PLUS_EXPR
, r2
,
1486 const_binop (MULT_EXPR
, i2
, ratio
));
1488 real
= const_binop (MULT_EXPR
, i1
, ratio
);
1489 real
= const_binop (PLUS_EXPR
, real
, r1
);
1490 real
= const_binop (code
, real
, div
);
1492 imag
= const_binop (MULT_EXPR
, r1
, ratio
);
1493 imag
= const_binop (MINUS_EXPR
, i1
, imag
);
1494 imag
= const_binop (code
, imag
, div
);
1504 return build_complex (type
, real
, imag
);
1507 if (TREE_CODE (arg1
) == VECTOR_CST
1508 && TREE_CODE (arg2
) == VECTOR_CST
1509 && known_eq (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)),
1510 TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg2
))))
1512 tree type
= TREE_TYPE (arg1
);
1514 if (VECTOR_CST_STEPPED_P (arg1
)
1515 && VECTOR_CST_STEPPED_P (arg2
))
1516 /* We can operate directly on the encoding if:
1518 a3 - a2 == a2 - a1 && b3 - b2 == b2 - b1
1520 (a3 op b3) - (a2 op b2) == (a2 op b2) - (a1 op b1)
1522 Addition and subtraction are the supported operators
1523 for which this is true. */
1524 step_ok_p
= (code
== PLUS_EXPR
|| code
== MINUS_EXPR
);
1525 else if (VECTOR_CST_STEPPED_P (arg1
))
1526 /* We can operate directly on stepped encodings if:
1530 (a3 op c) - (a2 op c) == (a2 op c) - (a1 op c)
1532 which is true if (x -> x op c) distributes over addition. */
1533 step_ok_p
= distributes_over_addition_p (code
, 1);
1535 /* Similarly in reverse. */
1536 step_ok_p
= distributes_over_addition_p (code
, 2);
1537 tree_vector_builder elts
;
1538 if (!elts
.new_binary_operation (type
, arg1
, arg2
, step_ok_p
))
1540 unsigned int count
= elts
.encoded_nelts ();
1541 for (unsigned int i
= 0; i
< count
; ++i
)
1543 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1544 tree elem2
= VECTOR_CST_ELT (arg2
, i
);
1546 tree elt
= const_binop (code
, elem1
, elem2
);
1548 /* It is possible that const_binop cannot handle the given
1549 code and return NULL_TREE */
1550 if (elt
== NULL_TREE
)
1552 elts
.quick_push (elt
);
1555 return elts
.build ();
1558 /* Shifts allow a scalar offset for a vector. */
1559 if (TREE_CODE (arg1
) == VECTOR_CST
1560 && TREE_CODE (arg2
) == INTEGER_CST
)
1562 tree type
= TREE_TYPE (arg1
);
1563 bool step_ok_p
= distributes_over_addition_p (code
, 1);
1564 tree_vector_builder elts
;
1565 if (!elts
.new_unary_operation (type
, arg1
, step_ok_p
))
1567 unsigned int count
= elts
.encoded_nelts ();
1568 for (unsigned int i
= 0; i
< count
; ++i
)
1570 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1572 tree elt
= const_binop (code
, elem1
, arg2
);
1574 /* It is possible that const_binop cannot handle the given
1575 code and return NULL_TREE. */
1576 if (elt
== NULL_TREE
)
1578 elts
.quick_push (elt
);
1581 return elts
.build ();
1586 /* Overload that adds a TYPE parameter to be able to dispatch
1587 to fold_relational_const. */
1590 const_binop (enum tree_code code
, tree type
, tree arg1
, tree arg2
)
1592 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
1593 return fold_relational_const (code
, type
, arg1
, arg2
);
1595 /* ??? Until we make the const_binop worker take the type of the
1596 result as argument put those cases that need it here. */
1599 case VEC_SERIES_EXPR
:
1600 if (CONSTANT_CLASS_P (arg1
)
1601 && CONSTANT_CLASS_P (arg2
))
1602 return build_vec_series (type
, arg1
, arg2
);
1606 if ((TREE_CODE (arg1
) == REAL_CST
1607 && TREE_CODE (arg2
) == REAL_CST
)
1608 || (TREE_CODE (arg1
) == INTEGER_CST
1609 && TREE_CODE (arg2
) == INTEGER_CST
))
1610 return build_complex (type
, arg1
, arg2
);
1613 case POINTER_DIFF_EXPR
:
1614 if (poly_int_tree_p (arg1
) && poly_int_tree_p (arg2
))
1616 poly_offset_int res
= (wi::to_poly_offset (arg1
)
1617 - wi::to_poly_offset (arg2
));
1618 return force_fit_type (type
, res
, 1,
1619 TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
));
1623 case VEC_PACK_TRUNC_EXPR
:
1624 case VEC_PACK_FIX_TRUNC_EXPR
:
1625 case VEC_PACK_FLOAT_EXPR
:
1627 unsigned int HOST_WIDE_INT out_nelts
, in_nelts
, i
;
1629 if (TREE_CODE (arg1
) != VECTOR_CST
1630 || TREE_CODE (arg2
) != VECTOR_CST
)
1633 if (!VECTOR_CST_NELTS (arg1
).is_constant (&in_nelts
))
1636 out_nelts
= in_nelts
* 2;
1637 gcc_assert (known_eq (in_nelts
, VECTOR_CST_NELTS (arg2
))
1638 && known_eq (out_nelts
, TYPE_VECTOR_SUBPARTS (type
)));
1640 tree_vector_builder
elts (type
, out_nelts
, 1);
1641 for (i
= 0; i
< out_nelts
; i
++)
1643 tree elt
= (i
< in_nelts
1644 ? VECTOR_CST_ELT (arg1
, i
)
1645 : VECTOR_CST_ELT (arg2
, i
- in_nelts
));
1646 elt
= fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
1648 : code
== VEC_PACK_FLOAT_EXPR
1649 ? FLOAT_EXPR
: FIX_TRUNC_EXPR
,
1650 TREE_TYPE (type
), elt
);
1651 if (elt
== NULL_TREE
|| !CONSTANT_CLASS_P (elt
))
1653 elts
.quick_push (elt
);
1656 return elts
.build ();
1659 case VEC_WIDEN_MULT_LO_EXPR
:
1660 case VEC_WIDEN_MULT_HI_EXPR
:
1661 case VEC_WIDEN_MULT_EVEN_EXPR
:
1662 case VEC_WIDEN_MULT_ODD_EXPR
:
1664 unsigned HOST_WIDE_INT out_nelts
, in_nelts
, out
, ofs
, scale
;
1666 if (TREE_CODE (arg1
) != VECTOR_CST
|| TREE_CODE (arg2
) != VECTOR_CST
)
1669 if (!VECTOR_CST_NELTS (arg1
).is_constant (&in_nelts
))
1671 out_nelts
= in_nelts
/ 2;
1672 gcc_assert (known_eq (in_nelts
, VECTOR_CST_NELTS (arg2
))
1673 && known_eq (out_nelts
, TYPE_VECTOR_SUBPARTS (type
)));
1675 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
1676 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? out_nelts
: 0;
1677 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
1678 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : out_nelts
;
1679 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
1681 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
1684 tree_vector_builder
elts (type
, out_nelts
, 1);
1685 for (out
= 0; out
< out_nelts
; out
++)
1687 unsigned int in
= (out
<< scale
) + ofs
;
1688 tree t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
),
1689 VECTOR_CST_ELT (arg1
, in
));
1690 tree t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
),
1691 VECTOR_CST_ELT (arg2
, in
));
1693 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
1695 tree elt
= const_binop (MULT_EXPR
, t1
, t2
);
1696 if (elt
== NULL_TREE
|| !CONSTANT_CLASS_P (elt
))
1698 elts
.quick_push (elt
);
1701 return elts
.build ();
1707 if (TREE_CODE_CLASS (code
) != tcc_binary
)
1710 /* Make sure type and arg0 have the same saturating flag. */
1711 gcc_checking_assert (TYPE_SATURATING (type
)
1712 == TYPE_SATURATING (TREE_TYPE (arg1
)));
1714 return const_binop (code
, arg1
, arg2
);
1717 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1718 Return zero if computing the constants is not possible. */
1721 const_unop (enum tree_code code
, tree type
, tree arg0
)
1723 /* Don't perform the operation, other than NEGATE and ABS, if
1724 flag_signaling_nans is on and the operand is a signaling NaN. */
1725 if (TREE_CODE (arg0
) == REAL_CST
1726 && HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
1727 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg0
))
1728 && code
!= NEGATE_EXPR
1729 && code
!= ABS_EXPR
)
1736 case FIX_TRUNC_EXPR
:
1737 case FIXED_CONVERT_EXPR
:
1738 return fold_convert_const (code
, type
, arg0
);
1740 case ADDR_SPACE_CONVERT_EXPR
:
1741 /* If the source address is 0, and the source address space
1742 cannot have a valid object at 0, fold to dest type null. */
1743 if (integer_zerop (arg0
)
1744 && !(targetm
.addr_space
.zero_address_valid
1745 (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
))))))
1746 return fold_convert_const (code
, type
, arg0
);
1749 case VIEW_CONVERT_EXPR
:
1750 return fold_view_convert_expr (type
, arg0
);
1754 /* Can't call fold_negate_const directly here as that doesn't
1755 handle all cases and we might not be able to negate some
1757 tree tem
= fold_negate_expr (UNKNOWN_LOCATION
, arg0
);
1758 if (tem
&& CONSTANT_CLASS_P (tem
))
1764 if (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
)
1765 return fold_abs_const (arg0
, type
);
1769 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1771 tree ipart
= fold_negate_const (TREE_IMAGPART (arg0
),
1773 return build_complex (type
, TREE_REALPART (arg0
), ipart
);
1778 if (TREE_CODE (arg0
) == INTEGER_CST
)
1779 return fold_not_const (arg0
, type
);
1780 else if (POLY_INT_CST_P (arg0
))
1781 return wide_int_to_tree (type
, -poly_int_cst_value (arg0
));
1782 /* Perform BIT_NOT_EXPR on each element individually. */
1783 else if (TREE_CODE (arg0
) == VECTOR_CST
)
1787 /* This can cope with stepped encodings because ~x == -1 - x. */
1788 tree_vector_builder elements
;
1789 elements
.new_unary_operation (type
, arg0
, true);
1790 unsigned int i
, count
= elements
.encoded_nelts ();
1791 for (i
= 0; i
< count
; ++i
)
1793 elem
= VECTOR_CST_ELT (arg0
, i
);
1794 elem
= const_unop (BIT_NOT_EXPR
, TREE_TYPE (type
), elem
);
1795 if (elem
== NULL_TREE
)
1797 elements
.quick_push (elem
);
1800 return elements
.build ();
1804 case TRUTH_NOT_EXPR
:
1805 if (TREE_CODE (arg0
) == INTEGER_CST
)
1806 return constant_boolean_node (integer_zerop (arg0
), type
);
1810 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1811 return fold_convert (type
, TREE_REALPART (arg0
));
1815 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1816 return fold_convert (type
, TREE_IMAGPART (arg0
));
1819 case VEC_UNPACK_LO_EXPR
:
1820 case VEC_UNPACK_HI_EXPR
:
1821 case VEC_UNPACK_FLOAT_LO_EXPR
:
1822 case VEC_UNPACK_FLOAT_HI_EXPR
:
1823 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
1824 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
1826 unsigned HOST_WIDE_INT out_nelts
, in_nelts
, i
;
1827 enum tree_code subcode
;
1829 if (TREE_CODE (arg0
) != VECTOR_CST
)
1832 if (!VECTOR_CST_NELTS (arg0
).is_constant (&in_nelts
))
1834 out_nelts
= in_nelts
/ 2;
1835 gcc_assert (known_eq (out_nelts
, TYPE_VECTOR_SUBPARTS (type
)));
1837 unsigned int offset
= 0;
1838 if ((!BYTES_BIG_ENDIAN
) ^ (code
== VEC_UNPACK_LO_EXPR
1839 || code
== VEC_UNPACK_FLOAT_LO_EXPR
1840 || code
== VEC_UNPACK_FIX_TRUNC_LO_EXPR
))
1843 if (code
== VEC_UNPACK_LO_EXPR
|| code
== VEC_UNPACK_HI_EXPR
)
1845 else if (code
== VEC_UNPACK_FLOAT_LO_EXPR
1846 || code
== VEC_UNPACK_FLOAT_HI_EXPR
)
1847 subcode
= FLOAT_EXPR
;
1849 subcode
= FIX_TRUNC_EXPR
;
1851 tree_vector_builder
elts (type
, out_nelts
, 1);
1852 for (i
= 0; i
< out_nelts
; i
++)
1854 tree elt
= fold_convert_const (subcode
, TREE_TYPE (type
),
1855 VECTOR_CST_ELT (arg0
, i
+ offset
));
1856 if (elt
== NULL_TREE
|| !CONSTANT_CLASS_P (elt
))
1858 elts
.quick_push (elt
);
1861 return elts
.build ();
1864 case VEC_DUPLICATE_EXPR
:
1865 if (CONSTANT_CLASS_P (arg0
))
1866 return build_vector_from_val (type
, arg0
);
1876 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1877 indicates which particular sizetype to create. */
1880 size_int_kind (poly_int64 number
, enum size_type_kind kind
)
1882 return build_int_cst (sizetype_tab
[(int) kind
], number
);
1885 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1886 is a tree code. The type of the result is taken from the operands.
1887 Both must be equivalent integer types, ala int_binop_types_match_p.
1888 If the operands are constant, so is the result. */
1891 size_binop_loc (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
)
1893 tree type
= TREE_TYPE (arg0
);
1895 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1896 return error_mark_node
;
1898 gcc_assert (int_binop_types_match_p (code
, TREE_TYPE (arg0
),
1901 /* Handle the special case of two poly_int constants faster. */
1902 if (poly_int_tree_p (arg0
) && poly_int_tree_p (arg1
))
1904 /* And some specific cases even faster than that. */
1905 if (code
== PLUS_EXPR
)
1907 if (integer_zerop (arg0
) && !TREE_OVERFLOW (arg0
))
1909 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1912 else if (code
== MINUS_EXPR
)
1914 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1917 else if (code
== MULT_EXPR
)
1919 if (integer_onep (arg0
) && !TREE_OVERFLOW (arg0
))
1923 /* Handle general case of two integer constants. For sizetype
1924 constant calculations we always want to know about overflow,
1925 even in the unsigned case. */
1926 tree res
= int_const_binop_1 (code
, arg0
, arg1
, -1);
1927 if (res
!= NULL_TREE
)
1931 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
1934 /* Given two values, either both of sizetype or both of bitsizetype,
1935 compute the difference between the two values. Return the value
1936 in signed type corresponding to the type of the operands. */
1939 size_diffop_loc (location_t loc
, tree arg0
, tree arg1
)
1941 tree type
= TREE_TYPE (arg0
);
1944 gcc_assert (int_binop_types_match_p (MINUS_EXPR
, TREE_TYPE (arg0
),
1947 /* If the type is already signed, just do the simple thing. */
1948 if (!TYPE_UNSIGNED (type
))
1949 return size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
);
1951 if (type
== sizetype
)
1953 else if (type
== bitsizetype
)
1954 ctype
= sbitsizetype
;
1956 ctype
= signed_type_for (type
);
1958 /* If either operand is not a constant, do the conversions to the signed
1959 type and subtract. The hardware will do the right thing with any
1960 overflow in the subtraction. */
1961 if (TREE_CODE (arg0
) != INTEGER_CST
|| TREE_CODE (arg1
) != INTEGER_CST
)
1962 return size_binop_loc (loc
, MINUS_EXPR
,
1963 fold_convert_loc (loc
, ctype
, arg0
),
1964 fold_convert_loc (loc
, ctype
, arg1
));
1966 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1967 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1968 overflow) and negate (which can't either). Special-case a result
1969 of zero while we're here. */
1970 if (tree_int_cst_equal (arg0
, arg1
))
1971 return build_int_cst (ctype
, 0);
1972 else if (tree_int_cst_lt (arg1
, arg0
))
1973 return fold_convert_loc (loc
, ctype
,
1974 size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
));
1976 return size_binop_loc (loc
, MINUS_EXPR
, build_int_cst (ctype
, 0),
1977 fold_convert_loc (loc
, ctype
,
1978 size_binop_loc (loc
,
1983 /* A subroutine of fold_convert_const handling conversions of an
1984 INTEGER_CST to another integer type. */
1987 fold_convert_const_int_from_int (tree type
, const_tree arg1
)
1989 /* Given an integer constant, make new constant with new type,
1990 appropriately sign-extended or truncated. Use widest_int
1991 so that any extension is done according ARG1's type. */
1992 return force_fit_type (type
, wi::to_widest (arg1
),
1993 !POINTER_TYPE_P (TREE_TYPE (arg1
)),
1994 TREE_OVERFLOW (arg1
));
1997 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1998 to an integer type. */
2001 fold_convert_const_int_from_real (enum tree_code code
, tree type
, const_tree arg1
)
2003 bool overflow
= false;
2006 /* The following code implements the floating point to integer
2007 conversion rules required by the Java Language Specification,
2008 that IEEE NaNs are mapped to zero and values that overflow
2009 the target precision saturate, i.e. values greater than
2010 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
2011 are mapped to INT_MIN. These semantics are allowed by the
2012 C and C++ standards that simply state that the behavior of
2013 FP-to-integer conversion is unspecified upon overflow. */
2017 REAL_VALUE_TYPE x
= TREE_REAL_CST (arg1
);
2021 case FIX_TRUNC_EXPR
:
2022 real_trunc (&r
, VOIDmode
, &x
);
2029 /* If R is NaN, return zero and show we have an overflow. */
2030 if (REAL_VALUE_ISNAN (r
))
2033 val
= wi::zero (TYPE_PRECISION (type
));
2036 /* See if R is less than the lower bound or greater than the
2041 tree lt
= TYPE_MIN_VALUE (type
);
2042 REAL_VALUE_TYPE l
= real_value_from_int_cst (NULL_TREE
, lt
);
2043 if (real_less (&r
, &l
))
2046 val
= wi::to_wide (lt
);
2052 tree ut
= TYPE_MAX_VALUE (type
);
2055 REAL_VALUE_TYPE u
= real_value_from_int_cst (NULL_TREE
, ut
);
2056 if (real_less (&u
, &r
))
2059 val
= wi::to_wide (ut
);
2065 val
= real_to_integer (&r
, &overflow
, TYPE_PRECISION (type
));
2067 t
= force_fit_type (type
, val
, -1, overflow
| TREE_OVERFLOW (arg1
));
2071 /* A subroutine of fold_convert_const handling conversions of a
2072 FIXED_CST to an integer type. */
2075 fold_convert_const_int_from_fixed (tree type
, const_tree arg1
)
2078 double_int temp
, temp_trunc
;
2081 /* Right shift FIXED_CST to temp by fbit. */
2082 temp
= TREE_FIXED_CST (arg1
).data
;
2083 mode
= TREE_FIXED_CST (arg1
).mode
;
2084 if (GET_MODE_FBIT (mode
) < HOST_BITS_PER_DOUBLE_INT
)
2086 temp
= temp
.rshift (GET_MODE_FBIT (mode
),
2087 HOST_BITS_PER_DOUBLE_INT
,
2088 SIGNED_FIXED_POINT_MODE_P (mode
));
2090 /* Left shift temp to temp_trunc by fbit. */
2091 temp_trunc
= temp
.lshift (GET_MODE_FBIT (mode
),
2092 HOST_BITS_PER_DOUBLE_INT
,
2093 SIGNED_FIXED_POINT_MODE_P (mode
));
2097 temp
= double_int_zero
;
2098 temp_trunc
= double_int_zero
;
2101 /* If FIXED_CST is negative, we need to round the value toward 0.
2102 By checking if the fractional bits are not zero to add 1 to temp. */
2103 if (SIGNED_FIXED_POINT_MODE_P (mode
)
2104 && temp_trunc
.is_negative ()
2105 && TREE_FIXED_CST (arg1
).data
!= temp_trunc
)
2106 temp
+= double_int_one
;
2108 /* Given a fixed-point constant, make new constant with new type,
2109 appropriately sign-extended or truncated. */
2110 t
= force_fit_type (type
, temp
, -1,
2111 (temp
.is_negative ()
2112 && (TYPE_UNSIGNED (type
)
2113 < TYPE_UNSIGNED (TREE_TYPE (arg1
))))
2114 | TREE_OVERFLOW (arg1
));
2119 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2120 to another floating point type. */
2123 fold_convert_const_real_from_real (tree type
, const_tree arg1
)
2125 REAL_VALUE_TYPE value
;
2128 /* Don't perform the operation if flag_signaling_nans is on
2129 and the operand is a signaling NaN. */
2130 if (HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
)))
2131 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg1
)))
2134 real_convert (&value
, TYPE_MODE (type
), &TREE_REAL_CST (arg1
));
2135 t
= build_real (type
, value
);
2137 /* If converting an infinity or NAN to a representation that doesn't
2138 have one, set the overflow bit so that we can produce some kind of
2139 error message at the appropriate point if necessary. It's not the
2140 most user-friendly message, but it's better than nothing. */
2141 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1
))
2142 && !MODE_HAS_INFINITIES (TYPE_MODE (type
)))
2143 TREE_OVERFLOW (t
) = 1;
2144 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
2145 && !MODE_HAS_NANS (TYPE_MODE (type
)))
2146 TREE_OVERFLOW (t
) = 1;
2147 /* Regular overflow, conversion produced an infinity in a mode that
2148 can't represent them. */
2149 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type
))
2150 && REAL_VALUE_ISINF (value
)
2151 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1
)))
2152 TREE_OVERFLOW (t
) = 1;
2154 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2158 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2159 to a floating point type. */
2162 fold_convert_const_real_from_fixed (tree type
, const_tree arg1
)
2164 REAL_VALUE_TYPE value
;
2167 real_convert_from_fixed (&value
, SCALAR_FLOAT_TYPE_MODE (type
),
2168 &TREE_FIXED_CST (arg1
));
2169 t
= build_real (type
, value
);
2171 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2175 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2176 to another fixed-point type. */
2179 fold_convert_const_fixed_from_fixed (tree type
, const_tree arg1
)
2181 FIXED_VALUE_TYPE value
;
2185 overflow_p
= fixed_convert (&value
, SCALAR_TYPE_MODE (type
),
2186 &TREE_FIXED_CST (arg1
), TYPE_SATURATING (type
));
2187 t
= build_fixed (type
, value
);
2189 /* Propagate overflow flags. */
2190 if (overflow_p
| TREE_OVERFLOW (arg1
))
2191 TREE_OVERFLOW (t
) = 1;
2195 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2196 to a fixed-point type. */
2199 fold_convert_const_fixed_from_int (tree type
, const_tree arg1
)
2201 FIXED_VALUE_TYPE value
;
2206 gcc_assert (TREE_INT_CST_NUNITS (arg1
) <= 2);
2208 di
.low
= TREE_INT_CST_ELT (arg1
, 0);
2209 if (TREE_INT_CST_NUNITS (arg1
) == 1)
2210 di
.high
= (HOST_WIDE_INT
) di
.low
< 0 ? HOST_WIDE_INT_M1
: 0;
2212 di
.high
= TREE_INT_CST_ELT (arg1
, 1);
2214 overflow_p
= fixed_convert_from_int (&value
, SCALAR_TYPE_MODE (type
), di
,
2215 TYPE_UNSIGNED (TREE_TYPE (arg1
)),
2216 TYPE_SATURATING (type
));
2217 t
= build_fixed (type
, value
);
2219 /* Propagate overflow flags. */
2220 if (overflow_p
| TREE_OVERFLOW (arg1
))
2221 TREE_OVERFLOW (t
) = 1;
2225 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2226 to a fixed-point type. */
2229 fold_convert_const_fixed_from_real (tree type
, const_tree arg1
)
2231 FIXED_VALUE_TYPE value
;
2235 overflow_p
= fixed_convert_from_real (&value
, SCALAR_TYPE_MODE (type
),
2236 &TREE_REAL_CST (arg1
),
2237 TYPE_SATURATING (type
));
2238 t
= build_fixed (type
, value
);
2240 /* Propagate overflow flags. */
2241 if (overflow_p
| TREE_OVERFLOW (arg1
))
2242 TREE_OVERFLOW (t
) = 1;
2246 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2247 type TYPE. If no simplification can be done return NULL_TREE. */
2250 fold_convert_const (enum tree_code code
, tree type
, tree arg1
)
2252 tree arg_type
= TREE_TYPE (arg1
);
2253 if (arg_type
== type
)
2256 /* We can't widen types, since the runtime value could overflow the
2257 original type before being extended to the new type. */
2258 if (POLY_INT_CST_P (arg1
)
2259 && (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
))
2260 && TYPE_PRECISION (type
) <= TYPE_PRECISION (arg_type
))
2261 return build_poly_int_cst (type
,
2262 poly_wide_int::from (poly_int_cst_value (arg1
),
2263 TYPE_PRECISION (type
),
2264 TYPE_SIGN (arg_type
)));
2266 if (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
)
2267 || TREE_CODE (type
) == OFFSET_TYPE
)
2269 if (TREE_CODE (arg1
) == INTEGER_CST
)
2270 return fold_convert_const_int_from_int (type
, arg1
);
2271 else if (TREE_CODE (arg1
) == REAL_CST
)
2272 return fold_convert_const_int_from_real (code
, type
, arg1
);
2273 else if (TREE_CODE (arg1
) == FIXED_CST
)
2274 return fold_convert_const_int_from_fixed (type
, arg1
);
2276 else if (TREE_CODE (type
) == REAL_TYPE
)
2278 if (TREE_CODE (arg1
) == INTEGER_CST
)
2279 return build_real_from_int_cst (type
, arg1
);
2280 else if (TREE_CODE (arg1
) == REAL_CST
)
2281 return fold_convert_const_real_from_real (type
, arg1
);
2282 else if (TREE_CODE (arg1
) == FIXED_CST
)
2283 return fold_convert_const_real_from_fixed (type
, arg1
);
2285 else if (TREE_CODE (type
) == FIXED_POINT_TYPE
)
2287 if (TREE_CODE (arg1
) == FIXED_CST
)
2288 return fold_convert_const_fixed_from_fixed (type
, arg1
);
2289 else if (TREE_CODE (arg1
) == INTEGER_CST
)
2290 return fold_convert_const_fixed_from_int (type
, arg1
);
2291 else if (TREE_CODE (arg1
) == REAL_CST
)
2292 return fold_convert_const_fixed_from_real (type
, arg1
);
2294 else if (TREE_CODE (type
) == VECTOR_TYPE
)
2296 if (TREE_CODE (arg1
) == VECTOR_CST
2297 && known_eq (TYPE_VECTOR_SUBPARTS (type
), VECTOR_CST_NELTS (arg1
)))
2299 tree elttype
= TREE_TYPE (type
);
2300 tree arg1_elttype
= TREE_TYPE (TREE_TYPE (arg1
));
2301 /* We can't handle steps directly when extending, since the
2302 values need to wrap at the original precision first. */
2304 = (INTEGRAL_TYPE_P (elttype
)
2305 && INTEGRAL_TYPE_P (arg1_elttype
)
2306 && TYPE_PRECISION (elttype
) <= TYPE_PRECISION (arg1_elttype
));
2307 tree_vector_builder v
;
2308 if (!v
.new_unary_operation (type
, arg1
, step_ok_p
))
2310 unsigned int len
= v
.encoded_nelts ();
2311 for (unsigned int i
= 0; i
< len
; ++i
)
2313 tree elt
= VECTOR_CST_ELT (arg1
, i
);
2314 tree cvt
= fold_convert_const (code
, elttype
, elt
);
2315 if (cvt
== NULL_TREE
)
2325 /* Construct a vector of zero elements of vector type TYPE. */
2328 build_zero_vector (tree type
)
2332 t
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), integer_zero_node
);
2333 return build_vector_from_val (type
, t
);
2336 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2339 fold_convertible_p (const_tree type
, const_tree arg
)
2341 tree orig
= TREE_TYPE (arg
);
2346 if (TREE_CODE (arg
) == ERROR_MARK
2347 || TREE_CODE (type
) == ERROR_MARK
2348 || TREE_CODE (orig
) == ERROR_MARK
)
2351 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2354 switch (TREE_CODE (type
))
2356 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2357 case POINTER_TYPE
: case REFERENCE_TYPE
:
2359 return (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2360 || TREE_CODE (orig
) == OFFSET_TYPE
);
2363 case FIXED_POINT_TYPE
:
2366 return TREE_CODE (type
) == TREE_CODE (orig
);
2373 /* Convert expression ARG to type TYPE. Used by the middle-end for
2374 simple conversions in preference to calling the front-end's convert. */
2377 fold_convert_loc (location_t loc
, tree type
, tree arg
)
2379 tree orig
= TREE_TYPE (arg
);
2385 if (TREE_CODE (arg
) == ERROR_MARK
2386 || TREE_CODE (type
) == ERROR_MARK
2387 || TREE_CODE (orig
) == ERROR_MARK
)
2388 return error_mark_node
;
2390 switch (TREE_CODE (type
))
2393 case REFERENCE_TYPE
:
2394 /* Handle conversions between pointers to different address spaces. */
2395 if (POINTER_TYPE_P (orig
)
2396 && (TYPE_ADDR_SPACE (TREE_TYPE (type
))
2397 != TYPE_ADDR_SPACE (TREE_TYPE (orig
))))
2398 return fold_build1_loc (loc
, ADDR_SPACE_CONVERT_EXPR
, type
, arg
);
2401 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2403 if (TREE_CODE (arg
) == INTEGER_CST
)
2405 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2406 if (tem
!= NULL_TREE
)
2409 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2410 || TREE_CODE (orig
) == OFFSET_TYPE
)
2411 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2412 if (TREE_CODE (orig
) == COMPLEX_TYPE
)
2413 return fold_convert_loc (loc
, type
,
2414 fold_build1_loc (loc
, REALPART_EXPR
,
2415 TREE_TYPE (orig
), arg
));
2416 gcc_assert (TREE_CODE (orig
) == VECTOR_TYPE
2417 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2418 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2421 if (TREE_CODE (arg
) == INTEGER_CST
)
2423 tem
= fold_convert_const (FLOAT_EXPR
, type
, arg
);
2424 if (tem
!= NULL_TREE
)
2427 else if (TREE_CODE (arg
) == REAL_CST
)
2429 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2430 if (tem
!= NULL_TREE
)
2433 else if (TREE_CODE (arg
) == FIXED_CST
)
2435 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2436 if (tem
!= NULL_TREE
)
2440 switch (TREE_CODE (orig
))
2443 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2444 case POINTER_TYPE
: case REFERENCE_TYPE
:
2445 return fold_build1_loc (loc
, FLOAT_EXPR
, type
, arg
);
2448 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2450 case FIXED_POINT_TYPE
:
2451 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2454 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2455 return fold_convert_loc (loc
, type
, tem
);
2461 case FIXED_POINT_TYPE
:
2462 if (TREE_CODE (arg
) == FIXED_CST
|| TREE_CODE (arg
) == INTEGER_CST
2463 || TREE_CODE (arg
) == REAL_CST
)
2465 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2466 if (tem
!= NULL_TREE
)
2467 goto fold_convert_exit
;
2470 switch (TREE_CODE (orig
))
2472 case FIXED_POINT_TYPE
:
2477 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2480 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2481 return fold_convert_loc (loc
, type
, tem
);
2488 switch (TREE_CODE (orig
))
2491 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2492 case POINTER_TYPE
: case REFERENCE_TYPE
:
2494 case FIXED_POINT_TYPE
:
2495 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
2496 fold_convert_loc (loc
, TREE_TYPE (type
), arg
),
2497 fold_convert_loc (loc
, TREE_TYPE (type
),
2498 integer_zero_node
));
2503 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
2505 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2506 TREE_OPERAND (arg
, 0));
2507 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2508 TREE_OPERAND (arg
, 1));
2509 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2512 arg
= save_expr (arg
);
2513 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2514 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, TREE_TYPE (orig
), arg
);
2515 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
), rpart
);
2516 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
), ipart
);
2517 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2525 if (integer_zerop (arg
))
2526 return build_zero_vector (type
);
2527 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2528 gcc_assert (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2529 || TREE_CODE (orig
) == VECTOR_TYPE
);
2530 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2533 tem
= fold_ignored_result (arg
);
2534 return fold_build1_loc (loc
, NOP_EXPR
, type
, tem
);
2537 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2538 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2542 protected_set_expr_location_unshare (tem
, loc
);
2546 /* Return false if expr can be assumed not to be an lvalue, true
2550 maybe_lvalue_p (const_tree x
)
2552 /* We only need to wrap lvalue tree codes. */
2553 switch (TREE_CODE (x
))
2566 case ARRAY_RANGE_REF
:
2572 case PREINCREMENT_EXPR
:
2573 case PREDECREMENT_EXPR
:
2575 case TRY_CATCH_EXPR
:
2576 case WITH_CLEANUP_EXPR
:
2585 /* Assume the worst for front-end tree codes. */
2586 if ((int)TREE_CODE (x
) >= NUM_TREE_CODES
)
2594 /* Return an expr equal to X but certainly not valid as an lvalue. */
2597 non_lvalue_loc (location_t loc
, tree x
)
2599 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2604 if (! maybe_lvalue_p (x
))
2606 return build1_loc (loc
, NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
2609 /* When pedantic, return an expr equal to X but certainly not valid as a
2610 pedantic lvalue. Otherwise, return X. */
2613 pedantic_non_lvalue_loc (location_t loc
, tree x
)
2615 return protected_set_expr_location_unshare (x
, loc
);
2618 /* Given a tree comparison code, return the code that is the logical inverse.
2619 It is generally not safe to do this for floating-point comparisons, except
2620 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2621 ERROR_MARK in this case. */
2624 invert_tree_comparison (enum tree_code code
, bool honor_nans
)
2626 if (honor_nans
&& flag_trapping_math
&& code
!= EQ_EXPR
&& code
!= NE_EXPR
2627 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
)
2637 return honor_nans
? UNLE_EXPR
: LE_EXPR
;
2639 return honor_nans
? UNLT_EXPR
: LT_EXPR
;
2641 return honor_nans
? UNGE_EXPR
: GE_EXPR
;
2643 return honor_nans
? UNGT_EXPR
: GT_EXPR
;
2657 return UNORDERED_EXPR
;
2658 case UNORDERED_EXPR
:
2659 return ORDERED_EXPR
;
2665 /* Similar, but return the comparison that results if the operands are
2666 swapped. This is safe for floating-point. */
2669 swap_tree_comparison (enum tree_code code
)
2676 case UNORDERED_EXPR
:
2702 /* Convert a comparison tree code from an enum tree_code representation
2703 into a compcode bit-based encoding. This function is the inverse of
2704 compcode_to_comparison. */
2706 static enum comparison_code
2707 comparison_to_compcode (enum tree_code code
)
2724 return COMPCODE_ORD
;
2725 case UNORDERED_EXPR
:
2726 return COMPCODE_UNORD
;
2728 return COMPCODE_UNLT
;
2730 return COMPCODE_UNEQ
;
2732 return COMPCODE_UNLE
;
2734 return COMPCODE_UNGT
;
2736 return COMPCODE_LTGT
;
2738 return COMPCODE_UNGE
;
2744 /* Convert a compcode bit-based encoding of a comparison operator back
2745 to GCC's enum tree_code representation. This function is the
2746 inverse of comparison_to_compcode. */
2748 static enum tree_code
2749 compcode_to_comparison (enum comparison_code code
)
2766 return ORDERED_EXPR
;
2767 case COMPCODE_UNORD
:
2768 return UNORDERED_EXPR
;
2786 /* Return a tree for the comparison which is the combination of
2787 doing the AND or OR (depending on CODE) of the two operations LCODE
2788 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2789 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2790 if this makes the transformation invalid. */
2793 combine_comparisons (location_t loc
,
2794 enum tree_code code
, enum tree_code lcode
,
2795 enum tree_code rcode
, tree truth_type
,
2796 tree ll_arg
, tree lr_arg
)
2798 bool honor_nans
= HONOR_NANS (ll_arg
);
2799 enum comparison_code lcompcode
= comparison_to_compcode (lcode
);
2800 enum comparison_code rcompcode
= comparison_to_compcode (rcode
);
2805 case TRUTH_AND_EXPR
: case TRUTH_ANDIF_EXPR
:
2806 compcode
= lcompcode
& rcompcode
;
2809 case TRUTH_OR_EXPR
: case TRUTH_ORIF_EXPR
:
2810 compcode
= lcompcode
| rcompcode
;
2819 /* Eliminate unordered comparisons, as well as LTGT and ORD
2820 which are not used unless the mode has NaNs. */
2821 compcode
&= ~COMPCODE_UNORD
;
2822 if (compcode
== COMPCODE_LTGT
)
2823 compcode
= COMPCODE_NE
;
2824 else if (compcode
== COMPCODE_ORD
)
2825 compcode
= COMPCODE_TRUE
;
2827 else if (flag_trapping_math
)
2829 /* Check that the original operation and the optimized ones will trap
2830 under the same condition. */
2831 bool ltrap
= (lcompcode
& COMPCODE_UNORD
) == 0
2832 && (lcompcode
!= COMPCODE_EQ
)
2833 && (lcompcode
!= COMPCODE_ORD
);
2834 bool rtrap
= (rcompcode
& COMPCODE_UNORD
) == 0
2835 && (rcompcode
!= COMPCODE_EQ
)
2836 && (rcompcode
!= COMPCODE_ORD
);
2837 bool trap
= (compcode
& COMPCODE_UNORD
) == 0
2838 && (compcode
!= COMPCODE_EQ
)
2839 && (compcode
!= COMPCODE_ORD
);
2841 /* In a short-circuited boolean expression the LHS might be
2842 such that the RHS, if evaluated, will never trap. For
2843 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2844 if neither x nor y is NaN. (This is a mixed blessing: for
2845 example, the expression above will never trap, hence
2846 optimizing it to x < y would be invalid). */
2847 if ((code
== TRUTH_ORIF_EXPR
&& (lcompcode
& COMPCODE_UNORD
))
2848 || (code
== TRUTH_ANDIF_EXPR
&& !(lcompcode
& COMPCODE_UNORD
)))
2851 /* If the comparison was short-circuited, and only the RHS
2852 trapped, we may now generate a spurious trap. */
2854 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2857 /* If we changed the conditions that cause a trap, we lose. */
2858 if ((ltrap
|| rtrap
) != trap
)
2862 if (compcode
== COMPCODE_TRUE
)
2863 return constant_boolean_node (true, truth_type
);
2864 else if (compcode
== COMPCODE_FALSE
)
2865 return constant_boolean_node (false, truth_type
);
2868 enum tree_code tcode
;
2870 tcode
= compcode_to_comparison ((enum comparison_code
) compcode
);
2871 return fold_build2_loc (loc
, tcode
, truth_type
, ll_arg
, lr_arg
);
2875 /* Return nonzero if two operands (typically of the same tree node)
2876 are necessarily equal. FLAGS modifies behavior as follows:
2878 If OEP_ONLY_CONST is set, only return nonzero for constants.
2879 This function tests whether the operands are indistinguishable;
2880 it does not test whether they are equal using C's == operation.
2881 The distinction is important for IEEE floating point, because
2882 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2883 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2885 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2886 even though it may hold multiple values during a function.
2887 This is because a GCC tree node guarantees that nothing else is
2888 executed between the evaluation of its "operands" (which may often
2889 be evaluated in arbitrary order). Hence if the operands themselves
2890 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2891 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2892 unset means assuming isochronic (or instantaneous) tree equivalence.
2893 Unless comparing arbitrary expression trees, such as from different
2894 statements, this flag can usually be left unset.
2896 If OEP_PURE_SAME is set, then pure functions with identical arguments
2897 are considered the same. It is used when the caller has other ways
2898 to ensure that global memory is unchanged in between.
2900 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2901 not values of expressions.
2903 If OEP_LEXICOGRAPHIC is set, then also handle expressions with side-effects
2904 such as MODIFY_EXPR, RETURN_EXPR, as well as STATEMENT_LISTs.
2906 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2907 any operand with side effect. This is unnecesarily conservative in the
2908 case we know that arg0 and arg1 are in disjoint code paths (such as in
2909 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2910 addresses with TREE_CONSTANT flag set so we know that &var == &var
2911 even if var is volatile. */
2914 operand_equal_p (const_tree arg0
, const_tree arg1
, unsigned int flags
)
2916 /* When checking, verify at the outermost operand_equal_p call that
2917 if operand_equal_p returns non-zero then ARG0 and ARG1 has the same
2919 if (flag_checking
&& !(flags
& OEP_NO_HASH_CHECK
))
2921 if (operand_equal_p (arg0
, arg1
, flags
| OEP_NO_HASH_CHECK
))
2925 inchash::hash
hstate0 (0), hstate1 (0);
2926 inchash::add_expr (arg0
, hstate0
, flags
| OEP_HASH_CHECK
);
2927 inchash::add_expr (arg1
, hstate1
, flags
| OEP_HASH_CHECK
);
2928 hashval_t h0
= hstate0
.end ();
2929 hashval_t h1
= hstate1
.end ();
2930 gcc_assert (h0
== h1
);
2938 /* If either is ERROR_MARK, they aren't equal. */
2939 if (TREE_CODE (arg0
) == ERROR_MARK
|| TREE_CODE (arg1
) == ERROR_MARK
2940 || TREE_TYPE (arg0
) == error_mark_node
2941 || TREE_TYPE (arg1
) == error_mark_node
)
2944 /* Similar, if either does not have a type (like a released SSA name),
2945 they aren't equal. */
2946 if (!TREE_TYPE (arg0
) || !TREE_TYPE (arg1
))
2949 /* We cannot consider pointers to different address space equal. */
2950 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
2951 && POINTER_TYPE_P (TREE_TYPE (arg1
))
2952 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
)))
2953 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1
)))))
2956 /* Check equality of integer constants before bailing out due to
2957 precision differences. */
2958 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2960 /* Address of INTEGER_CST is not defined; check that we did not forget
2961 to drop the OEP_ADDRESS_OF flags. */
2962 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
2963 return tree_int_cst_equal (arg0
, arg1
);
2966 if (!(flags
& OEP_ADDRESS_OF
))
2968 /* If both types don't have the same signedness, then we can't consider
2969 them equal. We must check this before the STRIP_NOPS calls
2970 because they may change the signedness of the arguments. As pointers
2971 strictly don't have a signedness, require either two pointers or
2972 two non-pointers as well. */
2973 if (TYPE_UNSIGNED (TREE_TYPE (arg0
)) != TYPE_UNSIGNED (TREE_TYPE (arg1
))
2974 || POINTER_TYPE_P (TREE_TYPE (arg0
))
2975 != POINTER_TYPE_P (TREE_TYPE (arg1
)))
2978 /* If both types don't have the same precision, then it is not safe
2980 if (element_precision (TREE_TYPE (arg0
))
2981 != element_precision (TREE_TYPE (arg1
)))
2988 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2989 sanity check once the issue is solved. */
2991 /* Addresses of conversions and SSA_NAMEs (and many other things)
2992 are not defined. Check that we did not forget to drop the
2993 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2994 gcc_checking_assert (!CONVERT_EXPR_P (arg0
) && !CONVERT_EXPR_P (arg1
)
2995 && TREE_CODE (arg0
) != SSA_NAME
);
2998 /* In case both args are comparisons but with different comparison
2999 code, try to swap the comparison operands of one arg to produce
3000 a match and compare that variant. */
3001 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
3002 && COMPARISON_CLASS_P (arg0
)
3003 && COMPARISON_CLASS_P (arg1
))
3005 enum tree_code swap_code
= swap_tree_comparison (TREE_CODE (arg1
));
3007 if (TREE_CODE (arg0
) == swap_code
)
3008 return operand_equal_p (TREE_OPERAND (arg0
, 0),
3009 TREE_OPERAND (arg1
, 1), flags
)
3010 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3011 TREE_OPERAND (arg1
, 0), flags
);
3014 if (TREE_CODE (arg0
) != TREE_CODE (arg1
))
3016 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
3017 if (CONVERT_EXPR_P (arg0
) && CONVERT_EXPR_P (arg1
))
3019 else if (flags
& OEP_ADDRESS_OF
)
3021 /* If we are interested in comparing addresses ignore
3022 MEM_REF wrappings of the base that can appear just for
3024 if (TREE_CODE (arg0
) == MEM_REF
3026 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ADDR_EXPR
3027 && TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0) == arg1
3028 && integer_zerop (TREE_OPERAND (arg0
, 1)))
3030 else if (TREE_CODE (arg1
) == MEM_REF
3032 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ADDR_EXPR
3033 && TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0) == arg0
3034 && integer_zerop (TREE_OPERAND (arg1
, 1)))
3042 /* When not checking adddresses, this is needed for conversions and for
3043 COMPONENT_REF. Might as well play it safe and always test this. */
3044 if (TREE_CODE (TREE_TYPE (arg0
)) == ERROR_MARK
3045 || TREE_CODE (TREE_TYPE (arg1
)) == ERROR_MARK
3046 || (TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
))
3047 && !(flags
& OEP_ADDRESS_OF
)))
3050 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
3051 We don't care about side effects in that case because the SAVE_EXPR
3052 takes care of that for us. In all other cases, two expressions are
3053 equal if they have no side effects. If we have two identical
3054 expressions with side effects that should be treated the same due
3055 to the only side effects being identical SAVE_EXPR's, that will
3056 be detected in the recursive calls below.
3057 If we are taking an invariant address of two identical objects
3058 they are necessarily equal as well. */
3059 if (arg0
== arg1
&& ! (flags
& OEP_ONLY_CONST
)
3060 && (TREE_CODE (arg0
) == SAVE_EXPR
3061 || (flags
& OEP_MATCH_SIDE_EFFECTS
)
3062 || (! TREE_SIDE_EFFECTS (arg0
) && ! TREE_SIDE_EFFECTS (arg1
))))
3065 /* Next handle constant cases, those for which we can return 1 even
3066 if ONLY_CONST is set. */
3067 if (TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
))
3068 switch (TREE_CODE (arg0
))
3071 return tree_int_cst_equal (arg0
, arg1
);
3074 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0
),
3075 TREE_FIXED_CST (arg1
));
3078 if (real_identical (&TREE_REAL_CST (arg0
), &TREE_REAL_CST (arg1
)))
3082 if (!HONOR_SIGNED_ZEROS (arg0
))
3084 /* If we do not distinguish between signed and unsigned zero,
3085 consider them equal. */
3086 if (real_zerop (arg0
) && real_zerop (arg1
))
3093 if (VECTOR_CST_LOG2_NPATTERNS (arg0
)
3094 != VECTOR_CST_LOG2_NPATTERNS (arg1
))
3097 if (VECTOR_CST_NELTS_PER_PATTERN (arg0
)
3098 != VECTOR_CST_NELTS_PER_PATTERN (arg1
))
3101 unsigned int count
= vector_cst_encoded_nelts (arg0
);
3102 for (unsigned int i
= 0; i
< count
; ++i
)
3103 if (!operand_equal_p (VECTOR_CST_ENCODED_ELT (arg0
, i
),
3104 VECTOR_CST_ENCODED_ELT (arg1
, i
), flags
))
3110 return (operand_equal_p (TREE_REALPART (arg0
), TREE_REALPART (arg1
),
3112 && operand_equal_p (TREE_IMAGPART (arg0
), TREE_IMAGPART (arg1
),
3116 return (TREE_STRING_LENGTH (arg0
) == TREE_STRING_LENGTH (arg1
)
3117 && ! memcmp (TREE_STRING_POINTER (arg0
),
3118 TREE_STRING_POINTER (arg1
),
3119 TREE_STRING_LENGTH (arg0
)));
3122 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
3123 return operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0),
3124 flags
| OEP_ADDRESS_OF
3125 | OEP_MATCH_SIDE_EFFECTS
);
3127 /* In GIMPLE empty constructors are allowed in initializers of
3129 return !CONSTRUCTOR_NELTS (arg0
) && !CONSTRUCTOR_NELTS (arg1
);
3134 if (flags
& OEP_ONLY_CONST
)
3137 /* Define macros to test an operand from arg0 and arg1 for equality and a
3138 variant that allows null and views null as being different from any
3139 non-null value. In the latter case, if either is null, the both
3140 must be; otherwise, do the normal comparison. */
3141 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
3142 TREE_OPERAND (arg1, N), flags)
3144 #define OP_SAME_WITH_NULL(N) \
3145 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3146 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3148 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
3151 /* Two conversions are equal only if signedness and modes match. */
3152 switch (TREE_CODE (arg0
))
3155 case FIX_TRUNC_EXPR
:
3156 if (TYPE_UNSIGNED (TREE_TYPE (arg0
))
3157 != TYPE_UNSIGNED (TREE_TYPE (arg1
)))
3167 case tcc_comparison
:
3169 if (OP_SAME (0) && OP_SAME (1))
3172 /* For commutative ops, allow the other order. */
3173 return (commutative_tree_code (TREE_CODE (arg0
))
3174 && operand_equal_p (TREE_OPERAND (arg0
, 0),
3175 TREE_OPERAND (arg1
, 1), flags
)
3176 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3177 TREE_OPERAND (arg1
, 0), flags
));
3180 /* If either of the pointer (or reference) expressions we are
3181 dereferencing contain a side effect, these cannot be equal,
3182 but their addresses can be. */
3183 if ((flags
& OEP_MATCH_SIDE_EFFECTS
) == 0
3184 && (TREE_SIDE_EFFECTS (arg0
)
3185 || TREE_SIDE_EFFECTS (arg1
)))
3188 switch (TREE_CODE (arg0
))
3191 if (!(flags
& OEP_ADDRESS_OF
)
3192 && (TYPE_ALIGN (TREE_TYPE (arg0
))
3193 != TYPE_ALIGN (TREE_TYPE (arg1
))))
3195 flags
&= ~OEP_ADDRESS_OF
;
3199 /* Require the same offset. */
3200 if (!operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3201 TYPE_SIZE (TREE_TYPE (arg1
)),
3202 flags
& ~OEP_ADDRESS_OF
))
3207 case VIEW_CONVERT_EXPR
:
3210 case TARGET_MEM_REF
:
3212 if (!(flags
& OEP_ADDRESS_OF
))
3214 /* Require equal access sizes */
3215 if (TYPE_SIZE (TREE_TYPE (arg0
)) != TYPE_SIZE (TREE_TYPE (arg1
))
3216 && (!TYPE_SIZE (TREE_TYPE (arg0
))
3217 || !TYPE_SIZE (TREE_TYPE (arg1
))
3218 || !operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3219 TYPE_SIZE (TREE_TYPE (arg1
)),
3222 /* Verify that access happens in similar types. */
3223 if (!types_compatible_p (TREE_TYPE (arg0
), TREE_TYPE (arg1
)))
3225 /* Verify that accesses are TBAA compatible. */
3226 if (!alias_ptr_types_compatible_p
3227 (TREE_TYPE (TREE_OPERAND (arg0
, 1)),
3228 TREE_TYPE (TREE_OPERAND (arg1
, 1)))
3229 || (MR_DEPENDENCE_CLIQUE (arg0
)
3230 != MR_DEPENDENCE_CLIQUE (arg1
))
3231 || (MR_DEPENDENCE_BASE (arg0
)
3232 != MR_DEPENDENCE_BASE (arg1
)))
3234 /* Verify that alignment is compatible. */
3235 if (TYPE_ALIGN (TREE_TYPE (arg0
))
3236 != TYPE_ALIGN (TREE_TYPE (arg1
)))
3239 flags
&= ~OEP_ADDRESS_OF
;
3240 return (OP_SAME (0) && OP_SAME (1)
3241 /* TARGET_MEM_REF require equal extra operands. */
3242 && (TREE_CODE (arg0
) != TARGET_MEM_REF
3243 || (OP_SAME_WITH_NULL (2)
3244 && OP_SAME_WITH_NULL (3)
3245 && OP_SAME_WITH_NULL (4))));
3248 case ARRAY_RANGE_REF
:
3251 flags
&= ~OEP_ADDRESS_OF
;
3252 /* Compare the array index by value if it is constant first as we
3253 may have different types but same value here. */
3254 return ((tree_int_cst_equal (TREE_OPERAND (arg0
, 1),
3255 TREE_OPERAND (arg1
, 1))
3257 && OP_SAME_WITH_NULL (2)
3258 && OP_SAME_WITH_NULL (3)
3259 /* Compare low bound and element size as with OEP_ADDRESS_OF
3260 we have to account for the offset of the ref. */
3261 && (TREE_TYPE (TREE_OPERAND (arg0
, 0))
3262 == TREE_TYPE (TREE_OPERAND (arg1
, 0))
3263 || (operand_equal_p (array_ref_low_bound
3264 (CONST_CAST_TREE (arg0
)),
3266 (CONST_CAST_TREE (arg1
)), flags
)
3267 && operand_equal_p (array_ref_element_size
3268 (CONST_CAST_TREE (arg0
)),
3269 array_ref_element_size
3270 (CONST_CAST_TREE (arg1
)),
3274 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3275 may be NULL when we're called to compare MEM_EXPRs. */
3276 if (!OP_SAME_WITH_NULL (0)
3279 flags
&= ~OEP_ADDRESS_OF
;
3280 return OP_SAME_WITH_NULL (2);
3285 flags
&= ~OEP_ADDRESS_OF
;
3286 return OP_SAME (1) && OP_SAME (2);
3292 case tcc_expression
:
3293 switch (TREE_CODE (arg0
))
3296 /* Be sure we pass right ADDRESS_OF flag. */
3297 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
3298 return operand_equal_p (TREE_OPERAND (arg0
, 0),
3299 TREE_OPERAND (arg1
, 0),
3300 flags
| OEP_ADDRESS_OF
);
3302 case TRUTH_NOT_EXPR
:
3305 case TRUTH_ANDIF_EXPR
:
3306 case TRUTH_ORIF_EXPR
:
3307 return OP_SAME (0) && OP_SAME (1);
3309 case WIDEN_MULT_PLUS_EXPR
:
3310 case WIDEN_MULT_MINUS_EXPR
:
3313 /* The multiplcation operands are commutative. */
3316 case TRUTH_AND_EXPR
:
3318 case TRUTH_XOR_EXPR
:
3319 if (OP_SAME (0) && OP_SAME (1))
3322 /* Otherwise take into account this is a commutative operation. */
3323 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
3324 TREE_OPERAND (arg1
, 1), flags
)
3325 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3326 TREE_OPERAND (arg1
, 0), flags
));
3329 if (! OP_SAME (1) || ! OP_SAME_WITH_NULL (2))
3331 flags
&= ~OEP_ADDRESS_OF
;
3334 case BIT_INSERT_EXPR
:
3335 /* BIT_INSERT_EXPR has an implict operand as the type precision
3336 of op1. Need to check to make sure they are the same. */
3337 if (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
3338 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
3339 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 1)))
3340 != TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 1))))
3346 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3351 case PREDECREMENT_EXPR
:
3352 case PREINCREMENT_EXPR
:
3353 case POSTDECREMENT_EXPR
:
3354 case POSTINCREMENT_EXPR
:
3355 if (flags
& OEP_LEXICOGRAPHIC
)
3356 return OP_SAME (0) && OP_SAME (1);
3359 case CLEANUP_POINT_EXPR
:
3361 if (flags
& OEP_LEXICOGRAPHIC
)
3370 switch (TREE_CODE (arg0
))
3373 if ((CALL_EXPR_FN (arg0
) == NULL_TREE
)
3374 != (CALL_EXPR_FN (arg1
) == NULL_TREE
))
3375 /* If not both CALL_EXPRs are either internal or normal function
3376 functions, then they are not equal. */
3378 else if (CALL_EXPR_FN (arg0
) == NULL_TREE
)
3380 /* If the CALL_EXPRs call different internal functions, then they
3382 if (CALL_EXPR_IFN (arg0
) != CALL_EXPR_IFN (arg1
))
3387 /* If the CALL_EXPRs call different functions, then they are not
3389 if (! operand_equal_p (CALL_EXPR_FN (arg0
), CALL_EXPR_FN (arg1
),
3394 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3396 unsigned int cef
= call_expr_flags (arg0
);
3397 if (flags
& OEP_PURE_SAME
)
3398 cef
&= ECF_CONST
| ECF_PURE
;
3401 if (!cef
&& !(flags
& OEP_LEXICOGRAPHIC
))
3405 /* Now see if all the arguments are the same. */
3407 const_call_expr_arg_iterator iter0
, iter1
;
3409 for (a0
= first_const_call_expr_arg (arg0
, &iter0
),
3410 a1
= first_const_call_expr_arg (arg1
, &iter1
);
3412 a0
= next_const_call_expr_arg (&iter0
),
3413 a1
= next_const_call_expr_arg (&iter1
))
3414 if (! operand_equal_p (a0
, a1
, flags
))
3417 /* If we get here and both argument lists are exhausted
3418 then the CALL_EXPRs are equal. */
3419 return ! (a0
|| a1
);
3425 case tcc_declaration
:
3426 /* Consider __builtin_sqrt equal to sqrt. */
3427 return (TREE_CODE (arg0
) == FUNCTION_DECL
3428 && DECL_BUILT_IN (arg0
) && DECL_BUILT_IN (arg1
)
3429 && DECL_BUILT_IN_CLASS (arg0
) == DECL_BUILT_IN_CLASS (arg1
)
3430 && DECL_FUNCTION_CODE (arg0
) == DECL_FUNCTION_CODE (arg1
));
3432 case tcc_exceptional
:
3433 if (TREE_CODE (arg0
) == CONSTRUCTOR
)
3435 /* In GIMPLE constructors are used only to build vectors from
3436 elements. Individual elements in the constructor must be
3437 indexed in increasing order and form an initial sequence.
3439 We make no effort to compare constructors in generic.
3440 (see sem_variable::equals in ipa-icf which can do so for
3442 if (!VECTOR_TYPE_P (TREE_TYPE (arg0
))
3443 || !VECTOR_TYPE_P (TREE_TYPE (arg1
)))
3446 /* Be sure that vectors constructed have the same representation.
3447 We only tested element precision and modes to match.
3448 Vectors may be BLKmode and thus also check that the number of
3450 if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)),
3451 TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
))))
3454 vec
<constructor_elt
, va_gc
> *v0
= CONSTRUCTOR_ELTS (arg0
);
3455 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (arg1
);
3456 unsigned int len
= vec_safe_length (v0
);
3458 if (len
!= vec_safe_length (v1
))
3461 for (unsigned int i
= 0; i
< len
; i
++)
3463 constructor_elt
*c0
= &(*v0
)[i
];
3464 constructor_elt
*c1
= &(*v1
)[i
];
3466 if (!operand_equal_p (c0
->value
, c1
->value
, flags
)
3467 /* In GIMPLE the indexes can be either NULL or matching i.
3468 Double check this so we won't get false
3469 positives for GENERIC. */
3471 && (TREE_CODE (c0
->index
) != INTEGER_CST
3472 || !compare_tree_int (c0
->index
, i
)))
3474 && (TREE_CODE (c1
->index
) != INTEGER_CST
3475 || !compare_tree_int (c1
->index
, i
))))
3480 else if (TREE_CODE (arg0
) == STATEMENT_LIST
3481 && (flags
& OEP_LEXICOGRAPHIC
))
3483 /* Compare the STATEMENT_LISTs. */
3484 tree_stmt_iterator tsi1
, tsi2
;
3485 tree body1
= CONST_CAST_TREE (arg0
);
3486 tree body2
= CONST_CAST_TREE (arg1
);
3487 for (tsi1
= tsi_start (body1
), tsi2
= tsi_start (body2
); ;
3488 tsi_next (&tsi1
), tsi_next (&tsi2
))
3490 /* The lists don't have the same number of statements. */
3491 if (tsi_end_p (tsi1
) ^ tsi_end_p (tsi2
))
3493 if (tsi_end_p (tsi1
) && tsi_end_p (tsi2
))
3495 if (!operand_equal_p (tsi_stmt (tsi1
), tsi_stmt (tsi2
),
3496 flags
& (OEP_LEXICOGRAPHIC
3497 | OEP_NO_HASH_CHECK
)))
3504 switch (TREE_CODE (arg0
))
3507 if (flags
& OEP_LEXICOGRAPHIC
)
3508 return OP_SAME_WITH_NULL (0);
3510 case DEBUG_BEGIN_STMT
:
3511 if (flags
& OEP_LEXICOGRAPHIC
)
3523 #undef OP_SAME_WITH_NULL
3526 /* Similar to operand_equal_p, but see if ARG0 might be a variant of ARG1
3527 with a different signedness or a narrower precision. */
3530 operand_equal_for_comparison_p (tree arg0
, tree arg1
)
3532 if (operand_equal_p (arg0
, arg1
, 0))
3535 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
3536 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
3539 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3540 and see if the inner values are the same. This removes any
3541 signedness comparison, which doesn't matter here. */
3546 if (operand_equal_p (op0
, op1
, 0))
3549 /* Discard a single widening conversion from ARG1 and see if the inner
3550 value is the same as ARG0. */
3551 if (CONVERT_EXPR_P (arg1
)
3552 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
3553 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
3554 < TYPE_PRECISION (TREE_TYPE (arg1
))
3555 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
3561 /* See if ARG is an expression that is either a comparison or is performing
3562 arithmetic on comparisons. The comparisons must only be comparing
3563 two different values, which will be stored in *CVAL1 and *CVAL2; if
3564 they are nonzero it means that some operands have already been found.
3565 No variables may be used anywhere else in the expression except in the
3568 If this is true, return 1. Otherwise, return zero. */
3571 twoval_comparison_p (tree arg
, tree
*cval1
, tree
*cval2
)
3573 enum tree_code code
= TREE_CODE (arg
);
3574 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3576 /* We can handle some of the tcc_expression cases here. */
3577 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3579 else if (tclass
== tcc_expression
3580 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
3581 || code
== COMPOUND_EXPR
))
3582 tclass
= tcc_binary
;
3587 return twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
);
3590 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
)
3591 && twoval_comparison_p (TREE_OPERAND (arg
, 1), cval1
, cval2
));
3596 case tcc_expression
:
3597 if (code
== COND_EXPR
)
3598 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
)
3599 && twoval_comparison_p (TREE_OPERAND (arg
, 1), cval1
, cval2
)
3600 && twoval_comparison_p (TREE_OPERAND (arg
, 2), cval1
, cval2
));
3603 case tcc_comparison
:
3604 /* First see if we can handle the first operand, then the second. For
3605 the second operand, we know *CVAL1 can't be zero. It must be that
3606 one side of the comparison is each of the values; test for the
3607 case where this isn't true by failing if the two operands
3610 if (operand_equal_p (TREE_OPERAND (arg
, 0),
3611 TREE_OPERAND (arg
, 1), 0))
3615 *cval1
= TREE_OPERAND (arg
, 0);
3616 else if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 0), 0))
3618 else if (*cval2
== 0)
3619 *cval2
= TREE_OPERAND (arg
, 0);
3620 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 0), 0))
3625 if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 1), 0))
3627 else if (*cval2
== 0)
3628 *cval2
= TREE_OPERAND (arg
, 1);
3629 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 1), 0))
3641 /* ARG is a tree that is known to contain just arithmetic operations and
3642 comparisons. Evaluate the operations in the tree substituting NEW0 for
3643 any occurrence of OLD0 as an operand of a comparison and likewise for
3647 eval_subst (location_t loc
, tree arg
, tree old0
, tree new0
,
3648 tree old1
, tree new1
)
3650 tree type
= TREE_TYPE (arg
);
3651 enum tree_code code
= TREE_CODE (arg
);
3652 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3654 /* We can handle some of the tcc_expression cases here. */
3655 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3657 else if (tclass
== tcc_expression
3658 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
3659 tclass
= tcc_binary
;
3664 return fold_build1_loc (loc
, code
, type
,
3665 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3666 old0
, new0
, old1
, new1
));
3669 return fold_build2_loc (loc
, code
, type
,
3670 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3671 old0
, new0
, old1
, new1
),
3672 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3673 old0
, new0
, old1
, new1
));
3675 case tcc_expression
:
3679 return eval_subst (loc
, TREE_OPERAND (arg
, 0), old0
, new0
,
3683 return eval_subst (loc
, TREE_OPERAND (arg
, 1), old0
, new0
,
3687 return fold_build3_loc (loc
, code
, type
,
3688 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3689 old0
, new0
, old1
, new1
),
3690 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3691 old0
, new0
, old1
, new1
),
3692 eval_subst (loc
, TREE_OPERAND (arg
, 2),
3693 old0
, new0
, old1
, new1
));
3697 /* Fall through - ??? */
3699 case tcc_comparison
:
3701 tree arg0
= TREE_OPERAND (arg
, 0);
3702 tree arg1
= TREE_OPERAND (arg
, 1);
3704 /* We need to check both for exact equality and tree equality. The
3705 former will be true if the operand has a side-effect. In that
3706 case, we know the operand occurred exactly once. */
3708 if (arg0
== old0
|| operand_equal_p (arg0
, old0
, 0))
3710 else if (arg0
== old1
|| operand_equal_p (arg0
, old1
, 0))
3713 if (arg1
== old0
|| operand_equal_p (arg1
, old0
, 0))
3715 else if (arg1
== old1
|| operand_equal_p (arg1
, old1
, 0))
3718 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
3726 /* Return a tree for the case when the result of an expression is RESULT
3727 converted to TYPE and OMITTED was previously an operand of the expression
3728 but is now not needed (e.g., we folded OMITTED * 0).
3730 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3731 the conversion of RESULT to TYPE. */
3734 omit_one_operand_loc (location_t loc
, tree type
, tree result
, tree omitted
)
3736 tree t
= fold_convert_loc (loc
, type
, result
);
3738 /* If the resulting operand is an empty statement, just return the omitted
3739 statement casted to void. */
3740 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
3741 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
3742 fold_ignored_result (omitted
));
3744 if (TREE_SIDE_EFFECTS (omitted
))
3745 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3746 fold_ignored_result (omitted
), t
);
3748 return non_lvalue_loc (loc
, t
);
3751 /* Return a tree for the case when the result of an expression is RESULT
3752 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3753 of the expression but are now not needed.
3755 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3756 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3757 evaluated before OMITTED2. Otherwise, if neither has side effects,
3758 just do the conversion of RESULT to TYPE. */
3761 omit_two_operands_loc (location_t loc
, tree type
, tree result
,
3762 tree omitted1
, tree omitted2
)
3764 tree t
= fold_convert_loc (loc
, type
, result
);
3766 if (TREE_SIDE_EFFECTS (omitted2
))
3767 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted2
, t
);
3768 if (TREE_SIDE_EFFECTS (omitted1
))
3769 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted1
, t
);
3771 return TREE_CODE (t
) != COMPOUND_EXPR
? non_lvalue_loc (loc
, t
) : t
;
3775 /* Return a simplified tree node for the truth-negation of ARG. This
3776 never alters ARG itself. We assume that ARG is an operation that
3777 returns a truth value (0 or 1).
3779 FIXME: one would think we would fold the result, but it causes
3780 problems with the dominator optimizer. */
3783 fold_truth_not_expr (location_t loc
, tree arg
)
3785 tree type
= TREE_TYPE (arg
);
3786 enum tree_code code
= TREE_CODE (arg
);
3787 location_t loc1
, loc2
;
3789 /* If this is a comparison, we can simply invert it, except for
3790 floating-point non-equality comparisons, in which case we just
3791 enclose a TRUTH_NOT_EXPR around what we have. */
3793 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3795 tree op_type
= TREE_TYPE (TREE_OPERAND (arg
, 0));
3796 if (FLOAT_TYPE_P (op_type
)
3797 && flag_trapping_math
3798 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
3799 && code
!= NE_EXPR
&& code
!= EQ_EXPR
)
3802 code
= invert_tree_comparison (code
, HONOR_NANS (op_type
));
3803 if (code
== ERROR_MARK
)
3806 tree ret
= build2_loc (loc
, code
, type
, TREE_OPERAND (arg
, 0),
3807 TREE_OPERAND (arg
, 1));
3808 if (TREE_NO_WARNING (arg
))
3809 TREE_NO_WARNING (ret
) = 1;
3816 return constant_boolean_node (integer_zerop (arg
), type
);
3818 case TRUTH_AND_EXPR
:
3819 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3820 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3821 return build2_loc (loc
, TRUTH_OR_EXPR
, type
,
3822 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3823 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3826 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3827 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3828 return build2_loc (loc
, TRUTH_AND_EXPR
, type
,
3829 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3830 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3832 case TRUTH_XOR_EXPR
:
3833 /* Here we can invert either operand. We invert the first operand
3834 unless the second operand is a TRUTH_NOT_EXPR in which case our
3835 result is the XOR of the first operand with the inside of the
3836 negation of the second operand. */
3838 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == TRUTH_NOT_EXPR
)
3839 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
, TREE_OPERAND (arg
, 0),
3840 TREE_OPERAND (TREE_OPERAND (arg
, 1), 0));
3842 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
,
3843 invert_truthvalue_loc (loc
, TREE_OPERAND (arg
, 0)),
3844 TREE_OPERAND (arg
, 1));
3846 case TRUTH_ANDIF_EXPR
:
3847 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3848 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3849 return build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
3850 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3851 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3853 case TRUTH_ORIF_EXPR
:
3854 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3855 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3856 return build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
3857 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3858 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3860 case TRUTH_NOT_EXPR
:
3861 return TREE_OPERAND (arg
, 0);
3865 tree arg1
= TREE_OPERAND (arg
, 1);
3866 tree arg2
= TREE_OPERAND (arg
, 2);
3868 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3869 loc2
= expr_location_or (TREE_OPERAND (arg
, 2), loc
);
3871 /* A COND_EXPR may have a throw as one operand, which
3872 then has void type. Just leave void operands
3874 return build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
3875 VOID_TYPE_P (TREE_TYPE (arg1
))
3876 ? arg1
: invert_truthvalue_loc (loc1
, arg1
),
3877 VOID_TYPE_P (TREE_TYPE (arg2
))
3878 ? arg2
: invert_truthvalue_loc (loc2
, arg2
));
3882 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3883 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3884 TREE_OPERAND (arg
, 0),
3885 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 1)));
3887 case NON_LVALUE_EXPR
:
3888 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3889 return invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0));
3892 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
3893 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3898 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3899 return build1_loc (loc
, TREE_CODE (arg
), type
,
3900 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3903 if (!integer_onep (TREE_OPERAND (arg
, 1)))
3905 return build2_loc (loc
, EQ_EXPR
, type
, arg
, build_int_cst (type
, 0));
3908 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3910 case CLEANUP_POINT_EXPR
:
3911 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3912 return build1_loc (loc
, CLEANUP_POINT_EXPR
, type
,
3913 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3920 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3921 assume that ARG is an operation that returns a truth value (0 or 1
3922 for scalars, 0 or -1 for vectors). Return the folded expression if
3923 folding is successful. Otherwise, return NULL_TREE. */
3926 fold_invert_truthvalue (location_t loc
, tree arg
)
3928 tree type
= TREE_TYPE (arg
);
3929 return fold_unary_loc (loc
, VECTOR_TYPE_P (type
)
3935 /* Return a simplified tree node for the truth-negation of ARG. This
3936 never alters ARG itself. We assume that ARG is an operation that
3937 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3940 invert_truthvalue_loc (location_t loc
, tree arg
)
3942 if (TREE_CODE (arg
) == ERROR_MARK
)
3945 tree type
= TREE_TYPE (arg
);
3946 return fold_build1_loc (loc
, VECTOR_TYPE_P (type
)
3952 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3953 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3954 and uses reverse storage order if REVERSEP is nonzero. ORIG_INNER
3955 is the original memory reference used to preserve the alias set of
3959 make_bit_field_ref (location_t loc
, tree inner
, tree orig_inner
, tree type
,
3960 HOST_WIDE_INT bitsize
, poly_int64 bitpos
,
3961 int unsignedp
, int reversep
)
3963 tree result
, bftype
;
3965 /* Attempt not to lose the access path if possible. */
3966 if (TREE_CODE (orig_inner
) == COMPONENT_REF
)
3968 tree ninner
= TREE_OPERAND (orig_inner
, 0);
3970 poly_int64 nbitsize
, nbitpos
;
3972 int nunsignedp
, nreversep
, nvolatilep
= 0;
3973 tree base
= get_inner_reference (ninner
, &nbitsize
, &nbitpos
,
3974 &noffset
, &nmode
, &nunsignedp
,
3975 &nreversep
, &nvolatilep
);
3977 && noffset
== NULL_TREE
3978 && known_subrange_p (bitpos
, bitsize
, nbitpos
, nbitsize
)
3988 alias_set_type iset
= get_alias_set (orig_inner
);
3989 if (iset
== 0 && get_alias_set (inner
) != iset
)
3990 inner
= fold_build2 (MEM_REF
, TREE_TYPE (inner
),
3991 build_fold_addr_expr (inner
),
3992 build_int_cst (ptr_type_node
, 0));
3994 if (known_eq (bitpos
, 0) && !reversep
)
3996 tree size
= TYPE_SIZE (TREE_TYPE (inner
));
3997 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner
))
3998 || POINTER_TYPE_P (TREE_TYPE (inner
)))
3999 && tree_fits_shwi_p (size
)
4000 && tree_to_shwi (size
) == bitsize
)
4001 return fold_convert_loc (loc
, type
, inner
);
4005 if (TYPE_PRECISION (bftype
) != bitsize
4006 || TYPE_UNSIGNED (bftype
) == !unsignedp
)
4007 bftype
= build_nonstandard_integer_type (bitsize
, 0);
4009 result
= build3_loc (loc
, BIT_FIELD_REF
, bftype
, inner
,
4010 bitsize_int (bitsize
), bitsize_int (bitpos
));
4011 REF_REVERSE_STORAGE_ORDER (result
) = reversep
;
4014 result
= fold_convert_loc (loc
, type
, result
);
4019 /* Optimize a bit-field compare.
4021 There are two cases: First is a compare against a constant and the
4022 second is a comparison of two items where the fields are at the same
4023 bit position relative to the start of a chunk (byte, halfword, word)
4024 large enough to contain it. In these cases we can avoid the shift
4025 implicit in bitfield extractions.
4027 For constants, we emit a compare of the shifted constant with the
4028 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
4029 compared. For two fields at the same position, we do the ANDs with the
4030 similar mask and compare the result of the ANDs.
4032 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
4033 COMPARE_TYPE is the type of the comparison, and LHS and RHS
4034 are the left and right operands of the comparison, respectively.
4036 If the optimization described above can be done, we return the resulting
4037 tree. Otherwise we return zero. */
4040 optimize_bit_field_compare (location_t loc
, enum tree_code code
,
4041 tree compare_type
, tree lhs
, tree rhs
)
4043 poly_int64 plbitpos
, plbitsize
, rbitpos
, rbitsize
;
4044 HOST_WIDE_INT lbitpos
, lbitsize
, nbitpos
, nbitsize
;
4045 tree type
= TREE_TYPE (lhs
);
4047 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
4048 machine_mode lmode
, rmode
;
4049 scalar_int_mode nmode
;
4050 int lunsignedp
, runsignedp
;
4051 int lreversep
, rreversep
;
4052 int lvolatilep
= 0, rvolatilep
= 0;
4053 tree linner
, rinner
= NULL_TREE
;
4057 /* Get all the information about the extractions being done. If the bit size
4058 is the same as the size of the underlying object, we aren't doing an
4059 extraction at all and so can do nothing. We also don't want to
4060 do anything if the inner expression is a PLACEHOLDER_EXPR since we
4061 then will no longer be able to replace it. */
4062 linner
= get_inner_reference (lhs
, &plbitsize
, &plbitpos
, &offset
, &lmode
,
4063 &lunsignedp
, &lreversep
, &lvolatilep
);
4065 || !known_size_p (plbitsize
)
4066 || !plbitsize
.is_constant (&lbitsize
)
4067 || !plbitpos
.is_constant (&lbitpos
)
4068 || known_eq (lbitsize
, GET_MODE_BITSIZE (lmode
))
4070 || TREE_CODE (linner
) == PLACEHOLDER_EXPR
4075 rreversep
= lreversep
;
4078 /* If this is not a constant, we can only do something if bit positions,
4079 sizes, signedness and storage order are the same. */
4081 = get_inner_reference (rhs
, &rbitsize
, &rbitpos
, &offset
, &rmode
,
4082 &runsignedp
, &rreversep
, &rvolatilep
);
4085 || maybe_ne (lbitpos
, rbitpos
)
4086 || maybe_ne (lbitsize
, rbitsize
)
4087 || lunsignedp
!= runsignedp
4088 || lreversep
!= rreversep
4090 || TREE_CODE (rinner
) == PLACEHOLDER_EXPR
4095 /* Honor the C++ memory model and mimic what RTL expansion does. */
4096 poly_uint64 bitstart
= 0;
4097 poly_uint64 bitend
= 0;
4098 if (TREE_CODE (lhs
) == COMPONENT_REF
)
4100 get_bit_range (&bitstart
, &bitend
, lhs
, &plbitpos
, &offset
);
4101 if (!plbitpos
.is_constant (&lbitpos
) || offset
!= NULL_TREE
)
4105 /* See if we can find a mode to refer to this field. We should be able to,
4106 but fail if we can't. */
4107 if (!get_best_mode (lbitsize
, lbitpos
, bitstart
, bitend
,
4108 const_p
? TYPE_ALIGN (TREE_TYPE (linner
))
4109 : MIN (TYPE_ALIGN (TREE_TYPE (linner
)),
4110 TYPE_ALIGN (TREE_TYPE (rinner
))),
4111 BITS_PER_WORD
, false, &nmode
))
4114 /* Set signed and unsigned types of the precision of this mode for the
4116 unsigned_type
= lang_hooks
.types
.type_for_mode (nmode
, 1);
4118 /* Compute the bit position and size for the new reference and our offset
4119 within it. If the new reference is the same size as the original, we
4120 won't optimize anything, so return zero. */
4121 nbitsize
= GET_MODE_BITSIZE (nmode
);
4122 nbitpos
= lbitpos
& ~ (nbitsize
- 1);
4124 if (nbitsize
== lbitsize
)
4127 if (lreversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
4128 lbitpos
= nbitsize
- lbitsize
- lbitpos
;
4130 /* Make the mask to be used against the extracted field. */
4131 mask
= build_int_cst_type (unsigned_type
, -1);
4132 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (nbitsize
- lbitsize
));
4133 mask
= const_binop (RSHIFT_EXPR
, mask
,
4134 size_int (nbitsize
- lbitsize
- lbitpos
));
4141 /* If not comparing with constant, just rework the comparison
4143 tree t1
= make_bit_field_ref (loc
, linner
, lhs
, unsigned_type
,
4144 nbitsize
, nbitpos
, 1, lreversep
);
4145 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
, t1
, mask
);
4146 tree t2
= make_bit_field_ref (loc
, rinner
, rhs
, unsigned_type
,
4147 nbitsize
, nbitpos
, 1, rreversep
);
4148 t2
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
, t2
, mask
);
4149 return fold_build2_loc (loc
, code
, compare_type
, t1
, t2
);
4152 /* Otherwise, we are handling the constant case. See if the constant is too
4153 big for the field. Warn and return a tree for 0 (false) if so. We do
4154 this not only for its own sake, but to avoid having to test for this
4155 error case below. If we didn't, we might generate wrong code.
4157 For unsigned fields, the constant shifted right by the field length should
4158 be all zero. For signed fields, the high-order bits should agree with
4163 if (wi::lrshift (wi::to_wide (rhs
), lbitsize
) != 0)
4165 warning (0, "comparison is always %d due to width of bit-field",
4167 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
4172 wide_int tem
= wi::arshift (wi::to_wide (rhs
), lbitsize
- 1);
4173 if (tem
!= 0 && tem
!= -1)
4175 warning (0, "comparison is always %d due to width of bit-field",
4177 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
4184 /* Single-bit compares should always be against zero. */
4185 if (lbitsize
== 1 && ! integer_zerop (rhs
))
4187 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
4188 rhs
= build_int_cst (type
, 0);
4191 /* Make a new bitfield reference, shift the constant over the
4192 appropriate number of bits and mask it with the computed mask
4193 (in case this was a signed field). If we changed it, make a new one. */
4194 lhs
= make_bit_field_ref (loc
, linner
, lhs
, unsigned_type
,
4195 nbitsize
, nbitpos
, 1, lreversep
);
4197 rhs
= const_binop (BIT_AND_EXPR
,
4198 const_binop (LSHIFT_EXPR
,
4199 fold_convert_loc (loc
, unsigned_type
, rhs
),
4200 size_int (lbitpos
)),
4203 lhs
= build2_loc (loc
, code
, compare_type
,
4204 build2 (BIT_AND_EXPR
, unsigned_type
, lhs
, mask
), rhs
);
4208 /* Subroutine for fold_truth_andor_1: decode a field reference.
4210 If EXP is a comparison reference, we return the innermost reference.
4212 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4213 set to the starting bit number.
4215 If the innermost field can be completely contained in a mode-sized
4216 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4218 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4219 otherwise it is not changed.
4221 *PUNSIGNEDP is set to the signedness of the field.
4223 *PREVERSEP is set to the storage order of the field.
4225 *PMASK is set to the mask used. This is either contained in a
4226 BIT_AND_EXPR or derived from the width of the field.
4228 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4230 Return 0 if this is not a component reference or is one that we can't
4231 do anything with. */
4234 decode_field_reference (location_t loc
, tree
*exp_
, HOST_WIDE_INT
*pbitsize
,
4235 HOST_WIDE_INT
*pbitpos
, machine_mode
*pmode
,
4236 int *punsignedp
, int *preversep
, int *pvolatilep
,
4237 tree
*pmask
, tree
*pand_mask
)
4240 tree outer_type
= 0;
4242 tree mask
, inner
, offset
;
4244 unsigned int precision
;
4246 /* All the optimizations using this function assume integer fields.
4247 There are problems with FP fields since the type_for_size call
4248 below can fail for, e.g., XFmode. */
4249 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp
)))
4252 /* We are interested in the bare arrangement of bits, so strip everything
4253 that doesn't affect the machine mode. However, record the type of the
4254 outermost expression if it may matter below. */
4255 if (CONVERT_EXPR_P (exp
)
4256 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4257 outer_type
= TREE_TYPE (exp
);
4260 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
4262 and_mask
= TREE_OPERAND (exp
, 1);
4263 exp
= TREE_OPERAND (exp
, 0);
4264 STRIP_NOPS (exp
); STRIP_NOPS (and_mask
);
4265 if (TREE_CODE (and_mask
) != INTEGER_CST
)
4269 poly_int64 poly_bitsize
, poly_bitpos
;
4270 inner
= get_inner_reference (exp
, &poly_bitsize
, &poly_bitpos
, &offset
,
4271 pmode
, punsignedp
, preversep
, pvolatilep
);
4272 if ((inner
== exp
&& and_mask
== 0)
4273 || !poly_bitsize
.is_constant (pbitsize
)
4274 || !poly_bitpos
.is_constant (pbitpos
)
4277 || TREE_CODE (inner
) == PLACEHOLDER_EXPR
4278 /* Reject out-of-bound accesses (PR79731). */
4279 || (! AGGREGATE_TYPE_P (TREE_TYPE (inner
))
4280 && compare_tree_int (TYPE_SIZE (TREE_TYPE (inner
)),
4281 *pbitpos
+ *pbitsize
) < 0))
4286 /* If the number of bits in the reference is the same as the bitsize of
4287 the outer type, then the outer type gives the signedness. Otherwise
4288 (in case of a small bitfield) the signedness is unchanged. */
4289 if (outer_type
&& *pbitsize
== TYPE_PRECISION (outer_type
))
4290 *punsignedp
= TYPE_UNSIGNED (outer_type
);
4292 /* Compute the mask to access the bitfield. */
4293 unsigned_type
= lang_hooks
.types
.type_for_size (*pbitsize
, 1);
4294 precision
= TYPE_PRECISION (unsigned_type
);
4296 mask
= build_int_cst_type (unsigned_type
, -1);
4298 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4299 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4301 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4303 mask
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
4304 fold_convert_loc (loc
, unsigned_type
, and_mask
), mask
);
4307 *pand_mask
= and_mask
;
4311 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4312 bit positions and MASK is SIGNED. */
4315 all_ones_mask_p (const_tree mask
, unsigned int size
)
4317 tree type
= TREE_TYPE (mask
);
4318 unsigned int precision
= TYPE_PRECISION (type
);
4320 /* If this function returns true when the type of the mask is
4321 UNSIGNED, then there will be errors. In particular see
4322 gcc.c-torture/execute/990326-1.c. There does not appear to be
4323 any documentation paper trail as to why this is so. But the pre
4324 wide-int worked with that restriction and it has been preserved
4326 if (size
> precision
|| TYPE_SIGN (type
) == UNSIGNED
)
4329 return wi::mask (size
, false, precision
) == wi::to_wide (mask
);
4332 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4333 represents the sign bit of EXP's type. If EXP represents a sign
4334 or zero extension, also test VAL against the unextended type.
4335 The return value is the (sub)expression whose sign bit is VAL,
4336 or NULL_TREE otherwise. */
4339 sign_bit_p (tree exp
, const_tree val
)
4344 /* Tree EXP must have an integral type. */
4345 t
= TREE_TYPE (exp
);
4346 if (! INTEGRAL_TYPE_P (t
))
4349 /* Tree VAL must be an integer constant. */
4350 if (TREE_CODE (val
) != INTEGER_CST
4351 || TREE_OVERFLOW (val
))
4354 width
= TYPE_PRECISION (t
);
4355 if (wi::only_sign_bit_p (wi::to_wide (val
), width
))
4358 /* Handle extension from a narrower type. */
4359 if (TREE_CODE (exp
) == NOP_EXPR
4360 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))) < width
)
4361 return sign_bit_p (TREE_OPERAND (exp
, 0), val
);
4366 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4367 to be evaluated unconditionally. */
4370 simple_operand_p (const_tree exp
)
4372 /* Strip any conversions that don't change the machine mode. */
4375 return (CONSTANT_CLASS_P (exp
)
4376 || TREE_CODE (exp
) == SSA_NAME
4378 && ! TREE_ADDRESSABLE (exp
)
4379 && ! TREE_THIS_VOLATILE (exp
)
4380 && ! DECL_NONLOCAL (exp
)
4381 /* Don't regard global variables as simple. They may be
4382 allocated in ways unknown to the compiler (shared memory,
4383 #pragma weak, etc). */
4384 && ! TREE_PUBLIC (exp
)
4385 && ! DECL_EXTERNAL (exp
)
4386 /* Weakrefs are not safe to be read, since they can be NULL.
4387 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4388 have DECL_WEAK flag set. */
4389 && (! VAR_OR_FUNCTION_DECL_P (exp
) || ! DECL_WEAK (exp
))
4390 /* Loading a static variable is unduly expensive, but global
4391 registers aren't expensive. */
4392 && (! TREE_STATIC (exp
) || DECL_REGISTER (exp
))));
4395 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4396 to be evaluated unconditionally.
4397 I addition to simple_operand_p, we assume that comparisons, conversions,
4398 and logic-not operations are simple, if their operands are simple, too. */
4401 simple_operand_p_2 (tree exp
)
4403 enum tree_code code
;
4405 if (TREE_SIDE_EFFECTS (exp
)
4406 || tree_could_trap_p (exp
))
4409 while (CONVERT_EXPR_P (exp
))
4410 exp
= TREE_OPERAND (exp
, 0);
4412 code
= TREE_CODE (exp
);
4414 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
4415 return (simple_operand_p (TREE_OPERAND (exp
, 0))
4416 && simple_operand_p (TREE_OPERAND (exp
, 1)));
4418 if (code
== TRUTH_NOT_EXPR
)
4419 return simple_operand_p_2 (TREE_OPERAND (exp
, 0));
4421 return simple_operand_p (exp
);
4425 /* The following functions are subroutines to fold_range_test and allow it to
4426 try to change a logical combination of comparisons into a range test.
4429 X == 2 || X == 3 || X == 4 || X == 5
4433 (unsigned) (X - 2) <= 3
4435 We describe each set of comparisons as being either inside or outside
4436 a range, using a variable named like IN_P, and then describe the
4437 range with a lower and upper bound. If one of the bounds is omitted,
4438 it represents either the highest or lowest value of the type.
4440 In the comments below, we represent a range by two numbers in brackets
4441 preceded by a "+" to designate being inside that range, or a "-" to
4442 designate being outside that range, so the condition can be inverted by
4443 flipping the prefix. An omitted bound is represented by a "-". For
4444 example, "- [-, 10]" means being outside the range starting at the lowest
4445 possible value and ending at 10, in other words, being greater than 10.
4446 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4449 We set up things so that the missing bounds are handled in a consistent
4450 manner so neither a missing bound nor "true" and "false" need to be
4451 handled using a special case. */
4453 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4454 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4455 and UPPER1_P are nonzero if the respective argument is an upper bound
4456 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4457 must be specified for a comparison. ARG1 will be converted to ARG0's
4458 type if both are specified. */
4461 range_binop (enum tree_code code
, tree type
, tree arg0
, int upper0_p
,
4462 tree arg1
, int upper1_p
)
4468 /* If neither arg represents infinity, do the normal operation.
4469 Else, if not a comparison, return infinity. Else handle the special
4470 comparison rules. Note that most of the cases below won't occur, but
4471 are handled for consistency. */
4473 if (arg0
!= 0 && arg1
!= 0)
4475 tem
= fold_build2 (code
, type
!= 0 ? type
: TREE_TYPE (arg0
),
4476 arg0
, fold_convert (TREE_TYPE (arg0
), arg1
));
4478 return TREE_CODE (tem
) == INTEGER_CST
? tem
: 0;
4481 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
4484 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4485 for neither. In real maths, we cannot assume open ended ranges are
4486 the same. But, this is computer arithmetic, where numbers are finite.
4487 We can therefore make the transformation of any unbounded range with
4488 the value Z, Z being greater than any representable number. This permits
4489 us to treat unbounded ranges as equal. */
4490 sgn0
= arg0
!= 0 ? 0 : (upper0_p
? 1 : -1);
4491 sgn1
= arg1
!= 0 ? 0 : (upper1_p
? 1 : -1);
4495 result
= sgn0
== sgn1
;
4498 result
= sgn0
!= sgn1
;
4501 result
= sgn0
< sgn1
;
4504 result
= sgn0
<= sgn1
;
4507 result
= sgn0
> sgn1
;
4510 result
= sgn0
>= sgn1
;
4516 return constant_boolean_node (result
, type
);
4519 /* Helper routine for make_range. Perform one step for it, return
4520 new expression if the loop should continue or NULL_TREE if it should
4524 make_range_step (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
,
4525 tree exp_type
, tree
*p_low
, tree
*p_high
, int *p_in_p
,
4526 bool *strict_overflow_p
)
4528 tree arg0_type
= TREE_TYPE (arg0
);
4529 tree n_low
, n_high
, low
= *p_low
, high
= *p_high
;
4530 int in_p
= *p_in_p
, n_in_p
;
4534 case TRUTH_NOT_EXPR
:
4535 /* We can only do something if the range is testing for zero. */
4536 if (low
== NULL_TREE
|| high
== NULL_TREE
4537 || ! integer_zerop (low
) || ! integer_zerop (high
))
4542 case EQ_EXPR
: case NE_EXPR
:
4543 case LT_EXPR
: case LE_EXPR
: case GE_EXPR
: case GT_EXPR
:
4544 /* We can only do something if the range is testing for zero
4545 and if the second operand is an integer constant. Note that
4546 saying something is "in" the range we make is done by
4547 complementing IN_P since it will set in the initial case of
4548 being not equal to zero; "out" is leaving it alone. */
4549 if (low
== NULL_TREE
|| high
== NULL_TREE
4550 || ! integer_zerop (low
) || ! integer_zerop (high
)
4551 || TREE_CODE (arg1
) != INTEGER_CST
)
4556 case NE_EXPR
: /* - [c, c] */
4559 case EQ_EXPR
: /* + [c, c] */
4560 in_p
= ! in_p
, low
= high
= arg1
;
4562 case GT_EXPR
: /* - [-, c] */
4563 low
= 0, high
= arg1
;
4565 case GE_EXPR
: /* + [c, -] */
4566 in_p
= ! in_p
, low
= arg1
, high
= 0;
4568 case LT_EXPR
: /* - [c, -] */
4569 low
= arg1
, high
= 0;
4571 case LE_EXPR
: /* + [-, c] */
4572 in_p
= ! in_p
, low
= 0, high
= arg1
;
4578 /* If this is an unsigned comparison, we also know that EXP is
4579 greater than or equal to zero. We base the range tests we make
4580 on that fact, so we record it here so we can parse existing
4581 range tests. We test arg0_type since often the return type
4582 of, e.g. EQ_EXPR, is boolean. */
4583 if (TYPE_UNSIGNED (arg0_type
) && (low
== 0 || high
== 0))
4585 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
4587 build_int_cst (arg0_type
, 0),
4591 in_p
= n_in_p
, low
= n_low
, high
= n_high
;
4593 /* If the high bound is missing, but we have a nonzero low
4594 bound, reverse the range so it goes from zero to the low bound
4596 if (high
== 0 && low
&& ! integer_zerop (low
))
4599 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low
, 0,
4600 build_int_cst (TREE_TYPE (low
), 1), 0);
4601 low
= build_int_cst (arg0_type
, 0);
4611 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4612 low and high are non-NULL, then normalize will DTRT. */
4613 if (!TYPE_UNSIGNED (arg0_type
)
4614 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4616 if (low
== NULL_TREE
)
4617 low
= TYPE_MIN_VALUE (arg0_type
);
4618 if (high
== NULL_TREE
)
4619 high
= TYPE_MAX_VALUE (arg0_type
);
4622 /* (-x) IN [a,b] -> x in [-b, -a] */
4623 n_low
= range_binop (MINUS_EXPR
, exp_type
,
4624 build_int_cst (exp_type
, 0),
4626 n_high
= range_binop (MINUS_EXPR
, exp_type
,
4627 build_int_cst (exp_type
, 0),
4629 if (n_high
!= 0 && TREE_OVERFLOW (n_high
))
4635 return build2_loc (loc
, MINUS_EXPR
, exp_type
, negate_expr (arg0
),
4636 build_int_cst (exp_type
, 1));
4640 if (TREE_CODE (arg1
) != INTEGER_CST
)
4643 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4644 move a constant to the other side. */
4645 if (!TYPE_UNSIGNED (arg0_type
)
4646 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4649 /* If EXP is signed, any overflow in the computation is undefined,
4650 so we don't worry about it so long as our computations on
4651 the bounds don't overflow. For unsigned, overflow is defined
4652 and this is exactly the right thing. */
4653 n_low
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4654 arg0_type
, low
, 0, arg1
, 0);
4655 n_high
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4656 arg0_type
, high
, 1, arg1
, 0);
4657 if ((n_low
!= 0 && TREE_OVERFLOW (n_low
))
4658 || (n_high
!= 0 && TREE_OVERFLOW (n_high
)))
4661 if (TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4662 *strict_overflow_p
= true;
4665 /* Check for an unsigned range which has wrapped around the maximum
4666 value thus making n_high < n_low, and normalize it. */
4667 if (n_low
&& n_high
&& tree_int_cst_lt (n_high
, n_low
))
4669 low
= range_binop (PLUS_EXPR
, arg0_type
, n_high
, 0,
4670 build_int_cst (TREE_TYPE (n_high
), 1), 0);
4671 high
= range_binop (MINUS_EXPR
, arg0_type
, n_low
, 0,
4672 build_int_cst (TREE_TYPE (n_low
), 1), 0);
4674 /* If the range is of the form +/- [ x+1, x ], we won't
4675 be able to normalize it. But then, it represents the
4676 whole range or the empty set, so make it
4678 if (tree_int_cst_equal (n_low
, low
)
4679 && tree_int_cst_equal (n_high
, high
))
4685 low
= n_low
, high
= n_high
;
4693 case NON_LVALUE_EXPR
:
4694 if (TYPE_PRECISION (arg0_type
) > TYPE_PRECISION (exp_type
))
4697 if (! INTEGRAL_TYPE_P (arg0_type
)
4698 || (low
!= 0 && ! int_fits_type_p (low
, arg0_type
))
4699 || (high
!= 0 && ! int_fits_type_p (high
, arg0_type
)))
4702 n_low
= low
, n_high
= high
;
4705 n_low
= fold_convert_loc (loc
, arg0_type
, n_low
);
4708 n_high
= fold_convert_loc (loc
, arg0_type
, n_high
);
4710 /* If we're converting arg0 from an unsigned type, to exp,
4711 a signed type, we will be doing the comparison as unsigned.
4712 The tests above have already verified that LOW and HIGH
4715 So we have to ensure that we will handle large unsigned
4716 values the same way that the current signed bounds treat
4719 if (!TYPE_UNSIGNED (exp_type
) && TYPE_UNSIGNED (arg0_type
))
4723 /* For fixed-point modes, we need to pass the saturating flag
4724 as the 2nd parameter. */
4725 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type
)))
4727 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
),
4728 TYPE_SATURATING (arg0_type
));
4731 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
), 1);
4733 /* A range without an upper bound is, naturally, unbounded.
4734 Since convert would have cropped a very large value, use
4735 the max value for the destination type. */
4737 = TYPE_MAX_VALUE (equiv_type
) ? TYPE_MAX_VALUE (equiv_type
)
4738 : TYPE_MAX_VALUE (arg0_type
);
4740 if (TYPE_PRECISION (exp_type
) == TYPE_PRECISION (arg0_type
))
4741 high_positive
= fold_build2_loc (loc
, RSHIFT_EXPR
, arg0_type
,
4742 fold_convert_loc (loc
, arg0_type
,
4744 build_int_cst (arg0_type
, 1));
4746 /* If the low bound is specified, "and" the range with the
4747 range for which the original unsigned value will be
4751 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 1, n_low
, n_high
,
4752 1, fold_convert_loc (loc
, arg0_type
,
4757 in_p
= (n_in_p
== in_p
);
4761 /* Otherwise, "or" the range with the range of the input
4762 that will be interpreted as negative. */
4763 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 0, n_low
, n_high
,
4764 1, fold_convert_loc (loc
, arg0_type
,
4769 in_p
= (in_p
!= n_in_p
);
4783 /* Given EXP, a logical expression, set the range it is testing into
4784 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4785 actually being tested. *PLOW and *PHIGH will be made of the same
4786 type as the returned expression. If EXP is not a comparison, we
4787 will most likely not be returning a useful value and range. Set
4788 *STRICT_OVERFLOW_P to true if the return value is only valid
4789 because signed overflow is undefined; otherwise, do not change
4790 *STRICT_OVERFLOW_P. */
4793 make_range (tree exp
, int *pin_p
, tree
*plow
, tree
*phigh
,
4794 bool *strict_overflow_p
)
4796 enum tree_code code
;
4797 tree arg0
, arg1
= NULL_TREE
;
4798 tree exp_type
, nexp
;
4801 location_t loc
= EXPR_LOCATION (exp
);
4803 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4804 and see if we can refine the range. Some of the cases below may not
4805 happen, but it doesn't seem worth worrying about this. We "continue"
4806 the outer loop when we've changed something; otherwise we "break"
4807 the switch, which will "break" the while. */
4810 low
= high
= build_int_cst (TREE_TYPE (exp
), 0);
4814 code
= TREE_CODE (exp
);
4815 exp_type
= TREE_TYPE (exp
);
4818 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
4820 if (TREE_OPERAND_LENGTH (exp
) > 0)
4821 arg0
= TREE_OPERAND (exp
, 0);
4822 if (TREE_CODE_CLASS (code
) == tcc_binary
4823 || TREE_CODE_CLASS (code
) == tcc_comparison
4824 || (TREE_CODE_CLASS (code
) == tcc_expression
4825 && TREE_OPERAND_LENGTH (exp
) > 1))
4826 arg1
= TREE_OPERAND (exp
, 1);
4828 if (arg0
== NULL_TREE
)
4831 nexp
= make_range_step (loc
, code
, arg0
, arg1
, exp_type
, &low
,
4832 &high
, &in_p
, strict_overflow_p
);
4833 if (nexp
== NULL_TREE
)
4838 /* If EXP is a constant, we can evaluate whether this is true or false. */
4839 if (TREE_CODE (exp
) == INTEGER_CST
)
4841 in_p
= in_p
== (integer_onep (range_binop (GE_EXPR
, integer_type_node
,
4843 && integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4849 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4853 /* Returns TRUE if [LOW, HIGH] range check can be optimized to
4854 a bitwise check i.e. when
4855 LOW == 0xXX...X00...0
4856 HIGH == 0xXX...X11...1
4857 Return corresponding mask in MASK and stem in VALUE. */
4860 maskable_range_p (const_tree low
, const_tree high
, tree type
, tree
*mask
,
4863 if (TREE_CODE (low
) != INTEGER_CST
4864 || TREE_CODE (high
) != INTEGER_CST
)
4867 unsigned prec
= TYPE_PRECISION (type
);
4868 wide_int lo
= wi::to_wide (low
, prec
);
4869 wide_int hi
= wi::to_wide (high
, prec
);
4871 wide_int end_mask
= lo
^ hi
;
4872 if ((end_mask
& (end_mask
+ 1)) != 0
4873 || (lo
& end_mask
) != 0)
4876 wide_int stem_mask
= ~end_mask
;
4877 wide_int stem
= lo
& stem_mask
;
4878 if (stem
!= (hi
& stem_mask
))
4881 *mask
= wide_int_to_tree (type
, stem_mask
);
4882 *value
= wide_int_to_tree (type
, stem
);
4887 /* Helper routine for build_range_check and match.pd. Return the type to
4888 perform the check or NULL if it shouldn't be optimized. */
4891 range_check_type (tree etype
)
4893 /* First make sure that arithmetics in this type is valid, then make sure
4894 that it wraps around. */
4895 if (TREE_CODE (etype
) == ENUMERAL_TYPE
|| TREE_CODE (etype
) == BOOLEAN_TYPE
)
4896 etype
= lang_hooks
.types
.type_for_size (TYPE_PRECISION (etype
),
4897 TYPE_UNSIGNED (etype
));
4899 if (TREE_CODE (etype
) == INTEGER_TYPE
&& !TYPE_OVERFLOW_WRAPS (etype
))
4901 tree utype
, minv
, maxv
;
4903 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4904 for the type in question, as we rely on this here. */
4905 utype
= unsigned_type_for (etype
);
4906 maxv
= fold_convert (utype
, TYPE_MAX_VALUE (etype
));
4907 maxv
= range_binop (PLUS_EXPR
, NULL_TREE
, maxv
, 1,
4908 build_int_cst (TREE_TYPE (maxv
), 1), 1);
4909 minv
= fold_convert (utype
, TYPE_MIN_VALUE (etype
));
4911 if (integer_zerop (range_binop (NE_EXPR
, integer_type_node
,
4920 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4921 type, TYPE, return an expression to test if EXP is in (or out of, depending
4922 on IN_P) the range. Return 0 if the test couldn't be created. */
4925 build_range_check (location_t loc
, tree type
, tree exp
, int in_p
,
4926 tree low
, tree high
)
4928 tree etype
= TREE_TYPE (exp
), mask
, value
;
4930 /* Disable this optimization for function pointer expressions
4931 on targets that require function pointer canonicalization. */
4932 if (targetm
.have_canonicalize_funcptr_for_compare ()
4933 && TREE_CODE (etype
) == POINTER_TYPE
4934 && TREE_CODE (TREE_TYPE (etype
)) == FUNCTION_TYPE
)
4939 value
= build_range_check (loc
, type
, exp
, 1, low
, high
);
4941 return invert_truthvalue_loc (loc
, value
);
4946 if (low
== 0 && high
== 0)
4947 return omit_one_operand_loc (loc
, type
, build_int_cst (type
, 1), exp
);
4950 return fold_build2_loc (loc
, LE_EXPR
, type
, exp
,
4951 fold_convert_loc (loc
, etype
, high
));
4954 return fold_build2_loc (loc
, GE_EXPR
, type
, exp
,
4955 fold_convert_loc (loc
, etype
, low
));
4957 if (operand_equal_p (low
, high
, 0))
4958 return fold_build2_loc (loc
, EQ_EXPR
, type
, exp
,
4959 fold_convert_loc (loc
, etype
, low
));
4961 if (TREE_CODE (exp
) == BIT_AND_EXPR
4962 && maskable_range_p (low
, high
, etype
, &mask
, &value
))
4963 return fold_build2_loc (loc
, EQ_EXPR
, type
,
4964 fold_build2_loc (loc
, BIT_AND_EXPR
, etype
,
4968 if (integer_zerop (low
))
4970 if (! TYPE_UNSIGNED (etype
))
4972 etype
= unsigned_type_for (etype
);
4973 high
= fold_convert_loc (loc
, etype
, high
);
4974 exp
= fold_convert_loc (loc
, etype
, exp
);
4976 return build_range_check (loc
, type
, exp
, 1, 0, high
);
4979 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4980 if (integer_onep (low
) && TREE_CODE (high
) == INTEGER_CST
)
4982 int prec
= TYPE_PRECISION (etype
);
4984 if (wi::mask
<widest_int
> (prec
- 1, false) == wi::to_widest (high
))
4986 if (TYPE_UNSIGNED (etype
))
4988 tree signed_etype
= signed_type_for (etype
);
4989 if (TYPE_PRECISION (signed_etype
) != TYPE_PRECISION (etype
))
4991 = build_nonstandard_integer_type (TYPE_PRECISION (etype
), 0);
4993 etype
= signed_etype
;
4994 exp
= fold_convert_loc (loc
, etype
, exp
);
4996 return fold_build2_loc (loc
, GT_EXPR
, type
, exp
,
4997 build_int_cst (etype
, 0));
5001 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
5002 This requires wrap-around arithmetics for the type of the expression. */
5003 etype
= range_check_type (etype
);
5004 if (etype
== NULL_TREE
)
5007 if (POINTER_TYPE_P (etype
))
5008 etype
= unsigned_type_for (etype
);
5010 high
= fold_convert_loc (loc
, etype
, high
);
5011 low
= fold_convert_loc (loc
, etype
, low
);
5012 exp
= fold_convert_loc (loc
, etype
, exp
);
5014 value
= const_binop (MINUS_EXPR
, high
, low
);
5016 if (value
!= 0 && !TREE_OVERFLOW (value
))
5017 return build_range_check (loc
, type
,
5018 fold_build2_loc (loc
, MINUS_EXPR
, etype
, exp
, low
),
5019 1, build_int_cst (etype
, 0), value
);
5024 /* Return the predecessor of VAL in its type, handling the infinite case. */
5027 range_predecessor (tree val
)
5029 tree type
= TREE_TYPE (val
);
5031 if (INTEGRAL_TYPE_P (type
)
5032 && operand_equal_p (val
, TYPE_MIN_VALUE (type
), 0))
5035 return range_binop (MINUS_EXPR
, NULL_TREE
, val
, 0,
5036 build_int_cst (TREE_TYPE (val
), 1), 0);
5039 /* Return the successor of VAL in its type, handling the infinite case. */
5042 range_successor (tree val
)
5044 tree type
= TREE_TYPE (val
);
5046 if (INTEGRAL_TYPE_P (type
)
5047 && operand_equal_p (val
, TYPE_MAX_VALUE (type
), 0))
5050 return range_binop (PLUS_EXPR
, NULL_TREE
, val
, 0,
5051 build_int_cst (TREE_TYPE (val
), 1), 0);
5054 /* Given two ranges, see if we can merge them into one. Return 1 if we
5055 can, 0 if we can't. Set the output range into the specified parameters. */
5058 merge_ranges (int *pin_p
, tree
*plow
, tree
*phigh
, int in0_p
, tree low0
,
5059 tree high0
, int in1_p
, tree low1
, tree high1
)
5067 int lowequal
= ((low0
== 0 && low1
== 0)
5068 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
5069 low0
, 0, low1
, 0)));
5070 int highequal
= ((high0
== 0 && high1
== 0)
5071 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
5072 high0
, 1, high1
, 1)));
5074 /* Make range 0 be the range that starts first, or ends last if they
5075 start at the same value. Swap them if it isn't. */
5076 if (integer_onep (range_binop (GT_EXPR
, integer_type_node
,
5079 && integer_onep (range_binop (GT_EXPR
, integer_type_node
,
5080 high1
, 1, high0
, 1))))
5082 temp
= in0_p
, in0_p
= in1_p
, in1_p
= temp
;
5083 tem
= low0
, low0
= low1
, low1
= tem
;
5084 tem
= high0
, high0
= high1
, high1
= tem
;
5087 /* If the second range is != high1 where high1 is the type maximum of
5088 the type, try first merging with < high1 range. */
5091 && TREE_CODE (low1
) == INTEGER_CST
5092 && (TREE_CODE (TREE_TYPE (low1
)) == INTEGER_TYPE
5093 || (TREE_CODE (TREE_TYPE (low1
)) == ENUMERAL_TYPE
5094 && known_eq (TYPE_PRECISION (TREE_TYPE (low1
)),
5095 GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low1
))))))
5096 && operand_equal_p (low1
, high1
, 0))
5098 if (tree_int_cst_equal (low1
, TYPE_MAX_VALUE (TREE_TYPE (low1
)))
5099 && merge_ranges (pin_p
, plow
, phigh
, in0_p
, low0
, high0
,
5100 !in1_p
, NULL_TREE
, range_predecessor (low1
)))
5102 /* Similarly for the second range != low1 where low1 is the type minimum
5103 of the type, try first merging with > low1 range. */
5104 if (tree_int_cst_equal (low1
, TYPE_MIN_VALUE (TREE_TYPE (low1
)))
5105 && merge_ranges (pin_p
, plow
, phigh
, in0_p
, low0
, high0
,
5106 !in1_p
, range_successor (low1
), NULL_TREE
))
5110 /* Now flag two cases, whether the ranges are disjoint or whether the
5111 second range is totally subsumed in the first. Note that the tests
5112 below are simplified by the ones above. */
5113 no_overlap
= integer_onep (range_binop (LT_EXPR
, integer_type_node
,
5114 high0
, 1, low1
, 0));
5115 subset
= integer_onep (range_binop (LE_EXPR
, integer_type_node
,
5116 high1
, 1, high0
, 1));
5118 /* We now have four cases, depending on whether we are including or
5119 excluding the two ranges. */
5122 /* If they don't overlap, the result is false. If the second range
5123 is a subset it is the result. Otherwise, the range is from the start
5124 of the second to the end of the first. */
5126 in_p
= 0, low
= high
= 0;
5128 in_p
= 1, low
= low1
, high
= high1
;
5130 in_p
= 1, low
= low1
, high
= high0
;
5133 else if (in0_p
&& ! in1_p
)
5135 /* If they don't overlap, the result is the first range. If they are
5136 equal, the result is false. If the second range is a subset of the
5137 first, and the ranges begin at the same place, we go from just after
5138 the end of the second range to the end of the first. If the second
5139 range is not a subset of the first, or if it is a subset and both
5140 ranges end at the same place, the range starts at the start of the
5141 first range and ends just before the second range.
5142 Otherwise, we can't describe this as a single range. */
5144 in_p
= 1, low
= low0
, high
= high0
;
5145 else if (lowequal
&& highequal
)
5146 in_p
= 0, low
= high
= 0;
5147 else if (subset
&& lowequal
)
5149 low
= range_successor (high1
);
5154 /* We are in the weird situation where high0 > high1 but
5155 high1 has no successor. Punt. */
5159 else if (! subset
|| highequal
)
5162 high
= range_predecessor (low1
);
5166 /* low0 < low1 but low1 has no predecessor. Punt. */
5174 else if (! in0_p
&& in1_p
)
5176 /* If they don't overlap, the result is the second range. If the second
5177 is a subset of the first, the result is false. Otherwise,
5178 the range starts just after the first range and ends at the
5179 end of the second. */
5181 in_p
= 1, low
= low1
, high
= high1
;
5182 else if (subset
|| highequal
)
5183 in_p
= 0, low
= high
= 0;
5186 low
= range_successor (high0
);
5191 /* high1 > high0 but high0 has no successor. Punt. */
5199 /* The case where we are excluding both ranges. Here the complex case
5200 is if they don't overlap. In that case, the only time we have a
5201 range is if they are adjacent. If the second is a subset of the
5202 first, the result is the first. Otherwise, the range to exclude
5203 starts at the beginning of the first range and ends at the end of the
5207 if (integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
5208 range_successor (high0
),
5210 in_p
= 0, low
= low0
, high
= high1
;
5213 /* Canonicalize - [min, x] into - [-, x]. */
5214 if (low0
&& TREE_CODE (low0
) == INTEGER_CST
)
5215 switch (TREE_CODE (TREE_TYPE (low0
)))
5218 if (maybe_ne (TYPE_PRECISION (TREE_TYPE (low0
)),
5220 (TYPE_MODE (TREE_TYPE (low0
)))))
5224 if (tree_int_cst_equal (low0
,
5225 TYPE_MIN_VALUE (TREE_TYPE (low0
))))
5229 if (TYPE_UNSIGNED (TREE_TYPE (low0
))
5230 && integer_zerop (low0
))
5237 /* Canonicalize - [x, max] into - [x, -]. */
5238 if (high1
&& TREE_CODE (high1
) == INTEGER_CST
)
5239 switch (TREE_CODE (TREE_TYPE (high1
)))
5242 if (maybe_ne (TYPE_PRECISION (TREE_TYPE (high1
)),
5244 (TYPE_MODE (TREE_TYPE (high1
)))))
5248 if (tree_int_cst_equal (high1
,
5249 TYPE_MAX_VALUE (TREE_TYPE (high1
))))
5253 if (TYPE_UNSIGNED (TREE_TYPE (high1
))
5254 && integer_zerop (range_binop (PLUS_EXPR
, NULL_TREE
,
5256 build_int_cst (TREE_TYPE (high1
), 1),
5264 /* The ranges might be also adjacent between the maximum and
5265 minimum values of the given type. For
5266 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
5267 return + [x + 1, y - 1]. */
5268 if (low0
== 0 && high1
== 0)
5270 low
= range_successor (high0
);
5271 high
= range_predecessor (low1
);
5272 if (low
== 0 || high
== 0)
5282 in_p
= 0, low
= low0
, high
= high0
;
5284 in_p
= 0, low
= low0
, high
= high1
;
5287 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
5292 /* Subroutine of fold, looking inside expressions of the form
5293 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5294 of the COND_EXPR. This function is being used also to optimize
5295 A op B ? C : A, by reversing the comparison first.
5297 Return a folded expression whose code is not a COND_EXPR
5298 anymore, or NULL_TREE if no folding opportunity is found. */
5301 fold_cond_expr_with_comparison (location_t loc
, tree type
,
5302 tree arg0
, tree arg1
, tree arg2
)
5304 enum tree_code comp_code
= TREE_CODE (arg0
);
5305 tree arg00
= TREE_OPERAND (arg0
, 0);
5306 tree arg01
= TREE_OPERAND (arg0
, 1);
5307 tree arg1_type
= TREE_TYPE (arg1
);
5313 /* If we have A op 0 ? A : -A, consider applying the following
5316 A == 0? A : -A same as -A
5317 A != 0? A : -A same as A
5318 A >= 0? A : -A same as abs (A)
5319 A > 0? A : -A same as abs (A)
5320 A <= 0? A : -A same as -abs (A)
5321 A < 0? A : -A same as -abs (A)
5323 None of these transformations work for modes with signed
5324 zeros. If A is +/-0, the first two transformations will
5325 change the sign of the result (from +0 to -0, or vice
5326 versa). The last four will fix the sign of the result,
5327 even though the original expressions could be positive or
5328 negative, depending on the sign of A.
5330 Note that all these transformations are correct if A is
5331 NaN, since the two alternatives (A and -A) are also NaNs. */
5332 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5333 && (FLOAT_TYPE_P (TREE_TYPE (arg01
))
5334 ? real_zerop (arg01
)
5335 : integer_zerop (arg01
))
5336 && ((TREE_CODE (arg2
) == NEGATE_EXPR
5337 && operand_equal_p (TREE_OPERAND (arg2
, 0), arg1
, 0))
5338 /* In the case that A is of the form X-Y, '-A' (arg2) may
5339 have already been folded to Y-X, check for that. */
5340 || (TREE_CODE (arg1
) == MINUS_EXPR
5341 && TREE_CODE (arg2
) == MINUS_EXPR
5342 && operand_equal_p (TREE_OPERAND (arg1
, 0),
5343 TREE_OPERAND (arg2
, 1), 0)
5344 && operand_equal_p (TREE_OPERAND (arg1
, 1),
5345 TREE_OPERAND (arg2
, 0), 0))))
5350 tem
= fold_convert_loc (loc
, arg1_type
, arg1
);
5351 return fold_convert_loc (loc
, type
, negate_expr (tem
));
5354 return fold_convert_loc (loc
, type
, arg1
);
5357 if (flag_trapping_math
)
5362 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5364 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5365 return fold_convert_loc (loc
, type
, tem
);
5368 if (flag_trapping_math
)
5373 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5375 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5376 return negate_expr (fold_convert_loc (loc
, type
, tem
));
5378 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5382 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5383 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5384 both transformations are correct when A is NaN: A != 0
5385 is then true, and A == 0 is false. */
5387 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5388 && integer_zerop (arg01
) && integer_zerop (arg2
))
5390 if (comp_code
== NE_EXPR
)
5391 return fold_convert_loc (loc
, type
, arg1
);
5392 else if (comp_code
== EQ_EXPR
)
5393 return build_zero_cst (type
);
5396 /* Try some transformations of A op B ? A : B.
5398 A == B? A : B same as B
5399 A != B? A : B same as A
5400 A >= B? A : B same as max (A, B)
5401 A > B? A : B same as max (B, A)
5402 A <= B? A : B same as min (A, B)
5403 A < B? A : B same as min (B, A)
5405 As above, these transformations don't work in the presence
5406 of signed zeros. For example, if A and B are zeros of
5407 opposite sign, the first two transformations will change
5408 the sign of the result. In the last four, the original
5409 expressions give different results for (A=+0, B=-0) and
5410 (A=-0, B=+0), but the transformed expressions do not.
5412 The first two transformations are correct if either A or B
5413 is a NaN. In the first transformation, the condition will
5414 be false, and B will indeed be chosen. In the case of the
5415 second transformation, the condition A != B will be true,
5416 and A will be chosen.
5418 The conversions to max() and min() are not correct if B is
5419 a number and A is not. The conditions in the original
5420 expressions will be false, so all four give B. The min()
5421 and max() versions would give a NaN instead. */
5422 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5423 && operand_equal_for_comparison_p (arg01
, arg2
)
5424 /* Avoid these transformations if the COND_EXPR may be used
5425 as an lvalue in the C++ front-end. PR c++/19199. */
5427 || VECTOR_TYPE_P (type
)
5428 || (! lang_GNU_CXX ()
5429 && strcmp (lang_hooks
.name
, "GNU Objective-C++") != 0)
5430 || ! maybe_lvalue_p (arg1
)
5431 || ! maybe_lvalue_p (arg2
)))
5433 tree comp_op0
= arg00
;
5434 tree comp_op1
= arg01
;
5435 tree comp_type
= TREE_TYPE (comp_op0
);
5440 return fold_convert_loc (loc
, type
, arg2
);
5442 return fold_convert_loc (loc
, type
, arg1
);
5447 /* In C++ a ?: expression can be an lvalue, so put the
5448 operand which will be used if they are equal first
5449 so that we can convert this back to the
5450 corresponding COND_EXPR. */
5451 if (!HONOR_NANS (arg1
))
5453 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5454 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5455 tem
= (comp_code
== LE_EXPR
|| comp_code
== UNLE_EXPR
)
5456 ? fold_build2_loc (loc
, MIN_EXPR
, comp_type
, comp_op0
, comp_op1
)
5457 : fold_build2_loc (loc
, MIN_EXPR
, comp_type
,
5458 comp_op1
, comp_op0
);
5459 return fold_convert_loc (loc
, type
, tem
);
5466 if (!HONOR_NANS (arg1
))
5468 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5469 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5470 tem
= (comp_code
== GE_EXPR
|| comp_code
== UNGE_EXPR
)
5471 ? fold_build2_loc (loc
, MAX_EXPR
, comp_type
, comp_op0
, comp_op1
)
5472 : fold_build2_loc (loc
, MAX_EXPR
, comp_type
,
5473 comp_op1
, comp_op0
);
5474 return fold_convert_loc (loc
, type
, tem
);
5478 if (!HONOR_NANS (arg1
))
5479 return fold_convert_loc (loc
, type
, arg2
);
5482 if (!HONOR_NANS (arg1
))
5483 return fold_convert_loc (loc
, type
, arg1
);
5486 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5496 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5497 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5498 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5502 /* EXP is some logical combination of boolean tests. See if we can
5503 merge it into some range test. Return the new tree if so. */
5506 fold_range_test (location_t loc
, enum tree_code code
, tree type
,
5509 int or_op
= (code
== TRUTH_ORIF_EXPR
5510 || code
== TRUTH_OR_EXPR
);
5511 int in0_p
, in1_p
, in_p
;
5512 tree low0
, low1
, low
, high0
, high1
, high
;
5513 bool strict_overflow_p
= false;
5515 const char * const warnmsg
= G_("assuming signed overflow does not occur "
5516 "when simplifying range test");
5518 if (!INTEGRAL_TYPE_P (type
))
5521 lhs
= make_range (op0
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
5522 rhs
= make_range (op1
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
5524 /* If this is an OR operation, invert both sides; we will invert
5525 again at the end. */
5527 in0_p
= ! in0_p
, in1_p
= ! in1_p
;
5529 /* If both expressions are the same, if we can merge the ranges, and we
5530 can build the range test, return it or it inverted. If one of the
5531 ranges is always true or always false, consider it to be the same
5532 expression as the other. */
5533 if ((lhs
== 0 || rhs
== 0 || operand_equal_p (lhs
, rhs
, 0))
5534 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
5536 && (tem
= (build_range_check (loc
, type
,
5538 : rhs
!= 0 ? rhs
: integer_zero_node
,
5539 in_p
, low
, high
))) != 0)
5541 if (strict_overflow_p
)
5542 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
5543 return or_op
? invert_truthvalue_loc (loc
, tem
) : tem
;
5546 /* On machines where the branch cost is expensive, if this is a
5547 short-circuited branch and the underlying object on both sides
5548 is the same, make a non-short-circuit operation. */
5549 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5550 && !flag_sanitize_coverage
5551 && lhs
!= 0 && rhs
!= 0
5552 && (code
== TRUTH_ANDIF_EXPR
5553 || code
== TRUTH_ORIF_EXPR
)
5554 && operand_equal_p (lhs
, rhs
, 0))
5556 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5557 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5558 which cases we can't do this. */
5559 if (simple_operand_p (lhs
))
5560 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5561 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5564 else if (!lang_hooks
.decls
.global_bindings_p ()
5565 && !CONTAINS_PLACEHOLDER_P (lhs
))
5567 tree common
= save_expr (lhs
);
5569 if ((lhs
= build_range_check (loc
, type
, common
,
5570 or_op
? ! in0_p
: in0_p
,
5572 && (rhs
= build_range_check (loc
, type
, common
,
5573 or_op
? ! in1_p
: in1_p
,
5576 if (strict_overflow_p
)
5577 fold_overflow_warning (warnmsg
,
5578 WARN_STRICT_OVERFLOW_COMPARISON
);
5579 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5580 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5589 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5590 bit value. Arrange things so the extra bits will be set to zero if and
5591 only if C is signed-extended to its full width. If MASK is nonzero,
5592 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5595 unextend (tree c
, int p
, int unsignedp
, tree mask
)
5597 tree type
= TREE_TYPE (c
);
5598 int modesize
= GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (type
));
5601 if (p
== modesize
|| unsignedp
)
5604 /* We work by getting just the sign bit into the low-order bit, then
5605 into the high-order bit, then sign-extend. We then XOR that value
5607 temp
= build_int_cst (TREE_TYPE (c
),
5608 wi::extract_uhwi (wi::to_wide (c
), p
- 1, 1));
5610 /* We must use a signed type in order to get an arithmetic right shift.
5611 However, we must also avoid introducing accidental overflows, so that
5612 a subsequent call to integer_zerop will work. Hence we must
5613 do the type conversion here. At this point, the constant is either
5614 zero or one, and the conversion to a signed type can never overflow.
5615 We could get an overflow if this conversion is done anywhere else. */
5616 if (TYPE_UNSIGNED (type
))
5617 temp
= fold_convert (signed_type_for (type
), temp
);
5619 temp
= const_binop (LSHIFT_EXPR
, temp
, size_int (modesize
- 1));
5620 temp
= const_binop (RSHIFT_EXPR
, temp
, size_int (modesize
- p
- 1));
5622 temp
= const_binop (BIT_AND_EXPR
, temp
,
5623 fold_convert (TREE_TYPE (c
), mask
));
5624 /* If necessary, convert the type back to match the type of C. */
5625 if (TYPE_UNSIGNED (type
))
5626 temp
= fold_convert (type
, temp
);
5628 return fold_convert (type
, const_binop (BIT_XOR_EXPR
, c
, temp
));
5631 /* For an expression that has the form
5635 we can drop one of the inner expressions and simplify to
5639 LOC is the location of the resulting expression. OP is the inner
5640 logical operation; the left-hand side in the examples above, while CMPOP
5641 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5642 removing a condition that guards another, as in
5643 (A != NULL && A->...) || A == NULL
5644 which we must not transform. If RHS_ONLY is true, only eliminate the
5645 right-most operand of the inner logical operation. */
5648 merge_truthop_with_opposite_arm (location_t loc
, tree op
, tree cmpop
,
5651 tree type
= TREE_TYPE (cmpop
);
5652 enum tree_code code
= TREE_CODE (cmpop
);
5653 enum tree_code truthop_code
= TREE_CODE (op
);
5654 tree lhs
= TREE_OPERAND (op
, 0);
5655 tree rhs
= TREE_OPERAND (op
, 1);
5656 tree orig_lhs
= lhs
, orig_rhs
= rhs
;
5657 enum tree_code rhs_code
= TREE_CODE (rhs
);
5658 enum tree_code lhs_code
= TREE_CODE (lhs
);
5659 enum tree_code inv_code
;
5661 if (TREE_SIDE_EFFECTS (op
) || TREE_SIDE_EFFECTS (cmpop
))
5664 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
5667 if (rhs_code
== truthop_code
)
5669 tree newrhs
= merge_truthop_with_opposite_arm (loc
, rhs
, cmpop
, rhs_only
);
5670 if (newrhs
!= NULL_TREE
)
5673 rhs_code
= TREE_CODE (rhs
);
5676 if (lhs_code
== truthop_code
&& !rhs_only
)
5678 tree newlhs
= merge_truthop_with_opposite_arm (loc
, lhs
, cmpop
, false);
5679 if (newlhs
!= NULL_TREE
)
5682 lhs_code
= TREE_CODE (lhs
);
5686 inv_code
= invert_tree_comparison (code
, HONOR_NANS (type
));
5687 if (inv_code
== rhs_code
5688 && operand_equal_p (TREE_OPERAND (rhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5689 && operand_equal_p (TREE_OPERAND (rhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5691 if (!rhs_only
&& inv_code
== lhs_code
5692 && operand_equal_p (TREE_OPERAND (lhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5693 && operand_equal_p (TREE_OPERAND (lhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5695 if (rhs
!= orig_rhs
|| lhs
!= orig_lhs
)
5696 return fold_build2_loc (loc
, truthop_code
, TREE_TYPE (cmpop
),
5701 /* Find ways of folding logical expressions of LHS and RHS:
5702 Try to merge two comparisons to the same innermost item.
5703 Look for range tests like "ch >= '0' && ch <= '9'".
5704 Look for combinations of simple terms on machines with expensive branches
5705 and evaluate the RHS unconditionally.
5707 For example, if we have p->a == 2 && p->b == 4 and we can make an
5708 object large enough to span both A and B, we can do this with a comparison
5709 against the object ANDed with the a mask.
5711 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5712 operations to do this with one comparison.
5714 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5715 function and the one above.
5717 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5718 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5720 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5723 We return the simplified tree or 0 if no optimization is possible. */
5726 fold_truth_andor_1 (location_t loc
, enum tree_code code
, tree truth_type
,
5729 /* If this is the "or" of two comparisons, we can do something if
5730 the comparisons are NE_EXPR. If this is the "and", we can do something
5731 if the comparisons are EQ_EXPR. I.e.,
5732 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5734 WANTED_CODE is this operation code. For single bit fields, we can
5735 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5736 comparison for one-bit fields. */
5738 enum tree_code wanted_code
;
5739 enum tree_code lcode
, rcode
;
5740 tree ll_arg
, lr_arg
, rl_arg
, rr_arg
;
5741 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
5742 HOST_WIDE_INT ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
5743 HOST_WIDE_INT rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
5744 HOST_WIDE_INT xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
5745 HOST_WIDE_INT lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
5746 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
5747 int ll_reversep
, lr_reversep
, rl_reversep
, rr_reversep
;
5748 machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
5749 scalar_int_mode lnmode
, rnmode
;
5750 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
5751 tree ll_and_mask
, lr_and_mask
, rl_and_mask
, rr_and_mask
;
5752 tree l_const
, r_const
;
5753 tree lntype
, rntype
, result
;
5754 HOST_WIDE_INT first_bit
, end_bit
;
5757 /* Start by getting the comparison codes. Fail if anything is volatile.
5758 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5759 it were surrounded with a NE_EXPR. */
5761 if (TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
5764 lcode
= TREE_CODE (lhs
);
5765 rcode
= TREE_CODE (rhs
);
5767 if (lcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (lhs
, 1)))
5769 lhs
= build2 (NE_EXPR
, truth_type
, lhs
,
5770 build_int_cst (TREE_TYPE (lhs
), 0));
5774 if (rcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (rhs
, 1)))
5776 rhs
= build2 (NE_EXPR
, truth_type
, rhs
,
5777 build_int_cst (TREE_TYPE (rhs
), 0));
5781 if (TREE_CODE_CLASS (lcode
) != tcc_comparison
5782 || TREE_CODE_CLASS (rcode
) != tcc_comparison
)
5785 ll_arg
= TREE_OPERAND (lhs
, 0);
5786 lr_arg
= TREE_OPERAND (lhs
, 1);
5787 rl_arg
= TREE_OPERAND (rhs
, 0);
5788 rr_arg
= TREE_OPERAND (rhs
, 1);
5790 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5791 if (simple_operand_p (ll_arg
)
5792 && simple_operand_p (lr_arg
))
5794 if (operand_equal_p (ll_arg
, rl_arg
, 0)
5795 && operand_equal_p (lr_arg
, rr_arg
, 0))
5797 result
= combine_comparisons (loc
, code
, lcode
, rcode
,
5798 truth_type
, ll_arg
, lr_arg
);
5802 else if (operand_equal_p (ll_arg
, rr_arg
, 0)
5803 && operand_equal_p (lr_arg
, rl_arg
, 0))
5805 result
= combine_comparisons (loc
, code
, lcode
,
5806 swap_tree_comparison (rcode
),
5807 truth_type
, ll_arg
, lr_arg
);
5813 code
= ((code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
)
5814 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
);
5816 /* If the RHS can be evaluated unconditionally and its operands are
5817 simple, it wins to evaluate the RHS unconditionally on machines
5818 with expensive branches. In this case, this isn't a comparison
5819 that can be merged. */
5821 if (BRANCH_COST (optimize_function_for_speed_p (cfun
),
5823 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg
))
5824 && simple_operand_p (rl_arg
)
5825 && simple_operand_p (rr_arg
))
5827 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5828 if (code
== TRUTH_OR_EXPR
5829 && lcode
== NE_EXPR
&& integer_zerop (lr_arg
)
5830 && rcode
== NE_EXPR
&& integer_zerop (rr_arg
)
5831 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5832 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5833 return build2_loc (loc
, NE_EXPR
, truth_type
,
5834 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5836 build_int_cst (TREE_TYPE (ll_arg
), 0));
5838 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5839 if (code
== TRUTH_AND_EXPR
5840 && lcode
== EQ_EXPR
&& integer_zerop (lr_arg
)
5841 && rcode
== EQ_EXPR
&& integer_zerop (rr_arg
)
5842 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5843 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5844 return build2_loc (loc
, EQ_EXPR
, truth_type
,
5845 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5847 build_int_cst (TREE_TYPE (ll_arg
), 0));
5850 /* See if the comparisons can be merged. Then get all the parameters for
5853 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
5854 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
))
5857 ll_reversep
= lr_reversep
= rl_reversep
= rr_reversep
= 0;
5859 ll_inner
= decode_field_reference (loc
, &ll_arg
,
5860 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
5861 &ll_unsignedp
, &ll_reversep
, &volatilep
,
5862 &ll_mask
, &ll_and_mask
);
5863 lr_inner
= decode_field_reference (loc
, &lr_arg
,
5864 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
5865 &lr_unsignedp
, &lr_reversep
, &volatilep
,
5866 &lr_mask
, &lr_and_mask
);
5867 rl_inner
= decode_field_reference (loc
, &rl_arg
,
5868 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
5869 &rl_unsignedp
, &rl_reversep
, &volatilep
,
5870 &rl_mask
, &rl_and_mask
);
5871 rr_inner
= decode_field_reference (loc
, &rr_arg
,
5872 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
5873 &rr_unsignedp
, &rr_reversep
, &volatilep
,
5874 &rr_mask
, &rr_and_mask
);
5876 /* It must be true that the inner operation on the lhs of each
5877 comparison must be the same if we are to be able to do anything.
5878 Then see if we have constants. If not, the same must be true for
5881 || ll_reversep
!= rl_reversep
5882 || ll_inner
== 0 || rl_inner
== 0
5883 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
5886 if (TREE_CODE (lr_arg
) == INTEGER_CST
5887 && TREE_CODE (rr_arg
) == INTEGER_CST
)
5889 l_const
= lr_arg
, r_const
= rr_arg
;
5890 lr_reversep
= ll_reversep
;
5892 else if (lr_reversep
!= rr_reversep
5893 || lr_inner
== 0 || rr_inner
== 0
5894 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
5897 l_const
= r_const
= 0;
5899 /* If either comparison code is not correct for our logical operation,
5900 fail. However, we can convert a one-bit comparison against zero into
5901 the opposite comparison against that bit being set in the field. */
5903 wanted_code
= (code
== TRUTH_AND_EXPR
? EQ_EXPR
: NE_EXPR
);
5904 if (lcode
!= wanted_code
)
5906 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
5908 /* Make the left operand unsigned, since we are only interested
5909 in the value of one bit. Otherwise we are doing the wrong
5918 /* This is analogous to the code for l_const above. */
5919 if (rcode
!= wanted_code
)
5921 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
5930 /* See if we can find a mode that contains both fields being compared on
5931 the left. If we can't, fail. Otherwise, update all constants and masks
5932 to be relative to a field of that size. */
5933 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
5934 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
5935 if (!get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5936 TYPE_ALIGN (TREE_TYPE (ll_inner
)), BITS_PER_WORD
,
5937 volatilep
, &lnmode
))
5940 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
5941 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
5942 lntype
= lang_hooks
.types
.type_for_size (lnbitsize
, 1);
5943 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
5945 if (ll_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5947 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
5948 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
5951 ll_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, ll_mask
),
5952 size_int (xll_bitpos
));
5953 rl_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, rl_mask
),
5954 size_int (xrl_bitpos
));
5958 l_const
= fold_convert_loc (loc
, lntype
, l_const
);
5959 l_const
= unextend (l_const
, ll_bitsize
, ll_unsignedp
, ll_and_mask
);
5960 l_const
= const_binop (LSHIFT_EXPR
, l_const
, size_int (xll_bitpos
));
5961 if (! integer_zerop (const_binop (BIT_AND_EXPR
, l_const
,
5962 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5965 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5967 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5972 r_const
= fold_convert_loc (loc
, lntype
, r_const
);
5973 r_const
= unextend (r_const
, rl_bitsize
, rl_unsignedp
, rl_and_mask
);
5974 r_const
= const_binop (LSHIFT_EXPR
, r_const
, size_int (xrl_bitpos
));
5975 if (! integer_zerop (const_binop (BIT_AND_EXPR
, r_const
,
5976 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5979 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5981 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5985 /* If the right sides are not constant, do the same for it. Also,
5986 disallow this optimization if a size or signedness mismatch occurs
5987 between the left and right sides. */
5990 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
5991 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
5992 /* Make sure the two fields on the right
5993 correspond to the left without being swapped. */
5994 || ll_bitpos
- rl_bitpos
!= lr_bitpos
- rr_bitpos
)
5997 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
5998 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
5999 if (!get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
6000 TYPE_ALIGN (TREE_TYPE (lr_inner
)), BITS_PER_WORD
,
6001 volatilep
, &rnmode
))
6004 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
6005 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
6006 rntype
= lang_hooks
.types
.type_for_size (rnbitsize
, 1);
6007 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
6009 if (lr_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
6011 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
6012 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
6015 lr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
6017 size_int (xlr_bitpos
));
6018 rr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
6020 size_int (xrr_bitpos
));
6022 /* Make a mask that corresponds to both fields being compared.
6023 Do this for both items being compared. If the operands are the
6024 same size and the bits being compared are in the same position
6025 then we can do this by masking both and comparing the masked
6027 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
6028 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
);
6029 if (lnbitsize
== rnbitsize
6030 && xll_bitpos
== xlr_bitpos
6034 lhs
= make_bit_field_ref (loc
, ll_inner
, ll_arg
,
6035 lntype
, lnbitsize
, lnbitpos
,
6036 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
6037 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
6038 lhs
= build2 (BIT_AND_EXPR
, lntype
, lhs
, ll_mask
);
6040 rhs
= make_bit_field_ref (loc
, lr_inner
, lr_arg
,
6041 rntype
, rnbitsize
, rnbitpos
,
6042 lr_unsignedp
|| rr_unsignedp
, lr_reversep
);
6043 if (! all_ones_mask_p (lr_mask
, rnbitsize
))
6044 rhs
= build2 (BIT_AND_EXPR
, rntype
, rhs
, lr_mask
);
6046 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
6049 /* There is still another way we can do something: If both pairs of
6050 fields being compared are adjacent, we may be able to make a wider
6051 field containing them both.
6053 Note that we still must mask the lhs/rhs expressions. Furthermore,
6054 the mask must be shifted to account for the shift done by
6055 make_bit_field_ref. */
6056 if (((ll_bitsize
+ ll_bitpos
== rl_bitpos
6057 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
6058 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
6059 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
6067 lhs
= make_bit_field_ref (loc
, ll_inner
, ll_arg
, lntype
,
6068 ll_bitsize
+ rl_bitsize
,
6069 MIN (ll_bitpos
, rl_bitpos
),
6070 ll_unsignedp
, ll_reversep
);
6071 rhs
= make_bit_field_ref (loc
, lr_inner
, lr_arg
, rntype
,
6072 lr_bitsize
+ rr_bitsize
,
6073 MIN (lr_bitpos
, rr_bitpos
),
6074 lr_unsignedp
, lr_reversep
);
6076 ll_mask
= const_binop (RSHIFT_EXPR
, ll_mask
,
6077 size_int (MIN (xll_bitpos
, xrl_bitpos
)));
6078 lr_mask
= const_binop (RSHIFT_EXPR
, lr_mask
,
6079 size_int (MIN (xlr_bitpos
, xrr_bitpos
)));
6081 /* Convert to the smaller type before masking out unwanted bits. */
6083 if (lntype
!= rntype
)
6085 if (lnbitsize
> rnbitsize
)
6087 lhs
= fold_convert_loc (loc
, rntype
, lhs
);
6088 ll_mask
= fold_convert_loc (loc
, rntype
, ll_mask
);
6091 else if (lnbitsize
< rnbitsize
)
6093 rhs
= fold_convert_loc (loc
, lntype
, rhs
);
6094 lr_mask
= fold_convert_loc (loc
, lntype
, lr_mask
);
6099 if (! all_ones_mask_p (ll_mask
, ll_bitsize
+ rl_bitsize
))
6100 lhs
= build2 (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
6102 if (! all_ones_mask_p (lr_mask
, lr_bitsize
+ rr_bitsize
))
6103 rhs
= build2 (BIT_AND_EXPR
, type
, rhs
, lr_mask
);
6105 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
6111 /* Handle the case of comparisons with constants. If there is something in
6112 common between the masks, those bits of the constants must be the same.
6113 If not, the condition is always false. Test for this to avoid generating
6114 incorrect code below. */
6115 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
);
6116 if (! integer_zerop (result
)
6117 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
),
6118 const_binop (BIT_AND_EXPR
, result
, r_const
)) != 1)
6120 if (wanted_code
== NE_EXPR
)
6122 warning (0, "%<or%> of unmatched not-equal tests is always 1");
6123 return constant_boolean_node (true, truth_type
);
6127 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
6128 return constant_boolean_node (false, truth_type
);
6135 /* Construct the expression we will return. First get the component
6136 reference we will make. Unless the mask is all ones the width of
6137 that field, perform the mask operation. Then compare with the
6139 result
= make_bit_field_ref (loc
, ll_inner
, ll_arg
,
6140 lntype
, lnbitsize
, lnbitpos
,
6141 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
6143 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
6144 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
6145 result
= build2_loc (loc
, BIT_AND_EXPR
, lntype
, result
, ll_mask
);
6147 return build2_loc (loc
, wanted_code
, truth_type
, result
,
6148 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
6151 /* T is an integer expression that is being multiplied, divided, or taken a
6152 modulus (CODE says which and what kind of divide or modulus) by a
6153 constant C. See if we can eliminate that operation by folding it with
6154 other operations already in T. WIDE_TYPE, if non-null, is a type that
6155 should be used for the computation if wider than our type.
6157 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
6158 (X * 2) + (Y * 4). We must, however, be assured that either the original
6159 expression would not overflow or that overflow is undefined for the type
6160 in the language in question.
6162 If we return a non-null expression, it is an equivalent form of the
6163 original computation, but need not be in the original type.
6165 We set *STRICT_OVERFLOW_P to true if the return values depends on
6166 signed overflow being undefined. Otherwise we do not change
6167 *STRICT_OVERFLOW_P. */
6170 extract_muldiv (tree t
, tree c
, enum tree_code code
, tree wide_type
,
6171 bool *strict_overflow_p
)
6173 /* To avoid exponential search depth, refuse to allow recursion past
6174 three levels. Beyond that (1) it's highly unlikely that we'll find
6175 something interesting and (2) we've probably processed it before
6176 when we built the inner expression. */
6185 ret
= extract_muldiv_1 (t
, c
, code
, wide_type
, strict_overflow_p
);
6192 extract_muldiv_1 (tree t
, tree c
, enum tree_code code
, tree wide_type
,
6193 bool *strict_overflow_p
)
6195 tree type
= TREE_TYPE (t
);
6196 enum tree_code tcode
= TREE_CODE (t
);
6197 tree ctype
= (wide_type
!= 0
6198 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (wide_type
))
6199 > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
)))
6200 ? wide_type
: type
);
6202 int same_p
= tcode
== code
;
6203 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
6204 bool sub_strict_overflow_p
;
6206 /* Don't deal with constants of zero here; they confuse the code below. */
6207 if (integer_zerop (c
))
6210 if (TREE_CODE_CLASS (tcode
) == tcc_unary
)
6211 op0
= TREE_OPERAND (t
, 0);
6213 if (TREE_CODE_CLASS (tcode
) == tcc_binary
)
6214 op0
= TREE_OPERAND (t
, 0), op1
= TREE_OPERAND (t
, 1);
6216 /* Note that we need not handle conditional operations here since fold
6217 already handles those cases. So just do arithmetic here. */
6221 /* For a constant, we can always simplify if we are a multiply
6222 or (for divide and modulus) if it is a multiple of our constant. */
6223 if (code
== MULT_EXPR
6224 || wi::multiple_of_p (wi::to_wide (t
), wi::to_wide (c
),
6227 tree tem
= const_binop (code
, fold_convert (ctype
, t
),
6228 fold_convert (ctype
, c
));
6229 /* If the multiplication overflowed, we lost information on it.
6230 See PR68142 and PR69845. */
6231 if (TREE_OVERFLOW (tem
))
6237 CASE_CONVERT
: case NON_LVALUE_EXPR
:
6238 /* If op0 is an expression ... */
6239 if ((COMPARISON_CLASS_P (op0
)
6240 || UNARY_CLASS_P (op0
)
6241 || BINARY_CLASS_P (op0
)
6242 || VL_EXP_CLASS_P (op0
)
6243 || EXPRESSION_CLASS_P (op0
))
6244 /* ... and has wrapping overflow, and its type is smaller
6245 than ctype, then we cannot pass through as widening. */
6246 && (((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
6247 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0
)))
6248 && (TYPE_PRECISION (ctype
)
6249 > TYPE_PRECISION (TREE_TYPE (op0
))))
6250 /* ... or this is a truncation (t is narrower than op0),
6251 then we cannot pass through this narrowing. */
6252 || (TYPE_PRECISION (type
)
6253 < TYPE_PRECISION (TREE_TYPE (op0
)))
6254 /* ... or signedness changes for division or modulus,
6255 then we cannot pass through this conversion. */
6256 || (code
!= MULT_EXPR
6257 && (TYPE_UNSIGNED (ctype
)
6258 != TYPE_UNSIGNED (TREE_TYPE (op0
))))
6259 /* ... or has undefined overflow while the converted to
6260 type has not, we cannot do the operation in the inner type
6261 as that would introduce undefined overflow. */
6262 || ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
6263 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0
)))
6264 && !TYPE_OVERFLOW_UNDEFINED (type
))))
6267 /* Pass the constant down and see if we can make a simplification. If
6268 we can, replace this expression with the inner simplification for
6269 possible later conversion to our or some other type. */
6270 if ((t2
= fold_convert (TREE_TYPE (op0
), c
)) != 0
6271 && TREE_CODE (t2
) == INTEGER_CST
6272 && !TREE_OVERFLOW (t2
)
6273 && (t1
= extract_muldiv (op0
, t2
, code
,
6274 code
== MULT_EXPR
? ctype
: NULL_TREE
,
6275 strict_overflow_p
)) != 0)
6280 /* If widening the type changes it from signed to unsigned, then we
6281 must avoid building ABS_EXPR itself as unsigned. */
6282 if (TYPE_UNSIGNED (ctype
) && !TYPE_UNSIGNED (type
))
6284 tree cstype
= (*signed_type_for
) (ctype
);
6285 if ((t1
= extract_muldiv (op0
, c
, code
, cstype
, strict_overflow_p
))
6288 t1
= fold_build1 (tcode
, cstype
, fold_convert (cstype
, t1
));
6289 return fold_convert (ctype
, t1
);
6293 /* If the constant is negative, we cannot simplify this. */
6294 if (tree_int_cst_sgn (c
) == -1)
6298 /* For division and modulus, type can't be unsigned, as e.g.
6299 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6300 For signed types, even with wrapping overflow, this is fine. */
6301 if (code
!= MULT_EXPR
&& TYPE_UNSIGNED (type
))
6303 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
, strict_overflow_p
))
6305 return fold_build1 (tcode
, ctype
, fold_convert (ctype
, t1
));
6308 case MIN_EXPR
: case MAX_EXPR
:
6309 /* If widening the type changes the signedness, then we can't perform
6310 this optimization as that changes the result. */
6311 if (TYPE_UNSIGNED (ctype
) != TYPE_UNSIGNED (type
))
6314 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6315 sub_strict_overflow_p
= false;
6316 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6317 &sub_strict_overflow_p
)) != 0
6318 && (t2
= extract_muldiv (op1
, c
, code
, wide_type
,
6319 &sub_strict_overflow_p
)) != 0)
6321 if (tree_int_cst_sgn (c
) < 0)
6322 tcode
= (tcode
== MIN_EXPR
? MAX_EXPR
: MIN_EXPR
);
6323 if (sub_strict_overflow_p
)
6324 *strict_overflow_p
= true;
6325 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6326 fold_convert (ctype
, t2
));
6330 case LSHIFT_EXPR
: case RSHIFT_EXPR
:
6331 /* If the second operand is constant, this is a multiplication
6332 or floor division, by a power of two, so we can treat it that
6333 way unless the multiplier or divisor overflows. Signed
6334 left-shift overflow is implementation-defined rather than
6335 undefined in C90, so do not convert signed left shift into
6337 if (TREE_CODE (op1
) == INTEGER_CST
6338 && (tcode
== RSHIFT_EXPR
|| TYPE_UNSIGNED (TREE_TYPE (op0
)))
6339 /* const_binop may not detect overflow correctly,
6340 so check for it explicitly here. */
6341 && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)),
6343 && (t1
= fold_convert (ctype
,
6344 const_binop (LSHIFT_EXPR
, size_one_node
,
6346 && !TREE_OVERFLOW (t1
))
6347 return extract_muldiv (build2 (tcode
== LSHIFT_EXPR
6348 ? MULT_EXPR
: FLOOR_DIV_EXPR
,
6350 fold_convert (ctype
, op0
),
6352 c
, code
, wide_type
, strict_overflow_p
);
6355 case PLUS_EXPR
: case MINUS_EXPR
:
6356 /* See if we can eliminate the operation on both sides. If we can, we
6357 can return a new PLUS or MINUS. If we can't, the only remaining
6358 cases where we can do anything are if the second operand is a
6360 sub_strict_overflow_p
= false;
6361 t1
= extract_muldiv (op0
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6362 t2
= extract_muldiv (op1
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6363 if (t1
!= 0 && t2
!= 0
6364 && TYPE_OVERFLOW_WRAPS (ctype
)
6365 && (code
== MULT_EXPR
6366 /* If not multiplication, we can only do this if both operands
6367 are divisible by c. */
6368 || (multiple_of_p (ctype
, op0
, c
)
6369 && multiple_of_p (ctype
, op1
, c
))))
6371 if (sub_strict_overflow_p
)
6372 *strict_overflow_p
= true;
6373 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6374 fold_convert (ctype
, t2
));
6377 /* If this was a subtraction, negate OP1 and set it to be an addition.
6378 This simplifies the logic below. */
6379 if (tcode
== MINUS_EXPR
)
6381 tcode
= PLUS_EXPR
, op1
= negate_expr (op1
);
6382 /* If OP1 was not easily negatable, the constant may be OP0. */
6383 if (TREE_CODE (op0
) == INTEGER_CST
)
6385 std::swap (op0
, op1
);
6390 if (TREE_CODE (op1
) != INTEGER_CST
)
6393 /* If either OP1 or C are negative, this optimization is not safe for
6394 some of the division and remainder types while for others we need
6395 to change the code. */
6396 if (tree_int_cst_sgn (op1
) < 0 || tree_int_cst_sgn (c
) < 0)
6398 if (code
== CEIL_DIV_EXPR
)
6399 code
= FLOOR_DIV_EXPR
;
6400 else if (code
== FLOOR_DIV_EXPR
)
6401 code
= CEIL_DIV_EXPR
;
6402 else if (code
!= MULT_EXPR
6403 && code
!= CEIL_MOD_EXPR
&& code
!= FLOOR_MOD_EXPR
)
6407 /* If it's a multiply or a division/modulus operation of a multiple
6408 of our constant, do the operation and verify it doesn't overflow. */
6409 if (code
== MULT_EXPR
6410 || wi::multiple_of_p (wi::to_wide (op1
), wi::to_wide (c
),
6413 op1
= const_binop (code
, fold_convert (ctype
, op1
),
6414 fold_convert (ctype
, c
));
6415 /* We allow the constant to overflow with wrapping semantics. */
6417 || (TREE_OVERFLOW (op1
) && !TYPE_OVERFLOW_WRAPS (ctype
)))
6423 /* If we have an unsigned type, we cannot widen the operation since it
6424 will change the result if the original computation overflowed. */
6425 if (TYPE_UNSIGNED (ctype
) && ctype
!= type
)
6428 /* The last case is if we are a multiply. In that case, we can
6429 apply the distributive law to commute the multiply and addition
6430 if the multiplication of the constants doesn't overflow
6431 and overflow is defined. With undefined overflow
6432 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6433 if (code
== MULT_EXPR
&& TYPE_OVERFLOW_WRAPS (ctype
))
6434 return fold_build2 (tcode
, ctype
,
6435 fold_build2 (code
, ctype
,
6436 fold_convert (ctype
, op0
),
6437 fold_convert (ctype
, c
)),
6443 /* We have a special case here if we are doing something like
6444 (C * 8) % 4 since we know that's zero. */
6445 if ((code
== TRUNC_MOD_EXPR
|| code
== CEIL_MOD_EXPR
6446 || code
== FLOOR_MOD_EXPR
|| code
== ROUND_MOD_EXPR
)
6447 /* If the multiplication can overflow we cannot optimize this. */
6448 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
))
6449 && TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
6450 && wi::multiple_of_p (wi::to_wide (op1
), wi::to_wide (c
),
6453 *strict_overflow_p
= true;
6454 return omit_one_operand (type
, integer_zero_node
, op0
);
6457 /* ... fall through ... */
6459 case TRUNC_DIV_EXPR
: case CEIL_DIV_EXPR
: case FLOOR_DIV_EXPR
:
6460 case ROUND_DIV_EXPR
: case EXACT_DIV_EXPR
:
6461 /* If we can extract our operation from the LHS, do so and return a
6462 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6463 do something only if the second operand is a constant. */
6465 && TYPE_OVERFLOW_WRAPS (ctype
)
6466 && (t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6467 strict_overflow_p
)) != 0)
6468 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6469 fold_convert (ctype
, op1
));
6470 else if (tcode
== MULT_EXPR
&& code
== MULT_EXPR
6471 && TYPE_OVERFLOW_WRAPS (ctype
)
6472 && (t1
= extract_muldiv (op1
, c
, code
, wide_type
,
6473 strict_overflow_p
)) != 0)
6474 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6475 fold_convert (ctype
, t1
));
6476 else if (TREE_CODE (op1
) != INTEGER_CST
)
6479 /* If these are the same operation types, we can associate them
6480 assuming no overflow. */
6483 bool overflow_p
= false;
6484 bool overflow_mul_p
;
6485 signop sign
= TYPE_SIGN (ctype
);
6486 unsigned prec
= TYPE_PRECISION (ctype
);
6487 wide_int mul
= wi::mul (wi::to_wide (op1
, prec
),
6488 wi::to_wide (c
, prec
),
6489 sign
, &overflow_mul_p
);
6490 overflow_p
= TREE_OVERFLOW (c
) | TREE_OVERFLOW (op1
);
6492 && ((sign
== UNSIGNED
&& tcode
!= MULT_EXPR
) || sign
== SIGNED
))
6495 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6496 wide_int_to_tree (ctype
, mul
));
6499 /* If these operations "cancel" each other, we have the main
6500 optimizations of this pass, which occur when either constant is a
6501 multiple of the other, in which case we replace this with either an
6502 operation or CODE or TCODE.
6504 If we have an unsigned type, we cannot do this since it will change
6505 the result if the original computation overflowed. */
6506 if (TYPE_OVERFLOW_UNDEFINED (ctype
)
6507 && ((code
== MULT_EXPR
&& tcode
== EXACT_DIV_EXPR
)
6508 || (tcode
== MULT_EXPR
6509 && code
!= TRUNC_MOD_EXPR
&& code
!= CEIL_MOD_EXPR
6510 && code
!= FLOOR_MOD_EXPR
&& code
!= ROUND_MOD_EXPR
6511 && code
!= MULT_EXPR
)))
6513 if (wi::multiple_of_p (wi::to_wide (op1
), wi::to_wide (c
),
6516 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6517 *strict_overflow_p
= true;
6518 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6519 fold_convert (ctype
,
6520 const_binop (TRUNC_DIV_EXPR
,
6523 else if (wi::multiple_of_p (wi::to_wide (c
), wi::to_wide (op1
),
6526 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6527 *strict_overflow_p
= true;
6528 return fold_build2 (code
, ctype
, fold_convert (ctype
, op0
),
6529 fold_convert (ctype
,
6530 const_binop (TRUNC_DIV_EXPR
,
6543 /* Return a node which has the indicated constant VALUE (either 0 or
6544 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6545 and is of the indicated TYPE. */
6548 constant_boolean_node (bool value
, tree type
)
6550 if (type
== integer_type_node
)
6551 return value
? integer_one_node
: integer_zero_node
;
6552 else if (type
== boolean_type_node
)
6553 return value
? boolean_true_node
: boolean_false_node
;
6554 else if (TREE_CODE (type
) == VECTOR_TYPE
)
6555 return build_vector_from_val (type
,
6556 build_int_cst (TREE_TYPE (type
),
6559 return fold_convert (type
, value
? integer_one_node
: integer_zero_node
);
6563 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6564 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6565 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6566 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6567 COND is the first argument to CODE; otherwise (as in the example
6568 given here), it is the second argument. TYPE is the type of the
6569 original expression. Return NULL_TREE if no simplification is
6573 fold_binary_op_with_conditional_arg (location_t loc
,
6574 enum tree_code code
,
6575 tree type
, tree op0
, tree op1
,
6576 tree cond
, tree arg
, int cond_first_p
)
6578 tree cond_type
= cond_first_p
? TREE_TYPE (op0
) : TREE_TYPE (op1
);
6579 tree arg_type
= cond_first_p
? TREE_TYPE (op1
) : TREE_TYPE (op0
);
6580 tree test
, true_value
, false_value
;
6581 tree lhs
= NULL_TREE
;
6582 tree rhs
= NULL_TREE
;
6583 enum tree_code cond_code
= COND_EXPR
;
6585 if (TREE_CODE (cond
) == COND_EXPR
6586 || TREE_CODE (cond
) == VEC_COND_EXPR
)
6588 test
= TREE_OPERAND (cond
, 0);
6589 true_value
= TREE_OPERAND (cond
, 1);
6590 false_value
= TREE_OPERAND (cond
, 2);
6591 /* If this operand throws an expression, then it does not make
6592 sense to try to perform a logical or arithmetic operation
6594 if (VOID_TYPE_P (TREE_TYPE (true_value
)))
6596 if (VOID_TYPE_P (TREE_TYPE (false_value
)))
6599 else if (!(TREE_CODE (type
) != VECTOR_TYPE
6600 && TREE_CODE (TREE_TYPE (cond
)) == VECTOR_TYPE
))
6602 tree testtype
= TREE_TYPE (cond
);
6604 true_value
= constant_boolean_node (true, testtype
);
6605 false_value
= constant_boolean_node (false, testtype
);
6608 /* Detect the case of mixing vector and scalar types - bail out. */
6611 if (TREE_CODE (TREE_TYPE (test
)) == VECTOR_TYPE
)
6612 cond_code
= VEC_COND_EXPR
;
6614 /* This transformation is only worthwhile if we don't have to wrap ARG
6615 in a SAVE_EXPR and the operation can be simplified without recursing
6616 on at least one of the branches once its pushed inside the COND_EXPR. */
6617 if (!TREE_CONSTANT (arg
)
6618 && (TREE_SIDE_EFFECTS (arg
)
6619 || TREE_CODE (arg
) == COND_EXPR
|| TREE_CODE (arg
) == VEC_COND_EXPR
6620 || TREE_CONSTANT (true_value
) || TREE_CONSTANT (false_value
)))
6623 arg
= fold_convert_loc (loc
, arg_type
, arg
);
6626 true_value
= fold_convert_loc (loc
, cond_type
, true_value
);
6628 lhs
= fold_build2_loc (loc
, code
, type
, true_value
, arg
);
6630 lhs
= fold_build2_loc (loc
, code
, type
, arg
, true_value
);
6634 false_value
= fold_convert_loc (loc
, cond_type
, false_value
);
6636 rhs
= fold_build2_loc (loc
, code
, type
, false_value
, arg
);
6638 rhs
= fold_build2_loc (loc
, code
, type
, arg
, false_value
);
6641 /* Check that we have simplified at least one of the branches. */
6642 if (!TREE_CONSTANT (arg
) && !TREE_CONSTANT (lhs
) && !TREE_CONSTANT (rhs
))
6645 return fold_build3_loc (loc
, cond_code
, type
, test
, lhs
, rhs
);
6649 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6651 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6652 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6653 ADDEND is the same as X.
6655 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6656 and finite. The problematic cases are when X is zero, and its mode
6657 has signed zeros. In the case of rounding towards -infinity,
6658 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6659 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6662 fold_real_zero_addition_p (const_tree type
, const_tree addend
, int negate
)
6664 if (!real_zerop (addend
))
6667 /* Don't allow the fold with -fsignaling-nans. */
6668 if (HONOR_SNANS (element_mode (type
)))
6671 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6672 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
6675 /* In a vector or complex, we would need to check the sign of all zeros. */
6676 if (TREE_CODE (addend
) != REAL_CST
)
6679 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6680 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend
)))
6683 /* The mode has signed zeros, and we have to honor their sign.
6684 In this situation, there is only one case we can return true for.
6685 X - 0 is the same as X unless rounding towards -infinity is
6687 return negate
&& !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
));
6690 /* Subroutine of match.pd that optimizes comparisons of a division by
6691 a nonzero integer constant against an integer constant, i.e.
6694 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6695 GE_EXPR or LE_EXPR. ARG01 and ARG1 must be a INTEGER_CST. */
6698 fold_div_compare (enum tree_code code
, tree c1
, tree c2
, tree
*lo
,
6699 tree
*hi
, bool *neg_overflow
)
6701 tree prod
, tmp
, type
= TREE_TYPE (c1
);
6702 signop sign
= TYPE_SIGN (type
);
6705 /* We have to do this the hard way to detect unsigned overflow.
6706 prod = int_const_binop (MULT_EXPR, c1, c2); */
6707 wide_int val
= wi::mul (wi::to_wide (c1
), wi::to_wide (c2
), sign
, &overflow
);
6708 prod
= force_fit_type (type
, val
, -1, overflow
);
6709 *neg_overflow
= false;
6711 if (sign
== UNSIGNED
)
6713 tmp
= int_const_binop (MINUS_EXPR
, c1
, build_int_cst (type
, 1));
6716 /* Likewise *hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6717 val
= wi::add (wi::to_wide (prod
), wi::to_wide (tmp
), sign
, &overflow
);
6718 *hi
= force_fit_type (type
, val
, -1, overflow
| TREE_OVERFLOW (prod
));
6720 else if (tree_int_cst_sgn (c1
) >= 0)
6722 tmp
= int_const_binop (MINUS_EXPR
, c1
, build_int_cst (type
, 1));
6723 switch (tree_int_cst_sgn (c2
))
6726 *neg_overflow
= true;
6727 *lo
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6732 *lo
= fold_negate_const (tmp
, type
);
6737 *hi
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6747 /* A negative divisor reverses the relational operators. */
6748 code
= swap_tree_comparison (code
);
6750 tmp
= int_const_binop (PLUS_EXPR
, c1
, build_int_cst (type
, 1));
6751 switch (tree_int_cst_sgn (c2
))
6754 *hi
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6759 *hi
= fold_negate_const (tmp
, type
);
6764 *neg_overflow
= true;
6765 *lo
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6774 if (code
!= EQ_EXPR
&& code
!= NE_EXPR
)
6777 if (TREE_OVERFLOW (*lo
)
6778 || operand_equal_p (*lo
, TYPE_MIN_VALUE (type
), 0))
6780 if (TREE_OVERFLOW (*hi
)
6781 || operand_equal_p (*hi
, TYPE_MAX_VALUE (type
), 0))
6788 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6789 equality/inequality test, then return a simplified form of the test
6790 using a sign testing. Otherwise return NULL. TYPE is the desired
6794 fold_single_bit_test_into_sign_test (location_t loc
,
6795 enum tree_code code
, tree arg0
, tree arg1
,
6798 /* If this is testing a single bit, we can optimize the test. */
6799 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6800 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6801 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6803 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6804 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6805 tree arg00
= sign_bit_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1));
6807 if (arg00
!= NULL_TREE
6808 /* This is only a win if casting to a signed type is cheap,
6809 i.e. when arg00's type is not a partial mode. */
6810 && type_has_mode_precision_p (TREE_TYPE (arg00
)))
6812 tree stype
= signed_type_for (TREE_TYPE (arg00
));
6813 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
6815 fold_convert_loc (loc
, stype
, arg00
),
6816 build_int_cst (stype
, 0));
6823 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6824 equality/inequality test, then return a simplified form of
6825 the test using shifts and logical operations. Otherwise return
6826 NULL. TYPE is the desired result type. */
6829 fold_single_bit_test (location_t loc
, enum tree_code code
,
6830 tree arg0
, tree arg1
, tree result_type
)
6832 /* If this is testing a single bit, we can optimize the test. */
6833 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6834 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6835 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6837 tree inner
= TREE_OPERAND (arg0
, 0);
6838 tree type
= TREE_TYPE (arg0
);
6839 int bitnum
= tree_log2 (TREE_OPERAND (arg0
, 1));
6840 scalar_int_mode operand_mode
= SCALAR_INT_TYPE_MODE (type
);
6842 tree signed_type
, unsigned_type
, intermediate_type
;
6845 /* First, see if we can fold the single bit test into a sign-bit
6847 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
,
6852 /* Otherwise we have (A & C) != 0 where C is a single bit,
6853 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6854 Similarly for (A & C) == 0. */
6856 /* If INNER is a right shift of a constant and it plus BITNUM does
6857 not overflow, adjust BITNUM and INNER. */
6858 if (TREE_CODE (inner
) == RSHIFT_EXPR
6859 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
6860 && bitnum
< TYPE_PRECISION (type
)
6861 && wi::ltu_p (wi::to_wide (TREE_OPERAND (inner
, 1)),
6862 TYPE_PRECISION (type
) - bitnum
))
6864 bitnum
+= tree_to_uhwi (TREE_OPERAND (inner
, 1));
6865 inner
= TREE_OPERAND (inner
, 0);
6868 /* If we are going to be able to omit the AND below, we must do our
6869 operations as unsigned. If we must use the AND, we have a choice.
6870 Normally unsigned is faster, but for some machines signed is. */
6871 ops_unsigned
= (load_extend_op (operand_mode
) == SIGN_EXTEND
6872 && !flag_syntax_only
) ? 0 : 1;
6874 signed_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 0);
6875 unsigned_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 1);
6876 intermediate_type
= ops_unsigned
? unsigned_type
: signed_type
;
6877 inner
= fold_convert_loc (loc
, intermediate_type
, inner
);
6880 inner
= build2 (RSHIFT_EXPR
, intermediate_type
,
6881 inner
, size_int (bitnum
));
6883 one
= build_int_cst (intermediate_type
, 1);
6885 if (code
== EQ_EXPR
)
6886 inner
= fold_build2_loc (loc
, BIT_XOR_EXPR
, intermediate_type
, inner
, one
);
6888 /* Put the AND last so it can combine with more things. */
6889 inner
= build2 (BIT_AND_EXPR
, intermediate_type
, inner
, one
);
6891 /* Make sure to return the proper type. */
6892 inner
= fold_convert_loc (loc
, result_type
, inner
);
6899 /* Test whether it is preferable two swap two operands, ARG0 and
6900 ARG1, for example because ARG0 is an integer constant and ARG1
6904 tree_swap_operands_p (const_tree arg0
, const_tree arg1
)
6906 if (CONSTANT_CLASS_P (arg1
))
6908 if (CONSTANT_CLASS_P (arg0
))
6914 if (TREE_CONSTANT (arg1
))
6916 if (TREE_CONSTANT (arg0
))
6919 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6920 for commutative and comparison operators. Ensuring a canonical
6921 form allows the optimizers to find additional redundancies without
6922 having to explicitly check for both orderings. */
6923 if (TREE_CODE (arg0
) == SSA_NAME
6924 && TREE_CODE (arg1
) == SSA_NAME
6925 && SSA_NAME_VERSION (arg0
) > SSA_NAME_VERSION (arg1
))
6928 /* Put SSA_NAMEs last. */
6929 if (TREE_CODE (arg1
) == SSA_NAME
)
6931 if (TREE_CODE (arg0
) == SSA_NAME
)
6934 /* Put variables last. */
6944 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6945 means A >= Y && A != MAX, but in this case we know that
6946 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6949 fold_to_nonsharp_ineq_using_bound (location_t loc
, tree ineq
, tree bound
)
6951 tree a
, typea
, type
= TREE_TYPE (ineq
), a1
, diff
, y
;
6953 if (TREE_CODE (bound
) == LT_EXPR
)
6954 a
= TREE_OPERAND (bound
, 0);
6955 else if (TREE_CODE (bound
) == GT_EXPR
)
6956 a
= TREE_OPERAND (bound
, 1);
6960 typea
= TREE_TYPE (a
);
6961 if (!INTEGRAL_TYPE_P (typea
)
6962 && !POINTER_TYPE_P (typea
))
6965 if (TREE_CODE (ineq
) == LT_EXPR
)
6967 a1
= TREE_OPERAND (ineq
, 1);
6968 y
= TREE_OPERAND (ineq
, 0);
6970 else if (TREE_CODE (ineq
) == GT_EXPR
)
6972 a1
= TREE_OPERAND (ineq
, 0);
6973 y
= TREE_OPERAND (ineq
, 1);
6978 if (TREE_TYPE (a1
) != typea
)
6981 if (POINTER_TYPE_P (typea
))
6983 /* Convert the pointer types into integer before taking the difference. */
6984 tree ta
= fold_convert_loc (loc
, ssizetype
, a
);
6985 tree ta1
= fold_convert_loc (loc
, ssizetype
, a1
);
6986 diff
= fold_binary_loc (loc
, MINUS_EXPR
, ssizetype
, ta1
, ta
);
6989 diff
= fold_binary_loc (loc
, MINUS_EXPR
, typea
, a1
, a
);
6991 if (!diff
|| !integer_onep (diff
))
6994 return fold_build2_loc (loc
, GE_EXPR
, type
, a
, y
);
6997 /* Fold a sum or difference of at least one multiplication.
6998 Returns the folded tree or NULL if no simplification could be made. */
7001 fold_plusminus_mult_expr (location_t loc
, enum tree_code code
, tree type
,
7002 tree arg0
, tree arg1
)
7004 tree arg00
, arg01
, arg10
, arg11
;
7005 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
7007 /* (A * C) +- (B * C) -> (A+-B) * C.
7008 (A * C) +- A -> A * (C+-1).
7009 We are most concerned about the case where C is a constant,
7010 but other combinations show up during loop reduction. Since
7011 it is not difficult, try all four possibilities. */
7013 if (TREE_CODE (arg0
) == MULT_EXPR
)
7015 arg00
= TREE_OPERAND (arg0
, 0);
7016 arg01
= TREE_OPERAND (arg0
, 1);
7018 else if (TREE_CODE (arg0
) == INTEGER_CST
)
7020 arg00
= build_one_cst (type
);
7025 /* We cannot generate constant 1 for fract. */
7026 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
7029 arg01
= build_one_cst (type
);
7031 if (TREE_CODE (arg1
) == MULT_EXPR
)
7033 arg10
= TREE_OPERAND (arg1
, 0);
7034 arg11
= TREE_OPERAND (arg1
, 1);
7036 else if (TREE_CODE (arg1
) == INTEGER_CST
)
7038 arg10
= build_one_cst (type
);
7039 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7040 the purpose of this canonicalization. */
7041 if (wi::neg_p (wi::to_wide (arg1
), TYPE_SIGN (TREE_TYPE (arg1
)))
7042 && negate_expr_p (arg1
)
7043 && code
== PLUS_EXPR
)
7045 arg11
= negate_expr (arg1
);
7053 /* We cannot generate constant 1 for fract. */
7054 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
7057 arg11
= build_one_cst (type
);
7061 /* Prefer factoring a common non-constant. */
7062 if (operand_equal_p (arg00
, arg10
, 0))
7063 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
7064 else if (operand_equal_p (arg01
, arg11
, 0))
7065 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
7066 else if (operand_equal_p (arg00
, arg11
, 0))
7067 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
7068 else if (operand_equal_p (arg01
, arg10
, 0))
7069 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
7071 /* No identical multiplicands; see if we can find a common
7072 power-of-two factor in non-power-of-two multiplies. This
7073 can help in multi-dimensional array access. */
7074 else if (tree_fits_shwi_p (arg01
)
7075 && tree_fits_shwi_p (arg11
))
7077 HOST_WIDE_INT int01
, int11
, tmp
;
7080 int01
= tree_to_shwi (arg01
);
7081 int11
= tree_to_shwi (arg11
);
7083 /* Move min of absolute values to int11. */
7084 if (absu_hwi (int01
) < absu_hwi (int11
))
7086 tmp
= int01
, int01
= int11
, int11
= tmp
;
7087 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
7094 if (exact_log2 (absu_hwi (int11
)) > 0 && int01
% int11
== 0
7095 /* The remainder should not be a constant, otherwise we
7096 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7097 increased the number of multiplications necessary. */
7098 && TREE_CODE (arg10
) != INTEGER_CST
)
7100 alt0
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (arg00
), arg00
,
7101 build_int_cst (TREE_TYPE (arg00
),
7106 maybe_same
= alt0
, alt0
= alt1
, alt1
= maybe_same
;
7113 if (! INTEGRAL_TYPE_P (type
)
7114 || TYPE_OVERFLOW_WRAPS (type
)
7115 /* We are neither factoring zero nor minus one. */
7116 || TREE_CODE (same
) == INTEGER_CST
)
7117 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7118 fold_build2_loc (loc
, code
, type
,
7119 fold_convert_loc (loc
, type
, alt0
),
7120 fold_convert_loc (loc
, type
, alt1
)),
7121 fold_convert_loc (loc
, type
, same
));
7123 /* Same may be zero and thus the operation 'code' may overflow. Likewise
7124 same may be minus one and thus the multiplication may overflow. Perform
7125 the sum operation in an unsigned type. */
7126 tree utype
= unsigned_type_for (type
);
7127 tree tem
= fold_build2_loc (loc
, code
, utype
,
7128 fold_convert_loc (loc
, utype
, alt0
),
7129 fold_convert_loc (loc
, utype
, alt1
));
7130 /* If the sum evaluated to a constant that is not -INF the multiplication
7132 if (TREE_CODE (tem
) == INTEGER_CST
7133 && (wi::to_wide (tem
)
7134 != wi::min_value (TYPE_PRECISION (utype
), SIGNED
)))
7135 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7136 fold_convert (type
, tem
), same
);
7138 /* Do not resort to unsigned multiplication because
7139 we lose the no-overflow property of the expression. */
7143 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7144 specified by EXPR into the buffer PTR of length LEN bytes.
7145 Return the number of bytes placed in the buffer, or zero
7149 native_encode_int (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7151 tree type
= TREE_TYPE (expr
);
7152 int total_bytes
= GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
));
7153 int byte
, offset
, word
, words
;
7154 unsigned char value
;
7156 if ((off
== -1 && total_bytes
> len
) || off
>= total_bytes
)
7163 return MIN (len
, total_bytes
- off
);
7165 words
= total_bytes
/ UNITS_PER_WORD
;
7167 for (byte
= 0; byte
< total_bytes
; byte
++)
7169 int bitpos
= byte
* BITS_PER_UNIT
;
7170 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7172 value
= wi::extract_uhwi (wi::to_widest (expr
), bitpos
, BITS_PER_UNIT
);
7174 if (total_bytes
> UNITS_PER_WORD
)
7176 word
= byte
/ UNITS_PER_WORD
;
7177 if (WORDS_BIG_ENDIAN
)
7178 word
= (words
- 1) - word
;
7179 offset
= word
* UNITS_PER_WORD
;
7180 if (BYTES_BIG_ENDIAN
)
7181 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7183 offset
+= byte
% UNITS_PER_WORD
;
7186 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
7187 if (offset
>= off
&& offset
- off
< len
)
7188 ptr
[offset
- off
] = value
;
7190 return MIN (len
, total_bytes
- off
);
7194 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7195 specified by EXPR into the buffer PTR of length LEN bytes.
7196 Return the number of bytes placed in the buffer, or zero
7200 native_encode_fixed (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7202 tree type
= TREE_TYPE (expr
);
7203 scalar_mode mode
= SCALAR_TYPE_MODE (type
);
7204 int total_bytes
= GET_MODE_SIZE (mode
);
7205 FIXED_VALUE_TYPE value
;
7206 tree i_value
, i_type
;
7208 if (total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7211 i_type
= lang_hooks
.types
.type_for_size (GET_MODE_BITSIZE (mode
), 1);
7213 if (NULL_TREE
== i_type
|| TYPE_PRECISION (i_type
) != total_bytes
)
7216 value
= TREE_FIXED_CST (expr
);
7217 i_value
= double_int_to_tree (i_type
, value
.data
);
7219 return native_encode_int (i_value
, ptr
, len
, off
);
7223 /* Subroutine of native_encode_expr. Encode the REAL_CST
7224 specified by EXPR into the buffer PTR of length LEN bytes.
7225 Return the number of bytes placed in the buffer, or zero
7229 native_encode_real (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7231 tree type
= TREE_TYPE (expr
);
7232 int total_bytes
= GET_MODE_SIZE (SCALAR_FLOAT_TYPE_MODE (type
));
7233 int byte
, offset
, word
, words
, bitpos
;
7234 unsigned char value
;
7236 /* There are always 32 bits in each long, no matter the size of
7237 the hosts long. We handle floating point representations with
7241 if ((off
== -1 && total_bytes
> len
) || off
>= total_bytes
)
7248 return MIN (len
, total_bytes
- off
);
7250 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7252 real_to_target (tmp
, TREE_REAL_CST_PTR (expr
), TYPE_MODE (type
));
7254 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7255 bitpos
+= BITS_PER_UNIT
)
7257 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7258 value
= (unsigned char) (tmp
[bitpos
/ 32] >> (bitpos
& 31));
7260 if (UNITS_PER_WORD
< 4)
7262 word
= byte
/ UNITS_PER_WORD
;
7263 if (WORDS_BIG_ENDIAN
)
7264 word
= (words
- 1) - word
;
7265 offset
= word
* UNITS_PER_WORD
;
7266 if (BYTES_BIG_ENDIAN
)
7267 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7269 offset
+= byte
% UNITS_PER_WORD
;
7274 if (BYTES_BIG_ENDIAN
)
7276 /* Reverse bytes within each long, or within the entire float
7277 if it's smaller than a long (for HFmode). */
7278 offset
= MIN (3, total_bytes
- 1) - offset
;
7279 gcc_assert (offset
>= 0);
7282 offset
= offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3);
7284 && offset
- off
< len
)
7285 ptr
[offset
- off
] = value
;
7287 return MIN (len
, total_bytes
- off
);
7290 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7291 specified by EXPR into the buffer PTR of length LEN bytes.
7292 Return the number of bytes placed in the buffer, or zero
7296 native_encode_complex (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7301 part
= TREE_REALPART (expr
);
7302 rsize
= native_encode_expr (part
, ptr
, len
, off
);
7303 if (off
== -1 && rsize
== 0)
7305 part
= TREE_IMAGPART (expr
);
7307 off
= MAX (0, off
- GET_MODE_SIZE (SCALAR_TYPE_MODE (TREE_TYPE (part
))));
7308 isize
= native_encode_expr (part
, ptr
? ptr
+ rsize
: NULL
,
7310 if (off
== -1 && isize
!= rsize
)
7312 return rsize
+ isize
;
7316 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7317 specified by EXPR into the buffer PTR of length LEN bytes.
7318 Return the number of bytes placed in the buffer, or zero
7322 native_encode_vector (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7324 unsigned HOST_WIDE_INT i
, count
;
7329 if (!VECTOR_CST_NELTS (expr
).is_constant (&count
))
7331 itype
= TREE_TYPE (TREE_TYPE (expr
));
7332 size
= GET_MODE_SIZE (SCALAR_TYPE_MODE (itype
));
7333 for (i
= 0; i
< count
; i
++)
7340 elem
= VECTOR_CST_ELT (expr
, i
);
7341 int res
= native_encode_expr (elem
, ptr
? ptr
+ offset
: NULL
,
7343 if ((off
== -1 && res
!= size
) || res
== 0)
7347 return (off
== -1 && i
< count
- 1) ? 0 : offset
;
7355 /* Subroutine of native_encode_expr. Encode the STRING_CST
7356 specified by EXPR into the buffer PTR of length LEN bytes.
7357 Return the number of bytes placed in the buffer, or zero
7361 native_encode_string (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7363 tree type
= TREE_TYPE (expr
);
7365 /* Wide-char strings are encoded in target byte-order so native
7366 encoding them is trivial. */
7367 if (BITS_PER_UNIT
!= CHAR_BIT
7368 || TREE_CODE (type
) != ARRAY_TYPE
7369 || TREE_CODE (TREE_TYPE (type
)) != INTEGER_TYPE
7370 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type
)))
7373 HOST_WIDE_INT total_bytes
= tree_to_shwi (TYPE_SIZE_UNIT (TREE_TYPE (expr
)));
7374 if ((off
== -1 && total_bytes
> len
) || off
>= total_bytes
)
7380 else if (TREE_STRING_LENGTH (expr
) - off
< MIN (total_bytes
, len
))
7383 if (off
< TREE_STRING_LENGTH (expr
))
7385 written
= MIN (len
, TREE_STRING_LENGTH (expr
) - off
);
7386 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, written
);
7388 memset (ptr
+ written
, 0,
7389 MIN (total_bytes
- written
, len
- written
));
7392 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, MIN (total_bytes
, len
));
7393 return MIN (total_bytes
- off
, len
);
7397 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7398 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7399 buffer PTR of length LEN bytes. If PTR is NULL, don't actually store
7400 anything, just do a dry run. If OFF is not -1 then start
7401 the encoding at byte offset OFF and encode at most LEN bytes.
7402 Return the number of bytes placed in the buffer, or zero upon failure. */
7405 native_encode_expr (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7407 /* We don't support starting at negative offset and -1 is special. */
7411 switch (TREE_CODE (expr
))
7414 return native_encode_int (expr
, ptr
, len
, off
);
7417 return native_encode_real (expr
, ptr
, len
, off
);
7420 return native_encode_fixed (expr
, ptr
, len
, off
);
7423 return native_encode_complex (expr
, ptr
, len
, off
);
7426 return native_encode_vector (expr
, ptr
, len
, off
);
7429 return native_encode_string (expr
, ptr
, len
, off
);
7437 /* Subroutine of native_interpret_expr. Interpret the contents of
7438 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7439 If the buffer cannot be interpreted, return NULL_TREE. */
7442 native_interpret_int (tree type
, const unsigned char *ptr
, int len
)
7444 int total_bytes
= GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
));
7446 if (total_bytes
> len
7447 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7450 wide_int result
= wi::from_buffer (ptr
, total_bytes
);
7452 return wide_int_to_tree (type
, result
);
7456 /* Subroutine of native_interpret_expr. Interpret the contents of
7457 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7458 If the buffer cannot be interpreted, return NULL_TREE. */
7461 native_interpret_fixed (tree type
, const unsigned char *ptr
, int len
)
7463 scalar_mode mode
= SCALAR_TYPE_MODE (type
);
7464 int total_bytes
= GET_MODE_SIZE (mode
);
7466 FIXED_VALUE_TYPE fixed_value
;
7468 if (total_bytes
> len
7469 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7472 result
= double_int::from_buffer (ptr
, total_bytes
);
7473 fixed_value
= fixed_from_double_int (result
, mode
);
7475 return build_fixed (type
, fixed_value
);
7479 /* Subroutine of native_interpret_expr. Interpret the contents of
7480 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7481 If the buffer cannot be interpreted, return NULL_TREE. */
7484 native_interpret_real (tree type
, const unsigned char *ptr
, int len
)
7486 scalar_float_mode mode
= SCALAR_FLOAT_TYPE_MODE (type
);
7487 int total_bytes
= GET_MODE_SIZE (mode
);
7488 unsigned char value
;
7489 /* There are always 32 bits in each long, no matter the size of
7490 the hosts long. We handle floating point representations with
7495 if (total_bytes
> len
|| total_bytes
> 24)
7497 int words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7499 memset (tmp
, 0, sizeof (tmp
));
7500 for (int bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7501 bitpos
+= BITS_PER_UNIT
)
7503 /* Both OFFSET and BYTE index within a long;
7504 bitpos indexes the whole float. */
7505 int offset
, byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7506 if (UNITS_PER_WORD
< 4)
7508 int word
= byte
/ UNITS_PER_WORD
;
7509 if (WORDS_BIG_ENDIAN
)
7510 word
= (words
- 1) - word
;
7511 offset
= word
* UNITS_PER_WORD
;
7512 if (BYTES_BIG_ENDIAN
)
7513 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7515 offset
+= byte
% UNITS_PER_WORD
;
7520 if (BYTES_BIG_ENDIAN
)
7522 /* Reverse bytes within each long, or within the entire float
7523 if it's smaller than a long (for HFmode). */
7524 offset
= MIN (3, total_bytes
- 1) - offset
;
7525 gcc_assert (offset
>= 0);
7528 value
= ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)];
7530 tmp
[bitpos
/ 32] |= (unsigned long)value
<< (bitpos
& 31);
7533 real_from_target (&r
, tmp
, mode
);
7534 return build_real (type
, r
);
7538 /* Subroutine of native_interpret_expr. Interpret the contents of
7539 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7540 If the buffer cannot be interpreted, return NULL_TREE. */
7543 native_interpret_complex (tree type
, const unsigned char *ptr
, int len
)
7545 tree etype
, rpart
, ipart
;
7548 etype
= TREE_TYPE (type
);
7549 size
= GET_MODE_SIZE (SCALAR_TYPE_MODE (etype
));
7552 rpart
= native_interpret_expr (etype
, ptr
, size
);
7555 ipart
= native_interpret_expr (etype
, ptr
+size
, size
);
7558 return build_complex (type
, rpart
, ipart
);
7562 /* Subroutine of native_interpret_expr. Interpret the contents of
7563 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7564 If the buffer cannot be interpreted, return NULL_TREE. */
7567 native_interpret_vector (tree type
, const unsigned char *ptr
, unsigned int len
)
7570 unsigned int i
, size
;
7571 unsigned HOST_WIDE_INT count
;
7573 etype
= TREE_TYPE (type
);
7574 size
= GET_MODE_SIZE (SCALAR_TYPE_MODE (etype
));
7575 if (!TYPE_VECTOR_SUBPARTS (type
).is_constant (&count
)
7576 || size
* count
> len
)
7579 tree_vector_builder
elements (type
, count
, 1);
7580 for (i
= 0; i
< count
; ++i
)
7582 elem
= native_interpret_expr (etype
, ptr
+(i
*size
), size
);
7585 elements
.quick_push (elem
);
7587 return elements
.build ();
7591 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7592 the buffer PTR of length LEN as a constant of type TYPE. For
7593 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7594 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7595 return NULL_TREE. */
7598 native_interpret_expr (tree type
, const unsigned char *ptr
, int len
)
7600 switch (TREE_CODE (type
))
7606 case REFERENCE_TYPE
:
7607 return native_interpret_int (type
, ptr
, len
);
7610 return native_interpret_real (type
, ptr
, len
);
7612 case FIXED_POINT_TYPE
:
7613 return native_interpret_fixed (type
, ptr
, len
);
7616 return native_interpret_complex (type
, ptr
, len
);
7619 return native_interpret_vector (type
, ptr
, len
);
7626 /* Returns true if we can interpret the contents of a native encoding
7630 can_native_interpret_type_p (tree type
)
7632 switch (TREE_CODE (type
))
7638 case REFERENCE_TYPE
:
7639 case FIXED_POINT_TYPE
:
7650 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7651 TYPE at compile-time. If we're unable to perform the conversion
7652 return NULL_TREE. */
7655 fold_view_convert_expr (tree type
, tree expr
)
7657 /* We support up to 512-bit values (for V8DFmode). */
7658 unsigned char buffer
[64];
7661 /* Check that the host and target are sane. */
7662 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
7665 len
= native_encode_expr (expr
, buffer
, sizeof (buffer
));
7669 return native_interpret_expr (type
, buffer
, len
);
7672 /* Build an expression for the address of T. Folds away INDIRECT_REF
7673 to avoid confusing the gimplify process. */
7676 build_fold_addr_expr_with_type_loc (location_t loc
, tree t
, tree ptrtype
)
7678 /* The size of the object is not relevant when talking about its address. */
7679 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
7680 t
= TREE_OPERAND (t
, 0);
7682 if (TREE_CODE (t
) == INDIRECT_REF
)
7684 t
= TREE_OPERAND (t
, 0);
7686 if (TREE_TYPE (t
) != ptrtype
)
7687 t
= build1_loc (loc
, NOP_EXPR
, ptrtype
, t
);
7689 else if (TREE_CODE (t
) == MEM_REF
7690 && integer_zerop (TREE_OPERAND (t
, 1)))
7691 return TREE_OPERAND (t
, 0);
7692 else if (TREE_CODE (t
) == MEM_REF
7693 && TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
7694 return fold_binary (POINTER_PLUS_EXPR
, ptrtype
,
7695 TREE_OPERAND (t
, 0),
7696 convert_to_ptrofftype (TREE_OPERAND (t
, 1)));
7697 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
7699 t
= build_fold_addr_expr_loc (loc
, TREE_OPERAND (t
, 0));
7701 if (TREE_TYPE (t
) != ptrtype
)
7702 t
= fold_convert_loc (loc
, ptrtype
, t
);
7705 t
= build1_loc (loc
, ADDR_EXPR
, ptrtype
, t
);
7710 /* Build an expression for the address of T. */
7713 build_fold_addr_expr_loc (location_t loc
, tree t
)
7715 tree ptrtype
= build_pointer_type (TREE_TYPE (t
));
7717 return build_fold_addr_expr_with_type_loc (loc
, t
, ptrtype
);
7720 /* Fold a unary expression of code CODE and type TYPE with operand
7721 OP0. Return the folded expression if folding is successful.
7722 Otherwise, return NULL_TREE. */
7725 fold_unary_loc (location_t loc
, enum tree_code code
, tree type
, tree op0
)
7729 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
7731 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
7732 && TREE_CODE_LENGTH (code
) == 1);
7737 if (CONVERT_EXPR_CODE_P (code
)
7738 || code
== FLOAT_EXPR
|| code
== ABS_EXPR
|| code
== NEGATE_EXPR
)
7740 /* Don't use STRIP_NOPS, because signedness of argument type
7742 STRIP_SIGN_NOPS (arg0
);
7746 /* Strip any conversions that don't change the mode. This
7747 is safe for every expression, except for a comparison
7748 expression because its signedness is derived from its
7751 Note that this is done as an internal manipulation within
7752 the constant folder, in order to find the simplest
7753 representation of the arguments so that their form can be
7754 studied. In any cases, the appropriate type conversions
7755 should be put back in the tree that will get out of the
7760 if (CONSTANT_CLASS_P (arg0
))
7762 tree tem
= const_unop (code
, type
, arg0
);
7765 if (TREE_TYPE (tem
) != type
)
7766 tem
= fold_convert_loc (loc
, type
, tem
);
7772 tem
= generic_simplify (loc
, code
, type
, op0
);
7776 if (TREE_CODE_CLASS (code
) == tcc_unary
)
7778 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
7779 return build2 (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7780 fold_build1_loc (loc
, code
, type
,
7781 fold_convert_loc (loc
, TREE_TYPE (op0
),
7782 TREE_OPERAND (arg0
, 1))));
7783 else if (TREE_CODE (arg0
) == COND_EXPR
)
7785 tree arg01
= TREE_OPERAND (arg0
, 1);
7786 tree arg02
= TREE_OPERAND (arg0
, 2);
7787 if (! VOID_TYPE_P (TREE_TYPE (arg01
)))
7788 arg01
= fold_build1_loc (loc
, code
, type
,
7789 fold_convert_loc (loc
,
7790 TREE_TYPE (op0
), arg01
));
7791 if (! VOID_TYPE_P (TREE_TYPE (arg02
)))
7792 arg02
= fold_build1_loc (loc
, code
, type
,
7793 fold_convert_loc (loc
,
7794 TREE_TYPE (op0
), arg02
));
7795 tem
= fold_build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7798 /* If this was a conversion, and all we did was to move into
7799 inside the COND_EXPR, bring it back out. But leave it if
7800 it is a conversion from integer to integer and the
7801 result precision is no wider than a word since such a
7802 conversion is cheap and may be optimized away by combine,
7803 while it couldn't if it were outside the COND_EXPR. Then return
7804 so we don't get into an infinite recursion loop taking the
7805 conversion out and then back in. */
7807 if ((CONVERT_EXPR_CODE_P (code
)
7808 || code
== NON_LVALUE_EXPR
)
7809 && TREE_CODE (tem
) == COND_EXPR
7810 && TREE_CODE (TREE_OPERAND (tem
, 1)) == code
7811 && TREE_CODE (TREE_OPERAND (tem
, 2)) == code
7812 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 1))
7813 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 2))
7814 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))
7815 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 2), 0)))
7816 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7818 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))))
7819 && TYPE_PRECISION (TREE_TYPE (tem
)) <= BITS_PER_WORD
)
7820 || flag_syntax_only
))
7821 tem
= build1_loc (loc
, code
, type
,
7823 TREE_TYPE (TREE_OPERAND
7824 (TREE_OPERAND (tem
, 1), 0)),
7825 TREE_OPERAND (tem
, 0),
7826 TREE_OPERAND (TREE_OPERAND (tem
, 1), 0),
7827 TREE_OPERAND (TREE_OPERAND (tem
, 2),
7835 case NON_LVALUE_EXPR
:
7836 if (!maybe_lvalue_p (op0
))
7837 return fold_convert_loc (loc
, type
, op0
);
7842 case FIX_TRUNC_EXPR
:
7843 if (COMPARISON_CLASS_P (op0
))
7845 /* If we have (type) (a CMP b) and type is an integral type, return
7846 new expression involving the new type. Canonicalize
7847 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7849 Do not fold the result as that would not simplify further, also
7850 folding again results in recursions. */
7851 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
7852 return build2_loc (loc
, TREE_CODE (op0
), type
,
7853 TREE_OPERAND (op0
, 0),
7854 TREE_OPERAND (op0
, 1));
7855 else if (!INTEGRAL_TYPE_P (type
) && !VOID_TYPE_P (type
)
7856 && TREE_CODE (type
) != VECTOR_TYPE
)
7857 return build3_loc (loc
, COND_EXPR
, type
, op0
,
7858 constant_boolean_node (true, type
),
7859 constant_boolean_node (false, type
));
7862 /* Handle (T *)&A.B.C for A being of type T and B and C
7863 living at offset zero. This occurs frequently in
7864 C++ upcasting and then accessing the base. */
7865 if (TREE_CODE (op0
) == ADDR_EXPR
7866 && POINTER_TYPE_P (type
)
7867 && handled_component_p (TREE_OPERAND (op0
, 0)))
7869 poly_int64 bitsize
, bitpos
;
7872 int unsignedp
, reversep
, volatilep
;
7874 = get_inner_reference (TREE_OPERAND (op0
, 0), &bitsize
, &bitpos
,
7875 &offset
, &mode
, &unsignedp
, &reversep
,
7877 /* If the reference was to a (constant) zero offset, we can use
7878 the address of the base if it has the same base type
7879 as the result type and the pointer type is unqualified. */
7881 && known_eq (bitpos
, 0)
7882 && (TYPE_MAIN_VARIANT (TREE_TYPE (type
))
7883 == TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
7884 && TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
7885 return fold_convert_loc (loc
, type
,
7886 build_fold_addr_expr_loc (loc
, base
));
7889 if (TREE_CODE (op0
) == MODIFY_EXPR
7890 && TREE_CONSTANT (TREE_OPERAND (op0
, 1))
7891 /* Detect assigning a bitfield. */
7892 && !(TREE_CODE (TREE_OPERAND (op0
, 0)) == COMPONENT_REF
7894 (TREE_OPERAND (TREE_OPERAND (op0
, 0), 1))))
7896 /* Don't leave an assignment inside a conversion
7897 unless assigning a bitfield. */
7898 tem
= fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 1));
7899 /* First do the assignment, then return converted constant. */
7900 tem
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (tem
), op0
, tem
);
7901 TREE_NO_WARNING (tem
) = 1;
7902 TREE_USED (tem
) = 1;
7906 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7907 constants (if x has signed type, the sign bit cannot be set
7908 in c). This folds extension into the BIT_AND_EXPR.
7909 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7910 very likely don't have maximal range for their precision and this
7911 transformation effectively doesn't preserve non-maximal ranges. */
7912 if (TREE_CODE (type
) == INTEGER_TYPE
7913 && TREE_CODE (op0
) == BIT_AND_EXPR
7914 && TREE_CODE (TREE_OPERAND (op0
, 1)) == INTEGER_CST
)
7916 tree and_expr
= op0
;
7917 tree and0
= TREE_OPERAND (and_expr
, 0);
7918 tree and1
= TREE_OPERAND (and_expr
, 1);
7921 if (TYPE_UNSIGNED (TREE_TYPE (and_expr
))
7922 || (TYPE_PRECISION (type
)
7923 <= TYPE_PRECISION (TREE_TYPE (and_expr
))))
7925 else if (TYPE_PRECISION (TREE_TYPE (and1
))
7926 <= HOST_BITS_PER_WIDE_INT
7927 && tree_fits_uhwi_p (and1
))
7929 unsigned HOST_WIDE_INT cst
;
7931 cst
= tree_to_uhwi (and1
);
7932 cst
&= HOST_WIDE_INT_M1U
7933 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
7934 change
= (cst
== 0);
7936 && !flag_syntax_only
7937 && (load_extend_op (TYPE_MODE (TREE_TYPE (and0
)))
7940 tree uns
= unsigned_type_for (TREE_TYPE (and0
));
7941 and0
= fold_convert_loc (loc
, uns
, and0
);
7942 and1
= fold_convert_loc (loc
, uns
, and1
);
7947 tem
= force_fit_type (type
, wi::to_widest (and1
), 0,
7948 TREE_OVERFLOW (and1
));
7949 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
7950 fold_convert_loc (loc
, type
, and0
), tem
);
7954 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7955 cast (T1)X will fold away. We assume that this happens when X itself
7957 if (POINTER_TYPE_P (type
)
7958 && TREE_CODE (arg0
) == POINTER_PLUS_EXPR
7959 && CONVERT_EXPR_P (TREE_OPERAND (arg0
, 0)))
7961 tree arg00
= TREE_OPERAND (arg0
, 0);
7962 tree arg01
= TREE_OPERAND (arg0
, 1);
7964 return fold_build_pointer_plus_loc
7965 (loc
, fold_convert_loc (loc
, type
, arg00
), arg01
);
7968 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7969 of the same precision, and X is an integer type not narrower than
7970 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7971 if (INTEGRAL_TYPE_P (type
)
7972 && TREE_CODE (op0
) == BIT_NOT_EXPR
7973 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7974 && CONVERT_EXPR_P (TREE_OPERAND (op0
, 0))
7975 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
7977 tem
= TREE_OPERAND (TREE_OPERAND (op0
, 0), 0);
7978 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7979 && TYPE_PRECISION (type
) <= TYPE_PRECISION (TREE_TYPE (tem
)))
7980 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
7981 fold_convert_loc (loc
, type
, tem
));
7984 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7985 type of X and Y (integer types only). */
7986 if (INTEGRAL_TYPE_P (type
)
7987 && TREE_CODE (op0
) == MULT_EXPR
7988 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7989 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7991 /* Be careful not to introduce new overflows. */
7993 if (TYPE_OVERFLOW_WRAPS (type
))
7996 mult_type
= unsigned_type_for (type
);
7998 if (TYPE_PRECISION (mult_type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
8000 tem
= fold_build2_loc (loc
, MULT_EXPR
, mult_type
,
8001 fold_convert_loc (loc
, mult_type
,
8002 TREE_OPERAND (op0
, 0)),
8003 fold_convert_loc (loc
, mult_type
,
8004 TREE_OPERAND (op0
, 1)));
8005 return fold_convert_loc (loc
, type
, tem
);
8011 case VIEW_CONVERT_EXPR
:
8012 if (TREE_CODE (op0
) == MEM_REF
)
8014 if (TYPE_ALIGN (TREE_TYPE (op0
)) != TYPE_ALIGN (type
))
8015 type
= build_aligned_type (type
, TYPE_ALIGN (TREE_TYPE (op0
)));
8016 tem
= fold_build2_loc (loc
, MEM_REF
, type
,
8017 TREE_OPERAND (op0
, 0), TREE_OPERAND (op0
, 1));
8018 REF_REVERSE_STORAGE_ORDER (tem
) = REF_REVERSE_STORAGE_ORDER (op0
);
8025 tem
= fold_negate_expr (loc
, arg0
);
8027 return fold_convert_loc (loc
, type
, tem
);
8031 /* Convert fabs((double)float) into (double)fabsf(float). */
8032 if (TREE_CODE (arg0
) == NOP_EXPR
8033 && TREE_CODE (type
) == REAL_TYPE
)
8035 tree targ0
= strip_float_extensions (arg0
);
8037 return fold_convert_loc (loc
, type
,
8038 fold_build1_loc (loc
, ABS_EXPR
,
8045 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8046 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8047 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8048 fold_convert_loc (loc
, type
,
8049 TREE_OPERAND (arg0
, 0)))))
8050 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, tem
,
8051 fold_convert_loc (loc
, type
,
8052 TREE_OPERAND (arg0
, 1)));
8053 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8054 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8055 fold_convert_loc (loc
, type
,
8056 TREE_OPERAND (arg0
, 1)))))
8057 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
8058 fold_convert_loc (loc
, type
,
8059 TREE_OPERAND (arg0
, 0)), tem
);
8063 case TRUTH_NOT_EXPR
:
8064 /* Note that the operand of this must be an int
8065 and its values must be 0 or 1.
8066 ("true" is a fixed value perhaps depending on the language,
8067 but we don't handle values other than 1 correctly yet.) */
8068 tem
= fold_truth_not_expr (loc
, arg0
);
8071 return fold_convert_loc (loc
, type
, tem
);
8074 /* Fold *&X to X if X is an lvalue. */
8075 if (TREE_CODE (op0
) == ADDR_EXPR
)
8077 tree op00
= TREE_OPERAND (op0
, 0);
8079 || TREE_CODE (op00
) == PARM_DECL
8080 || TREE_CODE (op00
) == RESULT_DECL
)
8081 && !TREE_READONLY (op00
))
8088 } /* switch (code) */
8092 /* If the operation was a conversion do _not_ mark a resulting constant
8093 with TREE_OVERFLOW if the original constant was not. These conversions
8094 have implementation defined behavior and retaining the TREE_OVERFLOW
8095 flag here would confuse later passes such as VRP. */
8097 fold_unary_ignore_overflow_loc (location_t loc
, enum tree_code code
,
8098 tree type
, tree op0
)
8100 tree res
= fold_unary_loc (loc
, code
, type
, op0
);
8102 && TREE_CODE (res
) == INTEGER_CST
8103 && TREE_CODE (op0
) == INTEGER_CST
8104 && CONVERT_EXPR_CODE_P (code
))
8105 TREE_OVERFLOW (res
) = TREE_OVERFLOW (op0
);
8110 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8111 operands OP0 and OP1. LOC is the location of the resulting expression.
8112 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8113 Return the folded expression if folding is successful. Otherwise,
8114 return NULL_TREE. */
8116 fold_truth_andor (location_t loc
, enum tree_code code
, tree type
,
8117 tree arg0
, tree arg1
, tree op0
, tree op1
)
8121 /* We only do these simplifications if we are optimizing. */
8125 /* Check for things like (A || B) && (A || C). We can convert this
8126 to A || (B && C). Note that either operator can be any of the four
8127 truth and/or operations and the transformation will still be
8128 valid. Also note that we only care about order for the
8129 ANDIF and ORIF operators. If B contains side effects, this
8130 might change the truth-value of A. */
8131 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8132 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
8133 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
8134 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
8135 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
8136 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
8138 tree a00
= TREE_OPERAND (arg0
, 0);
8139 tree a01
= TREE_OPERAND (arg0
, 1);
8140 tree a10
= TREE_OPERAND (arg1
, 0);
8141 tree a11
= TREE_OPERAND (arg1
, 1);
8142 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
8143 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
8144 && (code
== TRUTH_AND_EXPR
8145 || code
== TRUTH_OR_EXPR
));
8147 if (operand_equal_p (a00
, a10
, 0))
8148 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8149 fold_build2_loc (loc
, code
, type
, a01
, a11
));
8150 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
8151 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8152 fold_build2_loc (loc
, code
, type
, a01
, a10
));
8153 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
8154 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a01
,
8155 fold_build2_loc (loc
, code
, type
, a00
, a11
));
8157 /* This case if tricky because we must either have commutative
8158 operators or else A10 must not have side-effects. */
8160 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
8161 && operand_equal_p (a01
, a11
, 0))
8162 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
8163 fold_build2_loc (loc
, code
, type
, a00
, a10
),
8167 /* See if we can build a range comparison. */
8168 if ((tem
= fold_range_test (loc
, code
, type
, op0
, op1
)) != 0)
8171 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
)
8172 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
))
8174 tem
= merge_truthop_with_opposite_arm (loc
, arg0
, arg1
, true);
8176 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
8179 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ORIF_EXPR
)
8180 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ANDIF_EXPR
))
8182 tem
= merge_truthop_with_opposite_arm (loc
, arg1
, arg0
, false);
8184 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
8187 /* Check for the possibility of merging component references. If our
8188 lhs is another similar operation, try to merge its rhs with our
8189 rhs. Then try to merge our lhs and rhs. */
8190 if (TREE_CODE (arg0
) == code
8191 && (tem
= fold_truth_andor_1 (loc
, code
, type
,
8192 TREE_OPERAND (arg0
, 1), arg1
)) != 0)
8193 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
8195 if ((tem
= fold_truth_andor_1 (loc
, code
, type
, arg0
, arg1
)) != 0)
8198 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8199 && !flag_sanitize_coverage
8200 && (code
== TRUTH_AND_EXPR
8201 || code
== TRUTH_ANDIF_EXPR
8202 || code
== TRUTH_OR_EXPR
8203 || code
== TRUTH_ORIF_EXPR
))
8205 enum tree_code ncode
, icode
;
8207 ncode
= (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_AND_EXPR
)
8208 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
;
8209 icode
= ncode
== TRUTH_AND_EXPR
? TRUTH_ANDIF_EXPR
: TRUTH_ORIF_EXPR
;
8211 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8212 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8213 We don't want to pack more than two leafs to a non-IF AND/OR
8215 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8216 equal to IF-CODE, then we don't want to add right-hand operand.
8217 If the inner right-hand side of left-hand operand has
8218 side-effects, or isn't simple, then we can't add to it,
8219 as otherwise we might destroy if-sequence. */
8220 if (TREE_CODE (arg0
) == icode
8221 && simple_operand_p_2 (arg1
)
8222 /* Needed for sequence points to handle trappings, and
8224 && simple_operand_p_2 (TREE_OPERAND (arg0
, 1)))
8226 tem
= fold_build2_loc (loc
, ncode
, type
, TREE_OPERAND (arg0
, 1),
8228 return fold_build2_loc (loc
, icode
, type
, TREE_OPERAND (arg0
, 0),
8231 /* Same as above but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8232 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8233 else if (TREE_CODE (arg1
) == icode
8234 && simple_operand_p_2 (arg0
)
8235 /* Needed for sequence points to handle trappings, and
8237 && simple_operand_p_2 (TREE_OPERAND (arg1
, 0)))
8239 tem
= fold_build2_loc (loc
, ncode
, type
,
8240 arg0
, TREE_OPERAND (arg1
, 0));
8241 return fold_build2_loc (loc
, icode
, type
, tem
,
8242 TREE_OPERAND (arg1
, 1));
8244 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8246 For sequence point consistancy, we need to check for trapping,
8247 and side-effects. */
8248 else if (code
== icode
&& simple_operand_p_2 (arg0
)
8249 && simple_operand_p_2 (arg1
))
8250 return fold_build2_loc (loc
, ncode
, type
, arg0
, arg1
);
8256 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8257 by changing CODE to reduce the magnitude of constants involved in
8258 ARG0 of the comparison.
8259 Returns a canonicalized comparison tree if a simplification was
8260 possible, otherwise returns NULL_TREE.
8261 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8262 valid if signed overflow is undefined. */
8265 maybe_canonicalize_comparison_1 (location_t loc
, enum tree_code code
, tree type
,
8266 tree arg0
, tree arg1
,
8267 bool *strict_overflow_p
)
8269 enum tree_code code0
= TREE_CODE (arg0
);
8270 tree t
, cst0
= NULL_TREE
;
8273 /* Match A +- CST code arg1. We can change this only if overflow
8275 if (!((ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8276 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8277 /* In principle pointers also have undefined overflow behavior,
8278 but that causes problems elsewhere. */
8279 && !POINTER_TYPE_P (TREE_TYPE (arg0
))
8280 && (code0
== MINUS_EXPR
8281 || code0
== PLUS_EXPR
)
8282 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
))
8285 /* Identify the constant in arg0 and its sign. */
8286 cst0
= TREE_OPERAND (arg0
, 1);
8287 sgn0
= tree_int_cst_sgn (cst0
);
8289 /* Overflowed constants and zero will cause problems. */
8290 if (integer_zerop (cst0
)
8291 || TREE_OVERFLOW (cst0
))
8294 /* See if we can reduce the magnitude of the constant in
8295 arg0 by changing the comparison code. */
8296 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8298 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8300 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8301 else if (code
== GT_EXPR
8302 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8304 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8305 else if (code
== LE_EXPR
8306 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8308 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8309 else if (code
== GE_EXPR
8310 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8314 *strict_overflow_p
= true;
8316 /* Now build the constant reduced in magnitude. But not if that
8317 would produce one outside of its types range. */
8318 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0
))
8320 && TYPE_MIN_VALUE (TREE_TYPE (cst0
))
8321 && tree_int_cst_equal (cst0
, TYPE_MIN_VALUE (TREE_TYPE (cst0
))))
8323 && TYPE_MAX_VALUE (TREE_TYPE (cst0
))
8324 && tree_int_cst_equal (cst0
, TYPE_MAX_VALUE (TREE_TYPE (cst0
))))))
8327 t
= int_const_binop (sgn0
== -1 ? PLUS_EXPR
: MINUS_EXPR
,
8328 cst0
, build_int_cst (TREE_TYPE (cst0
), 1));
8329 t
= fold_build2_loc (loc
, code0
, TREE_TYPE (arg0
), TREE_OPERAND (arg0
, 0), t
);
8330 t
= fold_convert (TREE_TYPE (arg1
), t
);
8332 return fold_build2_loc (loc
, code
, type
, t
, arg1
);
8335 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8336 overflow further. Try to decrease the magnitude of constants involved
8337 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8338 and put sole constants at the second argument position.
8339 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8342 maybe_canonicalize_comparison (location_t loc
, enum tree_code code
, tree type
,
8343 tree arg0
, tree arg1
)
8346 bool strict_overflow_p
;
8347 const char * const warnmsg
= G_("assuming signed overflow does not occur "
8348 "when reducing constant in comparison");
8350 /* Try canonicalization by simplifying arg0. */
8351 strict_overflow_p
= false;
8352 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg0
, arg1
,
8353 &strict_overflow_p
);
8356 if (strict_overflow_p
)
8357 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8361 /* Try canonicalization by simplifying arg1 using the swapped
8363 code
= swap_tree_comparison (code
);
8364 strict_overflow_p
= false;
8365 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg1
, arg0
,
8366 &strict_overflow_p
);
8367 if (t
&& strict_overflow_p
)
8368 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8372 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8373 space. This is used to avoid issuing overflow warnings for
8374 expressions like &p->x which can not wrap. */
8377 pointer_may_wrap_p (tree base
, tree offset
, poly_int64 bitpos
)
8379 if (!POINTER_TYPE_P (TREE_TYPE (base
)))
8382 if (maybe_lt (bitpos
, 0))
8385 poly_wide_int wi_offset
;
8386 int precision
= TYPE_PRECISION (TREE_TYPE (base
));
8387 if (offset
== NULL_TREE
)
8388 wi_offset
= wi::zero (precision
);
8389 else if (!poly_int_tree_p (offset
) || TREE_OVERFLOW (offset
))
8392 wi_offset
= wi::to_poly_wide (offset
);
8395 poly_wide_int units
= wi::shwi (bits_to_bytes_round_down (bitpos
),
8397 poly_wide_int total
= wi::add (wi_offset
, units
, UNSIGNED
, &overflow
);
8401 poly_uint64 total_hwi
, size
;
8402 if (!total
.to_uhwi (&total_hwi
)
8403 || !poly_int_tree_p (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (base
))),
8405 || known_eq (size
, 0U))
8408 if (known_le (total_hwi
, size
))
8411 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8413 if (TREE_CODE (base
) == ADDR_EXPR
8414 && poly_int_tree_p (TYPE_SIZE_UNIT (TREE_TYPE (TREE_OPERAND (base
, 0))),
8416 && maybe_ne (size
, 0U)
8417 && known_le (total_hwi
, size
))
8423 /* Return a positive integer when the symbol DECL is known to have
8424 a nonzero address, zero when it's known not to (e.g., it's a weak
8425 symbol), and a negative integer when the symbol is not yet in the
8426 symbol table and so whether or not its address is zero is unknown.
8427 For function local objects always return positive integer. */
8429 maybe_nonzero_address (tree decl
)
8431 if (DECL_P (decl
) && decl_in_symtab_p (decl
))
8432 if (struct symtab_node
*symbol
= symtab_node::get_create (decl
))
8433 return symbol
->nonzero_address ();
8435 /* Function local objects are never NULL. */
8437 && (DECL_CONTEXT (decl
)
8438 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
8439 && auto_var_in_fn_p (decl
, DECL_CONTEXT (decl
))))
8445 /* Subroutine of fold_binary. This routine performs all of the
8446 transformations that are common to the equality/inequality
8447 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8448 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8449 fold_binary should call fold_binary. Fold a comparison with
8450 tree code CODE and type TYPE with operands OP0 and OP1. Return
8451 the folded comparison or NULL_TREE. */
8454 fold_comparison (location_t loc
, enum tree_code code
, tree type
,
8457 const bool equality_code
= (code
== EQ_EXPR
|| code
== NE_EXPR
);
8458 tree arg0
, arg1
, tem
;
8463 STRIP_SIGN_NOPS (arg0
);
8464 STRIP_SIGN_NOPS (arg1
);
8466 /* For comparisons of pointers we can decompose it to a compile time
8467 comparison of the base objects and the offsets into the object.
8468 This requires at least one operand being an ADDR_EXPR or a
8469 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8470 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
8471 && (TREE_CODE (arg0
) == ADDR_EXPR
8472 || TREE_CODE (arg1
) == ADDR_EXPR
8473 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8474 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
8476 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
8477 poly_int64 bitsize
, bitpos0
= 0, bitpos1
= 0;
8479 int volatilep
, reversep
, unsignedp
;
8480 bool indirect_base0
= false, indirect_base1
= false;
8482 /* Get base and offset for the access. Strip ADDR_EXPR for
8483 get_inner_reference, but put it back by stripping INDIRECT_REF
8484 off the base object if possible. indirect_baseN will be true
8485 if baseN is not an address but refers to the object itself. */
8487 if (TREE_CODE (arg0
) == ADDR_EXPR
)
8490 = get_inner_reference (TREE_OPERAND (arg0
, 0),
8491 &bitsize
, &bitpos0
, &offset0
, &mode
,
8492 &unsignedp
, &reversep
, &volatilep
);
8493 if (TREE_CODE (base0
) == INDIRECT_REF
)
8494 base0
= TREE_OPERAND (base0
, 0);
8496 indirect_base0
= true;
8498 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
8500 base0
= TREE_OPERAND (arg0
, 0);
8501 STRIP_SIGN_NOPS (base0
);
8502 if (TREE_CODE (base0
) == ADDR_EXPR
)
8505 = get_inner_reference (TREE_OPERAND (base0
, 0),
8506 &bitsize
, &bitpos0
, &offset0
, &mode
,
8507 &unsignedp
, &reversep
, &volatilep
);
8508 if (TREE_CODE (base0
) == INDIRECT_REF
)
8509 base0
= TREE_OPERAND (base0
, 0);
8511 indirect_base0
= true;
8513 if (offset0
== NULL_TREE
|| integer_zerop (offset0
))
8514 offset0
= TREE_OPERAND (arg0
, 1);
8516 offset0
= size_binop (PLUS_EXPR
, offset0
,
8517 TREE_OPERAND (arg0
, 1));
8518 if (poly_int_tree_p (offset0
))
8520 poly_offset_int tem
= wi::sext (wi::to_poly_offset (offset0
),
8521 TYPE_PRECISION (sizetype
));
8522 tem
<<= LOG2_BITS_PER_UNIT
;
8524 if (tem
.to_shwi (&bitpos0
))
8525 offset0
= NULL_TREE
;
8530 if (TREE_CODE (arg1
) == ADDR_EXPR
)
8533 = get_inner_reference (TREE_OPERAND (arg1
, 0),
8534 &bitsize
, &bitpos1
, &offset1
, &mode
,
8535 &unsignedp
, &reversep
, &volatilep
);
8536 if (TREE_CODE (base1
) == INDIRECT_REF
)
8537 base1
= TREE_OPERAND (base1
, 0);
8539 indirect_base1
= true;
8541 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
8543 base1
= TREE_OPERAND (arg1
, 0);
8544 STRIP_SIGN_NOPS (base1
);
8545 if (TREE_CODE (base1
) == ADDR_EXPR
)
8548 = get_inner_reference (TREE_OPERAND (base1
, 0),
8549 &bitsize
, &bitpos1
, &offset1
, &mode
,
8550 &unsignedp
, &reversep
, &volatilep
);
8551 if (TREE_CODE (base1
) == INDIRECT_REF
)
8552 base1
= TREE_OPERAND (base1
, 0);
8554 indirect_base1
= true;
8556 if (offset1
== NULL_TREE
|| integer_zerop (offset1
))
8557 offset1
= TREE_OPERAND (arg1
, 1);
8559 offset1
= size_binop (PLUS_EXPR
, offset1
,
8560 TREE_OPERAND (arg1
, 1));
8561 if (poly_int_tree_p (offset1
))
8563 poly_offset_int tem
= wi::sext (wi::to_poly_offset (offset1
),
8564 TYPE_PRECISION (sizetype
));
8565 tem
<<= LOG2_BITS_PER_UNIT
;
8567 if (tem
.to_shwi (&bitpos1
))
8568 offset1
= NULL_TREE
;
8572 /* If we have equivalent bases we might be able to simplify. */
8573 if (indirect_base0
== indirect_base1
8574 && operand_equal_p (base0
, base1
,
8575 indirect_base0
? OEP_ADDRESS_OF
: 0))
8577 /* We can fold this expression to a constant if the non-constant
8578 offset parts are equal. */
8579 if ((offset0
== offset1
8580 || (offset0
&& offset1
8581 && operand_equal_p (offset0
, offset1
, 0)))
8584 && (DECL_P (base0
) || CONSTANT_CLASS_P (base0
)))
8585 || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))))
8588 && maybe_ne (bitpos0
, bitpos1
)
8589 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8590 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8591 fold_overflow_warning (("assuming pointer wraparound does not "
8592 "occur when comparing P +- C1 with "
8594 WARN_STRICT_OVERFLOW_CONDITIONAL
);
8599 if (known_eq (bitpos0
, bitpos1
))
8600 return constant_boolean_node (true, type
);
8601 if (known_ne (bitpos0
, bitpos1
))
8602 return constant_boolean_node (false, type
);
8605 if (known_ne (bitpos0
, bitpos1
))
8606 return constant_boolean_node (true, type
);
8607 if (known_eq (bitpos0
, bitpos1
))
8608 return constant_boolean_node (false, type
);
8611 if (known_lt (bitpos0
, bitpos1
))
8612 return constant_boolean_node (true, type
);
8613 if (known_ge (bitpos0
, bitpos1
))
8614 return constant_boolean_node (false, type
);
8617 if (known_le (bitpos0
, bitpos1
))
8618 return constant_boolean_node (true, type
);
8619 if (known_gt (bitpos0
, bitpos1
))
8620 return constant_boolean_node (false, type
);
8623 if (known_ge (bitpos0
, bitpos1
))
8624 return constant_boolean_node (true, type
);
8625 if (known_lt (bitpos0
, bitpos1
))
8626 return constant_boolean_node (false, type
);
8629 if (known_gt (bitpos0
, bitpos1
))
8630 return constant_boolean_node (true, type
);
8631 if (known_le (bitpos0
, bitpos1
))
8632 return constant_boolean_node (false, type
);
8637 /* We can simplify the comparison to a comparison of the variable
8638 offset parts if the constant offset parts are equal.
8639 Be careful to use signed sizetype here because otherwise we
8640 mess with array offsets in the wrong way. This is possible
8641 because pointer arithmetic is restricted to retain within an
8642 object and overflow on pointer differences is undefined as of
8643 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8644 else if (known_eq (bitpos0
, bitpos1
)
8647 && (DECL_P (base0
) || CONSTANT_CLASS_P (base0
)))
8648 || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))))
8650 /* By converting to signed sizetype we cover middle-end pointer
8651 arithmetic which operates on unsigned pointer types of size
8652 type size and ARRAY_REF offsets which are properly sign or
8653 zero extended from their type in case it is narrower than
8655 if (offset0
== NULL_TREE
)
8656 offset0
= build_int_cst (ssizetype
, 0);
8658 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
8659 if (offset1
== NULL_TREE
)
8660 offset1
= build_int_cst (ssizetype
, 0);
8662 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
8665 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8666 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8667 fold_overflow_warning (("assuming pointer wraparound does not "
8668 "occur when comparing P +- C1 with "
8670 WARN_STRICT_OVERFLOW_COMPARISON
);
8672 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
8675 /* For equal offsets we can simplify to a comparison of the
8677 else if (known_eq (bitpos0
, bitpos1
)
8679 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
8681 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
8682 && ((offset0
== offset1
)
8683 || (offset0
&& offset1
8684 && operand_equal_p (offset0
, offset1
, 0))))
8687 base0
= build_fold_addr_expr_loc (loc
, base0
);
8689 base1
= build_fold_addr_expr_loc (loc
, base1
);
8690 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
8692 /* Comparison between an ordinary (non-weak) symbol and a null
8693 pointer can be eliminated since such symbols must have a non
8694 null address. In C, relational expressions between pointers
8695 to objects and null pointers are undefined. The results
8696 below follow the C++ rules with the additional property that
8697 every object pointer compares greater than a null pointer.
8699 else if (((DECL_P (base0
)
8700 && maybe_nonzero_address (base0
) > 0
8701 /* Avoid folding references to struct members at offset 0 to
8702 prevent tests like '&ptr->firstmember == 0' from getting
8703 eliminated. When ptr is null, although the -> expression
8704 is strictly speaking invalid, GCC retains it as a matter
8705 of QoI. See PR c/44555. */
8706 && (offset0
== NULL_TREE
&& known_ne (bitpos0
, 0)))
8707 || CONSTANT_CLASS_P (base0
))
8709 /* The caller guarantees that when one of the arguments is
8710 constant (i.e., null in this case) it is second. */
8711 && integer_zerop (arg1
))
8718 return constant_boolean_node (false, type
);
8722 return constant_boolean_node (true, type
);
8729 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8730 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8731 the resulting offset is smaller in absolute value than the
8732 original one and has the same sign. */
8733 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8734 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
8735 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8736 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8737 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
8738 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
8739 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
8740 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
8742 tree const1
= TREE_OPERAND (arg0
, 1);
8743 tree const2
= TREE_OPERAND (arg1
, 1);
8744 tree variable1
= TREE_OPERAND (arg0
, 0);
8745 tree variable2
= TREE_OPERAND (arg1
, 0);
8747 const char * const warnmsg
= G_("assuming signed overflow does not "
8748 "occur when combining constants around "
8751 /* Put the constant on the side where it doesn't overflow and is
8752 of lower absolute value and of same sign than before. */
8753 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8754 ? MINUS_EXPR
: PLUS_EXPR
,
8756 if (!TREE_OVERFLOW (cst
)
8757 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
)
8758 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const2
))
8760 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8761 return fold_build2_loc (loc
, code
, type
,
8763 fold_build2_loc (loc
, TREE_CODE (arg1
),
8768 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8769 ? MINUS_EXPR
: PLUS_EXPR
,
8771 if (!TREE_OVERFLOW (cst
)
8772 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
)
8773 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const1
))
8775 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8776 return fold_build2_loc (loc
, code
, type
,
8777 fold_build2_loc (loc
, TREE_CODE (arg0
),
8784 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
8788 /* If we are comparing an expression that just has comparisons
8789 of two integer values, arithmetic expressions of those comparisons,
8790 and constants, we can simplify it. There are only three cases
8791 to check: the two values can either be equal, the first can be
8792 greater, or the second can be greater. Fold the expression for
8793 those three values. Since each value must be 0 or 1, we have
8794 eight possibilities, each of which corresponds to the constant 0
8795 or 1 or one of the six possible comparisons.
8797 This handles common cases like (a > b) == 0 but also handles
8798 expressions like ((x > y) - (y > x)) > 0, which supposedly
8799 occur in macroized code. */
8801 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
8803 tree cval1
= 0, cval2
= 0;
8805 if (twoval_comparison_p (arg0
, &cval1
, &cval2
)
8806 /* Don't handle degenerate cases here; they should already
8807 have been handled anyway. */
8808 && cval1
!= 0 && cval2
!= 0
8809 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
8810 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
8811 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
8812 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
8813 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
8814 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
8815 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
8817 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
8818 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
8820 /* We can't just pass T to eval_subst in case cval1 or cval2
8821 was the same as ARG1. */
8824 = fold_build2_loc (loc
, code
, type
,
8825 eval_subst (loc
, arg0
, cval1
, maxval
,
8829 = fold_build2_loc (loc
, code
, type
,
8830 eval_subst (loc
, arg0
, cval1
, maxval
,
8834 = fold_build2_loc (loc
, code
, type
,
8835 eval_subst (loc
, arg0
, cval1
, minval
,
8839 /* All three of these results should be 0 or 1. Confirm they are.
8840 Then use those values to select the proper code to use. */
8842 if (TREE_CODE (high_result
) == INTEGER_CST
8843 && TREE_CODE (equal_result
) == INTEGER_CST
8844 && TREE_CODE (low_result
) == INTEGER_CST
)
8846 /* Make a 3-bit mask with the high-order bit being the
8847 value for `>', the next for '=', and the low for '<'. */
8848 switch ((integer_onep (high_result
) * 4)
8849 + (integer_onep (equal_result
) * 2)
8850 + integer_onep (low_result
))
8854 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
8875 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
8878 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
8887 /* Subroutine of fold_binary. Optimize complex multiplications of the
8888 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8889 argument EXPR represents the expression "z" of type TYPE. */
8892 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
8894 tree itype
= TREE_TYPE (type
);
8895 tree rpart
, ipart
, tem
;
8897 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
8899 rpart
= TREE_OPERAND (expr
, 0);
8900 ipart
= TREE_OPERAND (expr
, 1);
8902 else if (TREE_CODE (expr
) == COMPLEX_CST
)
8904 rpart
= TREE_REALPART (expr
);
8905 ipart
= TREE_IMAGPART (expr
);
8909 expr
= save_expr (expr
);
8910 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
8911 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
8914 rpart
= save_expr (rpart
);
8915 ipart
= save_expr (ipart
);
8916 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
8917 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
8918 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
8919 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
8920 build_zero_cst (itype
));
8924 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8925 CONSTRUCTOR ARG into array ELTS, which has NELTS elements, and return
8926 true if successful. */
8929 vec_cst_ctor_to_array (tree arg
, unsigned int nelts
, tree
*elts
)
8931 unsigned HOST_WIDE_INT i
, nunits
;
8933 if (TREE_CODE (arg
) == VECTOR_CST
8934 && VECTOR_CST_NELTS (arg
).is_constant (&nunits
))
8936 for (i
= 0; i
< nunits
; ++i
)
8937 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
8939 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
8941 constructor_elt
*elt
;
8943 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
8944 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
8947 elts
[i
] = elt
->value
;
8951 for (; i
< nelts
; i
++)
8953 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
8957 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8958 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8959 NULL_TREE otherwise. */
8962 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const vec_perm_indices
&sel
)
8965 unsigned HOST_WIDE_INT nelts
;
8966 bool need_ctor
= false;
8968 if (!sel
.length ().is_constant (&nelts
))
8970 gcc_assert (known_eq (TYPE_VECTOR_SUBPARTS (type
), nelts
)
8971 && known_eq (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)), nelts
)
8972 && known_eq (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)), nelts
));
8973 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
8974 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
8977 tree
*in_elts
= XALLOCAVEC (tree
, nelts
* 2);
8978 if (!vec_cst_ctor_to_array (arg0
, nelts
, in_elts
)
8979 || !vec_cst_ctor_to_array (arg1
, nelts
, in_elts
+ nelts
))
8982 tree_vector_builder
out_elts (type
, nelts
, 1);
8983 for (i
= 0; i
< nelts
; i
++)
8985 HOST_WIDE_INT index
;
8986 if (!sel
[i
].is_constant (&index
))
8988 if (!CONSTANT_CLASS_P (in_elts
[index
]))
8990 out_elts
.quick_push (unshare_expr (in_elts
[index
]));
8995 vec
<constructor_elt
, va_gc
> *v
;
8996 vec_alloc (v
, nelts
);
8997 for (i
= 0; i
< nelts
; i
++)
8998 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, out_elts
[i
]);
8999 return build_constructor (type
, v
);
9002 return out_elts
.build ();
9005 /* Try to fold a pointer difference of type TYPE two address expressions of
9006 array references AREF0 and AREF1 using location LOC. Return a
9007 simplified expression for the difference or NULL_TREE. */
9010 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
9011 tree aref0
, tree aref1
,
9012 bool use_pointer_diff
)
9014 tree base0
= TREE_OPERAND (aref0
, 0);
9015 tree base1
= TREE_OPERAND (aref1
, 0);
9016 tree base_offset
= build_int_cst (type
, 0);
9018 /* If the bases are array references as well, recurse. If the bases
9019 are pointer indirections compute the difference of the pointers.
9020 If the bases are equal, we are set. */
9021 if ((TREE_CODE (base0
) == ARRAY_REF
9022 && TREE_CODE (base1
) == ARRAY_REF
9024 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
,
9026 || (INDIRECT_REF_P (base0
)
9027 && INDIRECT_REF_P (base1
)
9030 ? fold_binary_loc (loc
, POINTER_DIFF_EXPR
, type
,
9031 TREE_OPERAND (base0
, 0),
9032 TREE_OPERAND (base1
, 0))
9033 : fold_binary_loc (loc
, MINUS_EXPR
, type
,
9035 TREE_OPERAND (base0
, 0)),
9037 TREE_OPERAND (base1
, 0)))))
9038 || operand_equal_p (base0
, base1
, OEP_ADDRESS_OF
))
9040 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
9041 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
9042 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
9043 tree diff
= fold_build2_loc (loc
, MINUS_EXPR
, type
, op0
, op1
);
9044 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9046 fold_build2_loc (loc
, MULT_EXPR
, type
,
9052 /* If the real or vector real constant CST of type TYPE has an exact
9053 inverse, return it, else return NULL. */
9056 exact_inverse (tree type
, tree cst
)
9062 switch (TREE_CODE (cst
))
9065 r
= TREE_REAL_CST (cst
);
9067 if (exact_real_inverse (TYPE_MODE (type
), &r
))
9068 return build_real (type
, r
);
9074 unit_type
= TREE_TYPE (type
);
9075 mode
= TYPE_MODE (unit_type
);
9077 tree_vector_builder elts
;
9078 if (!elts
.new_unary_operation (type
, cst
, false))
9080 unsigned int count
= elts
.encoded_nelts ();
9081 for (unsigned int i
= 0; i
< count
; ++i
)
9083 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
9084 if (!exact_real_inverse (mode
, &r
))
9086 elts
.quick_push (build_real (unit_type
, r
));
9089 return elts
.build ();
9097 /* Mask out the tz least significant bits of X of type TYPE where
9098 tz is the number of trailing zeroes in Y. */
9100 mask_with_tz (tree type
, const wide_int
&x
, const wide_int
&y
)
9102 int tz
= wi::ctz (y
);
9104 return wi::mask (tz
, true, TYPE_PRECISION (type
)) & x
;
9108 /* Return true when T is an address and is known to be nonzero.
9109 For floating point we further ensure that T is not denormal.
9110 Similar logic is present in nonzero_address in rtlanal.h.
9112 If the return value is based on the assumption that signed overflow
9113 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9114 change *STRICT_OVERFLOW_P. */
9117 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
9119 tree type
= TREE_TYPE (t
);
9120 enum tree_code code
;
9122 /* Doing something useful for floating point would need more work. */
9123 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
9126 code
= TREE_CODE (t
);
9127 switch (TREE_CODE_CLASS (code
))
9130 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9133 case tcc_comparison
:
9134 return tree_binary_nonzero_warnv_p (code
, type
,
9135 TREE_OPERAND (t
, 0),
9136 TREE_OPERAND (t
, 1),
9139 case tcc_declaration
:
9141 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9149 case TRUTH_NOT_EXPR
:
9150 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9153 case TRUTH_AND_EXPR
:
9155 case TRUTH_XOR_EXPR
:
9156 return tree_binary_nonzero_warnv_p (code
, type
,
9157 TREE_OPERAND (t
, 0),
9158 TREE_OPERAND (t
, 1),
9166 case WITH_SIZE_EXPR
:
9168 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9173 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
9177 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
9182 tree fndecl
= get_callee_fndecl (t
);
9183 if (!fndecl
) return false;
9184 if (flag_delete_null_pointer_checks
&& !flag_check_new
9185 && DECL_IS_OPERATOR_NEW (fndecl
)
9186 && !TREE_NOTHROW (fndecl
))
9188 if (flag_delete_null_pointer_checks
9189 && lookup_attribute ("returns_nonnull",
9190 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
9192 return alloca_call_p (t
);
9201 /* Return true when T is an address and is known to be nonzero.
9202 Handle warnings about undefined signed overflow. */
9205 tree_expr_nonzero_p (tree t
)
9207 bool ret
, strict_overflow_p
;
9209 strict_overflow_p
= false;
9210 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
9211 if (strict_overflow_p
)
9212 fold_overflow_warning (("assuming signed overflow does not occur when "
9213 "determining that expression is always "
9215 WARN_STRICT_OVERFLOW_MISC
);
9219 /* Return true if T is known not to be equal to an integer W. */
9222 expr_not_equal_to (tree t
, const wide_int
&w
)
9224 wide_int min
, max
, nz
;
9225 value_range_type rtype
;
9226 switch (TREE_CODE (t
))
9229 return wi::to_wide (t
) != w
;
9232 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
9234 rtype
= get_range_info (t
, &min
, &max
);
9235 if (rtype
== VR_RANGE
)
9237 if (wi::lt_p (max
, w
, TYPE_SIGN (TREE_TYPE (t
))))
9239 if (wi::lt_p (w
, min
, TYPE_SIGN (TREE_TYPE (t
))))
9242 else if (rtype
== VR_ANTI_RANGE
9243 && wi::le_p (min
, w
, TYPE_SIGN (TREE_TYPE (t
)))
9244 && wi::le_p (w
, max
, TYPE_SIGN (TREE_TYPE (t
))))
9246 /* If T has some known zero bits and W has any of those bits set,
9247 then T is known not to be equal to W. */
9248 if (wi::ne_p (wi::zext (wi::bit_and_not (w
, get_nonzero_bits (t
)),
9249 TYPE_PRECISION (TREE_TYPE (t
))), 0))
9258 /* Fold a binary expression of code CODE and type TYPE with operands
9259 OP0 and OP1. LOC is the location of the resulting expression.
9260 Return the folded expression if folding is successful. Otherwise,
9261 return NULL_TREE. */
9264 fold_binary_loc (location_t loc
, enum tree_code code
, tree type
,
9267 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
9268 tree arg0
, arg1
, tem
;
9269 tree t1
= NULL_TREE
;
9270 bool strict_overflow_p
;
9273 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
9274 && TREE_CODE_LENGTH (code
) == 2
9276 && op1
!= NULL_TREE
);
9281 /* Strip any conversions that don't change the mode. This is
9282 safe for every expression, except for a comparison expression
9283 because its signedness is derived from its operands. So, in
9284 the latter case, only strip conversions that don't change the
9285 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9288 Note that this is done as an internal manipulation within the
9289 constant folder, in order to find the simplest representation
9290 of the arguments so that their form can be studied. In any
9291 cases, the appropriate type conversions should be put back in
9292 the tree that will get out of the constant folder. */
9294 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
9296 STRIP_SIGN_NOPS (arg0
);
9297 STRIP_SIGN_NOPS (arg1
);
9305 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9306 constant but we can't do arithmetic on them. */
9307 if (CONSTANT_CLASS_P (arg0
) && CONSTANT_CLASS_P (arg1
))
9309 tem
= const_binop (code
, type
, arg0
, arg1
);
9310 if (tem
!= NULL_TREE
)
9312 if (TREE_TYPE (tem
) != type
)
9313 tem
= fold_convert_loc (loc
, type
, tem
);
9318 /* If this is a commutative operation, and ARG0 is a constant, move it
9319 to ARG1 to reduce the number of tests below. */
9320 if (commutative_tree_code (code
)
9321 && tree_swap_operands_p (arg0
, arg1
))
9322 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
9324 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9325 to ARG1 to reduce the number of tests below. */
9326 if (kind
== tcc_comparison
9327 && tree_swap_operands_p (arg0
, arg1
))
9328 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
9330 tem
= generic_simplify (loc
, code
, type
, op0
, op1
);
9334 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9336 First check for cases where an arithmetic operation is applied to a
9337 compound, conditional, or comparison operation. Push the arithmetic
9338 operation inside the compound or conditional to see if any folding
9339 can then be done. Convert comparison to conditional for this purpose.
9340 The also optimizes non-constant cases that used to be done in
9343 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9344 one of the operands is a comparison and the other is a comparison, a
9345 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9346 code below would make the expression more complex. Change it to a
9347 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9348 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9350 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
9351 || code
== EQ_EXPR
|| code
== NE_EXPR
)
9352 && !VECTOR_TYPE_P (TREE_TYPE (arg0
))
9353 && ((truth_value_p (TREE_CODE (arg0
))
9354 && (truth_value_p (TREE_CODE (arg1
))
9355 || (TREE_CODE (arg1
) == BIT_AND_EXPR
9356 && integer_onep (TREE_OPERAND (arg1
, 1)))))
9357 || (truth_value_p (TREE_CODE (arg1
))
9358 && (truth_value_p (TREE_CODE (arg0
))
9359 || (TREE_CODE (arg0
) == BIT_AND_EXPR
9360 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
9362 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
9363 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
9366 fold_convert_loc (loc
, boolean_type_node
, arg0
),
9367 fold_convert_loc (loc
, boolean_type_node
, arg1
));
9369 if (code
== EQ_EXPR
)
9370 tem
= invert_truthvalue_loc (loc
, tem
);
9372 return fold_convert_loc (loc
, type
, tem
);
9375 if (TREE_CODE_CLASS (code
) == tcc_binary
9376 || TREE_CODE_CLASS (code
) == tcc_comparison
)
9378 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
9380 tem
= fold_build2_loc (loc
, code
, type
,
9381 fold_convert_loc (loc
, TREE_TYPE (op0
),
9382 TREE_OPERAND (arg0
, 1)), op1
);
9383 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
9386 if (TREE_CODE (arg1
) == COMPOUND_EXPR
)
9388 tem
= fold_build2_loc (loc
, code
, type
, op0
,
9389 fold_convert_loc (loc
, TREE_TYPE (op1
),
9390 TREE_OPERAND (arg1
, 1)));
9391 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
9395 if (TREE_CODE (arg0
) == COND_EXPR
9396 || TREE_CODE (arg0
) == VEC_COND_EXPR
9397 || COMPARISON_CLASS_P (arg0
))
9399 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9401 /*cond_first_p=*/1);
9402 if (tem
!= NULL_TREE
)
9406 if (TREE_CODE (arg1
) == COND_EXPR
9407 || TREE_CODE (arg1
) == VEC_COND_EXPR
9408 || COMPARISON_CLASS_P (arg1
))
9410 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9412 /*cond_first_p=*/0);
9413 if (tem
!= NULL_TREE
)
9421 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9422 if (TREE_CODE (arg0
) == ADDR_EXPR
9423 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
9425 tree iref
= TREE_OPERAND (arg0
, 0);
9426 return fold_build2 (MEM_REF
, type
,
9427 TREE_OPERAND (iref
, 0),
9428 int_const_binop (PLUS_EXPR
, arg1
,
9429 TREE_OPERAND (iref
, 1)));
9432 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9433 if (TREE_CODE (arg0
) == ADDR_EXPR
9434 && handled_component_p (TREE_OPERAND (arg0
, 0)))
9438 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
9442 return fold_build2 (MEM_REF
, type
,
9443 build_fold_addr_expr (base
),
9444 int_const_binop (PLUS_EXPR
, arg1
,
9445 size_int (coffset
)));
9450 case POINTER_PLUS_EXPR
:
9451 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9452 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9453 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
9454 return fold_convert_loc (loc
, type
,
9455 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
9456 fold_convert_loc (loc
, sizetype
,
9458 fold_convert_loc (loc
, sizetype
,
9464 if (INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
9466 /* X + (X / CST) * -CST is X % CST. */
9467 if (TREE_CODE (arg1
) == MULT_EXPR
9468 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
9469 && operand_equal_p (arg0
,
9470 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
9472 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
9473 tree cst1
= TREE_OPERAND (arg1
, 1);
9474 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
9476 if (sum
&& integer_zerop (sum
))
9477 return fold_convert_loc (loc
, type
,
9478 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
9479 TREE_TYPE (arg0
), arg0
,
9484 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9485 one. Make sure the type is not saturating and has the signedness of
9486 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9487 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9488 if ((TREE_CODE (arg0
) == MULT_EXPR
9489 || TREE_CODE (arg1
) == MULT_EXPR
)
9490 && !TYPE_SATURATING (type
)
9491 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9492 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9493 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9495 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9500 if (! FLOAT_TYPE_P (type
))
9502 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9503 (plus (plus (mult) (mult)) (foo)) so that we can
9504 take advantage of the factoring cases below. */
9505 if (ANY_INTEGRAL_TYPE_P (type
)
9506 && TYPE_OVERFLOW_WRAPS (type
)
9507 && (((TREE_CODE (arg0
) == PLUS_EXPR
9508 || TREE_CODE (arg0
) == MINUS_EXPR
)
9509 && TREE_CODE (arg1
) == MULT_EXPR
)
9510 || ((TREE_CODE (arg1
) == PLUS_EXPR
9511 || TREE_CODE (arg1
) == MINUS_EXPR
)
9512 && TREE_CODE (arg0
) == MULT_EXPR
)))
9514 tree parg0
, parg1
, parg
, marg
;
9515 enum tree_code pcode
;
9517 if (TREE_CODE (arg1
) == MULT_EXPR
)
9518 parg
= arg0
, marg
= arg1
;
9520 parg
= arg1
, marg
= arg0
;
9521 pcode
= TREE_CODE (parg
);
9522 parg0
= TREE_OPERAND (parg
, 0);
9523 parg1
= TREE_OPERAND (parg
, 1);
9527 if (TREE_CODE (parg0
) == MULT_EXPR
9528 && TREE_CODE (parg1
) != MULT_EXPR
)
9529 return fold_build2_loc (loc
, pcode
, type
,
9530 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9531 fold_convert_loc (loc
, type
,
9533 fold_convert_loc (loc
, type
,
9535 fold_convert_loc (loc
, type
, parg1
));
9536 if (TREE_CODE (parg0
) != MULT_EXPR
9537 && TREE_CODE (parg1
) == MULT_EXPR
)
9539 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9540 fold_convert_loc (loc
, type
, parg0
),
9541 fold_build2_loc (loc
, pcode
, type
,
9542 fold_convert_loc (loc
, type
, marg
),
9543 fold_convert_loc (loc
, type
,
9549 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9550 to __complex__ ( x, y ). This is not the same for SNaNs or
9551 if signed zeros are involved. */
9552 if (!HONOR_SNANS (element_mode (arg0
))
9553 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9554 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9556 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9557 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9558 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9559 bool arg0rz
= false, arg0iz
= false;
9560 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9561 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9563 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9564 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9565 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9567 tree rp
= arg1r
? arg1r
9568 : build1 (REALPART_EXPR
, rtype
, arg1
);
9569 tree ip
= arg0i
? arg0i
9570 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9571 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9573 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9575 tree rp
= arg0r
? arg0r
9576 : build1 (REALPART_EXPR
, rtype
, arg0
);
9577 tree ip
= arg1i
? arg1i
9578 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
9579 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9584 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9585 We associate floats only if the user has specified
9586 -fassociative-math. */
9587 if (flag_associative_math
9588 && TREE_CODE (arg1
) == PLUS_EXPR
9589 && TREE_CODE (arg0
) != MULT_EXPR
)
9591 tree tree10
= TREE_OPERAND (arg1
, 0);
9592 tree tree11
= TREE_OPERAND (arg1
, 1);
9593 if (TREE_CODE (tree11
) == MULT_EXPR
9594 && TREE_CODE (tree10
) == MULT_EXPR
)
9597 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
9598 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
9601 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9602 We associate floats only if the user has specified
9603 -fassociative-math. */
9604 if (flag_associative_math
9605 && TREE_CODE (arg0
) == PLUS_EXPR
9606 && TREE_CODE (arg1
) != MULT_EXPR
)
9608 tree tree00
= TREE_OPERAND (arg0
, 0);
9609 tree tree01
= TREE_OPERAND (arg0
, 1);
9610 if (TREE_CODE (tree01
) == MULT_EXPR
9611 && TREE_CODE (tree00
) == MULT_EXPR
)
9614 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
9615 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
9621 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9622 is a rotate of A by C1 bits. */
9623 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9624 is a rotate of A by B bits.
9625 Similarly for (A << B) | (A >> (-B & C3)) where C3 is Z-1,
9626 though in this case CODE must be | and not + or ^, otherwise
9627 it doesn't return A when B is 0. */
9629 enum tree_code code0
, code1
;
9631 code0
= TREE_CODE (arg0
);
9632 code1
= TREE_CODE (arg1
);
9633 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
9634 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
9635 && operand_equal_p (TREE_OPERAND (arg0
, 0),
9636 TREE_OPERAND (arg1
, 0), 0)
9637 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9638 TYPE_UNSIGNED (rtype
))
9639 /* Only create rotates in complete modes. Other cases are not
9640 expanded properly. */
9641 && (element_precision (rtype
)
9642 == GET_MODE_UNIT_PRECISION (TYPE_MODE (rtype
))))
9644 tree tree01
, tree11
;
9645 tree orig_tree01
, orig_tree11
;
9646 enum tree_code code01
, code11
;
9648 tree01
= orig_tree01
= TREE_OPERAND (arg0
, 1);
9649 tree11
= orig_tree11
= TREE_OPERAND (arg1
, 1);
9650 STRIP_NOPS (tree01
);
9651 STRIP_NOPS (tree11
);
9652 code01
= TREE_CODE (tree01
);
9653 code11
= TREE_CODE (tree11
);
9654 if (code11
!= MINUS_EXPR
9655 && (code01
== MINUS_EXPR
|| code01
== BIT_AND_EXPR
))
9657 std::swap (code0
, code1
);
9658 std::swap (code01
, code11
);
9659 std::swap (tree01
, tree11
);
9660 std::swap (orig_tree01
, orig_tree11
);
9662 if (code01
== INTEGER_CST
9663 && code11
== INTEGER_CST
9664 && (wi::to_widest (tree01
) + wi::to_widest (tree11
)
9665 == element_precision (rtype
)))
9667 tem
= build2_loc (loc
, LROTATE_EXPR
,
9668 rtype
, TREE_OPERAND (arg0
, 0),
9669 code0
== LSHIFT_EXPR
9670 ? orig_tree01
: orig_tree11
);
9671 return fold_convert_loc (loc
, type
, tem
);
9673 else if (code11
== MINUS_EXPR
)
9675 tree tree110
, tree111
;
9676 tree110
= TREE_OPERAND (tree11
, 0);
9677 tree111
= TREE_OPERAND (tree11
, 1);
9678 STRIP_NOPS (tree110
);
9679 STRIP_NOPS (tree111
);
9680 if (TREE_CODE (tree110
) == INTEGER_CST
9681 && compare_tree_int (tree110
,
9682 element_precision (rtype
)) == 0
9683 && operand_equal_p (tree01
, tree111
, 0))
9685 tem
= build2_loc (loc
, (code0
== LSHIFT_EXPR
9686 ? LROTATE_EXPR
: RROTATE_EXPR
),
9687 rtype
, TREE_OPERAND (arg0
, 0),
9689 return fold_convert_loc (loc
, type
, tem
);
9692 else if (code
== BIT_IOR_EXPR
9693 && code11
== BIT_AND_EXPR
9694 && pow2p_hwi (element_precision (rtype
)))
9696 tree tree110
, tree111
;
9697 tree110
= TREE_OPERAND (tree11
, 0);
9698 tree111
= TREE_OPERAND (tree11
, 1);
9699 STRIP_NOPS (tree110
);
9700 STRIP_NOPS (tree111
);
9701 if (TREE_CODE (tree110
) == NEGATE_EXPR
9702 && TREE_CODE (tree111
) == INTEGER_CST
9703 && compare_tree_int (tree111
,
9704 element_precision (rtype
) - 1) == 0
9705 && operand_equal_p (tree01
, TREE_OPERAND (tree110
, 0), 0))
9707 tem
= build2_loc (loc
, (code0
== LSHIFT_EXPR
9708 ? LROTATE_EXPR
: RROTATE_EXPR
),
9709 rtype
, TREE_OPERAND (arg0
, 0),
9711 return fold_convert_loc (loc
, type
, tem
);
9718 /* In most languages, can't associate operations on floats through
9719 parentheses. Rather than remember where the parentheses were, we
9720 don't associate floats at all, unless the user has specified
9722 And, we need to make sure type is not saturating. */
9724 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
9725 && !TYPE_SATURATING (type
))
9727 tree var0
, minus_var0
, con0
, minus_con0
, lit0
, minus_lit0
;
9728 tree var1
, minus_var1
, con1
, minus_con1
, lit1
, minus_lit1
;
9732 /* Split both trees into variables, constants, and literals. Then
9733 associate each group together, the constants with literals,
9734 then the result with variables. This increases the chances of
9735 literals being recombined later and of generating relocatable
9736 expressions for the sum of a constant and literal. */
9737 var0
= split_tree (arg0
, type
, code
,
9738 &minus_var0
, &con0
, &minus_con0
,
9739 &lit0
, &minus_lit0
, 0);
9740 var1
= split_tree (arg1
, type
, code
,
9741 &minus_var1
, &con1
, &minus_con1
,
9742 &lit1
, &minus_lit1
, code
== MINUS_EXPR
);
9744 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9745 if (code
== MINUS_EXPR
)
9748 /* With undefined overflow prefer doing association in a type
9749 which wraps on overflow, if that is one of the operand types. */
9750 if ((POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
))
9751 && !TYPE_OVERFLOW_WRAPS (type
))
9753 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
9754 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
9755 atype
= TREE_TYPE (arg0
);
9756 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9757 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
9758 atype
= TREE_TYPE (arg1
);
9759 gcc_assert (TYPE_PRECISION (atype
) == TYPE_PRECISION (type
));
9762 /* With undefined overflow we can only associate constants with one
9763 variable, and constants whose association doesn't overflow. */
9764 if ((POINTER_TYPE_P (atype
) || INTEGRAL_TYPE_P (atype
))
9765 && !TYPE_OVERFLOW_WRAPS (atype
))
9767 if ((var0
&& var1
) || (minus_var0
&& minus_var1
))
9769 /* ??? If split_tree would handle NEGATE_EXPR we could
9770 simply reject these cases and the allowed cases would
9771 be the var0/minus_var1 ones. */
9772 tree tmp0
= var0
? var0
: minus_var0
;
9773 tree tmp1
= var1
? var1
: minus_var1
;
9774 bool one_neg
= false;
9776 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
9778 tmp0
= TREE_OPERAND (tmp0
, 0);
9781 if (CONVERT_EXPR_P (tmp0
)
9782 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9783 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9784 <= TYPE_PRECISION (atype
)))
9785 tmp0
= TREE_OPERAND (tmp0
, 0);
9786 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
9788 tmp1
= TREE_OPERAND (tmp1
, 0);
9791 if (CONVERT_EXPR_P (tmp1
)
9792 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9793 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9794 <= TYPE_PRECISION (atype
)))
9795 tmp1
= TREE_OPERAND (tmp1
, 0);
9796 /* The only case we can still associate with two variables
9797 is if they cancel out. */
9799 || !operand_equal_p (tmp0
, tmp1
, 0))
9802 else if ((var0
&& minus_var1
9803 && ! operand_equal_p (var0
, minus_var1
, 0))
9804 || (minus_var0
&& var1
9805 && ! operand_equal_p (minus_var0
, var1
, 0)))
9809 /* Only do something if we found more than two objects. Otherwise,
9810 nothing has changed and we risk infinite recursion. */
9812 && ((var0
!= 0) + (var1
!= 0)
9813 + (minus_var0
!= 0) + (minus_var1
!= 0)
9814 + (con0
!= 0) + (con1
!= 0)
9815 + (minus_con0
!= 0) + (minus_con1
!= 0)
9816 + (lit0
!= 0) + (lit1
!= 0)
9817 + (minus_lit0
!= 0) + (minus_lit1
!= 0)) > 2)
9819 var0
= associate_trees (loc
, var0
, var1
, code
, atype
);
9820 minus_var0
= associate_trees (loc
, minus_var0
, minus_var1
,
9822 con0
= associate_trees (loc
, con0
, con1
, code
, atype
);
9823 minus_con0
= associate_trees (loc
, minus_con0
, minus_con1
,
9825 lit0
= associate_trees (loc
, lit0
, lit1
, code
, atype
);
9826 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
,
9829 if (minus_var0
&& var0
)
9831 var0
= associate_trees (loc
, var0
, minus_var0
,
9835 if (minus_con0
&& con0
)
9837 con0
= associate_trees (loc
, con0
, minus_con0
,
9842 /* Preserve the MINUS_EXPR if the negative part of the literal is
9843 greater than the positive part. Otherwise, the multiplicative
9844 folding code (i.e extract_muldiv) may be fooled in case
9845 unsigned constants are subtracted, like in the following
9846 example: ((X*2 + 4) - 8U)/2. */
9847 if (minus_lit0
&& lit0
)
9849 if (TREE_CODE (lit0
) == INTEGER_CST
9850 && TREE_CODE (minus_lit0
) == INTEGER_CST
9851 && tree_int_cst_lt (lit0
, minus_lit0
)
9852 /* But avoid ending up with only negated parts. */
9855 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
9861 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
9867 /* Don't introduce overflows through reassociation. */
9868 if ((lit0
&& TREE_OVERFLOW_P (lit0
))
9869 || (minus_lit0
&& TREE_OVERFLOW_P (minus_lit0
)))
9872 /* Eliminate lit0 and minus_lit0 to con0 and minus_con0. */
9873 con0
= associate_trees (loc
, con0
, lit0
, code
, atype
);
9875 minus_con0
= associate_trees (loc
, minus_con0
, minus_lit0
,
9879 /* Eliminate minus_con0. */
9883 con0
= associate_trees (loc
, con0
, minus_con0
,
9886 var0
= associate_trees (loc
, var0
, minus_con0
,
9893 /* Eliminate minus_var0. */
9897 con0
= associate_trees (loc
, con0
, minus_var0
,
9905 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
9912 case POINTER_DIFF_EXPR
:
9914 /* Fold &a[i] - &a[j] to i-j. */
9915 if (TREE_CODE (arg0
) == ADDR_EXPR
9916 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
9917 && TREE_CODE (arg1
) == ADDR_EXPR
9918 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
9920 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
9921 TREE_OPERAND (arg0
, 0),
9922 TREE_OPERAND (arg1
, 0),
9924 == POINTER_DIFF_EXPR
);
9929 /* Further transformations are not for pointers. */
9930 if (code
== POINTER_DIFF_EXPR
)
9933 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9934 if (TREE_CODE (arg0
) == NEGATE_EXPR
9935 && negate_expr_p (op1
)
9936 /* If arg0 is e.g. unsigned int and type is int, then this could
9937 introduce UB, because if A is INT_MIN at runtime, the original
9938 expression can be well defined while the latter is not.
9940 && !(ANY_INTEGRAL_TYPE_P (type
)
9941 && TYPE_OVERFLOW_UNDEFINED (type
)
9942 && ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
9943 && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))))
9944 return fold_build2_loc (loc
, MINUS_EXPR
, type
, negate_expr (op1
),
9945 fold_convert_loc (loc
, type
,
9946 TREE_OPERAND (arg0
, 0)));
9948 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9949 __complex__ ( x, -y ). This is not the same for SNaNs or if
9950 signed zeros are involved. */
9951 if (!HONOR_SNANS (element_mode (arg0
))
9952 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9953 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9955 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9956 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9957 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9958 bool arg0rz
= false, arg0iz
= false;
9959 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9960 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9962 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9963 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9964 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9966 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9968 : build1 (REALPART_EXPR
, rtype
, arg1
));
9969 tree ip
= arg0i
? arg0i
9970 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9971 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9973 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9975 tree rp
= arg0r
? arg0r
9976 : build1 (REALPART_EXPR
, rtype
, arg0
);
9977 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9979 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
9980 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9985 /* A - B -> A + (-B) if B is easily negatable. */
9986 if (negate_expr_p (op1
)
9987 && ! TYPE_OVERFLOW_SANITIZED (type
)
9988 && ((FLOAT_TYPE_P (type
)
9989 /* Avoid this transformation if B is a positive REAL_CST. */
9990 && (TREE_CODE (op1
) != REAL_CST
9991 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (op1
))))
9992 || INTEGRAL_TYPE_P (type
)))
9993 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9994 fold_convert_loc (loc
, type
, arg0
),
9997 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9998 one. Make sure the type is not saturating and has the signedness of
9999 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10000 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10001 if ((TREE_CODE (arg0
) == MULT_EXPR
10002 || TREE_CODE (arg1
) == MULT_EXPR
)
10003 && !TYPE_SATURATING (type
)
10004 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10005 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10006 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10008 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10016 if (! FLOAT_TYPE_P (type
))
10018 /* Transform x * -C into -x * C if x is easily negatable. */
10019 if (TREE_CODE (op1
) == INTEGER_CST
10020 && tree_int_cst_sgn (op1
) == -1
10021 && negate_expr_p (op0
)
10022 && negate_expr_p (op1
)
10023 && (tem
= negate_expr (op1
)) != op1
10024 && ! TREE_OVERFLOW (tem
))
10025 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10026 fold_convert_loc (loc
, type
,
10027 negate_expr (op0
)), tem
);
10029 strict_overflow_p
= false;
10030 if (TREE_CODE (arg1
) == INTEGER_CST
10031 && (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10032 &strict_overflow_p
)) != 0)
10034 if (strict_overflow_p
)
10035 fold_overflow_warning (("assuming signed overflow does not "
10036 "occur when simplifying "
10038 WARN_STRICT_OVERFLOW_MISC
);
10039 return fold_convert_loc (loc
, type
, tem
);
10042 /* Optimize z * conj(z) for integer complex numbers. */
10043 if (TREE_CODE (arg0
) == CONJ_EXPR
10044 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10045 return fold_mult_zconjz (loc
, type
, arg1
);
10046 if (TREE_CODE (arg1
) == CONJ_EXPR
10047 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10048 return fold_mult_zconjz (loc
, type
, arg0
);
10052 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10053 This is not the same for NaNs or if signed zeros are
10055 if (!HONOR_NANS (arg0
)
10056 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
10057 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
10058 && TREE_CODE (arg1
) == COMPLEX_CST
10059 && real_zerop (TREE_REALPART (arg1
)))
10061 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10062 if (real_onep (TREE_IMAGPART (arg1
)))
10064 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10065 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
10067 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
10068 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
10070 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10071 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
10072 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
10076 /* Optimize z * conj(z) for floating point complex numbers.
10077 Guarded by flag_unsafe_math_optimizations as non-finite
10078 imaginary components don't produce scalar results. */
10079 if (flag_unsafe_math_optimizations
10080 && TREE_CODE (arg0
) == CONJ_EXPR
10081 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10082 return fold_mult_zconjz (loc
, type
, arg1
);
10083 if (flag_unsafe_math_optimizations
10084 && TREE_CODE (arg1
) == CONJ_EXPR
10085 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10086 return fold_mult_zconjz (loc
, type
, arg0
);
10091 /* Canonicalize (X & C1) | C2. */
10092 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10093 && TREE_CODE (arg1
) == INTEGER_CST
10094 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10096 int width
= TYPE_PRECISION (type
), w
;
10097 wide_int c1
= wi::to_wide (TREE_OPERAND (arg0
, 1));
10098 wide_int c2
= wi::to_wide (arg1
);
10100 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
10101 if ((c1
& c2
) == c1
)
10102 return omit_one_operand_loc (loc
, type
, arg1
,
10103 TREE_OPERAND (arg0
, 0));
10105 wide_int msk
= wi::mask (width
, false,
10106 TYPE_PRECISION (TREE_TYPE (arg1
)));
10108 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
10109 if (wi::bit_and_not (msk
, c1
| c2
) == 0)
10111 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10112 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
, tem
, arg1
);
10115 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
10116 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
10117 mode which allows further optimizations. */
10120 wide_int c3
= wi::bit_and_not (c1
, c2
);
10121 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
10123 wide_int mask
= wi::mask (w
, false,
10124 TYPE_PRECISION (type
));
10125 if (((c1
| c2
) & mask
) == mask
10126 && wi::bit_and_not (c1
, mask
) == 0)
10135 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10136 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tem
,
10137 wide_int_to_tree (type
, c3
));
10138 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
, tem
, arg1
);
10142 /* See if this can be simplified into a rotate first. If that
10143 is unsuccessful continue in the association code. */
10147 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
10148 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10149 && INTEGRAL_TYPE_P (type
)
10150 && integer_onep (TREE_OPERAND (arg0
, 1))
10151 && integer_onep (arg1
))
10152 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
10153 build_zero_cst (TREE_TYPE (arg0
)));
10155 /* See if this can be simplified into a rotate first. If that
10156 is unsuccessful continue in the association code. */
10160 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
10161 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10162 && INTEGRAL_TYPE_P (type
)
10163 && integer_onep (TREE_OPERAND (arg0
, 1))
10164 && integer_onep (arg1
))
10167 tem
= TREE_OPERAND (arg0
, 0);
10168 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
10169 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
10171 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
10172 build_zero_cst (TREE_TYPE (tem
)));
10174 /* Fold ~X & 1 as (X & 1) == 0. */
10175 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10176 && INTEGRAL_TYPE_P (type
)
10177 && integer_onep (arg1
))
10180 tem
= TREE_OPERAND (arg0
, 0);
10181 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
10182 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
10184 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
10185 build_zero_cst (TREE_TYPE (tem
)));
10187 /* Fold !X & 1 as X == 0. */
10188 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10189 && integer_onep (arg1
))
10191 tem
= TREE_OPERAND (arg0
, 0);
10192 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
10193 build_zero_cst (TREE_TYPE (tem
)));
10196 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
10197 multiple of 1 << CST. */
10198 if (TREE_CODE (arg1
) == INTEGER_CST
)
10200 wi::tree_to_wide_ref cst1
= wi::to_wide (arg1
);
10201 wide_int ncst1
= -cst1
;
10202 if ((cst1
& ncst1
) == ncst1
10203 && multiple_of_p (type
, arg0
,
10204 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
10205 return fold_convert_loc (loc
, type
, arg0
);
10208 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10210 if (TREE_CODE (arg1
) == INTEGER_CST
10211 && TREE_CODE (arg0
) == MULT_EXPR
10212 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10214 wi::tree_to_wide_ref warg1
= wi::to_wide (arg1
);
10216 = mask_with_tz (type
, warg1
, wi::to_wide (TREE_OPERAND (arg0
, 1)));
10219 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
10221 else if (masked
!= warg1
)
10223 /* Avoid the transform if arg1 is a mask of some
10224 mode which allows further optimizations. */
10225 int pop
= wi::popcount (warg1
);
10226 if (!(pop
>= BITS_PER_UNIT
10228 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
10229 return fold_build2_loc (loc
, code
, type
, op0
,
10230 wide_int_to_tree (type
, masked
));
10234 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10235 ((A & N) + B) & M -> (A + B) & M
10236 Similarly if (N & M) == 0,
10237 ((A | N) + B) & M -> (A + B) & M
10238 and for - instead of + (or unary - instead of +)
10239 and/or ^ instead of |.
10240 If B is constant and (B & M) == 0, fold into A & M. */
10241 if (TREE_CODE (arg1
) == INTEGER_CST
)
10243 wi::tree_to_wide_ref cst1
= wi::to_wide (arg1
);
10244 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
10245 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10246 && (TREE_CODE (arg0
) == PLUS_EXPR
10247 || TREE_CODE (arg0
) == MINUS_EXPR
10248 || TREE_CODE (arg0
) == NEGATE_EXPR
)
10249 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
10250 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
10256 /* Now we know that arg0 is (C + D) or (C - D) or
10257 -C and arg1 (M) is == (1LL << cst) - 1.
10258 Store C into PMOP[0] and D into PMOP[1]. */
10259 pmop
[0] = TREE_OPERAND (arg0
, 0);
10261 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
10263 pmop
[1] = TREE_OPERAND (arg0
, 1);
10267 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
10270 for (; which
>= 0; which
--)
10271 switch (TREE_CODE (pmop
[which
]))
10276 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
10279 cst0
= wi::to_wide (TREE_OPERAND (pmop
[which
], 1)) & cst1
;
10280 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
10285 else if (cst0
!= 0)
10287 /* If C or D is of the form (A & N) where
10288 (N & M) == M, or of the form (A | N) or
10289 (A ^ N) where (N & M) == 0, replace it with A. */
10290 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
10293 /* If C or D is a N where (N & M) == 0, it can be
10294 omitted (assumed 0). */
10295 if ((TREE_CODE (arg0
) == PLUS_EXPR
10296 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
10297 && (cst1
& wi::to_wide (pmop
[which
])) == 0)
10298 pmop
[which
] = NULL
;
10304 /* Only build anything new if we optimized one or both arguments
10306 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
10307 || (TREE_CODE (arg0
) != NEGATE_EXPR
10308 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
10310 tree utype
= TREE_TYPE (arg0
);
10311 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
10313 /* Perform the operations in a type that has defined
10314 overflow behavior. */
10315 utype
= unsigned_type_for (TREE_TYPE (arg0
));
10316 if (pmop
[0] != NULL
)
10317 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
10318 if (pmop
[1] != NULL
)
10319 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
10322 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
10323 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
10324 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
10326 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
10327 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
10329 else if (pmop
[0] != NULL
)
10331 else if (pmop
[1] != NULL
)
10334 return build_int_cst (type
, 0);
10336 else if (pmop
[0] == NULL
)
10337 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
10339 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
10341 /* TEM is now the new binary +, - or unary - replacement. */
10342 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
10343 fold_convert_loc (loc
, utype
, arg1
));
10344 return fold_convert_loc (loc
, type
, tem
);
10349 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10350 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
10351 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
10353 prec
= element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
10355 wide_int mask
= wide_int::from (wi::to_wide (arg1
), prec
, UNSIGNED
);
10358 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10364 /* Don't touch a floating-point divide by zero unless the mode
10365 of the constant can represent infinity. */
10366 if (TREE_CODE (arg1
) == REAL_CST
10367 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
10368 && real_zerop (arg1
))
10371 /* (-A) / (-B) -> A / B */
10372 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10373 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10374 TREE_OPERAND (arg0
, 0),
10375 negate_expr (arg1
));
10376 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10377 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10378 negate_expr (arg0
),
10379 TREE_OPERAND (arg1
, 0));
10382 case TRUNC_DIV_EXPR
:
10385 case FLOOR_DIV_EXPR
:
10386 /* Simplify A / (B << N) where A and B are positive and B is
10387 a power of 2, to A >> (N + log2(B)). */
10388 strict_overflow_p
= false;
10389 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10390 && (TYPE_UNSIGNED (type
)
10391 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
10393 tree sval
= TREE_OPERAND (arg1
, 0);
10394 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
10396 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
10397 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
10398 wi::exact_log2 (wi::to_wide (sval
)));
10400 if (strict_overflow_p
)
10401 fold_overflow_warning (("assuming signed overflow does not "
10402 "occur when simplifying A / (B << N)"),
10403 WARN_STRICT_OVERFLOW_MISC
);
10405 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
10407 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
10408 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
10414 case ROUND_DIV_EXPR
:
10415 case CEIL_DIV_EXPR
:
10416 case EXACT_DIV_EXPR
:
10417 if (integer_zerop (arg1
))
10420 /* Convert -A / -B to A / B when the type is signed and overflow is
10422 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10423 && TREE_CODE (op0
) == NEGATE_EXPR
10424 && negate_expr_p (op1
))
10426 if (INTEGRAL_TYPE_P (type
))
10427 fold_overflow_warning (("assuming signed overflow does not occur "
10428 "when distributing negation across "
10430 WARN_STRICT_OVERFLOW_MISC
);
10431 return fold_build2_loc (loc
, code
, type
,
10432 fold_convert_loc (loc
, type
,
10433 TREE_OPERAND (arg0
, 0)),
10434 negate_expr (op1
));
10436 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10437 && TREE_CODE (arg1
) == NEGATE_EXPR
10438 && negate_expr_p (op0
))
10440 if (INTEGRAL_TYPE_P (type
))
10441 fold_overflow_warning (("assuming signed overflow does not occur "
10442 "when distributing negation across "
10444 WARN_STRICT_OVERFLOW_MISC
);
10445 return fold_build2_loc (loc
, code
, type
,
10447 fold_convert_loc (loc
, type
,
10448 TREE_OPERAND (arg1
, 0)));
10451 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10452 operation, EXACT_DIV_EXPR.
10454 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10455 At one time others generated faster code, it's not clear if they do
10456 after the last round to changes to the DIV code in expmed.c. */
10457 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
10458 && multiple_of_p (type
, arg0
, arg1
))
10459 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
,
10460 fold_convert (type
, arg0
),
10461 fold_convert (type
, arg1
));
10463 strict_overflow_p
= false;
10464 if (TREE_CODE (arg1
) == INTEGER_CST
10465 && (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10466 &strict_overflow_p
)) != 0)
10468 if (strict_overflow_p
)
10469 fold_overflow_warning (("assuming signed overflow does not occur "
10470 "when simplifying division"),
10471 WARN_STRICT_OVERFLOW_MISC
);
10472 return fold_convert_loc (loc
, type
, tem
);
10477 case CEIL_MOD_EXPR
:
10478 case FLOOR_MOD_EXPR
:
10479 case ROUND_MOD_EXPR
:
10480 case TRUNC_MOD_EXPR
:
10481 strict_overflow_p
= false;
10482 if (TREE_CODE (arg1
) == INTEGER_CST
10483 && (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10484 &strict_overflow_p
)) != 0)
10486 if (strict_overflow_p
)
10487 fold_overflow_warning (("assuming signed overflow does not occur "
10488 "when simplifying modulus"),
10489 WARN_STRICT_OVERFLOW_MISC
);
10490 return fold_convert_loc (loc
, type
, tem
);
10499 /* Since negative shift count is not well-defined,
10500 don't try to compute it in the compiler. */
10501 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
10504 prec
= element_precision (type
);
10506 /* If we have a rotate of a bit operation with the rotate count and
10507 the second operand of the bit operation both constant,
10508 permute the two operations. */
10509 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10510 && (TREE_CODE (arg0
) == BIT_AND_EXPR
10511 || TREE_CODE (arg0
) == BIT_IOR_EXPR
10512 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
10513 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10515 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10516 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10517 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
10518 fold_build2_loc (loc
, code
, type
,
10520 fold_build2_loc (loc
, code
, type
,
10524 /* Two consecutive rotates adding up to the some integer
10525 multiple of the precision of the type can be ignored. */
10526 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10527 && TREE_CODE (arg0
) == RROTATE_EXPR
10528 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10529 && wi::umod_trunc (wi::to_wide (arg1
)
10530 + wi::to_wide (TREE_OPERAND (arg0
, 1)),
10532 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10540 case TRUTH_ANDIF_EXPR
:
10541 /* Note that the operands of this must be ints
10542 and their values must be 0 or 1.
10543 ("true" is a fixed value perhaps depending on the language.) */
10544 /* If first arg is constant zero, return it. */
10545 if (integer_zerop (arg0
))
10546 return fold_convert_loc (loc
, type
, arg0
);
10548 case TRUTH_AND_EXPR
:
10549 /* If either arg is constant true, drop it. */
10550 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10551 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10552 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
10553 /* Preserve sequence points. */
10554 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10555 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10556 /* If second arg is constant zero, result is zero, but first arg
10557 must be evaluated. */
10558 if (integer_zerop (arg1
))
10559 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10560 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10561 case will be handled here. */
10562 if (integer_zerop (arg0
))
10563 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10565 /* !X && X is always false. */
10566 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10567 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10568 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
10569 /* X && !X is always false. */
10570 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10571 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10572 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10574 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10575 means A >= Y && A != MAX, but in this case we know that
10578 if (!TREE_SIDE_EFFECTS (arg0
)
10579 && !TREE_SIDE_EFFECTS (arg1
))
10581 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
10582 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
10583 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
10585 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
10586 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
10587 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
10590 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10596 case TRUTH_ORIF_EXPR
:
10597 /* Note that the operands of this must be ints
10598 and their values must be 0 or true.
10599 ("true" is a fixed value perhaps depending on the language.) */
10600 /* If first arg is constant true, return it. */
10601 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10602 return fold_convert_loc (loc
, type
, arg0
);
10604 case TRUTH_OR_EXPR
:
10605 /* If either arg is constant zero, drop it. */
10606 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
10607 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10608 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
10609 /* Preserve sequence points. */
10610 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10611 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10612 /* If second arg is constant true, result is true, but we must
10613 evaluate first arg. */
10614 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
10615 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10616 /* Likewise for first arg, but note this only occurs here for
10618 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10619 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10621 /* !X || X is always true. */
10622 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10623 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10624 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10625 /* X || !X is always true. */
10626 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10627 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10628 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10630 /* (X && !Y) || (!X && Y) is X ^ Y */
10631 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
10632 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
10634 tree a0
, a1
, l0
, l1
, n0
, n1
;
10636 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10637 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10639 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10640 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10642 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
10643 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
10645 if ((operand_equal_p (n0
, a0
, 0)
10646 && operand_equal_p (n1
, a1
, 0))
10647 || (operand_equal_p (n0
, a1
, 0)
10648 && operand_equal_p (n1
, a0
, 0)))
10649 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
10652 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10658 case TRUTH_XOR_EXPR
:
10659 /* If the second arg is constant zero, drop it. */
10660 if (integer_zerop (arg1
))
10661 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10662 /* If the second arg is constant true, this is a logical inversion. */
10663 if (integer_onep (arg1
))
10665 tem
= invert_truthvalue_loc (loc
, arg0
);
10666 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
10668 /* Identical arguments cancel to zero. */
10669 if (operand_equal_p (arg0
, arg1
, 0))
10670 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10672 /* !X ^ X is always true. */
10673 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10674 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10675 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10677 /* X ^ !X is always true. */
10678 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10679 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10680 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10689 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
10690 if (tem
!= NULL_TREE
)
10693 /* bool_var != 1 becomes !bool_var. */
10694 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
10695 && code
== NE_EXPR
)
10696 return fold_convert_loc (loc
, type
,
10697 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10698 TREE_TYPE (arg0
), arg0
));
10700 /* bool_var == 0 becomes !bool_var. */
10701 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
10702 && code
== EQ_EXPR
)
10703 return fold_convert_loc (loc
, type
,
10704 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10705 TREE_TYPE (arg0
), arg0
));
10707 /* !exp != 0 becomes !exp */
10708 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
10709 && code
== NE_EXPR
)
10710 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10712 /* If this is an EQ or NE comparison with zero and ARG0 is
10713 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10714 two operations, but the latter can be done in one less insn
10715 on machines that have only two-operand insns or on which a
10716 constant cannot be the first operand. */
10717 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10718 && integer_zerop (arg1
))
10720 tree arg00
= TREE_OPERAND (arg0
, 0);
10721 tree arg01
= TREE_OPERAND (arg0
, 1);
10722 if (TREE_CODE (arg00
) == LSHIFT_EXPR
10723 && integer_onep (TREE_OPERAND (arg00
, 0)))
10725 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
10726 arg01
, TREE_OPERAND (arg00
, 1));
10727 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10728 build_int_cst (TREE_TYPE (arg0
), 1));
10729 return fold_build2_loc (loc
, code
, type
,
10730 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10733 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
10734 && integer_onep (TREE_OPERAND (arg01
, 0)))
10736 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
10737 arg00
, TREE_OPERAND (arg01
, 1));
10738 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10739 build_int_cst (TREE_TYPE (arg0
), 1));
10740 return fold_build2_loc (loc
, code
, type
,
10741 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10746 /* If this is an NE or EQ comparison of zero against the result of a
10747 signed MOD operation whose second operand is a power of 2, make
10748 the MOD operation unsigned since it is simpler and equivalent. */
10749 if (integer_zerop (arg1
)
10750 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
10751 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
10752 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
10753 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
10754 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
10755 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10757 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
10758 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
10759 fold_convert_loc (loc
, newtype
,
10760 TREE_OPERAND (arg0
, 0)),
10761 fold_convert_loc (loc
, newtype
,
10762 TREE_OPERAND (arg0
, 1)));
10764 return fold_build2_loc (loc
, code
, type
, newmod
,
10765 fold_convert_loc (loc
, newtype
, arg1
));
10768 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10769 C1 is a valid shift constant, and C2 is a power of two, i.e.
10771 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10772 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
10773 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
10775 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10776 && integer_zerop (arg1
))
10778 tree itype
= TREE_TYPE (arg0
);
10779 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
10780 prec
= TYPE_PRECISION (itype
);
10782 /* Check for a valid shift count. */
10783 if (wi::ltu_p (wi::to_wide (arg001
), prec
))
10785 tree arg01
= TREE_OPERAND (arg0
, 1);
10786 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10787 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
10788 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10789 can be rewritten as (X & (C2 << C1)) != 0. */
10790 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
10792 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
10793 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
10794 return fold_build2_loc (loc
, code
, type
, tem
,
10795 fold_convert_loc (loc
, itype
, arg1
));
10797 /* Otherwise, for signed (arithmetic) shifts,
10798 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10799 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10800 else if (!TYPE_UNSIGNED (itype
))
10801 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
10802 arg000
, build_int_cst (itype
, 0));
10803 /* Otherwise, of unsigned (logical) shifts,
10804 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10805 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10807 return omit_one_operand_loc (loc
, type
,
10808 code
== EQ_EXPR
? integer_one_node
10809 : integer_zero_node
,
10814 /* If this is a comparison of a field, we may be able to simplify it. */
10815 if ((TREE_CODE (arg0
) == COMPONENT_REF
10816 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
10817 /* Handle the constant case even without -O
10818 to make sure the warnings are given. */
10819 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
10821 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
10826 /* Optimize comparisons of strlen vs zero to a compare of the
10827 first character of the string vs zero. To wit,
10828 strlen(ptr) == 0 => *ptr == 0
10829 strlen(ptr) != 0 => *ptr != 0
10830 Other cases should reduce to one of these two (or a constant)
10831 due to the return value of strlen being unsigned. */
10832 if (TREE_CODE (arg0
) == CALL_EXPR
10833 && integer_zerop (arg1
))
10835 tree fndecl
= get_callee_fndecl (arg0
);
10838 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
10839 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
10840 && call_expr_nargs (arg0
) == 1
10841 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
10843 tree iref
= build_fold_indirect_ref_loc (loc
,
10844 CALL_EXPR_ARG (arg0
, 0));
10845 return fold_build2_loc (loc
, code
, type
, iref
,
10846 build_int_cst (TREE_TYPE (iref
), 0));
10850 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10851 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10852 if (TREE_CODE (arg0
) == RSHIFT_EXPR
10853 && integer_zerop (arg1
)
10854 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10856 tree arg00
= TREE_OPERAND (arg0
, 0);
10857 tree arg01
= TREE_OPERAND (arg0
, 1);
10858 tree itype
= TREE_TYPE (arg00
);
10859 if (wi::to_wide (arg01
) == element_precision (itype
) - 1)
10861 if (TYPE_UNSIGNED (itype
))
10863 itype
= signed_type_for (itype
);
10864 arg00
= fold_convert_loc (loc
, itype
, arg00
);
10866 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
10867 type
, arg00
, build_zero_cst (itype
));
10871 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10872 (X & C) == 0 when C is a single bit. */
10873 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10874 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
10875 && integer_zerop (arg1
)
10876 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10878 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
10879 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
10880 TREE_OPERAND (arg0
, 1));
10881 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
10883 fold_convert_loc (loc
, TREE_TYPE (arg0
),
10887 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10888 constant C is a power of two, i.e. a single bit. */
10889 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10890 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
10891 && integer_zerop (arg1
)
10892 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10893 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10894 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10896 tree arg00
= TREE_OPERAND (arg0
, 0);
10897 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10898 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
10901 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10902 when is C is a power of two, i.e. a single bit. */
10903 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10904 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
10905 && integer_zerop (arg1
)
10906 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10907 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10908 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10910 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10911 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
10912 arg000
, TREE_OPERAND (arg0
, 1));
10913 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10914 tem
, build_int_cst (TREE_TYPE (tem
), 0));
10917 if (integer_zerop (arg1
)
10918 && tree_expr_nonzero_p (arg0
))
10920 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
10921 return omit_one_operand_loc (loc
, type
, res
, arg0
);
10924 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10925 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10926 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10928 tree arg00
= TREE_OPERAND (arg0
, 0);
10929 tree arg01
= TREE_OPERAND (arg0
, 1);
10930 tree arg10
= TREE_OPERAND (arg1
, 0);
10931 tree arg11
= TREE_OPERAND (arg1
, 1);
10932 tree itype
= TREE_TYPE (arg0
);
10934 if (operand_equal_p (arg01
, arg11
, 0))
10936 tem
= fold_convert_loc (loc
, itype
, arg10
);
10937 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
10938 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, tem
, arg01
);
10939 return fold_build2_loc (loc
, code
, type
, tem
,
10940 build_zero_cst (itype
));
10942 if (operand_equal_p (arg01
, arg10
, 0))
10944 tem
= fold_convert_loc (loc
, itype
, arg11
);
10945 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
10946 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, tem
, arg01
);
10947 return fold_build2_loc (loc
, code
, type
, tem
,
10948 build_zero_cst (itype
));
10950 if (operand_equal_p (arg00
, arg11
, 0))
10952 tem
= fold_convert_loc (loc
, itype
, arg10
);
10953 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
, tem
);
10954 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, tem
, arg00
);
10955 return fold_build2_loc (loc
, code
, type
, tem
,
10956 build_zero_cst (itype
));
10958 if (operand_equal_p (arg00
, arg10
, 0))
10960 tem
= fold_convert_loc (loc
, itype
, arg11
);
10961 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
, tem
);
10962 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, tem
, arg00
);
10963 return fold_build2_loc (loc
, code
, type
, tem
,
10964 build_zero_cst (itype
));
10968 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10969 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
10971 tree arg00
= TREE_OPERAND (arg0
, 0);
10972 tree arg01
= TREE_OPERAND (arg0
, 1);
10973 tree arg10
= TREE_OPERAND (arg1
, 0);
10974 tree arg11
= TREE_OPERAND (arg1
, 1);
10975 tree itype
= TREE_TYPE (arg0
);
10977 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10978 operand_equal_p guarantees no side-effects so we don't need
10979 to use omit_one_operand on Z. */
10980 if (operand_equal_p (arg01
, arg11
, 0))
10981 return fold_build2_loc (loc
, code
, type
, arg00
,
10982 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10984 if (operand_equal_p (arg01
, arg10
, 0))
10985 return fold_build2_loc (loc
, code
, type
, arg00
,
10986 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10988 if (operand_equal_p (arg00
, arg11
, 0))
10989 return fold_build2_loc (loc
, code
, type
, arg01
,
10990 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10992 if (operand_equal_p (arg00
, arg10
, 0))
10993 return fold_build2_loc (loc
, code
, type
, arg01
,
10994 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10997 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
10998 if (TREE_CODE (arg01
) == INTEGER_CST
10999 && TREE_CODE (arg11
) == INTEGER_CST
)
11001 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
11002 fold_convert_loc (loc
, itype
, arg11
));
11003 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
11004 return fold_build2_loc (loc
, code
, type
, tem
,
11005 fold_convert_loc (loc
, itype
, arg10
));
11009 /* Attempt to simplify equality/inequality comparisons of complex
11010 values. Only lower the comparison if the result is known or
11011 can be simplified to a single scalar comparison. */
11012 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
11013 || TREE_CODE (arg0
) == COMPLEX_CST
)
11014 && (TREE_CODE (arg1
) == COMPLEX_EXPR
11015 || TREE_CODE (arg1
) == COMPLEX_CST
))
11017 tree real0
, imag0
, real1
, imag1
;
11020 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
11022 real0
= TREE_OPERAND (arg0
, 0);
11023 imag0
= TREE_OPERAND (arg0
, 1);
11027 real0
= TREE_REALPART (arg0
);
11028 imag0
= TREE_IMAGPART (arg0
);
11031 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
11033 real1
= TREE_OPERAND (arg1
, 0);
11034 imag1
= TREE_OPERAND (arg1
, 1);
11038 real1
= TREE_REALPART (arg1
);
11039 imag1
= TREE_IMAGPART (arg1
);
11042 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
11043 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
11045 if (integer_zerop (rcond
))
11047 if (code
== EQ_EXPR
)
11048 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
11050 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
11054 if (code
== NE_EXPR
)
11055 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
11057 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
11061 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
11062 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
11064 if (integer_zerop (icond
))
11066 if (code
== EQ_EXPR
)
11067 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
11069 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
11073 if (code
== NE_EXPR
)
11074 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
11076 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
11087 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
11088 if (tem
!= NULL_TREE
)
11091 /* Transform comparisons of the form X +- C CMP X. */
11092 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
11093 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11094 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
11095 && !HONOR_SNANS (arg0
))
11097 tree arg01
= TREE_OPERAND (arg0
, 1);
11098 enum tree_code code0
= TREE_CODE (arg0
);
11099 int is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
11101 /* (X - c) > X becomes false. */
11102 if (code
== GT_EXPR
11103 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
11104 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
11105 return constant_boolean_node (0, type
);
11107 /* Likewise (X + c) < X becomes false. */
11108 if (code
== LT_EXPR
11109 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
11110 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
11111 return constant_boolean_node (0, type
);
11113 /* Convert (X - c) <= X to true. */
11114 if (!HONOR_NANS (arg1
)
11116 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
11117 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
11118 return constant_boolean_node (1, type
);
11120 /* Convert (X + c) >= X to true. */
11121 if (!HONOR_NANS (arg1
)
11123 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
11124 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
11125 return constant_boolean_node (1, type
);
11128 /* If we are comparing an ABS_EXPR with a constant, we can
11129 convert all the cases into explicit comparisons, but they may
11130 well not be faster than doing the ABS and one comparison.
11131 But ABS (X) <= C is a range comparison, which becomes a subtraction
11132 and a comparison, and is probably faster. */
11133 if (code
== LE_EXPR
11134 && TREE_CODE (arg1
) == INTEGER_CST
11135 && TREE_CODE (arg0
) == ABS_EXPR
11136 && ! TREE_SIDE_EFFECTS (arg0
)
11137 && (tem
= negate_expr (arg1
)) != 0
11138 && TREE_CODE (tem
) == INTEGER_CST
11139 && !TREE_OVERFLOW (tem
))
11140 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
11141 build2 (GE_EXPR
, type
,
11142 TREE_OPERAND (arg0
, 0), tem
),
11143 build2 (LE_EXPR
, type
,
11144 TREE_OPERAND (arg0
, 0), arg1
));
11146 /* Convert ABS_EXPR<x> >= 0 to true. */
11147 strict_overflow_p
= false;
11148 if (code
== GE_EXPR
11149 && (integer_zerop (arg1
)
11150 || (! HONOR_NANS (arg0
)
11151 && real_zerop (arg1
)))
11152 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11154 if (strict_overflow_p
)
11155 fold_overflow_warning (("assuming signed overflow does not occur "
11156 "when simplifying comparison of "
11157 "absolute value and zero"),
11158 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11159 return omit_one_operand_loc (loc
, type
,
11160 constant_boolean_node (true, type
),
11164 /* Convert ABS_EXPR<x> < 0 to false. */
11165 strict_overflow_p
= false;
11166 if (code
== LT_EXPR
11167 && (integer_zerop (arg1
) || real_zerop (arg1
))
11168 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11170 if (strict_overflow_p
)
11171 fold_overflow_warning (("assuming signed overflow does not occur "
11172 "when simplifying comparison of "
11173 "absolute value and zero"),
11174 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11175 return omit_one_operand_loc (loc
, type
,
11176 constant_boolean_node (false, type
),
11180 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11181 and similarly for >= into !=. */
11182 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11183 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11184 && TREE_CODE (arg1
) == LSHIFT_EXPR
11185 && integer_onep (TREE_OPERAND (arg1
, 0)))
11186 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11187 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11188 TREE_OPERAND (arg1
, 1)),
11189 build_zero_cst (TREE_TYPE (arg0
)));
11191 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11192 otherwise Y might be >= # of bits in X's type and thus e.g.
11193 (unsigned char) (1 << Y) for Y 15 might be 0.
11194 If the cast is widening, then 1 << Y should have unsigned type,
11195 otherwise if Y is number of bits in the signed shift type minus 1,
11196 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11197 31 might be 0xffffffff80000000. */
11198 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11199 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11200 && CONVERT_EXPR_P (arg1
)
11201 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
11202 && (element_precision (TREE_TYPE (arg1
))
11203 >= element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
11204 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
11205 || (element_precision (TREE_TYPE (arg1
))
11206 == element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
11207 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
11209 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11210 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
11211 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11212 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
11213 build_zero_cst (TREE_TYPE (arg0
)));
11218 case UNORDERED_EXPR
:
11226 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11228 tree targ0
= strip_float_extensions (arg0
);
11229 tree targ1
= strip_float_extensions (arg1
);
11230 tree newtype
= TREE_TYPE (targ0
);
11232 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
11233 newtype
= TREE_TYPE (targ1
);
11235 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
11236 return fold_build2_loc (loc
, code
, type
,
11237 fold_convert_loc (loc
, newtype
, targ0
),
11238 fold_convert_loc (loc
, newtype
, targ1
));
11243 case COMPOUND_EXPR
:
11244 /* When pedantic, a compound expression can be neither an lvalue
11245 nor an integer constant expression. */
11246 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
11248 /* Don't let (0, 0) be null pointer constant. */
11249 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
11250 : fold_convert_loc (loc
, type
, arg1
);
11251 return pedantic_non_lvalue_loc (loc
, tem
);
11254 /* An ASSERT_EXPR should never be passed to fold_binary. */
11255 gcc_unreachable ();
11259 } /* switch (code) */
11262 /* Used by contains_label_[p1]. */
11264 struct contains_label_data
11266 hash_set
<tree
> *pset
;
11267 bool inside_switch_p
;
11270 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11271 a LABEL_EXPR or CASE_LABEL_EXPR not inside of another SWITCH_EXPR; otherwise
11272 return NULL_TREE. Do not check the subtrees of GOTO_EXPR. */
11275 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data
)
11277 contains_label_data
*d
= (contains_label_data
*) data
;
11278 switch (TREE_CODE (*tp
))
11283 case CASE_LABEL_EXPR
:
11284 if (!d
->inside_switch_p
)
11289 if (!d
->inside_switch_p
)
11291 if (walk_tree (&SWITCH_COND (*tp
), contains_label_1
, data
, d
->pset
))
11293 d
->inside_switch_p
= true;
11294 if (walk_tree (&SWITCH_BODY (*tp
), contains_label_1
, data
, d
->pset
))
11296 d
->inside_switch_p
= false;
11297 *walk_subtrees
= 0;
11302 *walk_subtrees
= 0;
11310 /* Return whether the sub-tree ST contains a label which is accessible from
11311 outside the sub-tree. */
11314 contains_label_p (tree st
)
11316 hash_set
<tree
> pset
;
11317 contains_label_data data
= { &pset
, false };
11318 return walk_tree (&st
, contains_label_1
, &data
, &pset
) != NULL_TREE
;
11321 /* Fold a ternary expression of code CODE and type TYPE with operands
11322 OP0, OP1, and OP2. Return the folded expression if folding is
11323 successful. Otherwise, return NULL_TREE. */
11326 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
11327 tree op0
, tree op1
, tree op2
)
11330 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
11331 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11333 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
11334 && TREE_CODE_LENGTH (code
) == 3);
11336 /* If this is a commutative operation, and OP0 is a constant, move it
11337 to OP1 to reduce the number of tests below. */
11338 if (commutative_ternary_tree_code (code
)
11339 && tree_swap_operands_p (op0
, op1
))
11340 return fold_build3_loc (loc
, code
, type
, op1
, op0
, op2
);
11342 tem
= generic_simplify (loc
, code
, type
, op0
, op1
, op2
);
11346 /* Strip any conversions that don't change the mode. This is safe
11347 for every expression, except for a comparison expression because
11348 its signedness is derived from its operands. So, in the latter
11349 case, only strip conversions that don't change the signedness.
11351 Note that this is done as an internal manipulation within the
11352 constant folder, in order to find the simplest representation of
11353 the arguments so that their form can be studied. In any cases,
11354 the appropriate type conversions should be put back in the tree
11355 that will get out of the constant folder. */
11376 case COMPONENT_REF
:
11377 if (TREE_CODE (arg0
) == CONSTRUCTOR
11378 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
11380 unsigned HOST_WIDE_INT idx
;
11382 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
11389 case VEC_COND_EXPR
:
11390 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11391 so all simple results must be passed through pedantic_non_lvalue. */
11392 if (TREE_CODE (arg0
) == INTEGER_CST
)
11394 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
11395 tem
= integer_zerop (arg0
) ? op2
: op1
;
11396 /* Only optimize constant conditions when the selected branch
11397 has the same type as the COND_EXPR. This avoids optimizing
11398 away "c ? x : throw", where the throw has a void type.
11399 Avoid throwing away that operand which contains label. */
11400 if ((!TREE_SIDE_EFFECTS (unused_op
)
11401 || !contains_label_p (unused_op
))
11402 && (! VOID_TYPE_P (TREE_TYPE (tem
))
11403 || VOID_TYPE_P (type
)))
11404 return pedantic_non_lvalue_loc (loc
, tem
);
11407 else if (TREE_CODE (arg0
) == VECTOR_CST
)
11409 unsigned HOST_WIDE_INT nelts
;
11410 if ((TREE_CODE (arg1
) == VECTOR_CST
11411 || TREE_CODE (arg1
) == CONSTRUCTOR
)
11412 && (TREE_CODE (arg2
) == VECTOR_CST
11413 || TREE_CODE (arg2
) == CONSTRUCTOR
)
11414 && TYPE_VECTOR_SUBPARTS (type
).is_constant (&nelts
))
11416 vec_perm_builder
sel (nelts
, nelts
, 1);
11417 for (unsigned int i
= 0; i
< nelts
; i
++)
11419 tree val
= VECTOR_CST_ELT (arg0
, i
);
11420 if (integer_all_onesp (val
))
11421 sel
.quick_push (i
);
11422 else if (integer_zerop (val
))
11423 sel
.quick_push (nelts
+ i
);
11424 else /* Currently unreachable. */
11427 vec_perm_indices
indices (sel
, 2, nelts
);
11428 tree t
= fold_vec_perm (type
, arg1
, arg2
, indices
);
11429 if (t
!= NULL_TREE
)
11434 /* If we have A op B ? A : C, we may be able to convert this to a
11435 simpler expression, depending on the operation and the values
11436 of B and C. Signed zeros prevent all of these transformations,
11437 for reasons given above each one.
11439 Also try swapping the arguments and inverting the conditional. */
11440 if (COMPARISON_CLASS_P (arg0
)
11441 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0), op1
)
11442 && !HONOR_SIGNED_ZEROS (element_mode (op1
)))
11444 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
11449 if (COMPARISON_CLASS_P (arg0
)
11450 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0), op2
)
11451 && !HONOR_SIGNED_ZEROS (element_mode (op2
)))
11453 location_t loc0
= expr_location_or (arg0
, loc
);
11454 tem
= fold_invert_truthvalue (loc0
, arg0
);
11455 if (tem
&& COMPARISON_CLASS_P (tem
))
11457 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
11463 /* If the second operand is simpler than the third, swap them
11464 since that produces better jump optimization results. */
11465 if (truth_value_p (TREE_CODE (arg0
))
11466 && tree_swap_operands_p (op1
, op2
))
11468 location_t loc0
= expr_location_or (arg0
, loc
);
11469 /* See if this can be inverted. If it can't, possibly because
11470 it was a floating-point inequality comparison, don't do
11472 tem
= fold_invert_truthvalue (loc0
, arg0
);
11474 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
11477 /* Convert A ? 1 : 0 to simply A. */
11478 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
11479 : (integer_onep (op1
)
11480 && !VECTOR_TYPE_P (type
)))
11481 && integer_zerop (op2
)
11482 /* If we try to convert OP0 to our type, the
11483 call to fold will try to move the conversion inside
11484 a COND, which will recurse. In that case, the COND_EXPR
11485 is probably the best choice, so leave it alone. */
11486 && type
== TREE_TYPE (arg0
))
11487 return pedantic_non_lvalue_loc (loc
, arg0
);
11489 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11490 over COND_EXPR in cases such as floating point comparisons. */
11491 if (integer_zerop (op1
)
11492 && code
== COND_EXPR
11493 && integer_onep (op2
)
11494 && !VECTOR_TYPE_P (type
)
11495 && truth_value_p (TREE_CODE (arg0
)))
11496 return pedantic_non_lvalue_loc (loc
,
11497 fold_convert_loc (loc
, type
,
11498 invert_truthvalue_loc (loc
,
11501 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11502 if (TREE_CODE (arg0
) == LT_EXPR
11503 && integer_zerop (TREE_OPERAND (arg0
, 1))
11504 && integer_zerop (op2
)
11505 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
11507 /* sign_bit_p looks through both zero and sign extensions,
11508 but for this optimization only sign extensions are
11510 tree tem2
= TREE_OPERAND (arg0
, 0);
11511 while (tem
!= tem2
)
11513 if (TREE_CODE (tem2
) != NOP_EXPR
11514 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
11519 tem2
= TREE_OPERAND (tem2
, 0);
11521 /* sign_bit_p only checks ARG1 bits within A's precision.
11522 If <sign bit of A> has wider type than A, bits outside
11523 of A's precision in <sign bit of A> need to be checked.
11524 If they are all 0, this optimization needs to be done
11525 in unsigned A's type, if they are all 1 in signed A's type,
11526 otherwise this can't be done. */
11528 && TYPE_PRECISION (TREE_TYPE (tem
))
11529 < TYPE_PRECISION (TREE_TYPE (arg1
))
11530 && TYPE_PRECISION (TREE_TYPE (tem
))
11531 < TYPE_PRECISION (type
))
11533 int inner_width
, outer_width
;
11536 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
11537 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
11538 if (outer_width
> TYPE_PRECISION (type
))
11539 outer_width
= TYPE_PRECISION (type
);
11541 wide_int mask
= wi::shifted_mask
11542 (inner_width
, outer_width
- inner_width
, false,
11543 TYPE_PRECISION (TREE_TYPE (arg1
)));
11545 wide_int common
= mask
& wi::to_wide (arg1
);
11546 if (common
== mask
)
11548 tem_type
= signed_type_for (TREE_TYPE (tem
));
11549 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11551 else if (common
== 0)
11553 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
11554 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11562 fold_convert_loc (loc
, type
,
11563 fold_build2_loc (loc
, BIT_AND_EXPR
,
11564 TREE_TYPE (tem
), tem
,
11565 fold_convert_loc (loc
,
11570 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11571 already handled above. */
11572 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11573 && integer_onep (TREE_OPERAND (arg0
, 1))
11574 && integer_zerop (op2
)
11575 && integer_pow2p (arg1
))
11577 tree tem
= TREE_OPERAND (arg0
, 0);
11579 if (TREE_CODE (tem
) == RSHIFT_EXPR
11580 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
11581 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
)
11582 == tree_to_uhwi (TREE_OPERAND (tem
, 1)))
11583 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11584 fold_convert_loc (loc
, type
,
11585 TREE_OPERAND (tem
, 0)),
11589 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11590 is probably obsolete because the first operand should be a
11591 truth value (that's why we have the two cases above), but let's
11592 leave it in until we can confirm this for all front-ends. */
11593 if (integer_zerop (op2
)
11594 && TREE_CODE (arg0
) == NE_EXPR
11595 && integer_zerop (TREE_OPERAND (arg0
, 1))
11596 && integer_pow2p (arg1
)
11597 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
11598 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
11599 arg1
, OEP_ONLY_CONST
))
11600 return pedantic_non_lvalue_loc (loc
,
11601 fold_convert_loc (loc
, type
,
11602 TREE_OPERAND (arg0
, 0)));
11604 /* Disable the transformations below for vectors, since
11605 fold_binary_op_with_conditional_arg may undo them immediately,
11606 yielding an infinite loop. */
11607 if (code
== VEC_COND_EXPR
)
11610 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11611 if (integer_zerop (op2
)
11612 && truth_value_p (TREE_CODE (arg0
))
11613 && truth_value_p (TREE_CODE (arg1
))
11614 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11615 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
11616 : TRUTH_ANDIF_EXPR
,
11617 type
, fold_convert_loc (loc
, type
, arg0
), op1
);
11619 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11620 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
11621 && truth_value_p (TREE_CODE (arg0
))
11622 && truth_value_p (TREE_CODE (arg1
))
11623 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11625 location_t loc0
= expr_location_or (arg0
, loc
);
11626 /* Only perform transformation if ARG0 is easily inverted. */
11627 tem
= fold_invert_truthvalue (loc0
, arg0
);
11629 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11632 type
, fold_convert_loc (loc
, type
, tem
),
11636 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11637 if (integer_zerop (arg1
)
11638 && truth_value_p (TREE_CODE (arg0
))
11639 && truth_value_p (TREE_CODE (op2
))
11640 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11642 location_t loc0
= expr_location_or (arg0
, loc
);
11643 /* Only perform transformation if ARG0 is easily inverted. */
11644 tem
= fold_invert_truthvalue (loc0
, arg0
);
11646 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11647 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
11648 type
, fold_convert_loc (loc
, type
, tem
),
11652 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11653 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
11654 && truth_value_p (TREE_CODE (arg0
))
11655 && truth_value_p (TREE_CODE (op2
))
11656 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11657 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11658 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
11659 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
11664 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11665 of fold_ternary on them. */
11666 gcc_unreachable ();
11668 case BIT_FIELD_REF
:
11669 if (TREE_CODE (arg0
) == VECTOR_CST
11670 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
11671 || (VECTOR_TYPE_P (type
)
11672 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
))))
11673 && tree_fits_uhwi_p (op1
)
11674 && tree_fits_uhwi_p (op2
))
11676 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
11677 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
11678 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
11679 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
11682 && (idx
% width
) == 0
11683 && (n
% width
) == 0
11684 && known_le ((idx
+ n
) / width
,
11685 TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
))))
11690 if (TREE_CODE (arg0
) == VECTOR_CST
)
11694 tem
= VECTOR_CST_ELT (arg0
, idx
);
11695 if (VECTOR_TYPE_P (type
))
11696 tem
= fold_build1 (VIEW_CONVERT_EXPR
, type
, tem
);
11700 tree_vector_builder
vals (type
, n
, 1);
11701 for (unsigned i
= 0; i
< n
; ++i
)
11702 vals
.quick_push (VECTOR_CST_ELT (arg0
, idx
+ i
));
11703 return vals
.build ();
11708 /* On constants we can use native encode/interpret to constant
11709 fold (nearly) all BIT_FIELD_REFs. */
11710 if (CONSTANT_CLASS_P (arg0
)
11711 && can_native_interpret_type_p (type
)
11712 && BITS_PER_UNIT
== 8
11713 && tree_fits_uhwi_p (op1
)
11714 && tree_fits_uhwi_p (op2
))
11716 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11717 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
11718 /* Limit us to a reasonable amount of work. To relax the
11719 other limitations we need bit-shifting of the buffer
11720 and rounding up the size. */
11721 if (bitpos
% BITS_PER_UNIT
== 0
11722 && bitsize
% BITS_PER_UNIT
== 0
11723 && bitsize
<= MAX_BITSIZE_MODE_ANY_MODE
)
11725 unsigned char b
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
11726 unsigned HOST_WIDE_INT len
11727 = native_encode_expr (arg0
, b
, bitsize
/ BITS_PER_UNIT
,
11728 bitpos
/ BITS_PER_UNIT
);
11730 && len
* BITS_PER_UNIT
>= bitsize
)
11732 tree v
= native_interpret_expr (type
, b
,
11733 bitsize
/ BITS_PER_UNIT
);
11742 case VEC_PERM_EXPR
:
11743 if (TREE_CODE (arg2
) == VECTOR_CST
)
11745 /* Build a vector of integers from the tree mask. */
11746 vec_perm_builder builder
;
11747 if (!tree_to_vec_perm_builder (&builder
, arg2
))
11750 /* Create a vec_perm_indices for the integer vector. */
11751 poly_uint64 nelts
= TYPE_VECTOR_SUBPARTS (type
);
11752 bool single_arg
= (op0
== op1
);
11753 vec_perm_indices
sel (builder
, single_arg
? 1 : 2, nelts
);
11755 /* Check for cases that fold to OP0 or OP1 in their original
11757 if (sel
.series_p (0, 1, 0, 1))
11759 if (sel
.series_p (0, 1, nelts
, 1))
11764 if (sel
.all_from_input_p (0))
11766 else if (sel
.all_from_input_p (1))
11769 sel
.rotate_inputs (1);
11773 if ((TREE_CODE (op0
) == VECTOR_CST
11774 || TREE_CODE (op0
) == CONSTRUCTOR
)
11775 && (TREE_CODE (op1
) == VECTOR_CST
11776 || TREE_CODE (op1
) == CONSTRUCTOR
))
11778 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
11779 if (t
!= NULL_TREE
)
11783 bool changed
= (op0
== op1
&& !single_arg
);
11785 /* Generate a canonical form of the selector. */
11786 if (arg2
== op2
&& sel
.encoding () != builder
)
11788 /* Some targets are deficient and fail to expand a single
11789 argument permutation while still allowing an equivalent
11790 2-argument version. */
11791 if (sel
.ninputs () == 2
11792 || can_vec_perm_const_p (TYPE_MODE (type
), sel
, false))
11793 op2
= vec_perm_indices_to_tree (TREE_TYPE (arg2
), sel
);
11796 vec_perm_indices
sel2 (builder
, 2, nelts
);
11797 if (can_vec_perm_const_p (TYPE_MODE (type
), sel2
, false))
11798 op2
= vec_perm_indices_to_tree (TREE_TYPE (arg2
), sel2
);
11800 /* Not directly supported with either encoding,
11801 so use the preferred form. */
11802 op2
= vec_perm_indices_to_tree (TREE_TYPE (arg2
), sel
);
11808 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
11812 case BIT_INSERT_EXPR
:
11813 /* Perform (partial) constant folding of BIT_INSERT_EXPR. */
11814 if (TREE_CODE (arg0
) == INTEGER_CST
11815 && TREE_CODE (arg1
) == INTEGER_CST
)
11817 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11818 unsigned bitsize
= TYPE_PRECISION (TREE_TYPE (arg1
));
11819 wide_int tem
= (wi::to_wide (arg0
)
11820 & wi::shifted_mask (bitpos
, bitsize
, true,
11821 TYPE_PRECISION (type
)));
11823 = wi::lshift (wi::zext (wi::to_wide (arg1
, TYPE_PRECISION (type
)),
11825 return wide_int_to_tree (type
, wi::bit_or (tem
, tem2
));
11827 else if (TREE_CODE (arg0
) == VECTOR_CST
11828 && CONSTANT_CLASS_P (arg1
)
11829 && types_compatible_p (TREE_TYPE (TREE_TYPE (arg0
)),
11832 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11833 unsigned HOST_WIDE_INT elsize
11834 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (arg1
)));
11835 if (bitpos
% elsize
== 0)
11837 unsigned k
= bitpos
/ elsize
;
11838 unsigned HOST_WIDE_INT nelts
;
11839 if (operand_equal_p (VECTOR_CST_ELT (arg0
, k
), arg1
, 0))
11841 else if (VECTOR_CST_NELTS (arg0
).is_constant (&nelts
))
11843 tree_vector_builder
elts (type
, nelts
, 1);
11844 elts
.quick_grow (nelts
);
11845 for (unsigned HOST_WIDE_INT i
= 0; i
< nelts
; ++i
)
11846 elts
[i
] = (i
== k
? arg1
: VECTOR_CST_ELT (arg0
, i
));
11847 return elts
.build ();
11855 } /* switch (code) */
11858 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
11859 of an array (or vector). */
11862 get_array_ctor_element_at_index (tree ctor
, offset_int access_index
)
11864 tree index_type
= NULL_TREE
;
11865 offset_int low_bound
= 0;
11867 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
11869 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
11870 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
11872 /* Static constructors for variably sized objects makes no sense. */
11873 gcc_assert (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) == INTEGER_CST
);
11874 index_type
= TREE_TYPE (TYPE_MIN_VALUE (domain_type
));
11875 low_bound
= wi::to_offset (TYPE_MIN_VALUE (domain_type
));
11880 access_index
= wi::ext (access_index
, TYPE_PRECISION (index_type
),
11881 TYPE_SIGN (index_type
));
11883 offset_int index
= low_bound
- 1;
11885 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11886 TYPE_SIGN (index_type
));
11888 offset_int max_index
;
11889 unsigned HOST_WIDE_INT cnt
;
11892 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
, cval
)
11894 /* Array constructor might explicitly set index, or specify a range,
11895 or leave index NULL meaning that it is next index after previous
11899 if (TREE_CODE (cfield
) == INTEGER_CST
)
11900 max_index
= index
= wi::to_offset (cfield
);
11903 gcc_assert (TREE_CODE (cfield
) == RANGE_EXPR
);
11904 index
= wi::to_offset (TREE_OPERAND (cfield
, 0));
11905 max_index
= wi::to_offset (TREE_OPERAND (cfield
, 1));
11912 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11913 TYPE_SIGN (index_type
));
11917 /* Do we have match? */
11918 if (wi::cmpu (access_index
, index
) >= 0
11919 && wi::cmpu (access_index
, max_index
) <= 0)
11925 /* Perform constant folding and related simplification of EXPR.
11926 The related simplifications include x*1 => x, x*0 => 0, etc.,
11927 and application of the associative law.
11928 NOP_EXPR conversions may be removed freely (as long as we
11929 are careful not to change the type of the overall expression).
11930 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11931 but we can constant-fold them if they have constant operands. */
11933 #ifdef ENABLE_FOLD_CHECKING
11934 # define fold(x) fold_1 (x)
11935 static tree
fold_1 (tree
);
11941 const tree t
= expr
;
11942 enum tree_code code
= TREE_CODE (t
);
11943 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11945 location_t loc
= EXPR_LOCATION (expr
);
11947 /* Return right away if a constant. */
11948 if (kind
== tcc_constant
)
11951 /* CALL_EXPR-like objects with variable numbers of operands are
11952 treated specially. */
11953 if (kind
== tcc_vl_exp
)
11955 if (code
== CALL_EXPR
)
11957 tem
= fold_call_expr (loc
, expr
, false);
11958 return tem
? tem
: expr
;
11963 if (IS_EXPR_CODE_CLASS (kind
))
11965 tree type
= TREE_TYPE (t
);
11966 tree op0
, op1
, op2
;
11968 switch (TREE_CODE_LENGTH (code
))
11971 op0
= TREE_OPERAND (t
, 0);
11972 tem
= fold_unary_loc (loc
, code
, type
, op0
);
11973 return tem
? tem
: expr
;
11975 op0
= TREE_OPERAND (t
, 0);
11976 op1
= TREE_OPERAND (t
, 1);
11977 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
11978 return tem
? tem
: expr
;
11980 op0
= TREE_OPERAND (t
, 0);
11981 op1
= TREE_OPERAND (t
, 1);
11982 op2
= TREE_OPERAND (t
, 2);
11983 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
11984 return tem
? tem
: expr
;
11994 tree op0
= TREE_OPERAND (t
, 0);
11995 tree op1
= TREE_OPERAND (t
, 1);
11997 if (TREE_CODE (op1
) == INTEGER_CST
11998 && TREE_CODE (op0
) == CONSTRUCTOR
11999 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
12001 tree val
= get_array_ctor_element_at_index (op0
,
12002 wi::to_offset (op1
));
12010 /* Return a VECTOR_CST if possible. */
12013 tree type
= TREE_TYPE (t
);
12014 if (TREE_CODE (type
) != VECTOR_TYPE
)
12019 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
12020 if (! CONSTANT_CLASS_P (val
))
12023 return build_vector_from_ctor (type
, CONSTRUCTOR_ELTS (t
));
12027 return fold (DECL_INITIAL (t
));
12031 } /* switch (code) */
12034 #ifdef ENABLE_FOLD_CHECKING
12037 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
12038 hash_table
<nofree_ptr_hash
<const tree_node
> > *);
12039 static void fold_check_failed (const_tree
, const_tree
);
12040 void print_fold_checksum (const_tree
);
12042 /* When --enable-checking=fold, compute a digest of expr before
12043 and after actual fold call to see if fold did not accidentally
12044 change original expr. */
12050 struct md5_ctx ctx
;
12051 unsigned char checksum_before
[16], checksum_after
[16];
12052 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12054 md5_init_ctx (&ctx
);
12055 fold_checksum_tree (expr
, &ctx
, &ht
);
12056 md5_finish_ctx (&ctx
, checksum_before
);
12059 ret
= fold_1 (expr
);
12061 md5_init_ctx (&ctx
);
12062 fold_checksum_tree (expr
, &ctx
, &ht
);
12063 md5_finish_ctx (&ctx
, checksum_after
);
12065 if (memcmp (checksum_before
, checksum_after
, 16))
12066 fold_check_failed (expr
, ret
);
12072 print_fold_checksum (const_tree expr
)
12074 struct md5_ctx ctx
;
12075 unsigned char checksum
[16], cnt
;
12076 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12078 md5_init_ctx (&ctx
);
12079 fold_checksum_tree (expr
, &ctx
, &ht
);
12080 md5_finish_ctx (&ctx
, checksum
);
12081 for (cnt
= 0; cnt
< 16; ++cnt
)
12082 fprintf (stderr
, "%02x", checksum
[cnt
]);
12083 putc ('\n', stderr
);
12087 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
12089 internal_error ("fold check: original tree changed by fold");
12093 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
12094 hash_table
<nofree_ptr_hash
<const tree_node
> > *ht
)
12096 const tree_node
**slot
;
12097 enum tree_code code
;
12098 union tree_node buf
;
12104 slot
= ht
->find_slot (expr
, INSERT
);
12108 code
= TREE_CODE (expr
);
12109 if (TREE_CODE_CLASS (code
) == tcc_declaration
12110 && HAS_DECL_ASSEMBLER_NAME_P (expr
))
12112 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
12113 memcpy ((char *) &buf
, expr
, tree_size (expr
));
12114 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
12115 buf
.decl_with_vis
.symtab_node
= NULL
;
12116 expr
= (tree
) &buf
;
12118 else if (TREE_CODE_CLASS (code
) == tcc_type
12119 && (TYPE_POINTER_TO (expr
)
12120 || TYPE_REFERENCE_TO (expr
)
12121 || TYPE_CACHED_VALUES_P (expr
)
12122 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
12123 || TYPE_NEXT_VARIANT (expr
)
12124 || TYPE_ALIAS_SET_KNOWN_P (expr
)))
12126 /* Allow these fields to be modified. */
12128 memcpy ((char *) &buf
, expr
, tree_size (expr
));
12129 expr
= tmp
= (tree
) &buf
;
12130 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
12131 TYPE_POINTER_TO (tmp
) = NULL
;
12132 TYPE_REFERENCE_TO (tmp
) = NULL
;
12133 TYPE_NEXT_VARIANT (tmp
) = NULL
;
12134 TYPE_ALIAS_SET (tmp
) = -1;
12135 if (TYPE_CACHED_VALUES_P (tmp
))
12137 TYPE_CACHED_VALUES_P (tmp
) = 0;
12138 TYPE_CACHED_VALUES (tmp
) = NULL
;
12141 md5_process_bytes (expr
, tree_size (expr
), ctx
);
12142 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
12143 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
12144 if (TREE_CODE_CLASS (code
) != tcc_type
12145 && TREE_CODE_CLASS (code
) != tcc_declaration
12146 && code
!= TREE_LIST
12147 && code
!= SSA_NAME
12148 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
12149 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
12150 switch (TREE_CODE_CLASS (code
))
12156 md5_process_bytes (TREE_STRING_POINTER (expr
),
12157 TREE_STRING_LENGTH (expr
), ctx
);
12160 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
12161 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
12164 len
= vector_cst_encoded_nelts (expr
);
12165 for (i
= 0; i
< len
; ++i
)
12166 fold_checksum_tree (VECTOR_CST_ENCODED_ELT (expr
, i
), ctx
, ht
);
12172 case tcc_exceptional
:
12176 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
12177 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
12178 expr
= TREE_CHAIN (expr
);
12179 goto recursive_label
;
12182 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
12183 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
12189 case tcc_expression
:
12190 case tcc_reference
:
12191 case tcc_comparison
:
12194 case tcc_statement
:
12196 len
= TREE_OPERAND_LENGTH (expr
);
12197 for (i
= 0; i
< len
; ++i
)
12198 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
12200 case tcc_declaration
:
12201 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
12202 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
12203 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
12205 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
12206 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
12207 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
12208 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
12209 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
12212 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
12214 if (TREE_CODE (expr
) == FUNCTION_DECL
)
12216 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
12217 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
12219 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
12223 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
12224 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
12225 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
12226 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
12227 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
12228 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
12229 if (INTEGRAL_TYPE_P (expr
)
12230 || SCALAR_FLOAT_TYPE_P (expr
))
12232 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
12233 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
12235 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
12236 if (TREE_CODE (expr
) == RECORD_TYPE
12237 || TREE_CODE (expr
) == UNION_TYPE
12238 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
12239 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
12240 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
12247 /* Helper function for outputting the checksum of a tree T. When
12248 debugging with gdb, you can "define mynext" to be "next" followed
12249 by "call debug_fold_checksum (op0)", then just trace down till the
12252 DEBUG_FUNCTION
void
12253 debug_fold_checksum (const_tree t
)
12256 unsigned char checksum
[16];
12257 struct md5_ctx ctx
;
12258 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12260 md5_init_ctx (&ctx
);
12261 fold_checksum_tree (t
, &ctx
, &ht
);
12262 md5_finish_ctx (&ctx
, checksum
);
12265 for (i
= 0; i
< 16; i
++)
12266 fprintf (stderr
, "%d ", checksum
[i
]);
12268 fprintf (stderr
, "\n");
12273 /* Fold a unary tree expression with code CODE of type TYPE with an
12274 operand OP0. LOC is the location of the resulting expression.
12275 Return a folded expression if successful. Otherwise, return a tree
12276 expression with code CODE of type TYPE with an operand OP0. */
12279 fold_build1_loc (location_t loc
,
12280 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
12283 #ifdef ENABLE_FOLD_CHECKING
12284 unsigned char checksum_before
[16], checksum_after
[16];
12285 struct md5_ctx ctx
;
12286 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12288 md5_init_ctx (&ctx
);
12289 fold_checksum_tree (op0
, &ctx
, &ht
);
12290 md5_finish_ctx (&ctx
, checksum_before
);
12294 tem
= fold_unary_loc (loc
, code
, type
, op0
);
12296 tem
= build1_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
12298 #ifdef ENABLE_FOLD_CHECKING
12299 md5_init_ctx (&ctx
);
12300 fold_checksum_tree (op0
, &ctx
, &ht
);
12301 md5_finish_ctx (&ctx
, checksum_after
);
12303 if (memcmp (checksum_before
, checksum_after
, 16))
12304 fold_check_failed (op0
, tem
);
12309 /* Fold a binary tree expression with code CODE of type TYPE with
12310 operands OP0 and OP1. LOC is the location of the resulting
12311 expression. Return a folded expression if successful. Otherwise,
12312 return a tree expression with code CODE of type TYPE with operands
12316 fold_build2_loc (location_t loc
,
12317 enum tree_code code
, tree type
, tree op0
, tree op1
12321 #ifdef ENABLE_FOLD_CHECKING
12322 unsigned char checksum_before_op0
[16],
12323 checksum_before_op1
[16],
12324 checksum_after_op0
[16],
12325 checksum_after_op1
[16];
12326 struct md5_ctx ctx
;
12327 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12329 md5_init_ctx (&ctx
);
12330 fold_checksum_tree (op0
, &ctx
, &ht
);
12331 md5_finish_ctx (&ctx
, checksum_before_op0
);
12334 md5_init_ctx (&ctx
);
12335 fold_checksum_tree (op1
, &ctx
, &ht
);
12336 md5_finish_ctx (&ctx
, checksum_before_op1
);
12340 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
12342 tem
= build2_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
12344 #ifdef ENABLE_FOLD_CHECKING
12345 md5_init_ctx (&ctx
);
12346 fold_checksum_tree (op0
, &ctx
, &ht
);
12347 md5_finish_ctx (&ctx
, checksum_after_op0
);
12350 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12351 fold_check_failed (op0
, tem
);
12353 md5_init_ctx (&ctx
);
12354 fold_checksum_tree (op1
, &ctx
, &ht
);
12355 md5_finish_ctx (&ctx
, checksum_after_op1
);
12357 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12358 fold_check_failed (op1
, tem
);
12363 /* Fold a ternary tree expression with code CODE of type TYPE with
12364 operands OP0, OP1, and OP2. Return a folded expression if
12365 successful. Otherwise, return a tree expression with code CODE of
12366 type TYPE with operands OP0, OP1, and OP2. */
12369 fold_build3_loc (location_t loc
, enum tree_code code
, tree type
,
12370 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
12373 #ifdef ENABLE_FOLD_CHECKING
12374 unsigned char checksum_before_op0
[16],
12375 checksum_before_op1
[16],
12376 checksum_before_op2
[16],
12377 checksum_after_op0
[16],
12378 checksum_after_op1
[16],
12379 checksum_after_op2
[16];
12380 struct md5_ctx ctx
;
12381 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12383 md5_init_ctx (&ctx
);
12384 fold_checksum_tree (op0
, &ctx
, &ht
);
12385 md5_finish_ctx (&ctx
, checksum_before_op0
);
12388 md5_init_ctx (&ctx
);
12389 fold_checksum_tree (op1
, &ctx
, &ht
);
12390 md5_finish_ctx (&ctx
, checksum_before_op1
);
12393 md5_init_ctx (&ctx
);
12394 fold_checksum_tree (op2
, &ctx
, &ht
);
12395 md5_finish_ctx (&ctx
, checksum_before_op2
);
12399 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
12400 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
12402 tem
= build3_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
12404 #ifdef ENABLE_FOLD_CHECKING
12405 md5_init_ctx (&ctx
);
12406 fold_checksum_tree (op0
, &ctx
, &ht
);
12407 md5_finish_ctx (&ctx
, checksum_after_op0
);
12410 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12411 fold_check_failed (op0
, tem
);
12413 md5_init_ctx (&ctx
);
12414 fold_checksum_tree (op1
, &ctx
, &ht
);
12415 md5_finish_ctx (&ctx
, checksum_after_op1
);
12418 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12419 fold_check_failed (op1
, tem
);
12421 md5_init_ctx (&ctx
);
12422 fold_checksum_tree (op2
, &ctx
, &ht
);
12423 md5_finish_ctx (&ctx
, checksum_after_op2
);
12425 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
12426 fold_check_failed (op2
, tem
);
12431 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12432 arguments in ARGARRAY, and a null static chain.
12433 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12434 of type TYPE from the given operands as constructed by build_call_array. */
12437 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
12438 int nargs
, tree
*argarray
)
12441 #ifdef ENABLE_FOLD_CHECKING
12442 unsigned char checksum_before_fn
[16],
12443 checksum_before_arglist
[16],
12444 checksum_after_fn
[16],
12445 checksum_after_arglist
[16];
12446 struct md5_ctx ctx
;
12447 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12450 md5_init_ctx (&ctx
);
12451 fold_checksum_tree (fn
, &ctx
, &ht
);
12452 md5_finish_ctx (&ctx
, checksum_before_fn
);
12455 md5_init_ctx (&ctx
);
12456 for (i
= 0; i
< nargs
; i
++)
12457 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12458 md5_finish_ctx (&ctx
, checksum_before_arglist
);
12462 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
12464 tem
= build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12466 #ifdef ENABLE_FOLD_CHECKING
12467 md5_init_ctx (&ctx
);
12468 fold_checksum_tree (fn
, &ctx
, &ht
);
12469 md5_finish_ctx (&ctx
, checksum_after_fn
);
12472 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
12473 fold_check_failed (fn
, tem
);
12475 md5_init_ctx (&ctx
);
12476 for (i
= 0; i
< nargs
; i
++)
12477 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12478 md5_finish_ctx (&ctx
, checksum_after_arglist
);
12480 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
12481 fold_check_failed (NULL_TREE
, tem
);
12486 /* Perform constant folding and related simplification of initializer
12487 expression EXPR. These behave identically to "fold_buildN" but ignore
12488 potential run-time traps and exceptions that fold must preserve. */
12490 #define START_FOLD_INIT \
12491 int saved_signaling_nans = flag_signaling_nans;\
12492 int saved_trapping_math = flag_trapping_math;\
12493 int saved_rounding_math = flag_rounding_math;\
12494 int saved_trapv = flag_trapv;\
12495 int saved_folding_initializer = folding_initializer;\
12496 flag_signaling_nans = 0;\
12497 flag_trapping_math = 0;\
12498 flag_rounding_math = 0;\
12500 folding_initializer = 1;
12502 #define END_FOLD_INIT \
12503 flag_signaling_nans = saved_signaling_nans;\
12504 flag_trapping_math = saved_trapping_math;\
12505 flag_rounding_math = saved_rounding_math;\
12506 flag_trapv = saved_trapv;\
12507 folding_initializer = saved_folding_initializer;
12510 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
12511 tree type
, tree op
)
12516 result
= fold_build1_loc (loc
, code
, type
, op
);
12523 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
12524 tree type
, tree op0
, tree op1
)
12529 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
12536 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
12537 int nargs
, tree
*argarray
)
12542 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12548 #undef START_FOLD_INIT
12549 #undef END_FOLD_INIT
12551 /* Determine if first argument is a multiple of second argument. Return 0 if
12552 it is not, or we cannot easily determined it to be.
12554 An example of the sort of thing we care about (at this point; this routine
12555 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12556 fold cases do now) is discovering that
12558 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12564 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12566 This code also handles discovering that
12568 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12570 is a multiple of 8 so we don't have to worry about dealing with a
12571 possible remainder.
12573 Note that we *look* inside a SAVE_EXPR only to determine how it was
12574 calculated; it is not safe for fold to do much of anything else with the
12575 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12576 at run time. For example, the latter example above *cannot* be implemented
12577 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12578 evaluation time of the original SAVE_EXPR is not necessarily the same at
12579 the time the new expression is evaluated. The only optimization of this
12580 sort that would be valid is changing
12582 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12586 SAVE_EXPR (I) * SAVE_EXPR (J)
12588 (where the same SAVE_EXPR (J) is used in the original and the
12589 transformed version). */
12592 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
12597 if (operand_equal_p (top
, bottom
, 0))
12600 if (TREE_CODE (type
) != INTEGER_TYPE
)
12603 switch (TREE_CODE (top
))
12606 /* Bitwise and provides a power of two multiple. If the mask is
12607 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12608 if (!integer_pow2p (bottom
))
12610 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12611 || multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12614 if (TREE_CODE (bottom
) == INTEGER_CST
)
12616 op1
= TREE_OPERAND (top
, 0);
12617 op2
= TREE_OPERAND (top
, 1);
12618 if (TREE_CODE (op1
) == INTEGER_CST
)
12619 std::swap (op1
, op2
);
12620 if (TREE_CODE (op2
) == INTEGER_CST
)
12622 if (multiple_of_p (type
, op2
, bottom
))
12624 /* Handle multiple_of_p ((x * 2 + 2) * 4, 8). */
12625 if (multiple_of_p (type
, bottom
, op2
))
12627 widest_int w
= wi::sdiv_trunc (wi::to_widest (bottom
),
12628 wi::to_widest (op2
));
12629 if (wi::fits_to_tree_p (w
, TREE_TYPE (bottom
)))
12631 op2
= wide_int_to_tree (TREE_TYPE (bottom
), w
);
12632 return multiple_of_p (type
, op1
, op2
);
12635 return multiple_of_p (type
, op1
, bottom
);
12638 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12639 || multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12642 /* It is impossible to prove if op0 - op1 is multiple of bottom
12643 precisely, so be conservative here checking if both op0 and op1
12644 are multiple of bottom. Note we check the second operand first
12645 since it's usually simpler. */
12646 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12647 && multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12650 /* The same as MINUS_EXPR, but handle cases like op0 + 0xfffffffd
12651 as op0 - 3 if the expression has unsigned type. For example,
12652 (X / 3) + 0xfffffffd is multiple of 3, but 0xfffffffd is not. */
12653 op1
= TREE_OPERAND (top
, 1);
12654 if (TYPE_UNSIGNED (type
)
12655 && TREE_CODE (op1
) == INTEGER_CST
&& tree_int_cst_sign_bit (op1
))
12656 op1
= fold_build1 (NEGATE_EXPR
, type
, op1
);
12657 return (multiple_of_p (type
, op1
, bottom
)
12658 && multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12661 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
12663 op1
= TREE_OPERAND (top
, 1);
12664 /* const_binop may not detect overflow correctly,
12665 so check for it explicitly here. */
12666 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)),
12668 && (t1
= fold_convert (type
,
12669 const_binop (LSHIFT_EXPR
, size_one_node
,
12671 && !TREE_OVERFLOW (t1
))
12672 return multiple_of_p (type
, t1
, bottom
);
12677 /* Can't handle conversions from non-integral or wider integral type. */
12678 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
12679 || (TYPE_PRECISION (type
)
12680 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
12686 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
12689 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12690 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
12693 if (TREE_CODE (bottom
) != INTEGER_CST
12694 || integer_zerop (bottom
)
12695 || (TYPE_UNSIGNED (type
)
12696 && (tree_int_cst_sgn (top
) < 0
12697 || tree_int_cst_sgn (bottom
) < 0)))
12699 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
12703 if (TREE_CODE (bottom
) == INTEGER_CST
12704 && (stmt
= SSA_NAME_DEF_STMT (top
)) != NULL
12705 && gimple_code (stmt
) == GIMPLE_ASSIGN
)
12707 enum tree_code code
= gimple_assign_rhs_code (stmt
);
12709 /* Check for special cases to see if top is defined as multiple
12712 top = (X & ~(bottom - 1) ; bottom is power of 2
12718 if (code
== BIT_AND_EXPR
12719 && (op2
= gimple_assign_rhs2 (stmt
)) != NULL_TREE
12720 && TREE_CODE (op2
) == INTEGER_CST
12721 && integer_pow2p (bottom
)
12722 && wi::multiple_of_p (wi::to_widest (op2
),
12723 wi::to_widest (bottom
), UNSIGNED
))
12726 op1
= gimple_assign_rhs1 (stmt
);
12727 if (code
== MINUS_EXPR
12728 && (op2
= gimple_assign_rhs2 (stmt
)) != NULL_TREE
12729 && TREE_CODE (op2
) == SSA_NAME
12730 && (stmt
= SSA_NAME_DEF_STMT (op2
)) != NULL
12731 && gimple_code (stmt
) == GIMPLE_ASSIGN
12732 && (code
= gimple_assign_rhs_code (stmt
)) == TRUNC_MOD_EXPR
12733 && operand_equal_p (op1
, gimple_assign_rhs1 (stmt
), 0)
12734 && operand_equal_p (bottom
, gimple_assign_rhs2 (stmt
), 0))
12741 if (POLY_INT_CST_P (top
) && poly_int_tree_p (bottom
))
12742 return multiple_p (wi::to_poly_widest (top
),
12743 wi::to_poly_widest (bottom
));
12749 #define tree_expr_nonnegative_warnv_p(X, Y) \
12750 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
12752 #define RECURSE(X) \
12753 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12755 /* Return true if CODE or TYPE is known to be non-negative. */
12758 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
12760 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
12761 && truth_value_p (code
))
12762 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12763 have a signed:1 type (where the value is -1 and 0). */
12768 /* Return true if (CODE OP0) is known to be non-negative. If the return
12769 value is based on the assumption that signed overflow is undefined,
12770 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12771 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12774 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12775 bool *strict_overflow_p
, int depth
)
12777 if (TYPE_UNSIGNED (type
))
12783 /* We can't return 1 if flag_wrapv is set because
12784 ABS_EXPR<INT_MIN> = INT_MIN. */
12785 if (!ANY_INTEGRAL_TYPE_P (type
))
12787 if (TYPE_OVERFLOW_UNDEFINED (type
))
12789 *strict_overflow_p
= true;
12794 case NON_LVALUE_EXPR
:
12796 case FIX_TRUNC_EXPR
:
12797 return RECURSE (op0
);
12801 tree inner_type
= TREE_TYPE (op0
);
12802 tree outer_type
= type
;
12804 if (TREE_CODE (outer_type
) == REAL_TYPE
)
12806 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12807 return RECURSE (op0
);
12808 if (INTEGRAL_TYPE_P (inner_type
))
12810 if (TYPE_UNSIGNED (inner_type
))
12812 return RECURSE (op0
);
12815 else if (INTEGRAL_TYPE_P (outer_type
))
12817 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12818 return RECURSE (op0
);
12819 if (INTEGRAL_TYPE_P (inner_type
))
12820 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
12821 && TYPE_UNSIGNED (inner_type
);
12827 return tree_simple_nonnegative_warnv_p (code
, type
);
12830 /* We don't know sign of `t', so be conservative and return false. */
12834 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12835 value is based on the assumption that signed overflow is undefined,
12836 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12837 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12840 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12841 tree op1
, bool *strict_overflow_p
,
12844 if (TYPE_UNSIGNED (type
))
12849 case POINTER_PLUS_EXPR
:
12851 if (FLOAT_TYPE_P (type
))
12852 return RECURSE (op0
) && RECURSE (op1
);
12854 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12855 both unsigned and at least 2 bits shorter than the result. */
12856 if (TREE_CODE (type
) == INTEGER_TYPE
12857 && TREE_CODE (op0
) == NOP_EXPR
12858 && TREE_CODE (op1
) == NOP_EXPR
)
12860 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
12861 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
12862 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
12863 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
12865 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
12866 TYPE_PRECISION (inner2
)) + 1;
12867 return prec
< TYPE_PRECISION (type
);
12873 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12875 /* x * x is always non-negative for floating point x
12876 or without overflow. */
12877 if (operand_equal_p (op0
, op1
, 0)
12878 || (RECURSE (op0
) && RECURSE (op1
)))
12880 if (ANY_INTEGRAL_TYPE_P (type
)
12881 && TYPE_OVERFLOW_UNDEFINED (type
))
12882 *strict_overflow_p
= true;
12887 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12888 both unsigned and their total bits is shorter than the result. */
12889 if (TREE_CODE (type
) == INTEGER_TYPE
12890 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
12891 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
12893 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
12894 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
12896 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
12897 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
12900 bool unsigned0
= TYPE_UNSIGNED (inner0
);
12901 bool unsigned1
= TYPE_UNSIGNED (inner1
);
12903 if (TREE_CODE (op0
) == INTEGER_CST
)
12904 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
12906 if (TREE_CODE (op1
) == INTEGER_CST
)
12907 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
12909 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
12910 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
12912 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
12913 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
12914 : TYPE_PRECISION (inner0
);
12916 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
12917 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
12918 : TYPE_PRECISION (inner1
);
12920 return precision0
+ precision1
< TYPE_PRECISION (type
);
12927 return RECURSE (op0
) || RECURSE (op1
);
12933 case TRUNC_DIV_EXPR
:
12934 case CEIL_DIV_EXPR
:
12935 case FLOOR_DIV_EXPR
:
12936 case ROUND_DIV_EXPR
:
12937 return RECURSE (op0
) && RECURSE (op1
);
12939 case TRUNC_MOD_EXPR
:
12940 return RECURSE (op0
);
12942 case FLOOR_MOD_EXPR
:
12943 return RECURSE (op1
);
12945 case CEIL_MOD_EXPR
:
12946 case ROUND_MOD_EXPR
:
12948 return tree_simple_nonnegative_warnv_p (code
, type
);
12951 /* We don't know sign of `t', so be conservative and return false. */
12955 /* Return true if T is known to be non-negative. If the return
12956 value is based on the assumption that signed overflow is undefined,
12957 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12958 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12961 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
12963 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
12966 switch (TREE_CODE (t
))
12969 return tree_int_cst_sgn (t
) >= 0;
12972 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
12975 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
12978 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
12981 /* Limit the depth of recursion to avoid quadratic behavior.
12982 This is expected to catch almost all occurrences in practice.
12983 If this code misses important cases that unbounded recursion
12984 would not, passes that need this information could be revised
12985 to provide it through dataflow propagation. */
12986 return (!name_registered_for_update_p (t
)
12987 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
12988 && gimple_stmt_nonnegative_warnv_p (SSA_NAME_DEF_STMT (t
),
12989 strict_overflow_p
, depth
));
12992 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
12996 /* Return true if T is known to be non-negative. If the return
12997 value is based on the assumption that signed overflow is undefined,
12998 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12999 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13002 tree_call_nonnegative_warnv_p (tree type
, combined_fn fn
, tree arg0
, tree arg1
,
13003 bool *strict_overflow_p
, int depth
)
13024 case CFN_BUILT_IN_BSWAP32
:
13025 case CFN_BUILT_IN_BSWAP64
:
13031 /* sqrt(-0.0) is -0.0. */
13032 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
13034 return RECURSE (arg0
);
13062 CASE_CFN_NEARBYINT
:
13063 CASE_CFN_NEARBYINT_FN
:
13072 CASE_CFN_SIGNIFICAND
:
13077 /* True if the 1st argument is nonnegative. */
13078 return RECURSE (arg0
);
13082 /* True if the 1st OR 2nd arguments are nonnegative. */
13083 return RECURSE (arg0
) || RECURSE (arg1
);
13087 /* True if the 1st AND 2nd arguments are nonnegative. */
13088 return RECURSE (arg0
) && RECURSE (arg1
);
13091 CASE_CFN_COPYSIGN_FN
:
13092 /* True if the 2nd argument is nonnegative. */
13093 return RECURSE (arg1
);
13096 /* True if the 1st argument is nonnegative or the second
13097 argument is an even integer. */
13098 if (TREE_CODE (arg1
) == INTEGER_CST
13099 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
13101 return RECURSE (arg0
);
13104 /* True if the 1st argument is nonnegative or the second
13105 argument is an even integer valued real. */
13106 if (TREE_CODE (arg1
) == REAL_CST
)
13111 c
= TREE_REAL_CST (arg1
);
13112 n
= real_to_integer (&c
);
13115 REAL_VALUE_TYPE cint
;
13116 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
13117 if (real_identical (&c
, &cint
))
13121 return RECURSE (arg0
);
13126 return tree_simple_nonnegative_warnv_p (CALL_EXPR
, type
);
13129 /* Return true if T is known to be non-negative. If the return
13130 value is based on the assumption that signed overflow is undefined,
13131 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13132 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13135 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13137 enum tree_code code
= TREE_CODE (t
);
13138 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
13145 tree temp
= TARGET_EXPR_SLOT (t
);
13146 t
= TARGET_EXPR_INITIAL (t
);
13148 /* If the initializer is non-void, then it's a normal expression
13149 that will be assigned to the slot. */
13150 if (!VOID_TYPE_P (t
))
13151 return RECURSE (t
);
13153 /* Otherwise, the initializer sets the slot in some way. One common
13154 way is an assignment statement at the end of the initializer. */
13157 if (TREE_CODE (t
) == BIND_EXPR
)
13158 t
= expr_last (BIND_EXPR_BODY (t
));
13159 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
13160 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
13161 t
= expr_last (TREE_OPERAND (t
, 0));
13162 else if (TREE_CODE (t
) == STATEMENT_LIST
)
13167 if (TREE_CODE (t
) == MODIFY_EXPR
13168 && TREE_OPERAND (t
, 0) == temp
)
13169 return RECURSE (TREE_OPERAND (t
, 1));
13176 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
13177 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
13179 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
13180 get_call_combined_fn (t
),
13183 strict_overflow_p
, depth
);
13185 case COMPOUND_EXPR
:
13187 return RECURSE (TREE_OPERAND (t
, 1));
13190 return RECURSE (expr_last (TREE_OPERAND (t
, 1)));
13193 return RECURSE (TREE_OPERAND (t
, 0));
13196 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
13201 #undef tree_expr_nonnegative_warnv_p
13203 /* Return true if T is known to be non-negative. If the return
13204 value is based on the assumption that signed overflow is undefined,
13205 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13206 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13209 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13211 enum tree_code code
;
13212 if (t
== error_mark_node
)
13215 code
= TREE_CODE (t
);
13216 switch (TREE_CODE_CLASS (code
))
13219 case tcc_comparison
:
13220 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13222 TREE_OPERAND (t
, 0),
13223 TREE_OPERAND (t
, 1),
13224 strict_overflow_p
, depth
);
13227 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13229 TREE_OPERAND (t
, 0),
13230 strict_overflow_p
, depth
);
13233 case tcc_declaration
:
13234 case tcc_reference
:
13235 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13243 case TRUTH_AND_EXPR
:
13244 case TRUTH_OR_EXPR
:
13245 case TRUTH_XOR_EXPR
:
13246 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13248 TREE_OPERAND (t
, 0),
13249 TREE_OPERAND (t
, 1),
13250 strict_overflow_p
, depth
);
13251 case TRUTH_NOT_EXPR
:
13252 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13254 TREE_OPERAND (t
, 0),
13255 strict_overflow_p
, depth
);
13262 case WITH_SIZE_EXPR
:
13264 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13267 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13271 /* Return true if `t' is known to be non-negative. Handle warnings
13272 about undefined signed overflow. */
13275 tree_expr_nonnegative_p (tree t
)
13277 bool ret
, strict_overflow_p
;
13279 strict_overflow_p
= false;
13280 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
13281 if (strict_overflow_p
)
13282 fold_overflow_warning (("assuming signed overflow does not occur when "
13283 "determining that expression is always "
13285 WARN_STRICT_OVERFLOW_MISC
);
13290 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13291 For floating point we further ensure that T is not denormal.
13292 Similar logic is present in nonzero_address in rtlanal.h.
13294 If the return value is based on the assumption that signed overflow
13295 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13296 change *STRICT_OVERFLOW_P. */
13299 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
13300 bool *strict_overflow_p
)
13305 return tree_expr_nonzero_warnv_p (op0
,
13306 strict_overflow_p
);
13310 tree inner_type
= TREE_TYPE (op0
);
13311 tree outer_type
= type
;
13313 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
13314 && tree_expr_nonzero_warnv_p (op0
,
13315 strict_overflow_p
));
13319 case NON_LVALUE_EXPR
:
13320 return tree_expr_nonzero_warnv_p (op0
,
13321 strict_overflow_p
);
13330 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13331 For floating point we further ensure that T is not denormal.
13332 Similar logic is present in nonzero_address in rtlanal.h.
13334 If the return value is based on the assumption that signed overflow
13335 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13336 change *STRICT_OVERFLOW_P. */
13339 tree_binary_nonzero_warnv_p (enum tree_code code
,
13342 tree op1
, bool *strict_overflow_p
)
13344 bool sub_strict_overflow_p
;
13347 case POINTER_PLUS_EXPR
:
13349 if (ANY_INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_UNDEFINED (type
))
13351 /* With the presence of negative values it is hard
13352 to say something. */
13353 sub_strict_overflow_p
= false;
13354 if (!tree_expr_nonnegative_warnv_p (op0
,
13355 &sub_strict_overflow_p
)
13356 || !tree_expr_nonnegative_warnv_p (op1
,
13357 &sub_strict_overflow_p
))
13359 /* One of operands must be positive and the other non-negative. */
13360 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13361 overflows, on a twos-complement machine the sum of two
13362 nonnegative numbers can never be zero. */
13363 return (tree_expr_nonzero_warnv_p (op0
,
13365 || tree_expr_nonzero_warnv_p (op1
,
13366 strict_overflow_p
));
13371 if (TYPE_OVERFLOW_UNDEFINED (type
))
13373 if (tree_expr_nonzero_warnv_p (op0
,
13375 && tree_expr_nonzero_warnv_p (op1
,
13376 strict_overflow_p
))
13378 *strict_overflow_p
= true;
13385 sub_strict_overflow_p
= false;
13386 if (tree_expr_nonzero_warnv_p (op0
,
13387 &sub_strict_overflow_p
)
13388 && tree_expr_nonzero_warnv_p (op1
,
13389 &sub_strict_overflow_p
))
13391 if (sub_strict_overflow_p
)
13392 *strict_overflow_p
= true;
13397 sub_strict_overflow_p
= false;
13398 if (tree_expr_nonzero_warnv_p (op0
,
13399 &sub_strict_overflow_p
))
13401 if (sub_strict_overflow_p
)
13402 *strict_overflow_p
= true;
13404 /* When both operands are nonzero, then MAX must be too. */
13405 if (tree_expr_nonzero_warnv_p (op1
,
13406 strict_overflow_p
))
13409 /* MAX where operand 0 is positive is positive. */
13410 return tree_expr_nonnegative_warnv_p (op0
,
13411 strict_overflow_p
);
13413 /* MAX where operand 1 is positive is positive. */
13414 else if (tree_expr_nonzero_warnv_p (op1
,
13415 &sub_strict_overflow_p
)
13416 && tree_expr_nonnegative_warnv_p (op1
,
13417 &sub_strict_overflow_p
))
13419 if (sub_strict_overflow_p
)
13420 *strict_overflow_p
= true;
13426 return (tree_expr_nonzero_warnv_p (op1
,
13428 || tree_expr_nonzero_warnv_p (op0
,
13429 strict_overflow_p
));
13438 /* Return true when T is an address and is known to be nonzero.
13439 For floating point we further ensure that T is not denormal.
13440 Similar logic is present in nonzero_address in rtlanal.h.
13442 If the return value is based on the assumption that signed overflow
13443 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13444 change *STRICT_OVERFLOW_P. */
13447 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
13449 bool sub_strict_overflow_p
;
13450 switch (TREE_CODE (t
))
13453 return !integer_zerop (t
);
13457 tree base
= TREE_OPERAND (t
, 0);
13459 if (!DECL_P (base
))
13460 base
= get_base_address (base
);
13462 if (base
&& TREE_CODE (base
) == TARGET_EXPR
)
13463 base
= TARGET_EXPR_SLOT (base
);
13468 /* For objects in symbol table check if we know they are non-zero.
13469 Don't do anything for variables and functions before symtab is built;
13470 it is quite possible that they will be declared weak later. */
13471 int nonzero_addr
= maybe_nonzero_address (base
);
13472 if (nonzero_addr
>= 0)
13473 return nonzero_addr
;
13475 /* Constants are never weak. */
13476 if (CONSTANT_CLASS_P (base
))
13483 sub_strict_overflow_p
= false;
13484 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
13485 &sub_strict_overflow_p
)
13486 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
13487 &sub_strict_overflow_p
))
13489 if (sub_strict_overflow_p
)
13490 *strict_overflow_p
= true;
13496 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
13498 return expr_not_equal_to (t
, wi::zero (TYPE_PRECISION (TREE_TYPE (t
))));
13506 #define integer_valued_real_p(X) \
13507 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
13509 #define RECURSE(X) \
13510 ((integer_valued_real_p) (X, depth + 1))
13512 /* Return true if the floating point result of (CODE OP0) has an
13513 integer value. We also allow +Inf, -Inf and NaN to be considered
13514 integer values. Return false for signaling NaN.
13516 DEPTH is the current nesting depth of the query. */
13519 integer_valued_real_unary_p (tree_code code
, tree op0
, int depth
)
13527 return RECURSE (op0
);
13531 tree type
= TREE_TYPE (op0
);
13532 if (TREE_CODE (type
) == INTEGER_TYPE
)
13534 if (TREE_CODE (type
) == REAL_TYPE
)
13535 return RECURSE (op0
);
13545 /* Return true if the floating point result of (CODE OP0 OP1) has an
13546 integer value. We also allow +Inf, -Inf and NaN to be considered
13547 integer values. Return false for signaling NaN.
13549 DEPTH is the current nesting depth of the query. */
13552 integer_valued_real_binary_p (tree_code code
, tree op0
, tree op1
, int depth
)
13561 return RECURSE (op0
) && RECURSE (op1
);
13569 /* Return true if the floating point result of calling FNDECL with arguments
13570 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13571 considered integer values. Return false for signaling NaN. If FNDECL
13572 takes fewer than 2 arguments, the remaining ARGn are null.
13574 DEPTH is the current nesting depth of the query. */
13577 integer_valued_real_call_p (combined_fn fn
, tree arg0
, tree arg1
, int depth
)
13585 CASE_CFN_NEARBYINT
:
13586 CASE_CFN_NEARBYINT_FN
:
13599 return RECURSE (arg0
) && RECURSE (arg1
);
13607 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13608 has an integer value. We also allow +Inf, -Inf and NaN to be
13609 considered integer values. Return false for signaling NaN.
13611 DEPTH is the current nesting depth of the query. */
13614 integer_valued_real_single_p (tree t
, int depth
)
13616 switch (TREE_CODE (t
))
13619 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
13622 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
13625 /* Limit the depth of recursion to avoid quadratic behavior.
13626 This is expected to catch almost all occurrences in practice.
13627 If this code misses important cases that unbounded recursion
13628 would not, passes that need this information could be revised
13629 to provide it through dataflow propagation. */
13630 return (!name_registered_for_update_p (t
)
13631 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
13632 && gimple_stmt_integer_valued_real_p (SSA_NAME_DEF_STMT (t
),
13641 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13642 has an integer value. We also allow +Inf, -Inf and NaN to be
13643 considered integer values. Return false for signaling NaN.
13645 DEPTH is the current nesting depth of the query. */
13648 integer_valued_real_invalid_p (tree t
, int depth
)
13650 switch (TREE_CODE (t
))
13652 case COMPOUND_EXPR
:
13655 return RECURSE (TREE_OPERAND (t
, 1));
13658 return RECURSE (TREE_OPERAND (t
, 0));
13667 #undef integer_valued_real_p
13669 /* Return true if the floating point expression T has an integer value.
13670 We also allow +Inf, -Inf and NaN to be considered integer values.
13671 Return false for signaling NaN.
13673 DEPTH is the current nesting depth of the query. */
13676 integer_valued_real_p (tree t
, int depth
)
13678 if (t
== error_mark_node
)
13681 tree_code code
= TREE_CODE (t
);
13682 switch (TREE_CODE_CLASS (code
))
13685 case tcc_comparison
:
13686 return integer_valued_real_binary_p (code
, TREE_OPERAND (t
, 0),
13687 TREE_OPERAND (t
, 1), depth
);
13690 return integer_valued_real_unary_p (code
, TREE_OPERAND (t
, 0), depth
);
13693 case tcc_declaration
:
13694 case tcc_reference
:
13695 return integer_valued_real_single_p (t
, depth
);
13705 return integer_valued_real_single_p (t
, depth
);
13709 tree arg0
= (call_expr_nargs (t
) > 0
13710 ? CALL_EXPR_ARG (t
, 0)
13712 tree arg1
= (call_expr_nargs (t
) > 1
13713 ? CALL_EXPR_ARG (t
, 1)
13715 return integer_valued_real_call_p (get_call_combined_fn (t
),
13716 arg0
, arg1
, depth
);
13720 return integer_valued_real_invalid_p (t
, depth
);
13724 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13725 attempt to fold the expression to a constant without modifying TYPE,
13728 If the expression could be simplified to a constant, then return
13729 the constant. If the expression would not be simplified to a
13730 constant, then return NULL_TREE. */
13733 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
13735 tree tem
= fold_binary (code
, type
, op0
, op1
);
13736 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13739 /* Given the components of a unary expression CODE, TYPE and OP0,
13740 attempt to fold the expression to a constant without modifying
13743 If the expression could be simplified to a constant, then return
13744 the constant. If the expression would not be simplified to a
13745 constant, then return NULL_TREE. */
13748 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
13750 tree tem
= fold_unary (code
, type
, op0
);
13751 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13754 /* If EXP represents referencing an element in a constant string
13755 (either via pointer arithmetic or array indexing), return the
13756 tree representing the value accessed, otherwise return NULL. */
13759 fold_read_from_constant_string (tree exp
)
13761 if ((TREE_CODE (exp
) == INDIRECT_REF
13762 || TREE_CODE (exp
) == ARRAY_REF
)
13763 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
13765 tree exp1
= TREE_OPERAND (exp
, 0);
13768 location_t loc
= EXPR_LOCATION (exp
);
13770 if (TREE_CODE (exp
) == INDIRECT_REF
)
13771 string
= string_constant (exp1
, &index
);
13774 tree low_bound
= array_ref_low_bound (exp
);
13775 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
13777 /* Optimize the special-case of a zero lower bound.
13779 We convert the low_bound to sizetype to avoid some problems
13780 with constant folding. (E.g. suppose the lower bound is 1,
13781 and its mode is QI. Without the conversion,l (ARRAY
13782 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13783 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13784 if (! integer_zerop (low_bound
))
13785 index
= size_diffop_loc (loc
, index
,
13786 fold_convert_loc (loc
, sizetype
, low_bound
));
13791 scalar_int_mode char_mode
;
13793 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
13794 && TREE_CODE (string
) == STRING_CST
13795 && TREE_CODE (index
) == INTEGER_CST
13796 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
13797 && is_int_mode (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))),
13799 && GET_MODE_SIZE (char_mode
) == 1)
13800 return build_int_cst_type (TREE_TYPE (exp
),
13801 (TREE_STRING_POINTER (string
)
13802 [TREE_INT_CST_LOW (index
)]));
13807 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13808 an integer constant, real, or fixed-point constant.
13810 TYPE is the type of the result. */
13813 fold_negate_const (tree arg0
, tree type
)
13815 tree t
= NULL_TREE
;
13817 switch (TREE_CODE (arg0
))
13820 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13825 FIXED_VALUE_TYPE f
;
13826 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
13827 &(TREE_FIXED_CST (arg0
)), NULL
,
13828 TYPE_SATURATING (type
));
13829 t
= build_fixed (type
, f
);
13830 /* Propagate overflow flags. */
13831 if (overflow_p
| TREE_OVERFLOW (arg0
))
13832 TREE_OVERFLOW (t
) = 1;
13837 if (poly_int_tree_p (arg0
))
13840 poly_wide_int res
= wi::neg (wi::to_poly_wide (arg0
), &overflow
);
13841 t
= force_fit_type (type
, res
, 1,
13842 (overflow
&& ! TYPE_UNSIGNED (type
))
13843 || TREE_OVERFLOW (arg0
));
13847 gcc_unreachable ();
13853 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13854 an integer constant or real constant.
13856 TYPE is the type of the result. */
13859 fold_abs_const (tree arg0
, tree type
)
13861 tree t
= NULL_TREE
;
13863 switch (TREE_CODE (arg0
))
13867 /* If the value is unsigned or non-negative, then the absolute value
13868 is the same as the ordinary value. */
13869 if (!wi::neg_p (wi::to_wide (arg0
), TYPE_SIGN (type
)))
13872 /* If the value is negative, then the absolute value is
13877 wide_int val
= wi::neg (wi::to_wide (arg0
), &overflow
);
13878 t
= force_fit_type (type
, val
, -1,
13879 overflow
| TREE_OVERFLOW (arg0
));
13885 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
13886 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13892 gcc_unreachable ();
13898 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13899 constant. TYPE is the type of the result. */
13902 fold_not_const (const_tree arg0
, tree type
)
13904 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
13906 return force_fit_type (type
, ~wi::to_wide (arg0
), 0, TREE_OVERFLOW (arg0
));
13909 /* Given CODE, a relational operator, the target type, TYPE and two
13910 constant operands OP0 and OP1, return the result of the
13911 relational operation. If the result is not a compile time
13912 constant, then return NULL_TREE. */
13915 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
13917 int result
, invert
;
13919 /* From here on, the only cases we handle are when the result is
13920 known to be a constant. */
13922 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
13924 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
13925 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
13927 /* Handle the cases where either operand is a NaN. */
13928 if (real_isnan (c0
) || real_isnan (c1
))
13938 case UNORDERED_EXPR
:
13952 if (flag_trapping_math
)
13958 gcc_unreachable ();
13961 return constant_boolean_node (result
, type
);
13964 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
13967 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
13969 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
13970 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
13971 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
13974 /* Handle equality/inequality of complex constants. */
13975 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
13977 tree rcond
= fold_relational_const (code
, type
,
13978 TREE_REALPART (op0
),
13979 TREE_REALPART (op1
));
13980 tree icond
= fold_relational_const (code
, type
,
13981 TREE_IMAGPART (op0
),
13982 TREE_IMAGPART (op1
));
13983 if (code
== EQ_EXPR
)
13984 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
13985 else if (code
== NE_EXPR
)
13986 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
13991 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
13993 if (!VECTOR_TYPE_P (type
))
13995 /* Have vector comparison with scalar boolean result. */
13996 gcc_assert ((code
== EQ_EXPR
|| code
== NE_EXPR
)
13997 && known_eq (VECTOR_CST_NELTS (op0
),
13998 VECTOR_CST_NELTS (op1
)));
13999 unsigned HOST_WIDE_INT nunits
;
14000 if (!VECTOR_CST_NELTS (op0
).is_constant (&nunits
))
14002 for (unsigned i
= 0; i
< nunits
; i
++)
14004 tree elem0
= VECTOR_CST_ELT (op0
, i
);
14005 tree elem1
= VECTOR_CST_ELT (op1
, i
);
14006 tree tmp
= fold_relational_const (code
, type
, elem0
, elem1
);
14007 if (tmp
== NULL_TREE
)
14009 if (integer_zerop (tmp
))
14010 return constant_boolean_node (false, type
);
14012 return constant_boolean_node (true, type
);
14014 tree_vector_builder elts
;
14015 if (!elts
.new_binary_operation (type
, op0
, op1
, false))
14017 unsigned int count
= elts
.encoded_nelts ();
14018 for (unsigned i
= 0; i
< count
; i
++)
14020 tree elem_type
= TREE_TYPE (type
);
14021 tree elem0
= VECTOR_CST_ELT (op0
, i
);
14022 tree elem1
= VECTOR_CST_ELT (op1
, i
);
14024 tree tem
= fold_relational_const (code
, elem_type
,
14027 if (tem
== NULL_TREE
)
14030 elts
.quick_push (build_int_cst (elem_type
,
14031 integer_zerop (tem
) ? 0 : -1));
14034 return elts
.build ();
14037 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
14039 To compute GT, swap the arguments and do LT.
14040 To compute GE, do LT and invert the result.
14041 To compute LE, swap the arguments, do LT and invert the result.
14042 To compute NE, do EQ and invert the result.
14044 Therefore, the code below must handle only EQ and LT. */
14046 if (code
== LE_EXPR
|| code
== GT_EXPR
)
14048 std::swap (op0
, op1
);
14049 code
= swap_tree_comparison (code
);
14052 /* Note that it is safe to invert for real values here because we
14053 have already handled the one case that it matters. */
14056 if (code
== NE_EXPR
|| code
== GE_EXPR
)
14059 code
= invert_tree_comparison (code
, false);
14062 /* Compute a result for LT or EQ if args permit;
14063 Otherwise return T. */
14064 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
14066 if (code
== EQ_EXPR
)
14067 result
= tree_int_cst_equal (op0
, op1
);
14069 result
= tree_int_cst_lt (op0
, op1
);
14076 return constant_boolean_node (result
, type
);
14079 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
14080 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
14084 fold_build_cleanup_point_expr (tree type
, tree expr
)
14086 /* If the expression does not have side effects then we don't have to wrap
14087 it with a cleanup point expression. */
14088 if (!TREE_SIDE_EFFECTS (expr
))
14091 /* If the expression is a return, check to see if the expression inside the
14092 return has no side effects or the right hand side of the modify expression
14093 inside the return. If either don't have side effects set we don't need to
14094 wrap the expression in a cleanup point expression. Note we don't check the
14095 left hand side of the modify because it should always be a return decl. */
14096 if (TREE_CODE (expr
) == RETURN_EXPR
)
14098 tree op
= TREE_OPERAND (expr
, 0);
14099 if (!op
|| !TREE_SIDE_EFFECTS (op
))
14101 op
= TREE_OPERAND (op
, 1);
14102 if (!TREE_SIDE_EFFECTS (op
))
14106 return build1_loc (EXPR_LOCATION (expr
), CLEANUP_POINT_EXPR
, type
, expr
);
14109 /* Given a pointer value OP0 and a type TYPE, return a simplified version
14110 of an indirection through OP0, or NULL_TREE if no simplification is
14114 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
14118 poly_uint64 const_op01
;
14121 subtype
= TREE_TYPE (sub
);
14122 if (!POINTER_TYPE_P (subtype
)
14123 || TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (op0
)))
14126 if (TREE_CODE (sub
) == ADDR_EXPR
)
14128 tree op
= TREE_OPERAND (sub
, 0);
14129 tree optype
= TREE_TYPE (op
);
14131 /* *&CONST_DECL -> to the value of the const decl. */
14132 if (TREE_CODE (op
) == CONST_DECL
)
14133 return DECL_INITIAL (op
);
14134 /* *&p => p; make sure to handle *&"str"[cst] here. */
14135 if (type
== optype
)
14137 tree fop
= fold_read_from_constant_string (op
);
14143 /* *(foo *)&fooarray => fooarray[0] */
14144 else if (TREE_CODE (optype
) == ARRAY_TYPE
14145 && type
== TREE_TYPE (optype
)
14146 && (!in_gimple_form
14147 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14149 tree type_domain
= TYPE_DOMAIN (optype
);
14150 tree min_val
= size_zero_node
;
14151 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14152 min_val
= TYPE_MIN_VALUE (type_domain
);
14154 && TREE_CODE (min_val
) != INTEGER_CST
)
14156 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
14157 NULL_TREE
, NULL_TREE
);
14159 /* *(foo *)&complexfoo => __real__ complexfoo */
14160 else if (TREE_CODE (optype
) == COMPLEX_TYPE
14161 && type
== TREE_TYPE (optype
))
14162 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
14163 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
14164 else if (VECTOR_TYPE_P (optype
)
14165 && type
== TREE_TYPE (optype
))
14167 tree part_width
= TYPE_SIZE (type
);
14168 tree index
= bitsize_int (0);
14169 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
14174 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
14175 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
14177 tree op00
= TREE_OPERAND (sub
, 0);
14178 tree op01
= TREE_OPERAND (sub
, 1);
14181 if (TREE_CODE (op00
) == ADDR_EXPR
)
14184 op00
= TREE_OPERAND (op00
, 0);
14185 op00type
= TREE_TYPE (op00
);
14187 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
14188 if (VECTOR_TYPE_P (op00type
)
14189 && type
== TREE_TYPE (op00type
)
14190 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
14191 but we want to treat offsets with MSB set as negative.
14192 For the code below negative offsets are invalid and
14193 TYPE_SIZE of the element is something unsigned, so
14194 check whether op01 fits into poly_int64, which implies
14195 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
14196 then just use poly_uint64 because we want to treat the
14197 value as unsigned. */
14198 && tree_fits_poly_int64_p (op01
))
14200 tree part_width
= TYPE_SIZE (type
);
14201 poly_uint64 max_offset
14202 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
14203 * TYPE_VECTOR_SUBPARTS (op00type
));
14204 if (known_lt (const_op01
, max_offset
))
14206 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
14207 return fold_build3_loc (loc
,
14208 BIT_FIELD_REF
, type
, op00
,
14209 part_width
, index
);
14212 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14213 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
14214 && type
== TREE_TYPE (op00type
))
14216 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
14218 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
14220 /* ((foo *)&fooarray)[1] => fooarray[1] */
14221 else if (TREE_CODE (op00type
) == ARRAY_TYPE
14222 && type
== TREE_TYPE (op00type
))
14224 tree type_domain
= TYPE_DOMAIN (op00type
);
14225 tree min_val
= size_zero_node
;
14226 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14227 min_val
= TYPE_MIN_VALUE (type_domain
);
14228 poly_uint64 type_size
, index
;
14229 if (poly_int_tree_p (min_val
)
14230 && poly_int_tree_p (TYPE_SIZE_UNIT (type
), &type_size
)
14231 && multiple_p (const_op01
, type_size
, &index
))
14233 poly_offset_int off
= index
+ wi::to_poly_offset (min_val
);
14234 op01
= wide_int_to_tree (sizetype
, off
);
14235 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
14236 NULL_TREE
, NULL_TREE
);
14242 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14243 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
14244 && type
== TREE_TYPE (TREE_TYPE (subtype
))
14245 && (!in_gimple_form
14246 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14249 tree min_val
= size_zero_node
;
14250 sub
= build_fold_indirect_ref_loc (loc
, sub
);
14251 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
14252 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14253 min_val
= TYPE_MIN_VALUE (type_domain
);
14255 && TREE_CODE (min_val
) != INTEGER_CST
)
14257 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
14264 /* Builds an expression for an indirection through T, simplifying some
14268 build_fold_indirect_ref_loc (location_t loc
, tree t
)
14270 tree type
= TREE_TYPE (TREE_TYPE (t
));
14271 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
14276 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
14279 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14282 fold_indirect_ref_loc (location_t loc
, tree t
)
14284 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
14292 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14293 whose result is ignored. The type of the returned tree need not be
14294 the same as the original expression. */
14297 fold_ignored_result (tree t
)
14299 if (!TREE_SIDE_EFFECTS (t
))
14300 return integer_zero_node
;
14303 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
14306 t
= TREE_OPERAND (t
, 0);
14310 case tcc_comparison
:
14311 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14312 t
= TREE_OPERAND (t
, 0);
14313 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
14314 t
= TREE_OPERAND (t
, 1);
14319 case tcc_expression
:
14320 switch (TREE_CODE (t
))
14322 case COMPOUND_EXPR
:
14323 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14325 t
= TREE_OPERAND (t
, 0);
14329 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
14330 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
14332 t
= TREE_OPERAND (t
, 0);
14345 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14348 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
14350 tree div
= NULL_TREE
;
14355 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14356 have to do anything. Only do this when we are not given a const,
14357 because in that case, this check is more expensive than just
14359 if (TREE_CODE (value
) != INTEGER_CST
)
14361 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14363 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14367 /* If divisor is a power of two, simplify this to bit manipulation. */
14368 if (pow2_or_zerop (divisor
))
14370 if (TREE_CODE (value
) == INTEGER_CST
)
14372 wide_int val
= wi::to_wide (value
);
14375 if ((val
& (divisor
- 1)) == 0)
14378 overflow_p
= TREE_OVERFLOW (value
);
14379 val
+= divisor
- 1;
14380 val
&= (int) -divisor
;
14384 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
14390 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
14391 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
14392 t
= build_int_cst (TREE_TYPE (value
), - (int) divisor
);
14393 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14399 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14400 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
14401 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14407 /* Likewise, but round down. */
14410 round_down_loc (location_t loc
, tree value
, int divisor
)
14412 tree div
= NULL_TREE
;
14414 gcc_assert (divisor
> 0);
14418 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14419 have to do anything. Only do this when we are not given a const,
14420 because in that case, this check is more expensive than just
14422 if (TREE_CODE (value
) != INTEGER_CST
)
14424 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14426 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14430 /* If divisor is a power of two, simplify this to bit manipulation. */
14431 if (pow2_or_zerop (divisor
))
14435 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
14436 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14441 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14442 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
14443 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14449 /* Returns the pointer to the base of the object addressed by EXP and
14450 extracts the information about the offset of the access, storing it
14451 to PBITPOS and POFFSET. */
14454 split_address_to_core_and_offset (tree exp
,
14455 poly_int64_pod
*pbitpos
, tree
*poffset
)
14459 int unsignedp
, reversep
, volatilep
;
14460 poly_int64 bitsize
;
14461 location_t loc
= EXPR_LOCATION (exp
);
14463 if (TREE_CODE (exp
) == ADDR_EXPR
)
14465 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
14466 poffset
, &mode
, &unsignedp
, &reversep
,
14468 core
= build_fold_addr_expr_loc (loc
, core
);
14470 else if (TREE_CODE (exp
) == POINTER_PLUS_EXPR
)
14472 core
= TREE_OPERAND (exp
, 0);
14475 *poffset
= TREE_OPERAND (exp
, 1);
14476 if (poly_int_tree_p (*poffset
))
14478 poly_offset_int tem
14479 = wi::sext (wi::to_poly_offset (*poffset
),
14480 TYPE_PRECISION (TREE_TYPE (*poffset
)));
14481 tem
<<= LOG2_BITS_PER_UNIT
;
14482 if (tem
.to_shwi (pbitpos
))
14483 *poffset
= NULL_TREE
;
14490 *poffset
= NULL_TREE
;
14496 /* Returns true if addresses of E1 and E2 differ by a constant, false
14497 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14500 ptr_difference_const (tree e1
, tree e2
, poly_int64_pod
*diff
)
14503 poly_int64 bitpos1
, bitpos2
;
14504 tree toffset1
, toffset2
, tdiff
, type
;
14506 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
14507 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
14509 poly_int64 bytepos1
, bytepos2
;
14510 if (!multiple_p (bitpos1
, BITS_PER_UNIT
, &bytepos1
)
14511 || !multiple_p (bitpos2
, BITS_PER_UNIT
, &bytepos2
)
14512 || !operand_equal_p (core1
, core2
, 0))
14515 if (toffset1
&& toffset2
)
14517 type
= TREE_TYPE (toffset1
);
14518 if (type
!= TREE_TYPE (toffset2
))
14519 toffset2
= fold_convert (type
, toffset2
);
14521 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
14522 if (!cst_and_fits_in_hwi (tdiff
))
14525 *diff
= int_cst_value (tdiff
);
14527 else if (toffset1
|| toffset2
)
14529 /* If only one of the offsets is non-constant, the difference cannot
14536 *diff
+= bytepos1
- bytepos2
;
14540 /* Return OFF converted to a pointer offset type suitable as offset for
14541 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14543 convert_to_ptrofftype_loc (location_t loc
, tree off
)
14545 return fold_convert_loc (loc
, sizetype
, off
);
14548 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14550 fold_build_pointer_plus_loc (location_t loc
, tree ptr
, tree off
)
14552 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14553 ptr
, convert_to_ptrofftype_loc (loc
, off
));
14556 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14558 fold_build_pointer_plus_hwi_loc (location_t loc
, tree ptr
, HOST_WIDE_INT off
)
14560 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14561 ptr
, size_int (off
));
14564 /* Return a char pointer for a C string if it is a string constant
14565 or sum of string constant and integer constant. We only support
14566 string constants properly terminated with '\0' character.
14567 If STRLEN is a valid pointer, length (including terminating character)
14568 of returned string is stored to the argument. */
14571 c_getstr (tree src
, unsigned HOST_WIDE_INT
*strlen
)
14578 src
= string_constant (src
, &offset_node
);
14582 unsigned HOST_WIDE_INT offset
= 0;
14583 if (offset_node
!= NULL_TREE
)
14585 if (!tree_fits_uhwi_p (offset_node
))
14588 offset
= tree_to_uhwi (offset_node
);
14591 unsigned HOST_WIDE_INT string_length
= TREE_STRING_LENGTH (src
);
14592 const char *string
= TREE_STRING_POINTER (src
);
14594 /* Support only properly null-terminated strings. */
14595 if (string_length
== 0
14596 || string
[string_length
- 1] != '\0'
14597 || offset
>= string_length
)
14601 *strlen
= string_length
- offset
;
14602 return string
+ offset
;
14605 /* Given a tree T, compute which bits in T may be nonzero. */
14608 tree_nonzero_bits (const_tree t
)
14610 switch (TREE_CODE (t
))
14613 return wi::to_wide (t
);
14615 return get_nonzero_bits (t
);
14616 case NON_LVALUE_EXPR
:
14618 return tree_nonzero_bits (TREE_OPERAND (t
, 0));
14620 return wi::bit_and (tree_nonzero_bits (TREE_OPERAND (t
, 0)),
14621 tree_nonzero_bits (TREE_OPERAND (t
, 1)));
14624 return wi::bit_or (tree_nonzero_bits (TREE_OPERAND (t
, 0)),
14625 tree_nonzero_bits (TREE_OPERAND (t
, 1)));
14627 return wi::bit_or (tree_nonzero_bits (TREE_OPERAND (t
, 1)),
14628 tree_nonzero_bits (TREE_OPERAND (t
, 2)));
14630 return wide_int::from (tree_nonzero_bits (TREE_OPERAND (t
, 0)),
14631 TYPE_PRECISION (TREE_TYPE (t
)),
14632 TYPE_SIGN (TREE_TYPE (TREE_OPERAND (t
, 0))));
14634 if (INTEGRAL_TYPE_P (TREE_TYPE (t
)))
14636 wide_int nzbits1
= tree_nonzero_bits (TREE_OPERAND (t
, 0));
14637 wide_int nzbits2
= tree_nonzero_bits (TREE_OPERAND (t
, 1));
14638 if (wi::bit_and (nzbits1
, nzbits2
) == 0)
14639 return wi::bit_or (nzbits1
, nzbits2
);
14643 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
14645 tree type
= TREE_TYPE (t
);
14646 wide_int nzbits
= tree_nonzero_bits (TREE_OPERAND (t
, 0));
14647 wide_int arg1
= wi::to_wide (TREE_OPERAND (t
, 1),
14648 TYPE_PRECISION (type
));
14649 return wi::neg_p (arg1
)
14650 ? wi::rshift (nzbits
, -arg1
, TYPE_SIGN (type
))
14651 : wi::lshift (nzbits
, arg1
);
14655 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
14657 tree type
= TREE_TYPE (t
);
14658 wide_int nzbits
= tree_nonzero_bits (TREE_OPERAND (t
, 0));
14659 wide_int arg1
= wi::to_wide (TREE_OPERAND (t
, 1),
14660 TYPE_PRECISION (type
));
14661 return wi::neg_p (arg1
)
14662 ? wi::lshift (nzbits
, -arg1
)
14663 : wi::rshift (nzbits
, arg1
, TYPE_SIGN (type
));
14670 return wi::shwi (-1, TYPE_PRECISION (TREE_TYPE (t
)));
14675 namespace selftest
{
14677 /* Helper functions for writing tests of folding trees. */
14679 /* Verify that the binary op (LHS CODE RHS) folds to CONSTANT. */
14682 assert_binop_folds_to_const (tree lhs
, enum tree_code code
, tree rhs
,
14685 ASSERT_EQ (constant
, fold_build2 (code
, TREE_TYPE (lhs
), lhs
, rhs
));
14688 /* Verify that the binary op (LHS CODE RHS) folds to an NON_LVALUE_EXPR
14689 wrapping WRAPPED_EXPR. */
14692 assert_binop_folds_to_nonlvalue (tree lhs
, enum tree_code code
, tree rhs
,
14695 tree result
= fold_build2 (code
, TREE_TYPE (lhs
), lhs
, rhs
);
14696 ASSERT_NE (wrapped_expr
, result
);
14697 ASSERT_EQ (NON_LVALUE_EXPR
, TREE_CODE (result
));
14698 ASSERT_EQ (wrapped_expr
, TREE_OPERAND (result
, 0));
14701 /* Verify that various arithmetic binary operations are folded
14705 test_arithmetic_folding ()
14707 tree type
= integer_type_node
;
14708 tree x
= create_tmp_var_raw (type
, "x");
14709 tree zero
= build_zero_cst (type
);
14710 tree one
= build_int_cst (type
, 1);
14713 /* 1 <-- (0 + 1) */
14714 assert_binop_folds_to_const (zero
, PLUS_EXPR
, one
,
14716 assert_binop_folds_to_const (one
, PLUS_EXPR
, zero
,
14719 /* (nonlvalue)x <-- (x + 0) */
14720 assert_binop_folds_to_nonlvalue (x
, PLUS_EXPR
, zero
,
14724 /* 0 <-- (x - x) */
14725 assert_binop_folds_to_const (x
, MINUS_EXPR
, x
,
14727 assert_binop_folds_to_nonlvalue (x
, MINUS_EXPR
, zero
,
14730 /* Multiplication. */
14731 /* 0 <-- (x * 0) */
14732 assert_binop_folds_to_const (x
, MULT_EXPR
, zero
,
14735 /* (nonlvalue)x <-- (x * 1) */
14736 assert_binop_folds_to_nonlvalue (x
, MULT_EXPR
, one
,
14740 /* Verify that various binary operations on vectors are folded
14744 test_vector_folding ()
14746 tree inner_type
= integer_type_node
;
14747 tree type
= build_vector_type (inner_type
, 4);
14748 tree zero
= build_zero_cst (type
);
14749 tree one
= build_one_cst (type
);
14751 /* Verify equality tests that return a scalar boolean result. */
14752 tree res_type
= boolean_type_node
;
14753 ASSERT_FALSE (integer_nonzerop (fold_build2 (EQ_EXPR
, res_type
, zero
, one
)));
14754 ASSERT_TRUE (integer_nonzerop (fold_build2 (EQ_EXPR
, res_type
, zero
, zero
)));
14755 ASSERT_TRUE (integer_nonzerop (fold_build2 (NE_EXPR
, res_type
, zero
, one
)));
14756 ASSERT_FALSE (integer_nonzerop (fold_build2 (NE_EXPR
, res_type
, one
, one
)));
14759 /* Verify folding of VEC_DUPLICATE_EXPRs. */
14762 test_vec_duplicate_folding ()
14764 scalar_int_mode int_mode
= SCALAR_INT_TYPE_MODE (ssizetype
);
14765 machine_mode vec_mode
= targetm
.vectorize
.preferred_simd_mode (int_mode
);
14766 /* This will be 1 if VEC_MODE isn't a vector mode. */
14767 poly_uint64 nunits
= GET_MODE_NUNITS (vec_mode
);
14769 tree type
= build_vector_type (ssizetype
, nunits
);
14770 tree dup5_expr
= fold_unary (VEC_DUPLICATE_EXPR
, type
, ssize_int (5));
14771 tree dup5_cst
= build_vector_from_val (type
, ssize_int (5));
14772 ASSERT_TRUE (operand_equal_p (dup5_expr
, dup5_cst
, 0));
14775 /* Run all of the selftests within this file. */
14778 fold_const_c_tests ()
14780 test_arithmetic_folding ();
14781 test_vector_folding ();
14782 test_vec_duplicate_folding ();
14785 } // namespace selftest
14787 #endif /* CHECKING_P */