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 (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg2
) == INTEGER_CST
)
1616 offset_int res
= wi::sub (wi::to_offset (arg1
),
1617 wi::to_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
:
1626 unsigned int HOST_WIDE_INT out_nelts
, in_nelts
, i
;
1628 if (TREE_CODE (arg1
) != VECTOR_CST
1629 || TREE_CODE (arg2
) != VECTOR_CST
)
1632 if (!VECTOR_CST_NELTS (arg1
).is_constant (&in_nelts
))
1635 out_nelts
= in_nelts
* 2;
1636 gcc_assert (known_eq (in_nelts
, VECTOR_CST_NELTS (arg2
))
1637 && known_eq (out_nelts
, TYPE_VECTOR_SUBPARTS (type
)));
1639 tree_vector_builder
elts (type
, out_nelts
, 1);
1640 for (i
= 0; i
< out_nelts
; i
++)
1642 tree elt
= (i
< in_nelts
1643 ? VECTOR_CST_ELT (arg1
, i
)
1644 : VECTOR_CST_ELT (arg2
, i
- in_nelts
));
1645 elt
= fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
1646 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
1647 TREE_TYPE (type
), elt
);
1648 if (elt
== NULL_TREE
|| !CONSTANT_CLASS_P (elt
))
1650 elts
.quick_push (elt
);
1653 return elts
.build ();
1656 case VEC_WIDEN_MULT_LO_EXPR
:
1657 case VEC_WIDEN_MULT_HI_EXPR
:
1658 case VEC_WIDEN_MULT_EVEN_EXPR
:
1659 case VEC_WIDEN_MULT_ODD_EXPR
:
1661 unsigned HOST_WIDE_INT out_nelts
, in_nelts
, out
, ofs
, scale
;
1663 if (TREE_CODE (arg1
) != VECTOR_CST
|| TREE_CODE (arg2
) != VECTOR_CST
)
1666 if (!VECTOR_CST_NELTS (arg1
).is_constant (&in_nelts
))
1668 out_nelts
= in_nelts
/ 2;
1669 gcc_assert (known_eq (in_nelts
, VECTOR_CST_NELTS (arg2
))
1670 && known_eq (out_nelts
, TYPE_VECTOR_SUBPARTS (type
)));
1672 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
1673 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? out_nelts
: 0;
1674 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
1675 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : out_nelts
;
1676 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
1678 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
1681 tree_vector_builder
elts (type
, out_nelts
, 1);
1682 for (out
= 0; out
< out_nelts
; out
++)
1684 unsigned int in
= (out
<< scale
) + ofs
;
1685 tree t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
),
1686 VECTOR_CST_ELT (arg1
, in
));
1687 tree t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
),
1688 VECTOR_CST_ELT (arg2
, in
));
1690 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
1692 tree elt
= const_binop (MULT_EXPR
, t1
, t2
);
1693 if (elt
== NULL_TREE
|| !CONSTANT_CLASS_P (elt
))
1695 elts
.quick_push (elt
);
1698 return elts
.build ();
1704 if (TREE_CODE_CLASS (code
) != tcc_binary
)
1707 /* Make sure type and arg0 have the same saturating flag. */
1708 gcc_checking_assert (TYPE_SATURATING (type
)
1709 == TYPE_SATURATING (TREE_TYPE (arg1
)));
1711 return const_binop (code
, arg1
, arg2
);
1714 /* Compute CODE ARG1 with resulting type TYPE with ARG1 being constant.
1715 Return zero if computing the constants is not possible. */
1718 const_unop (enum tree_code code
, tree type
, tree arg0
)
1720 /* Don't perform the operation, other than NEGATE and ABS, if
1721 flag_signaling_nans is on and the operand is a signaling NaN. */
1722 if (TREE_CODE (arg0
) == REAL_CST
1723 && HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
1724 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg0
))
1725 && code
!= NEGATE_EXPR
1726 && code
!= ABS_EXPR
)
1733 case FIX_TRUNC_EXPR
:
1734 case FIXED_CONVERT_EXPR
:
1735 return fold_convert_const (code
, type
, arg0
);
1737 case ADDR_SPACE_CONVERT_EXPR
:
1738 /* If the source address is 0, and the source address space
1739 cannot have a valid object at 0, fold to dest type null. */
1740 if (integer_zerop (arg0
)
1741 && !(targetm
.addr_space
.zero_address_valid
1742 (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
))))))
1743 return fold_convert_const (code
, type
, arg0
);
1746 case VIEW_CONVERT_EXPR
:
1747 return fold_view_convert_expr (type
, arg0
);
1751 /* Can't call fold_negate_const directly here as that doesn't
1752 handle all cases and we might not be able to negate some
1754 tree tem
= fold_negate_expr (UNKNOWN_LOCATION
, arg0
);
1755 if (tem
&& CONSTANT_CLASS_P (tem
))
1761 if (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
)
1762 return fold_abs_const (arg0
, type
);
1766 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1768 tree ipart
= fold_negate_const (TREE_IMAGPART (arg0
),
1770 return build_complex (type
, TREE_REALPART (arg0
), ipart
);
1775 if (TREE_CODE (arg0
) == INTEGER_CST
)
1776 return fold_not_const (arg0
, type
);
1777 else if (POLY_INT_CST_P (arg0
))
1778 return wide_int_to_tree (type
, -poly_int_cst_value (arg0
));
1779 /* Perform BIT_NOT_EXPR on each element individually. */
1780 else if (TREE_CODE (arg0
) == VECTOR_CST
)
1784 /* This can cope with stepped encodings because ~x == -1 - x. */
1785 tree_vector_builder elements
;
1786 elements
.new_unary_operation (type
, arg0
, true);
1787 unsigned int i
, count
= elements
.encoded_nelts ();
1788 for (i
= 0; i
< count
; ++i
)
1790 elem
= VECTOR_CST_ELT (arg0
, i
);
1791 elem
= const_unop (BIT_NOT_EXPR
, TREE_TYPE (type
), elem
);
1792 if (elem
== NULL_TREE
)
1794 elements
.quick_push (elem
);
1797 return elements
.build ();
1801 case TRUTH_NOT_EXPR
:
1802 if (TREE_CODE (arg0
) == INTEGER_CST
)
1803 return constant_boolean_node (integer_zerop (arg0
), type
);
1807 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1808 return fold_convert (type
, TREE_REALPART (arg0
));
1812 if (TREE_CODE (arg0
) == COMPLEX_CST
)
1813 return fold_convert (type
, TREE_IMAGPART (arg0
));
1816 case VEC_UNPACK_LO_EXPR
:
1817 case VEC_UNPACK_HI_EXPR
:
1818 case VEC_UNPACK_FLOAT_LO_EXPR
:
1819 case VEC_UNPACK_FLOAT_HI_EXPR
:
1821 unsigned HOST_WIDE_INT out_nelts
, in_nelts
, i
;
1822 enum tree_code subcode
;
1824 if (TREE_CODE (arg0
) != VECTOR_CST
)
1827 if (!VECTOR_CST_NELTS (arg0
).is_constant (&in_nelts
))
1829 out_nelts
= in_nelts
/ 2;
1830 gcc_assert (known_eq (out_nelts
, TYPE_VECTOR_SUBPARTS (type
)));
1832 unsigned int offset
= 0;
1833 if ((!BYTES_BIG_ENDIAN
) ^ (code
== VEC_UNPACK_LO_EXPR
1834 || code
== VEC_UNPACK_FLOAT_LO_EXPR
))
1837 if (code
== VEC_UNPACK_LO_EXPR
|| code
== VEC_UNPACK_HI_EXPR
)
1840 subcode
= FLOAT_EXPR
;
1842 tree_vector_builder
elts (type
, out_nelts
, 1);
1843 for (i
= 0; i
< out_nelts
; i
++)
1845 tree elt
= fold_convert_const (subcode
, TREE_TYPE (type
),
1846 VECTOR_CST_ELT (arg0
, i
+ offset
));
1847 if (elt
== NULL_TREE
|| !CONSTANT_CLASS_P (elt
))
1849 elts
.quick_push (elt
);
1852 return elts
.build ();
1855 case VEC_DUPLICATE_EXPR
:
1856 if (CONSTANT_CLASS_P (arg0
))
1857 return build_vector_from_val (type
, arg0
);
1867 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1868 indicates which particular sizetype to create. */
1871 size_int_kind (poly_int64 number
, enum size_type_kind kind
)
1873 return build_int_cst (sizetype_tab
[(int) kind
], number
);
1876 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1877 is a tree code. The type of the result is taken from the operands.
1878 Both must be equivalent integer types, ala int_binop_types_match_p.
1879 If the operands are constant, so is the result. */
1882 size_binop_loc (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
)
1884 tree type
= TREE_TYPE (arg0
);
1886 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1887 return error_mark_node
;
1889 gcc_assert (int_binop_types_match_p (code
, TREE_TYPE (arg0
),
1892 /* Handle the special case of two poly_int constants faster. */
1893 if (poly_int_tree_p (arg0
) && poly_int_tree_p (arg1
))
1895 /* And some specific cases even faster than that. */
1896 if (code
== PLUS_EXPR
)
1898 if (integer_zerop (arg0
) && !TREE_OVERFLOW (arg0
))
1900 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1903 else if (code
== MINUS_EXPR
)
1905 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1908 else if (code
== MULT_EXPR
)
1910 if (integer_onep (arg0
) && !TREE_OVERFLOW (arg0
))
1914 /* Handle general case of two integer constants. For sizetype
1915 constant calculations we always want to know about overflow,
1916 even in the unsigned case. */
1917 tree res
= int_const_binop_1 (code
, arg0
, arg1
, -1);
1918 if (res
!= NULL_TREE
)
1922 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
1925 /* Given two values, either both of sizetype or both of bitsizetype,
1926 compute the difference between the two values. Return the value
1927 in signed type corresponding to the type of the operands. */
1930 size_diffop_loc (location_t loc
, tree arg0
, tree arg1
)
1932 tree type
= TREE_TYPE (arg0
);
1935 gcc_assert (int_binop_types_match_p (MINUS_EXPR
, TREE_TYPE (arg0
),
1938 /* If the type is already signed, just do the simple thing. */
1939 if (!TYPE_UNSIGNED (type
))
1940 return size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
);
1942 if (type
== sizetype
)
1944 else if (type
== bitsizetype
)
1945 ctype
= sbitsizetype
;
1947 ctype
= signed_type_for (type
);
1949 /* If either operand is not a constant, do the conversions to the signed
1950 type and subtract. The hardware will do the right thing with any
1951 overflow in the subtraction. */
1952 if (TREE_CODE (arg0
) != INTEGER_CST
|| TREE_CODE (arg1
) != INTEGER_CST
)
1953 return size_binop_loc (loc
, MINUS_EXPR
,
1954 fold_convert_loc (loc
, ctype
, arg0
),
1955 fold_convert_loc (loc
, ctype
, arg1
));
1957 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1958 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1959 overflow) and negate (which can't either). Special-case a result
1960 of zero while we're here. */
1961 if (tree_int_cst_equal (arg0
, arg1
))
1962 return build_int_cst (ctype
, 0);
1963 else if (tree_int_cst_lt (arg1
, arg0
))
1964 return fold_convert_loc (loc
, ctype
,
1965 size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
));
1967 return size_binop_loc (loc
, MINUS_EXPR
, build_int_cst (ctype
, 0),
1968 fold_convert_loc (loc
, ctype
,
1969 size_binop_loc (loc
,
1974 /* A subroutine of fold_convert_const handling conversions of an
1975 INTEGER_CST to another integer type. */
1978 fold_convert_const_int_from_int (tree type
, const_tree arg1
)
1980 /* Given an integer constant, make new constant with new type,
1981 appropriately sign-extended or truncated. Use widest_int
1982 so that any extension is done according ARG1's type. */
1983 return force_fit_type (type
, wi::to_widest (arg1
),
1984 !POINTER_TYPE_P (TREE_TYPE (arg1
)),
1985 TREE_OVERFLOW (arg1
));
1988 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1989 to an integer type. */
1992 fold_convert_const_int_from_real (enum tree_code code
, tree type
, const_tree arg1
)
1994 bool overflow
= false;
1997 /* The following code implements the floating point to integer
1998 conversion rules required by the Java Language Specification,
1999 that IEEE NaNs are mapped to zero and values that overflow
2000 the target precision saturate, i.e. values greater than
2001 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
2002 are mapped to INT_MIN. These semantics are allowed by the
2003 C and C++ standards that simply state that the behavior of
2004 FP-to-integer conversion is unspecified upon overflow. */
2008 REAL_VALUE_TYPE x
= TREE_REAL_CST (arg1
);
2012 case FIX_TRUNC_EXPR
:
2013 real_trunc (&r
, VOIDmode
, &x
);
2020 /* If R is NaN, return zero and show we have an overflow. */
2021 if (REAL_VALUE_ISNAN (r
))
2024 val
= wi::zero (TYPE_PRECISION (type
));
2027 /* See if R is less than the lower bound or greater than the
2032 tree lt
= TYPE_MIN_VALUE (type
);
2033 REAL_VALUE_TYPE l
= real_value_from_int_cst (NULL_TREE
, lt
);
2034 if (real_less (&r
, &l
))
2037 val
= wi::to_wide (lt
);
2043 tree ut
= TYPE_MAX_VALUE (type
);
2046 REAL_VALUE_TYPE u
= real_value_from_int_cst (NULL_TREE
, ut
);
2047 if (real_less (&u
, &r
))
2050 val
= wi::to_wide (ut
);
2056 val
= real_to_integer (&r
, &overflow
, TYPE_PRECISION (type
));
2058 t
= force_fit_type (type
, val
, -1, overflow
| TREE_OVERFLOW (arg1
));
2062 /* A subroutine of fold_convert_const handling conversions of a
2063 FIXED_CST to an integer type. */
2066 fold_convert_const_int_from_fixed (tree type
, const_tree arg1
)
2069 double_int temp
, temp_trunc
;
2072 /* Right shift FIXED_CST to temp by fbit. */
2073 temp
= TREE_FIXED_CST (arg1
).data
;
2074 mode
= TREE_FIXED_CST (arg1
).mode
;
2075 if (GET_MODE_FBIT (mode
) < HOST_BITS_PER_DOUBLE_INT
)
2077 temp
= temp
.rshift (GET_MODE_FBIT (mode
),
2078 HOST_BITS_PER_DOUBLE_INT
,
2079 SIGNED_FIXED_POINT_MODE_P (mode
));
2081 /* Left shift temp to temp_trunc by fbit. */
2082 temp_trunc
= temp
.lshift (GET_MODE_FBIT (mode
),
2083 HOST_BITS_PER_DOUBLE_INT
,
2084 SIGNED_FIXED_POINT_MODE_P (mode
));
2088 temp
= double_int_zero
;
2089 temp_trunc
= double_int_zero
;
2092 /* If FIXED_CST is negative, we need to round the value toward 0.
2093 By checking if the fractional bits are not zero to add 1 to temp. */
2094 if (SIGNED_FIXED_POINT_MODE_P (mode
)
2095 && temp_trunc
.is_negative ()
2096 && TREE_FIXED_CST (arg1
).data
!= temp_trunc
)
2097 temp
+= double_int_one
;
2099 /* Given a fixed-point constant, make new constant with new type,
2100 appropriately sign-extended or truncated. */
2101 t
= force_fit_type (type
, temp
, -1,
2102 (temp
.is_negative ()
2103 && (TYPE_UNSIGNED (type
)
2104 < TYPE_UNSIGNED (TREE_TYPE (arg1
))))
2105 | TREE_OVERFLOW (arg1
));
2110 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2111 to another floating point type. */
2114 fold_convert_const_real_from_real (tree type
, const_tree arg1
)
2116 REAL_VALUE_TYPE value
;
2119 /* Don't perform the operation if flag_signaling_nans is on
2120 and the operand is a signaling NaN. */
2121 if (HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
)))
2122 && REAL_VALUE_ISSIGNALING_NAN (TREE_REAL_CST (arg1
)))
2125 real_convert (&value
, TYPE_MODE (type
), &TREE_REAL_CST (arg1
));
2126 t
= build_real (type
, value
);
2128 /* If converting an infinity or NAN to a representation that doesn't
2129 have one, set the overflow bit so that we can produce some kind of
2130 error message at the appropriate point if necessary. It's not the
2131 most user-friendly message, but it's better than nothing. */
2132 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1
))
2133 && !MODE_HAS_INFINITIES (TYPE_MODE (type
)))
2134 TREE_OVERFLOW (t
) = 1;
2135 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
2136 && !MODE_HAS_NANS (TYPE_MODE (type
)))
2137 TREE_OVERFLOW (t
) = 1;
2138 /* Regular overflow, conversion produced an infinity in a mode that
2139 can't represent them. */
2140 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type
))
2141 && REAL_VALUE_ISINF (value
)
2142 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1
)))
2143 TREE_OVERFLOW (t
) = 1;
2145 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2149 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2150 to a floating point type. */
2153 fold_convert_const_real_from_fixed (tree type
, const_tree arg1
)
2155 REAL_VALUE_TYPE value
;
2158 real_convert_from_fixed (&value
, SCALAR_FLOAT_TYPE_MODE (type
),
2159 &TREE_FIXED_CST (arg1
));
2160 t
= build_real (type
, value
);
2162 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
2166 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2167 to another fixed-point type. */
2170 fold_convert_const_fixed_from_fixed (tree type
, const_tree arg1
)
2172 FIXED_VALUE_TYPE value
;
2176 overflow_p
= fixed_convert (&value
, SCALAR_TYPE_MODE (type
),
2177 &TREE_FIXED_CST (arg1
), TYPE_SATURATING (type
));
2178 t
= build_fixed (type
, value
);
2180 /* Propagate overflow flags. */
2181 if (overflow_p
| TREE_OVERFLOW (arg1
))
2182 TREE_OVERFLOW (t
) = 1;
2186 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2187 to a fixed-point type. */
2190 fold_convert_const_fixed_from_int (tree type
, const_tree arg1
)
2192 FIXED_VALUE_TYPE value
;
2197 gcc_assert (TREE_INT_CST_NUNITS (arg1
) <= 2);
2199 di
.low
= TREE_INT_CST_ELT (arg1
, 0);
2200 if (TREE_INT_CST_NUNITS (arg1
) == 1)
2201 di
.high
= (HOST_WIDE_INT
) di
.low
< 0 ? HOST_WIDE_INT_M1
: 0;
2203 di
.high
= TREE_INT_CST_ELT (arg1
, 1);
2205 overflow_p
= fixed_convert_from_int (&value
, SCALAR_TYPE_MODE (type
), di
,
2206 TYPE_UNSIGNED (TREE_TYPE (arg1
)),
2207 TYPE_SATURATING (type
));
2208 t
= build_fixed (type
, value
);
2210 /* Propagate overflow flags. */
2211 if (overflow_p
| TREE_OVERFLOW (arg1
))
2212 TREE_OVERFLOW (t
) = 1;
2216 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2217 to a fixed-point type. */
2220 fold_convert_const_fixed_from_real (tree type
, const_tree arg1
)
2222 FIXED_VALUE_TYPE value
;
2226 overflow_p
= fixed_convert_from_real (&value
, SCALAR_TYPE_MODE (type
),
2227 &TREE_REAL_CST (arg1
),
2228 TYPE_SATURATING (type
));
2229 t
= build_fixed (type
, value
);
2231 /* Propagate overflow flags. */
2232 if (overflow_p
| TREE_OVERFLOW (arg1
))
2233 TREE_OVERFLOW (t
) = 1;
2237 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2238 type TYPE. If no simplification can be done return NULL_TREE. */
2241 fold_convert_const (enum tree_code code
, tree type
, tree arg1
)
2243 tree arg_type
= TREE_TYPE (arg1
);
2244 if (arg_type
== type
)
2247 /* We can't widen types, since the runtime value could overflow the
2248 original type before being extended to the new type. */
2249 if (POLY_INT_CST_P (arg1
)
2250 && (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
))
2251 && TYPE_PRECISION (type
) <= TYPE_PRECISION (arg_type
))
2252 return build_poly_int_cst (type
,
2253 poly_wide_int::from (poly_int_cst_value (arg1
),
2254 TYPE_PRECISION (type
),
2255 TYPE_SIGN (arg_type
)));
2257 if (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
)
2258 || TREE_CODE (type
) == OFFSET_TYPE
)
2260 if (TREE_CODE (arg1
) == INTEGER_CST
)
2261 return fold_convert_const_int_from_int (type
, arg1
);
2262 else if (TREE_CODE (arg1
) == REAL_CST
)
2263 return fold_convert_const_int_from_real (code
, type
, arg1
);
2264 else if (TREE_CODE (arg1
) == FIXED_CST
)
2265 return fold_convert_const_int_from_fixed (type
, arg1
);
2267 else if (TREE_CODE (type
) == REAL_TYPE
)
2269 if (TREE_CODE (arg1
) == INTEGER_CST
)
2270 return build_real_from_int_cst (type
, arg1
);
2271 else if (TREE_CODE (arg1
) == REAL_CST
)
2272 return fold_convert_const_real_from_real (type
, arg1
);
2273 else if (TREE_CODE (arg1
) == FIXED_CST
)
2274 return fold_convert_const_real_from_fixed (type
, arg1
);
2276 else if (TREE_CODE (type
) == FIXED_POINT_TYPE
)
2278 if (TREE_CODE (arg1
) == FIXED_CST
)
2279 return fold_convert_const_fixed_from_fixed (type
, arg1
);
2280 else if (TREE_CODE (arg1
) == INTEGER_CST
)
2281 return fold_convert_const_fixed_from_int (type
, arg1
);
2282 else if (TREE_CODE (arg1
) == REAL_CST
)
2283 return fold_convert_const_fixed_from_real (type
, arg1
);
2285 else if (TREE_CODE (type
) == VECTOR_TYPE
)
2287 if (TREE_CODE (arg1
) == VECTOR_CST
2288 && known_eq (TYPE_VECTOR_SUBPARTS (type
), VECTOR_CST_NELTS (arg1
)))
2290 tree elttype
= TREE_TYPE (type
);
2291 tree arg1_elttype
= TREE_TYPE (TREE_TYPE (arg1
));
2292 /* We can't handle steps directly when extending, since the
2293 values need to wrap at the original precision first. */
2295 = (INTEGRAL_TYPE_P (elttype
)
2296 && INTEGRAL_TYPE_P (arg1_elttype
)
2297 && TYPE_PRECISION (elttype
) <= TYPE_PRECISION (arg1_elttype
));
2298 tree_vector_builder v
;
2299 if (!v
.new_unary_operation (type
, arg1
, step_ok_p
))
2301 unsigned int len
= v
.encoded_nelts ();
2302 for (unsigned int i
= 0; i
< len
; ++i
)
2304 tree elt
= VECTOR_CST_ELT (arg1
, i
);
2305 tree cvt
= fold_convert_const (code
, elttype
, elt
);
2306 if (cvt
== NULL_TREE
)
2316 /* Construct a vector of zero elements of vector type TYPE. */
2319 build_zero_vector (tree type
)
2323 t
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), integer_zero_node
);
2324 return build_vector_from_val (type
, t
);
2327 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
2330 fold_convertible_p (const_tree type
, const_tree arg
)
2332 tree orig
= TREE_TYPE (arg
);
2337 if (TREE_CODE (arg
) == ERROR_MARK
2338 || TREE_CODE (type
) == ERROR_MARK
2339 || TREE_CODE (orig
) == ERROR_MARK
)
2342 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2345 switch (TREE_CODE (type
))
2347 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2348 case POINTER_TYPE
: case REFERENCE_TYPE
:
2350 return (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2351 || TREE_CODE (orig
) == OFFSET_TYPE
);
2354 case FIXED_POINT_TYPE
:
2357 return TREE_CODE (type
) == TREE_CODE (orig
);
2364 /* Convert expression ARG to type TYPE. Used by the middle-end for
2365 simple conversions in preference to calling the front-end's convert. */
2368 fold_convert_loc (location_t loc
, tree type
, tree arg
)
2370 tree orig
= TREE_TYPE (arg
);
2376 if (TREE_CODE (arg
) == ERROR_MARK
2377 || TREE_CODE (type
) == ERROR_MARK
2378 || TREE_CODE (orig
) == ERROR_MARK
)
2379 return error_mark_node
;
2381 switch (TREE_CODE (type
))
2384 case REFERENCE_TYPE
:
2385 /* Handle conversions between pointers to different address spaces. */
2386 if (POINTER_TYPE_P (orig
)
2387 && (TYPE_ADDR_SPACE (TREE_TYPE (type
))
2388 != TYPE_ADDR_SPACE (TREE_TYPE (orig
))))
2389 return fold_build1_loc (loc
, ADDR_SPACE_CONVERT_EXPR
, type
, arg
);
2392 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
2394 if (TREE_CODE (arg
) == INTEGER_CST
)
2396 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2397 if (tem
!= NULL_TREE
)
2400 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2401 || TREE_CODE (orig
) == OFFSET_TYPE
)
2402 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2403 if (TREE_CODE (orig
) == COMPLEX_TYPE
)
2404 return fold_convert_loc (loc
, type
,
2405 fold_build1_loc (loc
, REALPART_EXPR
,
2406 TREE_TYPE (orig
), arg
));
2407 gcc_assert (TREE_CODE (orig
) == VECTOR_TYPE
2408 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2409 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2412 if (TREE_CODE (arg
) == INTEGER_CST
)
2414 tem
= fold_convert_const (FLOAT_EXPR
, type
, arg
);
2415 if (tem
!= NULL_TREE
)
2418 else if (TREE_CODE (arg
) == REAL_CST
)
2420 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
2421 if (tem
!= NULL_TREE
)
2424 else if (TREE_CODE (arg
) == FIXED_CST
)
2426 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2427 if (tem
!= NULL_TREE
)
2431 switch (TREE_CODE (orig
))
2434 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2435 case POINTER_TYPE
: case REFERENCE_TYPE
:
2436 return fold_build1_loc (loc
, FLOAT_EXPR
, type
, arg
);
2439 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2441 case FIXED_POINT_TYPE
:
2442 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2445 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2446 return fold_convert_loc (loc
, type
, tem
);
2452 case FIXED_POINT_TYPE
:
2453 if (TREE_CODE (arg
) == FIXED_CST
|| TREE_CODE (arg
) == INTEGER_CST
2454 || TREE_CODE (arg
) == REAL_CST
)
2456 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2457 if (tem
!= NULL_TREE
)
2458 goto fold_convert_exit
;
2461 switch (TREE_CODE (orig
))
2463 case FIXED_POINT_TYPE
:
2468 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2471 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2472 return fold_convert_loc (loc
, type
, tem
);
2479 switch (TREE_CODE (orig
))
2482 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2483 case POINTER_TYPE
: case REFERENCE_TYPE
:
2485 case FIXED_POINT_TYPE
:
2486 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
2487 fold_convert_loc (loc
, TREE_TYPE (type
), arg
),
2488 fold_convert_loc (loc
, TREE_TYPE (type
),
2489 integer_zero_node
));
2494 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
2496 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2497 TREE_OPERAND (arg
, 0));
2498 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2499 TREE_OPERAND (arg
, 1));
2500 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2503 arg
= save_expr (arg
);
2504 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2505 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, TREE_TYPE (orig
), arg
);
2506 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
), rpart
);
2507 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
), ipart
);
2508 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2516 if (integer_zerop (arg
))
2517 return build_zero_vector (type
);
2518 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2519 gcc_assert (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2520 || TREE_CODE (orig
) == VECTOR_TYPE
);
2521 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2524 tem
= fold_ignored_result (arg
);
2525 return fold_build1_loc (loc
, NOP_EXPR
, type
, tem
);
2528 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2529 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2533 protected_set_expr_location_unshare (tem
, loc
);
2537 /* Return false if expr can be assumed not to be an lvalue, true
2541 maybe_lvalue_p (const_tree x
)
2543 /* We only need to wrap lvalue tree codes. */
2544 switch (TREE_CODE (x
))
2557 case ARRAY_RANGE_REF
:
2563 case PREINCREMENT_EXPR
:
2564 case PREDECREMENT_EXPR
:
2566 case TRY_CATCH_EXPR
:
2567 case WITH_CLEANUP_EXPR
:
2576 /* Assume the worst for front-end tree codes. */
2577 if ((int)TREE_CODE (x
) >= NUM_TREE_CODES
)
2585 /* Return an expr equal to X but certainly not valid as an lvalue. */
2588 non_lvalue_loc (location_t loc
, tree x
)
2590 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2595 if (! maybe_lvalue_p (x
))
2597 return build1_loc (loc
, NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
2600 /* When pedantic, return an expr equal to X but certainly not valid as a
2601 pedantic lvalue. Otherwise, return X. */
2604 pedantic_non_lvalue_loc (location_t loc
, tree x
)
2606 return protected_set_expr_location_unshare (x
, loc
);
2609 /* Given a tree comparison code, return the code that is the logical inverse.
2610 It is generally not safe to do this for floating-point comparisons, except
2611 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2612 ERROR_MARK in this case. */
2615 invert_tree_comparison (enum tree_code code
, bool honor_nans
)
2617 if (honor_nans
&& flag_trapping_math
&& code
!= EQ_EXPR
&& code
!= NE_EXPR
2618 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
)
2628 return honor_nans
? UNLE_EXPR
: LE_EXPR
;
2630 return honor_nans
? UNLT_EXPR
: LT_EXPR
;
2632 return honor_nans
? UNGE_EXPR
: GE_EXPR
;
2634 return honor_nans
? UNGT_EXPR
: GT_EXPR
;
2648 return UNORDERED_EXPR
;
2649 case UNORDERED_EXPR
:
2650 return ORDERED_EXPR
;
2656 /* Similar, but return the comparison that results if the operands are
2657 swapped. This is safe for floating-point. */
2660 swap_tree_comparison (enum tree_code code
)
2667 case UNORDERED_EXPR
:
2693 /* Convert a comparison tree code from an enum tree_code representation
2694 into a compcode bit-based encoding. This function is the inverse of
2695 compcode_to_comparison. */
2697 static enum comparison_code
2698 comparison_to_compcode (enum tree_code code
)
2715 return COMPCODE_ORD
;
2716 case UNORDERED_EXPR
:
2717 return COMPCODE_UNORD
;
2719 return COMPCODE_UNLT
;
2721 return COMPCODE_UNEQ
;
2723 return COMPCODE_UNLE
;
2725 return COMPCODE_UNGT
;
2727 return COMPCODE_LTGT
;
2729 return COMPCODE_UNGE
;
2735 /* Convert a compcode bit-based encoding of a comparison operator back
2736 to GCC's enum tree_code representation. This function is the
2737 inverse of comparison_to_compcode. */
2739 static enum tree_code
2740 compcode_to_comparison (enum comparison_code code
)
2757 return ORDERED_EXPR
;
2758 case COMPCODE_UNORD
:
2759 return UNORDERED_EXPR
;
2777 /* Return a tree for the comparison which is the combination of
2778 doing the AND or OR (depending on CODE) of the two operations LCODE
2779 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2780 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2781 if this makes the transformation invalid. */
2784 combine_comparisons (location_t loc
,
2785 enum tree_code code
, enum tree_code lcode
,
2786 enum tree_code rcode
, tree truth_type
,
2787 tree ll_arg
, tree lr_arg
)
2789 bool honor_nans
= HONOR_NANS (ll_arg
);
2790 enum comparison_code lcompcode
= comparison_to_compcode (lcode
);
2791 enum comparison_code rcompcode
= comparison_to_compcode (rcode
);
2796 case TRUTH_AND_EXPR
: case TRUTH_ANDIF_EXPR
:
2797 compcode
= lcompcode
& rcompcode
;
2800 case TRUTH_OR_EXPR
: case TRUTH_ORIF_EXPR
:
2801 compcode
= lcompcode
| rcompcode
;
2810 /* Eliminate unordered comparisons, as well as LTGT and ORD
2811 which are not used unless the mode has NaNs. */
2812 compcode
&= ~COMPCODE_UNORD
;
2813 if (compcode
== COMPCODE_LTGT
)
2814 compcode
= COMPCODE_NE
;
2815 else if (compcode
== COMPCODE_ORD
)
2816 compcode
= COMPCODE_TRUE
;
2818 else if (flag_trapping_math
)
2820 /* Check that the original operation and the optimized ones will trap
2821 under the same condition. */
2822 bool ltrap
= (lcompcode
& COMPCODE_UNORD
) == 0
2823 && (lcompcode
!= COMPCODE_EQ
)
2824 && (lcompcode
!= COMPCODE_ORD
);
2825 bool rtrap
= (rcompcode
& COMPCODE_UNORD
) == 0
2826 && (rcompcode
!= COMPCODE_EQ
)
2827 && (rcompcode
!= COMPCODE_ORD
);
2828 bool trap
= (compcode
& COMPCODE_UNORD
) == 0
2829 && (compcode
!= COMPCODE_EQ
)
2830 && (compcode
!= COMPCODE_ORD
);
2832 /* In a short-circuited boolean expression the LHS might be
2833 such that the RHS, if evaluated, will never trap. For
2834 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2835 if neither x nor y is NaN. (This is a mixed blessing: for
2836 example, the expression above will never trap, hence
2837 optimizing it to x < y would be invalid). */
2838 if ((code
== TRUTH_ORIF_EXPR
&& (lcompcode
& COMPCODE_UNORD
))
2839 || (code
== TRUTH_ANDIF_EXPR
&& !(lcompcode
& COMPCODE_UNORD
)))
2842 /* If the comparison was short-circuited, and only the RHS
2843 trapped, we may now generate a spurious trap. */
2845 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2848 /* If we changed the conditions that cause a trap, we lose. */
2849 if ((ltrap
|| rtrap
) != trap
)
2853 if (compcode
== COMPCODE_TRUE
)
2854 return constant_boolean_node (true, truth_type
);
2855 else if (compcode
== COMPCODE_FALSE
)
2856 return constant_boolean_node (false, truth_type
);
2859 enum tree_code tcode
;
2861 tcode
= compcode_to_comparison ((enum comparison_code
) compcode
);
2862 return fold_build2_loc (loc
, tcode
, truth_type
, ll_arg
, lr_arg
);
2866 /* Return nonzero if two operands (typically of the same tree node)
2867 are necessarily equal. FLAGS modifies behavior as follows:
2869 If OEP_ONLY_CONST is set, only return nonzero for constants.
2870 This function tests whether the operands are indistinguishable;
2871 it does not test whether they are equal using C's == operation.
2872 The distinction is important for IEEE floating point, because
2873 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2874 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2876 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2877 even though it may hold multiple values during a function.
2878 This is because a GCC tree node guarantees that nothing else is
2879 executed between the evaluation of its "operands" (which may often
2880 be evaluated in arbitrary order). Hence if the operands themselves
2881 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2882 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2883 unset means assuming isochronic (or instantaneous) tree equivalence.
2884 Unless comparing arbitrary expression trees, such as from different
2885 statements, this flag can usually be left unset.
2887 If OEP_PURE_SAME is set, then pure functions with identical arguments
2888 are considered the same. It is used when the caller has other ways
2889 to ensure that global memory is unchanged in between.
2891 If OEP_ADDRESS_OF is set, we are actually comparing addresses of objects,
2892 not values of expressions.
2894 If OEP_LEXICOGRAPHIC is set, then also handle expressions with side-effects
2895 such as MODIFY_EXPR, RETURN_EXPR, as well as STATEMENT_LISTs.
2897 Unless OEP_MATCH_SIDE_EFFECTS is set, the function returns false on
2898 any operand with side effect. This is unnecesarily conservative in the
2899 case we know that arg0 and arg1 are in disjoint code paths (such as in
2900 ?: operator). In addition OEP_MATCH_SIDE_EFFECTS is used when comparing
2901 addresses with TREE_CONSTANT flag set so we know that &var == &var
2902 even if var is volatile. */
2905 operand_equal_p (const_tree arg0
, const_tree arg1
, unsigned int flags
)
2907 /* When checking, verify at the outermost operand_equal_p call that
2908 if operand_equal_p returns non-zero then ARG0 and ARG1 has the same
2910 if (flag_checking
&& !(flags
& OEP_NO_HASH_CHECK
))
2912 if (operand_equal_p (arg0
, arg1
, flags
| OEP_NO_HASH_CHECK
))
2916 inchash::hash
hstate0 (0), hstate1 (0);
2917 inchash::add_expr (arg0
, hstate0
, flags
| OEP_HASH_CHECK
);
2918 inchash::add_expr (arg1
, hstate1
, flags
| OEP_HASH_CHECK
);
2919 hashval_t h0
= hstate0
.end ();
2920 hashval_t h1
= hstate1
.end ();
2921 gcc_assert (h0
== h1
);
2929 /* If either is ERROR_MARK, they aren't equal. */
2930 if (TREE_CODE (arg0
) == ERROR_MARK
|| TREE_CODE (arg1
) == ERROR_MARK
2931 || TREE_TYPE (arg0
) == error_mark_node
2932 || TREE_TYPE (arg1
) == error_mark_node
)
2935 /* Similar, if either does not have a type (like a released SSA name),
2936 they aren't equal. */
2937 if (!TREE_TYPE (arg0
) || !TREE_TYPE (arg1
))
2940 /* We cannot consider pointers to different address space equal. */
2941 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
2942 && POINTER_TYPE_P (TREE_TYPE (arg1
))
2943 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
)))
2944 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1
)))))
2947 /* Check equality of integer constants before bailing out due to
2948 precision differences. */
2949 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2951 /* Address of INTEGER_CST is not defined; check that we did not forget
2952 to drop the OEP_ADDRESS_OF flags. */
2953 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
2954 return tree_int_cst_equal (arg0
, arg1
);
2957 if (!(flags
& OEP_ADDRESS_OF
))
2959 /* If both types don't have the same signedness, then we can't consider
2960 them equal. We must check this before the STRIP_NOPS calls
2961 because they may change the signedness of the arguments. As pointers
2962 strictly don't have a signedness, require either two pointers or
2963 two non-pointers as well. */
2964 if (TYPE_UNSIGNED (TREE_TYPE (arg0
)) != TYPE_UNSIGNED (TREE_TYPE (arg1
))
2965 || POINTER_TYPE_P (TREE_TYPE (arg0
))
2966 != POINTER_TYPE_P (TREE_TYPE (arg1
)))
2969 /* If both types don't have the same precision, then it is not safe
2971 if (element_precision (TREE_TYPE (arg0
))
2972 != element_precision (TREE_TYPE (arg1
)))
2979 /* FIXME: Fortran FE currently produce ADDR_EXPR of NOP_EXPR. Enable the
2980 sanity check once the issue is solved. */
2982 /* Addresses of conversions and SSA_NAMEs (and many other things)
2983 are not defined. Check that we did not forget to drop the
2984 OEP_ADDRESS_OF/OEP_CONSTANT_ADDRESS_OF flags. */
2985 gcc_checking_assert (!CONVERT_EXPR_P (arg0
) && !CONVERT_EXPR_P (arg1
)
2986 && TREE_CODE (arg0
) != SSA_NAME
);
2989 /* In case both args are comparisons but with different comparison
2990 code, try to swap the comparison operands of one arg to produce
2991 a match and compare that variant. */
2992 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2993 && COMPARISON_CLASS_P (arg0
)
2994 && COMPARISON_CLASS_P (arg1
))
2996 enum tree_code swap_code
= swap_tree_comparison (TREE_CODE (arg1
));
2998 if (TREE_CODE (arg0
) == swap_code
)
2999 return operand_equal_p (TREE_OPERAND (arg0
, 0),
3000 TREE_OPERAND (arg1
, 1), flags
)
3001 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3002 TREE_OPERAND (arg1
, 0), flags
);
3005 if (TREE_CODE (arg0
) != TREE_CODE (arg1
))
3007 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
3008 if (CONVERT_EXPR_P (arg0
) && CONVERT_EXPR_P (arg1
))
3010 else if (flags
& OEP_ADDRESS_OF
)
3012 /* If we are interested in comparing addresses ignore
3013 MEM_REF wrappings of the base that can appear just for
3015 if (TREE_CODE (arg0
) == MEM_REF
3017 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ADDR_EXPR
3018 && TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0) == arg1
3019 && integer_zerop (TREE_OPERAND (arg0
, 1)))
3021 else if (TREE_CODE (arg1
) == MEM_REF
3023 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ADDR_EXPR
3024 && TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0) == arg0
3025 && integer_zerop (TREE_OPERAND (arg1
, 1)))
3033 /* When not checking adddresses, this is needed for conversions and for
3034 COMPONENT_REF. Might as well play it safe and always test this. */
3035 if (TREE_CODE (TREE_TYPE (arg0
)) == ERROR_MARK
3036 || TREE_CODE (TREE_TYPE (arg1
)) == ERROR_MARK
3037 || (TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
))
3038 && !(flags
& OEP_ADDRESS_OF
)))
3041 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
3042 We don't care about side effects in that case because the SAVE_EXPR
3043 takes care of that for us. In all other cases, two expressions are
3044 equal if they have no side effects. If we have two identical
3045 expressions with side effects that should be treated the same due
3046 to the only side effects being identical SAVE_EXPR's, that will
3047 be detected in the recursive calls below.
3048 If we are taking an invariant address of two identical objects
3049 they are necessarily equal as well. */
3050 if (arg0
== arg1
&& ! (flags
& OEP_ONLY_CONST
)
3051 && (TREE_CODE (arg0
) == SAVE_EXPR
3052 || (flags
& OEP_MATCH_SIDE_EFFECTS
)
3053 || (! TREE_SIDE_EFFECTS (arg0
) && ! TREE_SIDE_EFFECTS (arg1
))))
3056 /* Next handle constant cases, those for which we can return 1 even
3057 if ONLY_CONST is set. */
3058 if (TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
))
3059 switch (TREE_CODE (arg0
))
3062 return tree_int_cst_equal (arg0
, arg1
);
3065 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0
),
3066 TREE_FIXED_CST (arg1
));
3069 if (real_identical (&TREE_REAL_CST (arg0
), &TREE_REAL_CST (arg1
)))
3073 if (!HONOR_SIGNED_ZEROS (arg0
))
3075 /* If we do not distinguish between signed and unsigned zero,
3076 consider them equal. */
3077 if (real_zerop (arg0
) && real_zerop (arg1
))
3084 if (VECTOR_CST_LOG2_NPATTERNS (arg0
)
3085 != VECTOR_CST_LOG2_NPATTERNS (arg1
))
3088 if (VECTOR_CST_NELTS_PER_PATTERN (arg0
)
3089 != VECTOR_CST_NELTS_PER_PATTERN (arg1
))
3092 unsigned int count
= vector_cst_encoded_nelts (arg0
);
3093 for (unsigned int i
= 0; i
< count
; ++i
)
3094 if (!operand_equal_p (VECTOR_CST_ENCODED_ELT (arg0
, i
),
3095 VECTOR_CST_ENCODED_ELT (arg1
, i
), flags
))
3101 return (operand_equal_p (TREE_REALPART (arg0
), TREE_REALPART (arg1
),
3103 && operand_equal_p (TREE_IMAGPART (arg0
), TREE_IMAGPART (arg1
),
3107 return (TREE_STRING_LENGTH (arg0
) == TREE_STRING_LENGTH (arg1
)
3108 && ! memcmp (TREE_STRING_POINTER (arg0
),
3109 TREE_STRING_POINTER (arg1
),
3110 TREE_STRING_LENGTH (arg0
)));
3113 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
3114 return operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0),
3115 flags
| OEP_ADDRESS_OF
3116 | OEP_MATCH_SIDE_EFFECTS
);
3118 /* In GIMPLE empty constructors are allowed in initializers of
3120 return !CONSTRUCTOR_NELTS (arg0
) && !CONSTRUCTOR_NELTS (arg1
);
3125 if (flags
& OEP_ONLY_CONST
)
3128 /* Define macros to test an operand from arg0 and arg1 for equality and a
3129 variant that allows null and views null as being different from any
3130 non-null value. In the latter case, if either is null, the both
3131 must be; otherwise, do the normal comparison. */
3132 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
3133 TREE_OPERAND (arg1, N), flags)
3135 #define OP_SAME_WITH_NULL(N) \
3136 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3137 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3139 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
3142 /* Two conversions are equal only if signedness and modes match. */
3143 switch (TREE_CODE (arg0
))
3146 case FIX_TRUNC_EXPR
:
3147 if (TYPE_UNSIGNED (TREE_TYPE (arg0
))
3148 != TYPE_UNSIGNED (TREE_TYPE (arg1
)))
3158 case tcc_comparison
:
3160 if (OP_SAME (0) && OP_SAME (1))
3163 /* For commutative ops, allow the other order. */
3164 return (commutative_tree_code (TREE_CODE (arg0
))
3165 && operand_equal_p (TREE_OPERAND (arg0
, 0),
3166 TREE_OPERAND (arg1
, 1), flags
)
3167 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3168 TREE_OPERAND (arg1
, 0), flags
));
3171 /* If either of the pointer (or reference) expressions we are
3172 dereferencing contain a side effect, these cannot be equal,
3173 but their addresses can be. */
3174 if ((flags
& OEP_MATCH_SIDE_EFFECTS
) == 0
3175 && (TREE_SIDE_EFFECTS (arg0
)
3176 || TREE_SIDE_EFFECTS (arg1
)))
3179 switch (TREE_CODE (arg0
))
3182 if (!(flags
& OEP_ADDRESS_OF
)
3183 && (TYPE_ALIGN (TREE_TYPE (arg0
))
3184 != TYPE_ALIGN (TREE_TYPE (arg1
))))
3186 flags
&= ~OEP_ADDRESS_OF
;
3190 /* Require the same offset. */
3191 if (!operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3192 TYPE_SIZE (TREE_TYPE (arg1
)),
3193 flags
& ~OEP_ADDRESS_OF
))
3198 case VIEW_CONVERT_EXPR
:
3201 case TARGET_MEM_REF
:
3203 if (!(flags
& OEP_ADDRESS_OF
))
3205 /* Require equal access sizes */
3206 if (TYPE_SIZE (TREE_TYPE (arg0
)) != TYPE_SIZE (TREE_TYPE (arg1
))
3207 && (!TYPE_SIZE (TREE_TYPE (arg0
))
3208 || !TYPE_SIZE (TREE_TYPE (arg1
))
3209 || !operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
3210 TYPE_SIZE (TREE_TYPE (arg1
)),
3213 /* Verify that access happens in similar types. */
3214 if (!types_compatible_p (TREE_TYPE (arg0
), TREE_TYPE (arg1
)))
3216 /* Verify that accesses are TBAA compatible. */
3217 if (!alias_ptr_types_compatible_p
3218 (TREE_TYPE (TREE_OPERAND (arg0
, 1)),
3219 TREE_TYPE (TREE_OPERAND (arg1
, 1)))
3220 || (MR_DEPENDENCE_CLIQUE (arg0
)
3221 != MR_DEPENDENCE_CLIQUE (arg1
))
3222 || (MR_DEPENDENCE_BASE (arg0
)
3223 != MR_DEPENDENCE_BASE (arg1
)))
3225 /* Verify that alignment is compatible. */
3226 if (TYPE_ALIGN (TREE_TYPE (arg0
))
3227 != TYPE_ALIGN (TREE_TYPE (arg1
)))
3230 flags
&= ~OEP_ADDRESS_OF
;
3231 return (OP_SAME (0) && OP_SAME (1)
3232 /* TARGET_MEM_REF require equal extra operands. */
3233 && (TREE_CODE (arg0
) != TARGET_MEM_REF
3234 || (OP_SAME_WITH_NULL (2)
3235 && OP_SAME_WITH_NULL (3)
3236 && OP_SAME_WITH_NULL (4))));
3239 case ARRAY_RANGE_REF
:
3242 flags
&= ~OEP_ADDRESS_OF
;
3243 /* Compare the array index by value if it is constant first as we
3244 may have different types but same value here. */
3245 return ((tree_int_cst_equal (TREE_OPERAND (arg0
, 1),
3246 TREE_OPERAND (arg1
, 1))
3248 && OP_SAME_WITH_NULL (2)
3249 && OP_SAME_WITH_NULL (3)
3250 /* Compare low bound and element size as with OEP_ADDRESS_OF
3251 we have to account for the offset of the ref. */
3252 && (TREE_TYPE (TREE_OPERAND (arg0
, 0))
3253 == TREE_TYPE (TREE_OPERAND (arg1
, 0))
3254 || (operand_equal_p (array_ref_low_bound
3255 (CONST_CAST_TREE (arg0
)),
3257 (CONST_CAST_TREE (arg1
)), flags
)
3258 && operand_equal_p (array_ref_element_size
3259 (CONST_CAST_TREE (arg0
)),
3260 array_ref_element_size
3261 (CONST_CAST_TREE (arg1
)),
3265 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
3266 may be NULL when we're called to compare MEM_EXPRs. */
3267 if (!OP_SAME_WITH_NULL (0)
3270 flags
&= ~OEP_ADDRESS_OF
;
3271 return OP_SAME_WITH_NULL (2);
3276 flags
&= ~OEP_ADDRESS_OF
;
3277 return OP_SAME (1) && OP_SAME (2);
3283 case tcc_expression
:
3284 switch (TREE_CODE (arg0
))
3287 /* Be sure we pass right ADDRESS_OF flag. */
3288 gcc_checking_assert (!(flags
& OEP_ADDRESS_OF
));
3289 return operand_equal_p (TREE_OPERAND (arg0
, 0),
3290 TREE_OPERAND (arg1
, 0),
3291 flags
| OEP_ADDRESS_OF
);
3293 case TRUTH_NOT_EXPR
:
3296 case TRUTH_ANDIF_EXPR
:
3297 case TRUTH_ORIF_EXPR
:
3298 return OP_SAME (0) && OP_SAME (1);
3301 case WIDEN_MULT_PLUS_EXPR
:
3302 case WIDEN_MULT_MINUS_EXPR
:
3305 /* The multiplcation operands are commutative. */
3308 case TRUTH_AND_EXPR
:
3310 case TRUTH_XOR_EXPR
:
3311 if (OP_SAME (0) && OP_SAME (1))
3314 /* Otherwise take into account this is a commutative operation. */
3315 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
3316 TREE_OPERAND (arg1
, 1), flags
)
3317 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3318 TREE_OPERAND (arg1
, 0), flags
));
3321 if (! OP_SAME (1) || ! OP_SAME_WITH_NULL (2))
3323 flags
&= ~OEP_ADDRESS_OF
;
3326 case BIT_INSERT_EXPR
:
3327 /* BIT_INSERT_EXPR has an implict operand as the type precision
3328 of op1. Need to check to make sure they are the same. */
3329 if (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
3330 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
3331 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 1)))
3332 != TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 1))))
3338 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3343 case PREDECREMENT_EXPR
:
3344 case PREINCREMENT_EXPR
:
3345 case POSTDECREMENT_EXPR
:
3346 case POSTINCREMENT_EXPR
:
3347 if (flags
& OEP_LEXICOGRAPHIC
)
3348 return OP_SAME (0) && OP_SAME (1);
3351 case CLEANUP_POINT_EXPR
:
3353 if (flags
& OEP_LEXICOGRAPHIC
)
3362 switch (TREE_CODE (arg0
))
3365 if ((CALL_EXPR_FN (arg0
) == NULL_TREE
)
3366 != (CALL_EXPR_FN (arg1
) == NULL_TREE
))
3367 /* If not both CALL_EXPRs are either internal or normal function
3368 functions, then they are not equal. */
3370 else if (CALL_EXPR_FN (arg0
) == NULL_TREE
)
3372 /* If the CALL_EXPRs call different internal functions, then they
3374 if (CALL_EXPR_IFN (arg0
) != CALL_EXPR_IFN (arg1
))
3379 /* If the CALL_EXPRs call different functions, then they are not
3381 if (! operand_equal_p (CALL_EXPR_FN (arg0
), CALL_EXPR_FN (arg1
),
3386 /* FIXME: We could skip this test for OEP_MATCH_SIDE_EFFECTS. */
3388 unsigned int cef
= call_expr_flags (arg0
);
3389 if (flags
& OEP_PURE_SAME
)
3390 cef
&= ECF_CONST
| ECF_PURE
;
3393 if (!cef
&& !(flags
& OEP_LEXICOGRAPHIC
))
3397 /* Now see if all the arguments are the same. */
3399 const_call_expr_arg_iterator iter0
, iter1
;
3401 for (a0
= first_const_call_expr_arg (arg0
, &iter0
),
3402 a1
= first_const_call_expr_arg (arg1
, &iter1
);
3404 a0
= next_const_call_expr_arg (&iter0
),
3405 a1
= next_const_call_expr_arg (&iter1
))
3406 if (! operand_equal_p (a0
, a1
, flags
))
3409 /* If we get here and both argument lists are exhausted
3410 then the CALL_EXPRs are equal. */
3411 return ! (a0
|| a1
);
3417 case tcc_declaration
:
3418 /* Consider __builtin_sqrt equal to sqrt. */
3419 return (TREE_CODE (arg0
) == FUNCTION_DECL
3420 && DECL_BUILT_IN (arg0
) && DECL_BUILT_IN (arg1
)
3421 && DECL_BUILT_IN_CLASS (arg0
) == DECL_BUILT_IN_CLASS (arg1
)
3422 && DECL_FUNCTION_CODE (arg0
) == DECL_FUNCTION_CODE (arg1
));
3424 case tcc_exceptional
:
3425 if (TREE_CODE (arg0
) == CONSTRUCTOR
)
3427 /* In GIMPLE constructors are used only to build vectors from
3428 elements. Individual elements in the constructor must be
3429 indexed in increasing order and form an initial sequence.
3431 We make no effort to compare constructors in generic.
3432 (see sem_variable::equals in ipa-icf which can do so for
3434 if (!VECTOR_TYPE_P (TREE_TYPE (arg0
))
3435 || !VECTOR_TYPE_P (TREE_TYPE (arg1
)))
3438 /* Be sure that vectors constructed have the same representation.
3439 We only tested element precision and modes to match.
3440 Vectors may be BLKmode and thus also check that the number of
3442 if (maybe_ne (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)),
3443 TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
))))
3446 vec
<constructor_elt
, va_gc
> *v0
= CONSTRUCTOR_ELTS (arg0
);
3447 vec
<constructor_elt
, va_gc
> *v1
= CONSTRUCTOR_ELTS (arg1
);
3448 unsigned int len
= vec_safe_length (v0
);
3450 if (len
!= vec_safe_length (v1
))
3453 for (unsigned int i
= 0; i
< len
; i
++)
3455 constructor_elt
*c0
= &(*v0
)[i
];
3456 constructor_elt
*c1
= &(*v1
)[i
];
3458 if (!operand_equal_p (c0
->value
, c1
->value
, flags
)
3459 /* In GIMPLE the indexes can be either NULL or matching i.
3460 Double check this so we won't get false
3461 positives for GENERIC. */
3463 && (TREE_CODE (c0
->index
) != INTEGER_CST
3464 || !compare_tree_int (c0
->index
, i
)))
3466 && (TREE_CODE (c1
->index
) != INTEGER_CST
3467 || !compare_tree_int (c1
->index
, i
))))
3472 else if (TREE_CODE (arg0
) == STATEMENT_LIST
3473 && (flags
& OEP_LEXICOGRAPHIC
))
3475 /* Compare the STATEMENT_LISTs. */
3476 tree_stmt_iterator tsi1
, tsi2
;
3477 tree body1
= CONST_CAST_TREE (arg0
);
3478 tree body2
= CONST_CAST_TREE (arg1
);
3479 for (tsi1
= tsi_start (body1
), tsi2
= tsi_start (body2
); ;
3480 tsi_next (&tsi1
), tsi_next (&tsi2
))
3482 /* The lists don't have the same number of statements. */
3483 if (tsi_end_p (tsi1
) ^ tsi_end_p (tsi2
))
3485 if (tsi_end_p (tsi1
) && tsi_end_p (tsi2
))
3487 if (!operand_equal_p (tsi_stmt (tsi1
), tsi_stmt (tsi2
),
3488 flags
& (OEP_LEXICOGRAPHIC
3489 | OEP_NO_HASH_CHECK
)))
3496 switch (TREE_CODE (arg0
))
3499 if (flags
& OEP_LEXICOGRAPHIC
)
3500 return OP_SAME_WITH_NULL (0);
3502 case DEBUG_BEGIN_STMT
:
3503 if (flags
& OEP_LEXICOGRAPHIC
)
3515 #undef OP_SAME_WITH_NULL
3518 /* Similar to operand_equal_p, but see if ARG0 might be a variant of ARG1
3519 with a different signedness or a narrower precision. */
3522 operand_equal_for_comparison_p (tree arg0
, tree arg1
)
3524 if (operand_equal_p (arg0
, arg1
, 0))
3527 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
3528 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
3531 /* Discard any conversions that don't change the modes of ARG0 and ARG1
3532 and see if the inner values are the same. This removes any
3533 signedness comparison, which doesn't matter here. */
3538 if (operand_equal_p (op0
, op1
, 0))
3541 /* Discard a single widening conversion from ARG1 and see if the inner
3542 value is the same as ARG0. */
3543 if (CONVERT_EXPR_P (arg1
)
3544 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
3545 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
3546 < TYPE_PRECISION (TREE_TYPE (arg1
))
3547 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
3553 /* See if ARG is an expression that is either a comparison or is performing
3554 arithmetic on comparisons. The comparisons must only be comparing
3555 two different values, which will be stored in *CVAL1 and *CVAL2; if
3556 they are nonzero it means that some operands have already been found.
3557 No variables may be used anywhere else in the expression except in the
3560 If this is true, return 1. Otherwise, return zero. */
3563 twoval_comparison_p (tree arg
, tree
*cval1
, tree
*cval2
)
3565 enum tree_code code
= TREE_CODE (arg
);
3566 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3568 /* We can handle some of the tcc_expression cases here. */
3569 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3571 else if (tclass
== tcc_expression
3572 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
3573 || code
== COMPOUND_EXPR
))
3574 tclass
= tcc_binary
;
3579 return twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
);
3582 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
)
3583 && twoval_comparison_p (TREE_OPERAND (arg
, 1), cval1
, cval2
));
3588 case tcc_expression
:
3589 if (code
== COND_EXPR
)
3590 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
)
3591 && twoval_comparison_p (TREE_OPERAND (arg
, 1), cval1
, cval2
)
3592 && twoval_comparison_p (TREE_OPERAND (arg
, 2), cval1
, cval2
));
3595 case tcc_comparison
:
3596 /* First see if we can handle the first operand, then the second. For
3597 the second operand, we know *CVAL1 can't be zero. It must be that
3598 one side of the comparison is each of the values; test for the
3599 case where this isn't true by failing if the two operands
3602 if (operand_equal_p (TREE_OPERAND (arg
, 0),
3603 TREE_OPERAND (arg
, 1), 0))
3607 *cval1
= TREE_OPERAND (arg
, 0);
3608 else if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 0), 0))
3610 else if (*cval2
== 0)
3611 *cval2
= TREE_OPERAND (arg
, 0);
3612 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 0), 0))
3617 if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 1), 0))
3619 else if (*cval2
== 0)
3620 *cval2
= TREE_OPERAND (arg
, 1);
3621 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 1), 0))
3633 /* ARG is a tree that is known to contain just arithmetic operations and
3634 comparisons. Evaluate the operations in the tree substituting NEW0 for
3635 any occurrence of OLD0 as an operand of a comparison and likewise for
3639 eval_subst (location_t loc
, tree arg
, tree old0
, tree new0
,
3640 tree old1
, tree new1
)
3642 tree type
= TREE_TYPE (arg
);
3643 enum tree_code code
= TREE_CODE (arg
);
3644 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
3646 /* We can handle some of the tcc_expression cases here. */
3647 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
3649 else if (tclass
== tcc_expression
3650 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
3651 tclass
= tcc_binary
;
3656 return fold_build1_loc (loc
, code
, type
,
3657 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3658 old0
, new0
, old1
, new1
));
3661 return fold_build2_loc (loc
, code
, type
,
3662 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3663 old0
, new0
, old1
, new1
),
3664 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3665 old0
, new0
, old1
, new1
));
3667 case tcc_expression
:
3671 return eval_subst (loc
, TREE_OPERAND (arg
, 0), old0
, new0
,
3675 return eval_subst (loc
, TREE_OPERAND (arg
, 1), old0
, new0
,
3679 return fold_build3_loc (loc
, code
, type
,
3680 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3681 old0
, new0
, old1
, new1
),
3682 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3683 old0
, new0
, old1
, new1
),
3684 eval_subst (loc
, TREE_OPERAND (arg
, 2),
3685 old0
, new0
, old1
, new1
));
3689 /* Fall through - ??? */
3691 case tcc_comparison
:
3693 tree arg0
= TREE_OPERAND (arg
, 0);
3694 tree arg1
= TREE_OPERAND (arg
, 1);
3696 /* We need to check both for exact equality and tree equality. The
3697 former will be true if the operand has a side-effect. In that
3698 case, we know the operand occurred exactly once. */
3700 if (arg0
== old0
|| operand_equal_p (arg0
, old0
, 0))
3702 else if (arg0
== old1
|| operand_equal_p (arg0
, old1
, 0))
3705 if (arg1
== old0
|| operand_equal_p (arg1
, old0
, 0))
3707 else if (arg1
== old1
|| operand_equal_p (arg1
, old1
, 0))
3710 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
3718 /* Return a tree for the case when the result of an expression is RESULT
3719 converted to TYPE and OMITTED was previously an operand of the expression
3720 but is now not needed (e.g., we folded OMITTED * 0).
3722 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3723 the conversion of RESULT to TYPE. */
3726 omit_one_operand_loc (location_t loc
, tree type
, tree result
, tree omitted
)
3728 tree t
= fold_convert_loc (loc
, type
, result
);
3730 /* If the resulting operand is an empty statement, just return the omitted
3731 statement casted to void. */
3732 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
3733 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
3734 fold_ignored_result (omitted
));
3736 if (TREE_SIDE_EFFECTS (omitted
))
3737 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3738 fold_ignored_result (omitted
), t
);
3740 return non_lvalue_loc (loc
, t
);
3743 /* Return a tree for the case when the result of an expression is RESULT
3744 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3745 of the expression but are now not needed.
3747 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3748 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3749 evaluated before OMITTED2. Otherwise, if neither has side effects,
3750 just do the conversion of RESULT to TYPE. */
3753 omit_two_operands_loc (location_t loc
, tree type
, tree result
,
3754 tree omitted1
, tree omitted2
)
3756 tree t
= fold_convert_loc (loc
, type
, result
);
3758 if (TREE_SIDE_EFFECTS (omitted2
))
3759 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted2
, t
);
3760 if (TREE_SIDE_EFFECTS (omitted1
))
3761 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted1
, t
);
3763 return TREE_CODE (t
) != COMPOUND_EXPR
? non_lvalue_loc (loc
, t
) : t
;
3767 /* Return a simplified tree node for the truth-negation of ARG. This
3768 never alters ARG itself. We assume that ARG is an operation that
3769 returns a truth value (0 or 1).
3771 FIXME: one would think we would fold the result, but it causes
3772 problems with the dominator optimizer. */
3775 fold_truth_not_expr (location_t loc
, tree arg
)
3777 tree type
= TREE_TYPE (arg
);
3778 enum tree_code code
= TREE_CODE (arg
);
3779 location_t loc1
, loc2
;
3781 /* If this is a comparison, we can simply invert it, except for
3782 floating-point non-equality comparisons, in which case we just
3783 enclose a TRUTH_NOT_EXPR around what we have. */
3785 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3787 tree op_type
= TREE_TYPE (TREE_OPERAND (arg
, 0));
3788 if (FLOAT_TYPE_P (op_type
)
3789 && flag_trapping_math
3790 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
3791 && code
!= NE_EXPR
&& code
!= EQ_EXPR
)
3794 code
= invert_tree_comparison (code
, HONOR_NANS (op_type
));
3795 if (code
== ERROR_MARK
)
3798 tree ret
= build2_loc (loc
, code
, type
, TREE_OPERAND (arg
, 0),
3799 TREE_OPERAND (arg
, 1));
3800 if (TREE_NO_WARNING (arg
))
3801 TREE_NO_WARNING (ret
) = 1;
3808 return constant_boolean_node (integer_zerop (arg
), type
);
3810 case TRUTH_AND_EXPR
:
3811 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3812 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3813 return build2_loc (loc
, TRUTH_OR_EXPR
, type
,
3814 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3815 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3818 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3819 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3820 return build2_loc (loc
, TRUTH_AND_EXPR
, type
,
3821 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3822 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3824 case TRUTH_XOR_EXPR
:
3825 /* Here we can invert either operand. We invert the first operand
3826 unless the second operand is a TRUTH_NOT_EXPR in which case our
3827 result is the XOR of the first operand with the inside of the
3828 negation of the second operand. */
3830 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == TRUTH_NOT_EXPR
)
3831 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
, TREE_OPERAND (arg
, 0),
3832 TREE_OPERAND (TREE_OPERAND (arg
, 1), 0));
3834 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
,
3835 invert_truthvalue_loc (loc
, TREE_OPERAND (arg
, 0)),
3836 TREE_OPERAND (arg
, 1));
3838 case TRUTH_ANDIF_EXPR
:
3839 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3840 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3841 return build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
3842 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3843 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3845 case TRUTH_ORIF_EXPR
:
3846 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3847 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3848 return build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
3849 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3850 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3852 case TRUTH_NOT_EXPR
:
3853 return TREE_OPERAND (arg
, 0);
3857 tree arg1
= TREE_OPERAND (arg
, 1);
3858 tree arg2
= TREE_OPERAND (arg
, 2);
3860 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3861 loc2
= expr_location_or (TREE_OPERAND (arg
, 2), loc
);
3863 /* A COND_EXPR may have a throw as one operand, which
3864 then has void type. Just leave void operands
3866 return build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
3867 VOID_TYPE_P (TREE_TYPE (arg1
))
3868 ? arg1
: invert_truthvalue_loc (loc1
, arg1
),
3869 VOID_TYPE_P (TREE_TYPE (arg2
))
3870 ? arg2
: invert_truthvalue_loc (loc2
, arg2
));
3874 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3875 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3876 TREE_OPERAND (arg
, 0),
3877 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 1)));
3879 case NON_LVALUE_EXPR
:
3880 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3881 return invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0));
3884 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
3885 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3890 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3891 return build1_loc (loc
, TREE_CODE (arg
), type
,
3892 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3895 if (!integer_onep (TREE_OPERAND (arg
, 1)))
3897 return build2_loc (loc
, EQ_EXPR
, type
, arg
, build_int_cst (type
, 0));
3900 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3902 case CLEANUP_POINT_EXPR
:
3903 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3904 return build1_loc (loc
, CLEANUP_POINT_EXPR
, type
,
3905 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3912 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3913 assume that ARG is an operation that returns a truth value (0 or 1
3914 for scalars, 0 or -1 for vectors). Return the folded expression if
3915 folding is successful. Otherwise, return NULL_TREE. */
3918 fold_invert_truthvalue (location_t loc
, tree arg
)
3920 tree type
= TREE_TYPE (arg
);
3921 return fold_unary_loc (loc
, VECTOR_TYPE_P (type
)
3927 /* Return a simplified tree node for the truth-negation of ARG. This
3928 never alters ARG itself. We assume that ARG is an operation that
3929 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3932 invert_truthvalue_loc (location_t loc
, tree arg
)
3934 if (TREE_CODE (arg
) == ERROR_MARK
)
3937 tree type
= TREE_TYPE (arg
);
3938 return fold_build1_loc (loc
, VECTOR_TYPE_P (type
)
3944 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3945 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero
3946 and uses reverse storage order if REVERSEP is nonzero. ORIG_INNER
3947 is the original memory reference used to preserve the alias set of
3951 make_bit_field_ref (location_t loc
, tree inner
, tree orig_inner
, tree type
,
3952 HOST_WIDE_INT bitsize
, poly_int64 bitpos
,
3953 int unsignedp
, int reversep
)
3955 tree result
, bftype
;
3957 /* Attempt not to lose the access path if possible. */
3958 if (TREE_CODE (orig_inner
) == COMPONENT_REF
)
3960 tree ninner
= TREE_OPERAND (orig_inner
, 0);
3962 poly_int64 nbitsize
, nbitpos
;
3964 int nunsignedp
, nreversep
, nvolatilep
= 0;
3965 tree base
= get_inner_reference (ninner
, &nbitsize
, &nbitpos
,
3966 &noffset
, &nmode
, &nunsignedp
,
3967 &nreversep
, &nvolatilep
);
3969 && noffset
== NULL_TREE
3970 && known_subrange_p (bitpos
, bitsize
, nbitpos
, nbitsize
)
3980 alias_set_type iset
= get_alias_set (orig_inner
);
3981 if (iset
== 0 && get_alias_set (inner
) != iset
)
3982 inner
= fold_build2 (MEM_REF
, TREE_TYPE (inner
),
3983 build_fold_addr_expr (inner
),
3984 build_int_cst (ptr_type_node
, 0));
3986 if (known_eq (bitpos
, 0) && !reversep
)
3988 tree size
= TYPE_SIZE (TREE_TYPE (inner
));
3989 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner
))
3990 || POINTER_TYPE_P (TREE_TYPE (inner
)))
3991 && tree_fits_shwi_p (size
)
3992 && tree_to_shwi (size
) == bitsize
)
3993 return fold_convert_loc (loc
, type
, inner
);
3997 if (TYPE_PRECISION (bftype
) != bitsize
3998 || TYPE_UNSIGNED (bftype
) == !unsignedp
)
3999 bftype
= build_nonstandard_integer_type (bitsize
, 0);
4001 result
= build3_loc (loc
, BIT_FIELD_REF
, bftype
, inner
,
4002 bitsize_int (bitsize
), bitsize_int (bitpos
));
4003 REF_REVERSE_STORAGE_ORDER (result
) = reversep
;
4006 result
= fold_convert_loc (loc
, type
, result
);
4011 /* Optimize a bit-field compare.
4013 There are two cases: First is a compare against a constant and the
4014 second is a comparison of two items where the fields are at the same
4015 bit position relative to the start of a chunk (byte, halfword, word)
4016 large enough to contain it. In these cases we can avoid the shift
4017 implicit in bitfield extractions.
4019 For constants, we emit a compare of the shifted constant with the
4020 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
4021 compared. For two fields at the same position, we do the ANDs with the
4022 similar mask and compare the result of the ANDs.
4024 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
4025 COMPARE_TYPE is the type of the comparison, and LHS and RHS
4026 are the left and right operands of the comparison, respectively.
4028 If the optimization described above can be done, we return the resulting
4029 tree. Otherwise we return zero. */
4032 optimize_bit_field_compare (location_t loc
, enum tree_code code
,
4033 tree compare_type
, tree lhs
, tree rhs
)
4035 poly_int64 plbitpos
, plbitsize
, rbitpos
, rbitsize
;
4036 HOST_WIDE_INT lbitpos
, lbitsize
, nbitpos
, nbitsize
;
4037 tree type
= TREE_TYPE (lhs
);
4039 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
4040 machine_mode lmode
, rmode
;
4041 scalar_int_mode nmode
;
4042 int lunsignedp
, runsignedp
;
4043 int lreversep
, rreversep
;
4044 int lvolatilep
= 0, rvolatilep
= 0;
4045 tree linner
, rinner
= NULL_TREE
;
4049 /* Get all the information about the extractions being done. If the bit size
4050 is the same as the size of the underlying object, we aren't doing an
4051 extraction at all and so can do nothing. We also don't want to
4052 do anything if the inner expression is a PLACEHOLDER_EXPR since we
4053 then will no longer be able to replace it. */
4054 linner
= get_inner_reference (lhs
, &plbitsize
, &plbitpos
, &offset
, &lmode
,
4055 &lunsignedp
, &lreversep
, &lvolatilep
);
4057 || !known_size_p (plbitsize
)
4058 || !plbitsize
.is_constant (&lbitsize
)
4059 || !plbitpos
.is_constant (&lbitpos
)
4060 || known_eq (lbitsize
, GET_MODE_BITSIZE (lmode
))
4062 || TREE_CODE (linner
) == PLACEHOLDER_EXPR
4067 rreversep
= lreversep
;
4070 /* If this is not a constant, we can only do something if bit positions,
4071 sizes, signedness and storage order are the same. */
4073 = get_inner_reference (rhs
, &rbitsize
, &rbitpos
, &offset
, &rmode
,
4074 &runsignedp
, &rreversep
, &rvolatilep
);
4077 || maybe_ne (lbitpos
, rbitpos
)
4078 || maybe_ne (lbitsize
, rbitsize
)
4079 || lunsignedp
!= runsignedp
4080 || lreversep
!= rreversep
4082 || TREE_CODE (rinner
) == PLACEHOLDER_EXPR
4087 /* Honor the C++ memory model and mimic what RTL expansion does. */
4088 poly_uint64 bitstart
= 0;
4089 poly_uint64 bitend
= 0;
4090 if (TREE_CODE (lhs
) == COMPONENT_REF
)
4092 get_bit_range (&bitstart
, &bitend
, lhs
, &plbitpos
, &offset
);
4093 if (!plbitpos
.is_constant (&lbitpos
) || offset
!= NULL_TREE
)
4097 /* See if we can find a mode to refer to this field. We should be able to,
4098 but fail if we can't. */
4099 if (!get_best_mode (lbitsize
, lbitpos
, bitstart
, bitend
,
4100 const_p
? TYPE_ALIGN (TREE_TYPE (linner
))
4101 : MIN (TYPE_ALIGN (TREE_TYPE (linner
)),
4102 TYPE_ALIGN (TREE_TYPE (rinner
))),
4103 BITS_PER_WORD
, false, &nmode
))
4106 /* Set signed and unsigned types of the precision of this mode for the
4108 unsigned_type
= lang_hooks
.types
.type_for_mode (nmode
, 1);
4110 /* Compute the bit position and size for the new reference and our offset
4111 within it. If the new reference is the same size as the original, we
4112 won't optimize anything, so return zero. */
4113 nbitsize
= GET_MODE_BITSIZE (nmode
);
4114 nbitpos
= lbitpos
& ~ (nbitsize
- 1);
4116 if (nbitsize
== lbitsize
)
4119 if (lreversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
4120 lbitpos
= nbitsize
- lbitsize
- lbitpos
;
4122 /* Make the mask to be used against the extracted field. */
4123 mask
= build_int_cst_type (unsigned_type
, -1);
4124 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (nbitsize
- lbitsize
));
4125 mask
= const_binop (RSHIFT_EXPR
, mask
,
4126 size_int (nbitsize
- lbitsize
- lbitpos
));
4133 /* If not comparing with constant, just rework the comparison
4135 tree t1
= make_bit_field_ref (loc
, linner
, lhs
, unsigned_type
,
4136 nbitsize
, nbitpos
, 1, lreversep
);
4137 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
, t1
, mask
);
4138 tree t2
= make_bit_field_ref (loc
, rinner
, rhs
, unsigned_type
,
4139 nbitsize
, nbitpos
, 1, rreversep
);
4140 t2
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
, t2
, mask
);
4141 return fold_build2_loc (loc
, code
, compare_type
, t1
, t2
);
4144 /* Otherwise, we are handling the constant case. See if the constant is too
4145 big for the field. Warn and return a tree for 0 (false) if so. We do
4146 this not only for its own sake, but to avoid having to test for this
4147 error case below. If we didn't, we might generate wrong code.
4149 For unsigned fields, the constant shifted right by the field length should
4150 be all zero. For signed fields, the high-order bits should agree with
4155 if (wi::lrshift (wi::to_wide (rhs
), lbitsize
) != 0)
4157 warning (0, "comparison is always %d due to width of bit-field",
4159 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
4164 wide_int tem
= wi::arshift (wi::to_wide (rhs
), lbitsize
- 1);
4165 if (tem
!= 0 && tem
!= -1)
4167 warning (0, "comparison is always %d due to width of bit-field",
4169 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
4176 /* Single-bit compares should always be against zero. */
4177 if (lbitsize
== 1 && ! integer_zerop (rhs
))
4179 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
4180 rhs
= build_int_cst (type
, 0);
4183 /* Make a new bitfield reference, shift the constant over the
4184 appropriate number of bits and mask it with the computed mask
4185 (in case this was a signed field). If we changed it, make a new one. */
4186 lhs
= make_bit_field_ref (loc
, linner
, lhs
, unsigned_type
,
4187 nbitsize
, nbitpos
, 1, lreversep
);
4189 rhs
= const_binop (BIT_AND_EXPR
,
4190 const_binop (LSHIFT_EXPR
,
4191 fold_convert_loc (loc
, unsigned_type
, rhs
),
4192 size_int (lbitpos
)),
4195 lhs
= build2_loc (loc
, code
, compare_type
,
4196 build2 (BIT_AND_EXPR
, unsigned_type
, lhs
, mask
), rhs
);
4200 /* Subroutine for fold_truth_andor_1: decode a field reference.
4202 If EXP is a comparison reference, we return the innermost reference.
4204 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4205 set to the starting bit number.
4207 If the innermost field can be completely contained in a mode-sized
4208 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
4210 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4211 otherwise it is not changed.
4213 *PUNSIGNEDP is set to the signedness of the field.
4215 *PREVERSEP is set to the storage order of the field.
4217 *PMASK is set to the mask used. This is either contained in a
4218 BIT_AND_EXPR or derived from the width of the field.
4220 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4222 Return 0 if this is not a component reference or is one that we can't
4223 do anything with. */
4226 decode_field_reference (location_t loc
, tree
*exp_
, HOST_WIDE_INT
*pbitsize
,
4227 HOST_WIDE_INT
*pbitpos
, machine_mode
*pmode
,
4228 int *punsignedp
, int *preversep
, int *pvolatilep
,
4229 tree
*pmask
, tree
*pand_mask
)
4232 tree outer_type
= 0;
4234 tree mask
, inner
, offset
;
4236 unsigned int precision
;
4238 /* All the optimizations using this function assume integer fields.
4239 There are problems with FP fields since the type_for_size call
4240 below can fail for, e.g., XFmode. */
4241 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp
)))
4244 /* We are interested in the bare arrangement of bits, so strip everything
4245 that doesn't affect the machine mode. However, record the type of the
4246 outermost expression if it may matter below. */
4247 if (CONVERT_EXPR_P (exp
)
4248 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4249 outer_type
= TREE_TYPE (exp
);
4252 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
4254 and_mask
= TREE_OPERAND (exp
, 1);
4255 exp
= TREE_OPERAND (exp
, 0);
4256 STRIP_NOPS (exp
); STRIP_NOPS (and_mask
);
4257 if (TREE_CODE (and_mask
) != INTEGER_CST
)
4261 poly_int64 poly_bitsize
, poly_bitpos
;
4262 inner
= get_inner_reference (exp
, &poly_bitsize
, &poly_bitpos
, &offset
,
4263 pmode
, punsignedp
, preversep
, pvolatilep
);
4264 if ((inner
== exp
&& and_mask
== 0)
4265 || !poly_bitsize
.is_constant (pbitsize
)
4266 || !poly_bitpos
.is_constant (pbitpos
)
4269 || TREE_CODE (inner
) == PLACEHOLDER_EXPR
4270 /* Reject out-of-bound accesses (PR79731). */
4271 || (! AGGREGATE_TYPE_P (TREE_TYPE (inner
))
4272 && compare_tree_int (TYPE_SIZE (TREE_TYPE (inner
)),
4273 *pbitpos
+ *pbitsize
) < 0))
4278 /* If the number of bits in the reference is the same as the bitsize of
4279 the outer type, then the outer type gives the signedness. Otherwise
4280 (in case of a small bitfield) the signedness is unchanged. */
4281 if (outer_type
&& *pbitsize
== TYPE_PRECISION (outer_type
))
4282 *punsignedp
= TYPE_UNSIGNED (outer_type
);
4284 /* Compute the mask to access the bitfield. */
4285 unsigned_type
= lang_hooks
.types
.type_for_size (*pbitsize
, 1);
4286 precision
= TYPE_PRECISION (unsigned_type
);
4288 mask
= build_int_cst_type (unsigned_type
, -1);
4290 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4291 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
4293 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
4295 mask
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
4296 fold_convert_loc (loc
, unsigned_type
, and_mask
), mask
);
4299 *pand_mask
= and_mask
;
4303 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4304 bit positions and MASK is SIGNED. */
4307 all_ones_mask_p (const_tree mask
, unsigned int size
)
4309 tree type
= TREE_TYPE (mask
);
4310 unsigned int precision
= TYPE_PRECISION (type
);
4312 /* If this function returns true when the type of the mask is
4313 UNSIGNED, then there will be errors. In particular see
4314 gcc.c-torture/execute/990326-1.c. There does not appear to be
4315 any documentation paper trail as to why this is so. But the pre
4316 wide-int worked with that restriction and it has been preserved
4318 if (size
> precision
|| TYPE_SIGN (type
) == UNSIGNED
)
4321 return wi::mask (size
, false, precision
) == wi::to_wide (mask
);
4324 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4325 represents the sign bit of EXP's type. If EXP represents a sign
4326 or zero extension, also test VAL against the unextended type.
4327 The return value is the (sub)expression whose sign bit is VAL,
4328 or NULL_TREE otherwise. */
4331 sign_bit_p (tree exp
, const_tree val
)
4336 /* Tree EXP must have an integral type. */
4337 t
= TREE_TYPE (exp
);
4338 if (! INTEGRAL_TYPE_P (t
))
4341 /* Tree VAL must be an integer constant. */
4342 if (TREE_CODE (val
) != INTEGER_CST
4343 || TREE_OVERFLOW (val
))
4346 width
= TYPE_PRECISION (t
);
4347 if (wi::only_sign_bit_p (wi::to_wide (val
), width
))
4350 /* Handle extension from a narrower type. */
4351 if (TREE_CODE (exp
) == NOP_EXPR
4352 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))) < width
)
4353 return sign_bit_p (TREE_OPERAND (exp
, 0), val
);
4358 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
4359 to be evaluated unconditionally. */
4362 simple_operand_p (const_tree exp
)
4364 /* Strip any conversions that don't change the machine mode. */
4367 return (CONSTANT_CLASS_P (exp
)
4368 || TREE_CODE (exp
) == SSA_NAME
4370 && ! TREE_ADDRESSABLE (exp
)
4371 && ! TREE_THIS_VOLATILE (exp
)
4372 && ! DECL_NONLOCAL (exp
)
4373 /* Don't regard global variables as simple. They may be
4374 allocated in ways unknown to the compiler (shared memory,
4375 #pragma weak, etc). */
4376 && ! TREE_PUBLIC (exp
)
4377 && ! DECL_EXTERNAL (exp
)
4378 /* Weakrefs are not safe to be read, since they can be NULL.
4379 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
4380 have DECL_WEAK flag set. */
4381 && (! VAR_OR_FUNCTION_DECL_P (exp
) || ! DECL_WEAK (exp
))
4382 /* Loading a static variable is unduly expensive, but global
4383 registers aren't expensive. */
4384 && (! TREE_STATIC (exp
) || DECL_REGISTER (exp
))));
4387 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
4388 to be evaluated unconditionally.
4389 I addition to simple_operand_p, we assume that comparisons, conversions,
4390 and logic-not operations are simple, if their operands are simple, too. */
4393 simple_operand_p_2 (tree exp
)
4395 enum tree_code code
;
4397 if (TREE_SIDE_EFFECTS (exp
)
4398 || tree_could_trap_p (exp
))
4401 while (CONVERT_EXPR_P (exp
))
4402 exp
= TREE_OPERAND (exp
, 0);
4404 code
= TREE_CODE (exp
);
4406 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
4407 return (simple_operand_p (TREE_OPERAND (exp
, 0))
4408 && simple_operand_p (TREE_OPERAND (exp
, 1)));
4410 if (code
== TRUTH_NOT_EXPR
)
4411 return simple_operand_p_2 (TREE_OPERAND (exp
, 0));
4413 return simple_operand_p (exp
);
4417 /* The following functions are subroutines to fold_range_test and allow it to
4418 try to change a logical combination of comparisons into a range test.
4421 X == 2 || X == 3 || X == 4 || X == 5
4425 (unsigned) (X - 2) <= 3
4427 We describe each set of comparisons as being either inside or outside
4428 a range, using a variable named like IN_P, and then describe the
4429 range with a lower and upper bound. If one of the bounds is omitted,
4430 it represents either the highest or lowest value of the type.
4432 In the comments below, we represent a range by two numbers in brackets
4433 preceded by a "+" to designate being inside that range, or a "-" to
4434 designate being outside that range, so the condition can be inverted by
4435 flipping the prefix. An omitted bound is represented by a "-". For
4436 example, "- [-, 10]" means being outside the range starting at the lowest
4437 possible value and ending at 10, in other words, being greater than 10.
4438 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4441 We set up things so that the missing bounds are handled in a consistent
4442 manner so neither a missing bound nor "true" and "false" need to be
4443 handled using a special case. */
4445 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4446 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4447 and UPPER1_P are nonzero if the respective argument is an upper bound
4448 and zero for a lower. TYPE, if nonzero, is the type of the result; it
4449 must be specified for a comparison. ARG1 will be converted to ARG0's
4450 type if both are specified. */
4453 range_binop (enum tree_code code
, tree type
, tree arg0
, int upper0_p
,
4454 tree arg1
, int upper1_p
)
4460 /* If neither arg represents infinity, do the normal operation.
4461 Else, if not a comparison, return infinity. Else handle the special
4462 comparison rules. Note that most of the cases below won't occur, but
4463 are handled for consistency. */
4465 if (arg0
!= 0 && arg1
!= 0)
4467 tem
= fold_build2 (code
, type
!= 0 ? type
: TREE_TYPE (arg0
),
4468 arg0
, fold_convert (TREE_TYPE (arg0
), arg1
));
4470 return TREE_CODE (tem
) == INTEGER_CST
? tem
: 0;
4473 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
4476 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4477 for neither. In real maths, we cannot assume open ended ranges are
4478 the same. But, this is computer arithmetic, where numbers are finite.
4479 We can therefore make the transformation of any unbounded range with
4480 the value Z, Z being greater than any representable number. This permits
4481 us to treat unbounded ranges as equal. */
4482 sgn0
= arg0
!= 0 ? 0 : (upper0_p
? 1 : -1);
4483 sgn1
= arg1
!= 0 ? 0 : (upper1_p
? 1 : -1);
4487 result
= sgn0
== sgn1
;
4490 result
= sgn0
!= sgn1
;
4493 result
= sgn0
< sgn1
;
4496 result
= sgn0
<= sgn1
;
4499 result
= sgn0
> sgn1
;
4502 result
= sgn0
>= sgn1
;
4508 return constant_boolean_node (result
, type
);
4511 /* Helper routine for make_range. Perform one step for it, return
4512 new expression if the loop should continue or NULL_TREE if it should
4516 make_range_step (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
,
4517 tree exp_type
, tree
*p_low
, tree
*p_high
, int *p_in_p
,
4518 bool *strict_overflow_p
)
4520 tree arg0_type
= TREE_TYPE (arg0
);
4521 tree n_low
, n_high
, low
= *p_low
, high
= *p_high
;
4522 int in_p
= *p_in_p
, n_in_p
;
4526 case TRUTH_NOT_EXPR
:
4527 /* We can only do something if the range is testing for zero. */
4528 if (low
== NULL_TREE
|| high
== NULL_TREE
4529 || ! integer_zerop (low
) || ! integer_zerop (high
))
4534 case EQ_EXPR
: case NE_EXPR
:
4535 case LT_EXPR
: case LE_EXPR
: case GE_EXPR
: case GT_EXPR
:
4536 /* We can only do something if the range is testing for zero
4537 and if the second operand is an integer constant. Note that
4538 saying something is "in" the range we make is done by
4539 complementing IN_P since it will set in the initial case of
4540 being not equal to zero; "out" is leaving it alone. */
4541 if (low
== NULL_TREE
|| high
== NULL_TREE
4542 || ! integer_zerop (low
) || ! integer_zerop (high
)
4543 || TREE_CODE (arg1
) != INTEGER_CST
)
4548 case NE_EXPR
: /* - [c, c] */
4551 case EQ_EXPR
: /* + [c, c] */
4552 in_p
= ! in_p
, low
= high
= arg1
;
4554 case GT_EXPR
: /* - [-, c] */
4555 low
= 0, high
= arg1
;
4557 case GE_EXPR
: /* + [c, -] */
4558 in_p
= ! in_p
, low
= arg1
, high
= 0;
4560 case LT_EXPR
: /* - [c, -] */
4561 low
= arg1
, high
= 0;
4563 case LE_EXPR
: /* + [-, c] */
4564 in_p
= ! in_p
, low
= 0, high
= arg1
;
4570 /* If this is an unsigned comparison, we also know that EXP is
4571 greater than or equal to zero. We base the range tests we make
4572 on that fact, so we record it here so we can parse existing
4573 range tests. We test arg0_type since often the return type
4574 of, e.g. EQ_EXPR, is boolean. */
4575 if (TYPE_UNSIGNED (arg0_type
) && (low
== 0 || high
== 0))
4577 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
4579 build_int_cst (arg0_type
, 0),
4583 in_p
= n_in_p
, low
= n_low
, high
= n_high
;
4585 /* If the high bound is missing, but we have a nonzero low
4586 bound, reverse the range so it goes from zero to the low bound
4588 if (high
== 0 && low
&& ! integer_zerop (low
))
4591 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low
, 0,
4592 build_int_cst (TREE_TYPE (low
), 1), 0);
4593 low
= build_int_cst (arg0_type
, 0);
4603 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4604 low and high are non-NULL, then normalize will DTRT. */
4605 if (!TYPE_UNSIGNED (arg0_type
)
4606 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4608 if (low
== NULL_TREE
)
4609 low
= TYPE_MIN_VALUE (arg0_type
);
4610 if (high
== NULL_TREE
)
4611 high
= TYPE_MAX_VALUE (arg0_type
);
4614 /* (-x) IN [a,b] -> x in [-b, -a] */
4615 n_low
= range_binop (MINUS_EXPR
, exp_type
,
4616 build_int_cst (exp_type
, 0),
4618 n_high
= range_binop (MINUS_EXPR
, exp_type
,
4619 build_int_cst (exp_type
, 0),
4621 if (n_high
!= 0 && TREE_OVERFLOW (n_high
))
4627 return build2_loc (loc
, MINUS_EXPR
, exp_type
, negate_expr (arg0
),
4628 build_int_cst (exp_type
, 1));
4632 if (TREE_CODE (arg1
) != INTEGER_CST
)
4635 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4636 move a constant to the other side. */
4637 if (!TYPE_UNSIGNED (arg0_type
)
4638 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4641 /* If EXP is signed, any overflow in the computation is undefined,
4642 so we don't worry about it so long as our computations on
4643 the bounds don't overflow. For unsigned, overflow is defined
4644 and this is exactly the right thing. */
4645 n_low
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4646 arg0_type
, low
, 0, arg1
, 0);
4647 n_high
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4648 arg0_type
, high
, 1, arg1
, 0);
4649 if ((n_low
!= 0 && TREE_OVERFLOW (n_low
))
4650 || (n_high
!= 0 && TREE_OVERFLOW (n_high
)))
4653 if (TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4654 *strict_overflow_p
= true;
4657 /* Check for an unsigned range which has wrapped around the maximum
4658 value thus making n_high < n_low, and normalize it. */
4659 if (n_low
&& n_high
&& tree_int_cst_lt (n_high
, n_low
))
4661 low
= range_binop (PLUS_EXPR
, arg0_type
, n_high
, 0,
4662 build_int_cst (TREE_TYPE (n_high
), 1), 0);
4663 high
= range_binop (MINUS_EXPR
, arg0_type
, n_low
, 0,
4664 build_int_cst (TREE_TYPE (n_low
), 1), 0);
4666 /* If the range is of the form +/- [ x+1, x ], we won't
4667 be able to normalize it. But then, it represents the
4668 whole range or the empty set, so make it
4670 if (tree_int_cst_equal (n_low
, low
)
4671 && tree_int_cst_equal (n_high
, high
))
4677 low
= n_low
, high
= n_high
;
4685 case NON_LVALUE_EXPR
:
4686 if (TYPE_PRECISION (arg0_type
) > TYPE_PRECISION (exp_type
))
4689 if (! INTEGRAL_TYPE_P (arg0_type
)
4690 || (low
!= 0 && ! int_fits_type_p (low
, arg0_type
))
4691 || (high
!= 0 && ! int_fits_type_p (high
, arg0_type
)))
4694 n_low
= low
, n_high
= high
;
4697 n_low
= fold_convert_loc (loc
, arg0_type
, n_low
);
4700 n_high
= fold_convert_loc (loc
, arg0_type
, n_high
);
4702 /* If we're converting arg0 from an unsigned type, to exp,
4703 a signed type, we will be doing the comparison as unsigned.
4704 The tests above have already verified that LOW and HIGH
4707 So we have to ensure that we will handle large unsigned
4708 values the same way that the current signed bounds treat
4711 if (!TYPE_UNSIGNED (exp_type
) && TYPE_UNSIGNED (arg0_type
))
4715 /* For fixed-point modes, we need to pass the saturating flag
4716 as the 2nd parameter. */
4717 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type
)))
4719 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
),
4720 TYPE_SATURATING (arg0_type
));
4723 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
), 1);
4725 /* A range without an upper bound is, naturally, unbounded.
4726 Since convert would have cropped a very large value, use
4727 the max value for the destination type. */
4729 = TYPE_MAX_VALUE (equiv_type
) ? TYPE_MAX_VALUE (equiv_type
)
4730 : TYPE_MAX_VALUE (arg0_type
);
4732 if (TYPE_PRECISION (exp_type
) == TYPE_PRECISION (arg0_type
))
4733 high_positive
= fold_build2_loc (loc
, RSHIFT_EXPR
, arg0_type
,
4734 fold_convert_loc (loc
, arg0_type
,
4736 build_int_cst (arg0_type
, 1));
4738 /* If the low bound is specified, "and" the range with the
4739 range for which the original unsigned value will be
4743 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 1, n_low
, n_high
,
4744 1, fold_convert_loc (loc
, arg0_type
,
4749 in_p
= (n_in_p
== in_p
);
4753 /* Otherwise, "or" the range with the range of the input
4754 that will be interpreted as negative. */
4755 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 0, n_low
, n_high
,
4756 1, fold_convert_loc (loc
, arg0_type
,
4761 in_p
= (in_p
!= n_in_p
);
4775 /* Given EXP, a logical expression, set the range it is testing into
4776 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4777 actually being tested. *PLOW and *PHIGH will be made of the same
4778 type as the returned expression. If EXP is not a comparison, we
4779 will most likely not be returning a useful value and range. Set
4780 *STRICT_OVERFLOW_P to true if the return value is only valid
4781 because signed overflow is undefined; otherwise, do not change
4782 *STRICT_OVERFLOW_P. */
4785 make_range (tree exp
, int *pin_p
, tree
*plow
, tree
*phigh
,
4786 bool *strict_overflow_p
)
4788 enum tree_code code
;
4789 tree arg0
, arg1
= NULL_TREE
;
4790 tree exp_type
, nexp
;
4793 location_t loc
= EXPR_LOCATION (exp
);
4795 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4796 and see if we can refine the range. Some of the cases below may not
4797 happen, but it doesn't seem worth worrying about this. We "continue"
4798 the outer loop when we've changed something; otherwise we "break"
4799 the switch, which will "break" the while. */
4802 low
= high
= build_int_cst (TREE_TYPE (exp
), 0);
4806 code
= TREE_CODE (exp
);
4807 exp_type
= TREE_TYPE (exp
);
4810 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
4812 if (TREE_OPERAND_LENGTH (exp
) > 0)
4813 arg0
= TREE_OPERAND (exp
, 0);
4814 if (TREE_CODE_CLASS (code
) == tcc_binary
4815 || TREE_CODE_CLASS (code
) == tcc_comparison
4816 || (TREE_CODE_CLASS (code
) == tcc_expression
4817 && TREE_OPERAND_LENGTH (exp
) > 1))
4818 arg1
= TREE_OPERAND (exp
, 1);
4820 if (arg0
== NULL_TREE
)
4823 nexp
= make_range_step (loc
, code
, arg0
, arg1
, exp_type
, &low
,
4824 &high
, &in_p
, strict_overflow_p
);
4825 if (nexp
== NULL_TREE
)
4830 /* If EXP is a constant, we can evaluate whether this is true or false. */
4831 if (TREE_CODE (exp
) == INTEGER_CST
)
4833 in_p
= in_p
== (integer_onep (range_binop (GE_EXPR
, integer_type_node
,
4835 && integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4841 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4845 /* Returns TRUE if [LOW, HIGH] range check can be optimized to
4846 a bitwise check i.e. when
4847 LOW == 0xXX...X00...0
4848 HIGH == 0xXX...X11...1
4849 Return corresponding mask in MASK and stem in VALUE. */
4852 maskable_range_p (const_tree low
, const_tree high
, tree type
, tree
*mask
,
4855 if (TREE_CODE (low
) != INTEGER_CST
4856 || TREE_CODE (high
) != INTEGER_CST
)
4859 unsigned prec
= TYPE_PRECISION (type
);
4860 wide_int lo
= wi::to_wide (low
, prec
);
4861 wide_int hi
= wi::to_wide (high
, prec
);
4863 wide_int end_mask
= lo
^ hi
;
4864 if ((end_mask
& (end_mask
+ 1)) != 0
4865 || (lo
& end_mask
) != 0)
4868 wide_int stem_mask
= ~end_mask
;
4869 wide_int stem
= lo
& stem_mask
;
4870 if (stem
!= (hi
& stem_mask
))
4873 *mask
= wide_int_to_tree (type
, stem_mask
);
4874 *value
= wide_int_to_tree (type
, stem
);
4879 /* Helper routine for build_range_check and match.pd. Return the type to
4880 perform the check or NULL if it shouldn't be optimized. */
4883 range_check_type (tree etype
)
4885 /* First make sure that arithmetics in this type is valid, then make sure
4886 that it wraps around. */
4887 if (TREE_CODE (etype
) == ENUMERAL_TYPE
|| TREE_CODE (etype
) == BOOLEAN_TYPE
)
4888 etype
= lang_hooks
.types
.type_for_size (TYPE_PRECISION (etype
),
4889 TYPE_UNSIGNED (etype
));
4891 if (TREE_CODE (etype
) == INTEGER_TYPE
&& !TYPE_OVERFLOW_WRAPS (etype
))
4893 tree utype
, minv
, maxv
;
4895 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4896 for the type in question, as we rely on this here. */
4897 utype
= unsigned_type_for (etype
);
4898 maxv
= fold_convert (utype
, TYPE_MAX_VALUE (etype
));
4899 maxv
= range_binop (PLUS_EXPR
, NULL_TREE
, maxv
, 1,
4900 build_int_cst (TREE_TYPE (maxv
), 1), 1);
4901 minv
= fold_convert (utype
, TYPE_MIN_VALUE (etype
));
4903 if (integer_zerop (range_binop (NE_EXPR
, integer_type_node
,
4912 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4913 type, TYPE, return an expression to test if EXP is in (or out of, depending
4914 on IN_P) the range. Return 0 if the test couldn't be created. */
4917 build_range_check (location_t loc
, tree type
, tree exp
, int in_p
,
4918 tree low
, tree high
)
4920 tree etype
= TREE_TYPE (exp
), mask
, value
;
4922 /* Disable this optimization for function pointer expressions
4923 on targets that require function pointer canonicalization. */
4924 if (targetm
.have_canonicalize_funcptr_for_compare ()
4925 && POINTER_TYPE_P (etype
)
4926 && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (etype
)))
4931 value
= build_range_check (loc
, type
, exp
, 1, low
, high
);
4933 return invert_truthvalue_loc (loc
, value
);
4938 if (low
== 0 && high
== 0)
4939 return omit_one_operand_loc (loc
, type
, build_int_cst (type
, 1), exp
);
4942 return fold_build2_loc (loc
, LE_EXPR
, type
, exp
,
4943 fold_convert_loc (loc
, etype
, high
));
4946 return fold_build2_loc (loc
, GE_EXPR
, type
, exp
,
4947 fold_convert_loc (loc
, etype
, low
));
4949 if (operand_equal_p (low
, high
, 0))
4950 return fold_build2_loc (loc
, EQ_EXPR
, type
, exp
,
4951 fold_convert_loc (loc
, etype
, low
));
4953 if (TREE_CODE (exp
) == BIT_AND_EXPR
4954 && maskable_range_p (low
, high
, etype
, &mask
, &value
))
4955 return fold_build2_loc (loc
, EQ_EXPR
, type
,
4956 fold_build2_loc (loc
, BIT_AND_EXPR
, etype
,
4960 if (integer_zerop (low
))
4962 if (! TYPE_UNSIGNED (etype
))
4964 etype
= unsigned_type_for (etype
);
4965 high
= fold_convert_loc (loc
, etype
, high
);
4966 exp
= fold_convert_loc (loc
, etype
, exp
);
4968 return build_range_check (loc
, type
, exp
, 1, 0, high
);
4971 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4972 if (integer_onep (low
) && TREE_CODE (high
) == INTEGER_CST
)
4974 int prec
= TYPE_PRECISION (etype
);
4976 if (wi::mask
<widest_int
> (prec
- 1, false) == wi::to_widest (high
))
4978 if (TYPE_UNSIGNED (etype
))
4980 tree signed_etype
= signed_type_for (etype
);
4981 if (TYPE_PRECISION (signed_etype
) != TYPE_PRECISION (etype
))
4983 = build_nonstandard_integer_type (TYPE_PRECISION (etype
), 0);
4985 etype
= signed_etype
;
4986 exp
= fold_convert_loc (loc
, etype
, exp
);
4988 return fold_build2_loc (loc
, GT_EXPR
, type
, exp
,
4989 build_int_cst (etype
, 0));
4993 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4994 This requires wrap-around arithmetics for the type of the expression. */
4995 etype
= range_check_type (etype
);
4996 if (etype
== NULL_TREE
)
4999 if (POINTER_TYPE_P (etype
))
5000 etype
= unsigned_type_for (etype
);
5002 high
= fold_convert_loc (loc
, etype
, high
);
5003 low
= fold_convert_loc (loc
, etype
, low
);
5004 exp
= fold_convert_loc (loc
, etype
, exp
);
5006 value
= const_binop (MINUS_EXPR
, high
, low
);
5008 if (value
!= 0 && !TREE_OVERFLOW (value
))
5009 return build_range_check (loc
, type
,
5010 fold_build2_loc (loc
, MINUS_EXPR
, etype
, exp
, low
),
5011 1, build_int_cst (etype
, 0), value
);
5016 /* Return the predecessor of VAL in its type, handling the infinite case. */
5019 range_predecessor (tree val
)
5021 tree type
= TREE_TYPE (val
);
5023 if (INTEGRAL_TYPE_P (type
)
5024 && operand_equal_p (val
, TYPE_MIN_VALUE (type
), 0))
5027 return range_binop (MINUS_EXPR
, NULL_TREE
, val
, 0,
5028 build_int_cst (TREE_TYPE (val
), 1), 0);
5031 /* Return the successor of VAL in its type, handling the infinite case. */
5034 range_successor (tree val
)
5036 tree type
= TREE_TYPE (val
);
5038 if (INTEGRAL_TYPE_P (type
)
5039 && operand_equal_p (val
, TYPE_MAX_VALUE (type
), 0))
5042 return range_binop (PLUS_EXPR
, NULL_TREE
, val
, 0,
5043 build_int_cst (TREE_TYPE (val
), 1), 0);
5046 /* Given two ranges, see if we can merge them into one. Return 1 if we
5047 can, 0 if we can't. Set the output range into the specified parameters. */
5050 merge_ranges (int *pin_p
, tree
*plow
, tree
*phigh
, int in0_p
, tree low0
,
5051 tree high0
, int in1_p
, tree low1
, tree high1
)
5059 int lowequal
= ((low0
== 0 && low1
== 0)
5060 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
5061 low0
, 0, low1
, 0)));
5062 int highequal
= ((high0
== 0 && high1
== 0)
5063 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
5064 high0
, 1, high1
, 1)));
5066 /* Make range 0 be the range that starts first, or ends last if they
5067 start at the same value. Swap them if it isn't. */
5068 if (integer_onep (range_binop (GT_EXPR
, integer_type_node
,
5071 && integer_onep (range_binop (GT_EXPR
, integer_type_node
,
5072 high1
, 1, high0
, 1))))
5074 temp
= in0_p
, in0_p
= in1_p
, in1_p
= temp
;
5075 tem
= low0
, low0
= low1
, low1
= tem
;
5076 tem
= high0
, high0
= high1
, high1
= tem
;
5079 /* Now flag two cases, whether the ranges are disjoint or whether the
5080 second range is totally subsumed in the first. Note that the tests
5081 below are simplified by the ones above. */
5082 no_overlap
= integer_onep (range_binop (LT_EXPR
, integer_type_node
,
5083 high0
, 1, low1
, 0));
5084 subset
= integer_onep (range_binop (LE_EXPR
, integer_type_node
,
5085 high1
, 1, high0
, 1));
5087 /* We now have four cases, depending on whether we are including or
5088 excluding the two ranges. */
5091 /* If they don't overlap, the result is false. If the second range
5092 is a subset it is the result. Otherwise, the range is from the start
5093 of the second to the end of the first. */
5095 in_p
= 0, low
= high
= 0;
5097 in_p
= 1, low
= low1
, high
= high1
;
5099 in_p
= 1, low
= low1
, high
= high0
;
5102 else if (in0_p
&& ! in1_p
)
5104 /* If they don't overlap, the result is the first range. If they are
5105 equal, the result is false. If the second range is a subset of the
5106 first, and the ranges begin at the same place, we go from just after
5107 the end of the second range to the end of the first. If the second
5108 range is not a subset of the first, or if it is a subset and both
5109 ranges end at the same place, the range starts at the start of the
5110 first range and ends just before the second range.
5111 Otherwise, we can't describe this as a single range. */
5113 in_p
= 1, low
= low0
, high
= high0
;
5114 else if (lowequal
&& highequal
)
5115 in_p
= 0, low
= high
= 0;
5116 else if (subset
&& lowequal
)
5118 low
= range_successor (high1
);
5123 /* We are in the weird situation where high0 > high1 but
5124 high1 has no successor. Punt. */
5128 else if (! subset
|| highequal
)
5131 high
= range_predecessor (low1
);
5135 /* low0 < low1 but low1 has no predecessor. Punt. */
5143 else if (! in0_p
&& in1_p
)
5145 /* If they don't overlap, the result is the second range. If the second
5146 is a subset of the first, the result is false. Otherwise,
5147 the range starts just after the first range and ends at the
5148 end of the second. */
5150 in_p
= 1, low
= low1
, high
= high1
;
5151 else if (subset
|| highequal
)
5152 in_p
= 0, low
= high
= 0;
5155 low
= range_successor (high0
);
5160 /* high1 > high0 but high0 has no successor. Punt. */
5168 /* The case where we are excluding both ranges. Here the complex case
5169 is if they don't overlap. In that case, the only time we have a
5170 range is if they are adjacent. If the second is a subset of the
5171 first, the result is the first. Otherwise, the range to exclude
5172 starts at the beginning of the first range and ends at the end of the
5176 if (integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
5177 range_successor (high0
),
5179 in_p
= 0, low
= low0
, high
= high1
;
5182 /* Canonicalize - [min, x] into - [-, x]. */
5183 if (low0
&& TREE_CODE (low0
) == INTEGER_CST
)
5184 switch (TREE_CODE (TREE_TYPE (low0
)))
5187 if (maybe_ne (TYPE_PRECISION (TREE_TYPE (low0
)),
5189 (TYPE_MODE (TREE_TYPE (low0
)))))
5193 if (tree_int_cst_equal (low0
,
5194 TYPE_MIN_VALUE (TREE_TYPE (low0
))))
5198 if (TYPE_UNSIGNED (TREE_TYPE (low0
))
5199 && integer_zerop (low0
))
5206 /* Canonicalize - [x, max] into - [x, -]. */
5207 if (high1
&& TREE_CODE (high1
) == INTEGER_CST
)
5208 switch (TREE_CODE (TREE_TYPE (high1
)))
5211 if (maybe_ne (TYPE_PRECISION (TREE_TYPE (high1
)),
5213 (TYPE_MODE (TREE_TYPE (high1
)))))
5217 if (tree_int_cst_equal (high1
,
5218 TYPE_MAX_VALUE (TREE_TYPE (high1
))))
5222 if (TYPE_UNSIGNED (TREE_TYPE (high1
))
5223 && integer_zerop (range_binop (PLUS_EXPR
, NULL_TREE
,
5225 build_int_cst (TREE_TYPE (high1
), 1),
5233 /* The ranges might be also adjacent between the maximum and
5234 minimum values of the given type. For
5235 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
5236 return + [x + 1, y - 1]. */
5237 if (low0
== 0 && high1
== 0)
5239 low
= range_successor (high0
);
5240 high
= range_predecessor (low1
);
5241 if (low
== 0 || high
== 0)
5251 in_p
= 0, low
= low0
, high
= high0
;
5253 in_p
= 0, low
= low0
, high
= high1
;
5256 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
5261 /* Subroutine of fold, looking inside expressions of the form
5262 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5263 of the COND_EXPR. This function is being used also to optimize
5264 A op B ? C : A, by reversing the comparison first.
5266 Return a folded expression whose code is not a COND_EXPR
5267 anymore, or NULL_TREE if no folding opportunity is found. */
5270 fold_cond_expr_with_comparison (location_t loc
, tree type
,
5271 tree arg0
, tree arg1
, tree arg2
)
5273 enum tree_code comp_code
= TREE_CODE (arg0
);
5274 tree arg00
= TREE_OPERAND (arg0
, 0);
5275 tree arg01
= TREE_OPERAND (arg0
, 1);
5276 tree arg1_type
= TREE_TYPE (arg1
);
5282 /* If we have A op 0 ? A : -A, consider applying the following
5285 A == 0? A : -A same as -A
5286 A != 0? A : -A same as A
5287 A >= 0? A : -A same as abs (A)
5288 A > 0? A : -A same as abs (A)
5289 A <= 0? A : -A same as -abs (A)
5290 A < 0? A : -A same as -abs (A)
5292 None of these transformations work for modes with signed
5293 zeros. If A is +/-0, the first two transformations will
5294 change the sign of the result (from +0 to -0, or vice
5295 versa). The last four will fix the sign of the result,
5296 even though the original expressions could be positive or
5297 negative, depending on the sign of A.
5299 Note that all these transformations are correct if A is
5300 NaN, since the two alternatives (A and -A) are also NaNs. */
5301 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5302 && (FLOAT_TYPE_P (TREE_TYPE (arg01
))
5303 ? real_zerop (arg01
)
5304 : integer_zerop (arg01
))
5305 && ((TREE_CODE (arg2
) == NEGATE_EXPR
5306 && operand_equal_p (TREE_OPERAND (arg2
, 0), arg1
, 0))
5307 /* In the case that A is of the form X-Y, '-A' (arg2) may
5308 have already been folded to Y-X, check for that. */
5309 || (TREE_CODE (arg1
) == MINUS_EXPR
5310 && TREE_CODE (arg2
) == MINUS_EXPR
5311 && operand_equal_p (TREE_OPERAND (arg1
, 0),
5312 TREE_OPERAND (arg2
, 1), 0)
5313 && operand_equal_p (TREE_OPERAND (arg1
, 1),
5314 TREE_OPERAND (arg2
, 0), 0))))
5319 tem
= fold_convert_loc (loc
, arg1_type
, arg1
);
5320 return fold_convert_loc (loc
, type
, negate_expr (tem
));
5323 return fold_convert_loc (loc
, type
, arg1
);
5326 if (flag_trapping_math
)
5331 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5333 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5334 return fold_convert_loc (loc
, type
, tem
);
5337 if (flag_trapping_math
)
5342 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
5344 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
5345 return negate_expr (fold_convert_loc (loc
, type
, tem
));
5347 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5351 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
5352 A == 0 ? A : 0 is always 0 unless A is -0. Note that
5353 both transformations are correct when A is NaN: A != 0
5354 is then true, and A == 0 is false. */
5356 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5357 && integer_zerop (arg01
) && integer_zerop (arg2
))
5359 if (comp_code
== NE_EXPR
)
5360 return fold_convert_loc (loc
, type
, arg1
);
5361 else if (comp_code
== EQ_EXPR
)
5362 return build_zero_cst (type
);
5365 /* Try some transformations of A op B ? A : B.
5367 A == B? A : B same as B
5368 A != B? A : B same as A
5369 A >= B? A : B same as max (A, B)
5370 A > B? A : B same as max (B, A)
5371 A <= B? A : B same as min (A, B)
5372 A < B? A : B same as min (B, A)
5374 As above, these transformations don't work in the presence
5375 of signed zeros. For example, if A and B are zeros of
5376 opposite sign, the first two transformations will change
5377 the sign of the result. In the last four, the original
5378 expressions give different results for (A=+0, B=-0) and
5379 (A=-0, B=+0), but the transformed expressions do not.
5381 The first two transformations are correct if either A or B
5382 is a NaN. In the first transformation, the condition will
5383 be false, and B will indeed be chosen. In the case of the
5384 second transformation, the condition A != B will be true,
5385 and A will be chosen.
5387 The conversions to max() and min() are not correct if B is
5388 a number and A is not. The conditions in the original
5389 expressions will be false, so all four give B. The min()
5390 and max() versions would give a NaN instead. */
5391 if (!HONOR_SIGNED_ZEROS (element_mode (type
))
5392 && operand_equal_for_comparison_p (arg01
, arg2
)
5393 /* Avoid these transformations if the COND_EXPR may be used
5394 as an lvalue in the C++ front-end. PR c++/19199. */
5396 || VECTOR_TYPE_P (type
)
5397 || (! lang_GNU_CXX ()
5398 && strcmp (lang_hooks
.name
, "GNU Objective-C++") != 0)
5399 || ! maybe_lvalue_p (arg1
)
5400 || ! maybe_lvalue_p (arg2
)))
5402 tree comp_op0
= arg00
;
5403 tree comp_op1
= arg01
;
5404 tree comp_type
= TREE_TYPE (comp_op0
);
5409 return fold_convert_loc (loc
, type
, arg2
);
5411 return fold_convert_loc (loc
, type
, arg1
);
5416 /* In C++ a ?: expression can be an lvalue, so put the
5417 operand which will be used if they are equal first
5418 so that we can convert this back to the
5419 corresponding COND_EXPR. */
5420 if (!HONOR_NANS (arg1
))
5422 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5423 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5424 tem
= (comp_code
== LE_EXPR
|| comp_code
== UNLE_EXPR
)
5425 ? fold_build2_loc (loc
, MIN_EXPR
, comp_type
, comp_op0
, comp_op1
)
5426 : fold_build2_loc (loc
, MIN_EXPR
, comp_type
,
5427 comp_op1
, comp_op0
);
5428 return fold_convert_loc (loc
, type
, tem
);
5435 if (!HONOR_NANS (arg1
))
5437 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
5438 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
5439 tem
= (comp_code
== GE_EXPR
|| comp_code
== UNGE_EXPR
)
5440 ? fold_build2_loc (loc
, MAX_EXPR
, comp_type
, comp_op0
, comp_op1
)
5441 : fold_build2_loc (loc
, MAX_EXPR
, comp_type
,
5442 comp_op1
, comp_op0
);
5443 return fold_convert_loc (loc
, type
, tem
);
5447 if (!HONOR_NANS (arg1
))
5448 return fold_convert_loc (loc
, type
, arg2
);
5451 if (!HONOR_NANS (arg1
))
5452 return fold_convert_loc (loc
, type
, arg1
);
5455 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
5465 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5466 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
5467 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
5471 /* EXP is some logical combination of boolean tests. See if we can
5472 merge it into some range test. Return the new tree if so. */
5475 fold_range_test (location_t loc
, enum tree_code code
, tree type
,
5478 int or_op
= (code
== TRUTH_ORIF_EXPR
5479 || code
== TRUTH_OR_EXPR
);
5480 int in0_p
, in1_p
, in_p
;
5481 tree low0
, low1
, low
, high0
, high1
, high
;
5482 bool strict_overflow_p
= false;
5484 const char * const warnmsg
= G_("assuming signed overflow does not occur "
5485 "when simplifying range test");
5487 if (!INTEGRAL_TYPE_P (type
))
5490 lhs
= make_range (op0
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
5491 rhs
= make_range (op1
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
5493 /* If this is an OR operation, invert both sides; we will invert
5494 again at the end. */
5496 in0_p
= ! in0_p
, in1_p
= ! in1_p
;
5498 /* If both expressions are the same, if we can merge the ranges, and we
5499 can build the range test, return it or it inverted. If one of the
5500 ranges is always true or always false, consider it to be the same
5501 expression as the other. */
5502 if ((lhs
== 0 || rhs
== 0 || operand_equal_p (lhs
, rhs
, 0))
5503 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
5505 && (tem
= (build_range_check (loc
, type
,
5507 : rhs
!= 0 ? rhs
: integer_zero_node
,
5508 in_p
, low
, high
))) != 0)
5510 if (strict_overflow_p
)
5511 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
5512 return or_op
? invert_truthvalue_loc (loc
, tem
) : tem
;
5515 /* On machines where the branch cost is expensive, if this is a
5516 short-circuited branch and the underlying object on both sides
5517 is the same, make a non-short-circuit operation. */
5518 bool logical_op_non_short_circuit
= LOGICAL_OP_NON_SHORT_CIRCUIT
;
5519 if (PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT
) != -1)
5520 logical_op_non_short_circuit
5521 = PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT
);
5522 if (logical_op_non_short_circuit
5523 && !flag_sanitize_coverage
5524 && lhs
!= 0 && rhs
!= 0
5525 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
)
5526 && operand_equal_p (lhs
, rhs
, 0))
5528 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5529 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5530 which cases we can't do this. */
5531 if (simple_operand_p (lhs
))
5532 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5533 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5536 else if (!lang_hooks
.decls
.global_bindings_p ()
5537 && !CONTAINS_PLACEHOLDER_P (lhs
))
5539 tree common
= save_expr (lhs
);
5541 if ((lhs
= build_range_check (loc
, type
, common
,
5542 or_op
? ! in0_p
: in0_p
,
5544 && (rhs
= build_range_check (loc
, type
, common
,
5545 or_op
? ! in1_p
: in1_p
,
5548 if (strict_overflow_p
)
5549 fold_overflow_warning (warnmsg
,
5550 WARN_STRICT_OVERFLOW_COMPARISON
);
5551 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
5552 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
5561 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5562 bit value. Arrange things so the extra bits will be set to zero if and
5563 only if C is signed-extended to its full width. If MASK is nonzero,
5564 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5567 unextend (tree c
, int p
, int unsignedp
, tree mask
)
5569 tree type
= TREE_TYPE (c
);
5570 int modesize
= GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (type
));
5573 if (p
== modesize
|| unsignedp
)
5576 /* We work by getting just the sign bit into the low-order bit, then
5577 into the high-order bit, then sign-extend. We then XOR that value
5579 temp
= build_int_cst (TREE_TYPE (c
),
5580 wi::extract_uhwi (wi::to_wide (c
), p
- 1, 1));
5582 /* We must use a signed type in order to get an arithmetic right shift.
5583 However, we must also avoid introducing accidental overflows, so that
5584 a subsequent call to integer_zerop will work. Hence we must
5585 do the type conversion here. At this point, the constant is either
5586 zero or one, and the conversion to a signed type can never overflow.
5587 We could get an overflow if this conversion is done anywhere else. */
5588 if (TYPE_UNSIGNED (type
))
5589 temp
= fold_convert (signed_type_for (type
), temp
);
5591 temp
= const_binop (LSHIFT_EXPR
, temp
, size_int (modesize
- 1));
5592 temp
= const_binop (RSHIFT_EXPR
, temp
, size_int (modesize
- p
- 1));
5594 temp
= const_binop (BIT_AND_EXPR
, temp
,
5595 fold_convert (TREE_TYPE (c
), mask
));
5596 /* If necessary, convert the type back to match the type of C. */
5597 if (TYPE_UNSIGNED (type
))
5598 temp
= fold_convert (type
, temp
);
5600 return fold_convert (type
, const_binop (BIT_XOR_EXPR
, c
, temp
));
5603 /* For an expression that has the form
5607 we can drop one of the inner expressions and simplify to
5611 LOC is the location of the resulting expression. OP is the inner
5612 logical operation; the left-hand side in the examples above, while CMPOP
5613 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5614 removing a condition that guards another, as in
5615 (A != NULL && A->...) || A == NULL
5616 which we must not transform. If RHS_ONLY is true, only eliminate the
5617 right-most operand of the inner logical operation. */
5620 merge_truthop_with_opposite_arm (location_t loc
, tree op
, tree cmpop
,
5623 tree type
= TREE_TYPE (cmpop
);
5624 enum tree_code code
= TREE_CODE (cmpop
);
5625 enum tree_code truthop_code
= TREE_CODE (op
);
5626 tree lhs
= TREE_OPERAND (op
, 0);
5627 tree rhs
= TREE_OPERAND (op
, 1);
5628 tree orig_lhs
= lhs
, orig_rhs
= rhs
;
5629 enum tree_code rhs_code
= TREE_CODE (rhs
);
5630 enum tree_code lhs_code
= TREE_CODE (lhs
);
5631 enum tree_code inv_code
;
5633 if (TREE_SIDE_EFFECTS (op
) || TREE_SIDE_EFFECTS (cmpop
))
5636 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
5639 if (rhs_code
== truthop_code
)
5641 tree newrhs
= merge_truthop_with_opposite_arm (loc
, rhs
, cmpop
, rhs_only
);
5642 if (newrhs
!= NULL_TREE
)
5645 rhs_code
= TREE_CODE (rhs
);
5648 if (lhs_code
== truthop_code
&& !rhs_only
)
5650 tree newlhs
= merge_truthop_with_opposite_arm (loc
, lhs
, cmpop
, false);
5651 if (newlhs
!= NULL_TREE
)
5654 lhs_code
= TREE_CODE (lhs
);
5658 inv_code
= invert_tree_comparison (code
, HONOR_NANS (type
));
5659 if (inv_code
== rhs_code
5660 && operand_equal_p (TREE_OPERAND (rhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5661 && operand_equal_p (TREE_OPERAND (rhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5663 if (!rhs_only
&& inv_code
== lhs_code
5664 && operand_equal_p (TREE_OPERAND (lhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5665 && operand_equal_p (TREE_OPERAND (lhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5667 if (rhs
!= orig_rhs
|| lhs
!= orig_lhs
)
5668 return fold_build2_loc (loc
, truthop_code
, TREE_TYPE (cmpop
),
5673 /* Find ways of folding logical expressions of LHS and RHS:
5674 Try to merge two comparisons to the same innermost item.
5675 Look for range tests like "ch >= '0' && ch <= '9'".
5676 Look for combinations of simple terms on machines with expensive branches
5677 and evaluate the RHS unconditionally.
5679 For example, if we have p->a == 2 && p->b == 4 and we can make an
5680 object large enough to span both A and B, we can do this with a comparison
5681 against the object ANDed with the a mask.
5683 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5684 operations to do this with one comparison.
5686 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5687 function and the one above.
5689 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5690 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5692 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5695 We return the simplified tree or 0 if no optimization is possible. */
5698 fold_truth_andor_1 (location_t loc
, enum tree_code code
, tree truth_type
,
5701 /* If this is the "or" of two comparisons, we can do something if
5702 the comparisons are NE_EXPR. If this is the "and", we can do something
5703 if the comparisons are EQ_EXPR. I.e.,
5704 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5706 WANTED_CODE is this operation code. For single bit fields, we can
5707 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5708 comparison for one-bit fields. */
5710 enum tree_code wanted_code
;
5711 enum tree_code lcode
, rcode
;
5712 tree ll_arg
, lr_arg
, rl_arg
, rr_arg
;
5713 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
5714 HOST_WIDE_INT ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
5715 HOST_WIDE_INT rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
5716 HOST_WIDE_INT xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
5717 HOST_WIDE_INT lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
5718 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
5719 int ll_reversep
, lr_reversep
, rl_reversep
, rr_reversep
;
5720 machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
5721 scalar_int_mode lnmode
, rnmode
;
5722 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
5723 tree ll_and_mask
, lr_and_mask
, rl_and_mask
, rr_and_mask
;
5724 tree l_const
, r_const
;
5725 tree lntype
, rntype
, result
;
5726 HOST_WIDE_INT first_bit
, end_bit
;
5729 /* Start by getting the comparison codes. Fail if anything is volatile.
5730 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5731 it were surrounded with a NE_EXPR. */
5733 if (TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
5736 lcode
= TREE_CODE (lhs
);
5737 rcode
= TREE_CODE (rhs
);
5739 if (lcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (lhs
, 1)))
5741 lhs
= build2 (NE_EXPR
, truth_type
, lhs
,
5742 build_int_cst (TREE_TYPE (lhs
), 0));
5746 if (rcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (rhs
, 1)))
5748 rhs
= build2 (NE_EXPR
, truth_type
, rhs
,
5749 build_int_cst (TREE_TYPE (rhs
), 0));
5753 if (TREE_CODE_CLASS (lcode
) != tcc_comparison
5754 || TREE_CODE_CLASS (rcode
) != tcc_comparison
)
5757 ll_arg
= TREE_OPERAND (lhs
, 0);
5758 lr_arg
= TREE_OPERAND (lhs
, 1);
5759 rl_arg
= TREE_OPERAND (rhs
, 0);
5760 rr_arg
= TREE_OPERAND (rhs
, 1);
5762 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5763 if (simple_operand_p (ll_arg
)
5764 && simple_operand_p (lr_arg
))
5766 if (operand_equal_p (ll_arg
, rl_arg
, 0)
5767 && operand_equal_p (lr_arg
, rr_arg
, 0))
5769 result
= combine_comparisons (loc
, code
, lcode
, rcode
,
5770 truth_type
, ll_arg
, lr_arg
);
5774 else if (operand_equal_p (ll_arg
, rr_arg
, 0)
5775 && operand_equal_p (lr_arg
, rl_arg
, 0))
5777 result
= combine_comparisons (loc
, code
, lcode
,
5778 swap_tree_comparison (rcode
),
5779 truth_type
, ll_arg
, lr_arg
);
5785 code
= ((code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
)
5786 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
);
5788 /* If the RHS can be evaluated unconditionally and its operands are
5789 simple, it wins to evaluate the RHS unconditionally on machines
5790 with expensive branches. In this case, this isn't a comparison
5791 that can be merged. */
5793 if (BRANCH_COST (optimize_function_for_speed_p (cfun
),
5795 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg
))
5796 && simple_operand_p (rl_arg
)
5797 && simple_operand_p (rr_arg
))
5799 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5800 if (code
== TRUTH_OR_EXPR
5801 && lcode
== NE_EXPR
&& integer_zerop (lr_arg
)
5802 && rcode
== NE_EXPR
&& integer_zerop (rr_arg
)
5803 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5804 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5805 return build2_loc (loc
, NE_EXPR
, truth_type
,
5806 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5808 build_int_cst (TREE_TYPE (ll_arg
), 0));
5810 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5811 if (code
== TRUTH_AND_EXPR
5812 && lcode
== EQ_EXPR
&& integer_zerop (lr_arg
)
5813 && rcode
== EQ_EXPR
&& integer_zerop (rr_arg
)
5814 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5815 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5816 return build2_loc (loc
, EQ_EXPR
, truth_type
,
5817 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5819 build_int_cst (TREE_TYPE (ll_arg
), 0));
5822 /* See if the comparisons can be merged. Then get all the parameters for
5825 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
5826 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
))
5829 ll_reversep
= lr_reversep
= rl_reversep
= rr_reversep
= 0;
5831 ll_inner
= decode_field_reference (loc
, &ll_arg
,
5832 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
5833 &ll_unsignedp
, &ll_reversep
, &volatilep
,
5834 &ll_mask
, &ll_and_mask
);
5835 lr_inner
= decode_field_reference (loc
, &lr_arg
,
5836 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
5837 &lr_unsignedp
, &lr_reversep
, &volatilep
,
5838 &lr_mask
, &lr_and_mask
);
5839 rl_inner
= decode_field_reference (loc
, &rl_arg
,
5840 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
5841 &rl_unsignedp
, &rl_reversep
, &volatilep
,
5842 &rl_mask
, &rl_and_mask
);
5843 rr_inner
= decode_field_reference (loc
, &rr_arg
,
5844 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
5845 &rr_unsignedp
, &rr_reversep
, &volatilep
,
5846 &rr_mask
, &rr_and_mask
);
5848 /* It must be true that the inner operation on the lhs of each
5849 comparison must be the same if we are to be able to do anything.
5850 Then see if we have constants. If not, the same must be true for
5853 || ll_reversep
!= rl_reversep
5854 || ll_inner
== 0 || rl_inner
== 0
5855 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
5858 if (TREE_CODE (lr_arg
) == INTEGER_CST
5859 && TREE_CODE (rr_arg
) == INTEGER_CST
)
5861 l_const
= lr_arg
, r_const
= rr_arg
;
5862 lr_reversep
= ll_reversep
;
5864 else if (lr_reversep
!= rr_reversep
5865 || lr_inner
== 0 || rr_inner
== 0
5866 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
5869 l_const
= r_const
= 0;
5871 /* If either comparison code is not correct for our logical operation,
5872 fail. However, we can convert a one-bit comparison against zero into
5873 the opposite comparison against that bit being set in the field. */
5875 wanted_code
= (code
== TRUTH_AND_EXPR
? EQ_EXPR
: NE_EXPR
);
5876 if (lcode
!= wanted_code
)
5878 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
5880 /* Make the left operand unsigned, since we are only interested
5881 in the value of one bit. Otherwise we are doing the wrong
5890 /* This is analogous to the code for l_const above. */
5891 if (rcode
!= wanted_code
)
5893 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
5902 /* See if we can find a mode that contains both fields being compared on
5903 the left. If we can't, fail. Otherwise, update all constants and masks
5904 to be relative to a field of that size. */
5905 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
5906 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
5907 if (!get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5908 TYPE_ALIGN (TREE_TYPE (ll_inner
)), BITS_PER_WORD
,
5909 volatilep
, &lnmode
))
5912 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
5913 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
5914 lntype
= lang_hooks
.types
.type_for_size (lnbitsize
, 1);
5915 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
5917 if (ll_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5919 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
5920 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
5923 ll_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, ll_mask
),
5924 size_int (xll_bitpos
));
5925 rl_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, rl_mask
),
5926 size_int (xrl_bitpos
));
5930 l_const
= fold_convert_loc (loc
, lntype
, l_const
);
5931 l_const
= unextend (l_const
, ll_bitsize
, ll_unsignedp
, ll_and_mask
);
5932 l_const
= const_binop (LSHIFT_EXPR
, l_const
, size_int (xll_bitpos
));
5933 if (! integer_zerop (const_binop (BIT_AND_EXPR
, l_const
,
5934 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5937 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5939 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5944 r_const
= fold_convert_loc (loc
, lntype
, r_const
);
5945 r_const
= unextend (r_const
, rl_bitsize
, rl_unsignedp
, rl_and_mask
);
5946 r_const
= const_binop (LSHIFT_EXPR
, r_const
, size_int (xrl_bitpos
));
5947 if (! integer_zerop (const_binop (BIT_AND_EXPR
, r_const
,
5948 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5951 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5953 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5957 /* If the right sides are not constant, do the same for it. Also,
5958 disallow this optimization if a size, signedness or storage order
5959 mismatch occurs between the left and right sides. */
5962 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
5963 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
5964 || ll_reversep
!= lr_reversep
5965 /* Make sure the two fields on the right
5966 correspond to the left without being swapped. */
5967 || ll_bitpos
- rl_bitpos
!= lr_bitpos
- rr_bitpos
)
5970 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
5971 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
5972 if (!get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5973 TYPE_ALIGN (TREE_TYPE (lr_inner
)), BITS_PER_WORD
,
5974 volatilep
, &rnmode
))
5977 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
5978 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
5979 rntype
= lang_hooks
.types
.type_for_size (rnbitsize
, 1);
5980 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
5982 if (lr_reversep
? !BYTES_BIG_ENDIAN
: BYTES_BIG_ENDIAN
)
5984 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
5985 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
5988 lr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5990 size_int (xlr_bitpos
));
5991 rr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5993 size_int (xrr_bitpos
));
5995 /* Make a mask that corresponds to both fields being compared.
5996 Do this for both items being compared. If the operands are the
5997 same size and the bits being compared are in the same position
5998 then we can do this by masking both and comparing the masked
6000 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
6001 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
);
6002 if (lnbitsize
== rnbitsize
6003 && xll_bitpos
== xlr_bitpos
6007 lhs
= make_bit_field_ref (loc
, ll_inner
, ll_arg
,
6008 lntype
, lnbitsize
, lnbitpos
,
6009 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
6010 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
6011 lhs
= build2 (BIT_AND_EXPR
, lntype
, lhs
, ll_mask
);
6013 rhs
= make_bit_field_ref (loc
, lr_inner
, lr_arg
,
6014 rntype
, rnbitsize
, rnbitpos
,
6015 lr_unsignedp
|| rr_unsignedp
, lr_reversep
);
6016 if (! all_ones_mask_p (lr_mask
, rnbitsize
))
6017 rhs
= build2 (BIT_AND_EXPR
, rntype
, rhs
, lr_mask
);
6019 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
6022 /* There is still another way we can do something: If both pairs of
6023 fields being compared are adjacent, we may be able to make a wider
6024 field containing them both.
6026 Note that we still must mask the lhs/rhs expressions. Furthermore,
6027 the mask must be shifted to account for the shift done by
6028 make_bit_field_ref. */
6029 if (((ll_bitsize
+ ll_bitpos
== rl_bitpos
6030 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
6031 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
6032 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
6040 lhs
= make_bit_field_ref (loc
, ll_inner
, ll_arg
, lntype
,
6041 ll_bitsize
+ rl_bitsize
,
6042 MIN (ll_bitpos
, rl_bitpos
),
6043 ll_unsignedp
, ll_reversep
);
6044 rhs
= make_bit_field_ref (loc
, lr_inner
, lr_arg
, rntype
,
6045 lr_bitsize
+ rr_bitsize
,
6046 MIN (lr_bitpos
, rr_bitpos
),
6047 lr_unsignedp
, lr_reversep
);
6049 ll_mask
= const_binop (RSHIFT_EXPR
, ll_mask
,
6050 size_int (MIN (xll_bitpos
, xrl_bitpos
)));
6051 lr_mask
= const_binop (RSHIFT_EXPR
, lr_mask
,
6052 size_int (MIN (xlr_bitpos
, xrr_bitpos
)));
6054 /* Convert to the smaller type before masking out unwanted bits. */
6056 if (lntype
!= rntype
)
6058 if (lnbitsize
> rnbitsize
)
6060 lhs
= fold_convert_loc (loc
, rntype
, lhs
);
6061 ll_mask
= fold_convert_loc (loc
, rntype
, ll_mask
);
6064 else if (lnbitsize
< rnbitsize
)
6066 rhs
= fold_convert_loc (loc
, lntype
, rhs
);
6067 lr_mask
= fold_convert_loc (loc
, lntype
, lr_mask
);
6072 if (! all_ones_mask_p (ll_mask
, ll_bitsize
+ rl_bitsize
))
6073 lhs
= build2 (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
6075 if (! all_ones_mask_p (lr_mask
, lr_bitsize
+ rr_bitsize
))
6076 rhs
= build2 (BIT_AND_EXPR
, type
, rhs
, lr_mask
);
6078 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
6084 /* Handle the case of comparisons with constants. If there is something in
6085 common between the masks, those bits of the constants must be the same.
6086 If not, the condition is always false. Test for this to avoid generating
6087 incorrect code below. */
6088 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
);
6089 if (! integer_zerop (result
)
6090 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
),
6091 const_binop (BIT_AND_EXPR
, result
, r_const
)) != 1)
6093 if (wanted_code
== NE_EXPR
)
6095 warning (0, "%<or%> of unmatched not-equal tests is always 1");
6096 return constant_boolean_node (true, truth_type
);
6100 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
6101 return constant_boolean_node (false, truth_type
);
6108 /* Construct the expression we will return. First get the component
6109 reference we will make. Unless the mask is all ones the width of
6110 that field, perform the mask operation. Then compare with the
6112 result
= make_bit_field_ref (loc
, ll_inner
, ll_arg
,
6113 lntype
, lnbitsize
, lnbitpos
,
6114 ll_unsignedp
|| rl_unsignedp
, ll_reversep
);
6116 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
6117 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
6118 result
= build2_loc (loc
, BIT_AND_EXPR
, lntype
, result
, ll_mask
);
6120 return build2_loc (loc
, wanted_code
, truth_type
, result
,
6121 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
6124 /* T is an integer expression that is being multiplied, divided, or taken a
6125 modulus (CODE says which and what kind of divide or modulus) by a
6126 constant C. See if we can eliminate that operation by folding it with
6127 other operations already in T. WIDE_TYPE, if non-null, is a type that
6128 should be used for the computation if wider than our type.
6130 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
6131 (X * 2) + (Y * 4). We must, however, be assured that either the original
6132 expression would not overflow or that overflow is undefined for the type
6133 in the language in question.
6135 If we return a non-null expression, it is an equivalent form of the
6136 original computation, but need not be in the original type.
6138 We set *STRICT_OVERFLOW_P to true if the return values depends on
6139 signed overflow being undefined. Otherwise we do not change
6140 *STRICT_OVERFLOW_P. */
6143 extract_muldiv (tree t
, tree c
, enum tree_code code
, tree wide_type
,
6144 bool *strict_overflow_p
)
6146 /* To avoid exponential search depth, refuse to allow recursion past
6147 three levels. Beyond that (1) it's highly unlikely that we'll find
6148 something interesting and (2) we've probably processed it before
6149 when we built the inner expression. */
6158 ret
= extract_muldiv_1 (t
, c
, code
, wide_type
, strict_overflow_p
);
6165 extract_muldiv_1 (tree t
, tree c
, enum tree_code code
, tree wide_type
,
6166 bool *strict_overflow_p
)
6168 tree type
= TREE_TYPE (t
);
6169 enum tree_code tcode
= TREE_CODE (t
);
6170 tree ctype
= (wide_type
!= 0
6171 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (wide_type
))
6172 > GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
)))
6173 ? wide_type
: type
);
6175 int same_p
= tcode
== code
;
6176 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
6177 bool sub_strict_overflow_p
;
6179 /* Don't deal with constants of zero here; they confuse the code below. */
6180 if (integer_zerop (c
))
6183 if (TREE_CODE_CLASS (tcode
) == tcc_unary
)
6184 op0
= TREE_OPERAND (t
, 0);
6186 if (TREE_CODE_CLASS (tcode
) == tcc_binary
)
6187 op0
= TREE_OPERAND (t
, 0), op1
= TREE_OPERAND (t
, 1);
6189 /* Note that we need not handle conditional operations here since fold
6190 already handles those cases. So just do arithmetic here. */
6194 /* For a constant, we can always simplify if we are a multiply
6195 or (for divide and modulus) if it is a multiple of our constant. */
6196 if (code
== MULT_EXPR
6197 || wi::multiple_of_p (wi::to_wide (t
), wi::to_wide (c
),
6200 tree tem
= const_binop (code
, fold_convert (ctype
, t
),
6201 fold_convert (ctype
, c
));
6202 /* If the multiplication overflowed, we lost information on it.
6203 See PR68142 and PR69845. */
6204 if (TREE_OVERFLOW (tem
))
6210 CASE_CONVERT
: case NON_LVALUE_EXPR
:
6211 /* If op0 is an expression ... */
6212 if ((COMPARISON_CLASS_P (op0
)
6213 || UNARY_CLASS_P (op0
)
6214 || BINARY_CLASS_P (op0
)
6215 || VL_EXP_CLASS_P (op0
)
6216 || EXPRESSION_CLASS_P (op0
))
6217 /* ... and has wrapping overflow, and its type is smaller
6218 than ctype, then we cannot pass through as widening. */
6219 && (((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
6220 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0
)))
6221 && (TYPE_PRECISION (ctype
)
6222 > TYPE_PRECISION (TREE_TYPE (op0
))))
6223 /* ... or this is a truncation (t is narrower than op0),
6224 then we cannot pass through this narrowing. */
6225 || (TYPE_PRECISION (type
)
6226 < TYPE_PRECISION (TREE_TYPE (op0
)))
6227 /* ... or signedness changes for division or modulus,
6228 then we cannot pass through this conversion. */
6229 || (code
!= MULT_EXPR
6230 && (TYPE_UNSIGNED (ctype
)
6231 != TYPE_UNSIGNED (TREE_TYPE (op0
))))
6232 /* ... or has undefined overflow while the converted to
6233 type has not, we cannot do the operation in the inner type
6234 as that would introduce undefined overflow. */
6235 || ((ANY_INTEGRAL_TYPE_P (TREE_TYPE (op0
))
6236 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0
)))
6237 && !TYPE_OVERFLOW_UNDEFINED (type
))))
6240 /* Pass the constant down and see if we can make a simplification. If
6241 we can, replace this expression with the inner simplification for
6242 possible later conversion to our or some other type. */
6243 if ((t2
= fold_convert (TREE_TYPE (op0
), c
)) != 0
6244 && TREE_CODE (t2
) == INTEGER_CST
6245 && !TREE_OVERFLOW (t2
)
6246 && (t1
= extract_muldiv (op0
, t2
, code
,
6247 code
== MULT_EXPR
? ctype
: NULL_TREE
,
6248 strict_overflow_p
)) != 0)
6253 /* If widening the type changes it from signed to unsigned, then we
6254 must avoid building ABS_EXPR itself as unsigned. */
6255 if (TYPE_UNSIGNED (ctype
) && !TYPE_UNSIGNED (type
))
6257 tree cstype
= (*signed_type_for
) (ctype
);
6258 if ((t1
= extract_muldiv (op0
, c
, code
, cstype
, strict_overflow_p
))
6261 t1
= fold_build1 (tcode
, cstype
, fold_convert (cstype
, t1
));
6262 return fold_convert (ctype
, t1
);
6266 /* If the constant is negative, we cannot simplify this. */
6267 if (tree_int_cst_sgn (c
) == -1)
6271 /* For division and modulus, type can't be unsigned, as e.g.
6272 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
6273 For signed types, even with wrapping overflow, this is fine. */
6274 if (code
!= MULT_EXPR
&& TYPE_UNSIGNED (type
))
6276 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
, strict_overflow_p
))
6278 return fold_build1 (tcode
, ctype
, fold_convert (ctype
, t1
));
6281 case MIN_EXPR
: case MAX_EXPR
:
6282 /* If widening the type changes the signedness, then we can't perform
6283 this optimization as that changes the result. */
6284 if (TYPE_UNSIGNED (ctype
) != TYPE_UNSIGNED (type
))
6287 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
6288 sub_strict_overflow_p
= false;
6289 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6290 &sub_strict_overflow_p
)) != 0
6291 && (t2
= extract_muldiv (op1
, c
, code
, wide_type
,
6292 &sub_strict_overflow_p
)) != 0)
6294 if (tree_int_cst_sgn (c
) < 0)
6295 tcode
= (tcode
== MIN_EXPR
? MAX_EXPR
: MIN_EXPR
);
6296 if (sub_strict_overflow_p
)
6297 *strict_overflow_p
= true;
6298 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6299 fold_convert (ctype
, t2
));
6303 case LSHIFT_EXPR
: case RSHIFT_EXPR
:
6304 /* If the second operand is constant, this is a multiplication
6305 or floor division, by a power of two, so we can treat it that
6306 way unless the multiplier or divisor overflows. Signed
6307 left-shift overflow is implementation-defined rather than
6308 undefined in C90, so do not convert signed left shift into
6310 if (TREE_CODE (op1
) == INTEGER_CST
6311 && (tcode
== RSHIFT_EXPR
|| TYPE_UNSIGNED (TREE_TYPE (op0
)))
6312 /* const_binop may not detect overflow correctly,
6313 so check for it explicitly here. */
6314 && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)),
6316 && (t1
= fold_convert (ctype
,
6317 const_binop (LSHIFT_EXPR
, size_one_node
,
6319 && !TREE_OVERFLOW (t1
))
6320 return extract_muldiv (build2 (tcode
== LSHIFT_EXPR
6321 ? MULT_EXPR
: FLOOR_DIV_EXPR
,
6323 fold_convert (ctype
, op0
),
6325 c
, code
, wide_type
, strict_overflow_p
);
6328 case PLUS_EXPR
: case MINUS_EXPR
:
6329 /* See if we can eliminate the operation on both sides. If we can, we
6330 can return a new PLUS or MINUS. If we can't, the only remaining
6331 cases where we can do anything are if the second operand is a
6333 sub_strict_overflow_p
= false;
6334 t1
= extract_muldiv (op0
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6335 t2
= extract_muldiv (op1
, c
, code
, wide_type
, &sub_strict_overflow_p
);
6336 if (t1
!= 0 && t2
!= 0
6337 && TYPE_OVERFLOW_WRAPS (ctype
)
6338 && (code
== MULT_EXPR
6339 /* If not multiplication, we can only do this if both operands
6340 are divisible by c. */
6341 || (multiple_of_p (ctype
, op0
, c
)
6342 && multiple_of_p (ctype
, op1
, c
))))
6344 if (sub_strict_overflow_p
)
6345 *strict_overflow_p
= true;
6346 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6347 fold_convert (ctype
, t2
));
6350 /* If this was a subtraction, negate OP1 and set it to be an addition.
6351 This simplifies the logic below. */
6352 if (tcode
== MINUS_EXPR
)
6354 tcode
= PLUS_EXPR
, op1
= negate_expr (op1
);
6355 /* If OP1 was not easily negatable, the constant may be OP0. */
6356 if (TREE_CODE (op0
) == INTEGER_CST
)
6358 std::swap (op0
, op1
);
6363 if (TREE_CODE (op1
) != INTEGER_CST
)
6366 /* If either OP1 or C are negative, this optimization is not safe for
6367 some of the division and remainder types while for others we need
6368 to change the code. */
6369 if (tree_int_cst_sgn (op1
) < 0 || tree_int_cst_sgn (c
) < 0)
6371 if (code
== CEIL_DIV_EXPR
)
6372 code
= FLOOR_DIV_EXPR
;
6373 else if (code
== FLOOR_DIV_EXPR
)
6374 code
= CEIL_DIV_EXPR
;
6375 else if (code
!= MULT_EXPR
6376 && code
!= CEIL_MOD_EXPR
&& code
!= FLOOR_MOD_EXPR
)
6380 /* If it's a multiply or a division/modulus operation of a multiple
6381 of our constant, do the operation and verify it doesn't overflow. */
6382 if (code
== MULT_EXPR
6383 || wi::multiple_of_p (wi::to_wide (op1
), wi::to_wide (c
),
6386 op1
= const_binop (code
, fold_convert (ctype
, op1
),
6387 fold_convert (ctype
, c
));
6388 /* We allow the constant to overflow with wrapping semantics. */
6390 || (TREE_OVERFLOW (op1
) && !TYPE_OVERFLOW_WRAPS (ctype
)))
6396 /* If we have an unsigned type, we cannot widen the operation since it
6397 will change the result if the original computation overflowed. */
6398 if (TYPE_UNSIGNED (ctype
) && ctype
!= type
)
6401 /* The last case is if we are a multiply. In that case, we can
6402 apply the distributive law to commute the multiply and addition
6403 if the multiplication of the constants doesn't overflow
6404 and overflow is defined. With undefined overflow
6405 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
6406 if (code
== MULT_EXPR
&& TYPE_OVERFLOW_WRAPS (ctype
))
6407 return fold_build2 (tcode
, ctype
,
6408 fold_build2 (code
, ctype
,
6409 fold_convert (ctype
, op0
),
6410 fold_convert (ctype
, c
)),
6416 /* We have a special case here if we are doing something like
6417 (C * 8) % 4 since we know that's zero. */
6418 if ((code
== TRUNC_MOD_EXPR
|| code
== CEIL_MOD_EXPR
6419 || code
== FLOOR_MOD_EXPR
|| code
== ROUND_MOD_EXPR
)
6420 /* If the multiplication can overflow we cannot optimize this. */
6421 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
))
6422 && TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
6423 && wi::multiple_of_p (wi::to_wide (op1
), wi::to_wide (c
),
6426 *strict_overflow_p
= true;
6427 return omit_one_operand (type
, integer_zero_node
, op0
);
6430 /* ... fall through ... */
6432 case TRUNC_DIV_EXPR
: case CEIL_DIV_EXPR
: case FLOOR_DIV_EXPR
:
6433 case ROUND_DIV_EXPR
: case EXACT_DIV_EXPR
:
6434 /* If we can extract our operation from the LHS, do so and return a
6435 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6436 do something only if the second operand is a constant. */
6438 && TYPE_OVERFLOW_WRAPS (ctype
)
6439 && (t1
= extract_muldiv (op0
, c
, code
, wide_type
,
6440 strict_overflow_p
)) != 0)
6441 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
6442 fold_convert (ctype
, op1
));
6443 else if (tcode
== MULT_EXPR
&& code
== MULT_EXPR
6444 && TYPE_OVERFLOW_WRAPS (ctype
)
6445 && (t1
= extract_muldiv (op1
, c
, code
, wide_type
,
6446 strict_overflow_p
)) != 0)
6447 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6448 fold_convert (ctype
, t1
));
6449 else if (TREE_CODE (op1
) != INTEGER_CST
)
6452 /* If these are the same operation types, we can associate them
6453 assuming no overflow. */
6456 bool overflow_p
= false;
6457 bool overflow_mul_p
;
6458 signop sign
= TYPE_SIGN (ctype
);
6459 unsigned prec
= TYPE_PRECISION (ctype
);
6460 wide_int mul
= wi::mul (wi::to_wide (op1
, prec
),
6461 wi::to_wide (c
, prec
),
6462 sign
, &overflow_mul_p
);
6463 overflow_p
= TREE_OVERFLOW (c
) | TREE_OVERFLOW (op1
);
6465 && ((sign
== UNSIGNED
&& tcode
!= MULT_EXPR
) || sign
== SIGNED
))
6468 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6469 wide_int_to_tree (ctype
, mul
));
6472 /* If these operations "cancel" each other, we have the main
6473 optimizations of this pass, which occur when either constant is a
6474 multiple of the other, in which case we replace this with either an
6475 operation or CODE or TCODE.
6477 If we have an unsigned type, we cannot do this since it will change
6478 the result if the original computation overflowed. */
6479 if (TYPE_OVERFLOW_UNDEFINED (ctype
)
6480 && ((code
== MULT_EXPR
&& tcode
== EXACT_DIV_EXPR
)
6481 || (tcode
== MULT_EXPR
6482 && code
!= TRUNC_MOD_EXPR
&& code
!= CEIL_MOD_EXPR
6483 && code
!= FLOOR_MOD_EXPR
&& code
!= ROUND_MOD_EXPR
6484 && code
!= MULT_EXPR
)))
6486 if (wi::multiple_of_p (wi::to_wide (op1
), wi::to_wide (c
),
6489 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6490 *strict_overflow_p
= true;
6491 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
6492 fold_convert (ctype
,
6493 const_binop (TRUNC_DIV_EXPR
,
6496 else if (wi::multiple_of_p (wi::to_wide (c
), wi::to_wide (op1
),
6499 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6500 *strict_overflow_p
= true;
6501 return fold_build2 (code
, ctype
, fold_convert (ctype
, op0
),
6502 fold_convert (ctype
,
6503 const_binop (TRUNC_DIV_EXPR
,
6516 /* Return a node which has the indicated constant VALUE (either 0 or
6517 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6518 and is of the indicated TYPE. */
6521 constant_boolean_node (bool value
, tree type
)
6523 if (type
== integer_type_node
)
6524 return value
? integer_one_node
: integer_zero_node
;
6525 else if (type
== boolean_type_node
)
6526 return value
? boolean_true_node
: boolean_false_node
;
6527 else if (TREE_CODE (type
) == VECTOR_TYPE
)
6528 return build_vector_from_val (type
,
6529 build_int_cst (TREE_TYPE (type
),
6532 return fold_convert (type
, value
? integer_one_node
: integer_zero_node
);
6536 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6537 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6538 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6539 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6540 COND is the first argument to CODE; otherwise (as in the example
6541 given here), it is the second argument. TYPE is the type of the
6542 original expression. Return NULL_TREE if no simplification is
6546 fold_binary_op_with_conditional_arg (location_t loc
,
6547 enum tree_code code
,
6548 tree type
, tree op0
, tree op1
,
6549 tree cond
, tree arg
, int cond_first_p
)
6551 tree cond_type
= cond_first_p
? TREE_TYPE (op0
) : TREE_TYPE (op1
);
6552 tree arg_type
= cond_first_p
? TREE_TYPE (op1
) : TREE_TYPE (op0
);
6553 tree test
, true_value
, false_value
;
6554 tree lhs
= NULL_TREE
;
6555 tree rhs
= NULL_TREE
;
6556 enum tree_code cond_code
= COND_EXPR
;
6558 if (TREE_CODE (cond
) == COND_EXPR
6559 || TREE_CODE (cond
) == VEC_COND_EXPR
)
6561 test
= TREE_OPERAND (cond
, 0);
6562 true_value
= TREE_OPERAND (cond
, 1);
6563 false_value
= TREE_OPERAND (cond
, 2);
6564 /* If this operand throws an expression, then it does not make
6565 sense to try to perform a logical or arithmetic operation
6567 if (VOID_TYPE_P (TREE_TYPE (true_value
)))
6569 if (VOID_TYPE_P (TREE_TYPE (false_value
)))
6572 else if (!(TREE_CODE (type
) != VECTOR_TYPE
6573 && TREE_CODE (TREE_TYPE (cond
)) == VECTOR_TYPE
))
6575 tree testtype
= TREE_TYPE (cond
);
6577 true_value
= constant_boolean_node (true, testtype
);
6578 false_value
= constant_boolean_node (false, testtype
);
6581 /* Detect the case of mixing vector and scalar types - bail out. */
6584 if (TREE_CODE (TREE_TYPE (test
)) == VECTOR_TYPE
)
6585 cond_code
= VEC_COND_EXPR
;
6587 /* This transformation is only worthwhile if we don't have to wrap ARG
6588 in a SAVE_EXPR and the operation can be simplified without recursing
6589 on at least one of the branches once its pushed inside the COND_EXPR. */
6590 if (!TREE_CONSTANT (arg
)
6591 && (TREE_SIDE_EFFECTS (arg
)
6592 || TREE_CODE (arg
) == COND_EXPR
|| TREE_CODE (arg
) == VEC_COND_EXPR
6593 || TREE_CONSTANT (true_value
) || TREE_CONSTANT (false_value
)))
6596 arg
= fold_convert_loc (loc
, arg_type
, arg
);
6599 true_value
= fold_convert_loc (loc
, cond_type
, true_value
);
6601 lhs
= fold_build2_loc (loc
, code
, type
, true_value
, arg
);
6603 lhs
= fold_build2_loc (loc
, code
, type
, arg
, true_value
);
6607 false_value
= fold_convert_loc (loc
, cond_type
, false_value
);
6609 rhs
= fold_build2_loc (loc
, code
, type
, false_value
, arg
);
6611 rhs
= fold_build2_loc (loc
, code
, type
, arg
, false_value
);
6614 /* Check that we have simplified at least one of the branches. */
6615 if (!TREE_CONSTANT (arg
) && !TREE_CONSTANT (lhs
) && !TREE_CONSTANT (rhs
))
6618 return fold_build3_loc (loc
, cond_code
, type
, test
, lhs
, rhs
);
6622 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6624 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6625 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6626 ADDEND is the same as X.
6628 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6629 and finite. The problematic cases are when X is zero, and its mode
6630 has signed zeros. In the case of rounding towards -infinity,
6631 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6632 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6635 fold_real_zero_addition_p (const_tree type
, const_tree addend
, int negate
)
6637 if (!real_zerop (addend
))
6640 /* Don't allow the fold with -fsignaling-nans. */
6641 if (HONOR_SNANS (element_mode (type
)))
6644 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6645 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
6648 /* In a vector or complex, we would need to check the sign of all zeros. */
6649 if (TREE_CODE (addend
) != REAL_CST
)
6652 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6653 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend
)))
6656 /* The mode has signed zeros, and we have to honor their sign.
6657 In this situation, there is only one case we can return true for.
6658 X - 0 is the same as X unless rounding towards -infinity is
6660 return negate
&& !HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (type
));
6663 /* Subroutine of match.pd that optimizes comparisons of a division by
6664 a nonzero integer constant against an integer constant, i.e.
6667 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6668 GE_EXPR or LE_EXPR. ARG01 and ARG1 must be a INTEGER_CST. */
6671 fold_div_compare (enum tree_code code
, tree c1
, tree c2
, tree
*lo
,
6672 tree
*hi
, bool *neg_overflow
)
6674 tree prod
, tmp
, type
= TREE_TYPE (c1
);
6675 signop sign
= TYPE_SIGN (type
);
6678 /* We have to do this the hard way to detect unsigned overflow.
6679 prod = int_const_binop (MULT_EXPR, c1, c2); */
6680 wide_int val
= wi::mul (wi::to_wide (c1
), wi::to_wide (c2
), sign
, &overflow
);
6681 prod
= force_fit_type (type
, val
, -1, overflow
);
6682 *neg_overflow
= false;
6684 if (sign
== UNSIGNED
)
6686 tmp
= int_const_binop (MINUS_EXPR
, c1
, build_int_cst (type
, 1));
6689 /* Likewise *hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6690 val
= wi::add (wi::to_wide (prod
), wi::to_wide (tmp
), sign
, &overflow
);
6691 *hi
= force_fit_type (type
, val
, -1, overflow
| TREE_OVERFLOW (prod
));
6693 else if (tree_int_cst_sgn (c1
) >= 0)
6695 tmp
= int_const_binop (MINUS_EXPR
, c1
, build_int_cst (type
, 1));
6696 switch (tree_int_cst_sgn (c2
))
6699 *neg_overflow
= true;
6700 *lo
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6705 *lo
= fold_negate_const (tmp
, type
);
6710 *hi
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6720 /* A negative divisor reverses the relational operators. */
6721 code
= swap_tree_comparison (code
);
6723 tmp
= int_const_binop (PLUS_EXPR
, c1
, build_int_cst (type
, 1));
6724 switch (tree_int_cst_sgn (c2
))
6727 *hi
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6732 *hi
= fold_negate_const (tmp
, type
);
6737 *neg_overflow
= true;
6738 *lo
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6747 if (code
!= EQ_EXPR
&& code
!= NE_EXPR
)
6750 if (TREE_OVERFLOW (*lo
)
6751 || operand_equal_p (*lo
, TYPE_MIN_VALUE (type
), 0))
6753 if (TREE_OVERFLOW (*hi
)
6754 || operand_equal_p (*hi
, TYPE_MAX_VALUE (type
), 0))
6761 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6762 equality/inequality test, then return a simplified form of the test
6763 using a sign testing. Otherwise return NULL. TYPE is the desired
6767 fold_single_bit_test_into_sign_test (location_t loc
,
6768 enum tree_code code
, tree arg0
, tree arg1
,
6771 /* If this is testing a single bit, we can optimize the test. */
6772 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6773 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6774 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6776 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6777 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6778 tree arg00
= sign_bit_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1));
6780 if (arg00
!= NULL_TREE
6781 /* This is only a win if casting to a signed type is cheap,
6782 i.e. when arg00's type is not a partial mode. */
6783 && type_has_mode_precision_p (TREE_TYPE (arg00
)))
6785 tree stype
= signed_type_for (TREE_TYPE (arg00
));
6786 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
6788 fold_convert_loc (loc
, stype
, arg00
),
6789 build_int_cst (stype
, 0));
6796 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6797 equality/inequality test, then return a simplified form of
6798 the test using shifts and logical operations. Otherwise return
6799 NULL. TYPE is the desired result type. */
6802 fold_single_bit_test (location_t loc
, enum tree_code code
,
6803 tree arg0
, tree arg1
, tree result_type
)
6805 /* If this is testing a single bit, we can optimize the test. */
6806 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6807 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6808 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6810 tree inner
= TREE_OPERAND (arg0
, 0);
6811 tree type
= TREE_TYPE (arg0
);
6812 int bitnum
= tree_log2 (TREE_OPERAND (arg0
, 1));
6813 scalar_int_mode operand_mode
= SCALAR_INT_TYPE_MODE (type
);
6815 tree signed_type
, unsigned_type
, intermediate_type
;
6818 /* First, see if we can fold the single bit test into a sign-bit
6820 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
,
6825 /* Otherwise we have (A & C) != 0 where C is a single bit,
6826 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6827 Similarly for (A & C) == 0. */
6829 /* If INNER is a right shift of a constant and it plus BITNUM does
6830 not overflow, adjust BITNUM and INNER. */
6831 if (TREE_CODE (inner
) == RSHIFT_EXPR
6832 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
6833 && bitnum
< TYPE_PRECISION (type
)
6834 && wi::ltu_p (wi::to_wide (TREE_OPERAND (inner
, 1)),
6835 TYPE_PRECISION (type
) - bitnum
))
6837 bitnum
+= tree_to_uhwi (TREE_OPERAND (inner
, 1));
6838 inner
= TREE_OPERAND (inner
, 0);
6841 /* If we are going to be able to omit the AND below, we must do our
6842 operations as unsigned. If we must use the AND, we have a choice.
6843 Normally unsigned is faster, but for some machines signed is. */
6844 ops_unsigned
= (load_extend_op (operand_mode
) == SIGN_EXTEND
6845 && !flag_syntax_only
) ? 0 : 1;
6847 signed_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 0);
6848 unsigned_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 1);
6849 intermediate_type
= ops_unsigned
? unsigned_type
: signed_type
;
6850 inner
= fold_convert_loc (loc
, intermediate_type
, inner
);
6853 inner
= build2 (RSHIFT_EXPR
, intermediate_type
,
6854 inner
, size_int (bitnum
));
6856 one
= build_int_cst (intermediate_type
, 1);
6858 if (code
== EQ_EXPR
)
6859 inner
= fold_build2_loc (loc
, BIT_XOR_EXPR
, intermediate_type
, inner
, one
);
6861 /* Put the AND last so it can combine with more things. */
6862 inner
= build2 (BIT_AND_EXPR
, intermediate_type
, inner
, one
);
6864 /* Make sure to return the proper type. */
6865 inner
= fold_convert_loc (loc
, result_type
, inner
);
6872 /* Test whether it is preferable two swap two operands, ARG0 and
6873 ARG1, for example because ARG0 is an integer constant and ARG1
6877 tree_swap_operands_p (const_tree arg0
, const_tree arg1
)
6879 if (CONSTANT_CLASS_P (arg1
))
6881 if (CONSTANT_CLASS_P (arg0
))
6887 if (TREE_CONSTANT (arg1
))
6889 if (TREE_CONSTANT (arg0
))
6892 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6893 for commutative and comparison operators. Ensuring a canonical
6894 form allows the optimizers to find additional redundancies without
6895 having to explicitly check for both orderings. */
6896 if (TREE_CODE (arg0
) == SSA_NAME
6897 && TREE_CODE (arg1
) == SSA_NAME
6898 && SSA_NAME_VERSION (arg0
) > SSA_NAME_VERSION (arg1
))
6901 /* Put SSA_NAMEs last. */
6902 if (TREE_CODE (arg1
) == SSA_NAME
)
6904 if (TREE_CODE (arg0
) == SSA_NAME
)
6907 /* Put variables last. */
6917 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6918 means A >= Y && A != MAX, but in this case we know that
6919 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6922 fold_to_nonsharp_ineq_using_bound (location_t loc
, tree ineq
, tree bound
)
6924 tree a
, typea
, type
= TREE_TYPE (ineq
), a1
, diff
, y
;
6926 if (TREE_CODE (bound
) == LT_EXPR
)
6927 a
= TREE_OPERAND (bound
, 0);
6928 else if (TREE_CODE (bound
) == GT_EXPR
)
6929 a
= TREE_OPERAND (bound
, 1);
6933 typea
= TREE_TYPE (a
);
6934 if (!INTEGRAL_TYPE_P (typea
)
6935 && !POINTER_TYPE_P (typea
))
6938 if (TREE_CODE (ineq
) == LT_EXPR
)
6940 a1
= TREE_OPERAND (ineq
, 1);
6941 y
= TREE_OPERAND (ineq
, 0);
6943 else if (TREE_CODE (ineq
) == GT_EXPR
)
6945 a1
= TREE_OPERAND (ineq
, 0);
6946 y
= TREE_OPERAND (ineq
, 1);
6951 if (TREE_TYPE (a1
) != typea
)
6954 if (POINTER_TYPE_P (typea
))
6956 /* Convert the pointer types into integer before taking the difference. */
6957 tree ta
= fold_convert_loc (loc
, ssizetype
, a
);
6958 tree ta1
= fold_convert_loc (loc
, ssizetype
, a1
);
6959 diff
= fold_binary_loc (loc
, MINUS_EXPR
, ssizetype
, ta1
, ta
);
6962 diff
= fold_binary_loc (loc
, MINUS_EXPR
, typea
, a1
, a
);
6964 if (!diff
|| !integer_onep (diff
))
6967 return fold_build2_loc (loc
, GE_EXPR
, type
, a
, y
);
6970 /* Fold a sum or difference of at least one multiplication.
6971 Returns the folded tree or NULL if no simplification could be made. */
6974 fold_plusminus_mult_expr (location_t loc
, enum tree_code code
, tree type
,
6975 tree arg0
, tree arg1
)
6977 tree arg00
, arg01
, arg10
, arg11
;
6978 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
6980 /* (A * C) +- (B * C) -> (A+-B) * C.
6981 (A * C) +- A -> A * (C+-1).
6982 We are most concerned about the case where C is a constant,
6983 but other combinations show up during loop reduction. Since
6984 it is not difficult, try all four possibilities. */
6986 if (TREE_CODE (arg0
) == MULT_EXPR
)
6988 arg00
= TREE_OPERAND (arg0
, 0);
6989 arg01
= TREE_OPERAND (arg0
, 1);
6991 else if (TREE_CODE (arg0
) == INTEGER_CST
)
6993 arg00
= build_one_cst (type
);
6998 /* We cannot generate constant 1 for fract. */
6999 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
7002 arg01
= build_one_cst (type
);
7004 if (TREE_CODE (arg1
) == MULT_EXPR
)
7006 arg10
= TREE_OPERAND (arg1
, 0);
7007 arg11
= TREE_OPERAND (arg1
, 1);
7009 else if (TREE_CODE (arg1
) == INTEGER_CST
)
7011 arg10
= build_one_cst (type
);
7012 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7013 the purpose of this canonicalization. */
7014 if (wi::neg_p (wi::to_wide (arg1
), TYPE_SIGN (TREE_TYPE (arg1
)))
7015 && negate_expr_p (arg1
)
7016 && code
== PLUS_EXPR
)
7018 arg11
= negate_expr (arg1
);
7026 /* We cannot generate constant 1 for fract. */
7027 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
7030 arg11
= build_one_cst (type
);
7034 /* Prefer factoring a common non-constant. */
7035 if (operand_equal_p (arg00
, arg10
, 0))
7036 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
7037 else if (operand_equal_p (arg01
, arg11
, 0))
7038 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
7039 else if (operand_equal_p (arg00
, arg11
, 0))
7040 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
7041 else if (operand_equal_p (arg01
, arg10
, 0))
7042 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
7044 /* No identical multiplicands; see if we can find a common
7045 power-of-two factor in non-power-of-two multiplies. This
7046 can help in multi-dimensional array access. */
7047 else if (tree_fits_shwi_p (arg01
)
7048 && tree_fits_shwi_p (arg11
))
7050 HOST_WIDE_INT int01
, int11
, tmp
;
7053 int01
= tree_to_shwi (arg01
);
7054 int11
= tree_to_shwi (arg11
);
7056 /* Move min of absolute values to int11. */
7057 if (absu_hwi (int01
) < absu_hwi (int11
))
7059 tmp
= int01
, int01
= int11
, int11
= tmp
;
7060 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
7067 if (exact_log2 (absu_hwi (int11
)) > 0 && int01
% int11
== 0
7068 /* The remainder should not be a constant, otherwise we
7069 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7070 increased the number of multiplications necessary. */
7071 && TREE_CODE (arg10
) != INTEGER_CST
)
7073 alt0
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (arg00
), arg00
,
7074 build_int_cst (TREE_TYPE (arg00
),
7079 maybe_same
= alt0
, alt0
= alt1
, alt1
= maybe_same
;
7086 if (! INTEGRAL_TYPE_P (type
)
7087 || TYPE_OVERFLOW_WRAPS (type
)
7088 /* We are neither factoring zero nor minus one. */
7089 || TREE_CODE (same
) == INTEGER_CST
)
7090 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7091 fold_build2_loc (loc
, code
, type
,
7092 fold_convert_loc (loc
, type
, alt0
),
7093 fold_convert_loc (loc
, type
, alt1
)),
7094 fold_convert_loc (loc
, type
, same
));
7096 /* Same may be zero and thus the operation 'code' may overflow. Likewise
7097 same may be minus one and thus the multiplication may overflow. Perform
7098 the sum operation in an unsigned type. */
7099 tree utype
= unsigned_type_for (type
);
7100 tree tem
= fold_build2_loc (loc
, code
, utype
,
7101 fold_convert_loc (loc
, utype
, alt0
),
7102 fold_convert_loc (loc
, utype
, alt1
));
7103 /* If the sum evaluated to a constant that is not -INF the multiplication
7105 if (TREE_CODE (tem
) == INTEGER_CST
7106 && (wi::to_wide (tem
)
7107 != wi::min_value (TYPE_PRECISION (utype
), SIGNED
)))
7108 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7109 fold_convert (type
, tem
), same
);
7111 /* Do not resort to unsigned multiplication because
7112 we lose the no-overflow property of the expression. */
7116 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7117 specified by EXPR into the buffer PTR of length LEN bytes.
7118 Return the number of bytes placed in the buffer, or zero
7122 native_encode_int (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7124 tree type
= TREE_TYPE (expr
);
7125 int total_bytes
= GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
));
7126 int byte
, offset
, word
, words
;
7127 unsigned char value
;
7129 if ((off
== -1 && total_bytes
> len
) || off
>= total_bytes
)
7136 return MIN (len
, total_bytes
- off
);
7138 words
= total_bytes
/ UNITS_PER_WORD
;
7140 for (byte
= 0; byte
< total_bytes
; byte
++)
7142 int bitpos
= byte
* BITS_PER_UNIT
;
7143 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7145 value
= wi::extract_uhwi (wi::to_widest (expr
), bitpos
, BITS_PER_UNIT
);
7147 if (total_bytes
> UNITS_PER_WORD
)
7149 word
= byte
/ UNITS_PER_WORD
;
7150 if (WORDS_BIG_ENDIAN
)
7151 word
= (words
- 1) - word
;
7152 offset
= word
* UNITS_PER_WORD
;
7153 if (BYTES_BIG_ENDIAN
)
7154 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7156 offset
+= byte
% UNITS_PER_WORD
;
7159 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
7160 if (offset
>= off
&& offset
- off
< len
)
7161 ptr
[offset
- off
] = value
;
7163 return MIN (len
, total_bytes
- off
);
7167 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7168 specified by EXPR into the buffer PTR of length LEN bytes.
7169 Return the number of bytes placed in the buffer, or zero
7173 native_encode_fixed (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7175 tree type
= TREE_TYPE (expr
);
7176 scalar_mode mode
= SCALAR_TYPE_MODE (type
);
7177 int total_bytes
= GET_MODE_SIZE (mode
);
7178 FIXED_VALUE_TYPE value
;
7179 tree i_value
, i_type
;
7181 if (total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7184 i_type
= lang_hooks
.types
.type_for_size (GET_MODE_BITSIZE (mode
), 1);
7186 if (NULL_TREE
== i_type
|| TYPE_PRECISION (i_type
) != total_bytes
)
7189 value
= TREE_FIXED_CST (expr
);
7190 i_value
= double_int_to_tree (i_type
, value
.data
);
7192 return native_encode_int (i_value
, ptr
, len
, off
);
7196 /* Subroutine of native_encode_expr. Encode the REAL_CST
7197 specified by EXPR into the buffer PTR of length LEN bytes.
7198 Return the number of bytes placed in the buffer, or zero
7202 native_encode_real (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7204 tree type
= TREE_TYPE (expr
);
7205 int total_bytes
= GET_MODE_SIZE (SCALAR_FLOAT_TYPE_MODE (type
));
7206 int byte
, offset
, word
, words
, bitpos
;
7207 unsigned char value
;
7209 /* There are always 32 bits in each long, no matter the size of
7210 the hosts long. We handle floating point representations with
7214 if ((off
== -1 && total_bytes
> len
) || off
>= total_bytes
)
7221 return MIN (len
, total_bytes
- off
);
7223 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7225 real_to_target (tmp
, TREE_REAL_CST_PTR (expr
), TYPE_MODE (type
));
7227 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7228 bitpos
+= BITS_PER_UNIT
)
7230 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7231 value
= (unsigned char) (tmp
[bitpos
/ 32] >> (bitpos
& 31));
7233 if (UNITS_PER_WORD
< 4)
7235 word
= byte
/ UNITS_PER_WORD
;
7236 if (WORDS_BIG_ENDIAN
)
7237 word
= (words
- 1) - word
;
7238 offset
= word
* UNITS_PER_WORD
;
7239 if (BYTES_BIG_ENDIAN
)
7240 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7242 offset
+= byte
% UNITS_PER_WORD
;
7247 if (BYTES_BIG_ENDIAN
)
7249 /* Reverse bytes within each long, or within the entire float
7250 if it's smaller than a long (for HFmode). */
7251 offset
= MIN (3, total_bytes
- 1) - offset
;
7252 gcc_assert (offset
>= 0);
7255 offset
= offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3);
7257 && offset
- off
< len
)
7258 ptr
[offset
- off
] = value
;
7260 return MIN (len
, total_bytes
- off
);
7263 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7264 specified by EXPR into the buffer PTR of length LEN bytes.
7265 Return the number of bytes placed in the buffer, or zero
7269 native_encode_complex (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7274 part
= TREE_REALPART (expr
);
7275 rsize
= native_encode_expr (part
, ptr
, len
, off
);
7276 if (off
== -1 && rsize
== 0)
7278 part
= TREE_IMAGPART (expr
);
7280 off
= MAX (0, off
- GET_MODE_SIZE (SCALAR_TYPE_MODE (TREE_TYPE (part
))));
7281 isize
= native_encode_expr (part
, ptr
? ptr
+ rsize
: NULL
,
7283 if (off
== -1 && isize
!= rsize
)
7285 return rsize
+ isize
;
7289 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7290 specified by EXPR into the buffer PTR of length LEN bytes.
7291 Return the number of bytes placed in the buffer, or zero
7295 native_encode_vector (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7297 unsigned HOST_WIDE_INT i
, count
;
7302 if (!VECTOR_CST_NELTS (expr
).is_constant (&count
))
7304 itype
= TREE_TYPE (TREE_TYPE (expr
));
7305 size
= GET_MODE_SIZE (SCALAR_TYPE_MODE (itype
));
7306 for (i
= 0; i
< count
; i
++)
7313 elem
= VECTOR_CST_ELT (expr
, i
);
7314 int res
= native_encode_expr (elem
, ptr
? ptr
+ offset
: NULL
,
7316 if ((off
== -1 && res
!= size
) || res
== 0)
7320 return (off
== -1 && i
< count
- 1) ? 0 : offset
;
7328 /* Subroutine of native_encode_expr. Encode the STRING_CST
7329 specified by EXPR into the buffer PTR of length LEN bytes.
7330 Return the number of bytes placed in the buffer, or zero
7334 native_encode_string (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7336 tree type
= TREE_TYPE (expr
);
7338 /* Wide-char strings are encoded in target byte-order so native
7339 encoding them is trivial. */
7340 if (BITS_PER_UNIT
!= CHAR_BIT
7341 || TREE_CODE (type
) != ARRAY_TYPE
7342 || TREE_CODE (TREE_TYPE (type
)) != INTEGER_TYPE
7343 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type
)))
7346 HOST_WIDE_INT total_bytes
= tree_to_shwi (TYPE_SIZE_UNIT (TREE_TYPE (expr
)));
7347 if ((off
== -1 && total_bytes
> len
) || off
>= total_bytes
)
7353 else if (TREE_STRING_LENGTH (expr
) - off
< MIN (total_bytes
, len
))
7356 if (off
< TREE_STRING_LENGTH (expr
))
7358 written
= MIN (len
, TREE_STRING_LENGTH (expr
) - off
);
7359 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, written
);
7361 memset (ptr
+ written
, 0,
7362 MIN (total_bytes
- written
, len
- written
));
7365 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, MIN (total_bytes
, len
));
7366 return MIN (total_bytes
- off
, len
);
7370 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7371 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7372 buffer PTR of length LEN bytes. If PTR is NULL, don't actually store
7373 anything, just do a dry run. If OFF is not -1 then start
7374 the encoding at byte offset OFF and encode at most LEN bytes.
7375 Return the number of bytes placed in the buffer, or zero upon failure. */
7378 native_encode_expr (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7380 /* We don't support starting at negative offset and -1 is special. */
7384 switch (TREE_CODE (expr
))
7387 return native_encode_int (expr
, ptr
, len
, off
);
7390 return native_encode_real (expr
, ptr
, len
, off
);
7393 return native_encode_fixed (expr
, ptr
, len
, off
);
7396 return native_encode_complex (expr
, ptr
, len
, off
);
7399 return native_encode_vector (expr
, ptr
, len
, off
);
7402 return native_encode_string (expr
, ptr
, len
, off
);
7410 /* Subroutine of native_interpret_expr. Interpret the contents of
7411 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7412 If the buffer cannot be interpreted, return NULL_TREE. */
7415 native_interpret_int (tree type
, const unsigned char *ptr
, int len
)
7417 int total_bytes
= GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (type
));
7419 if (total_bytes
> len
7420 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7423 wide_int result
= wi::from_buffer (ptr
, total_bytes
);
7425 return wide_int_to_tree (type
, result
);
7429 /* Subroutine of native_interpret_expr. Interpret the contents of
7430 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7431 If the buffer cannot be interpreted, return NULL_TREE. */
7434 native_interpret_fixed (tree type
, const unsigned char *ptr
, int len
)
7436 scalar_mode mode
= SCALAR_TYPE_MODE (type
);
7437 int total_bytes
= GET_MODE_SIZE (mode
);
7439 FIXED_VALUE_TYPE fixed_value
;
7441 if (total_bytes
> len
7442 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7445 result
= double_int::from_buffer (ptr
, total_bytes
);
7446 fixed_value
= fixed_from_double_int (result
, mode
);
7448 return build_fixed (type
, fixed_value
);
7452 /* Subroutine of native_interpret_expr. Interpret the contents of
7453 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7454 If the buffer cannot be interpreted, return NULL_TREE. */
7457 native_interpret_real (tree type
, const unsigned char *ptr
, int len
)
7459 scalar_float_mode mode
= SCALAR_FLOAT_TYPE_MODE (type
);
7460 int total_bytes
= GET_MODE_SIZE (mode
);
7461 unsigned char value
;
7462 /* There are always 32 bits in each long, no matter the size of
7463 the hosts long. We handle floating point representations with
7468 if (total_bytes
> len
|| total_bytes
> 24)
7470 int words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7472 memset (tmp
, 0, sizeof (tmp
));
7473 for (int bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7474 bitpos
+= BITS_PER_UNIT
)
7476 /* Both OFFSET and BYTE index within a long;
7477 bitpos indexes the whole float. */
7478 int offset
, byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7479 if (UNITS_PER_WORD
< 4)
7481 int word
= byte
/ UNITS_PER_WORD
;
7482 if (WORDS_BIG_ENDIAN
)
7483 word
= (words
- 1) - word
;
7484 offset
= word
* UNITS_PER_WORD
;
7485 if (BYTES_BIG_ENDIAN
)
7486 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7488 offset
+= byte
% UNITS_PER_WORD
;
7493 if (BYTES_BIG_ENDIAN
)
7495 /* Reverse bytes within each long, or within the entire float
7496 if it's smaller than a long (for HFmode). */
7497 offset
= MIN (3, total_bytes
- 1) - offset
;
7498 gcc_assert (offset
>= 0);
7501 value
= ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)];
7503 tmp
[bitpos
/ 32] |= (unsigned long)value
<< (bitpos
& 31);
7506 real_from_target (&r
, tmp
, mode
);
7507 return build_real (type
, r
);
7511 /* Subroutine of native_interpret_expr. Interpret the contents of
7512 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7513 If the buffer cannot be interpreted, return NULL_TREE. */
7516 native_interpret_complex (tree type
, const unsigned char *ptr
, int len
)
7518 tree etype
, rpart
, ipart
;
7521 etype
= TREE_TYPE (type
);
7522 size
= GET_MODE_SIZE (SCALAR_TYPE_MODE (etype
));
7525 rpart
= native_interpret_expr (etype
, ptr
, size
);
7528 ipart
= native_interpret_expr (etype
, ptr
+size
, size
);
7531 return build_complex (type
, rpart
, ipart
);
7535 /* Subroutine of native_interpret_expr. Interpret the contents of
7536 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7537 If the buffer cannot be interpreted, return NULL_TREE. */
7540 native_interpret_vector (tree type
, const unsigned char *ptr
, unsigned int len
)
7543 unsigned int i
, size
;
7544 unsigned HOST_WIDE_INT count
;
7546 etype
= TREE_TYPE (type
);
7547 size
= GET_MODE_SIZE (SCALAR_TYPE_MODE (etype
));
7548 if (!TYPE_VECTOR_SUBPARTS (type
).is_constant (&count
)
7549 || size
* count
> len
)
7552 tree_vector_builder
elements (type
, count
, 1);
7553 for (i
= 0; i
< count
; ++i
)
7555 elem
= native_interpret_expr (etype
, ptr
+(i
*size
), size
);
7558 elements
.quick_push (elem
);
7560 return elements
.build ();
7564 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7565 the buffer PTR of length LEN as a constant of type TYPE. For
7566 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7567 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7568 return NULL_TREE. */
7571 native_interpret_expr (tree type
, const unsigned char *ptr
, int len
)
7573 switch (TREE_CODE (type
))
7579 case REFERENCE_TYPE
:
7580 return native_interpret_int (type
, ptr
, len
);
7583 return native_interpret_real (type
, ptr
, len
);
7585 case FIXED_POINT_TYPE
:
7586 return native_interpret_fixed (type
, ptr
, len
);
7589 return native_interpret_complex (type
, ptr
, len
);
7592 return native_interpret_vector (type
, ptr
, len
);
7599 /* Returns true if we can interpret the contents of a native encoding
7603 can_native_interpret_type_p (tree type
)
7605 switch (TREE_CODE (type
))
7611 case REFERENCE_TYPE
:
7612 case FIXED_POINT_TYPE
:
7623 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7624 TYPE at compile-time. If we're unable to perform the conversion
7625 return NULL_TREE. */
7628 fold_view_convert_expr (tree type
, tree expr
)
7630 /* We support up to 512-bit values (for V8DFmode). */
7631 unsigned char buffer
[64];
7634 /* Check that the host and target are sane. */
7635 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
7638 len
= native_encode_expr (expr
, buffer
, sizeof (buffer
));
7642 return native_interpret_expr (type
, buffer
, len
);
7645 /* Build an expression for the address of T. Folds away INDIRECT_REF
7646 to avoid confusing the gimplify process. */
7649 build_fold_addr_expr_with_type_loc (location_t loc
, tree t
, tree ptrtype
)
7651 /* The size of the object is not relevant when talking about its address. */
7652 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
7653 t
= TREE_OPERAND (t
, 0);
7655 if (TREE_CODE (t
) == INDIRECT_REF
)
7657 t
= TREE_OPERAND (t
, 0);
7659 if (TREE_TYPE (t
) != ptrtype
)
7660 t
= build1_loc (loc
, NOP_EXPR
, ptrtype
, t
);
7662 else if (TREE_CODE (t
) == MEM_REF
7663 && integer_zerop (TREE_OPERAND (t
, 1)))
7664 return TREE_OPERAND (t
, 0);
7665 else if (TREE_CODE (t
) == MEM_REF
7666 && TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
7667 return fold_binary (POINTER_PLUS_EXPR
, ptrtype
,
7668 TREE_OPERAND (t
, 0),
7669 convert_to_ptrofftype (TREE_OPERAND (t
, 1)));
7670 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
7672 t
= build_fold_addr_expr_loc (loc
, TREE_OPERAND (t
, 0));
7674 if (TREE_TYPE (t
) != ptrtype
)
7675 t
= fold_convert_loc (loc
, ptrtype
, t
);
7678 t
= build1_loc (loc
, ADDR_EXPR
, ptrtype
, t
);
7683 /* Build an expression for the address of T. */
7686 build_fold_addr_expr_loc (location_t loc
, tree t
)
7688 tree ptrtype
= build_pointer_type (TREE_TYPE (t
));
7690 return build_fold_addr_expr_with_type_loc (loc
, t
, ptrtype
);
7693 /* Fold a unary expression of code CODE and type TYPE with operand
7694 OP0. Return the folded expression if folding is successful.
7695 Otherwise, return NULL_TREE. */
7698 fold_unary_loc (location_t loc
, enum tree_code code
, tree type
, tree op0
)
7702 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
7704 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
7705 && TREE_CODE_LENGTH (code
) == 1);
7710 if (CONVERT_EXPR_CODE_P (code
)
7711 || code
== FLOAT_EXPR
|| code
== ABS_EXPR
|| code
== NEGATE_EXPR
)
7713 /* Don't use STRIP_NOPS, because signedness of argument type
7715 STRIP_SIGN_NOPS (arg0
);
7719 /* Strip any conversions that don't change the mode. This
7720 is safe for every expression, except for a comparison
7721 expression because its signedness is derived from its
7724 Note that this is done as an internal manipulation within
7725 the constant folder, in order to find the simplest
7726 representation of the arguments so that their form can be
7727 studied. In any cases, the appropriate type conversions
7728 should be put back in the tree that will get out of the
7733 if (CONSTANT_CLASS_P (arg0
))
7735 tree tem
= const_unop (code
, type
, arg0
);
7738 if (TREE_TYPE (tem
) != type
)
7739 tem
= fold_convert_loc (loc
, type
, tem
);
7745 tem
= generic_simplify (loc
, code
, type
, op0
);
7749 if (TREE_CODE_CLASS (code
) == tcc_unary
)
7751 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
7752 return build2 (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7753 fold_build1_loc (loc
, code
, type
,
7754 fold_convert_loc (loc
, TREE_TYPE (op0
),
7755 TREE_OPERAND (arg0
, 1))));
7756 else if (TREE_CODE (arg0
) == COND_EXPR
)
7758 tree arg01
= TREE_OPERAND (arg0
, 1);
7759 tree arg02
= TREE_OPERAND (arg0
, 2);
7760 if (! VOID_TYPE_P (TREE_TYPE (arg01
)))
7761 arg01
= fold_build1_loc (loc
, code
, type
,
7762 fold_convert_loc (loc
,
7763 TREE_TYPE (op0
), arg01
));
7764 if (! VOID_TYPE_P (TREE_TYPE (arg02
)))
7765 arg02
= fold_build1_loc (loc
, code
, type
,
7766 fold_convert_loc (loc
,
7767 TREE_TYPE (op0
), arg02
));
7768 tem
= fold_build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7771 /* If this was a conversion, and all we did was to move into
7772 inside the COND_EXPR, bring it back out. But leave it if
7773 it is a conversion from integer to integer and the
7774 result precision is no wider than a word since such a
7775 conversion is cheap and may be optimized away by combine,
7776 while it couldn't if it were outside the COND_EXPR. Then return
7777 so we don't get into an infinite recursion loop taking the
7778 conversion out and then back in. */
7780 if ((CONVERT_EXPR_CODE_P (code
)
7781 || code
== NON_LVALUE_EXPR
)
7782 && TREE_CODE (tem
) == COND_EXPR
7783 && TREE_CODE (TREE_OPERAND (tem
, 1)) == code
7784 && TREE_CODE (TREE_OPERAND (tem
, 2)) == code
7785 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 1))
7786 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 2))
7787 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))
7788 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 2), 0)))
7789 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7791 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))))
7792 && TYPE_PRECISION (TREE_TYPE (tem
)) <= BITS_PER_WORD
)
7793 || flag_syntax_only
))
7794 tem
= build1_loc (loc
, code
, type
,
7796 TREE_TYPE (TREE_OPERAND
7797 (TREE_OPERAND (tem
, 1), 0)),
7798 TREE_OPERAND (tem
, 0),
7799 TREE_OPERAND (TREE_OPERAND (tem
, 1), 0),
7800 TREE_OPERAND (TREE_OPERAND (tem
, 2),
7808 case NON_LVALUE_EXPR
:
7809 if (!maybe_lvalue_p (op0
))
7810 return fold_convert_loc (loc
, type
, op0
);
7815 case FIX_TRUNC_EXPR
:
7816 if (COMPARISON_CLASS_P (op0
))
7818 /* If we have (type) (a CMP b) and type is an integral type, return
7819 new expression involving the new type. Canonicalize
7820 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7822 Do not fold the result as that would not simplify further, also
7823 folding again results in recursions. */
7824 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
7825 return build2_loc (loc
, TREE_CODE (op0
), type
,
7826 TREE_OPERAND (op0
, 0),
7827 TREE_OPERAND (op0
, 1));
7828 else if (!INTEGRAL_TYPE_P (type
) && !VOID_TYPE_P (type
)
7829 && TREE_CODE (type
) != VECTOR_TYPE
)
7830 return build3_loc (loc
, COND_EXPR
, type
, op0
,
7831 constant_boolean_node (true, type
),
7832 constant_boolean_node (false, type
));
7835 /* Handle (T *)&A.B.C for A being of type T and B and C
7836 living at offset zero. This occurs frequently in
7837 C++ upcasting and then accessing the base. */
7838 if (TREE_CODE (op0
) == ADDR_EXPR
7839 && POINTER_TYPE_P (type
)
7840 && handled_component_p (TREE_OPERAND (op0
, 0)))
7842 poly_int64 bitsize
, bitpos
;
7845 int unsignedp
, reversep
, volatilep
;
7847 = get_inner_reference (TREE_OPERAND (op0
, 0), &bitsize
, &bitpos
,
7848 &offset
, &mode
, &unsignedp
, &reversep
,
7850 /* If the reference was to a (constant) zero offset, we can use
7851 the address of the base if it has the same base type
7852 as the result type and the pointer type is unqualified. */
7854 && known_eq (bitpos
, 0)
7855 && (TYPE_MAIN_VARIANT (TREE_TYPE (type
))
7856 == TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
7857 && TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
7858 return fold_convert_loc (loc
, type
,
7859 build_fold_addr_expr_loc (loc
, base
));
7862 if (TREE_CODE (op0
) == MODIFY_EXPR
7863 && TREE_CONSTANT (TREE_OPERAND (op0
, 1))
7864 /* Detect assigning a bitfield. */
7865 && !(TREE_CODE (TREE_OPERAND (op0
, 0)) == COMPONENT_REF
7867 (TREE_OPERAND (TREE_OPERAND (op0
, 0), 1))))
7869 /* Don't leave an assignment inside a conversion
7870 unless assigning a bitfield. */
7871 tem
= fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 1));
7872 /* First do the assignment, then return converted constant. */
7873 tem
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (tem
), op0
, tem
);
7874 TREE_NO_WARNING (tem
) = 1;
7875 TREE_USED (tem
) = 1;
7879 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7880 constants (if x has signed type, the sign bit cannot be set
7881 in c). This folds extension into the BIT_AND_EXPR.
7882 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7883 very likely don't have maximal range for their precision and this
7884 transformation effectively doesn't preserve non-maximal ranges. */
7885 if (TREE_CODE (type
) == INTEGER_TYPE
7886 && TREE_CODE (op0
) == BIT_AND_EXPR
7887 && TREE_CODE (TREE_OPERAND (op0
, 1)) == INTEGER_CST
)
7889 tree and_expr
= op0
;
7890 tree and0
= TREE_OPERAND (and_expr
, 0);
7891 tree and1
= TREE_OPERAND (and_expr
, 1);
7894 if (TYPE_UNSIGNED (TREE_TYPE (and_expr
))
7895 || (TYPE_PRECISION (type
)
7896 <= TYPE_PRECISION (TREE_TYPE (and_expr
))))
7898 else if (TYPE_PRECISION (TREE_TYPE (and1
))
7899 <= HOST_BITS_PER_WIDE_INT
7900 && tree_fits_uhwi_p (and1
))
7902 unsigned HOST_WIDE_INT cst
;
7904 cst
= tree_to_uhwi (and1
);
7905 cst
&= HOST_WIDE_INT_M1U
7906 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
7907 change
= (cst
== 0);
7909 && !flag_syntax_only
7910 && (load_extend_op (TYPE_MODE (TREE_TYPE (and0
)))
7913 tree uns
= unsigned_type_for (TREE_TYPE (and0
));
7914 and0
= fold_convert_loc (loc
, uns
, and0
);
7915 and1
= fold_convert_loc (loc
, uns
, and1
);
7920 tem
= force_fit_type (type
, wi::to_widest (and1
), 0,
7921 TREE_OVERFLOW (and1
));
7922 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
7923 fold_convert_loc (loc
, type
, and0
), tem
);
7927 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type, when the new
7928 cast (T1)X will fold away. We assume that this happens when X itself
7930 if (POINTER_TYPE_P (type
)
7931 && TREE_CODE (arg0
) == POINTER_PLUS_EXPR
7932 && CONVERT_EXPR_P (TREE_OPERAND (arg0
, 0)))
7934 tree arg00
= TREE_OPERAND (arg0
, 0);
7935 tree arg01
= TREE_OPERAND (arg0
, 1);
7937 return fold_build_pointer_plus_loc
7938 (loc
, fold_convert_loc (loc
, type
, arg00
), arg01
);
7941 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7942 of the same precision, and X is an integer type not narrower than
7943 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7944 if (INTEGRAL_TYPE_P (type
)
7945 && TREE_CODE (op0
) == BIT_NOT_EXPR
7946 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7947 && CONVERT_EXPR_P (TREE_OPERAND (op0
, 0))
7948 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
7950 tem
= TREE_OPERAND (TREE_OPERAND (op0
, 0), 0);
7951 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7952 && TYPE_PRECISION (type
) <= TYPE_PRECISION (TREE_TYPE (tem
)))
7953 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
7954 fold_convert_loc (loc
, type
, tem
));
7957 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7958 type of X and Y (integer types only). */
7959 if (INTEGRAL_TYPE_P (type
)
7960 && TREE_CODE (op0
) == MULT_EXPR
7961 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7962 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7964 /* Be careful not to introduce new overflows. */
7966 if (TYPE_OVERFLOW_WRAPS (type
))
7969 mult_type
= unsigned_type_for (type
);
7971 if (TYPE_PRECISION (mult_type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7973 tem
= fold_build2_loc (loc
, MULT_EXPR
, mult_type
,
7974 fold_convert_loc (loc
, mult_type
,
7975 TREE_OPERAND (op0
, 0)),
7976 fold_convert_loc (loc
, mult_type
,
7977 TREE_OPERAND (op0
, 1)));
7978 return fold_convert_loc (loc
, type
, tem
);
7984 case VIEW_CONVERT_EXPR
:
7985 if (TREE_CODE (op0
) == MEM_REF
)
7987 if (TYPE_ALIGN (TREE_TYPE (op0
)) != TYPE_ALIGN (type
))
7988 type
= build_aligned_type (type
, TYPE_ALIGN (TREE_TYPE (op0
)));
7989 tem
= fold_build2_loc (loc
, MEM_REF
, type
,
7990 TREE_OPERAND (op0
, 0), TREE_OPERAND (op0
, 1));
7991 REF_REVERSE_STORAGE_ORDER (tem
) = REF_REVERSE_STORAGE_ORDER (op0
);
7998 tem
= fold_negate_expr (loc
, arg0
);
8000 return fold_convert_loc (loc
, type
, tem
);
8004 /* Convert fabs((double)float) into (double)fabsf(float). */
8005 if (TREE_CODE (arg0
) == NOP_EXPR
8006 && TREE_CODE (type
) == REAL_TYPE
)
8008 tree targ0
= strip_float_extensions (arg0
);
8010 return fold_convert_loc (loc
, type
,
8011 fold_build1_loc (loc
, ABS_EXPR
,
8018 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8019 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8020 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8021 fold_convert_loc (loc
, type
,
8022 TREE_OPERAND (arg0
, 0)))))
8023 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, tem
,
8024 fold_convert_loc (loc
, type
,
8025 TREE_OPERAND (arg0
, 1)));
8026 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8027 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8028 fold_convert_loc (loc
, type
,
8029 TREE_OPERAND (arg0
, 1)))))
8030 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
8031 fold_convert_loc (loc
, type
,
8032 TREE_OPERAND (arg0
, 0)), tem
);
8036 case TRUTH_NOT_EXPR
:
8037 /* Note that the operand of this must be an int
8038 and its values must be 0 or 1.
8039 ("true" is a fixed value perhaps depending on the language,
8040 but we don't handle values other than 1 correctly yet.) */
8041 tem
= fold_truth_not_expr (loc
, arg0
);
8044 return fold_convert_loc (loc
, type
, tem
);
8047 /* Fold *&X to X if X is an lvalue. */
8048 if (TREE_CODE (op0
) == ADDR_EXPR
)
8050 tree op00
= TREE_OPERAND (op0
, 0);
8052 || TREE_CODE (op00
) == PARM_DECL
8053 || TREE_CODE (op00
) == RESULT_DECL
)
8054 && !TREE_READONLY (op00
))
8061 } /* switch (code) */
8065 /* If the operation was a conversion do _not_ mark a resulting constant
8066 with TREE_OVERFLOW if the original constant was not. These conversions
8067 have implementation defined behavior and retaining the TREE_OVERFLOW
8068 flag here would confuse later passes such as VRP. */
8070 fold_unary_ignore_overflow_loc (location_t loc
, enum tree_code code
,
8071 tree type
, tree op0
)
8073 tree res
= fold_unary_loc (loc
, code
, type
, op0
);
8075 && TREE_CODE (res
) == INTEGER_CST
8076 && TREE_CODE (op0
) == INTEGER_CST
8077 && CONVERT_EXPR_CODE_P (code
))
8078 TREE_OVERFLOW (res
) = TREE_OVERFLOW (op0
);
8083 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8084 operands OP0 and OP1. LOC is the location of the resulting expression.
8085 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8086 Return the folded expression if folding is successful. Otherwise,
8087 return NULL_TREE. */
8089 fold_truth_andor (location_t loc
, enum tree_code code
, tree type
,
8090 tree arg0
, tree arg1
, tree op0
, tree op1
)
8094 /* We only do these simplifications if we are optimizing. */
8098 /* Check for things like (A || B) && (A || C). We can convert this
8099 to A || (B && C). Note that either operator can be any of the four
8100 truth and/or operations and the transformation will still be
8101 valid. Also note that we only care about order for the
8102 ANDIF and ORIF operators. If B contains side effects, this
8103 might change the truth-value of A. */
8104 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8105 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
8106 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
8107 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
8108 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
8109 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
8111 tree a00
= TREE_OPERAND (arg0
, 0);
8112 tree a01
= TREE_OPERAND (arg0
, 1);
8113 tree a10
= TREE_OPERAND (arg1
, 0);
8114 tree a11
= TREE_OPERAND (arg1
, 1);
8115 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
8116 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
8117 && (code
== TRUTH_AND_EXPR
8118 || code
== TRUTH_OR_EXPR
));
8120 if (operand_equal_p (a00
, a10
, 0))
8121 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8122 fold_build2_loc (loc
, code
, type
, a01
, a11
));
8123 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
8124 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8125 fold_build2_loc (loc
, code
, type
, a01
, a10
));
8126 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
8127 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a01
,
8128 fold_build2_loc (loc
, code
, type
, a00
, a11
));
8130 /* This case if tricky because we must either have commutative
8131 operators or else A10 must not have side-effects. */
8133 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
8134 && operand_equal_p (a01
, a11
, 0))
8135 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
8136 fold_build2_loc (loc
, code
, type
, a00
, a10
),
8140 /* See if we can build a range comparison. */
8141 if ((tem
= fold_range_test (loc
, code
, type
, op0
, op1
)) != 0)
8144 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
)
8145 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
))
8147 tem
= merge_truthop_with_opposite_arm (loc
, arg0
, arg1
, true);
8149 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
8152 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ORIF_EXPR
)
8153 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ANDIF_EXPR
))
8155 tem
= merge_truthop_with_opposite_arm (loc
, arg1
, arg0
, false);
8157 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
8160 /* Check for the possibility of merging component references. If our
8161 lhs is another similar operation, try to merge its rhs with our
8162 rhs. Then try to merge our lhs and rhs. */
8163 if (TREE_CODE (arg0
) == code
8164 && (tem
= fold_truth_andor_1 (loc
, code
, type
,
8165 TREE_OPERAND (arg0
, 1), arg1
)) != 0)
8166 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
8168 if ((tem
= fold_truth_andor_1 (loc
, code
, type
, arg0
, arg1
)) != 0)
8171 bool logical_op_non_short_circuit
= LOGICAL_OP_NON_SHORT_CIRCUIT
;
8172 if (PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT
) != -1)
8173 logical_op_non_short_circuit
8174 = PARAM_VALUE (PARAM_LOGICAL_OP_NON_SHORT_CIRCUIT
);
8175 if (logical_op_non_short_circuit
8176 && !flag_sanitize_coverage
8177 && (code
== TRUTH_AND_EXPR
8178 || code
== TRUTH_ANDIF_EXPR
8179 || code
== TRUTH_OR_EXPR
8180 || code
== TRUTH_ORIF_EXPR
))
8182 enum tree_code ncode
, icode
;
8184 ncode
= (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_AND_EXPR
)
8185 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
;
8186 icode
= ncode
== TRUTH_AND_EXPR
? TRUTH_ANDIF_EXPR
: TRUTH_ORIF_EXPR
;
8188 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8189 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8190 We don't want to pack more than two leafs to a non-IF AND/OR
8192 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8193 equal to IF-CODE, then we don't want to add right-hand operand.
8194 If the inner right-hand side of left-hand operand has
8195 side-effects, or isn't simple, then we can't add to it,
8196 as otherwise we might destroy if-sequence. */
8197 if (TREE_CODE (arg0
) == icode
8198 && simple_operand_p_2 (arg1
)
8199 /* Needed for sequence points to handle trappings, and
8201 && simple_operand_p_2 (TREE_OPERAND (arg0
, 1)))
8203 tem
= fold_build2_loc (loc
, ncode
, type
, TREE_OPERAND (arg0
, 1),
8205 return fold_build2_loc (loc
, icode
, type
, TREE_OPERAND (arg0
, 0),
8208 /* Same as above but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8209 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8210 else if (TREE_CODE (arg1
) == icode
8211 && simple_operand_p_2 (arg0
)
8212 /* Needed for sequence points to handle trappings, and
8214 && simple_operand_p_2 (TREE_OPERAND (arg1
, 0)))
8216 tem
= fold_build2_loc (loc
, ncode
, type
,
8217 arg0
, TREE_OPERAND (arg1
, 0));
8218 return fold_build2_loc (loc
, icode
, type
, tem
,
8219 TREE_OPERAND (arg1
, 1));
8221 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8223 For sequence point consistancy, we need to check for trapping,
8224 and side-effects. */
8225 else if (code
== icode
&& simple_operand_p_2 (arg0
)
8226 && simple_operand_p_2 (arg1
))
8227 return fold_build2_loc (loc
, ncode
, type
, arg0
, arg1
);
8233 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8234 by changing CODE to reduce the magnitude of constants involved in
8235 ARG0 of the comparison.
8236 Returns a canonicalized comparison tree if a simplification was
8237 possible, otherwise returns NULL_TREE.
8238 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8239 valid if signed overflow is undefined. */
8242 maybe_canonicalize_comparison_1 (location_t loc
, enum tree_code code
, tree type
,
8243 tree arg0
, tree arg1
,
8244 bool *strict_overflow_p
)
8246 enum tree_code code0
= TREE_CODE (arg0
);
8247 tree t
, cst0
= NULL_TREE
;
8250 /* Match A +- CST code arg1. We can change this only if overflow
8252 if (!((ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8253 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8254 /* In principle pointers also have undefined overflow behavior,
8255 but that causes problems elsewhere. */
8256 && !POINTER_TYPE_P (TREE_TYPE (arg0
))
8257 && (code0
== MINUS_EXPR
8258 || code0
== PLUS_EXPR
)
8259 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
))
8262 /* Identify the constant in arg0 and its sign. */
8263 cst0
= TREE_OPERAND (arg0
, 1);
8264 sgn0
= tree_int_cst_sgn (cst0
);
8266 /* Overflowed constants and zero will cause problems. */
8267 if (integer_zerop (cst0
)
8268 || TREE_OVERFLOW (cst0
))
8271 /* See if we can reduce the magnitude of the constant in
8272 arg0 by changing the comparison code. */
8273 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8275 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8277 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8278 else if (code
== GT_EXPR
8279 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8281 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8282 else if (code
== LE_EXPR
8283 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8285 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8286 else if (code
== GE_EXPR
8287 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8291 *strict_overflow_p
= true;
8293 /* Now build the constant reduced in magnitude. But not if that
8294 would produce one outside of its types range. */
8295 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0
))
8297 && TYPE_MIN_VALUE (TREE_TYPE (cst0
))
8298 && tree_int_cst_equal (cst0
, TYPE_MIN_VALUE (TREE_TYPE (cst0
))))
8300 && TYPE_MAX_VALUE (TREE_TYPE (cst0
))
8301 && tree_int_cst_equal (cst0
, TYPE_MAX_VALUE (TREE_TYPE (cst0
))))))
8304 t
= int_const_binop (sgn0
== -1 ? PLUS_EXPR
: MINUS_EXPR
,
8305 cst0
, build_int_cst (TREE_TYPE (cst0
), 1));
8306 t
= fold_build2_loc (loc
, code0
, TREE_TYPE (arg0
), TREE_OPERAND (arg0
, 0), t
);
8307 t
= fold_convert (TREE_TYPE (arg1
), t
);
8309 return fold_build2_loc (loc
, code
, type
, t
, arg1
);
8312 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8313 overflow further. Try to decrease the magnitude of constants involved
8314 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8315 and put sole constants at the second argument position.
8316 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8319 maybe_canonicalize_comparison (location_t loc
, enum tree_code code
, tree type
,
8320 tree arg0
, tree arg1
)
8323 bool strict_overflow_p
;
8324 const char * const warnmsg
= G_("assuming signed overflow does not occur "
8325 "when reducing constant in comparison");
8327 /* Try canonicalization by simplifying arg0. */
8328 strict_overflow_p
= false;
8329 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg0
, arg1
,
8330 &strict_overflow_p
);
8333 if (strict_overflow_p
)
8334 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8338 /* Try canonicalization by simplifying arg1 using the swapped
8340 code
= swap_tree_comparison (code
);
8341 strict_overflow_p
= false;
8342 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg1
, arg0
,
8343 &strict_overflow_p
);
8344 if (t
&& strict_overflow_p
)
8345 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8349 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8350 space. This is used to avoid issuing overflow warnings for
8351 expressions like &p->x which can not wrap. */
8354 pointer_may_wrap_p (tree base
, tree offset
, poly_int64 bitpos
)
8356 if (!POINTER_TYPE_P (TREE_TYPE (base
)))
8359 if (maybe_lt (bitpos
, 0))
8362 poly_wide_int wi_offset
;
8363 int precision
= TYPE_PRECISION (TREE_TYPE (base
));
8364 if (offset
== NULL_TREE
)
8365 wi_offset
= wi::zero (precision
);
8366 else if (!poly_int_tree_p (offset
) || TREE_OVERFLOW (offset
))
8369 wi_offset
= wi::to_poly_wide (offset
);
8372 poly_wide_int units
= wi::shwi (bits_to_bytes_round_down (bitpos
),
8374 poly_wide_int total
= wi::add (wi_offset
, units
, UNSIGNED
, &overflow
);
8378 poly_uint64 total_hwi
, size
;
8379 if (!total
.to_uhwi (&total_hwi
)
8380 || !poly_int_tree_p (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (base
))),
8382 || known_eq (size
, 0U))
8385 if (known_le (total_hwi
, size
))
8388 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8390 if (TREE_CODE (base
) == ADDR_EXPR
8391 && poly_int_tree_p (TYPE_SIZE_UNIT (TREE_TYPE (TREE_OPERAND (base
, 0))),
8393 && maybe_ne (size
, 0U)
8394 && known_le (total_hwi
, size
))
8400 /* Return a positive integer when the symbol DECL is known to have
8401 a nonzero address, zero when it's known not to (e.g., it's a weak
8402 symbol), and a negative integer when the symbol is not yet in the
8403 symbol table and so whether or not its address is zero is unknown.
8404 For function local objects always return positive integer. */
8406 maybe_nonzero_address (tree decl
)
8408 if (DECL_P (decl
) && decl_in_symtab_p (decl
))
8409 if (struct symtab_node
*symbol
= symtab_node::get_create (decl
))
8410 return symbol
->nonzero_address ();
8412 /* Function local objects are never NULL. */
8414 && (DECL_CONTEXT (decl
)
8415 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
8416 && auto_var_in_fn_p (decl
, DECL_CONTEXT (decl
))))
8422 /* Subroutine of fold_binary. This routine performs all of the
8423 transformations that are common to the equality/inequality
8424 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8425 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8426 fold_binary should call fold_binary. Fold a comparison with
8427 tree code CODE and type TYPE with operands OP0 and OP1. Return
8428 the folded comparison or NULL_TREE. */
8431 fold_comparison (location_t loc
, enum tree_code code
, tree type
,
8434 const bool equality_code
= (code
== EQ_EXPR
|| code
== NE_EXPR
);
8435 tree arg0
, arg1
, tem
;
8440 STRIP_SIGN_NOPS (arg0
);
8441 STRIP_SIGN_NOPS (arg1
);
8443 /* For comparisons of pointers we can decompose it to a compile time
8444 comparison of the base objects and the offsets into the object.
8445 This requires at least one operand being an ADDR_EXPR or a
8446 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8447 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
8448 && (TREE_CODE (arg0
) == ADDR_EXPR
8449 || TREE_CODE (arg1
) == ADDR_EXPR
8450 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8451 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
8453 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
8454 poly_int64 bitsize
, bitpos0
= 0, bitpos1
= 0;
8456 int volatilep
, reversep
, unsignedp
;
8457 bool indirect_base0
= false, indirect_base1
= false;
8459 /* Get base and offset for the access. Strip ADDR_EXPR for
8460 get_inner_reference, but put it back by stripping INDIRECT_REF
8461 off the base object if possible. indirect_baseN will be true
8462 if baseN is not an address but refers to the object itself. */
8464 if (TREE_CODE (arg0
) == ADDR_EXPR
)
8467 = get_inner_reference (TREE_OPERAND (arg0
, 0),
8468 &bitsize
, &bitpos0
, &offset0
, &mode
,
8469 &unsignedp
, &reversep
, &volatilep
);
8470 if (TREE_CODE (base0
) == INDIRECT_REF
)
8471 base0
= TREE_OPERAND (base0
, 0);
8473 indirect_base0
= true;
8475 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
8477 base0
= TREE_OPERAND (arg0
, 0);
8478 STRIP_SIGN_NOPS (base0
);
8479 if (TREE_CODE (base0
) == ADDR_EXPR
)
8482 = get_inner_reference (TREE_OPERAND (base0
, 0),
8483 &bitsize
, &bitpos0
, &offset0
, &mode
,
8484 &unsignedp
, &reversep
, &volatilep
);
8485 if (TREE_CODE (base0
) == INDIRECT_REF
)
8486 base0
= TREE_OPERAND (base0
, 0);
8488 indirect_base0
= true;
8490 if (offset0
== NULL_TREE
|| integer_zerop (offset0
))
8491 offset0
= TREE_OPERAND (arg0
, 1);
8493 offset0
= size_binop (PLUS_EXPR
, offset0
,
8494 TREE_OPERAND (arg0
, 1));
8495 if (poly_int_tree_p (offset0
))
8497 poly_offset_int tem
= wi::sext (wi::to_poly_offset (offset0
),
8498 TYPE_PRECISION (sizetype
));
8499 tem
<<= LOG2_BITS_PER_UNIT
;
8501 if (tem
.to_shwi (&bitpos0
))
8502 offset0
= NULL_TREE
;
8507 if (TREE_CODE (arg1
) == ADDR_EXPR
)
8510 = get_inner_reference (TREE_OPERAND (arg1
, 0),
8511 &bitsize
, &bitpos1
, &offset1
, &mode
,
8512 &unsignedp
, &reversep
, &volatilep
);
8513 if (TREE_CODE (base1
) == INDIRECT_REF
)
8514 base1
= TREE_OPERAND (base1
, 0);
8516 indirect_base1
= true;
8518 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
8520 base1
= TREE_OPERAND (arg1
, 0);
8521 STRIP_SIGN_NOPS (base1
);
8522 if (TREE_CODE (base1
) == ADDR_EXPR
)
8525 = get_inner_reference (TREE_OPERAND (base1
, 0),
8526 &bitsize
, &bitpos1
, &offset1
, &mode
,
8527 &unsignedp
, &reversep
, &volatilep
);
8528 if (TREE_CODE (base1
) == INDIRECT_REF
)
8529 base1
= TREE_OPERAND (base1
, 0);
8531 indirect_base1
= true;
8533 if (offset1
== NULL_TREE
|| integer_zerop (offset1
))
8534 offset1
= TREE_OPERAND (arg1
, 1);
8536 offset1
= size_binop (PLUS_EXPR
, offset1
,
8537 TREE_OPERAND (arg1
, 1));
8538 if (poly_int_tree_p (offset1
))
8540 poly_offset_int tem
= wi::sext (wi::to_poly_offset (offset1
),
8541 TYPE_PRECISION (sizetype
));
8542 tem
<<= LOG2_BITS_PER_UNIT
;
8544 if (tem
.to_shwi (&bitpos1
))
8545 offset1
= NULL_TREE
;
8549 /* If we have equivalent bases we might be able to simplify. */
8550 if (indirect_base0
== indirect_base1
8551 && operand_equal_p (base0
, base1
,
8552 indirect_base0
? OEP_ADDRESS_OF
: 0))
8554 /* We can fold this expression to a constant if the non-constant
8555 offset parts are equal. */
8556 if ((offset0
== offset1
8557 || (offset0
&& offset1
8558 && operand_equal_p (offset0
, offset1
, 0)))
8561 && (DECL_P (base0
) || CONSTANT_CLASS_P (base0
)))
8562 || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))))
8565 && maybe_ne (bitpos0
, bitpos1
)
8566 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8567 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8568 fold_overflow_warning (("assuming pointer wraparound does not "
8569 "occur when comparing P +- C1 with "
8571 WARN_STRICT_OVERFLOW_CONDITIONAL
);
8576 if (known_eq (bitpos0
, bitpos1
))
8577 return constant_boolean_node (true, type
);
8578 if (known_ne (bitpos0
, bitpos1
))
8579 return constant_boolean_node (false, type
);
8582 if (known_ne (bitpos0
, bitpos1
))
8583 return constant_boolean_node (true, type
);
8584 if (known_eq (bitpos0
, bitpos1
))
8585 return constant_boolean_node (false, type
);
8588 if (known_lt (bitpos0
, bitpos1
))
8589 return constant_boolean_node (true, type
);
8590 if (known_ge (bitpos0
, bitpos1
))
8591 return constant_boolean_node (false, type
);
8594 if (known_le (bitpos0
, bitpos1
))
8595 return constant_boolean_node (true, type
);
8596 if (known_gt (bitpos0
, bitpos1
))
8597 return constant_boolean_node (false, type
);
8600 if (known_ge (bitpos0
, bitpos1
))
8601 return constant_boolean_node (true, type
);
8602 if (known_lt (bitpos0
, bitpos1
))
8603 return constant_boolean_node (false, type
);
8606 if (known_gt (bitpos0
, bitpos1
))
8607 return constant_boolean_node (true, type
);
8608 if (known_le (bitpos0
, bitpos1
))
8609 return constant_boolean_node (false, type
);
8614 /* We can simplify the comparison to a comparison of the variable
8615 offset parts if the constant offset parts are equal.
8616 Be careful to use signed sizetype here because otherwise we
8617 mess with array offsets in the wrong way. This is possible
8618 because pointer arithmetic is restricted to retain within an
8619 object and overflow on pointer differences is undefined as of
8620 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8621 else if (known_eq (bitpos0
, bitpos1
)
8624 && (DECL_P (base0
) || CONSTANT_CLASS_P (base0
)))
8625 || TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))))
8627 /* By converting to signed sizetype we cover middle-end pointer
8628 arithmetic which operates on unsigned pointer types of size
8629 type size and ARRAY_REF offsets which are properly sign or
8630 zero extended from their type in case it is narrower than
8632 if (offset0
== NULL_TREE
)
8633 offset0
= build_int_cst (ssizetype
, 0);
8635 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
8636 if (offset1
== NULL_TREE
)
8637 offset1
= build_int_cst (ssizetype
, 0);
8639 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
8642 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8643 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8644 fold_overflow_warning (("assuming pointer wraparound does not "
8645 "occur when comparing P +- C1 with "
8647 WARN_STRICT_OVERFLOW_COMPARISON
);
8649 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
8652 /* For equal offsets we can simplify to a comparison of the
8654 else if (known_eq (bitpos0
, bitpos1
)
8656 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
8658 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
8659 && ((offset0
== offset1
)
8660 || (offset0
&& offset1
8661 && operand_equal_p (offset0
, offset1
, 0))))
8664 base0
= build_fold_addr_expr_loc (loc
, base0
);
8666 base1
= build_fold_addr_expr_loc (loc
, base1
);
8667 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
8669 /* Comparison between an ordinary (non-weak) symbol and a null
8670 pointer can be eliminated since such symbols must have a non
8671 null address. In C, relational expressions between pointers
8672 to objects and null pointers are undefined. The results
8673 below follow the C++ rules with the additional property that
8674 every object pointer compares greater than a null pointer.
8676 else if (((DECL_P (base0
)
8677 && maybe_nonzero_address (base0
) > 0
8678 /* Avoid folding references to struct members at offset 0 to
8679 prevent tests like '&ptr->firstmember == 0' from getting
8680 eliminated. When ptr is null, although the -> expression
8681 is strictly speaking invalid, GCC retains it as a matter
8682 of QoI. See PR c/44555. */
8683 && (offset0
== NULL_TREE
&& known_ne (bitpos0
, 0)))
8684 || CONSTANT_CLASS_P (base0
))
8686 /* The caller guarantees that when one of the arguments is
8687 constant (i.e., null in this case) it is second. */
8688 && integer_zerop (arg1
))
8695 return constant_boolean_node (false, type
);
8699 return constant_boolean_node (true, type
);
8706 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8707 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
8708 the resulting offset is smaller in absolute value than the
8709 original one and has the same sign. */
8710 if (ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
8711 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
8712 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8713 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8714 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
8715 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
8716 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
8717 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
8719 tree const1
= TREE_OPERAND (arg0
, 1);
8720 tree const2
= TREE_OPERAND (arg1
, 1);
8721 tree variable1
= TREE_OPERAND (arg0
, 0);
8722 tree variable2
= TREE_OPERAND (arg1
, 0);
8724 const char * const warnmsg
= G_("assuming signed overflow does not "
8725 "occur when combining constants around "
8728 /* Put the constant on the side where it doesn't overflow and is
8729 of lower absolute value and of same sign than before. */
8730 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8731 ? MINUS_EXPR
: PLUS_EXPR
,
8733 if (!TREE_OVERFLOW (cst
)
8734 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
)
8735 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const2
))
8737 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8738 return fold_build2_loc (loc
, code
, type
,
8740 fold_build2_loc (loc
, TREE_CODE (arg1
),
8745 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8746 ? MINUS_EXPR
: PLUS_EXPR
,
8748 if (!TREE_OVERFLOW (cst
)
8749 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
)
8750 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const1
))
8752 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
8753 return fold_build2_loc (loc
, code
, type
,
8754 fold_build2_loc (loc
, TREE_CODE (arg0
),
8761 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
8765 /* If we are comparing an expression that just has comparisons
8766 of two integer values, arithmetic expressions of those comparisons,
8767 and constants, we can simplify it. There are only three cases
8768 to check: the two values can either be equal, the first can be
8769 greater, or the second can be greater. Fold the expression for
8770 those three values. Since each value must be 0 or 1, we have
8771 eight possibilities, each of which corresponds to the constant 0
8772 or 1 or one of the six possible comparisons.
8774 This handles common cases like (a > b) == 0 but also handles
8775 expressions like ((x > y) - (y > x)) > 0, which supposedly
8776 occur in macroized code. */
8778 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
8780 tree cval1
= 0, cval2
= 0;
8782 if (twoval_comparison_p (arg0
, &cval1
, &cval2
)
8783 /* Don't handle degenerate cases here; they should already
8784 have been handled anyway. */
8785 && cval1
!= 0 && cval2
!= 0
8786 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
8787 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
8788 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
8789 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
8790 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
8791 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
8792 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
8794 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
8795 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
8797 /* We can't just pass T to eval_subst in case cval1 or cval2
8798 was the same as ARG1. */
8801 = fold_build2_loc (loc
, code
, type
,
8802 eval_subst (loc
, arg0
, cval1
, maxval
,
8806 = fold_build2_loc (loc
, code
, type
,
8807 eval_subst (loc
, arg0
, cval1
, maxval
,
8811 = fold_build2_loc (loc
, code
, type
,
8812 eval_subst (loc
, arg0
, cval1
, minval
,
8816 /* All three of these results should be 0 or 1. Confirm they are.
8817 Then use those values to select the proper code to use. */
8819 if (TREE_CODE (high_result
) == INTEGER_CST
8820 && TREE_CODE (equal_result
) == INTEGER_CST
8821 && TREE_CODE (low_result
) == INTEGER_CST
)
8823 /* Make a 3-bit mask with the high-order bit being the
8824 value for `>', the next for '=', and the low for '<'. */
8825 switch ((integer_onep (high_result
) * 4)
8826 + (integer_onep (equal_result
) * 2)
8827 + integer_onep (low_result
))
8831 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
8852 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
8855 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
8864 /* Subroutine of fold_binary. Optimize complex multiplications of the
8865 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
8866 argument EXPR represents the expression "z" of type TYPE. */
8869 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
8871 tree itype
= TREE_TYPE (type
);
8872 tree rpart
, ipart
, tem
;
8874 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
8876 rpart
= TREE_OPERAND (expr
, 0);
8877 ipart
= TREE_OPERAND (expr
, 1);
8879 else if (TREE_CODE (expr
) == COMPLEX_CST
)
8881 rpart
= TREE_REALPART (expr
);
8882 ipart
= TREE_IMAGPART (expr
);
8886 expr
= save_expr (expr
);
8887 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
8888 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
8891 rpart
= save_expr (rpart
);
8892 ipart
= save_expr (ipart
);
8893 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
8894 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
8895 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
8896 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
8897 build_zero_cst (itype
));
8901 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
8902 CONSTRUCTOR ARG into array ELTS, which has NELTS elements, and return
8903 true if successful. */
8906 vec_cst_ctor_to_array (tree arg
, unsigned int nelts
, tree
*elts
)
8908 unsigned HOST_WIDE_INT i
, nunits
;
8910 if (TREE_CODE (arg
) == VECTOR_CST
8911 && VECTOR_CST_NELTS (arg
).is_constant (&nunits
))
8913 for (i
= 0; i
< nunits
; ++i
)
8914 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
8916 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
8918 constructor_elt
*elt
;
8920 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
8921 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
8924 elts
[i
] = elt
->value
;
8928 for (; i
< nelts
; i
++)
8930 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
8934 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
8935 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
8936 NULL_TREE otherwise. */
8939 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const vec_perm_indices
&sel
)
8942 unsigned HOST_WIDE_INT nelts
;
8943 bool need_ctor
= false;
8945 if (!sel
.length ().is_constant (&nelts
))
8947 gcc_assert (known_eq (TYPE_VECTOR_SUBPARTS (type
), nelts
)
8948 && known_eq (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)), nelts
)
8949 && known_eq (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)), nelts
));
8950 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
8951 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
8954 tree
*in_elts
= XALLOCAVEC (tree
, nelts
* 2);
8955 if (!vec_cst_ctor_to_array (arg0
, nelts
, in_elts
)
8956 || !vec_cst_ctor_to_array (arg1
, nelts
, in_elts
+ nelts
))
8959 tree_vector_builder
out_elts (type
, nelts
, 1);
8960 for (i
= 0; i
< nelts
; i
++)
8962 HOST_WIDE_INT index
;
8963 if (!sel
[i
].is_constant (&index
))
8965 if (!CONSTANT_CLASS_P (in_elts
[index
]))
8967 out_elts
.quick_push (unshare_expr (in_elts
[index
]));
8972 vec
<constructor_elt
, va_gc
> *v
;
8973 vec_alloc (v
, nelts
);
8974 for (i
= 0; i
< nelts
; i
++)
8975 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, out_elts
[i
]);
8976 return build_constructor (type
, v
);
8979 return out_elts
.build ();
8982 /* Try to fold a pointer difference of type TYPE two address expressions of
8983 array references AREF0 and AREF1 using location LOC. Return a
8984 simplified expression for the difference or NULL_TREE. */
8987 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
8988 tree aref0
, tree aref1
,
8989 bool use_pointer_diff
)
8991 tree base0
= TREE_OPERAND (aref0
, 0);
8992 tree base1
= TREE_OPERAND (aref1
, 0);
8993 tree base_offset
= build_int_cst (type
, 0);
8995 /* If the bases are array references as well, recurse. If the bases
8996 are pointer indirections compute the difference of the pointers.
8997 If the bases are equal, we are set. */
8998 if ((TREE_CODE (base0
) == ARRAY_REF
8999 && TREE_CODE (base1
) == ARRAY_REF
9001 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
,
9003 || (INDIRECT_REF_P (base0
)
9004 && INDIRECT_REF_P (base1
)
9007 ? fold_binary_loc (loc
, POINTER_DIFF_EXPR
, type
,
9008 TREE_OPERAND (base0
, 0),
9009 TREE_OPERAND (base1
, 0))
9010 : fold_binary_loc (loc
, MINUS_EXPR
, type
,
9012 TREE_OPERAND (base0
, 0)),
9014 TREE_OPERAND (base1
, 0)))))
9015 || operand_equal_p (base0
, base1
, OEP_ADDRESS_OF
))
9017 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
9018 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
9019 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
9020 tree diff
= fold_build2_loc (loc
, MINUS_EXPR
, type
, op0
, op1
);
9021 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9023 fold_build2_loc (loc
, MULT_EXPR
, type
,
9029 /* If the real or vector real constant CST of type TYPE has an exact
9030 inverse, return it, else return NULL. */
9033 exact_inverse (tree type
, tree cst
)
9039 switch (TREE_CODE (cst
))
9042 r
= TREE_REAL_CST (cst
);
9044 if (exact_real_inverse (TYPE_MODE (type
), &r
))
9045 return build_real (type
, r
);
9051 unit_type
= TREE_TYPE (type
);
9052 mode
= TYPE_MODE (unit_type
);
9054 tree_vector_builder elts
;
9055 if (!elts
.new_unary_operation (type
, cst
, false))
9057 unsigned int count
= elts
.encoded_nelts ();
9058 for (unsigned int i
= 0; i
< count
; ++i
)
9060 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
9061 if (!exact_real_inverse (mode
, &r
))
9063 elts
.quick_push (build_real (unit_type
, r
));
9066 return elts
.build ();
9074 /* Mask out the tz least significant bits of X of type TYPE where
9075 tz is the number of trailing zeroes in Y. */
9077 mask_with_tz (tree type
, const wide_int
&x
, const wide_int
&y
)
9079 int tz
= wi::ctz (y
);
9081 return wi::mask (tz
, true, TYPE_PRECISION (type
)) & x
;
9085 /* Return true when T is an address and is known to be nonzero.
9086 For floating point we further ensure that T is not denormal.
9087 Similar logic is present in nonzero_address in rtlanal.h.
9089 If the return value is based on the assumption that signed overflow
9090 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9091 change *STRICT_OVERFLOW_P. */
9094 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
9096 tree type
= TREE_TYPE (t
);
9097 enum tree_code code
;
9099 /* Doing something useful for floating point would need more work. */
9100 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
9103 code
= TREE_CODE (t
);
9104 switch (TREE_CODE_CLASS (code
))
9107 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9110 case tcc_comparison
:
9111 return tree_binary_nonzero_warnv_p (code
, type
,
9112 TREE_OPERAND (t
, 0),
9113 TREE_OPERAND (t
, 1),
9116 case tcc_declaration
:
9118 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9126 case TRUTH_NOT_EXPR
:
9127 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9130 case TRUTH_AND_EXPR
:
9132 case TRUTH_XOR_EXPR
:
9133 return tree_binary_nonzero_warnv_p (code
, type
,
9134 TREE_OPERAND (t
, 0),
9135 TREE_OPERAND (t
, 1),
9143 case WITH_SIZE_EXPR
:
9145 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9150 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
9154 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
9159 tree fndecl
= get_callee_fndecl (t
);
9160 if (!fndecl
) return false;
9161 if (flag_delete_null_pointer_checks
&& !flag_check_new
9162 && DECL_IS_OPERATOR_NEW (fndecl
)
9163 && !TREE_NOTHROW (fndecl
))
9165 if (flag_delete_null_pointer_checks
9166 && lookup_attribute ("returns_nonnull",
9167 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
9169 return alloca_call_p (t
);
9178 /* Return true when T is an address and is known to be nonzero.
9179 Handle warnings about undefined signed overflow. */
9182 tree_expr_nonzero_p (tree t
)
9184 bool ret
, strict_overflow_p
;
9186 strict_overflow_p
= false;
9187 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
9188 if (strict_overflow_p
)
9189 fold_overflow_warning (("assuming signed overflow does not occur when "
9190 "determining that expression is always "
9192 WARN_STRICT_OVERFLOW_MISC
);
9196 /* Return true if T is known not to be equal to an integer W. */
9199 expr_not_equal_to (tree t
, const wide_int
&w
)
9201 wide_int min
, max
, nz
;
9202 value_range_type rtype
;
9203 switch (TREE_CODE (t
))
9206 return wi::to_wide (t
) != w
;
9209 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
9211 rtype
= get_range_info (t
, &min
, &max
);
9212 if (rtype
== VR_RANGE
)
9214 if (wi::lt_p (max
, w
, TYPE_SIGN (TREE_TYPE (t
))))
9216 if (wi::lt_p (w
, min
, TYPE_SIGN (TREE_TYPE (t
))))
9219 else if (rtype
== VR_ANTI_RANGE
9220 && wi::le_p (min
, w
, TYPE_SIGN (TREE_TYPE (t
)))
9221 && wi::le_p (w
, max
, TYPE_SIGN (TREE_TYPE (t
))))
9223 /* If T has some known zero bits and W has any of those bits set,
9224 then T is known not to be equal to W. */
9225 if (wi::ne_p (wi::zext (wi::bit_and_not (w
, get_nonzero_bits (t
)),
9226 TYPE_PRECISION (TREE_TYPE (t
))), 0))
9235 /* Fold a binary expression of code CODE and type TYPE with operands
9236 OP0 and OP1. LOC is the location of the resulting expression.
9237 Return the folded expression if folding is successful. Otherwise,
9238 return NULL_TREE. */
9241 fold_binary_loc (location_t loc
, enum tree_code code
, tree type
,
9244 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
9245 tree arg0
, arg1
, tem
;
9246 tree t1
= NULL_TREE
;
9247 bool strict_overflow_p
;
9250 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
9251 && TREE_CODE_LENGTH (code
) == 2
9253 && op1
!= NULL_TREE
);
9258 /* Strip any conversions that don't change the mode. This is
9259 safe for every expression, except for a comparison expression
9260 because its signedness is derived from its operands. So, in
9261 the latter case, only strip conversions that don't change the
9262 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9265 Note that this is done as an internal manipulation within the
9266 constant folder, in order to find the simplest representation
9267 of the arguments so that their form can be studied. In any
9268 cases, the appropriate type conversions should be put back in
9269 the tree that will get out of the constant folder. */
9271 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
9273 STRIP_SIGN_NOPS (arg0
);
9274 STRIP_SIGN_NOPS (arg1
);
9282 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9283 constant but we can't do arithmetic on them. */
9284 if (CONSTANT_CLASS_P (arg0
) && CONSTANT_CLASS_P (arg1
))
9286 tem
= const_binop (code
, type
, arg0
, arg1
);
9287 if (tem
!= NULL_TREE
)
9289 if (TREE_TYPE (tem
) != type
)
9290 tem
= fold_convert_loc (loc
, type
, tem
);
9295 /* If this is a commutative operation, and ARG0 is a constant, move it
9296 to ARG1 to reduce the number of tests below. */
9297 if (commutative_tree_code (code
)
9298 && tree_swap_operands_p (arg0
, arg1
))
9299 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
9301 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9302 to ARG1 to reduce the number of tests below. */
9303 if (kind
== tcc_comparison
9304 && tree_swap_operands_p (arg0
, arg1
))
9305 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
9307 tem
= generic_simplify (loc
, code
, type
, op0
, op1
);
9311 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9313 First check for cases where an arithmetic operation is applied to a
9314 compound, conditional, or comparison operation. Push the arithmetic
9315 operation inside the compound or conditional to see if any folding
9316 can then be done. Convert comparison to conditional for this purpose.
9317 The also optimizes non-constant cases that used to be done in
9320 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9321 one of the operands is a comparison and the other is a comparison, a
9322 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9323 code below would make the expression more complex. Change it to a
9324 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9325 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9327 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
9328 || code
== EQ_EXPR
|| code
== NE_EXPR
)
9329 && !VECTOR_TYPE_P (TREE_TYPE (arg0
))
9330 && ((truth_value_p (TREE_CODE (arg0
))
9331 && (truth_value_p (TREE_CODE (arg1
))
9332 || (TREE_CODE (arg1
) == BIT_AND_EXPR
9333 && integer_onep (TREE_OPERAND (arg1
, 1)))))
9334 || (truth_value_p (TREE_CODE (arg1
))
9335 && (truth_value_p (TREE_CODE (arg0
))
9336 || (TREE_CODE (arg0
) == BIT_AND_EXPR
9337 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
9339 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
9340 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
9343 fold_convert_loc (loc
, boolean_type_node
, arg0
),
9344 fold_convert_loc (loc
, boolean_type_node
, arg1
));
9346 if (code
== EQ_EXPR
)
9347 tem
= invert_truthvalue_loc (loc
, tem
);
9349 return fold_convert_loc (loc
, type
, tem
);
9352 if (TREE_CODE_CLASS (code
) == tcc_binary
9353 || TREE_CODE_CLASS (code
) == tcc_comparison
)
9355 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
9357 tem
= fold_build2_loc (loc
, code
, type
,
9358 fold_convert_loc (loc
, TREE_TYPE (op0
),
9359 TREE_OPERAND (arg0
, 1)), op1
);
9360 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
9363 if (TREE_CODE (arg1
) == COMPOUND_EXPR
)
9365 tem
= fold_build2_loc (loc
, code
, type
, op0
,
9366 fold_convert_loc (loc
, TREE_TYPE (op1
),
9367 TREE_OPERAND (arg1
, 1)));
9368 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
9372 if (TREE_CODE (arg0
) == COND_EXPR
9373 || TREE_CODE (arg0
) == VEC_COND_EXPR
9374 || COMPARISON_CLASS_P (arg0
))
9376 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9378 /*cond_first_p=*/1);
9379 if (tem
!= NULL_TREE
)
9383 if (TREE_CODE (arg1
) == COND_EXPR
9384 || TREE_CODE (arg1
) == VEC_COND_EXPR
9385 || COMPARISON_CLASS_P (arg1
))
9387 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9389 /*cond_first_p=*/0);
9390 if (tem
!= NULL_TREE
)
9398 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9399 if (TREE_CODE (arg0
) == ADDR_EXPR
9400 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
9402 tree iref
= TREE_OPERAND (arg0
, 0);
9403 return fold_build2 (MEM_REF
, type
,
9404 TREE_OPERAND (iref
, 0),
9405 int_const_binop (PLUS_EXPR
, arg1
,
9406 TREE_OPERAND (iref
, 1)));
9409 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9410 if (TREE_CODE (arg0
) == ADDR_EXPR
9411 && handled_component_p (TREE_OPERAND (arg0
, 0)))
9415 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
9419 return fold_build2 (MEM_REF
, type
,
9420 build_fold_addr_expr (base
),
9421 int_const_binop (PLUS_EXPR
, arg1
,
9422 size_int (coffset
)));
9427 case POINTER_PLUS_EXPR
:
9428 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9429 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9430 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
9431 return fold_convert_loc (loc
, type
,
9432 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
9433 fold_convert_loc (loc
, sizetype
,
9435 fold_convert_loc (loc
, sizetype
,
9441 if (INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
9443 /* X + (X / CST) * -CST is X % CST. */
9444 if (TREE_CODE (arg1
) == MULT_EXPR
9445 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
9446 && operand_equal_p (arg0
,
9447 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
9449 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
9450 tree cst1
= TREE_OPERAND (arg1
, 1);
9451 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
9453 if (sum
&& integer_zerop (sum
))
9454 return fold_convert_loc (loc
, type
,
9455 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
9456 TREE_TYPE (arg0
), arg0
,
9461 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
9462 one. Make sure the type is not saturating and has the signedness of
9463 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9464 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9465 if ((TREE_CODE (arg0
) == MULT_EXPR
9466 || TREE_CODE (arg1
) == MULT_EXPR
)
9467 && !TYPE_SATURATING (type
)
9468 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9469 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9470 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9472 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9477 if (! FLOAT_TYPE_P (type
))
9479 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9480 (plus (plus (mult) (mult)) (foo)) so that we can
9481 take advantage of the factoring cases below. */
9482 if (ANY_INTEGRAL_TYPE_P (type
)
9483 && TYPE_OVERFLOW_WRAPS (type
)
9484 && (((TREE_CODE (arg0
) == PLUS_EXPR
9485 || TREE_CODE (arg0
) == MINUS_EXPR
)
9486 && TREE_CODE (arg1
) == MULT_EXPR
)
9487 || ((TREE_CODE (arg1
) == PLUS_EXPR
9488 || TREE_CODE (arg1
) == MINUS_EXPR
)
9489 && TREE_CODE (arg0
) == MULT_EXPR
)))
9491 tree parg0
, parg1
, parg
, marg
;
9492 enum tree_code pcode
;
9494 if (TREE_CODE (arg1
) == MULT_EXPR
)
9495 parg
= arg0
, marg
= arg1
;
9497 parg
= arg1
, marg
= arg0
;
9498 pcode
= TREE_CODE (parg
);
9499 parg0
= TREE_OPERAND (parg
, 0);
9500 parg1
= TREE_OPERAND (parg
, 1);
9504 if (TREE_CODE (parg0
) == MULT_EXPR
9505 && TREE_CODE (parg1
) != MULT_EXPR
)
9506 return fold_build2_loc (loc
, pcode
, type
,
9507 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9508 fold_convert_loc (loc
, type
,
9510 fold_convert_loc (loc
, type
,
9512 fold_convert_loc (loc
, type
, parg1
));
9513 if (TREE_CODE (parg0
) != MULT_EXPR
9514 && TREE_CODE (parg1
) == MULT_EXPR
)
9516 fold_build2_loc (loc
, PLUS_EXPR
, type
,
9517 fold_convert_loc (loc
, type
, parg0
),
9518 fold_build2_loc (loc
, pcode
, type
,
9519 fold_convert_loc (loc
, type
, marg
),
9520 fold_convert_loc (loc
, type
,
9526 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9527 to __complex__ ( x, y ). This is not the same for SNaNs or
9528 if signed zeros are involved. */
9529 if (!HONOR_SNANS (element_mode (arg0
))
9530 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9531 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9533 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9534 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9535 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9536 bool arg0rz
= false, arg0iz
= false;
9537 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9538 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9540 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9541 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9542 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9544 tree rp
= arg1r
? arg1r
9545 : build1 (REALPART_EXPR
, rtype
, arg1
);
9546 tree ip
= arg0i
? arg0i
9547 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9548 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9550 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9552 tree rp
= arg0r
? arg0r
9553 : build1 (REALPART_EXPR
, rtype
, arg0
);
9554 tree ip
= arg1i
? arg1i
9555 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
9556 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9561 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
9562 We associate floats only if the user has specified
9563 -fassociative-math. */
9564 if (flag_associative_math
9565 && TREE_CODE (arg1
) == PLUS_EXPR
9566 && TREE_CODE (arg0
) != MULT_EXPR
)
9568 tree tree10
= TREE_OPERAND (arg1
, 0);
9569 tree tree11
= TREE_OPERAND (arg1
, 1);
9570 if (TREE_CODE (tree11
) == MULT_EXPR
9571 && TREE_CODE (tree10
) == MULT_EXPR
)
9574 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
9575 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
9578 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
9579 We associate floats only if the user has specified
9580 -fassociative-math. */
9581 if (flag_associative_math
9582 && TREE_CODE (arg0
) == PLUS_EXPR
9583 && TREE_CODE (arg1
) != MULT_EXPR
)
9585 tree tree00
= TREE_OPERAND (arg0
, 0);
9586 tree tree01
= TREE_OPERAND (arg0
, 1);
9587 if (TREE_CODE (tree01
) == MULT_EXPR
9588 && TREE_CODE (tree00
) == MULT_EXPR
)
9591 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
9592 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
9598 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9599 is a rotate of A by C1 bits. */
9600 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9601 is a rotate of A by B bits.
9602 Similarly for (A << B) | (A >> (-B & C3)) where C3 is Z-1,
9603 though in this case CODE must be | and not + or ^, otherwise
9604 it doesn't return A when B is 0. */
9606 enum tree_code code0
, code1
;
9608 code0
= TREE_CODE (arg0
);
9609 code1
= TREE_CODE (arg1
);
9610 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
9611 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
9612 && operand_equal_p (TREE_OPERAND (arg0
, 0),
9613 TREE_OPERAND (arg1
, 0), 0)
9614 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
9615 TYPE_UNSIGNED (rtype
))
9616 /* Only create rotates in complete modes. Other cases are not
9617 expanded properly. */
9618 && (element_precision (rtype
)
9619 == GET_MODE_UNIT_PRECISION (TYPE_MODE (rtype
))))
9621 tree tree01
, tree11
;
9622 tree orig_tree01
, orig_tree11
;
9623 enum tree_code code01
, code11
;
9625 tree01
= orig_tree01
= TREE_OPERAND (arg0
, 1);
9626 tree11
= orig_tree11
= TREE_OPERAND (arg1
, 1);
9627 STRIP_NOPS (tree01
);
9628 STRIP_NOPS (tree11
);
9629 code01
= TREE_CODE (tree01
);
9630 code11
= TREE_CODE (tree11
);
9631 if (code11
!= MINUS_EXPR
9632 && (code01
== MINUS_EXPR
|| code01
== BIT_AND_EXPR
))
9634 std::swap (code0
, code1
);
9635 std::swap (code01
, code11
);
9636 std::swap (tree01
, tree11
);
9637 std::swap (orig_tree01
, orig_tree11
);
9639 if (code01
== INTEGER_CST
9640 && code11
== INTEGER_CST
9641 && (wi::to_widest (tree01
) + wi::to_widest (tree11
)
9642 == element_precision (rtype
)))
9644 tem
= build2_loc (loc
, LROTATE_EXPR
,
9645 rtype
, TREE_OPERAND (arg0
, 0),
9646 code0
== LSHIFT_EXPR
9647 ? orig_tree01
: orig_tree11
);
9648 return fold_convert_loc (loc
, type
, tem
);
9650 else if (code11
== MINUS_EXPR
)
9652 tree tree110
, tree111
;
9653 tree110
= TREE_OPERAND (tree11
, 0);
9654 tree111
= TREE_OPERAND (tree11
, 1);
9655 STRIP_NOPS (tree110
);
9656 STRIP_NOPS (tree111
);
9657 if (TREE_CODE (tree110
) == INTEGER_CST
9658 && compare_tree_int (tree110
,
9659 element_precision (rtype
)) == 0
9660 && operand_equal_p (tree01
, tree111
, 0))
9662 tem
= build2_loc (loc
, (code0
== LSHIFT_EXPR
9663 ? LROTATE_EXPR
: RROTATE_EXPR
),
9664 rtype
, TREE_OPERAND (arg0
, 0),
9666 return fold_convert_loc (loc
, type
, tem
);
9669 else if (code
== BIT_IOR_EXPR
9670 && code11
== BIT_AND_EXPR
9671 && pow2p_hwi (element_precision (rtype
)))
9673 tree tree110
, tree111
;
9674 tree110
= TREE_OPERAND (tree11
, 0);
9675 tree111
= TREE_OPERAND (tree11
, 1);
9676 STRIP_NOPS (tree110
);
9677 STRIP_NOPS (tree111
);
9678 if (TREE_CODE (tree110
) == NEGATE_EXPR
9679 && TREE_CODE (tree111
) == INTEGER_CST
9680 && compare_tree_int (tree111
,
9681 element_precision (rtype
) - 1) == 0
9682 && operand_equal_p (tree01
, TREE_OPERAND (tree110
, 0), 0))
9684 tem
= build2_loc (loc
, (code0
== LSHIFT_EXPR
9685 ? LROTATE_EXPR
: RROTATE_EXPR
),
9686 rtype
, TREE_OPERAND (arg0
, 0),
9688 return fold_convert_loc (loc
, type
, tem
);
9695 /* In most languages, can't associate operations on floats through
9696 parentheses. Rather than remember where the parentheses were, we
9697 don't associate floats at all, unless the user has specified
9699 And, we need to make sure type is not saturating. */
9701 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
9702 && !TYPE_SATURATING (type
))
9704 tree var0
, minus_var0
, con0
, minus_con0
, lit0
, minus_lit0
;
9705 tree var1
, minus_var1
, con1
, minus_con1
, lit1
, minus_lit1
;
9709 /* Split both trees into variables, constants, and literals. Then
9710 associate each group together, the constants with literals,
9711 then the result with variables. This increases the chances of
9712 literals being recombined later and of generating relocatable
9713 expressions for the sum of a constant and literal. */
9714 var0
= split_tree (arg0
, type
, code
,
9715 &minus_var0
, &con0
, &minus_con0
,
9716 &lit0
, &minus_lit0
, 0);
9717 var1
= split_tree (arg1
, type
, code
,
9718 &minus_var1
, &con1
, &minus_con1
,
9719 &lit1
, &minus_lit1
, code
== MINUS_EXPR
);
9721 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
9722 if (code
== MINUS_EXPR
)
9725 /* With undefined overflow prefer doing association in a type
9726 which wraps on overflow, if that is one of the operand types. */
9727 if ((POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
))
9728 && !TYPE_OVERFLOW_WRAPS (type
))
9730 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
9731 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
9732 atype
= TREE_TYPE (arg0
);
9733 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9734 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
9735 atype
= TREE_TYPE (arg1
);
9736 gcc_assert (TYPE_PRECISION (atype
) == TYPE_PRECISION (type
));
9739 /* With undefined overflow we can only associate constants with one
9740 variable, and constants whose association doesn't overflow. */
9741 if ((POINTER_TYPE_P (atype
) || INTEGRAL_TYPE_P (atype
))
9742 && !TYPE_OVERFLOW_WRAPS (atype
))
9744 if ((var0
&& var1
) || (minus_var0
&& minus_var1
))
9746 /* ??? If split_tree would handle NEGATE_EXPR we could
9747 simply reject these cases and the allowed cases would
9748 be the var0/minus_var1 ones. */
9749 tree tmp0
= var0
? var0
: minus_var0
;
9750 tree tmp1
= var1
? var1
: minus_var1
;
9751 bool one_neg
= false;
9753 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
9755 tmp0
= TREE_OPERAND (tmp0
, 0);
9758 if (CONVERT_EXPR_P (tmp0
)
9759 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9760 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
9761 <= TYPE_PRECISION (atype
)))
9762 tmp0
= TREE_OPERAND (tmp0
, 0);
9763 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
9765 tmp1
= TREE_OPERAND (tmp1
, 0);
9768 if (CONVERT_EXPR_P (tmp1
)
9769 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9770 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
9771 <= TYPE_PRECISION (atype
)))
9772 tmp1
= TREE_OPERAND (tmp1
, 0);
9773 /* The only case we can still associate with two variables
9774 is if they cancel out. */
9776 || !operand_equal_p (tmp0
, tmp1
, 0))
9779 else if ((var0
&& minus_var1
9780 && ! operand_equal_p (var0
, minus_var1
, 0))
9781 || (minus_var0
&& var1
9782 && ! operand_equal_p (minus_var0
, var1
, 0)))
9786 /* Only do something if we found more than two objects. Otherwise,
9787 nothing has changed and we risk infinite recursion. */
9789 && ((var0
!= 0) + (var1
!= 0)
9790 + (minus_var0
!= 0) + (minus_var1
!= 0)
9791 + (con0
!= 0) + (con1
!= 0)
9792 + (minus_con0
!= 0) + (minus_con1
!= 0)
9793 + (lit0
!= 0) + (lit1
!= 0)
9794 + (minus_lit0
!= 0) + (minus_lit1
!= 0)) > 2)
9796 var0
= associate_trees (loc
, var0
, var1
, code
, atype
);
9797 minus_var0
= associate_trees (loc
, minus_var0
, minus_var1
,
9799 con0
= associate_trees (loc
, con0
, con1
, code
, atype
);
9800 minus_con0
= associate_trees (loc
, minus_con0
, minus_con1
,
9802 lit0
= associate_trees (loc
, lit0
, lit1
, code
, atype
);
9803 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
,
9806 if (minus_var0
&& var0
)
9808 var0
= associate_trees (loc
, var0
, minus_var0
,
9812 if (minus_con0
&& con0
)
9814 con0
= associate_trees (loc
, con0
, minus_con0
,
9819 /* Preserve the MINUS_EXPR if the negative part of the literal is
9820 greater than the positive part. Otherwise, the multiplicative
9821 folding code (i.e extract_muldiv) may be fooled in case
9822 unsigned constants are subtracted, like in the following
9823 example: ((X*2 + 4) - 8U)/2. */
9824 if (minus_lit0
&& lit0
)
9826 if (TREE_CODE (lit0
) == INTEGER_CST
9827 && TREE_CODE (minus_lit0
) == INTEGER_CST
9828 && tree_int_cst_lt (lit0
, minus_lit0
)
9829 /* But avoid ending up with only negated parts. */
9832 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
9838 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
9844 /* Don't introduce overflows through reassociation. */
9845 if ((lit0
&& TREE_OVERFLOW_P (lit0
))
9846 || (minus_lit0
&& TREE_OVERFLOW_P (minus_lit0
)))
9849 /* Eliminate lit0 and minus_lit0 to con0 and minus_con0. */
9850 con0
= associate_trees (loc
, con0
, lit0
, code
, atype
);
9852 minus_con0
= associate_trees (loc
, minus_con0
, minus_lit0
,
9856 /* Eliminate minus_con0. */
9860 con0
= associate_trees (loc
, con0
, minus_con0
,
9863 var0
= associate_trees (loc
, var0
, minus_con0
,
9870 /* Eliminate minus_var0. */
9874 con0
= associate_trees (loc
, con0
, minus_var0
,
9882 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
9889 case POINTER_DIFF_EXPR
:
9891 /* Fold &a[i] - &a[j] to i-j. */
9892 if (TREE_CODE (arg0
) == ADDR_EXPR
9893 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
9894 && TREE_CODE (arg1
) == ADDR_EXPR
9895 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
9897 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
9898 TREE_OPERAND (arg0
, 0),
9899 TREE_OPERAND (arg1
, 0),
9901 == POINTER_DIFF_EXPR
);
9906 /* Further transformations are not for pointers. */
9907 if (code
== POINTER_DIFF_EXPR
)
9910 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
9911 if (TREE_CODE (arg0
) == NEGATE_EXPR
9912 && negate_expr_p (op1
)
9913 /* If arg0 is e.g. unsigned int and type is int, then this could
9914 introduce UB, because if A is INT_MIN at runtime, the original
9915 expression can be well defined while the latter is not.
9917 && !(ANY_INTEGRAL_TYPE_P (type
)
9918 && TYPE_OVERFLOW_UNDEFINED (type
)
9919 && ANY_INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
9920 && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))))
9921 return fold_build2_loc (loc
, MINUS_EXPR
, type
, negate_expr (op1
),
9922 fold_convert_loc (loc
, type
,
9923 TREE_OPERAND (arg0
, 0)));
9925 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
9926 __complex__ ( x, -y ). This is not the same for SNaNs or if
9927 signed zeros are involved. */
9928 if (!HONOR_SNANS (element_mode (arg0
))
9929 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
9930 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9932 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
9933 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
9934 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
9935 bool arg0rz
= false, arg0iz
= false;
9936 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
9937 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
9939 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
9940 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
9941 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
9943 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9945 : build1 (REALPART_EXPR
, rtype
, arg1
));
9946 tree ip
= arg0i
? arg0i
9947 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
9948 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9950 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
9952 tree rp
= arg0r
? arg0r
9953 : build1 (REALPART_EXPR
, rtype
, arg0
);
9954 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
9956 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
9957 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
9962 /* A - B -> A + (-B) if B is easily negatable. */
9963 if (negate_expr_p (op1
)
9964 && ! TYPE_OVERFLOW_SANITIZED (type
)
9965 && ((FLOAT_TYPE_P (type
)
9966 /* Avoid this transformation if B is a positive REAL_CST. */
9967 && (TREE_CODE (op1
) != REAL_CST
9968 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (op1
))))
9969 || INTEGRAL_TYPE_P (type
)))
9970 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9971 fold_convert_loc (loc
, type
, arg0
),
9974 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
9975 one. Make sure the type is not saturating and has the signedness of
9976 the stripped operands, as fold_plusminus_mult_expr will re-associate.
9977 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
9978 if ((TREE_CODE (arg0
) == MULT_EXPR
9979 || TREE_CODE (arg1
) == MULT_EXPR
)
9980 && !TYPE_SATURATING (type
)
9981 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
9982 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
9983 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
9985 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
9993 if (! FLOAT_TYPE_P (type
))
9995 /* Transform x * -C into -x * C if x is easily negatable. */
9996 if (TREE_CODE (op1
) == INTEGER_CST
9997 && tree_int_cst_sgn (op1
) == -1
9998 && negate_expr_p (op0
)
9999 && negate_expr_p (op1
)
10000 && (tem
= negate_expr (op1
)) != op1
10001 && ! TREE_OVERFLOW (tem
))
10002 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10003 fold_convert_loc (loc
, type
,
10004 negate_expr (op0
)), tem
);
10006 strict_overflow_p
= false;
10007 if (TREE_CODE (arg1
) == INTEGER_CST
10008 && (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10009 &strict_overflow_p
)) != 0)
10011 if (strict_overflow_p
)
10012 fold_overflow_warning (("assuming signed overflow does not "
10013 "occur when simplifying "
10015 WARN_STRICT_OVERFLOW_MISC
);
10016 return fold_convert_loc (loc
, type
, tem
);
10019 /* Optimize z * conj(z) for integer complex numbers. */
10020 if (TREE_CODE (arg0
) == CONJ_EXPR
10021 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10022 return fold_mult_zconjz (loc
, type
, arg1
);
10023 if (TREE_CODE (arg1
) == CONJ_EXPR
10024 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10025 return fold_mult_zconjz (loc
, type
, arg0
);
10029 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10030 This is not the same for NaNs or if signed zeros are
10032 if (!HONOR_NANS (arg0
)
10033 && !HONOR_SIGNED_ZEROS (element_mode (arg0
))
10034 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
10035 && TREE_CODE (arg1
) == COMPLEX_CST
10036 && real_zerop (TREE_REALPART (arg1
)))
10038 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10039 if (real_onep (TREE_IMAGPART (arg1
)))
10041 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10042 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
10044 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
10045 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
10047 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10048 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
10049 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
10053 /* Optimize z * conj(z) for floating point complex numbers.
10054 Guarded by flag_unsafe_math_optimizations as non-finite
10055 imaginary components don't produce scalar results. */
10056 if (flag_unsafe_math_optimizations
10057 && TREE_CODE (arg0
) == CONJ_EXPR
10058 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10059 return fold_mult_zconjz (loc
, type
, arg1
);
10060 if (flag_unsafe_math_optimizations
10061 && TREE_CODE (arg1
) == CONJ_EXPR
10062 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10063 return fold_mult_zconjz (loc
, type
, arg0
);
10068 /* Canonicalize (X & C1) | C2. */
10069 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10070 && TREE_CODE (arg1
) == INTEGER_CST
10071 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10073 int width
= TYPE_PRECISION (type
), w
;
10074 wide_int c1
= wi::to_wide (TREE_OPERAND (arg0
, 1));
10075 wide_int c2
= wi::to_wide (arg1
);
10077 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
10078 if ((c1
& c2
) == c1
)
10079 return omit_one_operand_loc (loc
, type
, arg1
,
10080 TREE_OPERAND (arg0
, 0));
10082 wide_int msk
= wi::mask (width
, false,
10083 TYPE_PRECISION (TREE_TYPE (arg1
)));
10085 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
10086 if (wi::bit_and_not (msk
, c1
| c2
) == 0)
10088 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10089 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
, tem
, arg1
);
10092 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
10093 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
10094 mode which allows further optimizations. */
10097 wide_int c3
= wi::bit_and_not (c1
, c2
);
10098 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
10100 wide_int mask
= wi::mask (w
, false,
10101 TYPE_PRECISION (type
));
10102 if (((c1
| c2
) & mask
) == mask
10103 && wi::bit_and_not (c1
, mask
) == 0)
10112 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10113 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tem
,
10114 wide_int_to_tree (type
, c3
));
10115 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
, tem
, arg1
);
10119 /* See if this can be simplified into a rotate first. If that
10120 is unsuccessful continue in the association code. */
10124 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
10125 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10126 && INTEGRAL_TYPE_P (type
)
10127 && integer_onep (TREE_OPERAND (arg0
, 1))
10128 && integer_onep (arg1
))
10129 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
10130 build_zero_cst (TREE_TYPE (arg0
)));
10132 /* See if this can be simplified into a rotate first. If that
10133 is unsuccessful continue in the association code. */
10137 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
10138 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10139 && INTEGRAL_TYPE_P (type
)
10140 && integer_onep (TREE_OPERAND (arg0
, 1))
10141 && integer_onep (arg1
))
10144 tem
= TREE_OPERAND (arg0
, 0);
10145 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
10146 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
10148 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
10149 build_zero_cst (TREE_TYPE (tem
)));
10151 /* Fold ~X & 1 as (X & 1) == 0. */
10152 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10153 && INTEGRAL_TYPE_P (type
)
10154 && integer_onep (arg1
))
10157 tem
= TREE_OPERAND (arg0
, 0);
10158 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
10159 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
10161 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
10162 build_zero_cst (TREE_TYPE (tem
)));
10164 /* Fold !X & 1 as X == 0. */
10165 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10166 && integer_onep (arg1
))
10168 tem
= TREE_OPERAND (arg0
, 0);
10169 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
10170 build_zero_cst (TREE_TYPE (tem
)));
10173 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
10174 multiple of 1 << CST. */
10175 if (TREE_CODE (arg1
) == INTEGER_CST
)
10177 wi::tree_to_wide_ref cst1
= wi::to_wide (arg1
);
10178 wide_int ncst1
= -cst1
;
10179 if ((cst1
& ncst1
) == ncst1
10180 && multiple_of_p (type
, arg0
,
10181 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
10182 return fold_convert_loc (loc
, type
, arg0
);
10185 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
10187 if (TREE_CODE (arg1
) == INTEGER_CST
10188 && TREE_CODE (arg0
) == MULT_EXPR
10189 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10191 wi::tree_to_wide_ref warg1
= wi::to_wide (arg1
);
10193 = mask_with_tz (type
, warg1
, wi::to_wide (TREE_OPERAND (arg0
, 1)));
10196 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
10198 else if (masked
!= warg1
)
10200 /* Avoid the transform if arg1 is a mask of some
10201 mode which allows further optimizations. */
10202 int pop
= wi::popcount (warg1
);
10203 if (!(pop
>= BITS_PER_UNIT
10205 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
10206 return fold_build2_loc (loc
, code
, type
, op0
,
10207 wide_int_to_tree (type
, masked
));
10211 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
10212 ((A & N) + B) & M -> (A + B) & M
10213 Similarly if (N & M) == 0,
10214 ((A | N) + B) & M -> (A + B) & M
10215 and for - instead of + (or unary - instead of +)
10216 and/or ^ instead of |.
10217 If B is constant and (B & M) == 0, fold into A & M. */
10218 if (TREE_CODE (arg1
) == INTEGER_CST
)
10220 wi::tree_to_wide_ref cst1
= wi::to_wide (arg1
);
10221 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
10222 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10223 && (TREE_CODE (arg0
) == PLUS_EXPR
10224 || TREE_CODE (arg0
) == MINUS_EXPR
10225 || TREE_CODE (arg0
) == NEGATE_EXPR
)
10226 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
10227 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
10233 /* Now we know that arg0 is (C + D) or (C - D) or
10234 -C and arg1 (M) is == (1LL << cst) - 1.
10235 Store C into PMOP[0] and D into PMOP[1]. */
10236 pmop
[0] = TREE_OPERAND (arg0
, 0);
10238 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
10240 pmop
[1] = TREE_OPERAND (arg0
, 1);
10244 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
10247 for (; which
>= 0; which
--)
10248 switch (TREE_CODE (pmop
[which
]))
10253 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
10256 cst0
= wi::to_wide (TREE_OPERAND (pmop
[which
], 1)) & cst1
;
10257 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
10262 else if (cst0
!= 0)
10264 /* If C or D is of the form (A & N) where
10265 (N & M) == M, or of the form (A | N) or
10266 (A ^ N) where (N & M) == 0, replace it with A. */
10267 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
10270 /* If C or D is a N where (N & M) == 0, it can be
10271 omitted (assumed 0). */
10272 if ((TREE_CODE (arg0
) == PLUS_EXPR
10273 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
10274 && (cst1
& wi::to_wide (pmop
[which
])) == 0)
10275 pmop
[which
] = NULL
;
10281 /* Only build anything new if we optimized one or both arguments
10283 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
10284 || (TREE_CODE (arg0
) != NEGATE_EXPR
10285 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
10287 tree utype
= TREE_TYPE (arg0
);
10288 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
10290 /* Perform the operations in a type that has defined
10291 overflow behavior. */
10292 utype
= unsigned_type_for (TREE_TYPE (arg0
));
10293 if (pmop
[0] != NULL
)
10294 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
10295 if (pmop
[1] != NULL
)
10296 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
10299 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
10300 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
10301 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
10303 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
10304 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
10306 else if (pmop
[0] != NULL
)
10308 else if (pmop
[1] != NULL
)
10311 return build_int_cst (type
, 0);
10313 else if (pmop
[0] == NULL
)
10314 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
10316 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
10318 /* TEM is now the new binary +, - or unary - replacement. */
10319 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
10320 fold_convert_loc (loc
, utype
, arg1
));
10321 return fold_convert_loc (loc
, type
, tem
);
10326 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
10327 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
10328 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
10330 prec
= element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
10332 wide_int mask
= wide_int::from (wi::to_wide (arg1
), prec
, UNSIGNED
);
10335 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10341 /* Don't touch a floating-point divide by zero unless the mode
10342 of the constant can represent infinity. */
10343 if (TREE_CODE (arg1
) == REAL_CST
10344 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
10345 && real_zerop (arg1
))
10348 /* (-A) / (-B) -> A / B */
10349 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10350 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10351 TREE_OPERAND (arg0
, 0),
10352 negate_expr (arg1
));
10353 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10354 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
10355 negate_expr (arg0
),
10356 TREE_OPERAND (arg1
, 0));
10359 case TRUNC_DIV_EXPR
:
10362 case FLOOR_DIV_EXPR
:
10363 /* Simplify A / (B << N) where A and B are positive and B is
10364 a power of 2, to A >> (N + log2(B)). */
10365 strict_overflow_p
= false;
10366 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10367 && (TYPE_UNSIGNED (type
)
10368 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
10370 tree sval
= TREE_OPERAND (arg1
, 0);
10371 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
10373 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
10374 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
10375 wi::exact_log2 (wi::to_wide (sval
)));
10377 if (strict_overflow_p
)
10378 fold_overflow_warning (("assuming signed overflow does not "
10379 "occur when simplifying A / (B << N)"),
10380 WARN_STRICT_OVERFLOW_MISC
);
10382 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
10384 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
10385 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
10391 case ROUND_DIV_EXPR
:
10392 case CEIL_DIV_EXPR
:
10393 case EXACT_DIV_EXPR
:
10394 if (integer_zerop (arg1
))
10397 /* Convert -A / -B to A / B when the type is signed and overflow is
10399 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10400 && TREE_CODE (op0
) == NEGATE_EXPR
10401 && negate_expr_p (op1
))
10403 if (INTEGRAL_TYPE_P (type
))
10404 fold_overflow_warning (("assuming signed overflow does not occur "
10405 "when distributing negation across "
10407 WARN_STRICT_OVERFLOW_MISC
);
10408 return fold_build2_loc (loc
, code
, type
,
10409 fold_convert_loc (loc
, type
,
10410 TREE_OPERAND (arg0
, 0)),
10411 negate_expr (op1
));
10413 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
10414 && TREE_CODE (arg1
) == NEGATE_EXPR
10415 && negate_expr_p (op0
))
10417 if (INTEGRAL_TYPE_P (type
))
10418 fold_overflow_warning (("assuming signed overflow does not occur "
10419 "when distributing negation across "
10421 WARN_STRICT_OVERFLOW_MISC
);
10422 return fold_build2_loc (loc
, code
, type
,
10424 fold_convert_loc (loc
, type
,
10425 TREE_OPERAND (arg1
, 0)));
10428 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10429 operation, EXACT_DIV_EXPR.
10431 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10432 At one time others generated faster code, it's not clear if they do
10433 after the last round to changes to the DIV code in expmed.c. */
10434 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
10435 && multiple_of_p (type
, arg0
, arg1
))
10436 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
,
10437 fold_convert (type
, arg0
),
10438 fold_convert (type
, arg1
));
10440 strict_overflow_p
= false;
10441 if (TREE_CODE (arg1
) == INTEGER_CST
10442 && (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10443 &strict_overflow_p
)) != 0)
10445 if (strict_overflow_p
)
10446 fold_overflow_warning (("assuming signed overflow does not occur "
10447 "when simplifying division"),
10448 WARN_STRICT_OVERFLOW_MISC
);
10449 return fold_convert_loc (loc
, type
, tem
);
10454 case CEIL_MOD_EXPR
:
10455 case FLOOR_MOD_EXPR
:
10456 case ROUND_MOD_EXPR
:
10457 case TRUNC_MOD_EXPR
:
10458 strict_overflow_p
= false;
10459 if (TREE_CODE (arg1
) == INTEGER_CST
10460 && (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10461 &strict_overflow_p
)) != 0)
10463 if (strict_overflow_p
)
10464 fold_overflow_warning (("assuming signed overflow does not occur "
10465 "when simplifying modulus"),
10466 WARN_STRICT_OVERFLOW_MISC
);
10467 return fold_convert_loc (loc
, type
, tem
);
10476 /* Since negative shift count is not well-defined,
10477 don't try to compute it in the compiler. */
10478 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
10481 prec
= element_precision (type
);
10483 /* If we have a rotate of a bit operation with the rotate count and
10484 the second operand of the bit operation both constant,
10485 permute the two operations. */
10486 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10487 && (TREE_CODE (arg0
) == BIT_AND_EXPR
10488 || TREE_CODE (arg0
) == BIT_IOR_EXPR
10489 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
10490 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10492 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10493 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10494 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
10495 fold_build2_loc (loc
, code
, type
,
10497 fold_build2_loc (loc
, code
, type
,
10501 /* Two consecutive rotates adding up to the some integer
10502 multiple of the precision of the type can be ignored. */
10503 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
10504 && TREE_CODE (arg0
) == RROTATE_EXPR
10505 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10506 && wi::umod_trunc (wi::to_wide (arg1
)
10507 + wi::to_wide (TREE_OPERAND (arg0
, 1)),
10509 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10517 case TRUTH_ANDIF_EXPR
:
10518 /* Note that the operands of this must be ints
10519 and their values must be 0 or 1.
10520 ("true" is a fixed value perhaps depending on the language.) */
10521 /* If first arg is constant zero, return it. */
10522 if (integer_zerop (arg0
))
10523 return fold_convert_loc (loc
, type
, arg0
);
10525 case TRUTH_AND_EXPR
:
10526 /* If either arg is constant true, drop it. */
10527 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10528 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10529 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
10530 /* Preserve sequence points. */
10531 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10532 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10533 /* If second arg is constant zero, result is zero, but first arg
10534 must be evaluated. */
10535 if (integer_zerop (arg1
))
10536 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10537 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10538 case will be handled here. */
10539 if (integer_zerop (arg0
))
10540 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10542 /* !X && X is always false. */
10543 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10544 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10545 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
10546 /* X && !X is always false. */
10547 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10548 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10549 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10551 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
10552 means A >= Y && A != MAX, but in this case we know that
10555 if (!TREE_SIDE_EFFECTS (arg0
)
10556 && !TREE_SIDE_EFFECTS (arg1
))
10558 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
10559 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
10560 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
10562 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
10563 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
10564 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
10567 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10573 case TRUTH_ORIF_EXPR
:
10574 /* Note that the operands of this must be ints
10575 and their values must be 0 or true.
10576 ("true" is a fixed value perhaps depending on the language.) */
10577 /* If first arg is constant true, return it. */
10578 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10579 return fold_convert_loc (loc
, type
, arg0
);
10581 case TRUTH_OR_EXPR
:
10582 /* If either arg is constant zero, drop it. */
10583 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
10584 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10585 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
10586 /* Preserve sequence points. */
10587 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
10588 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10589 /* If second arg is constant true, result is true, but we must
10590 evaluate first arg. */
10591 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
10592 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10593 /* Likewise for first arg, but note this only occurs here for
10595 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
10596 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
10598 /* !X || X is always true. */
10599 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10600 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10601 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10602 /* X || !X is always true. */
10603 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10604 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10605 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10607 /* (X && !Y) || (!X && Y) is X ^ Y */
10608 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
10609 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
10611 tree a0
, a1
, l0
, l1
, n0
, n1
;
10613 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10614 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10616 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10617 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10619 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
10620 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
10622 if ((operand_equal_p (n0
, a0
, 0)
10623 && operand_equal_p (n1
, a1
, 0))
10624 || (operand_equal_p (n0
, a1
, 0)
10625 && operand_equal_p (n1
, a0
, 0)))
10626 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
10629 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
10635 case TRUTH_XOR_EXPR
:
10636 /* If the second arg is constant zero, drop it. */
10637 if (integer_zerop (arg1
))
10638 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10639 /* If the second arg is constant true, this is a logical inversion. */
10640 if (integer_onep (arg1
))
10642 tem
= invert_truthvalue_loc (loc
, arg0
);
10643 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
10645 /* Identical arguments cancel to zero. */
10646 if (operand_equal_p (arg0
, arg1
, 0))
10647 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
10649 /* !X ^ X is always true. */
10650 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
10651 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10652 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
10654 /* X ^ !X is always true. */
10655 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
10656 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10657 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
10666 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
10667 if (tem
!= NULL_TREE
)
10670 /* bool_var != 1 becomes !bool_var. */
10671 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
10672 && code
== NE_EXPR
)
10673 return fold_convert_loc (loc
, type
,
10674 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10675 TREE_TYPE (arg0
), arg0
));
10677 /* bool_var == 0 becomes !bool_var. */
10678 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
10679 && code
== EQ_EXPR
)
10680 return fold_convert_loc (loc
, type
,
10681 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
10682 TREE_TYPE (arg0
), arg0
));
10684 /* !exp != 0 becomes !exp */
10685 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
10686 && code
== NE_EXPR
)
10687 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10689 /* If this is an EQ or NE comparison with zero and ARG0 is
10690 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
10691 two operations, but the latter can be done in one less insn
10692 on machines that have only two-operand insns or on which a
10693 constant cannot be the first operand. */
10694 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10695 && integer_zerop (arg1
))
10697 tree arg00
= TREE_OPERAND (arg0
, 0);
10698 tree arg01
= TREE_OPERAND (arg0
, 1);
10699 if (TREE_CODE (arg00
) == LSHIFT_EXPR
10700 && integer_onep (TREE_OPERAND (arg00
, 0)))
10702 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
10703 arg01
, TREE_OPERAND (arg00
, 1));
10704 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10705 build_int_cst (TREE_TYPE (arg0
), 1));
10706 return fold_build2_loc (loc
, code
, type
,
10707 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10710 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
10711 && integer_onep (TREE_OPERAND (arg01
, 0)))
10713 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
10714 arg00
, TREE_OPERAND (arg01
, 1));
10715 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
10716 build_int_cst (TREE_TYPE (arg0
), 1));
10717 return fold_build2_loc (loc
, code
, type
,
10718 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
10723 /* If this is an NE or EQ comparison of zero against the result of a
10724 signed MOD operation whose second operand is a power of 2, make
10725 the MOD operation unsigned since it is simpler and equivalent. */
10726 if (integer_zerop (arg1
)
10727 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
10728 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
10729 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
10730 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
10731 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
10732 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10734 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
10735 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
10736 fold_convert_loc (loc
, newtype
,
10737 TREE_OPERAND (arg0
, 0)),
10738 fold_convert_loc (loc
, newtype
,
10739 TREE_OPERAND (arg0
, 1)));
10741 return fold_build2_loc (loc
, code
, type
, newmod
,
10742 fold_convert_loc (loc
, newtype
, arg1
));
10745 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10746 C1 is a valid shift constant, and C2 is a power of two, i.e.
10748 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10749 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
10750 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
10752 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10753 && integer_zerop (arg1
))
10755 tree itype
= TREE_TYPE (arg0
);
10756 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
10757 prec
= TYPE_PRECISION (itype
);
10759 /* Check for a valid shift count. */
10760 if (wi::ltu_p (wi::to_wide (arg001
), prec
))
10762 tree arg01
= TREE_OPERAND (arg0
, 1);
10763 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10764 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
10765 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10766 can be rewritten as (X & (C2 << C1)) != 0. */
10767 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
10769 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
10770 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
10771 return fold_build2_loc (loc
, code
, type
, tem
,
10772 fold_convert_loc (loc
, itype
, arg1
));
10774 /* Otherwise, for signed (arithmetic) shifts,
10775 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10776 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
10777 else if (!TYPE_UNSIGNED (itype
))
10778 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
10779 arg000
, build_int_cst (itype
, 0));
10780 /* Otherwise, of unsigned (logical) shifts,
10781 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10782 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
10784 return omit_one_operand_loc (loc
, type
,
10785 code
== EQ_EXPR
? integer_one_node
10786 : integer_zero_node
,
10791 /* If this is a comparison of a field, we may be able to simplify it. */
10792 if ((TREE_CODE (arg0
) == COMPONENT_REF
10793 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
10794 /* Handle the constant case even without -O
10795 to make sure the warnings are given. */
10796 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
10798 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
10803 /* Optimize comparisons of strlen vs zero to a compare of the
10804 first character of the string vs zero. To wit,
10805 strlen(ptr) == 0 => *ptr == 0
10806 strlen(ptr) != 0 => *ptr != 0
10807 Other cases should reduce to one of these two (or a constant)
10808 due to the return value of strlen being unsigned. */
10809 if (TREE_CODE (arg0
) == CALL_EXPR
&& integer_zerop (arg1
))
10811 tree fndecl
= get_callee_fndecl (arg0
);
10814 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
10815 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
10816 && call_expr_nargs (arg0
) == 1
10817 && (TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0)))
10821 = build_pointer_type (build_qualified_type (char_type_node
,
10823 tree ptr
= fold_convert_loc (loc
, ptrtype
,
10824 CALL_EXPR_ARG (arg0
, 0));
10825 tree iref
= build_fold_indirect_ref_loc (loc
, ptr
);
10826 return fold_build2_loc (loc
, code
, type
, iref
,
10827 build_int_cst (TREE_TYPE (iref
), 0));
10831 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10832 of X. Similarly fold (X >> C) == 0 into X >= 0. */
10833 if (TREE_CODE (arg0
) == RSHIFT_EXPR
10834 && integer_zerop (arg1
)
10835 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
10837 tree arg00
= TREE_OPERAND (arg0
, 0);
10838 tree arg01
= TREE_OPERAND (arg0
, 1);
10839 tree itype
= TREE_TYPE (arg00
);
10840 if (wi::to_wide (arg01
) == element_precision (itype
) - 1)
10842 if (TYPE_UNSIGNED (itype
))
10844 itype
= signed_type_for (itype
);
10845 arg00
= fold_convert_loc (loc
, itype
, arg00
);
10847 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
10848 type
, arg00
, build_zero_cst (itype
));
10852 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10853 (X & C) == 0 when C is a single bit. */
10854 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10855 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
10856 && integer_zerop (arg1
)
10857 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
10859 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
10860 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
10861 TREE_OPERAND (arg0
, 1));
10862 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
10864 fold_convert_loc (loc
, TREE_TYPE (arg0
),
10868 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10869 constant C is a power of two, i.e. a single bit. */
10870 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10871 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
10872 && integer_zerop (arg1
)
10873 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10874 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10875 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10877 tree arg00
= TREE_OPERAND (arg0
, 0);
10878 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10879 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
10882 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10883 when is C is a power of two, i.e. a single bit. */
10884 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10885 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
10886 && integer_zerop (arg1
)
10887 && integer_pow2p (TREE_OPERAND (arg0
, 1))
10888 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
10889 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
10891 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
10892 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
10893 arg000
, TREE_OPERAND (arg0
, 1));
10894 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
10895 tem
, build_int_cst (TREE_TYPE (tem
), 0));
10898 if (integer_zerop (arg1
)
10899 && tree_expr_nonzero_p (arg0
))
10901 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
10902 return omit_one_operand_loc (loc
, type
, res
, arg0
);
10905 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
10906 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10907 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10909 tree arg00
= TREE_OPERAND (arg0
, 0);
10910 tree arg01
= TREE_OPERAND (arg0
, 1);
10911 tree arg10
= TREE_OPERAND (arg1
, 0);
10912 tree arg11
= TREE_OPERAND (arg1
, 1);
10913 tree itype
= TREE_TYPE (arg0
);
10915 if (operand_equal_p (arg01
, arg11
, 0))
10917 tem
= fold_convert_loc (loc
, itype
, arg10
);
10918 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
10919 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, tem
, arg01
);
10920 return fold_build2_loc (loc
, code
, type
, tem
,
10921 build_zero_cst (itype
));
10923 if (operand_equal_p (arg01
, arg10
, 0))
10925 tem
= fold_convert_loc (loc
, itype
, arg11
);
10926 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
10927 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, tem
, arg01
);
10928 return fold_build2_loc (loc
, code
, type
, tem
,
10929 build_zero_cst (itype
));
10931 if (operand_equal_p (arg00
, arg11
, 0))
10933 tem
= fold_convert_loc (loc
, itype
, arg10
);
10934 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
, tem
);
10935 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, tem
, arg00
);
10936 return fold_build2_loc (loc
, code
, type
, tem
,
10937 build_zero_cst (itype
));
10939 if (operand_equal_p (arg00
, arg10
, 0))
10941 tem
= fold_convert_loc (loc
, itype
, arg11
);
10942 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
, tem
);
10943 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, tem
, arg00
);
10944 return fold_build2_loc (loc
, code
, type
, tem
,
10945 build_zero_cst (itype
));
10949 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
10950 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
10952 tree arg00
= TREE_OPERAND (arg0
, 0);
10953 tree arg01
= TREE_OPERAND (arg0
, 1);
10954 tree arg10
= TREE_OPERAND (arg1
, 0);
10955 tree arg11
= TREE_OPERAND (arg1
, 1);
10956 tree itype
= TREE_TYPE (arg0
);
10958 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
10959 operand_equal_p guarantees no side-effects so we don't need
10960 to use omit_one_operand on Z. */
10961 if (operand_equal_p (arg01
, arg11
, 0))
10962 return fold_build2_loc (loc
, code
, type
, arg00
,
10963 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10965 if (operand_equal_p (arg01
, arg10
, 0))
10966 return fold_build2_loc (loc
, code
, type
, arg00
,
10967 fold_convert_loc (loc
, TREE_TYPE (arg00
),
10969 if (operand_equal_p (arg00
, arg11
, 0))
10970 return fold_build2_loc (loc
, code
, type
, arg01
,
10971 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10973 if (operand_equal_p (arg00
, arg10
, 0))
10974 return fold_build2_loc (loc
, code
, type
, arg01
,
10975 fold_convert_loc (loc
, TREE_TYPE (arg01
),
10978 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
10979 if (TREE_CODE (arg01
) == INTEGER_CST
10980 && TREE_CODE (arg11
) == INTEGER_CST
)
10982 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
10983 fold_convert_loc (loc
, itype
, arg11
));
10984 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
10985 return fold_build2_loc (loc
, code
, type
, tem
,
10986 fold_convert_loc (loc
, itype
, arg10
));
10990 /* Attempt to simplify equality/inequality comparisons of complex
10991 values. Only lower the comparison if the result is known or
10992 can be simplified to a single scalar comparison. */
10993 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
10994 || TREE_CODE (arg0
) == COMPLEX_CST
)
10995 && (TREE_CODE (arg1
) == COMPLEX_EXPR
10996 || TREE_CODE (arg1
) == COMPLEX_CST
))
10998 tree real0
, imag0
, real1
, imag1
;
11001 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
11003 real0
= TREE_OPERAND (arg0
, 0);
11004 imag0
= TREE_OPERAND (arg0
, 1);
11008 real0
= TREE_REALPART (arg0
);
11009 imag0
= TREE_IMAGPART (arg0
);
11012 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
11014 real1
= TREE_OPERAND (arg1
, 0);
11015 imag1
= TREE_OPERAND (arg1
, 1);
11019 real1
= TREE_REALPART (arg1
);
11020 imag1
= TREE_IMAGPART (arg1
);
11023 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
11024 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
11026 if (integer_zerop (rcond
))
11028 if (code
== EQ_EXPR
)
11029 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
11031 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
11035 if (code
== NE_EXPR
)
11036 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
11038 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
11042 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
11043 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
11045 if (integer_zerop (icond
))
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
, real0
, real1
);
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
, real0
, real1
);
11068 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
11069 if (tem
!= NULL_TREE
)
11072 /* Transform comparisons of the form X +- C CMP X. */
11073 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
11074 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11075 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
11076 && !HONOR_SNANS (arg0
))
11078 tree arg01
= TREE_OPERAND (arg0
, 1);
11079 enum tree_code code0
= TREE_CODE (arg0
);
11080 int is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
11082 /* (X - c) > X becomes false. */
11083 if (code
== GT_EXPR
11084 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
11085 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
11086 return constant_boolean_node (0, type
);
11088 /* Likewise (X + c) < X becomes false. */
11089 if (code
== LT_EXPR
11090 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
11091 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
11092 return constant_boolean_node (0, type
);
11094 /* Convert (X - c) <= X to true. */
11095 if (!HONOR_NANS (arg1
)
11097 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
11098 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
11099 return constant_boolean_node (1, type
);
11101 /* Convert (X + c) >= X to true. */
11102 if (!HONOR_NANS (arg1
)
11104 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
11105 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
11106 return constant_boolean_node (1, type
);
11109 /* If we are comparing an ABS_EXPR with a constant, we can
11110 convert all the cases into explicit comparisons, but they may
11111 well not be faster than doing the ABS and one comparison.
11112 But ABS (X) <= C is a range comparison, which becomes a subtraction
11113 and a comparison, and is probably faster. */
11114 if (code
== LE_EXPR
11115 && TREE_CODE (arg1
) == INTEGER_CST
11116 && TREE_CODE (arg0
) == ABS_EXPR
11117 && ! TREE_SIDE_EFFECTS (arg0
)
11118 && (tem
= negate_expr (arg1
)) != 0
11119 && TREE_CODE (tem
) == INTEGER_CST
11120 && !TREE_OVERFLOW (tem
))
11121 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
11122 build2 (GE_EXPR
, type
,
11123 TREE_OPERAND (arg0
, 0), tem
),
11124 build2 (LE_EXPR
, type
,
11125 TREE_OPERAND (arg0
, 0), arg1
));
11127 /* Convert ABS_EXPR<x> >= 0 to true. */
11128 strict_overflow_p
= false;
11129 if (code
== GE_EXPR
11130 && (integer_zerop (arg1
)
11131 || (! HONOR_NANS (arg0
)
11132 && real_zerop (arg1
)))
11133 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11135 if (strict_overflow_p
)
11136 fold_overflow_warning (("assuming signed overflow does not occur "
11137 "when simplifying comparison of "
11138 "absolute value and zero"),
11139 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11140 return omit_one_operand_loc (loc
, type
,
11141 constant_boolean_node (true, type
),
11145 /* Convert ABS_EXPR<x> < 0 to false. */
11146 strict_overflow_p
= false;
11147 if (code
== LT_EXPR
11148 && (integer_zerop (arg1
) || real_zerop (arg1
))
11149 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
11151 if (strict_overflow_p
)
11152 fold_overflow_warning (("assuming signed overflow does not occur "
11153 "when simplifying comparison of "
11154 "absolute value and zero"),
11155 WARN_STRICT_OVERFLOW_CONDITIONAL
);
11156 return omit_one_operand_loc (loc
, type
,
11157 constant_boolean_node (false, type
),
11161 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11162 and similarly for >= into !=. */
11163 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11164 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11165 && TREE_CODE (arg1
) == LSHIFT_EXPR
11166 && integer_onep (TREE_OPERAND (arg1
, 0)))
11167 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11168 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11169 TREE_OPERAND (arg1
, 1)),
11170 build_zero_cst (TREE_TYPE (arg0
)));
11172 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
11173 otherwise Y might be >= # of bits in X's type and thus e.g.
11174 (unsigned char) (1 << Y) for Y 15 might be 0.
11175 If the cast is widening, then 1 << Y should have unsigned type,
11176 otherwise if Y is number of bits in the signed shift type minus 1,
11177 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
11178 31 might be 0xffffffff80000000. */
11179 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
11180 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
11181 && CONVERT_EXPR_P (arg1
)
11182 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
11183 && (element_precision (TREE_TYPE (arg1
))
11184 >= element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
11185 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
11186 || (element_precision (TREE_TYPE (arg1
))
11187 == element_precision (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
11188 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
11190 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
11191 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
11192 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
11193 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
11194 build_zero_cst (TREE_TYPE (arg0
)));
11199 case UNORDERED_EXPR
:
11207 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
11209 tree targ0
= strip_float_extensions (arg0
);
11210 tree targ1
= strip_float_extensions (arg1
);
11211 tree newtype
= TREE_TYPE (targ0
);
11213 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
11214 newtype
= TREE_TYPE (targ1
);
11216 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
11217 return fold_build2_loc (loc
, code
, type
,
11218 fold_convert_loc (loc
, newtype
, targ0
),
11219 fold_convert_loc (loc
, newtype
, targ1
));
11224 case COMPOUND_EXPR
:
11225 /* When pedantic, a compound expression can be neither an lvalue
11226 nor an integer constant expression. */
11227 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
11229 /* Don't let (0, 0) be null pointer constant. */
11230 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
11231 : fold_convert_loc (loc
, type
, arg1
);
11232 return pedantic_non_lvalue_loc (loc
, tem
);
11235 /* An ASSERT_EXPR should never be passed to fold_binary. */
11236 gcc_unreachable ();
11240 } /* switch (code) */
11243 /* Used by contains_label_[p1]. */
11245 struct contains_label_data
11247 hash_set
<tree
> *pset
;
11248 bool inside_switch_p
;
11251 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
11252 a LABEL_EXPR or CASE_LABEL_EXPR not inside of another SWITCH_EXPR; otherwise
11253 return NULL_TREE. Do not check the subtrees of GOTO_EXPR. */
11256 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data
)
11258 contains_label_data
*d
= (contains_label_data
*) data
;
11259 switch (TREE_CODE (*tp
))
11264 case CASE_LABEL_EXPR
:
11265 if (!d
->inside_switch_p
)
11270 if (!d
->inside_switch_p
)
11272 if (walk_tree (&SWITCH_COND (*tp
), contains_label_1
, data
, d
->pset
))
11274 d
->inside_switch_p
= true;
11275 if (walk_tree (&SWITCH_BODY (*tp
), contains_label_1
, data
, d
->pset
))
11277 d
->inside_switch_p
= false;
11278 *walk_subtrees
= 0;
11283 *walk_subtrees
= 0;
11291 /* Return whether the sub-tree ST contains a label which is accessible from
11292 outside the sub-tree. */
11295 contains_label_p (tree st
)
11297 hash_set
<tree
> pset
;
11298 contains_label_data data
= { &pset
, false };
11299 return walk_tree (&st
, contains_label_1
, &data
, &pset
) != NULL_TREE
;
11302 /* Fold a ternary expression of code CODE and type TYPE with operands
11303 OP0, OP1, and OP2. Return the folded expression if folding is
11304 successful. Otherwise, return NULL_TREE. */
11307 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
11308 tree op0
, tree op1
, tree op2
)
11311 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
11312 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11314 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
11315 && TREE_CODE_LENGTH (code
) == 3);
11317 /* If this is a commutative operation, and OP0 is a constant, move it
11318 to OP1 to reduce the number of tests below. */
11319 if (commutative_ternary_tree_code (code
)
11320 && tree_swap_operands_p (op0
, op1
))
11321 return fold_build3_loc (loc
, code
, type
, op1
, op0
, op2
);
11323 tem
= generic_simplify (loc
, code
, type
, op0
, op1
, op2
);
11327 /* Strip any conversions that don't change the mode. This is safe
11328 for every expression, except for a comparison expression because
11329 its signedness is derived from its operands. So, in the latter
11330 case, only strip conversions that don't change the signedness.
11332 Note that this is done as an internal manipulation within the
11333 constant folder, in order to find the simplest representation of
11334 the arguments so that their form can be studied. In any cases,
11335 the appropriate type conversions should be put back in the tree
11336 that will get out of the constant folder. */
11357 case COMPONENT_REF
:
11358 if (TREE_CODE (arg0
) == CONSTRUCTOR
11359 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
11361 unsigned HOST_WIDE_INT idx
;
11363 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
11370 case VEC_COND_EXPR
:
11371 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11372 so all simple results must be passed through pedantic_non_lvalue. */
11373 if (TREE_CODE (arg0
) == INTEGER_CST
)
11375 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
11376 tem
= integer_zerop (arg0
) ? op2
: op1
;
11377 /* Only optimize constant conditions when the selected branch
11378 has the same type as the COND_EXPR. This avoids optimizing
11379 away "c ? x : throw", where the throw has a void type.
11380 Avoid throwing away that operand which contains label. */
11381 if ((!TREE_SIDE_EFFECTS (unused_op
)
11382 || !contains_label_p (unused_op
))
11383 && (! VOID_TYPE_P (TREE_TYPE (tem
))
11384 || VOID_TYPE_P (type
)))
11385 return pedantic_non_lvalue_loc (loc
, tem
);
11388 else if (TREE_CODE (arg0
) == VECTOR_CST
)
11390 unsigned HOST_WIDE_INT nelts
;
11391 if ((TREE_CODE (arg1
) == VECTOR_CST
11392 || TREE_CODE (arg1
) == CONSTRUCTOR
)
11393 && (TREE_CODE (arg2
) == VECTOR_CST
11394 || TREE_CODE (arg2
) == CONSTRUCTOR
)
11395 && TYPE_VECTOR_SUBPARTS (type
).is_constant (&nelts
))
11397 vec_perm_builder
sel (nelts
, nelts
, 1);
11398 for (unsigned int i
= 0; i
< nelts
; i
++)
11400 tree val
= VECTOR_CST_ELT (arg0
, i
);
11401 if (integer_all_onesp (val
))
11402 sel
.quick_push (i
);
11403 else if (integer_zerop (val
))
11404 sel
.quick_push (nelts
+ i
);
11405 else /* Currently unreachable. */
11408 vec_perm_indices
indices (sel
, 2, nelts
);
11409 tree t
= fold_vec_perm (type
, arg1
, arg2
, indices
);
11410 if (t
!= NULL_TREE
)
11415 /* If we have A op B ? A : C, we may be able to convert this to a
11416 simpler expression, depending on the operation and the values
11417 of B and C. Signed zeros prevent all of these transformations,
11418 for reasons given above each one.
11420 Also try swapping the arguments and inverting the conditional. */
11421 if (COMPARISON_CLASS_P (arg0
)
11422 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0), op1
)
11423 && !HONOR_SIGNED_ZEROS (element_mode (op1
)))
11425 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
11430 if (COMPARISON_CLASS_P (arg0
)
11431 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0), op2
)
11432 && !HONOR_SIGNED_ZEROS (element_mode (op2
)))
11434 location_t loc0
= expr_location_or (arg0
, loc
);
11435 tem
= fold_invert_truthvalue (loc0
, arg0
);
11436 if (tem
&& COMPARISON_CLASS_P (tem
))
11438 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
11444 /* If the second operand is simpler than the third, swap them
11445 since that produces better jump optimization results. */
11446 if (truth_value_p (TREE_CODE (arg0
))
11447 && tree_swap_operands_p (op1
, op2
))
11449 location_t loc0
= expr_location_or (arg0
, loc
);
11450 /* See if this can be inverted. If it can't, possibly because
11451 it was a floating-point inequality comparison, don't do
11453 tem
= fold_invert_truthvalue (loc0
, arg0
);
11455 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
11458 /* Convert A ? 1 : 0 to simply A. */
11459 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
11460 : (integer_onep (op1
)
11461 && !VECTOR_TYPE_P (type
)))
11462 && integer_zerop (op2
)
11463 /* If we try to convert OP0 to our type, the
11464 call to fold will try to move the conversion inside
11465 a COND, which will recurse. In that case, the COND_EXPR
11466 is probably the best choice, so leave it alone. */
11467 && type
== TREE_TYPE (arg0
))
11468 return pedantic_non_lvalue_loc (loc
, arg0
);
11470 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
11471 over COND_EXPR in cases such as floating point comparisons. */
11472 if (integer_zerop (op1
)
11473 && code
== COND_EXPR
11474 && integer_onep (op2
)
11475 && !VECTOR_TYPE_P (type
)
11476 && truth_value_p (TREE_CODE (arg0
)))
11477 return pedantic_non_lvalue_loc (loc
,
11478 fold_convert_loc (loc
, type
,
11479 invert_truthvalue_loc (loc
,
11482 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
11483 if (TREE_CODE (arg0
) == LT_EXPR
11484 && integer_zerop (TREE_OPERAND (arg0
, 1))
11485 && integer_zerop (op2
)
11486 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
11488 /* sign_bit_p looks through both zero and sign extensions,
11489 but for this optimization only sign extensions are
11491 tree tem2
= TREE_OPERAND (arg0
, 0);
11492 while (tem
!= tem2
)
11494 if (TREE_CODE (tem2
) != NOP_EXPR
11495 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
11500 tem2
= TREE_OPERAND (tem2
, 0);
11502 /* sign_bit_p only checks ARG1 bits within A's precision.
11503 If <sign bit of A> has wider type than A, bits outside
11504 of A's precision in <sign bit of A> need to be checked.
11505 If they are all 0, this optimization needs to be done
11506 in unsigned A's type, if they are all 1 in signed A's type,
11507 otherwise this can't be done. */
11509 && TYPE_PRECISION (TREE_TYPE (tem
))
11510 < TYPE_PRECISION (TREE_TYPE (arg1
))
11511 && TYPE_PRECISION (TREE_TYPE (tem
))
11512 < TYPE_PRECISION (type
))
11514 int inner_width
, outer_width
;
11517 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
11518 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
11519 if (outer_width
> TYPE_PRECISION (type
))
11520 outer_width
= TYPE_PRECISION (type
);
11522 wide_int mask
= wi::shifted_mask
11523 (inner_width
, outer_width
- inner_width
, false,
11524 TYPE_PRECISION (TREE_TYPE (arg1
)));
11526 wide_int common
= mask
& wi::to_wide (arg1
);
11527 if (common
== mask
)
11529 tem_type
= signed_type_for (TREE_TYPE (tem
));
11530 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11532 else if (common
== 0)
11534 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
11535 tem
= fold_convert_loc (loc
, tem_type
, tem
);
11543 fold_convert_loc (loc
, type
,
11544 fold_build2_loc (loc
, BIT_AND_EXPR
,
11545 TREE_TYPE (tem
), tem
,
11546 fold_convert_loc (loc
,
11551 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
11552 already handled above. */
11553 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11554 && integer_onep (TREE_OPERAND (arg0
, 1))
11555 && integer_zerop (op2
)
11556 && integer_pow2p (arg1
))
11558 tree tem
= TREE_OPERAND (arg0
, 0);
11560 if (TREE_CODE (tem
) == RSHIFT_EXPR
11561 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
11562 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
)
11563 == tree_to_uhwi (TREE_OPERAND (tem
, 1)))
11564 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11565 fold_convert_loc (loc
, type
,
11566 TREE_OPERAND (tem
, 0)),
11570 /* A & N ? N : 0 is simply A & N if N is a power of two. This
11571 is probably obsolete because the first operand should be a
11572 truth value (that's why we have the two cases above), but let's
11573 leave it in until we can confirm this for all front-ends. */
11574 if (integer_zerop (op2
)
11575 && TREE_CODE (arg0
) == NE_EXPR
11576 && integer_zerop (TREE_OPERAND (arg0
, 1))
11577 && integer_pow2p (arg1
)
11578 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
11579 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
11580 arg1
, OEP_ONLY_CONST
)
11581 /* operand_equal_p compares just value, not precision, so e.g.
11582 arg1 could be 8-bit -128 and be power of two, but BIT_AND_EXPR
11583 second operand 32-bit -128, which is not a power of two (or vice
11585 && integer_pow2p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1)))
11586 return pedantic_non_lvalue_loc (loc
,
11587 fold_convert_loc (loc
, type
,
11588 TREE_OPERAND (arg0
,
11591 /* Disable the transformations below for vectors, since
11592 fold_binary_op_with_conditional_arg may undo them immediately,
11593 yielding an infinite loop. */
11594 if (code
== VEC_COND_EXPR
)
11597 /* Convert A ? B : 0 into A && B if A and B are truth values. */
11598 if (integer_zerop (op2
)
11599 && truth_value_p (TREE_CODE (arg0
))
11600 && truth_value_p (TREE_CODE (arg1
))
11601 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11602 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
11603 : TRUTH_ANDIF_EXPR
,
11604 type
, fold_convert_loc (loc
, type
, arg0
), op1
);
11606 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
11607 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
11608 && truth_value_p (TREE_CODE (arg0
))
11609 && truth_value_p (TREE_CODE (arg1
))
11610 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11612 location_t loc0
= expr_location_or (arg0
, loc
);
11613 /* Only perform transformation if ARG0 is easily inverted. */
11614 tem
= fold_invert_truthvalue (loc0
, arg0
);
11616 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11619 type
, fold_convert_loc (loc
, type
, tem
),
11623 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
11624 if (integer_zerop (arg1
)
11625 && truth_value_p (TREE_CODE (arg0
))
11626 && truth_value_p (TREE_CODE (op2
))
11627 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11629 location_t loc0
= expr_location_or (arg0
, loc
);
11630 /* Only perform transformation if ARG0 is easily inverted. */
11631 tem
= fold_invert_truthvalue (loc0
, arg0
);
11633 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11634 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
11635 type
, fold_convert_loc (loc
, type
, tem
),
11639 /* Convert A ? 1 : B into A || B if A and B are truth values. */
11640 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
11641 && truth_value_p (TREE_CODE (arg0
))
11642 && truth_value_p (TREE_CODE (op2
))
11643 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
11644 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
11645 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
11646 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
11651 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
11652 of fold_ternary on them. */
11653 gcc_unreachable ();
11655 case BIT_FIELD_REF
:
11656 if (TREE_CODE (arg0
) == VECTOR_CST
11657 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
11658 || (VECTOR_TYPE_P (type
)
11659 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
))))
11660 && tree_fits_uhwi_p (op1
)
11661 && tree_fits_uhwi_p (op2
))
11663 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
11664 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
11665 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
11666 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
11669 && (idx
% width
) == 0
11670 && (n
% width
) == 0
11671 && known_le ((idx
+ n
) / width
,
11672 TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
))))
11677 if (TREE_CODE (arg0
) == VECTOR_CST
)
11681 tem
= VECTOR_CST_ELT (arg0
, idx
);
11682 if (VECTOR_TYPE_P (type
))
11683 tem
= fold_build1 (VIEW_CONVERT_EXPR
, type
, tem
);
11687 tree_vector_builder
vals (type
, n
, 1);
11688 for (unsigned i
= 0; i
< n
; ++i
)
11689 vals
.quick_push (VECTOR_CST_ELT (arg0
, idx
+ i
));
11690 return vals
.build ();
11695 /* On constants we can use native encode/interpret to constant
11696 fold (nearly) all BIT_FIELD_REFs. */
11697 if (CONSTANT_CLASS_P (arg0
)
11698 && can_native_interpret_type_p (type
)
11699 && BITS_PER_UNIT
== 8
11700 && tree_fits_uhwi_p (op1
)
11701 && tree_fits_uhwi_p (op2
))
11703 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11704 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
11705 /* Limit us to a reasonable amount of work. To relax the
11706 other limitations we need bit-shifting of the buffer
11707 and rounding up the size. */
11708 if (bitpos
% BITS_PER_UNIT
== 0
11709 && bitsize
% BITS_PER_UNIT
== 0
11710 && bitsize
<= MAX_BITSIZE_MODE_ANY_MODE
)
11712 unsigned char b
[MAX_BITSIZE_MODE_ANY_MODE
/ BITS_PER_UNIT
];
11713 unsigned HOST_WIDE_INT len
11714 = native_encode_expr (arg0
, b
, bitsize
/ BITS_PER_UNIT
,
11715 bitpos
/ BITS_PER_UNIT
);
11717 && len
* BITS_PER_UNIT
>= bitsize
)
11719 tree v
= native_interpret_expr (type
, b
,
11720 bitsize
/ BITS_PER_UNIT
);
11730 /* For integers we can decompose the FMA if possible. */
11731 if (TREE_CODE (arg0
) == INTEGER_CST
11732 && TREE_CODE (arg1
) == INTEGER_CST
)
11733 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
11734 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
11735 if (integer_zerop (arg2
))
11736 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
11738 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
11740 case VEC_PERM_EXPR
:
11741 if (TREE_CODE (arg2
) == VECTOR_CST
)
11743 /* Build a vector of integers from the tree mask. */
11744 vec_perm_builder builder
;
11745 if (!tree_to_vec_perm_builder (&builder
, arg2
))
11748 /* Create a vec_perm_indices for the integer vector. */
11749 poly_uint64 nelts
= TYPE_VECTOR_SUBPARTS (type
);
11750 bool single_arg
= (op0
== op1
);
11751 vec_perm_indices
sel (builder
, single_arg
? 1 : 2, nelts
);
11753 /* Check for cases that fold to OP0 or OP1 in their original
11755 if (sel
.series_p (0, 1, 0, 1))
11757 if (sel
.series_p (0, 1, nelts
, 1))
11762 if (sel
.all_from_input_p (0))
11764 else if (sel
.all_from_input_p (1))
11767 sel
.rotate_inputs (1);
11771 if ((TREE_CODE (op0
) == VECTOR_CST
11772 || TREE_CODE (op0
) == CONSTRUCTOR
)
11773 && (TREE_CODE (op1
) == VECTOR_CST
11774 || TREE_CODE (op1
) == CONSTRUCTOR
))
11776 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
11777 if (t
!= NULL_TREE
)
11781 bool changed
= (op0
== op1
&& !single_arg
);
11783 /* Generate a canonical form of the selector. */
11784 if (arg2
== op2
&& sel
.encoding () != builder
)
11786 /* Some targets are deficient and fail to expand a single
11787 argument permutation while still allowing an equivalent
11788 2-argument version. */
11789 if (sel
.ninputs () == 2
11790 || can_vec_perm_const_p (TYPE_MODE (type
), sel
, false))
11791 op2
= vec_perm_indices_to_tree (TREE_TYPE (arg2
), sel
);
11794 vec_perm_indices
sel2 (builder
, 2, nelts
);
11795 if (can_vec_perm_const_p (TYPE_MODE (type
), sel2
, false))
11796 op2
= vec_perm_indices_to_tree (TREE_TYPE (arg2
), sel2
);
11798 /* Not directly supported with either encoding,
11799 so use the preferred form. */
11800 op2
= vec_perm_indices_to_tree (TREE_TYPE (arg2
), sel
);
11806 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
11810 case BIT_INSERT_EXPR
:
11811 /* Perform (partial) constant folding of BIT_INSERT_EXPR. */
11812 if (TREE_CODE (arg0
) == INTEGER_CST
11813 && TREE_CODE (arg1
) == INTEGER_CST
)
11815 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11816 unsigned bitsize
= TYPE_PRECISION (TREE_TYPE (arg1
));
11817 wide_int tem
= (wi::to_wide (arg0
)
11818 & wi::shifted_mask (bitpos
, bitsize
, true,
11819 TYPE_PRECISION (type
)));
11821 = wi::lshift (wi::zext (wi::to_wide (arg1
, TYPE_PRECISION (type
)),
11823 return wide_int_to_tree (type
, wi::bit_or (tem
, tem2
));
11825 else if (TREE_CODE (arg0
) == VECTOR_CST
11826 && CONSTANT_CLASS_P (arg1
)
11827 && types_compatible_p (TREE_TYPE (TREE_TYPE (arg0
)),
11830 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
11831 unsigned HOST_WIDE_INT elsize
11832 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (arg1
)));
11833 if (bitpos
% elsize
== 0)
11835 unsigned k
= bitpos
/ elsize
;
11836 unsigned HOST_WIDE_INT nelts
;
11837 if (operand_equal_p (VECTOR_CST_ELT (arg0
, k
), arg1
, 0))
11839 else if (VECTOR_CST_NELTS (arg0
).is_constant (&nelts
))
11841 tree_vector_builder
elts (type
, nelts
, 1);
11842 elts
.quick_grow (nelts
);
11843 for (unsigned HOST_WIDE_INT i
= 0; i
< nelts
; ++i
)
11844 elts
[i
] = (i
== k
? arg1
: VECTOR_CST_ELT (arg0
, i
));
11845 return elts
.build ();
11853 } /* switch (code) */
11856 /* Gets the element ACCESS_INDEX from CTOR, which must be a CONSTRUCTOR
11857 of an array (or vector). */
11860 get_array_ctor_element_at_index (tree ctor
, offset_int access_index
)
11862 tree index_type
= NULL_TREE
;
11863 offset_int low_bound
= 0;
11865 if (TREE_CODE (TREE_TYPE (ctor
)) == ARRAY_TYPE
)
11867 tree domain_type
= TYPE_DOMAIN (TREE_TYPE (ctor
));
11868 if (domain_type
&& TYPE_MIN_VALUE (domain_type
))
11870 /* Static constructors for variably sized objects makes no sense. */
11871 gcc_assert (TREE_CODE (TYPE_MIN_VALUE (domain_type
)) == INTEGER_CST
);
11872 index_type
= TREE_TYPE (TYPE_MIN_VALUE (domain_type
));
11873 low_bound
= wi::to_offset (TYPE_MIN_VALUE (domain_type
));
11878 access_index
= wi::ext (access_index
, TYPE_PRECISION (index_type
),
11879 TYPE_SIGN (index_type
));
11881 offset_int index
= low_bound
- 1;
11883 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11884 TYPE_SIGN (index_type
));
11886 offset_int max_index
;
11887 unsigned HOST_WIDE_INT cnt
;
11890 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor
), cnt
, cfield
, cval
)
11892 /* Array constructor might explicitly set index, or specify a range,
11893 or leave index NULL meaning that it is next index after previous
11897 if (TREE_CODE (cfield
) == INTEGER_CST
)
11898 max_index
= index
= wi::to_offset (cfield
);
11901 gcc_assert (TREE_CODE (cfield
) == RANGE_EXPR
);
11902 index
= wi::to_offset (TREE_OPERAND (cfield
, 0));
11903 max_index
= wi::to_offset (TREE_OPERAND (cfield
, 1));
11910 index
= wi::ext (index
, TYPE_PRECISION (index_type
),
11911 TYPE_SIGN (index_type
));
11915 /* Do we have match? */
11916 if (wi::cmpu (access_index
, index
) >= 0
11917 && wi::cmpu (access_index
, max_index
) <= 0)
11923 /* Perform constant folding and related simplification of EXPR.
11924 The related simplifications include x*1 => x, x*0 => 0, etc.,
11925 and application of the associative law.
11926 NOP_EXPR conversions may be removed freely (as long as we
11927 are careful not to change the type of the overall expression).
11928 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11929 but we can constant-fold them if they have constant operands. */
11931 #ifdef ENABLE_FOLD_CHECKING
11932 # define fold(x) fold_1 (x)
11933 static tree
fold_1 (tree
);
11939 const tree t
= expr
;
11940 enum tree_code code
= TREE_CODE (t
);
11941 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
11943 location_t loc
= EXPR_LOCATION (expr
);
11945 /* Return right away if a constant. */
11946 if (kind
== tcc_constant
)
11949 /* CALL_EXPR-like objects with variable numbers of operands are
11950 treated specially. */
11951 if (kind
== tcc_vl_exp
)
11953 if (code
== CALL_EXPR
)
11955 tem
= fold_call_expr (loc
, expr
, false);
11956 return tem
? tem
: expr
;
11961 if (IS_EXPR_CODE_CLASS (kind
))
11963 tree type
= TREE_TYPE (t
);
11964 tree op0
, op1
, op2
;
11966 switch (TREE_CODE_LENGTH (code
))
11969 op0
= TREE_OPERAND (t
, 0);
11970 tem
= fold_unary_loc (loc
, code
, type
, op0
);
11971 return tem
? tem
: expr
;
11973 op0
= TREE_OPERAND (t
, 0);
11974 op1
= TREE_OPERAND (t
, 1);
11975 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
11976 return tem
? tem
: expr
;
11978 op0
= TREE_OPERAND (t
, 0);
11979 op1
= TREE_OPERAND (t
, 1);
11980 op2
= TREE_OPERAND (t
, 2);
11981 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
11982 return tem
? tem
: expr
;
11992 tree op0
= TREE_OPERAND (t
, 0);
11993 tree op1
= TREE_OPERAND (t
, 1);
11995 if (TREE_CODE (op1
) == INTEGER_CST
11996 && TREE_CODE (op0
) == CONSTRUCTOR
11997 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
11999 tree val
= get_array_ctor_element_at_index (op0
,
12000 wi::to_offset (op1
));
12008 /* Return a VECTOR_CST if possible. */
12011 tree type
= TREE_TYPE (t
);
12012 if (TREE_CODE (type
) != VECTOR_TYPE
)
12017 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
12018 if (! CONSTANT_CLASS_P (val
))
12021 return build_vector_from_ctor (type
, CONSTRUCTOR_ELTS (t
));
12025 return fold (DECL_INITIAL (t
));
12029 } /* switch (code) */
12032 #ifdef ENABLE_FOLD_CHECKING
12035 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
12036 hash_table
<nofree_ptr_hash
<const tree_node
> > *);
12037 static void fold_check_failed (const_tree
, const_tree
);
12038 void print_fold_checksum (const_tree
);
12040 /* When --enable-checking=fold, compute a digest of expr before
12041 and after actual fold call to see if fold did not accidentally
12042 change original expr. */
12048 struct md5_ctx ctx
;
12049 unsigned char checksum_before
[16], checksum_after
[16];
12050 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12052 md5_init_ctx (&ctx
);
12053 fold_checksum_tree (expr
, &ctx
, &ht
);
12054 md5_finish_ctx (&ctx
, checksum_before
);
12057 ret
= fold_1 (expr
);
12059 md5_init_ctx (&ctx
);
12060 fold_checksum_tree (expr
, &ctx
, &ht
);
12061 md5_finish_ctx (&ctx
, checksum_after
);
12063 if (memcmp (checksum_before
, checksum_after
, 16))
12064 fold_check_failed (expr
, ret
);
12070 print_fold_checksum (const_tree expr
)
12072 struct md5_ctx ctx
;
12073 unsigned char checksum
[16], cnt
;
12074 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12076 md5_init_ctx (&ctx
);
12077 fold_checksum_tree (expr
, &ctx
, &ht
);
12078 md5_finish_ctx (&ctx
, checksum
);
12079 for (cnt
= 0; cnt
< 16; ++cnt
)
12080 fprintf (stderr
, "%02x", checksum
[cnt
]);
12081 putc ('\n', stderr
);
12085 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
12087 internal_error ("fold check: original tree changed by fold");
12091 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
12092 hash_table
<nofree_ptr_hash
<const tree_node
> > *ht
)
12094 const tree_node
**slot
;
12095 enum tree_code code
;
12096 union tree_node buf
;
12102 slot
= ht
->find_slot (expr
, INSERT
);
12106 code
= TREE_CODE (expr
);
12107 if (TREE_CODE_CLASS (code
) == tcc_declaration
12108 && HAS_DECL_ASSEMBLER_NAME_P (expr
))
12110 /* Allow DECL_ASSEMBLER_NAME and symtab_node to be modified. */
12111 memcpy ((char *) &buf
, expr
, tree_size (expr
));
12112 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
12113 buf
.decl_with_vis
.symtab_node
= NULL
;
12114 expr
= (tree
) &buf
;
12116 else if (TREE_CODE_CLASS (code
) == tcc_type
12117 && (TYPE_POINTER_TO (expr
)
12118 || TYPE_REFERENCE_TO (expr
)
12119 || TYPE_CACHED_VALUES_P (expr
)
12120 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
12121 || TYPE_NEXT_VARIANT (expr
)
12122 || TYPE_ALIAS_SET_KNOWN_P (expr
)))
12124 /* Allow these fields to be modified. */
12126 memcpy ((char *) &buf
, expr
, tree_size (expr
));
12127 expr
= tmp
= (tree
) &buf
;
12128 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
12129 TYPE_POINTER_TO (tmp
) = NULL
;
12130 TYPE_REFERENCE_TO (tmp
) = NULL
;
12131 TYPE_NEXT_VARIANT (tmp
) = NULL
;
12132 TYPE_ALIAS_SET (tmp
) = -1;
12133 if (TYPE_CACHED_VALUES_P (tmp
))
12135 TYPE_CACHED_VALUES_P (tmp
) = 0;
12136 TYPE_CACHED_VALUES (tmp
) = NULL
;
12139 md5_process_bytes (expr
, tree_size (expr
), ctx
);
12140 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
12141 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
12142 if (TREE_CODE_CLASS (code
) != tcc_type
12143 && TREE_CODE_CLASS (code
) != tcc_declaration
12144 && code
!= TREE_LIST
12145 && code
!= SSA_NAME
12146 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
12147 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
12148 switch (TREE_CODE_CLASS (code
))
12154 md5_process_bytes (TREE_STRING_POINTER (expr
),
12155 TREE_STRING_LENGTH (expr
), ctx
);
12158 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
12159 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
12162 len
= vector_cst_encoded_nelts (expr
);
12163 for (i
= 0; i
< len
; ++i
)
12164 fold_checksum_tree (VECTOR_CST_ENCODED_ELT (expr
, i
), ctx
, ht
);
12170 case tcc_exceptional
:
12174 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
12175 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
12176 expr
= TREE_CHAIN (expr
);
12177 goto recursive_label
;
12180 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
12181 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
12187 case tcc_expression
:
12188 case tcc_reference
:
12189 case tcc_comparison
:
12192 case tcc_statement
:
12194 len
= TREE_OPERAND_LENGTH (expr
);
12195 for (i
= 0; i
< len
; ++i
)
12196 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
12198 case tcc_declaration
:
12199 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
12200 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
12201 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
12203 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
12204 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
12205 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
12206 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
12207 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
12210 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
12212 if (TREE_CODE (expr
) == FUNCTION_DECL
)
12214 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
12215 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
12217 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
12221 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
12222 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
12223 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
12224 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
12225 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
12226 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
12227 if (INTEGRAL_TYPE_P (expr
)
12228 || SCALAR_FLOAT_TYPE_P (expr
))
12230 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
12231 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
12233 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
12234 if (TREE_CODE (expr
) == RECORD_TYPE
12235 || TREE_CODE (expr
) == UNION_TYPE
12236 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
12237 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
12238 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
12245 /* Helper function for outputting the checksum of a tree T. When
12246 debugging with gdb, you can "define mynext" to be "next" followed
12247 by "call debug_fold_checksum (op0)", then just trace down till the
12250 DEBUG_FUNCTION
void
12251 debug_fold_checksum (const_tree t
)
12254 unsigned char checksum
[16];
12255 struct md5_ctx ctx
;
12256 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12258 md5_init_ctx (&ctx
);
12259 fold_checksum_tree (t
, &ctx
, &ht
);
12260 md5_finish_ctx (&ctx
, checksum
);
12263 for (i
= 0; i
< 16; i
++)
12264 fprintf (stderr
, "%d ", checksum
[i
]);
12266 fprintf (stderr
, "\n");
12271 /* Fold a unary tree expression with code CODE of type TYPE with an
12272 operand OP0. LOC is the location of the resulting expression.
12273 Return a folded expression if successful. Otherwise, return a tree
12274 expression with code CODE of type TYPE with an operand OP0. */
12277 fold_build1_loc (location_t loc
,
12278 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
12281 #ifdef ENABLE_FOLD_CHECKING
12282 unsigned char checksum_before
[16], checksum_after
[16];
12283 struct md5_ctx ctx
;
12284 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12286 md5_init_ctx (&ctx
);
12287 fold_checksum_tree (op0
, &ctx
, &ht
);
12288 md5_finish_ctx (&ctx
, checksum_before
);
12292 tem
= fold_unary_loc (loc
, code
, type
, op0
);
12294 tem
= build1_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
12296 #ifdef ENABLE_FOLD_CHECKING
12297 md5_init_ctx (&ctx
);
12298 fold_checksum_tree (op0
, &ctx
, &ht
);
12299 md5_finish_ctx (&ctx
, checksum_after
);
12301 if (memcmp (checksum_before
, checksum_after
, 16))
12302 fold_check_failed (op0
, tem
);
12307 /* Fold a binary tree expression with code CODE of type TYPE with
12308 operands OP0 and OP1. LOC is the location of the resulting
12309 expression. Return a folded expression if successful. Otherwise,
12310 return a tree expression with code CODE of type TYPE with operands
12314 fold_build2_loc (location_t loc
,
12315 enum tree_code code
, tree type
, tree op0
, tree op1
12319 #ifdef ENABLE_FOLD_CHECKING
12320 unsigned char checksum_before_op0
[16],
12321 checksum_before_op1
[16],
12322 checksum_after_op0
[16],
12323 checksum_after_op1
[16];
12324 struct md5_ctx ctx
;
12325 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12327 md5_init_ctx (&ctx
);
12328 fold_checksum_tree (op0
, &ctx
, &ht
);
12329 md5_finish_ctx (&ctx
, checksum_before_op0
);
12332 md5_init_ctx (&ctx
);
12333 fold_checksum_tree (op1
, &ctx
, &ht
);
12334 md5_finish_ctx (&ctx
, checksum_before_op1
);
12338 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
12340 tem
= build2_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
12342 #ifdef ENABLE_FOLD_CHECKING
12343 md5_init_ctx (&ctx
);
12344 fold_checksum_tree (op0
, &ctx
, &ht
);
12345 md5_finish_ctx (&ctx
, checksum_after_op0
);
12348 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12349 fold_check_failed (op0
, tem
);
12351 md5_init_ctx (&ctx
);
12352 fold_checksum_tree (op1
, &ctx
, &ht
);
12353 md5_finish_ctx (&ctx
, checksum_after_op1
);
12355 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12356 fold_check_failed (op1
, tem
);
12361 /* Fold a ternary tree expression with code CODE of type TYPE with
12362 operands OP0, OP1, and OP2. Return a folded expression if
12363 successful. Otherwise, return a tree expression with code CODE of
12364 type TYPE with operands OP0, OP1, and OP2. */
12367 fold_build3_loc (location_t loc
, enum tree_code code
, tree type
,
12368 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
12371 #ifdef ENABLE_FOLD_CHECKING
12372 unsigned char checksum_before_op0
[16],
12373 checksum_before_op1
[16],
12374 checksum_before_op2
[16],
12375 checksum_after_op0
[16],
12376 checksum_after_op1
[16],
12377 checksum_after_op2
[16];
12378 struct md5_ctx ctx
;
12379 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12381 md5_init_ctx (&ctx
);
12382 fold_checksum_tree (op0
, &ctx
, &ht
);
12383 md5_finish_ctx (&ctx
, checksum_before_op0
);
12386 md5_init_ctx (&ctx
);
12387 fold_checksum_tree (op1
, &ctx
, &ht
);
12388 md5_finish_ctx (&ctx
, checksum_before_op1
);
12391 md5_init_ctx (&ctx
);
12392 fold_checksum_tree (op2
, &ctx
, &ht
);
12393 md5_finish_ctx (&ctx
, checksum_before_op2
);
12397 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
12398 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
12400 tem
= build3_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
12402 #ifdef ENABLE_FOLD_CHECKING
12403 md5_init_ctx (&ctx
);
12404 fold_checksum_tree (op0
, &ctx
, &ht
);
12405 md5_finish_ctx (&ctx
, checksum_after_op0
);
12408 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
12409 fold_check_failed (op0
, tem
);
12411 md5_init_ctx (&ctx
);
12412 fold_checksum_tree (op1
, &ctx
, &ht
);
12413 md5_finish_ctx (&ctx
, checksum_after_op1
);
12416 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
12417 fold_check_failed (op1
, tem
);
12419 md5_init_ctx (&ctx
);
12420 fold_checksum_tree (op2
, &ctx
, &ht
);
12421 md5_finish_ctx (&ctx
, checksum_after_op2
);
12423 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
12424 fold_check_failed (op2
, tem
);
12429 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
12430 arguments in ARGARRAY, and a null static chain.
12431 Return a folded expression if successful. Otherwise, return a CALL_EXPR
12432 of type TYPE from the given operands as constructed by build_call_array. */
12435 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
12436 int nargs
, tree
*argarray
)
12439 #ifdef ENABLE_FOLD_CHECKING
12440 unsigned char checksum_before_fn
[16],
12441 checksum_before_arglist
[16],
12442 checksum_after_fn
[16],
12443 checksum_after_arglist
[16];
12444 struct md5_ctx ctx
;
12445 hash_table
<nofree_ptr_hash
<const tree_node
> > ht (32);
12448 md5_init_ctx (&ctx
);
12449 fold_checksum_tree (fn
, &ctx
, &ht
);
12450 md5_finish_ctx (&ctx
, checksum_before_fn
);
12453 md5_init_ctx (&ctx
);
12454 for (i
= 0; i
< nargs
; i
++)
12455 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12456 md5_finish_ctx (&ctx
, checksum_before_arglist
);
12460 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
12462 tem
= build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12464 #ifdef ENABLE_FOLD_CHECKING
12465 md5_init_ctx (&ctx
);
12466 fold_checksum_tree (fn
, &ctx
, &ht
);
12467 md5_finish_ctx (&ctx
, checksum_after_fn
);
12470 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
12471 fold_check_failed (fn
, tem
);
12473 md5_init_ctx (&ctx
);
12474 for (i
= 0; i
< nargs
; i
++)
12475 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
12476 md5_finish_ctx (&ctx
, checksum_after_arglist
);
12478 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
12479 fold_check_failed (NULL_TREE
, tem
);
12484 /* Perform constant folding and related simplification of initializer
12485 expression EXPR. These behave identically to "fold_buildN" but ignore
12486 potential run-time traps and exceptions that fold must preserve. */
12488 #define START_FOLD_INIT \
12489 int saved_signaling_nans = flag_signaling_nans;\
12490 int saved_trapping_math = flag_trapping_math;\
12491 int saved_rounding_math = flag_rounding_math;\
12492 int saved_trapv = flag_trapv;\
12493 int saved_folding_initializer = folding_initializer;\
12494 flag_signaling_nans = 0;\
12495 flag_trapping_math = 0;\
12496 flag_rounding_math = 0;\
12498 folding_initializer = 1;
12500 #define END_FOLD_INIT \
12501 flag_signaling_nans = saved_signaling_nans;\
12502 flag_trapping_math = saved_trapping_math;\
12503 flag_rounding_math = saved_rounding_math;\
12504 flag_trapv = saved_trapv;\
12505 folding_initializer = saved_folding_initializer;
12508 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
12509 tree type
, tree op
)
12514 result
= fold_build1_loc (loc
, code
, type
, op
);
12521 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
12522 tree type
, tree op0
, tree op1
)
12527 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
12534 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
12535 int nargs
, tree
*argarray
)
12540 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
12546 #undef START_FOLD_INIT
12547 #undef END_FOLD_INIT
12549 /* Determine if first argument is a multiple of second argument. Return 0 if
12550 it is not, or we cannot easily determined it to be.
12552 An example of the sort of thing we care about (at this point; this routine
12553 could surely be made more general, and expanded to do what the *_DIV_EXPR's
12554 fold cases do now) is discovering that
12556 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12562 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12564 This code also handles discovering that
12566 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12568 is a multiple of 8 so we don't have to worry about dealing with a
12569 possible remainder.
12571 Note that we *look* inside a SAVE_EXPR only to determine how it was
12572 calculated; it is not safe for fold to do much of anything else with the
12573 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12574 at run time. For example, the latter example above *cannot* be implemented
12575 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12576 evaluation time of the original SAVE_EXPR is not necessarily the same at
12577 the time the new expression is evaluated. The only optimization of this
12578 sort that would be valid is changing
12580 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12584 SAVE_EXPR (I) * SAVE_EXPR (J)
12586 (where the same SAVE_EXPR (J) is used in the original and the
12587 transformed version). */
12590 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
12595 if (operand_equal_p (top
, bottom
, 0))
12598 if (TREE_CODE (type
) != INTEGER_TYPE
)
12601 switch (TREE_CODE (top
))
12604 /* Bitwise and provides a power of two multiple. If the mask is
12605 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
12606 if (!integer_pow2p (bottom
))
12608 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12609 || multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12612 if (TREE_CODE (bottom
) == INTEGER_CST
)
12614 op1
= TREE_OPERAND (top
, 0);
12615 op2
= TREE_OPERAND (top
, 1);
12616 if (TREE_CODE (op1
) == INTEGER_CST
)
12617 std::swap (op1
, op2
);
12618 if (TREE_CODE (op2
) == INTEGER_CST
)
12620 if (multiple_of_p (type
, op2
, bottom
))
12622 /* Handle multiple_of_p ((x * 2 + 2) * 4, 8). */
12623 if (multiple_of_p (type
, bottom
, op2
))
12625 widest_int w
= wi::sdiv_trunc (wi::to_widest (bottom
),
12626 wi::to_widest (op2
));
12627 if (wi::fits_to_tree_p (w
, TREE_TYPE (bottom
)))
12629 op2
= wide_int_to_tree (TREE_TYPE (bottom
), w
);
12630 return multiple_of_p (type
, op1
, op2
);
12633 return multiple_of_p (type
, op1
, bottom
);
12636 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12637 || multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12640 /* It is impossible to prove if op0 - op1 is multiple of bottom
12641 precisely, so be conservative here checking if both op0 and op1
12642 are multiple of bottom. Note we check the second operand first
12643 since it's usually simpler. */
12644 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12645 && multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12648 /* The same as MINUS_EXPR, but handle cases like op0 + 0xfffffffd
12649 as op0 - 3 if the expression has unsigned type. For example,
12650 (X / 3) + 0xfffffffd is multiple of 3, but 0xfffffffd is not. */
12651 op1
= TREE_OPERAND (top
, 1);
12652 if (TYPE_UNSIGNED (type
)
12653 && TREE_CODE (op1
) == INTEGER_CST
&& tree_int_cst_sign_bit (op1
))
12654 op1
= fold_build1 (NEGATE_EXPR
, type
, op1
);
12655 return (multiple_of_p (type
, op1
, bottom
)
12656 && multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
));
12659 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
12661 op1
= TREE_OPERAND (top
, 1);
12662 /* const_binop may not detect overflow correctly,
12663 so check for it explicitly here. */
12664 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)),
12666 && (t1
= fold_convert (type
,
12667 const_binop (LSHIFT_EXPR
, size_one_node
,
12669 && !TREE_OVERFLOW (t1
))
12670 return multiple_of_p (type
, t1
, bottom
);
12675 /* Can't handle conversions from non-integral or wider integral type. */
12676 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
12677 || (TYPE_PRECISION (type
)
12678 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
12684 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
12687 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
12688 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
12691 if (TREE_CODE (bottom
) != INTEGER_CST
12692 || integer_zerop (bottom
)
12693 || (TYPE_UNSIGNED (type
)
12694 && (tree_int_cst_sgn (top
) < 0
12695 || tree_int_cst_sgn (bottom
) < 0)))
12697 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
12701 if (TREE_CODE (bottom
) == INTEGER_CST
12702 && (stmt
= SSA_NAME_DEF_STMT (top
)) != NULL
12703 && gimple_code (stmt
) == GIMPLE_ASSIGN
)
12705 enum tree_code code
= gimple_assign_rhs_code (stmt
);
12707 /* Check for special cases to see if top is defined as multiple
12710 top = (X & ~(bottom - 1) ; bottom is power of 2
12716 if (code
== BIT_AND_EXPR
12717 && (op2
= gimple_assign_rhs2 (stmt
)) != NULL_TREE
12718 && TREE_CODE (op2
) == INTEGER_CST
12719 && integer_pow2p (bottom
)
12720 && wi::multiple_of_p (wi::to_widest (op2
),
12721 wi::to_widest (bottom
), UNSIGNED
))
12724 op1
= gimple_assign_rhs1 (stmt
);
12725 if (code
== MINUS_EXPR
12726 && (op2
= gimple_assign_rhs2 (stmt
)) != NULL_TREE
12727 && TREE_CODE (op2
) == SSA_NAME
12728 && (stmt
= SSA_NAME_DEF_STMT (op2
)) != NULL
12729 && gimple_code (stmt
) == GIMPLE_ASSIGN
12730 && (code
= gimple_assign_rhs_code (stmt
)) == TRUNC_MOD_EXPR
12731 && operand_equal_p (op1
, gimple_assign_rhs1 (stmt
), 0)
12732 && operand_equal_p (bottom
, gimple_assign_rhs2 (stmt
), 0))
12739 if (POLY_INT_CST_P (top
) && poly_int_tree_p (bottom
))
12740 return multiple_p (wi::to_poly_widest (top
),
12741 wi::to_poly_widest (bottom
));
12747 #define tree_expr_nonnegative_warnv_p(X, Y) \
12748 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
12750 #define RECURSE(X) \
12751 ((tree_expr_nonnegative_warnv_p) (X, strict_overflow_p, depth + 1))
12753 /* Return true if CODE or TYPE is known to be non-negative. */
12756 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
12758 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
12759 && truth_value_p (code
))
12760 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12761 have a signed:1 type (where the value is -1 and 0). */
12766 /* Return true if (CODE OP0) is known to be non-negative. If the return
12767 value is based on the assumption that signed overflow is undefined,
12768 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12769 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12772 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12773 bool *strict_overflow_p
, int depth
)
12775 if (TYPE_UNSIGNED (type
))
12781 /* We can't return 1 if flag_wrapv is set because
12782 ABS_EXPR<INT_MIN> = INT_MIN. */
12783 if (!ANY_INTEGRAL_TYPE_P (type
))
12785 if (TYPE_OVERFLOW_UNDEFINED (type
))
12787 *strict_overflow_p
= true;
12792 case NON_LVALUE_EXPR
:
12794 case FIX_TRUNC_EXPR
:
12795 return RECURSE (op0
);
12799 tree inner_type
= TREE_TYPE (op0
);
12800 tree outer_type
= type
;
12802 if (TREE_CODE (outer_type
) == REAL_TYPE
)
12804 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12805 return RECURSE (op0
);
12806 if (INTEGRAL_TYPE_P (inner_type
))
12808 if (TYPE_UNSIGNED (inner_type
))
12810 return RECURSE (op0
);
12813 else if (INTEGRAL_TYPE_P (outer_type
))
12815 if (TREE_CODE (inner_type
) == REAL_TYPE
)
12816 return RECURSE (op0
);
12817 if (INTEGRAL_TYPE_P (inner_type
))
12818 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
12819 && TYPE_UNSIGNED (inner_type
);
12825 return tree_simple_nonnegative_warnv_p (code
, type
);
12828 /* We don't know sign of `t', so be conservative and return false. */
12832 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
12833 value is based on the assumption that signed overflow is undefined,
12834 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12835 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12838 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
12839 tree op1
, bool *strict_overflow_p
,
12842 if (TYPE_UNSIGNED (type
))
12847 case POINTER_PLUS_EXPR
:
12849 if (FLOAT_TYPE_P (type
))
12850 return RECURSE (op0
) && RECURSE (op1
);
12852 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12853 both unsigned and at least 2 bits shorter than the result. */
12854 if (TREE_CODE (type
) == INTEGER_TYPE
12855 && TREE_CODE (op0
) == NOP_EXPR
12856 && TREE_CODE (op1
) == NOP_EXPR
)
12858 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
12859 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
12860 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
12861 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
12863 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
12864 TYPE_PRECISION (inner2
)) + 1;
12865 return prec
< TYPE_PRECISION (type
);
12871 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12873 /* x * x is always non-negative for floating point x
12874 or without overflow. */
12875 if (operand_equal_p (op0
, op1
, 0)
12876 || (RECURSE (op0
) && RECURSE (op1
)))
12878 if (ANY_INTEGRAL_TYPE_P (type
)
12879 && TYPE_OVERFLOW_UNDEFINED (type
))
12880 *strict_overflow_p
= true;
12885 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12886 both unsigned and their total bits is shorter than the result. */
12887 if (TREE_CODE (type
) == INTEGER_TYPE
12888 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
12889 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
12891 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
12892 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
12894 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
12895 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
12898 bool unsigned0
= TYPE_UNSIGNED (inner0
);
12899 bool unsigned1
= TYPE_UNSIGNED (inner1
);
12901 if (TREE_CODE (op0
) == INTEGER_CST
)
12902 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
12904 if (TREE_CODE (op1
) == INTEGER_CST
)
12905 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
12907 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
12908 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
12910 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
12911 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
12912 : TYPE_PRECISION (inner0
);
12914 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
12915 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
12916 : TYPE_PRECISION (inner1
);
12918 return precision0
+ precision1
< TYPE_PRECISION (type
);
12925 return RECURSE (op0
) || RECURSE (op1
);
12931 case TRUNC_DIV_EXPR
:
12932 case CEIL_DIV_EXPR
:
12933 case FLOOR_DIV_EXPR
:
12934 case ROUND_DIV_EXPR
:
12935 return RECURSE (op0
) && RECURSE (op1
);
12937 case TRUNC_MOD_EXPR
:
12938 return RECURSE (op0
);
12940 case FLOOR_MOD_EXPR
:
12941 return RECURSE (op1
);
12943 case CEIL_MOD_EXPR
:
12944 case ROUND_MOD_EXPR
:
12946 return tree_simple_nonnegative_warnv_p (code
, type
);
12949 /* We don't know sign of `t', so be conservative and return false. */
12953 /* Return true if T is known to be non-negative. If the return
12954 value is based on the assumption that signed overflow is undefined,
12955 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12956 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
12959 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
12961 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
12964 switch (TREE_CODE (t
))
12967 return tree_int_cst_sgn (t
) >= 0;
12970 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
12973 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
12976 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
12979 /* Limit the depth of recursion to avoid quadratic behavior.
12980 This is expected to catch almost all occurrences in practice.
12981 If this code misses important cases that unbounded recursion
12982 would not, passes that need this information could be revised
12983 to provide it through dataflow propagation. */
12984 return (!name_registered_for_update_p (t
)
12985 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
12986 && gimple_stmt_nonnegative_warnv_p (SSA_NAME_DEF_STMT (t
),
12987 strict_overflow_p
, depth
));
12990 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
12994 /* Return true if T is known to be non-negative. If the return
12995 value is based on the assumption that signed overflow is undefined,
12996 set *STRICT_OVERFLOW_P to true; otherwise, don't change
12997 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13000 tree_call_nonnegative_warnv_p (tree type
, combined_fn fn
, tree arg0
, tree arg1
,
13001 bool *strict_overflow_p
, int depth
)
13022 case CFN_BUILT_IN_BSWAP32
:
13023 case CFN_BUILT_IN_BSWAP64
:
13029 /* sqrt(-0.0) is -0.0. */
13030 if (!HONOR_SIGNED_ZEROS (element_mode (type
)))
13032 return RECURSE (arg0
);
13060 CASE_CFN_NEARBYINT
:
13061 CASE_CFN_NEARBYINT_FN
:
13070 CASE_CFN_SIGNIFICAND
:
13075 /* True if the 1st argument is nonnegative. */
13076 return RECURSE (arg0
);
13080 /* True if the 1st OR 2nd arguments are nonnegative. */
13081 return RECURSE (arg0
) || RECURSE (arg1
);
13085 /* True if the 1st AND 2nd arguments are nonnegative. */
13086 return RECURSE (arg0
) && RECURSE (arg1
);
13089 CASE_CFN_COPYSIGN_FN
:
13090 /* True if the 2nd argument is nonnegative. */
13091 return RECURSE (arg1
);
13094 /* True if the 1st argument is nonnegative or the second
13095 argument is an even integer. */
13096 if (TREE_CODE (arg1
) == INTEGER_CST
13097 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
13099 return RECURSE (arg0
);
13102 /* True if the 1st argument is nonnegative or the second
13103 argument is an even integer valued real. */
13104 if (TREE_CODE (arg1
) == REAL_CST
)
13109 c
= TREE_REAL_CST (arg1
);
13110 n
= real_to_integer (&c
);
13113 REAL_VALUE_TYPE cint
;
13114 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
13115 if (real_identical (&c
, &cint
))
13119 return RECURSE (arg0
);
13124 return tree_simple_nonnegative_warnv_p (CALL_EXPR
, type
);
13127 /* Return true if T is known to be non-negative. If the return
13128 value is based on the assumption that signed overflow is undefined,
13129 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13130 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13133 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13135 enum tree_code code
= TREE_CODE (t
);
13136 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
13143 tree temp
= TARGET_EXPR_SLOT (t
);
13144 t
= TARGET_EXPR_INITIAL (t
);
13146 /* If the initializer is non-void, then it's a normal expression
13147 that will be assigned to the slot. */
13148 if (!VOID_TYPE_P (t
))
13149 return RECURSE (t
);
13151 /* Otherwise, the initializer sets the slot in some way. One common
13152 way is an assignment statement at the end of the initializer. */
13155 if (TREE_CODE (t
) == BIND_EXPR
)
13156 t
= expr_last (BIND_EXPR_BODY (t
));
13157 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
13158 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
13159 t
= expr_last (TREE_OPERAND (t
, 0));
13160 else if (TREE_CODE (t
) == STATEMENT_LIST
)
13165 if (TREE_CODE (t
) == MODIFY_EXPR
13166 && TREE_OPERAND (t
, 0) == temp
)
13167 return RECURSE (TREE_OPERAND (t
, 1));
13174 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
13175 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
13177 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
13178 get_call_combined_fn (t
),
13181 strict_overflow_p
, depth
);
13183 case COMPOUND_EXPR
:
13185 return RECURSE (TREE_OPERAND (t
, 1));
13188 return RECURSE (expr_last (TREE_OPERAND (t
, 1)));
13191 return RECURSE (TREE_OPERAND (t
, 0));
13194 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
), TREE_TYPE (t
));
13199 #undef tree_expr_nonnegative_warnv_p
13201 /* Return true if T is known to be non-negative. If the return
13202 value is based on the assumption that signed overflow is undefined,
13203 set *STRICT_OVERFLOW_P to true; otherwise, don't change
13204 *STRICT_OVERFLOW_P. DEPTH is the current nesting depth of the query. */
13207 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
, int depth
)
13209 enum tree_code code
;
13210 if (t
== error_mark_node
)
13213 code
= TREE_CODE (t
);
13214 switch (TREE_CODE_CLASS (code
))
13217 case tcc_comparison
:
13218 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13220 TREE_OPERAND (t
, 0),
13221 TREE_OPERAND (t
, 1),
13222 strict_overflow_p
, depth
);
13225 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13227 TREE_OPERAND (t
, 0),
13228 strict_overflow_p
, depth
);
13231 case tcc_declaration
:
13232 case tcc_reference
:
13233 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13241 case TRUTH_AND_EXPR
:
13242 case TRUTH_OR_EXPR
:
13243 case TRUTH_XOR_EXPR
:
13244 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
13246 TREE_OPERAND (t
, 0),
13247 TREE_OPERAND (t
, 1),
13248 strict_overflow_p
, depth
);
13249 case TRUTH_NOT_EXPR
:
13250 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
13252 TREE_OPERAND (t
, 0),
13253 strict_overflow_p
, depth
);
13260 case WITH_SIZE_EXPR
:
13262 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13265 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
, depth
);
13269 /* Return true if `t' is known to be non-negative. Handle warnings
13270 about undefined signed overflow. */
13273 tree_expr_nonnegative_p (tree t
)
13275 bool ret
, strict_overflow_p
;
13277 strict_overflow_p
= false;
13278 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
13279 if (strict_overflow_p
)
13280 fold_overflow_warning (("assuming signed overflow does not occur when "
13281 "determining that expression is always "
13283 WARN_STRICT_OVERFLOW_MISC
);
13288 /* Return true when (CODE OP0) is an address and is known to be nonzero.
13289 For floating point we further ensure that T is not denormal.
13290 Similar logic is present in nonzero_address in rtlanal.h.
13292 If the return value is based on the assumption that signed overflow
13293 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13294 change *STRICT_OVERFLOW_P. */
13297 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
13298 bool *strict_overflow_p
)
13303 return tree_expr_nonzero_warnv_p (op0
,
13304 strict_overflow_p
);
13308 tree inner_type
= TREE_TYPE (op0
);
13309 tree outer_type
= type
;
13311 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
13312 && tree_expr_nonzero_warnv_p (op0
,
13313 strict_overflow_p
));
13317 case NON_LVALUE_EXPR
:
13318 return tree_expr_nonzero_warnv_p (op0
,
13319 strict_overflow_p
);
13328 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
13329 For floating point we further ensure that T is not denormal.
13330 Similar logic is present in nonzero_address in rtlanal.h.
13332 If the return value is based on the assumption that signed overflow
13333 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13334 change *STRICT_OVERFLOW_P. */
13337 tree_binary_nonzero_warnv_p (enum tree_code code
,
13340 tree op1
, bool *strict_overflow_p
)
13342 bool sub_strict_overflow_p
;
13345 case POINTER_PLUS_EXPR
:
13347 if (ANY_INTEGRAL_TYPE_P (type
) && TYPE_OVERFLOW_UNDEFINED (type
))
13349 /* With the presence of negative values it is hard
13350 to say something. */
13351 sub_strict_overflow_p
= false;
13352 if (!tree_expr_nonnegative_warnv_p (op0
,
13353 &sub_strict_overflow_p
)
13354 || !tree_expr_nonnegative_warnv_p (op1
,
13355 &sub_strict_overflow_p
))
13357 /* One of operands must be positive and the other non-negative. */
13358 /* We don't set *STRICT_OVERFLOW_P here: even if this value
13359 overflows, on a twos-complement machine the sum of two
13360 nonnegative numbers can never be zero. */
13361 return (tree_expr_nonzero_warnv_p (op0
,
13363 || tree_expr_nonzero_warnv_p (op1
,
13364 strict_overflow_p
));
13369 if (TYPE_OVERFLOW_UNDEFINED (type
))
13371 if (tree_expr_nonzero_warnv_p (op0
,
13373 && tree_expr_nonzero_warnv_p (op1
,
13374 strict_overflow_p
))
13376 *strict_overflow_p
= true;
13383 sub_strict_overflow_p
= false;
13384 if (tree_expr_nonzero_warnv_p (op0
,
13385 &sub_strict_overflow_p
)
13386 && tree_expr_nonzero_warnv_p (op1
,
13387 &sub_strict_overflow_p
))
13389 if (sub_strict_overflow_p
)
13390 *strict_overflow_p
= true;
13395 sub_strict_overflow_p
= false;
13396 if (tree_expr_nonzero_warnv_p (op0
,
13397 &sub_strict_overflow_p
))
13399 if (sub_strict_overflow_p
)
13400 *strict_overflow_p
= true;
13402 /* When both operands are nonzero, then MAX must be too. */
13403 if (tree_expr_nonzero_warnv_p (op1
,
13404 strict_overflow_p
))
13407 /* MAX where operand 0 is positive is positive. */
13408 return tree_expr_nonnegative_warnv_p (op0
,
13409 strict_overflow_p
);
13411 /* MAX where operand 1 is positive is positive. */
13412 else if (tree_expr_nonzero_warnv_p (op1
,
13413 &sub_strict_overflow_p
)
13414 && tree_expr_nonnegative_warnv_p (op1
,
13415 &sub_strict_overflow_p
))
13417 if (sub_strict_overflow_p
)
13418 *strict_overflow_p
= true;
13424 return (tree_expr_nonzero_warnv_p (op1
,
13426 || tree_expr_nonzero_warnv_p (op0
,
13427 strict_overflow_p
));
13436 /* Return true when T is an address and is known to be nonzero.
13437 For floating point we further ensure that T is not denormal.
13438 Similar logic is present in nonzero_address in rtlanal.h.
13440 If the return value is based on the assumption that signed overflow
13441 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
13442 change *STRICT_OVERFLOW_P. */
13445 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
13447 bool sub_strict_overflow_p
;
13448 switch (TREE_CODE (t
))
13451 return !integer_zerop (t
);
13455 tree base
= TREE_OPERAND (t
, 0);
13457 if (!DECL_P (base
))
13458 base
= get_base_address (base
);
13460 if (base
&& TREE_CODE (base
) == TARGET_EXPR
)
13461 base
= TARGET_EXPR_SLOT (base
);
13466 /* For objects in symbol table check if we know they are non-zero.
13467 Don't do anything for variables and functions before symtab is built;
13468 it is quite possible that they will be declared weak later. */
13469 int nonzero_addr
= maybe_nonzero_address (base
);
13470 if (nonzero_addr
>= 0)
13471 return nonzero_addr
;
13473 /* Constants are never weak. */
13474 if (CONSTANT_CLASS_P (base
))
13481 sub_strict_overflow_p
= false;
13482 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
13483 &sub_strict_overflow_p
)
13484 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
13485 &sub_strict_overflow_p
))
13487 if (sub_strict_overflow_p
)
13488 *strict_overflow_p
= true;
13494 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
13496 return expr_not_equal_to (t
, wi::zero (TYPE_PRECISION (TREE_TYPE (t
))));
13504 #define integer_valued_real_p(X) \
13505 _Pragma ("GCC error \"Use RECURSE for recursive calls\"") 0
13507 #define RECURSE(X) \
13508 ((integer_valued_real_p) (X, depth + 1))
13510 /* Return true if the floating point result of (CODE OP0) has an
13511 integer value. We also allow +Inf, -Inf and NaN to be considered
13512 integer values. Return false for signaling NaN.
13514 DEPTH is the current nesting depth of the query. */
13517 integer_valued_real_unary_p (tree_code code
, tree op0
, int depth
)
13525 return RECURSE (op0
);
13529 tree type
= TREE_TYPE (op0
);
13530 if (TREE_CODE (type
) == INTEGER_TYPE
)
13532 if (TREE_CODE (type
) == REAL_TYPE
)
13533 return RECURSE (op0
);
13543 /* Return true if the floating point result of (CODE OP0 OP1) has an
13544 integer value. We also allow +Inf, -Inf and NaN to be considered
13545 integer values. Return false for signaling NaN.
13547 DEPTH is the current nesting depth of the query. */
13550 integer_valued_real_binary_p (tree_code code
, tree op0
, tree op1
, int depth
)
13559 return RECURSE (op0
) && RECURSE (op1
);
13567 /* Return true if the floating point result of calling FNDECL with arguments
13568 ARG0 and ARG1 has an integer value. We also allow +Inf, -Inf and NaN to be
13569 considered integer values. Return false for signaling NaN. If FNDECL
13570 takes fewer than 2 arguments, the remaining ARGn are null.
13572 DEPTH is the current nesting depth of the query. */
13575 integer_valued_real_call_p (combined_fn fn
, tree arg0
, tree arg1
, int depth
)
13583 CASE_CFN_NEARBYINT
:
13584 CASE_CFN_NEARBYINT_FN
:
13597 return RECURSE (arg0
) && RECURSE (arg1
);
13605 /* Return true if the floating point expression T (a GIMPLE_SINGLE_RHS)
13606 has an integer value. We also allow +Inf, -Inf and NaN to be
13607 considered integer values. Return false for signaling NaN.
13609 DEPTH is the current nesting depth of the query. */
13612 integer_valued_real_single_p (tree t
, int depth
)
13614 switch (TREE_CODE (t
))
13617 return real_isinteger (TREE_REAL_CST_PTR (t
), TYPE_MODE (TREE_TYPE (t
)));
13620 return RECURSE (TREE_OPERAND (t
, 1)) && RECURSE (TREE_OPERAND (t
, 2));
13623 /* Limit the depth of recursion to avoid quadratic behavior.
13624 This is expected to catch almost all occurrences in practice.
13625 If this code misses important cases that unbounded recursion
13626 would not, passes that need this information could be revised
13627 to provide it through dataflow propagation. */
13628 return (!name_registered_for_update_p (t
)
13629 && depth
< PARAM_VALUE (PARAM_MAX_SSA_NAME_QUERY_DEPTH
)
13630 && gimple_stmt_integer_valued_real_p (SSA_NAME_DEF_STMT (t
),
13639 /* Return true if the floating point expression T (a GIMPLE_INVALID_RHS)
13640 has an integer value. We also allow +Inf, -Inf and NaN to be
13641 considered integer values. Return false for signaling NaN.
13643 DEPTH is the current nesting depth of the query. */
13646 integer_valued_real_invalid_p (tree t
, int depth
)
13648 switch (TREE_CODE (t
))
13650 case COMPOUND_EXPR
:
13653 return RECURSE (TREE_OPERAND (t
, 1));
13656 return RECURSE (TREE_OPERAND (t
, 0));
13665 #undef integer_valued_real_p
13667 /* Return true if the floating point expression T has an integer value.
13668 We also allow +Inf, -Inf and NaN to be considered integer values.
13669 Return false for signaling NaN.
13671 DEPTH is the current nesting depth of the query. */
13674 integer_valued_real_p (tree t
, int depth
)
13676 if (t
== error_mark_node
)
13679 tree_code code
= TREE_CODE (t
);
13680 switch (TREE_CODE_CLASS (code
))
13683 case tcc_comparison
:
13684 return integer_valued_real_binary_p (code
, TREE_OPERAND (t
, 0),
13685 TREE_OPERAND (t
, 1), depth
);
13688 return integer_valued_real_unary_p (code
, TREE_OPERAND (t
, 0), depth
);
13691 case tcc_declaration
:
13692 case tcc_reference
:
13693 return integer_valued_real_single_p (t
, depth
);
13703 return integer_valued_real_single_p (t
, depth
);
13707 tree arg0
= (call_expr_nargs (t
) > 0
13708 ? CALL_EXPR_ARG (t
, 0)
13710 tree arg1
= (call_expr_nargs (t
) > 1
13711 ? CALL_EXPR_ARG (t
, 1)
13713 return integer_valued_real_call_p (get_call_combined_fn (t
),
13714 arg0
, arg1
, depth
);
13718 return integer_valued_real_invalid_p (t
, depth
);
13722 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
13723 attempt to fold the expression to a constant without modifying TYPE,
13726 If the expression could be simplified to a constant, then return
13727 the constant. If the expression would not be simplified to a
13728 constant, then return NULL_TREE. */
13731 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
13733 tree tem
= fold_binary (code
, type
, op0
, op1
);
13734 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13737 /* Given the components of a unary expression CODE, TYPE and OP0,
13738 attempt to fold the expression to a constant without modifying
13741 If the expression could be simplified to a constant, then return
13742 the constant. If the expression would not be simplified to a
13743 constant, then return NULL_TREE. */
13746 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
13748 tree tem
= fold_unary (code
, type
, op0
);
13749 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
13752 /* If EXP represents referencing an element in a constant string
13753 (either via pointer arithmetic or array indexing), return the
13754 tree representing the value accessed, otherwise return NULL. */
13757 fold_read_from_constant_string (tree exp
)
13759 if ((TREE_CODE (exp
) == INDIRECT_REF
13760 || TREE_CODE (exp
) == ARRAY_REF
)
13761 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
13763 tree exp1
= TREE_OPERAND (exp
, 0);
13766 location_t loc
= EXPR_LOCATION (exp
);
13768 if (TREE_CODE (exp
) == INDIRECT_REF
)
13769 string
= string_constant (exp1
, &index
);
13772 tree low_bound
= array_ref_low_bound (exp
);
13773 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
13775 /* Optimize the special-case of a zero lower bound.
13777 We convert the low_bound to sizetype to avoid some problems
13778 with constant folding. (E.g. suppose the lower bound is 1,
13779 and its mode is QI. Without the conversion,l (ARRAY
13780 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
13781 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
13782 if (! integer_zerop (low_bound
))
13783 index
= size_diffop_loc (loc
, index
,
13784 fold_convert_loc (loc
, sizetype
, low_bound
));
13789 scalar_int_mode char_mode
;
13791 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
13792 && TREE_CODE (string
) == STRING_CST
13793 && TREE_CODE (index
) == INTEGER_CST
13794 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
13795 && is_int_mode (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))),
13797 && GET_MODE_SIZE (char_mode
) == 1)
13798 return build_int_cst_type (TREE_TYPE (exp
),
13799 (TREE_STRING_POINTER (string
)
13800 [TREE_INT_CST_LOW (index
)]));
13805 /* Return the tree for neg (ARG0) when ARG0 is known to be either
13806 an integer constant, real, or fixed-point constant.
13808 TYPE is the type of the result. */
13811 fold_negate_const (tree arg0
, tree type
)
13813 tree t
= NULL_TREE
;
13815 switch (TREE_CODE (arg0
))
13818 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13823 FIXED_VALUE_TYPE f
;
13824 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
13825 &(TREE_FIXED_CST (arg0
)), NULL
,
13826 TYPE_SATURATING (type
));
13827 t
= build_fixed (type
, f
);
13828 /* Propagate overflow flags. */
13829 if (overflow_p
| TREE_OVERFLOW (arg0
))
13830 TREE_OVERFLOW (t
) = 1;
13835 if (poly_int_tree_p (arg0
))
13838 poly_wide_int res
= wi::neg (wi::to_poly_wide (arg0
), &overflow
);
13839 t
= force_fit_type (type
, res
, 1,
13840 (overflow
&& ! TYPE_UNSIGNED (type
))
13841 || TREE_OVERFLOW (arg0
));
13845 gcc_unreachable ();
13851 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13852 an integer constant or real constant.
13854 TYPE is the type of the result. */
13857 fold_abs_const (tree arg0
, tree type
)
13859 tree t
= NULL_TREE
;
13861 switch (TREE_CODE (arg0
))
13865 /* If the value is unsigned or non-negative, then the absolute value
13866 is the same as the ordinary value. */
13867 if (!wi::neg_p (wi::to_wide (arg0
), TYPE_SIGN (type
)))
13870 /* If the value is negative, then the absolute value is
13875 wide_int val
= wi::neg (wi::to_wide (arg0
), &overflow
);
13876 t
= force_fit_type (type
, val
, -1,
13877 overflow
| TREE_OVERFLOW (arg0
));
13883 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
13884 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
13890 gcc_unreachable ();
13896 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13897 constant. TYPE is the type of the result. */
13900 fold_not_const (const_tree arg0
, tree type
)
13902 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
13904 return force_fit_type (type
, ~wi::to_wide (arg0
), 0, TREE_OVERFLOW (arg0
));
13907 /* Given CODE, a relational operator, the target type, TYPE and two
13908 constant operands OP0 and OP1, return the result of the
13909 relational operation. If the result is not a compile time
13910 constant, then return NULL_TREE. */
13913 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
13915 int result
, invert
;
13917 /* From here on, the only cases we handle are when the result is
13918 known to be a constant. */
13920 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
13922 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
13923 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
13925 /* Handle the cases where either operand is a NaN. */
13926 if (real_isnan (c0
) || real_isnan (c1
))
13936 case UNORDERED_EXPR
:
13950 if (flag_trapping_math
)
13956 gcc_unreachable ();
13959 return constant_boolean_node (result
, type
);
13962 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
13965 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
13967 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
13968 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
13969 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
13972 /* Handle equality/inequality of complex constants. */
13973 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
13975 tree rcond
= fold_relational_const (code
, type
,
13976 TREE_REALPART (op0
),
13977 TREE_REALPART (op1
));
13978 tree icond
= fold_relational_const (code
, type
,
13979 TREE_IMAGPART (op0
),
13980 TREE_IMAGPART (op1
));
13981 if (code
== EQ_EXPR
)
13982 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
13983 else if (code
== NE_EXPR
)
13984 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
13989 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
13991 if (!VECTOR_TYPE_P (type
))
13993 /* Have vector comparison with scalar boolean result. */
13994 gcc_assert ((code
== EQ_EXPR
|| code
== NE_EXPR
)
13995 && known_eq (VECTOR_CST_NELTS (op0
),
13996 VECTOR_CST_NELTS (op1
)));
13997 unsigned HOST_WIDE_INT nunits
;
13998 if (!VECTOR_CST_NELTS (op0
).is_constant (&nunits
))
14000 for (unsigned i
= 0; i
< nunits
; i
++)
14002 tree elem0
= VECTOR_CST_ELT (op0
, i
);
14003 tree elem1
= VECTOR_CST_ELT (op1
, i
);
14004 tree tmp
= fold_relational_const (code
, type
, elem0
, elem1
);
14005 if (tmp
== NULL_TREE
)
14007 if (integer_zerop (tmp
))
14008 return constant_boolean_node (false, type
);
14010 return constant_boolean_node (true, type
);
14012 tree_vector_builder elts
;
14013 if (!elts
.new_binary_operation (type
, op0
, op1
, false))
14015 unsigned int count
= elts
.encoded_nelts ();
14016 for (unsigned i
= 0; i
< count
; i
++)
14018 tree elem_type
= TREE_TYPE (type
);
14019 tree elem0
= VECTOR_CST_ELT (op0
, i
);
14020 tree elem1
= VECTOR_CST_ELT (op1
, i
);
14022 tree tem
= fold_relational_const (code
, elem_type
,
14025 if (tem
== NULL_TREE
)
14028 elts
.quick_push (build_int_cst (elem_type
,
14029 integer_zerop (tem
) ? 0 : -1));
14032 return elts
.build ();
14035 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
14037 To compute GT, swap the arguments and do LT.
14038 To compute GE, do LT and invert the result.
14039 To compute LE, swap the arguments, do LT and invert the result.
14040 To compute NE, do EQ and invert the result.
14042 Therefore, the code below must handle only EQ and LT. */
14044 if (code
== LE_EXPR
|| code
== GT_EXPR
)
14046 std::swap (op0
, op1
);
14047 code
= swap_tree_comparison (code
);
14050 /* Note that it is safe to invert for real values here because we
14051 have already handled the one case that it matters. */
14054 if (code
== NE_EXPR
|| code
== GE_EXPR
)
14057 code
= invert_tree_comparison (code
, false);
14060 /* Compute a result for LT or EQ if args permit;
14061 Otherwise return T. */
14062 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
14064 if (code
== EQ_EXPR
)
14065 result
= tree_int_cst_equal (op0
, op1
);
14067 result
= tree_int_cst_lt (op0
, op1
);
14074 return constant_boolean_node (result
, type
);
14077 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
14078 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
14082 fold_build_cleanup_point_expr (tree type
, tree expr
)
14084 /* If the expression does not have side effects then we don't have to wrap
14085 it with a cleanup point expression. */
14086 if (!TREE_SIDE_EFFECTS (expr
))
14089 /* If the expression is a return, check to see if the expression inside the
14090 return has no side effects or the right hand side of the modify expression
14091 inside the return. If either don't have side effects set we don't need to
14092 wrap the expression in a cleanup point expression. Note we don't check the
14093 left hand side of the modify because it should always be a return decl. */
14094 if (TREE_CODE (expr
) == RETURN_EXPR
)
14096 tree op
= TREE_OPERAND (expr
, 0);
14097 if (!op
|| !TREE_SIDE_EFFECTS (op
))
14099 op
= TREE_OPERAND (op
, 1);
14100 if (!TREE_SIDE_EFFECTS (op
))
14104 return build1_loc (EXPR_LOCATION (expr
), CLEANUP_POINT_EXPR
, type
, expr
);
14107 /* Given a pointer value OP0 and a type TYPE, return a simplified version
14108 of an indirection through OP0, or NULL_TREE if no simplification is
14112 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
14116 poly_uint64 const_op01
;
14119 subtype
= TREE_TYPE (sub
);
14120 if (!POINTER_TYPE_P (subtype
)
14121 || TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (op0
)))
14124 if (TREE_CODE (sub
) == ADDR_EXPR
)
14126 tree op
= TREE_OPERAND (sub
, 0);
14127 tree optype
= TREE_TYPE (op
);
14129 /* *&CONST_DECL -> to the value of the const decl. */
14130 if (TREE_CODE (op
) == CONST_DECL
)
14131 return DECL_INITIAL (op
);
14132 /* *&p => p; make sure to handle *&"str"[cst] here. */
14133 if (type
== optype
)
14135 tree fop
= fold_read_from_constant_string (op
);
14141 /* *(foo *)&fooarray => fooarray[0] */
14142 else if (TREE_CODE (optype
) == ARRAY_TYPE
14143 && type
== TREE_TYPE (optype
)
14144 && (!in_gimple_form
14145 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14147 tree type_domain
= TYPE_DOMAIN (optype
);
14148 tree min_val
= size_zero_node
;
14149 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14150 min_val
= TYPE_MIN_VALUE (type_domain
);
14152 && TREE_CODE (min_val
) != INTEGER_CST
)
14154 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
14155 NULL_TREE
, NULL_TREE
);
14157 /* *(foo *)&complexfoo => __real__ complexfoo */
14158 else if (TREE_CODE (optype
) == COMPLEX_TYPE
14159 && type
== TREE_TYPE (optype
))
14160 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
14161 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
14162 else if (VECTOR_TYPE_P (optype
)
14163 && type
== TREE_TYPE (optype
))
14165 tree part_width
= TYPE_SIZE (type
);
14166 tree index
= bitsize_int (0);
14167 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
,
14172 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
14173 && poly_int_tree_p (TREE_OPERAND (sub
, 1), &const_op01
))
14175 tree op00
= TREE_OPERAND (sub
, 0);
14176 tree op01
= TREE_OPERAND (sub
, 1);
14179 if (TREE_CODE (op00
) == ADDR_EXPR
)
14182 op00
= TREE_OPERAND (op00
, 0);
14183 op00type
= TREE_TYPE (op00
);
14185 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
14186 if (VECTOR_TYPE_P (op00type
)
14187 && type
== TREE_TYPE (op00type
)
14188 /* POINTER_PLUS_EXPR second operand is sizetype, unsigned,
14189 but we want to treat offsets with MSB set as negative.
14190 For the code below negative offsets are invalid and
14191 TYPE_SIZE of the element is something unsigned, so
14192 check whether op01 fits into poly_int64, which implies
14193 it is from 0 to INTTYPE_MAXIMUM (HOST_WIDE_INT), and
14194 then just use poly_uint64 because we want to treat the
14195 value as unsigned. */
14196 && tree_fits_poly_int64_p (op01
))
14198 tree part_width
= TYPE_SIZE (type
);
14199 poly_uint64 max_offset
14200 = (tree_to_uhwi (part_width
) / BITS_PER_UNIT
14201 * TYPE_VECTOR_SUBPARTS (op00type
));
14202 if (known_lt (const_op01
, max_offset
))
14204 tree index
= bitsize_int (const_op01
* BITS_PER_UNIT
);
14205 return fold_build3_loc (loc
,
14206 BIT_FIELD_REF
, type
, op00
,
14207 part_width
, index
);
14210 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14211 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
14212 && type
== TREE_TYPE (op00type
))
14214 if (known_eq (wi::to_poly_offset (TYPE_SIZE_UNIT (type
)),
14216 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
14218 /* ((foo *)&fooarray)[1] => fooarray[1] */
14219 else if (TREE_CODE (op00type
) == ARRAY_TYPE
14220 && type
== TREE_TYPE (op00type
))
14222 tree type_domain
= TYPE_DOMAIN (op00type
);
14223 tree min_val
= size_zero_node
;
14224 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14225 min_val
= TYPE_MIN_VALUE (type_domain
);
14226 offset_int off
= wi::to_offset (op01
);
14227 offset_int el_sz
= wi::to_offset (TYPE_SIZE_UNIT (type
));
14228 offset_int remainder
;
14229 off
= wi::divmod_trunc (off
, el_sz
, SIGNED
, &remainder
);
14230 if (remainder
== 0 && TREE_CODE (min_val
) == INTEGER_CST
)
14232 off
= off
+ wi::to_offset (min_val
);
14233 op01
= wide_int_to_tree (sizetype
, off
);
14234 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
14235 NULL_TREE
, NULL_TREE
);
14241 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14242 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
14243 && type
== TREE_TYPE (TREE_TYPE (subtype
))
14244 && (!in_gimple_form
14245 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
14248 tree min_val
= size_zero_node
;
14249 sub
= build_fold_indirect_ref_loc (loc
, sub
);
14250 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
14251 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
14252 min_val
= TYPE_MIN_VALUE (type_domain
);
14254 && TREE_CODE (min_val
) != INTEGER_CST
)
14256 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
14263 /* Builds an expression for an indirection through T, simplifying some
14267 build_fold_indirect_ref_loc (location_t loc
, tree t
)
14269 tree type
= TREE_TYPE (TREE_TYPE (t
));
14270 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
14275 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
14278 /* Given an INDIRECT_REF T, return either T or a simplified version. */
14281 fold_indirect_ref_loc (location_t loc
, tree t
)
14283 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
14291 /* Strip non-trapping, non-side-effecting tree nodes from an expression
14292 whose result is ignored. The type of the returned tree need not be
14293 the same as the original expression. */
14296 fold_ignored_result (tree t
)
14298 if (!TREE_SIDE_EFFECTS (t
))
14299 return integer_zero_node
;
14302 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
14305 t
= TREE_OPERAND (t
, 0);
14309 case tcc_comparison
:
14310 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14311 t
= TREE_OPERAND (t
, 0);
14312 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
14313 t
= TREE_OPERAND (t
, 1);
14318 case tcc_expression
:
14319 switch (TREE_CODE (t
))
14321 case COMPOUND_EXPR
:
14322 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
14324 t
= TREE_OPERAND (t
, 0);
14328 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
14329 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
14331 t
= TREE_OPERAND (t
, 0);
14344 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
14347 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
14349 tree div
= NULL_TREE
;
14354 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14355 have to do anything. Only do this when we are not given a const,
14356 because in that case, this check is more expensive than just
14358 if (TREE_CODE (value
) != INTEGER_CST
)
14360 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14362 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14366 /* If divisor is a power of two, simplify this to bit manipulation. */
14367 if (pow2_or_zerop (divisor
))
14369 if (TREE_CODE (value
) == INTEGER_CST
)
14371 wide_int val
= wi::to_wide (value
);
14374 if ((val
& (divisor
- 1)) == 0)
14377 overflow_p
= TREE_OVERFLOW (value
);
14378 val
+= divisor
- 1;
14379 val
&= (int) -divisor
;
14383 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
14389 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
14390 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
14391 t
= build_int_cst (TREE_TYPE (value
), - (int) divisor
);
14392 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14398 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14399 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
14400 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14406 /* Likewise, but round down. */
14409 round_down_loc (location_t loc
, tree value
, int divisor
)
14411 tree div
= NULL_TREE
;
14413 gcc_assert (divisor
> 0);
14417 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
14418 have to do anything. Only do this when we are not given a const,
14419 because in that case, this check is more expensive than just
14421 if (TREE_CODE (value
) != INTEGER_CST
)
14423 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14425 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
14429 /* If divisor is a power of two, simplify this to bit manipulation. */
14430 if (pow2_or_zerop (divisor
))
14434 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
14435 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
14440 div
= build_int_cst (TREE_TYPE (value
), divisor
);
14441 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
14442 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
14448 /* Returns the pointer to the base of the object addressed by EXP and
14449 extracts the information about the offset of the access, storing it
14450 to PBITPOS and POFFSET. */
14453 split_address_to_core_and_offset (tree exp
,
14454 poly_int64_pod
*pbitpos
, tree
*poffset
)
14458 int unsignedp
, reversep
, volatilep
;
14459 poly_int64 bitsize
;
14460 location_t loc
= EXPR_LOCATION (exp
);
14462 if (TREE_CODE (exp
) == ADDR_EXPR
)
14464 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
14465 poffset
, &mode
, &unsignedp
, &reversep
,
14467 core
= build_fold_addr_expr_loc (loc
, core
);
14469 else if (TREE_CODE (exp
) == POINTER_PLUS_EXPR
)
14471 core
= TREE_OPERAND (exp
, 0);
14474 *poffset
= TREE_OPERAND (exp
, 1);
14475 if (poly_int_tree_p (*poffset
))
14477 poly_offset_int tem
14478 = wi::sext (wi::to_poly_offset (*poffset
),
14479 TYPE_PRECISION (TREE_TYPE (*poffset
)));
14480 tem
<<= LOG2_BITS_PER_UNIT
;
14481 if (tem
.to_shwi (pbitpos
))
14482 *poffset
= NULL_TREE
;
14489 *poffset
= NULL_TREE
;
14495 /* Returns true if addresses of E1 and E2 differ by a constant, false
14496 otherwise. If they do, E1 - E2 is stored in *DIFF. */
14499 ptr_difference_const (tree e1
, tree e2
, poly_int64_pod
*diff
)
14502 poly_int64 bitpos1
, bitpos2
;
14503 tree toffset1
, toffset2
, tdiff
, type
;
14505 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
14506 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
14508 poly_int64 bytepos1
, bytepos2
;
14509 if (!multiple_p (bitpos1
, BITS_PER_UNIT
, &bytepos1
)
14510 || !multiple_p (bitpos2
, BITS_PER_UNIT
, &bytepos2
)
14511 || !operand_equal_p (core1
, core2
, 0))
14514 if (toffset1
&& toffset2
)
14516 type
= TREE_TYPE (toffset1
);
14517 if (type
!= TREE_TYPE (toffset2
))
14518 toffset2
= fold_convert (type
, toffset2
);
14520 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
14521 if (!cst_and_fits_in_hwi (tdiff
))
14524 *diff
= int_cst_value (tdiff
);
14526 else if (toffset1
|| toffset2
)
14528 /* If only one of the offsets is non-constant, the difference cannot
14535 *diff
+= bytepos1
- bytepos2
;
14539 /* Return OFF converted to a pointer offset type suitable as offset for
14540 POINTER_PLUS_EXPR. Use location LOC for this conversion. */
14542 convert_to_ptrofftype_loc (location_t loc
, tree off
)
14544 return fold_convert_loc (loc
, sizetype
, off
);
14547 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14549 fold_build_pointer_plus_loc (location_t loc
, tree ptr
, tree off
)
14551 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14552 ptr
, convert_to_ptrofftype_loc (loc
, off
));
14555 /* Build and fold a POINTER_PLUS_EXPR at LOC offsetting PTR by OFF. */
14557 fold_build_pointer_plus_hwi_loc (location_t loc
, tree ptr
, HOST_WIDE_INT off
)
14559 return fold_build2_loc (loc
, POINTER_PLUS_EXPR
, TREE_TYPE (ptr
),
14560 ptr
, size_int (off
));
14563 /* Return a char pointer for a C string if it is a string constant
14564 or sum of string constant and integer constant. We only support
14565 string constants properly terminated with '\0' character.
14566 If STRLEN is a valid pointer, length (including terminating character)
14567 of returned string is stored to the argument. */
14570 c_getstr (tree src
, unsigned HOST_WIDE_INT
*strlen
)
14577 src
= string_constant (src
, &offset_node
);
14581 unsigned HOST_WIDE_INT offset
= 0;
14582 if (offset_node
!= NULL_TREE
)
14584 if (!tree_fits_uhwi_p (offset_node
))
14587 offset
= tree_to_uhwi (offset_node
);
14590 unsigned HOST_WIDE_INT string_length
= TREE_STRING_LENGTH (src
);
14591 const char *string
= TREE_STRING_POINTER (src
);
14593 /* Support only properly null-terminated strings. */
14594 if (string_length
== 0
14595 || string
[string_length
- 1] != '\0'
14596 || offset
>= string_length
)
14600 *strlen
= string_length
- offset
;
14601 return string
+ offset
;
14606 namespace selftest
{
14608 /* Helper functions for writing tests of folding trees. */
14610 /* Verify that the binary op (LHS CODE RHS) folds to CONSTANT. */
14613 assert_binop_folds_to_const (tree lhs
, enum tree_code code
, tree rhs
,
14616 ASSERT_EQ (constant
, fold_build2 (code
, TREE_TYPE (lhs
), lhs
, rhs
));
14619 /* Verify that the binary op (LHS CODE RHS) folds to an NON_LVALUE_EXPR
14620 wrapping WRAPPED_EXPR. */
14623 assert_binop_folds_to_nonlvalue (tree lhs
, enum tree_code code
, tree rhs
,
14626 tree result
= fold_build2 (code
, TREE_TYPE (lhs
), lhs
, rhs
);
14627 ASSERT_NE (wrapped_expr
, result
);
14628 ASSERT_EQ (NON_LVALUE_EXPR
, TREE_CODE (result
));
14629 ASSERT_EQ (wrapped_expr
, TREE_OPERAND (result
, 0));
14632 /* Verify that various arithmetic binary operations are folded
14636 test_arithmetic_folding ()
14638 tree type
= integer_type_node
;
14639 tree x
= create_tmp_var_raw (type
, "x");
14640 tree zero
= build_zero_cst (type
);
14641 tree one
= build_int_cst (type
, 1);
14644 /* 1 <-- (0 + 1) */
14645 assert_binop_folds_to_const (zero
, PLUS_EXPR
, one
,
14647 assert_binop_folds_to_const (one
, PLUS_EXPR
, zero
,
14650 /* (nonlvalue)x <-- (x + 0) */
14651 assert_binop_folds_to_nonlvalue (x
, PLUS_EXPR
, zero
,
14655 /* 0 <-- (x - x) */
14656 assert_binop_folds_to_const (x
, MINUS_EXPR
, x
,
14658 assert_binop_folds_to_nonlvalue (x
, MINUS_EXPR
, zero
,
14661 /* Multiplication. */
14662 /* 0 <-- (x * 0) */
14663 assert_binop_folds_to_const (x
, MULT_EXPR
, zero
,
14666 /* (nonlvalue)x <-- (x * 1) */
14667 assert_binop_folds_to_nonlvalue (x
, MULT_EXPR
, one
,
14671 /* Verify that various binary operations on vectors are folded
14675 test_vector_folding ()
14677 tree inner_type
= integer_type_node
;
14678 tree type
= build_vector_type (inner_type
, 4);
14679 tree zero
= build_zero_cst (type
);
14680 tree one
= build_one_cst (type
);
14682 /* Verify equality tests that return a scalar boolean result. */
14683 tree res_type
= boolean_type_node
;
14684 ASSERT_FALSE (integer_nonzerop (fold_build2 (EQ_EXPR
, res_type
, zero
, one
)));
14685 ASSERT_TRUE (integer_nonzerop (fold_build2 (EQ_EXPR
, res_type
, zero
, zero
)));
14686 ASSERT_TRUE (integer_nonzerop (fold_build2 (NE_EXPR
, res_type
, zero
, one
)));
14687 ASSERT_FALSE (integer_nonzerop (fold_build2 (NE_EXPR
, res_type
, one
, one
)));
14690 /* Verify folding of VEC_DUPLICATE_EXPRs. */
14693 test_vec_duplicate_folding ()
14695 scalar_int_mode int_mode
= SCALAR_INT_TYPE_MODE (ssizetype
);
14696 machine_mode vec_mode
= targetm
.vectorize
.preferred_simd_mode (int_mode
);
14697 /* This will be 1 if VEC_MODE isn't a vector mode. */
14698 poly_uint64 nunits
= GET_MODE_NUNITS (vec_mode
);
14700 tree type
= build_vector_type (ssizetype
, nunits
);
14701 tree dup5_expr
= fold_unary (VEC_DUPLICATE_EXPR
, type
, ssize_int (5));
14702 tree dup5_cst
= build_vector_from_val (type
, ssize_int (5));
14703 ASSERT_TRUE (operand_equal_p (dup5_expr
, dup5_cst
, 0));
14706 /* Run all of the selftests within this file. */
14709 fold_const_c_tests ()
14711 test_arithmetic_folding ();
14712 test_vector_folding ();
14713 test_vec_duplicate_folding ();
14716 } // namespace selftest
14718 #endif /* CHECKING_P */