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
,
10600 fold_convert_loc (loc
, type
, arg0
),
10603 return fold_build2_loc (loc
, MINUS_EXPR
, type
, tmp
, arg11
);
10606 /* A - (-B) -> A + B */
10607 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
10608 return fold_build2_loc (loc
, PLUS_EXPR
, type
, op0
,
10609 fold_convert_loc (loc
, type
,
10610 TREE_OPERAND (arg1
, 0)));
10611 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10612 if (TREE_CODE (arg0
) == NEGATE_EXPR
10613 && negate_expr_p (arg1
)
10614 && reorder_operands_p (arg0
, arg1
))
10615 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10616 fold_convert_loc (loc
, type
,
10617 negate_expr (arg1
)),
10618 fold_convert_loc (loc
, type
,
10619 TREE_OPERAND (arg0
, 0)));
10620 /* Convert -A - 1 to ~A. */
10621 if (TREE_CODE (arg0
) == NEGATE_EXPR
10622 && integer_each_onep (arg1
)
10623 && !TYPE_OVERFLOW_TRAPS (type
))
10624 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
10625 fold_convert_loc (loc
, type
,
10626 TREE_OPERAND (arg0
, 0)));
10628 /* Convert -1 - A to ~A. */
10629 if (TREE_CODE (type
) != COMPLEX_TYPE
10630 && integer_all_onesp (arg0
))
10631 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op1
);
10634 /* X - (X / Y) * Y is X % Y. */
10635 if ((INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
10636 && TREE_CODE (arg1
) == MULT_EXPR
10637 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10638 && operand_equal_p (arg0
,
10639 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0)
10640 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1),
10641 TREE_OPERAND (arg1
, 1), 0))
10643 fold_convert_loc (loc
, type
,
10644 fold_build2_loc (loc
, TRUNC_MOD_EXPR
, TREE_TYPE (arg0
),
10645 arg0
, TREE_OPERAND (arg1
, 1)));
10647 if (! FLOAT_TYPE_P (type
))
10649 if (integer_zerop (arg0
))
10650 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10651 if (integer_zerop (arg1
))
10652 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10654 /* Fold A - (A & B) into ~B & A. */
10655 if (!TREE_SIDE_EFFECTS (arg0
)
10656 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10658 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0))
10660 tree arg10
= fold_convert_loc (loc
, type
,
10661 TREE_OPERAND (arg1
, 0));
10662 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10663 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10665 fold_convert_loc (loc
, type
, arg0
));
10667 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10669 tree arg11
= fold_convert_loc (loc
,
10670 type
, TREE_OPERAND (arg1
, 1));
10671 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10672 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10674 fold_convert_loc (loc
, type
, arg0
));
10678 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10679 any power of 2 minus 1. */
10680 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10681 && TREE_CODE (arg1
) == BIT_AND_EXPR
10682 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10683 TREE_OPERAND (arg1
, 0), 0))
10685 tree mask0
= TREE_OPERAND (arg0
, 1);
10686 tree mask1
= TREE_OPERAND (arg1
, 1);
10687 tree tem
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, mask0
);
10689 if (operand_equal_p (tem
, mask1
, 0))
10691 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
10692 TREE_OPERAND (arg0
, 0), mask1
);
10693 return fold_build2_loc (loc
, MINUS_EXPR
, type
, tem
, mask1
);
10698 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10699 else if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 1))
10700 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10702 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10703 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10704 (-ARG1 + ARG0) reduces to -ARG1. */
10705 else if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10706 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10708 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10709 __complex__ ( x, -y ). This is not the same for SNaNs or if
10710 signed zeros are involved. */
10711 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10712 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10713 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10715 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10716 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10717 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10718 bool arg0rz
= false, arg0iz
= false;
10719 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10720 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10722 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10723 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10724 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10726 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10728 : build1 (REALPART_EXPR
, rtype
, arg1
));
10729 tree ip
= arg0i
? arg0i
10730 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10731 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10733 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10735 tree rp
= arg0r
? arg0r
10736 : build1 (REALPART_EXPR
, rtype
, arg0
);
10737 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10739 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
10740 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10745 /* Fold &x - &x. This can happen from &x.foo - &x.
10746 This is unsafe for certain floats even in non-IEEE formats.
10747 In IEEE, it is unsafe because it does wrong for NaNs.
10748 Also note that operand_equal_p is always false if an operand
10751 if ((!FLOAT_TYPE_P (type
) || !HONOR_NANS (TYPE_MODE (type
)))
10752 && operand_equal_p (arg0
, arg1
, 0))
10753 return omit_one_operand_loc (loc
, type
, build_zero_cst (type
), arg0
);
10755 /* A - B -> A + (-B) if B is easily negatable. */
10756 if (negate_expr_p (arg1
)
10757 && ((FLOAT_TYPE_P (type
)
10758 /* Avoid this transformation if B is a positive REAL_CST. */
10759 && (TREE_CODE (arg1
) != REAL_CST
10760 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
))))
10761 || INTEGRAL_TYPE_P (type
)))
10762 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10763 fold_convert_loc (loc
, type
, arg0
),
10764 fold_convert_loc (loc
, type
,
10765 negate_expr (arg1
)));
10767 /* Try folding difference of addresses. */
10769 HOST_WIDE_INT diff
;
10771 if ((TREE_CODE (arg0
) == ADDR_EXPR
10772 || TREE_CODE (arg1
) == ADDR_EXPR
)
10773 && ptr_difference_const (arg0
, arg1
, &diff
))
10774 return build_int_cst_type (type
, diff
);
10777 /* Fold &a[i] - &a[j] to i-j. */
10778 if (TREE_CODE (arg0
) == ADDR_EXPR
10779 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
10780 && TREE_CODE (arg1
) == ADDR_EXPR
10781 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
10783 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
10784 TREE_OPERAND (arg0
, 0),
10785 TREE_OPERAND (arg1
, 0));
10790 if (FLOAT_TYPE_P (type
)
10791 && flag_unsafe_math_optimizations
10792 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10793 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10794 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10797 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
10798 one. Make sure the type is not saturating and has the signedness of
10799 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10800 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10801 if ((TREE_CODE (arg0
) == MULT_EXPR
10802 || TREE_CODE (arg1
) == MULT_EXPR
)
10803 && !TYPE_SATURATING (type
)
10804 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10805 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10806 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10808 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10816 /* (-A) * (-B) -> A * B */
10817 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10818 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10819 fold_convert_loc (loc
, type
,
10820 TREE_OPERAND (arg0
, 0)),
10821 fold_convert_loc (loc
, type
,
10822 negate_expr (arg1
)));
10823 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10824 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10825 fold_convert_loc (loc
, type
,
10826 negate_expr (arg0
)),
10827 fold_convert_loc (loc
, type
,
10828 TREE_OPERAND (arg1
, 0)));
10830 if (! FLOAT_TYPE_P (type
))
10832 if (integer_zerop (arg1
))
10833 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10834 if (integer_onep (arg1
))
10835 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10836 /* Transform x * -1 into -x. Make sure to do the negation
10837 on the original operand with conversions not stripped
10838 because we can only strip non-sign-changing conversions. */
10839 if (integer_minus_onep (arg1
))
10840 return fold_convert_loc (loc
, type
, negate_expr (op0
));
10841 /* Transform x * -C into -x * C if x is easily negatable. */
10842 if (TREE_CODE (arg1
) == INTEGER_CST
10843 && tree_int_cst_sgn (arg1
) == -1
10844 && negate_expr_p (arg0
)
10845 && (tem
= negate_expr (arg1
)) != arg1
10846 && !TREE_OVERFLOW (tem
))
10847 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10848 fold_convert_loc (loc
, type
,
10849 negate_expr (arg0
)),
10852 /* (a * (1 << b)) is (a << b) */
10853 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10854 && integer_onep (TREE_OPERAND (arg1
, 0)))
10855 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op0
,
10856 TREE_OPERAND (arg1
, 1));
10857 if (TREE_CODE (arg0
) == LSHIFT_EXPR
10858 && integer_onep (TREE_OPERAND (arg0
, 0)))
10859 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op1
,
10860 TREE_OPERAND (arg0
, 1));
10862 /* (A + A) * C -> A * 2 * C */
10863 if (TREE_CODE (arg0
) == PLUS_EXPR
10864 && TREE_CODE (arg1
) == INTEGER_CST
10865 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10866 TREE_OPERAND (arg0
, 1), 0))
10867 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10868 omit_one_operand_loc (loc
, type
,
10869 TREE_OPERAND (arg0
, 0),
10870 TREE_OPERAND (arg0
, 1)),
10871 fold_build2_loc (loc
, MULT_EXPR
, type
,
10872 build_int_cst (type
, 2) , arg1
));
10874 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
10875 sign-changing only. */
10876 if (TREE_CODE (arg1
) == INTEGER_CST
10877 && TREE_CODE (arg0
) == EXACT_DIV_EXPR
10878 && operand_equal_p (arg1
, TREE_OPERAND (arg0
, 1), 0))
10879 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10881 strict_overflow_p
= false;
10882 if (TREE_CODE (arg1
) == INTEGER_CST
10883 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10884 &strict_overflow_p
)))
10886 if (strict_overflow_p
)
10887 fold_overflow_warning (("assuming signed overflow does not "
10888 "occur when simplifying "
10890 WARN_STRICT_OVERFLOW_MISC
);
10891 return fold_convert_loc (loc
, type
, tem
);
10894 /* Optimize z * conj(z) for integer complex numbers. */
10895 if (TREE_CODE (arg0
) == CONJ_EXPR
10896 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10897 return fold_mult_zconjz (loc
, type
, arg1
);
10898 if (TREE_CODE (arg1
) == CONJ_EXPR
10899 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10900 return fold_mult_zconjz (loc
, type
, arg0
);
10904 /* Maybe fold x * 0 to 0. The expressions aren't the same
10905 when x is NaN, since x * 0 is also NaN. Nor are they the
10906 same in modes with signed zeros, since multiplying a
10907 negative value by 0 gives -0, not +0. */
10908 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
10909 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10910 && real_zerop (arg1
))
10911 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10912 /* In IEEE floating point, x*1 is not equivalent to x for snans.
10913 Likewise for complex arithmetic with signed zeros. */
10914 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10915 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10916 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10917 && real_onep (arg1
))
10918 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10920 /* Transform x * -1.0 into -x. */
10921 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10922 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10923 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10924 && real_minus_onep (arg1
))
10925 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
10927 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
10928 the result for floating point types due to rounding so it is applied
10929 only if -fassociative-math was specify. */
10930 if (flag_associative_math
10931 && TREE_CODE (arg0
) == RDIV_EXPR
10932 && TREE_CODE (arg1
) == REAL_CST
10933 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
)
10935 tree tem
= const_binop (MULT_EXPR
, TREE_OPERAND (arg0
, 0),
10938 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
10939 TREE_OPERAND (arg0
, 1));
10942 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
10943 if (operand_equal_p (arg0
, arg1
, 0))
10945 tree tem
= fold_strip_sign_ops (arg0
);
10946 if (tem
!= NULL_TREE
)
10948 tem
= fold_convert_loc (loc
, type
, tem
);
10949 return fold_build2_loc (loc
, MULT_EXPR
, type
, tem
, tem
);
10953 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10954 This is not the same for NaNs or if signed zeros are
10956 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
10957 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10958 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
10959 && TREE_CODE (arg1
) == COMPLEX_CST
10960 && real_zerop (TREE_REALPART (arg1
)))
10962 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10963 if (real_onep (TREE_IMAGPART (arg1
)))
10965 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10966 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
10968 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
10969 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
10971 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10972 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
10973 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
10977 /* Optimize z * conj(z) for floating point complex numbers.
10978 Guarded by flag_unsafe_math_optimizations as non-finite
10979 imaginary components don't produce scalar results. */
10980 if (flag_unsafe_math_optimizations
10981 && TREE_CODE (arg0
) == CONJ_EXPR
10982 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10983 return fold_mult_zconjz (loc
, type
, arg1
);
10984 if (flag_unsafe_math_optimizations
10985 && TREE_CODE (arg1
) == CONJ_EXPR
10986 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10987 return fold_mult_zconjz (loc
, type
, arg0
);
10989 if (flag_unsafe_math_optimizations
)
10991 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
10992 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
10994 /* Optimizations of root(...)*root(...). */
10995 if (fcode0
== fcode1
&& BUILTIN_ROOT_P (fcode0
))
10998 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
10999 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11001 /* Optimize sqrt(x)*sqrt(x) as x. */
11002 if (BUILTIN_SQRT_P (fcode0
)
11003 && operand_equal_p (arg00
, arg10
, 0)
11004 && ! HONOR_SNANS (TYPE_MODE (type
)))
11007 /* Optimize root(x)*root(y) as root(x*y). */
11008 rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11009 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg00
, arg10
);
11010 return build_call_expr_loc (loc
, rootfn
, 1, arg
);
11013 /* Optimize expN(x)*expN(y) as expN(x+y). */
11014 if (fcode0
== fcode1
&& BUILTIN_EXPONENT_P (fcode0
))
11016 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11017 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
11018 CALL_EXPR_ARG (arg0
, 0),
11019 CALL_EXPR_ARG (arg1
, 0));
11020 return build_call_expr_loc (loc
, expfn
, 1, arg
);
11023 /* Optimizations of pow(...)*pow(...). */
11024 if ((fcode0
== BUILT_IN_POW
&& fcode1
== BUILT_IN_POW
)
11025 || (fcode0
== BUILT_IN_POWF
&& fcode1
== BUILT_IN_POWF
)
11026 || (fcode0
== BUILT_IN_POWL
&& fcode1
== BUILT_IN_POWL
))
11028 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11029 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11030 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11031 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
11033 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
11034 if (operand_equal_p (arg01
, arg11
, 0))
11036 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11037 tree arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
11039 return build_call_expr_loc (loc
, powfn
, 2, arg
, arg01
);
11042 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
11043 if (operand_equal_p (arg00
, arg10
, 0))
11045 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11046 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
11048 return build_call_expr_loc (loc
, powfn
, 2, arg00
, arg
);
11052 /* Optimize tan(x)*cos(x) as sin(x). */
11053 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_COS
)
11054 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_COSF
)
11055 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_COSL
)
11056 || (fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_TAN
)
11057 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_TANF
)
11058 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_TANL
))
11059 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11060 CALL_EXPR_ARG (arg1
, 0), 0))
11062 tree sinfn
= mathfn_built_in (type
, BUILT_IN_SIN
);
11064 if (sinfn
!= NULL_TREE
)
11065 return build_call_expr_loc (loc
, sinfn
, 1,
11066 CALL_EXPR_ARG (arg0
, 0));
11069 /* Optimize x*pow(x,c) as pow(x,c+1). */
11070 if (fcode1
== BUILT_IN_POW
11071 || fcode1
== BUILT_IN_POWF
11072 || fcode1
== BUILT_IN_POWL
)
11074 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11075 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
11076 if (TREE_CODE (arg11
) == REAL_CST
11077 && !TREE_OVERFLOW (arg11
)
11078 && operand_equal_p (arg0
, arg10
, 0))
11080 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
11084 c
= TREE_REAL_CST (arg11
);
11085 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
11086 arg
= build_real (type
, c
);
11087 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11091 /* Optimize pow(x,c)*x as pow(x,c+1). */
11092 if (fcode0
== BUILT_IN_POW
11093 || fcode0
== BUILT_IN_POWF
11094 || fcode0
== BUILT_IN_POWL
)
11096 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11097 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11098 if (TREE_CODE (arg01
) == REAL_CST
11099 && !TREE_OVERFLOW (arg01
)
11100 && operand_equal_p (arg1
, arg00
, 0))
11102 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11106 c
= TREE_REAL_CST (arg01
);
11107 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
11108 arg
= build_real (type
, c
);
11109 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
11113 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
11114 if (!in_gimple_form
11116 && operand_equal_p (arg0
, arg1
, 0))
11118 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
11122 tree arg
= build_real (type
, dconst2
);
11123 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11132 if (integer_all_onesp (arg1
))
11133 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11134 if (integer_zerop (arg1
))
11135 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11136 if (operand_equal_p (arg0
, arg1
, 0))
11137 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11139 /* ~X | X is -1. */
11140 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11141 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11143 t1
= build_zero_cst (type
);
11144 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11145 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11148 /* X | ~X is -1. */
11149 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11150 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11152 t1
= build_zero_cst (type
);
11153 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11154 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11157 /* Canonicalize (X & C1) | C2. */
11158 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11159 && TREE_CODE (arg1
) == INTEGER_CST
11160 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11162 int width
= TYPE_PRECISION (type
), w
;
11163 wide_int c1
= TREE_OPERAND (arg0
, 1);
11164 wide_int c2
= arg1
;
11166 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11167 if ((c1
& c2
) == c1
)
11168 return omit_one_operand_loc (loc
, type
, arg1
,
11169 TREE_OPERAND (arg0
, 0));
11171 wide_int msk
= wi::mask (width
, false,
11172 TYPE_PRECISION (TREE_TYPE (arg1
)));
11174 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11175 if (msk
.and_not (c1
| c2
) == 0)
11176 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11177 TREE_OPERAND (arg0
, 0), arg1
);
11179 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11180 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11181 mode which allows further optimizations. */
11184 wide_int c3
= c1
.and_not (c2
);
11185 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
11187 wide_int mask
= wi::mask (w
, false,
11188 TYPE_PRECISION (type
));
11189 if (((c1
| c2
) & mask
) == mask
&& c1
.and_not (mask
) == 0)
11197 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11198 fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11199 TREE_OPERAND (arg0
, 0),
11200 wide_int_to_tree (type
,
11205 /* (X & Y) | Y is (X, Y). */
11206 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11207 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11208 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11209 /* (X & Y) | X is (Y, X). */
11210 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11211 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11212 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11213 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11214 /* X | (X & Y) is (Y, X). */
11215 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11216 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11217 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11218 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11219 /* X | (Y & X) is (Y, X). */
11220 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11221 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11222 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11223 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11225 /* (X & ~Y) | (~X & Y) is X ^ Y */
11226 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11227 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
11229 tree a0
, a1
, l0
, l1
, n0
, n1
;
11231 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11232 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11234 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11235 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11237 n0
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l0
);
11238 n1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l1
);
11240 if ((operand_equal_p (n0
, a0
, 0)
11241 && operand_equal_p (n1
, a1
, 0))
11242 || (operand_equal_p (n0
, a1
, 0)
11243 && operand_equal_p (n1
, a0
, 0)))
11244 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, l0
, n1
);
11247 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11248 if (t1
!= NULL_TREE
)
11251 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11253 This results in more efficient code for machines without a NAND
11254 instruction. Combine will canonicalize to the first form
11255 which will allow use of NAND instructions provided by the
11256 backend if they exist. */
11257 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11258 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11261 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11262 build2 (BIT_AND_EXPR
, type
,
11263 fold_convert_loc (loc
, type
,
11264 TREE_OPERAND (arg0
, 0)),
11265 fold_convert_loc (loc
, type
,
11266 TREE_OPERAND (arg1
, 0))));
11269 /* See if this can be simplified into a rotate first. If that
11270 is unsuccessful continue in the association code. */
11274 if (integer_zerop (arg1
))
11275 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11276 if (integer_all_onesp (arg1
))
11277 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op0
);
11278 if (operand_equal_p (arg0
, arg1
, 0))
11279 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11281 /* ~X ^ X is -1. */
11282 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11283 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11285 t1
= build_zero_cst (type
);
11286 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11287 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11290 /* X ^ ~X is -1. */
11291 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11292 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11294 t1
= build_zero_cst (type
);
11295 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11296 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11299 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11300 with a constant, and the two constants have no bits in common,
11301 we should treat this as a BIT_IOR_EXPR since this may produce more
11302 simplifications. */
11303 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11304 && TREE_CODE (arg1
) == BIT_AND_EXPR
11305 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
11306 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
11307 && wi::bit_and (TREE_OPERAND (arg0
, 1),
11308 TREE_OPERAND (arg1
, 1)) == 0)
11310 code
= BIT_IOR_EXPR
;
11314 /* (X | Y) ^ X -> Y & ~ X*/
11315 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11316 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11318 tree t2
= TREE_OPERAND (arg0
, 1);
11319 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11321 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11322 fold_convert_loc (loc
, type
, t2
),
11323 fold_convert_loc (loc
, type
, t1
));
11327 /* (Y | X) ^ X -> Y & ~ X*/
11328 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11329 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11331 tree t2
= TREE_OPERAND (arg0
, 0);
11332 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11334 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11335 fold_convert_loc (loc
, type
, t2
),
11336 fold_convert_loc (loc
, type
, t1
));
11340 /* X ^ (X | Y) -> Y & ~ X*/
11341 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11342 && operand_equal_p (TREE_OPERAND (arg1
, 0), arg0
, 0))
11344 tree t2
= TREE_OPERAND (arg1
, 1);
11345 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11347 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11348 fold_convert_loc (loc
, type
, t2
),
11349 fold_convert_loc (loc
, type
, t1
));
11353 /* X ^ (Y | X) -> Y & ~ X*/
11354 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11355 && operand_equal_p (TREE_OPERAND (arg1
, 1), arg0
, 0))
11357 tree t2
= TREE_OPERAND (arg1
, 0);
11358 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11360 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11361 fold_convert_loc (loc
, type
, t2
),
11362 fold_convert_loc (loc
, type
, t1
));
11366 /* Convert ~X ^ ~Y to X ^ Y. */
11367 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11368 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11369 return fold_build2_loc (loc
, code
, type
,
11370 fold_convert_loc (loc
, type
,
11371 TREE_OPERAND (arg0
, 0)),
11372 fold_convert_loc (loc
, type
,
11373 TREE_OPERAND (arg1
, 0)));
11375 /* Convert ~X ^ C to X ^ ~C. */
11376 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11377 && TREE_CODE (arg1
) == INTEGER_CST
)
11378 return fold_build2_loc (loc
, code
, type
,
11379 fold_convert_loc (loc
, type
,
11380 TREE_OPERAND (arg0
, 0)),
11381 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, arg1
));
11383 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11384 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11385 && INTEGRAL_TYPE_P (type
)
11386 && integer_onep (TREE_OPERAND (arg0
, 1))
11387 && integer_onep (arg1
))
11388 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
11389 build_zero_cst (TREE_TYPE (arg0
)));
11391 /* Fold (X & Y) ^ Y as ~X & Y. */
11392 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11393 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11395 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11396 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11397 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11398 fold_convert_loc (loc
, type
, arg1
));
11400 /* Fold (X & Y) ^ X as ~Y & X. */
11401 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11402 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11403 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11405 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11406 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11407 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11408 fold_convert_loc (loc
, type
, arg1
));
11410 /* Fold X ^ (X & Y) as X & ~Y. */
11411 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11412 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11414 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11415 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11416 fold_convert_loc (loc
, type
, arg0
),
11417 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11419 /* Fold X ^ (Y & X) as ~Y & X. */
11420 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11421 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11422 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11424 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11425 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11426 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11427 fold_convert_loc (loc
, type
, arg0
));
11430 /* See if this can be simplified into a rotate first. If that
11431 is unsuccessful continue in the association code. */
11435 if (integer_all_onesp (arg1
))
11436 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11437 if (integer_zerop (arg1
))
11438 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11439 if (operand_equal_p (arg0
, arg1
, 0))
11440 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11442 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
11443 if ((TREE_CODE (arg0
) == BIT_NOT_EXPR
11444 || TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11445 || (TREE_CODE (arg0
) == EQ_EXPR
11446 && integer_zerop (TREE_OPERAND (arg0
, 1))))
11447 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11448 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
11450 /* X & ~X , X & (X == 0), and X & !X are always zero. */
11451 if ((TREE_CODE (arg1
) == BIT_NOT_EXPR
11452 || TREE_CODE (arg1
) == TRUTH_NOT_EXPR
11453 || (TREE_CODE (arg1
) == EQ_EXPR
11454 && integer_zerop (TREE_OPERAND (arg1
, 1))))
11455 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11456 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11458 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11459 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11460 && TREE_CODE (arg1
) == INTEGER_CST
11461 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11463 tree tmp1
= fold_convert_loc (loc
, type
, arg1
);
11464 tree tmp2
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11465 tree tmp3
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11466 tmp2
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp2
, tmp1
);
11467 tmp3
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp3
, tmp1
);
11469 fold_convert_loc (loc
, type
,
11470 fold_build2_loc (loc
, BIT_IOR_EXPR
,
11471 type
, tmp2
, tmp3
));
11474 /* (X | Y) & Y is (X, Y). */
11475 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11476 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11477 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11478 /* (X | Y) & X is (Y, X). */
11479 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11480 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11481 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11482 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11483 /* X & (X | Y) is (Y, X). */
11484 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11485 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11486 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11487 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11488 /* X & (Y | X) is (Y, X). */
11489 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11490 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11491 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11492 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11494 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11495 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11496 && INTEGRAL_TYPE_P (type
)
11497 && integer_onep (TREE_OPERAND (arg0
, 1))
11498 && integer_onep (arg1
))
11501 tem
= TREE_OPERAND (arg0
, 0);
11502 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11503 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11505 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11506 build_zero_cst (TREE_TYPE (tem
)));
11508 /* Fold ~X & 1 as (X & 1) == 0. */
11509 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11510 && INTEGRAL_TYPE_P (type
)
11511 && integer_onep (arg1
))
11514 tem
= TREE_OPERAND (arg0
, 0);
11515 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11516 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11518 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11519 build_zero_cst (TREE_TYPE (tem
)));
11521 /* Fold !X & 1 as X == 0. */
11522 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11523 && integer_onep (arg1
))
11525 tem
= TREE_OPERAND (arg0
, 0);
11526 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
11527 build_zero_cst (TREE_TYPE (tem
)));
11530 /* Fold (X ^ Y) & Y as ~X & Y. */
11531 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11532 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11534 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11535 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11536 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11537 fold_convert_loc (loc
, type
, arg1
));
11539 /* Fold (X ^ Y) & X as ~Y & X. */
11540 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11541 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11542 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11544 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11545 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11546 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11547 fold_convert_loc (loc
, type
, arg1
));
11549 /* Fold X & (X ^ Y) as X & ~Y. */
11550 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11551 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11553 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11554 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11555 fold_convert_loc (loc
, type
, arg0
),
11556 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11558 /* Fold X & (Y ^ X) as ~Y & X. */
11559 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11560 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11561 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11563 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11564 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11565 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11566 fold_convert_loc (loc
, type
, arg0
));
11569 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11570 multiple of 1 << CST. */
11571 if (TREE_CODE (arg1
) == INTEGER_CST
)
11573 wide_int cst1
= arg1
;
11574 wide_int ncst1
= -cst1
;
11575 if ((cst1
& ncst1
) == ncst1
11576 && multiple_of_p (type
, arg0
,
11577 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
11578 return fold_convert_loc (loc
, type
, arg0
);
11581 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
11583 if (TREE_CODE (arg1
) == INTEGER_CST
11584 && TREE_CODE (arg0
) == MULT_EXPR
11585 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11587 wide_int warg1
= arg1
;
11588 wide_int masked
= mask_with_tz (type
, warg1
, TREE_OPERAND (arg0
, 1));
11591 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
11593 else if (masked
!= warg1
)
11595 /* Avoid the transform if arg1 is a mask of some
11596 mode which allows further optimizations. */
11597 int pop
= wi::popcount (warg1
);
11598 if (!(pop
>= BITS_PER_UNIT
11599 && exact_log2 (pop
) != -1
11600 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
11601 return fold_build2_loc (loc
, code
, type
, op0
,
11602 wide_int_to_tree (type
, masked
));
11606 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11607 ((A & N) + B) & M -> (A + B) & M
11608 Similarly if (N & M) == 0,
11609 ((A | N) + B) & M -> (A + B) & M
11610 and for - instead of + (or unary - instead of +)
11611 and/or ^ instead of |.
11612 If B is constant and (B & M) == 0, fold into A & M. */
11613 if (TREE_CODE (arg1
) == INTEGER_CST
)
11615 wide_int cst1
= arg1
;
11616 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
11617 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
11618 && (TREE_CODE (arg0
) == PLUS_EXPR
11619 || TREE_CODE (arg0
) == MINUS_EXPR
11620 || TREE_CODE (arg0
) == NEGATE_EXPR
)
11621 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
11622 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
11628 /* Now we know that arg0 is (C + D) or (C - D) or
11629 -C and arg1 (M) is == (1LL << cst) - 1.
11630 Store C into PMOP[0] and D into PMOP[1]. */
11631 pmop
[0] = TREE_OPERAND (arg0
, 0);
11633 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
11635 pmop
[1] = TREE_OPERAND (arg0
, 1);
11639 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
11642 for (; which
>= 0; which
--)
11643 switch (TREE_CODE (pmop
[which
]))
11648 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
11651 cst0
= TREE_OPERAND (pmop
[which
], 1);
11653 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
11658 else if (cst0
!= 0)
11660 /* If C or D is of the form (A & N) where
11661 (N & M) == M, or of the form (A | N) or
11662 (A ^ N) where (N & M) == 0, replace it with A. */
11663 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
11666 /* If C or D is a N where (N & M) == 0, it can be
11667 omitted (assumed 0). */
11668 if ((TREE_CODE (arg0
) == PLUS_EXPR
11669 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
11670 && (cst1
& pmop
[which
]) == 0)
11671 pmop
[which
] = NULL
;
11677 /* Only build anything new if we optimized one or both arguments
11679 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
11680 || (TREE_CODE (arg0
) != NEGATE_EXPR
11681 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
11683 tree utype
= TREE_TYPE (arg0
);
11684 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
11686 /* Perform the operations in a type that has defined
11687 overflow behavior. */
11688 utype
= unsigned_type_for (TREE_TYPE (arg0
));
11689 if (pmop
[0] != NULL
)
11690 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
11691 if (pmop
[1] != NULL
)
11692 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
11695 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
11696 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
11697 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
11699 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
11700 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
11702 else if (pmop
[0] != NULL
)
11704 else if (pmop
[1] != NULL
)
11707 return build_int_cst (type
, 0);
11709 else if (pmop
[0] == NULL
)
11710 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
11712 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
11714 /* TEM is now the new binary +, - or unary - replacement. */
11715 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
11716 fold_convert_loc (loc
, utype
, arg1
));
11717 return fold_convert_loc (loc
, type
, tem
);
11722 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11723 if (t1
!= NULL_TREE
)
11725 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11726 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
11727 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
11729 prec
= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
11731 wide_int mask
= wide_int::from (arg1
, prec
, UNSIGNED
);
11734 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11737 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11739 This results in more efficient code for machines without a NOR
11740 instruction. Combine will canonicalize to the first form
11741 which will allow use of NOR instructions provided by the
11742 backend if they exist. */
11743 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11744 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11746 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11747 build2 (BIT_IOR_EXPR
, type
,
11748 fold_convert_loc (loc
, type
,
11749 TREE_OPERAND (arg0
, 0)),
11750 fold_convert_loc (loc
, type
,
11751 TREE_OPERAND (arg1
, 0))));
11754 /* If arg0 is derived from the address of an object or function, we may
11755 be able to fold this expression using the object or function's
11757 if (POINTER_TYPE_P (TREE_TYPE (arg0
)) && tree_fits_uhwi_p (arg1
))
11759 unsigned HOST_WIDE_INT modulus
, residue
;
11760 unsigned HOST_WIDE_INT low
= tree_to_uhwi (arg1
);
11762 modulus
= get_pointer_modulus_and_residue (arg0
, &residue
,
11763 integer_onep (arg1
));
11765 /* This works because modulus is a power of 2. If this weren't the
11766 case, we'd have to replace it by its greatest power-of-2
11767 divisor: modulus & -modulus. */
11769 return build_int_cst (type
, residue
& low
);
11772 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11773 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11774 if the new mask might be further optimized. */
11775 if ((TREE_CODE (arg0
) == LSHIFT_EXPR
11776 || TREE_CODE (arg0
) == RSHIFT_EXPR
)
11777 && TYPE_PRECISION (TREE_TYPE (arg0
)) <= HOST_BITS_PER_WIDE_INT
11778 && TREE_CODE (arg1
) == INTEGER_CST
11779 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
11780 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) > 0
11781 && (tree_to_uhwi (TREE_OPERAND (arg0
, 1))
11782 < TYPE_PRECISION (TREE_TYPE (arg0
))))
11784 unsigned int shiftc
= tree_to_uhwi (TREE_OPERAND (arg0
, 1));
11785 unsigned HOST_WIDE_INT mask
= TREE_INT_CST_LOW (arg1
);
11786 unsigned HOST_WIDE_INT newmask
, zerobits
= 0;
11787 tree shift_type
= TREE_TYPE (arg0
);
11789 if (TREE_CODE (arg0
) == LSHIFT_EXPR
)
11790 zerobits
= ((((unsigned HOST_WIDE_INT
) 1) << shiftc
) - 1);
11791 else if (TREE_CODE (arg0
) == RSHIFT_EXPR
11792 && TYPE_PRECISION (TREE_TYPE (arg0
))
11793 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg0
))))
11795 prec
= TYPE_PRECISION (TREE_TYPE (arg0
));
11796 tree arg00
= TREE_OPERAND (arg0
, 0);
11797 /* See if more bits can be proven as zero because of
11799 if (TREE_CODE (arg00
) == NOP_EXPR
11800 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00
, 0))))
11802 tree inner_type
= TREE_TYPE (TREE_OPERAND (arg00
, 0));
11803 if (TYPE_PRECISION (inner_type
)
11804 == GET_MODE_PRECISION (TYPE_MODE (inner_type
))
11805 && TYPE_PRECISION (inner_type
) < prec
)
11807 prec
= TYPE_PRECISION (inner_type
);
11808 /* See if we can shorten the right shift. */
11810 shift_type
= inner_type
;
11811 /* Otherwise X >> C1 is all zeros, so we'll optimize
11812 it into (X, 0) later on by making sure zerobits
11816 zerobits
= ~(unsigned HOST_WIDE_INT
) 0;
11819 zerobits
>>= HOST_BITS_PER_WIDE_INT
- shiftc
;
11820 zerobits
<<= prec
- shiftc
;
11822 /* For arithmetic shift if sign bit could be set, zerobits
11823 can contain actually sign bits, so no transformation is
11824 possible, unless MASK masks them all away. In that
11825 case the shift needs to be converted into logical shift. */
11826 if (!TYPE_UNSIGNED (TREE_TYPE (arg0
))
11827 && prec
== TYPE_PRECISION (TREE_TYPE (arg0
)))
11829 if ((mask
& zerobits
) == 0)
11830 shift_type
= unsigned_type_for (TREE_TYPE (arg0
));
11836 /* ((X << 16) & 0xff00) is (X, 0). */
11837 if ((mask
& zerobits
) == mask
)
11838 return omit_one_operand_loc (loc
, type
,
11839 build_int_cst (type
, 0), arg0
);
11841 newmask
= mask
| zerobits
;
11842 if (newmask
!= mask
&& (newmask
& (newmask
+ 1)) == 0)
11844 /* Only do the transformation if NEWMASK is some integer
11846 for (prec
= BITS_PER_UNIT
;
11847 prec
< HOST_BITS_PER_WIDE_INT
; prec
<<= 1)
11848 if (newmask
== (((unsigned HOST_WIDE_INT
) 1) << prec
) - 1)
11850 if (prec
< HOST_BITS_PER_WIDE_INT
11851 || newmask
== ~(unsigned HOST_WIDE_INT
) 0)
11855 if (shift_type
!= TREE_TYPE (arg0
))
11857 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), shift_type
,
11858 fold_convert_loc (loc
, shift_type
,
11859 TREE_OPERAND (arg0
, 0)),
11860 TREE_OPERAND (arg0
, 1));
11861 tem
= fold_convert_loc (loc
, type
, tem
);
11865 newmaskt
= build_int_cst_type (TREE_TYPE (op1
), newmask
);
11866 if (!tree_int_cst_equal (newmaskt
, arg1
))
11867 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tem
, newmaskt
);
11875 /* Don't touch a floating-point divide by zero unless the mode
11876 of the constant can represent infinity. */
11877 if (TREE_CODE (arg1
) == REAL_CST
11878 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
11879 && real_zerop (arg1
))
11882 /* Optimize A / A to 1.0 if we don't care about
11883 NaNs or Infinities. Skip the transformation
11884 for non-real operands. */
11885 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11886 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
11887 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0
)))
11888 && operand_equal_p (arg0
, arg1
, 0))
11890 tree r
= build_real (TREE_TYPE (arg0
), dconst1
);
11892 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
11895 /* The complex version of the above A / A optimization. */
11896 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11897 && operand_equal_p (arg0
, arg1
, 0))
11899 tree elem_type
= TREE_TYPE (TREE_TYPE (arg0
));
11900 if (! HONOR_NANS (TYPE_MODE (elem_type
))
11901 && ! HONOR_INFINITIES (TYPE_MODE (elem_type
)))
11903 tree r
= build_real (elem_type
, dconst1
);
11904 /* omit_two_operands will call fold_convert for us. */
11905 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
11909 /* (-A) / (-B) -> A / B */
11910 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
11911 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11912 TREE_OPERAND (arg0
, 0),
11913 negate_expr (arg1
));
11914 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
11915 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11916 negate_expr (arg0
),
11917 TREE_OPERAND (arg1
, 0));
11919 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
11920 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11921 && real_onep (arg1
))
11922 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11924 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
11925 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11926 && real_minus_onep (arg1
))
11927 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
,
11928 negate_expr (arg0
)));
11930 /* If ARG1 is a constant, we can convert this to a multiply by the
11931 reciprocal. This does not have the same rounding properties,
11932 so only do this if -freciprocal-math. We can actually
11933 always safely do it if ARG1 is a power of two, but it's hard to
11934 tell if it is or not in a portable manner. */
11936 && (TREE_CODE (arg1
) == REAL_CST
11937 || (TREE_CODE (arg1
) == COMPLEX_CST
11938 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg1
)))
11939 || (TREE_CODE (arg1
) == VECTOR_CST
11940 && VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg1
)))))
11942 if (flag_reciprocal_math
11943 && 0 != (tem
= const_binop (code
, build_one_cst (type
), arg1
)))
11944 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tem
);
11945 /* Find the reciprocal if optimizing and the result is exact.
11946 TODO: Complex reciprocal not implemented. */
11947 if (TREE_CODE (arg1
) != COMPLEX_CST
)
11949 tree inverse
= exact_inverse (TREE_TYPE (arg0
), arg1
);
11952 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, inverse
);
11955 /* Convert A/B/C to A/(B*C). */
11956 if (flag_reciprocal_math
11957 && TREE_CODE (arg0
) == RDIV_EXPR
)
11958 return fold_build2_loc (loc
, RDIV_EXPR
, type
, TREE_OPERAND (arg0
, 0),
11959 fold_build2_loc (loc
, MULT_EXPR
, type
,
11960 TREE_OPERAND (arg0
, 1), arg1
));
11962 /* Convert A/(B/C) to (A/B)*C. */
11963 if (flag_reciprocal_math
11964 && TREE_CODE (arg1
) == RDIV_EXPR
)
11965 return fold_build2_loc (loc
, MULT_EXPR
, type
,
11966 fold_build2_loc (loc
, RDIV_EXPR
, type
, arg0
,
11967 TREE_OPERAND (arg1
, 0)),
11968 TREE_OPERAND (arg1
, 1));
11970 /* Convert C1/(X*C2) into (C1/C2)/X. */
11971 if (flag_reciprocal_math
11972 && TREE_CODE (arg1
) == MULT_EXPR
11973 && TREE_CODE (arg0
) == REAL_CST
11974 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
11976 tree tem
= const_binop (RDIV_EXPR
, arg0
,
11977 TREE_OPERAND (arg1
, 1));
11979 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
11980 TREE_OPERAND (arg1
, 0));
11983 if (flag_unsafe_math_optimizations
)
11985 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
11986 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
11988 /* Optimize sin(x)/cos(x) as tan(x). */
11989 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_COS
)
11990 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_COSF
)
11991 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_COSL
))
11992 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11993 CALL_EXPR_ARG (arg1
, 0), 0))
11995 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
11997 if (tanfn
!= NULL_TREE
)
11998 return build_call_expr_loc (loc
, tanfn
, 1, CALL_EXPR_ARG (arg0
, 0));
12001 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
12002 if (((fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_SIN
)
12003 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_SINF
)
12004 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_SINL
))
12005 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
12006 CALL_EXPR_ARG (arg1
, 0), 0))
12008 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
12010 if (tanfn
!= NULL_TREE
)
12012 tree tmp
= build_call_expr_loc (loc
, tanfn
, 1,
12013 CALL_EXPR_ARG (arg0
, 0));
12014 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12015 build_real (type
, dconst1
), tmp
);
12019 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
12020 NaNs or Infinities. */
12021 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_TAN
)
12022 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_TANF
)
12023 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_TANL
)))
12025 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12026 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
12028 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
12029 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
12030 && operand_equal_p (arg00
, arg01
, 0))
12032 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
12034 if (cosfn
!= NULL_TREE
)
12035 return build_call_expr_loc (loc
, cosfn
, 1, arg00
);
12039 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
12040 NaNs or Infinities. */
12041 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_SIN
)
12042 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_SINF
)
12043 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_SINL
)))
12045 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12046 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
12048 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
12049 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
12050 && operand_equal_p (arg00
, arg01
, 0))
12052 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
12054 if (cosfn
!= NULL_TREE
)
12056 tree tmp
= build_call_expr_loc (loc
, cosfn
, 1, arg00
);
12057 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12058 build_real (type
, dconst1
),
12064 /* Optimize pow(x,c)/x as pow(x,c-1). */
12065 if (fcode0
== BUILT_IN_POW
12066 || fcode0
== BUILT_IN_POWF
12067 || fcode0
== BUILT_IN_POWL
)
12069 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12070 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
12071 if (TREE_CODE (arg01
) == REAL_CST
12072 && !TREE_OVERFLOW (arg01
)
12073 && operand_equal_p (arg1
, arg00
, 0))
12075 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
12079 c
= TREE_REAL_CST (arg01
);
12080 real_arithmetic (&c
, MINUS_EXPR
, &c
, &dconst1
);
12081 arg
= build_real (type
, c
);
12082 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
12086 /* Optimize a/root(b/c) into a*root(c/b). */
12087 if (BUILTIN_ROOT_P (fcode1
))
12089 tree rootarg
= CALL_EXPR_ARG (arg1
, 0);
12091 if (TREE_CODE (rootarg
) == RDIV_EXPR
)
12093 tree rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12094 tree b
= TREE_OPERAND (rootarg
, 0);
12095 tree c
= TREE_OPERAND (rootarg
, 1);
12097 tree tmp
= fold_build2_loc (loc
, RDIV_EXPR
, type
, c
, b
);
12099 tmp
= build_call_expr_loc (loc
, rootfn
, 1, tmp
);
12100 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tmp
);
12104 /* Optimize x/expN(y) into x*expN(-y). */
12105 if (BUILTIN_EXPONENT_P (fcode1
))
12107 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12108 tree arg
= negate_expr (CALL_EXPR_ARG (arg1
, 0));
12109 arg1
= build_call_expr_loc (loc
,
12111 fold_convert_loc (loc
, type
, arg
));
12112 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12115 /* Optimize x/pow(y,z) into x*pow(y,-z). */
12116 if (fcode1
== BUILT_IN_POW
12117 || fcode1
== BUILT_IN_POWF
12118 || fcode1
== BUILT_IN_POWL
)
12120 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12121 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
12122 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
12123 tree neg11
= fold_convert_loc (loc
, type
,
12124 negate_expr (arg11
));
12125 arg1
= build_call_expr_loc (loc
, powfn
, 2, arg10
, neg11
);
12126 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12131 case TRUNC_DIV_EXPR
:
12132 /* Optimize (X & (-A)) / A where A is a power of 2,
12134 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12135 && !TYPE_UNSIGNED (type
) && TREE_CODE (arg1
) == INTEGER_CST
12136 && integer_pow2p (arg1
) && tree_int_cst_sgn (arg1
) > 0)
12138 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (arg1
),
12139 arg1
, TREE_OPERAND (arg0
, 1));
12140 if (sum
&& integer_zerop (sum
)) {
12141 tree pow2
= build_int_cst (integer_type_node
,
12142 wi::exact_log2 (arg1
));
12143 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12144 TREE_OPERAND (arg0
, 0), pow2
);
12150 case FLOOR_DIV_EXPR
:
12151 /* Simplify A / (B << N) where A and B are positive and B is
12152 a power of 2, to A >> (N + log2(B)). */
12153 strict_overflow_p
= false;
12154 if (TREE_CODE (arg1
) == LSHIFT_EXPR
12155 && (TYPE_UNSIGNED (type
)
12156 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12158 tree sval
= TREE_OPERAND (arg1
, 0);
12159 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
12161 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
12162 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
12163 wi::exact_log2 (sval
));
12165 if (strict_overflow_p
)
12166 fold_overflow_warning (("assuming signed overflow does not "
12167 "occur when simplifying A / (B << N)"),
12168 WARN_STRICT_OVERFLOW_MISC
);
12170 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
12172 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12173 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
12177 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
12178 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
12179 if (INTEGRAL_TYPE_P (type
)
12180 && TYPE_UNSIGNED (type
)
12181 && code
== FLOOR_DIV_EXPR
)
12182 return fold_build2_loc (loc
, TRUNC_DIV_EXPR
, type
, op0
, op1
);
12186 case ROUND_DIV_EXPR
:
12187 case CEIL_DIV_EXPR
:
12188 case EXACT_DIV_EXPR
:
12189 if (integer_onep (arg1
))
12190 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12191 if (integer_zerop (arg1
))
12193 /* X / -1 is -X. */
12194 if (!TYPE_UNSIGNED (type
)
12195 && TREE_CODE (arg1
) == INTEGER_CST
12196 && wi::eq_p (arg1
, -1))
12197 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
12199 /* Convert -A / -B to A / B when the type is signed and overflow is
12201 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12202 && TREE_CODE (arg0
) == NEGATE_EXPR
12203 && negate_expr_p (arg1
))
12205 if (INTEGRAL_TYPE_P (type
))
12206 fold_overflow_warning (("assuming signed overflow does not occur "
12207 "when distributing negation across "
12209 WARN_STRICT_OVERFLOW_MISC
);
12210 return fold_build2_loc (loc
, code
, type
,
12211 fold_convert_loc (loc
, type
,
12212 TREE_OPERAND (arg0
, 0)),
12213 fold_convert_loc (loc
, type
,
12214 negate_expr (arg1
)));
12216 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12217 && TREE_CODE (arg1
) == NEGATE_EXPR
12218 && negate_expr_p (arg0
))
12220 if (INTEGRAL_TYPE_P (type
))
12221 fold_overflow_warning (("assuming signed overflow does not occur "
12222 "when distributing negation across "
12224 WARN_STRICT_OVERFLOW_MISC
);
12225 return fold_build2_loc (loc
, code
, type
,
12226 fold_convert_loc (loc
, type
,
12227 negate_expr (arg0
)),
12228 fold_convert_loc (loc
, type
,
12229 TREE_OPERAND (arg1
, 0)));
12232 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12233 operation, EXACT_DIV_EXPR.
12235 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12236 At one time others generated faster code, it's not clear if they do
12237 after the last round to changes to the DIV code in expmed.c. */
12238 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
12239 && multiple_of_p (type
, arg0
, arg1
))
12240 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
, arg0
, arg1
);
12242 strict_overflow_p
= false;
12243 if (TREE_CODE (arg1
) == INTEGER_CST
12244 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12245 &strict_overflow_p
)))
12247 if (strict_overflow_p
)
12248 fold_overflow_warning (("assuming signed overflow does not occur "
12249 "when simplifying division"),
12250 WARN_STRICT_OVERFLOW_MISC
);
12251 return fold_convert_loc (loc
, type
, tem
);
12256 case CEIL_MOD_EXPR
:
12257 case FLOOR_MOD_EXPR
:
12258 case ROUND_MOD_EXPR
:
12259 case TRUNC_MOD_EXPR
:
12260 /* X % 1 is always zero, but be sure to preserve any side
12262 if (integer_onep (arg1
))
12263 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12265 /* X % 0, return X % 0 unchanged so that we can get the
12266 proper warnings and errors. */
12267 if (integer_zerop (arg1
))
12270 /* 0 % X is always zero, but be sure to preserve any side
12271 effects in X. Place this after checking for X == 0. */
12272 if (integer_zerop (arg0
))
12273 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12275 /* X % -1 is zero. */
12276 if (!TYPE_UNSIGNED (type
)
12277 && TREE_CODE (arg1
) == INTEGER_CST
12278 && wi::eq_p (arg1
, -1))
12279 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12281 /* X % -C is the same as X % C. */
12282 if (code
== TRUNC_MOD_EXPR
12283 && TYPE_SIGN (type
) == SIGNED
12284 && TREE_CODE (arg1
) == INTEGER_CST
12285 && !TREE_OVERFLOW (arg1
)
12286 && wi::neg_p (arg1
)
12287 && !TYPE_OVERFLOW_TRAPS (type
)
12288 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
12289 && !sign_bit_p (arg1
, arg1
))
12290 return fold_build2_loc (loc
, code
, type
,
12291 fold_convert_loc (loc
, type
, arg0
),
12292 fold_convert_loc (loc
, type
,
12293 negate_expr (arg1
)));
12295 /* X % -Y is the same as X % Y. */
12296 if (code
== TRUNC_MOD_EXPR
12297 && !TYPE_UNSIGNED (type
)
12298 && TREE_CODE (arg1
) == NEGATE_EXPR
12299 && !TYPE_OVERFLOW_TRAPS (type
))
12300 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, arg0
),
12301 fold_convert_loc (loc
, type
,
12302 TREE_OPERAND (arg1
, 0)));
12304 strict_overflow_p
= false;
12305 if (TREE_CODE (arg1
) == INTEGER_CST
12306 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12307 &strict_overflow_p
)))
12309 if (strict_overflow_p
)
12310 fold_overflow_warning (("assuming signed overflow does not occur "
12311 "when simplifying modulus"),
12312 WARN_STRICT_OVERFLOW_MISC
);
12313 return fold_convert_loc (loc
, type
, tem
);
12316 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12317 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
12318 if ((code
== TRUNC_MOD_EXPR
|| code
== FLOOR_MOD_EXPR
)
12319 && (TYPE_UNSIGNED (type
)
12320 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12323 /* Also optimize A % (C << N) where C is a power of 2,
12324 to A & ((C << N) - 1). */
12325 if (TREE_CODE (arg1
) == LSHIFT_EXPR
)
12326 c
= TREE_OPERAND (arg1
, 0);
12328 if (integer_pow2p (c
) && tree_int_cst_sgn (c
) > 0)
12331 = fold_build2_loc (loc
, MINUS_EXPR
, TREE_TYPE (arg1
), arg1
,
12332 build_int_cst (TREE_TYPE (arg1
), 1));
12333 if (strict_overflow_p
)
12334 fold_overflow_warning (("assuming signed overflow does not "
12335 "occur when simplifying "
12336 "X % (power of two)"),
12337 WARN_STRICT_OVERFLOW_MISC
);
12338 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
12339 fold_convert_loc (loc
, type
, arg0
),
12340 fold_convert_loc (loc
, type
, mask
));
12348 if (integer_all_onesp (arg0
))
12349 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12353 /* Optimize -1 >> x for arithmetic right shifts. */
12354 if (integer_all_onesp (arg0
) && !TYPE_UNSIGNED (type
)
12355 && tree_expr_nonnegative_p (arg1
))
12356 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12357 /* ... fall through ... */
12361 if (integer_zerop (arg1
))
12362 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12363 if (integer_zerop (arg0
))
12364 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12366 /* Prefer vector1 << scalar to vector1 << vector2
12367 if vector2 is uniform. */
12368 if (VECTOR_TYPE_P (TREE_TYPE (arg1
))
12369 && (tem
= uniform_vector_p (arg1
)) != NULL_TREE
)
12370 return fold_build2_loc (loc
, code
, type
, op0
, tem
);
12372 /* Since negative shift count is not well-defined,
12373 don't try to compute it in the compiler. */
12374 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
12377 prec
= element_precision (type
);
12379 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
12380 if (TREE_CODE (op0
) == code
&& tree_fits_uhwi_p (arg1
)
12381 && tree_to_uhwi (arg1
) < prec
12382 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
12383 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) < prec
)
12385 unsigned int low
= (tree_to_uhwi (TREE_OPERAND (arg0
, 1))
12386 + tree_to_uhwi (arg1
));
12388 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12389 being well defined. */
12392 if (code
== LROTATE_EXPR
|| code
== RROTATE_EXPR
)
12394 else if (TYPE_UNSIGNED (type
) || code
== LSHIFT_EXPR
)
12395 return omit_one_operand_loc (loc
, type
, build_zero_cst (type
),
12396 TREE_OPERAND (arg0
, 0));
12401 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12402 build_int_cst (TREE_TYPE (arg1
), low
));
12405 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12406 into x & ((unsigned)-1 >> c) for unsigned types. */
12407 if (((code
== LSHIFT_EXPR
&& TREE_CODE (arg0
) == RSHIFT_EXPR
)
12408 || (TYPE_UNSIGNED (type
)
12409 && code
== RSHIFT_EXPR
&& TREE_CODE (arg0
) == LSHIFT_EXPR
))
12410 && tree_fits_uhwi_p (arg1
)
12411 && tree_to_uhwi (arg1
) < prec
12412 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
12413 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) < prec
)
12415 HOST_WIDE_INT low0
= tree_to_uhwi (TREE_OPERAND (arg0
, 1));
12416 HOST_WIDE_INT low1
= tree_to_uhwi (arg1
);
12422 arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12424 lshift
= build_minus_one_cst (type
);
12425 lshift
= const_binop (code
, lshift
, arg1
);
12427 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, arg00
, lshift
);
12431 /* Rewrite an LROTATE_EXPR by a constant into an
12432 RROTATE_EXPR by a new constant. */
12433 if (code
== LROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
)
12435 tree tem
= build_int_cst (TREE_TYPE (arg1
), prec
);
12436 tem
= const_binop (MINUS_EXPR
, tem
, arg1
);
12437 return fold_build2_loc (loc
, RROTATE_EXPR
, type
, op0
, tem
);
12440 /* If we have a rotate of a bit operation with the rotate count and
12441 the second operand of the bit operation both constant,
12442 permute the two operations. */
12443 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12444 && (TREE_CODE (arg0
) == BIT_AND_EXPR
12445 || TREE_CODE (arg0
) == BIT_IOR_EXPR
12446 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12447 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12448 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
12449 fold_build2_loc (loc
, code
, type
,
12450 TREE_OPERAND (arg0
, 0), arg1
),
12451 fold_build2_loc (loc
, code
, type
,
12452 TREE_OPERAND (arg0
, 1), arg1
));
12454 /* Two consecutive rotates adding up to the some integer
12455 multiple of the precision of the type can be ignored. */
12456 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12457 && TREE_CODE (arg0
) == RROTATE_EXPR
12458 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
12459 && wi::umod_trunc (wi::add (arg1
, TREE_OPERAND (arg0
, 1)),
12461 return TREE_OPERAND (arg0
, 0);
12463 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12464 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12465 if the latter can be further optimized. */
12466 if ((code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
12467 && TREE_CODE (arg0
) == BIT_AND_EXPR
12468 && TREE_CODE (arg1
) == INTEGER_CST
12469 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12471 tree mask
= fold_build2_loc (loc
, code
, type
,
12472 fold_convert_loc (loc
, type
,
12473 TREE_OPERAND (arg0
, 1)),
12475 tree shift
= fold_build2_loc (loc
, code
, type
,
12476 fold_convert_loc (loc
, type
,
12477 TREE_OPERAND (arg0
, 0)),
12479 tem
= fold_binary_loc (loc
, BIT_AND_EXPR
, type
, shift
, mask
);
12487 if (operand_equal_p (arg0
, arg1
, 0))
12488 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12489 if (INTEGRAL_TYPE_P (type
)
12490 && operand_equal_p (arg1
, TYPE_MIN_VALUE (type
), OEP_ONLY_CONST
))
12491 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12492 tem
= fold_minmax (loc
, MIN_EXPR
, type
, arg0
, arg1
);
12498 if (operand_equal_p (arg0
, arg1
, 0))
12499 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12500 if (INTEGRAL_TYPE_P (type
)
12501 && TYPE_MAX_VALUE (type
)
12502 && operand_equal_p (arg1
, TYPE_MAX_VALUE (type
), OEP_ONLY_CONST
))
12503 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12504 tem
= fold_minmax (loc
, MAX_EXPR
, type
, arg0
, arg1
);
12509 case TRUTH_ANDIF_EXPR
:
12510 /* Note that the operands of this must be ints
12511 and their values must be 0 or 1.
12512 ("true" is a fixed value perhaps depending on the language.) */
12513 /* If first arg is constant zero, return it. */
12514 if (integer_zerop (arg0
))
12515 return fold_convert_loc (loc
, type
, arg0
);
12516 case TRUTH_AND_EXPR
:
12517 /* If either arg is constant true, drop it. */
12518 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12519 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12520 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
12521 /* Preserve sequence points. */
12522 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12523 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12524 /* If second arg is constant zero, result is zero, but first arg
12525 must be evaluated. */
12526 if (integer_zerop (arg1
))
12527 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12528 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12529 case will be handled here. */
12530 if (integer_zerop (arg0
))
12531 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12533 /* !X && X is always false. */
12534 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12535 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12536 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12537 /* X && !X is always false. */
12538 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12539 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12540 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12542 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12543 means A >= Y && A != MAX, but in this case we know that
12546 if (!TREE_SIDE_EFFECTS (arg0
)
12547 && !TREE_SIDE_EFFECTS (arg1
))
12549 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
12550 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
12551 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
12553 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
12554 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
12555 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
12558 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12564 case TRUTH_ORIF_EXPR
:
12565 /* Note that the operands of this must be ints
12566 and their values must be 0 or true.
12567 ("true" is a fixed value perhaps depending on the language.) */
12568 /* If first arg is constant true, return it. */
12569 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12570 return fold_convert_loc (loc
, type
, arg0
);
12571 case TRUTH_OR_EXPR
:
12572 /* If either arg is constant zero, drop it. */
12573 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
12574 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12575 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
12576 /* Preserve sequence points. */
12577 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12578 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12579 /* If second arg is constant true, result is true, but we must
12580 evaluate first arg. */
12581 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
12582 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12583 /* Likewise for first arg, but note this only occurs here for
12585 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12586 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12588 /* !X || X is always true. */
12589 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12590 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12591 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12592 /* X || !X is always true. */
12593 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12594 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12595 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12597 /* (X && !Y) || (!X && Y) is X ^ Y */
12598 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
12599 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
12601 tree a0
, a1
, l0
, l1
, n0
, n1
;
12603 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
12604 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
12606 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12607 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
12609 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
12610 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
12612 if ((operand_equal_p (n0
, a0
, 0)
12613 && operand_equal_p (n1
, a1
, 0))
12614 || (operand_equal_p (n0
, a1
, 0)
12615 && operand_equal_p (n1
, a0
, 0)))
12616 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
12619 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12625 case TRUTH_XOR_EXPR
:
12626 /* If the second arg is constant zero, drop it. */
12627 if (integer_zerop (arg1
))
12628 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12629 /* If the second arg is constant true, this is a logical inversion. */
12630 if (integer_onep (arg1
))
12632 tem
= invert_truthvalue_loc (loc
, arg0
);
12633 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
12635 /* Identical arguments cancel to zero. */
12636 if (operand_equal_p (arg0
, arg1
, 0))
12637 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12639 /* !X ^ X is always true. */
12640 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12641 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12642 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12644 /* X ^ !X is always true. */
12645 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12646 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12647 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12656 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
12657 if (tem
!= NULL_TREE
)
12660 /* bool_var != 0 becomes bool_var. */
12661 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12662 && code
== NE_EXPR
)
12663 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12665 /* bool_var == 1 becomes bool_var. */
12666 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12667 && code
== EQ_EXPR
)
12668 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12670 /* bool_var != 1 becomes !bool_var. */
12671 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12672 && code
== NE_EXPR
)
12673 return fold_convert_loc (loc
, type
,
12674 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12675 TREE_TYPE (arg0
), arg0
));
12677 /* bool_var == 0 becomes !bool_var. */
12678 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12679 && code
== EQ_EXPR
)
12680 return fold_convert_loc (loc
, type
,
12681 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12682 TREE_TYPE (arg0
), arg0
));
12684 /* !exp != 0 becomes !exp */
12685 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
12686 && code
== NE_EXPR
)
12687 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12689 /* If this is an equality comparison of the address of two non-weak,
12690 unaliased symbols neither of which are extern (since we do not
12691 have access to attributes for externs), then we know the result. */
12692 if (TREE_CODE (arg0
) == ADDR_EXPR
12693 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0
, 0))
12694 && ! DECL_WEAK (TREE_OPERAND (arg0
, 0))
12695 && ! lookup_attribute ("alias",
12696 DECL_ATTRIBUTES (TREE_OPERAND (arg0
, 0)))
12697 && ! DECL_EXTERNAL (TREE_OPERAND (arg0
, 0))
12698 && TREE_CODE (arg1
) == ADDR_EXPR
12699 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1
, 0))
12700 && ! DECL_WEAK (TREE_OPERAND (arg1
, 0))
12701 && ! lookup_attribute ("alias",
12702 DECL_ATTRIBUTES (TREE_OPERAND (arg1
, 0)))
12703 && ! DECL_EXTERNAL (TREE_OPERAND (arg1
, 0)))
12705 /* We know that we're looking at the address of two
12706 non-weak, unaliased, static _DECL nodes.
12708 It is both wasteful and incorrect to call operand_equal_p
12709 to compare the two ADDR_EXPR nodes. It is wasteful in that
12710 all we need to do is test pointer equality for the arguments
12711 to the two ADDR_EXPR nodes. It is incorrect to use
12712 operand_equal_p as that function is NOT equivalent to a
12713 C equality test. It can in fact return false for two
12714 objects which would test as equal using the C equality
12716 bool equal
= TREE_OPERAND (arg0
, 0) == TREE_OPERAND (arg1
, 0);
12717 return constant_boolean_node (equal
12718 ? code
== EQ_EXPR
: code
!= EQ_EXPR
,
12722 /* Similarly for a NEGATE_EXPR. */
12723 if (TREE_CODE (arg0
) == NEGATE_EXPR
12724 && TREE_CODE (arg1
) == INTEGER_CST
12725 && 0 != (tem
= negate_expr (fold_convert_loc (loc
, TREE_TYPE (arg0
),
12727 && TREE_CODE (tem
) == INTEGER_CST
12728 && !TREE_OVERFLOW (tem
))
12729 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
12731 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12732 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12733 && TREE_CODE (arg1
) == INTEGER_CST
12734 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12735 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12736 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg0
),
12737 fold_convert_loc (loc
,
12740 TREE_OPERAND (arg0
, 1)));
12742 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12743 if ((TREE_CODE (arg0
) == PLUS_EXPR
12744 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
12745 || TREE_CODE (arg0
) == MINUS_EXPR
)
12746 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12749 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
12750 || POINTER_TYPE_P (TREE_TYPE (arg0
))))
12752 tree val
= TREE_OPERAND (arg0
, 1);
12753 return omit_two_operands_loc (loc
, type
,
12754 fold_build2_loc (loc
, code
, type
,
12756 build_int_cst (TREE_TYPE (val
),
12758 TREE_OPERAND (arg0
, 0), arg1
);
12761 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12762 if (TREE_CODE (arg0
) == MINUS_EXPR
12763 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == INTEGER_CST
12764 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12767 && wi::extract_uhwi (TREE_OPERAND (arg0
, 0), 0, 1) == 1)
12769 return omit_two_operands_loc (loc
, type
,
12771 ? boolean_true_node
: boolean_false_node
,
12772 TREE_OPERAND (arg0
, 1), arg1
);
12775 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12776 if (TREE_CODE (arg0
) == ABS_EXPR
12777 && (integer_zerop (arg1
) || real_zerop (arg1
)))
12778 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), arg1
);
12780 /* If this is an EQ or NE comparison with zero and ARG0 is
12781 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12782 two operations, but the latter can be done in one less insn
12783 on machines that have only two-operand insns or on which a
12784 constant cannot be the first operand. */
12785 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12786 && integer_zerop (arg1
))
12788 tree arg00
= TREE_OPERAND (arg0
, 0);
12789 tree arg01
= TREE_OPERAND (arg0
, 1);
12790 if (TREE_CODE (arg00
) == LSHIFT_EXPR
12791 && integer_onep (TREE_OPERAND (arg00
, 0)))
12793 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
12794 arg01
, TREE_OPERAND (arg00
, 1));
12795 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12796 build_int_cst (TREE_TYPE (arg0
), 1));
12797 return fold_build2_loc (loc
, code
, type
,
12798 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12801 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
12802 && integer_onep (TREE_OPERAND (arg01
, 0)))
12804 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
12805 arg00
, TREE_OPERAND (arg01
, 1));
12806 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12807 build_int_cst (TREE_TYPE (arg0
), 1));
12808 return fold_build2_loc (loc
, code
, type
,
12809 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12814 /* If this is an NE or EQ comparison of zero against the result of a
12815 signed MOD operation whose second operand is a power of 2, make
12816 the MOD operation unsigned since it is simpler and equivalent. */
12817 if (integer_zerop (arg1
)
12818 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
12819 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
12820 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
12821 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
12822 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
12823 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
12825 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
12826 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
12827 fold_convert_loc (loc
, newtype
,
12828 TREE_OPERAND (arg0
, 0)),
12829 fold_convert_loc (loc
, newtype
,
12830 TREE_OPERAND (arg0
, 1)));
12832 return fold_build2_loc (loc
, code
, type
, newmod
,
12833 fold_convert_loc (loc
, newtype
, arg1
));
12836 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12837 C1 is a valid shift constant, and C2 is a power of two, i.e.
12839 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12840 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
12841 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
12843 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12844 && integer_zerop (arg1
))
12846 tree itype
= TREE_TYPE (arg0
);
12847 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
12848 prec
= TYPE_PRECISION (itype
);
12850 /* Check for a valid shift count. */
12851 if (wi::ltu_p (arg001
, prec
))
12853 tree arg01
= TREE_OPERAND (arg0
, 1);
12854 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
12855 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
12856 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12857 can be rewritten as (X & (C2 << C1)) != 0. */
12858 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
12860 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
12861 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
12862 return fold_build2_loc (loc
, code
, type
, tem
,
12863 fold_convert_loc (loc
, itype
, arg1
));
12865 /* Otherwise, for signed (arithmetic) shifts,
12866 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12867 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
12868 else if (!TYPE_UNSIGNED (itype
))
12869 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
12870 arg000
, build_int_cst (itype
, 0));
12871 /* Otherwise, of unsigned (logical) shifts,
12872 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12873 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
12875 return omit_one_operand_loc (loc
, type
,
12876 code
== EQ_EXPR
? integer_one_node
12877 : integer_zero_node
,
12882 /* If we have (A & C) == C where C is a power of 2, convert this into
12883 (A & C) != 0. Similarly for NE_EXPR. */
12884 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12885 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12886 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
12887 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
12888 arg0
, fold_convert_loc (loc
, TREE_TYPE (arg0
),
12889 integer_zero_node
));
12891 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12892 bit, then fold the expression into A < 0 or A >= 0. */
12893 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
, type
);
12897 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12898 Similarly for NE_EXPR. */
12899 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12900 && TREE_CODE (arg1
) == INTEGER_CST
12901 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12903 tree notc
= fold_build1_loc (loc
, BIT_NOT_EXPR
,
12904 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
12905 TREE_OPERAND (arg0
, 1));
12907 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12908 fold_convert_loc (loc
, TREE_TYPE (arg0
), arg1
),
12910 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
12911 if (integer_nonzerop (dandnotc
))
12912 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
12915 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12916 Similarly for NE_EXPR. */
12917 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
12918 && TREE_CODE (arg1
) == INTEGER_CST
12919 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12921 tree notd
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
), arg1
);
12923 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12924 TREE_OPERAND (arg0
, 1),
12925 fold_convert_loc (loc
, TREE_TYPE (arg0
), notd
));
12926 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
12927 if (integer_nonzerop (candnotd
))
12928 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
12931 /* If this is a comparison of a field, we may be able to simplify it. */
12932 if ((TREE_CODE (arg0
) == COMPONENT_REF
12933 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
12934 /* Handle the constant case even without -O
12935 to make sure the warnings are given. */
12936 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
12938 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
12943 /* Optimize comparisons of strlen vs zero to a compare of the
12944 first character of the string vs zero. To wit,
12945 strlen(ptr) == 0 => *ptr == 0
12946 strlen(ptr) != 0 => *ptr != 0
12947 Other cases should reduce to one of these two (or a constant)
12948 due to the return value of strlen being unsigned. */
12949 if (TREE_CODE (arg0
) == CALL_EXPR
12950 && integer_zerop (arg1
))
12952 tree fndecl
= get_callee_fndecl (arg0
);
12955 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
12956 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
12957 && call_expr_nargs (arg0
) == 1
12958 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
12960 tree iref
= build_fold_indirect_ref_loc (loc
,
12961 CALL_EXPR_ARG (arg0
, 0));
12962 return fold_build2_loc (loc
, code
, type
, iref
,
12963 build_int_cst (TREE_TYPE (iref
), 0));
12967 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12968 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12969 if (TREE_CODE (arg0
) == RSHIFT_EXPR
12970 && integer_zerop (arg1
)
12971 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12973 tree arg00
= TREE_OPERAND (arg0
, 0);
12974 tree arg01
= TREE_OPERAND (arg0
, 1);
12975 tree itype
= TREE_TYPE (arg00
);
12976 if (wi::eq_p (arg01
, TYPE_PRECISION (itype
) - 1))
12978 if (TYPE_UNSIGNED (itype
))
12980 itype
= signed_type_for (itype
);
12981 arg00
= fold_convert_loc (loc
, itype
, arg00
);
12983 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
12984 type
, arg00
, build_zero_cst (itype
));
12988 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
12989 if (integer_zerop (arg1
)
12990 && TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12991 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12992 TREE_OPERAND (arg0
, 1));
12994 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
12995 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12996 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
12997 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12998 build_zero_cst (TREE_TYPE (arg0
)));
12999 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
13000 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13001 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13002 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
13003 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 1),
13004 build_zero_cst (TREE_TYPE (arg0
)));
13006 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
13007 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13008 && TREE_CODE (arg1
) == INTEGER_CST
13009 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
13010 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
13011 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg1
),
13012 TREE_OPERAND (arg0
, 1), arg1
));
13014 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
13015 (X & C) == 0 when C is a single bit. */
13016 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13017 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
13018 && integer_zerop (arg1
)
13019 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
13021 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
13022 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
13023 TREE_OPERAND (arg0
, 1));
13024 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
13026 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13030 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
13031 constant C is a power of two, i.e. a single bit. */
13032 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13033 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
13034 && integer_zerop (arg1
)
13035 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13036 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
13037 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
13039 tree arg00
= TREE_OPERAND (arg0
, 0);
13040 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13041 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
13044 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
13045 when is C is a power of two, i.e. a single bit. */
13046 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13047 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
13048 && integer_zerop (arg1
)
13049 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13050 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
13051 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
13053 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
13054 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
13055 arg000
, TREE_OPERAND (arg0
, 1));
13056 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13057 tem
, build_int_cst (TREE_TYPE (tem
), 0));
13060 if (integer_zerop (arg1
)
13061 && tree_expr_nonzero_p (arg0
))
13063 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
13064 return omit_one_operand_loc (loc
, type
, res
, arg0
);
13067 /* Fold -X op -Y as X op Y, where op is eq/ne. */
13068 if (TREE_CODE (arg0
) == NEGATE_EXPR
13069 && TREE_CODE (arg1
) == NEGATE_EXPR
)
13070 return fold_build2_loc (loc
, code
, type
,
13071 TREE_OPERAND (arg0
, 0),
13072 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13073 TREE_OPERAND (arg1
, 0)));
13075 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
13076 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13077 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
13079 tree arg00
= TREE_OPERAND (arg0
, 0);
13080 tree arg01
= TREE_OPERAND (arg0
, 1);
13081 tree arg10
= TREE_OPERAND (arg1
, 0);
13082 tree arg11
= TREE_OPERAND (arg1
, 1);
13083 tree itype
= TREE_TYPE (arg0
);
13085 if (operand_equal_p (arg01
, arg11
, 0))
13086 return fold_build2_loc (loc
, code
, type
,
13087 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13088 fold_build2_loc (loc
,
13089 BIT_XOR_EXPR
, itype
,
13092 build_zero_cst (itype
));
13094 if (operand_equal_p (arg01
, arg10
, 0))
13095 return fold_build2_loc (loc
, code
, type
,
13096 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13097 fold_build2_loc (loc
,
13098 BIT_XOR_EXPR
, itype
,
13101 build_zero_cst (itype
));
13103 if (operand_equal_p (arg00
, arg11
, 0))
13104 return fold_build2_loc (loc
, code
, type
,
13105 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13106 fold_build2_loc (loc
,
13107 BIT_XOR_EXPR
, itype
,
13110 build_zero_cst (itype
));
13112 if (operand_equal_p (arg00
, arg10
, 0))
13113 return fold_build2_loc (loc
, code
, type
,
13114 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13115 fold_build2_loc (loc
,
13116 BIT_XOR_EXPR
, itype
,
13119 build_zero_cst (itype
));
13122 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13123 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
13125 tree arg00
= TREE_OPERAND (arg0
, 0);
13126 tree arg01
= TREE_OPERAND (arg0
, 1);
13127 tree arg10
= TREE_OPERAND (arg1
, 0);
13128 tree arg11
= TREE_OPERAND (arg1
, 1);
13129 tree itype
= TREE_TYPE (arg0
);
13131 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
13132 operand_equal_p guarantees no side-effects so we don't need
13133 to use omit_one_operand on Z. */
13134 if (operand_equal_p (arg01
, arg11
, 0))
13135 return fold_build2_loc (loc
, code
, type
, arg00
,
13136 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13138 if (operand_equal_p (arg01
, arg10
, 0))
13139 return fold_build2_loc (loc
, code
, type
, arg00
,
13140 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13142 if (operand_equal_p (arg00
, arg11
, 0))
13143 return fold_build2_loc (loc
, code
, type
, arg01
,
13144 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13146 if (operand_equal_p (arg00
, arg10
, 0))
13147 return fold_build2_loc (loc
, code
, type
, arg01
,
13148 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13151 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
13152 if (TREE_CODE (arg01
) == INTEGER_CST
13153 && TREE_CODE (arg11
) == INTEGER_CST
)
13155 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
13156 fold_convert_loc (loc
, itype
, arg11
));
13157 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
13158 return fold_build2_loc (loc
, code
, type
, tem
,
13159 fold_convert_loc (loc
, itype
, arg10
));
13163 /* Attempt to simplify equality/inequality comparisons of complex
13164 values. Only lower the comparison if the result is known or
13165 can be simplified to a single scalar comparison. */
13166 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
13167 || TREE_CODE (arg0
) == COMPLEX_CST
)
13168 && (TREE_CODE (arg1
) == COMPLEX_EXPR
13169 || TREE_CODE (arg1
) == COMPLEX_CST
))
13171 tree real0
, imag0
, real1
, imag1
;
13174 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
13176 real0
= TREE_OPERAND (arg0
, 0);
13177 imag0
= TREE_OPERAND (arg0
, 1);
13181 real0
= TREE_REALPART (arg0
);
13182 imag0
= TREE_IMAGPART (arg0
);
13185 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
13187 real1
= TREE_OPERAND (arg1
, 0);
13188 imag1
= TREE_OPERAND (arg1
, 1);
13192 real1
= TREE_REALPART (arg1
);
13193 imag1
= TREE_IMAGPART (arg1
);
13196 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
13197 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
13199 if (integer_zerop (rcond
))
13201 if (code
== EQ_EXPR
)
13202 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13204 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
13208 if (code
== NE_EXPR
)
13209 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13211 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
13215 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
13216 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
13218 if (integer_zerop (icond
))
13220 if (code
== EQ_EXPR
)
13221 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13223 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
13227 if (code
== NE_EXPR
)
13228 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13230 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
13241 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
13242 if (tem
!= NULL_TREE
)
13245 /* Transform comparisons of the form X +- C CMP X. */
13246 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
13247 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13248 && ((TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
13249 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
))))
13250 || (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
13251 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))))
13253 tree arg01
= TREE_OPERAND (arg0
, 1);
13254 enum tree_code code0
= TREE_CODE (arg0
);
13257 if (TREE_CODE (arg01
) == REAL_CST
)
13258 is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
13260 is_positive
= tree_int_cst_sgn (arg01
);
13262 /* (X - c) > X becomes false. */
13263 if (code
== GT_EXPR
13264 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13265 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13267 if (TREE_CODE (arg01
) == INTEGER_CST
13268 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13269 fold_overflow_warning (("assuming signed overflow does not "
13270 "occur when assuming that (X - c) > X "
13271 "is always false"),
13272 WARN_STRICT_OVERFLOW_ALL
);
13273 return constant_boolean_node (0, type
);
13276 /* Likewise (X + c) < X becomes false. */
13277 if (code
== LT_EXPR
13278 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13279 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13281 if (TREE_CODE (arg01
) == INTEGER_CST
13282 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13283 fold_overflow_warning (("assuming signed overflow does not "
13284 "occur when assuming that "
13285 "(X + c) < X is always false"),
13286 WARN_STRICT_OVERFLOW_ALL
);
13287 return constant_boolean_node (0, type
);
13290 /* Convert (X - c) <= X to true. */
13291 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13293 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13294 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13296 if (TREE_CODE (arg01
) == INTEGER_CST
13297 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13298 fold_overflow_warning (("assuming signed overflow does not "
13299 "occur when assuming that "
13300 "(X - c) <= X is always true"),
13301 WARN_STRICT_OVERFLOW_ALL
);
13302 return constant_boolean_node (1, type
);
13305 /* Convert (X + c) >= X to true. */
13306 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13308 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13309 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13311 if (TREE_CODE (arg01
) == INTEGER_CST
13312 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13313 fold_overflow_warning (("assuming signed overflow does not "
13314 "occur when assuming that "
13315 "(X + c) >= X is always true"),
13316 WARN_STRICT_OVERFLOW_ALL
);
13317 return constant_boolean_node (1, type
);
13320 if (TREE_CODE (arg01
) == INTEGER_CST
)
13322 /* Convert X + c > X and X - c < X to true for integers. */
13323 if (code
== GT_EXPR
13324 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13325 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13327 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13328 fold_overflow_warning (("assuming signed overflow does "
13329 "not occur when assuming that "
13330 "(X + c) > X is always true"),
13331 WARN_STRICT_OVERFLOW_ALL
);
13332 return constant_boolean_node (1, type
);
13335 if (code
== LT_EXPR
13336 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13337 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13339 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13340 fold_overflow_warning (("assuming signed overflow does "
13341 "not occur when assuming that "
13342 "(X - c) < X is always true"),
13343 WARN_STRICT_OVERFLOW_ALL
);
13344 return constant_boolean_node (1, type
);
13347 /* Convert X + c <= X and X - c >= X to false for integers. */
13348 if (code
== LE_EXPR
13349 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13350 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13352 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13353 fold_overflow_warning (("assuming signed overflow does "
13354 "not occur when assuming that "
13355 "(X + c) <= X is always false"),
13356 WARN_STRICT_OVERFLOW_ALL
);
13357 return constant_boolean_node (0, type
);
13360 if (code
== GE_EXPR
13361 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13362 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13364 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13365 fold_overflow_warning (("assuming signed overflow does "
13366 "not occur when assuming that "
13367 "(X - c) >= X is always false"),
13368 WARN_STRICT_OVERFLOW_ALL
);
13369 return constant_boolean_node (0, type
);
13374 /* Comparisons with the highest or lowest possible integer of
13375 the specified precision will have known values. */
13377 tree arg1_type
= TREE_TYPE (arg1
);
13378 unsigned int prec
= TYPE_PRECISION (arg1_type
);
13380 if (TREE_CODE (arg1
) == INTEGER_CST
13381 && (INTEGRAL_TYPE_P (arg1_type
) || POINTER_TYPE_P (arg1_type
)))
13383 wide_int max
= wi::max_value (arg1_type
);
13384 wide_int signed_max
= wi::max_value (prec
, SIGNED
);
13385 wide_int min
= wi::min_value (arg1_type
);
13387 if (wi::eq_p (arg1
, max
))
13391 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13394 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13397 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13400 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13402 /* The GE_EXPR and LT_EXPR cases above are not normally
13403 reached because of previous transformations. */
13408 else if (wi::eq_p (arg1
, max
- 1))
13412 arg1
= const_binop (PLUS_EXPR
, arg1
,
13413 build_int_cst (TREE_TYPE (arg1
), 1));
13414 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13415 fold_convert_loc (loc
,
13416 TREE_TYPE (arg1
), arg0
),
13419 arg1
= const_binop (PLUS_EXPR
, arg1
,
13420 build_int_cst (TREE_TYPE (arg1
), 1));
13421 return fold_build2_loc (loc
, NE_EXPR
, type
,
13422 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13428 else if (wi::eq_p (arg1
, min
))
13432 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13435 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13438 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13441 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13446 else if (wi::eq_p (arg1
, min
+ 1))
13450 arg1
= const_binop (MINUS_EXPR
, arg1
,
13451 build_int_cst (TREE_TYPE (arg1
), 1));
13452 return fold_build2_loc (loc
, NE_EXPR
, type
,
13453 fold_convert_loc (loc
,
13454 TREE_TYPE (arg1
), arg0
),
13457 arg1
= const_binop (MINUS_EXPR
, arg1
,
13458 build_int_cst (TREE_TYPE (arg1
), 1));
13459 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13460 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13467 else if (wi::eq_p (arg1
, signed_max
)
13468 && TYPE_UNSIGNED (arg1_type
)
13469 /* We will flip the signedness of the comparison operator
13470 associated with the mode of arg1, so the sign bit is
13471 specified by this mode. Check that arg1 is the signed
13472 max associated with this sign bit. */
13473 && prec
== GET_MODE_PRECISION (TYPE_MODE (arg1_type
))
13474 /* signed_type does not work on pointer types. */
13475 && INTEGRAL_TYPE_P (arg1_type
))
13477 /* The following case also applies to X < signed_max+1
13478 and X >= signed_max+1 because previous transformations. */
13479 if (code
== LE_EXPR
|| code
== GT_EXPR
)
13481 tree st
= signed_type_for (arg1_type
);
13482 return fold_build2_loc (loc
,
13483 code
== LE_EXPR
? GE_EXPR
: LT_EXPR
,
13484 type
, fold_convert_loc (loc
, st
, arg0
),
13485 build_int_cst (st
, 0));
13491 /* If we are comparing an ABS_EXPR with a constant, we can
13492 convert all the cases into explicit comparisons, but they may
13493 well not be faster than doing the ABS and one comparison.
13494 But ABS (X) <= C is a range comparison, which becomes a subtraction
13495 and a comparison, and is probably faster. */
13496 if (code
== LE_EXPR
13497 && TREE_CODE (arg1
) == INTEGER_CST
13498 && TREE_CODE (arg0
) == ABS_EXPR
13499 && ! TREE_SIDE_EFFECTS (arg0
)
13500 && (0 != (tem
= negate_expr (arg1
)))
13501 && TREE_CODE (tem
) == INTEGER_CST
13502 && !TREE_OVERFLOW (tem
))
13503 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
13504 build2 (GE_EXPR
, type
,
13505 TREE_OPERAND (arg0
, 0), tem
),
13506 build2 (LE_EXPR
, type
,
13507 TREE_OPERAND (arg0
, 0), arg1
));
13509 /* Convert ABS_EXPR<x> >= 0 to true. */
13510 strict_overflow_p
= false;
13511 if (code
== GE_EXPR
13512 && (integer_zerop (arg1
)
13513 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
13514 && real_zerop (arg1
)))
13515 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13517 if (strict_overflow_p
)
13518 fold_overflow_warning (("assuming signed overflow does not occur "
13519 "when simplifying comparison of "
13520 "absolute value and zero"),
13521 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13522 return omit_one_operand_loc (loc
, type
,
13523 constant_boolean_node (true, type
),
13527 /* Convert ABS_EXPR<x> < 0 to false. */
13528 strict_overflow_p
= false;
13529 if (code
== LT_EXPR
13530 && (integer_zerop (arg1
) || real_zerop (arg1
))
13531 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13533 if (strict_overflow_p
)
13534 fold_overflow_warning (("assuming signed overflow does not occur "
13535 "when simplifying comparison of "
13536 "absolute value and zero"),
13537 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13538 return omit_one_operand_loc (loc
, type
,
13539 constant_boolean_node (false, type
),
13543 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13544 and similarly for >= into !=. */
13545 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13546 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13547 && TREE_CODE (arg1
) == LSHIFT_EXPR
13548 && integer_onep (TREE_OPERAND (arg1
, 0)))
13549 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13550 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13551 TREE_OPERAND (arg1
, 1)),
13552 build_zero_cst (TREE_TYPE (arg0
)));
13554 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
13555 otherwise Y might be >= # of bits in X's type and thus e.g.
13556 (unsigned char) (1 << Y) for Y 15 might be 0.
13557 If the cast is widening, then 1 << Y should have unsigned type,
13558 otherwise if Y is number of bits in the signed shift type minus 1,
13559 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
13560 31 might be 0xffffffff80000000. */
13561 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13562 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13563 && CONVERT_EXPR_P (arg1
)
13564 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
13565 && (TYPE_PRECISION (TREE_TYPE (arg1
))
13566 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
13567 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
13568 || (TYPE_PRECISION (TREE_TYPE (arg1
))
13569 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
13570 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
13572 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13573 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
13574 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13575 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
13576 build_zero_cst (TREE_TYPE (arg0
)));
13581 case UNORDERED_EXPR
:
13589 if (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
13591 t1
= fold_relational_const (code
, type
, arg0
, arg1
);
13592 if (t1
!= NULL_TREE
)
13596 /* If the first operand is NaN, the result is constant. */
13597 if (TREE_CODE (arg0
) == REAL_CST
13598 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0
))
13599 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13601 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13602 ? integer_zero_node
13603 : integer_one_node
;
13604 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
13607 /* If the second operand is NaN, the result is constant. */
13608 if (TREE_CODE (arg1
) == REAL_CST
13609 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
13610 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13612 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13613 ? integer_zero_node
13614 : integer_one_node
;
13615 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
13618 /* Simplify unordered comparison of something with itself. */
13619 if ((code
== UNLE_EXPR
|| code
== UNGE_EXPR
|| code
== UNEQ_EXPR
)
13620 && operand_equal_p (arg0
, arg1
, 0))
13621 return constant_boolean_node (1, type
);
13623 if (code
== LTGT_EXPR
13624 && !flag_trapping_math
13625 && operand_equal_p (arg0
, arg1
, 0))
13626 return constant_boolean_node (0, type
);
13628 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13630 tree targ0
= strip_float_extensions (arg0
);
13631 tree targ1
= strip_float_extensions (arg1
);
13632 tree newtype
= TREE_TYPE (targ0
);
13634 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
13635 newtype
= TREE_TYPE (targ1
);
13637 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
13638 return fold_build2_loc (loc
, code
, type
,
13639 fold_convert_loc (loc
, newtype
, targ0
),
13640 fold_convert_loc (loc
, newtype
, targ1
));
13645 case COMPOUND_EXPR
:
13646 /* When pedantic, a compound expression can be neither an lvalue
13647 nor an integer constant expression. */
13648 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
13650 /* Don't let (0, 0) be null pointer constant. */
13651 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
13652 : fold_convert_loc (loc
, type
, arg1
);
13653 return pedantic_non_lvalue_loc (loc
, tem
);
13656 if ((TREE_CODE (arg0
) == REAL_CST
13657 && TREE_CODE (arg1
) == REAL_CST
)
13658 || (TREE_CODE (arg0
) == INTEGER_CST
13659 && TREE_CODE (arg1
) == INTEGER_CST
))
13660 return build_complex (type
, arg0
, arg1
);
13661 if (TREE_CODE (arg0
) == REALPART_EXPR
13662 && TREE_CODE (arg1
) == IMAGPART_EXPR
13663 && TREE_TYPE (TREE_OPERAND (arg0
, 0)) == type
13664 && operand_equal_p (TREE_OPERAND (arg0
, 0),
13665 TREE_OPERAND (arg1
, 0), 0))
13666 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 0),
13667 TREE_OPERAND (arg1
, 0));
13671 /* An ASSERT_EXPR should never be passed to fold_binary. */
13672 gcc_unreachable ();
13674 case VEC_PACK_TRUNC_EXPR
:
13675 case VEC_PACK_FIX_TRUNC_EXPR
:
13677 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
13680 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
/ 2
13681 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
/ 2);
13682 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13685 elts
= XALLOCAVEC (tree
, nelts
);
13686 if (!vec_cst_ctor_to_array (arg0
, elts
)
13687 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
/ 2))
13690 for (i
= 0; i
< nelts
; i
++)
13692 elts
[i
] = fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
13693 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
13694 TREE_TYPE (type
), elts
[i
]);
13695 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
13699 return build_vector (type
, elts
);
13702 case VEC_WIDEN_MULT_LO_EXPR
:
13703 case VEC_WIDEN_MULT_HI_EXPR
:
13704 case VEC_WIDEN_MULT_EVEN_EXPR
:
13705 case VEC_WIDEN_MULT_ODD_EXPR
:
13707 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
13708 unsigned int out
, ofs
, scale
;
13711 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2
13712 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
* 2);
13713 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13716 elts
= XALLOCAVEC (tree
, nelts
* 4);
13717 if (!vec_cst_ctor_to_array (arg0
, elts
)
13718 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
* 2))
13721 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
13722 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? nelts
: 0;
13723 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
13724 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : nelts
;
13725 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
13726 scale
= 1, ofs
= 0;
13727 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
13728 scale
= 1, ofs
= 1;
13730 for (out
= 0; out
< nelts
; out
++)
13732 unsigned int in1
= (out
<< scale
) + ofs
;
13733 unsigned int in2
= in1
+ nelts
* 2;
13736 t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in1
]);
13737 t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in2
]);
13739 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
13741 elts
[out
] = const_binop (MULT_EXPR
, t1
, t2
);
13742 if (elts
[out
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[out
]))
13746 return build_vector (type
, elts
);
13751 } /* switch (code) */
13754 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
13755 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
13759 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
13761 switch (TREE_CODE (*tp
))
13767 *walk_subtrees
= 0;
13769 /* ... fall through ... */
13776 /* Return whether the sub-tree ST contains a label which is accessible from
13777 outside the sub-tree. */
13780 contains_label_p (tree st
)
13783 (walk_tree_without_duplicates (&st
, contains_label_1
, NULL
) != NULL_TREE
);
13786 /* Fold a ternary expression of code CODE and type TYPE with operands
13787 OP0, OP1, and OP2. Return the folded expression if folding is
13788 successful. Otherwise, return NULL_TREE. */
13791 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
13792 tree op0
, tree op1
, tree op2
)
13795 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
13796 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
13798 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
13799 && TREE_CODE_LENGTH (code
) == 3);
13801 /* If this is a commutative operation, and OP0 is a constant, move it
13802 to OP1 to reduce the number of tests below. */
13803 if (commutative_ternary_tree_code (code
)
13804 && tree_swap_operands_p (op0
, op1
, true))
13805 return fold_build3_loc (loc
, code
, type
, op1
, op0
, op2
);
13807 /* Strip any conversions that don't change the mode. This is safe
13808 for every expression, except for a comparison expression because
13809 its signedness is derived from its operands. So, in the latter
13810 case, only strip conversions that don't change the signedness.
13812 Note that this is done as an internal manipulation within the
13813 constant folder, in order to find the simplest representation of
13814 the arguments so that their form can be studied. In any cases,
13815 the appropriate type conversions should be put back in the tree
13816 that will get out of the constant folder. */
13837 case COMPONENT_REF
:
13838 if (TREE_CODE (arg0
) == CONSTRUCTOR
13839 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
13841 unsigned HOST_WIDE_INT idx
;
13843 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
13850 case VEC_COND_EXPR
:
13851 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13852 so all simple results must be passed through pedantic_non_lvalue. */
13853 if (TREE_CODE (arg0
) == INTEGER_CST
)
13855 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
13856 tem
= integer_zerop (arg0
) ? op2
: op1
;
13857 /* Only optimize constant conditions when the selected branch
13858 has the same type as the COND_EXPR. This avoids optimizing
13859 away "c ? x : throw", where the throw has a void type.
13860 Avoid throwing away that operand which contains label. */
13861 if ((!TREE_SIDE_EFFECTS (unused_op
)
13862 || !contains_label_p (unused_op
))
13863 && (! VOID_TYPE_P (TREE_TYPE (tem
))
13864 || VOID_TYPE_P (type
)))
13865 return pedantic_non_lvalue_loc (loc
, tem
);
13868 else if (TREE_CODE (arg0
) == VECTOR_CST
)
13870 if (integer_all_onesp (arg0
))
13871 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg2
);
13872 if (integer_zerop (arg0
))
13873 return pedantic_omit_one_operand_loc (loc
, type
, arg2
, arg1
);
13875 if ((TREE_CODE (arg1
) == VECTOR_CST
13876 || TREE_CODE (arg1
) == CONSTRUCTOR
)
13877 && (TREE_CODE (arg2
) == VECTOR_CST
13878 || TREE_CODE (arg2
) == CONSTRUCTOR
))
13880 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
13881 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
13882 gcc_assert (nelts
== VECTOR_CST_NELTS (arg0
));
13883 for (i
= 0; i
< nelts
; i
++)
13885 tree val
= VECTOR_CST_ELT (arg0
, i
);
13886 if (integer_all_onesp (val
))
13888 else if (integer_zerop (val
))
13889 sel
[i
] = nelts
+ i
;
13890 else /* Currently unreachable. */
13893 tree t
= fold_vec_perm (type
, arg1
, arg2
, sel
);
13894 if (t
!= NULL_TREE
)
13899 if (operand_equal_p (arg1
, op2
, 0))
13900 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg0
);
13902 /* If we have A op B ? A : C, we may be able to convert this to a
13903 simpler expression, depending on the operation and the values
13904 of B and C. Signed zeros prevent all of these transformations,
13905 for reasons given above each one.
13907 Also try swapping the arguments and inverting the conditional. */
13908 if (COMPARISON_CLASS_P (arg0
)
13909 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
13910 arg1
, TREE_OPERAND (arg0
, 1))
13911 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1
))))
13913 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
13918 if (COMPARISON_CLASS_P (arg0
)
13919 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
13921 TREE_OPERAND (arg0
, 1))
13922 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2
))))
13924 location_t loc0
= expr_location_or (arg0
, loc
);
13925 tem
= fold_invert_truthvalue (loc0
, arg0
);
13926 if (tem
&& COMPARISON_CLASS_P (tem
))
13928 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
13934 /* If the second operand is simpler than the third, swap them
13935 since that produces better jump optimization results. */
13936 if (truth_value_p (TREE_CODE (arg0
))
13937 && tree_swap_operands_p (op1
, op2
, false))
13939 location_t loc0
= expr_location_or (arg0
, loc
);
13940 /* See if this can be inverted. If it can't, possibly because
13941 it was a floating-point inequality comparison, don't do
13943 tem
= fold_invert_truthvalue (loc0
, arg0
);
13945 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
13948 /* Convert A ? 1 : 0 to simply A. */
13949 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
13950 : (integer_onep (op1
)
13951 && !VECTOR_TYPE_P (type
)))
13952 && integer_zerop (op2
)
13953 /* If we try to convert OP0 to our type, the
13954 call to fold will try to move the conversion inside
13955 a COND, which will recurse. In that case, the COND_EXPR
13956 is probably the best choice, so leave it alone. */
13957 && type
== TREE_TYPE (arg0
))
13958 return pedantic_non_lvalue_loc (loc
, arg0
);
13960 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13961 over COND_EXPR in cases such as floating point comparisons. */
13962 if (integer_zerop (op1
)
13963 && (code
== VEC_COND_EXPR
? integer_all_onesp (op2
)
13964 : (integer_onep (op2
)
13965 && !VECTOR_TYPE_P (type
)))
13966 && truth_value_p (TREE_CODE (arg0
)))
13967 return pedantic_non_lvalue_loc (loc
,
13968 fold_convert_loc (loc
, type
,
13969 invert_truthvalue_loc (loc
,
13972 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13973 if (TREE_CODE (arg0
) == LT_EXPR
13974 && integer_zerop (TREE_OPERAND (arg0
, 1))
13975 && integer_zerop (op2
)
13976 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
13978 /* sign_bit_p looks through both zero and sign extensions,
13979 but for this optimization only sign extensions are
13981 tree tem2
= TREE_OPERAND (arg0
, 0);
13982 while (tem
!= tem2
)
13984 if (TREE_CODE (tem2
) != NOP_EXPR
13985 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
13990 tem2
= TREE_OPERAND (tem2
, 0);
13992 /* sign_bit_p only checks ARG1 bits within A's precision.
13993 If <sign bit of A> has wider type than A, bits outside
13994 of A's precision in <sign bit of A> need to be checked.
13995 If they are all 0, this optimization needs to be done
13996 in unsigned A's type, if they are all 1 in signed A's type,
13997 otherwise this can't be done. */
13999 && TYPE_PRECISION (TREE_TYPE (tem
))
14000 < TYPE_PRECISION (TREE_TYPE (arg1
))
14001 && TYPE_PRECISION (TREE_TYPE (tem
))
14002 < TYPE_PRECISION (type
))
14004 int inner_width
, outer_width
;
14007 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
14008 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
14009 if (outer_width
> TYPE_PRECISION (type
))
14010 outer_width
= TYPE_PRECISION (type
);
14012 wide_int mask
= wi::shifted_mask
14013 (inner_width
, outer_width
- inner_width
, false,
14014 TYPE_PRECISION (TREE_TYPE (arg1
)));
14016 wide_int common
= mask
& arg1
;
14017 if (common
== mask
)
14019 tem_type
= signed_type_for (TREE_TYPE (tem
));
14020 tem
= fold_convert_loc (loc
, tem_type
, tem
);
14022 else if (common
== 0)
14024 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
14025 tem
= fold_convert_loc (loc
, tem_type
, tem
);
14033 fold_convert_loc (loc
, type
,
14034 fold_build2_loc (loc
, BIT_AND_EXPR
,
14035 TREE_TYPE (tem
), tem
,
14036 fold_convert_loc (loc
,
14041 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
14042 already handled above. */
14043 if (TREE_CODE (arg0
) == BIT_AND_EXPR
14044 && integer_onep (TREE_OPERAND (arg0
, 1))
14045 && integer_zerop (op2
)
14046 && integer_pow2p (arg1
))
14048 tree tem
= TREE_OPERAND (arg0
, 0);
14050 if (TREE_CODE (tem
) == RSHIFT_EXPR
14051 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
14052 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
) ==
14053 tree_to_uhwi (TREE_OPERAND (tem
, 1)))
14054 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
14055 TREE_OPERAND (tem
, 0), arg1
);
14058 /* A & N ? N : 0 is simply A & N if N is a power of two. This
14059 is probably obsolete because the first operand should be a
14060 truth value (that's why we have the two cases above), but let's
14061 leave it in until we can confirm this for all front-ends. */
14062 if (integer_zerop (op2
)
14063 && TREE_CODE (arg0
) == NE_EXPR
14064 && integer_zerop (TREE_OPERAND (arg0
, 1))
14065 && integer_pow2p (arg1
)
14066 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
14067 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
14068 arg1
, OEP_ONLY_CONST
))
14069 return pedantic_non_lvalue_loc (loc
,
14070 fold_convert_loc (loc
, type
,
14071 TREE_OPERAND (arg0
, 0)));
14073 /* Disable the transformations below for vectors, since
14074 fold_binary_op_with_conditional_arg may undo them immediately,
14075 yielding an infinite loop. */
14076 if (code
== VEC_COND_EXPR
)
14079 /* Convert A ? B : 0 into A && B if A and B are truth values. */
14080 if (integer_zerop (op2
)
14081 && truth_value_p (TREE_CODE (arg0
))
14082 && truth_value_p (TREE_CODE (arg1
))
14083 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14084 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
14085 : TRUTH_ANDIF_EXPR
,
14086 type
, fold_convert_loc (loc
, type
, arg0
), arg1
);
14088 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
14089 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
14090 && truth_value_p (TREE_CODE (arg0
))
14091 && truth_value_p (TREE_CODE (arg1
))
14092 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14094 location_t loc0
= expr_location_or (arg0
, loc
);
14095 /* Only perform transformation if ARG0 is easily inverted. */
14096 tem
= fold_invert_truthvalue (loc0
, arg0
);
14098 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14101 type
, fold_convert_loc (loc
, type
, tem
),
14105 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
14106 if (integer_zerop (arg1
)
14107 && truth_value_p (TREE_CODE (arg0
))
14108 && truth_value_p (TREE_CODE (op2
))
14109 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14111 location_t loc0
= expr_location_or (arg0
, loc
);
14112 /* Only perform transformation if ARG0 is easily inverted. */
14113 tem
= fold_invert_truthvalue (loc0
, arg0
);
14115 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14116 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
14117 type
, fold_convert_loc (loc
, type
, tem
),
14121 /* Convert A ? 1 : B into A || B if A and B are truth values. */
14122 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
14123 && truth_value_p (TREE_CODE (arg0
))
14124 && truth_value_p (TREE_CODE (op2
))
14125 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14126 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14127 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
14128 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
14133 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
14134 of fold_ternary on them. */
14135 gcc_unreachable ();
14137 case BIT_FIELD_REF
:
14138 if ((TREE_CODE (arg0
) == VECTOR_CST
14139 || (TREE_CODE (arg0
) == CONSTRUCTOR
14140 && TREE_CODE (TREE_TYPE (arg0
)) == VECTOR_TYPE
))
14141 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
14142 || (TREE_CODE (type
) == VECTOR_TYPE
14143 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
)))))
14145 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
14146 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
14147 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
14148 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
14151 && (idx
% width
) == 0
14152 && (n
% width
) == 0
14153 && ((idx
+ n
) / width
) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)))
14158 if (TREE_CODE (arg0
) == VECTOR_CST
)
14161 return VECTOR_CST_ELT (arg0
, idx
);
14163 tree
*vals
= XALLOCAVEC (tree
, n
);
14164 for (unsigned i
= 0; i
< n
; ++i
)
14165 vals
[i
] = VECTOR_CST_ELT (arg0
, idx
+ i
);
14166 return build_vector (type
, vals
);
14169 /* Constructor elements can be subvectors. */
14170 unsigned HOST_WIDE_INT k
= 1;
14171 if (CONSTRUCTOR_NELTS (arg0
) != 0)
14173 tree cons_elem
= TREE_TYPE (CONSTRUCTOR_ELT (arg0
, 0)->value
);
14174 if (TREE_CODE (cons_elem
) == VECTOR_TYPE
)
14175 k
= TYPE_VECTOR_SUBPARTS (cons_elem
);
14178 /* We keep an exact subset of the constructor elements. */
14179 if ((idx
% k
) == 0 && (n
% k
) == 0)
14181 if (CONSTRUCTOR_NELTS (arg0
) == 0)
14182 return build_constructor (type
, NULL
);
14187 if (idx
< CONSTRUCTOR_NELTS (arg0
))
14188 return CONSTRUCTOR_ELT (arg0
, idx
)->value
;
14189 return build_zero_cst (type
);
14192 vec
<constructor_elt
, va_gc
> *vals
;
14193 vec_alloc (vals
, n
);
14194 for (unsigned i
= 0;
14195 i
< n
&& idx
+ i
< CONSTRUCTOR_NELTS (arg0
);
14197 CONSTRUCTOR_APPEND_ELT (vals
, NULL_TREE
,
14199 (arg0
, idx
+ i
)->value
);
14200 return build_constructor (type
, vals
);
14202 /* The bitfield references a single constructor element. */
14203 else if (idx
+ n
<= (idx
/ k
+ 1) * k
)
14205 if (CONSTRUCTOR_NELTS (arg0
) <= idx
/ k
)
14206 return build_zero_cst (type
);
14208 return CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
;
14210 return fold_build3_loc (loc
, code
, type
,
14211 CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
, op1
,
14212 build_int_cst (TREE_TYPE (op2
), (idx
% k
) * width
));
14217 /* A bit-field-ref that referenced the full argument can be stripped. */
14218 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
14219 && TYPE_PRECISION (TREE_TYPE (arg0
)) == tree_to_uhwi (arg1
)
14220 && integer_zerop (op2
))
14221 return fold_convert_loc (loc
, type
, arg0
);
14223 /* On constants we can use native encode/interpret to constant
14224 fold (nearly) all BIT_FIELD_REFs. */
14225 if (CONSTANT_CLASS_P (arg0
)
14226 && can_native_interpret_type_p (type
)
14227 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)))
14228 /* This limitation should not be necessary, we just need to
14229 round this up to mode size. */
14230 && tree_to_uhwi (op1
) % BITS_PER_UNIT
== 0
14231 /* Need bit-shifting of the buffer to relax the following. */
14232 && tree_to_uhwi (op2
) % BITS_PER_UNIT
== 0)
14234 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
14235 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
14236 unsigned HOST_WIDE_INT clen
;
14237 clen
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)));
14238 /* ??? We cannot tell native_encode_expr to start at
14239 some random byte only. So limit us to a reasonable amount
14243 unsigned char *b
= XALLOCAVEC (unsigned char, clen
);
14244 unsigned HOST_WIDE_INT len
= native_encode_expr (arg0
, b
, clen
);
14246 && len
* BITS_PER_UNIT
>= bitpos
+ bitsize
)
14248 tree v
= native_interpret_expr (type
,
14249 b
+ bitpos
/ BITS_PER_UNIT
,
14250 bitsize
/ BITS_PER_UNIT
);
14260 /* For integers we can decompose the FMA if possible. */
14261 if (TREE_CODE (arg0
) == INTEGER_CST
14262 && TREE_CODE (arg1
) == INTEGER_CST
)
14263 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
14264 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
14265 if (integer_zerop (arg2
))
14266 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
14268 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
14270 case VEC_PERM_EXPR
:
14271 if (TREE_CODE (arg2
) == VECTOR_CST
)
14273 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
, mask
;
14274 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
14275 bool need_mask_canon
= false;
14276 bool all_in_vec0
= true;
14277 bool all_in_vec1
= true;
14278 bool maybe_identity
= true;
14279 bool single_arg
= (op0
== op1
);
14280 bool changed
= false;
14282 mask
= single_arg
? (nelts
- 1) : (2 * nelts
- 1);
14283 gcc_assert (nelts
== VECTOR_CST_NELTS (arg2
));
14284 for (i
= 0; i
< nelts
; i
++)
14286 tree val
= VECTOR_CST_ELT (arg2
, i
);
14287 if (TREE_CODE (val
) != INTEGER_CST
)
14290 /* Make sure that the perm value is in an acceptable
14293 if (wi::gtu_p (t
, mask
))
14295 need_mask_canon
= true;
14296 sel
[i
] = t
.to_uhwi () & mask
;
14299 sel
[i
] = t
.to_uhwi ();
14301 if (sel
[i
] < nelts
)
14302 all_in_vec1
= false;
14304 all_in_vec0
= false;
14306 if ((sel
[i
] & (nelts
-1)) != i
)
14307 maybe_identity
= false;
14310 if (maybe_identity
)
14320 else if (all_in_vec1
)
14323 for (i
= 0; i
< nelts
; i
++)
14325 need_mask_canon
= true;
14328 if ((TREE_CODE (op0
) == VECTOR_CST
14329 || TREE_CODE (op0
) == CONSTRUCTOR
)
14330 && (TREE_CODE (op1
) == VECTOR_CST
14331 || TREE_CODE (op1
) == CONSTRUCTOR
))
14333 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
14334 if (t
!= NULL_TREE
)
14338 if (op0
== op1
&& !single_arg
)
14341 if (need_mask_canon
&& arg2
== op2
)
14343 tree
*tsel
= XALLOCAVEC (tree
, nelts
);
14344 tree eltype
= TREE_TYPE (TREE_TYPE (arg2
));
14345 for (i
= 0; i
< nelts
; i
++)
14346 tsel
[i
] = build_int_cst (eltype
, sel
[i
]);
14347 op2
= build_vector (TREE_TYPE (arg2
), tsel
);
14352 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
14358 } /* switch (code) */
14361 /* Perform constant folding and related simplification of EXPR.
14362 The related simplifications include x*1 => x, x*0 => 0, etc.,
14363 and application of the associative law.
14364 NOP_EXPR conversions may be removed freely (as long as we
14365 are careful not to change the type of the overall expression).
14366 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14367 but we can constant-fold them if they have constant operands. */
14369 #ifdef ENABLE_FOLD_CHECKING
14370 # define fold(x) fold_1 (x)
14371 static tree
fold_1 (tree
);
14377 const tree t
= expr
;
14378 enum tree_code code
= TREE_CODE (t
);
14379 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
14381 location_t loc
= EXPR_LOCATION (expr
);
14383 /* Return right away if a constant. */
14384 if (kind
== tcc_constant
)
14387 /* CALL_EXPR-like objects with variable numbers of operands are
14388 treated specially. */
14389 if (kind
== tcc_vl_exp
)
14391 if (code
== CALL_EXPR
)
14393 tem
= fold_call_expr (loc
, expr
, false);
14394 return tem
? tem
: expr
;
14399 if (IS_EXPR_CODE_CLASS (kind
))
14401 tree type
= TREE_TYPE (t
);
14402 tree op0
, op1
, op2
;
14404 switch (TREE_CODE_LENGTH (code
))
14407 op0
= TREE_OPERAND (t
, 0);
14408 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14409 return tem
? tem
: expr
;
14411 op0
= TREE_OPERAND (t
, 0);
14412 op1
= TREE_OPERAND (t
, 1);
14413 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14414 return tem
? tem
: expr
;
14416 op0
= TREE_OPERAND (t
, 0);
14417 op1
= TREE_OPERAND (t
, 1);
14418 op2
= TREE_OPERAND (t
, 2);
14419 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14420 return tem
? tem
: expr
;
14430 tree op0
= TREE_OPERAND (t
, 0);
14431 tree op1
= TREE_OPERAND (t
, 1);
14433 if (TREE_CODE (op1
) == INTEGER_CST
14434 && TREE_CODE (op0
) == CONSTRUCTOR
14435 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
14437 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (op0
);
14438 unsigned HOST_WIDE_INT end
= vec_safe_length (elts
);
14439 unsigned HOST_WIDE_INT begin
= 0;
14441 /* Find a matching index by means of a binary search. */
14442 while (begin
!= end
)
14444 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
14445 tree index
= (*elts
)[middle
].index
;
14447 if (TREE_CODE (index
) == INTEGER_CST
14448 && tree_int_cst_lt (index
, op1
))
14449 begin
= middle
+ 1;
14450 else if (TREE_CODE (index
) == INTEGER_CST
14451 && tree_int_cst_lt (op1
, index
))
14453 else if (TREE_CODE (index
) == RANGE_EXPR
14454 && tree_int_cst_lt (TREE_OPERAND (index
, 1), op1
))
14455 begin
= middle
+ 1;
14456 else if (TREE_CODE (index
) == RANGE_EXPR
14457 && tree_int_cst_lt (op1
, TREE_OPERAND (index
, 0)))
14460 return (*elts
)[middle
].value
;
14467 /* Return a VECTOR_CST if possible. */
14470 tree type
= TREE_TYPE (t
);
14471 if (TREE_CODE (type
) != VECTOR_TYPE
)
14474 tree
*vec
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
14475 unsigned HOST_WIDE_INT idx
, pos
= 0;
14478 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, value
)
14480 if (!CONSTANT_CLASS_P (value
))
14482 if (TREE_CODE (value
) == VECTOR_CST
)
14484 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (value
); ++i
)
14485 vec
[pos
++] = VECTOR_CST_ELT (value
, i
);
14488 vec
[pos
++] = value
;
14490 for (; pos
< TYPE_VECTOR_SUBPARTS (type
); ++pos
)
14491 vec
[pos
] = build_zero_cst (TREE_TYPE (type
));
14493 return build_vector (type
, vec
);
14497 return fold (DECL_INITIAL (t
));
14501 } /* switch (code) */
14504 #ifdef ENABLE_FOLD_CHECKING
14507 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
14508 hash_table
<pointer_hash
<const tree_node
> > *);
14509 static void fold_check_failed (const_tree
, const_tree
);
14510 void print_fold_checksum (const_tree
);
14512 /* When --enable-checking=fold, compute a digest of expr before
14513 and after actual fold call to see if fold did not accidentally
14514 change original expr. */
14520 struct md5_ctx ctx
;
14521 unsigned char checksum_before
[16], checksum_after
[16];
14522 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14524 md5_init_ctx (&ctx
);
14525 fold_checksum_tree (expr
, &ctx
, &ht
);
14526 md5_finish_ctx (&ctx
, checksum_before
);
14529 ret
= fold_1 (expr
);
14531 md5_init_ctx (&ctx
);
14532 fold_checksum_tree (expr
, &ctx
, &ht
);
14533 md5_finish_ctx (&ctx
, checksum_after
);
14535 if (memcmp (checksum_before
, checksum_after
, 16))
14536 fold_check_failed (expr
, ret
);
14542 print_fold_checksum (const_tree expr
)
14544 struct md5_ctx ctx
;
14545 unsigned char checksum
[16], cnt
;
14546 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14548 md5_init_ctx (&ctx
);
14549 fold_checksum_tree (expr
, &ctx
, &ht
);
14550 md5_finish_ctx (&ctx
, checksum
);
14551 for (cnt
= 0; cnt
< 16; ++cnt
)
14552 fprintf (stderr
, "%02x", checksum
[cnt
]);
14553 putc ('\n', stderr
);
14557 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
14559 internal_error ("fold check: original tree changed by fold");
14563 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
14564 hash_table
<pointer_hash
<const tree_node
> > *ht
)
14566 const tree_node
**slot
;
14567 enum tree_code code
;
14568 union tree_node buf
;
14574 slot
= ht
->find_slot (expr
, INSERT
);
14578 code
= TREE_CODE (expr
);
14579 if (TREE_CODE_CLASS (code
) == tcc_declaration
14580 && DECL_ASSEMBLER_NAME_SET_P (expr
))
14582 /* Allow DECL_ASSEMBLER_NAME to be modified. */
14583 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14584 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
14585 expr
= (tree
) &buf
;
14587 else if (TREE_CODE_CLASS (code
) == tcc_type
14588 && (TYPE_POINTER_TO (expr
)
14589 || TYPE_REFERENCE_TO (expr
)
14590 || TYPE_CACHED_VALUES_P (expr
)
14591 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
14592 || TYPE_NEXT_VARIANT (expr
)))
14594 /* Allow these fields to be modified. */
14596 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14597 expr
= tmp
= (tree
) &buf
;
14598 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
14599 TYPE_POINTER_TO (tmp
) = NULL
;
14600 TYPE_REFERENCE_TO (tmp
) = NULL
;
14601 TYPE_NEXT_VARIANT (tmp
) = NULL
;
14602 if (TYPE_CACHED_VALUES_P (tmp
))
14604 TYPE_CACHED_VALUES_P (tmp
) = 0;
14605 TYPE_CACHED_VALUES (tmp
) = NULL
;
14608 md5_process_bytes (expr
, tree_size (expr
), ctx
);
14609 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
14610 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
14611 if (TREE_CODE_CLASS (code
) != tcc_type
14612 && TREE_CODE_CLASS (code
) != tcc_declaration
14613 && code
!= TREE_LIST
14614 && code
!= SSA_NAME
14615 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
14616 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
14617 switch (TREE_CODE_CLASS (code
))
14623 md5_process_bytes (TREE_STRING_POINTER (expr
),
14624 TREE_STRING_LENGTH (expr
), ctx
);
14627 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
14628 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
14631 for (i
= 0; i
< (int) VECTOR_CST_NELTS (expr
); ++i
)
14632 fold_checksum_tree (VECTOR_CST_ELT (expr
, i
), ctx
, ht
);
14638 case tcc_exceptional
:
14642 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
14643 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
14644 expr
= TREE_CHAIN (expr
);
14645 goto recursive_label
;
14648 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
14649 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
14655 case tcc_expression
:
14656 case tcc_reference
:
14657 case tcc_comparison
:
14660 case tcc_statement
:
14662 len
= TREE_OPERAND_LENGTH (expr
);
14663 for (i
= 0; i
< len
; ++i
)
14664 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
14666 case tcc_declaration
:
14667 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
14668 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
14669 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
14671 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
14672 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
14673 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
14674 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
14675 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
14678 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
14680 if (TREE_CODE (expr
) == FUNCTION_DECL
)
14682 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
14683 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
14685 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
14689 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
14690 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
14691 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
14692 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
14693 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
14694 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
14695 if (INTEGRAL_TYPE_P (expr
)
14696 || SCALAR_FLOAT_TYPE_P (expr
))
14698 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
14699 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
14701 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
14702 if (TREE_CODE (expr
) == RECORD_TYPE
14703 || TREE_CODE (expr
) == UNION_TYPE
14704 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
14705 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
14706 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
14713 /* Helper function for outputting the checksum of a tree T. When
14714 debugging with gdb, you can "define mynext" to be "next" followed
14715 by "call debug_fold_checksum (op0)", then just trace down till the
14718 DEBUG_FUNCTION
void
14719 debug_fold_checksum (const_tree t
)
14722 unsigned char checksum
[16];
14723 struct md5_ctx ctx
;
14724 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14726 md5_init_ctx (&ctx
);
14727 fold_checksum_tree (t
, &ctx
, &ht
);
14728 md5_finish_ctx (&ctx
, checksum
);
14731 for (i
= 0; i
< 16; i
++)
14732 fprintf (stderr
, "%d ", checksum
[i
]);
14734 fprintf (stderr
, "\n");
14739 /* Fold a unary tree expression with code CODE of type TYPE with an
14740 operand OP0. LOC is the location of the resulting expression.
14741 Return a folded expression if successful. Otherwise, return a tree
14742 expression with code CODE of type TYPE with an operand OP0. */
14745 fold_build1_stat_loc (location_t loc
,
14746 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
14749 #ifdef ENABLE_FOLD_CHECKING
14750 unsigned char checksum_before
[16], checksum_after
[16];
14751 struct md5_ctx ctx
;
14752 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14754 md5_init_ctx (&ctx
);
14755 fold_checksum_tree (op0
, &ctx
, &ht
);
14756 md5_finish_ctx (&ctx
, checksum_before
);
14760 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14762 tem
= build1_stat_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
14764 #ifdef ENABLE_FOLD_CHECKING
14765 md5_init_ctx (&ctx
);
14766 fold_checksum_tree (op0
, &ctx
, &ht
);
14767 md5_finish_ctx (&ctx
, checksum_after
);
14769 if (memcmp (checksum_before
, checksum_after
, 16))
14770 fold_check_failed (op0
, tem
);
14775 /* Fold a binary tree expression with code CODE of type TYPE with
14776 operands OP0 and OP1. LOC is the location of the resulting
14777 expression. Return a folded expression if successful. Otherwise,
14778 return a tree expression with code CODE of type TYPE with operands
14782 fold_build2_stat_loc (location_t loc
,
14783 enum tree_code code
, tree type
, tree op0
, tree op1
14787 #ifdef ENABLE_FOLD_CHECKING
14788 unsigned char checksum_before_op0
[16],
14789 checksum_before_op1
[16],
14790 checksum_after_op0
[16],
14791 checksum_after_op1
[16];
14792 struct md5_ctx ctx
;
14793 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14795 md5_init_ctx (&ctx
);
14796 fold_checksum_tree (op0
, &ctx
, &ht
);
14797 md5_finish_ctx (&ctx
, checksum_before_op0
);
14800 md5_init_ctx (&ctx
);
14801 fold_checksum_tree (op1
, &ctx
, &ht
);
14802 md5_finish_ctx (&ctx
, checksum_before_op1
);
14806 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14808 tem
= build2_stat_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
14810 #ifdef ENABLE_FOLD_CHECKING
14811 md5_init_ctx (&ctx
);
14812 fold_checksum_tree (op0
, &ctx
, &ht
);
14813 md5_finish_ctx (&ctx
, checksum_after_op0
);
14816 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14817 fold_check_failed (op0
, tem
);
14819 md5_init_ctx (&ctx
);
14820 fold_checksum_tree (op1
, &ctx
, &ht
);
14821 md5_finish_ctx (&ctx
, checksum_after_op1
);
14823 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
14824 fold_check_failed (op1
, tem
);
14829 /* Fold a ternary tree expression with code CODE of type TYPE with
14830 operands OP0, OP1, and OP2. Return a folded expression if
14831 successful. Otherwise, return a tree expression with code CODE of
14832 type TYPE with operands OP0, OP1, and OP2. */
14835 fold_build3_stat_loc (location_t loc
, enum tree_code code
, tree type
,
14836 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
14839 #ifdef ENABLE_FOLD_CHECKING
14840 unsigned char checksum_before_op0
[16],
14841 checksum_before_op1
[16],
14842 checksum_before_op2
[16],
14843 checksum_after_op0
[16],
14844 checksum_after_op1
[16],
14845 checksum_after_op2
[16];
14846 struct md5_ctx ctx
;
14847 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14849 md5_init_ctx (&ctx
);
14850 fold_checksum_tree (op0
, &ctx
, &ht
);
14851 md5_finish_ctx (&ctx
, checksum_before_op0
);
14854 md5_init_ctx (&ctx
);
14855 fold_checksum_tree (op1
, &ctx
, &ht
);
14856 md5_finish_ctx (&ctx
, checksum_before_op1
);
14859 md5_init_ctx (&ctx
);
14860 fold_checksum_tree (op2
, &ctx
, &ht
);
14861 md5_finish_ctx (&ctx
, checksum_before_op2
);
14865 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
14866 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14868 tem
= build3_stat_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
14870 #ifdef ENABLE_FOLD_CHECKING
14871 md5_init_ctx (&ctx
);
14872 fold_checksum_tree (op0
, &ctx
, &ht
);
14873 md5_finish_ctx (&ctx
, checksum_after_op0
);
14876 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14877 fold_check_failed (op0
, tem
);
14879 md5_init_ctx (&ctx
);
14880 fold_checksum_tree (op1
, &ctx
, &ht
);
14881 md5_finish_ctx (&ctx
, checksum_after_op1
);
14884 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
14885 fold_check_failed (op1
, tem
);
14887 md5_init_ctx (&ctx
);
14888 fold_checksum_tree (op2
, &ctx
, &ht
);
14889 md5_finish_ctx (&ctx
, checksum_after_op2
);
14891 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
14892 fold_check_failed (op2
, tem
);
14897 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14898 arguments in ARGARRAY, and a null static chain.
14899 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14900 of type TYPE from the given operands as constructed by build_call_array. */
14903 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
14904 int nargs
, tree
*argarray
)
14907 #ifdef ENABLE_FOLD_CHECKING
14908 unsigned char checksum_before_fn
[16],
14909 checksum_before_arglist
[16],
14910 checksum_after_fn
[16],
14911 checksum_after_arglist
[16];
14912 struct md5_ctx ctx
;
14913 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14916 md5_init_ctx (&ctx
);
14917 fold_checksum_tree (fn
, &ctx
, &ht
);
14918 md5_finish_ctx (&ctx
, checksum_before_fn
);
14921 md5_init_ctx (&ctx
);
14922 for (i
= 0; i
< nargs
; i
++)
14923 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
14924 md5_finish_ctx (&ctx
, checksum_before_arglist
);
14928 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
14930 #ifdef ENABLE_FOLD_CHECKING
14931 md5_init_ctx (&ctx
);
14932 fold_checksum_tree (fn
, &ctx
, &ht
);
14933 md5_finish_ctx (&ctx
, checksum_after_fn
);
14936 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
14937 fold_check_failed (fn
, tem
);
14939 md5_init_ctx (&ctx
);
14940 for (i
= 0; i
< nargs
; i
++)
14941 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
14942 md5_finish_ctx (&ctx
, checksum_after_arglist
);
14944 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
14945 fold_check_failed (NULL_TREE
, tem
);
14950 /* Perform constant folding and related simplification of initializer
14951 expression EXPR. These behave identically to "fold_buildN" but ignore
14952 potential run-time traps and exceptions that fold must preserve. */
14954 #define START_FOLD_INIT \
14955 int saved_signaling_nans = flag_signaling_nans;\
14956 int saved_trapping_math = flag_trapping_math;\
14957 int saved_rounding_math = flag_rounding_math;\
14958 int saved_trapv = flag_trapv;\
14959 int saved_folding_initializer = folding_initializer;\
14960 flag_signaling_nans = 0;\
14961 flag_trapping_math = 0;\
14962 flag_rounding_math = 0;\
14964 folding_initializer = 1;
14966 #define END_FOLD_INIT \
14967 flag_signaling_nans = saved_signaling_nans;\
14968 flag_trapping_math = saved_trapping_math;\
14969 flag_rounding_math = saved_rounding_math;\
14970 flag_trapv = saved_trapv;\
14971 folding_initializer = saved_folding_initializer;
14974 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
14975 tree type
, tree op
)
14980 result
= fold_build1_loc (loc
, code
, type
, op
);
14987 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
14988 tree type
, tree op0
, tree op1
)
14993 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
15000 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
15001 int nargs
, tree
*argarray
)
15006 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
15012 #undef START_FOLD_INIT
15013 #undef END_FOLD_INIT
15015 /* Determine if first argument is a multiple of second argument. Return 0 if
15016 it is not, or we cannot easily determined it to be.
15018 An example of the sort of thing we care about (at this point; this routine
15019 could surely be made more general, and expanded to do what the *_DIV_EXPR's
15020 fold cases do now) is discovering that
15022 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15028 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
15030 This code also handles discovering that
15032 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15034 is a multiple of 8 so we don't have to worry about dealing with a
15035 possible remainder.
15037 Note that we *look* inside a SAVE_EXPR only to determine how it was
15038 calculated; it is not safe for fold to do much of anything else with the
15039 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
15040 at run time. For example, the latter example above *cannot* be implemented
15041 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
15042 evaluation time of the original SAVE_EXPR is not necessarily the same at
15043 the time the new expression is evaluated. The only optimization of this
15044 sort that would be valid is changing
15046 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
15050 SAVE_EXPR (I) * SAVE_EXPR (J)
15052 (where the same SAVE_EXPR (J) is used in the original and the
15053 transformed version). */
15056 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
15058 if (operand_equal_p (top
, bottom
, 0))
15061 if (TREE_CODE (type
) != INTEGER_TYPE
)
15064 switch (TREE_CODE (top
))
15067 /* Bitwise and provides a power of two multiple. If the mask is
15068 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
15069 if (!integer_pow2p (bottom
))
15074 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
15075 || multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
15079 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
15080 && multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
15083 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
15087 op1
= TREE_OPERAND (top
, 1);
15088 /* const_binop may not detect overflow correctly,
15089 so check for it explicitly here. */
15090 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
15091 && 0 != (t1
= fold_convert (type
,
15092 const_binop (LSHIFT_EXPR
,
15095 && !TREE_OVERFLOW (t1
))
15096 return multiple_of_p (type
, t1
, bottom
);
15101 /* Can't handle conversions from non-integral or wider integral type. */
15102 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
15103 || (TYPE_PRECISION (type
)
15104 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
15107 /* .. fall through ... */
15110 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
15113 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
15114 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
15117 if (TREE_CODE (bottom
) != INTEGER_CST
15118 || integer_zerop (bottom
)
15119 || (TYPE_UNSIGNED (type
)
15120 && (tree_int_cst_sgn (top
) < 0
15121 || tree_int_cst_sgn (bottom
) < 0)))
15123 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
15131 /* Return true if CODE or TYPE is known to be non-negative. */
15134 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
15136 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
15137 && truth_value_p (code
))
15138 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15139 have a signed:1 type (where the value is -1 and 0). */
15144 /* Return true if (CODE OP0) is known to be non-negative. If the return
15145 value is based on the assumption that signed overflow is undefined,
15146 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15147 *STRICT_OVERFLOW_P. */
15150 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15151 bool *strict_overflow_p
)
15153 if (TYPE_UNSIGNED (type
))
15159 /* We can't return 1 if flag_wrapv is set because
15160 ABS_EXPR<INT_MIN> = INT_MIN. */
15161 if (!INTEGRAL_TYPE_P (type
))
15163 if (TYPE_OVERFLOW_UNDEFINED (type
))
15165 *strict_overflow_p
= true;
15170 case NON_LVALUE_EXPR
:
15172 case FIX_TRUNC_EXPR
:
15173 return tree_expr_nonnegative_warnv_p (op0
,
15174 strict_overflow_p
);
15178 tree inner_type
= TREE_TYPE (op0
);
15179 tree outer_type
= type
;
15181 if (TREE_CODE (outer_type
) == REAL_TYPE
)
15183 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15184 return tree_expr_nonnegative_warnv_p (op0
,
15185 strict_overflow_p
);
15186 if (INTEGRAL_TYPE_P (inner_type
))
15188 if (TYPE_UNSIGNED (inner_type
))
15190 return tree_expr_nonnegative_warnv_p (op0
,
15191 strict_overflow_p
);
15194 else if (INTEGRAL_TYPE_P (outer_type
))
15196 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15197 return tree_expr_nonnegative_warnv_p (op0
,
15198 strict_overflow_p
);
15199 if (INTEGRAL_TYPE_P (inner_type
))
15200 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
15201 && TYPE_UNSIGNED (inner_type
);
15207 return tree_simple_nonnegative_warnv_p (code
, type
);
15210 /* We don't know sign of `t', so be conservative and return false. */
15214 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
15215 value is based on the assumption that signed overflow is undefined,
15216 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15217 *STRICT_OVERFLOW_P. */
15220 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15221 tree op1
, bool *strict_overflow_p
)
15223 if (TYPE_UNSIGNED (type
))
15228 case POINTER_PLUS_EXPR
:
15230 if (FLOAT_TYPE_P (type
))
15231 return (tree_expr_nonnegative_warnv_p (op0
,
15233 && tree_expr_nonnegative_warnv_p (op1
,
15234 strict_overflow_p
));
15236 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
15237 both unsigned and at least 2 bits shorter than the result. */
15238 if (TREE_CODE (type
) == INTEGER_TYPE
15239 && TREE_CODE (op0
) == NOP_EXPR
15240 && TREE_CODE (op1
) == NOP_EXPR
)
15242 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
15243 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
15244 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
15245 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
15247 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
15248 TYPE_PRECISION (inner2
)) + 1;
15249 return prec
< TYPE_PRECISION (type
);
15255 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
15257 /* x * x is always non-negative for floating point x
15258 or without overflow. */
15259 if (operand_equal_p (op0
, op1
, 0)
15260 || (tree_expr_nonnegative_warnv_p (op0
, strict_overflow_p
)
15261 && tree_expr_nonnegative_warnv_p (op1
, strict_overflow_p
)))
15263 if (TYPE_OVERFLOW_UNDEFINED (type
))
15264 *strict_overflow_p
= true;
15269 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
15270 both unsigned and their total bits is shorter than the result. */
15271 if (TREE_CODE (type
) == INTEGER_TYPE
15272 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
15273 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
15275 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
15276 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
15278 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
15279 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
15282 bool unsigned0
= TYPE_UNSIGNED (inner0
);
15283 bool unsigned1
= TYPE_UNSIGNED (inner1
);
15285 if (TREE_CODE (op0
) == INTEGER_CST
)
15286 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
15288 if (TREE_CODE (op1
) == INTEGER_CST
)
15289 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
15291 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
15292 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
15294 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
15295 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
15296 : TYPE_PRECISION (inner0
);
15298 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
15299 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
15300 : TYPE_PRECISION (inner1
);
15302 return precision0
+ precision1
< TYPE_PRECISION (type
);
15309 return (tree_expr_nonnegative_warnv_p (op0
,
15311 || tree_expr_nonnegative_warnv_p (op1
,
15312 strict_overflow_p
));
15318 case TRUNC_DIV_EXPR
:
15319 case CEIL_DIV_EXPR
:
15320 case FLOOR_DIV_EXPR
:
15321 case ROUND_DIV_EXPR
:
15322 return (tree_expr_nonnegative_warnv_p (op0
,
15324 && tree_expr_nonnegative_warnv_p (op1
,
15325 strict_overflow_p
));
15327 case TRUNC_MOD_EXPR
:
15328 case CEIL_MOD_EXPR
:
15329 case FLOOR_MOD_EXPR
:
15330 case ROUND_MOD_EXPR
:
15331 return tree_expr_nonnegative_warnv_p (op0
,
15332 strict_overflow_p
);
15334 return tree_simple_nonnegative_warnv_p (code
, type
);
15337 /* We don't know sign of `t', so be conservative and return false. */
15341 /* Return true if T is known to be non-negative. If the return
15342 value is based on the assumption that signed overflow is undefined,
15343 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15344 *STRICT_OVERFLOW_P. */
15347 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15349 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15352 switch (TREE_CODE (t
))
15355 return tree_int_cst_sgn (t
) >= 0;
15358 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
15361 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
15364 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15366 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 2),
15367 strict_overflow_p
));
15369 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15372 /* We don't know sign of `t', so be conservative and return false. */
15376 /* Return true if T is known to be non-negative. If the return
15377 value is based on the assumption that signed overflow is undefined,
15378 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15379 *STRICT_OVERFLOW_P. */
15382 tree_call_nonnegative_warnv_p (tree type
, tree fndecl
,
15383 tree arg0
, tree arg1
, bool *strict_overflow_p
)
15385 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
15386 switch (DECL_FUNCTION_CODE (fndecl
))
15388 CASE_FLT_FN (BUILT_IN_ACOS
):
15389 CASE_FLT_FN (BUILT_IN_ACOSH
):
15390 CASE_FLT_FN (BUILT_IN_CABS
):
15391 CASE_FLT_FN (BUILT_IN_COSH
):
15392 CASE_FLT_FN (BUILT_IN_ERFC
):
15393 CASE_FLT_FN (BUILT_IN_EXP
):
15394 CASE_FLT_FN (BUILT_IN_EXP10
):
15395 CASE_FLT_FN (BUILT_IN_EXP2
):
15396 CASE_FLT_FN (BUILT_IN_FABS
):
15397 CASE_FLT_FN (BUILT_IN_FDIM
):
15398 CASE_FLT_FN (BUILT_IN_HYPOT
):
15399 CASE_FLT_FN (BUILT_IN_POW10
):
15400 CASE_INT_FN (BUILT_IN_FFS
):
15401 CASE_INT_FN (BUILT_IN_PARITY
):
15402 CASE_INT_FN (BUILT_IN_POPCOUNT
):
15403 CASE_INT_FN (BUILT_IN_CLZ
):
15404 CASE_INT_FN (BUILT_IN_CLRSB
):
15405 case BUILT_IN_BSWAP32
:
15406 case BUILT_IN_BSWAP64
:
15410 CASE_FLT_FN (BUILT_IN_SQRT
):
15411 /* sqrt(-0.0) is -0.0. */
15412 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
15414 return tree_expr_nonnegative_warnv_p (arg0
,
15415 strict_overflow_p
);
15417 CASE_FLT_FN (BUILT_IN_ASINH
):
15418 CASE_FLT_FN (BUILT_IN_ATAN
):
15419 CASE_FLT_FN (BUILT_IN_ATANH
):
15420 CASE_FLT_FN (BUILT_IN_CBRT
):
15421 CASE_FLT_FN (BUILT_IN_CEIL
):
15422 CASE_FLT_FN (BUILT_IN_ERF
):
15423 CASE_FLT_FN (BUILT_IN_EXPM1
):
15424 CASE_FLT_FN (BUILT_IN_FLOOR
):
15425 CASE_FLT_FN (BUILT_IN_FMOD
):
15426 CASE_FLT_FN (BUILT_IN_FREXP
):
15427 CASE_FLT_FN (BUILT_IN_ICEIL
):
15428 CASE_FLT_FN (BUILT_IN_IFLOOR
):
15429 CASE_FLT_FN (BUILT_IN_IRINT
):
15430 CASE_FLT_FN (BUILT_IN_IROUND
):
15431 CASE_FLT_FN (BUILT_IN_LCEIL
):
15432 CASE_FLT_FN (BUILT_IN_LDEXP
):
15433 CASE_FLT_FN (BUILT_IN_LFLOOR
):
15434 CASE_FLT_FN (BUILT_IN_LLCEIL
):
15435 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
15436 CASE_FLT_FN (BUILT_IN_LLRINT
):
15437 CASE_FLT_FN (BUILT_IN_LLROUND
):
15438 CASE_FLT_FN (BUILT_IN_LRINT
):
15439 CASE_FLT_FN (BUILT_IN_LROUND
):
15440 CASE_FLT_FN (BUILT_IN_MODF
):
15441 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
15442 CASE_FLT_FN (BUILT_IN_RINT
):
15443 CASE_FLT_FN (BUILT_IN_ROUND
):
15444 CASE_FLT_FN (BUILT_IN_SCALB
):
15445 CASE_FLT_FN (BUILT_IN_SCALBLN
):
15446 CASE_FLT_FN (BUILT_IN_SCALBN
):
15447 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
15448 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
15449 CASE_FLT_FN (BUILT_IN_SINH
):
15450 CASE_FLT_FN (BUILT_IN_TANH
):
15451 CASE_FLT_FN (BUILT_IN_TRUNC
):
15452 /* True if the 1st argument is nonnegative. */
15453 return tree_expr_nonnegative_warnv_p (arg0
,
15454 strict_overflow_p
);
15456 CASE_FLT_FN (BUILT_IN_FMAX
):
15457 /* True if the 1st OR 2nd arguments are nonnegative. */
15458 return (tree_expr_nonnegative_warnv_p (arg0
,
15460 || (tree_expr_nonnegative_warnv_p (arg1
,
15461 strict_overflow_p
)));
15463 CASE_FLT_FN (BUILT_IN_FMIN
):
15464 /* True if the 1st AND 2nd arguments are nonnegative. */
15465 return (tree_expr_nonnegative_warnv_p (arg0
,
15467 && (tree_expr_nonnegative_warnv_p (arg1
,
15468 strict_overflow_p
)));
15470 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
15471 /* True if the 2nd argument is nonnegative. */
15472 return tree_expr_nonnegative_warnv_p (arg1
,
15473 strict_overflow_p
);
15475 CASE_FLT_FN (BUILT_IN_POWI
):
15476 /* True if the 1st argument is nonnegative or the second
15477 argument is an even integer. */
15478 if (TREE_CODE (arg1
) == INTEGER_CST
15479 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
15481 return tree_expr_nonnegative_warnv_p (arg0
,
15482 strict_overflow_p
);
15484 CASE_FLT_FN (BUILT_IN_POW
):
15485 /* True if the 1st argument is nonnegative or the second
15486 argument is an even integer valued real. */
15487 if (TREE_CODE (arg1
) == REAL_CST
)
15492 c
= TREE_REAL_CST (arg1
);
15493 n
= real_to_integer (&c
);
15496 REAL_VALUE_TYPE cint
;
15497 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
15498 if (real_identical (&c
, &cint
))
15502 return tree_expr_nonnegative_warnv_p (arg0
,
15503 strict_overflow_p
);
15508 return tree_simple_nonnegative_warnv_p (CALL_EXPR
,
15512 /* Return true if T is known to be non-negative. If the return
15513 value is based on the assumption that signed overflow is undefined,
15514 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15515 *STRICT_OVERFLOW_P. */
15518 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15520 enum tree_code code
= TREE_CODE (t
);
15521 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15528 tree temp
= TARGET_EXPR_SLOT (t
);
15529 t
= TARGET_EXPR_INITIAL (t
);
15531 /* If the initializer is non-void, then it's a normal expression
15532 that will be assigned to the slot. */
15533 if (!VOID_TYPE_P (t
))
15534 return tree_expr_nonnegative_warnv_p (t
, strict_overflow_p
);
15536 /* Otherwise, the initializer sets the slot in some way. One common
15537 way is an assignment statement at the end of the initializer. */
15540 if (TREE_CODE (t
) == BIND_EXPR
)
15541 t
= expr_last (BIND_EXPR_BODY (t
));
15542 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
15543 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
15544 t
= expr_last (TREE_OPERAND (t
, 0));
15545 else if (TREE_CODE (t
) == STATEMENT_LIST
)
15550 if (TREE_CODE (t
) == MODIFY_EXPR
15551 && TREE_OPERAND (t
, 0) == temp
)
15552 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15553 strict_overflow_p
);
15560 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
15561 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
15563 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
15564 get_callee_fndecl (t
),
15567 strict_overflow_p
);
15569 case COMPOUND_EXPR
:
15571 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15572 strict_overflow_p
);
15574 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t
, 1)),
15575 strict_overflow_p
);
15577 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 0),
15578 strict_overflow_p
);
15581 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15585 /* We don't know sign of `t', so be conservative and return false. */
15589 /* Return true if T is known to be non-negative. If the return
15590 value is based on the assumption that signed overflow is undefined,
15591 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15592 *STRICT_OVERFLOW_P. */
15595 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15597 enum tree_code code
;
15598 if (t
== error_mark_node
)
15601 code
= TREE_CODE (t
);
15602 switch (TREE_CODE_CLASS (code
))
15605 case tcc_comparison
:
15606 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15608 TREE_OPERAND (t
, 0),
15609 TREE_OPERAND (t
, 1),
15610 strict_overflow_p
);
15613 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15615 TREE_OPERAND (t
, 0),
15616 strict_overflow_p
);
15619 case tcc_declaration
:
15620 case tcc_reference
:
15621 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15629 case TRUTH_AND_EXPR
:
15630 case TRUTH_OR_EXPR
:
15631 case TRUTH_XOR_EXPR
:
15632 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15634 TREE_OPERAND (t
, 0),
15635 TREE_OPERAND (t
, 1),
15636 strict_overflow_p
);
15637 case TRUTH_NOT_EXPR
:
15638 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15640 TREE_OPERAND (t
, 0),
15641 strict_overflow_p
);
15648 case WITH_SIZE_EXPR
:
15650 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15653 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
);
15657 /* Return true if `t' is known to be non-negative. Handle warnings
15658 about undefined signed overflow. */
15661 tree_expr_nonnegative_p (tree t
)
15663 bool ret
, strict_overflow_p
;
15665 strict_overflow_p
= false;
15666 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
15667 if (strict_overflow_p
)
15668 fold_overflow_warning (("assuming signed overflow does not occur when "
15669 "determining that expression is always "
15671 WARN_STRICT_OVERFLOW_MISC
);
15676 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15677 For floating point we further ensure that T is not denormal.
15678 Similar logic is present in nonzero_address in rtlanal.h.
15680 If the return value is based on the assumption that signed overflow
15681 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15682 change *STRICT_OVERFLOW_P. */
15685 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
15686 bool *strict_overflow_p
)
15691 return tree_expr_nonzero_warnv_p (op0
,
15692 strict_overflow_p
);
15696 tree inner_type
= TREE_TYPE (op0
);
15697 tree outer_type
= type
;
15699 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
15700 && tree_expr_nonzero_warnv_p (op0
,
15701 strict_overflow_p
));
15705 case NON_LVALUE_EXPR
:
15706 return tree_expr_nonzero_warnv_p (op0
,
15707 strict_overflow_p
);
15716 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15717 For floating point we further ensure that T is not denormal.
15718 Similar logic is present in nonzero_address in rtlanal.h.
15720 If the return value is based on the assumption that signed overflow
15721 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15722 change *STRICT_OVERFLOW_P. */
15725 tree_binary_nonzero_warnv_p (enum tree_code code
,
15728 tree op1
, bool *strict_overflow_p
)
15730 bool sub_strict_overflow_p
;
15733 case POINTER_PLUS_EXPR
:
15735 if (TYPE_OVERFLOW_UNDEFINED (type
))
15737 /* With the presence of negative values it is hard
15738 to say something. */
15739 sub_strict_overflow_p
= false;
15740 if (!tree_expr_nonnegative_warnv_p (op0
,
15741 &sub_strict_overflow_p
)
15742 || !tree_expr_nonnegative_warnv_p (op1
,
15743 &sub_strict_overflow_p
))
15745 /* One of operands must be positive and the other non-negative. */
15746 /* We don't set *STRICT_OVERFLOW_P here: even if this value
15747 overflows, on a twos-complement machine the sum of two
15748 nonnegative numbers can never be zero. */
15749 return (tree_expr_nonzero_warnv_p (op0
,
15751 || tree_expr_nonzero_warnv_p (op1
,
15752 strict_overflow_p
));
15757 if (TYPE_OVERFLOW_UNDEFINED (type
))
15759 if (tree_expr_nonzero_warnv_p (op0
,
15761 && tree_expr_nonzero_warnv_p (op1
,
15762 strict_overflow_p
))
15764 *strict_overflow_p
= true;
15771 sub_strict_overflow_p
= false;
15772 if (tree_expr_nonzero_warnv_p (op0
,
15773 &sub_strict_overflow_p
)
15774 && tree_expr_nonzero_warnv_p (op1
,
15775 &sub_strict_overflow_p
))
15777 if (sub_strict_overflow_p
)
15778 *strict_overflow_p
= true;
15783 sub_strict_overflow_p
= false;
15784 if (tree_expr_nonzero_warnv_p (op0
,
15785 &sub_strict_overflow_p
))
15787 if (sub_strict_overflow_p
)
15788 *strict_overflow_p
= true;
15790 /* When both operands are nonzero, then MAX must be too. */
15791 if (tree_expr_nonzero_warnv_p (op1
,
15792 strict_overflow_p
))
15795 /* MAX where operand 0 is positive is positive. */
15796 return tree_expr_nonnegative_warnv_p (op0
,
15797 strict_overflow_p
);
15799 /* MAX where operand 1 is positive is positive. */
15800 else if (tree_expr_nonzero_warnv_p (op1
,
15801 &sub_strict_overflow_p
)
15802 && tree_expr_nonnegative_warnv_p (op1
,
15803 &sub_strict_overflow_p
))
15805 if (sub_strict_overflow_p
)
15806 *strict_overflow_p
= true;
15812 return (tree_expr_nonzero_warnv_p (op1
,
15814 || tree_expr_nonzero_warnv_p (op0
,
15815 strict_overflow_p
));
15824 /* Return true when T is an address and is known to be nonzero.
15825 For floating point we further ensure that T is not denormal.
15826 Similar logic is present in nonzero_address in rtlanal.h.
15828 If the return value is based on the assumption that signed overflow
15829 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15830 change *STRICT_OVERFLOW_P. */
15833 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
15835 bool sub_strict_overflow_p
;
15836 switch (TREE_CODE (t
))
15839 return !integer_zerop (t
);
15843 tree base
= TREE_OPERAND (t
, 0);
15845 if (!DECL_P (base
))
15846 base
= get_base_address (base
);
15851 /* For objects in symbol table check if we know they are non-zero.
15852 Don't do anything for variables and functions before symtab is built;
15853 it is quite possible that they will be declared weak later. */
15854 if (DECL_P (base
) && decl_in_symtab_p (base
))
15856 struct symtab_node
*symbol
;
15858 symbol
= symtab_node::get_create (base
);
15860 return symbol
->nonzero_address ();
15865 /* Function local objects are never NULL. */
15867 && (DECL_CONTEXT (base
)
15868 && TREE_CODE (DECL_CONTEXT (base
)) == FUNCTION_DECL
15869 && auto_var_in_fn_p (base
, DECL_CONTEXT (base
))))
15872 /* Constants are never weak. */
15873 if (CONSTANT_CLASS_P (base
))
15880 sub_strict_overflow_p
= false;
15881 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
15882 &sub_strict_overflow_p
)
15883 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
15884 &sub_strict_overflow_p
))
15886 if (sub_strict_overflow_p
)
15887 *strict_overflow_p
= true;
15898 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15899 attempt to fold the expression to a constant without modifying TYPE,
15902 If the expression could be simplified to a constant, then return
15903 the constant. If the expression would not be simplified to a
15904 constant, then return NULL_TREE. */
15907 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
15909 tree tem
= fold_binary (code
, type
, op0
, op1
);
15910 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
15913 /* Given the components of a unary expression CODE, TYPE and OP0,
15914 attempt to fold the expression to a constant without modifying
15917 If the expression could be simplified to a constant, then return
15918 the constant. If the expression would not be simplified to a
15919 constant, then return NULL_TREE. */
15922 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
15924 tree tem
= fold_unary (code
, type
, op0
);
15925 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
15928 /* If EXP represents referencing an element in a constant string
15929 (either via pointer arithmetic or array indexing), return the
15930 tree representing the value accessed, otherwise return NULL. */
15933 fold_read_from_constant_string (tree exp
)
15935 if ((TREE_CODE (exp
) == INDIRECT_REF
15936 || TREE_CODE (exp
) == ARRAY_REF
)
15937 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
15939 tree exp1
= TREE_OPERAND (exp
, 0);
15942 location_t loc
= EXPR_LOCATION (exp
);
15944 if (TREE_CODE (exp
) == INDIRECT_REF
)
15945 string
= string_constant (exp1
, &index
);
15948 tree low_bound
= array_ref_low_bound (exp
);
15949 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
15951 /* Optimize the special-case of a zero lower bound.
15953 We convert the low_bound to sizetype to avoid some problems
15954 with constant folding. (E.g. suppose the lower bound is 1,
15955 and its mode is QI. Without the conversion,l (ARRAY
15956 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15957 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15958 if (! integer_zerop (low_bound
))
15959 index
= size_diffop_loc (loc
, index
,
15960 fold_convert_loc (loc
, sizetype
, low_bound
));
15966 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
15967 && TREE_CODE (string
) == STRING_CST
15968 && TREE_CODE (index
) == INTEGER_CST
15969 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
15970 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))))
15972 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))) == 1))
15973 return build_int_cst_type (TREE_TYPE (exp
),
15974 (TREE_STRING_POINTER (string
)
15975 [TREE_INT_CST_LOW (index
)]));
15980 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15981 an integer constant, real, or fixed-point constant.
15983 TYPE is the type of the result. */
15986 fold_negate_const (tree arg0
, tree type
)
15988 tree t
= NULL_TREE
;
15990 switch (TREE_CODE (arg0
))
15995 wide_int val
= wi::neg (arg0
, &overflow
);
15996 t
= force_fit_type (type
, val
, 1,
15997 (overflow
| TREE_OVERFLOW (arg0
))
15998 && !TYPE_UNSIGNED (type
));
16003 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16008 FIXED_VALUE_TYPE f
;
16009 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
16010 &(TREE_FIXED_CST (arg0
)), NULL
,
16011 TYPE_SATURATING (type
));
16012 t
= build_fixed (type
, f
);
16013 /* Propagate overflow flags. */
16014 if (overflow_p
| TREE_OVERFLOW (arg0
))
16015 TREE_OVERFLOW (t
) = 1;
16020 gcc_unreachable ();
16026 /* Return the tree for abs (ARG0) when ARG0 is known to be either
16027 an integer constant or real constant.
16029 TYPE is the type of the result. */
16032 fold_abs_const (tree arg0
, tree type
)
16034 tree t
= NULL_TREE
;
16036 switch (TREE_CODE (arg0
))
16040 /* If the value is unsigned or non-negative, then the absolute value
16041 is the same as the ordinary value. */
16042 if (!wi::neg_p (arg0
, TYPE_SIGN (type
)))
16045 /* If the value is negative, then the absolute value is
16050 wide_int val
= wi::neg (arg0
, &overflow
);
16051 t
= force_fit_type (type
, val
, -1,
16052 overflow
| TREE_OVERFLOW (arg0
));
16058 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
16059 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16065 gcc_unreachable ();
16071 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
16072 constant. TYPE is the type of the result. */
16075 fold_not_const (const_tree arg0
, tree type
)
16077 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
16079 return force_fit_type (type
, wi::bit_not (arg0
), 0, TREE_OVERFLOW (arg0
));
16082 /* Given CODE, a relational operator, the target type, TYPE and two
16083 constant operands OP0 and OP1, return the result of the
16084 relational operation. If the result is not a compile time
16085 constant, then return NULL_TREE. */
16088 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
16090 int result
, invert
;
16092 /* From here on, the only cases we handle are when the result is
16093 known to be a constant. */
16095 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
16097 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
16098 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
16100 /* Handle the cases where either operand is a NaN. */
16101 if (real_isnan (c0
) || real_isnan (c1
))
16111 case UNORDERED_EXPR
:
16125 if (flag_trapping_math
)
16131 gcc_unreachable ();
16134 return constant_boolean_node (result
, type
);
16137 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
16140 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
16142 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
16143 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
16144 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
16147 /* Handle equality/inequality of complex constants. */
16148 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
16150 tree rcond
= fold_relational_const (code
, type
,
16151 TREE_REALPART (op0
),
16152 TREE_REALPART (op1
));
16153 tree icond
= fold_relational_const (code
, type
,
16154 TREE_IMAGPART (op0
),
16155 TREE_IMAGPART (op1
));
16156 if (code
== EQ_EXPR
)
16157 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
16158 else if (code
== NE_EXPR
)
16159 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
16164 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
16166 unsigned count
= VECTOR_CST_NELTS (op0
);
16167 tree
*elts
= XALLOCAVEC (tree
, count
);
16168 gcc_assert (VECTOR_CST_NELTS (op1
) == count
16169 && TYPE_VECTOR_SUBPARTS (type
) == count
);
16171 for (unsigned i
= 0; i
< count
; i
++)
16173 tree elem_type
= TREE_TYPE (type
);
16174 tree elem0
= VECTOR_CST_ELT (op0
, i
);
16175 tree elem1
= VECTOR_CST_ELT (op1
, i
);
16177 tree tem
= fold_relational_const (code
, elem_type
,
16180 if (tem
== NULL_TREE
)
16183 elts
[i
] = build_int_cst (elem_type
, integer_zerop (tem
) ? 0 : -1);
16186 return build_vector (type
, elts
);
16189 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16191 To compute GT, swap the arguments and do LT.
16192 To compute GE, do LT and invert the result.
16193 To compute LE, swap the arguments, do LT and invert the result.
16194 To compute NE, do EQ and invert the result.
16196 Therefore, the code below must handle only EQ and LT. */
16198 if (code
== LE_EXPR
|| code
== GT_EXPR
)
16203 code
= swap_tree_comparison (code
);
16206 /* Note that it is safe to invert for real values here because we
16207 have already handled the one case that it matters. */
16210 if (code
== NE_EXPR
|| code
== GE_EXPR
)
16213 code
= invert_tree_comparison (code
, false);
16216 /* Compute a result for LT or EQ if args permit;
16217 Otherwise return T. */
16218 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
16220 if (code
== EQ_EXPR
)
16221 result
= tree_int_cst_equal (op0
, op1
);
16223 result
= tree_int_cst_lt (op0
, op1
);
16230 return constant_boolean_node (result
, type
);
16233 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16234 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16238 fold_build_cleanup_point_expr (tree type
, tree expr
)
16240 /* If the expression does not have side effects then we don't have to wrap
16241 it with a cleanup point expression. */
16242 if (!TREE_SIDE_EFFECTS (expr
))
16245 /* If the expression is a return, check to see if the expression inside the
16246 return has no side effects or the right hand side of the modify expression
16247 inside the return. If either don't have side effects set we don't need to
16248 wrap the expression in a cleanup point expression. Note we don't check the
16249 left hand side of the modify because it should always be a return decl. */
16250 if (TREE_CODE (expr
) == RETURN_EXPR
)
16252 tree op
= TREE_OPERAND (expr
, 0);
16253 if (!op
|| !TREE_SIDE_EFFECTS (op
))
16255 op
= TREE_OPERAND (op
, 1);
16256 if (!TREE_SIDE_EFFECTS (op
))
16260 return build1 (CLEANUP_POINT_EXPR
, type
, expr
);
16263 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16264 of an indirection through OP0, or NULL_TREE if no simplification is
16268 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
16274 subtype
= TREE_TYPE (sub
);
16275 if (!POINTER_TYPE_P (subtype
))
16278 if (TREE_CODE (sub
) == ADDR_EXPR
)
16280 tree op
= TREE_OPERAND (sub
, 0);
16281 tree optype
= TREE_TYPE (op
);
16282 /* *&CONST_DECL -> to the value of the const decl. */
16283 if (TREE_CODE (op
) == CONST_DECL
)
16284 return DECL_INITIAL (op
);
16285 /* *&p => p; make sure to handle *&"str"[cst] here. */
16286 if (type
== optype
)
16288 tree fop
= fold_read_from_constant_string (op
);
16294 /* *(foo *)&fooarray => fooarray[0] */
16295 else if (TREE_CODE (optype
) == ARRAY_TYPE
16296 && type
== TREE_TYPE (optype
)
16297 && (!in_gimple_form
16298 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16300 tree type_domain
= TYPE_DOMAIN (optype
);
16301 tree min_val
= size_zero_node
;
16302 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16303 min_val
= TYPE_MIN_VALUE (type_domain
);
16305 && TREE_CODE (min_val
) != INTEGER_CST
)
16307 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
16308 NULL_TREE
, NULL_TREE
);
16310 /* *(foo *)&complexfoo => __real__ complexfoo */
16311 else if (TREE_CODE (optype
) == COMPLEX_TYPE
16312 && type
== TREE_TYPE (optype
))
16313 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
16314 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16315 else if (TREE_CODE (optype
) == VECTOR_TYPE
16316 && type
== TREE_TYPE (optype
))
16318 tree part_width
= TYPE_SIZE (type
);
16319 tree index
= bitsize_int (0);
16320 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
16324 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
16325 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
16327 tree op00
= TREE_OPERAND (sub
, 0);
16328 tree op01
= TREE_OPERAND (sub
, 1);
16331 if (TREE_CODE (op00
) == ADDR_EXPR
)
16334 op00
= TREE_OPERAND (op00
, 0);
16335 op00type
= TREE_TYPE (op00
);
16337 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16338 if (TREE_CODE (op00type
) == VECTOR_TYPE
16339 && type
== TREE_TYPE (op00type
))
16341 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
16342 tree part_width
= TYPE_SIZE (type
);
16343 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
16344 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
16345 tree index
= bitsize_int (indexi
);
16347 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
16348 return fold_build3_loc (loc
,
16349 BIT_FIELD_REF
, type
, op00
,
16350 part_width
, index
);
16353 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16354 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
16355 && type
== TREE_TYPE (op00type
))
16357 tree size
= TYPE_SIZE_UNIT (type
);
16358 if (tree_int_cst_equal (size
, op01
))
16359 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
16361 /* ((foo *)&fooarray)[1] => fooarray[1] */
16362 else if (TREE_CODE (op00type
) == ARRAY_TYPE
16363 && type
== TREE_TYPE (op00type
))
16365 tree type_domain
= TYPE_DOMAIN (op00type
);
16366 tree min_val
= size_zero_node
;
16367 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16368 min_val
= TYPE_MIN_VALUE (type_domain
);
16369 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
16370 TYPE_SIZE_UNIT (type
));
16371 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
16372 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
16373 NULL_TREE
, NULL_TREE
);
16378 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16379 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
16380 && type
== TREE_TYPE (TREE_TYPE (subtype
))
16381 && (!in_gimple_form
16382 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16385 tree min_val
= size_zero_node
;
16386 sub
= build_fold_indirect_ref_loc (loc
, sub
);
16387 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
16388 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16389 min_val
= TYPE_MIN_VALUE (type_domain
);
16391 && TREE_CODE (min_val
) != INTEGER_CST
)
16393 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
16400 /* Builds an expression for an indirection through T, simplifying some
16404 build_fold_indirect_ref_loc (location_t loc
, tree t
)
16406 tree type
= TREE_TYPE (TREE_TYPE (t
));
16407 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
16412 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
16415 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16418 fold_indirect_ref_loc (location_t loc
, tree t
)
16420 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
16428 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16429 whose result is ignored. The type of the returned tree need not be
16430 the same as the original expression. */
16433 fold_ignored_result (tree t
)
16435 if (!TREE_SIDE_EFFECTS (t
))
16436 return integer_zero_node
;
16439 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
16442 t
= TREE_OPERAND (t
, 0);
16446 case tcc_comparison
:
16447 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16448 t
= TREE_OPERAND (t
, 0);
16449 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
16450 t
= TREE_OPERAND (t
, 1);
16455 case tcc_expression
:
16456 switch (TREE_CODE (t
))
16458 case COMPOUND_EXPR
:
16459 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16461 t
= TREE_OPERAND (t
, 0);
16465 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
16466 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
16468 t
= TREE_OPERAND (t
, 0);
16481 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
16484 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
16486 tree div
= NULL_TREE
;
16491 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16492 have to do anything. Only do this when we are not given a const,
16493 because in that case, this check is more expensive than just
16495 if (TREE_CODE (value
) != INTEGER_CST
)
16497 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16499 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16503 /* If divisor is a power of two, simplify this to bit manipulation. */
16504 if (divisor
== (divisor
& -divisor
))
16506 if (TREE_CODE (value
) == INTEGER_CST
)
16508 wide_int val
= value
;
16511 if ((val
& (divisor
- 1)) == 0)
16514 overflow_p
= TREE_OVERFLOW (value
);
16515 val
&= ~(divisor
- 1);
16520 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
16526 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
16527 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
16528 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16529 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16535 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16536 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
16537 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16543 /* Likewise, but round down. */
16546 round_down_loc (location_t loc
, tree value
, int divisor
)
16548 tree div
= NULL_TREE
;
16550 gcc_assert (divisor
> 0);
16554 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16555 have to do anything. Only do this when we are not given a const,
16556 because in that case, this check is more expensive than just
16558 if (TREE_CODE (value
) != INTEGER_CST
)
16560 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16562 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16566 /* If divisor is a power of two, simplify this to bit manipulation. */
16567 if (divisor
== (divisor
& -divisor
))
16571 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16572 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16577 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16578 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
16579 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16585 /* Returns the pointer to the base of the object addressed by EXP and
16586 extracts the information about the offset of the access, storing it
16587 to PBITPOS and POFFSET. */
16590 split_address_to_core_and_offset (tree exp
,
16591 HOST_WIDE_INT
*pbitpos
, tree
*poffset
)
16594 enum machine_mode mode
;
16595 int unsignedp
, volatilep
;
16596 HOST_WIDE_INT bitsize
;
16597 location_t loc
= EXPR_LOCATION (exp
);
16599 if (TREE_CODE (exp
) == ADDR_EXPR
)
16601 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
16602 poffset
, &mode
, &unsignedp
, &volatilep
,
16604 core
= build_fold_addr_expr_loc (loc
, core
);
16610 *poffset
= NULL_TREE
;
16616 /* Returns true if addresses of E1 and E2 differ by a constant, false
16617 otherwise. If they do, E1 - E2 is stored in *DIFF. */
16620 ptr_difference_const (tree e1
, tree e2
, HOST_WIDE_INT
*diff
)
16623 HOST_WIDE_INT bitpos1
, bitpos2
;
16624 tree toffset1
, toffset2
, tdiff
, type
;
16626 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
16627 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
16629 if (bitpos1
% BITS_PER_UNIT
!= 0
16630 || bitpos2
% BITS_PER_UNIT
!= 0
16631 || !operand_equal_p (core1
, core2
, 0))
16634 if (toffset1
&& toffset2
)
16636 type
= TREE_TYPE (toffset1
);
16637 if (type
!= TREE_TYPE (toffset2
))
16638 toffset2
= fold_convert (type
, toffset2
);
16640 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
16641 if (!cst_and_fits_in_hwi (tdiff
))
16644 *diff
= int_cst_value (tdiff
);
16646 else if (toffset1
|| toffset2
)
16648 /* If only one of the offsets is non-constant, the difference cannot
16655 *diff
+= (bitpos1
- bitpos2
) / BITS_PER_UNIT
;
16659 /* Simplify the floating point expression EXP when the sign of the
16660 result is not significant. Return NULL_TREE if no simplification
16664 fold_strip_sign_ops (tree exp
)
16667 location_t loc
= EXPR_LOCATION (exp
);
16669 switch (TREE_CODE (exp
))
16673 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16674 return arg0
? arg0
: TREE_OPERAND (exp
, 0);
16678 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp
))))
16680 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16681 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16682 if (arg0
!= NULL_TREE
|| arg1
!= NULL_TREE
)
16683 return fold_build2_loc (loc
, TREE_CODE (exp
), TREE_TYPE (exp
),
16684 arg0
? arg0
: TREE_OPERAND (exp
, 0),
16685 arg1
? arg1
: TREE_OPERAND (exp
, 1));
16688 case COMPOUND_EXPR
:
16689 arg0
= TREE_OPERAND (exp
, 0);
16690 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16692 return fold_build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (exp
), arg0
, arg1
);
16696 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16697 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 2));
16699 return fold_build3_loc (loc
,
16700 COND_EXPR
, TREE_TYPE (exp
), TREE_OPERAND (exp
, 0),
16701 arg0
? arg0
: TREE_OPERAND (exp
, 1),
16702 arg1
? arg1
: TREE_OPERAND (exp
, 2));
16707 const enum built_in_function fcode
= builtin_mathfn_code (exp
);
16710 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
16711 /* Strip copysign function call, return the 1st argument. */
16712 arg0
= CALL_EXPR_ARG (exp
, 0);
16713 arg1
= CALL_EXPR_ARG (exp
, 1);
16714 return omit_one_operand_loc (loc
, TREE_TYPE (exp
), arg0
, arg1
);
16717 /* Strip sign ops from the argument of "odd" math functions. */
16718 if (negate_mathfn_p (fcode
))
16720 arg0
= fold_strip_sign_ops (CALL_EXPR_ARG (exp
, 0));
16722 return build_call_expr_loc (loc
, get_callee_fndecl (exp
), 1, arg0
);