1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /*@@ This file should be rewritten to use an arbitrary precision
21 @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
22 @@ Perhaps the routines could also be used for bc/dc, and made a lib.
23 @@ The routines that translate from the ap rep should
24 @@ warn if precision et. al. is lost.
25 @@ This would also make life easier when this technology is used
26 @@ for cross-compilers. */
28 /* The entry points in this file are fold, size_int_wide and size_binop.
30 fold takes a tree as argument and returns a simplified tree.
32 size_binop takes a tree code for an arithmetic operation
33 and two operands that are trees, and produces a tree for the
34 result, assuming the type comes from `sizetype'.
36 size_int takes an integer value, and creates a tree constant
37 with type from `sizetype'.
39 Note: Since the folders get called on non-gimple code as well as
40 gimple code, we need to handle GIMPLE tuples as well as their
41 corresponding tree equivalents. */
45 #include "coretypes.h"
49 #include "stor-layout.h"
51 #include "tree-iterator.h"
57 #include "diagnostic-core.h"
59 #include "langhooks.h"
61 #include "basic-block.h"
62 #include "tree-ssa-alias.h"
63 #include "internal-fn.h"
65 #include "gimple-expr.h"
70 #include "hash-table.h" /* Required for ENABLE_FOLD_CHECKING. */
74 /* Nonzero if we are folding constants inside an initializer; zero
76 int folding_initializer
= 0;
78 /* The following constants represent a bit based encoding of GCC's
79 comparison operators. This encoding simplifies transformations
80 on relational comparison operators, such as AND and OR. */
81 enum comparison_code
{
100 static bool negate_mathfn_p (enum built_in_function
);
101 static bool negate_expr_p (tree
);
102 static tree
negate_expr (tree
);
103 static tree
split_tree (tree
, enum tree_code
, tree
*, tree
*, tree
*, int);
104 static tree
associate_trees (location_t
, tree
, tree
, enum tree_code
, tree
);
105 static tree
const_binop (enum tree_code
, tree
, tree
);
106 static enum comparison_code
comparison_to_compcode (enum tree_code
);
107 static enum tree_code
compcode_to_comparison (enum comparison_code
);
108 static int operand_equal_for_comparison_p (tree
, tree
, tree
);
109 static int twoval_comparison_p (tree
, tree
*, tree
*, int *);
110 static tree
eval_subst (location_t
, tree
, tree
, tree
, tree
, tree
);
111 static tree
pedantic_omit_one_operand_loc (location_t
, tree
, tree
, tree
);
112 static tree
distribute_bit_expr (location_t
, enum tree_code
, tree
, tree
, tree
);
113 static tree
make_bit_field_ref (location_t
, tree
, tree
,
114 HOST_WIDE_INT
, HOST_WIDE_INT
, int);
115 static tree
optimize_bit_field_compare (location_t
, enum tree_code
,
117 static tree
decode_field_reference (location_t
, tree
, HOST_WIDE_INT
*,
119 enum machine_mode
*, int *, int *,
121 static tree
sign_bit_p (tree
, const_tree
);
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
optimize_minmax_comparison (location_t
, enum tree_code
,
132 static tree
extract_muldiv (tree
, tree
, enum tree_code
, tree
, bool *);
133 static tree
extract_muldiv_1 (tree
, tree
, enum tree_code
, tree
, bool *);
134 static tree
fold_binary_op_with_conditional_arg (location_t
,
135 enum tree_code
, tree
,
138 static tree
fold_mathfn_compare (location_t
,
139 enum built_in_function
, enum tree_code
,
141 static tree
fold_inf_compare (location_t
, enum tree_code
, tree
, tree
, tree
);
142 static tree
fold_div_compare (location_t
, enum tree_code
, tree
, tree
, tree
);
143 static bool reorder_operands_p (const_tree
, const_tree
);
144 static tree
fold_negate_const (tree
, tree
);
145 static tree
fold_not_const (const_tree
, tree
);
146 static tree
fold_relational_const (enum tree_code
, tree
, tree
, tree
);
147 static tree
fold_convert_const (enum tree_code
, tree
, tree
);
149 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
150 Otherwise, return LOC. */
153 expr_location_or (tree t
, location_t loc
)
155 location_t tloc
= EXPR_LOCATION (t
);
156 return tloc
== UNKNOWN_LOCATION
? loc
: tloc
;
159 /* Similar to protected_set_expr_location, but never modify x in place,
160 if location can and needs to be set, unshare it. */
163 protected_set_expr_location_unshare (tree x
, location_t loc
)
165 if (CAN_HAVE_LOCATION_P (x
)
166 && EXPR_LOCATION (x
) != loc
167 && !(TREE_CODE (x
) == SAVE_EXPR
168 || TREE_CODE (x
) == TARGET_EXPR
169 || TREE_CODE (x
) == BIND_EXPR
))
172 SET_EXPR_LOCATION (x
, loc
);
177 /* If ARG2 divides ARG1 with zero remainder, carries out the exact
178 division and returns the quotient. Otherwise returns
182 div_if_zero_remainder (const_tree arg1
, const_tree arg2
)
186 if (wi::multiple_of_p (wi::to_widest (arg1
), wi::to_widest (arg2
),
188 return wide_int_to_tree (TREE_TYPE (arg1
), quo
);
193 /* This is nonzero if we should defer warnings about undefined
194 overflow. This facility exists because these warnings are a
195 special case. The code to estimate loop iterations does not want
196 to issue any warnings, since it works with expressions which do not
197 occur in user code. Various bits of cleanup code call fold(), but
198 only use the result if it has certain characteristics (e.g., is a
199 constant); that code only wants to issue a warning if the result is
202 static int fold_deferring_overflow_warnings
;
204 /* If a warning about undefined overflow is deferred, this is the
205 warning. Note that this may cause us to turn two warnings into
206 one, but that is fine since it is sufficient to only give one
207 warning per expression. */
209 static const char* fold_deferred_overflow_warning
;
211 /* If a warning about undefined overflow is deferred, this is the
212 level at which the warning should be emitted. */
214 static enum warn_strict_overflow_code fold_deferred_overflow_code
;
216 /* Start deferring overflow warnings. We could use a stack here to
217 permit nested calls, but at present it is not necessary. */
220 fold_defer_overflow_warnings (void)
222 ++fold_deferring_overflow_warnings
;
225 /* Stop deferring overflow warnings. If there is a pending warning,
226 and ISSUE is true, then issue the warning if appropriate. STMT is
227 the statement with which the warning should be associated (used for
228 location information); STMT may be NULL. CODE is the level of the
229 warning--a warn_strict_overflow_code value. This function will use
230 the smaller of CODE and the deferred code when deciding whether to
231 issue the warning. CODE may be zero to mean to always use the
235 fold_undefer_overflow_warnings (bool issue
, const_gimple stmt
, int code
)
240 gcc_assert (fold_deferring_overflow_warnings
> 0);
241 --fold_deferring_overflow_warnings
;
242 if (fold_deferring_overflow_warnings
> 0)
244 if (fold_deferred_overflow_warning
!= NULL
246 && code
< (int) fold_deferred_overflow_code
)
247 fold_deferred_overflow_code
= (enum warn_strict_overflow_code
) code
;
251 warnmsg
= fold_deferred_overflow_warning
;
252 fold_deferred_overflow_warning
= NULL
;
254 if (!issue
|| warnmsg
== NULL
)
257 if (gimple_no_warning_p (stmt
))
260 /* Use the smallest code level when deciding to issue the
262 if (code
== 0 || code
> (int) fold_deferred_overflow_code
)
263 code
= fold_deferred_overflow_code
;
265 if (!issue_strict_overflow_warning (code
))
269 locus
= input_location
;
271 locus
= gimple_location (stmt
);
272 warning_at (locus
, OPT_Wstrict_overflow
, "%s", warnmsg
);
275 /* Stop deferring overflow warnings, ignoring any deferred
279 fold_undefer_and_ignore_overflow_warnings (void)
281 fold_undefer_overflow_warnings (false, NULL
, 0);
284 /* Whether we are deferring overflow warnings. */
287 fold_deferring_overflow_warnings_p (void)
289 return fold_deferring_overflow_warnings
> 0;
292 /* This is called when we fold something based on the fact that signed
293 overflow is undefined. */
296 fold_overflow_warning (const char* gmsgid
, enum warn_strict_overflow_code wc
)
298 if (fold_deferring_overflow_warnings
> 0)
300 if (fold_deferred_overflow_warning
== NULL
301 || wc
< fold_deferred_overflow_code
)
303 fold_deferred_overflow_warning
= gmsgid
;
304 fold_deferred_overflow_code
= wc
;
307 else if (issue_strict_overflow_warning (wc
))
308 warning (OPT_Wstrict_overflow
, gmsgid
);
311 /* Return true if the built-in mathematical function specified by CODE
312 is odd, i.e. -f(x) == f(-x). */
315 negate_mathfn_p (enum built_in_function code
)
319 CASE_FLT_FN (BUILT_IN_ASIN
):
320 CASE_FLT_FN (BUILT_IN_ASINH
):
321 CASE_FLT_FN (BUILT_IN_ATAN
):
322 CASE_FLT_FN (BUILT_IN_ATANH
):
323 CASE_FLT_FN (BUILT_IN_CASIN
):
324 CASE_FLT_FN (BUILT_IN_CASINH
):
325 CASE_FLT_FN (BUILT_IN_CATAN
):
326 CASE_FLT_FN (BUILT_IN_CATANH
):
327 CASE_FLT_FN (BUILT_IN_CBRT
):
328 CASE_FLT_FN (BUILT_IN_CPROJ
):
329 CASE_FLT_FN (BUILT_IN_CSIN
):
330 CASE_FLT_FN (BUILT_IN_CSINH
):
331 CASE_FLT_FN (BUILT_IN_CTAN
):
332 CASE_FLT_FN (BUILT_IN_CTANH
):
333 CASE_FLT_FN (BUILT_IN_ERF
):
334 CASE_FLT_FN (BUILT_IN_LLROUND
):
335 CASE_FLT_FN (BUILT_IN_LROUND
):
336 CASE_FLT_FN (BUILT_IN_ROUND
):
337 CASE_FLT_FN (BUILT_IN_SIN
):
338 CASE_FLT_FN (BUILT_IN_SINH
):
339 CASE_FLT_FN (BUILT_IN_TAN
):
340 CASE_FLT_FN (BUILT_IN_TANH
):
341 CASE_FLT_FN (BUILT_IN_TRUNC
):
344 CASE_FLT_FN (BUILT_IN_LLRINT
):
345 CASE_FLT_FN (BUILT_IN_LRINT
):
346 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
347 CASE_FLT_FN (BUILT_IN_RINT
):
348 return !flag_rounding_math
;
356 /* Check whether we may negate an integer constant T without causing
360 may_negate_without_overflow_p (const_tree t
)
364 gcc_assert (TREE_CODE (t
) == INTEGER_CST
);
366 type
= TREE_TYPE (t
);
367 if (TYPE_UNSIGNED (type
))
370 return !wi::only_sign_bit_p (t
);
373 /* Determine whether an expression T can be cheaply negated using
374 the function negate_expr without introducing undefined overflow. */
377 negate_expr_p (tree t
)
384 type
= TREE_TYPE (t
);
387 switch (TREE_CODE (t
))
390 if (TYPE_OVERFLOW_WRAPS (type
))
393 /* Check that -CST will not overflow type. */
394 return may_negate_without_overflow_p (t
);
396 return (INTEGRAL_TYPE_P (type
)
397 && TYPE_OVERFLOW_WRAPS (type
));
404 /* We want to canonicalize to positive real constants. Pretend
405 that only negative ones can be easily negated. */
406 return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
409 return negate_expr_p (TREE_REALPART (t
))
410 && negate_expr_p (TREE_IMAGPART (t
));
414 if (FLOAT_TYPE_P (TREE_TYPE (type
)) || TYPE_OVERFLOW_WRAPS (type
))
417 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
419 for (i
= 0; i
< count
; i
++)
420 if (!negate_expr_p (VECTOR_CST_ELT (t
, i
)))
427 return negate_expr_p (TREE_OPERAND (t
, 0))
428 && negate_expr_p (TREE_OPERAND (t
, 1));
431 return negate_expr_p (TREE_OPERAND (t
, 0));
434 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
))
435 || HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
437 /* -(A + B) -> (-B) - A. */
438 if (negate_expr_p (TREE_OPERAND (t
, 1))
439 && reorder_operands_p (TREE_OPERAND (t
, 0),
440 TREE_OPERAND (t
, 1)))
442 /* -(A + B) -> (-A) - B. */
443 return negate_expr_p (TREE_OPERAND (t
, 0));
446 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
447 return !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
))
448 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
449 && reorder_operands_p (TREE_OPERAND (t
, 0),
450 TREE_OPERAND (t
, 1));
453 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
459 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t
))))
460 return negate_expr_p (TREE_OPERAND (t
, 1))
461 || negate_expr_p (TREE_OPERAND (t
, 0));
467 /* In general we can't negate A / B, because if A is INT_MIN and
468 B is 1, we may turn this into INT_MIN / -1 which is undefined
469 and actually traps on some architectures. But if overflow is
470 undefined, we can negate, because - (INT_MIN / 1) is an
472 if (INTEGRAL_TYPE_P (TREE_TYPE (t
)))
474 if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
)))
476 /* If overflow is undefined then we have to be careful because
477 we ask whether it's ok to associate the negate with the
478 division which is not ok for example for
479 -((a - b) / c) where (-(a - b)) / c may invoke undefined
480 overflow because of negating INT_MIN. So do not use
481 negate_expr_p here but open-code the two important cases. */
482 if (TREE_CODE (TREE_OPERAND (t
, 0)) == NEGATE_EXPR
483 || (TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
484 && may_negate_without_overflow_p (TREE_OPERAND (t
, 0))))
487 else if (negate_expr_p (TREE_OPERAND (t
, 0)))
489 return negate_expr_p (TREE_OPERAND (t
, 1));
492 /* Negate -((double)float) as (double)(-float). */
493 if (TREE_CODE (type
) == REAL_TYPE
)
495 tree tem
= strip_float_extensions (t
);
497 return negate_expr_p (tem
);
502 /* Negate -f(x) as f(-x). */
503 if (negate_mathfn_p (builtin_mathfn_code (t
)))
504 return negate_expr_p (CALL_EXPR_ARG (t
, 0));
508 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
509 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
511 tree op1
= TREE_OPERAND (t
, 1);
512 if (wi::eq_p (op1
, TYPE_PRECISION (type
) - 1))
523 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
524 simplification is possible.
525 If negate_expr_p would return true for T, NULL_TREE will never be
529 fold_negate_expr (location_t loc
, tree t
)
531 tree type
= TREE_TYPE (t
);
534 switch (TREE_CODE (t
))
536 /* Convert - (~A) to A + 1. */
538 if (INTEGRAL_TYPE_P (type
))
539 return fold_build2_loc (loc
, PLUS_EXPR
, type
, TREE_OPERAND (t
, 0),
540 build_one_cst (type
));
544 tem
= fold_negate_const (t
, type
);
545 if (TREE_OVERFLOW (tem
) == TREE_OVERFLOW (t
)
546 || !TYPE_OVERFLOW_TRAPS (type
))
551 tem
= fold_negate_const (t
, type
);
552 /* Two's complement FP formats, such as c4x, may overflow. */
553 if (!TREE_OVERFLOW (tem
) || !flag_trapping_math
)
558 tem
= fold_negate_const (t
, type
);
563 tree rpart
= negate_expr (TREE_REALPART (t
));
564 tree ipart
= negate_expr (TREE_IMAGPART (t
));
566 if ((TREE_CODE (rpart
) == REAL_CST
567 && TREE_CODE (ipart
) == REAL_CST
)
568 || (TREE_CODE (rpart
) == INTEGER_CST
569 && TREE_CODE (ipart
) == INTEGER_CST
))
570 return build_complex (type
, rpart
, ipart
);
576 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
577 tree
*elts
= XALLOCAVEC (tree
, count
);
579 for (i
= 0; i
< count
; i
++)
581 elts
[i
] = fold_negate_expr (loc
, VECTOR_CST_ELT (t
, i
));
582 if (elts
[i
] == NULL_TREE
)
586 return build_vector (type
, elts
);
590 if (negate_expr_p (t
))
591 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
592 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)),
593 fold_negate_expr (loc
, TREE_OPERAND (t
, 1)));
597 if (negate_expr_p (t
))
598 return fold_build1_loc (loc
, CONJ_EXPR
, type
,
599 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)));
603 return TREE_OPERAND (t
, 0);
606 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
))
607 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
609 /* -(A + B) -> (-B) - A. */
610 if (negate_expr_p (TREE_OPERAND (t
, 1))
611 && reorder_operands_p (TREE_OPERAND (t
, 0),
612 TREE_OPERAND (t
, 1)))
614 tem
= negate_expr (TREE_OPERAND (t
, 1));
615 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
616 tem
, TREE_OPERAND (t
, 0));
619 /* -(A + B) -> (-A) - B. */
620 if (negate_expr_p (TREE_OPERAND (t
, 0)))
622 tem
= negate_expr (TREE_OPERAND (t
, 0));
623 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
624 tem
, TREE_OPERAND (t
, 1));
630 /* - (A - B) -> B - A */
631 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
))
632 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
633 && reorder_operands_p (TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1)))
634 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
635 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 0));
639 if (TYPE_UNSIGNED (type
))
645 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
)))
647 tem
= TREE_OPERAND (t
, 1);
648 if (negate_expr_p (tem
))
649 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
650 TREE_OPERAND (t
, 0), negate_expr (tem
));
651 tem
= TREE_OPERAND (t
, 0);
652 if (negate_expr_p (tem
))
653 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
654 negate_expr (tem
), TREE_OPERAND (t
, 1));
661 /* In general we can't negate A / B, because if A is INT_MIN and
662 B is 1, we may turn this into INT_MIN / -1 which is undefined
663 and actually traps on some architectures. But if overflow is
664 undefined, we can negate, because - (INT_MIN / 1) is an
666 if (!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
668 const char * const warnmsg
= G_("assuming signed overflow does not "
669 "occur when negating a division");
670 tem
= TREE_OPERAND (t
, 1);
671 if (negate_expr_p (tem
))
673 if (INTEGRAL_TYPE_P (type
)
674 && (TREE_CODE (tem
) != INTEGER_CST
675 || integer_onep (tem
)))
676 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MISC
);
677 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
678 TREE_OPERAND (t
, 0), negate_expr (tem
));
680 /* If overflow is undefined then we have to be careful because
681 we ask whether it's ok to associate the negate with the
682 division which is not ok for example for
683 -((a - b) / c) where (-(a - b)) / c may invoke undefined
684 overflow because of negating INT_MIN. So do not use
685 negate_expr_p here but open-code the two important cases. */
686 tem
= TREE_OPERAND (t
, 0);
687 if ((INTEGRAL_TYPE_P (type
)
688 && (TREE_CODE (tem
) == NEGATE_EXPR
689 || (TREE_CODE (tem
) == INTEGER_CST
690 && may_negate_without_overflow_p (tem
))))
691 || !INTEGRAL_TYPE_P (type
))
692 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
693 negate_expr (tem
), TREE_OPERAND (t
, 1));
698 /* Convert -((double)float) into (double)(-float). */
699 if (TREE_CODE (type
) == REAL_TYPE
)
701 tem
= strip_float_extensions (t
);
702 if (tem
!= t
&& negate_expr_p (tem
))
703 return fold_convert_loc (loc
, type
, negate_expr (tem
));
708 /* Negate -f(x) as f(-x). */
709 if (negate_mathfn_p (builtin_mathfn_code (t
))
710 && negate_expr_p (CALL_EXPR_ARG (t
, 0)))
714 fndecl
= get_callee_fndecl (t
);
715 arg
= negate_expr (CALL_EXPR_ARG (t
, 0));
716 return build_call_expr_loc (loc
, fndecl
, 1, arg
);
721 /* Optimize -((int)x >> 31) into (unsigned)x >> 31 for int. */
722 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
724 tree op1
= TREE_OPERAND (t
, 1);
725 if (wi::eq_p (op1
, TYPE_PRECISION (type
) - 1))
727 tree ntype
= TYPE_UNSIGNED (type
)
728 ? signed_type_for (type
)
729 : unsigned_type_for (type
);
730 tree temp
= fold_convert_loc (loc
, ntype
, TREE_OPERAND (t
, 0));
731 temp
= fold_build2_loc (loc
, RSHIFT_EXPR
, ntype
, temp
, op1
);
732 return fold_convert_loc (loc
, type
, temp
);
744 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
745 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
757 loc
= EXPR_LOCATION (t
);
758 type
= TREE_TYPE (t
);
761 tem
= fold_negate_expr (loc
, t
);
763 tem
= build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
764 return fold_convert_loc (loc
, type
, tem
);
767 /* Split a tree IN into a constant, literal and variable parts that could be
768 combined with CODE to make IN. "constant" means an expression with
769 TREE_CONSTANT but that isn't an actual constant. CODE must be a
770 commutative arithmetic operation. Store the constant part into *CONP,
771 the literal in *LITP and return the variable part. If a part isn't
772 present, set it to null. If the tree does not decompose in this way,
773 return the entire tree as the variable part and the other parts as null.
775 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
776 case, we negate an operand that was subtracted. Except if it is a
777 literal for which we use *MINUS_LITP instead.
779 If NEGATE_P is true, we are negating all of IN, again except a literal
780 for which we use *MINUS_LITP instead.
782 If IN is itself a literal or constant, return it as appropriate.
784 Note that we do not guarantee that any of the three values will be the
785 same type as IN, but they will have the same signedness and mode. */
788 split_tree (tree in
, enum tree_code code
, tree
*conp
, tree
*litp
,
789 tree
*minus_litp
, int negate_p
)
797 /* Strip any conversions that don't change the machine mode or signedness. */
798 STRIP_SIGN_NOPS (in
);
800 if (TREE_CODE (in
) == INTEGER_CST
|| TREE_CODE (in
) == REAL_CST
801 || TREE_CODE (in
) == FIXED_CST
)
803 else if (TREE_CODE (in
) == code
804 || ((! FLOAT_TYPE_P (TREE_TYPE (in
)) || flag_associative_math
)
805 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in
))
806 /* We can associate addition and subtraction together (even
807 though the C standard doesn't say so) for integers because
808 the value is not affected. For reals, the value might be
809 affected, so we can't. */
810 && ((code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
811 || (code
== MINUS_EXPR
&& TREE_CODE (in
) == PLUS_EXPR
))))
813 tree op0
= TREE_OPERAND (in
, 0);
814 tree op1
= TREE_OPERAND (in
, 1);
815 int neg1_p
= TREE_CODE (in
) == MINUS_EXPR
;
816 int neg_litp_p
= 0, neg_conp_p
= 0, neg_var_p
= 0;
818 /* First see if either of the operands is a literal, then a constant. */
819 if (TREE_CODE (op0
) == INTEGER_CST
|| TREE_CODE (op0
) == REAL_CST
820 || TREE_CODE (op0
) == FIXED_CST
)
821 *litp
= op0
, op0
= 0;
822 else if (TREE_CODE (op1
) == INTEGER_CST
|| TREE_CODE (op1
) == REAL_CST
823 || TREE_CODE (op1
) == FIXED_CST
)
824 *litp
= op1
, neg_litp_p
= neg1_p
, op1
= 0;
826 if (op0
!= 0 && TREE_CONSTANT (op0
))
827 *conp
= op0
, op0
= 0;
828 else if (op1
!= 0 && TREE_CONSTANT (op1
))
829 *conp
= op1
, neg_conp_p
= neg1_p
, op1
= 0;
831 /* If we haven't dealt with either operand, this is not a case we can
832 decompose. Otherwise, VAR is either of the ones remaining, if any. */
833 if (op0
!= 0 && op1
!= 0)
838 var
= op1
, neg_var_p
= neg1_p
;
840 /* Now do any needed negations. */
842 *minus_litp
= *litp
, *litp
= 0;
844 *conp
= negate_expr (*conp
);
846 var
= negate_expr (var
);
848 else if (TREE_CODE (in
) == BIT_NOT_EXPR
849 && code
== PLUS_EXPR
)
851 /* -X - 1 is folded to ~X, undo that here. */
852 *minus_litp
= build_one_cst (TREE_TYPE (in
));
853 var
= negate_expr (TREE_OPERAND (in
, 0));
855 else if (TREE_CONSTANT (in
))
863 *minus_litp
= *litp
, *litp
= 0;
864 else if (*minus_litp
)
865 *litp
= *minus_litp
, *minus_litp
= 0;
866 *conp
= negate_expr (*conp
);
867 var
= negate_expr (var
);
873 /* Re-associate trees split by the above function. T1 and T2 are
874 either expressions to associate or null. Return the new
875 expression, if any. LOC is the location of the new expression. If
876 we build an operation, do it in TYPE and with CODE. */
879 associate_trees (location_t loc
, tree t1
, tree t2
, enum tree_code code
, tree type
)
886 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
887 try to fold this since we will have infinite recursion. But do
888 deal with any NEGATE_EXPRs. */
889 if (TREE_CODE (t1
) == code
|| TREE_CODE (t2
) == code
890 || TREE_CODE (t1
) == MINUS_EXPR
|| TREE_CODE (t2
) == MINUS_EXPR
)
892 if (code
== PLUS_EXPR
)
894 if (TREE_CODE (t1
) == NEGATE_EXPR
)
895 return build2_loc (loc
, MINUS_EXPR
, type
,
896 fold_convert_loc (loc
, type
, t2
),
897 fold_convert_loc (loc
, type
,
898 TREE_OPERAND (t1
, 0)));
899 else if (TREE_CODE (t2
) == NEGATE_EXPR
)
900 return build2_loc (loc
, MINUS_EXPR
, type
,
901 fold_convert_loc (loc
, type
, t1
),
902 fold_convert_loc (loc
, type
,
903 TREE_OPERAND (t2
, 0)));
904 else if (integer_zerop (t2
))
905 return fold_convert_loc (loc
, type
, t1
);
907 else if (code
== MINUS_EXPR
)
909 if (integer_zerop (t2
))
910 return fold_convert_loc (loc
, type
, t1
);
913 return build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
914 fold_convert_loc (loc
, type
, t2
));
917 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
918 fold_convert_loc (loc
, type
, t2
));
921 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
922 for use in int_const_binop, size_binop and size_diffop. */
925 int_binop_types_match_p (enum tree_code code
, const_tree type1
, const_tree type2
)
927 if (!INTEGRAL_TYPE_P (type1
) && !POINTER_TYPE_P (type1
))
929 if (!INTEGRAL_TYPE_P (type2
) && !POINTER_TYPE_P (type2
))
944 return TYPE_UNSIGNED (type1
) == TYPE_UNSIGNED (type2
)
945 && TYPE_PRECISION (type1
) == TYPE_PRECISION (type2
)
946 && TYPE_MODE (type1
) == TYPE_MODE (type2
);
950 /* Combine two integer constants ARG1 and ARG2 under operation CODE
951 to produce a new constant. Return NULL_TREE if we don't know how
952 to evaluate CODE at compile-time. */
955 int_const_binop_1 (enum tree_code code
, const_tree arg1
, const_tree parg2
,
960 tree type
= TREE_TYPE (arg1
);
961 signop sign
= TYPE_SIGN (type
);
962 bool overflow
= false;
964 wide_int arg2
= wide_int::from (parg2
, TYPE_PRECISION (type
),
965 TYPE_SIGN (TREE_TYPE (parg2
)));
970 res
= wi::bit_or (arg1
, arg2
);
974 res
= wi::bit_xor (arg1
, arg2
);
978 res
= wi::bit_and (arg1
, arg2
);
983 if (wi::neg_p (arg2
))
986 if (code
== RSHIFT_EXPR
)
992 if (code
== RSHIFT_EXPR
)
993 /* It's unclear from the C standard whether shifts can overflow.
994 The following code ignores overflow; perhaps a C standard
995 interpretation ruling is needed. */
996 res
= wi::rshift (arg1
, arg2
, sign
);
998 res
= wi::lshift (arg1
, arg2
);
1003 if (wi::neg_p (arg2
))
1006 if (code
== RROTATE_EXPR
)
1007 code
= LROTATE_EXPR
;
1009 code
= RROTATE_EXPR
;
1012 if (code
== RROTATE_EXPR
)
1013 res
= wi::rrotate (arg1
, arg2
);
1015 res
= wi::lrotate (arg1
, arg2
);
1019 res
= wi::add (arg1
, arg2
, sign
, &overflow
);
1023 res
= wi::sub (arg1
, arg2
, sign
, &overflow
);
1027 res
= wi::mul (arg1
, arg2
, sign
, &overflow
);
1030 case MULT_HIGHPART_EXPR
:
1031 res
= wi::mul_high (arg1
, arg2
, sign
);
1034 case TRUNC_DIV_EXPR
:
1035 case EXACT_DIV_EXPR
:
1038 res
= wi::div_trunc (arg1
, arg2
, sign
, &overflow
);
1041 case FLOOR_DIV_EXPR
:
1044 res
= wi::div_floor (arg1
, arg2
, sign
, &overflow
);
1050 res
= wi::div_ceil (arg1
, arg2
, sign
, &overflow
);
1053 case ROUND_DIV_EXPR
:
1056 res
= wi::div_round (arg1
, arg2
, sign
, &overflow
);
1059 case TRUNC_MOD_EXPR
:
1062 res
= wi::mod_trunc (arg1
, arg2
, sign
, &overflow
);
1065 case FLOOR_MOD_EXPR
:
1068 res
= wi::mod_floor (arg1
, arg2
, sign
, &overflow
);
1074 res
= wi::mod_ceil (arg1
, arg2
, sign
, &overflow
);
1077 case ROUND_MOD_EXPR
:
1080 res
= wi::mod_round (arg1
, arg2
, sign
, &overflow
);
1084 res
= wi::min (arg1
, arg2
, sign
);
1088 res
= wi::max (arg1
, arg2
, sign
);
1095 t
= force_fit_type (type
, res
, overflowable
,
1096 (((sign
== SIGNED
|| overflowable
== -1)
1098 | TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (parg2
)));
1104 int_const_binop (enum tree_code code
, const_tree arg1
, const_tree arg2
)
1106 return int_const_binop_1 (code
, arg1
, arg2
, 1);
1109 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1110 constant. We assume ARG1 and ARG2 have the same data type, or at least
1111 are the same kind of constant and the same machine mode. Return zero if
1112 combining the constants is not allowed in the current operating mode. */
1115 const_binop (enum tree_code code
, tree arg1
, tree arg2
)
1117 /* Sanity check for the recursive cases. */
1124 if (TREE_CODE (arg1
) == INTEGER_CST
)
1125 return int_const_binop (code
, arg1
, arg2
);
1127 if (TREE_CODE (arg1
) == REAL_CST
)
1129 enum machine_mode mode
;
1132 REAL_VALUE_TYPE value
;
1133 REAL_VALUE_TYPE result
;
1137 /* The following codes are handled by real_arithmetic. */
1152 d1
= TREE_REAL_CST (arg1
);
1153 d2
= TREE_REAL_CST (arg2
);
1155 type
= TREE_TYPE (arg1
);
1156 mode
= TYPE_MODE (type
);
1158 /* Don't perform operation if we honor signaling NaNs and
1159 either operand is a NaN. */
1160 if (HONOR_SNANS (mode
)
1161 && (REAL_VALUE_ISNAN (d1
) || REAL_VALUE_ISNAN (d2
)))
1164 /* Don't perform operation if it would raise a division
1165 by zero exception. */
1166 if (code
== RDIV_EXPR
1167 && REAL_VALUES_EQUAL (d2
, dconst0
)
1168 && (flag_trapping_math
|| ! MODE_HAS_INFINITIES (mode
)))
1171 /* If either operand is a NaN, just return it. Otherwise, set up
1172 for floating-point trap; we return an overflow. */
1173 if (REAL_VALUE_ISNAN (d1
))
1175 else if (REAL_VALUE_ISNAN (d2
))
1178 inexact
= real_arithmetic (&value
, code
, &d1
, &d2
);
1179 real_convert (&result
, mode
, &value
);
1181 /* Don't constant fold this floating point operation if
1182 the result has overflowed and flag_trapping_math. */
1183 if (flag_trapping_math
1184 && MODE_HAS_INFINITIES (mode
)
1185 && REAL_VALUE_ISINF (result
)
1186 && !REAL_VALUE_ISINF (d1
)
1187 && !REAL_VALUE_ISINF (d2
))
1190 /* Don't constant fold this floating point operation if the
1191 result may dependent upon the run-time rounding mode and
1192 flag_rounding_math is set, or if GCC's software emulation
1193 is unable to accurately represent the result. */
1194 if ((flag_rounding_math
1195 || (MODE_COMPOSITE_P (mode
) && !flag_unsafe_math_optimizations
))
1196 && (inexact
|| !real_identical (&result
, &value
)))
1199 t
= build_real (type
, result
);
1201 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
);
1205 if (TREE_CODE (arg1
) == FIXED_CST
)
1207 FIXED_VALUE_TYPE f1
;
1208 FIXED_VALUE_TYPE f2
;
1209 FIXED_VALUE_TYPE result
;
1214 /* The following codes are handled by fixed_arithmetic. */
1220 case TRUNC_DIV_EXPR
:
1221 f2
= TREE_FIXED_CST (arg2
);
1228 f2
.data
.high
= w2
.elt (1);
1229 f2
.data
.low
= w2
.elt (0);
1238 f1
= TREE_FIXED_CST (arg1
);
1239 type
= TREE_TYPE (arg1
);
1240 sat_p
= TYPE_SATURATING (type
);
1241 overflow_p
= fixed_arithmetic (&result
, code
, &f1
, &f2
, sat_p
);
1242 t
= build_fixed (type
, result
);
1243 /* Propagate overflow flags. */
1244 if (overflow_p
| TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
))
1245 TREE_OVERFLOW (t
) = 1;
1249 if (TREE_CODE (arg1
) == COMPLEX_CST
)
1251 tree type
= TREE_TYPE (arg1
);
1252 tree r1
= TREE_REALPART (arg1
);
1253 tree i1
= TREE_IMAGPART (arg1
);
1254 tree r2
= TREE_REALPART (arg2
);
1255 tree i2
= TREE_IMAGPART (arg2
);
1262 real
= const_binop (code
, r1
, r2
);
1263 imag
= const_binop (code
, i1
, i2
);
1267 if (COMPLEX_FLOAT_TYPE_P (type
))
1268 return do_mpc_arg2 (arg1
, arg2
, type
,
1269 /* do_nonfinite= */ folding_initializer
,
1272 real
= const_binop (MINUS_EXPR
,
1273 const_binop (MULT_EXPR
, r1
, r2
),
1274 const_binop (MULT_EXPR
, i1
, i2
));
1275 imag
= const_binop (PLUS_EXPR
,
1276 const_binop (MULT_EXPR
, r1
, i2
),
1277 const_binop (MULT_EXPR
, i1
, r2
));
1281 if (COMPLEX_FLOAT_TYPE_P (type
))
1282 return do_mpc_arg2 (arg1
, arg2
, type
,
1283 /* do_nonfinite= */ folding_initializer
,
1286 case TRUNC_DIV_EXPR
:
1288 case FLOOR_DIV_EXPR
:
1289 case ROUND_DIV_EXPR
:
1290 if (flag_complex_method
== 0)
1292 /* Keep this algorithm in sync with
1293 tree-complex.c:expand_complex_div_straight().
1295 Expand complex division to scalars, straightforward algorithm.
1296 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1300 = const_binop (PLUS_EXPR
,
1301 const_binop (MULT_EXPR
, r2
, r2
),
1302 const_binop (MULT_EXPR
, i2
, i2
));
1304 = const_binop (PLUS_EXPR
,
1305 const_binop (MULT_EXPR
, r1
, r2
),
1306 const_binop (MULT_EXPR
, i1
, i2
));
1308 = const_binop (MINUS_EXPR
,
1309 const_binop (MULT_EXPR
, i1
, r2
),
1310 const_binop (MULT_EXPR
, r1
, i2
));
1312 real
= const_binop (code
, t1
, magsquared
);
1313 imag
= const_binop (code
, t2
, magsquared
);
1317 /* Keep this algorithm in sync with
1318 tree-complex.c:expand_complex_div_wide().
1320 Expand complex division to scalars, modified algorithm to minimize
1321 overflow with wide input ranges. */
1322 tree compare
= fold_build2 (LT_EXPR
, boolean_type_node
,
1323 fold_abs_const (r2
, TREE_TYPE (type
)),
1324 fold_abs_const (i2
, TREE_TYPE (type
)));
1326 if (integer_nonzerop (compare
))
1328 /* In the TRUE branch, we compute
1330 div = (br * ratio) + bi;
1331 tr = (ar * ratio) + ai;
1332 ti = (ai * ratio) - ar;
1335 tree ratio
= const_binop (code
, r2
, i2
);
1336 tree div
= const_binop (PLUS_EXPR
, i2
,
1337 const_binop (MULT_EXPR
, r2
, ratio
));
1338 real
= const_binop (MULT_EXPR
, r1
, ratio
);
1339 real
= const_binop (PLUS_EXPR
, real
, i1
);
1340 real
= const_binop (code
, real
, div
);
1342 imag
= const_binop (MULT_EXPR
, i1
, ratio
);
1343 imag
= const_binop (MINUS_EXPR
, imag
, r1
);
1344 imag
= const_binop (code
, imag
, div
);
1348 /* In the FALSE branch, we compute
1350 divisor = (d * ratio) + c;
1351 tr = (b * ratio) + a;
1352 ti = b - (a * ratio);
1355 tree ratio
= const_binop (code
, i2
, r2
);
1356 tree div
= const_binop (PLUS_EXPR
, r2
,
1357 const_binop (MULT_EXPR
, i2
, ratio
));
1359 real
= const_binop (MULT_EXPR
, i1
, ratio
);
1360 real
= const_binop (PLUS_EXPR
, real
, r1
);
1361 real
= const_binop (code
, real
, div
);
1363 imag
= const_binop (MULT_EXPR
, r1
, ratio
);
1364 imag
= const_binop (MINUS_EXPR
, i1
, imag
);
1365 imag
= const_binop (code
, imag
, div
);
1375 return build_complex (type
, real
, imag
);
1378 if (TREE_CODE (arg1
) == VECTOR_CST
1379 && TREE_CODE (arg2
) == VECTOR_CST
)
1381 tree type
= TREE_TYPE (arg1
);
1382 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1383 tree
*elts
= XALLOCAVEC (tree
, count
);
1385 for (i
= 0; i
< count
; i
++)
1387 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1388 tree elem2
= VECTOR_CST_ELT (arg2
, i
);
1390 elts
[i
] = const_binop (code
, elem1
, elem2
);
1392 /* It is possible that const_binop cannot handle the given
1393 code and return NULL_TREE */
1394 if (elts
[i
] == NULL_TREE
)
1398 return build_vector (type
, elts
);
1401 /* Shifts allow a scalar offset for a vector. */
1402 if (TREE_CODE (arg1
) == VECTOR_CST
1403 && TREE_CODE (arg2
) == INTEGER_CST
)
1405 tree type
= TREE_TYPE (arg1
);
1406 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1407 tree
*elts
= XALLOCAVEC (tree
, count
);
1409 if (code
== VEC_LSHIFT_EXPR
1410 || code
== VEC_RSHIFT_EXPR
)
1412 if (!tree_fits_uhwi_p (arg2
))
1415 unsigned HOST_WIDE_INT shiftc
= tree_to_uhwi (arg2
);
1416 unsigned HOST_WIDE_INT outerc
= tree_to_uhwi (TYPE_SIZE (type
));
1417 unsigned HOST_WIDE_INT innerc
1418 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type
)));
1419 if (shiftc
>= outerc
|| (shiftc
% innerc
) != 0)
1421 int offset
= shiftc
/ innerc
;
1422 /* The direction of VEC_[LR]SHIFT_EXPR is endian dependent.
1423 For reductions, compiler emits VEC_RSHIFT_EXPR always,
1424 for !BYTES_BIG_ENDIAN picks first vector element, but
1425 for BYTES_BIG_ENDIAN last element from the vector. */
1426 if ((code
== VEC_RSHIFT_EXPR
) ^ (!BYTES_BIG_ENDIAN
))
1428 tree zero
= build_zero_cst (TREE_TYPE (type
));
1429 for (i
= 0; i
< count
; i
++)
1431 if (i
+ offset
< 0 || i
+ offset
>= count
)
1434 elts
[i
] = VECTOR_CST_ELT (arg1
, i
+ offset
);
1438 for (i
= 0; i
< count
; i
++)
1440 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1442 elts
[i
] = const_binop (code
, elem1
, arg2
);
1444 /* It is possible that const_binop cannot handle the given
1445 code and return NULL_TREE */
1446 if (elts
[i
] == NULL_TREE
)
1450 return build_vector (type
, elts
);
1455 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1456 indicates which particular sizetype to create. */
1459 size_int_kind (HOST_WIDE_INT number
, enum size_type_kind kind
)
1461 return build_int_cst (sizetype_tab
[(int) kind
], number
);
1464 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1465 is a tree code. The type of the result is taken from the operands.
1466 Both must be equivalent integer types, ala int_binop_types_match_p.
1467 If the operands are constant, so is the result. */
1470 size_binop_loc (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
)
1472 tree type
= TREE_TYPE (arg0
);
1474 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1475 return error_mark_node
;
1477 gcc_assert (int_binop_types_match_p (code
, TREE_TYPE (arg0
),
1480 /* Handle the special case of two integer constants faster. */
1481 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1483 /* And some specific cases even faster than that. */
1484 if (code
== PLUS_EXPR
)
1486 if (integer_zerop (arg0
) && !TREE_OVERFLOW (arg0
))
1488 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1491 else if (code
== MINUS_EXPR
)
1493 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1496 else if (code
== MULT_EXPR
)
1498 if (integer_onep (arg0
) && !TREE_OVERFLOW (arg0
))
1502 /* Handle general case of two integer constants. For sizetype
1503 constant calculations we always want to know about overflow,
1504 even in the unsigned case. */
1505 return int_const_binop_1 (code
, arg0
, arg1
, -1);
1508 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
1511 /* Given two values, either both of sizetype or both of bitsizetype,
1512 compute the difference between the two values. Return the value
1513 in signed type corresponding to the type of the operands. */
1516 size_diffop_loc (location_t loc
, tree arg0
, tree arg1
)
1518 tree type
= TREE_TYPE (arg0
);
1521 gcc_assert (int_binop_types_match_p (MINUS_EXPR
, TREE_TYPE (arg0
),
1524 /* If the type is already signed, just do the simple thing. */
1525 if (!TYPE_UNSIGNED (type
))
1526 return size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
);
1528 if (type
== sizetype
)
1530 else if (type
== bitsizetype
)
1531 ctype
= sbitsizetype
;
1533 ctype
= signed_type_for (type
);
1535 /* If either operand is not a constant, do the conversions to the signed
1536 type and subtract. The hardware will do the right thing with any
1537 overflow in the subtraction. */
1538 if (TREE_CODE (arg0
) != INTEGER_CST
|| TREE_CODE (arg1
) != INTEGER_CST
)
1539 return size_binop_loc (loc
, MINUS_EXPR
,
1540 fold_convert_loc (loc
, ctype
, arg0
),
1541 fold_convert_loc (loc
, ctype
, arg1
));
1543 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1544 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1545 overflow) and negate (which can't either). Special-case a result
1546 of zero while we're here. */
1547 if (tree_int_cst_equal (arg0
, arg1
))
1548 return build_int_cst (ctype
, 0);
1549 else if (tree_int_cst_lt (arg1
, arg0
))
1550 return fold_convert_loc (loc
, ctype
,
1551 size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
));
1553 return size_binop_loc (loc
, MINUS_EXPR
, build_int_cst (ctype
, 0),
1554 fold_convert_loc (loc
, ctype
,
1555 size_binop_loc (loc
,
1560 /* A subroutine of fold_convert_const handling conversions of an
1561 INTEGER_CST to another integer type. */
1564 fold_convert_const_int_from_int (tree type
, const_tree arg1
)
1566 /* Given an integer constant, make new constant with new type,
1567 appropriately sign-extended or truncated. Use widest_int
1568 so that any extension is done according ARG1's type. */
1569 return force_fit_type (type
, wi::to_widest (arg1
),
1570 !POINTER_TYPE_P (TREE_TYPE (arg1
)),
1571 TREE_OVERFLOW (arg1
));
1574 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1575 to an integer type. */
1578 fold_convert_const_int_from_real (enum tree_code code
, tree type
, const_tree arg1
)
1580 bool overflow
= false;
1583 /* The following code implements the floating point to integer
1584 conversion rules required by the Java Language Specification,
1585 that IEEE NaNs are mapped to zero and values that overflow
1586 the target precision saturate, i.e. values greater than
1587 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1588 are mapped to INT_MIN. These semantics are allowed by the
1589 C and C++ standards that simply state that the behavior of
1590 FP-to-integer conversion is unspecified upon overflow. */
1594 REAL_VALUE_TYPE x
= TREE_REAL_CST (arg1
);
1598 case FIX_TRUNC_EXPR
:
1599 real_trunc (&r
, VOIDmode
, &x
);
1606 /* If R is NaN, return zero and show we have an overflow. */
1607 if (REAL_VALUE_ISNAN (r
))
1610 val
= wi::zero (TYPE_PRECISION (type
));
1613 /* See if R is less than the lower bound or greater than the
1618 tree lt
= TYPE_MIN_VALUE (type
);
1619 REAL_VALUE_TYPE l
= real_value_from_int_cst (NULL_TREE
, lt
);
1620 if (REAL_VALUES_LESS (r
, l
))
1629 tree ut
= TYPE_MAX_VALUE (type
);
1632 REAL_VALUE_TYPE u
= real_value_from_int_cst (NULL_TREE
, ut
);
1633 if (REAL_VALUES_LESS (u
, r
))
1642 val
= real_to_integer (&r
, &overflow
, TYPE_PRECISION (type
));
1644 t
= force_fit_type (type
, val
, -1, overflow
| TREE_OVERFLOW (arg1
));
1648 /* A subroutine of fold_convert_const handling conversions of a
1649 FIXED_CST to an integer type. */
1652 fold_convert_const_int_from_fixed (tree type
, const_tree arg1
)
1655 double_int temp
, temp_trunc
;
1658 /* Right shift FIXED_CST to temp by fbit. */
1659 temp
= TREE_FIXED_CST (arg1
).data
;
1660 mode
= TREE_FIXED_CST (arg1
).mode
;
1661 if (GET_MODE_FBIT (mode
) < HOST_BITS_PER_DOUBLE_INT
)
1663 temp
= temp
.rshift (GET_MODE_FBIT (mode
),
1664 HOST_BITS_PER_DOUBLE_INT
,
1665 SIGNED_FIXED_POINT_MODE_P (mode
));
1667 /* Left shift temp to temp_trunc by fbit. */
1668 temp_trunc
= temp
.lshift (GET_MODE_FBIT (mode
),
1669 HOST_BITS_PER_DOUBLE_INT
,
1670 SIGNED_FIXED_POINT_MODE_P (mode
));
1674 temp
= double_int_zero
;
1675 temp_trunc
= double_int_zero
;
1678 /* If FIXED_CST is negative, we need to round the value toward 0.
1679 By checking if the fractional bits are not zero to add 1 to temp. */
1680 if (SIGNED_FIXED_POINT_MODE_P (mode
)
1681 && temp_trunc
.is_negative ()
1682 && TREE_FIXED_CST (arg1
).data
!= temp_trunc
)
1683 temp
+= double_int_one
;
1685 /* Given a fixed-point constant, make new constant with new type,
1686 appropriately sign-extended or truncated. */
1687 t
= force_fit_type (type
, temp
, -1,
1688 (temp
.is_negative ()
1689 && (TYPE_UNSIGNED (type
)
1690 < TYPE_UNSIGNED (TREE_TYPE (arg1
))))
1691 | TREE_OVERFLOW (arg1
));
1696 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1697 to another floating point type. */
1700 fold_convert_const_real_from_real (tree type
, const_tree arg1
)
1702 REAL_VALUE_TYPE value
;
1705 real_convert (&value
, TYPE_MODE (type
), &TREE_REAL_CST (arg1
));
1706 t
= build_real (type
, value
);
1708 /* If converting an infinity or NAN to a representation that doesn't
1709 have one, set the overflow bit so that we can produce some kind of
1710 error message at the appropriate point if necessary. It's not the
1711 most user-friendly message, but it's better than nothing. */
1712 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1
))
1713 && !MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1714 TREE_OVERFLOW (t
) = 1;
1715 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
1716 && !MODE_HAS_NANS (TYPE_MODE (type
)))
1717 TREE_OVERFLOW (t
) = 1;
1718 /* Regular overflow, conversion produced an infinity in a mode that
1719 can't represent them. */
1720 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type
))
1721 && REAL_VALUE_ISINF (value
)
1722 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1
)))
1723 TREE_OVERFLOW (t
) = 1;
1725 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
1729 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1730 to a floating point type. */
1733 fold_convert_const_real_from_fixed (tree type
, const_tree arg1
)
1735 REAL_VALUE_TYPE value
;
1738 real_convert_from_fixed (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
));
1739 t
= build_real (type
, value
);
1741 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
1745 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1746 to another fixed-point type. */
1749 fold_convert_const_fixed_from_fixed (tree type
, const_tree arg1
)
1751 FIXED_VALUE_TYPE value
;
1755 overflow_p
= fixed_convert (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
),
1756 TYPE_SATURATING (type
));
1757 t
= build_fixed (type
, value
);
1759 /* Propagate overflow flags. */
1760 if (overflow_p
| TREE_OVERFLOW (arg1
))
1761 TREE_OVERFLOW (t
) = 1;
1765 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
1766 to a fixed-point type. */
1769 fold_convert_const_fixed_from_int (tree type
, const_tree arg1
)
1771 FIXED_VALUE_TYPE value
;
1776 gcc_assert (TREE_INT_CST_NUNITS (arg1
) <= 2);
1778 di
.low
= TREE_INT_CST_ELT (arg1
, 0);
1779 if (TREE_INT_CST_NUNITS (arg1
) == 1)
1780 di
.high
= (HOST_WIDE_INT
) di
.low
< 0 ? (HOST_WIDE_INT
) -1 : 0;
1782 di
.high
= TREE_INT_CST_ELT (arg1
, 1);
1784 overflow_p
= fixed_convert_from_int (&value
, TYPE_MODE (type
), di
,
1785 TYPE_UNSIGNED (TREE_TYPE (arg1
)),
1786 TYPE_SATURATING (type
));
1787 t
= build_fixed (type
, value
);
1789 /* Propagate overflow flags. */
1790 if (overflow_p
| TREE_OVERFLOW (arg1
))
1791 TREE_OVERFLOW (t
) = 1;
1795 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1796 to a fixed-point type. */
1799 fold_convert_const_fixed_from_real (tree type
, const_tree arg1
)
1801 FIXED_VALUE_TYPE value
;
1805 overflow_p
= fixed_convert_from_real (&value
, TYPE_MODE (type
),
1806 &TREE_REAL_CST (arg1
),
1807 TYPE_SATURATING (type
));
1808 t
= build_fixed (type
, value
);
1810 /* Propagate overflow flags. */
1811 if (overflow_p
| TREE_OVERFLOW (arg1
))
1812 TREE_OVERFLOW (t
) = 1;
1816 /* Attempt to fold type conversion operation CODE of expression ARG1 to
1817 type TYPE. If no simplification can be done return NULL_TREE. */
1820 fold_convert_const (enum tree_code code
, tree type
, tree arg1
)
1822 if (TREE_TYPE (arg1
) == type
)
1825 if (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
)
1826 || TREE_CODE (type
) == OFFSET_TYPE
)
1828 if (TREE_CODE (arg1
) == INTEGER_CST
)
1829 return fold_convert_const_int_from_int (type
, arg1
);
1830 else if (TREE_CODE (arg1
) == REAL_CST
)
1831 return fold_convert_const_int_from_real (code
, type
, arg1
);
1832 else if (TREE_CODE (arg1
) == FIXED_CST
)
1833 return fold_convert_const_int_from_fixed (type
, arg1
);
1835 else if (TREE_CODE (type
) == REAL_TYPE
)
1837 if (TREE_CODE (arg1
) == INTEGER_CST
)
1838 return build_real_from_int_cst (type
, arg1
);
1839 else if (TREE_CODE (arg1
) == REAL_CST
)
1840 return fold_convert_const_real_from_real (type
, arg1
);
1841 else if (TREE_CODE (arg1
) == FIXED_CST
)
1842 return fold_convert_const_real_from_fixed (type
, arg1
);
1844 else if (TREE_CODE (type
) == FIXED_POINT_TYPE
)
1846 if (TREE_CODE (arg1
) == FIXED_CST
)
1847 return fold_convert_const_fixed_from_fixed (type
, arg1
);
1848 else if (TREE_CODE (arg1
) == INTEGER_CST
)
1849 return fold_convert_const_fixed_from_int (type
, arg1
);
1850 else if (TREE_CODE (arg1
) == REAL_CST
)
1851 return fold_convert_const_fixed_from_real (type
, arg1
);
1856 /* Construct a vector of zero elements of vector type TYPE. */
1859 build_zero_vector (tree type
)
1863 t
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), integer_zero_node
);
1864 return build_vector_from_val (type
, t
);
1867 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
1870 fold_convertible_p (const_tree type
, const_tree arg
)
1872 tree orig
= TREE_TYPE (arg
);
1877 if (TREE_CODE (arg
) == ERROR_MARK
1878 || TREE_CODE (type
) == ERROR_MARK
1879 || TREE_CODE (orig
) == ERROR_MARK
)
1882 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
1885 switch (TREE_CODE (type
))
1887 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1888 case POINTER_TYPE
: case REFERENCE_TYPE
:
1890 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
1891 || TREE_CODE (orig
) == OFFSET_TYPE
)
1893 return (TREE_CODE (orig
) == VECTOR_TYPE
1894 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
1897 case FIXED_POINT_TYPE
:
1901 return TREE_CODE (type
) == TREE_CODE (orig
);
1908 /* Convert expression ARG to type TYPE. Used by the middle-end for
1909 simple conversions in preference to calling the front-end's convert. */
1912 fold_convert_loc (location_t loc
, tree type
, tree arg
)
1914 tree orig
= TREE_TYPE (arg
);
1920 if (TREE_CODE (arg
) == ERROR_MARK
1921 || TREE_CODE (type
) == ERROR_MARK
1922 || TREE_CODE (orig
) == ERROR_MARK
)
1923 return error_mark_node
;
1925 switch (TREE_CODE (type
))
1928 case REFERENCE_TYPE
:
1929 /* Handle conversions between pointers to different address spaces. */
1930 if (POINTER_TYPE_P (orig
)
1931 && (TYPE_ADDR_SPACE (TREE_TYPE (type
))
1932 != TYPE_ADDR_SPACE (TREE_TYPE (orig
))))
1933 return fold_build1_loc (loc
, ADDR_SPACE_CONVERT_EXPR
, type
, arg
);
1936 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1938 if (TREE_CODE (arg
) == INTEGER_CST
)
1940 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
1941 if (tem
!= NULL_TREE
)
1944 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
1945 || TREE_CODE (orig
) == OFFSET_TYPE
)
1946 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
1947 if (TREE_CODE (orig
) == COMPLEX_TYPE
)
1948 return fold_convert_loc (loc
, type
,
1949 fold_build1_loc (loc
, REALPART_EXPR
,
1950 TREE_TYPE (orig
), arg
));
1951 gcc_assert (TREE_CODE (orig
) == VECTOR_TYPE
1952 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
1953 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
1956 if (TREE_CODE (arg
) == INTEGER_CST
)
1958 tem
= fold_convert_const (FLOAT_EXPR
, type
, arg
);
1959 if (tem
!= NULL_TREE
)
1962 else if (TREE_CODE (arg
) == REAL_CST
)
1964 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
1965 if (tem
!= NULL_TREE
)
1968 else if (TREE_CODE (arg
) == FIXED_CST
)
1970 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
1971 if (tem
!= NULL_TREE
)
1975 switch (TREE_CODE (orig
))
1978 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
1979 case POINTER_TYPE
: case REFERENCE_TYPE
:
1980 return fold_build1_loc (loc
, FLOAT_EXPR
, type
, arg
);
1983 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
1985 case FIXED_POINT_TYPE
:
1986 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
1989 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
1990 return fold_convert_loc (loc
, type
, tem
);
1996 case FIXED_POINT_TYPE
:
1997 if (TREE_CODE (arg
) == FIXED_CST
|| TREE_CODE (arg
) == INTEGER_CST
1998 || TREE_CODE (arg
) == REAL_CST
)
2000 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
2001 if (tem
!= NULL_TREE
)
2002 goto fold_convert_exit
;
2005 switch (TREE_CODE (orig
))
2007 case FIXED_POINT_TYPE
:
2012 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
2015 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2016 return fold_convert_loc (loc
, type
, tem
);
2023 switch (TREE_CODE (orig
))
2026 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
2027 case POINTER_TYPE
: case REFERENCE_TYPE
:
2029 case FIXED_POINT_TYPE
:
2030 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
2031 fold_convert_loc (loc
, TREE_TYPE (type
), arg
),
2032 fold_convert_loc (loc
, TREE_TYPE (type
),
2033 integer_zero_node
));
2038 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
2040 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2041 TREE_OPERAND (arg
, 0));
2042 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
),
2043 TREE_OPERAND (arg
, 1));
2044 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2047 arg
= save_expr (arg
);
2048 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
2049 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, TREE_TYPE (orig
), arg
);
2050 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
), rpart
);
2051 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
), ipart
);
2052 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
2060 if (integer_zerop (arg
))
2061 return build_zero_vector (type
);
2062 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
2063 gcc_assert (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
2064 || TREE_CODE (orig
) == VECTOR_TYPE
);
2065 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
2068 tem
= fold_ignored_result (arg
);
2069 return fold_build1_loc (loc
, NOP_EXPR
, type
, tem
);
2072 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
2073 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
2077 protected_set_expr_location_unshare (tem
, loc
);
2081 /* Return false if expr can be assumed not to be an lvalue, true
2085 maybe_lvalue_p (const_tree x
)
2087 /* We only need to wrap lvalue tree codes. */
2088 switch (TREE_CODE (x
))
2101 case ARRAY_RANGE_REF
:
2107 case PREINCREMENT_EXPR
:
2108 case PREDECREMENT_EXPR
:
2110 case TRY_CATCH_EXPR
:
2111 case WITH_CLEANUP_EXPR
:
2120 /* Assume the worst for front-end tree codes. */
2121 if ((int)TREE_CODE (x
) >= NUM_TREE_CODES
)
2129 /* Return an expr equal to X but certainly not valid as an lvalue. */
2132 non_lvalue_loc (location_t loc
, tree x
)
2134 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2139 if (! maybe_lvalue_p (x
))
2141 return build1_loc (loc
, NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
2144 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2145 Zero means allow extended lvalues. */
2147 int pedantic_lvalues
;
2149 /* When pedantic, return an expr equal to X but certainly not valid as a
2150 pedantic lvalue. Otherwise, return X. */
2153 pedantic_non_lvalue_loc (location_t loc
, tree x
)
2155 if (pedantic_lvalues
)
2156 return non_lvalue_loc (loc
, x
);
2158 return protected_set_expr_location_unshare (x
, loc
);
2161 /* Given a tree comparison code, return the code that is the logical inverse.
2162 It is generally not safe to do this for floating-point comparisons, except
2163 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2164 ERROR_MARK in this case. */
2167 invert_tree_comparison (enum tree_code code
, bool honor_nans
)
2169 if (honor_nans
&& flag_trapping_math
&& code
!= EQ_EXPR
&& code
!= NE_EXPR
2170 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
)
2180 return honor_nans
? UNLE_EXPR
: LE_EXPR
;
2182 return honor_nans
? UNLT_EXPR
: LT_EXPR
;
2184 return honor_nans
? UNGE_EXPR
: GE_EXPR
;
2186 return honor_nans
? UNGT_EXPR
: GT_EXPR
;
2200 return UNORDERED_EXPR
;
2201 case UNORDERED_EXPR
:
2202 return ORDERED_EXPR
;
2208 /* Similar, but return the comparison that results if the operands are
2209 swapped. This is safe for floating-point. */
2212 swap_tree_comparison (enum tree_code code
)
2219 case UNORDERED_EXPR
:
2245 /* Convert a comparison tree code from an enum tree_code representation
2246 into a compcode bit-based encoding. This function is the inverse of
2247 compcode_to_comparison. */
2249 static enum comparison_code
2250 comparison_to_compcode (enum tree_code code
)
2267 return COMPCODE_ORD
;
2268 case UNORDERED_EXPR
:
2269 return COMPCODE_UNORD
;
2271 return COMPCODE_UNLT
;
2273 return COMPCODE_UNEQ
;
2275 return COMPCODE_UNLE
;
2277 return COMPCODE_UNGT
;
2279 return COMPCODE_LTGT
;
2281 return COMPCODE_UNGE
;
2287 /* Convert a compcode bit-based encoding of a comparison operator back
2288 to GCC's enum tree_code representation. This function is the
2289 inverse of comparison_to_compcode. */
2291 static enum tree_code
2292 compcode_to_comparison (enum comparison_code code
)
2309 return ORDERED_EXPR
;
2310 case COMPCODE_UNORD
:
2311 return UNORDERED_EXPR
;
2329 /* Return a tree for the comparison which is the combination of
2330 doing the AND or OR (depending on CODE) of the two operations LCODE
2331 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2332 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2333 if this makes the transformation invalid. */
2336 combine_comparisons (location_t loc
,
2337 enum tree_code code
, enum tree_code lcode
,
2338 enum tree_code rcode
, tree truth_type
,
2339 tree ll_arg
, tree lr_arg
)
2341 bool honor_nans
= HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg
)));
2342 enum comparison_code lcompcode
= comparison_to_compcode (lcode
);
2343 enum comparison_code rcompcode
= comparison_to_compcode (rcode
);
2348 case TRUTH_AND_EXPR
: case TRUTH_ANDIF_EXPR
:
2349 compcode
= lcompcode
& rcompcode
;
2352 case TRUTH_OR_EXPR
: case TRUTH_ORIF_EXPR
:
2353 compcode
= lcompcode
| rcompcode
;
2362 /* Eliminate unordered comparisons, as well as LTGT and ORD
2363 which are not used unless the mode has NaNs. */
2364 compcode
&= ~COMPCODE_UNORD
;
2365 if (compcode
== COMPCODE_LTGT
)
2366 compcode
= COMPCODE_NE
;
2367 else if (compcode
== COMPCODE_ORD
)
2368 compcode
= COMPCODE_TRUE
;
2370 else if (flag_trapping_math
)
2372 /* Check that the original operation and the optimized ones will trap
2373 under the same condition. */
2374 bool ltrap
= (lcompcode
& COMPCODE_UNORD
) == 0
2375 && (lcompcode
!= COMPCODE_EQ
)
2376 && (lcompcode
!= COMPCODE_ORD
);
2377 bool rtrap
= (rcompcode
& COMPCODE_UNORD
) == 0
2378 && (rcompcode
!= COMPCODE_EQ
)
2379 && (rcompcode
!= COMPCODE_ORD
);
2380 bool trap
= (compcode
& COMPCODE_UNORD
) == 0
2381 && (compcode
!= COMPCODE_EQ
)
2382 && (compcode
!= COMPCODE_ORD
);
2384 /* In a short-circuited boolean expression the LHS might be
2385 such that the RHS, if evaluated, will never trap. For
2386 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2387 if neither x nor y is NaN. (This is a mixed blessing: for
2388 example, the expression above will never trap, hence
2389 optimizing it to x < y would be invalid). */
2390 if ((code
== TRUTH_ORIF_EXPR
&& (lcompcode
& COMPCODE_UNORD
))
2391 || (code
== TRUTH_ANDIF_EXPR
&& !(lcompcode
& COMPCODE_UNORD
)))
2394 /* If the comparison was short-circuited, and only the RHS
2395 trapped, we may now generate a spurious trap. */
2397 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2400 /* If we changed the conditions that cause a trap, we lose. */
2401 if ((ltrap
|| rtrap
) != trap
)
2405 if (compcode
== COMPCODE_TRUE
)
2406 return constant_boolean_node (true, truth_type
);
2407 else if (compcode
== COMPCODE_FALSE
)
2408 return constant_boolean_node (false, truth_type
);
2411 enum tree_code tcode
;
2413 tcode
= compcode_to_comparison ((enum comparison_code
) compcode
);
2414 return fold_build2_loc (loc
, tcode
, truth_type
, ll_arg
, lr_arg
);
2418 /* Return nonzero if two operands (typically of the same tree node)
2419 are necessarily equal. If either argument has side-effects this
2420 function returns zero. FLAGS modifies behavior as follows:
2422 If OEP_ONLY_CONST is set, only return nonzero for constants.
2423 This function tests whether the operands are indistinguishable;
2424 it does not test whether they are equal using C's == operation.
2425 The distinction is important for IEEE floating point, because
2426 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2427 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2429 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2430 even though it may hold multiple values during a function.
2431 This is because a GCC tree node guarantees that nothing else is
2432 executed between the evaluation of its "operands" (which may often
2433 be evaluated in arbitrary order). Hence if the operands themselves
2434 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2435 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2436 unset means assuming isochronic (or instantaneous) tree equivalence.
2437 Unless comparing arbitrary expression trees, such as from different
2438 statements, this flag can usually be left unset.
2440 If OEP_PURE_SAME is set, then pure functions with identical arguments
2441 are considered the same. It is used when the caller has other ways
2442 to ensure that global memory is unchanged in between. */
2445 operand_equal_p (const_tree arg0
, const_tree arg1
, unsigned int flags
)
2447 /* If either is ERROR_MARK, they aren't equal. */
2448 if (TREE_CODE (arg0
) == ERROR_MARK
|| TREE_CODE (arg1
) == ERROR_MARK
2449 || TREE_TYPE (arg0
) == error_mark_node
2450 || TREE_TYPE (arg1
) == error_mark_node
)
2453 /* Similar, if either does not have a type (like a released SSA name),
2454 they aren't equal. */
2455 if (!TREE_TYPE (arg0
) || !TREE_TYPE (arg1
))
2458 /* Check equality of integer constants before bailing out due to
2459 precision differences. */
2460 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2461 return tree_int_cst_equal (arg0
, arg1
);
2463 /* If both types don't have the same signedness, then we can't consider
2464 them equal. We must check this before the STRIP_NOPS calls
2465 because they may change the signedness of the arguments. As pointers
2466 strictly don't have a signedness, require either two pointers or
2467 two non-pointers as well. */
2468 if (TYPE_UNSIGNED (TREE_TYPE (arg0
)) != TYPE_UNSIGNED (TREE_TYPE (arg1
))
2469 || POINTER_TYPE_P (TREE_TYPE (arg0
)) != POINTER_TYPE_P (TREE_TYPE (arg1
)))
2472 /* We cannot consider pointers to different address space equal. */
2473 if (POINTER_TYPE_P (TREE_TYPE (arg0
)) && POINTER_TYPE_P (TREE_TYPE (arg1
))
2474 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
)))
2475 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1
)))))
2478 /* If both types don't have the same precision, then it is not safe
2480 if (element_precision (TREE_TYPE (arg0
))
2481 != element_precision (TREE_TYPE (arg1
)))
2487 /* In case both args are comparisons but with different comparison
2488 code, try to swap the comparison operands of one arg to produce
2489 a match and compare that variant. */
2490 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2491 && COMPARISON_CLASS_P (arg0
)
2492 && COMPARISON_CLASS_P (arg1
))
2494 enum tree_code swap_code
= swap_tree_comparison (TREE_CODE (arg1
));
2496 if (TREE_CODE (arg0
) == swap_code
)
2497 return operand_equal_p (TREE_OPERAND (arg0
, 0),
2498 TREE_OPERAND (arg1
, 1), flags
)
2499 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2500 TREE_OPERAND (arg1
, 0), flags
);
2503 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2504 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2505 && !(CONVERT_EXPR_P (arg0
) && CONVERT_EXPR_P (arg1
)))
2508 /* This is needed for conversions and for COMPONENT_REF.
2509 Might as well play it safe and always test this. */
2510 if (TREE_CODE (TREE_TYPE (arg0
)) == ERROR_MARK
2511 || TREE_CODE (TREE_TYPE (arg1
)) == ERROR_MARK
2512 || TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
)))
2515 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2516 We don't care about side effects in that case because the SAVE_EXPR
2517 takes care of that for us. In all other cases, two expressions are
2518 equal if they have no side effects. If we have two identical
2519 expressions with side effects that should be treated the same due
2520 to the only side effects being identical SAVE_EXPR's, that will
2521 be detected in the recursive calls below.
2522 If we are taking an invariant address of two identical objects
2523 they are necessarily equal as well. */
2524 if (arg0
== arg1
&& ! (flags
& OEP_ONLY_CONST
)
2525 && (TREE_CODE (arg0
) == SAVE_EXPR
2526 || (flags
& OEP_CONSTANT_ADDRESS_OF
)
2527 || (! TREE_SIDE_EFFECTS (arg0
) && ! TREE_SIDE_EFFECTS (arg1
))))
2530 /* Next handle constant cases, those for which we can return 1 even
2531 if ONLY_CONST is set. */
2532 if (TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
))
2533 switch (TREE_CODE (arg0
))
2536 return tree_int_cst_equal (arg0
, arg1
);
2539 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0
),
2540 TREE_FIXED_CST (arg1
));
2543 if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0
),
2544 TREE_REAL_CST (arg1
)))
2548 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
))))
2550 /* If we do not distinguish between signed and unsigned zero,
2551 consider them equal. */
2552 if (real_zerop (arg0
) && real_zerop (arg1
))
2561 if (VECTOR_CST_NELTS (arg0
) != VECTOR_CST_NELTS (arg1
))
2564 for (i
= 0; i
< VECTOR_CST_NELTS (arg0
); ++i
)
2566 if (!operand_equal_p (VECTOR_CST_ELT (arg0
, i
),
2567 VECTOR_CST_ELT (arg1
, i
), flags
))
2574 return (operand_equal_p (TREE_REALPART (arg0
), TREE_REALPART (arg1
),
2576 && operand_equal_p (TREE_IMAGPART (arg0
), TREE_IMAGPART (arg1
),
2580 return (TREE_STRING_LENGTH (arg0
) == TREE_STRING_LENGTH (arg1
)
2581 && ! memcmp (TREE_STRING_POINTER (arg0
),
2582 TREE_STRING_POINTER (arg1
),
2583 TREE_STRING_LENGTH (arg0
)));
2586 return operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0),
2587 TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
)
2588 ? OEP_CONSTANT_ADDRESS_OF
: 0);
2593 if (flags
& OEP_ONLY_CONST
)
2596 /* Define macros to test an operand from arg0 and arg1 for equality and a
2597 variant that allows null and views null as being different from any
2598 non-null value. In the latter case, if either is null, the both
2599 must be; otherwise, do the normal comparison. */
2600 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2601 TREE_OPERAND (arg1, N), flags)
2603 #define OP_SAME_WITH_NULL(N) \
2604 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2605 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2607 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
2610 /* Two conversions are equal only if signedness and modes match. */
2611 switch (TREE_CODE (arg0
))
2614 case FIX_TRUNC_EXPR
:
2615 if (TYPE_UNSIGNED (TREE_TYPE (arg0
))
2616 != TYPE_UNSIGNED (TREE_TYPE (arg1
)))
2626 case tcc_comparison
:
2628 if (OP_SAME (0) && OP_SAME (1))
2631 /* For commutative ops, allow the other order. */
2632 return (commutative_tree_code (TREE_CODE (arg0
))
2633 && operand_equal_p (TREE_OPERAND (arg0
, 0),
2634 TREE_OPERAND (arg1
, 1), flags
)
2635 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2636 TREE_OPERAND (arg1
, 0), flags
));
2639 /* If either of the pointer (or reference) expressions we are
2640 dereferencing contain a side effect, these cannot be equal,
2641 but their addresses can be. */
2642 if ((flags
& OEP_CONSTANT_ADDRESS_OF
) == 0
2643 && (TREE_SIDE_EFFECTS (arg0
)
2644 || TREE_SIDE_EFFECTS (arg1
)))
2647 switch (TREE_CODE (arg0
))
2650 flags
&= ~OEP_CONSTANT_ADDRESS_OF
;
2657 case TARGET_MEM_REF
:
2658 flags
&= ~OEP_CONSTANT_ADDRESS_OF
;
2659 /* Require equal extra operands and then fall through to MEM_REF
2660 handling of the two common operands. */
2661 if (!OP_SAME_WITH_NULL (2)
2662 || !OP_SAME_WITH_NULL (3)
2663 || !OP_SAME_WITH_NULL (4))
2667 flags
&= ~OEP_CONSTANT_ADDRESS_OF
;
2668 /* Require equal access sizes, and similar pointer types.
2669 We can have incomplete types for array references of
2670 variable-sized arrays from the Fortran frontend
2671 though. Also verify the types are compatible. */
2672 return ((TYPE_SIZE (TREE_TYPE (arg0
)) == TYPE_SIZE (TREE_TYPE (arg1
))
2673 || (TYPE_SIZE (TREE_TYPE (arg0
))
2674 && TYPE_SIZE (TREE_TYPE (arg1
))
2675 && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
2676 TYPE_SIZE (TREE_TYPE (arg1
)), flags
)))
2677 && types_compatible_p (TREE_TYPE (arg0
), TREE_TYPE (arg1
))
2678 && alias_ptr_types_compatible_p
2679 (TREE_TYPE (TREE_OPERAND (arg0
, 1)),
2680 TREE_TYPE (TREE_OPERAND (arg1
, 1)))
2681 && OP_SAME (0) && OP_SAME (1));
2684 case ARRAY_RANGE_REF
:
2685 /* Operands 2 and 3 may be null.
2686 Compare the array index by value if it is constant first as we
2687 may have different types but same value here. */
2690 flags
&= ~OEP_CONSTANT_ADDRESS_OF
;
2691 return ((tree_int_cst_equal (TREE_OPERAND (arg0
, 1),
2692 TREE_OPERAND (arg1
, 1))
2694 && OP_SAME_WITH_NULL (2)
2695 && OP_SAME_WITH_NULL (3));
2698 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
2699 may be NULL when we're called to compare MEM_EXPRs. */
2700 if (!OP_SAME_WITH_NULL (0)
2703 flags
&= ~OEP_CONSTANT_ADDRESS_OF
;
2704 return OP_SAME_WITH_NULL (2);
2709 flags
&= ~OEP_CONSTANT_ADDRESS_OF
;
2710 return OP_SAME (1) && OP_SAME (2);
2716 case tcc_expression
:
2717 switch (TREE_CODE (arg0
))
2720 case TRUTH_NOT_EXPR
:
2723 case TRUTH_ANDIF_EXPR
:
2724 case TRUTH_ORIF_EXPR
:
2725 return OP_SAME (0) && OP_SAME (1);
2728 case WIDEN_MULT_PLUS_EXPR
:
2729 case WIDEN_MULT_MINUS_EXPR
:
2732 /* The multiplcation operands are commutative. */
2735 case TRUTH_AND_EXPR
:
2737 case TRUTH_XOR_EXPR
:
2738 if (OP_SAME (0) && OP_SAME (1))
2741 /* Otherwise take into account this is a commutative operation. */
2742 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
2743 TREE_OPERAND (arg1
, 1), flags
)
2744 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2745 TREE_OPERAND (arg1
, 0), flags
));
2750 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2757 switch (TREE_CODE (arg0
))
2760 /* If the CALL_EXPRs call different functions, then they
2761 clearly can not be equal. */
2762 if (! operand_equal_p (CALL_EXPR_FN (arg0
), CALL_EXPR_FN (arg1
),
2767 unsigned int cef
= call_expr_flags (arg0
);
2768 if (flags
& OEP_PURE_SAME
)
2769 cef
&= ECF_CONST
| ECF_PURE
;
2776 /* Now see if all the arguments are the same. */
2778 const_call_expr_arg_iterator iter0
, iter1
;
2780 for (a0
= first_const_call_expr_arg (arg0
, &iter0
),
2781 a1
= first_const_call_expr_arg (arg1
, &iter1
);
2783 a0
= next_const_call_expr_arg (&iter0
),
2784 a1
= next_const_call_expr_arg (&iter1
))
2785 if (! operand_equal_p (a0
, a1
, flags
))
2788 /* If we get here and both argument lists are exhausted
2789 then the CALL_EXPRs are equal. */
2790 return ! (a0
|| a1
);
2796 case tcc_declaration
:
2797 /* Consider __builtin_sqrt equal to sqrt. */
2798 return (TREE_CODE (arg0
) == FUNCTION_DECL
2799 && DECL_BUILT_IN (arg0
) && DECL_BUILT_IN (arg1
)
2800 && DECL_BUILT_IN_CLASS (arg0
) == DECL_BUILT_IN_CLASS (arg1
)
2801 && DECL_FUNCTION_CODE (arg0
) == DECL_FUNCTION_CODE (arg1
));
2808 #undef OP_SAME_WITH_NULL
2811 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2812 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2814 When in doubt, return 0. */
2817 operand_equal_for_comparison_p (tree arg0
, tree arg1
, tree other
)
2819 int unsignedp1
, unsignedpo
;
2820 tree primarg0
, primarg1
, primother
;
2821 unsigned int correct_width
;
2823 if (operand_equal_p (arg0
, arg1
, 0))
2826 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
2827 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
2830 /* Discard any conversions that don't change the modes of ARG0 and ARG1
2831 and see if the inner values are the same. This removes any
2832 signedness comparison, which doesn't matter here. */
2833 primarg0
= arg0
, primarg1
= arg1
;
2834 STRIP_NOPS (primarg0
);
2835 STRIP_NOPS (primarg1
);
2836 if (operand_equal_p (primarg0
, primarg1
, 0))
2839 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2840 actual comparison operand, ARG0.
2842 First throw away any conversions to wider types
2843 already present in the operands. */
2845 primarg1
= get_narrower (arg1
, &unsignedp1
);
2846 primother
= get_narrower (other
, &unsignedpo
);
2848 correct_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
2849 if (unsignedp1
== unsignedpo
2850 && TYPE_PRECISION (TREE_TYPE (primarg1
)) < correct_width
2851 && TYPE_PRECISION (TREE_TYPE (primother
)) < correct_width
)
2853 tree type
= TREE_TYPE (arg0
);
2855 /* Make sure shorter operand is extended the right way
2856 to match the longer operand. */
2857 primarg1
= fold_convert (signed_or_unsigned_type_for
2858 (unsignedp1
, TREE_TYPE (primarg1
)), primarg1
);
2860 if (operand_equal_p (arg0
, fold_convert (type
, primarg1
), 0))
2867 /* See if ARG is an expression that is either a comparison or is performing
2868 arithmetic on comparisons. The comparisons must only be comparing
2869 two different values, which will be stored in *CVAL1 and *CVAL2; if
2870 they are nonzero it means that some operands have already been found.
2871 No variables may be used anywhere else in the expression except in the
2872 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
2873 the expression and save_expr needs to be called with CVAL1 and CVAL2.
2875 If this is true, return 1. Otherwise, return zero. */
2878 twoval_comparison_p (tree arg
, tree
*cval1
, tree
*cval2
, int *save_p
)
2880 enum tree_code code
= TREE_CODE (arg
);
2881 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
2883 /* We can handle some of the tcc_expression cases here. */
2884 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
2886 else if (tclass
== tcc_expression
2887 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
2888 || code
== COMPOUND_EXPR
))
2889 tclass
= tcc_binary
;
2891 else if (tclass
== tcc_expression
&& code
== SAVE_EXPR
2892 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
2894 /* If we've already found a CVAL1 or CVAL2, this expression is
2895 two complex to handle. */
2896 if (*cval1
|| *cval2
)
2906 return twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
);
2909 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
)
2910 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
2911 cval1
, cval2
, save_p
));
2916 case tcc_expression
:
2917 if (code
== COND_EXPR
)
2918 return (twoval_comparison_p (TREE_OPERAND (arg
, 0),
2919 cval1
, cval2
, save_p
)
2920 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
2921 cval1
, cval2
, save_p
)
2922 && twoval_comparison_p (TREE_OPERAND (arg
, 2),
2923 cval1
, cval2
, save_p
));
2926 case tcc_comparison
:
2927 /* First see if we can handle the first operand, then the second. For
2928 the second operand, we know *CVAL1 can't be zero. It must be that
2929 one side of the comparison is each of the values; test for the
2930 case where this isn't true by failing if the two operands
2933 if (operand_equal_p (TREE_OPERAND (arg
, 0),
2934 TREE_OPERAND (arg
, 1), 0))
2938 *cval1
= TREE_OPERAND (arg
, 0);
2939 else if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 0), 0))
2941 else if (*cval2
== 0)
2942 *cval2
= TREE_OPERAND (arg
, 0);
2943 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 0), 0))
2948 if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 1), 0))
2950 else if (*cval2
== 0)
2951 *cval2
= TREE_OPERAND (arg
, 1);
2952 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 1), 0))
2964 /* ARG is a tree that is known to contain just arithmetic operations and
2965 comparisons. Evaluate the operations in the tree substituting NEW0 for
2966 any occurrence of OLD0 as an operand of a comparison and likewise for
2970 eval_subst (location_t loc
, tree arg
, tree old0
, tree new0
,
2971 tree old1
, tree new1
)
2973 tree type
= TREE_TYPE (arg
);
2974 enum tree_code code
= TREE_CODE (arg
);
2975 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
2977 /* We can handle some of the tcc_expression cases here. */
2978 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
2980 else if (tclass
== tcc_expression
2981 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2982 tclass
= tcc_binary
;
2987 return fold_build1_loc (loc
, code
, type
,
2988 eval_subst (loc
, TREE_OPERAND (arg
, 0),
2989 old0
, new0
, old1
, new1
));
2992 return fold_build2_loc (loc
, code
, type
,
2993 eval_subst (loc
, TREE_OPERAND (arg
, 0),
2994 old0
, new0
, old1
, new1
),
2995 eval_subst (loc
, TREE_OPERAND (arg
, 1),
2996 old0
, new0
, old1
, new1
));
2998 case tcc_expression
:
3002 return eval_subst (loc
, TREE_OPERAND (arg
, 0), old0
, new0
,
3006 return eval_subst (loc
, TREE_OPERAND (arg
, 1), old0
, new0
,
3010 return fold_build3_loc (loc
, code
, type
,
3011 eval_subst (loc
, TREE_OPERAND (arg
, 0),
3012 old0
, new0
, old1
, new1
),
3013 eval_subst (loc
, TREE_OPERAND (arg
, 1),
3014 old0
, new0
, old1
, new1
),
3015 eval_subst (loc
, TREE_OPERAND (arg
, 2),
3016 old0
, new0
, old1
, new1
));
3020 /* Fall through - ??? */
3022 case tcc_comparison
:
3024 tree arg0
= TREE_OPERAND (arg
, 0);
3025 tree arg1
= TREE_OPERAND (arg
, 1);
3027 /* We need to check both for exact equality and tree equality. The
3028 former will be true if the operand has a side-effect. In that
3029 case, we know the operand occurred exactly once. */
3031 if (arg0
== old0
|| operand_equal_p (arg0
, old0
, 0))
3033 else if (arg0
== old1
|| operand_equal_p (arg0
, old1
, 0))
3036 if (arg1
== old0
|| operand_equal_p (arg1
, old0
, 0))
3038 else if (arg1
== old1
|| operand_equal_p (arg1
, old1
, 0))
3041 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
3049 /* Return a tree for the case when the result of an expression is RESULT
3050 converted to TYPE and OMITTED was previously an operand of the expression
3051 but is now not needed (e.g., we folded OMITTED * 0).
3053 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3054 the conversion of RESULT to TYPE. */
3057 omit_one_operand_loc (location_t loc
, tree type
, tree result
, tree omitted
)
3059 tree t
= fold_convert_loc (loc
, type
, result
);
3061 /* If the resulting operand is an empty statement, just return the omitted
3062 statement casted to void. */
3063 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
3064 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
3065 fold_ignored_result (omitted
));
3067 if (TREE_SIDE_EFFECTS (omitted
))
3068 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3069 fold_ignored_result (omitted
), t
);
3071 return non_lvalue_loc (loc
, t
);
3074 /* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
3077 pedantic_omit_one_operand_loc (location_t loc
, tree type
, tree result
,
3080 tree t
= fold_convert_loc (loc
, type
, result
);
3082 /* If the resulting operand is an empty statement, just return the omitted
3083 statement casted to void. */
3084 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
3085 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
3086 fold_ignored_result (omitted
));
3088 if (TREE_SIDE_EFFECTS (omitted
))
3089 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3090 fold_ignored_result (omitted
), t
);
3092 return pedantic_non_lvalue_loc (loc
, t
);
3095 /* Return a tree for the case when the result of an expression is RESULT
3096 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3097 of the expression but are now not needed.
3099 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3100 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3101 evaluated before OMITTED2. Otherwise, if neither has side effects,
3102 just do the conversion of RESULT to TYPE. */
3105 omit_two_operands_loc (location_t loc
, tree type
, tree result
,
3106 tree omitted1
, tree omitted2
)
3108 tree t
= fold_convert_loc (loc
, type
, result
);
3110 if (TREE_SIDE_EFFECTS (omitted2
))
3111 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted2
, t
);
3112 if (TREE_SIDE_EFFECTS (omitted1
))
3113 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted1
, t
);
3115 return TREE_CODE (t
) != COMPOUND_EXPR
? non_lvalue_loc (loc
, t
) : t
;
3119 /* Return a simplified tree node for the truth-negation of ARG. This
3120 never alters ARG itself. We assume that ARG is an operation that
3121 returns a truth value (0 or 1).
3123 FIXME: one would think we would fold the result, but it causes
3124 problems with the dominator optimizer. */
3127 fold_truth_not_expr (location_t loc
, tree arg
)
3129 tree type
= TREE_TYPE (arg
);
3130 enum tree_code code
= TREE_CODE (arg
);
3131 location_t loc1
, loc2
;
3133 /* If this is a comparison, we can simply invert it, except for
3134 floating-point non-equality comparisons, in which case we just
3135 enclose a TRUTH_NOT_EXPR around what we have. */
3137 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3139 tree op_type
= TREE_TYPE (TREE_OPERAND (arg
, 0));
3140 if (FLOAT_TYPE_P (op_type
)
3141 && flag_trapping_math
3142 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
3143 && code
!= NE_EXPR
&& code
!= EQ_EXPR
)
3146 code
= invert_tree_comparison (code
, HONOR_NANS (TYPE_MODE (op_type
)));
3147 if (code
== ERROR_MARK
)
3150 return build2_loc (loc
, code
, type
, TREE_OPERAND (arg
, 0),
3151 TREE_OPERAND (arg
, 1));
3157 return constant_boolean_node (integer_zerop (arg
), type
);
3159 case TRUTH_AND_EXPR
:
3160 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3161 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3162 return build2_loc (loc
, TRUTH_OR_EXPR
, type
,
3163 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3164 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3167 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3168 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3169 return build2_loc (loc
, TRUTH_AND_EXPR
, type
,
3170 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3171 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3173 case TRUTH_XOR_EXPR
:
3174 /* Here we can invert either operand. We invert the first operand
3175 unless the second operand is a TRUTH_NOT_EXPR in which case our
3176 result is the XOR of the first operand with the inside of the
3177 negation of the second operand. */
3179 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == TRUTH_NOT_EXPR
)
3180 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
, TREE_OPERAND (arg
, 0),
3181 TREE_OPERAND (TREE_OPERAND (arg
, 1), 0));
3183 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
,
3184 invert_truthvalue_loc (loc
, TREE_OPERAND (arg
, 0)),
3185 TREE_OPERAND (arg
, 1));
3187 case TRUTH_ANDIF_EXPR
:
3188 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3189 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3190 return build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
3191 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3192 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3194 case TRUTH_ORIF_EXPR
:
3195 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3196 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3197 return build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
3198 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3199 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3201 case TRUTH_NOT_EXPR
:
3202 return TREE_OPERAND (arg
, 0);
3206 tree arg1
= TREE_OPERAND (arg
, 1);
3207 tree arg2
= TREE_OPERAND (arg
, 2);
3209 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3210 loc2
= expr_location_or (TREE_OPERAND (arg
, 2), loc
);
3212 /* A COND_EXPR may have a throw as one operand, which
3213 then has void type. Just leave void operands
3215 return build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
3216 VOID_TYPE_P (TREE_TYPE (arg1
))
3217 ? arg1
: invert_truthvalue_loc (loc1
, arg1
),
3218 VOID_TYPE_P (TREE_TYPE (arg2
))
3219 ? arg2
: invert_truthvalue_loc (loc2
, arg2
));
3223 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3224 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3225 TREE_OPERAND (arg
, 0),
3226 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 1)));
3228 case NON_LVALUE_EXPR
:
3229 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3230 return invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0));
3233 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
3234 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3236 /* ... fall through ... */
3239 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3240 return build1_loc (loc
, TREE_CODE (arg
), type
,
3241 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3244 if (!integer_onep (TREE_OPERAND (arg
, 1)))
3246 return build2_loc (loc
, EQ_EXPR
, type
, arg
, build_int_cst (type
, 0));
3249 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3251 case CLEANUP_POINT_EXPR
:
3252 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3253 return build1_loc (loc
, CLEANUP_POINT_EXPR
, type
,
3254 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3261 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3262 assume that ARG is an operation that returns a truth value (0 or 1
3263 for scalars, 0 or -1 for vectors). Return the folded expression if
3264 folding is successful. Otherwise, return NULL_TREE. */
3267 fold_invert_truthvalue (location_t loc
, tree arg
)
3269 tree type
= TREE_TYPE (arg
);
3270 return fold_unary_loc (loc
, VECTOR_TYPE_P (type
)
3276 /* Return a simplified tree node for the truth-negation of ARG. This
3277 never alters ARG itself. We assume that ARG is an operation that
3278 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3281 invert_truthvalue_loc (location_t loc
, tree arg
)
3283 if (TREE_CODE (arg
) == ERROR_MARK
)
3286 tree type
= TREE_TYPE (arg
);
3287 return fold_build1_loc (loc
, VECTOR_TYPE_P (type
)
3293 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3294 operands are another bit-wise operation with a common input. If so,
3295 distribute the bit operations to save an operation and possibly two if
3296 constants are involved. For example, convert
3297 (A | B) & (A | C) into A | (B & C)
3298 Further simplification will occur if B and C are constants.
3300 If this optimization cannot be done, 0 will be returned. */
3303 distribute_bit_expr (location_t loc
, enum tree_code code
, tree type
,
3304 tree arg0
, tree arg1
)
3309 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
3310 || TREE_CODE (arg0
) == code
3311 || (TREE_CODE (arg0
) != BIT_AND_EXPR
3312 && TREE_CODE (arg0
) != BIT_IOR_EXPR
))
3315 if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0), 0))
3317 common
= TREE_OPERAND (arg0
, 0);
3318 left
= TREE_OPERAND (arg0
, 1);
3319 right
= TREE_OPERAND (arg1
, 1);
3321 else if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 1), 0))
3323 common
= TREE_OPERAND (arg0
, 0);
3324 left
= TREE_OPERAND (arg0
, 1);
3325 right
= TREE_OPERAND (arg1
, 0);
3327 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 0), 0))
3329 common
= TREE_OPERAND (arg0
, 1);
3330 left
= TREE_OPERAND (arg0
, 0);
3331 right
= TREE_OPERAND (arg1
, 1);
3333 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 1), 0))
3335 common
= TREE_OPERAND (arg0
, 1);
3336 left
= TREE_OPERAND (arg0
, 0);
3337 right
= TREE_OPERAND (arg1
, 0);
3342 common
= fold_convert_loc (loc
, type
, common
);
3343 left
= fold_convert_loc (loc
, type
, left
);
3344 right
= fold_convert_loc (loc
, type
, right
);
3345 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, common
,
3346 fold_build2_loc (loc
, code
, type
, left
, right
));
3349 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3350 with code CODE. This optimization is unsafe. */
3352 distribute_real_division (location_t loc
, enum tree_code code
, tree type
,
3353 tree arg0
, tree arg1
)
3355 bool mul0
= TREE_CODE (arg0
) == MULT_EXPR
;
3356 bool mul1
= TREE_CODE (arg1
) == MULT_EXPR
;
3358 /* (A / C) +- (B / C) -> (A +- B) / C. */
3360 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3361 TREE_OPERAND (arg1
, 1), 0))
3362 return fold_build2_loc (loc
, mul0
? MULT_EXPR
: RDIV_EXPR
, type
,
3363 fold_build2_loc (loc
, code
, type
,
3364 TREE_OPERAND (arg0
, 0),
3365 TREE_OPERAND (arg1
, 0)),
3366 TREE_OPERAND (arg0
, 1));
3368 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3369 if (operand_equal_p (TREE_OPERAND (arg0
, 0),
3370 TREE_OPERAND (arg1
, 0), 0)
3371 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
3372 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
3374 REAL_VALUE_TYPE r0
, r1
;
3375 r0
= TREE_REAL_CST (TREE_OPERAND (arg0
, 1));
3376 r1
= TREE_REAL_CST (TREE_OPERAND (arg1
, 1));
3378 real_arithmetic (&r0
, RDIV_EXPR
, &dconst1
, &r0
);
3380 real_arithmetic (&r1
, RDIV_EXPR
, &dconst1
, &r1
);
3381 real_arithmetic (&r0
, code
, &r0
, &r1
);
3382 return fold_build2_loc (loc
, MULT_EXPR
, type
,
3383 TREE_OPERAND (arg0
, 0),
3384 build_real (type
, r0
));
3390 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3391 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
3394 make_bit_field_ref (location_t loc
, tree inner
, tree type
,
3395 HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
, int unsignedp
)
3397 tree result
, bftype
;
3401 tree size
= TYPE_SIZE (TREE_TYPE (inner
));
3402 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner
))
3403 || POINTER_TYPE_P (TREE_TYPE (inner
)))
3404 && tree_fits_shwi_p (size
)
3405 && tree_to_shwi (size
) == bitsize
)
3406 return fold_convert_loc (loc
, type
, inner
);
3410 if (TYPE_PRECISION (bftype
) != bitsize
3411 || TYPE_UNSIGNED (bftype
) == !unsignedp
)
3412 bftype
= build_nonstandard_integer_type (bitsize
, 0);
3414 result
= build3_loc (loc
, BIT_FIELD_REF
, bftype
, inner
,
3415 size_int (bitsize
), bitsize_int (bitpos
));
3418 result
= fold_convert_loc (loc
, type
, result
);
3423 /* Optimize a bit-field compare.
3425 There are two cases: First is a compare against a constant and the
3426 second is a comparison of two items where the fields are at the same
3427 bit position relative to the start of a chunk (byte, halfword, word)
3428 large enough to contain it. In these cases we can avoid the shift
3429 implicit in bitfield extractions.
3431 For constants, we emit a compare of the shifted constant with the
3432 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3433 compared. For two fields at the same position, we do the ANDs with the
3434 similar mask and compare the result of the ANDs.
3436 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3437 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3438 are the left and right operands of the comparison, respectively.
3440 If the optimization described above can be done, we return the resulting
3441 tree. Otherwise we return zero. */
3444 optimize_bit_field_compare (location_t loc
, enum tree_code code
,
3445 tree compare_type
, tree lhs
, tree rhs
)
3447 HOST_WIDE_INT lbitpos
, lbitsize
, rbitpos
, rbitsize
, nbitpos
, nbitsize
;
3448 tree type
= TREE_TYPE (lhs
);
3450 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
3451 enum machine_mode lmode
, rmode
, nmode
;
3452 int lunsignedp
, runsignedp
;
3453 int lvolatilep
= 0, rvolatilep
= 0;
3454 tree linner
, rinner
= NULL_TREE
;
3458 /* Get all the information about the extractions being done. If the bit size
3459 if the same as the size of the underlying object, we aren't doing an
3460 extraction at all and so can do nothing. We also don't want to
3461 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3462 then will no longer be able to replace it. */
3463 linner
= get_inner_reference (lhs
, &lbitsize
, &lbitpos
, &offset
, &lmode
,
3464 &lunsignedp
, &lvolatilep
, false);
3465 if (linner
== lhs
|| lbitsize
== GET_MODE_BITSIZE (lmode
) || lbitsize
< 0
3466 || offset
!= 0 || TREE_CODE (linner
) == PLACEHOLDER_EXPR
|| lvolatilep
)
3471 /* If this is not a constant, we can only do something if bit positions,
3472 sizes, and signedness are the same. */
3473 rinner
= get_inner_reference (rhs
, &rbitsize
, &rbitpos
, &offset
, &rmode
,
3474 &runsignedp
, &rvolatilep
, false);
3476 if (rinner
== rhs
|| lbitpos
!= rbitpos
|| lbitsize
!= rbitsize
3477 || lunsignedp
!= runsignedp
|| offset
!= 0
3478 || TREE_CODE (rinner
) == PLACEHOLDER_EXPR
|| rvolatilep
)
3482 /* See if we can find a mode to refer to this field. We should be able to,
3483 but fail if we can't. */
3484 nmode
= get_best_mode (lbitsize
, lbitpos
, 0, 0,
3485 const_p
? TYPE_ALIGN (TREE_TYPE (linner
))
3486 : MIN (TYPE_ALIGN (TREE_TYPE (linner
)),
3487 TYPE_ALIGN (TREE_TYPE (rinner
))),
3489 if (nmode
== VOIDmode
)
3492 /* Set signed and unsigned types of the precision of this mode for the
3494 unsigned_type
= lang_hooks
.types
.type_for_mode (nmode
, 1);
3496 /* Compute the bit position and size for the new reference and our offset
3497 within it. If the new reference is the same size as the original, we
3498 won't optimize anything, so return zero. */
3499 nbitsize
= GET_MODE_BITSIZE (nmode
);
3500 nbitpos
= lbitpos
& ~ (nbitsize
- 1);
3502 if (nbitsize
== lbitsize
)
3505 if (BYTES_BIG_ENDIAN
)
3506 lbitpos
= nbitsize
- lbitsize
- lbitpos
;
3508 /* Make the mask to be used against the extracted field. */
3509 mask
= build_int_cst_type (unsigned_type
, -1);
3510 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (nbitsize
- lbitsize
));
3511 mask
= const_binop (RSHIFT_EXPR
, mask
,
3512 size_int (nbitsize
- lbitsize
- lbitpos
));
3515 /* If not comparing with constant, just rework the comparison
3517 return fold_build2_loc (loc
, code
, compare_type
,
3518 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3519 make_bit_field_ref (loc
, linner
,
3524 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3525 make_bit_field_ref (loc
, rinner
,
3531 /* Otherwise, we are handling the constant case. See if the constant is too
3532 big for the field. Warn and return a tree of for 0 (false) if so. We do
3533 this not only for its own sake, but to avoid having to test for this
3534 error case below. If we didn't, we might generate wrong code.
3536 For unsigned fields, the constant shifted right by the field length should
3537 be all zero. For signed fields, the high-order bits should agree with
3542 if (wi::lrshift (rhs
, lbitsize
) != 0)
3544 warning (0, "comparison is always %d due to width of bit-field",
3546 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3551 wide_int tem
= wi::arshift (rhs
, lbitsize
- 1);
3552 if (tem
!= 0 && tem
!= -1)
3554 warning (0, "comparison is always %d due to width of bit-field",
3556 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3560 /* Single-bit compares should always be against zero. */
3561 if (lbitsize
== 1 && ! integer_zerop (rhs
))
3563 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
3564 rhs
= build_int_cst (type
, 0);
3567 /* Make a new bitfield reference, shift the constant over the
3568 appropriate number of bits and mask it with the computed mask
3569 (in case this was a signed field). If we changed it, make a new one. */
3570 lhs
= make_bit_field_ref (loc
, linner
, unsigned_type
, nbitsize
, nbitpos
, 1);
3572 rhs
= const_binop (BIT_AND_EXPR
,
3573 const_binop (LSHIFT_EXPR
,
3574 fold_convert_loc (loc
, unsigned_type
, rhs
),
3575 size_int (lbitpos
)),
3578 lhs
= build2_loc (loc
, code
, compare_type
,
3579 build2 (BIT_AND_EXPR
, unsigned_type
, lhs
, mask
), rhs
);
3583 /* Subroutine for fold_truth_andor_1: decode a field reference.
3585 If EXP is a comparison reference, we return the innermost reference.
3587 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3588 set to the starting bit number.
3590 If the innermost field can be completely contained in a mode-sized
3591 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
3593 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3594 otherwise it is not changed.
3596 *PUNSIGNEDP is set to the signedness of the field.
3598 *PMASK is set to the mask used. This is either contained in a
3599 BIT_AND_EXPR or derived from the width of the field.
3601 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3603 Return 0 if this is not a component reference or is one that we can't
3604 do anything with. */
3607 decode_field_reference (location_t loc
, tree exp
, HOST_WIDE_INT
*pbitsize
,
3608 HOST_WIDE_INT
*pbitpos
, enum machine_mode
*pmode
,
3609 int *punsignedp
, int *pvolatilep
,
3610 tree
*pmask
, tree
*pand_mask
)
3612 tree outer_type
= 0;
3614 tree mask
, inner
, offset
;
3616 unsigned int precision
;
3618 /* All the optimizations using this function assume integer fields.
3619 There are problems with FP fields since the type_for_size call
3620 below can fail for, e.g., XFmode. */
3621 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp
)))
3624 /* We are interested in the bare arrangement of bits, so strip everything
3625 that doesn't affect the machine mode. However, record the type of the
3626 outermost expression if it may matter below. */
3627 if (CONVERT_EXPR_P (exp
)
3628 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
3629 outer_type
= TREE_TYPE (exp
);
3632 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
3634 and_mask
= TREE_OPERAND (exp
, 1);
3635 exp
= TREE_OPERAND (exp
, 0);
3636 STRIP_NOPS (exp
); STRIP_NOPS (and_mask
);
3637 if (TREE_CODE (and_mask
) != INTEGER_CST
)
3641 inner
= get_inner_reference (exp
, pbitsize
, pbitpos
, &offset
, pmode
,
3642 punsignedp
, pvolatilep
, false);
3643 if ((inner
== exp
&& and_mask
== 0)
3644 || *pbitsize
< 0 || offset
!= 0
3645 || TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3648 /* If the number of bits in the reference is the same as the bitsize of
3649 the outer type, then the outer type gives the signedness. Otherwise
3650 (in case of a small bitfield) the signedness is unchanged. */
3651 if (outer_type
&& *pbitsize
== TYPE_PRECISION (outer_type
))
3652 *punsignedp
= TYPE_UNSIGNED (outer_type
);
3654 /* Compute the mask to access the bitfield. */
3655 unsigned_type
= lang_hooks
.types
.type_for_size (*pbitsize
, 1);
3656 precision
= TYPE_PRECISION (unsigned_type
);
3658 mask
= build_int_cst_type (unsigned_type
, -1);
3660 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
3661 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
3663 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
3665 mask
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3666 fold_convert_loc (loc
, unsigned_type
, and_mask
), mask
);
3669 *pand_mask
= and_mask
;
3673 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3674 bit positions and MASK is SIGNED. */
3677 all_ones_mask_p (const_tree mask
, unsigned int size
)
3679 tree type
= TREE_TYPE (mask
);
3680 unsigned int precision
= TYPE_PRECISION (type
);
3682 /* If this function returns true when the type of the mask is
3683 UNSIGNED, then there will be errors. In particular see
3684 gcc.c-torture/execute/990326-1.c. There does not appear to be
3685 any documentation paper trail as to why this is so. But the pre
3686 wide-int worked with that restriction and it has been preserved
3688 if (size
> precision
|| TYPE_SIGN (type
) == UNSIGNED
)
3691 return wi::mask (size
, false, precision
) == mask
;
3694 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3695 represents the sign bit of EXP's type. If EXP represents a sign
3696 or zero extension, also test VAL against the unextended type.
3697 The return value is the (sub)expression whose sign bit is VAL,
3698 or NULL_TREE otherwise. */
3701 sign_bit_p (tree exp
, const_tree val
)
3706 /* Tree EXP must have an integral type. */
3707 t
= TREE_TYPE (exp
);
3708 if (! INTEGRAL_TYPE_P (t
))
3711 /* Tree VAL must be an integer constant. */
3712 if (TREE_CODE (val
) != INTEGER_CST
3713 || TREE_OVERFLOW (val
))
3716 width
= TYPE_PRECISION (t
);
3717 if (wi::only_sign_bit_p (val
, width
))
3720 /* Handle extension from a narrower type. */
3721 if (TREE_CODE (exp
) == NOP_EXPR
3722 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))) < width
)
3723 return sign_bit_p (TREE_OPERAND (exp
, 0), val
);
3728 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
3729 to be evaluated unconditionally. */
3732 simple_operand_p (const_tree exp
)
3734 /* Strip any conversions that don't change the machine mode. */
3737 return (CONSTANT_CLASS_P (exp
)
3738 || TREE_CODE (exp
) == SSA_NAME
3740 && ! TREE_ADDRESSABLE (exp
)
3741 && ! TREE_THIS_VOLATILE (exp
)
3742 && ! DECL_NONLOCAL (exp
)
3743 /* Don't regard global variables as simple. They may be
3744 allocated in ways unknown to the compiler (shared memory,
3745 #pragma weak, etc). */
3746 && ! TREE_PUBLIC (exp
)
3747 && ! DECL_EXTERNAL (exp
)
3748 /* Weakrefs are not safe to be read, since they can be NULL.
3749 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
3750 have DECL_WEAK flag set. */
3751 && (! VAR_OR_FUNCTION_DECL_P (exp
) || ! DECL_WEAK (exp
))
3752 /* Loading a static variable is unduly expensive, but global
3753 registers aren't expensive. */
3754 && (! TREE_STATIC (exp
) || DECL_REGISTER (exp
))));
3757 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
3758 to be evaluated unconditionally.
3759 I addition to simple_operand_p, we assume that comparisons, conversions,
3760 and logic-not operations are simple, if their operands are simple, too. */
3763 simple_operand_p_2 (tree exp
)
3765 enum tree_code code
;
3767 if (TREE_SIDE_EFFECTS (exp
)
3768 || tree_could_trap_p (exp
))
3771 while (CONVERT_EXPR_P (exp
))
3772 exp
= TREE_OPERAND (exp
, 0);
3774 code
= TREE_CODE (exp
);
3776 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3777 return (simple_operand_p (TREE_OPERAND (exp
, 0))
3778 && simple_operand_p (TREE_OPERAND (exp
, 1)));
3780 if (code
== TRUTH_NOT_EXPR
)
3781 return simple_operand_p_2 (TREE_OPERAND (exp
, 0));
3783 return simple_operand_p (exp
);
3787 /* The following functions are subroutines to fold_range_test and allow it to
3788 try to change a logical combination of comparisons into a range test.
3791 X == 2 || X == 3 || X == 4 || X == 5
3795 (unsigned) (X - 2) <= 3
3797 We describe each set of comparisons as being either inside or outside
3798 a range, using a variable named like IN_P, and then describe the
3799 range with a lower and upper bound. If one of the bounds is omitted,
3800 it represents either the highest or lowest value of the type.
3802 In the comments below, we represent a range by two numbers in brackets
3803 preceded by a "+" to designate being inside that range, or a "-" to
3804 designate being outside that range, so the condition can be inverted by
3805 flipping the prefix. An omitted bound is represented by a "-". For
3806 example, "- [-, 10]" means being outside the range starting at the lowest
3807 possible value and ending at 10, in other words, being greater than 10.
3808 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3811 We set up things so that the missing bounds are handled in a consistent
3812 manner so neither a missing bound nor "true" and "false" need to be
3813 handled using a special case. */
3815 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3816 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3817 and UPPER1_P are nonzero if the respective argument is an upper bound
3818 and zero for a lower. TYPE, if nonzero, is the type of the result; it
3819 must be specified for a comparison. ARG1 will be converted to ARG0's
3820 type if both are specified. */
3823 range_binop (enum tree_code code
, tree type
, tree arg0
, int upper0_p
,
3824 tree arg1
, int upper1_p
)
3830 /* If neither arg represents infinity, do the normal operation.
3831 Else, if not a comparison, return infinity. Else handle the special
3832 comparison rules. Note that most of the cases below won't occur, but
3833 are handled for consistency. */
3835 if (arg0
!= 0 && arg1
!= 0)
3837 tem
= fold_build2 (code
, type
!= 0 ? type
: TREE_TYPE (arg0
),
3838 arg0
, fold_convert (TREE_TYPE (arg0
), arg1
));
3840 return TREE_CODE (tem
) == INTEGER_CST
? tem
: 0;
3843 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
3846 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3847 for neither. In real maths, we cannot assume open ended ranges are
3848 the same. But, this is computer arithmetic, where numbers are finite.
3849 We can therefore make the transformation of any unbounded range with
3850 the value Z, Z being greater than any representable number. This permits
3851 us to treat unbounded ranges as equal. */
3852 sgn0
= arg0
!= 0 ? 0 : (upper0_p
? 1 : -1);
3853 sgn1
= arg1
!= 0 ? 0 : (upper1_p
? 1 : -1);
3857 result
= sgn0
== sgn1
;
3860 result
= sgn0
!= sgn1
;
3863 result
= sgn0
< sgn1
;
3866 result
= sgn0
<= sgn1
;
3869 result
= sgn0
> sgn1
;
3872 result
= sgn0
>= sgn1
;
3878 return constant_boolean_node (result
, type
);
3881 /* Helper routine for make_range. Perform one step for it, return
3882 new expression if the loop should continue or NULL_TREE if it should
3886 make_range_step (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
,
3887 tree exp_type
, tree
*p_low
, tree
*p_high
, int *p_in_p
,
3888 bool *strict_overflow_p
)
3890 tree arg0_type
= TREE_TYPE (arg0
);
3891 tree n_low
, n_high
, low
= *p_low
, high
= *p_high
;
3892 int in_p
= *p_in_p
, n_in_p
;
3896 case TRUTH_NOT_EXPR
:
3897 /* We can only do something if the range is testing for zero. */
3898 if (low
== NULL_TREE
|| high
== NULL_TREE
3899 || ! integer_zerop (low
) || ! integer_zerop (high
))
3904 case EQ_EXPR
: case NE_EXPR
:
3905 case LT_EXPR
: case LE_EXPR
: case GE_EXPR
: case GT_EXPR
:
3906 /* We can only do something if the range is testing for zero
3907 and if the second operand is an integer constant. Note that
3908 saying something is "in" the range we make is done by
3909 complementing IN_P since it will set in the initial case of
3910 being not equal to zero; "out" is leaving it alone. */
3911 if (low
== NULL_TREE
|| high
== NULL_TREE
3912 || ! integer_zerop (low
) || ! integer_zerop (high
)
3913 || TREE_CODE (arg1
) != INTEGER_CST
)
3918 case NE_EXPR
: /* - [c, c] */
3921 case EQ_EXPR
: /* + [c, c] */
3922 in_p
= ! in_p
, low
= high
= arg1
;
3924 case GT_EXPR
: /* - [-, c] */
3925 low
= 0, high
= arg1
;
3927 case GE_EXPR
: /* + [c, -] */
3928 in_p
= ! in_p
, low
= arg1
, high
= 0;
3930 case LT_EXPR
: /* - [c, -] */
3931 low
= arg1
, high
= 0;
3933 case LE_EXPR
: /* + [-, c] */
3934 in_p
= ! in_p
, low
= 0, high
= arg1
;
3940 /* If this is an unsigned comparison, we also know that EXP is
3941 greater than or equal to zero. We base the range tests we make
3942 on that fact, so we record it here so we can parse existing
3943 range tests. We test arg0_type since often the return type
3944 of, e.g. EQ_EXPR, is boolean. */
3945 if (TYPE_UNSIGNED (arg0_type
) && (low
== 0 || high
== 0))
3947 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
3949 build_int_cst (arg0_type
, 0),
3953 in_p
= n_in_p
, low
= n_low
, high
= n_high
;
3955 /* If the high bound is missing, but we have a nonzero low
3956 bound, reverse the range so it goes from zero to the low bound
3958 if (high
== 0 && low
&& ! integer_zerop (low
))
3961 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low
, 0,
3962 build_int_cst (TREE_TYPE (low
), 1), 0);
3963 low
= build_int_cst (arg0_type
, 0);
3973 /* If flag_wrapv and ARG0_TYPE is signed, make sure
3974 low and high are non-NULL, then normalize will DTRT. */
3975 if (!TYPE_UNSIGNED (arg0_type
)
3976 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
3978 if (low
== NULL_TREE
)
3979 low
= TYPE_MIN_VALUE (arg0_type
);
3980 if (high
== NULL_TREE
)
3981 high
= TYPE_MAX_VALUE (arg0_type
);
3984 /* (-x) IN [a,b] -> x in [-b, -a] */
3985 n_low
= range_binop (MINUS_EXPR
, exp_type
,
3986 build_int_cst (exp_type
, 0),
3988 n_high
= range_binop (MINUS_EXPR
, exp_type
,
3989 build_int_cst (exp_type
, 0),
3991 if (n_high
!= 0 && TREE_OVERFLOW (n_high
))
3997 return build2_loc (loc
, MINUS_EXPR
, exp_type
, negate_expr (arg0
),
3998 build_int_cst (exp_type
, 1));
4002 if (TREE_CODE (arg1
) != INTEGER_CST
)
4005 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4006 move a constant to the other side. */
4007 if (!TYPE_UNSIGNED (arg0_type
)
4008 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4011 /* If EXP is signed, any overflow in the computation is undefined,
4012 so we don't worry about it so long as our computations on
4013 the bounds don't overflow. For unsigned, overflow is defined
4014 and this is exactly the right thing. */
4015 n_low
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4016 arg0_type
, low
, 0, arg1
, 0);
4017 n_high
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
4018 arg0_type
, high
, 1, arg1
, 0);
4019 if ((n_low
!= 0 && TREE_OVERFLOW (n_low
))
4020 || (n_high
!= 0 && TREE_OVERFLOW (n_high
)))
4023 if (TYPE_OVERFLOW_UNDEFINED (arg0_type
))
4024 *strict_overflow_p
= true;
4027 /* Check for an unsigned range which has wrapped around the maximum
4028 value thus making n_high < n_low, and normalize it. */
4029 if (n_low
&& n_high
&& tree_int_cst_lt (n_high
, n_low
))
4031 low
= range_binop (PLUS_EXPR
, arg0_type
, n_high
, 0,
4032 build_int_cst (TREE_TYPE (n_high
), 1), 0);
4033 high
= range_binop (MINUS_EXPR
, arg0_type
, n_low
, 0,
4034 build_int_cst (TREE_TYPE (n_low
), 1), 0);
4036 /* If the range is of the form +/- [ x+1, x ], we won't
4037 be able to normalize it. But then, it represents the
4038 whole range or the empty set, so make it
4040 if (tree_int_cst_equal (n_low
, low
)
4041 && tree_int_cst_equal (n_high
, high
))
4047 low
= n_low
, high
= n_high
;
4055 case NON_LVALUE_EXPR
:
4056 if (TYPE_PRECISION (arg0_type
) > TYPE_PRECISION (exp_type
))
4059 if (! INTEGRAL_TYPE_P (arg0_type
)
4060 || (low
!= 0 && ! int_fits_type_p (low
, arg0_type
))
4061 || (high
!= 0 && ! int_fits_type_p (high
, arg0_type
)))
4064 n_low
= low
, n_high
= high
;
4067 n_low
= fold_convert_loc (loc
, arg0_type
, n_low
);
4070 n_high
= fold_convert_loc (loc
, arg0_type
, n_high
);
4072 /* If we're converting arg0 from an unsigned type, to exp,
4073 a signed type, we will be doing the comparison as unsigned.
4074 The tests above have already verified that LOW and HIGH
4077 So we have to ensure that we will handle large unsigned
4078 values the same way that the current signed bounds treat
4081 if (!TYPE_UNSIGNED (exp_type
) && TYPE_UNSIGNED (arg0_type
))
4085 /* For fixed-point modes, we need to pass the saturating flag
4086 as the 2nd parameter. */
4087 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type
)))
4089 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
),
4090 TYPE_SATURATING (arg0_type
));
4093 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
), 1);
4095 /* A range without an upper bound is, naturally, unbounded.
4096 Since convert would have cropped a very large value, use
4097 the max value for the destination type. */
4099 = TYPE_MAX_VALUE (equiv_type
) ? TYPE_MAX_VALUE (equiv_type
)
4100 : TYPE_MAX_VALUE (arg0_type
);
4102 if (TYPE_PRECISION (exp_type
) == TYPE_PRECISION (arg0_type
))
4103 high_positive
= fold_build2_loc (loc
, RSHIFT_EXPR
, arg0_type
,
4104 fold_convert_loc (loc
, arg0_type
,
4106 build_int_cst (arg0_type
, 1));
4108 /* If the low bound is specified, "and" the range with the
4109 range for which the original unsigned value will be
4113 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 1, n_low
, n_high
,
4114 1, fold_convert_loc (loc
, arg0_type
,
4119 in_p
= (n_in_p
== in_p
);
4123 /* Otherwise, "or" the range with the range of the input
4124 that will be interpreted as negative. */
4125 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 0, n_low
, n_high
,
4126 1, fold_convert_loc (loc
, arg0_type
,
4131 in_p
= (in_p
!= n_in_p
);
4145 /* Given EXP, a logical expression, set the range it is testing into
4146 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4147 actually being tested. *PLOW and *PHIGH will be made of the same
4148 type as the returned expression. If EXP is not a comparison, we
4149 will most likely not be returning a useful value and range. Set
4150 *STRICT_OVERFLOW_P to true if the return value is only valid
4151 because signed overflow is undefined; otherwise, do not change
4152 *STRICT_OVERFLOW_P. */
4155 make_range (tree exp
, int *pin_p
, tree
*plow
, tree
*phigh
,
4156 bool *strict_overflow_p
)
4158 enum tree_code code
;
4159 tree arg0
, arg1
= NULL_TREE
;
4160 tree exp_type
, nexp
;
4163 location_t loc
= EXPR_LOCATION (exp
);
4165 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4166 and see if we can refine the range. Some of the cases below may not
4167 happen, but it doesn't seem worth worrying about this. We "continue"
4168 the outer loop when we've changed something; otherwise we "break"
4169 the switch, which will "break" the while. */
4172 low
= high
= build_int_cst (TREE_TYPE (exp
), 0);
4176 code
= TREE_CODE (exp
);
4177 exp_type
= TREE_TYPE (exp
);
4180 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
4182 if (TREE_OPERAND_LENGTH (exp
) > 0)
4183 arg0
= TREE_OPERAND (exp
, 0);
4184 if (TREE_CODE_CLASS (code
) == tcc_binary
4185 || TREE_CODE_CLASS (code
) == tcc_comparison
4186 || (TREE_CODE_CLASS (code
) == tcc_expression
4187 && TREE_OPERAND_LENGTH (exp
) > 1))
4188 arg1
= TREE_OPERAND (exp
, 1);
4190 if (arg0
== NULL_TREE
)
4193 nexp
= make_range_step (loc
, code
, arg0
, arg1
, exp_type
, &low
,
4194 &high
, &in_p
, strict_overflow_p
);
4195 if (nexp
== NULL_TREE
)
4200 /* If EXP is a constant, we can evaluate whether this is true or false. */
4201 if (TREE_CODE (exp
) == INTEGER_CST
)
4203 in_p
= in_p
== (integer_onep (range_binop (GE_EXPR
, integer_type_node
,
4205 && integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4211 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4215 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4216 type, TYPE, return an expression to test if EXP is in (or out of, depending
4217 on IN_P) the range. Return 0 if the test couldn't be created. */
4220 build_range_check (location_t loc
, tree type
, tree exp
, int in_p
,
4221 tree low
, tree high
)
4223 tree etype
= TREE_TYPE (exp
), value
;
4225 #ifdef HAVE_canonicalize_funcptr_for_compare
4226 /* Disable this optimization for function pointer expressions
4227 on targets that require function pointer canonicalization. */
4228 if (HAVE_canonicalize_funcptr_for_compare
4229 && TREE_CODE (etype
) == POINTER_TYPE
4230 && TREE_CODE (TREE_TYPE (etype
)) == FUNCTION_TYPE
)
4236 value
= build_range_check (loc
, type
, exp
, 1, low
, high
);
4238 return invert_truthvalue_loc (loc
, value
);
4243 if (low
== 0 && high
== 0)
4244 return omit_one_operand_loc (loc
, type
, build_int_cst (type
, 1), exp
);
4247 return fold_build2_loc (loc
, LE_EXPR
, type
, exp
,
4248 fold_convert_loc (loc
, etype
, high
));
4251 return fold_build2_loc (loc
, GE_EXPR
, type
, exp
,
4252 fold_convert_loc (loc
, etype
, low
));
4254 if (operand_equal_p (low
, high
, 0))
4255 return fold_build2_loc (loc
, EQ_EXPR
, type
, exp
,
4256 fold_convert_loc (loc
, etype
, low
));
4258 if (integer_zerop (low
))
4260 if (! TYPE_UNSIGNED (etype
))
4262 etype
= unsigned_type_for (etype
);
4263 high
= fold_convert_loc (loc
, etype
, high
);
4264 exp
= fold_convert_loc (loc
, etype
, exp
);
4266 return build_range_check (loc
, type
, exp
, 1, 0, high
);
4269 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4270 if (integer_onep (low
) && TREE_CODE (high
) == INTEGER_CST
)
4272 int prec
= TYPE_PRECISION (etype
);
4274 if (wi::mask (prec
- 1, false, prec
) == high
)
4276 if (TYPE_UNSIGNED (etype
))
4278 tree signed_etype
= signed_type_for (etype
);
4279 if (TYPE_PRECISION (signed_etype
) != TYPE_PRECISION (etype
))
4281 = build_nonstandard_integer_type (TYPE_PRECISION (etype
), 0);
4283 etype
= signed_etype
;
4284 exp
= fold_convert_loc (loc
, etype
, exp
);
4286 return fold_build2_loc (loc
, GT_EXPR
, type
, exp
,
4287 build_int_cst (etype
, 0));
4291 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4292 This requires wrap-around arithmetics for the type of the expression.
4293 First make sure that arithmetics in this type is valid, then make sure
4294 that it wraps around. */
4295 if (TREE_CODE (etype
) == ENUMERAL_TYPE
|| TREE_CODE (etype
) == BOOLEAN_TYPE
)
4296 etype
= lang_hooks
.types
.type_for_size (TYPE_PRECISION (etype
),
4297 TYPE_UNSIGNED (etype
));
4299 if (TREE_CODE (etype
) == INTEGER_TYPE
&& !TYPE_OVERFLOW_WRAPS (etype
))
4301 tree utype
, minv
, maxv
;
4303 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4304 for the type in question, as we rely on this here. */
4305 utype
= unsigned_type_for (etype
);
4306 maxv
= fold_convert_loc (loc
, utype
, TYPE_MAX_VALUE (etype
));
4307 maxv
= range_binop (PLUS_EXPR
, NULL_TREE
, maxv
, 1,
4308 build_int_cst (TREE_TYPE (maxv
), 1), 1);
4309 minv
= fold_convert_loc (loc
, utype
, TYPE_MIN_VALUE (etype
));
4311 if (integer_zerop (range_binop (NE_EXPR
, integer_type_node
,
4318 high
= fold_convert_loc (loc
, etype
, high
);
4319 low
= fold_convert_loc (loc
, etype
, low
);
4320 exp
= fold_convert_loc (loc
, etype
, exp
);
4322 value
= const_binop (MINUS_EXPR
, high
, low
);
4325 if (POINTER_TYPE_P (etype
))
4327 if (value
!= 0 && !TREE_OVERFLOW (value
))
4329 low
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (low
), low
);
4330 return build_range_check (loc
, type
,
4331 fold_build_pointer_plus_loc (loc
, exp
, low
),
4332 1, build_int_cst (etype
, 0), value
);
4337 if (value
!= 0 && !TREE_OVERFLOW (value
))
4338 return build_range_check (loc
, type
,
4339 fold_build2_loc (loc
, MINUS_EXPR
, etype
, exp
, low
),
4340 1, build_int_cst (etype
, 0), value
);
4345 /* Return the predecessor of VAL in its type, handling the infinite case. */
4348 range_predecessor (tree val
)
4350 tree type
= TREE_TYPE (val
);
4352 if (INTEGRAL_TYPE_P (type
)
4353 && operand_equal_p (val
, TYPE_MIN_VALUE (type
), 0))
4356 return range_binop (MINUS_EXPR
, NULL_TREE
, val
, 0,
4357 build_int_cst (TREE_TYPE (val
), 1), 0);
4360 /* Return the successor of VAL in its type, handling the infinite case. */
4363 range_successor (tree val
)
4365 tree type
= TREE_TYPE (val
);
4367 if (INTEGRAL_TYPE_P (type
)
4368 && operand_equal_p (val
, TYPE_MAX_VALUE (type
), 0))
4371 return range_binop (PLUS_EXPR
, NULL_TREE
, val
, 0,
4372 build_int_cst (TREE_TYPE (val
), 1), 0);
4375 /* Given two ranges, see if we can merge them into one. Return 1 if we
4376 can, 0 if we can't. Set the output range into the specified parameters. */
4379 merge_ranges (int *pin_p
, tree
*plow
, tree
*phigh
, int in0_p
, tree low0
,
4380 tree high0
, int in1_p
, tree low1
, tree high1
)
4388 int lowequal
= ((low0
== 0 && low1
== 0)
4389 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4390 low0
, 0, low1
, 0)));
4391 int highequal
= ((high0
== 0 && high1
== 0)
4392 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4393 high0
, 1, high1
, 1)));
4395 /* Make range 0 be the range that starts first, or ends last if they
4396 start at the same value. Swap them if it isn't. */
4397 if (integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4400 && integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4401 high1
, 1, high0
, 1))))
4403 temp
= in0_p
, in0_p
= in1_p
, in1_p
= temp
;
4404 tem
= low0
, low0
= low1
, low1
= tem
;
4405 tem
= high0
, high0
= high1
, high1
= tem
;
4408 /* Now flag two cases, whether the ranges are disjoint or whether the
4409 second range is totally subsumed in the first. Note that the tests
4410 below are simplified by the ones above. */
4411 no_overlap
= integer_onep (range_binop (LT_EXPR
, integer_type_node
,
4412 high0
, 1, low1
, 0));
4413 subset
= integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4414 high1
, 1, high0
, 1));
4416 /* We now have four cases, depending on whether we are including or
4417 excluding the two ranges. */
4420 /* If they don't overlap, the result is false. If the second range
4421 is a subset it is the result. Otherwise, the range is from the start
4422 of the second to the end of the first. */
4424 in_p
= 0, low
= high
= 0;
4426 in_p
= 1, low
= low1
, high
= high1
;
4428 in_p
= 1, low
= low1
, high
= high0
;
4431 else if (in0_p
&& ! in1_p
)
4433 /* If they don't overlap, the result is the first range. If they are
4434 equal, the result is false. If the second range is a subset of the
4435 first, and the ranges begin at the same place, we go from just after
4436 the end of the second range to the end of the first. If the second
4437 range is not a subset of the first, or if it is a subset and both
4438 ranges end at the same place, the range starts at the start of the
4439 first range and ends just before the second range.
4440 Otherwise, we can't describe this as a single range. */
4442 in_p
= 1, low
= low0
, high
= high0
;
4443 else if (lowequal
&& highequal
)
4444 in_p
= 0, low
= high
= 0;
4445 else if (subset
&& lowequal
)
4447 low
= range_successor (high1
);
4452 /* We are in the weird situation where high0 > high1 but
4453 high1 has no successor. Punt. */
4457 else if (! subset
|| highequal
)
4460 high
= range_predecessor (low1
);
4464 /* low0 < low1 but low1 has no predecessor. Punt. */
4472 else if (! in0_p
&& in1_p
)
4474 /* If they don't overlap, the result is the second range. If the second
4475 is a subset of the first, the result is false. Otherwise,
4476 the range starts just after the first range and ends at the
4477 end of the second. */
4479 in_p
= 1, low
= low1
, high
= high1
;
4480 else if (subset
|| highequal
)
4481 in_p
= 0, low
= high
= 0;
4484 low
= range_successor (high0
);
4489 /* high1 > high0 but high0 has no successor. Punt. */
4497 /* The case where we are excluding both ranges. Here the complex case
4498 is if they don't overlap. In that case, the only time we have a
4499 range is if they are adjacent. If the second is a subset of the
4500 first, the result is the first. Otherwise, the range to exclude
4501 starts at the beginning of the first range and ends at the end of the
4505 if (integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4506 range_successor (high0
),
4508 in_p
= 0, low
= low0
, high
= high1
;
4511 /* Canonicalize - [min, x] into - [-, x]. */
4512 if (low0
&& TREE_CODE (low0
) == INTEGER_CST
)
4513 switch (TREE_CODE (TREE_TYPE (low0
)))
4516 if (TYPE_PRECISION (TREE_TYPE (low0
))
4517 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0
))))
4521 if (tree_int_cst_equal (low0
,
4522 TYPE_MIN_VALUE (TREE_TYPE (low0
))))
4526 if (TYPE_UNSIGNED (TREE_TYPE (low0
))
4527 && integer_zerop (low0
))
4534 /* Canonicalize - [x, max] into - [x, -]. */
4535 if (high1
&& TREE_CODE (high1
) == INTEGER_CST
)
4536 switch (TREE_CODE (TREE_TYPE (high1
)))
4539 if (TYPE_PRECISION (TREE_TYPE (high1
))
4540 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1
))))
4544 if (tree_int_cst_equal (high1
,
4545 TYPE_MAX_VALUE (TREE_TYPE (high1
))))
4549 if (TYPE_UNSIGNED (TREE_TYPE (high1
))
4550 && integer_zerop (range_binop (PLUS_EXPR
, NULL_TREE
,
4552 build_int_cst (TREE_TYPE (high1
), 1),
4560 /* The ranges might be also adjacent between the maximum and
4561 minimum values of the given type. For
4562 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4563 return + [x + 1, y - 1]. */
4564 if (low0
== 0 && high1
== 0)
4566 low
= range_successor (high0
);
4567 high
= range_predecessor (low1
);
4568 if (low
== 0 || high
== 0)
4578 in_p
= 0, low
= low0
, high
= high0
;
4580 in_p
= 0, low
= low0
, high
= high1
;
4583 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4588 /* Subroutine of fold, looking inside expressions of the form
4589 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4590 of the COND_EXPR. This function is being used also to optimize
4591 A op B ? C : A, by reversing the comparison first.
4593 Return a folded expression whose code is not a COND_EXPR
4594 anymore, or NULL_TREE if no folding opportunity is found. */
4597 fold_cond_expr_with_comparison (location_t loc
, tree type
,
4598 tree arg0
, tree arg1
, tree arg2
)
4600 enum tree_code comp_code
= TREE_CODE (arg0
);
4601 tree arg00
= TREE_OPERAND (arg0
, 0);
4602 tree arg01
= TREE_OPERAND (arg0
, 1);
4603 tree arg1_type
= TREE_TYPE (arg1
);
4609 /* If we have A op 0 ? A : -A, consider applying the following
4612 A == 0? A : -A same as -A
4613 A != 0? A : -A same as A
4614 A >= 0? A : -A same as abs (A)
4615 A > 0? A : -A same as abs (A)
4616 A <= 0? A : -A same as -abs (A)
4617 A < 0? A : -A same as -abs (A)
4619 None of these transformations work for modes with signed
4620 zeros. If A is +/-0, the first two transformations will
4621 change the sign of the result (from +0 to -0, or vice
4622 versa). The last four will fix the sign of the result,
4623 even though the original expressions could be positive or
4624 negative, depending on the sign of A.
4626 Note that all these transformations are correct if A is
4627 NaN, since the two alternatives (A and -A) are also NaNs. */
4628 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
4629 && (FLOAT_TYPE_P (TREE_TYPE (arg01
))
4630 ? real_zerop (arg01
)
4631 : integer_zerop (arg01
))
4632 && ((TREE_CODE (arg2
) == NEGATE_EXPR
4633 && operand_equal_p (TREE_OPERAND (arg2
, 0), arg1
, 0))
4634 /* In the case that A is of the form X-Y, '-A' (arg2) may
4635 have already been folded to Y-X, check for that. */
4636 || (TREE_CODE (arg1
) == MINUS_EXPR
4637 && TREE_CODE (arg2
) == MINUS_EXPR
4638 && operand_equal_p (TREE_OPERAND (arg1
, 0),
4639 TREE_OPERAND (arg2
, 1), 0)
4640 && operand_equal_p (TREE_OPERAND (arg1
, 1),
4641 TREE_OPERAND (arg2
, 0), 0))))
4646 tem
= fold_convert_loc (loc
, arg1_type
, arg1
);
4647 return pedantic_non_lvalue_loc (loc
,
4648 fold_convert_loc (loc
, type
,
4649 negate_expr (tem
)));
4652 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
4655 if (flag_trapping_math
)
4660 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
4661 arg1
= fold_convert_loc (loc
, signed_type_for
4662 (TREE_TYPE (arg1
)), arg1
);
4663 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
4664 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
4667 if (flag_trapping_math
)
4671 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
4672 arg1
= fold_convert_loc (loc
, signed_type_for
4673 (TREE_TYPE (arg1
)), arg1
);
4674 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
4675 return negate_expr (fold_convert_loc (loc
, type
, tem
));
4677 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
4681 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
4682 A == 0 ? A : 0 is always 0 unless A is -0. Note that
4683 both transformations are correct when A is NaN: A != 0
4684 is then true, and A == 0 is false. */
4686 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
4687 && integer_zerop (arg01
) && integer_zerop (arg2
))
4689 if (comp_code
== NE_EXPR
)
4690 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
4691 else if (comp_code
== EQ_EXPR
)
4692 return build_zero_cst (type
);
4695 /* Try some transformations of A op B ? A : B.
4697 A == B? A : B same as B
4698 A != B? A : B same as A
4699 A >= B? A : B same as max (A, B)
4700 A > B? A : B same as max (B, A)
4701 A <= B? A : B same as min (A, B)
4702 A < B? A : B same as min (B, A)
4704 As above, these transformations don't work in the presence
4705 of signed zeros. For example, if A and B are zeros of
4706 opposite sign, the first two transformations will change
4707 the sign of the result. In the last four, the original
4708 expressions give different results for (A=+0, B=-0) and
4709 (A=-0, B=+0), but the transformed expressions do not.
4711 The first two transformations are correct if either A or B
4712 is a NaN. In the first transformation, the condition will
4713 be false, and B will indeed be chosen. In the case of the
4714 second transformation, the condition A != B will be true,
4715 and A will be chosen.
4717 The conversions to max() and min() are not correct if B is
4718 a number and A is not. The conditions in the original
4719 expressions will be false, so all four give B. The min()
4720 and max() versions would give a NaN instead. */
4721 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
4722 && operand_equal_for_comparison_p (arg01
, arg2
, arg00
)
4723 /* Avoid these transformations if the COND_EXPR may be used
4724 as an lvalue in the C++ front-end. PR c++/19199. */
4726 || VECTOR_TYPE_P (type
)
4727 || (strcmp (lang_hooks
.name
, "GNU C++") != 0
4728 && strcmp (lang_hooks
.name
, "GNU Objective-C++") != 0)
4729 || ! maybe_lvalue_p (arg1
)
4730 || ! maybe_lvalue_p (arg2
)))
4732 tree comp_op0
= arg00
;
4733 tree comp_op1
= arg01
;
4734 tree comp_type
= TREE_TYPE (comp_op0
);
4736 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
4737 if (TYPE_MAIN_VARIANT (comp_type
) == TYPE_MAIN_VARIANT (type
))
4747 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg2
));
4749 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
4754 /* In C++ a ?: expression can be an lvalue, so put the
4755 operand which will be used if they are equal first
4756 so that we can convert this back to the
4757 corresponding COND_EXPR. */
4758 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
4760 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
4761 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
4762 tem
= (comp_code
== LE_EXPR
|| comp_code
== UNLE_EXPR
)
4763 ? fold_build2_loc (loc
, MIN_EXPR
, comp_type
, comp_op0
, comp_op1
)
4764 : fold_build2_loc (loc
, MIN_EXPR
, comp_type
,
4765 comp_op1
, comp_op0
);
4766 return pedantic_non_lvalue_loc (loc
,
4767 fold_convert_loc (loc
, type
, tem
));
4774 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
4776 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
4777 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
4778 tem
= (comp_code
== GE_EXPR
|| comp_code
== UNGE_EXPR
)
4779 ? fold_build2_loc (loc
, MAX_EXPR
, comp_type
, comp_op0
, comp_op1
)
4780 : fold_build2_loc (loc
, MAX_EXPR
, comp_type
,
4781 comp_op1
, comp_op0
);
4782 return pedantic_non_lvalue_loc (loc
,
4783 fold_convert_loc (loc
, type
, tem
));
4787 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
4788 return pedantic_non_lvalue_loc (loc
,
4789 fold_convert_loc (loc
, type
, arg2
));
4792 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
4793 return pedantic_non_lvalue_loc (loc
,
4794 fold_convert_loc (loc
, type
, arg1
));
4797 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
4802 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4803 we might still be able to simplify this. For example,
4804 if C1 is one less or one more than C2, this might have started
4805 out as a MIN or MAX and been transformed by this function.
4806 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
4808 if (INTEGRAL_TYPE_P (type
)
4809 && TREE_CODE (arg01
) == INTEGER_CST
4810 && TREE_CODE (arg2
) == INTEGER_CST
)
4814 if (TREE_CODE (arg1
) == INTEGER_CST
)
4816 /* We can replace A with C1 in this case. */
4817 arg1
= fold_convert_loc (loc
, type
, arg01
);
4818 return fold_build3_loc (loc
, COND_EXPR
, type
, arg0
, arg1
, arg2
);
4821 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
4822 MIN_EXPR, to preserve the signedness of the comparison. */
4823 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
),
4825 && operand_equal_p (arg01
,
4826 const_binop (PLUS_EXPR
, arg2
,
4827 build_int_cst (type
, 1)),
4830 tem
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (arg00
), arg00
,
4831 fold_convert_loc (loc
, TREE_TYPE (arg00
),
4833 return pedantic_non_lvalue_loc (loc
,
4834 fold_convert_loc (loc
, type
, tem
));
4839 /* If C1 is C2 - 1, this is min(A, C2), with the same care
4841 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
),
4843 && operand_equal_p (arg01
,
4844 const_binop (MINUS_EXPR
, arg2
,
4845 build_int_cst (type
, 1)),
4848 tem
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (arg00
), arg00
,
4849 fold_convert_loc (loc
, TREE_TYPE (arg00
),
4851 return pedantic_non_lvalue_loc (loc
,
4852 fold_convert_loc (loc
, type
, tem
));
4857 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
4858 MAX_EXPR, to preserve the signedness of the comparison. */
4859 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
),
4861 && operand_equal_p (arg01
,
4862 const_binop (MINUS_EXPR
, arg2
,
4863 build_int_cst (type
, 1)),
4866 tem
= fold_build2_loc (loc
, MAX_EXPR
, TREE_TYPE (arg00
), arg00
,
4867 fold_convert_loc (loc
, TREE_TYPE (arg00
),
4869 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
4874 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
4875 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
),
4877 && operand_equal_p (arg01
,
4878 const_binop (PLUS_EXPR
, arg2
,
4879 build_int_cst (type
, 1)),
4882 tem
= fold_build2_loc (loc
, MAX_EXPR
, TREE_TYPE (arg00
), arg00
,
4883 fold_convert_loc (loc
, TREE_TYPE (arg00
),
4885 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
4899 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
4900 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
4901 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
4905 /* EXP is some logical combination of boolean tests. See if we can
4906 merge it into some range test. Return the new tree if so. */
4909 fold_range_test (location_t loc
, enum tree_code code
, tree type
,
4912 int or_op
= (code
== TRUTH_ORIF_EXPR
4913 || code
== TRUTH_OR_EXPR
);
4914 int in0_p
, in1_p
, in_p
;
4915 tree low0
, low1
, low
, high0
, high1
, high
;
4916 bool strict_overflow_p
= false;
4918 const char * const warnmsg
= G_("assuming signed overflow does not occur "
4919 "when simplifying range test");
4921 if (!INTEGRAL_TYPE_P (type
))
4924 lhs
= make_range (op0
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
4925 rhs
= make_range (op1
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
4927 /* If this is an OR operation, invert both sides; we will invert
4928 again at the end. */
4930 in0_p
= ! in0_p
, in1_p
= ! in1_p
;
4932 /* If both expressions are the same, if we can merge the ranges, and we
4933 can build the range test, return it or it inverted. If one of the
4934 ranges is always true or always false, consider it to be the same
4935 expression as the other. */
4936 if ((lhs
== 0 || rhs
== 0 || operand_equal_p (lhs
, rhs
, 0))
4937 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
4939 && 0 != (tem
= (build_range_check (loc
, type
,
4941 : rhs
!= 0 ? rhs
: integer_zero_node
,
4944 if (strict_overflow_p
)
4945 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
4946 return or_op
? invert_truthvalue_loc (loc
, tem
) : tem
;
4949 /* On machines where the branch cost is expensive, if this is a
4950 short-circuited branch and the underlying object on both sides
4951 is the same, make a non-short-circuit operation. */
4952 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
4953 && lhs
!= 0 && rhs
!= 0
4954 && (code
== TRUTH_ANDIF_EXPR
4955 || code
== TRUTH_ORIF_EXPR
)
4956 && operand_equal_p (lhs
, rhs
, 0))
4958 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
4959 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4960 which cases we can't do this. */
4961 if (simple_operand_p (lhs
))
4962 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
4963 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
4966 else if (!lang_hooks
.decls
.global_bindings_p ()
4967 && !CONTAINS_PLACEHOLDER_P (lhs
))
4969 tree common
= save_expr (lhs
);
4971 if (0 != (lhs
= build_range_check (loc
, type
, common
,
4972 or_op
? ! in0_p
: in0_p
,
4974 && (0 != (rhs
= build_range_check (loc
, type
, common
,
4975 or_op
? ! in1_p
: in1_p
,
4978 if (strict_overflow_p
)
4979 fold_overflow_warning (warnmsg
,
4980 WARN_STRICT_OVERFLOW_COMPARISON
);
4981 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
4982 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
4991 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
4992 bit value. Arrange things so the extra bits will be set to zero if and
4993 only if C is signed-extended to its full width. If MASK is nonzero,
4994 it is an INTEGER_CST that should be AND'ed with the extra bits. */
4997 unextend (tree c
, int p
, int unsignedp
, tree mask
)
4999 tree type
= TREE_TYPE (c
);
5000 int modesize
= GET_MODE_BITSIZE (TYPE_MODE (type
));
5003 if (p
== modesize
|| unsignedp
)
5006 /* We work by getting just the sign bit into the low-order bit, then
5007 into the high-order bit, then sign-extend. We then XOR that value
5009 temp
= build_int_cst (TREE_TYPE (c
), wi::extract_uhwi (c
, p
- 1, 1));
5011 /* We must use a signed type in order to get an arithmetic right shift.
5012 However, we must also avoid introducing accidental overflows, so that
5013 a subsequent call to integer_zerop will work. Hence we must
5014 do the type conversion here. At this point, the constant is either
5015 zero or one, and the conversion to a signed type can never overflow.
5016 We could get an overflow if this conversion is done anywhere else. */
5017 if (TYPE_UNSIGNED (type
))
5018 temp
= fold_convert (signed_type_for (type
), temp
);
5020 temp
= const_binop (LSHIFT_EXPR
, temp
, size_int (modesize
- 1));
5021 temp
= const_binop (RSHIFT_EXPR
, temp
, size_int (modesize
- p
- 1));
5023 temp
= const_binop (BIT_AND_EXPR
, temp
,
5024 fold_convert (TREE_TYPE (c
), mask
));
5025 /* If necessary, convert the type back to match the type of C. */
5026 if (TYPE_UNSIGNED (type
))
5027 temp
= fold_convert (type
, temp
);
5029 return fold_convert (type
, const_binop (BIT_XOR_EXPR
, c
, temp
));
5032 /* For an expression that has the form
5036 we can drop one of the inner expressions and simplify to
5040 LOC is the location of the resulting expression. OP is the inner
5041 logical operation; the left-hand side in the examples above, while CMPOP
5042 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5043 removing a condition that guards another, as in
5044 (A != NULL && A->...) || A == NULL
5045 which we must not transform. If RHS_ONLY is true, only eliminate the
5046 right-most operand of the inner logical operation. */
5049 merge_truthop_with_opposite_arm (location_t loc
, tree op
, tree cmpop
,
5052 tree type
= TREE_TYPE (cmpop
);
5053 enum tree_code code
= TREE_CODE (cmpop
);
5054 enum tree_code truthop_code
= TREE_CODE (op
);
5055 tree lhs
= TREE_OPERAND (op
, 0);
5056 tree rhs
= TREE_OPERAND (op
, 1);
5057 tree orig_lhs
= lhs
, orig_rhs
= rhs
;
5058 enum tree_code rhs_code
= TREE_CODE (rhs
);
5059 enum tree_code lhs_code
= TREE_CODE (lhs
);
5060 enum tree_code inv_code
;
5062 if (TREE_SIDE_EFFECTS (op
) || TREE_SIDE_EFFECTS (cmpop
))
5065 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
5068 if (rhs_code
== truthop_code
)
5070 tree newrhs
= merge_truthop_with_opposite_arm (loc
, rhs
, cmpop
, rhs_only
);
5071 if (newrhs
!= NULL_TREE
)
5074 rhs_code
= TREE_CODE (rhs
);
5077 if (lhs_code
== truthop_code
&& !rhs_only
)
5079 tree newlhs
= merge_truthop_with_opposite_arm (loc
, lhs
, cmpop
, false);
5080 if (newlhs
!= NULL_TREE
)
5083 lhs_code
= TREE_CODE (lhs
);
5087 inv_code
= invert_tree_comparison (code
, HONOR_NANS (TYPE_MODE (type
)));
5088 if (inv_code
== rhs_code
5089 && operand_equal_p (TREE_OPERAND (rhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5090 && operand_equal_p (TREE_OPERAND (rhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5092 if (!rhs_only
&& inv_code
== lhs_code
5093 && operand_equal_p (TREE_OPERAND (lhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5094 && operand_equal_p (TREE_OPERAND (lhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5096 if (rhs
!= orig_rhs
|| lhs
!= orig_lhs
)
5097 return fold_build2_loc (loc
, truthop_code
, TREE_TYPE (cmpop
),
5102 /* Find ways of folding logical expressions of LHS and RHS:
5103 Try to merge two comparisons to the same innermost item.
5104 Look for range tests like "ch >= '0' && ch <= '9'".
5105 Look for combinations of simple terms on machines with expensive branches
5106 and evaluate the RHS unconditionally.
5108 For example, if we have p->a == 2 && p->b == 4 and we can make an
5109 object large enough to span both A and B, we can do this with a comparison
5110 against the object ANDed with the a mask.
5112 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5113 operations to do this with one comparison.
5115 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5116 function and the one above.
5118 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5119 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5121 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5124 We return the simplified tree or 0 if no optimization is possible. */
5127 fold_truth_andor_1 (location_t loc
, enum tree_code code
, tree truth_type
,
5130 /* If this is the "or" of two comparisons, we can do something if
5131 the comparisons are NE_EXPR. If this is the "and", we can do something
5132 if the comparisons are EQ_EXPR. I.e.,
5133 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5135 WANTED_CODE is this operation code. For single bit fields, we can
5136 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5137 comparison for one-bit fields. */
5139 enum tree_code wanted_code
;
5140 enum tree_code lcode
, rcode
;
5141 tree ll_arg
, lr_arg
, rl_arg
, rr_arg
;
5142 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
5143 HOST_WIDE_INT ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
5144 HOST_WIDE_INT rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
5145 HOST_WIDE_INT xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
5146 HOST_WIDE_INT lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
5147 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
5148 enum machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
5149 enum machine_mode lnmode
, rnmode
;
5150 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
5151 tree ll_and_mask
, lr_and_mask
, rl_and_mask
, rr_and_mask
;
5152 tree l_const
, r_const
;
5153 tree lntype
, rntype
, result
;
5154 HOST_WIDE_INT first_bit
, end_bit
;
5157 /* Start by getting the comparison codes. Fail if anything is volatile.
5158 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5159 it were surrounded with a NE_EXPR. */
5161 if (TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
5164 lcode
= TREE_CODE (lhs
);
5165 rcode
= TREE_CODE (rhs
);
5167 if (lcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (lhs
, 1)))
5169 lhs
= build2 (NE_EXPR
, truth_type
, lhs
,
5170 build_int_cst (TREE_TYPE (lhs
), 0));
5174 if (rcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (rhs
, 1)))
5176 rhs
= build2 (NE_EXPR
, truth_type
, rhs
,
5177 build_int_cst (TREE_TYPE (rhs
), 0));
5181 if (TREE_CODE_CLASS (lcode
) != tcc_comparison
5182 || TREE_CODE_CLASS (rcode
) != tcc_comparison
)
5185 ll_arg
= TREE_OPERAND (lhs
, 0);
5186 lr_arg
= TREE_OPERAND (lhs
, 1);
5187 rl_arg
= TREE_OPERAND (rhs
, 0);
5188 rr_arg
= TREE_OPERAND (rhs
, 1);
5190 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5191 if (simple_operand_p (ll_arg
)
5192 && simple_operand_p (lr_arg
))
5194 if (operand_equal_p (ll_arg
, rl_arg
, 0)
5195 && operand_equal_p (lr_arg
, rr_arg
, 0))
5197 result
= combine_comparisons (loc
, code
, lcode
, rcode
,
5198 truth_type
, ll_arg
, lr_arg
);
5202 else if (operand_equal_p (ll_arg
, rr_arg
, 0)
5203 && operand_equal_p (lr_arg
, rl_arg
, 0))
5205 result
= combine_comparisons (loc
, code
, lcode
,
5206 swap_tree_comparison (rcode
),
5207 truth_type
, ll_arg
, lr_arg
);
5213 code
= ((code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
)
5214 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
);
5216 /* If the RHS can be evaluated unconditionally and its operands are
5217 simple, it wins to evaluate the RHS unconditionally on machines
5218 with expensive branches. In this case, this isn't a comparison
5219 that can be merged. */
5221 if (BRANCH_COST (optimize_function_for_speed_p (cfun
),
5223 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg
))
5224 && simple_operand_p (rl_arg
)
5225 && simple_operand_p (rr_arg
))
5227 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5228 if (code
== TRUTH_OR_EXPR
5229 && lcode
== NE_EXPR
&& integer_zerop (lr_arg
)
5230 && rcode
== NE_EXPR
&& integer_zerop (rr_arg
)
5231 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5232 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5233 return build2_loc (loc
, NE_EXPR
, truth_type
,
5234 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5236 build_int_cst (TREE_TYPE (ll_arg
), 0));
5238 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5239 if (code
== TRUTH_AND_EXPR
5240 && lcode
== EQ_EXPR
&& integer_zerop (lr_arg
)
5241 && rcode
== EQ_EXPR
&& integer_zerop (rr_arg
)
5242 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5243 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5244 return build2_loc (loc
, EQ_EXPR
, truth_type
,
5245 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5247 build_int_cst (TREE_TYPE (ll_arg
), 0));
5250 /* See if the comparisons can be merged. Then get all the parameters for
5253 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
5254 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
))
5258 ll_inner
= decode_field_reference (loc
, ll_arg
,
5259 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
5260 &ll_unsignedp
, &volatilep
, &ll_mask
,
5262 lr_inner
= decode_field_reference (loc
, lr_arg
,
5263 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
5264 &lr_unsignedp
, &volatilep
, &lr_mask
,
5266 rl_inner
= decode_field_reference (loc
, rl_arg
,
5267 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
5268 &rl_unsignedp
, &volatilep
, &rl_mask
,
5270 rr_inner
= decode_field_reference (loc
, rr_arg
,
5271 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
5272 &rr_unsignedp
, &volatilep
, &rr_mask
,
5275 /* It must be true that the inner operation on the lhs of each
5276 comparison must be the same if we are to be able to do anything.
5277 Then see if we have constants. If not, the same must be true for
5279 if (volatilep
|| ll_inner
== 0 || rl_inner
== 0
5280 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
5283 if (TREE_CODE (lr_arg
) == INTEGER_CST
5284 && TREE_CODE (rr_arg
) == INTEGER_CST
)
5285 l_const
= lr_arg
, r_const
= rr_arg
;
5286 else if (lr_inner
== 0 || rr_inner
== 0
5287 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
5290 l_const
= r_const
= 0;
5292 /* If either comparison code is not correct for our logical operation,
5293 fail. However, we can convert a one-bit comparison against zero into
5294 the opposite comparison against that bit being set in the field. */
5296 wanted_code
= (code
== TRUTH_AND_EXPR
? EQ_EXPR
: NE_EXPR
);
5297 if (lcode
!= wanted_code
)
5299 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
5301 /* Make the left operand unsigned, since we are only interested
5302 in the value of one bit. Otherwise we are doing the wrong
5311 /* This is analogous to the code for l_const above. */
5312 if (rcode
!= wanted_code
)
5314 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
5323 /* See if we can find a mode that contains both fields being compared on
5324 the left. If we can't, fail. Otherwise, update all constants and masks
5325 to be relative to a field of that size. */
5326 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
5327 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
5328 lnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5329 TYPE_ALIGN (TREE_TYPE (ll_inner
)), word_mode
,
5331 if (lnmode
== VOIDmode
)
5334 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
5335 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
5336 lntype
= lang_hooks
.types
.type_for_size (lnbitsize
, 1);
5337 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
5339 if (BYTES_BIG_ENDIAN
)
5341 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
5342 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
5345 ll_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, ll_mask
),
5346 size_int (xll_bitpos
));
5347 rl_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, rl_mask
),
5348 size_int (xrl_bitpos
));
5352 l_const
= fold_convert_loc (loc
, lntype
, l_const
);
5353 l_const
= unextend (l_const
, ll_bitsize
, ll_unsignedp
, ll_and_mask
);
5354 l_const
= const_binop (LSHIFT_EXPR
, l_const
, size_int (xll_bitpos
));
5355 if (! integer_zerop (const_binop (BIT_AND_EXPR
, l_const
,
5356 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5359 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5361 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5366 r_const
= fold_convert_loc (loc
, lntype
, r_const
);
5367 r_const
= unextend (r_const
, rl_bitsize
, rl_unsignedp
, rl_and_mask
);
5368 r_const
= const_binop (LSHIFT_EXPR
, r_const
, size_int (xrl_bitpos
));
5369 if (! integer_zerop (const_binop (BIT_AND_EXPR
, r_const
,
5370 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5373 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5375 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5379 /* If the right sides are not constant, do the same for it. Also,
5380 disallow this optimization if a size or signedness mismatch occurs
5381 between the left and right sides. */
5384 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
5385 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
5386 /* Make sure the two fields on the right
5387 correspond to the left without being swapped. */
5388 || ll_bitpos
- rl_bitpos
!= lr_bitpos
- rr_bitpos
)
5391 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
5392 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
5393 rnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5394 TYPE_ALIGN (TREE_TYPE (lr_inner
)), word_mode
,
5396 if (rnmode
== VOIDmode
)
5399 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
5400 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
5401 rntype
= lang_hooks
.types
.type_for_size (rnbitsize
, 1);
5402 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
5404 if (BYTES_BIG_ENDIAN
)
5406 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
5407 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
5410 lr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5412 size_int (xlr_bitpos
));
5413 rr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5415 size_int (xrr_bitpos
));
5417 /* Make a mask that corresponds to both fields being compared.
5418 Do this for both items being compared. If the operands are the
5419 same size and the bits being compared are in the same position
5420 then we can do this by masking both and comparing the masked
5422 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5423 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
);
5424 if (lnbitsize
== rnbitsize
&& xll_bitpos
== xlr_bitpos
)
5426 lhs
= make_bit_field_ref (loc
, ll_inner
, lntype
, lnbitsize
, lnbitpos
,
5427 ll_unsignedp
|| rl_unsignedp
);
5428 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5429 lhs
= build2 (BIT_AND_EXPR
, lntype
, lhs
, ll_mask
);
5431 rhs
= make_bit_field_ref (loc
, lr_inner
, rntype
, rnbitsize
, rnbitpos
,
5432 lr_unsignedp
|| rr_unsignedp
);
5433 if (! all_ones_mask_p (lr_mask
, rnbitsize
))
5434 rhs
= build2 (BIT_AND_EXPR
, rntype
, rhs
, lr_mask
);
5436 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5439 /* There is still another way we can do something: If both pairs of
5440 fields being compared are adjacent, we may be able to make a wider
5441 field containing them both.
5443 Note that we still must mask the lhs/rhs expressions. Furthermore,
5444 the mask must be shifted to account for the shift done by
5445 make_bit_field_ref. */
5446 if ((ll_bitsize
+ ll_bitpos
== rl_bitpos
5447 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
5448 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
5449 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
5453 lhs
= make_bit_field_ref (loc
, ll_inner
, lntype
,
5454 ll_bitsize
+ rl_bitsize
,
5455 MIN (ll_bitpos
, rl_bitpos
), ll_unsignedp
);
5456 rhs
= make_bit_field_ref (loc
, lr_inner
, rntype
,
5457 lr_bitsize
+ rr_bitsize
,
5458 MIN (lr_bitpos
, rr_bitpos
), lr_unsignedp
);
5460 ll_mask
= const_binop (RSHIFT_EXPR
, ll_mask
,
5461 size_int (MIN (xll_bitpos
, xrl_bitpos
)));
5462 lr_mask
= const_binop (RSHIFT_EXPR
, lr_mask
,
5463 size_int (MIN (xlr_bitpos
, xrr_bitpos
)));
5465 /* Convert to the smaller type before masking out unwanted bits. */
5467 if (lntype
!= rntype
)
5469 if (lnbitsize
> rnbitsize
)
5471 lhs
= fold_convert_loc (loc
, rntype
, lhs
);
5472 ll_mask
= fold_convert_loc (loc
, rntype
, ll_mask
);
5475 else if (lnbitsize
< rnbitsize
)
5477 rhs
= fold_convert_loc (loc
, lntype
, rhs
);
5478 lr_mask
= fold_convert_loc (loc
, lntype
, lr_mask
);
5483 if (! all_ones_mask_p (ll_mask
, ll_bitsize
+ rl_bitsize
))
5484 lhs
= build2 (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
5486 if (! all_ones_mask_p (lr_mask
, lr_bitsize
+ rr_bitsize
))
5487 rhs
= build2 (BIT_AND_EXPR
, type
, rhs
, lr_mask
);
5489 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5495 /* Handle the case of comparisons with constants. If there is something in
5496 common between the masks, those bits of the constants must be the same.
5497 If not, the condition is always false. Test for this to avoid generating
5498 incorrect code below. */
5499 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
);
5500 if (! integer_zerop (result
)
5501 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
),
5502 const_binop (BIT_AND_EXPR
, result
, r_const
)) != 1)
5504 if (wanted_code
== NE_EXPR
)
5506 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5507 return constant_boolean_node (true, truth_type
);
5511 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5512 return constant_boolean_node (false, truth_type
);
5516 /* Construct the expression we will return. First get the component
5517 reference we will make. Unless the mask is all ones the width of
5518 that field, perform the mask operation. Then compare with the
5520 result
= make_bit_field_ref (loc
, ll_inner
, lntype
, lnbitsize
, lnbitpos
,
5521 ll_unsignedp
|| rl_unsignedp
);
5523 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5524 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5525 result
= build2_loc (loc
, BIT_AND_EXPR
, lntype
, result
, ll_mask
);
5527 return build2_loc (loc
, wanted_code
, truth_type
, result
,
5528 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
5531 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5535 optimize_minmax_comparison (location_t loc
, enum tree_code code
, tree type
,
5539 enum tree_code op_code
;
5542 int consts_equal
, consts_lt
;
5545 STRIP_SIGN_NOPS (arg0
);
5547 op_code
= TREE_CODE (arg0
);
5548 minmax_const
= TREE_OPERAND (arg0
, 1);
5549 comp_const
= fold_convert_loc (loc
, TREE_TYPE (arg0
), op1
);
5550 consts_equal
= tree_int_cst_equal (minmax_const
, comp_const
);
5551 consts_lt
= tree_int_cst_lt (minmax_const
, comp_const
);
5552 inner
= TREE_OPERAND (arg0
, 0);
5554 /* If something does not permit us to optimize, return the original tree. */
5555 if ((op_code
!= MIN_EXPR
&& op_code
!= MAX_EXPR
)
5556 || TREE_CODE (comp_const
) != INTEGER_CST
5557 || TREE_OVERFLOW (comp_const
)
5558 || TREE_CODE (minmax_const
) != INTEGER_CST
5559 || TREE_OVERFLOW (minmax_const
))
5562 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5563 and GT_EXPR, doing the rest with recursive calls using logical
5567 case NE_EXPR
: case LT_EXPR
: case LE_EXPR
:
5570 = optimize_minmax_comparison (loc
,
5571 invert_tree_comparison (code
, false),
5574 return invert_truthvalue_loc (loc
, tem
);
5580 fold_build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
5581 optimize_minmax_comparison
5582 (loc
, EQ_EXPR
, type
, arg0
, comp_const
),
5583 optimize_minmax_comparison
5584 (loc
, GT_EXPR
, type
, arg0
, comp_const
));
5587 if (op_code
== MAX_EXPR
&& consts_equal
)
5588 /* MAX (X, 0) == 0 -> X <= 0 */
5589 return fold_build2_loc (loc
, LE_EXPR
, type
, inner
, comp_const
);
5591 else if (op_code
== MAX_EXPR
&& consts_lt
)
5592 /* MAX (X, 0) == 5 -> X == 5 */
5593 return fold_build2_loc (loc
, EQ_EXPR
, type
, inner
, comp_const
);
5595 else if (op_code
== MAX_EXPR
)
5596 /* MAX (X, 0) == -1 -> false */
5597 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5599 else if (consts_equal
)
5600 /* MIN (X, 0) == 0 -> X >= 0 */
5601 return fold_build2_loc (loc
, GE_EXPR
, type
, inner
, comp_const
);
5604 /* MIN (X, 0) == 5 -> false */
5605 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5608 /* MIN (X, 0) == -1 -> X == -1 */
5609 return fold_build2_loc (loc
, EQ_EXPR
, type
, inner
, comp_const
);
5612 if (op_code
== MAX_EXPR
&& (consts_equal
|| consts_lt
))
5613 /* MAX (X, 0) > 0 -> X > 0
5614 MAX (X, 0) > 5 -> X > 5 */
5615 return fold_build2_loc (loc
, GT_EXPR
, type
, inner
, comp_const
);
5617 else if (op_code
== MAX_EXPR
)
5618 /* MAX (X, 0) > -1 -> true */
5619 return omit_one_operand_loc (loc
, type
, integer_one_node
, inner
);
5621 else if (op_code
== MIN_EXPR
&& (consts_equal
|| consts_lt
))
5622 /* MIN (X, 0) > 0 -> false
5623 MIN (X, 0) > 5 -> false */
5624 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5627 /* MIN (X, 0) > -1 -> X > -1 */
5628 return fold_build2_loc (loc
, GT_EXPR
, type
, inner
, comp_const
);
5635 /* T is an integer expression that is being multiplied, divided, or taken a
5636 modulus (CODE says which and what kind of divide or modulus) by a
5637 constant C. See if we can eliminate that operation by folding it with
5638 other operations already in T. WIDE_TYPE, if non-null, is a type that
5639 should be used for the computation if wider than our type.
5641 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5642 (X * 2) + (Y * 4). We must, however, be assured that either the original
5643 expression would not overflow or that overflow is undefined for the type
5644 in the language in question.
5646 If we return a non-null expression, it is an equivalent form of the
5647 original computation, but need not be in the original type.
5649 We set *STRICT_OVERFLOW_P to true if the return values depends on
5650 signed overflow being undefined. Otherwise we do not change
5651 *STRICT_OVERFLOW_P. */
5654 extract_muldiv (tree t
, tree c
, enum tree_code code
, tree wide_type
,
5655 bool *strict_overflow_p
)
5657 /* To avoid exponential search depth, refuse to allow recursion past
5658 three levels. Beyond that (1) it's highly unlikely that we'll find
5659 something interesting and (2) we've probably processed it before
5660 when we built the inner expression. */
5669 ret
= extract_muldiv_1 (t
, c
, code
, wide_type
, strict_overflow_p
);
5676 extract_muldiv_1 (tree t
, tree c
, enum tree_code code
, tree wide_type
,
5677 bool *strict_overflow_p
)
5679 tree type
= TREE_TYPE (t
);
5680 enum tree_code tcode
= TREE_CODE (t
);
5681 tree ctype
= (wide_type
!= 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type
))
5682 > GET_MODE_SIZE (TYPE_MODE (type
)))
5683 ? wide_type
: type
);
5685 int same_p
= tcode
== code
;
5686 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
5687 bool sub_strict_overflow_p
;
5689 /* Don't deal with constants of zero here; they confuse the code below. */
5690 if (integer_zerop (c
))
5693 if (TREE_CODE_CLASS (tcode
) == tcc_unary
)
5694 op0
= TREE_OPERAND (t
, 0);
5696 if (TREE_CODE_CLASS (tcode
) == tcc_binary
)
5697 op0
= TREE_OPERAND (t
, 0), op1
= TREE_OPERAND (t
, 1);
5699 /* Note that we need not handle conditional operations here since fold
5700 already handles those cases. So just do arithmetic here. */
5704 /* For a constant, we can always simplify if we are a multiply
5705 or (for divide and modulus) if it is a multiple of our constant. */
5706 if (code
== MULT_EXPR
5707 || wi::multiple_of_p (t
, c
, TYPE_SIGN (type
)))
5708 return const_binop (code
, fold_convert (ctype
, t
),
5709 fold_convert (ctype
, c
));
5712 CASE_CONVERT
: case NON_LVALUE_EXPR
:
5713 /* If op0 is an expression ... */
5714 if ((COMPARISON_CLASS_P (op0
)
5715 || UNARY_CLASS_P (op0
)
5716 || BINARY_CLASS_P (op0
)
5717 || VL_EXP_CLASS_P (op0
)
5718 || EXPRESSION_CLASS_P (op0
))
5719 /* ... and has wrapping overflow, and its type is smaller
5720 than ctype, then we cannot pass through as widening. */
5721 && ((TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0
))
5722 && (TYPE_PRECISION (ctype
)
5723 > TYPE_PRECISION (TREE_TYPE (op0
))))
5724 /* ... or this is a truncation (t is narrower than op0),
5725 then we cannot pass through this narrowing. */
5726 || (TYPE_PRECISION (type
)
5727 < TYPE_PRECISION (TREE_TYPE (op0
)))
5728 /* ... or signedness changes for division or modulus,
5729 then we cannot pass through this conversion. */
5730 || (code
!= MULT_EXPR
5731 && (TYPE_UNSIGNED (ctype
)
5732 != TYPE_UNSIGNED (TREE_TYPE (op0
))))
5733 /* ... or has undefined overflow while the converted to
5734 type has not, we cannot do the operation in the inner type
5735 as that would introduce undefined overflow. */
5736 || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0
))
5737 && !TYPE_OVERFLOW_UNDEFINED (type
))))
5740 /* Pass the constant down and see if we can make a simplification. If
5741 we can, replace this expression with the inner simplification for
5742 possible later conversion to our or some other type. */
5743 if ((t2
= fold_convert (TREE_TYPE (op0
), c
)) != 0
5744 && TREE_CODE (t2
) == INTEGER_CST
5745 && !TREE_OVERFLOW (t2
)
5746 && (0 != (t1
= extract_muldiv (op0
, t2
, code
,
5748 ? ctype
: NULL_TREE
,
5749 strict_overflow_p
))))
5754 /* If widening the type changes it from signed to unsigned, then we
5755 must avoid building ABS_EXPR itself as unsigned. */
5756 if (TYPE_UNSIGNED (ctype
) && !TYPE_UNSIGNED (type
))
5758 tree cstype
= (*signed_type_for
) (ctype
);
5759 if ((t1
= extract_muldiv (op0
, c
, code
, cstype
, strict_overflow_p
))
5762 t1
= fold_build1 (tcode
, cstype
, fold_convert (cstype
, t1
));
5763 return fold_convert (ctype
, t1
);
5767 /* If the constant is negative, we cannot simplify this. */
5768 if (tree_int_cst_sgn (c
) == -1)
5772 /* For division and modulus, type can't be unsigned, as e.g.
5773 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
5774 For signed types, even with wrapping overflow, this is fine. */
5775 if (code
!= MULT_EXPR
&& TYPE_UNSIGNED (type
))
5777 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
, strict_overflow_p
))
5779 return fold_build1 (tcode
, ctype
, fold_convert (ctype
, t1
));
5782 case MIN_EXPR
: case MAX_EXPR
:
5783 /* If widening the type changes the signedness, then we can't perform
5784 this optimization as that changes the result. */
5785 if (TYPE_UNSIGNED (ctype
) != TYPE_UNSIGNED (type
))
5788 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
5789 sub_strict_overflow_p
= false;
5790 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
,
5791 &sub_strict_overflow_p
)) != 0
5792 && (t2
= extract_muldiv (op1
, c
, code
, wide_type
,
5793 &sub_strict_overflow_p
)) != 0)
5795 if (tree_int_cst_sgn (c
) < 0)
5796 tcode
= (tcode
== MIN_EXPR
? MAX_EXPR
: MIN_EXPR
);
5797 if (sub_strict_overflow_p
)
5798 *strict_overflow_p
= true;
5799 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
5800 fold_convert (ctype
, t2
));
5804 case LSHIFT_EXPR
: case RSHIFT_EXPR
:
5805 /* If the second operand is constant, this is a multiplication
5806 or floor division, by a power of two, so we can treat it that
5807 way unless the multiplier or divisor overflows. Signed
5808 left-shift overflow is implementation-defined rather than
5809 undefined in C90, so do not convert signed left shift into
5811 if (TREE_CODE (op1
) == INTEGER_CST
5812 && (tcode
== RSHIFT_EXPR
|| TYPE_UNSIGNED (TREE_TYPE (op0
)))
5813 /* const_binop may not detect overflow correctly,
5814 so check for it explicitly here. */
5815 && wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
5816 && 0 != (t1
= fold_convert (ctype
,
5817 const_binop (LSHIFT_EXPR
,
5820 && !TREE_OVERFLOW (t1
))
5821 return extract_muldiv (build2 (tcode
== LSHIFT_EXPR
5822 ? MULT_EXPR
: FLOOR_DIV_EXPR
,
5824 fold_convert (ctype
, op0
),
5826 c
, code
, wide_type
, strict_overflow_p
);
5829 case PLUS_EXPR
: case MINUS_EXPR
:
5830 /* See if we can eliminate the operation on both sides. If we can, we
5831 can return a new PLUS or MINUS. If we can't, the only remaining
5832 cases where we can do anything are if the second operand is a
5834 sub_strict_overflow_p
= false;
5835 t1
= extract_muldiv (op0
, c
, code
, wide_type
, &sub_strict_overflow_p
);
5836 t2
= extract_muldiv (op1
, c
, code
, wide_type
, &sub_strict_overflow_p
);
5837 if (t1
!= 0 && t2
!= 0
5838 && (code
== MULT_EXPR
5839 /* If not multiplication, we can only do this if both operands
5840 are divisible by c. */
5841 || (multiple_of_p (ctype
, op0
, c
)
5842 && multiple_of_p (ctype
, op1
, c
))))
5844 if (sub_strict_overflow_p
)
5845 *strict_overflow_p
= true;
5846 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
5847 fold_convert (ctype
, t2
));
5850 /* If this was a subtraction, negate OP1 and set it to be an addition.
5851 This simplifies the logic below. */
5852 if (tcode
== MINUS_EXPR
)
5854 tcode
= PLUS_EXPR
, op1
= negate_expr (op1
);
5855 /* If OP1 was not easily negatable, the constant may be OP0. */
5856 if (TREE_CODE (op0
) == INTEGER_CST
)
5867 if (TREE_CODE (op1
) != INTEGER_CST
)
5870 /* If either OP1 or C are negative, this optimization is not safe for
5871 some of the division and remainder types while for others we need
5872 to change the code. */
5873 if (tree_int_cst_sgn (op1
) < 0 || tree_int_cst_sgn (c
) < 0)
5875 if (code
== CEIL_DIV_EXPR
)
5876 code
= FLOOR_DIV_EXPR
;
5877 else if (code
== FLOOR_DIV_EXPR
)
5878 code
= CEIL_DIV_EXPR
;
5879 else if (code
!= MULT_EXPR
5880 && code
!= CEIL_MOD_EXPR
&& code
!= FLOOR_MOD_EXPR
)
5884 /* If it's a multiply or a division/modulus operation of a multiple
5885 of our constant, do the operation and verify it doesn't overflow. */
5886 if (code
== MULT_EXPR
5887 || wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
5889 op1
= const_binop (code
, fold_convert (ctype
, op1
),
5890 fold_convert (ctype
, c
));
5891 /* We allow the constant to overflow with wrapping semantics. */
5893 || (TREE_OVERFLOW (op1
) && !TYPE_OVERFLOW_WRAPS (ctype
)))
5899 /* If we have an unsigned type, we cannot widen the operation since it
5900 will change the result if the original computation overflowed. */
5901 if (TYPE_UNSIGNED (ctype
) && ctype
!= type
)
5904 /* If we were able to eliminate our operation from the first side,
5905 apply our operation to the second side and reform the PLUS. */
5906 if (t1
!= 0 && (TREE_CODE (t1
) != code
|| code
== MULT_EXPR
))
5907 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
), op1
);
5909 /* The last case is if we are a multiply. In that case, we can
5910 apply the distributive law to commute the multiply and addition
5911 if the multiplication of the constants doesn't overflow
5912 and overflow is defined. With undefined overflow
5913 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
5914 if (code
== MULT_EXPR
&& TYPE_OVERFLOW_WRAPS (ctype
))
5915 return fold_build2 (tcode
, ctype
,
5916 fold_build2 (code
, ctype
,
5917 fold_convert (ctype
, op0
),
5918 fold_convert (ctype
, c
)),
5924 /* We have a special case here if we are doing something like
5925 (C * 8) % 4 since we know that's zero. */
5926 if ((code
== TRUNC_MOD_EXPR
|| code
== CEIL_MOD_EXPR
5927 || code
== FLOOR_MOD_EXPR
|| code
== ROUND_MOD_EXPR
)
5928 /* If the multiplication can overflow we cannot optimize this. */
5929 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
))
5930 && TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
5931 && wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
5933 *strict_overflow_p
= true;
5934 return omit_one_operand (type
, integer_zero_node
, op0
);
5937 /* ... fall through ... */
5939 case TRUNC_DIV_EXPR
: case CEIL_DIV_EXPR
: case FLOOR_DIV_EXPR
:
5940 case ROUND_DIV_EXPR
: case EXACT_DIV_EXPR
:
5941 /* If we can extract our operation from the LHS, do so and return a
5942 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
5943 do something only if the second operand is a constant. */
5945 && (t1
= extract_muldiv (op0
, c
, code
, wide_type
,
5946 strict_overflow_p
)) != 0)
5947 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
5948 fold_convert (ctype
, op1
));
5949 else if (tcode
== MULT_EXPR
&& code
== MULT_EXPR
5950 && (t1
= extract_muldiv (op1
, c
, code
, wide_type
,
5951 strict_overflow_p
)) != 0)
5952 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
5953 fold_convert (ctype
, t1
));
5954 else if (TREE_CODE (op1
) != INTEGER_CST
)
5957 /* If these are the same operation types, we can associate them
5958 assuming no overflow. */
5961 bool overflow_p
= false;
5962 bool overflow_mul_p
;
5963 signop sign
= TYPE_SIGN (ctype
);
5964 wide_int mul
= wi::mul (op1
, c
, sign
, &overflow_mul_p
);
5965 overflow_p
= TREE_OVERFLOW (c
) | TREE_OVERFLOW (op1
);
5967 && ((sign
== UNSIGNED
&& tcode
!= MULT_EXPR
) || sign
== SIGNED
))
5970 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
5971 wide_int_to_tree (ctype
, mul
));
5974 /* If these operations "cancel" each other, we have the main
5975 optimizations of this pass, which occur when either constant is a
5976 multiple of the other, in which case we replace this with either an
5977 operation or CODE or TCODE.
5979 If we have an unsigned type, we cannot do this since it will change
5980 the result if the original computation overflowed. */
5981 if (TYPE_OVERFLOW_UNDEFINED (ctype
)
5982 && ((code
== MULT_EXPR
&& tcode
== EXACT_DIV_EXPR
)
5983 || (tcode
== MULT_EXPR
5984 && code
!= TRUNC_MOD_EXPR
&& code
!= CEIL_MOD_EXPR
5985 && code
!= FLOOR_MOD_EXPR
&& code
!= ROUND_MOD_EXPR
5986 && code
!= MULT_EXPR
)))
5988 if (wi::multiple_of_p (op1
, c
, TYPE_SIGN (type
)))
5990 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
5991 *strict_overflow_p
= true;
5992 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
5993 fold_convert (ctype
,
5994 const_binop (TRUNC_DIV_EXPR
,
5997 else if (wi::multiple_of_p (c
, op1
, TYPE_SIGN (type
)))
5999 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
6000 *strict_overflow_p
= true;
6001 return fold_build2 (code
, ctype
, fold_convert (ctype
, op0
),
6002 fold_convert (ctype
,
6003 const_binop (TRUNC_DIV_EXPR
,
6016 /* Return a node which has the indicated constant VALUE (either 0 or
6017 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6018 and is of the indicated TYPE. */
6021 constant_boolean_node (bool value
, tree type
)
6023 if (type
== integer_type_node
)
6024 return value
? integer_one_node
: integer_zero_node
;
6025 else if (type
== boolean_type_node
)
6026 return value
? boolean_true_node
: boolean_false_node
;
6027 else if (TREE_CODE (type
) == VECTOR_TYPE
)
6028 return build_vector_from_val (type
,
6029 build_int_cst (TREE_TYPE (type
),
6032 return fold_convert (type
, value
? integer_one_node
: integer_zero_node
);
6036 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6037 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6038 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6039 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6040 COND is the first argument to CODE; otherwise (as in the example
6041 given here), it is the second argument. TYPE is the type of the
6042 original expression. Return NULL_TREE if no simplification is
6046 fold_binary_op_with_conditional_arg (location_t loc
,
6047 enum tree_code code
,
6048 tree type
, tree op0
, tree op1
,
6049 tree cond
, tree arg
, int cond_first_p
)
6051 tree cond_type
= cond_first_p
? TREE_TYPE (op0
) : TREE_TYPE (op1
);
6052 tree arg_type
= cond_first_p
? TREE_TYPE (op1
) : TREE_TYPE (op0
);
6053 tree test
, true_value
, false_value
;
6054 tree lhs
= NULL_TREE
;
6055 tree rhs
= NULL_TREE
;
6056 enum tree_code cond_code
= COND_EXPR
;
6058 if (TREE_CODE (cond
) == COND_EXPR
6059 || TREE_CODE (cond
) == VEC_COND_EXPR
)
6061 test
= TREE_OPERAND (cond
, 0);
6062 true_value
= TREE_OPERAND (cond
, 1);
6063 false_value
= TREE_OPERAND (cond
, 2);
6064 /* If this operand throws an expression, then it does not make
6065 sense to try to perform a logical or arithmetic operation
6067 if (VOID_TYPE_P (TREE_TYPE (true_value
)))
6069 if (VOID_TYPE_P (TREE_TYPE (false_value
)))
6074 tree testtype
= TREE_TYPE (cond
);
6076 true_value
= constant_boolean_node (true, testtype
);
6077 false_value
= constant_boolean_node (false, testtype
);
6080 if (TREE_CODE (TREE_TYPE (test
)) == VECTOR_TYPE
)
6081 cond_code
= VEC_COND_EXPR
;
6083 /* This transformation is only worthwhile if we don't have to wrap ARG
6084 in a SAVE_EXPR and the operation can be simplified without recursing
6085 on at least one of the branches once its pushed inside the COND_EXPR. */
6086 if (!TREE_CONSTANT (arg
)
6087 && (TREE_SIDE_EFFECTS (arg
)
6088 || TREE_CODE (arg
) == COND_EXPR
|| TREE_CODE (arg
) == VEC_COND_EXPR
6089 || TREE_CONSTANT (true_value
) || TREE_CONSTANT (false_value
)))
6092 arg
= fold_convert_loc (loc
, arg_type
, arg
);
6095 true_value
= fold_convert_loc (loc
, cond_type
, true_value
);
6097 lhs
= fold_build2_loc (loc
, code
, type
, true_value
, arg
);
6099 lhs
= fold_build2_loc (loc
, code
, type
, arg
, true_value
);
6103 false_value
= fold_convert_loc (loc
, cond_type
, false_value
);
6105 rhs
= fold_build2_loc (loc
, code
, type
, false_value
, arg
);
6107 rhs
= fold_build2_loc (loc
, code
, type
, arg
, false_value
);
6110 /* Check that we have simplified at least one of the branches. */
6111 if (!TREE_CONSTANT (arg
) && !TREE_CONSTANT (lhs
) && !TREE_CONSTANT (rhs
))
6114 return fold_build3_loc (loc
, cond_code
, type
, test
, lhs
, rhs
);
6118 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6120 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6121 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6122 ADDEND is the same as X.
6124 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6125 and finite. The problematic cases are when X is zero, and its mode
6126 has signed zeros. In the case of rounding towards -infinity,
6127 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6128 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6131 fold_real_zero_addition_p (const_tree type
, const_tree addend
, int negate
)
6133 if (!real_zerop (addend
))
6136 /* Don't allow the fold with -fsignaling-nans. */
6137 if (HONOR_SNANS (TYPE_MODE (type
)))
6140 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6141 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
6144 /* In a vector or complex, we would need to check the sign of all zeros. */
6145 if (TREE_CODE (addend
) != REAL_CST
)
6148 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6149 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend
)))
6152 /* The mode has signed zeros, and we have to honor their sign.
6153 In this situation, there is only one case we can return true for.
6154 X - 0 is the same as X unless rounding towards -infinity is
6156 return negate
&& !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
));
6159 /* Subroutine of fold() that checks comparisons of built-in math
6160 functions against real constants.
6162 FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6163 operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR. TYPE
6164 is the type of the result and ARG0 and ARG1 are the operands of the
6165 comparison. ARG1 must be a TREE_REAL_CST.
6167 The function returns the constant folded tree if a simplification
6168 can be made, and NULL_TREE otherwise. */
6171 fold_mathfn_compare (location_t loc
,
6172 enum built_in_function fcode
, enum tree_code code
,
6173 tree type
, tree arg0
, tree arg1
)
6177 if (BUILTIN_SQRT_P (fcode
))
6179 tree arg
= CALL_EXPR_ARG (arg0
, 0);
6180 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (arg0
));
6182 c
= TREE_REAL_CST (arg1
);
6183 if (REAL_VALUE_NEGATIVE (c
))
6185 /* sqrt(x) < y is always false, if y is negative. */
6186 if (code
== EQ_EXPR
|| code
== LT_EXPR
|| code
== LE_EXPR
)
6187 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
6189 /* sqrt(x) > y is always true, if y is negative and we
6190 don't care about NaNs, i.e. negative values of x. */
6191 if (code
== NE_EXPR
|| !HONOR_NANS (mode
))
6192 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
6194 /* sqrt(x) > y is the same as x >= 0, if y is negative. */
6195 return fold_build2_loc (loc
, GE_EXPR
, type
, arg
,
6196 build_real (TREE_TYPE (arg
), dconst0
));
6198 else if (code
== GT_EXPR
|| code
== GE_EXPR
)
6202 REAL_ARITHMETIC (c2
, MULT_EXPR
, c
, c
);
6203 real_convert (&c2
, mode
, &c2
);
6205 if (REAL_VALUE_ISINF (c2
))
6207 /* sqrt(x) > y is x == +Inf, when y is very large. */
6208 if (HONOR_INFINITIES (mode
))
6209 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg
,
6210 build_real (TREE_TYPE (arg
), c2
));
6212 /* sqrt(x) > y is always false, when y is very large
6213 and we don't care about infinities. */
6214 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
6217 /* sqrt(x) > c is the same as x > c*c. */
6218 return fold_build2_loc (loc
, code
, type
, arg
,
6219 build_real (TREE_TYPE (arg
), c2
));
6221 else if (code
== LT_EXPR
|| code
== LE_EXPR
)
6225 REAL_ARITHMETIC (c2
, MULT_EXPR
, c
, c
);
6226 real_convert (&c2
, mode
, &c2
);
6228 if (REAL_VALUE_ISINF (c2
))
6230 /* sqrt(x) < y is always true, when y is a very large
6231 value and we don't care about NaNs or Infinities. */
6232 if (! HONOR_NANS (mode
) && ! HONOR_INFINITIES (mode
))
6233 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
6235 /* sqrt(x) < y is x != +Inf when y is very large and we
6236 don't care about NaNs. */
6237 if (! HONOR_NANS (mode
))
6238 return fold_build2_loc (loc
, NE_EXPR
, type
, arg
,
6239 build_real (TREE_TYPE (arg
), c2
));
6241 /* sqrt(x) < y is x >= 0 when y is very large and we
6242 don't care about Infinities. */
6243 if (! HONOR_INFINITIES (mode
))
6244 return fold_build2_loc (loc
, GE_EXPR
, type
, arg
,
6245 build_real (TREE_TYPE (arg
), dconst0
));
6247 /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large. */
6248 arg
= save_expr (arg
);
6249 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
6250 fold_build2_loc (loc
, GE_EXPR
, type
, arg
,
6251 build_real (TREE_TYPE (arg
),
6253 fold_build2_loc (loc
, NE_EXPR
, type
, arg
,
6254 build_real (TREE_TYPE (arg
),
6258 /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs. */
6259 if (! HONOR_NANS (mode
))
6260 return fold_build2_loc (loc
, code
, type
, arg
,
6261 build_real (TREE_TYPE (arg
), c2
));
6263 /* sqrt(x) < c is the same as x >= 0 && x < c*c. */
6264 arg
= save_expr (arg
);
6265 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
6266 fold_build2_loc (loc
, GE_EXPR
, type
, arg
,
6267 build_real (TREE_TYPE (arg
),
6269 fold_build2_loc (loc
, code
, type
, arg
,
6270 build_real (TREE_TYPE (arg
),
6278 /* Subroutine of fold() that optimizes comparisons against Infinities,
6279 either +Inf or -Inf.
6281 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6282 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6283 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6285 The function returns the constant folded tree if a simplification
6286 can be made, and NULL_TREE otherwise. */
6289 fold_inf_compare (location_t loc
, enum tree_code code
, tree type
,
6290 tree arg0
, tree arg1
)
6292 enum machine_mode mode
;
6293 REAL_VALUE_TYPE max
;
6297 mode
= TYPE_MODE (TREE_TYPE (arg0
));
6299 /* For negative infinity swap the sense of the comparison. */
6300 neg
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
));
6302 code
= swap_tree_comparison (code
);
6307 /* x > +Inf is always false, if with ignore sNANs. */
6308 if (HONOR_SNANS (mode
))
6310 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6313 /* x <= +Inf is always true, if we don't case about NaNs. */
6314 if (! HONOR_NANS (mode
))
6315 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6317 /* x <= +Inf is the same as x == x, i.e. isfinite(x). */
6318 arg0
= save_expr (arg0
);
6319 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
, arg0
);
6323 /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX. */
6324 real_maxval (&max
, neg
, mode
);
6325 return fold_build2_loc (loc
, neg
? LT_EXPR
: GT_EXPR
, type
,
6326 arg0
, build_real (TREE_TYPE (arg0
), max
));
6329 /* x < +Inf is always equal to x <= DBL_MAX. */
6330 real_maxval (&max
, neg
, mode
);
6331 return fold_build2_loc (loc
, neg
? GE_EXPR
: LE_EXPR
, type
,
6332 arg0
, build_real (TREE_TYPE (arg0
), max
));
6335 /* x != +Inf is always equal to !(x > DBL_MAX). */
6336 real_maxval (&max
, neg
, mode
);
6337 if (! HONOR_NANS (mode
))
6338 return fold_build2_loc (loc
, neg
? GE_EXPR
: LE_EXPR
, type
,
6339 arg0
, build_real (TREE_TYPE (arg0
), max
));
6341 temp
= fold_build2_loc (loc
, neg
? LT_EXPR
: GT_EXPR
, type
,
6342 arg0
, build_real (TREE_TYPE (arg0
), max
));
6343 return fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, temp
);
6352 /* Subroutine of fold() that optimizes comparisons of a division by
6353 a nonzero integer constant against an integer constant, i.e.
6356 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6357 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6358 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6360 The function returns the constant folded tree if a simplification
6361 can be made, and NULL_TREE otherwise. */
6364 fold_div_compare (location_t loc
,
6365 enum tree_code code
, tree type
, tree arg0
, tree arg1
)
6367 tree prod
, tmp
, hi
, lo
;
6368 tree arg00
= TREE_OPERAND (arg0
, 0);
6369 tree arg01
= TREE_OPERAND (arg0
, 1);
6370 signop sign
= TYPE_SIGN (TREE_TYPE (arg0
));
6371 bool neg_overflow
= false;
6374 /* We have to do this the hard way to detect unsigned overflow.
6375 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6376 wide_int val
= wi::mul (arg01
, arg1
, sign
, &overflow
);
6377 prod
= force_fit_type (TREE_TYPE (arg00
), val
, -1, overflow
);
6378 neg_overflow
= false;
6380 if (sign
== UNSIGNED
)
6382 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6383 build_int_cst (TREE_TYPE (arg01
), 1));
6386 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6387 val
= wi::add (prod
, tmp
, sign
, &overflow
);
6388 hi
= force_fit_type (TREE_TYPE (arg00
), val
,
6389 -1, overflow
| TREE_OVERFLOW (prod
));
6391 else if (tree_int_cst_sgn (arg01
) >= 0)
6393 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6394 build_int_cst (TREE_TYPE (arg01
), 1));
6395 switch (tree_int_cst_sgn (arg1
))
6398 neg_overflow
= true;
6399 lo
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6404 lo
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6409 hi
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6419 /* A negative divisor reverses the relational operators. */
6420 code
= swap_tree_comparison (code
);
6422 tmp
= int_const_binop (PLUS_EXPR
, arg01
,
6423 build_int_cst (TREE_TYPE (arg01
), 1));
6424 switch (tree_int_cst_sgn (arg1
))
6427 hi
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6432 hi
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6437 neg_overflow
= true;
6438 lo
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6450 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6451 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg00
);
6452 if (TREE_OVERFLOW (hi
))
6453 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6454 if (TREE_OVERFLOW (lo
))
6455 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6456 return build_range_check (loc
, type
, arg00
, 1, lo
, hi
);
6459 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6460 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg00
);
6461 if (TREE_OVERFLOW (hi
))
6462 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6463 if (TREE_OVERFLOW (lo
))
6464 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6465 return build_range_check (loc
, type
, arg00
, 0, lo
, hi
);
6468 if (TREE_OVERFLOW (lo
))
6470 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6471 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6473 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6476 if (TREE_OVERFLOW (hi
))
6478 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6479 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6481 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6484 if (TREE_OVERFLOW (hi
))
6486 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6487 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6489 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6492 if (TREE_OVERFLOW (lo
))
6494 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6495 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6497 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6507 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6508 equality/inequality test, then return a simplified form of the test
6509 using a sign testing. Otherwise return NULL. TYPE is the desired
6513 fold_single_bit_test_into_sign_test (location_t loc
,
6514 enum tree_code code
, tree arg0
, tree arg1
,
6517 /* If this is testing a single bit, we can optimize the test. */
6518 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6519 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6520 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6522 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6523 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6524 tree arg00
= sign_bit_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1));
6526 if (arg00
!= NULL_TREE
6527 /* This is only a win if casting to a signed type is cheap,
6528 i.e. when arg00's type is not a partial mode. */
6529 && TYPE_PRECISION (TREE_TYPE (arg00
))
6530 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg00
))))
6532 tree stype
= signed_type_for (TREE_TYPE (arg00
));
6533 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
6535 fold_convert_loc (loc
, stype
, arg00
),
6536 build_int_cst (stype
, 0));
6543 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6544 equality/inequality test, then return a simplified form of
6545 the test using shifts and logical operations. Otherwise return
6546 NULL. TYPE is the desired result type. */
6549 fold_single_bit_test (location_t loc
, enum tree_code code
,
6550 tree arg0
, tree arg1
, tree result_type
)
6552 /* If this is testing a single bit, we can optimize the test. */
6553 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6554 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6555 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6557 tree inner
= TREE_OPERAND (arg0
, 0);
6558 tree type
= TREE_TYPE (arg0
);
6559 int bitnum
= tree_log2 (TREE_OPERAND (arg0
, 1));
6560 enum machine_mode operand_mode
= TYPE_MODE (type
);
6562 tree signed_type
, unsigned_type
, intermediate_type
;
6565 /* First, see if we can fold the single bit test into a sign-bit
6567 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
,
6572 /* Otherwise we have (A & C) != 0 where C is a single bit,
6573 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6574 Similarly for (A & C) == 0. */
6576 /* If INNER is a right shift of a constant and it plus BITNUM does
6577 not overflow, adjust BITNUM and INNER. */
6578 if (TREE_CODE (inner
) == RSHIFT_EXPR
6579 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
6580 && bitnum
< TYPE_PRECISION (type
)
6581 && wi::ltu_p (TREE_OPERAND (inner
, 1),
6582 TYPE_PRECISION (type
) - bitnum
))
6584 bitnum
+= tree_to_uhwi (TREE_OPERAND (inner
, 1));
6585 inner
= TREE_OPERAND (inner
, 0);
6588 /* If we are going to be able to omit the AND below, we must do our
6589 operations as unsigned. If we must use the AND, we have a choice.
6590 Normally unsigned is faster, but for some machines signed is. */
6591 #ifdef LOAD_EXTEND_OP
6592 ops_unsigned
= (LOAD_EXTEND_OP (operand_mode
) == SIGN_EXTEND
6593 && !flag_syntax_only
) ? 0 : 1;
6598 signed_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 0);
6599 unsigned_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 1);
6600 intermediate_type
= ops_unsigned
? unsigned_type
: signed_type
;
6601 inner
= fold_convert_loc (loc
, intermediate_type
, inner
);
6604 inner
= build2 (RSHIFT_EXPR
, intermediate_type
,
6605 inner
, size_int (bitnum
));
6607 one
= build_int_cst (intermediate_type
, 1);
6609 if (code
== EQ_EXPR
)
6610 inner
= fold_build2_loc (loc
, BIT_XOR_EXPR
, intermediate_type
, inner
, one
);
6612 /* Put the AND last so it can combine with more things. */
6613 inner
= build2 (BIT_AND_EXPR
, intermediate_type
, inner
, one
);
6615 /* Make sure to return the proper type. */
6616 inner
= fold_convert_loc (loc
, result_type
, inner
);
6623 /* Check whether we are allowed to reorder operands arg0 and arg1,
6624 such that the evaluation of arg1 occurs before arg0. */
6627 reorder_operands_p (const_tree arg0
, const_tree arg1
)
6629 if (! flag_evaluation_order
)
6631 if (TREE_CONSTANT (arg0
) || TREE_CONSTANT (arg1
))
6633 return ! TREE_SIDE_EFFECTS (arg0
)
6634 && ! TREE_SIDE_EFFECTS (arg1
);
6637 /* Test whether it is preferable two swap two operands, ARG0 and
6638 ARG1, for example because ARG0 is an integer constant and ARG1
6639 isn't. If REORDER is true, only recommend swapping if we can
6640 evaluate the operands in reverse order. */
6643 tree_swap_operands_p (const_tree arg0
, const_tree arg1
, bool reorder
)
6645 if (CONSTANT_CLASS_P (arg1
))
6647 if (CONSTANT_CLASS_P (arg0
))
6650 STRIP_SIGN_NOPS (arg0
);
6651 STRIP_SIGN_NOPS (arg1
);
6653 if (TREE_CONSTANT (arg1
))
6655 if (TREE_CONSTANT (arg0
))
6658 if (reorder
&& flag_evaluation_order
6659 && (TREE_SIDE_EFFECTS (arg0
) || TREE_SIDE_EFFECTS (arg1
)))
6662 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6663 for commutative and comparison operators. Ensuring a canonical
6664 form allows the optimizers to find additional redundancies without
6665 having to explicitly check for both orderings. */
6666 if (TREE_CODE (arg0
) == SSA_NAME
6667 && TREE_CODE (arg1
) == SSA_NAME
6668 && SSA_NAME_VERSION (arg0
) > SSA_NAME_VERSION (arg1
))
6671 /* Put SSA_NAMEs last. */
6672 if (TREE_CODE (arg1
) == SSA_NAME
)
6674 if (TREE_CODE (arg0
) == SSA_NAME
)
6677 /* Put variables last. */
6686 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6687 ARG0 is extended to a wider type. */
6690 fold_widened_comparison (location_t loc
, enum tree_code code
,
6691 tree type
, tree arg0
, tree arg1
)
6693 tree arg0_unw
= get_unwidened (arg0
, NULL_TREE
);
6695 tree shorter_type
, outer_type
;
6699 if (arg0_unw
== arg0
)
6701 shorter_type
= TREE_TYPE (arg0_unw
);
6703 #ifdef HAVE_canonicalize_funcptr_for_compare
6704 /* Disable this optimization if we're casting a function pointer
6705 type on targets that require function pointer canonicalization. */
6706 if (HAVE_canonicalize_funcptr_for_compare
6707 && TREE_CODE (shorter_type
) == POINTER_TYPE
6708 && TREE_CODE (TREE_TYPE (shorter_type
)) == FUNCTION_TYPE
)
6712 if (TYPE_PRECISION (TREE_TYPE (arg0
)) <= TYPE_PRECISION (shorter_type
))
6715 arg1_unw
= get_unwidened (arg1
, NULL_TREE
);
6717 /* If possible, express the comparison in the shorter mode. */
6718 if ((code
== EQ_EXPR
|| code
== NE_EXPR
6719 || TYPE_UNSIGNED (TREE_TYPE (arg0
)) == TYPE_UNSIGNED (shorter_type
))
6720 && (TREE_TYPE (arg1_unw
) == shorter_type
6721 || ((TYPE_PRECISION (shorter_type
)
6722 >= TYPE_PRECISION (TREE_TYPE (arg1_unw
)))
6723 && (TYPE_UNSIGNED (shorter_type
)
6724 == TYPE_UNSIGNED (TREE_TYPE (arg1_unw
))))
6725 || (TREE_CODE (arg1_unw
) == INTEGER_CST
6726 && (TREE_CODE (shorter_type
) == INTEGER_TYPE
6727 || TREE_CODE (shorter_type
) == BOOLEAN_TYPE
)
6728 && int_fits_type_p (arg1_unw
, shorter_type
))))
6729 return fold_build2_loc (loc
, code
, type
, arg0_unw
,
6730 fold_convert_loc (loc
, shorter_type
, arg1_unw
));
6732 if (TREE_CODE (arg1_unw
) != INTEGER_CST
6733 || TREE_CODE (shorter_type
) != INTEGER_TYPE
6734 || !int_fits_type_p (arg1_unw
, shorter_type
))
6737 /* If we are comparing with the integer that does not fit into the range
6738 of the shorter type, the result is known. */
6739 outer_type
= TREE_TYPE (arg1_unw
);
6740 min
= lower_bound_in_type (outer_type
, shorter_type
);
6741 max
= upper_bound_in_type (outer_type
, shorter_type
);
6743 above
= integer_nonzerop (fold_relational_const (LT_EXPR
, type
,
6745 below
= integer_nonzerop (fold_relational_const (LT_EXPR
, type
,
6752 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6757 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6763 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6765 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6770 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6772 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6781 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6782 ARG0 just the signedness is changed. */
6785 fold_sign_changed_comparison (location_t loc
, enum tree_code code
, tree type
,
6786 tree arg0
, tree arg1
)
6789 tree inner_type
, outer_type
;
6791 if (!CONVERT_EXPR_P (arg0
))
6794 outer_type
= TREE_TYPE (arg0
);
6795 arg0_inner
= TREE_OPERAND (arg0
, 0);
6796 inner_type
= TREE_TYPE (arg0_inner
);
6798 #ifdef HAVE_canonicalize_funcptr_for_compare
6799 /* Disable this optimization if we're casting a function pointer
6800 type on targets that require function pointer canonicalization. */
6801 if (HAVE_canonicalize_funcptr_for_compare
6802 && TREE_CODE (inner_type
) == POINTER_TYPE
6803 && TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
)
6807 if (TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
6810 if (TREE_CODE (arg1
) != INTEGER_CST
6811 && !(CONVERT_EXPR_P (arg1
)
6812 && TREE_TYPE (TREE_OPERAND (arg1
, 0)) == inner_type
))
6815 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
6820 if (POINTER_TYPE_P (inner_type
) != POINTER_TYPE_P (outer_type
))
6823 if (TREE_CODE (arg1
) == INTEGER_CST
)
6824 arg1
= force_fit_type (inner_type
, wi::to_widest (arg1
), 0,
6825 TREE_OVERFLOW (arg1
));
6827 arg1
= fold_convert_loc (loc
, inner_type
, arg1
);
6829 return fold_build2_loc (loc
, code
, type
, arg0_inner
, arg1
);
6833 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6834 means A >= Y && A != MAX, but in this case we know that
6835 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6838 fold_to_nonsharp_ineq_using_bound (location_t loc
, tree ineq
, tree bound
)
6840 tree a
, typea
, type
= TREE_TYPE (ineq
), a1
, diff
, y
;
6842 if (TREE_CODE (bound
) == LT_EXPR
)
6843 a
= TREE_OPERAND (bound
, 0);
6844 else if (TREE_CODE (bound
) == GT_EXPR
)
6845 a
= TREE_OPERAND (bound
, 1);
6849 typea
= TREE_TYPE (a
);
6850 if (!INTEGRAL_TYPE_P (typea
)
6851 && !POINTER_TYPE_P (typea
))
6854 if (TREE_CODE (ineq
) == LT_EXPR
)
6856 a1
= TREE_OPERAND (ineq
, 1);
6857 y
= TREE_OPERAND (ineq
, 0);
6859 else if (TREE_CODE (ineq
) == GT_EXPR
)
6861 a1
= TREE_OPERAND (ineq
, 0);
6862 y
= TREE_OPERAND (ineq
, 1);
6867 if (TREE_TYPE (a1
) != typea
)
6870 if (POINTER_TYPE_P (typea
))
6872 /* Convert the pointer types into integer before taking the difference. */
6873 tree ta
= fold_convert_loc (loc
, ssizetype
, a
);
6874 tree ta1
= fold_convert_loc (loc
, ssizetype
, a1
);
6875 diff
= fold_binary_loc (loc
, MINUS_EXPR
, ssizetype
, ta1
, ta
);
6878 diff
= fold_binary_loc (loc
, MINUS_EXPR
, typea
, a1
, a
);
6880 if (!diff
|| !integer_onep (diff
))
6883 return fold_build2_loc (loc
, GE_EXPR
, type
, a
, y
);
6886 /* Fold a sum or difference of at least one multiplication.
6887 Returns the folded tree or NULL if no simplification could be made. */
6890 fold_plusminus_mult_expr (location_t loc
, enum tree_code code
, tree type
,
6891 tree arg0
, tree arg1
)
6893 tree arg00
, arg01
, arg10
, arg11
;
6894 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
6896 /* (A * C) +- (B * C) -> (A+-B) * C.
6897 (A * C) +- A -> A * (C+-1).
6898 We are most concerned about the case where C is a constant,
6899 but other combinations show up during loop reduction. Since
6900 it is not difficult, try all four possibilities. */
6902 if (TREE_CODE (arg0
) == MULT_EXPR
)
6904 arg00
= TREE_OPERAND (arg0
, 0);
6905 arg01
= TREE_OPERAND (arg0
, 1);
6907 else if (TREE_CODE (arg0
) == INTEGER_CST
)
6909 arg00
= build_one_cst (type
);
6914 /* We cannot generate constant 1 for fract. */
6915 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
6918 arg01
= build_one_cst (type
);
6920 if (TREE_CODE (arg1
) == MULT_EXPR
)
6922 arg10
= TREE_OPERAND (arg1
, 0);
6923 arg11
= TREE_OPERAND (arg1
, 1);
6925 else if (TREE_CODE (arg1
) == INTEGER_CST
)
6927 arg10
= build_one_cst (type
);
6928 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
6929 the purpose of this canonicalization. */
6930 if (wi::neg_p (arg1
, TYPE_SIGN (TREE_TYPE (arg1
)))
6931 && negate_expr_p (arg1
)
6932 && code
== PLUS_EXPR
)
6934 arg11
= negate_expr (arg1
);
6942 /* We cannot generate constant 1 for fract. */
6943 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
6946 arg11
= build_one_cst (type
);
6950 if (operand_equal_p (arg01
, arg11
, 0))
6951 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
6952 else if (operand_equal_p (arg00
, arg10
, 0))
6953 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
6954 else if (operand_equal_p (arg00
, arg11
, 0))
6955 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
6956 else if (operand_equal_p (arg01
, arg10
, 0))
6957 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
6959 /* No identical multiplicands; see if we can find a common
6960 power-of-two factor in non-power-of-two multiplies. This
6961 can help in multi-dimensional array access. */
6962 else if (tree_fits_shwi_p (arg01
)
6963 && tree_fits_shwi_p (arg11
))
6965 HOST_WIDE_INT int01
, int11
, tmp
;
6968 int01
= tree_to_shwi (arg01
);
6969 int11
= tree_to_shwi (arg11
);
6971 /* Move min of absolute values to int11. */
6972 if (absu_hwi (int01
) < absu_hwi (int11
))
6974 tmp
= int01
, int01
= int11
, int11
= tmp
;
6975 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
6982 if (exact_log2 (absu_hwi (int11
)) > 0 && int01
% int11
== 0
6983 /* The remainder should not be a constant, otherwise we
6984 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
6985 increased the number of multiplications necessary. */
6986 && TREE_CODE (arg10
) != INTEGER_CST
)
6988 alt0
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (arg00
), arg00
,
6989 build_int_cst (TREE_TYPE (arg00
),
6994 maybe_same
= alt0
, alt0
= alt1
, alt1
= maybe_same
;
6999 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7000 fold_build2_loc (loc
, code
, type
,
7001 fold_convert_loc (loc
, type
, alt0
),
7002 fold_convert_loc (loc
, type
, alt1
)),
7003 fold_convert_loc (loc
, type
, same
));
7008 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7009 specified by EXPR into the buffer PTR of length LEN bytes.
7010 Return the number of bytes placed in the buffer, or zero
7014 native_encode_int (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7016 tree type
= TREE_TYPE (expr
);
7017 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7018 int byte
, offset
, word
, words
;
7019 unsigned char value
;
7021 if ((off
== -1 && total_bytes
> len
)
7022 || off
>= total_bytes
)
7026 words
= total_bytes
/ UNITS_PER_WORD
;
7028 for (byte
= 0; byte
< total_bytes
; byte
++)
7030 int bitpos
= byte
* BITS_PER_UNIT
;
7031 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7033 value
= wi::extract_uhwi (wi::to_widest (expr
), bitpos
, BITS_PER_UNIT
);
7035 if (total_bytes
> UNITS_PER_WORD
)
7037 word
= byte
/ UNITS_PER_WORD
;
7038 if (WORDS_BIG_ENDIAN
)
7039 word
= (words
- 1) - word
;
7040 offset
= word
* UNITS_PER_WORD
;
7041 if (BYTES_BIG_ENDIAN
)
7042 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7044 offset
+= byte
% UNITS_PER_WORD
;
7047 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
7049 && offset
- off
< len
)
7050 ptr
[offset
- off
] = value
;
7052 return MIN (len
, total_bytes
- off
);
7056 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7057 specified by EXPR into the buffer PTR of length LEN bytes.
7058 Return the number of bytes placed in the buffer, or zero
7062 native_encode_fixed (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7064 tree type
= TREE_TYPE (expr
);
7065 enum machine_mode mode
= TYPE_MODE (type
);
7066 int total_bytes
= GET_MODE_SIZE (mode
);
7067 FIXED_VALUE_TYPE value
;
7068 tree i_value
, i_type
;
7070 if (total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7073 i_type
= lang_hooks
.types
.type_for_size (GET_MODE_BITSIZE (mode
), 1);
7075 if (NULL_TREE
== i_type
7076 || TYPE_PRECISION (i_type
) != total_bytes
)
7079 value
= TREE_FIXED_CST (expr
);
7080 i_value
= double_int_to_tree (i_type
, value
.data
);
7082 return native_encode_int (i_value
, ptr
, len
, off
);
7086 /* Subroutine of native_encode_expr. Encode the REAL_CST
7087 specified by EXPR into the buffer PTR of length LEN bytes.
7088 Return the number of bytes placed in the buffer, or zero
7092 native_encode_real (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7094 tree type
= TREE_TYPE (expr
);
7095 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7096 int byte
, offset
, word
, words
, bitpos
;
7097 unsigned char value
;
7099 /* There are always 32 bits in each long, no matter the size of
7100 the hosts long. We handle floating point representations with
7104 if ((off
== -1 && total_bytes
> len
)
7105 || off
>= total_bytes
)
7109 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7111 real_to_target (tmp
, TREE_REAL_CST_PTR (expr
), TYPE_MODE (type
));
7113 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7114 bitpos
+= BITS_PER_UNIT
)
7116 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7117 value
= (unsigned char) (tmp
[bitpos
/ 32] >> (bitpos
& 31));
7119 if (UNITS_PER_WORD
< 4)
7121 word
= byte
/ UNITS_PER_WORD
;
7122 if (WORDS_BIG_ENDIAN
)
7123 word
= (words
- 1) - word
;
7124 offset
= word
* UNITS_PER_WORD
;
7125 if (BYTES_BIG_ENDIAN
)
7126 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7128 offset
+= byte
% UNITS_PER_WORD
;
7131 offset
= BYTES_BIG_ENDIAN
? 3 - byte
: byte
;
7132 offset
= offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3);
7134 && offset
- off
< len
)
7135 ptr
[offset
- off
] = value
;
7137 return MIN (len
, total_bytes
- off
);
7140 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7141 specified by EXPR into the buffer PTR of length LEN bytes.
7142 Return the number of bytes placed in the buffer, or zero
7146 native_encode_complex (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7151 part
= TREE_REALPART (expr
);
7152 rsize
= native_encode_expr (part
, ptr
, len
, off
);
7156 part
= TREE_IMAGPART (expr
);
7158 off
= MAX (0, off
- GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (part
))));
7159 isize
= native_encode_expr (part
, ptr
+rsize
, len
-rsize
, off
);
7163 return rsize
+ isize
;
7167 /* Subroutine of native_encode_expr. Encode the VECTOR_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_vector (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7180 count
= VECTOR_CST_NELTS (expr
);
7181 itype
= TREE_TYPE (TREE_TYPE (expr
));
7182 size
= GET_MODE_SIZE (TYPE_MODE (itype
));
7183 for (i
= 0; i
< count
; i
++)
7190 elem
= VECTOR_CST_ELT (expr
, i
);
7191 int res
= native_encode_expr (elem
, ptr
+offset
, len
-offset
, off
);
7192 if ((off
== -1 && res
!= size
)
7205 /* Subroutine of native_encode_expr. Encode the STRING_CST
7206 specified by EXPR into the buffer PTR of length LEN bytes.
7207 Return the number of bytes placed in the buffer, or zero
7211 native_encode_string (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7213 tree type
= TREE_TYPE (expr
);
7214 HOST_WIDE_INT total_bytes
;
7216 if (TREE_CODE (type
) != ARRAY_TYPE
7217 || TREE_CODE (TREE_TYPE (type
)) != INTEGER_TYPE
7218 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))) != BITS_PER_UNIT
7219 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type
)))
7221 total_bytes
= tree_to_shwi (TYPE_SIZE_UNIT (type
));
7222 if ((off
== -1 && total_bytes
> len
)
7223 || off
>= total_bytes
)
7227 if (TREE_STRING_LENGTH (expr
) - off
< MIN (total_bytes
, len
))
7230 if (off
< TREE_STRING_LENGTH (expr
))
7232 written
= MIN (len
, TREE_STRING_LENGTH (expr
) - off
);
7233 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, written
);
7235 memset (ptr
+ written
, 0,
7236 MIN (total_bytes
- written
, len
- written
));
7239 memcpy (ptr
, TREE_STRING_POINTER (expr
) + off
, MIN (total_bytes
, len
));
7240 return MIN (total_bytes
- off
, len
);
7244 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7245 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7246 buffer PTR of length LEN bytes. If OFF is not -1 then start
7247 the encoding at byte offset OFF and encode at most LEN bytes.
7248 Return the number of bytes placed in the buffer, or zero upon failure. */
7251 native_encode_expr (const_tree expr
, unsigned char *ptr
, int len
, int off
)
7253 switch (TREE_CODE (expr
))
7256 return native_encode_int (expr
, ptr
, len
, off
);
7259 return native_encode_real (expr
, ptr
, len
, off
);
7262 return native_encode_fixed (expr
, ptr
, len
, off
);
7265 return native_encode_complex (expr
, ptr
, len
, off
);
7268 return native_encode_vector (expr
, ptr
, len
, off
);
7271 return native_encode_string (expr
, ptr
, len
, off
);
7279 /* Subroutine of native_interpret_expr. Interpret the contents of
7280 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7281 If the buffer cannot be interpreted, return NULL_TREE. */
7284 native_interpret_int (tree type
, const unsigned char *ptr
, int len
)
7286 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7288 if (total_bytes
> len
7289 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7292 wide_int result
= wi::from_buffer (ptr
, total_bytes
);
7294 return wide_int_to_tree (type
, result
);
7298 /* Subroutine of native_interpret_expr. Interpret the contents of
7299 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7300 If the buffer cannot be interpreted, return NULL_TREE. */
7303 native_interpret_fixed (tree type
, const unsigned char *ptr
, int len
)
7305 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7307 FIXED_VALUE_TYPE fixed_value
;
7309 if (total_bytes
> len
7310 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7313 result
= double_int::from_buffer (ptr
, total_bytes
);
7314 fixed_value
= fixed_from_double_int (result
, TYPE_MODE (type
));
7316 return build_fixed (type
, fixed_value
);
7320 /* Subroutine of native_interpret_expr. Interpret the contents of
7321 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7322 If the buffer cannot be interpreted, return NULL_TREE. */
7325 native_interpret_real (tree type
, const unsigned char *ptr
, int len
)
7327 enum machine_mode mode
= TYPE_MODE (type
);
7328 int total_bytes
= GET_MODE_SIZE (mode
);
7329 int byte
, offset
, word
, words
, bitpos
;
7330 unsigned char value
;
7331 /* There are always 32 bits in each long, no matter the size of
7332 the hosts long. We handle floating point representations with
7337 total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7338 if (total_bytes
> len
|| total_bytes
> 24)
7340 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7342 memset (tmp
, 0, sizeof (tmp
));
7343 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7344 bitpos
+= BITS_PER_UNIT
)
7346 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7347 if (UNITS_PER_WORD
< 4)
7349 word
= byte
/ UNITS_PER_WORD
;
7350 if (WORDS_BIG_ENDIAN
)
7351 word
= (words
- 1) - word
;
7352 offset
= word
* UNITS_PER_WORD
;
7353 if (BYTES_BIG_ENDIAN
)
7354 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7356 offset
+= byte
% UNITS_PER_WORD
;
7359 offset
= BYTES_BIG_ENDIAN
? 3 - byte
: byte
;
7360 value
= ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)];
7362 tmp
[bitpos
/ 32] |= (unsigned long)value
<< (bitpos
& 31);
7365 real_from_target (&r
, tmp
, mode
);
7366 return build_real (type
, r
);
7370 /* Subroutine of native_interpret_expr. Interpret the contents of
7371 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7372 If the buffer cannot be interpreted, return NULL_TREE. */
7375 native_interpret_complex (tree type
, const unsigned char *ptr
, int len
)
7377 tree etype
, rpart
, ipart
;
7380 etype
= TREE_TYPE (type
);
7381 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7384 rpart
= native_interpret_expr (etype
, ptr
, size
);
7387 ipart
= native_interpret_expr (etype
, ptr
+size
, size
);
7390 return build_complex (type
, rpart
, ipart
);
7394 /* Subroutine of native_interpret_expr. Interpret the contents of
7395 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7396 If the buffer cannot be interpreted, return NULL_TREE. */
7399 native_interpret_vector (tree type
, const unsigned char *ptr
, int len
)
7405 etype
= TREE_TYPE (type
);
7406 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7407 count
= TYPE_VECTOR_SUBPARTS (type
);
7408 if (size
* count
> len
)
7411 elements
= XALLOCAVEC (tree
, count
);
7412 for (i
= count
- 1; i
>= 0; i
--)
7414 elem
= native_interpret_expr (etype
, ptr
+(i
*size
), size
);
7419 return build_vector (type
, elements
);
7423 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7424 the buffer PTR of length LEN as a constant of type TYPE. For
7425 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7426 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7427 return NULL_TREE. */
7430 native_interpret_expr (tree type
, const unsigned char *ptr
, int len
)
7432 switch (TREE_CODE (type
))
7438 case REFERENCE_TYPE
:
7439 return native_interpret_int (type
, ptr
, len
);
7442 return native_interpret_real (type
, ptr
, len
);
7444 case FIXED_POINT_TYPE
:
7445 return native_interpret_fixed (type
, ptr
, len
);
7448 return native_interpret_complex (type
, ptr
, len
);
7451 return native_interpret_vector (type
, ptr
, len
);
7458 /* Returns true if we can interpret the contents of a native encoding
7462 can_native_interpret_type_p (tree type
)
7464 switch (TREE_CODE (type
))
7470 case REFERENCE_TYPE
:
7471 case FIXED_POINT_TYPE
:
7481 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7482 TYPE at compile-time. If we're unable to perform the conversion
7483 return NULL_TREE. */
7486 fold_view_convert_expr (tree type
, tree expr
)
7488 /* We support up to 512-bit values (for V8DFmode). */
7489 unsigned char buffer
[64];
7492 /* Check that the host and target are sane. */
7493 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
7496 len
= native_encode_expr (expr
, buffer
, sizeof (buffer
));
7500 return native_interpret_expr (type
, buffer
, len
);
7503 /* Build an expression for the address of T. Folds away INDIRECT_REF
7504 to avoid confusing the gimplify process. */
7507 build_fold_addr_expr_with_type_loc (location_t loc
, tree t
, tree ptrtype
)
7509 /* The size of the object is not relevant when talking about its address. */
7510 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
7511 t
= TREE_OPERAND (t
, 0);
7513 if (TREE_CODE (t
) == INDIRECT_REF
)
7515 t
= TREE_OPERAND (t
, 0);
7517 if (TREE_TYPE (t
) != ptrtype
)
7518 t
= build1_loc (loc
, NOP_EXPR
, ptrtype
, t
);
7520 else if (TREE_CODE (t
) == MEM_REF
7521 && integer_zerop (TREE_OPERAND (t
, 1)))
7522 return TREE_OPERAND (t
, 0);
7523 else if (TREE_CODE (t
) == MEM_REF
7524 && TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
7525 return fold_binary (POINTER_PLUS_EXPR
, ptrtype
,
7526 TREE_OPERAND (t
, 0),
7527 convert_to_ptrofftype (TREE_OPERAND (t
, 1)));
7528 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
7530 t
= build_fold_addr_expr_loc (loc
, TREE_OPERAND (t
, 0));
7532 if (TREE_TYPE (t
) != ptrtype
)
7533 t
= fold_convert_loc (loc
, ptrtype
, t
);
7536 t
= build1_loc (loc
, ADDR_EXPR
, ptrtype
, t
);
7541 /* Build an expression for the address of T. */
7544 build_fold_addr_expr_loc (location_t loc
, tree t
)
7546 tree ptrtype
= build_pointer_type (TREE_TYPE (t
));
7548 return build_fold_addr_expr_with_type_loc (loc
, t
, ptrtype
);
7551 static bool vec_cst_ctor_to_array (tree
, tree
*);
7553 /* Fold a unary expression of code CODE and type TYPE with operand
7554 OP0. Return the folded expression if folding is successful.
7555 Otherwise, return NULL_TREE. */
7558 fold_unary_loc (location_t loc
, enum tree_code code
, tree type
, tree op0
)
7562 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
7564 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
7565 && TREE_CODE_LENGTH (code
) == 1);
7570 if (CONVERT_EXPR_CODE_P (code
)
7571 || code
== FLOAT_EXPR
|| code
== ABS_EXPR
|| code
== NEGATE_EXPR
)
7573 /* Don't use STRIP_NOPS, because signedness of argument type
7575 STRIP_SIGN_NOPS (arg0
);
7579 /* Strip any conversions that don't change the mode. This
7580 is safe for every expression, except for a comparison
7581 expression because its signedness is derived from its
7584 Note that this is done as an internal manipulation within
7585 the constant folder, in order to find the simplest
7586 representation of the arguments so that their form can be
7587 studied. In any cases, the appropriate type conversions
7588 should be put back in the tree that will get out of the
7594 if (TREE_CODE_CLASS (code
) == tcc_unary
)
7596 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
7597 return build2 (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7598 fold_build1_loc (loc
, code
, type
,
7599 fold_convert_loc (loc
, TREE_TYPE (op0
),
7600 TREE_OPERAND (arg0
, 1))));
7601 else if (TREE_CODE (arg0
) == COND_EXPR
)
7603 tree arg01
= TREE_OPERAND (arg0
, 1);
7604 tree arg02
= TREE_OPERAND (arg0
, 2);
7605 if (! VOID_TYPE_P (TREE_TYPE (arg01
)))
7606 arg01
= fold_build1_loc (loc
, code
, type
,
7607 fold_convert_loc (loc
,
7608 TREE_TYPE (op0
), arg01
));
7609 if (! VOID_TYPE_P (TREE_TYPE (arg02
)))
7610 arg02
= fold_build1_loc (loc
, code
, type
,
7611 fold_convert_loc (loc
,
7612 TREE_TYPE (op0
), arg02
));
7613 tem
= fold_build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7616 /* If this was a conversion, and all we did was to move into
7617 inside the COND_EXPR, bring it back out. But leave it if
7618 it is a conversion from integer to integer and the
7619 result precision is no wider than a word since such a
7620 conversion is cheap and may be optimized away by combine,
7621 while it couldn't if it were outside the COND_EXPR. Then return
7622 so we don't get into an infinite recursion loop taking the
7623 conversion out and then back in. */
7625 if ((CONVERT_EXPR_CODE_P (code
)
7626 || code
== NON_LVALUE_EXPR
)
7627 && TREE_CODE (tem
) == COND_EXPR
7628 && TREE_CODE (TREE_OPERAND (tem
, 1)) == code
7629 && TREE_CODE (TREE_OPERAND (tem
, 2)) == code
7630 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 1))
7631 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 2))
7632 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))
7633 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 2), 0)))
7634 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7636 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))))
7637 && TYPE_PRECISION (TREE_TYPE (tem
)) <= BITS_PER_WORD
)
7638 || flag_syntax_only
))
7639 tem
= build1_loc (loc
, code
, type
,
7641 TREE_TYPE (TREE_OPERAND
7642 (TREE_OPERAND (tem
, 1), 0)),
7643 TREE_OPERAND (tem
, 0),
7644 TREE_OPERAND (TREE_OPERAND (tem
, 1), 0),
7645 TREE_OPERAND (TREE_OPERAND (tem
, 2),
7654 /* Re-association barriers around constants and other re-association
7655 barriers can be removed. */
7656 if (CONSTANT_CLASS_P (op0
)
7657 || TREE_CODE (op0
) == PAREN_EXPR
)
7658 return fold_convert_loc (loc
, type
, op0
);
7661 case NON_LVALUE_EXPR
:
7662 if (!maybe_lvalue_p (op0
))
7663 return fold_convert_loc (loc
, type
, op0
);
7668 case FIX_TRUNC_EXPR
:
7669 if (TREE_TYPE (op0
) == type
)
7672 if (COMPARISON_CLASS_P (op0
))
7674 /* If we have (type) (a CMP b) and type is an integral type, return
7675 new expression involving the new type. Canonicalize
7676 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7678 Do not fold the result as that would not simplify further, also
7679 folding again results in recursions. */
7680 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
7681 return build2_loc (loc
, TREE_CODE (op0
), type
,
7682 TREE_OPERAND (op0
, 0),
7683 TREE_OPERAND (op0
, 1));
7684 else if (!INTEGRAL_TYPE_P (type
) && !VOID_TYPE_P (type
)
7685 && TREE_CODE (type
) != VECTOR_TYPE
)
7686 return build3_loc (loc
, COND_EXPR
, type
, op0
,
7687 constant_boolean_node (true, type
),
7688 constant_boolean_node (false, type
));
7691 /* Handle cases of two conversions in a row. */
7692 if (CONVERT_EXPR_P (op0
))
7694 tree inside_type
= TREE_TYPE (TREE_OPERAND (op0
, 0));
7695 tree inter_type
= TREE_TYPE (op0
);
7696 int inside_int
= INTEGRAL_TYPE_P (inside_type
);
7697 int inside_ptr
= POINTER_TYPE_P (inside_type
);
7698 int inside_float
= FLOAT_TYPE_P (inside_type
);
7699 int inside_vec
= TREE_CODE (inside_type
) == VECTOR_TYPE
;
7700 unsigned int inside_prec
= TYPE_PRECISION (inside_type
);
7701 int inside_unsignedp
= TYPE_UNSIGNED (inside_type
);
7702 int inter_int
= INTEGRAL_TYPE_P (inter_type
);
7703 int inter_ptr
= POINTER_TYPE_P (inter_type
);
7704 int inter_float
= FLOAT_TYPE_P (inter_type
);
7705 int inter_vec
= TREE_CODE (inter_type
) == VECTOR_TYPE
;
7706 unsigned int inter_prec
= TYPE_PRECISION (inter_type
);
7707 int inter_unsignedp
= TYPE_UNSIGNED (inter_type
);
7708 int final_int
= INTEGRAL_TYPE_P (type
);
7709 int final_ptr
= POINTER_TYPE_P (type
);
7710 int final_float
= FLOAT_TYPE_P (type
);
7711 int final_vec
= TREE_CODE (type
) == VECTOR_TYPE
;
7712 unsigned int final_prec
= TYPE_PRECISION (type
);
7713 int final_unsignedp
= TYPE_UNSIGNED (type
);
7715 /* In addition to the cases of two conversions in a row
7716 handled below, if we are converting something to its own
7717 type via an object of identical or wider precision, neither
7718 conversion is needed. */
7719 if (TYPE_MAIN_VARIANT (inside_type
) == TYPE_MAIN_VARIANT (type
)
7720 && (((inter_int
|| inter_ptr
) && final_int
)
7721 || (inter_float
&& final_float
))
7722 && inter_prec
>= final_prec
)
7723 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7725 /* Likewise, if the intermediate and initial types are either both
7726 float or both integer, we don't need the middle conversion if the
7727 former is wider than the latter and doesn't change the signedness
7728 (for integers). Avoid this if the final type is a pointer since
7729 then we sometimes need the middle conversion. Likewise if the
7730 final type has a precision not equal to the size of its mode. */
7731 if (((inter_int
&& inside_int
)
7732 || (inter_float
&& inside_float
)
7733 || (inter_vec
&& inside_vec
))
7734 && inter_prec
>= inside_prec
7735 && (inter_float
|| inter_vec
7736 || inter_unsignedp
== inside_unsignedp
)
7737 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
7738 && TYPE_MODE (type
) == TYPE_MODE (inter_type
))
7740 && (! final_vec
|| inter_prec
== inside_prec
))
7741 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7743 /* If we have a sign-extension of a zero-extended value, we can
7744 replace that by a single zero-extension. Likewise if the
7745 final conversion does not change precision we can drop the
7746 intermediate conversion. */
7747 if (inside_int
&& inter_int
&& final_int
7748 && ((inside_prec
< inter_prec
&& inter_prec
< final_prec
7749 && inside_unsignedp
&& !inter_unsignedp
)
7750 || final_prec
== inter_prec
))
7751 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7753 /* Two conversions in a row are not needed unless:
7754 - some conversion is floating-point (overstrict for now), or
7755 - some conversion is a vector (overstrict for now), or
7756 - the intermediate type is narrower than both initial and
7758 - the intermediate type and innermost type differ in signedness,
7759 and the outermost type is wider than the intermediate, or
7760 - the initial type is a pointer type and the precisions of the
7761 intermediate and final types differ, or
7762 - the final type is a pointer type and the precisions of the
7763 initial and intermediate types differ. */
7764 if (! inside_float
&& ! inter_float
&& ! final_float
7765 && ! inside_vec
&& ! inter_vec
&& ! final_vec
7766 && (inter_prec
>= inside_prec
|| inter_prec
>= final_prec
)
7767 && ! (inside_int
&& inter_int
7768 && inter_unsignedp
!= inside_unsignedp
7769 && inter_prec
< final_prec
)
7770 && ((inter_unsignedp
&& inter_prec
> inside_prec
)
7771 == (final_unsignedp
&& final_prec
> inter_prec
))
7772 && ! (inside_ptr
&& inter_prec
!= final_prec
)
7773 && ! (final_ptr
&& inside_prec
!= inter_prec
)
7774 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
7775 && TYPE_MODE (type
) == TYPE_MODE (inter_type
)))
7776 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7779 /* Handle (T *)&A.B.C for A being of type T and B and C
7780 living at offset zero. This occurs frequently in
7781 C++ upcasting and then accessing the base. */
7782 if (TREE_CODE (op0
) == ADDR_EXPR
7783 && POINTER_TYPE_P (type
)
7784 && handled_component_p (TREE_OPERAND (op0
, 0)))
7786 HOST_WIDE_INT bitsize
, bitpos
;
7788 enum machine_mode mode
;
7789 int unsignedp
, volatilep
;
7790 tree base
= TREE_OPERAND (op0
, 0);
7791 base
= get_inner_reference (base
, &bitsize
, &bitpos
, &offset
,
7792 &mode
, &unsignedp
, &volatilep
, false);
7793 /* If the reference was to a (constant) zero offset, we can use
7794 the address of the base if it has the same base type
7795 as the result type and the pointer type is unqualified. */
7796 if (! offset
&& bitpos
== 0
7797 && (TYPE_MAIN_VARIANT (TREE_TYPE (type
))
7798 == TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
7799 && TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
7800 return fold_convert_loc (loc
, type
,
7801 build_fold_addr_expr_loc (loc
, base
));
7804 if (TREE_CODE (op0
) == MODIFY_EXPR
7805 && TREE_CONSTANT (TREE_OPERAND (op0
, 1))
7806 /* Detect assigning a bitfield. */
7807 && !(TREE_CODE (TREE_OPERAND (op0
, 0)) == COMPONENT_REF
7809 (TREE_OPERAND (TREE_OPERAND (op0
, 0), 1))))
7811 /* Don't leave an assignment inside a conversion
7812 unless assigning a bitfield. */
7813 tem
= fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 1));
7814 /* First do the assignment, then return converted constant. */
7815 tem
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (tem
), op0
, tem
);
7816 TREE_NO_WARNING (tem
) = 1;
7817 TREE_USED (tem
) = 1;
7821 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7822 constants (if x has signed type, the sign bit cannot be set
7823 in c). This folds extension into the BIT_AND_EXPR.
7824 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7825 very likely don't have maximal range for their precision and this
7826 transformation effectively doesn't preserve non-maximal ranges. */
7827 if (TREE_CODE (type
) == INTEGER_TYPE
7828 && TREE_CODE (op0
) == BIT_AND_EXPR
7829 && TREE_CODE (TREE_OPERAND (op0
, 1)) == INTEGER_CST
)
7831 tree and_expr
= op0
;
7832 tree and0
= TREE_OPERAND (and_expr
, 0);
7833 tree and1
= TREE_OPERAND (and_expr
, 1);
7836 if (TYPE_UNSIGNED (TREE_TYPE (and_expr
))
7837 || (TYPE_PRECISION (type
)
7838 <= TYPE_PRECISION (TREE_TYPE (and_expr
))))
7840 else if (TYPE_PRECISION (TREE_TYPE (and1
))
7841 <= HOST_BITS_PER_WIDE_INT
7842 && tree_fits_uhwi_p (and1
))
7844 unsigned HOST_WIDE_INT cst
;
7846 cst
= tree_to_uhwi (and1
);
7847 cst
&= HOST_WIDE_INT_M1U
7848 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
7849 change
= (cst
== 0);
7850 #ifdef LOAD_EXTEND_OP
7852 && !flag_syntax_only
7853 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0
)))
7856 tree uns
= unsigned_type_for (TREE_TYPE (and0
));
7857 and0
= fold_convert_loc (loc
, uns
, and0
);
7858 and1
= fold_convert_loc (loc
, uns
, and1
);
7864 tem
= force_fit_type (type
, wi::to_widest (and1
), 0,
7865 TREE_OVERFLOW (and1
));
7866 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
7867 fold_convert_loc (loc
, type
, and0
), tem
);
7871 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
7872 when one of the new casts will fold away. Conservatively we assume
7873 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
7874 if (POINTER_TYPE_P (type
)
7875 && TREE_CODE (arg0
) == POINTER_PLUS_EXPR
7876 && (!TYPE_RESTRICT (type
) || TYPE_RESTRICT (TREE_TYPE (arg0
)))
7877 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
7878 || TREE_CODE (TREE_OPERAND (arg0
, 0)) == NOP_EXPR
7879 || TREE_CODE (TREE_OPERAND (arg0
, 1)) == NOP_EXPR
))
7881 tree arg00
= TREE_OPERAND (arg0
, 0);
7882 tree arg01
= TREE_OPERAND (arg0
, 1);
7884 return fold_build_pointer_plus_loc
7885 (loc
, fold_convert_loc (loc
, type
, arg00
), arg01
);
7888 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7889 of the same precision, and X is an integer type not narrower than
7890 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7891 if (INTEGRAL_TYPE_P (type
)
7892 && TREE_CODE (op0
) == BIT_NOT_EXPR
7893 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7894 && CONVERT_EXPR_P (TREE_OPERAND (op0
, 0))
7895 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
7897 tem
= TREE_OPERAND (TREE_OPERAND (op0
, 0), 0);
7898 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7899 && TYPE_PRECISION (type
) <= TYPE_PRECISION (TREE_TYPE (tem
)))
7900 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
7901 fold_convert_loc (loc
, type
, tem
));
7904 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7905 type of X and Y (integer types only). */
7906 if (INTEGRAL_TYPE_P (type
)
7907 && TREE_CODE (op0
) == MULT_EXPR
7908 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7909 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7911 /* Be careful not to introduce new overflows. */
7913 if (TYPE_OVERFLOW_WRAPS (type
))
7916 mult_type
= unsigned_type_for (type
);
7918 if (TYPE_PRECISION (mult_type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7920 tem
= fold_build2_loc (loc
, MULT_EXPR
, mult_type
,
7921 fold_convert_loc (loc
, mult_type
,
7922 TREE_OPERAND (op0
, 0)),
7923 fold_convert_loc (loc
, mult_type
,
7924 TREE_OPERAND (op0
, 1)));
7925 return fold_convert_loc (loc
, type
, tem
);
7929 tem
= fold_convert_const (code
, type
, arg0
);
7930 return tem
? tem
: NULL_TREE
;
7932 case ADDR_SPACE_CONVERT_EXPR
:
7933 if (integer_zerop (arg0
))
7934 return fold_convert_const (code
, type
, arg0
);
7937 case FIXED_CONVERT_EXPR
:
7938 tem
= fold_convert_const (code
, type
, arg0
);
7939 return tem
? tem
: NULL_TREE
;
7941 case VIEW_CONVERT_EXPR
:
7942 if (TREE_TYPE (op0
) == type
)
7944 if (TREE_CODE (op0
) == VIEW_CONVERT_EXPR
)
7945 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
,
7946 type
, TREE_OPERAND (op0
, 0));
7947 if (TREE_CODE (op0
) == MEM_REF
)
7948 return fold_build2_loc (loc
, MEM_REF
, type
,
7949 TREE_OPERAND (op0
, 0), TREE_OPERAND (op0
, 1));
7951 /* For integral conversions with the same precision or pointer
7952 conversions use a NOP_EXPR instead. */
7953 if ((INTEGRAL_TYPE_P (type
)
7954 || POINTER_TYPE_P (type
))
7955 && (INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7956 || POINTER_TYPE_P (TREE_TYPE (op0
)))
7957 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
7958 return fold_convert_loc (loc
, type
, op0
);
7960 /* Strip inner integral conversions that do not change the precision. */
7961 if (CONVERT_EXPR_P (op0
)
7962 && (INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7963 || POINTER_TYPE_P (TREE_TYPE (op0
)))
7964 && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0
, 0)))
7965 || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0
, 0))))
7966 && (TYPE_PRECISION (TREE_TYPE (op0
))
7967 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))))
7968 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
,
7969 type
, TREE_OPERAND (op0
, 0));
7971 return fold_view_convert_expr (type
, op0
);
7974 tem
= fold_negate_expr (loc
, arg0
);
7976 return fold_convert_loc (loc
, type
, tem
);
7980 if (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
)
7981 return fold_abs_const (arg0
, type
);
7982 else if (TREE_CODE (arg0
) == NEGATE_EXPR
)
7983 return fold_build1_loc (loc
, ABS_EXPR
, type
, TREE_OPERAND (arg0
, 0));
7984 /* Convert fabs((double)float) into (double)fabsf(float). */
7985 else if (TREE_CODE (arg0
) == NOP_EXPR
7986 && TREE_CODE (type
) == REAL_TYPE
)
7988 tree targ0
= strip_float_extensions (arg0
);
7990 return fold_convert_loc (loc
, type
,
7991 fold_build1_loc (loc
, ABS_EXPR
,
7995 /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on. */
7996 else if (TREE_CODE (arg0
) == ABS_EXPR
)
7998 else if (tree_expr_nonnegative_p (arg0
))
8001 /* Strip sign ops from argument. */
8002 if (TREE_CODE (type
) == REAL_TYPE
)
8004 tem
= fold_strip_sign_ops (arg0
);
8006 return fold_build1_loc (loc
, ABS_EXPR
, type
,
8007 fold_convert_loc (loc
, type
, tem
));
8012 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8013 return fold_convert_loc (loc
, type
, arg0
);
8014 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8016 tree itype
= TREE_TYPE (type
);
8017 tree rpart
= fold_convert_loc (loc
, itype
, TREE_OPERAND (arg0
, 0));
8018 tree ipart
= fold_convert_loc (loc
, itype
, TREE_OPERAND (arg0
, 1));
8019 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
,
8020 negate_expr (ipart
));
8022 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8024 tree itype
= TREE_TYPE (type
);
8025 tree rpart
= fold_convert_loc (loc
, itype
, TREE_REALPART (arg0
));
8026 tree ipart
= fold_convert_loc (loc
, itype
, TREE_IMAGPART (arg0
));
8027 return build_complex (type
, rpart
, negate_expr (ipart
));
8029 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8030 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
8034 if (TREE_CODE (arg0
) == INTEGER_CST
)
8035 return fold_not_const (arg0
, type
);
8036 else if (TREE_CODE (arg0
) == BIT_NOT_EXPR
)
8037 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
8038 /* Convert ~ (-A) to A - 1. */
8039 else if (INTEGRAL_TYPE_P (type
) && TREE_CODE (arg0
) == NEGATE_EXPR
)
8040 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
8041 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0)),
8042 build_int_cst (type
, 1));
8043 /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
8044 else if (INTEGRAL_TYPE_P (type
)
8045 && ((TREE_CODE (arg0
) == MINUS_EXPR
8046 && integer_onep (TREE_OPERAND (arg0
, 1)))
8047 || (TREE_CODE (arg0
) == PLUS_EXPR
8048 && integer_all_onesp (TREE_OPERAND (arg0
, 1)))))
8049 return fold_build1_loc (loc
, NEGATE_EXPR
, type
,
8050 fold_convert_loc (loc
, type
,
8051 TREE_OPERAND (arg0
, 0)));
8052 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8053 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8054 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8055 fold_convert_loc (loc
, type
,
8056 TREE_OPERAND (arg0
, 0)))))
8057 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, tem
,
8058 fold_convert_loc (loc
, type
,
8059 TREE_OPERAND (arg0
, 1)));
8060 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8061 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8062 fold_convert_loc (loc
, type
,
8063 TREE_OPERAND (arg0
, 1)))))
8064 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
8065 fold_convert_loc (loc
, type
,
8066 TREE_OPERAND (arg0
, 0)), tem
);
8067 /* Perform BIT_NOT_EXPR on each element individually. */
8068 else if (TREE_CODE (arg0
) == VECTOR_CST
)
8072 unsigned count
= VECTOR_CST_NELTS (arg0
), i
;
8074 elements
= XALLOCAVEC (tree
, count
);
8075 for (i
= 0; i
< count
; i
++)
8077 elem
= VECTOR_CST_ELT (arg0
, i
);
8078 elem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (type
), elem
);
8079 if (elem
== NULL_TREE
)
8084 return build_vector (type
, elements
);
8086 else if (COMPARISON_CLASS_P (arg0
)
8087 && (VECTOR_TYPE_P (type
)
8088 || (INTEGRAL_TYPE_P (type
) && TYPE_PRECISION (type
) == 1)))
8090 tree op_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
8091 enum tree_code subcode
= invert_tree_comparison (TREE_CODE (arg0
),
8092 HONOR_NANS (TYPE_MODE (op_type
)));
8093 if (subcode
!= ERROR_MARK
)
8094 return build2_loc (loc
, subcode
, type
, TREE_OPERAND (arg0
, 0),
8095 TREE_OPERAND (arg0
, 1));
8101 case TRUTH_NOT_EXPR
:
8102 /* Note that the operand of this must be an int
8103 and its values must be 0 or 1.
8104 ("true" is a fixed value perhaps depending on the language,
8105 but we don't handle values other than 1 correctly yet.) */
8106 tem
= fold_truth_not_expr (loc
, arg0
);
8109 return fold_convert_loc (loc
, type
, tem
);
8112 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8113 return fold_convert_loc (loc
, type
, arg0
);
8114 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8115 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 0),
8116 TREE_OPERAND (arg0
, 1));
8117 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8118 return fold_convert_loc (loc
, type
, TREE_REALPART (arg0
));
8119 if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8121 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8122 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), itype
,
8123 fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8124 TREE_OPERAND (arg0
, 0)),
8125 fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8126 TREE_OPERAND (arg0
, 1)));
8127 return fold_convert_loc (loc
, type
, tem
);
8129 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8131 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8132 tem
= fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8133 TREE_OPERAND (arg0
, 0));
8134 return fold_convert_loc (loc
, type
, tem
);
8136 if (TREE_CODE (arg0
) == CALL_EXPR
)
8138 tree fn
= get_callee_fndecl (arg0
);
8139 if (fn
&& DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
8140 switch (DECL_FUNCTION_CODE (fn
))
8142 CASE_FLT_FN (BUILT_IN_CEXPI
):
8143 fn
= mathfn_built_in (type
, BUILT_IN_COS
);
8145 return build_call_expr_loc (loc
, fn
, 1, CALL_EXPR_ARG (arg0
, 0));
8155 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8156 return build_zero_cst (type
);
8157 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8158 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 1),
8159 TREE_OPERAND (arg0
, 0));
8160 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8161 return fold_convert_loc (loc
, type
, TREE_IMAGPART (arg0
));
8162 if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8164 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8165 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), itype
,
8166 fold_build1_loc (loc
, IMAGPART_EXPR
, itype
,
8167 TREE_OPERAND (arg0
, 0)),
8168 fold_build1_loc (loc
, IMAGPART_EXPR
, itype
,
8169 TREE_OPERAND (arg0
, 1)));
8170 return fold_convert_loc (loc
, type
, tem
);
8172 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8174 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8175 tem
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, TREE_OPERAND (arg0
, 0));
8176 return fold_convert_loc (loc
, type
, negate_expr (tem
));
8178 if (TREE_CODE (arg0
) == CALL_EXPR
)
8180 tree fn
= get_callee_fndecl (arg0
);
8181 if (fn
&& DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
8182 switch (DECL_FUNCTION_CODE (fn
))
8184 CASE_FLT_FN (BUILT_IN_CEXPI
):
8185 fn
= mathfn_built_in (type
, BUILT_IN_SIN
);
8187 return build_call_expr_loc (loc
, fn
, 1, CALL_EXPR_ARG (arg0
, 0));
8197 /* Fold *&X to X if X is an lvalue. */
8198 if (TREE_CODE (op0
) == ADDR_EXPR
)
8200 tree op00
= TREE_OPERAND (op0
, 0);
8201 if ((TREE_CODE (op00
) == VAR_DECL
8202 || TREE_CODE (op00
) == PARM_DECL
8203 || TREE_CODE (op00
) == RESULT_DECL
)
8204 && !TREE_READONLY (op00
))
8209 case VEC_UNPACK_LO_EXPR
:
8210 case VEC_UNPACK_HI_EXPR
:
8211 case VEC_UNPACK_FLOAT_LO_EXPR
:
8212 case VEC_UNPACK_FLOAT_HI_EXPR
:
8214 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8216 enum tree_code subcode
;
8218 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2);
8219 if (TREE_CODE (arg0
) != VECTOR_CST
)
8222 elts
= XALLOCAVEC (tree
, nelts
* 2);
8223 if (!vec_cst_ctor_to_array (arg0
, elts
))
8226 if ((!BYTES_BIG_ENDIAN
) ^ (code
== VEC_UNPACK_LO_EXPR
8227 || code
== VEC_UNPACK_FLOAT_LO_EXPR
))
8230 if (code
== VEC_UNPACK_LO_EXPR
|| code
== VEC_UNPACK_HI_EXPR
)
8233 subcode
= FLOAT_EXPR
;
8235 for (i
= 0; i
< nelts
; i
++)
8237 elts
[i
] = fold_convert_const (subcode
, TREE_TYPE (type
), elts
[i
]);
8238 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
8242 return build_vector (type
, elts
);
8245 case REDUC_MIN_EXPR
:
8246 case REDUC_MAX_EXPR
:
8247 case REDUC_PLUS_EXPR
:
8249 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8251 enum tree_code subcode
;
8253 if (TREE_CODE (op0
) != VECTOR_CST
)
8256 elts
= XALLOCAVEC (tree
, nelts
);
8257 if (!vec_cst_ctor_to_array (op0
, elts
))
8262 case REDUC_MIN_EXPR
: subcode
= MIN_EXPR
; break;
8263 case REDUC_MAX_EXPR
: subcode
= MAX_EXPR
; break;
8264 case REDUC_PLUS_EXPR
: subcode
= PLUS_EXPR
; break;
8265 default: gcc_unreachable ();
8268 for (i
= 1; i
< nelts
; i
++)
8270 elts
[0] = const_binop (subcode
, elts
[0], elts
[i
]);
8271 if (elts
[0] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[0]))
8273 elts
[i
] = build_zero_cst (TREE_TYPE (type
));
8276 return build_vector (type
, elts
);
8281 } /* switch (code) */
8285 /* If the operation was a conversion do _not_ mark a resulting constant
8286 with TREE_OVERFLOW if the original constant was not. These conversions
8287 have implementation defined behavior and retaining the TREE_OVERFLOW
8288 flag here would confuse later passes such as VRP. */
8290 fold_unary_ignore_overflow_loc (location_t loc
, enum tree_code code
,
8291 tree type
, tree op0
)
8293 tree res
= fold_unary_loc (loc
, code
, type
, op0
);
8295 && TREE_CODE (res
) == INTEGER_CST
8296 && TREE_CODE (op0
) == INTEGER_CST
8297 && CONVERT_EXPR_CODE_P (code
))
8298 TREE_OVERFLOW (res
) = TREE_OVERFLOW (op0
);
8303 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8304 operands OP0 and OP1. LOC is the location of the resulting expression.
8305 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8306 Return the folded expression if folding is successful. Otherwise,
8307 return NULL_TREE. */
8309 fold_truth_andor (location_t loc
, enum tree_code code
, tree type
,
8310 tree arg0
, tree arg1
, tree op0
, tree op1
)
8314 /* We only do these simplifications if we are optimizing. */
8318 /* Check for things like (A || B) && (A || C). We can convert this
8319 to A || (B && C). Note that either operator can be any of the four
8320 truth and/or operations and the transformation will still be
8321 valid. Also note that we only care about order for the
8322 ANDIF and ORIF operators. If B contains side effects, this
8323 might change the truth-value of A. */
8324 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8325 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
8326 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
8327 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
8328 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
8329 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
8331 tree a00
= TREE_OPERAND (arg0
, 0);
8332 tree a01
= TREE_OPERAND (arg0
, 1);
8333 tree a10
= TREE_OPERAND (arg1
, 0);
8334 tree a11
= TREE_OPERAND (arg1
, 1);
8335 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
8336 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
8337 && (code
== TRUTH_AND_EXPR
8338 || code
== TRUTH_OR_EXPR
));
8340 if (operand_equal_p (a00
, a10
, 0))
8341 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8342 fold_build2_loc (loc
, code
, type
, a01
, a11
));
8343 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
8344 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8345 fold_build2_loc (loc
, code
, type
, a01
, a10
));
8346 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
8347 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a01
,
8348 fold_build2_loc (loc
, code
, type
, a00
, a11
));
8350 /* This case if tricky because we must either have commutative
8351 operators or else A10 must not have side-effects. */
8353 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
8354 && operand_equal_p (a01
, a11
, 0))
8355 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
8356 fold_build2_loc (loc
, code
, type
, a00
, a10
),
8360 /* See if we can build a range comparison. */
8361 if (0 != (tem
= fold_range_test (loc
, code
, type
, op0
, op1
)))
8364 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
)
8365 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
))
8367 tem
= merge_truthop_with_opposite_arm (loc
, arg0
, arg1
, true);
8369 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
8372 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ORIF_EXPR
)
8373 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ANDIF_EXPR
))
8375 tem
= merge_truthop_with_opposite_arm (loc
, arg1
, arg0
, false);
8377 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
8380 /* Check for the possibility of merging component references. If our
8381 lhs is another similar operation, try to merge its rhs with our
8382 rhs. Then try to merge our lhs and rhs. */
8383 if (TREE_CODE (arg0
) == code
8384 && 0 != (tem
= fold_truth_andor_1 (loc
, code
, type
,
8385 TREE_OPERAND (arg0
, 1), arg1
)))
8386 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
8388 if ((tem
= fold_truth_andor_1 (loc
, code
, type
, arg0
, arg1
)) != 0)
8391 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8392 && (code
== TRUTH_AND_EXPR
8393 || code
== TRUTH_ANDIF_EXPR
8394 || code
== TRUTH_OR_EXPR
8395 || code
== TRUTH_ORIF_EXPR
))
8397 enum tree_code ncode
, icode
;
8399 ncode
= (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_AND_EXPR
)
8400 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
;
8401 icode
= ncode
== TRUTH_AND_EXPR
? TRUTH_ANDIF_EXPR
: TRUTH_ORIF_EXPR
;
8403 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8404 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8405 We don't want to pack more than two leafs to a non-IF AND/OR
8407 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8408 equal to IF-CODE, then we don't want to add right-hand operand.
8409 If the inner right-hand side of left-hand operand has
8410 side-effects, or isn't simple, then we can't add to it,
8411 as otherwise we might destroy if-sequence. */
8412 if (TREE_CODE (arg0
) == icode
8413 && simple_operand_p_2 (arg1
)
8414 /* Needed for sequence points to handle trappings, and
8416 && simple_operand_p_2 (TREE_OPERAND (arg0
, 1)))
8418 tem
= fold_build2_loc (loc
, ncode
, type
, TREE_OPERAND (arg0
, 1),
8420 return fold_build2_loc (loc
, icode
, type
, TREE_OPERAND (arg0
, 0),
8423 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8424 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8425 else if (TREE_CODE (arg1
) == icode
8426 && simple_operand_p_2 (arg0
)
8427 /* Needed for sequence points to handle trappings, and
8429 && simple_operand_p_2 (TREE_OPERAND (arg1
, 0)))
8431 tem
= fold_build2_loc (loc
, ncode
, type
,
8432 arg0
, TREE_OPERAND (arg1
, 0));
8433 return fold_build2_loc (loc
, icode
, type
, tem
,
8434 TREE_OPERAND (arg1
, 1));
8436 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8438 For sequence point consistancy, we need to check for trapping,
8439 and side-effects. */
8440 else if (code
== icode
&& simple_operand_p_2 (arg0
)
8441 && simple_operand_p_2 (arg1
))
8442 return fold_build2_loc (loc
, ncode
, type
, arg0
, arg1
);
8448 /* Fold a binary expression of code CODE and type TYPE with operands
8449 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8450 Return the folded expression if folding is successful. Otherwise,
8451 return NULL_TREE. */
8454 fold_minmax (location_t loc
, enum tree_code code
, tree type
, tree op0
, tree op1
)
8456 enum tree_code compl_code
;
8458 if (code
== MIN_EXPR
)
8459 compl_code
= MAX_EXPR
;
8460 else if (code
== MAX_EXPR
)
8461 compl_code
= MIN_EXPR
;
8465 /* MIN (MAX (a, b), b) == b. */
8466 if (TREE_CODE (op0
) == compl_code
8467 && operand_equal_p (TREE_OPERAND (op0
, 1), op1
, 0))
8468 return omit_one_operand_loc (loc
, type
, op1
, TREE_OPERAND (op0
, 0));
8470 /* MIN (MAX (b, a), b) == b. */
8471 if (TREE_CODE (op0
) == compl_code
8472 && operand_equal_p (TREE_OPERAND (op0
, 0), op1
, 0)
8473 && reorder_operands_p (TREE_OPERAND (op0
, 1), op1
))
8474 return omit_one_operand_loc (loc
, type
, op1
, TREE_OPERAND (op0
, 1));
8476 /* MIN (a, MAX (a, b)) == a. */
8477 if (TREE_CODE (op1
) == compl_code
8478 && operand_equal_p (op0
, TREE_OPERAND (op1
, 0), 0)
8479 && reorder_operands_p (op0
, TREE_OPERAND (op1
, 1)))
8480 return omit_one_operand_loc (loc
, type
, op0
, TREE_OPERAND (op1
, 1));
8482 /* MIN (a, MAX (b, a)) == a. */
8483 if (TREE_CODE (op1
) == compl_code
8484 && operand_equal_p (op0
, TREE_OPERAND (op1
, 1), 0)
8485 && reorder_operands_p (op0
, TREE_OPERAND (op1
, 0)))
8486 return omit_one_operand_loc (loc
, type
, op0
, TREE_OPERAND (op1
, 0));
8491 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8492 by changing CODE to reduce the magnitude of constants involved in
8493 ARG0 of the comparison.
8494 Returns a canonicalized comparison tree if a simplification was
8495 possible, otherwise returns NULL_TREE.
8496 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8497 valid if signed overflow is undefined. */
8500 maybe_canonicalize_comparison_1 (location_t loc
, enum tree_code code
, tree type
,
8501 tree arg0
, tree arg1
,
8502 bool *strict_overflow_p
)
8504 enum tree_code code0
= TREE_CODE (arg0
);
8505 tree t
, cst0
= NULL_TREE
;
8509 /* Match A +- CST code arg1 and CST code arg1. We can change the
8510 first form only if overflow is undefined. */
8511 if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
8512 /* In principle pointers also have undefined overflow behavior,
8513 but that causes problems elsewhere. */
8514 && !POINTER_TYPE_P (TREE_TYPE (arg0
))
8515 && (code0
== MINUS_EXPR
8516 || code0
== PLUS_EXPR
)
8517 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
8518 || code0
== INTEGER_CST
))
8521 /* Identify the constant in arg0 and its sign. */
8522 if (code0
== INTEGER_CST
)
8525 cst0
= TREE_OPERAND (arg0
, 1);
8526 sgn0
= tree_int_cst_sgn (cst0
);
8528 /* Overflowed constants and zero will cause problems. */
8529 if (integer_zerop (cst0
)
8530 || TREE_OVERFLOW (cst0
))
8533 /* See if we can reduce the magnitude of the constant in
8534 arg0 by changing the comparison code. */
8535 if (code0
== INTEGER_CST
)
8537 /* CST <= arg1 -> CST-1 < arg1. */
8538 if (code
== LE_EXPR
&& sgn0
== 1)
8540 /* -CST < arg1 -> -CST-1 <= arg1. */
8541 else if (code
== LT_EXPR
&& sgn0
== -1)
8543 /* CST > arg1 -> CST-1 >= arg1. */
8544 else if (code
== GT_EXPR
&& sgn0
== 1)
8546 /* -CST >= arg1 -> -CST-1 > arg1. */
8547 else if (code
== GE_EXPR
&& sgn0
== -1)
8551 /* arg1 code' CST' might be more canonical. */
8556 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8558 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8560 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8561 else if (code
== GT_EXPR
8562 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8564 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8565 else if (code
== LE_EXPR
8566 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8568 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8569 else if (code
== GE_EXPR
8570 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8574 *strict_overflow_p
= true;
8577 /* Now build the constant reduced in magnitude. But not if that
8578 would produce one outside of its types range. */
8579 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0
))
8581 && TYPE_MIN_VALUE (TREE_TYPE (cst0
))
8582 && tree_int_cst_equal (cst0
, TYPE_MIN_VALUE (TREE_TYPE (cst0
))))
8584 && TYPE_MAX_VALUE (TREE_TYPE (cst0
))
8585 && tree_int_cst_equal (cst0
, TYPE_MAX_VALUE (TREE_TYPE (cst0
))))))
8586 /* We cannot swap the comparison here as that would cause us to
8587 endlessly recurse. */
8590 t
= int_const_binop (sgn0
== -1 ? PLUS_EXPR
: MINUS_EXPR
,
8591 cst0
, build_int_cst (TREE_TYPE (cst0
), 1));
8592 if (code0
!= INTEGER_CST
)
8593 t
= fold_build2_loc (loc
, code0
, TREE_TYPE (arg0
), TREE_OPERAND (arg0
, 0), t
);
8594 t
= fold_convert (TREE_TYPE (arg1
), t
);
8596 /* If swapping might yield to a more canonical form, do so. */
8598 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, arg1
, t
);
8600 return fold_build2_loc (loc
, code
, type
, t
, arg1
);
8603 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8604 overflow further. Try to decrease the magnitude of constants involved
8605 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8606 and put sole constants at the second argument position.
8607 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8610 maybe_canonicalize_comparison (location_t loc
, enum tree_code code
, tree type
,
8611 tree arg0
, tree arg1
)
8614 bool strict_overflow_p
;
8615 const char * const warnmsg
= G_("assuming signed overflow does not occur "
8616 "when reducing constant in comparison");
8618 /* Try canonicalization by simplifying arg0. */
8619 strict_overflow_p
= false;
8620 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg0
, arg1
,
8621 &strict_overflow_p
);
8624 if (strict_overflow_p
)
8625 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8629 /* Try canonicalization by simplifying arg1 using the swapped
8631 code
= swap_tree_comparison (code
);
8632 strict_overflow_p
= false;
8633 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg1
, arg0
,
8634 &strict_overflow_p
);
8635 if (t
&& strict_overflow_p
)
8636 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8640 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8641 space. This is used to avoid issuing overflow warnings for
8642 expressions like &p->x which can not wrap. */
8645 pointer_may_wrap_p (tree base
, tree offset
, HOST_WIDE_INT bitpos
)
8647 if (!POINTER_TYPE_P (TREE_TYPE (base
)))
8654 int precision
= TYPE_PRECISION (TREE_TYPE (base
));
8655 if (offset
== NULL_TREE
)
8656 wi_offset
= wi::zero (precision
);
8657 else if (TREE_CODE (offset
) != INTEGER_CST
|| TREE_OVERFLOW (offset
))
8663 wide_int units
= wi::shwi (bitpos
/ BITS_PER_UNIT
, precision
);
8664 wide_int total
= wi::add (wi_offset
, units
, UNSIGNED
, &overflow
);
8668 if (!wi::fits_uhwi_p (total
))
8671 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (TREE_TYPE (base
)));
8675 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8677 if (TREE_CODE (base
) == ADDR_EXPR
)
8679 HOST_WIDE_INT base_size
;
8681 base_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base
, 0)));
8682 if (base_size
> 0 && size
< base_size
)
8686 return total
.to_uhwi () > (unsigned HOST_WIDE_INT
) size
;
8689 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
8690 kind INTEGER_CST. This makes sure to properly sign-extend the
8693 static HOST_WIDE_INT
8694 size_low_cst (const_tree t
)
8696 HOST_WIDE_INT w
= TREE_INT_CST_ELT (t
, 0);
8697 int prec
= TYPE_PRECISION (TREE_TYPE (t
));
8698 if (prec
< HOST_BITS_PER_WIDE_INT
)
8699 return sext_hwi (w
, prec
);
8703 /* Subroutine of fold_binary. This routine performs all of the
8704 transformations that are common to the equality/inequality
8705 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8706 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8707 fold_binary should call fold_binary. Fold a comparison with
8708 tree code CODE and type TYPE with operands OP0 and OP1. Return
8709 the folded comparison or NULL_TREE. */
8712 fold_comparison (location_t loc
, enum tree_code code
, tree type
,
8715 const bool equality_code
= (code
== EQ_EXPR
|| code
== NE_EXPR
);
8716 tree arg0
, arg1
, tem
;
8721 STRIP_SIGN_NOPS (arg0
);
8722 STRIP_SIGN_NOPS (arg1
);
8724 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8725 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8726 && (equality_code
|| TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8727 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8728 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
8729 && TREE_CODE (arg1
) == INTEGER_CST
8730 && !TREE_OVERFLOW (arg1
))
8732 const enum tree_code
8733 reverse_op
= TREE_CODE (arg0
) == PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
;
8734 tree const1
= TREE_OPERAND (arg0
, 1);
8735 tree const2
= fold_convert_loc (loc
, TREE_TYPE (const1
), arg1
);
8736 tree variable
= TREE_OPERAND (arg0
, 0);
8737 tree new_const
= int_const_binop (reverse_op
, const2
, const1
);
8739 /* If the constant operation overflowed this can be
8740 simplified as a comparison against INT_MAX/INT_MIN. */
8741 if (TREE_OVERFLOW (new_const
))
8743 int const1_sgn
= tree_int_cst_sgn (const1
);
8744 enum tree_code code2
= code
;
8746 /* Get the sign of the constant on the lhs if the
8747 operation were VARIABLE + CONST1. */
8748 if (TREE_CODE (arg0
) == MINUS_EXPR
)
8749 const1_sgn
= -const1_sgn
;
8751 /* The sign of the constant determines if we overflowed
8752 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8753 Canonicalize to the INT_MIN overflow by swapping the comparison
8755 if (const1_sgn
== -1)
8756 code2
= swap_tree_comparison (code
);
8758 /* We now can look at the canonicalized case
8759 VARIABLE + 1 CODE2 INT_MIN
8760 and decide on the result. */
8767 omit_one_operand_loc (loc
, type
, boolean_false_node
, variable
);
8773 omit_one_operand_loc (loc
, type
, boolean_true_node
, variable
);
8782 fold_overflow_warning ("assuming signed overflow does not occur "
8783 "when changing X +- C1 cmp C2 to "
8785 WARN_STRICT_OVERFLOW_COMPARISON
);
8786 return fold_build2_loc (loc
, code
, type
, variable
, new_const
);
8790 /* Transform comparisons of the form X - Y CMP 0 to X CMP Y. */
8791 if (TREE_CODE (arg0
) == MINUS_EXPR
8793 && integer_zerop (arg1
))
8795 /* ??? The transformation is valid for the other operators if overflow
8796 is undefined for the type, but performing it here badly interacts
8797 with the transformation in fold_cond_expr_with_comparison which
8798 attempts to synthetize ABS_EXPR. */
8800 fold_overflow_warning ("assuming signed overflow does not occur "
8801 "when changing X - Y cmp 0 to X cmp Y",
8802 WARN_STRICT_OVERFLOW_COMPARISON
);
8803 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
8804 TREE_OPERAND (arg0
, 1));
8807 /* For comparisons of pointers we can decompose it to a compile time
8808 comparison of the base objects and the offsets into the object.
8809 This requires at least one operand being an ADDR_EXPR or a
8810 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8811 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
8812 && (TREE_CODE (arg0
) == ADDR_EXPR
8813 || TREE_CODE (arg1
) == ADDR_EXPR
8814 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8815 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
8817 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
8818 HOST_WIDE_INT bitsize
, bitpos0
= 0, bitpos1
= 0;
8819 enum machine_mode mode
;
8820 int volatilep
, unsignedp
;
8821 bool indirect_base0
= false, indirect_base1
= false;
8823 /* Get base and offset for the access. Strip ADDR_EXPR for
8824 get_inner_reference, but put it back by stripping INDIRECT_REF
8825 off the base object if possible. indirect_baseN will be true
8826 if baseN is not an address but refers to the object itself. */
8828 if (TREE_CODE (arg0
) == ADDR_EXPR
)
8830 base0
= get_inner_reference (TREE_OPERAND (arg0
, 0),
8831 &bitsize
, &bitpos0
, &offset0
, &mode
,
8832 &unsignedp
, &volatilep
, false);
8833 if (TREE_CODE (base0
) == INDIRECT_REF
)
8834 base0
= TREE_OPERAND (base0
, 0);
8836 indirect_base0
= true;
8838 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
8840 base0
= TREE_OPERAND (arg0
, 0);
8841 STRIP_SIGN_NOPS (base0
);
8842 if (TREE_CODE (base0
) == ADDR_EXPR
)
8844 base0
= TREE_OPERAND (base0
, 0);
8845 indirect_base0
= true;
8847 offset0
= TREE_OPERAND (arg0
, 1);
8848 if (tree_fits_shwi_p (offset0
))
8850 HOST_WIDE_INT off
= size_low_cst (offset0
);
8851 if ((HOST_WIDE_INT
) (((unsigned HOST_WIDE_INT
) off
)
8853 / BITS_PER_UNIT
== (HOST_WIDE_INT
) off
)
8855 bitpos0
= off
* BITS_PER_UNIT
;
8856 offset0
= NULL_TREE
;
8862 if (TREE_CODE (arg1
) == ADDR_EXPR
)
8864 base1
= get_inner_reference (TREE_OPERAND (arg1
, 0),
8865 &bitsize
, &bitpos1
, &offset1
, &mode
,
8866 &unsignedp
, &volatilep
, false);
8867 if (TREE_CODE (base1
) == INDIRECT_REF
)
8868 base1
= TREE_OPERAND (base1
, 0);
8870 indirect_base1
= true;
8872 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
8874 base1
= TREE_OPERAND (arg1
, 0);
8875 STRIP_SIGN_NOPS (base1
);
8876 if (TREE_CODE (base1
) == ADDR_EXPR
)
8878 base1
= TREE_OPERAND (base1
, 0);
8879 indirect_base1
= true;
8881 offset1
= TREE_OPERAND (arg1
, 1);
8882 if (tree_fits_shwi_p (offset1
))
8884 HOST_WIDE_INT off
= size_low_cst (offset1
);
8885 if ((HOST_WIDE_INT
) (((unsigned HOST_WIDE_INT
) off
)
8887 / BITS_PER_UNIT
== (HOST_WIDE_INT
) off
)
8889 bitpos1
= off
* BITS_PER_UNIT
;
8890 offset1
= NULL_TREE
;
8895 /* A local variable can never be pointed to by
8896 the default SSA name of an incoming parameter. */
8897 if ((TREE_CODE (arg0
) == ADDR_EXPR
8899 && TREE_CODE (base0
) == VAR_DECL
8900 && auto_var_in_fn_p (base0
, current_function_decl
)
8902 && TREE_CODE (base1
) == SSA_NAME
8903 && SSA_NAME_IS_DEFAULT_DEF (base1
)
8904 && TREE_CODE (SSA_NAME_VAR (base1
)) == PARM_DECL
)
8905 || (TREE_CODE (arg1
) == ADDR_EXPR
8907 && TREE_CODE (base1
) == VAR_DECL
8908 && auto_var_in_fn_p (base1
, current_function_decl
)
8910 && TREE_CODE (base0
) == SSA_NAME
8911 && SSA_NAME_IS_DEFAULT_DEF (base0
)
8912 && TREE_CODE (SSA_NAME_VAR (base0
)) == PARM_DECL
))
8914 if (code
== NE_EXPR
)
8915 return constant_boolean_node (1, type
);
8916 else if (code
== EQ_EXPR
)
8917 return constant_boolean_node (0, type
);
8919 /* If we have equivalent bases we might be able to simplify. */
8920 else if (indirect_base0
== indirect_base1
8921 && operand_equal_p (base0
, base1
, 0))
8923 /* We can fold this expression to a constant if the non-constant
8924 offset parts are equal. */
8925 if ((offset0
== offset1
8926 || (offset0
&& offset1
8927 && operand_equal_p (offset0
, offset1
, 0)))
8930 || (indirect_base0
&& DECL_P (base0
))
8931 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8935 && bitpos0
!= bitpos1
8936 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8937 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8938 fold_overflow_warning (("assuming pointer wraparound does not "
8939 "occur when comparing P +- C1 with "
8941 WARN_STRICT_OVERFLOW_CONDITIONAL
);
8946 return constant_boolean_node (bitpos0
== bitpos1
, type
);
8948 return constant_boolean_node (bitpos0
!= bitpos1
, type
);
8950 return constant_boolean_node (bitpos0
< bitpos1
, type
);
8952 return constant_boolean_node (bitpos0
<= bitpos1
, type
);
8954 return constant_boolean_node (bitpos0
>= bitpos1
, type
);
8956 return constant_boolean_node (bitpos0
> bitpos1
, type
);
8960 /* We can simplify the comparison to a comparison of the variable
8961 offset parts if the constant offset parts are equal.
8962 Be careful to use signed sizetype here because otherwise we
8963 mess with array offsets in the wrong way. This is possible
8964 because pointer arithmetic is restricted to retain within an
8965 object and overflow on pointer differences is undefined as of
8966 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8967 else if (bitpos0
== bitpos1
8969 || (indirect_base0
&& DECL_P (base0
))
8970 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8972 /* By converting to signed sizetype we cover middle-end pointer
8973 arithmetic which operates on unsigned pointer types of size
8974 type size and ARRAY_REF offsets which are properly sign or
8975 zero extended from their type in case it is narrower than
8977 if (offset0
== NULL_TREE
)
8978 offset0
= build_int_cst (ssizetype
, 0);
8980 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
8981 if (offset1
== NULL_TREE
)
8982 offset1
= build_int_cst (ssizetype
, 0);
8984 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
8987 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8988 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8989 fold_overflow_warning (("assuming pointer wraparound does not "
8990 "occur when comparing P +- C1 with "
8992 WARN_STRICT_OVERFLOW_COMPARISON
);
8994 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
8997 /* For non-equal bases we can simplify if they are addresses
8998 of local binding decls or constants. */
8999 else if (indirect_base0
&& indirect_base1
9000 /* We know that !operand_equal_p (base0, base1, 0)
9001 because the if condition was false. But make
9002 sure two decls are not the same. */
9004 && TREE_CODE (arg0
) == ADDR_EXPR
9005 && TREE_CODE (arg1
) == ADDR_EXPR
9006 && (((TREE_CODE (base0
) == VAR_DECL
9007 || TREE_CODE (base0
) == PARM_DECL
)
9008 && (targetm
.binds_local_p (base0
)
9009 || CONSTANT_CLASS_P (base1
)))
9010 || CONSTANT_CLASS_P (base0
))
9011 && (((TREE_CODE (base1
) == VAR_DECL
9012 || TREE_CODE (base1
) == PARM_DECL
)
9013 && (targetm
.binds_local_p (base1
)
9014 || CONSTANT_CLASS_P (base0
)))
9015 || CONSTANT_CLASS_P (base1
)))
9017 if (code
== EQ_EXPR
)
9018 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
9020 else if (code
== NE_EXPR
)
9021 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
9024 /* For equal offsets we can simplify to a comparison of the
9026 else if (bitpos0
== bitpos1
9028 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
9030 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
9031 && ((offset0
== offset1
)
9032 || (offset0
&& offset1
9033 && operand_equal_p (offset0
, offset1
, 0))))
9036 base0
= build_fold_addr_expr_loc (loc
, base0
);
9038 base1
= build_fold_addr_expr_loc (loc
, base1
);
9039 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
9043 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9044 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9045 the resulting offset is smaller in absolute value than the
9046 original one and has the same sign. */
9047 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
9048 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
9049 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9050 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
9051 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
9052 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
9053 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
9055 tree const1
= TREE_OPERAND (arg0
, 1);
9056 tree const2
= TREE_OPERAND (arg1
, 1);
9057 tree variable1
= TREE_OPERAND (arg0
, 0);
9058 tree variable2
= TREE_OPERAND (arg1
, 0);
9060 const char * const warnmsg
= G_("assuming signed overflow does not "
9061 "occur when combining constants around "
9064 /* Put the constant on the side where it doesn't overflow and is
9065 of lower absolute value and of same sign than before. */
9066 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
9067 ? MINUS_EXPR
: PLUS_EXPR
,
9069 if (!TREE_OVERFLOW (cst
)
9070 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
)
9071 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const2
))
9073 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
9074 return fold_build2_loc (loc
, code
, type
,
9076 fold_build2_loc (loc
, TREE_CODE (arg1
),
9081 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
9082 ? MINUS_EXPR
: PLUS_EXPR
,
9084 if (!TREE_OVERFLOW (cst
)
9085 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
)
9086 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const1
))
9088 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
9089 return fold_build2_loc (loc
, code
, type
,
9090 fold_build2_loc (loc
, TREE_CODE (arg0
),
9097 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9098 signed arithmetic case. That form is created by the compiler
9099 often enough for folding it to be of value. One example is in
9100 computing loop trip counts after Operator Strength Reduction. */
9101 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
9102 && TREE_CODE (arg0
) == MULT_EXPR
9103 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9104 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
9105 && integer_zerop (arg1
))
9107 tree const1
= TREE_OPERAND (arg0
, 1);
9108 tree const2
= arg1
; /* zero */
9109 tree variable1
= TREE_OPERAND (arg0
, 0);
9110 enum tree_code cmp_code
= code
;
9112 /* Handle unfolded multiplication by zero. */
9113 if (integer_zerop (const1
))
9114 return fold_build2_loc (loc
, cmp_code
, type
, const1
, const2
);
9116 fold_overflow_warning (("assuming signed overflow does not occur when "
9117 "eliminating multiplication in comparison "
9119 WARN_STRICT_OVERFLOW_COMPARISON
);
9121 /* If const1 is negative we swap the sense of the comparison. */
9122 if (tree_int_cst_sgn (const1
) < 0)
9123 cmp_code
= swap_tree_comparison (cmp_code
);
9125 return fold_build2_loc (loc
, cmp_code
, type
, variable1
, const2
);
9128 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
9132 if (FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9134 tree targ0
= strip_float_extensions (arg0
);
9135 tree targ1
= strip_float_extensions (arg1
);
9136 tree newtype
= TREE_TYPE (targ0
);
9138 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
9139 newtype
= TREE_TYPE (targ1
);
9141 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9142 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
9143 return fold_build2_loc (loc
, code
, type
,
9144 fold_convert_loc (loc
, newtype
, targ0
),
9145 fold_convert_loc (loc
, newtype
, targ1
));
9147 /* (-a) CMP (-b) -> b CMP a */
9148 if (TREE_CODE (arg0
) == NEGATE_EXPR
9149 && TREE_CODE (arg1
) == NEGATE_EXPR
)
9150 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg1
, 0),
9151 TREE_OPERAND (arg0
, 0));
9153 if (TREE_CODE (arg1
) == REAL_CST
)
9155 REAL_VALUE_TYPE cst
;
9156 cst
= TREE_REAL_CST (arg1
);
9158 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9159 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
9160 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9161 TREE_OPERAND (arg0
, 0),
9162 build_real (TREE_TYPE (arg1
),
9163 real_value_negate (&cst
)));
9165 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9166 /* a CMP (-0) -> a CMP 0 */
9167 if (REAL_VALUE_MINUS_ZERO (cst
))
9168 return fold_build2_loc (loc
, code
, type
, arg0
,
9169 build_real (TREE_TYPE (arg1
), dconst0
));
9171 /* x != NaN is always true, other ops are always false. */
9172 if (REAL_VALUE_ISNAN (cst
)
9173 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
))))
9175 tem
= (code
== NE_EXPR
) ? integer_one_node
: integer_zero_node
;
9176 return omit_one_operand_loc (loc
, type
, tem
, arg0
);
9179 /* Fold comparisons against infinity. */
9180 if (REAL_VALUE_ISINF (cst
)
9181 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
))))
9183 tem
= fold_inf_compare (loc
, code
, type
, arg0
, arg1
);
9184 if (tem
!= NULL_TREE
)
9189 /* If this is a comparison of a real constant with a PLUS_EXPR
9190 or a MINUS_EXPR of a real constant, we can convert it into a
9191 comparison with a revised real constant as long as no overflow
9192 occurs when unsafe_math_optimizations are enabled. */
9193 if (flag_unsafe_math_optimizations
9194 && TREE_CODE (arg1
) == REAL_CST
9195 && (TREE_CODE (arg0
) == PLUS_EXPR
9196 || TREE_CODE (arg0
) == MINUS_EXPR
)
9197 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
9198 && 0 != (tem
= const_binop (TREE_CODE (arg0
) == PLUS_EXPR
9199 ? MINUS_EXPR
: PLUS_EXPR
,
9200 arg1
, TREE_OPERAND (arg0
, 1)))
9201 && !TREE_OVERFLOW (tem
))
9202 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
9204 /* Likewise, we can simplify a comparison of a real constant with
9205 a MINUS_EXPR whose first operand is also a real constant, i.e.
9206 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9207 floating-point types only if -fassociative-math is set. */
9208 if (flag_associative_math
9209 && TREE_CODE (arg1
) == REAL_CST
9210 && TREE_CODE (arg0
) == MINUS_EXPR
9211 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
9212 && 0 != (tem
= const_binop (MINUS_EXPR
, TREE_OPERAND (arg0
, 0),
9214 && !TREE_OVERFLOW (tem
))
9215 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9216 TREE_OPERAND (arg0
, 1), tem
);
9218 /* Fold comparisons against built-in math functions. */
9219 if (TREE_CODE (arg1
) == REAL_CST
9220 && flag_unsafe_math_optimizations
9221 && ! flag_errno_math
)
9223 enum built_in_function fcode
= builtin_mathfn_code (arg0
);
9225 if (fcode
!= END_BUILTINS
)
9227 tem
= fold_mathfn_compare (loc
, fcode
, code
, type
, arg0
, arg1
);
9228 if (tem
!= NULL_TREE
)
9234 if (TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
9235 && CONVERT_EXPR_P (arg0
))
9237 /* If we are widening one operand of an integer comparison,
9238 see if the other operand is similarly being widened. Perhaps we
9239 can do the comparison in the narrower type. */
9240 tem
= fold_widened_comparison (loc
, code
, type
, arg0
, arg1
);
9244 /* Or if we are changing signedness. */
9245 tem
= fold_sign_changed_comparison (loc
, code
, type
, arg0
, arg1
);
9250 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9251 constant, we can simplify it. */
9252 if (TREE_CODE (arg1
) == INTEGER_CST
9253 && (TREE_CODE (arg0
) == MIN_EXPR
9254 || TREE_CODE (arg0
) == MAX_EXPR
)
9255 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
9257 tem
= optimize_minmax_comparison (loc
, code
, type
, op0
, op1
);
9262 /* Simplify comparison of something with itself. (For IEEE
9263 floating-point, we can only do some of these simplifications.) */
9264 if (operand_equal_p (arg0
, arg1
, 0))
9269 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
))
9270 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9271 return constant_boolean_node (1, type
);
9276 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
))
9277 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9278 return constant_boolean_node (1, type
);
9279 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
, arg1
);
9282 /* For NE, we can only do this simplification if integer
9283 or we don't honor IEEE floating point NaNs. */
9284 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
9285 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9287 /* ... fall through ... */
9290 return constant_boolean_node (0, type
);
9296 /* If we are comparing an expression that just has comparisons
9297 of two integer values, arithmetic expressions of those comparisons,
9298 and constants, we can simplify it. There are only three cases
9299 to check: the two values can either be equal, the first can be
9300 greater, or the second can be greater. Fold the expression for
9301 those three values. Since each value must be 0 or 1, we have
9302 eight possibilities, each of which corresponds to the constant 0
9303 or 1 or one of the six possible comparisons.
9305 This handles common cases like (a > b) == 0 but also handles
9306 expressions like ((x > y) - (y > x)) > 0, which supposedly
9307 occur in macroized code. */
9309 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
9311 tree cval1
= 0, cval2
= 0;
9314 if (twoval_comparison_p (arg0
, &cval1
, &cval2
, &save_p
)
9315 /* Don't handle degenerate cases here; they should already
9316 have been handled anyway. */
9317 && cval1
!= 0 && cval2
!= 0
9318 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
9319 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
9320 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
9321 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
9322 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
9323 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
9324 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
9326 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
9327 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
9329 /* We can't just pass T to eval_subst in case cval1 or cval2
9330 was the same as ARG1. */
9333 = fold_build2_loc (loc
, code
, type
,
9334 eval_subst (loc
, arg0
, cval1
, maxval
,
9338 = fold_build2_loc (loc
, code
, type
,
9339 eval_subst (loc
, arg0
, cval1
, maxval
,
9343 = fold_build2_loc (loc
, code
, type
,
9344 eval_subst (loc
, arg0
, cval1
, minval
,
9348 /* All three of these results should be 0 or 1. Confirm they are.
9349 Then use those values to select the proper code to use. */
9351 if (TREE_CODE (high_result
) == INTEGER_CST
9352 && TREE_CODE (equal_result
) == INTEGER_CST
9353 && TREE_CODE (low_result
) == INTEGER_CST
)
9355 /* Make a 3-bit mask with the high-order bit being the
9356 value for `>', the next for '=', and the low for '<'. */
9357 switch ((integer_onep (high_result
) * 4)
9358 + (integer_onep (equal_result
) * 2)
9359 + integer_onep (low_result
))
9363 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
9384 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
9389 tem
= save_expr (build2 (code
, type
, cval1
, cval2
));
9390 SET_EXPR_LOCATION (tem
, loc
);
9393 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
9398 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9399 into a single range test. */
9400 if ((TREE_CODE (arg0
) == TRUNC_DIV_EXPR
9401 || TREE_CODE (arg0
) == EXACT_DIV_EXPR
)
9402 && TREE_CODE (arg1
) == INTEGER_CST
9403 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9404 && !integer_zerop (TREE_OPERAND (arg0
, 1))
9405 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
9406 && !TREE_OVERFLOW (arg1
))
9408 tem
= fold_div_compare (loc
, code
, type
, arg0
, arg1
);
9409 if (tem
!= NULL_TREE
)
9413 /* Fold ~X op ~Y as Y op X. */
9414 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9415 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
9417 tree cmp_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
9418 return fold_build2_loc (loc
, code
, type
,
9419 fold_convert_loc (loc
, cmp_type
,
9420 TREE_OPERAND (arg1
, 0)),
9421 TREE_OPERAND (arg0
, 0));
9424 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9425 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9426 && (TREE_CODE (arg1
) == INTEGER_CST
|| TREE_CODE (arg1
) == VECTOR_CST
))
9428 tree cmp_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
9429 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9430 TREE_OPERAND (arg0
, 0),
9431 fold_build1_loc (loc
, BIT_NOT_EXPR
, cmp_type
,
9432 fold_convert_loc (loc
, cmp_type
, arg1
)));
9439 /* Subroutine of fold_binary. Optimize complex multiplications of the
9440 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9441 argument EXPR represents the expression "z" of type TYPE. */
9444 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
9446 tree itype
= TREE_TYPE (type
);
9447 tree rpart
, ipart
, tem
;
9449 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
9451 rpart
= TREE_OPERAND (expr
, 0);
9452 ipart
= TREE_OPERAND (expr
, 1);
9454 else if (TREE_CODE (expr
) == COMPLEX_CST
)
9456 rpart
= TREE_REALPART (expr
);
9457 ipart
= TREE_IMAGPART (expr
);
9461 expr
= save_expr (expr
);
9462 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
9463 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
9466 rpart
= save_expr (rpart
);
9467 ipart
= save_expr (ipart
);
9468 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
9469 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
9470 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
9471 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
9472 build_zero_cst (itype
));
9476 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9477 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9478 guarantees that P and N have the same least significant log2(M) bits.
9479 N is not otherwise constrained. In particular, N is not normalized to
9480 0 <= N < M as is common. In general, the precise value of P is unknown.
9481 M is chosen as large as possible such that constant N can be determined.
9483 Returns M and sets *RESIDUE to N.
9485 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9486 account. This is not always possible due to PR 35705.
9489 static unsigned HOST_WIDE_INT
9490 get_pointer_modulus_and_residue (tree expr
, unsigned HOST_WIDE_INT
*residue
,
9491 bool allow_func_align
)
9493 enum tree_code code
;
9497 code
= TREE_CODE (expr
);
9498 if (code
== ADDR_EXPR
)
9500 unsigned int bitalign
;
9501 get_object_alignment_1 (TREE_OPERAND (expr
, 0), &bitalign
, residue
);
9502 *residue
/= BITS_PER_UNIT
;
9503 return bitalign
/ BITS_PER_UNIT
;
9505 else if (code
== POINTER_PLUS_EXPR
)
9508 unsigned HOST_WIDE_INT modulus
;
9509 enum tree_code inner_code
;
9511 op0
= TREE_OPERAND (expr
, 0);
9513 modulus
= get_pointer_modulus_and_residue (op0
, residue
,
9516 op1
= TREE_OPERAND (expr
, 1);
9518 inner_code
= TREE_CODE (op1
);
9519 if (inner_code
== INTEGER_CST
)
9521 *residue
+= TREE_INT_CST_LOW (op1
);
9524 else if (inner_code
== MULT_EXPR
)
9526 op1
= TREE_OPERAND (op1
, 1);
9527 if (TREE_CODE (op1
) == INTEGER_CST
)
9529 unsigned HOST_WIDE_INT align
;
9531 /* Compute the greatest power-of-2 divisor of op1. */
9532 align
= TREE_INT_CST_LOW (op1
);
9535 /* If align is non-zero and less than *modulus, replace
9536 *modulus with align., If align is 0, then either op1 is 0
9537 or the greatest power-of-2 divisor of op1 doesn't fit in an
9538 unsigned HOST_WIDE_INT. In either case, no additional
9539 constraint is imposed. */
9541 modulus
= MIN (modulus
, align
);
9548 /* If we get here, we were unable to determine anything useful about the
9553 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
9554 CONSTRUCTOR ARG into array ELTS and return true if successful. */
9557 vec_cst_ctor_to_array (tree arg
, tree
*elts
)
9559 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg
)), i
;
9561 if (TREE_CODE (arg
) == VECTOR_CST
)
9563 for (i
= 0; i
< VECTOR_CST_NELTS (arg
); ++i
)
9564 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
9566 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
9568 constructor_elt
*elt
;
9570 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
9571 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
9574 elts
[i
] = elt
->value
;
9578 for (; i
< nelts
; i
++)
9580 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
9584 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
9585 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
9586 NULL_TREE otherwise. */
9589 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const unsigned char *sel
)
9591 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
9593 bool need_ctor
= false;
9595 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
9596 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
);
9597 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
9598 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
9601 elts
= XALLOCAVEC (tree
, nelts
* 3);
9602 if (!vec_cst_ctor_to_array (arg0
, elts
)
9603 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
))
9606 for (i
= 0; i
< nelts
; i
++)
9608 if (!CONSTANT_CLASS_P (elts
[sel
[i
]]))
9610 elts
[i
+ 2 * nelts
] = unshare_expr (elts
[sel
[i
]]);
9615 vec
<constructor_elt
, va_gc
> *v
;
9616 vec_alloc (v
, nelts
);
9617 for (i
= 0; i
< nelts
; i
++)
9618 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, elts
[2 * nelts
+ i
]);
9619 return build_constructor (type
, v
);
9622 return build_vector (type
, &elts
[2 * nelts
]);
9625 /* Try to fold a pointer difference of type TYPE two address expressions of
9626 array references AREF0 and AREF1 using location LOC. Return a
9627 simplified expression for the difference or NULL_TREE. */
9630 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
9631 tree aref0
, tree aref1
)
9633 tree base0
= TREE_OPERAND (aref0
, 0);
9634 tree base1
= TREE_OPERAND (aref1
, 0);
9635 tree base_offset
= build_int_cst (type
, 0);
9637 /* If the bases are array references as well, recurse. If the bases
9638 are pointer indirections compute the difference of the pointers.
9639 If the bases are equal, we are set. */
9640 if ((TREE_CODE (base0
) == ARRAY_REF
9641 && TREE_CODE (base1
) == ARRAY_REF
9643 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
)))
9644 || (INDIRECT_REF_P (base0
)
9645 && INDIRECT_REF_P (base1
)
9646 && (base_offset
= fold_binary_loc (loc
, MINUS_EXPR
, type
,
9647 TREE_OPERAND (base0
, 0),
9648 TREE_OPERAND (base1
, 0))))
9649 || operand_equal_p (base0
, base1
, 0))
9651 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
9652 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
9653 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
9654 tree diff
= build2 (MINUS_EXPR
, type
, op0
, op1
);
9655 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9657 fold_build2_loc (loc
, MULT_EXPR
, type
,
9663 /* If the real or vector real constant CST of type TYPE has an exact
9664 inverse, return it, else return NULL. */
9667 exact_inverse (tree type
, tree cst
)
9670 tree unit_type
, *elts
;
9671 enum machine_mode mode
;
9672 unsigned vec_nelts
, i
;
9674 switch (TREE_CODE (cst
))
9677 r
= TREE_REAL_CST (cst
);
9679 if (exact_real_inverse (TYPE_MODE (type
), &r
))
9680 return build_real (type
, r
);
9685 vec_nelts
= VECTOR_CST_NELTS (cst
);
9686 elts
= XALLOCAVEC (tree
, vec_nelts
);
9687 unit_type
= TREE_TYPE (type
);
9688 mode
= TYPE_MODE (unit_type
);
9690 for (i
= 0; i
< vec_nelts
; i
++)
9692 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
9693 if (!exact_real_inverse (mode
, &r
))
9695 elts
[i
] = build_real (unit_type
, r
);
9698 return build_vector (type
, elts
);
9705 /* Mask out the tz least significant bits of X of type TYPE where
9706 tz is the number of trailing zeroes in Y. */
9708 mask_with_tz (tree type
, const wide_int
&x
, const wide_int
&y
)
9710 int tz
= wi::ctz (y
);
9712 return wi::mask (tz
, true, TYPE_PRECISION (type
)) & x
;
9716 /* Return true when T is an address and is known to be nonzero.
9717 For floating point we further ensure that T is not denormal.
9718 Similar logic is present in nonzero_address in rtlanal.h.
9720 If the return value is based on the assumption that signed overflow
9721 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9722 change *STRICT_OVERFLOW_P. */
9725 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
9727 tree type
= TREE_TYPE (t
);
9728 enum tree_code code
;
9730 /* Doing something useful for floating point would need more work. */
9731 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
9734 code
= TREE_CODE (t
);
9735 switch (TREE_CODE_CLASS (code
))
9738 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9741 case tcc_comparison
:
9742 return tree_binary_nonzero_warnv_p (code
, type
,
9743 TREE_OPERAND (t
, 0),
9744 TREE_OPERAND (t
, 1),
9747 case tcc_declaration
:
9749 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9757 case TRUTH_NOT_EXPR
:
9758 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9761 case TRUTH_AND_EXPR
:
9763 case TRUTH_XOR_EXPR
:
9764 return tree_binary_nonzero_warnv_p (code
, type
,
9765 TREE_OPERAND (t
, 0),
9766 TREE_OPERAND (t
, 1),
9774 case WITH_SIZE_EXPR
:
9776 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9781 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
9785 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
9790 tree fndecl
= get_callee_fndecl (t
);
9791 if (!fndecl
) return false;
9792 if (flag_delete_null_pointer_checks
&& !flag_check_new
9793 && DECL_IS_OPERATOR_NEW (fndecl
)
9794 && !TREE_NOTHROW (fndecl
))
9796 if (flag_delete_null_pointer_checks
9797 && lookup_attribute ("returns_nonnull",
9798 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
9800 return alloca_call_p (t
);
9809 /* Return true when T is an address and is known to be nonzero.
9810 Handle warnings about undefined signed overflow. */
9813 tree_expr_nonzero_p (tree t
)
9815 bool ret
, strict_overflow_p
;
9817 strict_overflow_p
= false;
9818 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
9819 if (strict_overflow_p
)
9820 fold_overflow_warning (("assuming signed overflow does not occur when "
9821 "determining that expression is always "
9823 WARN_STRICT_OVERFLOW_MISC
);
9827 /* Fold a binary expression of code CODE and type TYPE with operands
9828 OP0 and OP1. LOC is the location of the resulting expression.
9829 Return the folded expression if folding is successful. Otherwise,
9830 return NULL_TREE. */
9833 fold_binary_loc (location_t loc
,
9834 enum tree_code code
, tree type
, tree op0
, tree op1
)
9836 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
9837 tree arg0
, arg1
, tem
;
9838 tree t1
= NULL_TREE
;
9839 bool strict_overflow_p
;
9842 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
9843 && TREE_CODE_LENGTH (code
) == 2
9845 && op1
!= NULL_TREE
);
9850 /* Strip any conversions that don't change the mode. This is
9851 safe for every expression, except for a comparison expression
9852 because its signedness is derived from its operands. So, in
9853 the latter case, only strip conversions that don't change the
9854 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9857 Note that this is done as an internal manipulation within the
9858 constant folder, in order to find the simplest representation
9859 of the arguments so that their form can be studied. In any
9860 cases, the appropriate type conversions should be put back in
9861 the tree that will get out of the constant folder. */
9863 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
9865 STRIP_SIGN_NOPS (arg0
);
9866 STRIP_SIGN_NOPS (arg1
);
9874 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9875 constant but we can't do arithmetic on them. */
9876 if ((TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
9877 || (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
9878 || (TREE_CODE (arg0
) == FIXED_CST
&& TREE_CODE (arg1
) == FIXED_CST
)
9879 || (TREE_CODE (arg0
) == FIXED_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
9880 || (TREE_CODE (arg0
) == COMPLEX_CST
&& TREE_CODE (arg1
) == COMPLEX_CST
)
9881 || (TREE_CODE (arg0
) == VECTOR_CST
&& TREE_CODE (arg1
) == VECTOR_CST
)
9882 || (TREE_CODE (arg0
) == VECTOR_CST
&& TREE_CODE (arg1
) == INTEGER_CST
))
9884 if (kind
== tcc_binary
)
9886 /* Make sure type and arg0 have the same saturating flag. */
9887 gcc_assert (TYPE_SATURATING (type
)
9888 == TYPE_SATURATING (TREE_TYPE (arg0
)));
9889 tem
= const_binop (code
, arg0
, arg1
);
9891 else if (kind
== tcc_comparison
)
9892 tem
= fold_relational_const (code
, type
, arg0
, arg1
);
9896 if (tem
!= NULL_TREE
)
9898 if (TREE_TYPE (tem
) != type
)
9899 tem
= fold_convert_loc (loc
, type
, tem
);
9904 /* If this is a commutative operation, and ARG0 is a constant, move it
9905 to ARG1 to reduce the number of tests below. */
9906 if (commutative_tree_code (code
)
9907 && tree_swap_operands_p (arg0
, arg1
, true))
9908 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
9910 /* Likewise if this is a comparison, and ARG0 is a constant, move it
9911 to ARG1 to reduce the number of tests below. */
9912 if (kind
== tcc_comparison
9913 && tree_swap_operands_p (arg0
, arg1
, true))
9914 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
9916 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9918 First check for cases where an arithmetic operation is applied to a
9919 compound, conditional, or comparison operation. Push the arithmetic
9920 operation inside the compound or conditional to see if any folding
9921 can then be done. Convert comparison to conditional for this purpose.
9922 The also optimizes non-constant cases that used to be done in
9925 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9926 one of the operands is a comparison and the other is a comparison, a
9927 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9928 code below would make the expression more complex. Change it to a
9929 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9930 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9932 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
9933 || code
== EQ_EXPR
|| code
== NE_EXPR
)
9934 && TREE_CODE (type
) != VECTOR_TYPE
9935 && ((truth_value_p (TREE_CODE (arg0
))
9936 && (truth_value_p (TREE_CODE (arg1
))
9937 || (TREE_CODE (arg1
) == BIT_AND_EXPR
9938 && integer_onep (TREE_OPERAND (arg1
, 1)))))
9939 || (truth_value_p (TREE_CODE (arg1
))
9940 && (truth_value_p (TREE_CODE (arg0
))
9941 || (TREE_CODE (arg0
) == BIT_AND_EXPR
9942 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
9944 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
9945 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
9948 fold_convert_loc (loc
, boolean_type_node
, arg0
),
9949 fold_convert_loc (loc
, boolean_type_node
, arg1
));
9951 if (code
== EQ_EXPR
)
9952 tem
= invert_truthvalue_loc (loc
, tem
);
9954 return fold_convert_loc (loc
, type
, tem
);
9957 if (TREE_CODE_CLASS (code
) == tcc_binary
9958 || TREE_CODE_CLASS (code
) == tcc_comparison
)
9960 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
9962 tem
= fold_build2_loc (loc
, code
, type
,
9963 fold_convert_loc (loc
, TREE_TYPE (op0
),
9964 TREE_OPERAND (arg0
, 1)), op1
);
9965 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
9968 if (TREE_CODE (arg1
) == COMPOUND_EXPR
9969 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
9971 tem
= fold_build2_loc (loc
, code
, type
, op0
,
9972 fold_convert_loc (loc
, TREE_TYPE (op1
),
9973 TREE_OPERAND (arg1
, 1)));
9974 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
9978 if (TREE_CODE (arg0
) == COND_EXPR
9979 || TREE_CODE (arg0
) == VEC_COND_EXPR
9980 || COMPARISON_CLASS_P (arg0
))
9982 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9984 /*cond_first_p=*/1);
9985 if (tem
!= NULL_TREE
)
9989 if (TREE_CODE (arg1
) == COND_EXPR
9990 || TREE_CODE (arg1
) == VEC_COND_EXPR
9991 || COMPARISON_CLASS_P (arg1
))
9993 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9995 /*cond_first_p=*/0);
9996 if (tem
!= NULL_TREE
)
10004 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
10005 if (TREE_CODE (arg0
) == ADDR_EXPR
10006 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
10008 tree iref
= TREE_OPERAND (arg0
, 0);
10009 return fold_build2 (MEM_REF
, type
,
10010 TREE_OPERAND (iref
, 0),
10011 int_const_binop (PLUS_EXPR
, arg1
,
10012 TREE_OPERAND (iref
, 1)));
10015 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
10016 if (TREE_CODE (arg0
) == ADDR_EXPR
10017 && handled_component_p (TREE_OPERAND (arg0
, 0)))
10020 HOST_WIDE_INT coffset
;
10021 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
10025 return fold_build2 (MEM_REF
, type
,
10026 build_fold_addr_expr (base
),
10027 int_const_binop (PLUS_EXPR
, arg1
,
10028 size_int (coffset
)));
10033 case POINTER_PLUS_EXPR
:
10034 /* 0 +p index -> (type)index */
10035 if (integer_zerop (arg0
))
10036 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10038 /* PTR +p 0 -> PTR */
10039 if (integer_zerop (arg1
))
10040 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10042 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
10043 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10044 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
10045 return fold_convert_loc (loc
, type
,
10046 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
10047 fold_convert_loc (loc
, sizetype
,
10049 fold_convert_loc (loc
, sizetype
,
10052 /* (PTR +p B) +p A -> PTR +p (B + A) */
10053 if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
10056 tree arg01
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (arg0
, 1));
10057 tree arg00
= TREE_OPERAND (arg0
, 0);
10058 inner
= fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
10059 arg01
, fold_convert_loc (loc
, sizetype
, arg1
));
10060 return fold_convert_loc (loc
, type
,
10061 fold_build_pointer_plus_loc (loc
,
10065 /* PTR_CST +p CST -> CST1 */
10066 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
10067 return fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
,
10068 fold_convert_loc (loc
, type
, arg1
));
10073 /* A + (-B) -> A - B */
10074 if (TREE_CODE (arg1
) == NEGATE_EXPR
10075 && (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
10076 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10077 fold_convert_loc (loc
, type
, arg0
),
10078 fold_convert_loc (loc
, type
,
10079 TREE_OPERAND (arg1
, 0)));
10080 /* (-A) + B -> B - A */
10081 if (TREE_CODE (arg0
) == NEGATE_EXPR
10082 && reorder_operands_p (TREE_OPERAND (arg0
, 0), arg1
)
10083 && (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
10084 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10085 fold_convert_loc (loc
, type
, arg1
),
10086 fold_convert_loc (loc
, type
,
10087 TREE_OPERAND (arg0
, 0)));
10089 if (INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
10091 /* Convert ~A + 1 to -A. */
10092 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10093 && integer_each_onep (arg1
))
10094 return fold_build1_loc (loc
, NEGATE_EXPR
, type
,
10095 fold_convert_loc (loc
, type
,
10096 TREE_OPERAND (arg0
, 0)));
10098 /* ~X + X is -1. */
10099 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10100 && !TYPE_OVERFLOW_TRAPS (type
))
10102 tree tem
= TREE_OPERAND (arg0
, 0);
10105 if (operand_equal_p (tem
, arg1
, 0))
10107 t1
= build_all_ones_cst (type
);
10108 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
10112 /* X + ~X is -1. */
10113 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
10114 && !TYPE_OVERFLOW_TRAPS (type
))
10116 tree tem
= TREE_OPERAND (arg1
, 0);
10119 if (operand_equal_p (arg0
, tem
, 0))
10121 t1
= build_all_ones_cst (type
);
10122 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
10126 /* X + (X / CST) * -CST is X % CST. */
10127 if (TREE_CODE (arg1
) == MULT_EXPR
10128 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10129 && operand_equal_p (arg0
,
10130 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
10132 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
10133 tree cst1
= TREE_OPERAND (arg1
, 1);
10134 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
10136 if (sum
&& integer_zerop (sum
))
10137 return fold_convert_loc (loc
, type
,
10138 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
10139 TREE_TYPE (arg0
), arg0
,
10144 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
10145 one. Make sure the type is not saturating and has the signedness of
10146 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10147 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10148 if ((TREE_CODE (arg0
) == MULT_EXPR
10149 || TREE_CODE (arg1
) == MULT_EXPR
)
10150 && !TYPE_SATURATING (type
)
10151 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10152 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10153 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10155 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10160 if (! FLOAT_TYPE_P (type
))
10162 if (integer_zerop (arg1
))
10163 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10165 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10166 with a constant, and the two constants have no bits in common,
10167 we should treat this as a BIT_IOR_EXPR since this may produce more
10168 simplifications. */
10169 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10170 && TREE_CODE (arg1
) == BIT_AND_EXPR
10171 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10172 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
10173 && wi::bit_and (TREE_OPERAND (arg0
, 1),
10174 TREE_OPERAND (arg1
, 1)) == 0)
10176 code
= BIT_IOR_EXPR
;
10180 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10181 (plus (plus (mult) (mult)) (foo)) so that we can
10182 take advantage of the factoring cases below. */
10183 if (TYPE_OVERFLOW_WRAPS (type
)
10184 && (((TREE_CODE (arg0
) == PLUS_EXPR
10185 || TREE_CODE (arg0
) == MINUS_EXPR
)
10186 && TREE_CODE (arg1
) == MULT_EXPR
)
10187 || ((TREE_CODE (arg1
) == PLUS_EXPR
10188 || TREE_CODE (arg1
) == MINUS_EXPR
)
10189 && TREE_CODE (arg0
) == MULT_EXPR
)))
10191 tree parg0
, parg1
, parg
, marg
;
10192 enum tree_code pcode
;
10194 if (TREE_CODE (arg1
) == MULT_EXPR
)
10195 parg
= arg0
, marg
= arg1
;
10197 parg
= arg1
, marg
= arg0
;
10198 pcode
= TREE_CODE (parg
);
10199 parg0
= TREE_OPERAND (parg
, 0);
10200 parg1
= TREE_OPERAND (parg
, 1);
10201 STRIP_NOPS (parg0
);
10202 STRIP_NOPS (parg1
);
10204 if (TREE_CODE (parg0
) == MULT_EXPR
10205 && TREE_CODE (parg1
) != MULT_EXPR
)
10206 return fold_build2_loc (loc
, pcode
, type
,
10207 fold_build2_loc (loc
, PLUS_EXPR
, type
,
10208 fold_convert_loc (loc
, type
,
10210 fold_convert_loc (loc
, type
,
10212 fold_convert_loc (loc
, type
, parg1
));
10213 if (TREE_CODE (parg0
) != MULT_EXPR
10214 && TREE_CODE (parg1
) == MULT_EXPR
)
10216 fold_build2_loc (loc
, PLUS_EXPR
, type
,
10217 fold_convert_loc (loc
, type
, parg0
),
10218 fold_build2_loc (loc
, pcode
, type
,
10219 fold_convert_loc (loc
, type
, marg
),
10220 fold_convert_loc (loc
, type
,
10226 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10227 if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 0))
10228 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10230 /* Likewise if the operands are reversed. */
10231 if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10232 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10234 /* Convert X + -C into X - C. */
10235 if (TREE_CODE (arg1
) == REAL_CST
10236 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
)))
10238 tem
= fold_negate_const (arg1
, type
);
10239 if (!TREE_OVERFLOW (arg1
) || !flag_trapping_math
)
10240 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10241 fold_convert_loc (loc
, type
, arg0
),
10242 fold_convert_loc (loc
, type
, tem
));
10245 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10246 to __complex__ ( x, y ). This is not the same for SNaNs or
10247 if signed zeros are involved. */
10248 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10249 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10250 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10252 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10253 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10254 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10255 bool arg0rz
= false, arg0iz
= false;
10256 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10257 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10259 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10260 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10261 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10263 tree rp
= arg1r
? arg1r
10264 : build1 (REALPART_EXPR
, rtype
, arg1
);
10265 tree ip
= arg0i
? arg0i
10266 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10267 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10269 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10271 tree rp
= arg0r
? arg0r
10272 : build1 (REALPART_EXPR
, rtype
, arg0
);
10273 tree ip
= arg1i
? arg1i
10274 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
10275 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10280 if (flag_unsafe_math_optimizations
10281 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10282 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10283 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10286 /* Convert x+x into x*2.0. */
10287 if (operand_equal_p (arg0
, arg1
, 0)
10288 && SCALAR_FLOAT_TYPE_P (type
))
10289 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
,
10290 build_real (type
, dconst2
));
10292 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10293 We associate floats only if the user has specified
10294 -fassociative-math. */
10295 if (flag_associative_math
10296 && TREE_CODE (arg1
) == PLUS_EXPR
10297 && TREE_CODE (arg0
) != MULT_EXPR
)
10299 tree tree10
= TREE_OPERAND (arg1
, 0);
10300 tree tree11
= TREE_OPERAND (arg1
, 1);
10301 if (TREE_CODE (tree11
) == MULT_EXPR
10302 && TREE_CODE (tree10
) == MULT_EXPR
)
10305 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
10306 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
10309 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10310 We associate floats only if the user has specified
10311 -fassociative-math. */
10312 if (flag_associative_math
10313 && TREE_CODE (arg0
) == PLUS_EXPR
10314 && TREE_CODE (arg1
) != MULT_EXPR
)
10316 tree tree00
= TREE_OPERAND (arg0
, 0);
10317 tree tree01
= TREE_OPERAND (arg0
, 1);
10318 if (TREE_CODE (tree01
) == MULT_EXPR
10319 && TREE_CODE (tree00
) == MULT_EXPR
)
10322 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
10323 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
10329 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10330 is a rotate of A by C1 bits. */
10331 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10332 is a rotate of A by B bits. */
10334 enum tree_code code0
, code1
;
10336 code0
= TREE_CODE (arg0
);
10337 code1
= TREE_CODE (arg1
);
10338 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
10339 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
10340 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10341 TREE_OPERAND (arg1
, 0), 0)
10342 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10343 TYPE_UNSIGNED (rtype
))
10344 /* Only create rotates in complete modes. Other cases are not
10345 expanded properly. */
10346 && (element_precision (rtype
)
10347 == element_precision (TYPE_MODE (rtype
))))
10349 tree tree01
, tree11
;
10350 enum tree_code code01
, code11
;
10352 tree01
= TREE_OPERAND (arg0
, 1);
10353 tree11
= TREE_OPERAND (arg1
, 1);
10354 STRIP_NOPS (tree01
);
10355 STRIP_NOPS (tree11
);
10356 code01
= TREE_CODE (tree01
);
10357 code11
= TREE_CODE (tree11
);
10358 if (code01
== INTEGER_CST
10359 && code11
== INTEGER_CST
10360 && (wi::to_widest (tree01
) + wi::to_widest (tree11
)
10361 == element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)))))
10363 tem
= build2_loc (loc
, LROTATE_EXPR
,
10364 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10365 TREE_OPERAND (arg0
, 0),
10366 code0
== LSHIFT_EXPR
? tree01
: tree11
);
10367 return fold_convert_loc (loc
, type
, tem
);
10369 else if (code11
== MINUS_EXPR
)
10371 tree tree110
, tree111
;
10372 tree110
= TREE_OPERAND (tree11
, 0);
10373 tree111
= TREE_OPERAND (tree11
, 1);
10374 STRIP_NOPS (tree110
);
10375 STRIP_NOPS (tree111
);
10376 if (TREE_CODE (tree110
) == INTEGER_CST
10377 && 0 == compare_tree_int (tree110
,
10379 (TREE_TYPE (TREE_OPERAND
10381 && operand_equal_p (tree01
, tree111
, 0))
10383 fold_convert_loc (loc
, type
,
10384 build2 ((code0
== LSHIFT_EXPR
10387 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10388 TREE_OPERAND (arg0
, 0), tree01
));
10390 else if (code01
== MINUS_EXPR
)
10392 tree tree010
, tree011
;
10393 tree010
= TREE_OPERAND (tree01
, 0);
10394 tree011
= TREE_OPERAND (tree01
, 1);
10395 STRIP_NOPS (tree010
);
10396 STRIP_NOPS (tree011
);
10397 if (TREE_CODE (tree010
) == INTEGER_CST
10398 && 0 == compare_tree_int (tree010
,
10400 (TREE_TYPE (TREE_OPERAND
10402 && operand_equal_p (tree11
, tree011
, 0))
10403 return fold_convert_loc
10405 build2 ((code0
!= LSHIFT_EXPR
10408 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10409 TREE_OPERAND (arg0
, 0), tree11
));
10415 /* In most languages, can't associate operations on floats through
10416 parentheses. Rather than remember where the parentheses were, we
10417 don't associate floats at all, unless the user has specified
10418 -fassociative-math.
10419 And, we need to make sure type is not saturating. */
10421 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
10422 && !TYPE_SATURATING (type
))
10424 tree var0
, con0
, lit0
, minus_lit0
;
10425 tree var1
, con1
, lit1
, minus_lit1
;
10429 /* Split both trees into variables, constants, and literals. Then
10430 associate each group together, the constants with literals,
10431 then the result with variables. This increases the chances of
10432 literals being recombined later and of generating relocatable
10433 expressions for the sum of a constant and literal. */
10434 var0
= split_tree (arg0
, code
, &con0
, &lit0
, &minus_lit0
, 0);
10435 var1
= split_tree (arg1
, code
, &con1
, &lit1
, &minus_lit1
,
10436 code
== MINUS_EXPR
);
10438 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10439 if (code
== MINUS_EXPR
)
10442 /* With undefined overflow prefer doing association in a type
10443 which wraps on overflow, if that is one of the operand types. */
10444 if ((POINTER_TYPE_P (type
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
10445 || (INTEGRAL_TYPE_P (type
) && !TYPE_OVERFLOW_WRAPS (type
)))
10447 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10448 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
10449 atype
= TREE_TYPE (arg0
);
10450 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10451 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
10452 atype
= TREE_TYPE (arg1
);
10453 gcc_assert (TYPE_PRECISION (atype
) == TYPE_PRECISION (type
));
10456 /* With undefined overflow we can only associate constants with one
10457 variable, and constants whose association doesn't overflow. */
10458 if ((POINTER_TYPE_P (atype
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
10459 || (INTEGRAL_TYPE_P (atype
) && !TYPE_OVERFLOW_WRAPS (atype
)))
10466 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
10467 tmp0
= TREE_OPERAND (tmp0
, 0);
10468 if (CONVERT_EXPR_P (tmp0
)
10469 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
10470 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
10471 <= TYPE_PRECISION (atype
)))
10472 tmp0
= TREE_OPERAND (tmp0
, 0);
10473 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
10474 tmp1
= TREE_OPERAND (tmp1
, 0);
10475 if (CONVERT_EXPR_P (tmp1
)
10476 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
10477 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
10478 <= TYPE_PRECISION (atype
)))
10479 tmp1
= TREE_OPERAND (tmp1
, 0);
10480 /* The only case we can still associate with two variables
10481 is if they are the same, modulo negation and bit-pattern
10482 preserving conversions. */
10483 if (!operand_equal_p (tmp0
, tmp1
, 0))
10488 /* Only do something if we found more than two objects. Otherwise,
10489 nothing has changed and we risk infinite recursion. */
10491 && (2 < ((var0
!= 0) + (var1
!= 0)
10492 + (con0
!= 0) + (con1
!= 0)
10493 + (lit0
!= 0) + (lit1
!= 0)
10494 + (minus_lit0
!= 0) + (minus_lit1
!= 0))))
10496 bool any_overflows
= false;
10497 if (lit0
) any_overflows
|= TREE_OVERFLOW (lit0
);
10498 if (lit1
) any_overflows
|= TREE_OVERFLOW (lit1
);
10499 if (minus_lit0
) any_overflows
|= TREE_OVERFLOW (minus_lit0
);
10500 if (minus_lit1
) any_overflows
|= TREE_OVERFLOW (minus_lit1
);
10501 var0
= associate_trees (loc
, var0
, var1
, code
, atype
);
10502 con0
= associate_trees (loc
, con0
, con1
, code
, atype
);
10503 lit0
= associate_trees (loc
, lit0
, lit1
, code
, atype
);
10504 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
,
10507 /* Preserve the MINUS_EXPR if the negative part of the literal is
10508 greater than the positive part. Otherwise, the multiplicative
10509 folding code (i.e extract_muldiv) may be fooled in case
10510 unsigned constants are subtracted, like in the following
10511 example: ((X*2 + 4) - 8U)/2. */
10512 if (minus_lit0
&& lit0
)
10514 if (TREE_CODE (lit0
) == INTEGER_CST
10515 && TREE_CODE (minus_lit0
) == INTEGER_CST
10516 && tree_int_cst_lt (lit0
, minus_lit0
))
10518 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
10519 MINUS_EXPR
, atype
);
10524 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
10525 MINUS_EXPR
, atype
);
10530 /* Don't introduce overflows through reassociation. */
10532 && ((lit0
&& TREE_OVERFLOW (lit0
))
10533 || (minus_lit0
&& TREE_OVERFLOW (minus_lit0
))))
10540 fold_convert_loc (loc
, type
,
10541 associate_trees (loc
, var0
, minus_lit0
,
10542 MINUS_EXPR
, atype
));
10545 con0
= associate_trees (loc
, con0
, minus_lit0
,
10546 MINUS_EXPR
, atype
);
10548 fold_convert_loc (loc
, type
,
10549 associate_trees (loc
, var0
, con0
,
10550 PLUS_EXPR
, atype
));
10554 con0
= associate_trees (loc
, con0
, lit0
, code
, atype
);
10556 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
10564 /* Pointer simplifications for subtraction, simple reassociations. */
10565 if (POINTER_TYPE_P (TREE_TYPE (arg1
)) && POINTER_TYPE_P (TREE_TYPE (arg0
)))
10567 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10568 if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
10569 && TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
10571 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10572 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10573 tree arg10
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10574 tree arg11
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10575 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10576 fold_build2_loc (loc
, MINUS_EXPR
, type
,
10578 fold_build2_loc (loc
, MINUS_EXPR
, type
,
10581 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10582 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
10584 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10585 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10586 tree tmp
= fold_binary_loc (loc
, MINUS_EXPR
, type
, arg00
,
10587 fold_convert_loc (loc
, type
, arg1
));
10589 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tmp
, arg01
);
10591 /* PTR0 - (PTR1 p+ A) -> (PTR0 - PTR1) - A, assuming PTR0 - PTR1
10593 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
10595 tree arg10
= fold_convert_loc (loc
, type
,
10596 TREE_OPERAND (arg1
, 0));
10597 tree arg11
= fold_convert_loc (loc
, type
,
10598 TREE_OPERAND (arg1
, 1));
10599 tree tmp
= fold_binary_loc (loc
, MINUS_EXPR
, type
, arg0
,
10600 fold_convert_loc (loc
, type
, arg10
));
10602 return fold_build2_loc (loc
, MINUS_EXPR
, type
, tmp
, arg11
);
10605 /* A - (-B) -> A + B */
10606 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
10607 return fold_build2_loc (loc
, PLUS_EXPR
, type
, op0
,
10608 fold_convert_loc (loc
, type
,
10609 TREE_OPERAND (arg1
, 0)));
10610 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10611 if (TREE_CODE (arg0
) == NEGATE_EXPR
10612 && negate_expr_p (arg1
)
10613 && reorder_operands_p (arg0
, arg1
))
10614 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10615 fold_convert_loc (loc
, type
,
10616 negate_expr (arg1
)),
10617 fold_convert_loc (loc
, type
,
10618 TREE_OPERAND (arg0
, 0)));
10619 /* Convert -A - 1 to ~A. */
10620 if (TREE_CODE (arg0
) == NEGATE_EXPR
10621 && integer_each_onep (arg1
)
10622 && !TYPE_OVERFLOW_TRAPS (type
))
10623 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
10624 fold_convert_loc (loc
, type
,
10625 TREE_OPERAND (arg0
, 0)));
10627 /* Convert -1 - A to ~A. */
10628 if (TREE_CODE (type
) != COMPLEX_TYPE
10629 && integer_all_onesp (arg0
))
10630 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op1
);
10633 /* X - (X / Y) * Y is X % Y. */
10634 if ((INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
10635 && TREE_CODE (arg1
) == MULT_EXPR
10636 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10637 && operand_equal_p (arg0
,
10638 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0)
10639 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1),
10640 TREE_OPERAND (arg1
, 1), 0))
10642 fold_convert_loc (loc
, type
,
10643 fold_build2_loc (loc
, TRUNC_MOD_EXPR
, TREE_TYPE (arg0
),
10644 arg0
, TREE_OPERAND (arg1
, 1)));
10646 if (! FLOAT_TYPE_P (type
))
10648 if (integer_zerop (arg0
))
10649 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10650 if (integer_zerop (arg1
))
10651 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10653 /* Fold A - (A & B) into ~B & A. */
10654 if (!TREE_SIDE_EFFECTS (arg0
)
10655 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10657 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0))
10659 tree arg10
= fold_convert_loc (loc
, type
,
10660 TREE_OPERAND (arg1
, 0));
10661 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10662 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10664 fold_convert_loc (loc
, type
, arg0
));
10666 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10668 tree arg11
= fold_convert_loc (loc
,
10669 type
, TREE_OPERAND (arg1
, 1));
10670 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10671 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10673 fold_convert_loc (loc
, type
, arg0
));
10677 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10678 any power of 2 minus 1. */
10679 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10680 && TREE_CODE (arg1
) == BIT_AND_EXPR
10681 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10682 TREE_OPERAND (arg1
, 0), 0))
10684 tree mask0
= TREE_OPERAND (arg0
, 1);
10685 tree mask1
= TREE_OPERAND (arg1
, 1);
10686 tree tem
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, mask0
);
10688 if (operand_equal_p (tem
, mask1
, 0))
10690 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
10691 TREE_OPERAND (arg0
, 0), mask1
);
10692 return fold_build2_loc (loc
, MINUS_EXPR
, type
, tem
, mask1
);
10697 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10698 else if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 1))
10699 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10701 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10702 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10703 (-ARG1 + ARG0) reduces to -ARG1. */
10704 else if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10705 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10707 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10708 __complex__ ( x, -y ). This is not the same for SNaNs or if
10709 signed zeros are involved. */
10710 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10711 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10712 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10714 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10715 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10716 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10717 bool arg0rz
= false, arg0iz
= false;
10718 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10719 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10721 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10722 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10723 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10725 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10727 : build1 (REALPART_EXPR
, rtype
, arg1
));
10728 tree ip
= arg0i
? arg0i
10729 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10730 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10732 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10734 tree rp
= arg0r
? arg0r
10735 : build1 (REALPART_EXPR
, rtype
, arg0
);
10736 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10738 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
10739 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10744 /* Fold &x - &x. This can happen from &x.foo - &x.
10745 This is unsafe for certain floats even in non-IEEE formats.
10746 In IEEE, it is unsafe because it does wrong for NaNs.
10747 Also note that operand_equal_p is always false if an operand
10750 if ((!FLOAT_TYPE_P (type
) || !HONOR_NANS (TYPE_MODE (type
)))
10751 && operand_equal_p (arg0
, arg1
, 0))
10752 return omit_one_operand_loc (loc
, type
, build_zero_cst (type
), arg0
);
10754 /* A - B -> A + (-B) if B is easily negatable. */
10755 if (negate_expr_p (arg1
)
10756 && ((FLOAT_TYPE_P (type
)
10757 /* Avoid this transformation if B is a positive REAL_CST. */
10758 && (TREE_CODE (arg1
) != REAL_CST
10759 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
))))
10760 || INTEGRAL_TYPE_P (type
)))
10761 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10762 fold_convert_loc (loc
, type
, arg0
),
10763 fold_convert_loc (loc
, type
,
10764 negate_expr (arg1
)));
10766 /* Try folding difference of addresses. */
10768 HOST_WIDE_INT diff
;
10770 if ((TREE_CODE (arg0
) == ADDR_EXPR
10771 || TREE_CODE (arg1
) == ADDR_EXPR
)
10772 && ptr_difference_const (arg0
, arg1
, &diff
))
10773 return build_int_cst_type (type
, diff
);
10776 /* Fold &a[i] - &a[j] to i-j. */
10777 if (TREE_CODE (arg0
) == ADDR_EXPR
10778 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
10779 && TREE_CODE (arg1
) == ADDR_EXPR
10780 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
10782 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
10783 TREE_OPERAND (arg0
, 0),
10784 TREE_OPERAND (arg1
, 0));
10789 if (FLOAT_TYPE_P (type
)
10790 && flag_unsafe_math_optimizations
10791 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10792 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10793 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10796 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
10797 one. Make sure the type is not saturating and has the signedness of
10798 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10799 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10800 if ((TREE_CODE (arg0
) == MULT_EXPR
10801 || TREE_CODE (arg1
) == MULT_EXPR
)
10802 && !TYPE_SATURATING (type
)
10803 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10804 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10805 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10807 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10815 /* (-A) * (-B) -> A * B */
10816 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10817 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10818 fold_convert_loc (loc
, type
,
10819 TREE_OPERAND (arg0
, 0)),
10820 fold_convert_loc (loc
, type
,
10821 negate_expr (arg1
)));
10822 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10823 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10824 fold_convert_loc (loc
, type
,
10825 negate_expr (arg0
)),
10826 fold_convert_loc (loc
, type
,
10827 TREE_OPERAND (arg1
, 0)));
10829 if (! FLOAT_TYPE_P (type
))
10831 if (integer_zerop (arg1
))
10832 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10833 if (integer_onep (arg1
))
10834 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10835 /* Transform x * -1 into -x. Make sure to do the negation
10836 on the original operand with conversions not stripped
10837 because we can only strip non-sign-changing conversions. */
10838 if (integer_minus_onep (arg1
))
10839 return fold_convert_loc (loc
, type
, negate_expr (op0
));
10840 /* Transform x * -C into -x * C if x is easily negatable. */
10841 if (TREE_CODE (arg1
) == INTEGER_CST
10842 && tree_int_cst_sgn (arg1
) == -1
10843 && negate_expr_p (arg0
)
10844 && (tem
= negate_expr (arg1
)) != arg1
10845 && !TREE_OVERFLOW (tem
))
10846 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10847 fold_convert_loc (loc
, type
,
10848 negate_expr (arg0
)),
10851 /* (a * (1 << b)) is (a << b) */
10852 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10853 && integer_onep (TREE_OPERAND (arg1
, 0)))
10854 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op0
,
10855 TREE_OPERAND (arg1
, 1));
10856 if (TREE_CODE (arg0
) == LSHIFT_EXPR
10857 && integer_onep (TREE_OPERAND (arg0
, 0)))
10858 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op1
,
10859 TREE_OPERAND (arg0
, 1));
10861 /* (A + A) * C -> A * 2 * C */
10862 if (TREE_CODE (arg0
) == PLUS_EXPR
10863 && TREE_CODE (arg1
) == INTEGER_CST
10864 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10865 TREE_OPERAND (arg0
, 1), 0))
10866 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10867 omit_one_operand_loc (loc
, type
,
10868 TREE_OPERAND (arg0
, 0),
10869 TREE_OPERAND (arg0
, 1)),
10870 fold_build2_loc (loc
, MULT_EXPR
, type
,
10871 build_int_cst (type
, 2) , arg1
));
10873 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
10874 sign-changing only. */
10875 if (TREE_CODE (arg1
) == INTEGER_CST
10876 && TREE_CODE (arg0
) == EXACT_DIV_EXPR
10877 && operand_equal_p (arg1
, TREE_OPERAND (arg0
, 1), 0))
10878 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10880 strict_overflow_p
= false;
10881 if (TREE_CODE (arg1
) == INTEGER_CST
10882 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10883 &strict_overflow_p
)))
10885 if (strict_overflow_p
)
10886 fold_overflow_warning (("assuming signed overflow does not "
10887 "occur when simplifying "
10889 WARN_STRICT_OVERFLOW_MISC
);
10890 return fold_convert_loc (loc
, type
, tem
);
10893 /* Optimize z * conj(z) for integer complex numbers. */
10894 if (TREE_CODE (arg0
) == CONJ_EXPR
10895 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10896 return fold_mult_zconjz (loc
, type
, arg1
);
10897 if (TREE_CODE (arg1
) == CONJ_EXPR
10898 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10899 return fold_mult_zconjz (loc
, type
, arg0
);
10903 /* Maybe fold x * 0 to 0. The expressions aren't the same
10904 when x is NaN, since x * 0 is also NaN. Nor are they the
10905 same in modes with signed zeros, since multiplying a
10906 negative value by 0 gives -0, not +0. */
10907 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
10908 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10909 && real_zerop (arg1
))
10910 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10911 /* In IEEE floating point, x*1 is not equivalent to x for snans.
10912 Likewise for complex arithmetic with signed zeros. */
10913 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10914 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10915 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10916 && real_onep (arg1
))
10917 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10919 /* Transform x * -1.0 into -x. */
10920 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10921 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10922 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10923 && real_minus_onep (arg1
))
10924 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
10926 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
10927 the result for floating point types due to rounding so it is applied
10928 only if -fassociative-math was specify. */
10929 if (flag_associative_math
10930 && TREE_CODE (arg0
) == RDIV_EXPR
10931 && TREE_CODE (arg1
) == REAL_CST
10932 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
)
10934 tree tem
= const_binop (MULT_EXPR
, TREE_OPERAND (arg0
, 0),
10937 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
10938 TREE_OPERAND (arg0
, 1));
10941 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
10942 if (operand_equal_p (arg0
, arg1
, 0))
10944 tree tem
= fold_strip_sign_ops (arg0
);
10945 if (tem
!= NULL_TREE
)
10947 tem
= fold_convert_loc (loc
, type
, tem
);
10948 return fold_build2_loc (loc
, MULT_EXPR
, type
, tem
, tem
);
10952 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10953 This is not the same for NaNs or if signed zeros are
10955 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
10956 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10957 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
10958 && TREE_CODE (arg1
) == COMPLEX_CST
10959 && real_zerop (TREE_REALPART (arg1
)))
10961 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10962 if (real_onep (TREE_IMAGPART (arg1
)))
10964 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10965 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
10967 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
10968 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
10970 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10971 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
10972 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
10976 /* Optimize z * conj(z) for floating point complex numbers.
10977 Guarded by flag_unsafe_math_optimizations as non-finite
10978 imaginary components don't produce scalar results. */
10979 if (flag_unsafe_math_optimizations
10980 && TREE_CODE (arg0
) == CONJ_EXPR
10981 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10982 return fold_mult_zconjz (loc
, type
, arg1
);
10983 if (flag_unsafe_math_optimizations
10984 && TREE_CODE (arg1
) == CONJ_EXPR
10985 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10986 return fold_mult_zconjz (loc
, type
, arg0
);
10988 if (flag_unsafe_math_optimizations
)
10990 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
10991 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
10993 /* Optimizations of root(...)*root(...). */
10994 if (fcode0
== fcode1
&& BUILTIN_ROOT_P (fcode0
))
10997 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
10998 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11000 /* Optimize sqrt(x)*sqrt(x) as x. */
11001 if (BUILTIN_SQRT_P (fcode0
)
11002 && operand_equal_p (arg00
, arg10
, 0)
11003 && ! HONOR_SNANS (TYPE_MODE (type
)))
11006 /* Optimize root(x)*root(y) as root(x*y). */
11007 rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11008 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg00
, arg10
);
11009 return build_call_expr_loc (loc
, rootfn
, 1, arg
);
11012 /* Optimize expN(x)*expN(y) as expN(x+y). */
11013 if (fcode0
== fcode1
&& BUILTIN_EXPONENT_P (fcode0
))
11015 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11016 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
11017 CALL_EXPR_ARG (arg0
, 0),
11018 CALL_EXPR_ARG (arg1
, 0));
11019 return build_call_expr_loc (loc
, expfn
, 1, arg
);
11022 /* Optimizations of pow(...)*pow(...). */
11023 if ((fcode0
== BUILT_IN_POW
&& fcode1
== BUILT_IN_POW
)
11024 || (fcode0
== BUILT_IN_POWF
&& fcode1
== BUILT_IN_POWF
)
11025 || (fcode0
== BUILT_IN_POWL
&& fcode1
== BUILT_IN_POWL
))
11027 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11028 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11029 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11030 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
11032 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
11033 if (operand_equal_p (arg01
, arg11
, 0))
11035 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11036 tree arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
11038 return build_call_expr_loc (loc
, powfn
, 2, arg
, arg01
);
11041 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
11042 if (operand_equal_p (arg00
, arg10
, 0))
11044 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11045 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
11047 return build_call_expr_loc (loc
, powfn
, 2, arg00
, arg
);
11051 /* Optimize tan(x)*cos(x) as sin(x). */
11052 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_COS
)
11053 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_COSF
)
11054 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_COSL
)
11055 || (fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_TAN
)
11056 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_TANF
)
11057 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_TANL
))
11058 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11059 CALL_EXPR_ARG (arg1
, 0), 0))
11061 tree sinfn
= mathfn_built_in (type
, BUILT_IN_SIN
);
11063 if (sinfn
!= NULL_TREE
)
11064 return build_call_expr_loc (loc
, sinfn
, 1,
11065 CALL_EXPR_ARG (arg0
, 0));
11068 /* Optimize x*pow(x,c) as pow(x,c+1). */
11069 if (fcode1
== BUILT_IN_POW
11070 || fcode1
== BUILT_IN_POWF
11071 || fcode1
== BUILT_IN_POWL
)
11073 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11074 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
11075 if (TREE_CODE (arg11
) == REAL_CST
11076 && !TREE_OVERFLOW (arg11
)
11077 && operand_equal_p (arg0
, arg10
, 0))
11079 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
11083 c
= TREE_REAL_CST (arg11
);
11084 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
11085 arg
= build_real (type
, c
);
11086 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11090 /* Optimize pow(x,c)*x as pow(x,c+1). */
11091 if (fcode0
== BUILT_IN_POW
11092 || fcode0
== BUILT_IN_POWF
11093 || fcode0
== BUILT_IN_POWL
)
11095 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11096 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11097 if (TREE_CODE (arg01
) == REAL_CST
11098 && !TREE_OVERFLOW (arg01
)
11099 && operand_equal_p (arg1
, arg00
, 0))
11101 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11105 c
= TREE_REAL_CST (arg01
);
11106 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
11107 arg
= build_real (type
, c
);
11108 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
11112 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
11113 if (!in_gimple_form
11115 && operand_equal_p (arg0
, arg1
, 0))
11117 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
11121 tree arg
= build_real (type
, dconst2
);
11122 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11131 if (integer_all_onesp (arg1
))
11132 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11133 if (integer_zerop (arg1
))
11134 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11135 if (operand_equal_p (arg0
, arg1
, 0))
11136 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11138 /* ~X | X is -1. */
11139 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11140 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11142 t1
= build_zero_cst (type
);
11143 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11144 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11147 /* X | ~X is -1. */
11148 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11149 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11151 t1
= build_zero_cst (type
);
11152 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11153 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11156 /* Canonicalize (X & C1) | C2. */
11157 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11158 && TREE_CODE (arg1
) == INTEGER_CST
11159 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11161 int width
= TYPE_PRECISION (type
), w
;
11162 wide_int c1
= TREE_OPERAND (arg0
, 1);
11163 wide_int c2
= arg1
;
11165 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11166 if ((c1
& c2
) == c1
)
11167 return omit_one_operand_loc (loc
, type
, arg1
,
11168 TREE_OPERAND (arg0
, 0));
11170 wide_int msk
= wi::mask (width
, false,
11171 TYPE_PRECISION (TREE_TYPE (arg1
)));
11173 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11174 if (msk
.and_not (c1
| c2
) == 0)
11175 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11176 TREE_OPERAND (arg0
, 0), arg1
);
11178 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11179 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11180 mode which allows further optimizations. */
11183 wide_int c3
= c1
.and_not (c2
);
11184 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
11186 wide_int mask
= wi::mask (w
, false,
11187 TYPE_PRECISION (type
));
11188 if (((c1
| c2
) & mask
) == mask
&& c1
.and_not (mask
) == 0)
11196 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11197 fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11198 TREE_OPERAND (arg0
, 0),
11199 wide_int_to_tree (type
,
11204 /* (X & Y) | Y is (X, Y). */
11205 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11206 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11207 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11208 /* (X & Y) | X is (Y, X). */
11209 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11210 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11211 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11212 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11213 /* X | (X & Y) is (Y, X). */
11214 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11215 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11216 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11217 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11218 /* X | (Y & X) is (Y, X). */
11219 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11220 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11221 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11222 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11224 /* (X & ~Y) | (~X & Y) is X ^ Y */
11225 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11226 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
11228 tree a0
, a1
, l0
, l1
, n0
, n1
;
11230 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11231 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11233 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11234 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11236 n0
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l0
);
11237 n1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l1
);
11239 if ((operand_equal_p (n0
, a0
, 0)
11240 && operand_equal_p (n1
, a1
, 0))
11241 || (operand_equal_p (n0
, a1
, 0)
11242 && operand_equal_p (n1
, a0
, 0)))
11243 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, l0
, n1
);
11246 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11247 if (t1
!= NULL_TREE
)
11250 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11252 This results in more efficient code for machines without a NAND
11253 instruction. Combine will canonicalize to the first form
11254 which will allow use of NAND instructions provided by the
11255 backend if they exist. */
11256 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11257 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11260 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11261 build2 (BIT_AND_EXPR
, type
,
11262 fold_convert_loc (loc
, type
,
11263 TREE_OPERAND (arg0
, 0)),
11264 fold_convert_loc (loc
, type
,
11265 TREE_OPERAND (arg1
, 0))));
11268 /* See if this can be simplified into a rotate first. If that
11269 is unsuccessful continue in the association code. */
11273 if (integer_zerop (arg1
))
11274 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11275 if (integer_all_onesp (arg1
))
11276 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op0
);
11277 if (operand_equal_p (arg0
, arg1
, 0))
11278 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11280 /* ~X ^ X is -1. */
11281 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11282 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11284 t1
= build_zero_cst (type
);
11285 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11286 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11289 /* X ^ ~X is -1. */
11290 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11291 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11293 t1
= build_zero_cst (type
);
11294 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11295 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11298 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11299 with a constant, and the two constants have no bits in common,
11300 we should treat this as a BIT_IOR_EXPR since this may produce more
11301 simplifications. */
11302 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11303 && TREE_CODE (arg1
) == BIT_AND_EXPR
11304 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
11305 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
11306 && wi::bit_and (TREE_OPERAND (arg0
, 1),
11307 TREE_OPERAND (arg1
, 1)) == 0)
11309 code
= BIT_IOR_EXPR
;
11313 /* (X | Y) ^ X -> Y & ~ X*/
11314 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11315 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11317 tree t2
= TREE_OPERAND (arg0
, 1);
11318 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11320 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11321 fold_convert_loc (loc
, type
, t2
),
11322 fold_convert_loc (loc
, type
, t1
));
11326 /* (Y | X) ^ X -> Y & ~ X*/
11327 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11328 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11330 tree t2
= TREE_OPERAND (arg0
, 0);
11331 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11333 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11334 fold_convert_loc (loc
, type
, t2
),
11335 fold_convert_loc (loc
, type
, t1
));
11339 /* X ^ (X | Y) -> Y & ~ X*/
11340 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11341 && operand_equal_p (TREE_OPERAND (arg1
, 0), arg0
, 0))
11343 tree t2
= TREE_OPERAND (arg1
, 1);
11344 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11346 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11347 fold_convert_loc (loc
, type
, t2
),
11348 fold_convert_loc (loc
, type
, t1
));
11352 /* X ^ (Y | X) -> Y & ~ X*/
11353 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11354 && operand_equal_p (TREE_OPERAND (arg1
, 1), arg0
, 0))
11356 tree t2
= TREE_OPERAND (arg1
, 0);
11357 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11359 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11360 fold_convert_loc (loc
, type
, t2
),
11361 fold_convert_loc (loc
, type
, t1
));
11365 /* Convert ~X ^ ~Y to X ^ Y. */
11366 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11367 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11368 return fold_build2_loc (loc
, code
, type
,
11369 fold_convert_loc (loc
, type
,
11370 TREE_OPERAND (arg0
, 0)),
11371 fold_convert_loc (loc
, type
,
11372 TREE_OPERAND (arg1
, 0)));
11374 /* Convert ~X ^ C to X ^ ~C. */
11375 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11376 && TREE_CODE (arg1
) == INTEGER_CST
)
11377 return fold_build2_loc (loc
, code
, type
,
11378 fold_convert_loc (loc
, type
,
11379 TREE_OPERAND (arg0
, 0)),
11380 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, arg1
));
11382 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11383 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11384 && INTEGRAL_TYPE_P (type
)
11385 && integer_onep (TREE_OPERAND (arg0
, 1))
11386 && integer_onep (arg1
))
11387 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
11388 build_zero_cst (TREE_TYPE (arg0
)));
11390 /* Fold (X & Y) ^ Y as ~X & Y. */
11391 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11392 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11394 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11395 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11396 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11397 fold_convert_loc (loc
, type
, arg1
));
11399 /* Fold (X & Y) ^ X as ~Y & X. */
11400 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11401 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11402 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11404 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11405 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11406 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11407 fold_convert_loc (loc
, type
, arg1
));
11409 /* Fold X ^ (X & Y) as X & ~Y. */
11410 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11411 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11413 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11414 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11415 fold_convert_loc (loc
, type
, arg0
),
11416 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11418 /* Fold X ^ (Y & X) as ~Y & X. */
11419 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11420 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11421 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11423 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11424 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11425 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11426 fold_convert_loc (loc
, type
, arg0
));
11429 /* See if this can be simplified into a rotate first. If that
11430 is unsuccessful continue in the association code. */
11434 if (integer_all_onesp (arg1
))
11435 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11436 if (integer_zerop (arg1
))
11437 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11438 if (operand_equal_p (arg0
, arg1
, 0))
11439 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11441 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
11442 if ((TREE_CODE (arg0
) == BIT_NOT_EXPR
11443 || TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11444 || (TREE_CODE (arg0
) == EQ_EXPR
11445 && integer_zerop (TREE_OPERAND (arg0
, 1))))
11446 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11447 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
11449 /* X & ~X , X & (X == 0), and X & !X are always zero. */
11450 if ((TREE_CODE (arg1
) == BIT_NOT_EXPR
11451 || TREE_CODE (arg1
) == TRUTH_NOT_EXPR
11452 || (TREE_CODE (arg1
) == EQ_EXPR
11453 && integer_zerop (TREE_OPERAND (arg1
, 1))))
11454 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11455 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11457 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11458 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11459 && TREE_CODE (arg1
) == INTEGER_CST
11460 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11462 tree tmp1
= fold_convert_loc (loc
, type
, arg1
);
11463 tree tmp2
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11464 tree tmp3
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11465 tmp2
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp2
, tmp1
);
11466 tmp3
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp3
, tmp1
);
11468 fold_convert_loc (loc
, type
,
11469 fold_build2_loc (loc
, BIT_IOR_EXPR
,
11470 type
, tmp2
, tmp3
));
11473 /* (X | Y) & Y is (X, Y). */
11474 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11475 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11476 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11477 /* (X | Y) & X is (Y, X). */
11478 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11479 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11480 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11481 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11482 /* X & (X | Y) is (Y, X). */
11483 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11484 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11485 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11486 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11487 /* X & (Y | X) is (Y, X). */
11488 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11489 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11490 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11491 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11493 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11494 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11495 && INTEGRAL_TYPE_P (type
)
11496 && integer_onep (TREE_OPERAND (arg0
, 1))
11497 && integer_onep (arg1
))
11500 tem
= TREE_OPERAND (arg0
, 0);
11501 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11502 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11504 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11505 build_zero_cst (TREE_TYPE (tem
)));
11507 /* Fold ~X & 1 as (X & 1) == 0. */
11508 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11509 && INTEGRAL_TYPE_P (type
)
11510 && integer_onep (arg1
))
11513 tem
= TREE_OPERAND (arg0
, 0);
11514 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11515 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11517 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11518 build_zero_cst (TREE_TYPE (tem
)));
11520 /* Fold !X & 1 as X == 0. */
11521 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11522 && integer_onep (arg1
))
11524 tem
= TREE_OPERAND (arg0
, 0);
11525 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
11526 build_zero_cst (TREE_TYPE (tem
)));
11529 /* Fold (X ^ Y) & Y as ~X & Y. */
11530 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11531 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11533 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11534 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11535 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11536 fold_convert_loc (loc
, type
, arg1
));
11538 /* Fold (X ^ Y) & X as ~Y & X. */
11539 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11540 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11541 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11543 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11544 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11545 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11546 fold_convert_loc (loc
, type
, arg1
));
11548 /* Fold X & (X ^ Y) as X & ~Y. */
11549 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11550 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11552 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11553 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11554 fold_convert_loc (loc
, type
, arg0
),
11555 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11557 /* Fold X & (Y ^ X) as ~Y & X. */
11558 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11559 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11560 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11562 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11563 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11564 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11565 fold_convert_loc (loc
, type
, arg0
));
11568 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11569 multiple of 1 << CST. */
11570 if (TREE_CODE (arg1
) == INTEGER_CST
)
11572 wide_int cst1
= arg1
;
11573 wide_int ncst1
= -cst1
;
11574 if ((cst1
& ncst1
) == ncst1
11575 && multiple_of_p (type
, arg0
,
11576 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
11577 return fold_convert_loc (loc
, type
, arg0
);
11580 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
11582 if (TREE_CODE (arg1
) == INTEGER_CST
11583 && TREE_CODE (arg0
) == MULT_EXPR
11584 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11586 wide_int warg1
= arg1
;
11587 wide_int masked
= mask_with_tz (type
, warg1
, TREE_OPERAND (arg0
, 1));
11590 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
11592 else if (masked
!= warg1
)
11594 /* Avoid the transform if arg1 is a mask of some
11595 mode which allows further optimizations. */
11596 int pop
= wi::popcount (warg1
);
11597 if (!(pop
>= BITS_PER_UNIT
11598 && exact_log2 (pop
) != -1
11599 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
11600 return fold_build2_loc (loc
, code
, type
, op0
,
11601 wide_int_to_tree (type
, masked
));
11605 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11606 ((A & N) + B) & M -> (A + B) & M
11607 Similarly if (N & M) == 0,
11608 ((A | N) + B) & M -> (A + B) & M
11609 and for - instead of + (or unary - instead of +)
11610 and/or ^ instead of |.
11611 If B is constant and (B & M) == 0, fold into A & M. */
11612 if (TREE_CODE (arg1
) == INTEGER_CST
)
11614 wide_int cst1
= arg1
;
11615 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
11616 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
11617 && (TREE_CODE (arg0
) == PLUS_EXPR
11618 || TREE_CODE (arg0
) == MINUS_EXPR
11619 || TREE_CODE (arg0
) == NEGATE_EXPR
)
11620 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
11621 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
11627 /* Now we know that arg0 is (C + D) or (C - D) or
11628 -C and arg1 (M) is == (1LL << cst) - 1.
11629 Store C into PMOP[0] and D into PMOP[1]. */
11630 pmop
[0] = TREE_OPERAND (arg0
, 0);
11632 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
11634 pmop
[1] = TREE_OPERAND (arg0
, 1);
11638 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
11641 for (; which
>= 0; which
--)
11642 switch (TREE_CODE (pmop
[which
]))
11647 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
11650 cst0
= TREE_OPERAND (pmop
[which
], 1);
11652 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
11657 else if (cst0
!= 0)
11659 /* If C or D is of the form (A & N) where
11660 (N & M) == M, or of the form (A | N) or
11661 (A ^ N) where (N & M) == 0, replace it with A. */
11662 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
11665 /* If C or D is a N where (N & M) == 0, it can be
11666 omitted (assumed 0). */
11667 if ((TREE_CODE (arg0
) == PLUS_EXPR
11668 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
11669 && (cst1
& pmop
[which
]) == 0)
11670 pmop
[which
] = NULL
;
11676 /* Only build anything new if we optimized one or both arguments
11678 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
11679 || (TREE_CODE (arg0
) != NEGATE_EXPR
11680 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
11682 tree utype
= TREE_TYPE (arg0
);
11683 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
11685 /* Perform the operations in a type that has defined
11686 overflow behavior. */
11687 utype
= unsigned_type_for (TREE_TYPE (arg0
));
11688 if (pmop
[0] != NULL
)
11689 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
11690 if (pmop
[1] != NULL
)
11691 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
11694 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
11695 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
11696 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
11698 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
11699 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
11701 else if (pmop
[0] != NULL
)
11703 else if (pmop
[1] != NULL
)
11706 return build_int_cst (type
, 0);
11708 else if (pmop
[0] == NULL
)
11709 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
11711 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
11713 /* TEM is now the new binary +, - or unary - replacement. */
11714 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
11715 fold_convert_loc (loc
, utype
, arg1
));
11716 return fold_convert_loc (loc
, type
, tem
);
11721 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11722 if (t1
!= NULL_TREE
)
11724 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11725 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
11726 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
11728 prec
= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
11730 wide_int mask
= wide_int::from (arg1
, prec
, UNSIGNED
);
11733 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11736 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11738 This results in more efficient code for machines without a NOR
11739 instruction. Combine will canonicalize to the first form
11740 which will allow use of NOR instructions provided by the
11741 backend if they exist. */
11742 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11743 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11745 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11746 build2 (BIT_IOR_EXPR
, type
,
11747 fold_convert_loc (loc
, type
,
11748 TREE_OPERAND (arg0
, 0)),
11749 fold_convert_loc (loc
, type
,
11750 TREE_OPERAND (arg1
, 0))));
11753 /* If arg0 is derived from the address of an object or function, we may
11754 be able to fold this expression using the object or function's
11756 if (POINTER_TYPE_P (TREE_TYPE (arg0
)) && tree_fits_uhwi_p (arg1
))
11758 unsigned HOST_WIDE_INT modulus
, residue
;
11759 unsigned HOST_WIDE_INT low
= tree_to_uhwi (arg1
);
11761 modulus
= get_pointer_modulus_and_residue (arg0
, &residue
,
11762 integer_onep (arg1
));
11764 /* This works because modulus is a power of 2. If this weren't the
11765 case, we'd have to replace it by its greatest power-of-2
11766 divisor: modulus & -modulus. */
11768 return build_int_cst (type
, residue
& low
);
11771 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11772 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11773 if the new mask might be further optimized. */
11774 if ((TREE_CODE (arg0
) == LSHIFT_EXPR
11775 || TREE_CODE (arg0
) == RSHIFT_EXPR
)
11776 && TYPE_PRECISION (TREE_TYPE (arg0
)) <= HOST_BITS_PER_WIDE_INT
11777 && TREE_CODE (arg1
) == INTEGER_CST
11778 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
11779 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) > 0
11780 && (tree_to_uhwi (TREE_OPERAND (arg0
, 1))
11781 < TYPE_PRECISION (TREE_TYPE (arg0
))))
11783 unsigned int shiftc
= tree_to_uhwi (TREE_OPERAND (arg0
, 1));
11784 unsigned HOST_WIDE_INT mask
= TREE_INT_CST_LOW (arg1
);
11785 unsigned HOST_WIDE_INT newmask
, zerobits
= 0;
11786 tree shift_type
= TREE_TYPE (arg0
);
11788 if (TREE_CODE (arg0
) == LSHIFT_EXPR
)
11789 zerobits
= ((((unsigned HOST_WIDE_INT
) 1) << shiftc
) - 1);
11790 else if (TREE_CODE (arg0
) == RSHIFT_EXPR
11791 && TYPE_PRECISION (TREE_TYPE (arg0
))
11792 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg0
))))
11794 prec
= TYPE_PRECISION (TREE_TYPE (arg0
));
11795 tree arg00
= TREE_OPERAND (arg0
, 0);
11796 /* See if more bits can be proven as zero because of
11798 if (TREE_CODE (arg00
) == NOP_EXPR
11799 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00
, 0))))
11801 tree inner_type
= TREE_TYPE (TREE_OPERAND (arg00
, 0));
11802 if (TYPE_PRECISION (inner_type
)
11803 == GET_MODE_PRECISION (TYPE_MODE (inner_type
))
11804 && TYPE_PRECISION (inner_type
) < prec
)
11806 prec
= TYPE_PRECISION (inner_type
);
11807 /* See if we can shorten the right shift. */
11809 shift_type
= inner_type
;
11810 /* Otherwise X >> C1 is all zeros, so we'll optimize
11811 it into (X, 0) later on by making sure zerobits
11815 zerobits
= ~(unsigned HOST_WIDE_INT
) 0;
11818 zerobits
>>= HOST_BITS_PER_WIDE_INT
- shiftc
;
11819 zerobits
<<= prec
- shiftc
;
11821 /* For arithmetic shift if sign bit could be set, zerobits
11822 can contain actually sign bits, so no transformation is
11823 possible, unless MASK masks them all away. In that
11824 case the shift needs to be converted into logical shift. */
11825 if (!TYPE_UNSIGNED (TREE_TYPE (arg0
))
11826 && prec
== TYPE_PRECISION (TREE_TYPE (arg0
)))
11828 if ((mask
& zerobits
) == 0)
11829 shift_type
= unsigned_type_for (TREE_TYPE (arg0
));
11835 /* ((X << 16) & 0xff00) is (X, 0). */
11836 if ((mask
& zerobits
) == mask
)
11837 return omit_one_operand_loc (loc
, type
,
11838 build_int_cst (type
, 0), arg0
);
11840 newmask
= mask
| zerobits
;
11841 if (newmask
!= mask
&& (newmask
& (newmask
+ 1)) == 0)
11843 /* Only do the transformation if NEWMASK is some integer
11845 for (prec
= BITS_PER_UNIT
;
11846 prec
< HOST_BITS_PER_WIDE_INT
; prec
<<= 1)
11847 if (newmask
== (((unsigned HOST_WIDE_INT
) 1) << prec
) - 1)
11849 if (prec
< HOST_BITS_PER_WIDE_INT
11850 || newmask
== ~(unsigned HOST_WIDE_INT
) 0)
11854 if (shift_type
!= TREE_TYPE (arg0
))
11856 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), shift_type
,
11857 fold_convert_loc (loc
, shift_type
,
11858 TREE_OPERAND (arg0
, 0)),
11859 TREE_OPERAND (arg0
, 1));
11860 tem
= fold_convert_loc (loc
, type
, tem
);
11864 newmaskt
= build_int_cst_type (TREE_TYPE (op1
), newmask
);
11865 if (!tree_int_cst_equal (newmaskt
, arg1
))
11866 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tem
, newmaskt
);
11874 /* Don't touch a floating-point divide by zero unless the mode
11875 of the constant can represent infinity. */
11876 if (TREE_CODE (arg1
) == REAL_CST
11877 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
11878 && real_zerop (arg1
))
11881 /* Optimize A / A to 1.0 if we don't care about
11882 NaNs or Infinities. Skip the transformation
11883 for non-real operands. */
11884 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11885 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
11886 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0
)))
11887 && operand_equal_p (arg0
, arg1
, 0))
11889 tree r
= build_real (TREE_TYPE (arg0
), dconst1
);
11891 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
11894 /* The complex version of the above A / A optimization. */
11895 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11896 && operand_equal_p (arg0
, arg1
, 0))
11898 tree elem_type
= TREE_TYPE (TREE_TYPE (arg0
));
11899 if (! HONOR_NANS (TYPE_MODE (elem_type
))
11900 && ! HONOR_INFINITIES (TYPE_MODE (elem_type
)))
11902 tree r
= build_real (elem_type
, dconst1
);
11903 /* omit_two_operands will call fold_convert for us. */
11904 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
11908 /* (-A) / (-B) -> A / B */
11909 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
11910 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11911 TREE_OPERAND (arg0
, 0),
11912 negate_expr (arg1
));
11913 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
11914 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11915 negate_expr (arg0
),
11916 TREE_OPERAND (arg1
, 0));
11918 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
11919 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11920 && real_onep (arg1
))
11921 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11923 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
11924 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11925 && real_minus_onep (arg1
))
11926 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
,
11927 negate_expr (arg0
)));
11929 /* If ARG1 is a constant, we can convert this to a multiply by the
11930 reciprocal. This does not have the same rounding properties,
11931 so only do this if -freciprocal-math. We can actually
11932 always safely do it if ARG1 is a power of two, but it's hard to
11933 tell if it is or not in a portable manner. */
11935 && (TREE_CODE (arg1
) == REAL_CST
11936 || (TREE_CODE (arg1
) == COMPLEX_CST
11937 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg1
)))
11938 || (TREE_CODE (arg1
) == VECTOR_CST
11939 && VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg1
)))))
11941 if (flag_reciprocal_math
11942 && 0 != (tem
= const_binop (code
, build_one_cst (type
), arg1
)))
11943 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tem
);
11944 /* Find the reciprocal if optimizing and the result is exact.
11945 TODO: Complex reciprocal not implemented. */
11946 if (TREE_CODE (arg1
) != COMPLEX_CST
)
11948 tree inverse
= exact_inverse (TREE_TYPE (arg0
), arg1
);
11951 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, inverse
);
11954 /* Convert A/B/C to A/(B*C). */
11955 if (flag_reciprocal_math
11956 && TREE_CODE (arg0
) == RDIV_EXPR
)
11957 return fold_build2_loc (loc
, RDIV_EXPR
, type
, TREE_OPERAND (arg0
, 0),
11958 fold_build2_loc (loc
, MULT_EXPR
, type
,
11959 TREE_OPERAND (arg0
, 1), arg1
));
11961 /* Convert A/(B/C) to (A/B)*C. */
11962 if (flag_reciprocal_math
11963 && TREE_CODE (arg1
) == RDIV_EXPR
)
11964 return fold_build2_loc (loc
, MULT_EXPR
, type
,
11965 fold_build2_loc (loc
, RDIV_EXPR
, type
, arg0
,
11966 TREE_OPERAND (arg1
, 0)),
11967 TREE_OPERAND (arg1
, 1));
11969 /* Convert C1/(X*C2) into (C1/C2)/X. */
11970 if (flag_reciprocal_math
11971 && TREE_CODE (arg1
) == MULT_EXPR
11972 && TREE_CODE (arg0
) == REAL_CST
11973 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
11975 tree tem
= const_binop (RDIV_EXPR
, arg0
,
11976 TREE_OPERAND (arg1
, 1));
11978 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
11979 TREE_OPERAND (arg1
, 0));
11982 if (flag_unsafe_math_optimizations
)
11984 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
11985 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
11987 /* Optimize sin(x)/cos(x) as tan(x). */
11988 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_COS
)
11989 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_COSF
)
11990 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_COSL
))
11991 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11992 CALL_EXPR_ARG (arg1
, 0), 0))
11994 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
11996 if (tanfn
!= NULL_TREE
)
11997 return build_call_expr_loc (loc
, tanfn
, 1, CALL_EXPR_ARG (arg0
, 0));
12000 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
12001 if (((fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_SIN
)
12002 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_SINF
)
12003 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_SINL
))
12004 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
12005 CALL_EXPR_ARG (arg1
, 0), 0))
12007 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
12009 if (tanfn
!= NULL_TREE
)
12011 tree tmp
= build_call_expr_loc (loc
, tanfn
, 1,
12012 CALL_EXPR_ARG (arg0
, 0));
12013 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12014 build_real (type
, dconst1
), tmp
);
12018 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
12019 NaNs or Infinities. */
12020 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_TAN
)
12021 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_TANF
)
12022 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_TANL
)))
12024 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12025 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
12027 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
12028 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
12029 && operand_equal_p (arg00
, arg01
, 0))
12031 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
12033 if (cosfn
!= NULL_TREE
)
12034 return build_call_expr_loc (loc
, cosfn
, 1, arg00
);
12038 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
12039 NaNs or Infinities. */
12040 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_SIN
)
12041 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_SINF
)
12042 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_SINL
)))
12044 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12045 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
12047 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
12048 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
12049 && operand_equal_p (arg00
, arg01
, 0))
12051 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
12053 if (cosfn
!= NULL_TREE
)
12055 tree tmp
= build_call_expr_loc (loc
, cosfn
, 1, arg00
);
12056 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12057 build_real (type
, dconst1
),
12063 /* Optimize pow(x,c)/x as pow(x,c-1). */
12064 if (fcode0
== BUILT_IN_POW
12065 || fcode0
== BUILT_IN_POWF
12066 || fcode0
== BUILT_IN_POWL
)
12068 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12069 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
12070 if (TREE_CODE (arg01
) == REAL_CST
12071 && !TREE_OVERFLOW (arg01
)
12072 && operand_equal_p (arg1
, arg00
, 0))
12074 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
12078 c
= TREE_REAL_CST (arg01
);
12079 real_arithmetic (&c
, MINUS_EXPR
, &c
, &dconst1
);
12080 arg
= build_real (type
, c
);
12081 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
12085 /* Optimize a/root(b/c) into a*root(c/b). */
12086 if (BUILTIN_ROOT_P (fcode1
))
12088 tree rootarg
= CALL_EXPR_ARG (arg1
, 0);
12090 if (TREE_CODE (rootarg
) == RDIV_EXPR
)
12092 tree rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12093 tree b
= TREE_OPERAND (rootarg
, 0);
12094 tree c
= TREE_OPERAND (rootarg
, 1);
12096 tree tmp
= fold_build2_loc (loc
, RDIV_EXPR
, type
, c
, b
);
12098 tmp
= build_call_expr_loc (loc
, rootfn
, 1, tmp
);
12099 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tmp
);
12103 /* Optimize x/expN(y) into x*expN(-y). */
12104 if (BUILTIN_EXPONENT_P (fcode1
))
12106 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12107 tree arg
= negate_expr (CALL_EXPR_ARG (arg1
, 0));
12108 arg1
= build_call_expr_loc (loc
,
12110 fold_convert_loc (loc
, type
, arg
));
12111 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12114 /* Optimize x/pow(y,z) into x*pow(y,-z). */
12115 if (fcode1
== BUILT_IN_POW
12116 || fcode1
== BUILT_IN_POWF
12117 || fcode1
== BUILT_IN_POWL
)
12119 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12120 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
12121 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
12122 tree neg11
= fold_convert_loc (loc
, type
,
12123 negate_expr (arg11
));
12124 arg1
= build_call_expr_loc (loc
, powfn
, 2, arg10
, neg11
);
12125 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12130 case TRUNC_DIV_EXPR
:
12131 /* Optimize (X & (-A)) / A where A is a power of 2,
12133 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12134 && !TYPE_UNSIGNED (type
) && TREE_CODE (arg1
) == INTEGER_CST
12135 && integer_pow2p (arg1
) && tree_int_cst_sgn (arg1
) > 0)
12137 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (arg1
),
12138 arg1
, TREE_OPERAND (arg0
, 1));
12139 if (sum
&& integer_zerop (sum
)) {
12140 tree pow2
= build_int_cst (integer_type_node
,
12141 wi::exact_log2 (arg1
));
12142 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12143 TREE_OPERAND (arg0
, 0), pow2
);
12149 case FLOOR_DIV_EXPR
:
12150 /* Simplify A / (B << N) where A and B are positive and B is
12151 a power of 2, to A >> (N + log2(B)). */
12152 strict_overflow_p
= false;
12153 if (TREE_CODE (arg1
) == LSHIFT_EXPR
12154 && (TYPE_UNSIGNED (type
)
12155 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12157 tree sval
= TREE_OPERAND (arg1
, 0);
12158 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
12160 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
12161 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
12162 wi::exact_log2 (sval
));
12164 if (strict_overflow_p
)
12165 fold_overflow_warning (("assuming signed overflow does not "
12166 "occur when simplifying A / (B << N)"),
12167 WARN_STRICT_OVERFLOW_MISC
);
12169 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
12171 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12172 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
12176 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
12177 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
12178 if (INTEGRAL_TYPE_P (type
)
12179 && TYPE_UNSIGNED (type
)
12180 && code
== FLOOR_DIV_EXPR
)
12181 return fold_build2_loc (loc
, TRUNC_DIV_EXPR
, type
, op0
, op1
);
12185 case ROUND_DIV_EXPR
:
12186 case CEIL_DIV_EXPR
:
12187 case EXACT_DIV_EXPR
:
12188 if (integer_onep (arg1
))
12189 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12190 if (integer_zerop (arg1
))
12192 /* X / -1 is -X. */
12193 if (!TYPE_UNSIGNED (type
)
12194 && TREE_CODE (arg1
) == INTEGER_CST
12195 && wi::eq_p (arg1
, -1))
12196 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
12198 /* Convert -A / -B to A / B when the type is signed and overflow is
12200 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12201 && TREE_CODE (arg0
) == NEGATE_EXPR
12202 && negate_expr_p (arg1
))
12204 if (INTEGRAL_TYPE_P (type
))
12205 fold_overflow_warning (("assuming signed overflow does not occur "
12206 "when distributing negation across "
12208 WARN_STRICT_OVERFLOW_MISC
);
12209 return fold_build2_loc (loc
, code
, type
,
12210 fold_convert_loc (loc
, type
,
12211 TREE_OPERAND (arg0
, 0)),
12212 fold_convert_loc (loc
, type
,
12213 negate_expr (arg1
)));
12215 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12216 && TREE_CODE (arg1
) == NEGATE_EXPR
12217 && negate_expr_p (arg0
))
12219 if (INTEGRAL_TYPE_P (type
))
12220 fold_overflow_warning (("assuming signed overflow does not occur "
12221 "when distributing negation across "
12223 WARN_STRICT_OVERFLOW_MISC
);
12224 return fold_build2_loc (loc
, code
, type
,
12225 fold_convert_loc (loc
, type
,
12226 negate_expr (arg0
)),
12227 fold_convert_loc (loc
, type
,
12228 TREE_OPERAND (arg1
, 0)));
12231 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12232 operation, EXACT_DIV_EXPR.
12234 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12235 At one time others generated faster code, it's not clear if they do
12236 after the last round to changes to the DIV code in expmed.c. */
12237 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
12238 && multiple_of_p (type
, arg0
, arg1
))
12239 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
, arg0
, arg1
);
12241 strict_overflow_p
= false;
12242 if (TREE_CODE (arg1
) == INTEGER_CST
12243 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12244 &strict_overflow_p
)))
12246 if (strict_overflow_p
)
12247 fold_overflow_warning (("assuming signed overflow does not occur "
12248 "when simplifying division"),
12249 WARN_STRICT_OVERFLOW_MISC
);
12250 return fold_convert_loc (loc
, type
, tem
);
12255 case CEIL_MOD_EXPR
:
12256 case FLOOR_MOD_EXPR
:
12257 case ROUND_MOD_EXPR
:
12258 case TRUNC_MOD_EXPR
:
12259 /* X % 1 is always zero, but be sure to preserve any side
12261 if (integer_onep (arg1
))
12262 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12264 /* X % 0, return X % 0 unchanged so that we can get the
12265 proper warnings and errors. */
12266 if (integer_zerop (arg1
))
12269 /* 0 % X is always zero, but be sure to preserve any side
12270 effects in X. Place this after checking for X == 0. */
12271 if (integer_zerop (arg0
))
12272 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12274 /* X % -1 is zero. */
12275 if (!TYPE_UNSIGNED (type
)
12276 && TREE_CODE (arg1
) == INTEGER_CST
12277 && wi::eq_p (arg1
, -1))
12278 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12280 /* X % -C is the same as X % C. */
12281 if (code
== TRUNC_MOD_EXPR
12282 && TYPE_SIGN (type
) == SIGNED
12283 && TREE_CODE (arg1
) == INTEGER_CST
12284 && !TREE_OVERFLOW (arg1
)
12285 && wi::neg_p (arg1
)
12286 && !TYPE_OVERFLOW_TRAPS (type
)
12287 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
12288 && !sign_bit_p (arg1
, arg1
))
12289 return fold_build2_loc (loc
, code
, type
,
12290 fold_convert_loc (loc
, type
, arg0
),
12291 fold_convert_loc (loc
, type
,
12292 negate_expr (arg1
)));
12294 /* X % -Y is the same as X % Y. */
12295 if (code
== TRUNC_MOD_EXPR
12296 && !TYPE_UNSIGNED (type
)
12297 && TREE_CODE (arg1
) == NEGATE_EXPR
12298 && !TYPE_OVERFLOW_TRAPS (type
))
12299 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, arg0
),
12300 fold_convert_loc (loc
, type
,
12301 TREE_OPERAND (arg1
, 0)));
12303 strict_overflow_p
= false;
12304 if (TREE_CODE (arg1
) == INTEGER_CST
12305 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12306 &strict_overflow_p
)))
12308 if (strict_overflow_p
)
12309 fold_overflow_warning (("assuming signed overflow does not occur "
12310 "when simplifying modulus"),
12311 WARN_STRICT_OVERFLOW_MISC
);
12312 return fold_convert_loc (loc
, type
, tem
);
12315 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12316 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
12317 if ((code
== TRUNC_MOD_EXPR
|| code
== FLOOR_MOD_EXPR
)
12318 && (TYPE_UNSIGNED (type
)
12319 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12322 /* Also optimize A % (C << N) where C is a power of 2,
12323 to A & ((C << N) - 1). */
12324 if (TREE_CODE (arg1
) == LSHIFT_EXPR
)
12325 c
= TREE_OPERAND (arg1
, 0);
12327 if (integer_pow2p (c
) && tree_int_cst_sgn (c
) > 0)
12330 = fold_build2_loc (loc
, MINUS_EXPR
, TREE_TYPE (arg1
), arg1
,
12331 build_int_cst (TREE_TYPE (arg1
), 1));
12332 if (strict_overflow_p
)
12333 fold_overflow_warning (("assuming signed overflow does not "
12334 "occur when simplifying "
12335 "X % (power of two)"),
12336 WARN_STRICT_OVERFLOW_MISC
);
12337 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
12338 fold_convert_loc (loc
, type
, arg0
),
12339 fold_convert_loc (loc
, type
, mask
));
12347 if (integer_all_onesp (arg0
))
12348 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12352 /* Optimize -1 >> x for arithmetic right shifts. */
12353 if (integer_all_onesp (arg0
) && !TYPE_UNSIGNED (type
)
12354 && tree_expr_nonnegative_p (arg1
))
12355 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12356 /* ... fall through ... */
12360 if (integer_zerop (arg1
))
12361 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12362 if (integer_zerop (arg0
))
12363 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12365 /* Prefer vector1 << scalar to vector1 << vector2
12366 if vector2 is uniform. */
12367 if (VECTOR_TYPE_P (TREE_TYPE (arg1
))
12368 && (tem
= uniform_vector_p (arg1
)) != NULL_TREE
)
12369 return fold_build2_loc (loc
, code
, type
, op0
, tem
);
12371 /* Since negative shift count is not well-defined,
12372 don't try to compute it in the compiler. */
12373 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
12376 prec
= element_precision (type
);
12378 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
12379 if (TREE_CODE (op0
) == code
&& tree_fits_uhwi_p (arg1
)
12380 && tree_to_uhwi (arg1
) < prec
12381 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
12382 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) < prec
)
12384 unsigned int low
= (tree_to_uhwi (TREE_OPERAND (arg0
, 1))
12385 + tree_to_uhwi (arg1
));
12387 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12388 being well defined. */
12391 if (code
== LROTATE_EXPR
|| code
== RROTATE_EXPR
)
12393 else if (TYPE_UNSIGNED (type
) || code
== LSHIFT_EXPR
)
12394 return omit_one_operand_loc (loc
, type
, build_zero_cst (type
),
12395 TREE_OPERAND (arg0
, 0));
12400 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12401 build_int_cst (TREE_TYPE (arg1
), low
));
12404 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12405 into x & ((unsigned)-1 >> c) for unsigned types. */
12406 if (((code
== LSHIFT_EXPR
&& TREE_CODE (arg0
) == RSHIFT_EXPR
)
12407 || (TYPE_UNSIGNED (type
)
12408 && code
== RSHIFT_EXPR
&& TREE_CODE (arg0
) == LSHIFT_EXPR
))
12409 && tree_fits_uhwi_p (arg1
)
12410 && tree_to_uhwi (arg1
) < prec
12411 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
12412 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) < prec
)
12414 HOST_WIDE_INT low0
= tree_to_uhwi (TREE_OPERAND (arg0
, 1));
12415 HOST_WIDE_INT low1
= tree_to_uhwi (arg1
);
12421 arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12423 lshift
= build_minus_one_cst (type
);
12424 lshift
= const_binop (code
, lshift
, arg1
);
12426 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, arg00
, lshift
);
12430 /* Rewrite an LROTATE_EXPR by a constant into an
12431 RROTATE_EXPR by a new constant. */
12432 if (code
== LROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
)
12434 tree tem
= build_int_cst (TREE_TYPE (arg1
), prec
);
12435 tem
= const_binop (MINUS_EXPR
, tem
, arg1
);
12436 return fold_build2_loc (loc
, RROTATE_EXPR
, type
, op0
, tem
);
12439 /* If we have a rotate of a bit operation with the rotate count and
12440 the second operand of the bit operation both constant,
12441 permute the two operations. */
12442 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12443 && (TREE_CODE (arg0
) == BIT_AND_EXPR
12444 || TREE_CODE (arg0
) == BIT_IOR_EXPR
12445 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12446 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12447 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
12448 fold_build2_loc (loc
, code
, type
,
12449 TREE_OPERAND (arg0
, 0), arg1
),
12450 fold_build2_loc (loc
, code
, type
,
12451 TREE_OPERAND (arg0
, 1), arg1
));
12453 /* Two consecutive rotates adding up to the some integer
12454 multiple of the precision of the type can be ignored. */
12455 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12456 && TREE_CODE (arg0
) == RROTATE_EXPR
12457 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
12458 && wi::umod_trunc (wi::add (arg1
, TREE_OPERAND (arg0
, 1)),
12460 return TREE_OPERAND (arg0
, 0);
12462 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12463 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12464 if the latter can be further optimized. */
12465 if ((code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
12466 && TREE_CODE (arg0
) == BIT_AND_EXPR
12467 && TREE_CODE (arg1
) == INTEGER_CST
12468 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12470 tree mask
= fold_build2_loc (loc
, code
, type
,
12471 fold_convert_loc (loc
, type
,
12472 TREE_OPERAND (arg0
, 1)),
12474 tree shift
= fold_build2_loc (loc
, code
, type
,
12475 fold_convert_loc (loc
, type
,
12476 TREE_OPERAND (arg0
, 0)),
12478 tem
= fold_binary_loc (loc
, BIT_AND_EXPR
, type
, shift
, mask
);
12486 if (operand_equal_p (arg0
, arg1
, 0))
12487 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12488 if (INTEGRAL_TYPE_P (type
)
12489 && operand_equal_p (arg1
, TYPE_MIN_VALUE (type
), OEP_ONLY_CONST
))
12490 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12491 tem
= fold_minmax (loc
, MIN_EXPR
, type
, arg0
, arg1
);
12497 if (operand_equal_p (arg0
, arg1
, 0))
12498 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12499 if (INTEGRAL_TYPE_P (type
)
12500 && TYPE_MAX_VALUE (type
)
12501 && operand_equal_p (arg1
, TYPE_MAX_VALUE (type
), OEP_ONLY_CONST
))
12502 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12503 tem
= fold_minmax (loc
, MAX_EXPR
, type
, arg0
, arg1
);
12508 case TRUTH_ANDIF_EXPR
:
12509 /* Note that the operands of this must be ints
12510 and their values must be 0 or 1.
12511 ("true" is a fixed value perhaps depending on the language.) */
12512 /* If first arg is constant zero, return it. */
12513 if (integer_zerop (arg0
))
12514 return fold_convert_loc (loc
, type
, arg0
);
12515 case TRUTH_AND_EXPR
:
12516 /* If either arg is constant true, drop it. */
12517 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12518 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12519 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
12520 /* Preserve sequence points. */
12521 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12522 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12523 /* If second arg is constant zero, result is zero, but first arg
12524 must be evaluated. */
12525 if (integer_zerop (arg1
))
12526 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12527 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12528 case will be handled here. */
12529 if (integer_zerop (arg0
))
12530 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12532 /* !X && X is always false. */
12533 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12534 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12535 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12536 /* X && !X is always false. */
12537 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12538 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12539 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12541 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12542 means A >= Y && A != MAX, but in this case we know that
12545 if (!TREE_SIDE_EFFECTS (arg0
)
12546 && !TREE_SIDE_EFFECTS (arg1
))
12548 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
12549 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
12550 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
12552 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
12553 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
12554 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
12557 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12563 case TRUTH_ORIF_EXPR
:
12564 /* Note that the operands of this must be ints
12565 and their values must be 0 or true.
12566 ("true" is a fixed value perhaps depending on the language.) */
12567 /* If first arg is constant true, return it. */
12568 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12569 return fold_convert_loc (loc
, type
, arg0
);
12570 case TRUTH_OR_EXPR
:
12571 /* If either arg is constant zero, drop it. */
12572 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
12573 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12574 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
12575 /* Preserve sequence points. */
12576 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12577 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12578 /* If second arg is constant true, result is true, but we must
12579 evaluate first arg. */
12580 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
12581 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12582 /* Likewise for first arg, but note this only occurs here for
12584 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12585 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12587 /* !X || X is always true. */
12588 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12589 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12590 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12591 /* X || !X is always true. */
12592 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12593 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12594 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12596 /* (X && !Y) || (!X && Y) is X ^ Y */
12597 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
12598 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
12600 tree a0
, a1
, l0
, l1
, n0
, n1
;
12602 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
12603 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
12605 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12606 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
12608 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
12609 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
12611 if ((operand_equal_p (n0
, a0
, 0)
12612 && operand_equal_p (n1
, a1
, 0))
12613 || (operand_equal_p (n0
, a1
, 0)
12614 && operand_equal_p (n1
, a0
, 0)))
12615 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
12618 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12624 case TRUTH_XOR_EXPR
:
12625 /* If the second arg is constant zero, drop it. */
12626 if (integer_zerop (arg1
))
12627 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12628 /* If the second arg is constant true, this is a logical inversion. */
12629 if (integer_onep (arg1
))
12631 tem
= invert_truthvalue_loc (loc
, arg0
);
12632 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
12634 /* Identical arguments cancel to zero. */
12635 if (operand_equal_p (arg0
, arg1
, 0))
12636 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12638 /* !X ^ X is always true. */
12639 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12640 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12641 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12643 /* X ^ !X is always true. */
12644 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12645 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12646 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12655 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
12656 if (tem
!= NULL_TREE
)
12659 /* bool_var != 0 becomes bool_var. */
12660 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12661 && code
== NE_EXPR
)
12662 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12664 /* bool_var == 1 becomes bool_var. */
12665 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12666 && code
== EQ_EXPR
)
12667 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12669 /* bool_var != 1 becomes !bool_var. */
12670 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12671 && code
== NE_EXPR
)
12672 return fold_convert_loc (loc
, type
,
12673 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12674 TREE_TYPE (arg0
), arg0
));
12676 /* bool_var == 0 becomes !bool_var. */
12677 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12678 && code
== EQ_EXPR
)
12679 return fold_convert_loc (loc
, type
,
12680 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12681 TREE_TYPE (arg0
), arg0
));
12683 /* !exp != 0 becomes !exp */
12684 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
12685 && code
== NE_EXPR
)
12686 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12688 /* If this is an equality comparison of the address of two non-weak,
12689 unaliased symbols neither of which are extern (since we do not
12690 have access to attributes for externs), then we know the result. */
12691 if (TREE_CODE (arg0
) == ADDR_EXPR
12692 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0
, 0))
12693 && ! DECL_WEAK (TREE_OPERAND (arg0
, 0))
12694 && ! lookup_attribute ("alias",
12695 DECL_ATTRIBUTES (TREE_OPERAND (arg0
, 0)))
12696 && ! DECL_EXTERNAL (TREE_OPERAND (arg0
, 0))
12697 && TREE_CODE (arg1
) == ADDR_EXPR
12698 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1
, 0))
12699 && ! DECL_WEAK (TREE_OPERAND (arg1
, 0))
12700 && ! lookup_attribute ("alias",
12701 DECL_ATTRIBUTES (TREE_OPERAND (arg1
, 0)))
12702 && ! DECL_EXTERNAL (TREE_OPERAND (arg1
, 0)))
12704 /* We know that we're looking at the address of two
12705 non-weak, unaliased, static _DECL nodes.
12707 It is both wasteful and incorrect to call operand_equal_p
12708 to compare the two ADDR_EXPR nodes. It is wasteful in that
12709 all we need to do is test pointer equality for the arguments
12710 to the two ADDR_EXPR nodes. It is incorrect to use
12711 operand_equal_p as that function is NOT equivalent to a
12712 C equality test. It can in fact return false for two
12713 objects which would test as equal using the C equality
12715 bool equal
= TREE_OPERAND (arg0
, 0) == TREE_OPERAND (arg1
, 0);
12716 return constant_boolean_node (equal
12717 ? code
== EQ_EXPR
: code
!= EQ_EXPR
,
12721 /* Similarly for a NEGATE_EXPR. */
12722 if (TREE_CODE (arg0
) == NEGATE_EXPR
12723 && TREE_CODE (arg1
) == INTEGER_CST
12724 && 0 != (tem
= negate_expr (fold_convert_loc (loc
, TREE_TYPE (arg0
),
12726 && TREE_CODE (tem
) == INTEGER_CST
12727 && !TREE_OVERFLOW (tem
))
12728 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
12730 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12731 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12732 && TREE_CODE (arg1
) == INTEGER_CST
12733 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12734 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12735 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg0
),
12736 fold_convert_loc (loc
,
12739 TREE_OPERAND (arg0
, 1)));
12741 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12742 if ((TREE_CODE (arg0
) == PLUS_EXPR
12743 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
12744 || TREE_CODE (arg0
) == MINUS_EXPR
)
12745 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12748 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
12749 || POINTER_TYPE_P (TREE_TYPE (arg0
))))
12751 tree val
= TREE_OPERAND (arg0
, 1);
12752 return omit_two_operands_loc (loc
, type
,
12753 fold_build2_loc (loc
, code
, type
,
12755 build_int_cst (TREE_TYPE (val
),
12757 TREE_OPERAND (arg0
, 0), arg1
);
12760 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12761 if (TREE_CODE (arg0
) == MINUS_EXPR
12762 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == INTEGER_CST
12763 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12766 && wi::extract_uhwi (TREE_OPERAND (arg0
, 0), 0, 1) == 1)
12768 return omit_two_operands_loc (loc
, type
,
12770 ? boolean_true_node
: boolean_false_node
,
12771 TREE_OPERAND (arg0
, 1), arg1
);
12774 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12775 if (TREE_CODE (arg0
) == ABS_EXPR
12776 && (integer_zerop (arg1
) || real_zerop (arg1
)))
12777 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), arg1
);
12779 /* If this is an EQ or NE comparison with zero and ARG0 is
12780 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12781 two operations, but the latter can be done in one less insn
12782 on machines that have only two-operand insns or on which a
12783 constant cannot be the first operand. */
12784 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12785 && integer_zerop (arg1
))
12787 tree arg00
= TREE_OPERAND (arg0
, 0);
12788 tree arg01
= TREE_OPERAND (arg0
, 1);
12789 if (TREE_CODE (arg00
) == LSHIFT_EXPR
12790 && integer_onep (TREE_OPERAND (arg00
, 0)))
12792 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
12793 arg01
, TREE_OPERAND (arg00
, 1));
12794 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12795 build_int_cst (TREE_TYPE (arg0
), 1));
12796 return fold_build2_loc (loc
, code
, type
,
12797 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12800 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
12801 && integer_onep (TREE_OPERAND (arg01
, 0)))
12803 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
12804 arg00
, TREE_OPERAND (arg01
, 1));
12805 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12806 build_int_cst (TREE_TYPE (arg0
), 1));
12807 return fold_build2_loc (loc
, code
, type
,
12808 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12813 /* If this is an NE or EQ comparison of zero against the result of a
12814 signed MOD operation whose second operand is a power of 2, make
12815 the MOD operation unsigned since it is simpler and equivalent. */
12816 if (integer_zerop (arg1
)
12817 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
12818 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
12819 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
12820 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
12821 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
12822 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
12824 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
12825 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
12826 fold_convert_loc (loc
, newtype
,
12827 TREE_OPERAND (arg0
, 0)),
12828 fold_convert_loc (loc
, newtype
,
12829 TREE_OPERAND (arg0
, 1)));
12831 return fold_build2_loc (loc
, code
, type
, newmod
,
12832 fold_convert_loc (loc
, newtype
, arg1
));
12835 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12836 C1 is a valid shift constant, and C2 is a power of two, i.e.
12838 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12839 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
12840 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
12842 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12843 && integer_zerop (arg1
))
12845 tree itype
= TREE_TYPE (arg0
);
12846 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
12847 prec
= TYPE_PRECISION (itype
);
12849 /* Check for a valid shift count. */
12850 if (wi::ltu_p (arg001
, prec
))
12852 tree arg01
= TREE_OPERAND (arg0
, 1);
12853 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
12854 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
12855 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12856 can be rewritten as (X & (C2 << C1)) != 0. */
12857 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
12859 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
12860 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
12861 return fold_build2_loc (loc
, code
, type
, tem
,
12862 fold_convert_loc (loc
, itype
, arg1
));
12864 /* Otherwise, for signed (arithmetic) shifts,
12865 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12866 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
12867 else if (!TYPE_UNSIGNED (itype
))
12868 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
12869 arg000
, build_int_cst (itype
, 0));
12870 /* Otherwise, of unsigned (logical) shifts,
12871 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12872 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
12874 return omit_one_operand_loc (loc
, type
,
12875 code
== EQ_EXPR
? integer_one_node
12876 : integer_zero_node
,
12881 /* If we have (A & C) == C where C is a power of 2, convert this into
12882 (A & C) != 0. Similarly for NE_EXPR. */
12883 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12884 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12885 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
12886 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
12887 arg0
, fold_convert_loc (loc
, TREE_TYPE (arg0
),
12888 integer_zero_node
));
12890 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12891 bit, then fold the expression into A < 0 or A >= 0. */
12892 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
, type
);
12896 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12897 Similarly for NE_EXPR. */
12898 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12899 && TREE_CODE (arg1
) == INTEGER_CST
12900 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12902 tree notc
= fold_build1_loc (loc
, BIT_NOT_EXPR
,
12903 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
12904 TREE_OPERAND (arg0
, 1));
12906 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12907 fold_convert_loc (loc
, TREE_TYPE (arg0
), arg1
),
12909 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
12910 if (integer_nonzerop (dandnotc
))
12911 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
12914 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12915 Similarly for NE_EXPR. */
12916 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
12917 && TREE_CODE (arg1
) == INTEGER_CST
12918 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12920 tree notd
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
), arg1
);
12922 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12923 TREE_OPERAND (arg0
, 1),
12924 fold_convert_loc (loc
, TREE_TYPE (arg0
), notd
));
12925 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
12926 if (integer_nonzerop (candnotd
))
12927 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
12930 /* If this is a comparison of a field, we may be able to simplify it. */
12931 if ((TREE_CODE (arg0
) == COMPONENT_REF
12932 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
12933 /* Handle the constant case even without -O
12934 to make sure the warnings are given. */
12935 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
12937 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
12942 /* Optimize comparisons of strlen vs zero to a compare of the
12943 first character of the string vs zero. To wit,
12944 strlen(ptr) == 0 => *ptr == 0
12945 strlen(ptr) != 0 => *ptr != 0
12946 Other cases should reduce to one of these two (or a constant)
12947 due to the return value of strlen being unsigned. */
12948 if (TREE_CODE (arg0
) == CALL_EXPR
12949 && integer_zerop (arg1
))
12951 tree fndecl
= get_callee_fndecl (arg0
);
12954 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
12955 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
12956 && call_expr_nargs (arg0
) == 1
12957 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
12959 tree iref
= build_fold_indirect_ref_loc (loc
,
12960 CALL_EXPR_ARG (arg0
, 0));
12961 return fold_build2_loc (loc
, code
, type
, iref
,
12962 build_int_cst (TREE_TYPE (iref
), 0));
12966 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12967 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12968 if (TREE_CODE (arg0
) == RSHIFT_EXPR
12969 && integer_zerop (arg1
)
12970 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12972 tree arg00
= TREE_OPERAND (arg0
, 0);
12973 tree arg01
= TREE_OPERAND (arg0
, 1);
12974 tree itype
= TREE_TYPE (arg00
);
12975 if (wi::eq_p (arg01
, TYPE_PRECISION (itype
) - 1))
12977 if (TYPE_UNSIGNED (itype
))
12979 itype
= signed_type_for (itype
);
12980 arg00
= fold_convert_loc (loc
, itype
, arg00
);
12982 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
12983 type
, arg00
, build_zero_cst (itype
));
12987 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
12988 if (integer_zerop (arg1
)
12989 && TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12990 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12991 TREE_OPERAND (arg0
, 1));
12993 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
12994 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12995 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
12996 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12997 build_zero_cst (TREE_TYPE (arg0
)));
12998 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
12999 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13000 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13001 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
13002 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 1),
13003 build_zero_cst (TREE_TYPE (arg0
)));
13005 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
13006 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13007 && TREE_CODE (arg1
) == INTEGER_CST
13008 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
13009 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
13010 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg1
),
13011 TREE_OPERAND (arg0
, 1), arg1
));
13013 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
13014 (X & C) == 0 when C is a single bit. */
13015 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13016 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
13017 && integer_zerop (arg1
)
13018 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
13020 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
13021 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
13022 TREE_OPERAND (arg0
, 1));
13023 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
13025 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13029 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
13030 constant C is a power of two, i.e. a single bit. */
13031 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13032 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
13033 && integer_zerop (arg1
)
13034 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13035 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
13036 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
13038 tree arg00
= TREE_OPERAND (arg0
, 0);
13039 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13040 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
13043 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
13044 when is C is a power of two, i.e. a single bit. */
13045 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13046 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
13047 && integer_zerop (arg1
)
13048 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13049 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
13050 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
13052 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
13053 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
13054 arg000
, TREE_OPERAND (arg0
, 1));
13055 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13056 tem
, build_int_cst (TREE_TYPE (tem
), 0));
13059 if (integer_zerop (arg1
)
13060 && tree_expr_nonzero_p (arg0
))
13062 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
13063 return omit_one_operand_loc (loc
, type
, res
, arg0
);
13066 /* Fold -X op -Y as X op Y, where op is eq/ne. */
13067 if (TREE_CODE (arg0
) == NEGATE_EXPR
13068 && TREE_CODE (arg1
) == NEGATE_EXPR
)
13069 return fold_build2_loc (loc
, code
, type
,
13070 TREE_OPERAND (arg0
, 0),
13071 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13072 TREE_OPERAND (arg1
, 0)));
13074 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
13075 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13076 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
13078 tree arg00
= TREE_OPERAND (arg0
, 0);
13079 tree arg01
= TREE_OPERAND (arg0
, 1);
13080 tree arg10
= TREE_OPERAND (arg1
, 0);
13081 tree arg11
= TREE_OPERAND (arg1
, 1);
13082 tree itype
= TREE_TYPE (arg0
);
13084 if (operand_equal_p (arg01
, arg11
, 0))
13085 return fold_build2_loc (loc
, code
, type
,
13086 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13087 fold_build2_loc (loc
,
13088 BIT_XOR_EXPR
, itype
,
13091 build_zero_cst (itype
));
13093 if (operand_equal_p (arg01
, arg10
, 0))
13094 return fold_build2_loc (loc
, code
, type
,
13095 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13096 fold_build2_loc (loc
,
13097 BIT_XOR_EXPR
, itype
,
13100 build_zero_cst (itype
));
13102 if (operand_equal_p (arg00
, arg11
, 0))
13103 return fold_build2_loc (loc
, code
, type
,
13104 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13105 fold_build2_loc (loc
,
13106 BIT_XOR_EXPR
, itype
,
13109 build_zero_cst (itype
));
13111 if (operand_equal_p (arg00
, arg10
, 0))
13112 return fold_build2_loc (loc
, code
, type
,
13113 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13114 fold_build2_loc (loc
,
13115 BIT_XOR_EXPR
, itype
,
13118 build_zero_cst (itype
));
13121 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13122 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
13124 tree arg00
= TREE_OPERAND (arg0
, 0);
13125 tree arg01
= TREE_OPERAND (arg0
, 1);
13126 tree arg10
= TREE_OPERAND (arg1
, 0);
13127 tree arg11
= TREE_OPERAND (arg1
, 1);
13128 tree itype
= TREE_TYPE (arg0
);
13130 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
13131 operand_equal_p guarantees no side-effects so we don't need
13132 to use omit_one_operand on Z. */
13133 if (operand_equal_p (arg01
, arg11
, 0))
13134 return fold_build2_loc (loc
, code
, type
, arg00
,
13135 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13137 if (operand_equal_p (arg01
, arg10
, 0))
13138 return fold_build2_loc (loc
, code
, type
, arg00
,
13139 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13141 if (operand_equal_p (arg00
, arg11
, 0))
13142 return fold_build2_loc (loc
, code
, type
, arg01
,
13143 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13145 if (operand_equal_p (arg00
, arg10
, 0))
13146 return fold_build2_loc (loc
, code
, type
, arg01
,
13147 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13150 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
13151 if (TREE_CODE (arg01
) == INTEGER_CST
13152 && TREE_CODE (arg11
) == INTEGER_CST
)
13154 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
13155 fold_convert_loc (loc
, itype
, arg11
));
13156 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
13157 return fold_build2_loc (loc
, code
, type
, tem
,
13158 fold_convert_loc (loc
, itype
, arg10
));
13162 /* Attempt to simplify equality/inequality comparisons of complex
13163 values. Only lower the comparison if the result is known or
13164 can be simplified to a single scalar comparison. */
13165 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
13166 || TREE_CODE (arg0
) == COMPLEX_CST
)
13167 && (TREE_CODE (arg1
) == COMPLEX_EXPR
13168 || TREE_CODE (arg1
) == COMPLEX_CST
))
13170 tree real0
, imag0
, real1
, imag1
;
13173 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
13175 real0
= TREE_OPERAND (arg0
, 0);
13176 imag0
= TREE_OPERAND (arg0
, 1);
13180 real0
= TREE_REALPART (arg0
);
13181 imag0
= TREE_IMAGPART (arg0
);
13184 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
13186 real1
= TREE_OPERAND (arg1
, 0);
13187 imag1
= TREE_OPERAND (arg1
, 1);
13191 real1
= TREE_REALPART (arg1
);
13192 imag1
= TREE_IMAGPART (arg1
);
13195 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
13196 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
13198 if (integer_zerop (rcond
))
13200 if (code
== EQ_EXPR
)
13201 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13203 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
13207 if (code
== NE_EXPR
)
13208 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13210 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
13214 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
13215 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
13217 if (integer_zerop (icond
))
13219 if (code
== EQ_EXPR
)
13220 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13222 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
13226 if (code
== NE_EXPR
)
13227 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13229 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
13240 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
13241 if (tem
!= NULL_TREE
)
13244 /* Transform comparisons of the form X +- C CMP X. */
13245 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
13246 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13247 && ((TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
13248 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
))))
13249 || (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
13250 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))))
13252 tree arg01
= TREE_OPERAND (arg0
, 1);
13253 enum tree_code code0
= TREE_CODE (arg0
);
13256 if (TREE_CODE (arg01
) == REAL_CST
)
13257 is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
13259 is_positive
= tree_int_cst_sgn (arg01
);
13261 /* (X - c) > X becomes false. */
13262 if (code
== GT_EXPR
13263 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13264 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13266 if (TREE_CODE (arg01
) == INTEGER_CST
13267 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13268 fold_overflow_warning (("assuming signed overflow does not "
13269 "occur when assuming that (X - c) > X "
13270 "is always false"),
13271 WARN_STRICT_OVERFLOW_ALL
);
13272 return constant_boolean_node (0, type
);
13275 /* Likewise (X + c) < X becomes false. */
13276 if (code
== LT_EXPR
13277 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13278 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13280 if (TREE_CODE (arg01
) == INTEGER_CST
13281 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13282 fold_overflow_warning (("assuming signed overflow does not "
13283 "occur when assuming that "
13284 "(X + c) < X is always false"),
13285 WARN_STRICT_OVERFLOW_ALL
);
13286 return constant_boolean_node (0, type
);
13289 /* Convert (X - c) <= X to true. */
13290 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13292 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13293 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13295 if (TREE_CODE (arg01
) == INTEGER_CST
13296 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13297 fold_overflow_warning (("assuming signed overflow does not "
13298 "occur when assuming that "
13299 "(X - c) <= X is always true"),
13300 WARN_STRICT_OVERFLOW_ALL
);
13301 return constant_boolean_node (1, type
);
13304 /* Convert (X + c) >= X to true. */
13305 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13307 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13308 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13310 if (TREE_CODE (arg01
) == INTEGER_CST
13311 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13312 fold_overflow_warning (("assuming signed overflow does not "
13313 "occur when assuming that "
13314 "(X + c) >= X is always true"),
13315 WARN_STRICT_OVERFLOW_ALL
);
13316 return constant_boolean_node (1, type
);
13319 if (TREE_CODE (arg01
) == INTEGER_CST
)
13321 /* Convert X + c > X and X - c < X to true for integers. */
13322 if (code
== GT_EXPR
13323 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13324 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13326 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13327 fold_overflow_warning (("assuming signed overflow does "
13328 "not occur when assuming that "
13329 "(X + c) > X is always true"),
13330 WARN_STRICT_OVERFLOW_ALL
);
13331 return constant_boolean_node (1, type
);
13334 if (code
== LT_EXPR
13335 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13336 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13338 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13339 fold_overflow_warning (("assuming signed overflow does "
13340 "not occur when assuming that "
13341 "(X - c) < X is always true"),
13342 WARN_STRICT_OVERFLOW_ALL
);
13343 return constant_boolean_node (1, type
);
13346 /* Convert X + c <= X and X - c >= X to false for integers. */
13347 if (code
== LE_EXPR
13348 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13349 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13351 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13352 fold_overflow_warning (("assuming signed overflow does "
13353 "not occur when assuming that "
13354 "(X + c) <= X is always false"),
13355 WARN_STRICT_OVERFLOW_ALL
);
13356 return constant_boolean_node (0, type
);
13359 if (code
== GE_EXPR
13360 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13361 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13363 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13364 fold_overflow_warning (("assuming signed overflow does "
13365 "not occur when assuming that "
13366 "(X - c) >= X is always false"),
13367 WARN_STRICT_OVERFLOW_ALL
);
13368 return constant_boolean_node (0, type
);
13373 /* Comparisons with the highest or lowest possible integer of
13374 the specified precision will have known values. */
13376 tree arg1_type
= TREE_TYPE (arg1
);
13377 unsigned int prec
= TYPE_PRECISION (arg1_type
);
13379 if (TREE_CODE (arg1
) == INTEGER_CST
13380 && (INTEGRAL_TYPE_P (arg1_type
) || POINTER_TYPE_P (arg1_type
)))
13382 wide_int max
= wi::max_value (arg1_type
);
13383 wide_int signed_max
= wi::max_value (prec
, SIGNED
);
13384 wide_int min
= wi::min_value (arg1_type
);
13386 if (wi::eq_p (arg1
, max
))
13390 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13393 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13396 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13399 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13401 /* The GE_EXPR and LT_EXPR cases above are not normally
13402 reached because of previous transformations. */
13407 else if (wi::eq_p (arg1
, max
- 1))
13411 arg1
= const_binop (PLUS_EXPR
, arg1
,
13412 build_int_cst (TREE_TYPE (arg1
), 1));
13413 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13414 fold_convert_loc (loc
,
13415 TREE_TYPE (arg1
), arg0
),
13418 arg1
= const_binop (PLUS_EXPR
, arg1
,
13419 build_int_cst (TREE_TYPE (arg1
), 1));
13420 return fold_build2_loc (loc
, NE_EXPR
, type
,
13421 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13427 else if (wi::eq_p (arg1
, min
))
13431 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13434 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13437 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13440 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13445 else if (wi::eq_p (arg1
, min
+ 1))
13449 arg1
= const_binop (MINUS_EXPR
, arg1
,
13450 build_int_cst (TREE_TYPE (arg1
), 1));
13451 return fold_build2_loc (loc
, NE_EXPR
, type
,
13452 fold_convert_loc (loc
,
13453 TREE_TYPE (arg1
), arg0
),
13456 arg1
= const_binop (MINUS_EXPR
, arg1
,
13457 build_int_cst (TREE_TYPE (arg1
), 1));
13458 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13459 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13466 else if (wi::eq_p (arg1
, signed_max
)
13467 && TYPE_UNSIGNED (arg1_type
)
13468 /* We will flip the signedness of the comparison operator
13469 associated with the mode of arg1, so the sign bit is
13470 specified by this mode. Check that arg1 is the signed
13471 max associated with this sign bit. */
13472 && prec
== GET_MODE_PRECISION (TYPE_MODE (arg1_type
))
13473 /* signed_type does not work on pointer types. */
13474 && INTEGRAL_TYPE_P (arg1_type
))
13476 /* The following case also applies to X < signed_max+1
13477 and X >= signed_max+1 because previous transformations. */
13478 if (code
== LE_EXPR
|| code
== GT_EXPR
)
13480 tree st
= signed_type_for (arg1_type
);
13481 return fold_build2_loc (loc
,
13482 code
== LE_EXPR
? GE_EXPR
: LT_EXPR
,
13483 type
, fold_convert_loc (loc
, st
, arg0
),
13484 build_int_cst (st
, 0));
13490 /* If we are comparing an ABS_EXPR with a constant, we can
13491 convert all the cases into explicit comparisons, but they may
13492 well not be faster than doing the ABS and one comparison.
13493 But ABS (X) <= C is a range comparison, which becomes a subtraction
13494 and a comparison, and is probably faster. */
13495 if (code
== LE_EXPR
13496 && TREE_CODE (arg1
) == INTEGER_CST
13497 && TREE_CODE (arg0
) == ABS_EXPR
13498 && ! TREE_SIDE_EFFECTS (arg0
)
13499 && (0 != (tem
= negate_expr (arg1
)))
13500 && TREE_CODE (tem
) == INTEGER_CST
13501 && !TREE_OVERFLOW (tem
))
13502 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
13503 build2 (GE_EXPR
, type
,
13504 TREE_OPERAND (arg0
, 0), tem
),
13505 build2 (LE_EXPR
, type
,
13506 TREE_OPERAND (arg0
, 0), arg1
));
13508 /* Convert ABS_EXPR<x> >= 0 to true. */
13509 strict_overflow_p
= false;
13510 if (code
== GE_EXPR
13511 && (integer_zerop (arg1
)
13512 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
13513 && real_zerop (arg1
)))
13514 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13516 if (strict_overflow_p
)
13517 fold_overflow_warning (("assuming signed overflow does not occur "
13518 "when simplifying comparison of "
13519 "absolute value and zero"),
13520 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13521 return omit_one_operand_loc (loc
, type
,
13522 constant_boolean_node (true, type
),
13526 /* Convert ABS_EXPR<x> < 0 to false. */
13527 strict_overflow_p
= false;
13528 if (code
== LT_EXPR
13529 && (integer_zerop (arg1
) || real_zerop (arg1
))
13530 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13532 if (strict_overflow_p
)
13533 fold_overflow_warning (("assuming signed overflow does not occur "
13534 "when simplifying comparison of "
13535 "absolute value and zero"),
13536 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13537 return omit_one_operand_loc (loc
, type
,
13538 constant_boolean_node (false, type
),
13542 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13543 and similarly for >= into !=. */
13544 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13545 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13546 && TREE_CODE (arg1
) == LSHIFT_EXPR
13547 && integer_onep (TREE_OPERAND (arg1
, 0)))
13548 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13549 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13550 TREE_OPERAND (arg1
, 1)),
13551 build_zero_cst (TREE_TYPE (arg0
)));
13553 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
13554 otherwise Y might be >= # of bits in X's type and thus e.g.
13555 (unsigned char) (1 << Y) for Y 15 might be 0.
13556 If the cast is widening, then 1 << Y should have unsigned type,
13557 otherwise if Y is number of bits in the signed shift type minus 1,
13558 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
13559 31 might be 0xffffffff80000000. */
13560 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13561 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13562 && CONVERT_EXPR_P (arg1
)
13563 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
13564 && (TYPE_PRECISION (TREE_TYPE (arg1
))
13565 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
13566 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
13567 || (TYPE_PRECISION (TREE_TYPE (arg1
))
13568 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
13569 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
13571 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13572 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
13573 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13574 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
13575 build_zero_cst (TREE_TYPE (arg0
)));
13580 case UNORDERED_EXPR
:
13588 if (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
13590 t1
= fold_relational_const (code
, type
, arg0
, arg1
);
13591 if (t1
!= NULL_TREE
)
13595 /* If the first operand is NaN, the result is constant. */
13596 if (TREE_CODE (arg0
) == REAL_CST
13597 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0
))
13598 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13600 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13601 ? integer_zero_node
13602 : integer_one_node
;
13603 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
13606 /* If the second operand is NaN, the result is constant. */
13607 if (TREE_CODE (arg1
) == REAL_CST
13608 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
13609 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13611 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13612 ? integer_zero_node
13613 : integer_one_node
;
13614 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
13617 /* Simplify unordered comparison of something with itself. */
13618 if ((code
== UNLE_EXPR
|| code
== UNGE_EXPR
|| code
== UNEQ_EXPR
)
13619 && operand_equal_p (arg0
, arg1
, 0))
13620 return constant_boolean_node (1, type
);
13622 if (code
== LTGT_EXPR
13623 && !flag_trapping_math
13624 && operand_equal_p (arg0
, arg1
, 0))
13625 return constant_boolean_node (0, type
);
13627 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13629 tree targ0
= strip_float_extensions (arg0
);
13630 tree targ1
= strip_float_extensions (arg1
);
13631 tree newtype
= TREE_TYPE (targ0
);
13633 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
13634 newtype
= TREE_TYPE (targ1
);
13636 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
13637 return fold_build2_loc (loc
, code
, type
,
13638 fold_convert_loc (loc
, newtype
, targ0
),
13639 fold_convert_loc (loc
, newtype
, targ1
));
13644 case COMPOUND_EXPR
:
13645 /* When pedantic, a compound expression can be neither an lvalue
13646 nor an integer constant expression. */
13647 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
13649 /* Don't let (0, 0) be null pointer constant. */
13650 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
13651 : fold_convert_loc (loc
, type
, arg1
);
13652 return pedantic_non_lvalue_loc (loc
, tem
);
13655 if ((TREE_CODE (arg0
) == REAL_CST
13656 && TREE_CODE (arg1
) == REAL_CST
)
13657 || (TREE_CODE (arg0
) == INTEGER_CST
13658 && TREE_CODE (arg1
) == INTEGER_CST
))
13659 return build_complex (type
, arg0
, arg1
);
13660 if (TREE_CODE (arg0
) == REALPART_EXPR
13661 && TREE_CODE (arg1
) == IMAGPART_EXPR
13662 && TREE_TYPE (TREE_OPERAND (arg0
, 0)) == type
13663 && operand_equal_p (TREE_OPERAND (arg0
, 0),
13664 TREE_OPERAND (arg1
, 0), 0))
13665 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 0),
13666 TREE_OPERAND (arg1
, 0));
13670 /* An ASSERT_EXPR should never be passed to fold_binary. */
13671 gcc_unreachable ();
13673 case VEC_PACK_TRUNC_EXPR
:
13674 case VEC_PACK_FIX_TRUNC_EXPR
:
13676 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
13679 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
/ 2
13680 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
/ 2);
13681 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13684 elts
= XALLOCAVEC (tree
, nelts
);
13685 if (!vec_cst_ctor_to_array (arg0
, elts
)
13686 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
/ 2))
13689 for (i
= 0; i
< nelts
; i
++)
13691 elts
[i
] = fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
13692 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
13693 TREE_TYPE (type
), elts
[i
]);
13694 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
13698 return build_vector (type
, elts
);
13701 case VEC_WIDEN_MULT_LO_EXPR
:
13702 case VEC_WIDEN_MULT_HI_EXPR
:
13703 case VEC_WIDEN_MULT_EVEN_EXPR
:
13704 case VEC_WIDEN_MULT_ODD_EXPR
:
13706 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
13707 unsigned int out
, ofs
, scale
;
13710 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2
13711 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
* 2);
13712 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13715 elts
= XALLOCAVEC (tree
, nelts
* 4);
13716 if (!vec_cst_ctor_to_array (arg0
, elts
)
13717 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
* 2))
13720 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
13721 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? nelts
: 0;
13722 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
13723 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : nelts
;
13724 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
13725 scale
= 1, ofs
= 0;
13726 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
13727 scale
= 1, ofs
= 1;
13729 for (out
= 0; out
< nelts
; out
++)
13731 unsigned int in1
= (out
<< scale
) + ofs
;
13732 unsigned int in2
= in1
+ nelts
* 2;
13735 t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in1
]);
13736 t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in2
]);
13738 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
13740 elts
[out
] = const_binop (MULT_EXPR
, t1
, t2
);
13741 if (elts
[out
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[out
]))
13745 return build_vector (type
, elts
);
13750 } /* switch (code) */
13753 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
13754 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
13758 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
13760 switch (TREE_CODE (*tp
))
13766 *walk_subtrees
= 0;
13768 /* ... fall through ... */
13775 /* Return whether the sub-tree ST contains a label which is accessible from
13776 outside the sub-tree. */
13779 contains_label_p (tree st
)
13782 (walk_tree_without_duplicates (&st
, contains_label_1
, NULL
) != NULL_TREE
);
13785 /* Fold a ternary expression of code CODE and type TYPE with operands
13786 OP0, OP1, and OP2. Return the folded expression if folding is
13787 successful. Otherwise, return NULL_TREE. */
13790 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
13791 tree op0
, tree op1
, tree op2
)
13794 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
13795 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
13797 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
13798 && TREE_CODE_LENGTH (code
) == 3);
13800 /* If this is a commutative operation, and OP0 is a constant, move it
13801 to OP1 to reduce the number of tests below. */
13802 if (commutative_ternary_tree_code (code
)
13803 && tree_swap_operands_p (op0
, op1
, true))
13804 return fold_build3_loc (loc
, code
, type
, op1
, op0
, op2
);
13806 /* Strip any conversions that don't change the mode. This is safe
13807 for every expression, except for a comparison expression because
13808 its signedness is derived from its operands. So, in the latter
13809 case, only strip conversions that don't change the signedness.
13811 Note that this is done as an internal manipulation within the
13812 constant folder, in order to find the simplest representation of
13813 the arguments so that their form can be studied. In any cases,
13814 the appropriate type conversions should be put back in the tree
13815 that will get out of the constant folder. */
13836 case COMPONENT_REF
:
13837 if (TREE_CODE (arg0
) == CONSTRUCTOR
13838 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
13840 unsigned HOST_WIDE_INT idx
;
13842 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
13849 case VEC_COND_EXPR
:
13850 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13851 so all simple results must be passed through pedantic_non_lvalue. */
13852 if (TREE_CODE (arg0
) == INTEGER_CST
)
13854 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
13855 tem
= integer_zerop (arg0
) ? op2
: op1
;
13856 /* Only optimize constant conditions when the selected branch
13857 has the same type as the COND_EXPR. This avoids optimizing
13858 away "c ? x : throw", where the throw has a void type.
13859 Avoid throwing away that operand which contains label. */
13860 if ((!TREE_SIDE_EFFECTS (unused_op
)
13861 || !contains_label_p (unused_op
))
13862 && (! VOID_TYPE_P (TREE_TYPE (tem
))
13863 || VOID_TYPE_P (type
)))
13864 return pedantic_non_lvalue_loc (loc
, tem
);
13867 else if (TREE_CODE (arg0
) == VECTOR_CST
)
13869 if (integer_all_onesp (arg0
))
13870 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg2
);
13871 if (integer_zerop (arg0
))
13872 return pedantic_omit_one_operand_loc (loc
, type
, arg2
, arg1
);
13874 if ((TREE_CODE (arg1
) == VECTOR_CST
13875 || TREE_CODE (arg1
) == CONSTRUCTOR
)
13876 && (TREE_CODE (arg2
) == VECTOR_CST
13877 || TREE_CODE (arg2
) == CONSTRUCTOR
))
13879 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
13880 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
13881 gcc_assert (nelts
== VECTOR_CST_NELTS (arg0
));
13882 for (i
= 0; i
< nelts
; i
++)
13884 tree val
= VECTOR_CST_ELT (arg0
, i
);
13885 if (integer_all_onesp (val
))
13887 else if (integer_zerop (val
))
13888 sel
[i
] = nelts
+ i
;
13889 else /* Currently unreachable. */
13892 tree t
= fold_vec_perm (type
, arg1
, arg2
, sel
);
13893 if (t
!= NULL_TREE
)
13898 if (operand_equal_p (arg1
, op2
, 0))
13899 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg0
);
13901 /* If we have A op B ? A : C, we may be able to convert this to a
13902 simpler expression, depending on the operation and the values
13903 of B and C. Signed zeros prevent all of these transformations,
13904 for reasons given above each one.
13906 Also try swapping the arguments and inverting the conditional. */
13907 if (COMPARISON_CLASS_P (arg0
)
13908 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
13909 arg1
, TREE_OPERAND (arg0
, 1))
13910 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1
))))
13912 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
13917 if (COMPARISON_CLASS_P (arg0
)
13918 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
13920 TREE_OPERAND (arg0
, 1))
13921 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2
))))
13923 location_t loc0
= expr_location_or (arg0
, loc
);
13924 tem
= fold_invert_truthvalue (loc0
, arg0
);
13925 if (tem
&& COMPARISON_CLASS_P (tem
))
13927 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
13933 /* If the second operand is simpler than the third, swap them
13934 since that produces better jump optimization results. */
13935 if (truth_value_p (TREE_CODE (arg0
))
13936 && tree_swap_operands_p (op1
, op2
, false))
13938 location_t loc0
= expr_location_or (arg0
, loc
);
13939 /* See if this can be inverted. If it can't, possibly because
13940 it was a floating-point inequality comparison, don't do
13942 tem
= fold_invert_truthvalue (loc0
, arg0
);
13944 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
13947 /* Convert A ? 1 : 0 to simply A. */
13948 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
13949 : (integer_onep (op1
)
13950 && !VECTOR_TYPE_P (type
)))
13951 && integer_zerop (op2
)
13952 /* If we try to convert OP0 to our type, the
13953 call to fold will try to move the conversion inside
13954 a COND, which will recurse. In that case, the COND_EXPR
13955 is probably the best choice, so leave it alone. */
13956 && type
== TREE_TYPE (arg0
))
13957 return pedantic_non_lvalue_loc (loc
, arg0
);
13959 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13960 over COND_EXPR in cases such as floating point comparisons. */
13961 if (integer_zerop (op1
)
13962 && (code
== VEC_COND_EXPR
? integer_all_onesp (op2
)
13963 : (integer_onep (op2
)
13964 && !VECTOR_TYPE_P (type
)))
13965 && truth_value_p (TREE_CODE (arg0
)))
13966 return pedantic_non_lvalue_loc (loc
,
13967 fold_convert_loc (loc
, type
,
13968 invert_truthvalue_loc (loc
,
13971 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13972 if (TREE_CODE (arg0
) == LT_EXPR
13973 && integer_zerop (TREE_OPERAND (arg0
, 1))
13974 && integer_zerop (op2
)
13975 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
13977 /* sign_bit_p looks through both zero and sign extensions,
13978 but for this optimization only sign extensions are
13980 tree tem2
= TREE_OPERAND (arg0
, 0);
13981 while (tem
!= tem2
)
13983 if (TREE_CODE (tem2
) != NOP_EXPR
13984 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
13989 tem2
= TREE_OPERAND (tem2
, 0);
13991 /* sign_bit_p only checks ARG1 bits within A's precision.
13992 If <sign bit of A> has wider type than A, bits outside
13993 of A's precision in <sign bit of A> need to be checked.
13994 If they are all 0, this optimization needs to be done
13995 in unsigned A's type, if they are all 1 in signed A's type,
13996 otherwise this can't be done. */
13998 && TYPE_PRECISION (TREE_TYPE (tem
))
13999 < TYPE_PRECISION (TREE_TYPE (arg1
))
14000 && TYPE_PRECISION (TREE_TYPE (tem
))
14001 < TYPE_PRECISION (type
))
14003 int inner_width
, outer_width
;
14006 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
14007 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
14008 if (outer_width
> TYPE_PRECISION (type
))
14009 outer_width
= TYPE_PRECISION (type
);
14011 wide_int mask
= wi::shifted_mask
14012 (inner_width
, outer_width
- inner_width
, false,
14013 TYPE_PRECISION (TREE_TYPE (arg1
)));
14015 wide_int common
= mask
& arg1
;
14016 if (common
== mask
)
14018 tem_type
= signed_type_for (TREE_TYPE (tem
));
14019 tem
= fold_convert_loc (loc
, tem_type
, tem
);
14021 else if (common
== 0)
14023 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
14024 tem
= fold_convert_loc (loc
, tem_type
, tem
);
14032 fold_convert_loc (loc
, type
,
14033 fold_build2_loc (loc
, BIT_AND_EXPR
,
14034 TREE_TYPE (tem
), tem
,
14035 fold_convert_loc (loc
,
14040 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
14041 already handled above. */
14042 if (TREE_CODE (arg0
) == BIT_AND_EXPR
14043 && integer_onep (TREE_OPERAND (arg0
, 1))
14044 && integer_zerop (op2
)
14045 && integer_pow2p (arg1
))
14047 tree tem
= TREE_OPERAND (arg0
, 0);
14049 if (TREE_CODE (tem
) == RSHIFT_EXPR
14050 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
14051 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
) ==
14052 tree_to_uhwi (TREE_OPERAND (tem
, 1)))
14053 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
14054 TREE_OPERAND (tem
, 0), arg1
);
14057 /* A & N ? N : 0 is simply A & N if N is a power of two. This
14058 is probably obsolete because the first operand should be a
14059 truth value (that's why we have the two cases above), but let's
14060 leave it in until we can confirm this for all front-ends. */
14061 if (integer_zerop (op2
)
14062 && TREE_CODE (arg0
) == NE_EXPR
14063 && integer_zerop (TREE_OPERAND (arg0
, 1))
14064 && integer_pow2p (arg1
)
14065 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
14066 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
14067 arg1
, OEP_ONLY_CONST
))
14068 return pedantic_non_lvalue_loc (loc
,
14069 fold_convert_loc (loc
, type
,
14070 TREE_OPERAND (arg0
, 0)));
14072 /* Disable the transformations below for vectors, since
14073 fold_binary_op_with_conditional_arg may undo them immediately,
14074 yielding an infinite loop. */
14075 if (code
== VEC_COND_EXPR
)
14078 /* Convert A ? B : 0 into A && B if A and B are truth values. */
14079 if (integer_zerop (op2
)
14080 && truth_value_p (TREE_CODE (arg0
))
14081 && truth_value_p (TREE_CODE (arg1
))
14082 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14083 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
14084 : TRUTH_ANDIF_EXPR
,
14085 type
, fold_convert_loc (loc
, type
, arg0
), arg1
);
14087 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
14088 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
14089 && truth_value_p (TREE_CODE (arg0
))
14090 && truth_value_p (TREE_CODE (arg1
))
14091 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14093 location_t loc0
= expr_location_or (arg0
, loc
);
14094 /* Only perform transformation if ARG0 is easily inverted. */
14095 tem
= fold_invert_truthvalue (loc0
, arg0
);
14097 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14100 type
, fold_convert_loc (loc
, type
, tem
),
14104 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
14105 if (integer_zerop (arg1
)
14106 && truth_value_p (TREE_CODE (arg0
))
14107 && truth_value_p (TREE_CODE (op2
))
14108 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14110 location_t loc0
= expr_location_or (arg0
, loc
);
14111 /* Only perform transformation if ARG0 is easily inverted. */
14112 tem
= fold_invert_truthvalue (loc0
, arg0
);
14114 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14115 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
14116 type
, fold_convert_loc (loc
, type
, tem
),
14120 /* Convert A ? 1 : B into A || B if A and B are truth values. */
14121 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
14122 && truth_value_p (TREE_CODE (arg0
))
14123 && truth_value_p (TREE_CODE (op2
))
14124 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14125 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14126 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
14127 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
14132 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
14133 of fold_ternary on them. */
14134 gcc_unreachable ();
14136 case BIT_FIELD_REF
:
14137 if ((TREE_CODE (arg0
) == VECTOR_CST
14138 || (TREE_CODE (arg0
) == CONSTRUCTOR
14139 && TREE_CODE (TREE_TYPE (arg0
)) == VECTOR_TYPE
))
14140 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
14141 || (TREE_CODE (type
) == VECTOR_TYPE
14142 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
)))))
14144 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
14145 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
14146 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
14147 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
14150 && (idx
% width
) == 0
14151 && (n
% width
) == 0
14152 && ((idx
+ n
) / width
) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)))
14157 if (TREE_CODE (arg0
) == VECTOR_CST
)
14160 return VECTOR_CST_ELT (arg0
, idx
);
14162 tree
*vals
= XALLOCAVEC (tree
, n
);
14163 for (unsigned i
= 0; i
< n
; ++i
)
14164 vals
[i
] = VECTOR_CST_ELT (arg0
, idx
+ i
);
14165 return build_vector (type
, vals
);
14168 /* Constructor elements can be subvectors. */
14169 unsigned HOST_WIDE_INT k
= 1;
14170 if (CONSTRUCTOR_NELTS (arg0
) != 0)
14172 tree cons_elem
= TREE_TYPE (CONSTRUCTOR_ELT (arg0
, 0)->value
);
14173 if (TREE_CODE (cons_elem
) == VECTOR_TYPE
)
14174 k
= TYPE_VECTOR_SUBPARTS (cons_elem
);
14177 /* We keep an exact subset of the constructor elements. */
14178 if ((idx
% k
) == 0 && (n
% k
) == 0)
14180 if (CONSTRUCTOR_NELTS (arg0
) == 0)
14181 return build_constructor (type
, NULL
);
14186 if (idx
< CONSTRUCTOR_NELTS (arg0
))
14187 return CONSTRUCTOR_ELT (arg0
, idx
)->value
;
14188 return build_zero_cst (type
);
14191 vec
<constructor_elt
, va_gc
> *vals
;
14192 vec_alloc (vals
, n
);
14193 for (unsigned i
= 0;
14194 i
< n
&& idx
+ i
< CONSTRUCTOR_NELTS (arg0
);
14196 CONSTRUCTOR_APPEND_ELT (vals
, NULL_TREE
,
14198 (arg0
, idx
+ i
)->value
);
14199 return build_constructor (type
, vals
);
14201 /* The bitfield references a single constructor element. */
14202 else if (idx
+ n
<= (idx
/ k
+ 1) * k
)
14204 if (CONSTRUCTOR_NELTS (arg0
) <= idx
/ k
)
14205 return build_zero_cst (type
);
14207 return CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
;
14209 return fold_build3_loc (loc
, code
, type
,
14210 CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
, op1
,
14211 build_int_cst (TREE_TYPE (op2
), (idx
% k
) * width
));
14216 /* A bit-field-ref that referenced the full argument can be stripped. */
14217 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
14218 && TYPE_PRECISION (TREE_TYPE (arg0
)) == tree_to_uhwi (arg1
)
14219 && integer_zerop (op2
))
14220 return fold_convert_loc (loc
, type
, arg0
);
14222 /* On constants we can use native encode/interpret to constant
14223 fold (nearly) all BIT_FIELD_REFs. */
14224 if (CONSTANT_CLASS_P (arg0
)
14225 && can_native_interpret_type_p (type
)
14226 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)))
14227 /* This limitation should not be necessary, we just need to
14228 round this up to mode size. */
14229 && tree_to_uhwi (op1
) % BITS_PER_UNIT
== 0
14230 /* Need bit-shifting of the buffer to relax the following. */
14231 && tree_to_uhwi (op2
) % BITS_PER_UNIT
== 0)
14233 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
14234 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
14235 unsigned HOST_WIDE_INT clen
;
14236 clen
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)));
14237 /* ??? We cannot tell native_encode_expr to start at
14238 some random byte only. So limit us to a reasonable amount
14242 unsigned char *b
= XALLOCAVEC (unsigned char, clen
);
14243 unsigned HOST_WIDE_INT len
= native_encode_expr (arg0
, b
, clen
);
14245 && len
* BITS_PER_UNIT
>= bitpos
+ bitsize
)
14247 tree v
= native_interpret_expr (type
,
14248 b
+ bitpos
/ BITS_PER_UNIT
,
14249 bitsize
/ BITS_PER_UNIT
);
14259 /* For integers we can decompose the FMA if possible. */
14260 if (TREE_CODE (arg0
) == INTEGER_CST
14261 && TREE_CODE (arg1
) == INTEGER_CST
)
14262 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
14263 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
14264 if (integer_zerop (arg2
))
14265 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
14267 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
14269 case VEC_PERM_EXPR
:
14270 if (TREE_CODE (arg2
) == VECTOR_CST
)
14272 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
, mask
;
14273 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
14274 bool need_mask_canon
= false;
14275 bool all_in_vec0
= true;
14276 bool all_in_vec1
= true;
14277 bool maybe_identity
= true;
14278 bool single_arg
= (op0
== op1
);
14279 bool changed
= false;
14281 mask
= single_arg
? (nelts
- 1) : (2 * nelts
- 1);
14282 gcc_assert (nelts
== VECTOR_CST_NELTS (arg2
));
14283 for (i
= 0; i
< nelts
; i
++)
14285 tree val
= VECTOR_CST_ELT (arg2
, i
);
14286 if (TREE_CODE (val
) != INTEGER_CST
)
14289 /* Make sure that the perm value is in an acceptable
14292 if (wi::gtu_p (t
, mask
))
14294 need_mask_canon
= true;
14295 sel
[i
] = t
.to_uhwi () & mask
;
14298 sel
[i
] = t
.to_uhwi ();
14300 if (sel
[i
] < nelts
)
14301 all_in_vec1
= false;
14303 all_in_vec0
= false;
14305 if ((sel
[i
] & (nelts
-1)) != i
)
14306 maybe_identity
= false;
14309 if (maybe_identity
)
14319 else if (all_in_vec1
)
14322 for (i
= 0; i
< nelts
; i
++)
14324 need_mask_canon
= true;
14327 if ((TREE_CODE (op0
) == VECTOR_CST
14328 || TREE_CODE (op0
) == CONSTRUCTOR
)
14329 && (TREE_CODE (op1
) == VECTOR_CST
14330 || TREE_CODE (op1
) == CONSTRUCTOR
))
14332 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
14333 if (t
!= NULL_TREE
)
14337 if (op0
== op1
&& !single_arg
)
14340 if (need_mask_canon
&& arg2
== op2
)
14342 tree
*tsel
= XALLOCAVEC (tree
, nelts
);
14343 tree eltype
= TREE_TYPE (TREE_TYPE (arg2
));
14344 for (i
= 0; i
< nelts
; i
++)
14345 tsel
[i
] = build_int_cst (eltype
, sel
[i
]);
14346 op2
= build_vector (TREE_TYPE (arg2
), tsel
);
14351 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
14357 } /* switch (code) */
14360 /* Perform constant folding and related simplification of EXPR.
14361 The related simplifications include x*1 => x, x*0 => 0, etc.,
14362 and application of the associative law.
14363 NOP_EXPR conversions may be removed freely (as long as we
14364 are careful not to change the type of the overall expression).
14365 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14366 but we can constant-fold them if they have constant operands. */
14368 #ifdef ENABLE_FOLD_CHECKING
14369 # define fold(x) fold_1 (x)
14370 static tree
fold_1 (tree
);
14376 const tree t
= expr
;
14377 enum tree_code code
= TREE_CODE (t
);
14378 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
14380 location_t loc
= EXPR_LOCATION (expr
);
14382 /* Return right away if a constant. */
14383 if (kind
== tcc_constant
)
14386 /* CALL_EXPR-like objects with variable numbers of operands are
14387 treated specially. */
14388 if (kind
== tcc_vl_exp
)
14390 if (code
== CALL_EXPR
)
14392 tem
= fold_call_expr (loc
, expr
, false);
14393 return tem
? tem
: expr
;
14398 if (IS_EXPR_CODE_CLASS (kind
))
14400 tree type
= TREE_TYPE (t
);
14401 tree op0
, op1
, op2
;
14403 switch (TREE_CODE_LENGTH (code
))
14406 op0
= TREE_OPERAND (t
, 0);
14407 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14408 return tem
? tem
: expr
;
14410 op0
= TREE_OPERAND (t
, 0);
14411 op1
= TREE_OPERAND (t
, 1);
14412 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14413 return tem
? tem
: expr
;
14415 op0
= TREE_OPERAND (t
, 0);
14416 op1
= TREE_OPERAND (t
, 1);
14417 op2
= TREE_OPERAND (t
, 2);
14418 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14419 return tem
? tem
: expr
;
14429 tree op0
= TREE_OPERAND (t
, 0);
14430 tree op1
= TREE_OPERAND (t
, 1);
14432 if (TREE_CODE (op1
) == INTEGER_CST
14433 && TREE_CODE (op0
) == CONSTRUCTOR
14434 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
14436 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (op0
);
14437 unsigned HOST_WIDE_INT end
= vec_safe_length (elts
);
14438 unsigned HOST_WIDE_INT begin
= 0;
14440 /* Find a matching index by means of a binary search. */
14441 while (begin
!= end
)
14443 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
14444 tree index
= (*elts
)[middle
].index
;
14446 if (TREE_CODE (index
) == INTEGER_CST
14447 && tree_int_cst_lt (index
, op1
))
14448 begin
= middle
+ 1;
14449 else if (TREE_CODE (index
) == INTEGER_CST
14450 && tree_int_cst_lt (op1
, index
))
14452 else if (TREE_CODE (index
) == RANGE_EXPR
14453 && tree_int_cst_lt (TREE_OPERAND (index
, 1), op1
))
14454 begin
= middle
+ 1;
14455 else if (TREE_CODE (index
) == RANGE_EXPR
14456 && tree_int_cst_lt (op1
, TREE_OPERAND (index
, 0)))
14459 return (*elts
)[middle
].value
;
14466 /* Return a VECTOR_CST if possible. */
14469 tree type
= TREE_TYPE (t
);
14470 if (TREE_CODE (type
) != VECTOR_TYPE
)
14473 tree
*vec
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
14474 unsigned HOST_WIDE_INT idx
, pos
= 0;
14477 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, value
)
14479 if (!CONSTANT_CLASS_P (value
))
14481 if (TREE_CODE (value
) == VECTOR_CST
)
14483 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (value
); ++i
)
14484 vec
[pos
++] = VECTOR_CST_ELT (value
, i
);
14487 vec
[pos
++] = value
;
14489 for (; pos
< TYPE_VECTOR_SUBPARTS (type
); ++pos
)
14490 vec
[pos
] = build_zero_cst (TREE_TYPE (type
));
14492 return build_vector (type
, vec
);
14496 return fold (DECL_INITIAL (t
));
14500 } /* switch (code) */
14503 #ifdef ENABLE_FOLD_CHECKING
14506 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
14507 hash_table
<pointer_hash
<const tree_node
> > *);
14508 static void fold_check_failed (const_tree
, const_tree
);
14509 void print_fold_checksum (const_tree
);
14511 /* When --enable-checking=fold, compute a digest of expr before
14512 and after actual fold call to see if fold did not accidentally
14513 change original expr. */
14519 struct md5_ctx ctx
;
14520 unsigned char checksum_before
[16], checksum_after
[16];
14521 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14523 md5_init_ctx (&ctx
);
14524 fold_checksum_tree (expr
, &ctx
, &ht
);
14525 md5_finish_ctx (&ctx
, checksum_before
);
14528 ret
= fold_1 (expr
);
14530 md5_init_ctx (&ctx
);
14531 fold_checksum_tree (expr
, &ctx
, &ht
);
14532 md5_finish_ctx (&ctx
, checksum_after
);
14534 if (memcmp (checksum_before
, checksum_after
, 16))
14535 fold_check_failed (expr
, ret
);
14541 print_fold_checksum (const_tree expr
)
14543 struct md5_ctx ctx
;
14544 unsigned char checksum
[16], cnt
;
14545 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14547 md5_init_ctx (&ctx
);
14548 fold_checksum_tree (expr
, &ctx
, &ht
);
14549 md5_finish_ctx (&ctx
, checksum
);
14550 for (cnt
= 0; cnt
< 16; ++cnt
)
14551 fprintf (stderr
, "%02x", checksum
[cnt
]);
14552 putc ('\n', stderr
);
14556 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
14558 internal_error ("fold check: original tree changed by fold");
14562 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
14563 hash_table
<pointer_hash
<const tree_node
> > *ht
)
14565 const tree_node
**slot
;
14566 enum tree_code code
;
14567 union tree_node buf
;
14573 slot
= ht
->find_slot (expr
, INSERT
);
14577 code
= TREE_CODE (expr
);
14578 if (TREE_CODE_CLASS (code
) == tcc_declaration
14579 && DECL_ASSEMBLER_NAME_SET_P (expr
))
14581 /* Allow DECL_ASSEMBLER_NAME to be modified. */
14582 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14583 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
14584 expr
= (tree
) &buf
;
14586 else if (TREE_CODE_CLASS (code
) == tcc_type
14587 && (TYPE_POINTER_TO (expr
)
14588 || TYPE_REFERENCE_TO (expr
)
14589 || TYPE_CACHED_VALUES_P (expr
)
14590 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
14591 || TYPE_NEXT_VARIANT (expr
)))
14593 /* Allow these fields to be modified. */
14595 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14596 expr
= tmp
= (tree
) &buf
;
14597 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
14598 TYPE_POINTER_TO (tmp
) = NULL
;
14599 TYPE_REFERENCE_TO (tmp
) = NULL
;
14600 TYPE_NEXT_VARIANT (tmp
) = NULL
;
14601 if (TYPE_CACHED_VALUES_P (tmp
))
14603 TYPE_CACHED_VALUES_P (tmp
) = 0;
14604 TYPE_CACHED_VALUES (tmp
) = NULL
;
14607 md5_process_bytes (expr
, tree_size (expr
), ctx
);
14608 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
14609 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
14610 if (TREE_CODE_CLASS (code
) != tcc_type
14611 && TREE_CODE_CLASS (code
) != tcc_declaration
14612 && code
!= TREE_LIST
14613 && code
!= SSA_NAME
14614 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
14615 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
14616 switch (TREE_CODE_CLASS (code
))
14622 md5_process_bytes (TREE_STRING_POINTER (expr
),
14623 TREE_STRING_LENGTH (expr
), ctx
);
14626 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
14627 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
14630 for (i
= 0; i
< (int) VECTOR_CST_NELTS (expr
); ++i
)
14631 fold_checksum_tree (VECTOR_CST_ELT (expr
, i
), ctx
, ht
);
14637 case tcc_exceptional
:
14641 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
14642 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
14643 expr
= TREE_CHAIN (expr
);
14644 goto recursive_label
;
14647 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
14648 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
14654 case tcc_expression
:
14655 case tcc_reference
:
14656 case tcc_comparison
:
14659 case tcc_statement
:
14661 len
= TREE_OPERAND_LENGTH (expr
);
14662 for (i
= 0; i
< len
; ++i
)
14663 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
14665 case tcc_declaration
:
14666 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
14667 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
14668 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
14670 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
14671 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
14672 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
14673 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
14674 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
14677 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
14679 if (TREE_CODE (expr
) == FUNCTION_DECL
)
14681 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
14682 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
14684 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
14688 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
14689 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
14690 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
14691 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
14692 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
14693 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
14694 if (INTEGRAL_TYPE_P (expr
)
14695 || SCALAR_FLOAT_TYPE_P (expr
))
14697 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
14698 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
14700 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
14701 if (TREE_CODE (expr
) == RECORD_TYPE
14702 || TREE_CODE (expr
) == UNION_TYPE
14703 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
14704 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
14705 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
14712 /* Helper function for outputting the checksum of a tree T. When
14713 debugging with gdb, you can "define mynext" to be "next" followed
14714 by "call debug_fold_checksum (op0)", then just trace down till the
14717 DEBUG_FUNCTION
void
14718 debug_fold_checksum (const_tree t
)
14721 unsigned char checksum
[16];
14722 struct md5_ctx ctx
;
14723 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14725 md5_init_ctx (&ctx
);
14726 fold_checksum_tree (t
, &ctx
, &ht
);
14727 md5_finish_ctx (&ctx
, checksum
);
14730 for (i
= 0; i
< 16; i
++)
14731 fprintf (stderr
, "%d ", checksum
[i
]);
14733 fprintf (stderr
, "\n");
14738 /* Fold a unary tree expression with code CODE of type TYPE with an
14739 operand OP0. LOC is the location of the resulting expression.
14740 Return a folded expression if successful. Otherwise, return a tree
14741 expression with code CODE of type TYPE with an operand OP0. */
14744 fold_build1_stat_loc (location_t loc
,
14745 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
14748 #ifdef ENABLE_FOLD_CHECKING
14749 unsigned char checksum_before
[16], checksum_after
[16];
14750 struct md5_ctx ctx
;
14751 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14753 md5_init_ctx (&ctx
);
14754 fold_checksum_tree (op0
, &ctx
, &ht
);
14755 md5_finish_ctx (&ctx
, checksum_before
);
14759 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14761 tem
= build1_stat_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
14763 #ifdef ENABLE_FOLD_CHECKING
14764 md5_init_ctx (&ctx
);
14765 fold_checksum_tree (op0
, &ctx
, &ht
);
14766 md5_finish_ctx (&ctx
, checksum_after
);
14768 if (memcmp (checksum_before
, checksum_after
, 16))
14769 fold_check_failed (op0
, tem
);
14774 /* Fold a binary tree expression with code CODE of type TYPE with
14775 operands OP0 and OP1. LOC is the location of the resulting
14776 expression. Return a folded expression if successful. Otherwise,
14777 return a tree expression with code CODE of type TYPE with operands
14781 fold_build2_stat_loc (location_t loc
,
14782 enum tree_code code
, tree type
, tree op0
, tree op1
14786 #ifdef ENABLE_FOLD_CHECKING
14787 unsigned char checksum_before_op0
[16],
14788 checksum_before_op1
[16],
14789 checksum_after_op0
[16],
14790 checksum_after_op1
[16];
14791 struct md5_ctx ctx
;
14792 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14794 md5_init_ctx (&ctx
);
14795 fold_checksum_tree (op0
, &ctx
, &ht
);
14796 md5_finish_ctx (&ctx
, checksum_before_op0
);
14799 md5_init_ctx (&ctx
);
14800 fold_checksum_tree (op1
, &ctx
, &ht
);
14801 md5_finish_ctx (&ctx
, checksum_before_op1
);
14805 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14807 tem
= build2_stat_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
14809 #ifdef ENABLE_FOLD_CHECKING
14810 md5_init_ctx (&ctx
);
14811 fold_checksum_tree (op0
, &ctx
, &ht
);
14812 md5_finish_ctx (&ctx
, checksum_after_op0
);
14815 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14816 fold_check_failed (op0
, tem
);
14818 md5_init_ctx (&ctx
);
14819 fold_checksum_tree (op1
, &ctx
, &ht
);
14820 md5_finish_ctx (&ctx
, checksum_after_op1
);
14822 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
14823 fold_check_failed (op1
, tem
);
14828 /* Fold a ternary tree expression with code CODE of type TYPE with
14829 operands OP0, OP1, and OP2. Return a folded expression if
14830 successful. Otherwise, return a tree expression with code CODE of
14831 type TYPE with operands OP0, OP1, and OP2. */
14834 fold_build3_stat_loc (location_t loc
, enum tree_code code
, tree type
,
14835 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
14838 #ifdef ENABLE_FOLD_CHECKING
14839 unsigned char checksum_before_op0
[16],
14840 checksum_before_op1
[16],
14841 checksum_before_op2
[16],
14842 checksum_after_op0
[16],
14843 checksum_after_op1
[16],
14844 checksum_after_op2
[16];
14845 struct md5_ctx ctx
;
14846 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14848 md5_init_ctx (&ctx
);
14849 fold_checksum_tree (op0
, &ctx
, &ht
);
14850 md5_finish_ctx (&ctx
, checksum_before_op0
);
14853 md5_init_ctx (&ctx
);
14854 fold_checksum_tree (op1
, &ctx
, &ht
);
14855 md5_finish_ctx (&ctx
, checksum_before_op1
);
14858 md5_init_ctx (&ctx
);
14859 fold_checksum_tree (op2
, &ctx
, &ht
);
14860 md5_finish_ctx (&ctx
, checksum_before_op2
);
14864 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
14865 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14867 tem
= build3_stat_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
14869 #ifdef ENABLE_FOLD_CHECKING
14870 md5_init_ctx (&ctx
);
14871 fold_checksum_tree (op0
, &ctx
, &ht
);
14872 md5_finish_ctx (&ctx
, checksum_after_op0
);
14875 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14876 fold_check_failed (op0
, tem
);
14878 md5_init_ctx (&ctx
);
14879 fold_checksum_tree (op1
, &ctx
, &ht
);
14880 md5_finish_ctx (&ctx
, checksum_after_op1
);
14883 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
14884 fold_check_failed (op1
, tem
);
14886 md5_init_ctx (&ctx
);
14887 fold_checksum_tree (op2
, &ctx
, &ht
);
14888 md5_finish_ctx (&ctx
, checksum_after_op2
);
14890 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
14891 fold_check_failed (op2
, tem
);
14896 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14897 arguments in ARGARRAY, and a null static chain.
14898 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14899 of type TYPE from the given operands as constructed by build_call_array. */
14902 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
14903 int nargs
, tree
*argarray
)
14906 #ifdef ENABLE_FOLD_CHECKING
14907 unsigned char checksum_before_fn
[16],
14908 checksum_before_arglist
[16],
14909 checksum_after_fn
[16],
14910 checksum_after_arglist
[16];
14911 struct md5_ctx ctx
;
14912 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14915 md5_init_ctx (&ctx
);
14916 fold_checksum_tree (fn
, &ctx
, &ht
);
14917 md5_finish_ctx (&ctx
, checksum_before_fn
);
14920 md5_init_ctx (&ctx
);
14921 for (i
= 0; i
< nargs
; i
++)
14922 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
14923 md5_finish_ctx (&ctx
, checksum_before_arglist
);
14927 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
14929 #ifdef ENABLE_FOLD_CHECKING
14930 md5_init_ctx (&ctx
);
14931 fold_checksum_tree (fn
, &ctx
, &ht
);
14932 md5_finish_ctx (&ctx
, checksum_after_fn
);
14935 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
14936 fold_check_failed (fn
, tem
);
14938 md5_init_ctx (&ctx
);
14939 for (i
= 0; i
< nargs
; i
++)
14940 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
14941 md5_finish_ctx (&ctx
, checksum_after_arglist
);
14943 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
14944 fold_check_failed (NULL_TREE
, tem
);
14949 /* Perform constant folding and related simplification of initializer
14950 expression EXPR. These behave identically to "fold_buildN" but ignore
14951 potential run-time traps and exceptions that fold must preserve. */
14953 #define START_FOLD_INIT \
14954 int saved_signaling_nans = flag_signaling_nans;\
14955 int saved_trapping_math = flag_trapping_math;\
14956 int saved_rounding_math = flag_rounding_math;\
14957 int saved_trapv = flag_trapv;\
14958 int saved_folding_initializer = folding_initializer;\
14959 flag_signaling_nans = 0;\
14960 flag_trapping_math = 0;\
14961 flag_rounding_math = 0;\
14963 folding_initializer = 1;
14965 #define END_FOLD_INIT \
14966 flag_signaling_nans = saved_signaling_nans;\
14967 flag_trapping_math = saved_trapping_math;\
14968 flag_rounding_math = saved_rounding_math;\
14969 flag_trapv = saved_trapv;\
14970 folding_initializer = saved_folding_initializer;
14973 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
14974 tree type
, tree op
)
14979 result
= fold_build1_loc (loc
, code
, type
, op
);
14986 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
14987 tree type
, tree op0
, tree op1
)
14992 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
14999 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
15000 int nargs
, tree
*argarray
)
15005 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
15011 #undef START_FOLD_INIT
15012 #undef END_FOLD_INIT
15014 /* Determine if first argument is a multiple of second argument. Return 0 if
15015 it is not, or we cannot easily determined it to be.
15017 An example of the sort of thing we care about (at this point; this routine
15018 could surely be made more general, and expanded to do what the *_DIV_EXPR's
15019 fold cases do now) is discovering that
15021 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15027 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
15029 This code also handles discovering that
15031 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15033 is a multiple of 8 so we don't have to worry about dealing with a
15034 possible remainder.
15036 Note that we *look* inside a SAVE_EXPR only to determine how it was
15037 calculated; it is not safe for fold to do much of anything else with the
15038 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
15039 at run time. For example, the latter example above *cannot* be implemented
15040 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
15041 evaluation time of the original SAVE_EXPR is not necessarily the same at
15042 the time the new expression is evaluated. The only optimization of this
15043 sort that would be valid is changing
15045 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
15049 SAVE_EXPR (I) * SAVE_EXPR (J)
15051 (where the same SAVE_EXPR (J) is used in the original and the
15052 transformed version). */
15055 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
15057 if (operand_equal_p (top
, bottom
, 0))
15060 if (TREE_CODE (type
) != INTEGER_TYPE
)
15063 switch (TREE_CODE (top
))
15066 /* Bitwise and provides a power of two multiple. If the mask is
15067 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
15068 if (!integer_pow2p (bottom
))
15073 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
15074 || multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
15078 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
15079 && multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
15082 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
15086 op1
= TREE_OPERAND (top
, 1);
15087 /* const_binop may not detect overflow correctly,
15088 so check for it explicitly here. */
15089 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
15090 && 0 != (t1
= fold_convert (type
,
15091 const_binop (LSHIFT_EXPR
,
15094 && !TREE_OVERFLOW (t1
))
15095 return multiple_of_p (type
, t1
, bottom
);
15100 /* Can't handle conversions from non-integral or wider integral type. */
15101 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
15102 || (TYPE_PRECISION (type
)
15103 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
15106 /* .. fall through ... */
15109 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
15112 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
15113 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
15116 if (TREE_CODE (bottom
) != INTEGER_CST
15117 || integer_zerop (bottom
)
15118 || (TYPE_UNSIGNED (type
)
15119 && (tree_int_cst_sgn (top
) < 0
15120 || tree_int_cst_sgn (bottom
) < 0)))
15122 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
15130 /* Return true if CODE or TYPE is known to be non-negative. */
15133 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
15135 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
15136 && truth_value_p (code
))
15137 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15138 have a signed:1 type (where the value is -1 and 0). */
15143 /* Return true if (CODE OP0) is known to be non-negative. If the return
15144 value is based on the assumption that signed overflow is undefined,
15145 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15146 *STRICT_OVERFLOW_P. */
15149 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15150 bool *strict_overflow_p
)
15152 if (TYPE_UNSIGNED (type
))
15158 /* We can't return 1 if flag_wrapv is set because
15159 ABS_EXPR<INT_MIN> = INT_MIN. */
15160 if (!INTEGRAL_TYPE_P (type
))
15162 if (TYPE_OVERFLOW_UNDEFINED (type
))
15164 *strict_overflow_p
= true;
15169 case NON_LVALUE_EXPR
:
15171 case FIX_TRUNC_EXPR
:
15172 return tree_expr_nonnegative_warnv_p (op0
,
15173 strict_overflow_p
);
15177 tree inner_type
= TREE_TYPE (op0
);
15178 tree outer_type
= type
;
15180 if (TREE_CODE (outer_type
) == REAL_TYPE
)
15182 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15183 return tree_expr_nonnegative_warnv_p (op0
,
15184 strict_overflow_p
);
15185 if (INTEGRAL_TYPE_P (inner_type
))
15187 if (TYPE_UNSIGNED (inner_type
))
15189 return tree_expr_nonnegative_warnv_p (op0
,
15190 strict_overflow_p
);
15193 else if (INTEGRAL_TYPE_P (outer_type
))
15195 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15196 return tree_expr_nonnegative_warnv_p (op0
,
15197 strict_overflow_p
);
15198 if (INTEGRAL_TYPE_P (inner_type
))
15199 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
15200 && TYPE_UNSIGNED (inner_type
);
15206 return tree_simple_nonnegative_warnv_p (code
, type
);
15209 /* We don't know sign of `t', so be conservative and return false. */
15213 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
15214 value is based on the assumption that signed overflow is undefined,
15215 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15216 *STRICT_OVERFLOW_P. */
15219 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15220 tree op1
, bool *strict_overflow_p
)
15222 if (TYPE_UNSIGNED (type
))
15227 case POINTER_PLUS_EXPR
:
15229 if (FLOAT_TYPE_P (type
))
15230 return (tree_expr_nonnegative_warnv_p (op0
,
15232 && tree_expr_nonnegative_warnv_p (op1
,
15233 strict_overflow_p
));
15235 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
15236 both unsigned and at least 2 bits shorter than the result. */
15237 if (TREE_CODE (type
) == INTEGER_TYPE
15238 && TREE_CODE (op0
) == NOP_EXPR
15239 && TREE_CODE (op1
) == NOP_EXPR
)
15241 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
15242 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
15243 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
15244 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
15246 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
15247 TYPE_PRECISION (inner2
)) + 1;
15248 return prec
< TYPE_PRECISION (type
);
15254 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
15256 /* x * x is always non-negative for floating point x
15257 or without overflow. */
15258 if (operand_equal_p (op0
, op1
, 0)
15259 || (tree_expr_nonnegative_warnv_p (op0
, strict_overflow_p
)
15260 && tree_expr_nonnegative_warnv_p (op1
, strict_overflow_p
)))
15262 if (TYPE_OVERFLOW_UNDEFINED (type
))
15263 *strict_overflow_p
= true;
15268 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
15269 both unsigned and their total bits is shorter than the result. */
15270 if (TREE_CODE (type
) == INTEGER_TYPE
15271 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
15272 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
15274 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
15275 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
15277 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
15278 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
15281 bool unsigned0
= TYPE_UNSIGNED (inner0
);
15282 bool unsigned1
= TYPE_UNSIGNED (inner1
);
15284 if (TREE_CODE (op0
) == INTEGER_CST
)
15285 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
15287 if (TREE_CODE (op1
) == INTEGER_CST
)
15288 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
15290 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
15291 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
15293 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
15294 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
15295 : TYPE_PRECISION (inner0
);
15297 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
15298 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
15299 : TYPE_PRECISION (inner1
);
15301 return precision0
+ precision1
< TYPE_PRECISION (type
);
15308 return (tree_expr_nonnegative_warnv_p (op0
,
15310 || tree_expr_nonnegative_warnv_p (op1
,
15311 strict_overflow_p
));
15317 case TRUNC_DIV_EXPR
:
15318 case CEIL_DIV_EXPR
:
15319 case FLOOR_DIV_EXPR
:
15320 case ROUND_DIV_EXPR
:
15321 return (tree_expr_nonnegative_warnv_p (op0
,
15323 && tree_expr_nonnegative_warnv_p (op1
,
15324 strict_overflow_p
));
15326 case TRUNC_MOD_EXPR
:
15327 case CEIL_MOD_EXPR
:
15328 case FLOOR_MOD_EXPR
:
15329 case ROUND_MOD_EXPR
:
15330 return tree_expr_nonnegative_warnv_p (op0
,
15331 strict_overflow_p
);
15333 return tree_simple_nonnegative_warnv_p (code
, type
);
15336 /* We don't know sign of `t', so be conservative and return false. */
15340 /* Return true if T is known to be non-negative. If the return
15341 value is based on the assumption that signed overflow is undefined,
15342 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15343 *STRICT_OVERFLOW_P. */
15346 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15348 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15351 switch (TREE_CODE (t
))
15354 return tree_int_cst_sgn (t
) >= 0;
15357 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
15360 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
15363 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15365 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 2),
15366 strict_overflow_p
));
15368 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15371 /* We don't know sign of `t', so be conservative and return false. */
15375 /* Return true if T is known to be non-negative. If the return
15376 value is based on the assumption that signed overflow is undefined,
15377 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15378 *STRICT_OVERFLOW_P. */
15381 tree_call_nonnegative_warnv_p (tree type
, tree fndecl
,
15382 tree arg0
, tree arg1
, bool *strict_overflow_p
)
15384 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
15385 switch (DECL_FUNCTION_CODE (fndecl
))
15387 CASE_FLT_FN (BUILT_IN_ACOS
):
15388 CASE_FLT_FN (BUILT_IN_ACOSH
):
15389 CASE_FLT_FN (BUILT_IN_CABS
):
15390 CASE_FLT_FN (BUILT_IN_COSH
):
15391 CASE_FLT_FN (BUILT_IN_ERFC
):
15392 CASE_FLT_FN (BUILT_IN_EXP
):
15393 CASE_FLT_FN (BUILT_IN_EXP10
):
15394 CASE_FLT_FN (BUILT_IN_EXP2
):
15395 CASE_FLT_FN (BUILT_IN_FABS
):
15396 CASE_FLT_FN (BUILT_IN_FDIM
):
15397 CASE_FLT_FN (BUILT_IN_HYPOT
):
15398 CASE_FLT_FN (BUILT_IN_POW10
):
15399 CASE_INT_FN (BUILT_IN_FFS
):
15400 CASE_INT_FN (BUILT_IN_PARITY
):
15401 CASE_INT_FN (BUILT_IN_POPCOUNT
):
15402 CASE_INT_FN (BUILT_IN_CLZ
):
15403 CASE_INT_FN (BUILT_IN_CLRSB
):
15404 case BUILT_IN_BSWAP32
:
15405 case BUILT_IN_BSWAP64
:
15409 CASE_FLT_FN (BUILT_IN_SQRT
):
15410 /* sqrt(-0.0) is -0.0. */
15411 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
15413 return tree_expr_nonnegative_warnv_p (arg0
,
15414 strict_overflow_p
);
15416 CASE_FLT_FN (BUILT_IN_ASINH
):
15417 CASE_FLT_FN (BUILT_IN_ATAN
):
15418 CASE_FLT_FN (BUILT_IN_ATANH
):
15419 CASE_FLT_FN (BUILT_IN_CBRT
):
15420 CASE_FLT_FN (BUILT_IN_CEIL
):
15421 CASE_FLT_FN (BUILT_IN_ERF
):
15422 CASE_FLT_FN (BUILT_IN_EXPM1
):
15423 CASE_FLT_FN (BUILT_IN_FLOOR
):
15424 CASE_FLT_FN (BUILT_IN_FMOD
):
15425 CASE_FLT_FN (BUILT_IN_FREXP
):
15426 CASE_FLT_FN (BUILT_IN_ICEIL
):
15427 CASE_FLT_FN (BUILT_IN_IFLOOR
):
15428 CASE_FLT_FN (BUILT_IN_IRINT
):
15429 CASE_FLT_FN (BUILT_IN_IROUND
):
15430 CASE_FLT_FN (BUILT_IN_LCEIL
):
15431 CASE_FLT_FN (BUILT_IN_LDEXP
):
15432 CASE_FLT_FN (BUILT_IN_LFLOOR
):
15433 CASE_FLT_FN (BUILT_IN_LLCEIL
):
15434 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
15435 CASE_FLT_FN (BUILT_IN_LLRINT
):
15436 CASE_FLT_FN (BUILT_IN_LLROUND
):
15437 CASE_FLT_FN (BUILT_IN_LRINT
):
15438 CASE_FLT_FN (BUILT_IN_LROUND
):
15439 CASE_FLT_FN (BUILT_IN_MODF
):
15440 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
15441 CASE_FLT_FN (BUILT_IN_RINT
):
15442 CASE_FLT_FN (BUILT_IN_ROUND
):
15443 CASE_FLT_FN (BUILT_IN_SCALB
):
15444 CASE_FLT_FN (BUILT_IN_SCALBLN
):
15445 CASE_FLT_FN (BUILT_IN_SCALBN
):
15446 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
15447 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
15448 CASE_FLT_FN (BUILT_IN_SINH
):
15449 CASE_FLT_FN (BUILT_IN_TANH
):
15450 CASE_FLT_FN (BUILT_IN_TRUNC
):
15451 /* True if the 1st argument is nonnegative. */
15452 return tree_expr_nonnegative_warnv_p (arg0
,
15453 strict_overflow_p
);
15455 CASE_FLT_FN (BUILT_IN_FMAX
):
15456 /* True if the 1st OR 2nd arguments are nonnegative. */
15457 return (tree_expr_nonnegative_warnv_p (arg0
,
15459 || (tree_expr_nonnegative_warnv_p (arg1
,
15460 strict_overflow_p
)));
15462 CASE_FLT_FN (BUILT_IN_FMIN
):
15463 /* True if the 1st AND 2nd arguments are nonnegative. */
15464 return (tree_expr_nonnegative_warnv_p (arg0
,
15466 && (tree_expr_nonnegative_warnv_p (arg1
,
15467 strict_overflow_p
)));
15469 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
15470 /* True if the 2nd argument is nonnegative. */
15471 return tree_expr_nonnegative_warnv_p (arg1
,
15472 strict_overflow_p
);
15474 CASE_FLT_FN (BUILT_IN_POWI
):
15475 /* True if the 1st argument is nonnegative or the second
15476 argument is an even integer. */
15477 if (TREE_CODE (arg1
) == INTEGER_CST
15478 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
15480 return tree_expr_nonnegative_warnv_p (arg0
,
15481 strict_overflow_p
);
15483 CASE_FLT_FN (BUILT_IN_POW
):
15484 /* True if the 1st argument is nonnegative or the second
15485 argument is an even integer valued real. */
15486 if (TREE_CODE (arg1
) == REAL_CST
)
15491 c
= TREE_REAL_CST (arg1
);
15492 n
= real_to_integer (&c
);
15495 REAL_VALUE_TYPE cint
;
15496 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
15497 if (real_identical (&c
, &cint
))
15501 return tree_expr_nonnegative_warnv_p (arg0
,
15502 strict_overflow_p
);
15507 return tree_simple_nonnegative_warnv_p (CALL_EXPR
,
15511 /* Return true if T is known to be non-negative. If the return
15512 value is based on the assumption that signed overflow is undefined,
15513 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15514 *STRICT_OVERFLOW_P. */
15517 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15519 enum tree_code code
= TREE_CODE (t
);
15520 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15527 tree temp
= TARGET_EXPR_SLOT (t
);
15528 t
= TARGET_EXPR_INITIAL (t
);
15530 /* If the initializer is non-void, then it's a normal expression
15531 that will be assigned to the slot. */
15532 if (!VOID_TYPE_P (t
))
15533 return tree_expr_nonnegative_warnv_p (t
, strict_overflow_p
);
15535 /* Otherwise, the initializer sets the slot in some way. One common
15536 way is an assignment statement at the end of the initializer. */
15539 if (TREE_CODE (t
) == BIND_EXPR
)
15540 t
= expr_last (BIND_EXPR_BODY (t
));
15541 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
15542 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
15543 t
= expr_last (TREE_OPERAND (t
, 0));
15544 else if (TREE_CODE (t
) == STATEMENT_LIST
)
15549 if (TREE_CODE (t
) == MODIFY_EXPR
15550 && TREE_OPERAND (t
, 0) == temp
)
15551 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15552 strict_overflow_p
);
15559 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
15560 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
15562 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
15563 get_callee_fndecl (t
),
15566 strict_overflow_p
);
15568 case COMPOUND_EXPR
:
15570 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15571 strict_overflow_p
);
15573 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t
, 1)),
15574 strict_overflow_p
);
15576 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 0),
15577 strict_overflow_p
);
15580 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15584 /* We don't know sign of `t', so be conservative and return false. */
15588 /* Return true if T is known to be non-negative. If the return
15589 value is based on the assumption that signed overflow is undefined,
15590 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15591 *STRICT_OVERFLOW_P. */
15594 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15596 enum tree_code code
;
15597 if (t
== error_mark_node
)
15600 code
= TREE_CODE (t
);
15601 switch (TREE_CODE_CLASS (code
))
15604 case tcc_comparison
:
15605 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15607 TREE_OPERAND (t
, 0),
15608 TREE_OPERAND (t
, 1),
15609 strict_overflow_p
);
15612 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15614 TREE_OPERAND (t
, 0),
15615 strict_overflow_p
);
15618 case tcc_declaration
:
15619 case tcc_reference
:
15620 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15628 case TRUTH_AND_EXPR
:
15629 case TRUTH_OR_EXPR
:
15630 case TRUTH_XOR_EXPR
:
15631 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15633 TREE_OPERAND (t
, 0),
15634 TREE_OPERAND (t
, 1),
15635 strict_overflow_p
);
15636 case TRUTH_NOT_EXPR
:
15637 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15639 TREE_OPERAND (t
, 0),
15640 strict_overflow_p
);
15647 case WITH_SIZE_EXPR
:
15649 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15652 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
);
15656 /* Return true if `t' is known to be non-negative. Handle warnings
15657 about undefined signed overflow. */
15660 tree_expr_nonnegative_p (tree t
)
15662 bool ret
, strict_overflow_p
;
15664 strict_overflow_p
= false;
15665 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
15666 if (strict_overflow_p
)
15667 fold_overflow_warning (("assuming signed overflow does not occur when "
15668 "determining that expression is always "
15670 WARN_STRICT_OVERFLOW_MISC
);
15675 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15676 For floating point we further ensure that T is not denormal.
15677 Similar logic is present in nonzero_address in rtlanal.h.
15679 If the return value is based on the assumption that signed overflow
15680 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15681 change *STRICT_OVERFLOW_P. */
15684 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
15685 bool *strict_overflow_p
)
15690 return tree_expr_nonzero_warnv_p (op0
,
15691 strict_overflow_p
);
15695 tree inner_type
= TREE_TYPE (op0
);
15696 tree outer_type
= type
;
15698 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
15699 && tree_expr_nonzero_warnv_p (op0
,
15700 strict_overflow_p
));
15704 case NON_LVALUE_EXPR
:
15705 return tree_expr_nonzero_warnv_p (op0
,
15706 strict_overflow_p
);
15715 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15716 For floating point we further ensure that T is not denormal.
15717 Similar logic is present in nonzero_address in rtlanal.h.
15719 If the return value is based on the assumption that signed overflow
15720 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15721 change *STRICT_OVERFLOW_P. */
15724 tree_binary_nonzero_warnv_p (enum tree_code code
,
15727 tree op1
, bool *strict_overflow_p
)
15729 bool sub_strict_overflow_p
;
15732 case POINTER_PLUS_EXPR
:
15734 if (TYPE_OVERFLOW_UNDEFINED (type
))
15736 /* With the presence of negative values it is hard
15737 to say something. */
15738 sub_strict_overflow_p
= false;
15739 if (!tree_expr_nonnegative_warnv_p (op0
,
15740 &sub_strict_overflow_p
)
15741 || !tree_expr_nonnegative_warnv_p (op1
,
15742 &sub_strict_overflow_p
))
15744 /* One of operands must be positive and the other non-negative. */
15745 /* We don't set *STRICT_OVERFLOW_P here: even if this value
15746 overflows, on a twos-complement machine the sum of two
15747 nonnegative numbers can never be zero. */
15748 return (tree_expr_nonzero_warnv_p (op0
,
15750 || tree_expr_nonzero_warnv_p (op1
,
15751 strict_overflow_p
));
15756 if (TYPE_OVERFLOW_UNDEFINED (type
))
15758 if (tree_expr_nonzero_warnv_p (op0
,
15760 && tree_expr_nonzero_warnv_p (op1
,
15761 strict_overflow_p
))
15763 *strict_overflow_p
= true;
15770 sub_strict_overflow_p
= false;
15771 if (tree_expr_nonzero_warnv_p (op0
,
15772 &sub_strict_overflow_p
)
15773 && tree_expr_nonzero_warnv_p (op1
,
15774 &sub_strict_overflow_p
))
15776 if (sub_strict_overflow_p
)
15777 *strict_overflow_p
= true;
15782 sub_strict_overflow_p
= false;
15783 if (tree_expr_nonzero_warnv_p (op0
,
15784 &sub_strict_overflow_p
))
15786 if (sub_strict_overflow_p
)
15787 *strict_overflow_p
= true;
15789 /* When both operands are nonzero, then MAX must be too. */
15790 if (tree_expr_nonzero_warnv_p (op1
,
15791 strict_overflow_p
))
15794 /* MAX where operand 0 is positive is positive. */
15795 return tree_expr_nonnegative_warnv_p (op0
,
15796 strict_overflow_p
);
15798 /* MAX where operand 1 is positive is positive. */
15799 else if (tree_expr_nonzero_warnv_p (op1
,
15800 &sub_strict_overflow_p
)
15801 && tree_expr_nonnegative_warnv_p (op1
,
15802 &sub_strict_overflow_p
))
15804 if (sub_strict_overflow_p
)
15805 *strict_overflow_p
= true;
15811 return (tree_expr_nonzero_warnv_p (op1
,
15813 || tree_expr_nonzero_warnv_p (op0
,
15814 strict_overflow_p
));
15823 /* Return true when T is an address and is known to be nonzero.
15824 For floating point we further ensure that T is not denormal.
15825 Similar logic is present in nonzero_address in rtlanal.h.
15827 If the return value is based on the assumption that signed overflow
15828 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15829 change *STRICT_OVERFLOW_P. */
15832 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
15834 bool sub_strict_overflow_p
;
15835 switch (TREE_CODE (t
))
15838 return !integer_zerop (t
);
15842 tree base
= TREE_OPERAND (t
, 0);
15844 if (!DECL_P (base
))
15845 base
= get_base_address (base
);
15850 /* For objects in symbol table check if we know they are non-zero.
15851 Don't do anything for variables and functions before symtab is built;
15852 it is quite possible that they will be declared weak later. */
15853 if (DECL_P (base
) && decl_in_symtab_p (base
))
15855 struct symtab_node
*symbol
;
15857 symbol
= symtab_node::get_create (base
);
15859 return symbol
->nonzero_address ();
15864 /* Function local objects are never NULL. */
15866 && (DECL_CONTEXT (base
)
15867 && TREE_CODE (DECL_CONTEXT (base
)) == FUNCTION_DECL
15868 && auto_var_in_fn_p (base
, DECL_CONTEXT (base
))))
15871 /* Constants are never weak. */
15872 if (CONSTANT_CLASS_P (base
))
15879 sub_strict_overflow_p
= false;
15880 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
15881 &sub_strict_overflow_p
)
15882 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
15883 &sub_strict_overflow_p
))
15885 if (sub_strict_overflow_p
)
15886 *strict_overflow_p
= true;
15897 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15898 attempt to fold the expression to a constant without modifying TYPE,
15901 If the expression could be simplified to a constant, then return
15902 the constant. If the expression would not be simplified to a
15903 constant, then return NULL_TREE. */
15906 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
15908 tree tem
= fold_binary (code
, type
, op0
, op1
);
15909 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
15912 /* Given the components of a unary expression CODE, TYPE and OP0,
15913 attempt to fold the expression to a constant without modifying
15916 If the expression could be simplified to a constant, then return
15917 the constant. If the expression would not be simplified to a
15918 constant, then return NULL_TREE. */
15921 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
15923 tree tem
= fold_unary (code
, type
, op0
);
15924 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
15927 /* If EXP represents referencing an element in a constant string
15928 (either via pointer arithmetic or array indexing), return the
15929 tree representing the value accessed, otherwise return NULL. */
15932 fold_read_from_constant_string (tree exp
)
15934 if ((TREE_CODE (exp
) == INDIRECT_REF
15935 || TREE_CODE (exp
) == ARRAY_REF
)
15936 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
15938 tree exp1
= TREE_OPERAND (exp
, 0);
15941 location_t loc
= EXPR_LOCATION (exp
);
15943 if (TREE_CODE (exp
) == INDIRECT_REF
)
15944 string
= string_constant (exp1
, &index
);
15947 tree low_bound
= array_ref_low_bound (exp
);
15948 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
15950 /* Optimize the special-case of a zero lower bound.
15952 We convert the low_bound to sizetype to avoid some problems
15953 with constant folding. (E.g. suppose the lower bound is 1,
15954 and its mode is QI. Without the conversion,l (ARRAY
15955 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15956 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15957 if (! integer_zerop (low_bound
))
15958 index
= size_diffop_loc (loc
, index
,
15959 fold_convert_loc (loc
, sizetype
, low_bound
));
15965 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
15966 && TREE_CODE (string
) == STRING_CST
15967 && TREE_CODE (index
) == INTEGER_CST
15968 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
15969 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))))
15971 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))) == 1))
15972 return build_int_cst_type (TREE_TYPE (exp
),
15973 (TREE_STRING_POINTER (string
)
15974 [TREE_INT_CST_LOW (index
)]));
15979 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15980 an integer constant, real, or fixed-point constant.
15982 TYPE is the type of the result. */
15985 fold_negate_const (tree arg0
, tree type
)
15987 tree t
= NULL_TREE
;
15989 switch (TREE_CODE (arg0
))
15994 wide_int val
= wi::neg (arg0
, &overflow
);
15995 t
= force_fit_type (type
, val
, 1,
15996 (overflow
| TREE_OVERFLOW (arg0
))
15997 && !TYPE_UNSIGNED (type
));
16002 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16007 FIXED_VALUE_TYPE f
;
16008 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
16009 &(TREE_FIXED_CST (arg0
)), NULL
,
16010 TYPE_SATURATING (type
));
16011 t
= build_fixed (type
, f
);
16012 /* Propagate overflow flags. */
16013 if (overflow_p
| TREE_OVERFLOW (arg0
))
16014 TREE_OVERFLOW (t
) = 1;
16019 gcc_unreachable ();
16025 /* Return the tree for abs (ARG0) when ARG0 is known to be either
16026 an integer constant or real constant.
16028 TYPE is the type of the result. */
16031 fold_abs_const (tree arg0
, tree type
)
16033 tree t
= NULL_TREE
;
16035 switch (TREE_CODE (arg0
))
16039 /* If the value is unsigned or non-negative, then the absolute value
16040 is the same as the ordinary value. */
16041 if (!wi::neg_p (arg0
, TYPE_SIGN (type
)))
16044 /* If the value is negative, then the absolute value is
16049 wide_int val
= wi::neg (arg0
, &overflow
);
16050 t
= force_fit_type (type
, val
, -1,
16051 overflow
| TREE_OVERFLOW (arg0
));
16057 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
16058 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16064 gcc_unreachable ();
16070 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
16071 constant. TYPE is the type of the result. */
16074 fold_not_const (const_tree arg0
, tree type
)
16076 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
16078 return force_fit_type (type
, wi::bit_not (arg0
), 0, TREE_OVERFLOW (arg0
));
16081 /* Given CODE, a relational operator, the target type, TYPE and two
16082 constant operands OP0 and OP1, return the result of the
16083 relational operation. If the result is not a compile time
16084 constant, then return NULL_TREE. */
16087 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
16089 int result
, invert
;
16091 /* From here on, the only cases we handle are when the result is
16092 known to be a constant. */
16094 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
16096 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
16097 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
16099 /* Handle the cases where either operand is a NaN. */
16100 if (real_isnan (c0
) || real_isnan (c1
))
16110 case UNORDERED_EXPR
:
16124 if (flag_trapping_math
)
16130 gcc_unreachable ();
16133 return constant_boolean_node (result
, type
);
16136 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
16139 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
16141 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
16142 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
16143 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
16146 /* Handle equality/inequality of complex constants. */
16147 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
16149 tree rcond
= fold_relational_const (code
, type
,
16150 TREE_REALPART (op0
),
16151 TREE_REALPART (op1
));
16152 tree icond
= fold_relational_const (code
, type
,
16153 TREE_IMAGPART (op0
),
16154 TREE_IMAGPART (op1
));
16155 if (code
== EQ_EXPR
)
16156 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
16157 else if (code
== NE_EXPR
)
16158 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
16163 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
16165 unsigned count
= VECTOR_CST_NELTS (op0
);
16166 tree
*elts
= XALLOCAVEC (tree
, count
);
16167 gcc_assert (VECTOR_CST_NELTS (op1
) == count
16168 && TYPE_VECTOR_SUBPARTS (type
) == count
);
16170 for (unsigned i
= 0; i
< count
; i
++)
16172 tree elem_type
= TREE_TYPE (type
);
16173 tree elem0
= VECTOR_CST_ELT (op0
, i
);
16174 tree elem1
= VECTOR_CST_ELT (op1
, i
);
16176 tree tem
= fold_relational_const (code
, elem_type
,
16179 if (tem
== NULL_TREE
)
16182 elts
[i
] = build_int_cst (elem_type
, integer_zerop (tem
) ? 0 : -1);
16185 return build_vector (type
, elts
);
16188 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16190 To compute GT, swap the arguments and do LT.
16191 To compute GE, do LT and invert the result.
16192 To compute LE, swap the arguments, do LT and invert the result.
16193 To compute NE, do EQ and invert the result.
16195 Therefore, the code below must handle only EQ and LT. */
16197 if (code
== LE_EXPR
|| code
== GT_EXPR
)
16202 code
= swap_tree_comparison (code
);
16205 /* Note that it is safe to invert for real values here because we
16206 have already handled the one case that it matters. */
16209 if (code
== NE_EXPR
|| code
== GE_EXPR
)
16212 code
= invert_tree_comparison (code
, false);
16215 /* Compute a result for LT or EQ if args permit;
16216 Otherwise return T. */
16217 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
16219 if (code
== EQ_EXPR
)
16220 result
= tree_int_cst_equal (op0
, op1
);
16222 result
= tree_int_cst_lt (op0
, op1
);
16229 return constant_boolean_node (result
, type
);
16232 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16233 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16237 fold_build_cleanup_point_expr (tree type
, tree expr
)
16239 /* If the expression does not have side effects then we don't have to wrap
16240 it with a cleanup point expression. */
16241 if (!TREE_SIDE_EFFECTS (expr
))
16244 /* If the expression is a return, check to see if the expression inside the
16245 return has no side effects or the right hand side of the modify expression
16246 inside the return. If either don't have side effects set we don't need to
16247 wrap the expression in a cleanup point expression. Note we don't check the
16248 left hand side of the modify because it should always be a return decl. */
16249 if (TREE_CODE (expr
) == RETURN_EXPR
)
16251 tree op
= TREE_OPERAND (expr
, 0);
16252 if (!op
|| !TREE_SIDE_EFFECTS (op
))
16254 op
= TREE_OPERAND (op
, 1);
16255 if (!TREE_SIDE_EFFECTS (op
))
16259 return build1 (CLEANUP_POINT_EXPR
, type
, expr
);
16262 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16263 of an indirection through OP0, or NULL_TREE if no simplification is
16267 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
16273 subtype
= TREE_TYPE (sub
);
16274 if (!POINTER_TYPE_P (subtype
))
16277 if (TREE_CODE (sub
) == ADDR_EXPR
)
16279 tree op
= TREE_OPERAND (sub
, 0);
16280 tree optype
= TREE_TYPE (op
);
16281 /* *&CONST_DECL -> to the value of the const decl. */
16282 if (TREE_CODE (op
) == CONST_DECL
)
16283 return DECL_INITIAL (op
);
16284 /* *&p => p; make sure to handle *&"str"[cst] here. */
16285 if (type
== optype
)
16287 tree fop
= fold_read_from_constant_string (op
);
16293 /* *(foo *)&fooarray => fooarray[0] */
16294 else if (TREE_CODE (optype
) == ARRAY_TYPE
16295 && type
== TREE_TYPE (optype
)
16296 && (!in_gimple_form
16297 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16299 tree type_domain
= TYPE_DOMAIN (optype
);
16300 tree min_val
= size_zero_node
;
16301 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16302 min_val
= TYPE_MIN_VALUE (type_domain
);
16304 && TREE_CODE (min_val
) != INTEGER_CST
)
16306 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
16307 NULL_TREE
, NULL_TREE
);
16309 /* *(foo *)&complexfoo => __real__ complexfoo */
16310 else if (TREE_CODE (optype
) == COMPLEX_TYPE
16311 && type
== TREE_TYPE (optype
))
16312 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
16313 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16314 else if (TREE_CODE (optype
) == VECTOR_TYPE
16315 && type
== TREE_TYPE (optype
))
16317 tree part_width
= TYPE_SIZE (type
);
16318 tree index
= bitsize_int (0);
16319 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
16323 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
16324 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
16326 tree op00
= TREE_OPERAND (sub
, 0);
16327 tree op01
= TREE_OPERAND (sub
, 1);
16330 if (TREE_CODE (op00
) == ADDR_EXPR
)
16333 op00
= TREE_OPERAND (op00
, 0);
16334 op00type
= TREE_TYPE (op00
);
16336 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16337 if (TREE_CODE (op00type
) == VECTOR_TYPE
16338 && type
== TREE_TYPE (op00type
))
16340 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
16341 tree part_width
= TYPE_SIZE (type
);
16342 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
16343 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
16344 tree index
= bitsize_int (indexi
);
16346 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
16347 return fold_build3_loc (loc
,
16348 BIT_FIELD_REF
, type
, op00
,
16349 part_width
, index
);
16352 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16353 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
16354 && type
== TREE_TYPE (op00type
))
16356 tree size
= TYPE_SIZE_UNIT (type
);
16357 if (tree_int_cst_equal (size
, op01
))
16358 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
16360 /* ((foo *)&fooarray)[1] => fooarray[1] */
16361 else if (TREE_CODE (op00type
) == ARRAY_TYPE
16362 && type
== TREE_TYPE (op00type
))
16364 tree type_domain
= TYPE_DOMAIN (op00type
);
16365 tree min_val
= size_zero_node
;
16366 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16367 min_val
= TYPE_MIN_VALUE (type_domain
);
16368 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
16369 TYPE_SIZE_UNIT (type
));
16370 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
16371 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
16372 NULL_TREE
, NULL_TREE
);
16377 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16378 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
16379 && type
== TREE_TYPE (TREE_TYPE (subtype
))
16380 && (!in_gimple_form
16381 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16384 tree min_val
= size_zero_node
;
16385 sub
= build_fold_indirect_ref_loc (loc
, sub
);
16386 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
16387 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16388 min_val
= TYPE_MIN_VALUE (type_domain
);
16390 && TREE_CODE (min_val
) != INTEGER_CST
)
16392 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
16399 /* Builds an expression for an indirection through T, simplifying some
16403 build_fold_indirect_ref_loc (location_t loc
, tree t
)
16405 tree type
= TREE_TYPE (TREE_TYPE (t
));
16406 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
16411 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
16414 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16417 fold_indirect_ref_loc (location_t loc
, tree t
)
16419 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
16427 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16428 whose result is ignored. The type of the returned tree need not be
16429 the same as the original expression. */
16432 fold_ignored_result (tree t
)
16434 if (!TREE_SIDE_EFFECTS (t
))
16435 return integer_zero_node
;
16438 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
16441 t
= TREE_OPERAND (t
, 0);
16445 case tcc_comparison
:
16446 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16447 t
= TREE_OPERAND (t
, 0);
16448 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
16449 t
= TREE_OPERAND (t
, 1);
16454 case tcc_expression
:
16455 switch (TREE_CODE (t
))
16457 case COMPOUND_EXPR
:
16458 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16460 t
= TREE_OPERAND (t
, 0);
16464 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
16465 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
16467 t
= TREE_OPERAND (t
, 0);
16480 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
16483 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
16485 tree div
= NULL_TREE
;
16490 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16491 have to do anything. Only do this when we are not given a const,
16492 because in that case, this check is more expensive than just
16494 if (TREE_CODE (value
) != INTEGER_CST
)
16496 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16498 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16502 /* If divisor is a power of two, simplify this to bit manipulation. */
16503 if (divisor
== (divisor
& -divisor
))
16505 if (TREE_CODE (value
) == INTEGER_CST
)
16507 wide_int val
= value
;
16510 if ((val
& (divisor
- 1)) == 0)
16513 overflow_p
= TREE_OVERFLOW (value
);
16514 val
&= ~(divisor
- 1);
16519 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
16525 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
16526 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
16527 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16528 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16534 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16535 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
16536 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16542 /* Likewise, but round down. */
16545 round_down_loc (location_t loc
, tree value
, int divisor
)
16547 tree div
= NULL_TREE
;
16549 gcc_assert (divisor
> 0);
16553 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16554 have to do anything. Only do this when we are not given a const,
16555 because in that case, this check is more expensive than just
16557 if (TREE_CODE (value
) != INTEGER_CST
)
16559 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16561 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16565 /* If divisor is a power of two, simplify this to bit manipulation. */
16566 if (divisor
== (divisor
& -divisor
))
16570 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16571 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16576 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16577 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
16578 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16584 /* Returns the pointer to the base of the object addressed by EXP and
16585 extracts the information about the offset of the access, storing it
16586 to PBITPOS and POFFSET. */
16589 split_address_to_core_and_offset (tree exp
,
16590 HOST_WIDE_INT
*pbitpos
, tree
*poffset
)
16593 enum machine_mode mode
;
16594 int unsignedp
, volatilep
;
16595 HOST_WIDE_INT bitsize
;
16596 location_t loc
= EXPR_LOCATION (exp
);
16598 if (TREE_CODE (exp
) == ADDR_EXPR
)
16600 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
16601 poffset
, &mode
, &unsignedp
, &volatilep
,
16603 core
= build_fold_addr_expr_loc (loc
, core
);
16609 *poffset
= NULL_TREE
;
16615 /* Returns true if addresses of E1 and E2 differ by a constant, false
16616 otherwise. If they do, E1 - E2 is stored in *DIFF. */
16619 ptr_difference_const (tree e1
, tree e2
, HOST_WIDE_INT
*diff
)
16622 HOST_WIDE_INT bitpos1
, bitpos2
;
16623 tree toffset1
, toffset2
, tdiff
, type
;
16625 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
16626 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
16628 if (bitpos1
% BITS_PER_UNIT
!= 0
16629 || bitpos2
% BITS_PER_UNIT
!= 0
16630 || !operand_equal_p (core1
, core2
, 0))
16633 if (toffset1
&& toffset2
)
16635 type
= TREE_TYPE (toffset1
);
16636 if (type
!= TREE_TYPE (toffset2
))
16637 toffset2
= fold_convert (type
, toffset2
);
16639 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
16640 if (!cst_and_fits_in_hwi (tdiff
))
16643 *diff
= int_cst_value (tdiff
);
16645 else if (toffset1
|| toffset2
)
16647 /* If only one of the offsets is non-constant, the difference cannot
16654 *diff
+= (bitpos1
- bitpos2
) / BITS_PER_UNIT
;
16658 /* Simplify the floating point expression EXP when the sign of the
16659 result is not significant. Return NULL_TREE if no simplification
16663 fold_strip_sign_ops (tree exp
)
16666 location_t loc
= EXPR_LOCATION (exp
);
16668 switch (TREE_CODE (exp
))
16672 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16673 return arg0
? arg0
: TREE_OPERAND (exp
, 0);
16677 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp
))))
16679 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16680 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16681 if (arg0
!= NULL_TREE
|| arg1
!= NULL_TREE
)
16682 return fold_build2_loc (loc
, TREE_CODE (exp
), TREE_TYPE (exp
),
16683 arg0
? arg0
: TREE_OPERAND (exp
, 0),
16684 arg1
? arg1
: TREE_OPERAND (exp
, 1));
16687 case COMPOUND_EXPR
:
16688 arg0
= TREE_OPERAND (exp
, 0);
16689 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16691 return fold_build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (exp
), arg0
, arg1
);
16695 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16696 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 2));
16698 return fold_build3_loc (loc
,
16699 COND_EXPR
, TREE_TYPE (exp
), TREE_OPERAND (exp
, 0),
16700 arg0
? arg0
: TREE_OPERAND (exp
, 1),
16701 arg1
? arg1
: TREE_OPERAND (exp
, 2));
16706 const enum built_in_function fcode
= builtin_mathfn_code (exp
);
16709 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
16710 /* Strip copysign function call, return the 1st argument. */
16711 arg0
= CALL_EXPR_ARG (exp
, 0);
16712 arg1
= CALL_EXPR_ARG (exp
, 1);
16713 return omit_one_operand_loc (loc
, TREE_TYPE (exp
), arg0
, arg1
);
16716 /* Strip sign ops from the argument of "odd" math functions. */
16717 if (negate_mathfn_p (fcode
))
16719 arg0
= fold_strip_sign_ops (CALL_EXPR_ARG (exp
, 0));
16721 return build_call_expr_loc (loc
, get_callee_fndecl (exp
), 1, arg0
);