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 tem
= fold_relational_const (code
, type
, arg0
, arg1
);
8725 if (tem
!= NULL_TREE
)
8728 /* If one arg is a real or integer constant, put it last. */
8729 if (tree_swap_operands_p (arg0
, arg1
, true))
8730 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
8732 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8733 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8734 && (equality_code
|| TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8735 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8736 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
8737 && TREE_CODE (arg1
) == INTEGER_CST
8738 && !TREE_OVERFLOW (arg1
))
8740 const enum tree_code
8741 reverse_op
= TREE_CODE (arg0
) == PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
;
8742 tree const1
= TREE_OPERAND (arg0
, 1);
8743 tree const2
= fold_convert_loc (loc
, TREE_TYPE (const1
), arg1
);
8744 tree variable
= TREE_OPERAND (arg0
, 0);
8745 tree new_const
= int_const_binop (reverse_op
, const2
, const1
);
8747 /* If the constant operation overflowed this can be
8748 simplified as a comparison against INT_MAX/INT_MIN. */
8749 if (TREE_OVERFLOW (new_const
))
8751 int const1_sgn
= tree_int_cst_sgn (const1
);
8752 enum tree_code code2
= code
;
8754 /* Get the sign of the constant on the lhs if the
8755 operation were VARIABLE + CONST1. */
8756 if (TREE_CODE (arg0
) == MINUS_EXPR
)
8757 const1_sgn
= -const1_sgn
;
8759 /* The sign of the constant determines if we overflowed
8760 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8761 Canonicalize to the INT_MIN overflow by swapping the comparison
8763 if (const1_sgn
== -1)
8764 code2
= swap_tree_comparison (code
);
8766 /* We now can look at the canonicalized case
8767 VARIABLE + 1 CODE2 INT_MIN
8768 and decide on the result. */
8775 omit_one_operand_loc (loc
, type
, boolean_false_node
, variable
);
8781 omit_one_operand_loc (loc
, type
, boolean_true_node
, variable
);
8790 fold_overflow_warning ("assuming signed overflow does not occur "
8791 "when changing X +- C1 cmp C2 to "
8793 WARN_STRICT_OVERFLOW_COMPARISON
);
8794 return fold_build2_loc (loc
, code
, type
, variable
, new_const
);
8798 /* Transform comparisons of the form X - Y CMP 0 to X CMP Y. */
8799 if (TREE_CODE (arg0
) == MINUS_EXPR
8801 && integer_zerop (arg1
))
8803 /* ??? The transformation is valid for the other operators if overflow
8804 is undefined for the type, but performing it here badly interacts
8805 with the transformation in fold_cond_expr_with_comparison which
8806 attempts to synthetize ABS_EXPR. */
8808 fold_overflow_warning ("assuming signed overflow does not occur "
8809 "when changing X - Y cmp 0 to X cmp Y",
8810 WARN_STRICT_OVERFLOW_COMPARISON
);
8811 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
8812 TREE_OPERAND (arg0
, 1));
8815 /* For comparisons of pointers we can decompose it to a compile time
8816 comparison of the base objects and the offsets into the object.
8817 This requires at least one operand being an ADDR_EXPR or a
8818 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8819 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
8820 && (TREE_CODE (arg0
) == ADDR_EXPR
8821 || TREE_CODE (arg1
) == ADDR_EXPR
8822 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8823 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
8825 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
8826 HOST_WIDE_INT bitsize
, bitpos0
= 0, bitpos1
= 0;
8827 enum machine_mode mode
;
8828 int volatilep
, unsignedp
;
8829 bool indirect_base0
= false, indirect_base1
= false;
8831 /* Get base and offset for the access. Strip ADDR_EXPR for
8832 get_inner_reference, but put it back by stripping INDIRECT_REF
8833 off the base object if possible. indirect_baseN will be true
8834 if baseN is not an address but refers to the object itself. */
8836 if (TREE_CODE (arg0
) == ADDR_EXPR
)
8838 base0
= get_inner_reference (TREE_OPERAND (arg0
, 0),
8839 &bitsize
, &bitpos0
, &offset0
, &mode
,
8840 &unsignedp
, &volatilep
, false);
8841 if (TREE_CODE (base0
) == INDIRECT_REF
)
8842 base0
= TREE_OPERAND (base0
, 0);
8844 indirect_base0
= true;
8846 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
8848 base0
= TREE_OPERAND (arg0
, 0);
8849 STRIP_SIGN_NOPS (base0
);
8850 if (TREE_CODE (base0
) == ADDR_EXPR
)
8852 base0
= TREE_OPERAND (base0
, 0);
8853 indirect_base0
= true;
8855 offset0
= TREE_OPERAND (arg0
, 1);
8856 if (tree_fits_shwi_p (offset0
))
8858 HOST_WIDE_INT off
= size_low_cst (offset0
);
8859 if ((HOST_WIDE_INT
) (((unsigned HOST_WIDE_INT
) off
)
8861 / BITS_PER_UNIT
== (HOST_WIDE_INT
) off
)
8863 bitpos0
= off
* BITS_PER_UNIT
;
8864 offset0
= NULL_TREE
;
8870 if (TREE_CODE (arg1
) == ADDR_EXPR
)
8872 base1
= get_inner_reference (TREE_OPERAND (arg1
, 0),
8873 &bitsize
, &bitpos1
, &offset1
, &mode
,
8874 &unsignedp
, &volatilep
, false);
8875 if (TREE_CODE (base1
) == INDIRECT_REF
)
8876 base1
= TREE_OPERAND (base1
, 0);
8878 indirect_base1
= true;
8880 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
8882 base1
= TREE_OPERAND (arg1
, 0);
8883 STRIP_SIGN_NOPS (base1
);
8884 if (TREE_CODE (base1
) == ADDR_EXPR
)
8886 base1
= TREE_OPERAND (base1
, 0);
8887 indirect_base1
= true;
8889 offset1
= TREE_OPERAND (arg1
, 1);
8890 if (tree_fits_shwi_p (offset1
))
8892 HOST_WIDE_INT off
= size_low_cst (offset1
);
8893 if ((HOST_WIDE_INT
) (((unsigned HOST_WIDE_INT
) off
)
8895 / BITS_PER_UNIT
== (HOST_WIDE_INT
) off
)
8897 bitpos1
= off
* BITS_PER_UNIT
;
8898 offset1
= NULL_TREE
;
8903 /* A local variable can never be pointed to by
8904 the default SSA name of an incoming parameter. */
8905 if ((TREE_CODE (arg0
) == ADDR_EXPR
8907 && TREE_CODE (base0
) == VAR_DECL
8908 && auto_var_in_fn_p (base0
, current_function_decl
)
8910 && TREE_CODE (base1
) == SSA_NAME
8911 && SSA_NAME_IS_DEFAULT_DEF (base1
)
8912 && TREE_CODE (SSA_NAME_VAR (base1
)) == PARM_DECL
)
8913 || (TREE_CODE (arg1
) == ADDR_EXPR
8915 && TREE_CODE (base1
) == VAR_DECL
8916 && auto_var_in_fn_p (base1
, current_function_decl
)
8918 && TREE_CODE (base0
) == SSA_NAME
8919 && SSA_NAME_IS_DEFAULT_DEF (base0
)
8920 && TREE_CODE (SSA_NAME_VAR (base0
)) == PARM_DECL
))
8922 if (code
== NE_EXPR
)
8923 return constant_boolean_node (1, type
);
8924 else if (code
== EQ_EXPR
)
8925 return constant_boolean_node (0, type
);
8927 /* If we have equivalent bases we might be able to simplify. */
8928 else if (indirect_base0
== indirect_base1
8929 && operand_equal_p (base0
, base1
, 0))
8931 /* We can fold this expression to a constant if the non-constant
8932 offset parts are equal. */
8933 if ((offset0
== offset1
8934 || (offset0
&& offset1
8935 && operand_equal_p (offset0
, offset1
, 0)))
8938 || (indirect_base0
&& DECL_P (base0
))
8939 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8943 && bitpos0
!= bitpos1
8944 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8945 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8946 fold_overflow_warning (("assuming pointer wraparound does not "
8947 "occur when comparing P +- C1 with "
8949 WARN_STRICT_OVERFLOW_CONDITIONAL
);
8954 return constant_boolean_node (bitpos0
== bitpos1
, type
);
8956 return constant_boolean_node (bitpos0
!= bitpos1
, type
);
8958 return constant_boolean_node (bitpos0
< bitpos1
, type
);
8960 return constant_boolean_node (bitpos0
<= bitpos1
, type
);
8962 return constant_boolean_node (bitpos0
>= bitpos1
, type
);
8964 return constant_boolean_node (bitpos0
> bitpos1
, type
);
8968 /* We can simplify the comparison to a comparison of the variable
8969 offset parts if the constant offset parts are equal.
8970 Be careful to use signed sizetype here because otherwise we
8971 mess with array offsets in the wrong way. This is possible
8972 because pointer arithmetic is restricted to retain within an
8973 object and overflow on pointer differences is undefined as of
8974 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
8975 else if (bitpos0
== bitpos1
8977 || (indirect_base0
&& DECL_P (base0
))
8978 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8980 /* By converting to signed sizetype we cover middle-end pointer
8981 arithmetic which operates on unsigned pointer types of size
8982 type size and ARRAY_REF offsets which are properly sign or
8983 zero extended from their type in case it is narrower than
8985 if (offset0
== NULL_TREE
)
8986 offset0
= build_int_cst (ssizetype
, 0);
8988 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
8989 if (offset1
== NULL_TREE
)
8990 offset1
= build_int_cst (ssizetype
, 0);
8992 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
8995 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8996 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8997 fold_overflow_warning (("assuming pointer wraparound does not "
8998 "occur when comparing P +- C1 with "
9000 WARN_STRICT_OVERFLOW_COMPARISON
);
9002 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
9005 /* For non-equal bases we can simplify if they are addresses
9006 of local binding decls or constants. */
9007 else if (indirect_base0
&& indirect_base1
9008 /* We know that !operand_equal_p (base0, base1, 0)
9009 because the if condition was false. But make
9010 sure two decls are not the same. */
9012 && TREE_CODE (arg0
) == ADDR_EXPR
9013 && TREE_CODE (arg1
) == ADDR_EXPR
9014 && (((TREE_CODE (base0
) == VAR_DECL
9015 || TREE_CODE (base0
) == PARM_DECL
)
9016 && (targetm
.binds_local_p (base0
)
9017 || CONSTANT_CLASS_P (base1
)))
9018 || CONSTANT_CLASS_P (base0
))
9019 && (((TREE_CODE (base1
) == VAR_DECL
9020 || TREE_CODE (base1
) == PARM_DECL
)
9021 && (targetm
.binds_local_p (base1
)
9022 || CONSTANT_CLASS_P (base0
)))
9023 || CONSTANT_CLASS_P (base1
)))
9025 if (code
== EQ_EXPR
)
9026 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
9028 else if (code
== NE_EXPR
)
9029 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
9032 /* For equal offsets we can simplify to a comparison of the
9034 else if (bitpos0
== bitpos1
9036 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
9038 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
9039 && ((offset0
== offset1
)
9040 || (offset0
&& offset1
9041 && operand_equal_p (offset0
, offset1
, 0))))
9044 base0
= build_fold_addr_expr_loc (loc
, base0
);
9046 base1
= build_fold_addr_expr_loc (loc
, base1
);
9047 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
9051 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9052 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9053 the resulting offset is smaller in absolute value than the
9054 original one and has the same sign. */
9055 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
9056 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
9057 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9058 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
9059 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
9060 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
9061 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
9063 tree const1
= TREE_OPERAND (arg0
, 1);
9064 tree const2
= TREE_OPERAND (arg1
, 1);
9065 tree variable1
= TREE_OPERAND (arg0
, 0);
9066 tree variable2
= TREE_OPERAND (arg1
, 0);
9068 const char * const warnmsg
= G_("assuming signed overflow does not "
9069 "occur when combining constants around "
9072 /* Put the constant on the side where it doesn't overflow and is
9073 of lower absolute value and of same sign than before. */
9074 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
9075 ? MINUS_EXPR
: PLUS_EXPR
,
9077 if (!TREE_OVERFLOW (cst
)
9078 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
)
9079 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const2
))
9081 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
9082 return fold_build2_loc (loc
, code
, type
,
9084 fold_build2_loc (loc
, TREE_CODE (arg1
),
9089 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
9090 ? MINUS_EXPR
: PLUS_EXPR
,
9092 if (!TREE_OVERFLOW (cst
)
9093 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
)
9094 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const1
))
9096 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
9097 return fold_build2_loc (loc
, code
, type
,
9098 fold_build2_loc (loc
, TREE_CODE (arg0
),
9105 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9106 signed arithmetic case. That form is created by the compiler
9107 often enough for folding it to be of value. One example is in
9108 computing loop trip counts after Operator Strength Reduction. */
9109 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
9110 && TREE_CODE (arg0
) == MULT_EXPR
9111 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9112 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
9113 && integer_zerop (arg1
))
9115 tree const1
= TREE_OPERAND (arg0
, 1);
9116 tree const2
= arg1
; /* zero */
9117 tree variable1
= TREE_OPERAND (arg0
, 0);
9118 enum tree_code cmp_code
= code
;
9120 /* Handle unfolded multiplication by zero. */
9121 if (integer_zerop (const1
))
9122 return fold_build2_loc (loc
, cmp_code
, type
, const1
, const2
);
9124 fold_overflow_warning (("assuming signed overflow does not occur when "
9125 "eliminating multiplication in comparison "
9127 WARN_STRICT_OVERFLOW_COMPARISON
);
9129 /* If const1 is negative we swap the sense of the comparison. */
9130 if (tree_int_cst_sgn (const1
) < 0)
9131 cmp_code
= swap_tree_comparison (cmp_code
);
9133 return fold_build2_loc (loc
, cmp_code
, type
, variable1
, const2
);
9136 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
9140 if (FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9142 tree targ0
= strip_float_extensions (arg0
);
9143 tree targ1
= strip_float_extensions (arg1
);
9144 tree newtype
= TREE_TYPE (targ0
);
9146 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
9147 newtype
= TREE_TYPE (targ1
);
9149 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9150 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
9151 return fold_build2_loc (loc
, code
, type
,
9152 fold_convert_loc (loc
, newtype
, targ0
),
9153 fold_convert_loc (loc
, newtype
, targ1
));
9155 /* (-a) CMP (-b) -> b CMP a */
9156 if (TREE_CODE (arg0
) == NEGATE_EXPR
9157 && TREE_CODE (arg1
) == NEGATE_EXPR
)
9158 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg1
, 0),
9159 TREE_OPERAND (arg0
, 0));
9161 if (TREE_CODE (arg1
) == REAL_CST
)
9163 REAL_VALUE_TYPE cst
;
9164 cst
= TREE_REAL_CST (arg1
);
9166 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9167 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
9168 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9169 TREE_OPERAND (arg0
, 0),
9170 build_real (TREE_TYPE (arg1
),
9171 real_value_negate (&cst
)));
9173 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9174 /* a CMP (-0) -> a CMP 0 */
9175 if (REAL_VALUE_MINUS_ZERO (cst
))
9176 return fold_build2_loc (loc
, code
, type
, arg0
,
9177 build_real (TREE_TYPE (arg1
), dconst0
));
9179 /* x != NaN is always true, other ops are always false. */
9180 if (REAL_VALUE_ISNAN (cst
)
9181 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
))))
9183 tem
= (code
== NE_EXPR
) ? integer_one_node
: integer_zero_node
;
9184 return omit_one_operand_loc (loc
, type
, tem
, arg0
);
9187 /* Fold comparisons against infinity. */
9188 if (REAL_VALUE_ISINF (cst
)
9189 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
))))
9191 tem
= fold_inf_compare (loc
, code
, type
, arg0
, arg1
);
9192 if (tem
!= NULL_TREE
)
9197 /* If this is a comparison of a real constant with a PLUS_EXPR
9198 or a MINUS_EXPR of a real constant, we can convert it into a
9199 comparison with a revised real constant as long as no overflow
9200 occurs when unsafe_math_optimizations are enabled. */
9201 if (flag_unsafe_math_optimizations
9202 && TREE_CODE (arg1
) == REAL_CST
9203 && (TREE_CODE (arg0
) == PLUS_EXPR
9204 || TREE_CODE (arg0
) == MINUS_EXPR
)
9205 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
9206 && 0 != (tem
= const_binop (TREE_CODE (arg0
) == PLUS_EXPR
9207 ? MINUS_EXPR
: PLUS_EXPR
,
9208 arg1
, TREE_OPERAND (arg0
, 1)))
9209 && !TREE_OVERFLOW (tem
))
9210 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
9212 /* Likewise, we can simplify a comparison of a real constant with
9213 a MINUS_EXPR whose first operand is also a real constant, i.e.
9214 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9215 floating-point types only if -fassociative-math is set. */
9216 if (flag_associative_math
9217 && TREE_CODE (arg1
) == REAL_CST
9218 && TREE_CODE (arg0
) == MINUS_EXPR
9219 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
9220 && 0 != (tem
= const_binop (MINUS_EXPR
, TREE_OPERAND (arg0
, 0),
9222 && !TREE_OVERFLOW (tem
))
9223 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9224 TREE_OPERAND (arg0
, 1), tem
);
9226 /* Fold comparisons against built-in math functions. */
9227 if (TREE_CODE (arg1
) == REAL_CST
9228 && flag_unsafe_math_optimizations
9229 && ! flag_errno_math
)
9231 enum built_in_function fcode
= builtin_mathfn_code (arg0
);
9233 if (fcode
!= END_BUILTINS
)
9235 tem
= fold_mathfn_compare (loc
, fcode
, code
, type
, arg0
, arg1
);
9236 if (tem
!= NULL_TREE
)
9242 if (TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
9243 && CONVERT_EXPR_P (arg0
))
9245 /* If we are widening one operand of an integer comparison,
9246 see if the other operand is similarly being widened. Perhaps we
9247 can do the comparison in the narrower type. */
9248 tem
= fold_widened_comparison (loc
, code
, type
, arg0
, arg1
);
9252 /* Or if we are changing signedness. */
9253 tem
= fold_sign_changed_comparison (loc
, code
, type
, arg0
, arg1
);
9258 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9259 constant, we can simplify it. */
9260 if (TREE_CODE (arg1
) == INTEGER_CST
9261 && (TREE_CODE (arg0
) == MIN_EXPR
9262 || TREE_CODE (arg0
) == MAX_EXPR
)
9263 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
9265 tem
= optimize_minmax_comparison (loc
, code
, type
, op0
, op1
);
9270 /* Simplify comparison of something with itself. (For IEEE
9271 floating-point, we can only do some of these simplifications.) */
9272 if (operand_equal_p (arg0
, arg1
, 0))
9277 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
))
9278 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9279 return constant_boolean_node (1, type
);
9284 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
))
9285 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9286 return constant_boolean_node (1, type
);
9287 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
, arg1
);
9290 /* For NE, we can only do this simplification if integer
9291 or we don't honor IEEE floating point NaNs. */
9292 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
9293 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9295 /* ... fall through ... */
9298 return constant_boolean_node (0, type
);
9304 /* If we are comparing an expression that just has comparisons
9305 of two integer values, arithmetic expressions of those comparisons,
9306 and constants, we can simplify it. There are only three cases
9307 to check: the two values can either be equal, the first can be
9308 greater, or the second can be greater. Fold the expression for
9309 those three values. Since each value must be 0 or 1, we have
9310 eight possibilities, each of which corresponds to the constant 0
9311 or 1 or one of the six possible comparisons.
9313 This handles common cases like (a > b) == 0 but also handles
9314 expressions like ((x > y) - (y > x)) > 0, which supposedly
9315 occur in macroized code. */
9317 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
9319 tree cval1
= 0, cval2
= 0;
9322 if (twoval_comparison_p (arg0
, &cval1
, &cval2
, &save_p
)
9323 /* Don't handle degenerate cases here; they should already
9324 have been handled anyway. */
9325 && cval1
!= 0 && cval2
!= 0
9326 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
9327 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
9328 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
9329 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
9330 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
9331 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
9332 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
9334 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
9335 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
9337 /* We can't just pass T to eval_subst in case cval1 or cval2
9338 was the same as ARG1. */
9341 = fold_build2_loc (loc
, code
, type
,
9342 eval_subst (loc
, arg0
, cval1
, maxval
,
9346 = fold_build2_loc (loc
, code
, type
,
9347 eval_subst (loc
, arg0
, cval1
, maxval
,
9351 = fold_build2_loc (loc
, code
, type
,
9352 eval_subst (loc
, arg0
, cval1
, minval
,
9356 /* All three of these results should be 0 or 1. Confirm they are.
9357 Then use those values to select the proper code to use. */
9359 if (TREE_CODE (high_result
) == INTEGER_CST
9360 && TREE_CODE (equal_result
) == INTEGER_CST
9361 && TREE_CODE (low_result
) == INTEGER_CST
)
9363 /* Make a 3-bit mask with the high-order bit being the
9364 value for `>', the next for '=', and the low for '<'. */
9365 switch ((integer_onep (high_result
) * 4)
9366 + (integer_onep (equal_result
) * 2)
9367 + integer_onep (low_result
))
9371 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
9392 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
9397 tem
= save_expr (build2 (code
, type
, cval1
, cval2
));
9398 SET_EXPR_LOCATION (tem
, loc
);
9401 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
9406 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9407 into a single range test. */
9408 if ((TREE_CODE (arg0
) == TRUNC_DIV_EXPR
9409 || TREE_CODE (arg0
) == EXACT_DIV_EXPR
)
9410 && TREE_CODE (arg1
) == INTEGER_CST
9411 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9412 && !integer_zerop (TREE_OPERAND (arg0
, 1))
9413 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
9414 && !TREE_OVERFLOW (arg1
))
9416 tem
= fold_div_compare (loc
, code
, type
, arg0
, arg1
);
9417 if (tem
!= NULL_TREE
)
9421 /* Fold ~X op ~Y as Y op X. */
9422 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9423 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
9425 tree cmp_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
9426 return fold_build2_loc (loc
, code
, type
,
9427 fold_convert_loc (loc
, cmp_type
,
9428 TREE_OPERAND (arg1
, 0)),
9429 TREE_OPERAND (arg0
, 0));
9432 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9433 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9434 && (TREE_CODE (arg1
) == INTEGER_CST
|| TREE_CODE (arg1
) == VECTOR_CST
))
9436 tree cmp_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
9437 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9438 TREE_OPERAND (arg0
, 0),
9439 fold_build1_loc (loc
, BIT_NOT_EXPR
, cmp_type
,
9440 fold_convert_loc (loc
, cmp_type
, arg1
)));
9447 /* Subroutine of fold_binary. Optimize complex multiplications of the
9448 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9449 argument EXPR represents the expression "z" of type TYPE. */
9452 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
9454 tree itype
= TREE_TYPE (type
);
9455 tree rpart
, ipart
, tem
;
9457 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
9459 rpart
= TREE_OPERAND (expr
, 0);
9460 ipart
= TREE_OPERAND (expr
, 1);
9462 else if (TREE_CODE (expr
) == COMPLEX_CST
)
9464 rpart
= TREE_REALPART (expr
);
9465 ipart
= TREE_IMAGPART (expr
);
9469 expr
= save_expr (expr
);
9470 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
9471 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
9474 rpart
= save_expr (rpart
);
9475 ipart
= save_expr (ipart
);
9476 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
9477 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
9478 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
9479 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
9480 build_zero_cst (itype
));
9484 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9485 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9486 guarantees that P and N have the same least significant log2(M) bits.
9487 N is not otherwise constrained. In particular, N is not normalized to
9488 0 <= N < M as is common. In general, the precise value of P is unknown.
9489 M is chosen as large as possible such that constant N can be determined.
9491 Returns M and sets *RESIDUE to N.
9493 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9494 account. This is not always possible due to PR 35705.
9497 static unsigned HOST_WIDE_INT
9498 get_pointer_modulus_and_residue (tree expr
, unsigned HOST_WIDE_INT
*residue
,
9499 bool allow_func_align
)
9501 enum tree_code code
;
9505 code
= TREE_CODE (expr
);
9506 if (code
== ADDR_EXPR
)
9508 unsigned int bitalign
;
9509 get_object_alignment_1 (TREE_OPERAND (expr
, 0), &bitalign
, residue
);
9510 *residue
/= BITS_PER_UNIT
;
9511 return bitalign
/ BITS_PER_UNIT
;
9513 else if (code
== POINTER_PLUS_EXPR
)
9516 unsigned HOST_WIDE_INT modulus
;
9517 enum tree_code inner_code
;
9519 op0
= TREE_OPERAND (expr
, 0);
9521 modulus
= get_pointer_modulus_and_residue (op0
, residue
,
9524 op1
= TREE_OPERAND (expr
, 1);
9526 inner_code
= TREE_CODE (op1
);
9527 if (inner_code
== INTEGER_CST
)
9529 *residue
+= TREE_INT_CST_LOW (op1
);
9532 else if (inner_code
== MULT_EXPR
)
9534 op1
= TREE_OPERAND (op1
, 1);
9535 if (TREE_CODE (op1
) == INTEGER_CST
)
9537 unsigned HOST_WIDE_INT align
;
9539 /* Compute the greatest power-of-2 divisor of op1. */
9540 align
= TREE_INT_CST_LOW (op1
);
9543 /* If align is non-zero and less than *modulus, replace
9544 *modulus with align., If align is 0, then either op1 is 0
9545 or the greatest power-of-2 divisor of op1 doesn't fit in an
9546 unsigned HOST_WIDE_INT. In either case, no additional
9547 constraint is imposed. */
9549 modulus
= MIN (modulus
, align
);
9556 /* If we get here, we were unable to determine anything useful about the
9561 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
9562 CONSTRUCTOR ARG into array ELTS and return true if successful. */
9565 vec_cst_ctor_to_array (tree arg
, tree
*elts
)
9567 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg
)), i
;
9569 if (TREE_CODE (arg
) == VECTOR_CST
)
9571 for (i
= 0; i
< VECTOR_CST_NELTS (arg
); ++i
)
9572 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
9574 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
9576 constructor_elt
*elt
;
9578 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
9579 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
9582 elts
[i
] = elt
->value
;
9586 for (; i
< nelts
; i
++)
9588 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
9592 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
9593 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
9594 NULL_TREE otherwise. */
9597 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const unsigned char *sel
)
9599 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
9601 bool need_ctor
= false;
9603 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
9604 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
);
9605 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
9606 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
9609 elts
= XALLOCAVEC (tree
, nelts
* 3);
9610 if (!vec_cst_ctor_to_array (arg0
, elts
)
9611 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
))
9614 for (i
= 0; i
< nelts
; i
++)
9616 if (!CONSTANT_CLASS_P (elts
[sel
[i
]]))
9618 elts
[i
+ 2 * nelts
] = unshare_expr (elts
[sel
[i
]]);
9623 vec
<constructor_elt
, va_gc
> *v
;
9624 vec_alloc (v
, nelts
);
9625 for (i
= 0; i
< nelts
; i
++)
9626 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, elts
[2 * nelts
+ i
]);
9627 return build_constructor (type
, v
);
9630 return build_vector (type
, &elts
[2 * nelts
]);
9633 /* Try to fold a pointer difference of type TYPE two address expressions of
9634 array references AREF0 and AREF1 using location LOC. Return a
9635 simplified expression for the difference or NULL_TREE. */
9638 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
9639 tree aref0
, tree aref1
)
9641 tree base0
= TREE_OPERAND (aref0
, 0);
9642 tree base1
= TREE_OPERAND (aref1
, 0);
9643 tree base_offset
= build_int_cst (type
, 0);
9645 /* If the bases are array references as well, recurse. If the bases
9646 are pointer indirections compute the difference of the pointers.
9647 If the bases are equal, we are set. */
9648 if ((TREE_CODE (base0
) == ARRAY_REF
9649 && TREE_CODE (base1
) == ARRAY_REF
9651 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
)))
9652 || (INDIRECT_REF_P (base0
)
9653 && INDIRECT_REF_P (base1
)
9654 && (base_offset
= fold_binary_loc (loc
, MINUS_EXPR
, type
,
9655 TREE_OPERAND (base0
, 0),
9656 TREE_OPERAND (base1
, 0))))
9657 || operand_equal_p (base0
, base1
, 0))
9659 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
9660 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
9661 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
9662 tree diff
= build2 (MINUS_EXPR
, type
, op0
, op1
);
9663 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9665 fold_build2_loc (loc
, MULT_EXPR
, type
,
9671 /* If the real or vector real constant CST of type TYPE has an exact
9672 inverse, return it, else return NULL. */
9675 exact_inverse (tree type
, tree cst
)
9678 tree unit_type
, *elts
;
9679 enum machine_mode mode
;
9680 unsigned vec_nelts
, i
;
9682 switch (TREE_CODE (cst
))
9685 r
= TREE_REAL_CST (cst
);
9687 if (exact_real_inverse (TYPE_MODE (type
), &r
))
9688 return build_real (type
, r
);
9693 vec_nelts
= VECTOR_CST_NELTS (cst
);
9694 elts
= XALLOCAVEC (tree
, vec_nelts
);
9695 unit_type
= TREE_TYPE (type
);
9696 mode
= TYPE_MODE (unit_type
);
9698 for (i
= 0; i
< vec_nelts
; i
++)
9700 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
9701 if (!exact_real_inverse (mode
, &r
))
9703 elts
[i
] = build_real (unit_type
, r
);
9706 return build_vector (type
, elts
);
9713 /* Mask out the tz least significant bits of X of type TYPE where
9714 tz is the number of trailing zeroes in Y. */
9716 mask_with_tz (tree type
, const wide_int
&x
, const wide_int
&y
)
9718 int tz
= wi::ctz (y
);
9720 return wi::mask (tz
, true, TYPE_PRECISION (type
)) & x
;
9724 /* Return true when T is an address and is known to be nonzero.
9725 For floating point we further ensure that T is not denormal.
9726 Similar logic is present in nonzero_address in rtlanal.h.
9728 If the return value is based on the assumption that signed overflow
9729 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9730 change *STRICT_OVERFLOW_P. */
9733 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
9735 tree type
= TREE_TYPE (t
);
9736 enum tree_code code
;
9738 /* Doing something useful for floating point would need more work. */
9739 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
9742 code
= TREE_CODE (t
);
9743 switch (TREE_CODE_CLASS (code
))
9746 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9749 case tcc_comparison
:
9750 return tree_binary_nonzero_warnv_p (code
, type
,
9751 TREE_OPERAND (t
, 0),
9752 TREE_OPERAND (t
, 1),
9755 case tcc_declaration
:
9757 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9765 case TRUTH_NOT_EXPR
:
9766 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9769 case TRUTH_AND_EXPR
:
9771 case TRUTH_XOR_EXPR
:
9772 return tree_binary_nonzero_warnv_p (code
, type
,
9773 TREE_OPERAND (t
, 0),
9774 TREE_OPERAND (t
, 1),
9782 case WITH_SIZE_EXPR
:
9784 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9789 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
9793 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
9798 tree fndecl
= get_callee_fndecl (t
);
9799 if (!fndecl
) return false;
9800 if (flag_delete_null_pointer_checks
&& !flag_check_new
9801 && DECL_IS_OPERATOR_NEW (fndecl
)
9802 && !TREE_NOTHROW (fndecl
))
9804 if (flag_delete_null_pointer_checks
9805 && lookup_attribute ("returns_nonnull",
9806 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
9808 return alloca_call_p (t
);
9817 /* Return true when T is an address and is known to be nonzero.
9818 Handle warnings about undefined signed overflow. */
9821 tree_expr_nonzero_p (tree t
)
9823 bool ret
, strict_overflow_p
;
9825 strict_overflow_p
= false;
9826 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
9827 if (strict_overflow_p
)
9828 fold_overflow_warning (("assuming signed overflow does not occur when "
9829 "determining that expression is always "
9831 WARN_STRICT_OVERFLOW_MISC
);
9835 /* Fold a binary expression of code CODE and type TYPE with operands
9836 OP0 and OP1. LOC is the location of the resulting expression.
9837 Return the folded expression if folding is successful. Otherwise,
9838 return NULL_TREE. */
9841 fold_binary_loc (location_t loc
,
9842 enum tree_code code
, tree type
, tree op0
, tree op1
)
9844 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
9845 tree arg0
, arg1
, tem
;
9846 tree t1
= NULL_TREE
;
9847 bool strict_overflow_p
;
9850 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
9851 && TREE_CODE_LENGTH (code
) == 2
9853 && op1
!= NULL_TREE
);
9858 /* Strip any conversions that don't change the mode. This is
9859 safe for every expression, except for a comparison expression
9860 because its signedness is derived from its operands. So, in
9861 the latter case, only strip conversions that don't change the
9862 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9865 Note that this is done as an internal manipulation within the
9866 constant folder, in order to find the simplest representation
9867 of the arguments so that their form can be studied. In any
9868 cases, the appropriate type conversions should be put back in
9869 the tree that will get out of the constant folder. */
9871 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
9873 STRIP_SIGN_NOPS (arg0
);
9874 STRIP_SIGN_NOPS (arg1
);
9882 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9883 constant but we can't do arithmetic on them. */
9884 if ((TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
9885 || (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
9886 || (TREE_CODE (arg0
) == FIXED_CST
&& TREE_CODE (arg1
) == FIXED_CST
)
9887 || (TREE_CODE (arg0
) == FIXED_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
9888 || (TREE_CODE (arg0
) == COMPLEX_CST
&& TREE_CODE (arg1
) == COMPLEX_CST
)
9889 || (TREE_CODE (arg0
) == VECTOR_CST
&& TREE_CODE (arg1
) == VECTOR_CST
)
9890 || (TREE_CODE (arg0
) == VECTOR_CST
&& TREE_CODE (arg1
) == INTEGER_CST
))
9892 if (kind
== tcc_binary
)
9894 /* Make sure type and arg0 have the same saturating flag. */
9895 gcc_assert (TYPE_SATURATING (type
)
9896 == TYPE_SATURATING (TREE_TYPE (arg0
)));
9897 tem
= const_binop (code
, arg0
, arg1
);
9899 else if (kind
== tcc_comparison
)
9900 tem
= fold_relational_const (code
, type
, arg0
, arg1
);
9904 if (tem
!= NULL_TREE
)
9906 if (TREE_TYPE (tem
) != type
)
9907 tem
= fold_convert_loc (loc
, type
, tem
);
9912 /* If this is a commutative operation, and ARG0 is a constant, move it
9913 to ARG1 to reduce the number of tests below. */
9914 if (commutative_tree_code (code
)
9915 && tree_swap_operands_p (arg0
, arg1
, true))
9916 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
9918 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9920 First check for cases where an arithmetic operation is applied to a
9921 compound, conditional, or comparison operation. Push the arithmetic
9922 operation inside the compound or conditional to see if any folding
9923 can then be done. Convert comparison to conditional for this purpose.
9924 The also optimizes non-constant cases that used to be done in
9927 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9928 one of the operands is a comparison and the other is a comparison, a
9929 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9930 code below would make the expression more complex. Change it to a
9931 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9932 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9934 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
9935 || code
== EQ_EXPR
|| code
== NE_EXPR
)
9936 && TREE_CODE (type
) != VECTOR_TYPE
9937 && ((truth_value_p (TREE_CODE (arg0
))
9938 && (truth_value_p (TREE_CODE (arg1
))
9939 || (TREE_CODE (arg1
) == BIT_AND_EXPR
9940 && integer_onep (TREE_OPERAND (arg1
, 1)))))
9941 || (truth_value_p (TREE_CODE (arg1
))
9942 && (truth_value_p (TREE_CODE (arg0
))
9943 || (TREE_CODE (arg0
) == BIT_AND_EXPR
9944 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
9946 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
9947 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
9950 fold_convert_loc (loc
, boolean_type_node
, arg0
),
9951 fold_convert_loc (loc
, boolean_type_node
, arg1
));
9953 if (code
== EQ_EXPR
)
9954 tem
= invert_truthvalue_loc (loc
, tem
);
9956 return fold_convert_loc (loc
, type
, tem
);
9959 if (TREE_CODE_CLASS (code
) == tcc_binary
9960 || TREE_CODE_CLASS (code
) == tcc_comparison
)
9962 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
9964 tem
= fold_build2_loc (loc
, code
, type
,
9965 fold_convert_loc (loc
, TREE_TYPE (op0
),
9966 TREE_OPERAND (arg0
, 1)), op1
);
9967 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
9970 if (TREE_CODE (arg1
) == COMPOUND_EXPR
9971 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
9973 tem
= fold_build2_loc (loc
, code
, type
, op0
,
9974 fold_convert_loc (loc
, TREE_TYPE (op1
),
9975 TREE_OPERAND (arg1
, 1)));
9976 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
9980 if (TREE_CODE (arg0
) == COND_EXPR
9981 || TREE_CODE (arg0
) == VEC_COND_EXPR
9982 || COMPARISON_CLASS_P (arg0
))
9984 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9986 /*cond_first_p=*/1);
9987 if (tem
!= NULL_TREE
)
9991 if (TREE_CODE (arg1
) == COND_EXPR
9992 || TREE_CODE (arg1
) == VEC_COND_EXPR
9993 || COMPARISON_CLASS_P (arg1
))
9995 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9997 /*cond_first_p=*/0);
9998 if (tem
!= NULL_TREE
)
10006 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
10007 if (TREE_CODE (arg0
) == ADDR_EXPR
10008 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
10010 tree iref
= TREE_OPERAND (arg0
, 0);
10011 return fold_build2 (MEM_REF
, type
,
10012 TREE_OPERAND (iref
, 0),
10013 int_const_binop (PLUS_EXPR
, arg1
,
10014 TREE_OPERAND (iref
, 1)));
10017 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
10018 if (TREE_CODE (arg0
) == ADDR_EXPR
10019 && handled_component_p (TREE_OPERAND (arg0
, 0)))
10022 HOST_WIDE_INT coffset
;
10023 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
10027 return fold_build2 (MEM_REF
, type
,
10028 build_fold_addr_expr (base
),
10029 int_const_binop (PLUS_EXPR
, arg1
,
10030 size_int (coffset
)));
10035 case POINTER_PLUS_EXPR
:
10036 /* 0 +p index -> (type)index */
10037 if (integer_zerop (arg0
))
10038 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10040 /* PTR +p 0 -> PTR */
10041 if (integer_zerop (arg1
))
10042 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10044 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
10045 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10046 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
10047 return fold_convert_loc (loc
, type
,
10048 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
10049 fold_convert_loc (loc
, sizetype
,
10051 fold_convert_loc (loc
, sizetype
,
10054 /* (PTR +p B) +p A -> PTR +p (B + A) */
10055 if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
10058 tree arg01
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (arg0
, 1));
10059 tree arg00
= TREE_OPERAND (arg0
, 0);
10060 inner
= fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
10061 arg01
, fold_convert_loc (loc
, sizetype
, arg1
));
10062 return fold_convert_loc (loc
, type
,
10063 fold_build_pointer_plus_loc (loc
,
10067 /* PTR_CST +p CST -> CST1 */
10068 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
10069 return fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
,
10070 fold_convert_loc (loc
, type
, arg1
));
10075 /* A + (-B) -> A - B */
10076 if (TREE_CODE (arg1
) == NEGATE_EXPR
10077 && (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
10078 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10079 fold_convert_loc (loc
, type
, arg0
),
10080 fold_convert_loc (loc
, type
,
10081 TREE_OPERAND (arg1
, 0)));
10082 /* (-A) + B -> B - A */
10083 if (TREE_CODE (arg0
) == NEGATE_EXPR
10084 && reorder_operands_p (TREE_OPERAND (arg0
, 0), arg1
)
10085 && (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
10086 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10087 fold_convert_loc (loc
, type
, arg1
),
10088 fold_convert_loc (loc
, type
,
10089 TREE_OPERAND (arg0
, 0)));
10091 if (INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
10093 /* Convert ~A + 1 to -A. */
10094 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10095 && integer_each_onep (arg1
))
10096 return fold_build1_loc (loc
, NEGATE_EXPR
, type
,
10097 fold_convert_loc (loc
, type
,
10098 TREE_OPERAND (arg0
, 0)));
10100 /* ~X + X is -1. */
10101 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10102 && !TYPE_OVERFLOW_TRAPS (type
))
10104 tree tem
= TREE_OPERAND (arg0
, 0);
10107 if (operand_equal_p (tem
, arg1
, 0))
10109 t1
= build_all_ones_cst (type
);
10110 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
10114 /* X + ~X is -1. */
10115 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
10116 && !TYPE_OVERFLOW_TRAPS (type
))
10118 tree tem
= TREE_OPERAND (arg1
, 0);
10121 if (operand_equal_p (arg0
, tem
, 0))
10123 t1
= build_all_ones_cst (type
);
10124 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
10128 /* X + (X / CST) * -CST is X % CST. */
10129 if (TREE_CODE (arg1
) == MULT_EXPR
10130 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10131 && operand_equal_p (arg0
,
10132 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
10134 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
10135 tree cst1
= TREE_OPERAND (arg1
, 1);
10136 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
10138 if (sum
&& integer_zerop (sum
))
10139 return fold_convert_loc (loc
, type
,
10140 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
10141 TREE_TYPE (arg0
), arg0
,
10146 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
10147 one. Make sure the type is not saturating and has the signedness of
10148 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10149 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10150 if ((TREE_CODE (arg0
) == MULT_EXPR
10151 || TREE_CODE (arg1
) == MULT_EXPR
)
10152 && !TYPE_SATURATING (type
)
10153 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10154 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10155 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10157 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10162 if (! FLOAT_TYPE_P (type
))
10164 if (integer_zerop (arg1
))
10165 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10167 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10168 with a constant, and the two constants have no bits in common,
10169 we should treat this as a BIT_IOR_EXPR since this may produce more
10170 simplifications. */
10171 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10172 && TREE_CODE (arg1
) == BIT_AND_EXPR
10173 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10174 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
10175 && wi::bit_and (TREE_OPERAND (arg0
, 1),
10176 TREE_OPERAND (arg1
, 1)) == 0)
10178 code
= BIT_IOR_EXPR
;
10182 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10183 (plus (plus (mult) (mult)) (foo)) so that we can
10184 take advantage of the factoring cases below. */
10185 if (TYPE_OVERFLOW_WRAPS (type
)
10186 && (((TREE_CODE (arg0
) == PLUS_EXPR
10187 || TREE_CODE (arg0
) == MINUS_EXPR
)
10188 && TREE_CODE (arg1
) == MULT_EXPR
)
10189 || ((TREE_CODE (arg1
) == PLUS_EXPR
10190 || TREE_CODE (arg1
) == MINUS_EXPR
)
10191 && TREE_CODE (arg0
) == MULT_EXPR
)))
10193 tree parg0
, parg1
, parg
, marg
;
10194 enum tree_code pcode
;
10196 if (TREE_CODE (arg1
) == MULT_EXPR
)
10197 parg
= arg0
, marg
= arg1
;
10199 parg
= arg1
, marg
= arg0
;
10200 pcode
= TREE_CODE (parg
);
10201 parg0
= TREE_OPERAND (parg
, 0);
10202 parg1
= TREE_OPERAND (parg
, 1);
10203 STRIP_NOPS (parg0
);
10204 STRIP_NOPS (parg1
);
10206 if (TREE_CODE (parg0
) == MULT_EXPR
10207 && TREE_CODE (parg1
) != MULT_EXPR
)
10208 return fold_build2_loc (loc
, pcode
, type
,
10209 fold_build2_loc (loc
, PLUS_EXPR
, type
,
10210 fold_convert_loc (loc
, type
,
10212 fold_convert_loc (loc
, type
,
10214 fold_convert_loc (loc
, type
, parg1
));
10215 if (TREE_CODE (parg0
) != MULT_EXPR
10216 && TREE_CODE (parg1
) == MULT_EXPR
)
10218 fold_build2_loc (loc
, PLUS_EXPR
, type
,
10219 fold_convert_loc (loc
, type
, parg0
),
10220 fold_build2_loc (loc
, pcode
, type
,
10221 fold_convert_loc (loc
, type
, marg
),
10222 fold_convert_loc (loc
, type
,
10228 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10229 if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 0))
10230 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10232 /* Likewise if the operands are reversed. */
10233 if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10234 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10236 /* Convert X + -C into X - C. */
10237 if (TREE_CODE (arg1
) == REAL_CST
10238 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
)))
10240 tem
= fold_negate_const (arg1
, type
);
10241 if (!TREE_OVERFLOW (arg1
) || !flag_trapping_math
)
10242 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10243 fold_convert_loc (loc
, type
, arg0
),
10244 fold_convert_loc (loc
, type
, tem
));
10247 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10248 to __complex__ ( x, y ). This is not the same for SNaNs or
10249 if signed zeros are involved. */
10250 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10251 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10252 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10254 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10255 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10256 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10257 bool arg0rz
= false, arg0iz
= false;
10258 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10259 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10261 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10262 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10263 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10265 tree rp
= arg1r
? arg1r
10266 : build1 (REALPART_EXPR
, rtype
, arg1
);
10267 tree ip
= arg0i
? arg0i
10268 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10269 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10271 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10273 tree rp
= arg0r
? arg0r
10274 : build1 (REALPART_EXPR
, rtype
, arg0
);
10275 tree ip
= arg1i
? arg1i
10276 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
10277 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10282 if (flag_unsafe_math_optimizations
10283 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10284 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10285 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10288 /* Convert x+x into x*2.0. */
10289 if (operand_equal_p (arg0
, arg1
, 0)
10290 && SCALAR_FLOAT_TYPE_P (type
))
10291 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
,
10292 build_real (type
, dconst2
));
10294 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10295 We associate floats only if the user has specified
10296 -fassociative-math. */
10297 if (flag_associative_math
10298 && TREE_CODE (arg1
) == PLUS_EXPR
10299 && TREE_CODE (arg0
) != MULT_EXPR
)
10301 tree tree10
= TREE_OPERAND (arg1
, 0);
10302 tree tree11
= TREE_OPERAND (arg1
, 1);
10303 if (TREE_CODE (tree11
) == MULT_EXPR
10304 && TREE_CODE (tree10
) == MULT_EXPR
)
10307 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
10308 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
10311 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10312 We associate floats only if the user has specified
10313 -fassociative-math. */
10314 if (flag_associative_math
10315 && TREE_CODE (arg0
) == PLUS_EXPR
10316 && TREE_CODE (arg1
) != MULT_EXPR
)
10318 tree tree00
= TREE_OPERAND (arg0
, 0);
10319 tree tree01
= TREE_OPERAND (arg0
, 1);
10320 if (TREE_CODE (tree01
) == MULT_EXPR
10321 && TREE_CODE (tree00
) == MULT_EXPR
)
10324 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
10325 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
10331 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10332 is a rotate of A by C1 bits. */
10333 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10334 is a rotate of A by B bits. */
10336 enum tree_code code0
, code1
;
10338 code0
= TREE_CODE (arg0
);
10339 code1
= TREE_CODE (arg1
);
10340 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
10341 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
10342 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10343 TREE_OPERAND (arg1
, 0), 0)
10344 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10345 TYPE_UNSIGNED (rtype
))
10346 /* Only create rotates in complete modes. Other cases are not
10347 expanded properly. */
10348 && (element_precision (rtype
)
10349 == element_precision (TYPE_MODE (rtype
))))
10351 tree tree01
, tree11
;
10352 enum tree_code code01
, code11
;
10354 tree01
= TREE_OPERAND (arg0
, 1);
10355 tree11
= TREE_OPERAND (arg1
, 1);
10356 STRIP_NOPS (tree01
);
10357 STRIP_NOPS (tree11
);
10358 code01
= TREE_CODE (tree01
);
10359 code11
= TREE_CODE (tree11
);
10360 if (code01
== INTEGER_CST
10361 && code11
== INTEGER_CST
10362 && (wi::to_widest (tree01
) + wi::to_widest (tree11
)
10363 == element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)))))
10365 tem
= build2_loc (loc
, LROTATE_EXPR
,
10366 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10367 TREE_OPERAND (arg0
, 0),
10368 code0
== LSHIFT_EXPR
? tree01
: tree11
);
10369 return fold_convert_loc (loc
, type
, tem
);
10371 else if (code11
== MINUS_EXPR
)
10373 tree tree110
, tree111
;
10374 tree110
= TREE_OPERAND (tree11
, 0);
10375 tree111
= TREE_OPERAND (tree11
, 1);
10376 STRIP_NOPS (tree110
);
10377 STRIP_NOPS (tree111
);
10378 if (TREE_CODE (tree110
) == INTEGER_CST
10379 && 0 == compare_tree_int (tree110
,
10381 (TREE_TYPE (TREE_OPERAND
10383 && operand_equal_p (tree01
, tree111
, 0))
10385 fold_convert_loc (loc
, type
,
10386 build2 ((code0
== LSHIFT_EXPR
10389 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10390 TREE_OPERAND (arg0
, 0), tree01
));
10392 else if (code01
== MINUS_EXPR
)
10394 tree tree010
, tree011
;
10395 tree010
= TREE_OPERAND (tree01
, 0);
10396 tree011
= TREE_OPERAND (tree01
, 1);
10397 STRIP_NOPS (tree010
);
10398 STRIP_NOPS (tree011
);
10399 if (TREE_CODE (tree010
) == INTEGER_CST
10400 && 0 == compare_tree_int (tree010
,
10402 (TREE_TYPE (TREE_OPERAND
10404 && operand_equal_p (tree11
, tree011
, 0))
10405 return fold_convert_loc
10407 build2 ((code0
!= LSHIFT_EXPR
10410 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10411 TREE_OPERAND (arg0
, 0), tree11
));
10417 /* In most languages, can't associate operations on floats through
10418 parentheses. Rather than remember where the parentheses were, we
10419 don't associate floats at all, unless the user has specified
10420 -fassociative-math.
10421 And, we need to make sure type is not saturating. */
10423 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
10424 && !TYPE_SATURATING (type
))
10426 tree var0
, con0
, lit0
, minus_lit0
;
10427 tree var1
, con1
, lit1
, minus_lit1
;
10431 /* Split both trees into variables, constants, and literals. Then
10432 associate each group together, the constants with literals,
10433 then the result with variables. This increases the chances of
10434 literals being recombined later and of generating relocatable
10435 expressions for the sum of a constant and literal. */
10436 var0
= split_tree (arg0
, code
, &con0
, &lit0
, &minus_lit0
, 0);
10437 var1
= split_tree (arg1
, code
, &con1
, &lit1
, &minus_lit1
,
10438 code
== MINUS_EXPR
);
10440 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10441 if (code
== MINUS_EXPR
)
10444 /* With undefined overflow prefer doing association in a type
10445 which wraps on overflow, if that is one of the operand types. */
10446 if ((POINTER_TYPE_P (type
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
10447 || (INTEGRAL_TYPE_P (type
) && !TYPE_OVERFLOW_WRAPS (type
)))
10449 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10450 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
10451 atype
= TREE_TYPE (arg0
);
10452 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10453 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
10454 atype
= TREE_TYPE (arg1
);
10455 gcc_assert (TYPE_PRECISION (atype
) == TYPE_PRECISION (type
));
10458 /* With undefined overflow we can only associate constants with one
10459 variable, and constants whose association doesn't overflow. */
10460 if ((POINTER_TYPE_P (atype
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
10461 || (INTEGRAL_TYPE_P (atype
) && !TYPE_OVERFLOW_WRAPS (atype
)))
10468 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
10469 tmp0
= TREE_OPERAND (tmp0
, 0);
10470 if (CONVERT_EXPR_P (tmp0
)
10471 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
10472 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
10473 <= TYPE_PRECISION (atype
)))
10474 tmp0
= TREE_OPERAND (tmp0
, 0);
10475 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
10476 tmp1
= TREE_OPERAND (tmp1
, 0);
10477 if (CONVERT_EXPR_P (tmp1
)
10478 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
10479 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
10480 <= TYPE_PRECISION (atype
)))
10481 tmp1
= TREE_OPERAND (tmp1
, 0);
10482 /* The only case we can still associate with two variables
10483 is if they are the same, modulo negation and bit-pattern
10484 preserving conversions. */
10485 if (!operand_equal_p (tmp0
, tmp1
, 0))
10490 /* Only do something if we found more than two objects. Otherwise,
10491 nothing has changed and we risk infinite recursion. */
10493 && (2 < ((var0
!= 0) + (var1
!= 0)
10494 + (con0
!= 0) + (con1
!= 0)
10495 + (lit0
!= 0) + (lit1
!= 0)
10496 + (minus_lit0
!= 0) + (minus_lit1
!= 0))))
10498 bool any_overflows
= false;
10499 if (lit0
) any_overflows
|= TREE_OVERFLOW (lit0
);
10500 if (lit1
) any_overflows
|= TREE_OVERFLOW (lit1
);
10501 if (minus_lit0
) any_overflows
|= TREE_OVERFLOW (minus_lit0
);
10502 if (minus_lit1
) any_overflows
|= TREE_OVERFLOW (minus_lit1
);
10503 var0
= associate_trees (loc
, var0
, var1
, code
, atype
);
10504 con0
= associate_trees (loc
, con0
, con1
, code
, atype
);
10505 lit0
= associate_trees (loc
, lit0
, lit1
, code
, atype
);
10506 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
,
10509 /* Preserve the MINUS_EXPR if the negative part of the literal is
10510 greater than the positive part. Otherwise, the multiplicative
10511 folding code (i.e extract_muldiv) may be fooled in case
10512 unsigned constants are subtracted, like in the following
10513 example: ((X*2 + 4) - 8U)/2. */
10514 if (minus_lit0
&& lit0
)
10516 if (TREE_CODE (lit0
) == INTEGER_CST
10517 && TREE_CODE (minus_lit0
) == INTEGER_CST
10518 && tree_int_cst_lt (lit0
, minus_lit0
))
10520 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
10521 MINUS_EXPR
, atype
);
10526 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
10527 MINUS_EXPR
, atype
);
10532 /* Don't introduce overflows through reassociation. */
10534 && ((lit0
&& TREE_OVERFLOW (lit0
))
10535 || (minus_lit0
&& TREE_OVERFLOW (minus_lit0
))))
10542 fold_convert_loc (loc
, type
,
10543 associate_trees (loc
, var0
, minus_lit0
,
10544 MINUS_EXPR
, atype
));
10547 con0
= associate_trees (loc
, con0
, minus_lit0
,
10548 MINUS_EXPR
, atype
);
10550 fold_convert_loc (loc
, type
,
10551 associate_trees (loc
, var0
, con0
,
10552 PLUS_EXPR
, atype
));
10556 con0
= associate_trees (loc
, con0
, lit0
, code
, atype
);
10558 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
10566 /* Pointer simplifications for subtraction, simple reassociations. */
10567 if (POINTER_TYPE_P (TREE_TYPE (arg1
)) && POINTER_TYPE_P (TREE_TYPE (arg0
)))
10569 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10570 if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
10571 && TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
10573 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10574 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10575 tree arg10
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10576 tree arg11
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10577 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10578 fold_build2_loc (loc
, MINUS_EXPR
, type
,
10580 fold_build2_loc (loc
, MINUS_EXPR
, type
,
10583 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10584 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
10586 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10587 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10588 tree tmp
= fold_binary_loc (loc
, MINUS_EXPR
, type
, arg00
,
10589 fold_convert_loc (loc
, type
, arg1
));
10591 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tmp
, arg01
);
10593 /* PTR0 - (PTR1 p+ A) -> (PTR0 - PTR1) - A, assuming PTR0 - PTR1
10595 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
10597 tree arg10
= fold_convert_loc (loc
, type
,
10598 TREE_OPERAND (arg1
, 0));
10599 tree arg11
= fold_convert_loc (loc
, type
,
10600 TREE_OPERAND (arg1
, 1));
10601 tree tmp
= fold_binary_loc (loc
, MINUS_EXPR
, type
, arg0
,
10602 fold_convert_loc (loc
, type
, arg10
));
10604 return fold_build2_loc (loc
, MINUS_EXPR
, type
, tmp
, arg11
);
10607 /* A - (-B) -> A + B */
10608 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
10609 return fold_build2_loc (loc
, PLUS_EXPR
, type
, op0
,
10610 fold_convert_loc (loc
, type
,
10611 TREE_OPERAND (arg1
, 0)));
10612 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10613 if (TREE_CODE (arg0
) == NEGATE_EXPR
10614 && negate_expr_p (arg1
)
10615 && reorder_operands_p (arg0
, arg1
))
10616 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10617 fold_convert_loc (loc
, type
,
10618 negate_expr (arg1
)),
10619 fold_convert_loc (loc
, type
,
10620 TREE_OPERAND (arg0
, 0)));
10621 /* Convert -A - 1 to ~A. */
10622 if (TREE_CODE (arg0
) == NEGATE_EXPR
10623 && integer_each_onep (arg1
)
10624 && !TYPE_OVERFLOW_TRAPS (type
))
10625 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
10626 fold_convert_loc (loc
, type
,
10627 TREE_OPERAND (arg0
, 0)));
10629 /* Convert -1 - A to ~A. */
10630 if (TREE_CODE (type
) != COMPLEX_TYPE
10631 && integer_all_onesp (arg0
))
10632 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op1
);
10635 /* X - (X / Y) * Y is X % Y. */
10636 if ((INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
10637 && TREE_CODE (arg1
) == MULT_EXPR
10638 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10639 && operand_equal_p (arg0
,
10640 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0)
10641 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1),
10642 TREE_OPERAND (arg1
, 1), 0))
10644 fold_convert_loc (loc
, type
,
10645 fold_build2_loc (loc
, TRUNC_MOD_EXPR
, TREE_TYPE (arg0
),
10646 arg0
, TREE_OPERAND (arg1
, 1)));
10648 if (! FLOAT_TYPE_P (type
))
10650 if (integer_zerop (arg0
))
10651 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10652 if (integer_zerop (arg1
))
10653 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10655 /* Fold A - (A & B) into ~B & A. */
10656 if (!TREE_SIDE_EFFECTS (arg0
)
10657 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10659 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0))
10661 tree arg10
= fold_convert_loc (loc
, type
,
10662 TREE_OPERAND (arg1
, 0));
10663 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10664 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10666 fold_convert_loc (loc
, type
, arg0
));
10668 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10670 tree arg11
= fold_convert_loc (loc
,
10671 type
, TREE_OPERAND (arg1
, 1));
10672 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10673 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10675 fold_convert_loc (loc
, type
, arg0
));
10679 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10680 any power of 2 minus 1. */
10681 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10682 && TREE_CODE (arg1
) == BIT_AND_EXPR
10683 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10684 TREE_OPERAND (arg1
, 0), 0))
10686 tree mask0
= TREE_OPERAND (arg0
, 1);
10687 tree mask1
= TREE_OPERAND (arg1
, 1);
10688 tree tem
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, mask0
);
10690 if (operand_equal_p (tem
, mask1
, 0))
10692 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
10693 TREE_OPERAND (arg0
, 0), mask1
);
10694 return fold_build2_loc (loc
, MINUS_EXPR
, type
, tem
, mask1
);
10699 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10700 else if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 1))
10701 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10703 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10704 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10705 (-ARG1 + ARG0) reduces to -ARG1. */
10706 else if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10707 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10709 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10710 __complex__ ( x, -y ). This is not the same for SNaNs or if
10711 signed zeros are involved. */
10712 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10713 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10714 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10716 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10717 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10718 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10719 bool arg0rz
= false, arg0iz
= false;
10720 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10721 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10723 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10724 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10725 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10727 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10729 : build1 (REALPART_EXPR
, rtype
, arg1
));
10730 tree ip
= arg0i
? arg0i
10731 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10732 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10734 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10736 tree rp
= arg0r
? arg0r
10737 : build1 (REALPART_EXPR
, rtype
, arg0
);
10738 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10740 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
10741 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10746 /* Fold &x - &x. This can happen from &x.foo - &x.
10747 This is unsafe for certain floats even in non-IEEE formats.
10748 In IEEE, it is unsafe because it does wrong for NaNs.
10749 Also note that operand_equal_p is always false if an operand
10752 if ((!FLOAT_TYPE_P (type
) || !HONOR_NANS (TYPE_MODE (type
)))
10753 && operand_equal_p (arg0
, arg1
, 0))
10754 return build_zero_cst (type
);
10756 /* A - B -> A + (-B) if B is easily negatable. */
10757 if (negate_expr_p (arg1
)
10758 && ((FLOAT_TYPE_P (type
)
10759 /* Avoid this transformation if B is a positive REAL_CST. */
10760 && (TREE_CODE (arg1
) != REAL_CST
10761 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
))))
10762 || INTEGRAL_TYPE_P (type
)))
10763 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10764 fold_convert_loc (loc
, type
, arg0
),
10765 fold_convert_loc (loc
, type
,
10766 negate_expr (arg1
)));
10768 /* Try folding difference of addresses. */
10770 HOST_WIDE_INT diff
;
10772 if ((TREE_CODE (arg0
) == ADDR_EXPR
10773 || TREE_CODE (arg1
) == ADDR_EXPR
)
10774 && ptr_difference_const (arg0
, arg1
, &diff
))
10775 return build_int_cst_type (type
, diff
);
10778 /* Fold &a[i] - &a[j] to i-j. */
10779 if (TREE_CODE (arg0
) == ADDR_EXPR
10780 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
10781 && TREE_CODE (arg1
) == ADDR_EXPR
10782 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
10784 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
10785 TREE_OPERAND (arg0
, 0),
10786 TREE_OPERAND (arg1
, 0));
10791 if (FLOAT_TYPE_P (type
)
10792 && flag_unsafe_math_optimizations
10793 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10794 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10795 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10798 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
10799 one. Make sure the type is not saturating and has the signedness of
10800 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10801 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10802 if ((TREE_CODE (arg0
) == MULT_EXPR
10803 || TREE_CODE (arg1
) == MULT_EXPR
)
10804 && !TYPE_SATURATING (type
)
10805 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10806 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10807 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10809 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10817 /* (-A) * (-B) -> A * B */
10818 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10819 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10820 fold_convert_loc (loc
, type
,
10821 TREE_OPERAND (arg0
, 0)),
10822 fold_convert_loc (loc
, type
,
10823 negate_expr (arg1
)));
10824 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10825 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10826 fold_convert_loc (loc
, type
,
10827 negate_expr (arg0
)),
10828 fold_convert_loc (loc
, type
,
10829 TREE_OPERAND (arg1
, 0)));
10831 if (! FLOAT_TYPE_P (type
))
10833 if (integer_zerop (arg1
))
10834 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10835 if (integer_onep (arg1
))
10836 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10837 /* Transform x * -1 into -x. Make sure to do the negation
10838 on the original operand with conversions not stripped
10839 because we can only strip non-sign-changing conversions. */
10840 if (integer_minus_onep (arg1
))
10841 return fold_convert_loc (loc
, type
, negate_expr (op0
));
10842 /* Transform x * -C into -x * C if x is easily negatable. */
10843 if (TREE_CODE (arg1
) == INTEGER_CST
10844 && tree_int_cst_sgn (arg1
) == -1
10845 && negate_expr_p (arg0
)
10846 && (tem
= negate_expr (arg1
)) != arg1
10847 && !TREE_OVERFLOW (tem
))
10848 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10849 fold_convert_loc (loc
, type
,
10850 negate_expr (arg0
)),
10853 /* (a * (1 << b)) is (a << b) */
10854 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10855 && integer_onep (TREE_OPERAND (arg1
, 0)))
10856 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op0
,
10857 TREE_OPERAND (arg1
, 1));
10858 if (TREE_CODE (arg0
) == LSHIFT_EXPR
10859 && integer_onep (TREE_OPERAND (arg0
, 0)))
10860 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op1
,
10861 TREE_OPERAND (arg0
, 1));
10863 /* (A + A) * C -> A * 2 * C */
10864 if (TREE_CODE (arg0
) == PLUS_EXPR
10865 && TREE_CODE (arg1
) == INTEGER_CST
10866 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10867 TREE_OPERAND (arg0
, 1), 0))
10868 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10869 omit_one_operand_loc (loc
, type
,
10870 TREE_OPERAND (arg0
, 0),
10871 TREE_OPERAND (arg0
, 1)),
10872 fold_build2_loc (loc
, MULT_EXPR
, type
,
10873 build_int_cst (type
, 2) , arg1
));
10875 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
10876 sign-changing only. */
10877 if (TREE_CODE (arg1
) == INTEGER_CST
10878 && TREE_CODE (arg0
) == EXACT_DIV_EXPR
10879 && operand_equal_p (arg1
, TREE_OPERAND (arg0
, 1), 0))
10880 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10882 strict_overflow_p
= false;
10883 if (TREE_CODE (arg1
) == INTEGER_CST
10884 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10885 &strict_overflow_p
)))
10887 if (strict_overflow_p
)
10888 fold_overflow_warning (("assuming signed overflow does not "
10889 "occur when simplifying "
10891 WARN_STRICT_OVERFLOW_MISC
);
10892 return fold_convert_loc (loc
, type
, tem
);
10895 /* Optimize z * conj(z) for integer complex numbers. */
10896 if (TREE_CODE (arg0
) == CONJ_EXPR
10897 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10898 return fold_mult_zconjz (loc
, type
, arg1
);
10899 if (TREE_CODE (arg1
) == CONJ_EXPR
10900 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10901 return fold_mult_zconjz (loc
, type
, arg0
);
10905 /* Maybe fold x * 0 to 0. The expressions aren't the same
10906 when x is NaN, since x * 0 is also NaN. Nor are they the
10907 same in modes with signed zeros, since multiplying a
10908 negative value by 0 gives -0, not +0. */
10909 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
10910 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10911 && real_zerop (arg1
))
10912 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10913 /* In IEEE floating point, x*1 is not equivalent to x for snans.
10914 Likewise for complex arithmetic with signed zeros. */
10915 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10916 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10917 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10918 && real_onep (arg1
))
10919 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10921 /* Transform x * -1.0 into -x. */
10922 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10923 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10924 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10925 && real_minus_onep (arg1
))
10926 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
10928 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
10929 the result for floating point types due to rounding so it is applied
10930 only if -fassociative-math was specify. */
10931 if (flag_associative_math
10932 && TREE_CODE (arg0
) == RDIV_EXPR
10933 && TREE_CODE (arg1
) == REAL_CST
10934 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
)
10936 tree tem
= const_binop (MULT_EXPR
, TREE_OPERAND (arg0
, 0),
10939 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
10940 TREE_OPERAND (arg0
, 1));
10943 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
10944 if (operand_equal_p (arg0
, arg1
, 0))
10946 tree tem
= fold_strip_sign_ops (arg0
);
10947 if (tem
!= NULL_TREE
)
10949 tem
= fold_convert_loc (loc
, type
, tem
);
10950 return fold_build2_loc (loc
, MULT_EXPR
, type
, tem
, tem
);
10954 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10955 This is not the same for NaNs or if signed zeros are
10957 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
10958 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10959 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
10960 && TREE_CODE (arg1
) == COMPLEX_CST
10961 && real_zerop (TREE_REALPART (arg1
)))
10963 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10964 if (real_onep (TREE_IMAGPART (arg1
)))
10966 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10967 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
10969 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
10970 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
10972 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10973 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
10974 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
10978 /* Optimize z * conj(z) for floating point complex numbers.
10979 Guarded by flag_unsafe_math_optimizations as non-finite
10980 imaginary components don't produce scalar results. */
10981 if (flag_unsafe_math_optimizations
10982 && TREE_CODE (arg0
) == CONJ_EXPR
10983 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10984 return fold_mult_zconjz (loc
, type
, arg1
);
10985 if (flag_unsafe_math_optimizations
10986 && TREE_CODE (arg1
) == CONJ_EXPR
10987 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10988 return fold_mult_zconjz (loc
, type
, arg0
);
10990 if (flag_unsafe_math_optimizations
)
10992 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
10993 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
10995 /* Optimizations of root(...)*root(...). */
10996 if (fcode0
== fcode1
&& BUILTIN_ROOT_P (fcode0
))
10999 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11000 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11002 /* Optimize sqrt(x)*sqrt(x) as x. */
11003 if (BUILTIN_SQRT_P (fcode0
)
11004 && operand_equal_p (arg00
, arg10
, 0)
11005 && ! HONOR_SNANS (TYPE_MODE (type
)))
11008 /* Optimize root(x)*root(y) as root(x*y). */
11009 rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11010 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg00
, arg10
);
11011 return build_call_expr_loc (loc
, rootfn
, 1, arg
);
11014 /* Optimize expN(x)*expN(y) as expN(x+y). */
11015 if (fcode0
== fcode1
&& BUILTIN_EXPONENT_P (fcode0
))
11017 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11018 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
11019 CALL_EXPR_ARG (arg0
, 0),
11020 CALL_EXPR_ARG (arg1
, 0));
11021 return build_call_expr_loc (loc
, expfn
, 1, arg
);
11024 /* Optimizations of pow(...)*pow(...). */
11025 if ((fcode0
== BUILT_IN_POW
&& fcode1
== BUILT_IN_POW
)
11026 || (fcode0
== BUILT_IN_POWF
&& fcode1
== BUILT_IN_POWF
)
11027 || (fcode0
== BUILT_IN_POWL
&& fcode1
== BUILT_IN_POWL
))
11029 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11030 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11031 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11032 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
11034 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
11035 if (operand_equal_p (arg01
, arg11
, 0))
11037 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11038 tree arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
11040 return build_call_expr_loc (loc
, powfn
, 2, arg
, arg01
);
11043 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
11044 if (operand_equal_p (arg00
, arg10
, 0))
11046 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11047 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
11049 return build_call_expr_loc (loc
, powfn
, 2, arg00
, arg
);
11053 /* Optimize tan(x)*cos(x) as sin(x). */
11054 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_COS
)
11055 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_COSF
)
11056 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_COSL
)
11057 || (fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_TAN
)
11058 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_TANF
)
11059 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_TANL
))
11060 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11061 CALL_EXPR_ARG (arg1
, 0), 0))
11063 tree sinfn
= mathfn_built_in (type
, BUILT_IN_SIN
);
11065 if (sinfn
!= NULL_TREE
)
11066 return build_call_expr_loc (loc
, sinfn
, 1,
11067 CALL_EXPR_ARG (arg0
, 0));
11070 /* Optimize x*pow(x,c) as pow(x,c+1). */
11071 if (fcode1
== BUILT_IN_POW
11072 || fcode1
== BUILT_IN_POWF
11073 || fcode1
== BUILT_IN_POWL
)
11075 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11076 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
11077 if (TREE_CODE (arg11
) == REAL_CST
11078 && !TREE_OVERFLOW (arg11
)
11079 && operand_equal_p (arg0
, arg10
, 0))
11081 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
11085 c
= TREE_REAL_CST (arg11
);
11086 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
11087 arg
= build_real (type
, c
);
11088 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11092 /* Optimize pow(x,c)*x as pow(x,c+1). */
11093 if (fcode0
== BUILT_IN_POW
11094 || fcode0
== BUILT_IN_POWF
11095 || fcode0
== BUILT_IN_POWL
)
11097 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11098 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11099 if (TREE_CODE (arg01
) == REAL_CST
11100 && !TREE_OVERFLOW (arg01
)
11101 && operand_equal_p (arg1
, arg00
, 0))
11103 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11107 c
= TREE_REAL_CST (arg01
);
11108 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
11109 arg
= build_real (type
, c
);
11110 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
11114 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
11115 if (!in_gimple_form
11117 && operand_equal_p (arg0
, arg1
, 0))
11119 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
11123 tree arg
= build_real (type
, dconst2
);
11124 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11133 if (integer_all_onesp (arg1
))
11134 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11135 if (integer_zerop (arg1
))
11136 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11137 if (operand_equal_p (arg0
, arg1
, 0))
11138 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11140 /* ~X | X is -1. */
11141 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11142 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11144 t1
= build_zero_cst (type
);
11145 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11146 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11149 /* X | ~X is -1. */
11150 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11151 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11153 t1
= build_zero_cst (type
);
11154 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11155 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11158 /* Canonicalize (X & C1) | C2. */
11159 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11160 && TREE_CODE (arg1
) == INTEGER_CST
11161 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11163 int width
= TYPE_PRECISION (type
), w
;
11164 wide_int c1
= TREE_OPERAND (arg0
, 1);
11165 wide_int c2
= arg1
;
11167 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11168 if ((c1
& c2
) == c1
)
11169 return omit_one_operand_loc (loc
, type
, arg1
,
11170 TREE_OPERAND (arg0
, 0));
11172 wide_int msk
= wi::mask (width
, false,
11173 TYPE_PRECISION (TREE_TYPE (arg1
)));
11175 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11176 if (msk
.and_not (c1
| c2
) == 0)
11177 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11178 TREE_OPERAND (arg0
, 0), arg1
);
11180 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11181 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11182 mode which allows further optimizations. */
11185 wide_int c3
= c1
.and_not (c2
);
11186 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
11188 wide_int mask
= wi::mask (w
, false,
11189 TYPE_PRECISION (type
));
11190 if (((c1
| c2
) & mask
) == mask
&& c1
.and_not (mask
) == 0)
11198 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11199 fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11200 TREE_OPERAND (arg0
, 0),
11201 wide_int_to_tree (type
,
11206 /* (X & Y) | Y is (X, Y). */
11207 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11208 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11209 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11210 /* (X & Y) | X is (Y, X). */
11211 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11212 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11213 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11214 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11215 /* X | (X & Y) is (Y, X). */
11216 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11217 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11218 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11219 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11220 /* X | (Y & X) is (Y, X). */
11221 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11222 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11223 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11224 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11226 /* (X & ~Y) | (~X & Y) is X ^ Y */
11227 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11228 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
11230 tree a0
, a1
, l0
, l1
, n0
, n1
;
11232 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11233 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11235 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11236 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11238 n0
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l0
);
11239 n1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l1
);
11241 if ((operand_equal_p (n0
, a0
, 0)
11242 && operand_equal_p (n1
, a1
, 0))
11243 || (operand_equal_p (n0
, a1
, 0)
11244 && operand_equal_p (n1
, a0
, 0)))
11245 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, l0
, n1
);
11248 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11249 if (t1
!= NULL_TREE
)
11252 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11254 This results in more efficient code for machines without a NAND
11255 instruction. Combine will canonicalize to the first form
11256 which will allow use of NAND instructions provided by the
11257 backend if they exist. */
11258 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11259 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11262 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11263 build2 (BIT_AND_EXPR
, type
,
11264 fold_convert_loc (loc
, type
,
11265 TREE_OPERAND (arg0
, 0)),
11266 fold_convert_loc (loc
, type
,
11267 TREE_OPERAND (arg1
, 0))));
11270 /* See if this can be simplified into a rotate first. If that
11271 is unsuccessful continue in the association code. */
11275 if (integer_zerop (arg1
))
11276 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11277 if (integer_all_onesp (arg1
))
11278 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op0
);
11279 if (operand_equal_p (arg0
, arg1
, 0))
11280 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11282 /* ~X ^ X is -1. */
11283 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11284 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11286 t1
= build_zero_cst (type
);
11287 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11288 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11291 /* X ^ ~X is -1. */
11292 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11293 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11295 t1
= build_zero_cst (type
);
11296 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11297 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11300 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11301 with a constant, and the two constants have no bits in common,
11302 we should treat this as a BIT_IOR_EXPR since this may produce more
11303 simplifications. */
11304 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11305 && TREE_CODE (arg1
) == BIT_AND_EXPR
11306 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
11307 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
11308 && wi::bit_and (TREE_OPERAND (arg0
, 1),
11309 TREE_OPERAND (arg1
, 1)) == 0)
11311 code
= BIT_IOR_EXPR
;
11315 /* (X | Y) ^ X -> Y & ~ X*/
11316 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11317 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11319 tree t2
= TREE_OPERAND (arg0
, 1);
11320 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11322 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11323 fold_convert_loc (loc
, type
, t2
),
11324 fold_convert_loc (loc
, type
, t1
));
11328 /* (Y | X) ^ X -> Y & ~ X*/
11329 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11330 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11332 tree t2
= TREE_OPERAND (arg0
, 0);
11333 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11335 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11336 fold_convert_loc (loc
, type
, t2
),
11337 fold_convert_loc (loc
, type
, t1
));
11341 /* X ^ (X | Y) -> Y & ~ X*/
11342 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11343 && operand_equal_p (TREE_OPERAND (arg1
, 0), arg0
, 0))
11345 tree t2
= TREE_OPERAND (arg1
, 1);
11346 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11348 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11349 fold_convert_loc (loc
, type
, t2
),
11350 fold_convert_loc (loc
, type
, t1
));
11354 /* X ^ (Y | X) -> Y & ~ X*/
11355 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11356 && operand_equal_p (TREE_OPERAND (arg1
, 1), arg0
, 0))
11358 tree t2
= TREE_OPERAND (arg1
, 0);
11359 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11361 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11362 fold_convert_loc (loc
, type
, t2
),
11363 fold_convert_loc (loc
, type
, t1
));
11367 /* Convert ~X ^ ~Y to X ^ Y. */
11368 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11369 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11370 return fold_build2_loc (loc
, code
, type
,
11371 fold_convert_loc (loc
, type
,
11372 TREE_OPERAND (arg0
, 0)),
11373 fold_convert_loc (loc
, type
,
11374 TREE_OPERAND (arg1
, 0)));
11376 /* Convert ~X ^ C to X ^ ~C. */
11377 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11378 && TREE_CODE (arg1
) == INTEGER_CST
)
11379 return fold_build2_loc (loc
, code
, type
,
11380 fold_convert_loc (loc
, type
,
11381 TREE_OPERAND (arg0
, 0)),
11382 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, arg1
));
11384 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11385 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11386 && INTEGRAL_TYPE_P (type
)
11387 && integer_onep (TREE_OPERAND (arg0
, 1))
11388 && integer_onep (arg1
))
11389 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
11390 build_zero_cst (TREE_TYPE (arg0
)));
11392 /* Fold (X & Y) ^ Y as ~X & Y. */
11393 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11394 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11396 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11397 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11398 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11399 fold_convert_loc (loc
, type
, arg1
));
11401 /* Fold (X & Y) ^ X as ~Y & X. */
11402 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11403 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11404 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11406 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11407 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11408 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11409 fold_convert_loc (loc
, type
, arg1
));
11411 /* Fold X ^ (X & Y) as X & ~Y. */
11412 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11413 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11415 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11416 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11417 fold_convert_loc (loc
, type
, arg0
),
11418 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11420 /* Fold X ^ (Y & X) as ~Y & X. */
11421 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11422 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11423 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11425 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11426 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11427 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11428 fold_convert_loc (loc
, type
, arg0
));
11431 /* See if this can be simplified into a rotate first. If that
11432 is unsuccessful continue in the association code. */
11436 if (integer_all_onesp (arg1
))
11437 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11438 if (integer_zerop (arg1
))
11439 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11440 if (operand_equal_p (arg0
, arg1
, 0))
11441 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11443 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
11444 if ((TREE_CODE (arg0
) == BIT_NOT_EXPR
11445 || TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11446 || (TREE_CODE (arg0
) == EQ_EXPR
11447 && integer_zerop (TREE_OPERAND (arg0
, 1))))
11448 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11449 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
11451 /* X & ~X , X & (X == 0), and X & !X are always zero. */
11452 if ((TREE_CODE (arg1
) == BIT_NOT_EXPR
11453 || TREE_CODE (arg1
) == TRUTH_NOT_EXPR
11454 || (TREE_CODE (arg1
) == EQ_EXPR
11455 && integer_zerop (TREE_OPERAND (arg1
, 1))))
11456 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11457 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11459 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11460 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11461 && TREE_CODE (arg1
) == INTEGER_CST
11462 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11464 tree tmp1
= fold_convert_loc (loc
, type
, arg1
);
11465 tree tmp2
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11466 tree tmp3
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11467 tmp2
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp2
, tmp1
);
11468 tmp3
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp3
, tmp1
);
11470 fold_convert_loc (loc
, type
,
11471 fold_build2_loc (loc
, BIT_IOR_EXPR
,
11472 type
, tmp2
, tmp3
));
11475 /* (X | Y) & Y is (X, Y). */
11476 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11477 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11478 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11479 /* (X | Y) & X is (Y, X). */
11480 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11481 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11482 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11483 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11484 /* X & (X | Y) is (Y, X). */
11485 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11486 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11487 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11488 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11489 /* X & (Y | X) is (Y, X). */
11490 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11491 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11492 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11493 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11495 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11496 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11497 && INTEGRAL_TYPE_P (type
)
11498 && integer_onep (TREE_OPERAND (arg0
, 1))
11499 && integer_onep (arg1
))
11502 tem
= TREE_OPERAND (arg0
, 0);
11503 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11504 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11506 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11507 build_zero_cst (TREE_TYPE (tem
)));
11509 /* Fold ~X & 1 as (X & 1) == 0. */
11510 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11511 && INTEGRAL_TYPE_P (type
)
11512 && integer_onep (arg1
))
11515 tem
= TREE_OPERAND (arg0
, 0);
11516 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11517 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11519 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11520 build_zero_cst (TREE_TYPE (tem
)));
11522 /* Fold !X & 1 as X == 0. */
11523 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11524 && integer_onep (arg1
))
11526 tem
= TREE_OPERAND (arg0
, 0);
11527 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
11528 build_zero_cst (TREE_TYPE (tem
)));
11531 /* Fold (X ^ Y) & Y as ~X & Y. */
11532 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11533 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11535 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11536 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11537 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11538 fold_convert_loc (loc
, type
, arg1
));
11540 /* Fold (X ^ Y) & X as ~Y & X. */
11541 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11542 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11543 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11545 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11546 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11547 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11548 fold_convert_loc (loc
, type
, arg1
));
11550 /* Fold X & (X ^ Y) as X & ~Y. */
11551 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11552 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11554 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11555 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11556 fold_convert_loc (loc
, type
, arg0
),
11557 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11559 /* Fold X & (Y ^ X) as ~Y & X. */
11560 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11561 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11562 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11564 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11565 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11566 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11567 fold_convert_loc (loc
, type
, arg0
));
11570 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11571 multiple of 1 << CST. */
11572 if (TREE_CODE (arg1
) == INTEGER_CST
)
11574 wide_int cst1
= arg1
;
11575 wide_int ncst1
= -cst1
;
11576 if ((cst1
& ncst1
) == ncst1
11577 && multiple_of_p (type
, arg0
,
11578 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
11579 return fold_convert_loc (loc
, type
, arg0
);
11582 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
11584 if (TREE_CODE (arg1
) == INTEGER_CST
11585 && TREE_CODE (arg0
) == MULT_EXPR
11586 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11588 wide_int warg1
= arg1
;
11589 wide_int masked
= mask_with_tz (type
, warg1
, TREE_OPERAND (arg0
, 1));
11592 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
11594 else if (masked
!= warg1
)
11596 /* Avoid the transform if arg1 is a mask of some
11597 mode which allows further optimizations. */
11598 int pop
= wi::popcount (warg1
);
11599 if (!(pop
>= BITS_PER_UNIT
11600 && exact_log2 (pop
) != -1
11601 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
11602 return fold_build2_loc (loc
, code
, type
, op0
,
11603 wide_int_to_tree (type
, masked
));
11607 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11608 ((A & N) + B) & M -> (A + B) & M
11609 Similarly if (N & M) == 0,
11610 ((A | N) + B) & M -> (A + B) & M
11611 and for - instead of + (or unary - instead of +)
11612 and/or ^ instead of |.
11613 If B is constant and (B & M) == 0, fold into A & M. */
11614 if (TREE_CODE (arg1
) == INTEGER_CST
)
11616 wide_int cst1
= arg1
;
11617 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
11618 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
11619 && (TREE_CODE (arg0
) == PLUS_EXPR
11620 || TREE_CODE (arg0
) == MINUS_EXPR
11621 || TREE_CODE (arg0
) == NEGATE_EXPR
)
11622 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
11623 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
11629 /* Now we know that arg0 is (C + D) or (C - D) or
11630 -C and arg1 (M) is == (1LL << cst) - 1.
11631 Store C into PMOP[0] and D into PMOP[1]. */
11632 pmop
[0] = TREE_OPERAND (arg0
, 0);
11634 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
11636 pmop
[1] = TREE_OPERAND (arg0
, 1);
11640 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
11643 for (; which
>= 0; which
--)
11644 switch (TREE_CODE (pmop
[which
]))
11649 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
11652 cst0
= TREE_OPERAND (pmop
[which
], 1);
11654 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
11659 else if (cst0
!= 0)
11661 /* If C or D is of the form (A & N) where
11662 (N & M) == M, or of the form (A | N) or
11663 (A ^ N) where (N & M) == 0, replace it with A. */
11664 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
11667 /* If C or D is a N where (N & M) == 0, it can be
11668 omitted (assumed 0). */
11669 if ((TREE_CODE (arg0
) == PLUS_EXPR
11670 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
11671 && (cst1
& pmop
[which
]) == 0)
11672 pmop
[which
] = NULL
;
11678 /* Only build anything new if we optimized one or both arguments
11680 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
11681 || (TREE_CODE (arg0
) != NEGATE_EXPR
11682 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
11684 tree utype
= TREE_TYPE (arg0
);
11685 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
11687 /* Perform the operations in a type that has defined
11688 overflow behavior. */
11689 utype
= unsigned_type_for (TREE_TYPE (arg0
));
11690 if (pmop
[0] != NULL
)
11691 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
11692 if (pmop
[1] != NULL
)
11693 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
11696 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
11697 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
11698 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
11700 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
11701 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
11703 else if (pmop
[0] != NULL
)
11705 else if (pmop
[1] != NULL
)
11708 return build_int_cst (type
, 0);
11710 else if (pmop
[0] == NULL
)
11711 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
11713 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
11715 /* TEM is now the new binary +, - or unary - replacement. */
11716 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
11717 fold_convert_loc (loc
, utype
, arg1
));
11718 return fold_convert_loc (loc
, type
, tem
);
11723 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11724 if (t1
!= NULL_TREE
)
11726 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11727 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
11728 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
11730 prec
= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
11732 wide_int mask
= wide_int::from (arg1
, prec
, UNSIGNED
);
11735 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11738 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11740 This results in more efficient code for machines without a NOR
11741 instruction. Combine will canonicalize to the first form
11742 which will allow use of NOR instructions provided by the
11743 backend if they exist. */
11744 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11745 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11747 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11748 build2 (BIT_IOR_EXPR
, type
,
11749 fold_convert_loc (loc
, type
,
11750 TREE_OPERAND (arg0
, 0)),
11751 fold_convert_loc (loc
, type
,
11752 TREE_OPERAND (arg1
, 0))));
11755 /* If arg0 is derived from the address of an object or function, we may
11756 be able to fold this expression using the object or function's
11758 if (POINTER_TYPE_P (TREE_TYPE (arg0
)) && tree_fits_uhwi_p (arg1
))
11760 unsigned HOST_WIDE_INT modulus
, residue
;
11761 unsigned HOST_WIDE_INT low
= tree_to_uhwi (arg1
);
11763 modulus
= get_pointer_modulus_and_residue (arg0
, &residue
,
11764 integer_onep (arg1
));
11766 /* This works because modulus is a power of 2. If this weren't the
11767 case, we'd have to replace it by its greatest power-of-2
11768 divisor: modulus & -modulus. */
11770 return build_int_cst (type
, residue
& low
);
11773 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11774 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11775 if the new mask might be further optimized. */
11776 if ((TREE_CODE (arg0
) == LSHIFT_EXPR
11777 || TREE_CODE (arg0
) == RSHIFT_EXPR
)
11778 && TYPE_PRECISION (TREE_TYPE (arg0
)) <= HOST_BITS_PER_WIDE_INT
11779 && TREE_CODE (arg1
) == INTEGER_CST
11780 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
11781 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) > 0
11782 && (tree_to_uhwi (TREE_OPERAND (arg0
, 1))
11783 < TYPE_PRECISION (TREE_TYPE (arg0
))))
11785 unsigned int shiftc
= tree_to_uhwi (TREE_OPERAND (arg0
, 1));
11786 unsigned HOST_WIDE_INT mask
= TREE_INT_CST_LOW (arg1
);
11787 unsigned HOST_WIDE_INT newmask
, zerobits
= 0;
11788 tree shift_type
= TREE_TYPE (arg0
);
11790 if (TREE_CODE (arg0
) == LSHIFT_EXPR
)
11791 zerobits
= ((((unsigned HOST_WIDE_INT
) 1) << shiftc
) - 1);
11792 else if (TREE_CODE (arg0
) == RSHIFT_EXPR
11793 && TYPE_PRECISION (TREE_TYPE (arg0
))
11794 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg0
))))
11796 prec
= TYPE_PRECISION (TREE_TYPE (arg0
));
11797 tree arg00
= TREE_OPERAND (arg0
, 0);
11798 /* See if more bits can be proven as zero because of
11800 if (TREE_CODE (arg00
) == NOP_EXPR
11801 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00
, 0))))
11803 tree inner_type
= TREE_TYPE (TREE_OPERAND (arg00
, 0));
11804 if (TYPE_PRECISION (inner_type
)
11805 == GET_MODE_PRECISION (TYPE_MODE (inner_type
))
11806 && TYPE_PRECISION (inner_type
) < prec
)
11808 prec
= TYPE_PRECISION (inner_type
);
11809 /* See if we can shorten the right shift. */
11811 shift_type
= inner_type
;
11812 /* Otherwise X >> C1 is all zeros, so we'll optimize
11813 it into (X, 0) later on by making sure zerobits
11817 zerobits
= ~(unsigned HOST_WIDE_INT
) 0;
11820 zerobits
>>= HOST_BITS_PER_WIDE_INT
- shiftc
;
11821 zerobits
<<= prec
- shiftc
;
11823 /* For arithmetic shift if sign bit could be set, zerobits
11824 can contain actually sign bits, so no transformation is
11825 possible, unless MASK masks them all away. In that
11826 case the shift needs to be converted into logical shift. */
11827 if (!TYPE_UNSIGNED (TREE_TYPE (arg0
))
11828 && prec
== TYPE_PRECISION (TREE_TYPE (arg0
)))
11830 if ((mask
& zerobits
) == 0)
11831 shift_type
= unsigned_type_for (TREE_TYPE (arg0
));
11837 /* ((X << 16) & 0xff00) is (X, 0). */
11838 if ((mask
& zerobits
) == mask
)
11839 return omit_one_operand_loc (loc
, type
,
11840 build_int_cst (type
, 0), arg0
);
11842 newmask
= mask
| zerobits
;
11843 if (newmask
!= mask
&& (newmask
& (newmask
+ 1)) == 0)
11845 /* Only do the transformation if NEWMASK is some integer
11847 for (prec
= BITS_PER_UNIT
;
11848 prec
< HOST_BITS_PER_WIDE_INT
; prec
<<= 1)
11849 if (newmask
== (((unsigned HOST_WIDE_INT
) 1) << prec
) - 1)
11851 if (prec
< HOST_BITS_PER_WIDE_INT
11852 || newmask
== ~(unsigned HOST_WIDE_INT
) 0)
11856 if (shift_type
!= TREE_TYPE (arg0
))
11858 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), shift_type
,
11859 fold_convert_loc (loc
, shift_type
,
11860 TREE_OPERAND (arg0
, 0)),
11861 TREE_OPERAND (arg0
, 1));
11862 tem
= fold_convert_loc (loc
, type
, tem
);
11866 newmaskt
= build_int_cst_type (TREE_TYPE (op1
), newmask
);
11867 if (!tree_int_cst_equal (newmaskt
, arg1
))
11868 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tem
, newmaskt
);
11876 /* Don't touch a floating-point divide by zero unless the mode
11877 of the constant can represent infinity. */
11878 if (TREE_CODE (arg1
) == REAL_CST
11879 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
11880 && real_zerop (arg1
))
11883 /* Optimize A / A to 1.0 if we don't care about
11884 NaNs or Infinities. Skip the transformation
11885 for non-real operands. */
11886 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11887 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
11888 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0
)))
11889 && operand_equal_p (arg0
, arg1
, 0))
11891 tree r
= build_real (TREE_TYPE (arg0
), dconst1
);
11893 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
11896 /* The complex version of the above A / A optimization. */
11897 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11898 && operand_equal_p (arg0
, arg1
, 0))
11900 tree elem_type
= TREE_TYPE (TREE_TYPE (arg0
));
11901 if (! HONOR_NANS (TYPE_MODE (elem_type
))
11902 && ! HONOR_INFINITIES (TYPE_MODE (elem_type
)))
11904 tree r
= build_real (elem_type
, dconst1
);
11905 /* omit_two_operands will call fold_convert for us. */
11906 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
11910 /* (-A) / (-B) -> A / B */
11911 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
11912 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11913 TREE_OPERAND (arg0
, 0),
11914 negate_expr (arg1
));
11915 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
11916 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11917 negate_expr (arg0
),
11918 TREE_OPERAND (arg1
, 0));
11920 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
11921 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11922 && real_onep (arg1
))
11923 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11925 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
11926 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11927 && real_minus_onep (arg1
))
11928 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
,
11929 negate_expr (arg0
)));
11931 /* If ARG1 is a constant, we can convert this to a multiply by the
11932 reciprocal. This does not have the same rounding properties,
11933 so only do this if -freciprocal-math. We can actually
11934 always safely do it if ARG1 is a power of two, but it's hard to
11935 tell if it is or not in a portable manner. */
11937 && (TREE_CODE (arg1
) == REAL_CST
11938 || (TREE_CODE (arg1
) == COMPLEX_CST
11939 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg1
)))
11940 || (TREE_CODE (arg1
) == VECTOR_CST
11941 && VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg1
)))))
11943 if (flag_reciprocal_math
11944 && 0 != (tem
= const_binop (code
, build_one_cst (type
), arg1
)))
11945 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tem
);
11946 /* Find the reciprocal if optimizing and the result is exact.
11947 TODO: Complex reciprocal not implemented. */
11948 if (TREE_CODE (arg1
) != COMPLEX_CST
)
11950 tree inverse
= exact_inverse (TREE_TYPE (arg0
), arg1
);
11953 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, inverse
);
11956 /* Convert A/B/C to A/(B*C). */
11957 if (flag_reciprocal_math
11958 && TREE_CODE (arg0
) == RDIV_EXPR
)
11959 return fold_build2_loc (loc
, RDIV_EXPR
, type
, TREE_OPERAND (arg0
, 0),
11960 fold_build2_loc (loc
, MULT_EXPR
, type
,
11961 TREE_OPERAND (arg0
, 1), arg1
));
11963 /* Convert A/(B/C) to (A/B)*C. */
11964 if (flag_reciprocal_math
11965 && TREE_CODE (arg1
) == RDIV_EXPR
)
11966 return fold_build2_loc (loc
, MULT_EXPR
, type
,
11967 fold_build2_loc (loc
, RDIV_EXPR
, type
, arg0
,
11968 TREE_OPERAND (arg1
, 0)),
11969 TREE_OPERAND (arg1
, 1));
11971 /* Convert C1/(X*C2) into (C1/C2)/X. */
11972 if (flag_reciprocal_math
11973 && TREE_CODE (arg1
) == MULT_EXPR
11974 && TREE_CODE (arg0
) == REAL_CST
11975 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
11977 tree tem
= const_binop (RDIV_EXPR
, arg0
,
11978 TREE_OPERAND (arg1
, 1));
11980 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
11981 TREE_OPERAND (arg1
, 0));
11984 if (flag_unsafe_math_optimizations
)
11986 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
11987 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
11989 /* Optimize sin(x)/cos(x) as tan(x). */
11990 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_COS
)
11991 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_COSF
)
11992 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_COSL
))
11993 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11994 CALL_EXPR_ARG (arg1
, 0), 0))
11996 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
11998 if (tanfn
!= NULL_TREE
)
11999 return build_call_expr_loc (loc
, tanfn
, 1, CALL_EXPR_ARG (arg0
, 0));
12002 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
12003 if (((fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_SIN
)
12004 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_SINF
)
12005 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_SINL
))
12006 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
12007 CALL_EXPR_ARG (arg1
, 0), 0))
12009 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
12011 if (tanfn
!= NULL_TREE
)
12013 tree tmp
= build_call_expr_loc (loc
, tanfn
, 1,
12014 CALL_EXPR_ARG (arg0
, 0));
12015 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12016 build_real (type
, dconst1
), tmp
);
12020 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
12021 NaNs or Infinities. */
12022 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_TAN
)
12023 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_TANF
)
12024 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_TANL
)))
12026 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12027 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
12029 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
12030 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
12031 && operand_equal_p (arg00
, arg01
, 0))
12033 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
12035 if (cosfn
!= NULL_TREE
)
12036 return build_call_expr_loc (loc
, cosfn
, 1, arg00
);
12040 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
12041 NaNs or Infinities. */
12042 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_SIN
)
12043 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_SINF
)
12044 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_SINL
)))
12046 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12047 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
12049 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
12050 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
12051 && operand_equal_p (arg00
, arg01
, 0))
12053 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
12055 if (cosfn
!= NULL_TREE
)
12057 tree tmp
= build_call_expr_loc (loc
, cosfn
, 1, arg00
);
12058 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12059 build_real (type
, dconst1
),
12065 /* Optimize pow(x,c)/x as pow(x,c-1). */
12066 if (fcode0
== BUILT_IN_POW
12067 || fcode0
== BUILT_IN_POWF
12068 || fcode0
== BUILT_IN_POWL
)
12070 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12071 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
12072 if (TREE_CODE (arg01
) == REAL_CST
12073 && !TREE_OVERFLOW (arg01
)
12074 && operand_equal_p (arg1
, arg00
, 0))
12076 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
12080 c
= TREE_REAL_CST (arg01
);
12081 real_arithmetic (&c
, MINUS_EXPR
, &c
, &dconst1
);
12082 arg
= build_real (type
, c
);
12083 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
12087 /* Optimize a/root(b/c) into a*root(c/b). */
12088 if (BUILTIN_ROOT_P (fcode1
))
12090 tree rootarg
= CALL_EXPR_ARG (arg1
, 0);
12092 if (TREE_CODE (rootarg
) == RDIV_EXPR
)
12094 tree rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12095 tree b
= TREE_OPERAND (rootarg
, 0);
12096 tree c
= TREE_OPERAND (rootarg
, 1);
12098 tree tmp
= fold_build2_loc (loc
, RDIV_EXPR
, type
, c
, b
);
12100 tmp
= build_call_expr_loc (loc
, rootfn
, 1, tmp
);
12101 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tmp
);
12105 /* Optimize x/expN(y) into x*expN(-y). */
12106 if (BUILTIN_EXPONENT_P (fcode1
))
12108 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12109 tree arg
= negate_expr (CALL_EXPR_ARG (arg1
, 0));
12110 arg1
= build_call_expr_loc (loc
,
12112 fold_convert_loc (loc
, type
, arg
));
12113 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12116 /* Optimize x/pow(y,z) into x*pow(y,-z). */
12117 if (fcode1
== BUILT_IN_POW
12118 || fcode1
== BUILT_IN_POWF
12119 || fcode1
== BUILT_IN_POWL
)
12121 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12122 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
12123 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
12124 tree neg11
= fold_convert_loc (loc
, type
,
12125 negate_expr (arg11
));
12126 arg1
= build_call_expr_loc (loc
, powfn
, 2, arg10
, neg11
);
12127 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12132 case TRUNC_DIV_EXPR
:
12133 /* Optimize (X & (-A)) / A where A is a power of 2,
12135 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12136 && !TYPE_UNSIGNED (type
) && TREE_CODE (arg1
) == INTEGER_CST
12137 && integer_pow2p (arg1
) && tree_int_cst_sgn (arg1
) > 0)
12139 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (arg1
),
12140 arg1
, TREE_OPERAND (arg0
, 1));
12141 if (sum
&& integer_zerop (sum
)) {
12142 tree pow2
= build_int_cst (integer_type_node
,
12143 wi::exact_log2 (arg1
));
12144 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12145 TREE_OPERAND (arg0
, 0), pow2
);
12151 case FLOOR_DIV_EXPR
:
12152 /* Simplify A / (B << N) where A and B are positive and B is
12153 a power of 2, to A >> (N + log2(B)). */
12154 strict_overflow_p
= false;
12155 if (TREE_CODE (arg1
) == LSHIFT_EXPR
12156 && (TYPE_UNSIGNED (type
)
12157 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12159 tree sval
= TREE_OPERAND (arg1
, 0);
12160 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
12162 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
12163 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
12164 wi::exact_log2 (sval
));
12166 if (strict_overflow_p
)
12167 fold_overflow_warning (("assuming signed overflow does not "
12168 "occur when simplifying A / (B << N)"),
12169 WARN_STRICT_OVERFLOW_MISC
);
12171 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
12173 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12174 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
12178 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
12179 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
12180 if (INTEGRAL_TYPE_P (type
)
12181 && TYPE_UNSIGNED (type
)
12182 && code
== FLOOR_DIV_EXPR
)
12183 return fold_build2_loc (loc
, TRUNC_DIV_EXPR
, type
, op0
, op1
);
12187 case ROUND_DIV_EXPR
:
12188 case CEIL_DIV_EXPR
:
12189 case EXACT_DIV_EXPR
:
12190 if (integer_onep (arg1
))
12191 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12192 if (integer_zerop (arg1
))
12194 /* X / -1 is -X. */
12195 if (!TYPE_UNSIGNED (type
)
12196 && TREE_CODE (arg1
) == INTEGER_CST
12197 && wi::eq_p (arg1
, -1))
12198 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
12200 /* Convert -A / -B to A / B when the type is signed and overflow is
12202 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12203 && TREE_CODE (arg0
) == NEGATE_EXPR
12204 && negate_expr_p (arg1
))
12206 if (INTEGRAL_TYPE_P (type
))
12207 fold_overflow_warning (("assuming signed overflow does not occur "
12208 "when distributing negation across "
12210 WARN_STRICT_OVERFLOW_MISC
);
12211 return fold_build2_loc (loc
, code
, type
,
12212 fold_convert_loc (loc
, type
,
12213 TREE_OPERAND (arg0
, 0)),
12214 fold_convert_loc (loc
, type
,
12215 negate_expr (arg1
)));
12217 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12218 && TREE_CODE (arg1
) == NEGATE_EXPR
12219 && negate_expr_p (arg0
))
12221 if (INTEGRAL_TYPE_P (type
))
12222 fold_overflow_warning (("assuming signed overflow does not occur "
12223 "when distributing negation across "
12225 WARN_STRICT_OVERFLOW_MISC
);
12226 return fold_build2_loc (loc
, code
, type
,
12227 fold_convert_loc (loc
, type
,
12228 negate_expr (arg0
)),
12229 fold_convert_loc (loc
, type
,
12230 TREE_OPERAND (arg1
, 0)));
12233 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12234 operation, EXACT_DIV_EXPR.
12236 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12237 At one time others generated faster code, it's not clear if they do
12238 after the last round to changes to the DIV code in expmed.c. */
12239 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
12240 && multiple_of_p (type
, arg0
, arg1
))
12241 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
, arg0
, arg1
);
12243 strict_overflow_p
= false;
12244 if (TREE_CODE (arg1
) == INTEGER_CST
12245 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12246 &strict_overflow_p
)))
12248 if (strict_overflow_p
)
12249 fold_overflow_warning (("assuming signed overflow does not occur "
12250 "when simplifying division"),
12251 WARN_STRICT_OVERFLOW_MISC
);
12252 return fold_convert_loc (loc
, type
, tem
);
12257 case CEIL_MOD_EXPR
:
12258 case FLOOR_MOD_EXPR
:
12259 case ROUND_MOD_EXPR
:
12260 case TRUNC_MOD_EXPR
:
12261 /* X % 1 is always zero, but be sure to preserve any side
12263 if (integer_onep (arg1
))
12264 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12266 /* X % 0, return X % 0 unchanged so that we can get the
12267 proper warnings and errors. */
12268 if (integer_zerop (arg1
))
12271 /* 0 % X is always zero, but be sure to preserve any side
12272 effects in X. Place this after checking for X == 0. */
12273 if (integer_zerop (arg0
))
12274 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12276 /* X % -1 is zero. */
12277 if (!TYPE_UNSIGNED (type
)
12278 && TREE_CODE (arg1
) == INTEGER_CST
12279 && wi::eq_p (arg1
, -1))
12280 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12282 /* X % -C is the same as X % C. */
12283 if (code
== TRUNC_MOD_EXPR
12284 && TYPE_SIGN (type
) == SIGNED
12285 && TREE_CODE (arg1
) == INTEGER_CST
12286 && !TREE_OVERFLOW (arg1
)
12287 && wi::neg_p (arg1
)
12288 && !TYPE_OVERFLOW_TRAPS (type
)
12289 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
12290 && !sign_bit_p (arg1
, arg1
))
12291 return fold_build2_loc (loc
, code
, type
,
12292 fold_convert_loc (loc
, type
, arg0
),
12293 fold_convert_loc (loc
, type
,
12294 negate_expr (arg1
)));
12296 /* X % -Y is the same as X % Y. */
12297 if (code
== TRUNC_MOD_EXPR
12298 && !TYPE_UNSIGNED (type
)
12299 && TREE_CODE (arg1
) == NEGATE_EXPR
12300 && !TYPE_OVERFLOW_TRAPS (type
))
12301 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, arg0
),
12302 fold_convert_loc (loc
, type
,
12303 TREE_OPERAND (arg1
, 0)));
12305 strict_overflow_p
= false;
12306 if (TREE_CODE (arg1
) == INTEGER_CST
12307 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12308 &strict_overflow_p
)))
12310 if (strict_overflow_p
)
12311 fold_overflow_warning (("assuming signed overflow does not occur "
12312 "when simplifying modulus"),
12313 WARN_STRICT_OVERFLOW_MISC
);
12314 return fold_convert_loc (loc
, type
, tem
);
12317 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12318 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
12319 if ((code
== TRUNC_MOD_EXPR
|| code
== FLOOR_MOD_EXPR
)
12320 && (TYPE_UNSIGNED (type
)
12321 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12324 /* Also optimize A % (C << N) where C is a power of 2,
12325 to A & ((C << N) - 1). */
12326 if (TREE_CODE (arg1
) == LSHIFT_EXPR
)
12327 c
= TREE_OPERAND (arg1
, 0);
12329 if (integer_pow2p (c
) && tree_int_cst_sgn (c
) > 0)
12332 = fold_build2_loc (loc
, MINUS_EXPR
, TREE_TYPE (arg1
), arg1
,
12333 build_int_cst (TREE_TYPE (arg1
), 1));
12334 if (strict_overflow_p
)
12335 fold_overflow_warning (("assuming signed overflow does not "
12336 "occur when simplifying "
12337 "X % (power of two)"),
12338 WARN_STRICT_OVERFLOW_MISC
);
12339 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
12340 fold_convert_loc (loc
, type
, arg0
),
12341 fold_convert_loc (loc
, type
, mask
));
12349 if (integer_all_onesp (arg0
))
12350 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12354 /* Optimize -1 >> x for arithmetic right shifts. */
12355 if (integer_all_onesp (arg0
) && !TYPE_UNSIGNED (type
)
12356 && tree_expr_nonnegative_p (arg1
))
12357 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12358 /* ... fall through ... */
12362 if (integer_zerop (arg1
))
12363 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12364 if (integer_zerop (arg0
))
12365 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12367 /* Prefer vector1 << scalar to vector1 << vector2
12368 if vector2 is uniform. */
12369 if (VECTOR_TYPE_P (TREE_TYPE (arg1
))
12370 && (tem
= uniform_vector_p (arg1
)) != NULL_TREE
)
12371 return fold_build2_loc (loc
, code
, type
, op0
, tem
);
12373 /* Since negative shift count is not well-defined,
12374 don't try to compute it in the compiler. */
12375 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
12378 prec
= element_precision (type
);
12380 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
12381 if (TREE_CODE (op0
) == code
&& tree_fits_uhwi_p (arg1
)
12382 && tree_to_uhwi (arg1
) < prec
12383 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
12384 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) < prec
)
12386 unsigned int low
= (tree_to_uhwi (TREE_OPERAND (arg0
, 1))
12387 + tree_to_uhwi (arg1
));
12389 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12390 being well defined. */
12393 if (code
== LROTATE_EXPR
|| code
== RROTATE_EXPR
)
12395 else if (TYPE_UNSIGNED (type
) || code
== LSHIFT_EXPR
)
12396 return omit_one_operand_loc (loc
, type
, build_zero_cst (type
),
12397 TREE_OPERAND (arg0
, 0));
12402 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12403 build_int_cst (TREE_TYPE (arg1
), low
));
12406 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12407 into x & ((unsigned)-1 >> c) for unsigned types. */
12408 if (((code
== LSHIFT_EXPR
&& TREE_CODE (arg0
) == RSHIFT_EXPR
)
12409 || (TYPE_UNSIGNED (type
)
12410 && code
== RSHIFT_EXPR
&& TREE_CODE (arg0
) == LSHIFT_EXPR
))
12411 && tree_fits_uhwi_p (arg1
)
12412 && tree_to_uhwi (arg1
) < prec
12413 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
12414 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) < prec
)
12416 HOST_WIDE_INT low0
= tree_to_uhwi (TREE_OPERAND (arg0
, 1));
12417 HOST_WIDE_INT low1
= tree_to_uhwi (arg1
);
12423 arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12425 lshift
= build_minus_one_cst (type
);
12426 lshift
= const_binop (code
, lshift
, arg1
);
12428 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, arg00
, lshift
);
12432 /* Rewrite an LROTATE_EXPR by a constant into an
12433 RROTATE_EXPR by a new constant. */
12434 if (code
== LROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
)
12436 tree tem
= build_int_cst (TREE_TYPE (arg1
), prec
);
12437 tem
= const_binop (MINUS_EXPR
, tem
, arg1
);
12438 return fold_build2_loc (loc
, RROTATE_EXPR
, type
, op0
, tem
);
12441 /* If we have a rotate of a bit operation with the rotate count and
12442 the second operand of the bit operation both constant,
12443 permute the two operations. */
12444 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12445 && (TREE_CODE (arg0
) == BIT_AND_EXPR
12446 || TREE_CODE (arg0
) == BIT_IOR_EXPR
12447 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12448 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12449 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
12450 fold_build2_loc (loc
, code
, type
,
12451 TREE_OPERAND (arg0
, 0), arg1
),
12452 fold_build2_loc (loc
, code
, type
,
12453 TREE_OPERAND (arg0
, 1), arg1
));
12455 /* Two consecutive rotates adding up to the some integer
12456 multiple of the precision of the type can be ignored. */
12457 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12458 && TREE_CODE (arg0
) == RROTATE_EXPR
12459 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
12460 && wi::umod_trunc (wi::add (arg1
, TREE_OPERAND (arg0
, 1)),
12462 return TREE_OPERAND (arg0
, 0);
12464 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12465 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12466 if the latter can be further optimized. */
12467 if ((code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
12468 && TREE_CODE (arg0
) == BIT_AND_EXPR
12469 && TREE_CODE (arg1
) == INTEGER_CST
12470 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12472 tree mask
= fold_build2_loc (loc
, code
, type
,
12473 fold_convert_loc (loc
, type
,
12474 TREE_OPERAND (arg0
, 1)),
12476 tree shift
= fold_build2_loc (loc
, code
, type
,
12477 fold_convert_loc (loc
, type
,
12478 TREE_OPERAND (arg0
, 0)),
12480 tem
= fold_binary_loc (loc
, BIT_AND_EXPR
, type
, shift
, mask
);
12488 if (operand_equal_p (arg0
, arg1
, 0))
12489 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12490 if (INTEGRAL_TYPE_P (type
)
12491 && operand_equal_p (arg1
, TYPE_MIN_VALUE (type
), OEP_ONLY_CONST
))
12492 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12493 tem
= fold_minmax (loc
, MIN_EXPR
, type
, arg0
, arg1
);
12499 if (operand_equal_p (arg0
, arg1
, 0))
12500 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12501 if (INTEGRAL_TYPE_P (type
)
12502 && TYPE_MAX_VALUE (type
)
12503 && operand_equal_p (arg1
, TYPE_MAX_VALUE (type
), OEP_ONLY_CONST
))
12504 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12505 tem
= fold_minmax (loc
, MAX_EXPR
, type
, arg0
, arg1
);
12510 case TRUTH_ANDIF_EXPR
:
12511 /* Note that the operands of this must be ints
12512 and their values must be 0 or 1.
12513 ("true" is a fixed value perhaps depending on the language.) */
12514 /* If first arg is constant zero, return it. */
12515 if (integer_zerop (arg0
))
12516 return fold_convert_loc (loc
, type
, arg0
);
12517 case TRUTH_AND_EXPR
:
12518 /* If either arg is constant true, drop it. */
12519 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12520 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12521 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
12522 /* Preserve sequence points. */
12523 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12524 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12525 /* If second arg is constant zero, result is zero, but first arg
12526 must be evaluated. */
12527 if (integer_zerop (arg1
))
12528 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12529 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12530 case will be handled here. */
12531 if (integer_zerop (arg0
))
12532 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12534 /* !X && X is always false. */
12535 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12536 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12537 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12538 /* X && !X is always false. */
12539 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12540 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12541 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12543 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12544 means A >= Y && A != MAX, but in this case we know that
12547 if (!TREE_SIDE_EFFECTS (arg0
)
12548 && !TREE_SIDE_EFFECTS (arg1
))
12550 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
12551 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
12552 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
12554 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
12555 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
12556 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
12559 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12565 case TRUTH_ORIF_EXPR
:
12566 /* Note that the operands of this must be ints
12567 and their values must be 0 or true.
12568 ("true" is a fixed value perhaps depending on the language.) */
12569 /* If first arg is constant true, return it. */
12570 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12571 return fold_convert_loc (loc
, type
, arg0
);
12572 case TRUTH_OR_EXPR
:
12573 /* If either arg is constant zero, drop it. */
12574 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
12575 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12576 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
12577 /* Preserve sequence points. */
12578 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12579 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12580 /* If second arg is constant true, result is true, but we must
12581 evaluate first arg. */
12582 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
12583 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12584 /* Likewise for first arg, but note this only occurs here for
12586 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12587 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12589 /* !X || X is always true. */
12590 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12591 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12592 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12593 /* X || !X is always true. */
12594 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12595 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12596 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12598 /* (X && !Y) || (!X && Y) is X ^ Y */
12599 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
12600 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
12602 tree a0
, a1
, l0
, l1
, n0
, n1
;
12604 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
12605 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
12607 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12608 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
12610 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
12611 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
12613 if ((operand_equal_p (n0
, a0
, 0)
12614 && operand_equal_p (n1
, a1
, 0))
12615 || (operand_equal_p (n0
, a1
, 0)
12616 && operand_equal_p (n1
, a0
, 0)))
12617 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
12620 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12626 case TRUTH_XOR_EXPR
:
12627 /* If the second arg is constant zero, drop it. */
12628 if (integer_zerop (arg1
))
12629 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12630 /* If the second arg is constant true, this is a logical inversion. */
12631 if (integer_onep (arg1
))
12633 tem
= invert_truthvalue_loc (loc
, arg0
);
12634 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
12636 /* Identical arguments cancel to zero. */
12637 if (operand_equal_p (arg0
, arg1
, 0))
12638 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12640 /* !X ^ X is always true. */
12641 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12642 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12643 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12645 /* X ^ !X is always true. */
12646 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12647 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12648 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12657 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
12658 if (tem
!= NULL_TREE
)
12661 /* bool_var != 0 becomes bool_var. */
12662 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12663 && code
== NE_EXPR
)
12664 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12666 /* bool_var == 1 becomes bool_var. */
12667 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12668 && code
== EQ_EXPR
)
12669 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12671 /* bool_var != 1 becomes !bool_var. */
12672 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12673 && code
== NE_EXPR
)
12674 return fold_convert_loc (loc
, type
,
12675 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12676 TREE_TYPE (arg0
), arg0
));
12678 /* bool_var == 0 becomes !bool_var. */
12679 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12680 && code
== EQ_EXPR
)
12681 return fold_convert_loc (loc
, type
,
12682 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12683 TREE_TYPE (arg0
), arg0
));
12685 /* !exp != 0 becomes !exp */
12686 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
12687 && code
== NE_EXPR
)
12688 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12690 /* If this is an equality comparison of the address of two non-weak,
12691 unaliased symbols neither of which are extern (since we do not
12692 have access to attributes for externs), then we know the result. */
12693 if (TREE_CODE (arg0
) == ADDR_EXPR
12694 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0
, 0))
12695 && ! DECL_WEAK (TREE_OPERAND (arg0
, 0))
12696 && ! lookup_attribute ("alias",
12697 DECL_ATTRIBUTES (TREE_OPERAND (arg0
, 0)))
12698 && ! DECL_EXTERNAL (TREE_OPERAND (arg0
, 0))
12699 && TREE_CODE (arg1
) == ADDR_EXPR
12700 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1
, 0))
12701 && ! DECL_WEAK (TREE_OPERAND (arg1
, 0))
12702 && ! lookup_attribute ("alias",
12703 DECL_ATTRIBUTES (TREE_OPERAND (arg1
, 0)))
12704 && ! DECL_EXTERNAL (TREE_OPERAND (arg1
, 0)))
12706 /* We know that we're looking at the address of two
12707 non-weak, unaliased, static _DECL nodes.
12709 It is both wasteful and incorrect to call operand_equal_p
12710 to compare the two ADDR_EXPR nodes. It is wasteful in that
12711 all we need to do is test pointer equality for the arguments
12712 to the two ADDR_EXPR nodes. It is incorrect to use
12713 operand_equal_p as that function is NOT equivalent to a
12714 C equality test. It can in fact return false for two
12715 objects which would test as equal using the C equality
12717 bool equal
= TREE_OPERAND (arg0
, 0) == TREE_OPERAND (arg1
, 0);
12718 return constant_boolean_node (equal
12719 ? code
== EQ_EXPR
: code
!= EQ_EXPR
,
12723 /* Similarly for a NEGATE_EXPR. */
12724 if (TREE_CODE (arg0
) == NEGATE_EXPR
12725 && TREE_CODE (arg1
) == INTEGER_CST
12726 && 0 != (tem
= negate_expr (fold_convert_loc (loc
, TREE_TYPE (arg0
),
12728 && TREE_CODE (tem
) == INTEGER_CST
12729 && !TREE_OVERFLOW (tem
))
12730 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
12732 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12733 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12734 && TREE_CODE (arg1
) == INTEGER_CST
12735 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12736 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12737 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg0
),
12738 fold_convert_loc (loc
,
12741 TREE_OPERAND (arg0
, 1)));
12743 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12744 if ((TREE_CODE (arg0
) == PLUS_EXPR
12745 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
12746 || TREE_CODE (arg0
) == MINUS_EXPR
)
12747 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12750 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
12751 || POINTER_TYPE_P (TREE_TYPE (arg0
))))
12753 tree val
= TREE_OPERAND (arg0
, 1);
12754 return omit_two_operands_loc (loc
, type
,
12755 fold_build2_loc (loc
, code
, type
,
12757 build_int_cst (TREE_TYPE (val
),
12759 TREE_OPERAND (arg0
, 0), arg1
);
12762 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12763 if (TREE_CODE (arg0
) == MINUS_EXPR
12764 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == INTEGER_CST
12765 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12768 && wi::extract_uhwi (TREE_OPERAND (arg0
, 0), 0, 1) == 1)
12770 return omit_two_operands_loc (loc
, type
,
12772 ? boolean_true_node
: boolean_false_node
,
12773 TREE_OPERAND (arg0
, 1), arg1
);
12776 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12777 if (TREE_CODE (arg0
) == ABS_EXPR
12778 && (integer_zerop (arg1
) || real_zerop (arg1
)))
12779 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), arg1
);
12781 /* If this is an EQ or NE comparison with zero and ARG0 is
12782 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12783 two operations, but the latter can be done in one less insn
12784 on machines that have only two-operand insns or on which a
12785 constant cannot be the first operand. */
12786 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12787 && integer_zerop (arg1
))
12789 tree arg00
= TREE_OPERAND (arg0
, 0);
12790 tree arg01
= TREE_OPERAND (arg0
, 1);
12791 if (TREE_CODE (arg00
) == LSHIFT_EXPR
12792 && integer_onep (TREE_OPERAND (arg00
, 0)))
12794 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
12795 arg01
, TREE_OPERAND (arg00
, 1));
12796 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12797 build_int_cst (TREE_TYPE (arg0
), 1));
12798 return fold_build2_loc (loc
, code
, type
,
12799 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12802 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
12803 && integer_onep (TREE_OPERAND (arg01
, 0)))
12805 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
12806 arg00
, TREE_OPERAND (arg01
, 1));
12807 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12808 build_int_cst (TREE_TYPE (arg0
), 1));
12809 return fold_build2_loc (loc
, code
, type
,
12810 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12815 /* If this is an NE or EQ comparison of zero against the result of a
12816 signed MOD operation whose second operand is a power of 2, make
12817 the MOD operation unsigned since it is simpler and equivalent. */
12818 if (integer_zerop (arg1
)
12819 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
12820 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
12821 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
12822 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
12823 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
12824 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
12826 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
12827 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
12828 fold_convert_loc (loc
, newtype
,
12829 TREE_OPERAND (arg0
, 0)),
12830 fold_convert_loc (loc
, newtype
,
12831 TREE_OPERAND (arg0
, 1)));
12833 return fold_build2_loc (loc
, code
, type
, newmod
,
12834 fold_convert_loc (loc
, newtype
, arg1
));
12837 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12838 C1 is a valid shift constant, and C2 is a power of two, i.e.
12840 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12841 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
12842 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
12844 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12845 && integer_zerop (arg1
))
12847 tree itype
= TREE_TYPE (arg0
);
12848 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
12849 prec
= TYPE_PRECISION (itype
);
12851 /* Check for a valid shift count. */
12852 if (wi::ltu_p (arg001
, prec
))
12854 tree arg01
= TREE_OPERAND (arg0
, 1);
12855 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
12856 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
12857 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12858 can be rewritten as (X & (C2 << C1)) != 0. */
12859 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
12861 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
12862 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
12863 return fold_build2_loc (loc
, code
, type
, tem
,
12864 fold_convert_loc (loc
, itype
, arg1
));
12866 /* Otherwise, for signed (arithmetic) shifts,
12867 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12868 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
12869 else if (!TYPE_UNSIGNED (itype
))
12870 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
12871 arg000
, build_int_cst (itype
, 0));
12872 /* Otherwise, of unsigned (logical) shifts,
12873 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12874 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
12876 return omit_one_operand_loc (loc
, type
,
12877 code
== EQ_EXPR
? integer_one_node
12878 : integer_zero_node
,
12883 /* If we have (A & C) == C where C is a power of 2, convert this into
12884 (A & C) != 0. Similarly for NE_EXPR. */
12885 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12886 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12887 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
12888 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
12889 arg0
, fold_convert_loc (loc
, TREE_TYPE (arg0
),
12890 integer_zero_node
));
12892 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12893 bit, then fold the expression into A < 0 or A >= 0. */
12894 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
, type
);
12898 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12899 Similarly for NE_EXPR. */
12900 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12901 && TREE_CODE (arg1
) == INTEGER_CST
12902 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12904 tree notc
= fold_build1_loc (loc
, BIT_NOT_EXPR
,
12905 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
12906 TREE_OPERAND (arg0
, 1));
12908 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12909 fold_convert_loc (loc
, TREE_TYPE (arg0
), arg1
),
12911 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
12912 if (integer_nonzerop (dandnotc
))
12913 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
12916 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12917 Similarly for NE_EXPR. */
12918 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
12919 && TREE_CODE (arg1
) == INTEGER_CST
12920 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12922 tree notd
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
), arg1
);
12924 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12925 TREE_OPERAND (arg0
, 1),
12926 fold_convert_loc (loc
, TREE_TYPE (arg0
), notd
));
12927 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
12928 if (integer_nonzerop (candnotd
))
12929 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
12932 /* If this is a comparison of a field, we may be able to simplify it. */
12933 if ((TREE_CODE (arg0
) == COMPONENT_REF
12934 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
12935 /* Handle the constant case even without -O
12936 to make sure the warnings are given. */
12937 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
12939 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
12944 /* Optimize comparisons of strlen vs zero to a compare of the
12945 first character of the string vs zero. To wit,
12946 strlen(ptr) == 0 => *ptr == 0
12947 strlen(ptr) != 0 => *ptr != 0
12948 Other cases should reduce to one of these two (or a constant)
12949 due to the return value of strlen being unsigned. */
12950 if (TREE_CODE (arg0
) == CALL_EXPR
12951 && integer_zerop (arg1
))
12953 tree fndecl
= get_callee_fndecl (arg0
);
12956 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
12957 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
12958 && call_expr_nargs (arg0
) == 1
12959 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
12961 tree iref
= build_fold_indirect_ref_loc (loc
,
12962 CALL_EXPR_ARG (arg0
, 0));
12963 return fold_build2_loc (loc
, code
, type
, iref
,
12964 build_int_cst (TREE_TYPE (iref
), 0));
12968 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12969 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12970 if (TREE_CODE (arg0
) == RSHIFT_EXPR
12971 && integer_zerop (arg1
)
12972 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12974 tree arg00
= TREE_OPERAND (arg0
, 0);
12975 tree arg01
= TREE_OPERAND (arg0
, 1);
12976 tree itype
= TREE_TYPE (arg00
);
12977 if (wi::eq_p (arg01
, TYPE_PRECISION (itype
) - 1))
12979 if (TYPE_UNSIGNED (itype
))
12981 itype
= signed_type_for (itype
);
12982 arg00
= fold_convert_loc (loc
, itype
, arg00
);
12984 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
12985 type
, arg00
, build_zero_cst (itype
));
12989 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
12990 if (integer_zerop (arg1
)
12991 && TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12992 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12993 TREE_OPERAND (arg0
, 1));
12995 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
12996 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12997 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
12998 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12999 build_zero_cst (TREE_TYPE (arg0
)));
13000 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
13001 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13002 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13003 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
13004 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 1),
13005 build_zero_cst (TREE_TYPE (arg0
)));
13007 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
13008 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13009 && TREE_CODE (arg1
) == INTEGER_CST
13010 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
13011 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
13012 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg1
),
13013 TREE_OPERAND (arg0
, 1), arg1
));
13015 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
13016 (X & C) == 0 when C is a single bit. */
13017 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13018 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
13019 && integer_zerop (arg1
)
13020 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
13022 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
13023 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
13024 TREE_OPERAND (arg0
, 1));
13025 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
13027 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13031 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
13032 constant C is a power of two, i.e. a single bit. */
13033 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13034 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
13035 && integer_zerop (arg1
)
13036 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13037 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
13038 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
13040 tree arg00
= TREE_OPERAND (arg0
, 0);
13041 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13042 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
13045 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
13046 when is C is a power of two, i.e. a single bit. */
13047 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13048 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
13049 && integer_zerop (arg1
)
13050 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13051 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
13052 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
13054 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
13055 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
13056 arg000
, TREE_OPERAND (arg0
, 1));
13057 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13058 tem
, build_int_cst (TREE_TYPE (tem
), 0));
13061 if (integer_zerop (arg1
)
13062 && tree_expr_nonzero_p (arg0
))
13064 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
13065 return omit_one_operand_loc (loc
, type
, res
, arg0
);
13068 /* Fold -X op -Y as X op Y, where op is eq/ne. */
13069 if (TREE_CODE (arg0
) == NEGATE_EXPR
13070 && TREE_CODE (arg1
) == NEGATE_EXPR
)
13071 return fold_build2_loc (loc
, code
, type
,
13072 TREE_OPERAND (arg0
, 0),
13073 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13074 TREE_OPERAND (arg1
, 0)));
13076 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
13077 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13078 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
13080 tree arg00
= TREE_OPERAND (arg0
, 0);
13081 tree arg01
= TREE_OPERAND (arg0
, 1);
13082 tree arg10
= TREE_OPERAND (arg1
, 0);
13083 tree arg11
= TREE_OPERAND (arg1
, 1);
13084 tree itype
= TREE_TYPE (arg0
);
13086 if (operand_equal_p (arg01
, arg11
, 0))
13087 return fold_build2_loc (loc
, code
, type
,
13088 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13089 fold_build2_loc (loc
,
13090 BIT_XOR_EXPR
, itype
,
13093 build_zero_cst (itype
));
13095 if (operand_equal_p (arg01
, arg10
, 0))
13096 return fold_build2_loc (loc
, code
, type
,
13097 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13098 fold_build2_loc (loc
,
13099 BIT_XOR_EXPR
, itype
,
13102 build_zero_cst (itype
));
13104 if (operand_equal_p (arg00
, arg11
, 0))
13105 return fold_build2_loc (loc
, code
, type
,
13106 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13107 fold_build2_loc (loc
,
13108 BIT_XOR_EXPR
, itype
,
13111 build_zero_cst (itype
));
13113 if (operand_equal_p (arg00
, arg10
, 0))
13114 return fold_build2_loc (loc
, code
, type
,
13115 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13116 fold_build2_loc (loc
,
13117 BIT_XOR_EXPR
, itype
,
13120 build_zero_cst (itype
));
13123 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13124 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
13126 tree arg00
= TREE_OPERAND (arg0
, 0);
13127 tree arg01
= TREE_OPERAND (arg0
, 1);
13128 tree arg10
= TREE_OPERAND (arg1
, 0);
13129 tree arg11
= TREE_OPERAND (arg1
, 1);
13130 tree itype
= TREE_TYPE (arg0
);
13132 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
13133 operand_equal_p guarantees no side-effects so we don't need
13134 to use omit_one_operand on Z. */
13135 if (operand_equal_p (arg01
, arg11
, 0))
13136 return fold_build2_loc (loc
, code
, type
, arg00
,
13137 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13139 if (operand_equal_p (arg01
, arg10
, 0))
13140 return fold_build2_loc (loc
, code
, type
, arg00
,
13141 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13143 if (operand_equal_p (arg00
, arg11
, 0))
13144 return fold_build2_loc (loc
, code
, type
, arg01
,
13145 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13147 if (operand_equal_p (arg00
, arg10
, 0))
13148 return fold_build2_loc (loc
, code
, type
, arg01
,
13149 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13152 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
13153 if (TREE_CODE (arg01
) == INTEGER_CST
13154 && TREE_CODE (arg11
) == INTEGER_CST
)
13156 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
13157 fold_convert_loc (loc
, itype
, arg11
));
13158 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
13159 return fold_build2_loc (loc
, code
, type
, tem
,
13160 fold_convert_loc (loc
, itype
, arg10
));
13164 /* Attempt to simplify equality/inequality comparisons of complex
13165 values. Only lower the comparison if the result is known or
13166 can be simplified to a single scalar comparison. */
13167 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
13168 || TREE_CODE (arg0
) == COMPLEX_CST
)
13169 && (TREE_CODE (arg1
) == COMPLEX_EXPR
13170 || TREE_CODE (arg1
) == COMPLEX_CST
))
13172 tree real0
, imag0
, real1
, imag1
;
13175 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
13177 real0
= TREE_OPERAND (arg0
, 0);
13178 imag0
= TREE_OPERAND (arg0
, 1);
13182 real0
= TREE_REALPART (arg0
);
13183 imag0
= TREE_IMAGPART (arg0
);
13186 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
13188 real1
= TREE_OPERAND (arg1
, 0);
13189 imag1
= TREE_OPERAND (arg1
, 1);
13193 real1
= TREE_REALPART (arg1
);
13194 imag1
= TREE_IMAGPART (arg1
);
13197 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
13198 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
13200 if (integer_zerop (rcond
))
13202 if (code
== EQ_EXPR
)
13203 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13205 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
13209 if (code
== NE_EXPR
)
13210 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13212 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
13216 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
13217 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
13219 if (integer_zerop (icond
))
13221 if (code
== EQ_EXPR
)
13222 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13224 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
13228 if (code
== NE_EXPR
)
13229 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13231 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
13242 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
13243 if (tem
!= NULL_TREE
)
13246 /* Transform comparisons of the form X +- C CMP X. */
13247 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
13248 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13249 && ((TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
13250 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
))))
13251 || (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
13252 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))))
13254 tree arg01
= TREE_OPERAND (arg0
, 1);
13255 enum tree_code code0
= TREE_CODE (arg0
);
13258 if (TREE_CODE (arg01
) == REAL_CST
)
13259 is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
13261 is_positive
= tree_int_cst_sgn (arg01
);
13263 /* (X - c) > X becomes false. */
13264 if (code
== GT_EXPR
13265 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13266 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13268 if (TREE_CODE (arg01
) == INTEGER_CST
13269 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13270 fold_overflow_warning (("assuming signed overflow does not "
13271 "occur when assuming that (X - c) > X "
13272 "is always false"),
13273 WARN_STRICT_OVERFLOW_ALL
);
13274 return constant_boolean_node (0, type
);
13277 /* Likewise (X + c) < X becomes false. */
13278 if (code
== LT_EXPR
13279 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13280 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13282 if (TREE_CODE (arg01
) == INTEGER_CST
13283 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13284 fold_overflow_warning (("assuming signed overflow does not "
13285 "occur when assuming that "
13286 "(X + c) < X is always false"),
13287 WARN_STRICT_OVERFLOW_ALL
);
13288 return constant_boolean_node (0, type
);
13291 /* Convert (X - c) <= X to true. */
13292 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13294 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13295 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13297 if (TREE_CODE (arg01
) == INTEGER_CST
13298 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13299 fold_overflow_warning (("assuming signed overflow does not "
13300 "occur when assuming that "
13301 "(X - c) <= X is always true"),
13302 WARN_STRICT_OVERFLOW_ALL
);
13303 return constant_boolean_node (1, type
);
13306 /* Convert (X + c) >= X to true. */
13307 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13309 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13310 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13312 if (TREE_CODE (arg01
) == INTEGER_CST
13313 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13314 fold_overflow_warning (("assuming signed overflow does not "
13315 "occur when assuming that "
13316 "(X + c) >= X is always true"),
13317 WARN_STRICT_OVERFLOW_ALL
);
13318 return constant_boolean_node (1, type
);
13321 if (TREE_CODE (arg01
) == INTEGER_CST
)
13323 /* Convert X + c > X and X - c < X to true for integers. */
13324 if (code
== GT_EXPR
13325 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13326 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13328 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13329 fold_overflow_warning (("assuming signed overflow does "
13330 "not occur when assuming that "
13331 "(X + c) > X is always true"),
13332 WARN_STRICT_OVERFLOW_ALL
);
13333 return constant_boolean_node (1, type
);
13336 if (code
== LT_EXPR
13337 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13338 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13340 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13341 fold_overflow_warning (("assuming signed overflow does "
13342 "not occur when assuming that "
13343 "(X - c) < X is always true"),
13344 WARN_STRICT_OVERFLOW_ALL
);
13345 return constant_boolean_node (1, type
);
13348 /* Convert X + c <= X and X - c >= X to false for integers. */
13349 if (code
== LE_EXPR
13350 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13351 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13353 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13354 fold_overflow_warning (("assuming signed overflow does "
13355 "not occur when assuming that "
13356 "(X + c) <= X is always false"),
13357 WARN_STRICT_OVERFLOW_ALL
);
13358 return constant_boolean_node (0, type
);
13361 if (code
== GE_EXPR
13362 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13363 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13365 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13366 fold_overflow_warning (("assuming signed overflow does "
13367 "not occur when assuming that "
13368 "(X - c) >= X is always false"),
13369 WARN_STRICT_OVERFLOW_ALL
);
13370 return constant_boolean_node (0, type
);
13375 /* Comparisons with the highest or lowest possible integer of
13376 the specified precision will have known values. */
13378 tree arg1_type
= TREE_TYPE (arg1
);
13379 unsigned int prec
= TYPE_PRECISION (arg1_type
);
13381 if (TREE_CODE (arg1
) == INTEGER_CST
13382 && (INTEGRAL_TYPE_P (arg1_type
) || POINTER_TYPE_P (arg1_type
)))
13384 wide_int max
= wi::max_value (arg1_type
);
13385 wide_int signed_max
= wi::max_value (prec
, SIGNED
);
13386 wide_int min
= wi::min_value (arg1_type
);
13388 if (wi::eq_p (arg1
, max
))
13392 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13395 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13398 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13401 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13403 /* The GE_EXPR and LT_EXPR cases above are not normally
13404 reached because of previous transformations. */
13409 else if (wi::eq_p (arg1
, max
- 1))
13413 arg1
= const_binop (PLUS_EXPR
, arg1
,
13414 build_int_cst (TREE_TYPE (arg1
), 1));
13415 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13416 fold_convert_loc (loc
,
13417 TREE_TYPE (arg1
), arg0
),
13420 arg1
= const_binop (PLUS_EXPR
, arg1
,
13421 build_int_cst (TREE_TYPE (arg1
), 1));
13422 return fold_build2_loc (loc
, NE_EXPR
, type
,
13423 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13429 else if (wi::eq_p (arg1
, min
))
13433 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13436 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13439 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13442 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13447 else if (wi::eq_p (arg1
, min
+ 1))
13451 arg1
= const_binop (MINUS_EXPR
, arg1
,
13452 build_int_cst (TREE_TYPE (arg1
), 1));
13453 return fold_build2_loc (loc
, NE_EXPR
, type
,
13454 fold_convert_loc (loc
,
13455 TREE_TYPE (arg1
), arg0
),
13458 arg1
= const_binop (MINUS_EXPR
, arg1
,
13459 build_int_cst (TREE_TYPE (arg1
), 1));
13460 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13461 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13468 else if (wi::eq_p (arg1
, signed_max
)
13469 && TYPE_UNSIGNED (arg1_type
)
13470 /* We will flip the signedness of the comparison operator
13471 associated with the mode of arg1, so the sign bit is
13472 specified by this mode. Check that arg1 is the signed
13473 max associated with this sign bit. */
13474 && prec
== GET_MODE_PRECISION (TYPE_MODE (arg1_type
))
13475 /* signed_type does not work on pointer types. */
13476 && INTEGRAL_TYPE_P (arg1_type
))
13478 /* The following case also applies to X < signed_max+1
13479 and X >= signed_max+1 because previous transformations. */
13480 if (code
== LE_EXPR
|| code
== GT_EXPR
)
13482 tree st
= signed_type_for (arg1_type
);
13483 return fold_build2_loc (loc
,
13484 code
== LE_EXPR
? GE_EXPR
: LT_EXPR
,
13485 type
, fold_convert_loc (loc
, st
, arg0
),
13486 build_int_cst (st
, 0));
13492 /* If we are comparing an ABS_EXPR with a constant, we can
13493 convert all the cases into explicit comparisons, but they may
13494 well not be faster than doing the ABS and one comparison.
13495 But ABS (X) <= C is a range comparison, which becomes a subtraction
13496 and a comparison, and is probably faster. */
13497 if (code
== LE_EXPR
13498 && TREE_CODE (arg1
) == INTEGER_CST
13499 && TREE_CODE (arg0
) == ABS_EXPR
13500 && ! TREE_SIDE_EFFECTS (arg0
)
13501 && (0 != (tem
= negate_expr (arg1
)))
13502 && TREE_CODE (tem
) == INTEGER_CST
13503 && !TREE_OVERFLOW (tem
))
13504 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
13505 build2 (GE_EXPR
, type
,
13506 TREE_OPERAND (arg0
, 0), tem
),
13507 build2 (LE_EXPR
, type
,
13508 TREE_OPERAND (arg0
, 0), arg1
));
13510 /* Convert ABS_EXPR<x> >= 0 to true. */
13511 strict_overflow_p
= false;
13512 if (code
== GE_EXPR
13513 && (integer_zerop (arg1
)
13514 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
13515 && real_zerop (arg1
)))
13516 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13518 if (strict_overflow_p
)
13519 fold_overflow_warning (("assuming signed overflow does not occur "
13520 "when simplifying comparison of "
13521 "absolute value and zero"),
13522 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13523 return omit_one_operand_loc (loc
, type
,
13524 constant_boolean_node (true, type
),
13528 /* Convert ABS_EXPR<x> < 0 to false. */
13529 strict_overflow_p
= false;
13530 if (code
== LT_EXPR
13531 && (integer_zerop (arg1
) || real_zerop (arg1
))
13532 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13534 if (strict_overflow_p
)
13535 fold_overflow_warning (("assuming signed overflow does not occur "
13536 "when simplifying comparison of "
13537 "absolute value and zero"),
13538 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13539 return omit_one_operand_loc (loc
, type
,
13540 constant_boolean_node (false, type
),
13544 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13545 and similarly for >= into !=. */
13546 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13547 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13548 && TREE_CODE (arg1
) == LSHIFT_EXPR
13549 && integer_onep (TREE_OPERAND (arg1
, 0)))
13550 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13551 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13552 TREE_OPERAND (arg1
, 1)),
13553 build_zero_cst (TREE_TYPE (arg0
)));
13555 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
13556 otherwise Y might be >= # of bits in X's type and thus e.g.
13557 (unsigned char) (1 << Y) for Y 15 might be 0.
13558 If the cast is widening, then 1 << Y should have unsigned type,
13559 otherwise if Y is number of bits in the signed shift type minus 1,
13560 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
13561 31 might be 0xffffffff80000000. */
13562 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13563 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13564 && CONVERT_EXPR_P (arg1
)
13565 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
13566 && (TYPE_PRECISION (TREE_TYPE (arg1
))
13567 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
13568 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
13569 || (TYPE_PRECISION (TREE_TYPE (arg1
))
13570 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
13571 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
13573 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13574 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
13575 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13576 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
13577 build_zero_cst (TREE_TYPE (arg0
)));
13582 case UNORDERED_EXPR
:
13590 if (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
13592 t1
= fold_relational_const (code
, type
, arg0
, arg1
);
13593 if (t1
!= NULL_TREE
)
13597 /* If the first operand is NaN, the result is constant. */
13598 if (TREE_CODE (arg0
) == REAL_CST
13599 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0
))
13600 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13602 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13603 ? integer_zero_node
13604 : integer_one_node
;
13605 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
13608 /* If the second operand is NaN, the result is constant. */
13609 if (TREE_CODE (arg1
) == REAL_CST
13610 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
13611 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13613 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13614 ? integer_zero_node
13615 : integer_one_node
;
13616 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
13619 /* Simplify unordered comparison of something with itself. */
13620 if ((code
== UNLE_EXPR
|| code
== UNGE_EXPR
|| code
== UNEQ_EXPR
)
13621 && operand_equal_p (arg0
, arg1
, 0))
13622 return constant_boolean_node (1, type
);
13624 if (code
== LTGT_EXPR
13625 && !flag_trapping_math
13626 && operand_equal_p (arg0
, arg1
, 0))
13627 return constant_boolean_node (0, type
);
13629 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13631 tree targ0
= strip_float_extensions (arg0
);
13632 tree targ1
= strip_float_extensions (arg1
);
13633 tree newtype
= TREE_TYPE (targ0
);
13635 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
13636 newtype
= TREE_TYPE (targ1
);
13638 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
13639 return fold_build2_loc (loc
, code
, type
,
13640 fold_convert_loc (loc
, newtype
, targ0
),
13641 fold_convert_loc (loc
, newtype
, targ1
));
13646 case COMPOUND_EXPR
:
13647 /* When pedantic, a compound expression can be neither an lvalue
13648 nor an integer constant expression. */
13649 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
13651 /* Don't let (0, 0) be null pointer constant. */
13652 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
13653 : fold_convert_loc (loc
, type
, arg1
);
13654 return pedantic_non_lvalue_loc (loc
, tem
);
13657 if ((TREE_CODE (arg0
) == REAL_CST
13658 && TREE_CODE (arg1
) == REAL_CST
)
13659 || (TREE_CODE (arg0
) == INTEGER_CST
13660 && TREE_CODE (arg1
) == INTEGER_CST
))
13661 return build_complex (type
, arg0
, arg1
);
13662 if (TREE_CODE (arg0
) == REALPART_EXPR
13663 && TREE_CODE (arg1
) == IMAGPART_EXPR
13664 && TREE_TYPE (TREE_OPERAND (arg0
, 0)) == type
13665 && operand_equal_p (TREE_OPERAND (arg0
, 0),
13666 TREE_OPERAND (arg1
, 0), 0))
13667 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 0),
13668 TREE_OPERAND (arg1
, 0));
13672 /* An ASSERT_EXPR should never be passed to fold_binary. */
13673 gcc_unreachable ();
13675 case VEC_PACK_TRUNC_EXPR
:
13676 case VEC_PACK_FIX_TRUNC_EXPR
:
13678 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
13681 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
/ 2
13682 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
/ 2);
13683 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13686 elts
= XALLOCAVEC (tree
, nelts
);
13687 if (!vec_cst_ctor_to_array (arg0
, elts
)
13688 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
/ 2))
13691 for (i
= 0; i
< nelts
; i
++)
13693 elts
[i
] = fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
13694 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
13695 TREE_TYPE (type
), elts
[i
]);
13696 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
13700 return build_vector (type
, elts
);
13703 case VEC_WIDEN_MULT_LO_EXPR
:
13704 case VEC_WIDEN_MULT_HI_EXPR
:
13705 case VEC_WIDEN_MULT_EVEN_EXPR
:
13706 case VEC_WIDEN_MULT_ODD_EXPR
:
13708 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
13709 unsigned int out
, ofs
, scale
;
13712 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2
13713 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
* 2);
13714 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13717 elts
= XALLOCAVEC (tree
, nelts
* 4);
13718 if (!vec_cst_ctor_to_array (arg0
, elts
)
13719 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
* 2))
13722 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
13723 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? nelts
: 0;
13724 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
13725 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : nelts
;
13726 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
13727 scale
= 1, ofs
= 0;
13728 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
13729 scale
= 1, ofs
= 1;
13731 for (out
= 0; out
< nelts
; out
++)
13733 unsigned int in1
= (out
<< scale
) + ofs
;
13734 unsigned int in2
= in1
+ nelts
* 2;
13737 t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in1
]);
13738 t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in2
]);
13740 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
13742 elts
[out
] = const_binop (MULT_EXPR
, t1
, t2
);
13743 if (elts
[out
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[out
]))
13747 return build_vector (type
, elts
);
13752 } /* switch (code) */
13755 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
13756 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
13760 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
13762 switch (TREE_CODE (*tp
))
13768 *walk_subtrees
= 0;
13770 /* ... fall through ... */
13777 /* Return whether the sub-tree ST contains a label which is accessible from
13778 outside the sub-tree. */
13781 contains_label_p (tree st
)
13784 (walk_tree_without_duplicates (&st
, contains_label_1
, NULL
) != NULL_TREE
);
13787 /* Fold a ternary expression of code CODE and type TYPE with operands
13788 OP0, OP1, and OP2. Return the folded expression if folding is
13789 successful. Otherwise, return NULL_TREE. */
13792 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
13793 tree op0
, tree op1
, tree op2
)
13796 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
13797 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
13799 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
13800 && TREE_CODE_LENGTH (code
) == 3);
13802 /* Strip any conversions that don't change the mode. This is safe
13803 for every expression, except for a comparison expression because
13804 its signedness is derived from its operands. So, in the latter
13805 case, only strip conversions that don't change the signedness.
13807 Note that this is done as an internal manipulation within the
13808 constant folder, in order to find the simplest representation of
13809 the arguments so that their form can be studied. In any cases,
13810 the appropriate type conversions should be put back in the tree
13811 that will get out of the constant folder. */
13832 case COMPONENT_REF
:
13833 if (TREE_CODE (arg0
) == CONSTRUCTOR
13834 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
13836 unsigned HOST_WIDE_INT idx
;
13838 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
13845 case VEC_COND_EXPR
:
13846 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13847 so all simple results must be passed through pedantic_non_lvalue. */
13848 if (TREE_CODE (arg0
) == INTEGER_CST
)
13850 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
13851 tem
= integer_zerop (arg0
) ? op2
: op1
;
13852 /* Only optimize constant conditions when the selected branch
13853 has the same type as the COND_EXPR. This avoids optimizing
13854 away "c ? x : throw", where the throw has a void type.
13855 Avoid throwing away that operand which contains label. */
13856 if ((!TREE_SIDE_EFFECTS (unused_op
)
13857 || !contains_label_p (unused_op
))
13858 && (! VOID_TYPE_P (TREE_TYPE (tem
))
13859 || VOID_TYPE_P (type
)))
13860 return pedantic_non_lvalue_loc (loc
, tem
);
13863 else if (TREE_CODE (arg0
) == VECTOR_CST
)
13865 if (integer_all_onesp (arg0
))
13866 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg2
);
13867 if (integer_zerop (arg0
))
13868 return pedantic_omit_one_operand_loc (loc
, type
, arg2
, arg1
);
13870 if ((TREE_CODE (arg1
) == VECTOR_CST
13871 || TREE_CODE (arg1
) == CONSTRUCTOR
)
13872 && (TREE_CODE (arg2
) == VECTOR_CST
13873 || TREE_CODE (arg2
) == CONSTRUCTOR
))
13875 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
13876 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
13877 gcc_assert (nelts
== VECTOR_CST_NELTS (arg0
));
13878 for (i
= 0; i
< nelts
; i
++)
13880 tree val
= VECTOR_CST_ELT (arg0
, i
);
13881 if (integer_all_onesp (val
))
13883 else if (integer_zerop (val
))
13884 sel
[i
] = nelts
+ i
;
13885 else /* Currently unreachable. */
13888 tree t
= fold_vec_perm (type
, arg1
, arg2
, sel
);
13889 if (t
!= NULL_TREE
)
13894 if (operand_equal_p (arg1
, op2
, 0))
13895 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg0
);
13897 /* If we have A op B ? A : C, we may be able to convert this to a
13898 simpler expression, depending on the operation and the values
13899 of B and C. Signed zeros prevent all of these transformations,
13900 for reasons given above each one.
13902 Also try swapping the arguments and inverting the conditional. */
13903 if (COMPARISON_CLASS_P (arg0
)
13904 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
13905 arg1
, TREE_OPERAND (arg0
, 1))
13906 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1
))))
13908 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
13913 if (COMPARISON_CLASS_P (arg0
)
13914 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
13916 TREE_OPERAND (arg0
, 1))
13917 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2
))))
13919 location_t loc0
= expr_location_or (arg0
, loc
);
13920 tem
= fold_invert_truthvalue (loc0
, arg0
);
13921 if (tem
&& COMPARISON_CLASS_P (tem
))
13923 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
13929 /* If the second operand is simpler than the third, swap them
13930 since that produces better jump optimization results. */
13931 if (truth_value_p (TREE_CODE (arg0
))
13932 && tree_swap_operands_p (op1
, op2
, false))
13934 location_t loc0
= expr_location_or (arg0
, loc
);
13935 /* See if this can be inverted. If it can't, possibly because
13936 it was a floating-point inequality comparison, don't do
13938 tem
= fold_invert_truthvalue (loc0
, arg0
);
13940 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
13943 /* Convert A ? 1 : 0 to simply A. */
13944 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
13945 : (integer_onep (op1
)
13946 && !VECTOR_TYPE_P (type
)))
13947 && integer_zerop (op2
)
13948 /* If we try to convert OP0 to our type, the
13949 call to fold will try to move the conversion inside
13950 a COND, which will recurse. In that case, the COND_EXPR
13951 is probably the best choice, so leave it alone. */
13952 && type
== TREE_TYPE (arg0
))
13953 return pedantic_non_lvalue_loc (loc
, arg0
);
13955 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13956 over COND_EXPR in cases such as floating point comparisons. */
13957 if (integer_zerop (op1
)
13958 && (code
== VEC_COND_EXPR
? integer_all_onesp (op2
)
13959 : (integer_onep (op2
)
13960 && !VECTOR_TYPE_P (type
)))
13961 && truth_value_p (TREE_CODE (arg0
)))
13962 return pedantic_non_lvalue_loc (loc
,
13963 fold_convert_loc (loc
, type
,
13964 invert_truthvalue_loc (loc
,
13967 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13968 if (TREE_CODE (arg0
) == LT_EXPR
13969 && integer_zerop (TREE_OPERAND (arg0
, 1))
13970 && integer_zerop (op2
)
13971 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
13973 /* sign_bit_p looks through both zero and sign extensions,
13974 but for this optimization only sign extensions are
13976 tree tem2
= TREE_OPERAND (arg0
, 0);
13977 while (tem
!= tem2
)
13979 if (TREE_CODE (tem2
) != NOP_EXPR
13980 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
13985 tem2
= TREE_OPERAND (tem2
, 0);
13987 /* sign_bit_p only checks ARG1 bits within A's precision.
13988 If <sign bit of A> has wider type than A, bits outside
13989 of A's precision in <sign bit of A> need to be checked.
13990 If they are all 0, this optimization needs to be done
13991 in unsigned A's type, if they are all 1 in signed A's type,
13992 otherwise this can't be done. */
13994 && TYPE_PRECISION (TREE_TYPE (tem
))
13995 < TYPE_PRECISION (TREE_TYPE (arg1
))
13996 && TYPE_PRECISION (TREE_TYPE (tem
))
13997 < TYPE_PRECISION (type
))
13999 int inner_width
, outer_width
;
14002 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
14003 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
14004 if (outer_width
> TYPE_PRECISION (type
))
14005 outer_width
= TYPE_PRECISION (type
);
14007 wide_int mask
= wi::shifted_mask
14008 (inner_width
, outer_width
- inner_width
, false,
14009 TYPE_PRECISION (TREE_TYPE (arg1
)));
14011 wide_int common
= mask
& arg1
;
14012 if (common
== mask
)
14014 tem_type
= signed_type_for (TREE_TYPE (tem
));
14015 tem
= fold_convert_loc (loc
, tem_type
, tem
);
14017 else if (common
== 0)
14019 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
14020 tem
= fold_convert_loc (loc
, tem_type
, tem
);
14028 fold_convert_loc (loc
, type
,
14029 fold_build2_loc (loc
, BIT_AND_EXPR
,
14030 TREE_TYPE (tem
), tem
,
14031 fold_convert_loc (loc
,
14036 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
14037 already handled above. */
14038 if (TREE_CODE (arg0
) == BIT_AND_EXPR
14039 && integer_onep (TREE_OPERAND (arg0
, 1))
14040 && integer_zerop (op2
)
14041 && integer_pow2p (arg1
))
14043 tree tem
= TREE_OPERAND (arg0
, 0);
14045 if (TREE_CODE (tem
) == RSHIFT_EXPR
14046 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
14047 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
) ==
14048 tree_to_uhwi (TREE_OPERAND (tem
, 1)))
14049 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
14050 TREE_OPERAND (tem
, 0), arg1
);
14053 /* A & N ? N : 0 is simply A & N if N is a power of two. This
14054 is probably obsolete because the first operand should be a
14055 truth value (that's why we have the two cases above), but let's
14056 leave it in until we can confirm this for all front-ends. */
14057 if (integer_zerop (op2
)
14058 && TREE_CODE (arg0
) == NE_EXPR
14059 && integer_zerop (TREE_OPERAND (arg0
, 1))
14060 && integer_pow2p (arg1
)
14061 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
14062 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
14063 arg1
, OEP_ONLY_CONST
))
14064 return pedantic_non_lvalue_loc (loc
,
14065 fold_convert_loc (loc
, type
,
14066 TREE_OPERAND (arg0
, 0)));
14068 /* Disable the transformations below for vectors, since
14069 fold_binary_op_with_conditional_arg may undo them immediately,
14070 yielding an infinite loop. */
14071 if (code
== VEC_COND_EXPR
)
14074 /* Convert A ? B : 0 into A && B if A and B are truth values. */
14075 if (integer_zerop (op2
)
14076 && truth_value_p (TREE_CODE (arg0
))
14077 && truth_value_p (TREE_CODE (arg1
))
14078 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14079 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
14080 : TRUTH_ANDIF_EXPR
,
14081 type
, fold_convert_loc (loc
, type
, arg0
), arg1
);
14083 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
14084 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
14085 && truth_value_p (TREE_CODE (arg0
))
14086 && truth_value_p (TREE_CODE (arg1
))
14087 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14089 location_t loc0
= expr_location_or (arg0
, loc
);
14090 /* Only perform transformation if ARG0 is easily inverted. */
14091 tem
= fold_invert_truthvalue (loc0
, arg0
);
14093 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14096 type
, fold_convert_loc (loc
, type
, tem
),
14100 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
14101 if (integer_zerop (arg1
)
14102 && truth_value_p (TREE_CODE (arg0
))
14103 && truth_value_p (TREE_CODE (op2
))
14104 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14106 location_t loc0
= expr_location_or (arg0
, loc
);
14107 /* Only perform transformation if ARG0 is easily inverted. */
14108 tem
= fold_invert_truthvalue (loc0
, arg0
);
14110 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14111 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
14112 type
, fold_convert_loc (loc
, type
, tem
),
14116 /* Convert A ? 1 : B into A || B if A and B are truth values. */
14117 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
14118 && truth_value_p (TREE_CODE (arg0
))
14119 && truth_value_p (TREE_CODE (op2
))
14120 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14121 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14122 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
14123 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
14128 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
14129 of fold_ternary on them. */
14130 gcc_unreachable ();
14132 case BIT_FIELD_REF
:
14133 if ((TREE_CODE (arg0
) == VECTOR_CST
14134 || (TREE_CODE (arg0
) == CONSTRUCTOR
14135 && TREE_CODE (TREE_TYPE (arg0
)) == VECTOR_TYPE
))
14136 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
14137 || (TREE_CODE (type
) == VECTOR_TYPE
14138 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
)))))
14140 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
14141 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
14142 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
14143 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
14146 && (idx
% width
) == 0
14147 && (n
% width
) == 0
14148 && ((idx
+ n
) / width
) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)))
14153 if (TREE_CODE (arg0
) == VECTOR_CST
)
14156 return VECTOR_CST_ELT (arg0
, idx
);
14158 tree
*vals
= XALLOCAVEC (tree
, n
);
14159 for (unsigned i
= 0; i
< n
; ++i
)
14160 vals
[i
] = VECTOR_CST_ELT (arg0
, idx
+ i
);
14161 return build_vector (type
, vals
);
14164 /* Constructor elements can be subvectors. */
14165 unsigned HOST_WIDE_INT k
= 1;
14166 if (CONSTRUCTOR_NELTS (arg0
) != 0)
14168 tree cons_elem
= TREE_TYPE (CONSTRUCTOR_ELT (arg0
, 0)->value
);
14169 if (TREE_CODE (cons_elem
) == VECTOR_TYPE
)
14170 k
= TYPE_VECTOR_SUBPARTS (cons_elem
);
14173 /* We keep an exact subset of the constructor elements. */
14174 if ((idx
% k
) == 0 && (n
% k
) == 0)
14176 if (CONSTRUCTOR_NELTS (arg0
) == 0)
14177 return build_constructor (type
, NULL
);
14182 if (idx
< CONSTRUCTOR_NELTS (arg0
))
14183 return CONSTRUCTOR_ELT (arg0
, idx
)->value
;
14184 return build_zero_cst (type
);
14187 vec
<constructor_elt
, va_gc
> *vals
;
14188 vec_alloc (vals
, n
);
14189 for (unsigned i
= 0;
14190 i
< n
&& idx
+ i
< CONSTRUCTOR_NELTS (arg0
);
14192 CONSTRUCTOR_APPEND_ELT (vals
, NULL_TREE
,
14194 (arg0
, idx
+ i
)->value
);
14195 return build_constructor (type
, vals
);
14197 /* The bitfield references a single constructor element. */
14198 else if (idx
+ n
<= (idx
/ k
+ 1) * k
)
14200 if (CONSTRUCTOR_NELTS (arg0
) <= idx
/ k
)
14201 return build_zero_cst (type
);
14203 return CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
;
14205 return fold_build3_loc (loc
, code
, type
,
14206 CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
, op1
,
14207 build_int_cst (TREE_TYPE (op2
), (idx
% k
) * width
));
14212 /* A bit-field-ref that referenced the full argument can be stripped. */
14213 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
14214 && TYPE_PRECISION (TREE_TYPE (arg0
)) == tree_to_uhwi (arg1
)
14215 && integer_zerop (op2
))
14216 return fold_convert_loc (loc
, type
, arg0
);
14218 /* On constants we can use native encode/interpret to constant
14219 fold (nearly) all BIT_FIELD_REFs. */
14220 if (CONSTANT_CLASS_P (arg0
)
14221 && can_native_interpret_type_p (type
)
14222 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)))
14223 /* This limitation should not be necessary, we just need to
14224 round this up to mode size. */
14225 && tree_to_uhwi (op1
) % BITS_PER_UNIT
== 0
14226 /* Need bit-shifting of the buffer to relax the following. */
14227 && tree_to_uhwi (op2
) % BITS_PER_UNIT
== 0)
14229 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
14230 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
14231 unsigned HOST_WIDE_INT clen
;
14232 clen
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)));
14233 /* ??? We cannot tell native_encode_expr to start at
14234 some random byte only. So limit us to a reasonable amount
14238 unsigned char *b
= XALLOCAVEC (unsigned char, clen
);
14239 unsigned HOST_WIDE_INT len
= native_encode_expr (arg0
, b
, clen
);
14241 && len
* BITS_PER_UNIT
>= bitpos
+ bitsize
)
14243 tree v
= native_interpret_expr (type
,
14244 b
+ bitpos
/ BITS_PER_UNIT
,
14245 bitsize
/ BITS_PER_UNIT
);
14255 /* For integers we can decompose the FMA if possible. */
14256 if (TREE_CODE (arg0
) == INTEGER_CST
14257 && TREE_CODE (arg1
) == INTEGER_CST
)
14258 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
14259 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
14260 if (integer_zerop (arg2
))
14261 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
14263 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
14265 case VEC_PERM_EXPR
:
14266 if (TREE_CODE (arg2
) == VECTOR_CST
)
14268 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
, mask
;
14269 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
14270 bool need_mask_canon
= false;
14271 bool all_in_vec0
= true;
14272 bool all_in_vec1
= true;
14273 bool maybe_identity
= true;
14274 bool single_arg
= (op0
== op1
);
14275 bool changed
= false;
14277 mask
= single_arg
? (nelts
- 1) : (2 * nelts
- 1);
14278 gcc_assert (nelts
== VECTOR_CST_NELTS (arg2
));
14279 for (i
= 0; i
< nelts
; i
++)
14281 tree val
= VECTOR_CST_ELT (arg2
, i
);
14282 if (TREE_CODE (val
) != INTEGER_CST
)
14285 /* Make sure that the perm value is in an acceptable
14288 if (wi::gtu_p (t
, mask
))
14290 need_mask_canon
= true;
14291 sel
[i
] = t
.to_uhwi () & mask
;
14294 sel
[i
] = t
.to_uhwi ();
14296 if (sel
[i
] < nelts
)
14297 all_in_vec1
= false;
14299 all_in_vec0
= false;
14301 if ((sel
[i
] & (nelts
-1)) != i
)
14302 maybe_identity
= false;
14305 if (maybe_identity
)
14315 else if (all_in_vec1
)
14318 for (i
= 0; i
< nelts
; i
++)
14320 need_mask_canon
= true;
14323 if ((TREE_CODE (op0
) == VECTOR_CST
14324 || TREE_CODE (op0
) == CONSTRUCTOR
)
14325 && (TREE_CODE (op1
) == VECTOR_CST
14326 || TREE_CODE (op1
) == CONSTRUCTOR
))
14328 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
14329 if (t
!= NULL_TREE
)
14333 if (op0
== op1
&& !single_arg
)
14336 if (need_mask_canon
&& arg2
== op2
)
14338 tree
*tsel
= XALLOCAVEC (tree
, nelts
);
14339 tree eltype
= TREE_TYPE (TREE_TYPE (arg2
));
14340 for (i
= 0; i
< nelts
; i
++)
14341 tsel
[i
] = build_int_cst (eltype
, sel
[i
]);
14342 op2
= build_vector (TREE_TYPE (arg2
), tsel
);
14347 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
14353 } /* switch (code) */
14356 /* Perform constant folding and related simplification of EXPR.
14357 The related simplifications include x*1 => x, x*0 => 0, etc.,
14358 and application of the associative law.
14359 NOP_EXPR conversions may be removed freely (as long as we
14360 are careful not to change the type of the overall expression).
14361 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14362 but we can constant-fold them if they have constant operands. */
14364 #ifdef ENABLE_FOLD_CHECKING
14365 # define fold(x) fold_1 (x)
14366 static tree
fold_1 (tree
);
14372 const tree t
= expr
;
14373 enum tree_code code
= TREE_CODE (t
);
14374 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
14376 location_t loc
= EXPR_LOCATION (expr
);
14378 /* Return right away if a constant. */
14379 if (kind
== tcc_constant
)
14382 /* CALL_EXPR-like objects with variable numbers of operands are
14383 treated specially. */
14384 if (kind
== tcc_vl_exp
)
14386 if (code
== CALL_EXPR
)
14388 tem
= fold_call_expr (loc
, expr
, false);
14389 return tem
? tem
: expr
;
14394 if (IS_EXPR_CODE_CLASS (kind
))
14396 tree type
= TREE_TYPE (t
);
14397 tree op0
, op1
, op2
;
14399 switch (TREE_CODE_LENGTH (code
))
14402 op0
= TREE_OPERAND (t
, 0);
14403 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14404 return tem
? tem
: expr
;
14406 op0
= TREE_OPERAND (t
, 0);
14407 op1
= TREE_OPERAND (t
, 1);
14408 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14409 return tem
? tem
: expr
;
14411 op0
= TREE_OPERAND (t
, 0);
14412 op1
= TREE_OPERAND (t
, 1);
14413 op2
= TREE_OPERAND (t
, 2);
14414 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14415 return tem
? tem
: expr
;
14425 tree op0
= TREE_OPERAND (t
, 0);
14426 tree op1
= TREE_OPERAND (t
, 1);
14428 if (TREE_CODE (op1
) == INTEGER_CST
14429 && TREE_CODE (op0
) == CONSTRUCTOR
14430 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
14432 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (op0
);
14433 unsigned HOST_WIDE_INT end
= vec_safe_length (elts
);
14434 unsigned HOST_WIDE_INT begin
= 0;
14436 /* Find a matching index by means of a binary search. */
14437 while (begin
!= end
)
14439 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
14440 tree index
= (*elts
)[middle
].index
;
14442 if (TREE_CODE (index
) == INTEGER_CST
14443 && tree_int_cst_lt (index
, op1
))
14444 begin
= middle
+ 1;
14445 else if (TREE_CODE (index
) == INTEGER_CST
14446 && tree_int_cst_lt (op1
, index
))
14448 else if (TREE_CODE (index
) == RANGE_EXPR
14449 && tree_int_cst_lt (TREE_OPERAND (index
, 1), op1
))
14450 begin
= middle
+ 1;
14451 else if (TREE_CODE (index
) == RANGE_EXPR
14452 && tree_int_cst_lt (op1
, TREE_OPERAND (index
, 0)))
14455 return (*elts
)[middle
].value
;
14462 /* Return a VECTOR_CST if possible. */
14465 tree type
= TREE_TYPE (t
);
14466 if (TREE_CODE (type
) != VECTOR_TYPE
)
14469 tree
*vec
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
14470 unsigned HOST_WIDE_INT idx
, pos
= 0;
14473 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, value
)
14475 if (!CONSTANT_CLASS_P (value
))
14477 if (TREE_CODE (value
) == VECTOR_CST
)
14479 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (value
); ++i
)
14480 vec
[pos
++] = VECTOR_CST_ELT (value
, i
);
14483 vec
[pos
++] = value
;
14485 for (; pos
< TYPE_VECTOR_SUBPARTS (type
); ++pos
)
14486 vec
[pos
] = build_zero_cst (TREE_TYPE (type
));
14488 return build_vector (type
, vec
);
14492 return fold (DECL_INITIAL (t
));
14496 } /* switch (code) */
14499 #ifdef ENABLE_FOLD_CHECKING
14502 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
14503 hash_table
<pointer_hash
<const tree_node
> > *);
14504 static void fold_check_failed (const_tree
, const_tree
);
14505 void print_fold_checksum (const_tree
);
14507 /* When --enable-checking=fold, compute a digest of expr before
14508 and after actual fold call to see if fold did not accidentally
14509 change original expr. */
14515 struct md5_ctx ctx
;
14516 unsigned char checksum_before
[16], checksum_after
[16];
14517 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14519 md5_init_ctx (&ctx
);
14520 fold_checksum_tree (expr
, &ctx
, &ht
);
14521 md5_finish_ctx (&ctx
, checksum_before
);
14524 ret
= fold_1 (expr
);
14526 md5_init_ctx (&ctx
);
14527 fold_checksum_tree (expr
, &ctx
, &ht
);
14528 md5_finish_ctx (&ctx
, checksum_after
);
14530 if (memcmp (checksum_before
, checksum_after
, 16))
14531 fold_check_failed (expr
, ret
);
14537 print_fold_checksum (const_tree expr
)
14539 struct md5_ctx ctx
;
14540 unsigned char checksum
[16], cnt
;
14541 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14543 md5_init_ctx (&ctx
);
14544 fold_checksum_tree (expr
, &ctx
, &ht
);
14545 md5_finish_ctx (&ctx
, checksum
);
14546 for (cnt
= 0; cnt
< 16; ++cnt
)
14547 fprintf (stderr
, "%02x", checksum
[cnt
]);
14548 putc ('\n', stderr
);
14552 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
14554 internal_error ("fold check: original tree changed by fold");
14558 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
14559 hash_table
<pointer_hash
<const tree_node
> > *ht
)
14561 const tree_node
**slot
;
14562 enum tree_code code
;
14563 union tree_node buf
;
14569 slot
= ht
->find_slot (expr
, INSERT
);
14573 code
= TREE_CODE (expr
);
14574 if (TREE_CODE_CLASS (code
) == tcc_declaration
14575 && DECL_ASSEMBLER_NAME_SET_P (expr
))
14577 /* Allow DECL_ASSEMBLER_NAME to be modified. */
14578 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14579 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
14580 expr
= (tree
) &buf
;
14582 else if (TREE_CODE_CLASS (code
) == tcc_type
14583 && (TYPE_POINTER_TO (expr
)
14584 || TYPE_REFERENCE_TO (expr
)
14585 || TYPE_CACHED_VALUES_P (expr
)
14586 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
14587 || TYPE_NEXT_VARIANT (expr
)))
14589 /* Allow these fields to be modified. */
14591 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14592 expr
= tmp
= (tree
) &buf
;
14593 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
14594 TYPE_POINTER_TO (tmp
) = NULL
;
14595 TYPE_REFERENCE_TO (tmp
) = NULL
;
14596 TYPE_NEXT_VARIANT (tmp
) = NULL
;
14597 if (TYPE_CACHED_VALUES_P (tmp
))
14599 TYPE_CACHED_VALUES_P (tmp
) = 0;
14600 TYPE_CACHED_VALUES (tmp
) = NULL
;
14603 md5_process_bytes (expr
, tree_size (expr
), ctx
);
14604 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
14605 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
14606 if (TREE_CODE_CLASS (code
) != tcc_type
14607 && TREE_CODE_CLASS (code
) != tcc_declaration
14608 && code
!= TREE_LIST
14609 && code
!= SSA_NAME
14610 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
14611 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
14612 switch (TREE_CODE_CLASS (code
))
14618 md5_process_bytes (TREE_STRING_POINTER (expr
),
14619 TREE_STRING_LENGTH (expr
), ctx
);
14622 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
14623 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
14626 for (i
= 0; i
< (int) VECTOR_CST_NELTS (expr
); ++i
)
14627 fold_checksum_tree (VECTOR_CST_ELT (expr
, i
), ctx
, ht
);
14633 case tcc_exceptional
:
14637 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
14638 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
14639 expr
= TREE_CHAIN (expr
);
14640 goto recursive_label
;
14643 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
14644 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
14650 case tcc_expression
:
14651 case tcc_reference
:
14652 case tcc_comparison
:
14655 case tcc_statement
:
14657 len
= TREE_OPERAND_LENGTH (expr
);
14658 for (i
= 0; i
< len
; ++i
)
14659 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
14661 case tcc_declaration
:
14662 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
14663 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
14664 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
14666 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
14667 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
14668 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
14669 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
14670 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
14673 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
14675 if (TREE_CODE (expr
) == FUNCTION_DECL
)
14677 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
14678 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
14680 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
14684 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
14685 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
14686 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
14687 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
14688 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
14689 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
14690 if (INTEGRAL_TYPE_P (expr
)
14691 || SCALAR_FLOAT_TYPE_P (expr
))
14693 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
14694 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
14696 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
14697 if (TREE_CODE (expr
) == RECORD_TYPE
14698 || TREE_CODE (expr
) == UNION_TYPE
14699 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
14700 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
14701 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
14708 /* Helper function for outputting the checksum of a tree T. When
14709 debugging with gdb, you can "define mynext" to be "next" followed
14710 by "call debug_fold_checksum (op0)", then just trace down till the
14713 DEBUG_FUNCTION
void
14714 debug_fold_checksum (const_tree t
)
14717 unsigned char checksum
[16];
14718 struct md5_ctx ctx
;
14719 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14721 md5_init_ctx (&ctx
);
14722 fold_checksum_tree (t
, &ctx
, &ht
);
14723 md5_finish_ctx (&ctx
, checksum
);
14726 for (i
= 0; i
< 16; i
++)
14727 fprintf (stderr
, "%d ", checksum
[i
]);
14729 fprintf (stderr
, "\n");
14734 /* Fold a unary tree expression with code CODE of type TYPE with an
14735 operand OP0. LOC is the location of the resulting expression.
14736 Return a folded expression if successful. Otherwise, return a tree
14737 expression with code CODE of type TYPE with an operand OP0. */
14740 fold_build1_stat_loc (location_t loc
,
14741 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
14744 #ifdef ENABLE_FOLD_CHECKING
14745 unsigned char checksum_before
[16], checksum_after
[16];
14746 struct md5_ctx ctx
;
14747 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14749 md5_init_ctx (&ctx
);
14750 fold_checksum_tree (op0
, &ctx
, &ht
);
14751 md5_finish_ctx (&ctx
, checksum_before
);
14755 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14757 tem
= build1_stat_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
14759 #ifdef ENABLE_FOLD_CHECKING
14760 md5_init_ctx (&ctx
);
14761 fold_checksum_tree (op0
, &ctx
, &ht
);
14762 md5_finish_ctx (&ctx
, checksum_after
);
14764 if (memcmp (checksum_before
, checksum_after
, 16))
14765 fold_check_failed (op0
, tem
);
14770 /* Fold a binary tree expression with code CODE of type TYPE with
14771 operands OP0 and OP1. LOC is the location of the resulting
14772 expression. Return a folded expression if successful. Otherwise,
14773 return a tree expression with code CODE of type TYPE with operands
14777 fold_build2_stat_loc (location_t loc
,
14778 enum tree_code code
, tree type
, tree op0
, tree op1
14782 #ifdef ENABLE_FOLD_CHECKING
14783 unsigned char checksum_before_op0
[16],
14784 checksum_before_op1
[16],
14785 checksum_after_op0
[16],
14786 checksum_after_op1
[16];
14787 struct md5_ctx ctx
;
14788 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14790 md5_init_ctx (&ctx
);
14791 fold_checksum_tree (op0
, &ctx
, &ht
);
14792 md5_finish_ctx (&ctx
, checksum_before_op0
);
14795 md5_init_ctx (&ctx
);
14796 fold_checksum_tree (op1
, &ctx
, &ht
);
14797 md5_finish_ctx (&ctx
, checksum_before_op1
);
14801 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14803 tem
= build2_stat_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
14805 #ifdef ENABLE_FOLD_CHECKING
14806 md5_init_ctx (&ctx
);
14807 fold_checksum_tree (op0
, &ctx
, &ht
);
14808 md5_finish_ctx (&ctx
, checksum_after_op0
);
14811 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14812 fold_check_failed (op0
, tem
);
14814 md5_init_ctx (&ctx
);
14815 fold_checksum_tree (op1
, &ctx
, &ht
);
14816 md5_finish_ctx (&ctx
, checksum_after_op1
);
14818 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
14819 fold_check_failed (op1
, tem
);
14824 /* Fold a ternary tree expression with code CODE of type TYPE with
14825 operands OP0, OP1, and OP2. Return a folded expression if
14826 successful. Otherwise, return a tree expression with code CODE of
14827 type TYPE with operands OP0, OP1, and OP2. */
14830 fold_build3_stat_loc (location_t loc
, enum tree_code code
, tree type
,
14831 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
14834 #ifdef ENABLE_FOLD_CHECKING
14835 unsigned char checksum_before_op0
[16],
14836 checksum_before_op1
[16],
14837 checksum_before_op2
[16],
14838 checksum_after_op0
[16],
14839 checksum_after_op1
[16],
14840 checksum_after_op2
[16];
14841 struct md5_ctx ctx
;
14842 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14844 md5_init_ctx (&ctx
);
14845 fold_checksum_tree (op0
, &ctx
, &ht
);
14846 md5_finish_ctx (&ctx
, checksum_before_op0
);
14849 md5_init_ctx (&ctx
);
14850 fold_checksum_tree (op1
, &ctx
, &ht
);
14851 md5_finish_ctx (&ctx
, checksum_before_op1
);
14854 md5_init_ctx (&ctx
);
14855 fold_checksum_tree (op2
, &ctx
, &ht
);
14856 md5_finish_ctx (&ctx
, checksum_before_op2
);
14860 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
14861 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14863 tem
= build3_stat_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
14865 #ifdef ENABLE_FOLD_CHECKING
14866 md5_init_ctx (&ctx
);
14867 fold_checksum_tree (op0
, &ctx
, &ht
);
14868 md5_finish_ctx (&ctx
, checksum_after_op0
);
14871 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14872 fold_check_failed (op0
, tem
);
14874 md5_init_ctx (&ctx
);
14875 fold_checksum_tree (op1
, &ctx
, &ht
);
14876 md5_finish_ctx (&ctx
, checksum_after_op1
);
14879 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
14880 fold_check_failed (op1
, tem
);
14882 md5_init_ctx (&ctx
);
14883 fold_checksum_tree (op2
, &ctx
, &ht
);
14884 md5_finish_ctx (&ctx
, checksum_after_op2
);
14886 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
14887 fold_check_failed (op2
, tem
);
14892 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14893 arguments in ARGARRAY, and a null static chain.
14894 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14895 of type TYPE from the given operands as constructed by build_call_array. */
14898 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
14899 int nargs
, tree
*argarray
)
14902 #ifdef ENABLE_FOLD_CHECKING
14903 unsigned char checksum_before_fn
[16],
14904 checksum_before_arglist
[16],
14905 checksum_after_fn
[16],
14906 checksum_after_arglist
[16];
14907 struct md5_ctx ctx
;
14908 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14911 md5_init_ctx (&ctx
);
14912 fold_checksum_tree (fn
, &ctx
, &ht
);
14913 md5_finish_ctx (&ctx
, checksum_before_fn
);
14916 md5_init_ctx (&ctx
);
14917 for (i
= 0; i
< nargs
; i
++)
14918 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
14919 md5_finish_ctx (&ctx
, checksum_before_arglist
);
14923 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
14925 #ifdef ENABLE_FOLD_CHECKING
14926 md5_init_ctx (&ctx
);
14927 fold_checksum_tree (fn
, &ctx
, &ht
);
14928 md5_finish_ctx (&ctx
, checksum_after_fn
);
14931 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
14932 fold_check_failed (fn
, tem
);
14934 md5_init_ctx (&ctx
);
14935 for (i
= 0; i
< nargs
; i
++)
14936 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
14937 md5_finish_ctx (&ctx
, checksum_after_arglist
);
14939 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
14940 fold_check_failed (NULL_TREE
, tem
);
14945 /* Perform constant folding and related simplification of initializer
14946 expression EXPR. These behave identically to "fold_buildN" but ignore
14947 potential run-time traps and exceptions that fold must preserve. */
14949 #define START_FOLD_INIT \
14950 int saved_signaling_nans = flag_signaling_nans;\
14951 int saved_trapping_math = flag_trapping_math;\
14952 int saved_rounding_math = flag_rounding_math;\
14953 int saved_trapv = flag_trapv;\
14954 int saved_folding_initializer = folding_initializer;\
14955 flag_signaling_nans = 0;\
14956 flag_trapping_math = 0;\
14957 flag_rounding_math = 0;\
14959 folding_initializer = 1;
14961 #define END_FOLD_INIT \
14962 flag_signaling_nans = saved_signaling_nans;\
14963 flag_trapping_math = saved_trapping_math;\
14964 flag_rounding_math = saved_rounding_math;\
14965 flag_trapv = saved_trapv;\
14966 folding_initializer = saved_folding_initializer;
14969 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
14970 tree type
, tree op
)
14975 result
= fold_build1_loc (loc
, code
, type
, op
);
14982 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
14983 tree type
, tree op0
, tree op1
)
14988 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
14995 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
14996 int nargs
, tree
*argarray
)
15001 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
15007 #undef START_FOLD_INIT
15008 #undef END_FOLD_INIT
15010 /* Determine if first argument is a multiple of second argument. Return 0 if
15011 it is not, or we cannot easily determined it to be.
15013 An example of the sort of thing we care about (at this point; this routine
15014 could surely be made more general, and expanded to do what the *_DIV_EXPR's
15015 fold cases do now) is discovering that
15017 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15023 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
15025 This code also handles discovering that
15027 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15029 is a multiple of 8 so we don't have to worry about dealing with a
15030 possible remainder.
15032 Note that we *look* inside a SAVE_EXPR only to determine how it was
15033 calculated; it is not safe for fold to do much of anything else with the
15034 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
15035 at run time. For example, the latter example above *cannot* be implemented
15036 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
15037 evaluation time of the original SAVE_EXPR is not necessarily the same at
15038 the time the new expression is evaluated. The only optimization of this
15039 sort that would be valid is changing
15041 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
15045 SAVE_EXPR (I) * SAVE_EXPR (J)
15047 (where the same SAVE_EXPR (J) is used in the original and the
15048 transformed version). */
15051 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
15053 if (operand_equal_p (top
, bottom
, 0))
15056 if (TREE_CODE (type
) != INTEGER_TYPE
)
15059 switch (TREE_CODE (top
))
15062 /* Bitwise and provides a power of two multiple. If the mask is
15063 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
15064 if (!integer_pow2p (bottom
))
15069 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
15070 || multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
15074 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
15075 && multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
15078 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
15082 op1
= TREE_OPERAND (top
, 1);
15083 /* const_binop may not detect overflow correctly,
15084 so check for it explicitly here. */
15085 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
15086 && 0 != (t1
= fold_convert (type
,
15087 const_binop (LSHIFT_EXPR
,
15090 && !TREE_OVERFLOW (t1
))
15091 return multiple_of_p (type
, t1
, bottom
);
15096 /* Can't handle conversions from non-integral or wider integral type. */
15097 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
15098 || (TYPE_PRECISION (type
)
15099 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
15102 /* .. fall through ... */
15105 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
15108 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
15109 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
15112 if (TREE_CODE (bottom
) != INTEGER_CST
15113 || integer_zerop (bottom
)
15114 || (TYPE_UNSIGNED (type
)
15115 && (tree_int_cst_sgn (top
) < 0
15116 || tree_int_cst_sgn (bottom
) < 0)))
15118 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
15126 /* Return true if CODE or TYPE is known to be non-negative. */
15129 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
15131 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
15132 && truth_value_p (code
))
15133 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15134 have a signed:1 type (where the value is -1 and 0). */
15139 /* Return true if (CODE OP0) is known to be non-negative. If the return
15140 value is based on the assumption that signed overflow is undefined,
15141 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15142 *STRICT_OVERFLOW_P. */
15145 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15146 bool *strict_overflow_p
)
15148 if (TYPE_UNSIGNED (type
))
15154 /* We can't return 1 if flag_wrapv is set because
15155 ABS_EXPR<INT_MIN> = INT_MIN. */
15156 if (!INTEGRAL_TYPE_P (type
))
15158 if (TYPE_OVERFLOW_UNDEFINED (type
))
15160 *strict_overflow_p
= true;
15165 case NON_LVALUE_EXPR
:
15167 case FIX_TRUNC_EXPR
:
15168 return tree_expr_nonnegative_warnv_p (op0
,
15169 strict_overflow_p
);
15173 tree inner_type
= TREE_TYPE (op0
);
15174 tree outer_type
= type
;
15176 if (TREE_CODE (outer_type
) == REAL_TYPE
)
15178 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15179 return tree_expr_nonnegative_warnv_p (op0
,
15180 strict_overflow_p
);
15181 if (INTEGRAL_TYPE_P (inner_type
))
15183 if (TYPE_UNSIGNED (inner_type
))
15185 return tree_expr_nonnegative_warnv_p (op0
,
15186 strict_overflow_p
);
15189 else if (INTEGRAL_TYPE_P (outer_type
))
15191 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15192 return tree_expr_nonnegative_warnv_p (op0
,
15193 strict_overflow_p
);
15194 if (INTEGRAL_TYPE_P (inner_type
))
15195 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
15196 && TYPE_UNSIGNED (inner_type
);
15202 return tree_simple_nonnegative_warnv_p (code
, type
);
15205 /* We don't know sign of `t', so be conservative and return false. */
15209 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
15210 value is based on the assumption that signed overflow is undefined,
15211 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15212 *STRICT_OVERFLOW_P. */
15215 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15216 tree op1
, bool *strict_overflow_p
)
15218 if (TYPE_UNSIGNED (type
))
15223 case POINTER_PLUS_EXPR
:
15225 if (FLOAT_TYPE_P (type
))
15226 return (tree_expr_nonnegative_warnv_p (op0
,
15228 && tree_expr_nonnegative_warnv_p (op1
,
15229 strict_overflow_p
));
15231 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
15232 both unsigned and at least 2 bits shorter than the result. */
15233 if (TREE_CODE (type
) == INTEGER_TYPE
15234 && TREE_CODE (op0
) == NOP_EXPR
15235 && TREE_CODE (op1
) == NOP_EXPR
)
15237 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
15238 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
15239 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
15240 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
15242 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
15243 TYPE_PRECISION (inner2
)) + 1;
15244 return prec
< TYPE_PRECISION (type
);
15250 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
15252 /* x * x is always non-negative for floating point x
15253 or without overflow. */
15254 if (operand_equal_p (op0
, op1
, 0)
15255 || (tree_expr_nonnegative_warnv_p (op0
, strict_overflow_p
)
15256 && tree_expr_nonnegative_warnv_p (op1
, strict_overflow_p
)))
15258 if (TYPE_OVERFLOW_UNDEFINED (type
))
15259 *strict_overflow_p
= true;
15264 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
15265 both unsigned and their total bits is shorter than the result. */
15266 if (TREE_CODE (type
) == INTEGER_TYPE
15267 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
15268 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
15270 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
15271 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
15273 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
15274 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
15277 bool unsigned0
= TYPE_UNSIGNED (inner0
);
15278 bool unsigned1
= TYPE_UNSIGNED (inner1
);
15280 if (TREE_CODE (op0
) == INTEGER_CST
)
15281 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
15283 if (TREE_CODE (op1
) == INTEGER_CST
)
15284 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
15286 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
15287 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
15289 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
15290 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
15291 : TYPE_PRECISION (inner0
);
15293 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
15294 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
15295 : TYPE_PRECISION (inner1
);
15297 return precision0
+ precision1
< TYPE_PRECISION (type
);
15304 return (tree_expr_nonnegative_warnv_p (op0
,
15306 || tree_expr_nonnegative_warnv_p (op1
,
15307 strict_overflow_p
));
15313 case TRUNC_DIV_EXPR
:
15314 case CEIL_DIV_EXPR
:
15315 case FLOOR_DIV_EXPR
:
15316 case ROUND_DIV_EXPR
:
15317 return (tree_expr_nonnegative_warnv_p (op0
,
15319 && tree_expr_nonnegative_warnv_p (op1
,
15320 strict_overflow_p
));
15322 case TRUNC_MOD_EXPR
:
15323 case CEIL_MOD_EXPR
:
15324 case FLOOR_MOD_EXPR
:
15325 case ROUND_MOD_EXPR
:
15326 return tree_expr_nonnegative_warnv_p (op0
,
15327 strict_overflow_p
);
15329 return tree_simple_nonnegative_warnv_p (code
, type
);
15332 /* We don't know sign of `t', so be conservative and return false. */
15336 /* Return true if T is known to be non-negative. If the return
15337 value is based on the assumption that signed overflow is undefined,
15338 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15339 *STRICT_OVERFLOW_P. */
15342 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15344 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15347 switch (TREE_CODE (t
))
15350 return tree_int_cst_sgn (t
) >= 0;
15353 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
15356 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
15359 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15361 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 2),
15362 strict_overflow_p
));
15364 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15367 /* We don't know sign of `t', so be conservative and return false. */
15371 /* Return true if T is known to be non-negative. If the return
15372 value is based on the assumption that signed overflow is undefined,
15373 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15374 *STRICT_OVERFLOW_P. */
15377 tree_call_nonnegative_warnv_p (tree type
, tree fndecl
,
15378 tree arg0
, tree arg1
, bool *strict_overflow_p
)
15380 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
15381 switch (DECL_FUNCTION_CODE (fndecl
))
15383 CASE_FLT_FN (BUILT_IN_ACOS
):
15384 CASE_FLT_FN (BUILT_IN_ACOSH
):
15385 CASE_FLT_FN (BUILT_IN_CABS
):
15386 CASE_FLT_FN (BUILT_IN_COSH
):
15387 CASE_FLT_FN (BUILT_IN_ERFC
):
15388 CASE_FLT_FN (BUILT_IN_EXP
):
15389 CASE_FLT_FN (BUILT_IN_EXP10
):
15390 CASE_FLT_FN (BUILT_IN_EXP2
):
15391 CASE_FLT_FN (BUILT_IN_FABS
):
15392 CASE_FLT_FN (BUILT_IN_FDIM
):
15393 CASE_FLT_FN (BUILT_IN_HYPOT
):
15394 CASE_FLT_FN (BUILT_IN_POW10
):
15395 CASE_INT_FN (BUILT_IN_FFS
):
15396 CASE_INT_FN (BUILT_IN_PARITY
):
15397 CASE_INT_FN (BUILT_IN_POPCOUNT
):
15398 CASE_INT_FN (BUILT_IN_CLZ
):
15399 CASE_INT_FN (BUILT_IN_CLRSB
):
15400 case BUILT_IN_BSWAP32
:
15401 case BUILT_IN_BSWAP64
:
15405 CASE_FLT_FN (BUILT_IN_SQRT
):
15406 /* sqrt(-0.0) is -0.0. */
15407 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
15409 return tree_expr_nonnegative_warnv_p (arg0
,
15410 strict_overflow_p
);
15412 CASE_FLT_FN (BUILT_IN_ASINH
):
15413 CASE_FLT_FN (BUILT_IN_ATAN
):
15414 CASE_FLT_FN (BUILT_IN_ATANH
):
15415 CASE_FLT_FN (BUILT_IN_CBRT
):
15416 CASE_FLT_FN (BUILT_IN_CEIL
):
15417 CASE_FLT_FN (BUILT_IN_ERF
):
15418 CASE_FLT_FN (BUILT_IN_EXPM1
):
15419 CASE_FLT_FN (BUILT_IN_FLOOR
):
15420 CASE_FLT_FN (BUILT_IN_FMOD
):
15421 CASE_FLT_FN (BUILT_IN_FREXP
):
15422 CASE_FLT_FN (BUILT_IN_ICEIL
):
15423 CASE_FLT_FN (BUILT_IN_IFLOOR
):
15424 CASE_FLT_FN (BUILT_IN_IRINT
):
15425 CASE_FLT_FN (BUILT_IN_IROUND
):
15426 CASE_FLT_FN (BUILT_IN_LCEIL
):
15427 CASE_FLT_FN (BUILT_IN_LDEXP
):
15428 CASE_FLT_FN (BUILT_IN_LFLOOR
):
15429 CASE_FLT_FN (BUILT_IN_LLCEIL
):
15430 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
15431 CASE_FLT_FN (BUILT_IN_LLRINT
):
15432 CASE_FLT_FN (BUILT_IN_LLROUND
):
15433 CASE_FLT_FN (BUILT_IN_LRINT
):
15434 CASE_FLT_FN (BUILT_IN_LROUND
):
15435 CASE_FLT_FN (BUILT_IN_MODF
):
15436 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
15437 CASE_FLT_FN (BUILT_IN_RINT
):
15438 CASE_FLT_FN (BUILT_IN_ROUND
):
15439 CASE_FLT_FN (BUILT_IN_SCALB
):
15440 CASE_FLT_FN (BUILT_IN_SCALBLN
):
15441 CASE_FLT_FN (BUILT_IN_SCALBN
):
15442 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
15443 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
15444 CASE_FLT_FN (BUILT_IN_SINH
):
15445 CASE_FLT_FN (BUILT_IN_TANH
):
15446 CASE_FLT_FN (BUILT_IN_TRUNC
):
15447 /* True if the 1st argument is nonnegative. */
15448 return tree_expr_nonnegative_warnv_p (arg0
,
15449 strict_overflow_p
);
15451 CASE_FLT_FN (BUILT_IN_FMAX
):
15452 /* True if the 1st OR 2nd arguments are nonnegative. */
15453 return (tree_expr_nonnegative_warnv_p (arg0
,
15455 || (tree_expr_nonnegative_warnv_p (arg1
,
15456 strict_overflow_p
)));
15458 CASE_FLT_FN (BUILT_IN_FMIN
):
15459 /* True if the 1st AND 2nd arguments are nonnegative. */
15460 return (tree_expr_nonnegative_warnv_p (arg0
,
15462 && (tree_expr_nonnegative_warnv_p (arg1
,
15463 strict_overflow_p
)));
15465 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
15466 /* True if the 2nd argument is nonnegative. */
15467 return tree_expr_nonnegative_warnv_p (arg1
,
15468 strict_overflow_p
);
15470 CASE_FLT_FN (BUILT_IN_POWI
):
15471 /* True if the 1st argument is nonnegative or the second
15472 argument is an even integer. */
15473 if (TREE_CODE (arg1
) == INTEGER_CST
15474 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
15476 return tree_expr_nonnegative_warnv_p (arg0
,
15477 strict_overflow_p
);
15479 CASE_FLT_FN (BUILT_IN_POW
):
15480 /* True if the 1st argument is nonnegative or the second
15481 argument is an even integer valued real. */
15482 if (TREE_CODE (arg1
) == REAL_CST
)
15487 c
= TREE_REAL_CST (arg1
);
15488 n
= real_to_integer (&c
);
15491 REAL_VALUE_TYPE cint
;
15492 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
15493 if (real_identical (&c
, &cint
))
15497 return tree_expr_nonnegative_warnv_p (arg0
,
15498 strict_overflow_p
);
15503 return tree_simple_nonnegative_warnv_p (CALL_EXPR
,
15507 /* Return true if T is known to be non-negative. If the return
15508 value is based on the assumption that signed overflow is undefined,
15509 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15510 *STRICT_OVERFLOW_P. */
15513 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15515 enum tree_code code
= TREE_CODE (t
);
15516 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15523 tree temp
= TARGET_EXPR_SLOT (t
);
15524 t
= TARGET_EXPR_INITIAL (t
);
15526 /* If the initializer is non-void, then it's a normal expression
15527 that will be assigned to the slot. */
15528 if (!VOID_TYPE_P (t
))
15529 return tree_expr_nonnegative_warnv_p (t
, strict_overflow_p
);
15531 /* Otherwise, the initializer sets the slot in some way. One common
15532 way is an assignment statement at the end of the initializer. */
15535 if (TREE_CODE (t
) == BIND_EXPR
)
15536 t
= expr_last (BIND_EXPR_BODY (t
));
15537 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
15538 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
15539 t
= expr_last (TREE_OPERAND (t
, 0));
15540 else if (TREE_CODE (t
) == STATEMENT_LIST
)
15545 if (TREE_CODE (t
) == MODIFY_EXPR
15546 && TREE_OPERAND (t
, 0) == temp
)
15547 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15548 strict_overflow_p
);
15555 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
15556 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
15558 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
15559 get_callee_fndecl (t
),
15562 strict_overflow_p
);
15564 case COMPOUND_EXPR
:
15566 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15567 strict_overflow_p
);
15569 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t
, 1)),
15570 strict_overflow_p
);
15572 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 0),
15573 strict_overflow_p
);
15576 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15580 /* We don't know sign of `t', so be conservative and return false. */
15584 /* Return true if T is known to be non-negative. If the return
15585 value is based on the assumption that signed overflow is undefined,
15586 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15587 *STRICT_OVERFLOW_P. */
15590 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15592 enum tree_code code
;
15593 if (t
== error_mark_node
)
15596 code
= TREE_CODE (t
);
15597 switch (TREE_CODE_CLASS (code
))
15600 case tcc_comparison
:
15601 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15603 TREE_OPERAND (t
, 0),
15604 TREE_OPERAND (t
, 1),
15605 strict_overflow_p
);
15608 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15610 TREE_OPERAND (t
, 0),
15611 strict_overflow_p
);
15614 case tcc_declaration
:
15615 case tcc_reference
:
15616 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15624 case TRUTH_AND_EXPR
:
15625 case TRUTH_OR_EXPR
:
15626 case TRUTH_XOR_EXPR
:
15627 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15629 TREE_OPERAND (t
, 0),
15630 TREE_OPERAND (t
, 1),
15631 strict_overflow_p
);
15632 case TRUTH_NOT_EXPR
:
15633 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15635 TREE_OPERAND (t
, 0),
15636 strict_overflow_p
);
15643 case WITH_SIZE_EXPR
:
15645 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15648 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
);
15652 /* Return true if `t' is known to be non-negative. Handle warnings
15653 about undefined signed overflow. */
15656 tree_expr_nonnegative_p (tree t
)
15658 bool ret
, strict_overflow_p
;
15660 strict_overflow_p
= false;
15661 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
15662 if (strict_overflow_p
)
15663 fold_overflow_warning (("assuming signed overflow does not occur when "
15664 "determining that expression is always "
15666 WARN_STRICT_OVERFLOW_MISC
);
15671 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15672 For floating point we further ensure that T is not denormal.
15673 Similar logic is present in nonzero_address in rtlanal.h.
15675 If the return value is based on the assumption that signed overflow
15676 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15677 change *STRICT_OVERFLOW_P. */
15680 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
15681 bool *strict_overflow_p
)
15686 return tree_expr_nonzero_warnv_p (op0
,
15687 strict_overflow_p
);
15691 tree inner_type
= TREE_TYPE (op0
);
15692 tree outer_type
= type
;
15694 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
15695 && tree_expr_nonzero_warnv_p (op0
,
15696 strict_overflow_p
));
15700 case NON_LVALUE_EXPR
:
15701 return tree_expr_nonzero_warnv_p (op0
,
15702 strict_overflow_p
);
15711 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15712 For floating point we further ensure that T is not denormal.
15713 Similar logic is present in nonzero_address in rtlanal.h.
15715 If the return value is based on the assumption that signed overflow
15716 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15717 change *STRICT_OVERFLOW_P. */
15720 tree_binary_nonzero_warnv_p (enum tree_code code
,
15723 tree op1
, bool *strict_overflow_p
)
15725 bool sub_strict_overflow_p
;
15728 case POINTER_PLUS_EXPR
:
15730 if (TYPE_OVERFLOW_UNDEFINED (type
))
15732 /* With the presence of negative values it is hard
15733 to say something. */
15734 sub_strict_overflow_p
= false;
15735 if (!tree_expr_nonnegative_warnv_p (op0
,
15736 &sub_strict_overflow_p
)
15737 || !tree_expr_nonnegative_warnv_p (op1
,
15738 &sub_strict_overflow_p
))
15740 /* One of operands must be positive and the other non-negative. */
15741 /* We don't set *STRICT_OVERFLOW_P here: even if this value
15742 overflows, on a twos-complement machine the sum of two
15743 nonnegative numbers can never be zero. */
15744 return (tree_expr_nonzero_warnv_p (op0
,
15746 || tree_expr_nonzero_warnv_p (op1
,
15747 strict_overflow_p
));
15752 if (TYPE_OVERFLOW_UNDEFINED (type
))
15754 if (tree_expr_nonzero_warnv_p (op0
,
15756 && tree_expr_nonzero_warnv_p (op1
,
15757 strict_overflow_p
))
15759 *strict_overflow_p
= true;
15766 sub_strict_overflow_p
= false;
15767 if (tree_expr_nonzero_warnv_p (op0
,
15768 &sub_strict_overflow_p
)
15769 && tree_expr_nonzero_warnv_p (op1
,
15770 &sub_strict_overflow_p
))
15772 if (sub_strict_overflow_p
)
15773 *strict_overflow_p
= true;
15778 sub_strict_overflow_p
= false;
15779 if (tree_expr_nonzero_warnv_p (op0
,
15780 &sub_strict_overflow_p
))
15782 if (sub_strict_overflow_p
)
15783 *strict_overflow_p
= true;
15785 /* When both operands are nonzero, then MAX must be too. */
15786 if (tree_expr_nonzero_warnv_p (op1
,
15787 strict_overflow_p
))
15790 /* MAX where operand 0 is positive is positive. */
15791 return tree_expr_nonnegative_warnv_p (op0
,
15792 strict_overflow_p
);
15794 /* MAX where operand 1 is positive is positive. */
15795 else if (tree_expr_nonzero_warnv_p (op1
,
15796 &sub_strict_overflow_p
)
15797 && tree_expr_nonnegative_warnv_p (op1
,
15798 &sub_strict_overflow_p
))
15800 if (sub_strict_overflow_p
)
15801 *strict_overflow_p
= true;
15807 return (tree_expr_nonzero_warnv_p (op1
,
15809 || tree_expr_nonzero_warnv_p (op0
,
15810 strict_overflow_p
));
15819 /* Return true when T is an address and is known to be nonzero.
15820 For floating point we further ensure that T is not denormal.
15821 Similar logic is present in nonzero_address in rtlanal.h.
15823 If the return value is based on the assumption that signed overflow
15824 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15825 change *STRICT_OVERFLOW_P. */
15828 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
15830 bool sub_strict_overflow_p
;
15831 switch (TREE_CODE (t
))
15834 return !integer_zerop (t
);
15838 tree base
= TREE_OPERAND (t
, 0);
15840 if (!DECL_P (base
))
15841 base
= get_base_address (base
);
15846 /* For objects in symbol table check if we know they are non-zero.
15847 Don't do anything for variables and functions before symtab is built;
15848 it is quite possible that they will be declared weak later. */
15849 if (DECL_P (base
) && decl_in_symtab_p (base
))
15851 struct symtab_node
*symbol
;
15853 symbol
= symtab_node::get_create (base
);
15855 return symbol
->nonzero_address ();
15860 /* Function local objects are never NULL. */
15862 && (DECL_CONTEXT (base
)
15863 && TREE_CODE (DECL_CONTEXT (base
)) == FUNCTION_DECL
15864 && auto_var_in_fn_p (base
, DECL_CONTEXT (base
))))
15867 /* Constants are never weak. */
15868 if (CONSTANT_CLASS_P (base
))
15875 sub_strict_overflow_p
= false;
15876 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
15877 &sub_strict_overflow_p
)
15878 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
15879 &sub_strict_overflow_p
))
15881 if (sub_strict_overflow_p
)
15882 *strict_overflow_p
= true;
15893 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15894 attempt to fold the expression to a constant without modifying TYPE,
15897 If the expression could be simplified to a constant, then return
15898 the constant. If the expression would not be simplified to a
15899 constant, then return NULL_TREE. */
15902 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
15904 tree tem
= fold_binary (code
, type
, op0
, op1
);
15905 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
15908 /* Given the components of a unary expression CODE, TYPE and OP0,
15909 attempt to fold the expression to a constant without modifying
15912 If the expression could be simplified to a constant, then return
15913 the constant. If the expression would not be simplified to a
15914 constant, then return NULL_TREE. */
15917 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
15919 tree tem
= fold_unary (code
, type
, op0
);
15920 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
15923 /* If EXP represents referencing an element in a constant string
15924 (either via pointer arithmetic or array indexing), return the
15925 tree representing the value accessed, otherwise return NULL. */
15928 fold_read_from_constant_string (tree exp
)
15930 if ((TREE_CODE (exp
) == INDIRECT_REF
15931 || TREE_CODE (exp
) == ARRAY_REF
)
15932 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
15934 tree exp1
= TREE_OPERAND (exp
, 0);
15937 location_t loc
= EXPR_LOCATION (exp
);
15939 if (TREE_CODE (exp
) == INDIRECT_REF
)
15940 string
= string_constant (exp1
, &index
);
15943 tree low_bound
= array_ref_low_bound (exp
);
15944 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
15946 /* Optimize the special-case of a zero lower bound.
15948 We convert the low_bound to sizetype to avoid some problems
15949 with constant folding. (E.g. suppose the lower bound is 1,
15950 and its mode is QI. Without the conversion,l (ARRAY
15951 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15952 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15953 if (! integer_zerop (low_bound
))
15954 index
= size_diffop_loc (loc
, index
,
15955 fold_convert_loc (loc
, sizetype
, low_bound
));
15961 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
15962 && TREE_CODE (string
) == STRING_CST
15963 && TREE_CODE (index
) == INTEGER_CST
15964 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
15965 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))))
15967 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))) == 1))
15968 return build_int_cst_type (TREE_TYPE (exp
),
15969 (TREE_STRING_POINTER (string
)
15970 [TREE_INT_CST_LOW (index
)]));
15975 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15976 an integer constant, real, or fixed-point constant.
15978 TYPE is the type of the result. */
15981 fold_negate_const (tree arg0
, tree type
)
15983 tree t
= NULL_TREE
;
15985 switch (TREE_CODE (arg0
))
15990 wide_int val
= wi::neg (arg0
, &overflow
);
15991 t
= force_fit_type (type
, val
, 1,
15992 (overflow
| TREE_OVERFLOW (arg0
))
15993 && !TYPE_UNSIGNED (type
));
15998 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16003 FIXED_VALUE_TYPE f
;
16004 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
16005 &(TREE_FIXED_CST (arg0
)), NULL
,
16006 TYPE_SATURATING (type
));
16007 t
= build_fixed (type
, f
);
16008 /* Propagate overflow flags. */
16009 if (overflow_p
| TREE_OVERFLOW (arg0
))
16010 TREE_OVERFLOW (t
) = 1;
16015 gcc_unreachable ();
16021 /* Return the tree for abs (ARG0) when ARG0 is known to be either
16022 an integer constant or real constant.
16024 TYPE is the type of the result. */
16027 fold_abs_const (tree arg0
, tree type
)
16029 tree t
= NULL_TREE
;
16031 switch (TREE_CODE (arg0
))
16035 /* If the value is unsigned or non-negative, then the absolute value
16036 is the same as the ordinary value. */
16037 if (!wi::neg_p (arg0
, TYPE_SIGN (type
)))
16040 /* If the value is negative, then the absolute value is
16045 wide_int val
= wi::neg (arg0
, &overflow
);
16046 t
= force_fit_type (type
, val
, -1,
16047 overflow
| TREE_OVERFLOW (arg0
));
16053 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
16054 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16060 gcc_unreachable ();
16066 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
16067 constant. TYPE is the type of the result. */
16070 fold_not_const (const_tree arg0
, tree type
)
16072 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
16074 return force_fit_type (type
, wi::bit_not (arg0
), 0, TREE_OVERFLOW (arg0
));
16077 /* Given CODE, a relational operator, the target type, TYPE and two
16078 constant operands OP0 and OP1, return the result of the
16079 relational operation. If the result is not a compile time
16080 constant, then return NULL_TREE. */
16083 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
16085 int result
, invert
;
16087 /* From here on, the only cases we handle are when the result is
16088 known to be a constant. */
16090 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
16092 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
16093 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
16095 /* Handle the cases where either operand is a NaN. */
16096 if (real_isnan (c0
) || real_isnan (c1
))
16106 case UNORDERED_EXPR
:
16120 if (flag_trapping_math
)
16126 gcc_unreachable ();
16129 return constant_boolean_node (result
, type
);
16132 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
16135 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
16137 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
16138 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
16139 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
16142 /* Handle equality/inequality of complex constants. */
16143 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
16145 tree rcond
= fold_relational_const (code
, type
,
16146 TREE_REALPART (op0
),
16147 TREE_REALPART (op1
));
16148 tree icond
= fold_relational_const (code
, type
,
16149 TREE_IMAGPART (op0
),
16150 TREE_IMAGPART (op1
));
16151 if (code
== EQ_EXPR
)
16152 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
16153 else if (code
== NE_EXPR
)
16154 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
16159 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
16161 unsigned count
= VECTOR_CST_NELTS (op0
);
16162 tree
*elts
= XALLOCAVEC (tree
, count
);
16163 gcc_assert (VECTOR_CST_NELTS (op1
) == count
16164 && TYPE_VECTOR_SUBPARTS (type
) == count
);
16166 for (unsigned i
= 0; i
< count
; i
++)
16168 tree elem_type
= TREE_TYPE (type
);
16169 tree elem0
= VECTOR_CST_ELT (op0
, i
);
16170 tree elem1
= VECTOR_CST_ELT (op1
, i
);
16172 tree tem
= fold_relational_const (code
, elem_type
,
16175 if (tem
== NULL_TREE
)
16178 elts
[i
] = build_int_cst (elem_type
, integer_zerop (tem
) ? 0 : -1);
16181 return build_vector (type
, elts
);
16184 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16186 To compute GT, swap the arguments and do LT.
16187 To compute GE, do LT and invert the result.
16188 To compute LE, swap the arguments, do LT and invert the result.
16189 To compute NE, do EQ and invert the result.
16191 Therefore, the code below must handle only EQ and LT. */
16193 if (code
== LE_EXPR
|| code
== GT_EXPR
)
16198 code
= swap_tree_comparison (code
);
16201 /* Note that it is safe to invert for real values here because we
16202 have already handled the one case that it matters. */
16205 if (code
== NE_EXPR
|| code
== GE_EXPR
)
16208 code
= invert_tree_comparison (code
, false);
16211 /* Compute a result for LT or EQ if args permit;
16212 Otherwise return T. */
16213 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
16215 if (code
== EQ_EXPR
)
16216 result
= tree_int_cst_equal (op0
, op1
);
16218 result
= tree_int_cst_lt (op0
, op1
);
16225 return constant_boolean_node (result
, type
);
16228 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16229 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16233 fold_build_cleanup_point_expr (tree type
, tree expr
)
16235 /* If the expression does not have side effects then we don't have to wrap
16236 it with a cleanup point expression. */
16237 if (!TREE_SIDE_EFFECTS (expr
))
16240 /* If the expression is a return, check to see if the expression inside the
16241 return has no side effects or the right hand side of the modify expression
16242 inside the return. If either don't have side effects set we don't need to
16243 wrap the expression in a cleanup point expression. Note we don't check the
16244 left hand side of the modify because it should always be a return decl. */
16245 if (TREE_CODE (expr
) == RETURN_EXPR
)
16247 tree op
= TREE_OPERAND (expr
, 0);
16248 if (!op
|| !TREE_SIDE_EFFECTS (op
))
16250 op
= TREE_OPERAND (op
, 1);
16251 if (!TREE_SIDE_EFFECTS (op
))
16255 return build1 (CLEANUP_POINT_EXPR
, type
, expr
);
16258 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16259 of an indirection through OP0, or NULL_TREE if no simplification is
16263 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
16269 subtype
= TREE_TYPE (sub
);
16270 if (!POINTER_TYPE_P (subtype
))
16273 if (TREE_CODE (sub
) == ADDR_EXPR
)
16275 tree op
= TREE_OPERAND (sub
, 0);
16276 tree optype
= TREE_TYPE (op
);
16277 /* *&CONST_DECL -> to the value of the const decl. */
16278 if (TREE_CODE (op
) == CONST_DECL
)
16279 return DECL_INITIAL (op
);
16280 /* *&p => p; make sure to handle *&"str"[cst] here. */
16281 if (type
== optype
)
16283 tree fop
= fold_read_from_constant_string (op
);
16289 /* *(foo *)&fooarray => fooarray[0] */
16290 else if (TREE_CODE (optype
) == ARRAY_TYPE
16291 && type
== TREE_TYPE (optype
)
16292 && (!in_gimple_form
16293 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16295 tree type_domain
= TYPE_DOMAIN (optype
);
16296 tree min_val
= size_zero_node
;
16297 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16298 min_val
= TYPE_MIN_VALUE (type_domain
);
16300 && TREE_CODE (min_val
) != INTEGER_CST
)
16302 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
16303 NULL_TREE
, NULL_TREE
);
16305 /* *(foo *)&complexfoo => __real__ complexfoo */
16306 else if (TREE_CODE (optype
) == COMPLEX_TYPE
16307 && type
== TREE_TYPE (optype
))
16308 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
16309 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16310 else if (TREE_CODE (optype
) == VECTOR_TYPE
16311 && type
== TREE_TYPE (optype
))
16313 tree part_width
= TYPE_SIZE (type
);
16314 tree index
= bitsize_int (0);
16315 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
16319 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
16320 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
16322 tree op00
= TREE_OPERAND (sub
, 0);
16323 tree op01
= TREE_OPERAND (sub
, 1);
16326 if (TREE_CODE (op00
) == ADDR_EXPR
)
16329 op00
= TREE_OPERAND (op00
, 0);
16330 op00type
= TREE_TYPE (op00
);
16332 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16333 if (TREE_CODE (op00type
) == VECTOR_TYPE
16334 && type
== TREE_TYPE (op00type
))
16336 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
16337 tree part_width
= TYPE_SIZE (type
);
16338 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
16339 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
16340 tree index
= bitsize_int (indexi
);
16342 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
16343 return fold_build3_loc (loc
,
16344 BIT_FIELD_REF
, type
, op00
,
16345 part_width
, index
);
16348 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16349 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
16350 && type
== TREE_TYPE (op00type
))
16352 tree size
= TYPE_SIZE_UNIT (type
);
16353 if (tree_int_cst_equal (size
, op01
))
16354 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
16356 /* ((foo *)&fooarray)[1] => fooarray[1] */
16357 else if (TREE_CODE (op00type
) == ARRAY_TYPE
16358 && type
== TREE_TYPE (op00type
))
16360 tree type_domain
= TYPE_DOMAIN (op00type
);
16361 tree min_val
= size_zero_node
;
16362 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16363 min_val
= TYPE_MIN_VALUE (type_domain
);
16364 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
16365 TYPE_SIZE_UNIT (type
));
16366 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
16367 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
16368 NULL_TREE
, NULL_TREE
);
16373 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16374 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
16375 && type
== TREE_TYPE (TREE_TYPE (subtype
))
16376 && (!in_gimple_form
16377 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16380 tree min_val
= size_zero_node
;
16381 sub
= build_fold_indirect_ref_loc (loc
, sub
);
16382 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
16383 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16384 min_val
= TYPE_MIN_VALUE (type_domain
);
16386 && TREE_CODE (min_val
) != INTEGER_CST
)
16388 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
16395 /* Builds an expression for an indirection through T, simplifying some
16399 build_fold_indirect_ref_loc (location_t loc
, tree t
)
16401 tree type
= TREE_TYPE (TREE_TYPE (t
));
16402 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
16407 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
16410 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16413 fold_indirect_ref_loc (location_t loc
, tree t
)
16415 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
16423 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16424 whose result is ignored. The type of the returned tree need not be
16425 the same as the original expression. */
16428 fold_ignored_result (tree t
)
16430 if (!TREE_SIDE_EFFECTS (t
))
16431 return integer_zero_node
;
16434 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
16437 t
= TREE_OPERAND (t
, 0);
16441 case tcc_comparison
:
16442 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16443 t
= TREE_OPERAND (t
, 0);
16444 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
16445 t
= TREE_OPERAND (t
, 1);
16450 case tcc_expression
:
16451 switch (TREE_CODE (t
))
16453 case COMPOUND_EXPR
:
16454 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16456 t
= TREE_OPERAND (t
, 0);
16460 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
16461 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
16463 t
= TREE_OPERAND (t
, 0);
16476 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
16479 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
16481 tree div
= NULL_TREE
;
16486 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16487 have to do anything. Only do this when we are not given a const,
16488 because in that case, this check is more expensive than just
16490 if (TREE_CODE (value
) != INTEGER_CST
)
16492 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16494 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16498 /* If divisor is a power of two, simplify this to bit manipulation. */
16499 if (divisor
== (divisor
& -divisor
))
16501 if (TREE_CODE (value
) == INTEGER_CST
)
16503 wide_int val
= value
;
16506 if ((val
& (divisor
- 1)) == 0)
16509 overflow_p
= TREE_OVERFLOW (value
);
16510 val
&= ~(divisor
- 1);
16515 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
16521 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
16522 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
16523 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16524 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16530 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16531 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
16532 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16538 /* Likewise, but round down. */
16541 round_down_loc (location_t loc
, tree value
, int divisor
)
16543 tree div
= NULL_TREE
;
16545 gcc_assert (divisor
> 0);
16549 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16550 have to do anything. Only do this when we are not given a const,
16551 because in that case, this check is more expensive than just
16553 if (TREE_CODE (value
) != INTEGER_CST
)
16555 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16557 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16561 /* If divisor is a power of two, simplify this to bit manipulation. */
16562 if (divisor
== (divisor
& -divisor
))
16566 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16567 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16572 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16573 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
16574 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16580 /* Returns the pointer to the base of the object addressed by EXP and
16581 extracts the information about the offset of the access, storing it
16582 to PBITPOS and POFFSET. */
16585 split_address_to_core_and_offset (tree exp
,
16586 HOST_WIDE_INT
*pbitpos
, tree
*poffset
)
16589 enum machine_mode mode
;
16590 int unsignedp
, volatilep
;
16591 HOST_WIDE_INT bitsize
;
16592 location_t loc
= EXPR_LOCATION (exp
);
16594 if (TREE_CODE (exp
) == ADDR_EXPR
)
16596 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
16597 poffset
, &mode
, &unsignedp
, &volatilep
,
16599 core
= build_fold_addr_expr_loc (loc
, core
);
16605 *poffset
= NULL_TREE
;
16611 /* Returns true if addresses of E1 and E2 differ by a constant, false
16612 otherwise. If they do, E1 - E2 is stored in *DIFF. */
16615 ptr_difference_const (tree e1
, tree e2
, HOST_WIDE_INT
*diff
)
16618 HOST_WIDE_INT bitpos1
, bitpos2
;
16619 tree toffset1
, toffset2
, tdiff
, type
;
16621 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
16622 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
16624 if (bitpos1
% BITS_PER_UNIT
!= 0
16625 || bitpos2
% BITS_PER_UNIT
!= 0
16626 || !operand_equal_p (core1
, core2
, 0))
16629 if (toffset1
&& toffset2
)
16631 type
= TREE_TYPE (toffset1
);
16632 if (type
!= TREE_TYPE (toffset2
))
16633 toffset2
= fold_convert (type
, toffset2
);
16635 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
16636 if (!cst_and_fits_in_hwi (tdiff
))
16639 *diff
= int_cst_value (tdiff
);
16641 else if (toffset1
|| toffset2
)
16643 /* If only one of the offsets is non-constant, the difference cannot
16650 *diff
+= (bitpos1
- bitpos2
) / BITS_PER_UNIT
;
16654 /* Simplify the floating point expression EXP when the sign of the
16655 result is not significant. Return NULL_TREE if no simplification
16659 fold_strip_sign_ops (tree exp
)
16662 location_t loc
= EXPR_LOCATION (exp
);
16664 switch (TREE_CODE (exp
))
16668 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16669 return arg0
? arg0
: TREE_OPERAND (exp
, 0);
16673 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp
))))
16675 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16676 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16677 if (arg0
!= NULL_TREE
|| arg1
!= NULL_TREE
)
16678 return fold_build2_loc (loc
, TREE_CODE (exp
), TREE_TYPE (exp
),
16679 arg0
? arg0
: TREE_OPERAND (exp
, 0),
16680 arg1
? arg1
: TREE_OPERAND (exp
, 1));
16683 case COMPOUND_EXPR
:
16684 arg0
= TREE_OPERAND (exp
, 0);
16685 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16687 return fold_build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (exp
), arg0
, arg1
);
16691 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16692 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 2));
16694 return fold_build3_loc (loc
,
16695 COND_EXPR
, TREE_TYPE (exp
), TREE_OPERAND (exp
, 0),
16696 arg0
? arg0
: TREE_OPERAND (exp
, 1),
16697 arg1
? arg1
: TREE_OPERAND (exp
, 2));
16702 const enum built_in_function fcode
= builtin_mathfn_code (exp
);
16705 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
16706 /* Strip copysign function call, return the 1st argument. */
16707 arg0
= CALL_EXPR_ARG (exp
, 0);
16708 arg1
= CALL_EXPR_ARG (exp
, 1);
16709 return omit_one_operand_loc (loc
, TREE_TYPE (exp
), arg0
, arg1
);
16712 /* Strip sign ops from the argument of "odd" math functions. */
16713 if (negate_mathfn_p (fcode
))
16715 arg0
= fold_strip_sign_ops (CALL_EXPR_ARG (exp
, 0));
16717 return build_call_expr_loc (loc
, get_callee_fndecl (exp
), 1, arg0
);