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 STRIP_SIGN_NOPS (arg0
);
6646 STRIP_SIGN_NOPS (arg1
);
6648 if (TREE_CODE (arg1
) == INTEGER_CST
)
6650 if (TREE_CODE (arg0
) == INTEGER_CST
)
6653 if (TREE_CODE (arg1
) == REAL_CST
)
6655 if (TREE_CODE (arg0
) == REAL_CST
)
6658 if (TREE_CODE (arg1
) == FIXED_CST
)
6660 if (TREE_CODE (arg0
) == FIXED_CST
)
6663 if (TREE_CODE (arg1
) == COMPLEX_CST
)
6665 if (TREE_CODE (arg0
) == COMPLEX_CST
)
6668 if (TREE_CONSTANT (arg1
))
6670 if (TREE_CONSTANT (arg0
))
6673 if (optimize_function_for_size_p (cfun
))
6676 if (reorder
&& flag_evaluation_order
6677 && (TREE_SIDE_EFFECTS (arg0
) || TREE_SIDE_EFFECTS (arg1
)))
6680 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6681 for commutative and comparison operators. Ensuring a canonical
6682 form allows the optimizers to find additional redundancies without
6683 having to explicitly check for both orderings. */
6684 if (TREE_CODE (arg0
) == SSA_NAME
6685 && TREE_CODE (arg1
) == SSA_NAME
6686 && SSA_NAME_VERSION (arg0
) > SSA_NAME_VERSION (arg1
))
6689 /* Put SSA_NAMEs last. */
6690 if (TREE_CODE (arg1
) == SSA_NAME
)
6692 if (TREE_CODE (arg0
) == SSA_NAME
)
6695 /* Put variables last. */
6704 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6705 ARG0 is extended to a wider type. */
6708 fold_widened_comparison (location_t loc
, enum tree_code code
,
6709 tree type
, tree arg0
, tree arg1
)
6711 tree arg0_unw
= get_unwidened (arg0
, NULL_TREE
);
6713 tree shorter_type
, outer_type
;
6717 if (arg0_unw
== arg0
)
6719 shorter_type
= TREE_TYPE (arg0_unw
);
6721 #ifdef HAVE_canonicalize_funcptr_for_compare
6722 /* Disable this optimization if we're casting a function pointer
6723 type on targets that require function pointer canonicalization. */
6724 if (HAVE_canonicalize_funcptr_for_compare
6725 && TREE_CODE (shorter_type
) == POINTER_TYPE
6726 && TREE_CODE (TREE_TYPE (shorter_type
)) == FUNCTION_TYPE
)
6730 if (TYPE_PRECISION (TREE_TYPE (arg0
)) <= TYPE_PRECISION (shorter_type
))
6733 arg1_unw
= get_unwidened (arg1
, NULL_TREE
);
6735 /* If possible, express the comparison in the shorter mode. */
6736 if ((code
== EQ_EXPR
|| code
== NE_EXPR
6737 || TYPE_UNSIGNED (TREE_TYPE (arg0
)) == TYPE_UNSIGNED (shorter_type
))
6738 && (TREE_TYPE (arg1_unw
) == shorter_type
6739 || ((TYPE_PRECISION (shorter_type
)
6740 >= TYPE_PRECISION (TREE_TYPE (arg1_unw
)))
6741 && (TYPE_UNSIGNED (shorter_type
)
6742 == TYPE_UNSIGNED (TREE_TYPE (arg1_unw
))))
6743 || (TREE_CODE (arg1_unw
) == INTEGER_CST
6744 && (TREE_CODE (shorter_type
) == INTEGER_TYPE
6745 || TREE_CODE (shorter_type
) == BOOLEAN_TYPE
)
6746 && int_fits_type_p (arg1_unw
, shorter_type
))))
6747 return fold_build2_loc (loc
, code
, type
, arg0_unw
,
6748 fold_convert_loc (loc
, shorter_type
, arg1_unw
));
6750 if (TREE_CODE (arg1_unw
) != INTEGER_CST
6751 || TREE_CODE (shorter_type
) != INTEGER_TYPE
6752 || !int_fits_type_p (arg1_unw
, shorter_type
))
6755 /* If we are comparing with the integer that does not fit into the range
6756 of the shorter type, the result is known. */
6757 outer_type
= TREE_TYPE (arg1_unw
);
6758 min
= lower_bound_in_type (outer_type
, shorter_type
);
6759 max
= upper_bound_in_type (outer_type
, shorter_type
);
6761 above
= integer_nonzerop (fold_relational_const (LT_EXPR
, type
,
6763 below
= integer_nonzerop (fold_relational_const (LT_EXPR
, type
,
6770 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6775 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6781 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6783 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6788 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6790 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6799 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6800 ARG0 just the signedness is changed. */
6803 fold_sign_changed_comparison (location_t loc
, enum tree_code code
, tree type
,
6804 tree arg0
, tree arg1
)
6807 tree inner_type
, outer_type
;
6809 if (!CONVERT_EXPR_P (arg0
))
6812 outer_type
= TREE_TYPE (arg0
);
6813 arg0_inner
= TREE_OPERAND (arg0
, 0);
6814 inner_type
= TREE_TYPE (arg0_inner
);
6816 #ifdef HAVE_canonicalize_funcptr_for_compare
6817 /* Disable this optimization if we're casting a function pointer
6818 type on targets that require function pointer canonicalization. */
6819 if (HAVE_canonicalize_funcptr_for_compare
6820 && TREE_CODE (inner_type
) == POINTER_TYPE
6821 && TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
)
6825 if (TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
6828 if (TREE_CODE (arg1
) != INTEGER_CST
6829 && !(CONVERT_EXPR_P (arg1
)
6830 && TREE_TYPE (TREE_OPERAND (arg1
, 0)) == inner_type
))
6833 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
6838 if (POINTER_TYPE_P (inner_type
) != POINTER_TYPE_P (outer_type
))
6841 if (TREE_CODE (arg1
) == INTEGER_CST
)
6842 arg1
= force_fit_type (inner_type
, wi::to_widest (arg1
), 0,
6843 TREE_OVERFLOW (arg1
));
6845 arg1
= fold_convert_loc (loc
, inner_type
, arg1
);
6847 return fold_build2_loc (loc
, code
, type
, arg0_inner
, arg1
);
6850 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
6851 step of the array. Reconstructs s and delta in the case of s *
6852 delta being an integer constant (and thus already folded). ADDR is
6853 the address. MULT is the multiplicative expression. If the
6854 function succeeds, the new address expression is returned.
6855 Otherwise NULL_TREE is returned. LOC is the location of the
6856 resulting expression. */
6859 try_move_mult_to_index (location_t loc
, tree addr
, tree op1
)
6861 tree s
, delta
, step
;
6862 tree ref
= TREE_OPERAND (addr
, 0), pref
;
6867 /* Strip the nops that might be added when converting op1 to sizetype. */
6870 /* Canonicalize op1 into a possibly non-constant delta
6871 and an INTEGER_CST s. */
6872 if (TREE_CODE (op1
) == MULT_EXPR
)
6874 tree arg0
= TREE_OPERAND (op1
, 0), arg1
= TREE_OPERAND (op1
, 1);
6879 if (TREE_CODE (arg0
) == INTEGER_CST
)
6884 else if (TREE_CODE (arg1
) == INTEGER_CST
)
6892 else if (TREE_CODE (op1
) == INTEGER_CST
)
6899 /* Simulate we are delta * 1. */
6901 s
= integer_one_node
;
6904 /* Handle &x.array the same as we would handle &x.array[0]. */
6905 if (TREE_CODE (ref
) == COMPONENT_REF
6906 && TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
6910 /* Remember if this was a multi-dimensional array. */
6911 if (TREE_CODE (TREE_OPERAND (ref
, 0)) == ARRAY_REF
)
6914 domain
= TYPE_DOMAIN (TREE_TYPE (ref
));
6917 itype
= TREE_TYPE (domain
);
6919 step
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ref
)));
6920 if (TREE_CODE (step
) != INTEGER_CST
)
6925 if (! tree_int_cst_equal (step
, s
))
6930 /* Try if delta is a multiple of step. */
6931 tree tmp
= div_if_zero_remainder (op1
, step
);
6937 /* Only fold here if we can verify we do not overflow one
6938 dimension of a multi-dimensional array. */
6943 if (!TYPE_MIN_VALUE (domain
)
6944 || !TYPE_MAX_VALUE (domain
)
6945 || TREE_CODE (TYPE_MAX_VALUE (domain
)) != INTEGER_CST
)
6948 tmp
= fold_binary_loc (loc
, PLUS_EXPR
, itype
,
6949 fold_convert_loc (loc
, itype
,
6950 TYPE_MIN_VALUE (domain
)),
6951 fold_convert_loc (loc
, itype
, delta
));
6952 if (TREE_CODE (tmp
) != INTEGER_CST
6953 || tree_int_cst_lt (TYPE_MAX_VALUE (domain
), tmp
))
6957 /* We found a suitable component reference. */
6959 pref
= TREE_OPERAND (addr
, 0);
6960 ret
= copy_node (pref
);
6961 SET_EXPR_LOCATION (ret
, loc
);
6963 ret
= build4_loc (loc
, ARRAY_REF
, TREE_TYPE (TREE_TYPE (ref
)), ret
,
6965 (loc
, PLUS_EXPR
, itype
,
6966 fold_convert_loc (loc
, itype
,
6968 (TYPE_DOMAIN (TREE_TYPE (ref
)))),
6969 fold_convert_loc (loc
, itype
, delta
)),
6970 NULL_TREE
, NULL_TREE
);
6971 return build_fold_addr_expr_loc (loc
, ret
);
6976 for (;; ref
= TREE_OPERAND (ref
, 0))
6978 if (TREE_CODE (ref
) == ARRAY_REF
)
6982 /* Remember if this was a multi-dimensional array. */
6983 if (TREE_CODE (TREE_OPERAND (ref
, 0)) == ARRAY_REF
)
6986 domain
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref
, 0)));
6989 itype
= TREE_TYPE (domain
);
6991 step
= array_ref_element_size (ref
);
6992 if (TREE_CODE (step
) != INTEGER_CST
)
6997 if (! tree_int_cst_equal (step
, s
))
7002 /* Try if delta is a multiple of step. */
7003 tree tmp
= div_if_zero_remainder (op1
, step
);
7009 /* Only fold here if we can verify we do not overflow one
7010 dimension of a multi-dimensional array. */
7015 if (TREE_CODE (TREE_OPERAND (ref
, 1)) != INTEGER_CST
7016 || !TYPE_MAX_VALUE (domain
)
7017 || TREE_CODE (TYPE_MAX_VALUE (domain
)) != INTEGER_CST
)
7020 tmp
= fold_binary_loc (loc
, PLUS_EXPR
, itype
,
7021 fold_convert_loc (loc
, itype
,
7022 TREE_OPERAND (ref
, 1)),
7023 fold_convert_loc (loc
, itype
, delta
));
7025 || TREE_CODE (tmp
) != INTEGER_CST
7026 || tree_int_cst_lt (TYPE_MAX_VALUE (domain
), tmp
))
7035 if (!handled_component_p (ref
))
7039 /* We found the suitable array reference. So copy everything up to it,
7040 and replace the index. */
7042 pref
= TREE_OPERAND (addr
, 0);
7043 ret
= copy_node (pref
);
7044 SET_EXPR_LOCATION (ret
, loc
);
7049 pref
= TREE_OPERAND (pref
, 0);
7050 TREE_OPERAND (pos
, 0) = copy_node (pref
);
7051 pos
= TREE_OPERAND (pos
, 0);
7054 TREE_OPERAND (pos
, 1)
7055 = fold_build2_loc (loc
, PLUS_EXPR
, itype
,
7056 fold_convert_loc (loc
, itype
, TREE_OPERAND (pos
, 1)),
7057 fold_convert_loc (loc
, itype
, delta
));
7058 return fold_build1_loc (loc
, ADDR_EXPR
, TREE_TYPE (addr
), ret
);
7062 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
7063 means A >= Y && A != MAX, but in this case we know that
7064 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
7067 fold_to_nonsharp_ineq_using_bound (location_t loc
, tree ineq
, tree bound
)
7069 tree a
, typea
, type
= TREE_TYPE (ineq
), a1
, diff
, y
;
7071 if (TREE_CODE (bound
) == LT_EXPR
)
7072 a
= TREE_OPERAND (bound
, 0);
7073 else if (TREE_CODE (bound
) == GT_EXPR
)
7074 a
= TREE_OPERAND (bound
, 1);
7078 typea
= TREE_TYPE (a
);
7079 if (!INTEGRAL_TYPE_P (typea
)
7080 && !POINTER_TYPE_P (typea
))
7083 if (TREE_CODE (ineq
) == LT_EXPR
)
7085 a1
= TREE_OPERAND (ineq
, 1);
7086 y
= TREE_OPERAND (ineq
, 0);
7088 else if (TREE_CODE (ineq
) == GT_EXPR
)
7090 a1
= TREE_OPERAND (ineq
, 0);
7091 y
= TREE_OPERAND (ineq
, 1);
7096 if (TREE_TYPE (a1
) != typea
)
7099 if (POINTER_TYPE_P (typea
))
7101 /* Convert the pointer types into integer before taking the difference. */
7102 tree ta
= fold_convert_loc (loc
, ssizetype
, a
);
7103 tree ta1
= fold_convert_loc (loc
, ssizetype
, a1
);
7104 diff
= fold_binary_loc (loc
, MINUS_EXPR
, ssizetype
, ta1
, ta
);
7107 diff
= fold_binary_loc (loc
, MINUS_EXPR
, typea
, a1
, a
);
7109 if (!diff
|| !integer_onep (diff
))
7112 return fold_build2_loc (loc
, GE_EXPR
, type
, a
, y
);
7115 /* Fold a sum or difference of at least one multiplication.
7116 Returns the folded tree or NULL if no simplification could be made. */
7119 fold_plusminus_mult_expr (location_t loc
, enum tree_code code
, tree type
,
7120 tree arg0
, tree arg1
)
7122 tree arg00
, arg01
, arg10
, arg11
;
7123 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
7125 /* (A * C) +- (B * C) -> (A+-B) * C.
7126 (A * C) +- A -> A * (C+-1).
7127 We are most concerned about the case where C is a constant,
7128 but other combinations show up during loop reduction. Since
7129 it is not difficult, try all four possibilities. */
7131 if (TREE_CODE (arg0
) == MULT_EXPR
)
7133 arg00
= TREE_OPERAND (arg0
, 0);
7134 arg01
= TREE_OPERAND (arg0
, 1);
7136 else if (TREE_CODE (arg0
) == INTEGER_CST
)
7138 arg00
= build_one_cst (type
);
7143 /* We cannot generate constant 1 for fract. */
7144 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
7147 arg01
= build_one_cst (type
);
7149 if (TREE_CODE (arg1
) == MULT_EXPR
)
7151 arg10
= TREE_OPERAND (arg1
, 0);
7152 arg11
= TREE_OPERAND (arg1
, 1);
7154 else if (TREE_CODE (arg1
) == INTEGER_CST
)
7156 arg10
= build_one_cst (type
);
7157 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7158 the purpose of this canonicalization. */
7159 if (wi::neg_p (arg1
, TYPE_SIGN (TREE_TYPE (arg1
)))
7160 && negate_expr_p (arg1
)
7161 && code
== PLUS_EXPR
)
7163 arg11
= negate_expr (arg1
);
7171 /* We cannot generate constant 1 for fract. */
7172 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
7175 arg11
= build_one_cst (type
);
7179 if (operand_equal_p (arg01
, arg11
, 0))
7180 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
7181 else if (operand_equal_p (arg00
, arg10
, 0))
7182 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
7183 else if (operand_equal_p (arg00
, arg11
, 0))
7184 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
7185 else if (operand_equal_p (arg01
, arg10
, 0))
7186 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
7188 /* No identical multiplicands; see if we can find a common
7189 power-of-two factor in non-power-of-two multiplies. This
7190 can help in multi-dimensional array access. */
7191 else if (tree_fits_shwi_p (arg01
)
7192 && tree_fits_shwi_p (arg11
))
7194 HOST_WIDE_INT int01
, int11
, tmp
;
7197 int01
= tree_to_shwi (arg01
);
7198 int11
= tree_to_shwi (arg11
);
7200 /* Move min of absolute values to int11. */
7201 if (absu_hwi (int01
) < absu_hwi (int11
))
7203 tmp
= int01
, int01
= int11
, int11
= tmp
;
7204 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
7211 if (exact_log2 (absu_hwi (int11
)) > 0 && int01
% int11
== 0
7212 /* The remainder should not be a constant, otherwise we
7213 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7214 increased the number of multiplications necessary. */
7215 && TREE_CODE (arg10
) != INTEGER_CST
)
7217 alt0
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (arg00
), arg00
,
7218 build_int_cst (TREE_TYPE (arg00
),
7223 maybe_same
= alt0
, alt0
= alt1
, alt1
= maybe_same
;
7228 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7229 fold_build2_loc (loc
, code
, type
,
7230 fold_convert_loc (loc
, type
, alt0
),
7231 fold_convert_loc (loc
, type
, alt1
)),
7232 fold_convert_loc (loc
, type
, same
));
7237 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7238 specified by EXPR into the buffer PTR of length LEN bytes.
7239 Return the number of bytes placed in the buffer, or zero
7243 native_encode_int (const_tree expr
, unsigned char *ptr
, int len
)
7245 tree type
= TREE_TYPE (expr
);
7246 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7247 int byte
, offset
, word
, words
;
7248 unsigned char value
;
7250 if (total_bytes
> len
)
7252 words
= total_bytes
/ UNITS_PER_WORD
;
7254 for (byte
= 0; byte
< total_bytes
; byte
++)
7256 int bitpos
= byte
* BITS_PER_UNIT
;
7257 /* Extend EXPR according to TYPE_SIGN if the precision isn't a whole
7259 value
= wi::extract_uhwi (wi::to_widest (expr
), bitpos
, BITS_PER_UNIT
);
7261 if (total_bytes
> UNITS_PER_WORD
)
7263 word
= byte
/ UNITS_PER_WORD
;
7264 if (WORDS_BIG_ENDIAN
)
7265 word
= (words
- 1) - word
;
7266 offset
= word
* UNITS_PER_WORD
;
7267 if (BYTES_BIG_ENDIAN
)
7268 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7270 offset
+= byte
% UNITS_PER_WORD
;
7273 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
7274 ptr
[offset
] = value
;
7280 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7281 specified by EXPR into the buffer PTR of length LEN bytes.
7282 Return the number of bytes placed in the buffer, or zero
7286 native_encode_fixed (const_tree expr
, unsigned char *ptr
, int len
)
7288 tree type
= TREE_TYPE (expr
);
7289 enum machine_mode mode
= TYPE_MODE (type
);
7290 int total_bytes
= GET_MODE_SIZE (mode
);
7291 FIXED_VALUE_TYPE value
;
7292 tree i_value
, i_type
;
7294 if (total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7297 i_type
= lang_hooks
.types
.type_for_size (GET_MODE_BITSIZE (mode
), 1);
7299 if (NULL_TREE
== i_type
7300 || TYPE_PRECISION (i_type
) != total_bytes
)
7303 value
= TREE_FIXED_CST (expr
);
7304 i_value
= double_int_to_tree (i_type
, value
.data
);
7306 return native_encode_int (i_value
, ptr
, len
);
7310 /* Subroutine of native_encode_expr. Encode the REAL_CST
7311 specified by EXPR into the buffer PTR of length LEN bytes.
7312 Return the number of bytes placed in the buffer, or zero
7316 native_encode_real (const_tree expr
, unsigned char *ptr
, int len
)
7318 tree type
= TREE_TYPE (expr
);
7319 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7320 int byte
, offset
, word
, words
, bitpos
;
7321 unsigned char value
;
7323 /* There are always 32 bits in each long, no matter the size of
7324 the hosts long. We handle floating point representations with
7328 if (total_bytes
> len
)
7330 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7332 real_to_target (tmp
, TREE_REAL_CST_PTR (expr
), TYPE_MODE (type
));
7334 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7335 bitpos
+= BITS_PER_UNIT
)
7337 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7338 value
= (unsigned char) (tmp
[bitpos
/ 32] >> (bitpos
& 31));
7340 if (UNITS_PER_WORD
< 4)
7342 word
= byte
/ UNITS_PER_WORD
;
7343 if (WORDS_BIG_ENDIAN
)
7344 word
= (words
- 1) - word
;
7345 offset
= word
* UNITS_PER_WORD
;
7346 if (BYTES_BIG_ENDIAN
)
7347 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7349 offset
+= byte
% UNITS_PER_WORD
;
7352 offset
= BYTES_BIG_ENDIAN
? 3 - byte
: byte
;
7353 ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)] = value
;
7358 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7359 specified by EXPR into the buffer PTR of length LEN bytes.
7360 Return the number of bytes placed in the buffer, or zero
7364 native_encode_complex (const_tree expr
, unsigned char *ptr
, int len
)
7369 part
= TREE_REALPART (expr
);
7370 rsize
= native_encode_expr (part
, ptr
, len
);
7373 part
= TREE_IMAGPART (expr
);
7374 isize
= native_encode_expr (part
, ptr
+rsize
, len
-rsize
);
7377 return rsize
+ isize
;
7381 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7382 specified by EXPR into the buffer PTR of length LEN bytes.
7383 Return the number of bytes placed in the buffer, or zero
7387 native_encode_vector (const_tree expr
, unsigned char *ptr
, int len
)
7394 count
= VECTOR_CST_NELTS (expr
);
7395 itype
= TREE_TYPE (TREE_TYPE (expr
));
7396 size
= GET_MODE_SIZE (TYPE_MODE (itype
));
7397 for (i
= 0; i
< count
; i
++)
7399 elem
= VECTOR_CST_ELT (expr
, i
);
7400 if (native_encode_expr (elem
, ptr
+offset
, len
-offset
) != size
)
7408 /* Subroutine of native_encode_expr. Encode the STRING_CST
7409 specified by EXPR into the buffer PTR of length LEN bytes.
7410 Return the number of bytes placed in the buffer, or zero
7414 native_encode_string (const_tree expr
, unsigned char *ptr
, int len
)
7416 tree type
= TREE_TYPE (expr
);
7417 HOST_WIDE_INT total_bytes
;
7419 if (TREE_CODE (type
) != ARRAY_TYPE
7420 || TREE_CODE (TREE_TYPE (type
)) != INTEGER_TYPE
7421 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))) != BITS_PER_UNIT
7422 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type
)))
7424 total_bytes
= tree_to_shwi (TYPE_SIZE_UNIT (type
));
7425 if (total_bytes
> len
)
7427 if (TREE_STRING_LENGTH (expr
) < total_bytes
)
7429 memcpy (ptr
, TREE_STRING_POINTER (expr
), TREE_STRING_LENGTH (expr
));
7430 memset (ptr
+ TREE_STRING_LENGTH (expr
), 0,
7431 total_bytes
- TREE_STRING_LENGTH (expr
));
7434 memcpy (ptr
, TREE_STRING_POINTER (expr
), total_bytes
);
7439 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7440 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7441 buffer PTR of length LEN bytes. Return the number of bytes
7442 placed in the buffer, or zero upon failure. */
7445 native_encode_expr (const_tree expr
, unsigned char *ptr
, int len
)
7447 switch (TREE_CODE (expr
))
7450 return native_encode_int (expr
, ptr
, len
);
7453 return native_encode_real (expr
, ptr
, len
);
7456 return native_encode_fixed (expr
, ptr
, len
);
7459 return native_encode_complex (expr
, ptr
, len
);
7462 return native_encode_vector (expr
, ptr
, len
);
7465 return native_encode_string (expr
, ptr
, len
);
7473 /* Subroutine of native_interpret_expr. Interpret the contents of
7474 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7475 If the buffer cannot be interpreted, return NULL_TREE. */
7478 native_interpret_int (tree type
, const unsigned char *ptr
, int len
)
7480 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7482 if (total_bytes
> len
7483 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7486 wide_int result
= wi::from_buffer (ptr
, total_bytes
);
7488 return wide_int_to_tree (type
, result
);
7492 /* Subroutine of native_interpret_expr. Interpret the contents of
7493 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7494 If the buffer cannot be interpreted, return NULL_TREE. */
7497 native_interpret_fixed (tree type
, const unsigned char *ptr
, int len
)
7499 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7501 FIXED_VALUE_TYPE fixed_value
;
7503 if (total_bytes
> len
7504 || total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7507 result
= double_int::from_buffer (ptr
, total_bytes
);
7508 fixed_value
= fixed_from_double_int (result
, TYPE_MODE (type
));
7510 return build_fixed (type
, fixed_value
);
7514 /* Subroutine of native_interpret_expr. Interpret the contents of
7515 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7516 If the buffer cannot be interpreted, return NULL_TREE. */
7519 native_interpret_real (tree type
, const unsigned char *ptr
, int len
)
7521 enum machine_mode mode
= TYPE_MODE (type
);
7522 int total_bytes
= GET_MODE_SIZE (mode
);
7523 int byte
, offset
, word
, words
, bitpos
;
7524 unsigned char value
;
7525 /* There are always 32 bits in each long, no matter the size of
7526 the hosts long. We handle floating point representations with
7531 total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7532 if (total_bytes
> len
|| total_bytes
> 24)
7534 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7536 memset (tmp
, 0, sizeof (tmp
));
7537 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7538 bitpos
+= BITS_PER_UNIT
)
7540 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7541 if (UNITS_PER_WORD
< 4)
7543 word
= byte
/ UNITS_PER_WORD
;
7544 if (WORDS_BIG_ENDIAN
)
7545 word
= (words
- 1) - word
;
7546 offset
= word
* UNITS_PER_WORD
;
7547 if (BYTES_BIG_ENDIAN
)
7548 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7550 offset
+= byte
% UNITS_PER_WORD
;
7553 offset
= BYTES_BIG_ENDIAN
? 3 - byte
: byte
;
7554 value
= ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)];
7556 tmp
[bitpos
/ 32] |= (unsigned long)value
<< (bitpos
& 31);
7559 real_from_target (&r
, tmp
, mode
);
7560 return build_real (type
, r
);
7564 /* Subroutine of native_interpret_expr. Interpret the contents of
7565 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7566 If the buffer cannot be interpreted, return NULL_TREE. */
7569 native_interpret_complex (tree type
, const unsigned char *ptr
, int len
)
7571 tree etype
, rpart
, ipart
;
7574 etype
= TREE_TYPE (type
);
7575 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7578 rpart
= native_interpret_expr (etype
, ptr
, size
);
7581 ipart
= native_interpret_expr (etype
, ptr
+size
, size
);
7584 return build_complex (type
, rpart
, ipart
);
7588 /* Subroutine of native_interpret_expr. Interpret the contents of
7589 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7590 If the buffer cannot be interpreted, return NULL_TREE. */
7593 native_interpret_vector (tree type
, const unsigned char *ptr
, int len
)
7599 etype
= TREE_TYPE (type
);
7600 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7601 count
= TYPE_VECTOR_SUBPARTS (type
);
7602 if (size
* count
> len
)
7605 elements
= XALLOCAVEC (tree
, count
);
7606 for (i
= count
- 1; i
>= 0; i
--)
7608 elem
= native_interpret_expr (etype
, ptr
+(i
*size
), size
);
7613 return build_vector (type
, elements
);
7617 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7618 the buffer PTR of length LEN as a constant of type TYPE. For
7619 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7620 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7621 return NULL_TREE. */
7624 native_interpret_expr (tree type
, const unsigned char *ptr
, int len
)
7626 switch (TREE_CODE (type
))
7632 case REFERENCE_TYPE
:
7633 return native_interpret_int (type
, ptr
, len
);
7636 return native_interpret_real (type
, ptr
, len
);
7638 case FIXED_POINT_TYPE
:
7639 return native_interpret_fixed (type
, ptr
, len
);
7642 return native_interpret_complex (type
, ptr
, len
);
7645 return native_interpret_vector (type
, ptr
, len
);
7652 /* Returns true if we can interpret the contents of a native encoding
7656 can_native_interpret_type_p (tree type
)
7658 switch (TREE_CODE (type
))
7664 case REFERENCE_TYPE
:
7665 case FIXED_POINT_TYPE
:
7675 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7676 TYPE at compile-time. If we're unable to perform the conversion
7677 return NULL_TREE. */
7680 fold_view_convert_expr (tree type
, tree expr
)
7682 /* We support up to 512-bit values (for V8DFmode). */
7683 unsigned char buffer
[64];
7686 /* Check that the host and target are sane. */
7687 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
7690 len
= native_encode_expr (expr
, buffer
, sizeof (buffer
));
7694 return native_interpret_expr (type
, buffer
, len
);
7697 /* Build an expression for the address of T. Folds away INDIRECT_REF
7698 to avoid confusing the gimplify process. */
7701 build_fold_addr_expr_with_type_loc (location_t loc
, tree t
, tree ptrtype
)
7703 /* The size of the object is not relevant when talking about its address. */
7704 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
7705 t
= TREE_OPERAND (t
, 0);
7707 if (TREE_CODE (t
) == INDIRECT_REF
)
7709 t
= TREE_OPERAND (t
, 0);
7711 if (TREE_TYPE (t
) != ptrtype
)
7712 t
= build1_loc (loc
, NOP_EXPR
, ptrtype
, t
);
7714 else if (TREE_CODE (t
) == MEM_REF
7715 && integer_zerop (TREE_OPERAND (t
, 1)))
7716 return TREE_OPERAND (t
, 0);
7717 else if (TREE_CODE (t
) == MEM_REF
7718 && TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
7719 return fold_binary (POINTER_PLUS_EXPR
, ptrtype
,
7720 TREE_OPERAND (t
, 0),
7721 convert_to_ptrofftype (TREE_OPERAND (t
, 1)));
7722 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
7724 t
= build_fold_addr_expr_loc (loc
, TREE_OPERAND (t
, 0));
7726 if (TREE_TYPE (t
) != ptrtype
)
7727 t
= fold_convert_loc (loc
, ptrtype
, t
);
7730 t
= build1_loc (loc
, ADDR_EXPR
, ptrtype
, t
);
7735 /* Build an expression for the address of T. */
7738 build_fold_addr_expr_loc (location_t loc
, tree t
)
7740 tree ptrtype
= build_pointer_type (TREE_TYPE (t
));
7742 return build_fold_addr_expr_with_type_loc (loc
, t
, ptrtype
);
7745 static bool vec_cst_ctor_to_array (tree
, tree
*);
7747 /* Fold a unary expression of code CODE and type TYPE with operand
7748 OP0. Return the folded expression if folding is successful.
7749 Otherwise, return NULL_TREE. */
7752 fold_unary_loc (location_t loc
, enum tree_code code
, tree type
, tree op0
)
7756 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
7758 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
7759 && TREE_CODE_LENGTH (code
) == 1);
7764 if (CONVERT_EXPR_CODE_P (code
)
7765 || code
== FLOAT_EXPR
|| code
== ABS_EXPR
|| code
== NEGATE_EXPR
)
7767 /* Don't use STRIP_NOPS, because signedness of argument type
7769 STRIP_SIGN_NOPS (arg0
);
7773 /* Strip any conversions that don't change the mode. This
7774 is safe for every expression, except for a comparison
7775 expression because its signedness is derived from its
7778 Note that this is done as an internal manipulation within
7779 the constant folder, in order to find the simplest
7780 representation of the arguments so that their form can be
7781 studied. In any cases, the appropriate type conversions
7782 should be put back in the tree that will get out of the
7788 if (TREE_CODE_CLASS (code
) == tcc_unary
)
7790 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
7791 return build2 (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7792 fold_build1_loc (loc
, code
, type
,
7793 fold_convert_loc (loc
, TREE_TYPE (op0
),
7794 TREE_OPERAND (arg0
, 1))));
7795 else if (TREE_CODE (arg0
) == COND_EXPR
)
7797 tree arg01
= TREE_OPERAND (arg0
, 1);
7798 tree arg02
= TREE_OPERAND (arg0
, 2);
7799 if (! VOID_TYPE_P (TREE_TYPE (arg01
)))
7800 arg01
= fold_build1_loc (loc
, code
, type
,
7801 fold_convert_loc (loc
,
7802 TREE_TYPE (op0
), arg01
));
7803 if (! VOID_TYPE_P (TREE_TYPE (arg02
)))
7804 arg02
= fold_build1_loc (loc
, code
, type
,
7805 fold_convert_loc (loc
,
7806 TREE_TYPE (op0
), arg02
));
7807 tem
= fold_build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7810 /* If this was a conversion, and all we did was to move into
7811 inside the COND_EXPR, bring it back out. But leave it if
7812 it is a conversion from integer to integer and the
7813 result precision is no wider than a word since such a
7814 conversion is cheap and may be optimized away by combine,
7815 while it couldn't if it were outside the COND_EXPR. Then return
7816 so we don't get into an infinite recursion loop taking the
7817 conversion out and then back in. */
7819 if ((CONVERT_EXPR_CODE_P (code
)
7820 || code
== NON_LVALUE_EXPR
)
7821 && TREE_CODE (tem
) == COND_EXPR
7822 && TREE_CODE (TREE_OPERAND (tem
, 1)) == code
7823 && TREE_CODE (TREE_OPERAND (tem
, 2)) == code
7824 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 1))
7825 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 2))
7826 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))
7827 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 2), 0)))
7828 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7830 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))))
7831 && TYPE_PRECISION (TREE_TYPE (tem
)) <= BITS_PER_WORD
)
7832 || flag_syntax_only
))
7833 tem
= build1_loc (loc
, code
, type
,
7835 TREE_TYPE (TREE_OPERAND
7836 (TREE_OPERAND (tem
, 1), 0)),
7837 TREE_OPERAND (tem
, 0),
7838 TREE_OPERAND (TREE_OPERAND (tem
, 1), 0),
7839 TREE_OPERAND (TREE_OPERAND (tem
, 2),
7848 /* Re-association barriers around constants and other re-association
7849 barriers can be removed. */
7850 if (CONSTANT_CLASS_P (op0
)
7851 || TREE_CODE (op0
) == PAREN_EXPR
)
7852 return fold_convert_loc (loc
, type
, op0
);
7855 case NON_LVALUE_EXPR
:
7856 if (!maybe_lvalue_p (op0
))
7857 return fold_convert_loc (loc
, type
, op0
);
7862 case FIX_TRUNC_EXPR
:
7863 if (TREE_TYPE (op0
) == type
)
7866 if (COMPARISON_CLASS_P (op0
))
7868 /* If we have (type) (a CMP b) and type is an integral type, return
7869 new expression involving the new type. Canonicalize
7870 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7872 Do not fold the result as that would not simplify further, also
7873 folding again results in recursions. */
7874 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
7875 return build2_loc (loc
, TREE_CODE (op0
), type
,
7876 TREE_OPERAND (op0
, 0),
7877 TREE_OPERAND (op0
, 1));
7878 else if (!INTEGRAL_TYPE_P (type
) && !VOID_TYPE_P (type
)
7879 && TREE_CODE (type
) != VECTOR_TYPE
)
7880 return build3_loc (loc
, COND_EXPR
, type
, op0
,
7881 constant_boolean_node (true, type
),
7882 constant_boolean_node (false, type
));
7885 /* Handle cases of two conversions in a row. */
7886 if (CONVERT_EXPR_P (op0
))
7888 tree inside_type
= TREE_TYPE (TREE_OPERAND (op0
, 0));
7889 tree inter_type
= TREE_TYPE (op0
);
7890 int inside_int
= INTEGRAL_TYPE_P (inside_type
);
7891 int inside_ptr
= POINTER_TYPE_P (inside_type
);
7892 int inside_float
= FLOAT_TYPE_P (inside_type
);
7893 int inside_vec
= TREE_CODE (inside_type
) == VECTOR_TYPE
;
7894 unsigned int inside_prec
= TYPE_PRECISION (inside_type
);
7895 int inside_unsignedp
= TYPE_UNSIGNED (inside_type
);
7896 int inter_int
= INTEGRAL_TYPE_P (inter_type
);
7897 int inter_ptr
= POINTER_TYPE_P (inter_type
);
7898 int inter_float
= FLOAT_TYPE_P (inter_type
);
7899 int inter_vec
= TREE_CODE (inter_type
) == VECTOR_TYPE
;
7900 unsigned int inter_prec
= TYPE_PRECISION (inter_type
);
7901 int inter_unsignedp
= TYPE_UNSIGNED (inter_type
);
7902 int final_int
= INTEGRAL_TYPE_P (type
);
7903 int final_ptr
= POINTER_TYPE_P (type
);
7904 int final_float
= FLOAT_TYPE_P (type
);
7905 int final_vec
= TREE_CODE (type
) == VECTOR_TYPE
;
7906 unsigned int final_prec
= TYPE_PRECISION (type
);
7907 int final_unsignedp
= TYPE_UNSIGNED (type
);
7909 /* In addition to the cases of two conversions in a row
7910 handled below, if we are converting something to its own
7911 type via an object of identical or wider precision, neither
7912 conversion is needed. */
7913 if (TYPE_MAIN_VARIANT (inside_type
) == TYPE_MAIN_VARIANT (type
)
7914 && (((inter_int
|| inter_ptr
) && final_int
)
7915 || (inter_float
&& final_float
))
7916 && inter_prec
>= final_prec
)
7917 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7919 /* Likewise, if the intermediate and initial types are either both
7920 float or both integer, we don't need the middle conversion if the
7921 former is wider than the latter and doesn't change the signedness
7922 (for integers). Avoid this if the final type is a pointer since
7923 then we sometimes need the middle conversion. Likewise if the
7924 final type has a precision not equal to the size of its mode. */
7925 if (((inter_int
&& inside_int
)
7926 || (inter_float
&& inside_float
)
7927 || (inter_vec
&& inside_vec
))
7928 && inter_prec
>= inside_prec
7929 && (inter_float
|| inter_vec
7930 || inter_unsignedp
== inside_unsignedp
)
7931 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
7932 && TYPE_MODE (type
) == TYPE_MODE (inter_type
))
7934 && (! final_vec
|| inter_prec
== inside_prec
))
7935 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7937 /* If we have a sign-extension of a zero-extended value, we can
7938 replace that by a single zero-extension. Likewise if the
7939 final conversion does not change precision we can drop the
7940 intermediate conversion. */
7941 if (inside_int
&& inter_int
&& final_int
7942 && ((inside_prec
< inter_prec
&& inter_prec
< final_prec
7943 && inside_unsignedp
&& !inter_unsignedp
)
7944 || final_prec
== inter_prec
))
7945 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7947 /* Two conversions in a row are not needed unless:
7948 - some conversion is floating-point (overstrict for now), or
7949 - some conversion is a vector (overstrict for now), or
7950 - the intermediate type is narrower than both initial and
7952 - the intermediate type and innermost type differ in signedness,
7953 and the outermost type is wider than the intermediate, or
7954 - the initial type is a pointer type and the precisions of the
7955 intermediate and final types differ, or
7956 - the final type is a pointer type and the precisions of the
7957 initial and intermediate types differ. */
7958 if (! inside_float
&& ! inter_float
&& ! final_float
7959 && ! inside_vec
&& ! inter_vec
&& ! final_vec
7960 && (inter_prec
>= inside_prec
|| inter_prec
>= final_prec
)
7961 && ! (inside_int
&& inter_int
7962 && inter_unsignedp
!= inside_unsignedp
7963 && inter_prec
< final_prec
)
7964 && ((inter_unsignedp
&& inter_prec
> inside_prec
)
7965 == (final_unsignedp
&& final_prec
> inter_prec
))
7966 && ! (inside_ptr
&& inter_prec
!= final_prec
)
7967 && ! (final_ptr
&& inside_prec
!= inter_prec
)
7968 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
7969 && TYPE_MODE (type
) == TYPE_MODE (inter_type
)))
7970 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7973 /* Handle (T *)&A.B.C for A being of type T and B and C
7974 living at offset zero. This occurs frequently in
7975 C++ upcasting and then accessing the base. */
7976 if (TREE_CODE (op0
) == ADDR_EXPR
7977 && POINTER_TYPE_P (type
)
7978 && handled_component_p (TREE_OPERAND (op0
, 0)))
7980 HOST_WIDE_INT bitsize
, bitpos
;
7982 enum machine_mode mode
;
7983 int unsignedp
, volatilep
;
7984 tree base
= TREE_OPERAND (op0
, 0);
7985 base
= get_inner_reference (base
, &bitsize
, &bitpos
, &offset
,
7986 &mode
, &unsignedp
, &volatilep
, false);
7987 /* If the reference was to a (constant) zero offset, we can use
7988 the address of the base if it has the same base type
7989 as the result type and the pointer type is unqualified. */
7990 if (! offset
&& bitpos
== 0
7991 && (TYPE_MAIN_VARIANT (TREE_TYPE (type
))
7992 == TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
7993 && TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
7994 return fold_convert_loc (loc
, type
,
7995 build_fold_addr_expr_loc (loc
, base
));
7998 if (TREE_CODE (op0
) == MODIFY_EXPR
7999 && TREE_CONSTANT (TREE_OPERAND (op0
, 1))
8000 /* Detect assigning a bitfield. */
8001 && !(TREE_CODE (TREE_OPERAND (op0
, 0)) == COMPONENT_REF
8003 (TREE_OPERAND (TREE_OPERAND (op0
, 0), 1))))
8005 /* Don't leave an assignment inside a conversion
8006 unless assigning a bitfield. */
8007 tem
= fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 1));
8008 /* First do the assignment, then return converted constant. */
8009 tem
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (tem
), op0
, tem
);
8010 TREE_NO_WARNING (tem
) = 1;
8011 TREE_USED (tem
) = 1;
8015 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
8016 constants (if x has signed type, the sign bit cannot be set
8017 in c). This folds extension into the BIT_AND_EXPR.
8018 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
8019 very likely don't have maximal range for their precision and this
8020 transformation effectively doesn't preserve non-maximal ranges. */
8021 if (TREE_CODE (type
) == INTEGER_TYPE
8022 && TREE_CODE (op0
) == BIT_AND_EXPR
8023 && TREE_CODE (TREE_OPERAND (op0
, 1)) == INTEGER_CST
)
8025 tree and_expr
= op0
;
8026 tree and0
= TREE_OPERAND (and_expr
, 0);
8027 tree and1
= TREE_OPERAND (and_expr
, 1);
8030 if (TYPE_UNSIGNED (TREE_TYPE (and_expr
))
8031 || (TYPE_PRECISION (type
)
8032 <= TYPE_PRECISION (TREE_TYPE (and_expr
))))
8034 else if (TYPE_PRECISION (TREE_TYPE (and1
))
8035 <= HOST_BITS_PER_WIDE_INT
8036 && tree_fits_uhwi_p (and1
))
8038 unsigned HOST_WIDE_INT cst
;
8040 cst
= tree_to_uhwi (and1
);
8041 cst
&= HOST_WIDE_INT_M1U
8042 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
8043 change
= (cst
== 0);
8044 #ifdef LOAD_EXTEND_OP
8046 && !flag_syntax_only
8047 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0
)))
8050 tree uns
= unsigned_type_for (TREE_TYPE (and0
));
8051 and0
= fold_convert_loc (loc
, uns
, and0
);
8052 and1
= fold_convert_loc (loc
, uns
, and1
);
8058 tem
= force_fit_type (type
, wi::to_widest (and1
), 0,
8059 TREE_OVERFLOW (and1
));
8060 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
8061 fold_convert_loc (loc
, type
, and0
), tem
);
8065 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
8066 when one of the new casts will fold away. Conservatively we assume
8067 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
8068 if (POINTER_TYPE_P (type
)
8069 && TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8070 && (!TYPE_RESTRICT (type
) || TYPE_RESTRICT (TREE_TYPE (arg0
)))
8071 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8072 || TREE_CODE (TREE_OPERAND (arg0
, 0)) == NOP_EXPR
8073 || TREE_CODE (TREE_OPERAND (arg0
, 1)) == NOP_EXPR
))
8075 tree arg00
= TREE_OPERAND (arg0
, 0);
8076 tree arg01
= TREE_OPERAND (arg0
, 1);
8078 return fold_build_pointer_plus_loc
8079 (loc
, fold_convert_loc (loc
, type
, arg00
), arg01
);
8082 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
8083 of the same precision, and X is an integer type not narrower than
8084 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
8085 if (INTEGRAL_TYPE_P (type
)
8086 && TREE_CODE (op0
) == BIT_NOT_EXPR
8087 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
8088 && CONVERT_EXPR_P (TREE_OPERAND (op0
, 0))
8089 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
8091 tem
= TREE_OPERAND (TREE_OPERAND (op0
, 0), 0);
8092 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
8093 && TYPE_PRECISION (type
) <= TYPE_PRECISION (TREE_TYPE (tem
)))
8094 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
8095 fold_convert_loc (loc
, type
, tem
));
8098 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
8099 type of X and Y (integer types only). */
8100 if (INTEGRAL_TYPE_P (type
)
8101 && TREE_CODE (op0
) == MULT_EXPR
8102 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
8103 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
8105 /* Be careful not to introduce new overflows. */
8107 if (TYPE_OVERFLOW_WRAPS (type
))
8110 mult_type
= unsigned_type_for (type
);
8112 if (TYPE_PRECISION (mult_type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
8114 tem
= fold_build2_loc (loc
, MULT_EXPR
, mult_type
,
8115 fold_convert_loc (loc
, mult_type
,
8116 TREE_OPERAND (op0
, 0)),
8117 fold_convert_loc (loc
, mult_type
,
8118 TREE_OPERAND (op0
, 1)));
8119 return fold_convert_loc (loc
, type
, tem
);
8123 tem
= fold_convert_const (code
, type
, arg0
);
8124 return tem
? tem
: NULL_TREE
;
8126 case ADDR_SPACE_CONVERT_EXPR
:
8127 if (integer_zerop (arg0
))
8128 return fold_convert_const (code
, type
, arg0
);
8131 case FIXED_CONVERT_EXPR
:
8132 tem
= fold_convert_const (code
, type
, arg0
);
8133 return tem
? tem
: NULL_TREE
;
8135 case VIEW_CONVERT_EXPR
:
8136 if (TREE_TYPE (op0
) == type
)
8138 if (TREE_CODE (op0
) == VIEW_CONVERT_EXPR
)
8139 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
,
8140 type
, TREE_OPERAND (op0
, 0));
8141 if (TREE_CODE (op0
) == MEM_REF
)
8142 return fold_build2_loc (loc
, MEM_REF
, type
,
8143 TREE_OPERAND (op0
, 0), TREE_OPERAND (op0
, 1));
8145 /* For integral conversions with the same precision or pointer
8146 conversions use a NOP_EXPR instead. */
8147 if ((INTEGRAL_TYPE_P (type
)
8148 || POINTER_TYPE_P (type
))
8149 && (INTEGRAL_TYPE_P (TREE_TYPE (op0
))
8150 || POINTER_TYPE_P (TREE_TYPE (op0
)))
8151 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
8152 return fold_convert_loc (loc
, type
, op0
);
8154 /* Strip inner integral conversions that do not change the precision. */
8155 if (CONVERT_EXPR_P (op0
)
8156 && (INTEGRAL_TYPE_P (TREE_TYPE (op0
))
8157 || POINTER_TYPE_P (TREE_TYPE (op0
)))
8158 && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0
, 0)))
8159 || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0
, 0))))
8160 && (TYPE_PRECISION (TREE_TYPE (op0
))
8161 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))))
8162 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
,
8163 type
, TREE_OPERAND (op0
, 0));
8165 return fold_view_convert_expr (type
, op0
);
8168 tem
= fold_negate_expr (loc
, arg0
);
8170 return fold_convert_loc (loc
, type
, tem
);
8174 if (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
)
8175 return fold_abs_const (arg0
, type
);
8176 else if (TREE_CODE (arg0
) == NEGATE_EXPR
)
8177 return fold_build1_loc (loc
, ABS_EXPR
, type
, TREE_OPERAND (arg0
, 0));
8178 /* Convert fabs((double)float) into (double)fabsf(float). */
8179 else if (TREE_CODE (arg0
) == NOP_EXPR
8180 && TREE_CODE (type
) == REAL_TYPE
)
8182 tree targ0
= strip_float_extensions (arg0
);
8184 return fold_convert_loc (loc
, type
,
8185 fold_build1_loc (loc
, ABS_EXPR
,
8189 /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on. */
8190 else if (TREE_CODE (arg0
) == ABS_EXPR
)
8192 else if (tree_expr_nonnegative_p (arg0
))
8195 /* Strip sign ops from argument. */
8196 if (TREE_CODE (type
) == REAL_TYPE
)
8198 tem
= fold_strip_sign_ops (arg0
);
8200 return fold_build1_loc (loc
, ABS_EXPR
, type
,
8201 fold_convert_loc (loc
, type
, tem
));
8206 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8207 return fold_convert_loc (loc
, type
, arg0
);
8208 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8210 tree itype
= TREE_TYPE (type
);
8211 tree rpart
= fold_convert_loc (loc
, itype
, TREE_OPERAND (arg0
, 0));
8212 tree ipart
= fold_convert_loc (loc
, itype
, TREE_OPERAND (arg0
, 1));
8213 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
,
8214 negate_expr (ipart
));
8216 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8218 tree itype
= TREE_TYPE (type
);
8219 tree rpart
= fold_convert_loc (loc
, itype
, TREE_REALPART (arg0
));
8220 tree ipart
= fold_convert_loc (loc
, itype
, TREE_IMAGPART (arg0
));
8221 return build_complex (type
, rpart
, negate_expr (ipart
));
8223 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8224 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
8228 if (TREE_CODE (arg0
) == INTEGER_CST
)
8229 return fold_not_const (arg0
, type
);
8230 else if (TREE_CODE (arg0
) == BIT_NOT_EXPR
)
8231 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
8232 /* Convert ~ (-A) to A - 1. */
8233 else if (INTEGRAL_TYPE_P (type
) && TREE_CODE (arg0
) == NEGATE_EXPR
)
8234 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
8235 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0)),
8236 build_int_cst (type
, 1));
8237 /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
8238 else if (INTEGRAL_TYPE_P (type
)
8239 && ((TREE_CODE (arg0
) == MINUS_EXPR
8240 && integer_onep (TREE_OPERAND (arg0
, 1)))
8241 || (TREE_CODE (arg0
) == PLUS_EXPR
8242 && integer_all_onesp (TREE_OPERAND (arg0
, 1)))))
8243 return fold_build1_loc (loc
, NEGATE_EXPR
, type
,
8244 fold_convert_loc (loc
, type
,
8245 TREE_OPERAND (arg0
, 0)));
8246 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8247 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8248 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8249 fold_convert_loc (loc
, type
,
8250 TREE_OPERAND (arg0
, 0)))))
8251 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, tem
,
8252 fold_convert_loc (loc
, type
,
8253 TREE_OPERAND (arg0
, 1)));
8254 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8255 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8256 fold_convert_loc (loc
, type
,
8257 TREE_OPERAND (arg0
, 1)))))
8258 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
8259 fold_convert_loc (loc
, type
,
8260 TREE_OPERAND (arg0
, 0)), tem
);
8261 /* Perform BIT_NOT_EXPR on each element individually. */
8262 else if (TREE_CODE (arg0
) == VECTOR_CST
)
8266 unsigned count
= VECTOR_CST_NELTS (arg0
), i
;
8268 elements
= XALLOCAVEC (tree
, count
);
8269 for (i
= 0; i
< count
; i
++)
8271 elem
= VECTOR_CST_ELT (arg0
, i
);
8272 elem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (type
), elem
);
8273 if (elem
== NULL_TREE
)
8278 return build_vector (type
, elements
);
8280 else if (COMPARISON_CLASS_P (arg0
)
8281 && (VECTOR_TYPE_P (type
)
8282 || (INTEGRAL_TYPE_P (type
) && TYPE_PRECISION (type
) == 1)))
8284 tree op_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
8285 enum tree_code subcode
= invert_tree_comparison (TREE_CODE (arg0
),
8286 HONOR_NANS (TYPE_MODE (op_type
)));
8287 if (subcode
!= ERROR_MARK
)
8288 return build2_loc (loc
, subcode
, type
, TREE_OPERAND (arg0
, 0),
8289 TREE_OPERAND (arg0
, 1));
8295 case TRUTH_NOT_EXPR
:
8296 /* Note that the operand of this must be an int
8297 and its values must be 0 or 1.
8298 ("true" is a fixed value perhaps depending on the language,
8299 but we don't handle values other than 1 correctly yet.) */
8300 tem
= fold_truth_not_expr (loc
, arg0
);
8303 return fold_convert_loc (loc
, type
, tem
);
8306 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8307 return fold_convert_loc (loc
, type
, arg0
);
8308 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8309 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 0),
8310 TREE_OPERAND (arg0
, 1));
8311 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8312 return fold_convert_loc (loc
, type
, TREE_REALPART (arg0
));
8313 if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8315 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8316 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), itype
,
8317 fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8318 TREE_OPERAND (arg0
, 0)),
8319 fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8320 TREE_OPERAND (arg0
, 1)));
8321 return fold_convert_loc (loc
, type
, tem
);
8323 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8325 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8326 tem
= fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8327 TREE_OPERAND (arg0
, 0));
8328 return fold_convert_loc (loc
, type
, tem
);
8330 if (TREE_CODE (arg0
) == CALL_EXPR
)
8332 tree fn
= get_callee_fndecl (arg0
);
8333 if (fn
&& DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
8334 switch (DECL_FUNCTION_CODE (fn
))
8336 CASE_FLT_FN (BUILT_IN_CEXPI
):
8337 fn
= mathfn_built_in (type
, BUILT_IN_COS
);
8339 return build_call_expr_loc (loc
, fn
, 1, CALL_EXPR_ARG (arg0
, 0));
8349 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8350 return build_zero_cst (type
);
8351 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8352 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 1),
8353 TREE_OPERAND (arg0
, 0));
8354 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8355 return fold_convert_loc (loc
, type
, TREE_IMAGPART (arg0
));
8356 if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8358 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8359 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), itype
,
8360 fold_build1_loc (loc
, IMAGPART_EXPR
, itype
,
8361 TREE_OPERAND (arg0
, 0)),
8362 fold_build1_loc (loc
, IMAGPART_EXPR
, itype
,
8363 TREE_OPERAND (arg0
, 1)));
8364 return fold_convert_loc (loc
, type
, tem
);
8366 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8368 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8369 tem
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, TREE_OPERAND (arg0
, 0));
8370 return fold_convert_loc (loc
, type
, negate_expr (tem
));
8372 if (TREE_CODE (arg0
) == CALL_EXPR
)
8374 tree fn
= get_callee_fndecl (arg0
);
8375 if (fn
&& DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
8376 switch (DECL_FUNCTION_CODE (fn
))
8378 CASE_FLT_FN (BUILT_IN_CEXPI
):
8379 fn
= mathfn_built_in (type
, BUILT_IN_SIN
);
8381 return build_call_expr_loc (loc
, fn
, 1, CALL_EXPR_ARG (arg0
, 0));
8391 /* Fold *&X to X if X is an lvalue. */
8392 if (TREE_CODE (op0
) == ADDR_EXPR
)
8394 tree op00
= TREE_OPERAND (op0
, 0);
8395 if ((TREE_CODE (op00
) == VAR_DECL
8396 || TREE_CODE (op00
) == PARM_DECL
8397 || TREE_CODE (op00
) == RESULT_DECL
)
8398 && !TREE_READONLY (op00
))
8403 case VEC_UNPACK_LO_EXPR
:
8404 case VEC_UNPACK_HI_EXPR
:
8405 case VEC_UNPACK_FLOAT_LO_EXPR
:
8406 case VEC_UNPACK_FLOAT_HI_EXPR
:
8408 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8410 enum tree_code subcode
;
8412 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2);
8413 if (TREE_CODE (arg0
) != VECTOR_CST
)
8416 elts
= XALLOCAVEC (tree
, nelts
* 2);
8417 if (!vec_cst_ctor_to_array (arg0
, elts
))
8420 if ((!BYTES_BIG_ENDIAN
) ^ (code
== VEC_UNPACK_LO_EXPR
8421 || code
== VEC_UNPACK_FLOAT_LO_EXPR
))
8424 if (code
== VEC_UNPACK_LO_EXPR
|| code
== VEC_UNPACK_HI_EXPR
)
8427 subcode
= FLOAT_EXPR
;
8429 for (i
= 0; i
< nelts
; i
++)
8431 elts
[i
] = fold_convert_const (subcode
, TREE_TYPE (type
), elts
[i
]);
8432 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
8436 return build_vector (type
, elts
);
8439 case REDUC_MIN_EXPR
:
8440 case REDUC_MAX_EXPR
:
8441 case REDUC_PLUS_EXPR
:
8443 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8445 enum tree_code subcode
;
8447 if (TREE_CODE (op0
) != VECTOR_CST
)
8450 elts
= XALLOCAVEC (tree
, nelts
);
8451 if (!vec_cst_ctor_to_array (op0
, elts
))
8456 case REDUC_MIN_EXPR
: subcode
= MIN_EXPR
; break;
8457 case REDUC_MAX_EXPR
: subcode
= MAX_EXPR
; break;
8458 case REDUC_PLUS_EXPR
: subcode
= PLUS_EXPR
; break;
8459 default: gcc_unreachable ();
8462 for (i
= 1; i
< nelts
; i
++)
8464 elts
[0] = const_binop (subcode
, elts
[0], elts
[i
]);
8465 if (elts
[0] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[0]))
8467 elts
[i
] = build_zero_cst (TREE_TYPE (type
));
8470 return build_vector (type
, elts
);
8475 } /* switch (code) */
8479 /* If the operation was a conversion do _not_ mark a resulting constant
8480 with TREE_OVERFLOW if the original constant was not. These conversions
8481 have implementation defined behavior and retaining the TREE_OVERFLOW
8482 flag here would confuse later passes such as VRP. */
8484 fold_unary_ignore_overflow_loc (location_t loc
, enum tree_code code
,
8485 tree type
, tree op0
)
8487 tree res
= fold_unary_loc (loc
, code
, type
, op0
);
8489 && TREE_CODE (res
) == INTEGER_CST
8490 && TREE_CODE (op0
) == INTEGER_CST
8491 && CONVERT_EXPR_CODE_P (code
))
8492 TREE_OVERFLOW (res
) = TREE_OVERFLOW (op0
);
8497 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8498 operands OP0 and OP1. LOC is the location of the resulting expression.
8499 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8500 Return the folded expression if folding is successful. Otherwise,
8501 return NULL_TREE. */
8503 fold_truth_andor (location_t loc
, enum tree_code code
, tree type
,
8504 tree arg0
, tree arg1
, tree op0
, tree op1
)
8508 /* We only do these simplifications if we are optimizing. */
8512 /* Check for things like (A || B) && (A || C). We can convert this
8513 to A || (B && C). Note that either operator can be any of the four
8514 truth and/or operations and the transformation will still be
8515 valid. Also note that we only care about order for the
8516 ANDIF and ORIF operators. If B contains side effects, this
8517 might change the truth-value of A. */
8518 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8519 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
8520 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
8521 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
8522 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
8523 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
8525 tree a00
= TREE_OPERAND (arg0
, 0);
8526 tree a01
= TREE_OPERAND (arg0
, 1);
8527 tree a10
= TREE_OPERAND (arg1
, 0);
8528 tree a11
= TREE_OPERAND (arg1
, 1);
8529 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
8530 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
8531 && (code
== TRUTH_AND_EXPR
8532 || code
== TRUTH_OR_EXPR
));
8534 if (operand_equal_p (a00
, a10
, 0))
8535 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8536 fold_build2_loc (loc
, code
, type
, a01
, a11
));
8537 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
8538 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8539 fold_build2_loc (loc
, code
, type
, a01
, a10
));
8540 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
8541 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a01
,
8542 fold_build2_loc (loc
, code
, type
, a00
, a11
));
8544 /* This case if tricky because we must either have commutative
8545 operators or else A10 must not have side-effects. */
8547 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
8548 && operand_equal_p (a01
, a11
, 0))
8549 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
8550 fold_build2_loc (loc
, code
, type
, a00
, a10
),
8554 /* See if we can build a range comparison. */
8555 if (0 != (tem
= fold_range_test (loc
, code
, type
, op0
, op1
)))
8558 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
)
8559 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
))
8561 tem
= merge_truthop_with_opposite_arm (loc
, arg0
, arg1
, true);
8563 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
8566 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ORIF_EXPR
)
8567 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ANDIF_EXPR
))
8569 tem
= merge_truthop_with_opposite_arm (loc
, arg1
, arg0
, false);
8571 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
8574 /* Check for the possibility of merging component references. If our
8575 lhs is another similar operation, try to merge its rhs with our
8576 rhs. Then try to merge our lhs and rhs. */
8577 if (TREE_CODE (arg0
) == code
8578 && 0 != (tem
= fold_truth_andor_1 (loc
, code
, type
,
8579 TREE_OPERAND (arg0
, 1), arg1
)))
8580 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
8582 if ((tem
= fold_truth_andor_1 (loc
, code
, type
, arg0
, arg1
)) != 0)
8585 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8586 && (code
== TRUTH_AND_EXPR
8587 || code
== TRUTH_ANDIF_EXPR
8588 || code
== TRUTH_OR_EXPR
8589 || code
== TRUTH_ORIF_EXPR
))
8591 enum tree_code ncode
, icode
;
8593 ncode
= (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_AND_EXPR
)
8594 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
;
8595 icode
= ncode
== TRUTH_AND_EXPR
? TRUTH_ANDIF_EXPR
: TRUTH_ORIF_EXPR
;
8597 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8598 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8599 We don't want to pack more than two leafs to a non-IF AND/OR
8601 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8602 equal to IF-CODE, then we don't want to add right-hand operand.
8603 If the inner right-hand side of left-hand operand has
8604 side-effects, or isn't simple, then we can't add to it,
8605 as otherwise we might destroy if-sequence. */
8606 if (TREE_CODE (arg0
) == icode
8607 && simple_operand_p_2 (arg1
)
8608 /* Needed for sequence points to handle trappings, and
8610 && simple_operand_p_2 (TREE_OPERAND (arg0
, 1)))
8612 tem
= fold_build2_loc (loc
, ncode
, type
, TREE_OPERAND (arg0
, 1),
8614 return fold_build2_loc (loc
, icode
, type
, TREE_OPERAND (arg0
, 0),
8617 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8618 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8619 else if (TREE_CODE (arg1
) == icode
8620 && simple_operand_p_2 (arg0
)
8621 /* Needed for sequence points to handle trappings, and
8623 && simple_operand_p_2 (TREE_OPERAND (arg1
, 0)))
8625 tem
= fold_build2_loc (loc
, ncode
, type
,
8626 arg0
, TREE_OPERAND (arg1
, 0));
8627 return fold_build2_loc (loc
, icode
, type
, tem
,
8628 TREE_OPERAND (arg1
, 1));
8630 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8632 For sequence point consistancy, we need to check for trapping,
8633 and side-effects. */
8634 else if (code
== icode
&& simple_operand_p_2 (arg0
)
8635 && simple_operand_p_2 (arg1
))
8636 return fold_build2_loc (loc
, ncode
, type
, arg0
, arg1
);
8642 /* Fold a binary expression of code CODE and type TYPE with operands
8643 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8644 Return the folded expression if folding is successful. Otherwise,
8645 return NULL_TREE. */
8648 fold_minmax (location_t loc
, enum tree_code code
, tree type
, tree op0
, tree op1
)
8650 enum tree_code compl_code
;
8652 if (code
== MIN_EXPR
)
8653 compl_code
= MAX_EXPR
;
8654 else if (code
== MAX_EXPR
)
8655 compl_code
= MIN_EXPR
;
8659 /* MIN (MAX (a, b), b) == b. */
8660 if (TREE_CODE (op0
) == compl_code
8661 && operand_equal_p (TREE_OPERAND (op0
, 1), op1
, 0))
8662 return omit_one_operand_loc (loc
, type
, op1
, TREE_OPERAND (op0
, 0));
8664 /* MIN (MAX (b, a), b) == b. */
8665 if (TREE_CODE (op0
) == compl_code
8666 && operand_equal_p (TREE_OPERAND (op0
, 0), op1
, 0)
8667 && reorder_operands_p (TREE_OPERAND (op0
, 1), op1
))
8668 return omit_one_operand_loc (loc
, type
, op1
, TREE_OPERAND (op0
, 1));
8670 /* MIN (a, MAX (a, b)) == a. */
8671 if (TREE_CODE (op1
) == compl_code
8672 && operand_equal_p (op0
, TREE_OPERAND (op1
, 0), 0)
8673 && reorder_operands_p (op0
, TREE_OPERAND (op1
, 1)))
8674 return omit_one_operand_loc (loc
, type
, op0
, TREE_OPERAND (op1
, 1));
8676 /* MIN (a, MAX (b, a)) == a. */
8677 if (TREE_CODE (op1
) == compl_code
8678 && operand_equal_p (op0
, TREE_OPERAND (op1
, 1), 0)
8679 && reorder_operands_p (op0
, TREE_OPERAND (op1
, 0)))
8680 return omit_one_operand_loc (loc
, type
, op0
, TREE_OPERAND (op1
, 0));
8685 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8686 by changing CODE to reduce the magnitude of constants involved in
8687 ARG0 of the comparison.
8688 Returns a canonicalized comparison tree if a simplification was
8689 possible, otherwise returns NULL_TREE.
8690 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8691 valid if signed overflow is undefined. */
8694 maybe_canonicalize_comparison_1 (location_t loc
, enum tree_code code
, tree type
,
8695 tree arg0
, tree arg1
,
8696 bool *strict_overflow_p
)
8698 enum tree_code code0
= TREE_CODE (arg0
);
8699 tree t
, cst0
= NULL_TREE
;
8703 /* Match A +- CST code arg1 and CST code arg1. We can change the
8704 first form only if overflow is undefined. */
8705 if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
8706 /* In principle pointers also have undefined overflow behavior,
8707 but that causes problems elsewhere. */
8708 && !POINTER_TYPE_P (TREE_TYPE (arg0
))
8709 && (code0
== MINUS_EXPR
8710 || code0
== PLUS_EXPR
)
8711 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
8712 || code0
== INTEGER_CST
))
8715 /* Identify the constant in arg0 and its sign. */
8716 if (code0
== INTEGER_CST
)
8719 cst0
= TREE_OPERAND (arg0
, 1);
8720 sgn0
= tree_int_cst_sgn (cst0
);
8722 /* Overflowed constants and zero will cause problems. */
8723 if (integer_zerop (cst0
)
8724 || TREE_OVERFLOW (cst0
))
8727 /* See if we can reduce the magnitude of the constant in
8728 arg0 by changing the comparison code. */
8729 if (code0
== INTEGER_CST
)
8731 /* CST <= arg1 -> CST-1 < arg1. */
8732 if (code
== LE_EXPR
&& sgn0
== 1)
8734 /* -CST < arg1 -> -CST-1 <= arg1. */
8735 else if (code
== LT_EXPR
&& sgn0
== -1)
8737 /* CST > arg1 -> CST-1 >= arg1. */
8738 else if (code
== GT_EXPR
&& sgn0
== 1)
8740 /* -CST >= arg1 -> -CST-1 > arg1. */
8741 else if (code
== GE_EXPR
&& sgn0
== -1)
8745 /* arg1 code' CST' might be more canonical. */
8750 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8752 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8754 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8755 else if (code
== GT_EXPR
8756 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8758 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8759 else if (code
== LE_EXPR
8760 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8762 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8763 else if (code
== GE_EXPR
8764 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8768 *strict_overflow_p
= true;
8771 /* Now build the constant reduced in magnitude. But not if that
8772 would produce one outside of its types range. */
8773 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0
))
8775 && TYPE_MIN_VALUE (TREE_TYPE (cst0
))
8776 && tree_int_cst_equal (cst0
, TYPE_MIN_VALUE (TREE_TYPE (cst0
))))
8778 && TYPE_MAX_VALUE (TREE_TYPE (cst0
))
8779 && tree_int_cst_equal (cst0
, TYPE_MAX_VALUE (TREE_TYPE (cst0
))))))
8780 /* We cannot swap the comparison here as that would cause us to
8781 endlessly recurse. */
8784 t
= int_const_binop (sgn0
== -1 ? PLUS_EXPR
: MINUS_EXPR
,
8785 cst0
, build_int_cst (TREE_TYPE (cst0
), 1));
8786 if (code0
!= INTEGER_CST
)
8787 t
= fold_build2_loc (loc
, code0
, TREE_TYPE (arg0
), TREE_OPERAND (arg0
, 0), t
);
8788 t
= fold_convert (TREE_TYPE (arg1
), t
);
8790 /* If swapping might yield to a more canonical form, do so. */
8792 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, arg1
, t
);
8794 return fold_build2_loc (loc
, code
, type
, t
, arg1
);
8797 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8798 overflow further. Try to decrease the magnitude of constants involved
8799 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8800 and put sole constants at the second argument position.
8801 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8804 maybe_canonicalize_comparison (location_t loc
, enum tree_code code
, tree type
,
8805 tree arg0
, tree arg1
)
8808 bool strict_overflow_p
;
8809 const char * const warnmsg
= G_("assuming signed overflow does not occur "
8810 "when reducing constant in comparison");
8812 /* Try canonicalization by simplifying arg0. */
8813 strict_overflow_p
= false;
8814 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg0
, arg1
,
8815 &strict_overflow_p
);
8818 if (strict_overflow_p
)
8819 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8823 /* Try canonicalization by simplifying arg1 using the swapped
8825 code
= swap_tree_comparison (code
);
8826 strict_overflow_p
= false;
8827 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg1
, arg0
,
8828 &strict_overflow_p
);
8829 if (t
&& strict_overflow_p
)
8830 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8834 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8835 space. This is used to avoid issuing overflow warnings for
8836 expressions like &p->x which can not wrap. */
8839 pointer_may_wrap_p (tree base
, tree offset
, HOST_WIDE_INT bitpos
)
8841 if (!POINTER_TYPE_P (TREE_TYPE (base
)))
8848 int precision
= TYPE_PRECISION (TREE_TYPE (base
));
8849 if (offset
== NULL_TREE
)
8850 wi_offset
= wi::zero (precision
);
8851 else if (TREE_CODE (offset
) != INTEGER_CST
|| TREE_OVERFLOW (offset
))
8857 wide_int units
= wi::shwi (bitpos
/ BITS_PER_UNIT
, precision
);
8858 wide_int total
= wi::add (wi_offset
, units
, UNSIGNED
, &overflow
);
8862 if (!wi::fits_uhwi_p (total
))
8865 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (TREE_TYPE (base
)));
8869 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8871 if (TREE_CODE (base
) == ADDR_EXPR
)
8873 HOST_WIDE_INT base_size
;
8875 base_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base
, 0)));
8876 if (base_size
> 0 && size
< base_size
)
8880 return total
.to_uhwi () > (unsigned HOST_WIDE_INT
) size
;
8883 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
8884 kind INTEGER_CST. This makes sure to properly sign-extend the
8887 static HOST_WIDE_INT
8888 size_low_cst (const_tree t
)
8890 HOST_WIDE_INT w
= TREE_INT_CST_ELT (t
, 0);
8891 int prec
= TYPE_PRECISION (TREE_TYPE (t
));
8892 if (prec
< HOST_BITS_PER_WIDE_INT
)
8893 return sext_hwi (w
, prec
);
8897 /* Subroutine of fold_binary. This routine performs all of the
8898 transformations that are common to the equality/inequality
8899 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8900 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8901 fold_binary should call fold_binary. Fold a comparison with
8902 tree code CODE and type TYPE with operands OP0 and OP1. Return
8903 the folded comparison or NULL_TREE. */
8906 fold_comparison (location_t loc
, enum tree_code code
, tree type
,
8909 const bool equality_code
= (code
== EQ_EXPR
|| code
== NE_EXPR
);
8910 tree arg0
, arg1
, tem
;
8915 STRIP_SIGN_NOPS (arg0
);
8916 STRIP_SIGN_NOPS (arg1
);
8918 tem
= fold_relational_const (code
, type
, arg0
, arg1
);
8919 if (tem
!= NULL_TREE
)
8922 /* If one arg is a real or integer constant, put it last. */
8923 if (tree_swap_operands_p (arg0
, arg1
, true))
8924 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
8926 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 -+ C1. */
8927 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8928 && (equality_code
|| TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8929 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8930 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
8931 && TREE_CODE (arg1
) == INTEGER_CST
8932 && !TREE_OVERFLOW (arg1
))
8934 const enum tree_code
8935 reverse_op
= TREE_CODE (arg0
) == PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
;
8936 tree const1
= TREE_OPERAND (arg0
, 1);
8937 tree const2
= fold_convert_loc (loc
, TREE_TYPE (const1
), arg1
);
8938 tree variable
= TREE_OPERAND (arg0
, 0);
8939 tree new_const
= int_const_binop (reverse_op
, const2
, const1
);
8941 /* If the constant operation overflowed this can be
8942 simplified as a comparison against INT_MAX/INT_MIN. */
8943 if (TREE_OVERFLOW (new_const
))
8945 int const1_sgn
= tree_int_cst_sgn (const1
);
8946 enum tree_code code2
= code
;
8948 /* Get the sign of the constant on the lhs if the
8949 operation were VARIABLE + CONST1. */
8950 if (TREE_CODE (arg0
) == MINUS_EXPR
)
8951 const1_sgn
= -const1_sgn
;
8953 /* The sign of the constant determines if we overflowed
8954 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8955 Canonicalize to the INT_MIN overflow by swapping the comparison
8957 if (const1_sgn
== -1)
8958 code2
= swap_tree_comparison (code
);
8960 /* We now can look at the canonicalized case
8961 VARIABLE + 1 CODE2 INT_MIN
8962 and decide on the result. */
8969 omit_one_operand_loc (loc
, type
, boolean_false_node
, variable
);
8975 omit_one_operand_loc (loc
, type
, boolean_true_node
, variable
);
8984 fold_overflow_warning ("assuming signed overflow does not occur "
8985 "when changing X +- C1 cmp C2 to "
8987 WARN_STRICT_OVERFLOW_COMPARISON
);
8988 return fold_build2_loc (loc
, code
, type
, variable
, new_const
);
8992 /* Transform comparisons of the form X - Y CMP 0 to X CMP Y. */
8993 if (TREE_CODE (arg0
) == MINUS_EXPR
8994 && (equality_code
|| TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
)))
8995 && integer_zerop (arg1
))
8998 fold_overflow_warning ("assuming signed overflow does not occur "
8999 "when changing X - Y cmp 0 to X cmp Y",
9000 WARN_STRICT_OVERFLOW_COMPARISON
);
9001 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
9002 TREE_OPERAND (arg0
, 1));
9005 /* For comparisons of pointers we can decompose it to a compile time
9006 comparison of the base objects and the offsets into the object.
9007 This requires at least one operand being an ADDR_EXPR or a
9008 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
9009 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
9010 && (TREE_CODE (arg0
) == ADDR_EXPR
9011 || TREE_CODE (arg1
) == ADDR_EXPR
9012 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
9013 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
9015 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
9016 HOST_WIDE_INT bitsize
, bitpos0
= 0, bitpos1
= 0;
9017 enum machine_mode mode
;
9018 int volatilep
, unsignedp
;
9019 bool indirect_base0
= false, indirect_base1
= false;
9021 /* Get base and offset for the access. Strip ADDR_EXPR for
9022 get_inner_reference, but put it back by stripping INDIRECT_REF
9023 off the base object if possible. indirect_baseN will be true
9024 if baseN is not an address but refers to the object itself. */
9026 if (TREE_CODE (arg0
) == ADDR_EXPR
)
9028 base0
= get_inner_reference (TREE_OPERAND (arg0
, 0),
9029 &bitsize
, &bitpos0
, &offset0
, &mode
,
9030 &unsignedp
, &volatilep
, false);
9031 if (TREE_CODE (base0
) == INDIRECT_REF
)
9032 base0
= TREE_OPERAND (base0
, 0);
9034 indirect_base0
= true;
9036 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
9038 base0
= TREE_OPERAND (arg0
, 0);
9039 STRIP_SIGN_NOPS (base0
);
9040 if (TREE_CODE (base0
) == ADDR_EXPR
)
9042 base0
= TREE_OPERAND (base0
, 0);
9043 indirect_base0
= true;
9045 offset0
= TREE_OPERAND (arg0
, 1);
9046 if (tree_fits_shwi_p (offset0
))
9048 HOST_WIDE_INT off
= size_low_cst (offset0
);
9049 if ((HOST_WIDE_INT
) (((unsigned HOST_WIDE_INT
) off
)
9051 / BITS_PER_UNIT
== (HOST_WIDE_INT
) off
)
9053 bitpos0
= off
* BITS_PER_UNIT
;
9054 offset0
= NULL_TREE
;
9060 if (TREE_CODE (arg1
) == ADDR_EXPR
)
9062 base1
= get_inner_reference (TREE_OPERAND (arg1
, 0),
9063 &bitsize
, &bitpos1
, &offset1
, &mode
,
9064 &unsignedp
, &volatilep
, false);
9065 if (TREE_CODE (base1
) == INDIRECT_REF
)
9066 base1
= TREE_OPERAND (base1
, 0);
9068 indirect_base1
= true;
9070 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
9072 base1
= TREE_OPERAND (arg1
, 0);
9073 STRIP_SIGN_NOPS (base1
);
9074 if (TREE_CODE (base1
) == ADDR_EXPR
)
9076 base1
= TREE_OPERAND (base1
, 0);
9077 indirect_base1
= true;
9079 offset1
= TREE_OPERAND (arg1
, 1);
9080 if (tree_fits_shwi_p (offset1
))
9082 HOST_WIDE_INT off
= size_low_cst (offset1
);
9083 if ((HOST_WIDE_INT
) (((unsigned HOST_WIDE_INT
) off
)
9085 / BITS_PER_UNIT
== (HOST_WIDE_INT
) off
)
9087 bitpos1
= off
* BITS_PER_UNIT
;
9088 offset1
= NULL_TREE
;
9093 /* A local variable can never be pointed to by
9094 the default SSA name of an incoming parameter. */
9095 if ((TREE_CODE (arg0
) == ADDR_EXPR
9097 && TREE_CODE (base0
) == VAR_DECL
9098 && auto_var_in_fn_p (base0
, current_function_decl
)
9100 && TREE_CODE (base1
) == SSA_NAME
9101 && SSA_NAME_IS_DEFAULT_DEF (base1
)
9102 && TREE_CODE (SSA_NAME_VAR (base1
)) == PARM_DECL
)
9103 || (TREE_CODE (arg1
) == ADDR_EXPR
9105 && TREE_CODE (base1
) == VAR_DECL
9106 && auto_var_in_fn_p (base1
, current_function_decl
)
9108 && TREE_CODE (base0
) == SSA_NAME
9109 && SSA_NAME_IS_DEFAULT_DEF (base0
)
9110 && TREE_CODE (SSA_NAME_VAR (base0
)) == PARM_DECL
))
9112 if (code
== NE_EXPR
)
9113 return constant_boolean_node (1, type
);
9114 else if (code
== EQ_EXPR
)
9115 return constant_boolean_node (0, type
);
9117 /* If we have equivalent bases we might be able to simplify. */
9118 else if (indirect_base0
== indirect_base1
9119 && operand_equal_p (base0
, base1
, 0))
9121 /* We can fold this expression to a constant if the non-constant
9122 offset parts are equal. */
9123 if ((offset0
== offset1
9124 || (offset0
&& offset1
9125 && operand_equal_p (offset0
, offset1
, 0)))
9128 || (indirect_base0
&& DECL_P (base0
))
9129 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
9133 && bitpos0
!= bitpos1
9134 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
9135 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
9136 fold_overflow_warning (("assuming pointer wraparound does not "
9137 "occur when comparing P +- C1 with "
9139 WARN_STRICT_OVERFLOW_CONDITIONAL
);
9144 return constant_boolean_node (bitpos0
== bitpos1
, type
);
9146 return constant_boolean_node (bitpos0
!= bitpos1
, type
);
9148 return constant_boolean_node (bitpos0
< bitpos1
, type
);
9150 return constant_boolean_node (bitpos0
<= bitpos1
, type
);
9152 return constant_boolean_node (bitpos0
>= bitpos1
, type
);
9154 return constant_boolean_node (bitpos0
> bitpos1
, type
);
9158 /* We can simplify the comparison to a comparison of the variable
9159 offset parts if the constant offset parts are equal.
9160 Be careful to use signed sizetype here because otherwise we
9161 mess with array offsets in the wrong way. This is possible
9162 because pointer arithmetic is restricted to retain within an
9163 object and overflow on pointer differences is undefined as of
9164 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
9165 else if (bitpos0
== bitpos1
9167 || (indirect_base0
&& DECL_P (base0
))
9168 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
9170 /* By converting to signed sizetype we cover middle-end pointer
9171 arithmetic which operates on unsigned pointer types of size
9172 type size and ARRAY_REF offsets which are properly sign or
9173 zero extended from their type in case it is narrower than
9175 if (offset0
== NULL_TREE
)
9176 offset0
= build_int_cst (ssizetype
, 0);
9178 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
9179 if (offset1
== NULL_TREE
)
9180 offset1
= build_int_cst (ssizetype
, 0);
9182 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
9185 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
9186 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
9187 fold_overflow_warning (("assuming pointer wraparound does not "
9188 "occur when comparing P +- C1 with "
9190 WARN_STRICT_OVERFLOW_COMPARISON
);
9192 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
9195 /* For non-equal bases we can simplify if they are addresses
9196 of local binding decls or constants. */
9197 else if (indirect_base0
&& indirect_base1
9198 /* We know that !operand_equal_p (base0, base1, 0)
9199 because the if condition was false. But make
9200 sure two decls are not the same. */
9202 && TREE_CODE (arg0
) == ADDR_EXPR
9203 && TREE_CODE (arg1
) == ADDR_EXPR
9204 && (((TREE_CODE (base0
) == VAR_DECL
9205 || TREE_CODE (base0
) == PARM_DECL
)
9206 && (targetm
.binds_local_p (base0
)
9207 || CONSTANT_CLASS_P (base1
)))
9208 || CONSTANT_CLASS_P (base0
))
9209 && (((TREE_CODE (base1
) == VAR_DECL
9210 || TREE_CODE (base1
) == PARM_DECL
)
9211 && (targetm
.binds_local_p (base1
)
9212 || CONSTANT_CLASS_P (base0
)))
9213 || CONSTANT_CLASS_P (base1
)))
9215 if (code
== EQ_EXPR
)
9216 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
9218 else if (code
== NE_EXPR
)
9219 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
9222 /* For equal offsets we can simplify to a comparison of the
9224 else if (bitpos0
== bitpos1
9226 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
9228 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
9229 && ((offset0
== offset1
)
9230 || (offset0
&& offset1
9231 && operand_equal_p (offset0
, offset1
, 0))))
9234 base0
= build_fold_addr_expr_loc (loc
, base0
);
9236 base1
= build_fold_addr_expr_loc (loc
, base1
);
9237 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
9241 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9242 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9243 the resulting offset is smaller in absolute value than the
9244 original one and has the same sign. */
9245 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
9246 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
9247 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9248 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
9249 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
9250 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
9251 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
9253 tree const1
= TREE_OPERAND (arg0
, 1);
9254 tree const2
= TREE_OPERAND (arg1
, 1);
9255 tree variable1
= TREE_OPERAND (arg0
, 0);
9256 tree variable2
= TREE_OPERAND (arg1
, 0);
9258 const char * const warnmsg
= G_("assuming signed overflow does not "
9259 "occur when combining constants around "
9262 /* Put the constant on the side where it doesn't overflow and is
9263 of lower absolute value and of same sign than before. */
9264 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
9265 ? MINUS_EXPR
: PLUS_EXPR
,
9267 if (!TREE_OVERFLOW (cst
)
9268 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
)
9269 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const2
))
9271 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
9272 return fold_build2_loc (loc
, code
, type
,
9274 fold_build2_loc (loc
, TREE_CODE (arg1
),
9279 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
9280 ? MINUS_EXPR
: PLUS_EXPR
,
9282 if (!TREE_OVERFLOW (cst
)
9283 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
)
9284 && tree_int_cst_sgn (cst
) == tree_int_cst_sgn (const1
))
9286 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
9287 return fold_build2_loc (loc
, code
, type
,
9288 fold_build2_loc (loc
, TREE_CODE (arg0
),
9295 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9296 signed arithmetic case. That form is created by the compiler
9297 often enough for folding it to be of value. One example is in
9298 computing loop trip counts after Operator Strength Reduction. */
9299 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
9300 && TREE_CODE (arg0
) == MULT_EXPR
9301 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9302 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
9303 && integer_zerop (arg1
))
9305 tree const1
= TREE_OPERAND (arg0
, 1);
9306 tree const2
= arg1
; /* zero */
9307 tree variable1
= TREE_OPERAND (arg0
, 0);
9308 enum tree_code cmp_code
= code
;
9310 /* Handle unfolded multiplication by zero. */
9311 if (integer_zerop (const1
))
9312 return fold_build2_loc (loc
, cmp_code
, type
, const1
, const2
);
9314 fold_overflow_warning (("assuming signed overflow does not occur when "
9315 "eliminating multiplication in comparison "
9317 WARN_STRICT_OVERFLOW_COMPARISON
);
9319 /* If const1 is negative we swap the sense of the comparison. */
9320 if (tree_int_cst_sgn (const1
) < 0)
9321 cmp_code
= swap_tree_comparison (cmp_code
);
9323 return fold_build2_loc (loc
, cmp_code
, type
, variable1
, const2
);
9326 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
9330 if (FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9332 tree targ0
= strip_float_extensions (arg0
);
9333 tree targ1
= strip_float_extensions (arg1
);
9334 tree newtype
= TREE_TYPE (targ0
);
9336 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
9337 newtype
= TREE_TYPE (targ1
);
9339 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9340 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
9341 return fold_build2_loc (loc
, code
, type
,
9342 fold_convert_loc (loc
, newtype
, targ0
),
9343 fold_convert_loc (loc
, newtype
, targ1
));
9345 /* (-a) CMP (-b) -> b CMP a */
9346 if (TREE_CODE (arg0
) == NEGATE_EXPR
9347 && TREE_CODE (arg1
) == NEGATE_EXPR
)
9348 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg1
, 0),
9349 TREE_OPERAND (arg0
, 0));
9351 if (TREE_CODE (arg1
) == REAL_CST
)
9353 REAL_VALUE_TYPE cst
;
9354 cst
= TREE_REAL_CST (arg1
);
9356 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9357 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
9358 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9359 TREE_OPERAND (arg0
, 0),
9360 build_real (TREE_TYPE (arg1
),
9361 real_value_negate (&cst
)));
9363 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9364 /* a CMP (-0) -> a CMP 0 */
9365 if (REAL_VALUE_MINUS_ZERO (cst
))
9366 return fold_build2_loc (loc
, code
, type
, arg0
,
9367 build_real (TREE_TYPE (arg1
), dconst0
));
9369 /* x != NaN is always true, other ops are always false. */
9370 if (REAL_VALUE_ISNAN (cst
)
9371 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
))))
9373 tem
= (code
== NE_EXPR
) ? integer_one_node
: integer_zero_node
;
9374 return omit_one_operand_loc (loc
, type
, tem
, arg0
);
9377 /* Fold comparisons against infinity. */
9378 if (REAL_VALUE_ISINF (cst
)
9379 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
))))
9381 tem
= fold_inf_compare (loc
, code
, type
, arg0
, arg1
);
9382 if (tem
!= NULL_TREE
)
9387 /* If this is a comparison of a real constant with a PLUS_EXPR
9388 or a MINUS_EXPR of a real constant, we can convert it into a
9389 comparison with a revised real constant as long as no overflow
9390 occurs when unsafe_math_optimizations are enabled. */
9391 if (flag_unsafe_math_optimizations
9392 && TREE_CODE (arg1
) == REAL_CST
9393 && (TREE_CODE (arg0
) == PLUS_EXPR
9394 || TREE_CODE (arg0
) == MINUS_EXPR
)
9395 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
9396 && 0 != (tem
= const_binop (TREE_CODE (arg0
) == PLUS_EXPR
9397 ? MINUS_EXPR
: PLUS_EXPR
,
9398 arg1
, TREE_OPERAND (arg0
, 1)))
9399 && !TREE_OVERFLOW (tem
))
9400 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
9402 /* Likewise, we can simplify a comparison of a real constant with
9403 a MINUS_EXPR whose first operand is also a real constant, i.e.
9404 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9405 floating-point types only if -fassociative-math is set. */
9406 if (flag_associative_math
9407 && TREE_CODE (arg1
) == REAL_CST
9408 && TREE_CODE (arg0
) == MINUS_EXPR
9409 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
9410 && 0 != (tem
= const_binop (MINUS_EXPR
, TREE_OPERAND (arg0
, 0),
9412 && !TREE_OVERFLOW (tem
))
9413 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9414 TREE_OPERAND (arg0
, 1), tem
);
9416 /* Fold comparisons against built-in math functions. */
9417 if (TREE_CODE (arg1
) == REAL_CST
9418 && flag_unsafe_math_optimizations
9419 && ! flag_errno_math
)
9421 enum built_in_function fcode
= builtin_mathfn_code (arg0
);
9423 if (fcode
!= END_BUILTINS
)
9425 tem
= fold_mathfn_compare (loc
, fcode
, code
, type
, arg0
, arg1
);
9426 if (tem
!= NULL_TREE
)
9432 if (TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
9433 && CONVERT_EXPR_P (arg0
))
9435 /* If we are widening one operand of an integer comparison,
9436 see if the other operand is similarly being widened. Perhaps we
9437 can do the comparison in the narrower type. */
9438 tem
= fold_widened_comparison (loc
, code
, type
, arg0
, arg1
);
9442 /* Or if we are changing signedness. */
9443 tem
= fold_sign_changed_comparison (loc
, code
, type
, arg0
, arg1
);
9448 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9449 constant, we can simplify it. */
9450 if (TREE_CODE (arg1
) == INTEGER_CST
9451 && (TREE_CODE (arg0
) == MIN_EXPR
9452 || TREE_CODE (arg0
) == MAX_EXPR
)
9453 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
9455 tem
= optimize_minmax_comparison (loc
, code
, type
, op0
, op1
);
9460 /* Simplify comparison of something with itself. (For IEEE
9461 floating-point, we can only do some of these simplifications.) */
9462 if (operand_equal_p (arg0
, arg1
, 0))
9467 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
))
9468 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9469 return constant_boolean_node (1, type
);
9474 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
))
9475 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9476 return constant_boolean_node (1, type
);
9477 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
, arg1
);
9480 /* For NE, we can only do this simplification if integer
9481 or we don't honor IEEE floating point NaNs. */
9482 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
9483 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9485 /* ... fall through ... */
9488 return constant_boolean_node (0, type
);
9494 /* If we are comparing an expression that just has comparisons
9495 of two integer values, arithmetic expressions of those comparisons,
9496 and constants, we can simplify it. There are only three cases
9497 to check: the two values can either be equal, the first can be
9498 greater, or the second can be greater. Fold the expression for
9499 those three values. Since each value must be 0 or 1, we have
9500 eight possibilities, each of which corresponds to the constant 0
9501 or 1 or one of the six possible comparisons.
9503 This handles common cases like (a > b) == 0 but also handles
9504 expressions like ((x > y) - (y > x)) > 0, which supposedly
9505 occur in macroized code. */
9507 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
9509 tree cval1
= 0, cval2
= 0;
9512 if (twoval_comparison_p (arg0
, &cval1
, &cval2
, &save_p
)
9513 /* Don't handle degenerate cases here; they should already
9514 have been handled anyway. */
9515 && cval1
!= 0 && cval2
!= 0
9516 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
9517 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
9518 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
9519 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
9520 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
9521 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
9522 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
9524 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
9525 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
9527 /* We can't just pass T to eval_subst in case cval1 or cval2
9528 was the same as ARG1. */
9531 = fold_build2_loc (loc
, code
, type
,
9532 eval_subst (loc
, arg0
, cval1
, maxval
,
9536 = fold_build2_loc (loc
, code
, type
,
9537 eval_subst (loc
, arg0
, cval1
, maxval
,
9541 = fold_build2_loc (loc
, code
, type
,
9542 eval_subst (loc
, arg0
, cval1
, minval
,
9546 /* All three of these results should be 0 or 1. Confirm they are.
9547 Then use those values to select the proper code to use. */
9549 if (TREE_CODE (high_result
) == INTEGER_CST
9550 && TREE_CODE (equal_result
) == INTEGER_CST
9551 && TREE_CODE (low_result
) == INTEGER_CST
)
9553 /* Make a 3-bit mask with the high-order bit being the
9554 value for `>', the next for '=', and the low for '<'. */
9555 switch ((integer_onep (high_result
) * 4)
9556 + (integer_onep (equal_result
) * 2)
9557 + integer_onep (low_result
))
9561 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
9582 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
9587 tem
= save_expr (build2 (code
, type
, cval1
, cval2
));
9588 SET_EXPR_LOCATION (tem
, loc
);
9591 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
9596 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9597 into a single range test. */
9598 if ((TREE_CODE (arg0
) == TRUNC_DIV_EXPR
9599 || TREE_CODE (arg0
) == EXACT_DIV_EXPR
)
9600 && TREE_CODE (arg1
) == INTEGER_CST
9601 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9602 && !integer_zerop (TREE_OPERAND (arg0
, 1))
9603 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
9604 && !TREE_OVERFLOW (arg1
))
9606 tem
= fold_div_compare (loc
, code
, type
, arg0
, arg1
);
9607 if (tem
!= NULL_TREE
)
9611 /* Fold ~X op ~Y as Y op X. */
9612 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9613 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
9615 tree cmp_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
9616 return fold_build2_loc (loc
, code
, type
,
9617 fold_convert_loc (loc
, cmp_type
,
9618 TREE_OPERAND (arg1
, 0)),
9619 TREE_OPERAND (arg0
, 0));
9622 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9623 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9624 && (TREE_CODE (arg1
) == INTEGER_CST
|| TREE_CODE (arg1
) == VECTOR_CST
))
9626 tree cmp_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
9627 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9628 TREE_OPERAND (arg0
, 0),
9629 fold_build1_loc (loc
, BIT_NOT_EXPR
, cmp_type
,
9630 fold_convert_loc (loc
, cmp_type
, arg1
)));
9637 /* Subroutine of fold_binary. Optimize complex multiplications of the
9638 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9639 argument EXPR represents the expression "z" of type TYPE. */
9642 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
9644 tree itype
= TREE_TYPE (type
);
9645 tree rpart
, ipart
, tem
;
9647 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
9649 rpart
= TREE_OPERAND (expr
, 0);
9650 ipart
= TREE_OPERAND (expr
, 1);
9652 else if (TREE_CODE (expr
) == COMPLEX_CST
)
9654 rpart
= TREE_REALPART (expr
);
9655 ipart
= TREE_IMAGPART (expr
);
9659 expr
= save_expr (expr
);
9660 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
9661 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
9664 rpart
= save_expr (rpart
);
9665 ipart
= save_expr (ipart
);
9666 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
9667 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
9668 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
9669 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
9670 build_zero_cst (itype
));
9674 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9675 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9676 guarantees that P and N have the same least significant log2(M) bits.
9677 N is not otherwise constrained. In particular, N is not normalized to
9678 0 <= N < M as is common. In general, the precise value of P is unknown.
9679 M is chosen as large as possible such that constant N can be determined.
9681 Returns M and sets *RESIDUE to N.
9683 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9684 account. This is not always possible due to PR 35705.
9687 static unsigned HOST_WIDE_INT
9688 get_pointer_modulus_and_residue (tree expr
, unsigned HOST_WIDE_INT
*residue
,
9689 bool allow_func_align
)
9691 enum tree_code code
;
9695 code
= TREE_CODE (expr
);
9696 if (code
== ADDR_EXPR
)
9698 unsigned int bitalign
;
9699 get_object_alignment_1 (TREE_OPERAND (expr
, 0), &bitalign
, residue
);
9700 *residue
/= BITS_PER_UNIT
;
9701 return bitalign
/ BITS_PER_UNIT
;
9703 else if (code
== POINTER_PLUS_EXPR
)
9706 unsigned HOST_WIDE_INT modulus
;
9707 enum tree_code inner_code
;
9709 op0
= TREE_OPERAND (expr
, 0);
9711 modulus
= get_pointer_modulus_and_residue (op0
, residue
,
9714 op1
= TREE_OPERAND (expr
, 1);
9716 inner_code
= TREE_CODE (op1
);
9717 if (inner_code
== INTEGER_CST
)
9719 *residue
+= TREE_INT_CST_LOW (op1
);
9722 else if (inner_code
== MULT_EXPR
)
9724 op1
= TREE_OPERAND (op1
, 1);
9725 if (TREE_CODE (op1
) == INTEGER_CST
)
9727 unsigned HOST_WIDE_INT align
;
9729 /* Compute the greatest power-of-2 divisor of op1. */
9730 align
= TREE_INT_CST_LOW (op1
);
9733 /* If align is non-zero and less than *modulus, replace
9734 *modulus with align., If align is 0, then either op1 is 0
9735 or the greatest power-of-2 divisor of op1 doesn't fit in an
9736 unsigned HOST_WIDE_INT. In either case, no additional
9737 constraint is imposed. */
9739 modulus
= MIN (modulus
, align
);
9746 /* If we get here, we were unable to determine anything useful about the
9751 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
9752 CONSTRUCTOR ARG into array ELTS and return true if successful. */
9755 vec_cst_ctor_to_array (tree arg
, tree
*elts
)
9757 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg
)), i
;
9759 if (TREE_CODE (arg
) == VECTOR_CST
)
9761 for (i
= 0; i
< VECTOR_CST_NELTS (arg
); ++i
)
9762 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
9764 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
9766 constructor_elt
*elt
;
9768 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
9769 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
9772 elts
[i
] = elt
->value
;
9776 for (; i
< nelts
; i
++)
9778 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
9782 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
9783 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
9784 NULL_TREE otherwise. */
9787 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const unsigned char *sel
)
9789 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
9791 bool need_ctor
= false;
9793 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
9794 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
);
9795 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
9796 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
9799 elts
= XALLOCAVEC (tree
, nelts
* 3);
9800 if (!vec_cst_ctor_to_array (arg0
, elts
)
9801 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
))
9804 for (i
= 0; i
< nelts
; i
++)
9806 if (!CONSTANT_CLASS_P (elts
[sel
[i
]]))
9808 elts
[i
+ 2 * nelts
] = unshare_expr (elts
[sel
[i
]]);
9813 vec
<constructor_elt
, va_gc
> *v
;
9814 vec_alloc (v
, nelts
);
9815 for (i
= 0; i
< nelts
; i
++)
9816 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, elts
[2 * nelts
+ i
]);
9817 return build_constructor (type
, v
);
9820 return build_vector (type
, &elts
[2 * nelts
]);
9823 /* Try to fold a pointer difference of type TYPE two address expressions of
9824 array references AREF0 and AREF1 using location LOC. Return a
9825 simplified expression for the difference or NULL_TREE. */
9828 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
9829 tree aref0
, tree aref1
)
9831 tree base0
= TREE_OPERAND (aref0
, 0);
9832 tree base1
= TREE_OPERAND (aref1
, 0);
9833 tree base_offset
= build_int_cst (type
, 0);
9835 /* If the bases are array references as well, recurse. If the bases
9836 are pointer indirections compute the difference of the pointers.
9837 If the bases are equal, we are set. */
9838 if ((TREE_CODE (base0
) == ARRAY_REF
9839 && TREE_CODE (base1
) == ARRAY_REF
9841 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
)))
9842 || (INDIRECT_REF_P (base0
)
9843 && INDIRECT_REF_P (base1
)
9844 && (base_offset
= fold_binary_loc (loc
, MINUS_EXPR
, type
,
9845 TREE_OPERAND (base0
, 0),
9846 TREE_OPERAND (base1
, 0))))
9847 || operand_equal_p (base0
, base1
, 0))
9849 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
9850 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
9851 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
9852 tree diff
= build2 (MINUS_EXPR
, type
, op0
, op1
);
9853 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9855 fold_build2_loc (loc
, MULT_EXPR
, type
,
9861 /* If the real or vector real constant CST of type TYPE has an exact
9862 inverse, return it, else return NULL. */
9865 exact_inverse (tree type
, tree cst
)
9868 tree unit_type
, *elts
;
9869 enum machine_mode mode
;
9870 unsigned vec_nelts
, i
;
9872 switch (TREE_CODE (cst
))
9875 r
= TREE_REAL_CST (cst
);
9877 if (exact_real_inverse (TYPE_MODE (type
), &r
))
9878 return build_real (type
, r
);
9883 vec_nelts
= VECTOR_CST_NELTS (cst
);
9884 elts
= XALLOCAVEC (tree
, vec_nelts
);
9885 unit_type
= TREE_TYPE (type
);
9886 mode
= TYPE_MODE (unit_type
);
9888 for (i
= 0; i
< vec_nelts
; i
++)
9890 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
9891 if (!exact_real_inverse (mode
, &r
))
9893 elts
[i
] = build_real (unit_type
, r
);
9896 return build_vector (type
, elts
);
9903 /* Mask out the tz least significant bits of X of type TYPE where
9904 tz is the number of trailing zeroes in Y. */
9906 mask_with_tz (tree type
, const wide_int
&x
, const wide_int
&y
)
9908 int tz
= wi::ctz (y
);
9910 return wi::mask (tz
, true, TYPE_PRECISION (type
)) & x
;
9914 /* Return true when T is an address and is known to be nonzero.
9915 For floating point we further ensure that T is not denormal.
9916 Similar logic is present in nonzero_address in rtlanal.h.
9918 If the return value is based on the assumption that signed overflow
9919 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9920 change *STRICT_OVERFLOW_P. */
9923 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
9925 tree type
= TREE_TYPE (t
);
9926 enum tree_code code
;
9928 /* Doing something useful for floating point would need more work. */
9929 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
9932 code
= TREE_CODE (t
);
9933 switch (TREE_CODE_CLASS (code
))
9936 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9939 case tcc_comparison
:
9940 return tree_binary_nonzero_warnv_p (code
, type
,
9941 TREE_OPERAND (t
, 0),
9942 TREE_OPERAND (t
, 1),
9945 case tcc_declaration
:
9947 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9955 case TRUTH_NOT_EXPR
:
9956 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
9959 case TRUTH_AND_EXPR
:
9961 case TRUTH_XOR_EXPR
:
9962 return tree_binary_nonzero_warnv_p (code
, type
,
9963 TREE_OPERAND (t
, 0),
9964 TREE_OPERAND (t
, 1),
9972 case WITH_SIZE_EXPR
:
9974 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
9979 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
9983 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
9988 tree fndecl
= get_callee_fndecl (t
);
9989 if (!fndecl
) return false;
9990 if (flag_delete_null_pointer_checks
&& !flag_check_new
9991 && DECL_IS_OPERATOR_NEW (fndecl
)
9992 && !TREE_NOTHROW (fndecl
))
9994 if (flag_delete_null_pointer_checks
9995 && lookup_attribute ("returns_nonnull",
9996 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
9998 return alloca_call_p (t
);
10007 /* Return true when T is an address and is known to be nonzero.
10008 Handle warnings about undefined signed overflow. */
10011 tree_expr_nonzero_p (tree t
)
10013 bool ret
, strict_overflow_p
;
10015 strict_overflow_p
= false;
10016 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
10017 if (strict_overflow_p
)
10018 fold_overflow_warning (("assuming signed overflow does not occur when "
10019 "determining that expression is always "
10021 WARN_STRICT_OVERFLOW_MISC
);
10025 /* Fold a binary expression of code CODE and type TYPE with operands
10026 OP0 and OP1. LOC is the location of the resulting expression.
10027 Return the folded expression if folding is successful. Otherwise,
10028 return NULL_TREE. */
10031 fold_binary_loc (location_t loc
,
10032 enum tree_code code
, tree type
, tree op0
, tree op1
)
10034 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
10035 tree arg0
, arg1
, tem
;
10036 tree t1
= NULL_TREE
;
10037 bool strict_overflow_p
;
10040 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
10041 && TREE_CODE_LENGTH (code
) == 2
10042 && op0
!= NULL_TREE
10043 && op1
!= NULL_TREE
);
10048 /* Strip any conversions that don't change the mode. This is
10049 safe for every expression, except for a comparison expression
10050 because its signedness is derived from its operands. So, in
10051 the latter case, only strip conversions that don't change the
10052 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
10055 Note that this is done as an internal manipulation within the
10056 constant folder, in order to find the simplest representation
10057 of the arguments so that their form can be studied. In any
10058 cases, the appropriate type conversions should be put back in
10059 the tree that will get out of the constant folder. */
10061 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
10063 STRIP_SIGN_NOPS (arg0
);
10064 STRIP_SIGN_NOPS (arg1
);
10072 /* Note that TREE_CONSTANT isn't enough: static var addresses are
10073 constant but we can't do arithmetic on them. */
10074 if ((TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
10075 || (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
10076 || (TREE_CODE (arg0
) == FIXED_CST
&& TREE_CODE (arg1
) == FIXED_CST
)
10077 || (TREE_CODE (arg0
) == FIXED_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
10078 || (TREE_CODE (arg0
) == COMPLEX_CST
&& TREE_CODE (arg1
) == COMPLEX_CST
)
10079 || (TREE_CODE (arg0
) == VECTOR_CST
&& TREE_CODE (arg1
) == VECTOR_CST
)
10080 || (TREE_CODE (arg0
) == VECTOR_CST
&& TREE_CODE (arg1
) == INTEGER_CST
))
10082 if (kind
== tcc_binary
)
10084 /* Make sure type and arg0 have the same saturating flag. */
10085 gcc_assert (TYPE_SATURATING (type
)
10086 == TYPE_SATURATING (TREE_TYPE (arg0
)));
10087 tem
= const_binop (code
, arg0
, arg1
);
10089 else if (kind
== tcc_comparison
)
10090 tem
= fold_relational_const (code
, type
, arg0
, arg1
);
10094 if (tem
!= NULL_TREE
)
10096 if (TREE_TYPE (tem
) != type
)
10097 tem
= fold_convert_loc (loc
, type
, tem
);
10102 /* If this is a commutative operation, and ARG0 is a constant, move it
10103 to ARG1 to reduce the number of tests below. */
10104 if (commutative_tree_code (code
)
10105 && tree_swap_operands_p (arg0
, arg1
, true))
10106 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
10108 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
10110 First check for cases where an arithmetic operation is applied to a
10111 compound, conditional, or comparison operation. Push the arithmetic
10112 operation inside the compound or conditional to see if any folding
10113 can then be done. Convert comparison to conditional for this purpose.
10114 The also optimizes non-constant cases that used to be done in
10117 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
10118 one of the operands is a comparison and the other is a comparison, a
10119 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
10120 code below would make the expression more complex. Change it to a
10121 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
10122 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
10124 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
10125 || code
== EQ_EXPR
|| code
== NE_EXPR
)
10126 && TREE_CODE (type
) != VECTOR_TYPE
10127 && ((truth_value_p (TREE_CODE (arg0
))
10128 && (truth_value_p (TREE_CODE (arg1
))
10129 || (TREE_CODE (arg1
) == BIT_AND_EXPR
10130 && integer_onep (TREE_OPERAND (arg1
, 1)))))
10131 || (truth_value_p (TREE_CODE (arg1
))
10132 && (truth_value_p (TREE_CODE (arg0
))
10133 || (TREE_CODE (arg0
) == BIT_AND_EXPR
10134 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
10136 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
10137 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
10140 fold_convert_loc (loc
, boolean_type_node
, arg0
),
10141 fold_convert_loc (loc
, boolean_type_node
, arg1
));
10143 if (code
== EQ_EXPR
)
10144 tem
= invert_truthvalue_loc (loc
, tem
);
10146 return fold_convert_loc (loc
, type
, tem
);
10149 if (TREE_CODE_CLASS (code
) == tcc_binary
10150 || TREE_CODE_CLASS (code
) == tcc_comparison
)
10152 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
10154 tem
= fold_build2_loc (loc
, code
, type
,
10155 fold_convert_loc (loc
, TREE_TYPE (op0
),
10156 TREE_OPERAND (arg0
, 1)), op1
);
10157 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
10160 if (TREE_CODE (arg1
) == COMPOUND_EXPR
10161 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
10163 tem
= fold_build2_loc (loc
, code
, type
, op0
,
10164 fold_convert_loc (loc
, TREE_TYPE (op1
),
10165 TREE_OPERAND (arg1
, 1)));
10166 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
10170 if (TREE_CODE (arg0
) == COND_EXPR
10171 || TREE_CODE (arg0
) == VEC_COND_EXPR
10172 || COMPARISON_CLASS_P (arg0
))
10174 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
10176 /*cond_first_p=*/1);
10177 if (tem
!= NULL_TREE
)
10181 if (TREE_CODE (arg1
) == COND_EXPR
10182 || TREE_CODE (arg1
) == VEC_COND_EXPR
10183 || COMPARISON_CLASS_P (arg1
))
10185 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
10187 /*cond_first_p=*/0);
10188 if (tem
!= NULL_TREE
)
10196 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
10197 if (TREE_CODE (arg0
) == ADDR_EXPR
10198 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
10200 tree iref
= TREE_OPERAND (arg0
, 0);
10201 return fold_build2 (MEM_REF
, type
,
10202 TREE_OPERAND (iref
, 0),
10203 int_const_binop (PLUS_EXPR
, arg1
,
10204 TREE_OPERAND (iref
, 1)));
10207 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
10208 if (TREE_CODE (arg0
) == ADDR_EXPR
10209 && handled_component_p (TREE_OPERAND (arg0
, 0)))
10212 HOST_WIDE_INT coffset
;
10213 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
10217 return fold_build2 (MEM_REF
, type
,
10218 build_fold_addr_expr (base
),
10219 int_const_binop (PLUS_EXPR
, arg1
,
10220 size_int (coffset
)));
10225 case POINTER_PLUS_EXPR
:
10226 /* 0 +p index -> (type)index */
10227 if (integer_zerop (arg0
))
10228 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10230 /* PTR +p 0 -> PTR */
10231 if (integer_zerop (arg1
))
10232 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10234 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
10235 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10236 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
10237 return fold_convert_loc (loc
, type
,
10238 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
10239 fold_convert_loc (loc
, sizetype
,
10241 fold_convert_loc (loc
, sizetype
,
10244 /* (PTR +p B) +p A -> PTR +p (B + A) */
10245 if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
10248 tree arg01
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (arg0
, 1));
10249 tree arg00
= TREE_OPERAND (arg0
, 0);
10250 inner
= fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
10251 arg01
, fold_convert_loc (loc
, sizetype
, arg1
));
10252 return fold_convert_loc (loc
, type
,
10253 fold_build_pointer_plus_loc (loc
,
10257 /* PTR_CST +p CST -> CST1 */
10258 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
10259 return fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
,
10260 fold_convert_loc (loc
, type
, arg1
));
10262 /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
10263 of the array. Loop optimizer sometimes produce this type of
10265 if (TREE_CODE (arg0
) == ADDR_EXPR
)
10267 tem
= try_move_mult_to_index (loc
, arg0
,
10268 fold_convert_loc (loc
,
10271 return fold_convert_loc (loc
, type
, tem
);
10277 /* A + (-B) -> A - B */
10278 if (TREE_CODE (arg1
) == NEGATE_EXPR
10279 && (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
10280 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10281 fold_convert_loc (loc
, type
, arg0
),
10282 fold_convert_loc (loc
, type
,
10283 TREE_OPERAND (arg1
, 0)));
10284 /* (-A) + B -> B - A */
10285 if (TREE_CODE (arg0
) == NEGATE_EXPR
10286 && reorder_operands_p (TREE_OPERAND (arg0
, 0), arg1
)
10287 && (flag_sanitize
& SANITIZE_SI_OVERFLOW
) == 0)
10288 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10289 fold_convert_loc (loc
, type
, arg1
),
10290 fold_convert_loc (loc
, type
,
10291 TREE_OPERAND (arg0
, 0)));
10293 if (INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
10295 /* Convert ~A + 1 to -A. */
10296 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10297 && integer_onep (arg1
))
10298 return fold_build1_loc (loc
, NEGATE_EXPR
, type
,
10299 fold_convert_loc (loc
, type
,
10300 TREE_OPERAND (arg0
, 0)));
10302 /* ~X + X is -1. */
10303 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10304 && !TYPE_OVERFLOW_TRAPS (type
))
10306 tree tem
= TREE_OPERAND (arg0
, 0);
10309 if (operand_equal_p (tem
, arg1
, 0))
10311 t1
= build_all_ones_cst (type
);
10312 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
10316 /* X + ~X is -1. */
10317 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
10318 && !TYPE_OVERFLOW_TRAPS (type
))
10320 tree tem
= TREE_OPERAND (arg1
, 0);
10323 if (operand_equal_p (arg0
, tem
, 0))
10325 t1
= build_all_ones_cst (type
);
10326 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
10330 /* X + (X / CST) * -CST is X % CST. */
10331 if (TREE_CODE (arg1
) == MULT_EXPR
10332 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10333 && operand_equal_p (arg0
,
10334 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
10336 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
10337 tree cst1
= TREE_OPERAND (arg1
, 1);
10338 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
10340 if (sum
&& integer_zerop (sum
))
10341 return fold_convert_loc (loc
, type
,
10342 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
10343 TREE_TYPE (arg0
), arg0
,
10348 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
10349 one. Make sure the type is not saturating and has the signedness of
10350 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10351 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10352 if ((TREE_CODE (arg0
) == MULT_EXPR
10353 || TREE_CODE (arg1
) == MULT_EXPR
)
10354 && !TYPE_SATURATING (type
)
10355 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10356 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10357 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10359 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10364 if (! FLOAT_TYPE_P (type
))
10366 if (integer_zerop (arg1
))
10367 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10369 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10370 with a constant, and the two constants have no bits in common,
10371 we should treat this as a BIT_IOR_EXPR since this may produce more
10372 simplifications. */
10373 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10374 && TREE_CODE (arg1
) == BIT_AND_EXPR
10375 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10376 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
10377 && wi::bit_and (TREE_OPERAND (arg0
, 1),
10378 TREE_OPERAND (arg1
, 1)) == 0)
10380 code
= BIT_IOR_EXPR
;
10384 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10385 (plus (plus (mult) (mult)) (foo)) so that we can
10386 take advantage of the factoring cases below. */
10387 if (TYPE_OVERFLOW_WRAPS (type
)
10388 && (((TREE_CODE (arg0
) == PLUS_EXPR
10389 || TREE_CODE (arg0
) == MINUS_EXPR
)
10390 && TREE_CODE (arg1
) == MULT_EXPR
)
10391 || ((TREE_CODE (arg1
) == PLUS_EXPR
10392 || TREE_CODE (arg1
) == MINUS_EXPR
)
10393 && TREE_CODE (arg0
) == MULT_EXPR
)))
10395 tree parg0
, parg1
, parg
, marg
;
10396 enum tree_code pcode
;
10398 if (TREE_CODE (arg1
) == MULT_EXPR
)
10399 parg
= arg0
, marg
= arg1
;
10401 parg
= arg1
, marg
= arg0
;
10402 pcode
= TREE_CODE (parg
);
10403 parg0
= TREE_OPERAND (parg
, 0);
10404 parg1
= TREE_OPERAND (parg
, 1);
10405 STRIP_NOPS (parg0
);
10406 STRIP_NOPS (parg1
);
10408 if (TREE_CODE (parg0
) == MULT_EXPR
10409 && TREE_CODE (parg1
) != MULT_EXPR
)
10410 return fold_build2_loc (loc
, pcode
, type
,
10411 fold_build2_loc (loc
, PLUS_EXPR
, type
,
10412 fold_convert_loc (loc
, type
,
10414 fold_convert_loc (loc
, type
,
10416 fold_convert_loc (loc
, type
, parg1
));
10417 if (TREE_CODE (parg0
) != MULT_EXPR
10418 && TREE_CODE (parg1
) == MULT_EXPR
)
10420 fold_build2_loc (loc
, PLUS_EXPR
, type
,
10421 fold_convert_loc (loc
, type
, parg0
),
10422 fold_build2_loc (loc
, pcode
, type
,
10423 fold_convert_loc (loc
, type
, marg
),
10424 fold_convert_loc (loc
, type
,
10430 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10431 if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 0))
10432 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10434 /* Likewise if the operands are reversed. */
10435 if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10436 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10438 /* Convert X + -C into X - C. */
10439 if (TREE_CODE (arg1
) == REAL_CST
10440 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
)))
10442 tem
= fold_negate_const (arg1
, type
);
10443 if (!TREE_OVERFLOW (arg1
) || !flag_trapping_math
)
10444 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10445 fold_convert_loc (loc
, type
, arg0
),
10446 fold_convert_loc (loc
, type
, tem
));
10449 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10450 to __complex__ ( x, y ). This is not the same for SNaNs or
10451 if signed zeros are involved. */
10452 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10453 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10454 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10456 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10457 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10458 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10459 bool arg0rz
= false, arg0iz
= false;
10460 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10461 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10463 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10464 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10465 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10467 tree rp
= arg1r
? arg1r
10468 : build1 (REALPART_EXPR
, rtype
, arg1
);
10469 tree ip
= arg0i
? arg0i
10470 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10471 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10473 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10475 tree rp
= arg0r
? arg0r
10476 : build1 (REALPART_EXPR
, rtype
, arg0
);
10477 tree ip
= arg1i
? arg1i
10478 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
10479 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10484 if (flag_unsafe_math_optimizations
10485 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10486 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10487 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10490 /* Convert x+x into x*2.0. */
10491 if (operand_equal_p (arg0
, arg1
, 0)
10492 && SCALAR_FLOAT_TYPE_P (type
))
10493 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
,
10494 build_real (type
, dconst2
));
10496 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10497 We associate floats only if the user has specified
10498 -fassociative-math. */
10499 if (flag_associative_math
10500 && TREE_CODE (arg1
) == PLUS_EXPR
10501 && TREE_CODE (arg0
) != MULT_EXPR
)
10503 tree tree10
= TREE_OPERAND (arg1
, 0);
10504 tree tree11
= TREE_OPERAND (arg1
, 1);
10505 if (TREE_CODE (tree11
) == MULT_EXPR
10506 && TREE_CODE (tree10
) == MULT_EXPR
)
10509 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
10510 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
10513 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10514 We associate floats only if the user has specified
10515 -fassociative-math. */
10516 if (flag_associative_math
10517 && TREE_CODE (arg0
) == PLUS_EXPR
10518 && TREE_CODE (arg1
) != MULT_EXPR
)
10520 tree tree00
= TREE_OPERAND (arg0
, 0);
10521 tree tree01
= TREE_OPERAND (arg0
, 1);
10522 if (TREE_CODE (tree01
) == MULT_EXPR
10523 && TREE_CODE (tree00
) == MULT_EXPR
)
10526 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
10527 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
10533 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10534 is a rotate of A by C1 bits. */
10535 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10536 is a rotate of A by B bits. */
10538 enum tree_code code0
, code1
;
10540 code0
= TREE_CODE (arg0
);
10541 code1
= TREE_CODE (arg1
);
10542 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
10543 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
10544 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10545 TREE_OPERAND (arg1
, 0), 0)
10546 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10547 TYPE_UNSIGNED (rtype
))
10548 /* Only create rotates in complete modes. Other cases are not
10549 expanded properly. */
10550 && (element_precision (rtype
)
10551 == element_precision (TYPE_MODE (rtype
))))
10553 tree tree01
, tree11
;
10554 enum tree_code code01
, code11
;
10556 tree01
= TREE_OPERAND (arg0
, 1);
10557 tree11
= TREE_OPERAND (arg1
, 1);
10558 STRIP_NOPS (tree01
);
10559 STRIP_NOPS (tree11
);
10560 code01
= TREE_CODE (tree01
);
10561 code11
= TREE_CODE (tree11
);
10562 if (code01
== INTEGER_CST
10563 && code11
== INTEGER_CST
10564 && (wi::to_widest (tree01
) + wi::to_widest (tree11
)
10565 == element_precision (TREE_TYPE (TREE_OPERAND (arg0
, 0)))))
10567 tem
= build2_loc (loc
, LROTATE_EXPR
,
10568 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10569 TREE_OPERAND (arg0
, 0),
10570 code0
== LSHIFT_EXPR
? tree01
: tree11
);
10571 return fold_convert_loc (loc
, type
, tem
);
10573 else if (code11
== MINUS_EXPR
)
10575 tree tree110
, tree111
;
10576 tree110
= TREE_OPERAND (tree11
, 0);
10577 tree111
= TREE_OPERAND (tree11
, 1);
10578 STRIP_NOPS (tree110
);
10579 STRIP_NOPS (tree111
);
10580 if (TREE_CODE (tree110
) == INTEGER_CST
10581 && 0 == compare_tree_int (tree110
,
10583 (TREE_TYPE (TREE_OPERAND
10585 && operand_equal_p (tree01
, tree111
, 0))
10587 fold_convert_loc (loc
, type
,
10588 build2 ((code0
== LSHIFT_EXPR
10591 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10592 TREE_OPERAND (arg0
, 0), tree01
));
10594 else if (code01
== MINUS_EXPR
)
10596 tree tree010
, tree011
;
10597 tree010
= TREE_OPERAND (tree01
, 0);
10598 tree011
= TREE_OPERAND (tree01
, 1);
10599 STRIP_NOPS (tree010
);
10600 STRIP_NOPS (tree011
);
10601 if (TREE_CODE (tree010
) == INTEGER_CST
10602 && 0 == compare_tree_int (tree010
,
10604 (TREE_TYPE (TREE_OPERAND
10606 && operand_equal_p (tree11
, tree011
, 0))
10607 return fold_convert_loc
10609 build2 ((code0
!= LSHIFT_EXPR
10612 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10613 TREE_OPERAND (arg0
, 0), tree11
));
10619 /* In most languages, can't associate operations on floats through
10620 parentheses. Rather than remember where the parentheses were, we
10621 don't associate floats at all, unless the user has specified
10622 -fassociative-math.
10623 And, we need to make sure type is not saturating. */
10625 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
10626 && !TYPE_SATURATING (type
))
10628 tree var0
, con0
, lit0
, minus_lit0
;
10629 tree var1
, con1
, lit1
, minus_lit1
;
10633 /* Split both trees into variables, constants, and literals. Then
10634 associate each group together, the constants with literals,
10635 then the result with variables. This increases the chances of
10636 literals being recombined later and of generating relocatable
10637 expressions for the sum of a constant and literal. */
10638 var0
= split_tree (arg0
, code
, &con0
, &lit0
, &minus_lit0
, 0);
10639 var1
= split_tree (arg1
, code
, &con1
, &lit1
, &minus_lit1
,
10640 code
== MINUS_EXPR
);
10642 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10643 if (code
== MINUS_EXPR
)
10646 /* With undefined overflow prefer doing association in a type
10647 which wraps on overflow, if that is one of the operand types. */
10648 if ((POINTER_TYPE_P (type
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
10649 || (INTEGRAL_TYPE_P (type
) && !TYPE_OVERFLOW_WRAPS (type
)))
10651 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
10652 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
10653 atype
= TREE_TYPE (arg0
);
10654 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
10655 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1
)))
10656 atype
= TREE_TYPE (arg1
);
10657 gcc_assert (TYPE_PRECISION (atype
) == TYPE_PRECISION (type
));
10660 /* With undefined overflow we can only associate constants with one
10661 variable, and constants whose association doesn't overflow. */
10662 if ((POINTER_TYPE_P (atype
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
10663 || (INTEGRAL_TYPE_P (atype
) && !TYPE_OVERFLOW_WRAPS (atype
)))
10670 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
10671 tmp0
= TREE_OPERAND (tmp0
, 0);
10672 if (CONVERT_EXPR_P (tmp0
)
10673 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
10674 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
10675 <= TYPE_PRECISION (atype
)))
10676 tmp0
= TREE_OPERAND (tmp0
, 0);
10677 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
10678 tmp1
= TREE_OPERAND (tmp1
, 0);
10679 if (CONVERT_EXPR_P (tmp1
)
10680 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
10681 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
10682 <= TYPE_PRECISION (atype
)))
10683 tmp1
= TREE_OPERAND (tmp1
, 0);
10684 /* The only case we can still associate with two variables
10685 is if they are the same, modulo negation and bit-pattern
10686 preserving conversions. */
10687 if (!operand_equal_p (tmp0
, tmp1
, 0))
10692 /* Only do something if we found more than two objects. Otherwise,
10693 nothing has changed and we risk infinite recursion. */
10695 && (2 < ((var0
!= 0) + (var1
!= 0)
10696 + (con0
!= 0) + (con1
!= 0)
10697 + (lit0
!= 0) + (lit1
!= 0)
10698 + (minus_lit0
!= 0) + (minus_lit1
!= 0))))
10700 bool any_overflows
= false;
10701 if (lit0
) any_overflows
|= TREE_OVERFLOW (lit0
);
10702 if (lit1
) any_overflows
|= TREE_OVERFLOW (lit1
);
10703 if (minus_lit0
) any_overflows
|= TREE_OVERFLOW (minus_lit0
);
10704 if (minus_lit1
) any_overflows
|= TREE_OVERFLOW (minus_lit1
);
10705 var0
= associate_trees (loc
, var0
, var1
, code
, atype
);
10706 con0
= associate_trees (loc
, con0
, con1
, code
, atype
);
10707 lit0
= associate_trees (loc
, lit0
, lit1
, code
, atype
);
10708 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
,
10711 /* Preserve the MINUS_EXPR if the negative part of the literal is
10712 greater than the positive part. Otherwise, the multiplicative
10713 folding code (i.e extract_muldiv) may be fooled in case
10714 unsigned constants are subtracted, like in the following
10715 example: ((X*2 + 4) - 8U)/2. */
10716 if (minus_lit0
&& lit0
)
10718 if (TREE_CODE (lit0
) == INTEGER_CST
10719 && TREE_CODE (minus_lit0
) == INTEGER_CST
10720 && tree_int_cst_lt (lit0
, minus_lit0
))
10722 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
10723 MINUS_EXPR
, atype
);
10728 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
10729 MINUS_EXPR
, atype
);
10734 /* Don't introduce overflows through reassociation. */
10736 && ((lit0
&& TREE_OVERFLOW (lit0
))
10737 || (minus_lit0
&& TREE_OVERFLOW (minus_lit0
))))
10744 fold_convert_loc (loc
, type
,
10745 associate_trees (loc
, var0
, minus_lit0
,
10746 MINUS_EXPR
, atype
));
10749 con0
= associate_trees (loc
, con0
, minus_lit0
,
10750 MINUS_EXPR
, atype
);
10752 fold_convert_loc (loc
, type
,
10753 associate_trees (loc
, var0
, con0
,
10754 PLUS_EXPR
, atype
));
10758 con0
= associate_trees (loc
, con0
, lit0
, code
, atype
);
10760 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
10768 /* Pointer simplifications for subtraction, simple reassociations. */
10769 if (POINTER_TYPE_P (TREE_TYPE (arg1
)) && POINTER_TYPE_P (TREE_TYPE (arg0
)))
10771 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10772 if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
10773 && TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
10775 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10776 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10777 tree arg10
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10778 tree arg11
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10779 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10780 fold_build2_loc (loc
, MINUS_EXPR
, type
,
10782 fold_build2_loc (loc
, MINUS_EXPR
, type
,
10785 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10786 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
10788 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10789 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10790 tree tmp
= fold_binary_loc (loc
, MINUS_EXPR
, type
, arg00
,
10791 fold_convert_loc (loc
, type
, arg1
));
10793 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tmp
, arg01
);
10796 /* A - (-B) -> A + B */
10797 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
10798 return fold_build2_loc (loc
, PLUS_EXPR
, type
, op0
,
10799 fold_convert_loc (loc
, type
,
10800 TREE_OPERAND (arg1
, 0)));
10801 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10802 if (TREE_CODE (arg0
) == NEGATE_EXPR
10803 && negate_expr_p (arg1
)
10804 && reorder_operands_p (arg0
, arg1
))
10805 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10806 fold_convert_loc (loc
, type
,
10807 negate_expr (arg1
)),
10808 fold_convert_loc (loc
, type
,
10809 TREE_OPERAND (arg0
, 0)));
10810 /* Convert -A - 1 to ~A. */
10811 if (TREE_CODE (type
) != COMPLEX_TYPE
10812 && TREE_CODE (arg0
) == NEGATE_EXPR
10813 && integer_onep (arg1
)
10814 && !TYPE_OVERFLOW_TRAPS (type
))
10815 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
10816 fold_convert_loc (loc
, type
,
10817 TREE_OPERAND (arg0
, 0)));
10819 /* Convert -1 - A to ~A. */
10820 if (TREE_CODE (type
) != COMPLEX_TYPE
10821 && integer_all_onesp (arg0
))
10822 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op1
);
10825 /* X - (X / Y) * Y is X % Y. */
10826 if ((INTEGRAL_TYPE_P (type
) || VECTOR_INTEGER_TYPE_P (type
))
10827 && TREE_CODE (arg1
) == MULT_EXPR
10828 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10829 && operand_equal_p (arg0
,
10830 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0)
10831 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1),
10832 TREE_OPERAND (arg1
, 1), 0))
10834 fold_convert_loc (loc
, type
,
10835 fold_build2_loc (loc
, TRUNC_MOD_EXPR
, TREE_TYPE (arg0
),
10836 arg0
, TREE_OPERAND (arg1
, 1)));
10838 if (! FLOAT_TYPE_P (type
))
10840 if (integer_zerop (arg0
))
10841 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10842 if (integer_zerop (arg1
))
10843 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10845 /* Fold A - (A & B) into ~B & A. */
10846 if (!TREE_SIDE_EFFECTS (arg0
)
10847 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10849 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0))
10851 tree arg10
= fold_convert_loc (loc
, type
,
10852 TREE_OPERAND (arg1
, 0));
10853 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10854 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10856 fold_convert_loc (loc
, type
, arg0
));
10858 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10860 tree arg11
= fold_convert_loc (loc
,
10861 type
, TREE_OPERAND (arg1
, 1));
10862 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10863 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10865 fold_convert_loc (loc
, type
, arg0
));
10869 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10870 any power of 2 minus 1. */
10871 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10872 && TREE_CODE (arg1
) == BIT_AND_EXPR
10873 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10874 TREE_OPERAND (arg1
, 0), 0))
10876 tree mask0
= TREE_OPERAND (arg0
, 1);
10877 tree mask1
= TREE_OPERAND (arg1
, 1);
10878 tree tem
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, mask0
);
10880 if (operand_equal_p (tem
, mask1
, 0))
10882 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
10883 TREE_OPERAND (arg0
, 0), mask1
);
10884 return fold_build2_loc (loc
, MINUS_EXPR
, type
, tem
, mask1
);
10889 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10890 else if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 1))
10891 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10893 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10894 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10895 (-ARG1 + ARG0) reduces to -ARG1. */
10896 else if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10897 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10899 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10900 __complex__ ( x, -y ). This is not the same for SNaNs or if
10901 signed zeros are involved. */
10902 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10903 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10904 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10906 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10907 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10908 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10909 bool arg0rz
= false, arg0iz
= false;
10910 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10911 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10913 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10914 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10915 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10917 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10919 : build1 (REALPART_EXPR
, rtype
, arg1
));
10920 tree ip
= arg0i
? arg0i
10921 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10922 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10924 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10926 tree rp
= arg0r
? arg0r
10927 : build1 (REALPART_EXPR
, rtype
, arg0
);
10928 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10930 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
10931 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10936 /* Fold &x - &x. This can happen from &x.foo - &x.
10937 This is unsafe for certain floats even in non-IEEE formats.
10938 In IEEE, it is unsafe because it does wrong for NaNs.
10939 Also note that operand_equal_p is always false if an operand
10942 if ((!FLOAT_TYPE_P (type
) || !HONOR_NANS (TYPE_MODE (type
)))
10943 && operand_equal_p (arg0
, arg1
, 0))
10944 return build_zero_cst (type
);
10946 /* A - B -> A + (-B) if B is easily negatable. */
10947 if (negate_expr_p (arg1
)
10948 && ((FLOAT_TYPE_P (type
)
10949 /* Avoid this transformation if B is a positive REAL_CST. */
10950 && (TREE_CODE (arg1
) != REAL_CST
10951 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
))))
10952 || INTEGRAL_TYPE_P (type
)))
10953 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10954 fold_convert_loc (loc
, type
, arg0
),
10955 fold_convert_loc (loc
, type
,
10956 negate_expr (arg1
)));
10958 /* Try folding difference of addresses. */
10960 HOST_WIDE_INT diff
;
10962 if ((TREE_CODE (arg0
) == ADDR_EXPR
10963 || TREE_CODE (arg1
) == ADDR_EXPR
)
10964 && ptr_difference_const (arg0
, arg1
, &diff
))
10965 return build_int_cst_type (type
, diff
);
10968 /* Fold &a[i] - &a[j] to i-j. */
10969 if (TREE_CODE (arg0
) == ADDR_EXPR
10970 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
10971 && TREE_CODE (arg1
) == ADDR_EXPR
10972 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
10974 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
10975 TREE_OPERAND (arg0
, 0),
10976 TREE_OPERAND (arg1
, 0));
10981 if (FLOAT_TYPE_P (type
)
10982 && flag_unsafe_math_optimizations
10983 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10984 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10985 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10988 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
10989 one. Make sure the type is not saturating and has the signedness of
10990 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10991 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10992 if ((TREE_CODE (arg0
) == MULT_EXPR
10993 || TREE_CODE (arg1
) == MULT_EXPR
)
10994 && !TYPE_SATURATING (type
)
10995 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10996 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10997 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10999 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
11007 /* (-A) * (-B) -> A * B */
11008 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
11009 return fold_build2_loc (loc
, MULT_EXPR
, type
,
11010 fold_convert_loc (loc
, type
,
11011 TREE_OPERAND (arg0
, 0)),
11012 fold_convert_loc (loc
, type
,
11013 negate_expr (arg1
)));
11014 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
11015 return fold_build2_loc (loc
, MULT_EXPR
, type
,
11016 fold_convert_loc (loc
, type
,
11017 negate_expr (arg0
)),
11018 fold_convert_loc (loc
, type
,
11019 TREE_OPERAND (arg1
, 0)));
11021 if (! FLOAT_TYPE_P (type
))
11023 if (integer_zerop (arg1
))
11024 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11025 if (integer_onep (arg1
))
11026 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11027 /* Transform x * -1 into -x. Make sure to do the negation
11028 on the original operand with conversions not stripped
11029 because we can only strip non-sign-changing conversions. */
11030 if (integer_minus_onep (arg1
))
11031 return fold_convert_loc (loc
, type
, negate_expr (op0
));
11032 /* Transform x * -C into -x * C if x is easily negatable. */
11033 if (TREE_CODE (arg1
) == INTEGER_CST
11034 && tree_int_cst_sgn (arg1
) == -1
11035 && negate_expr_p (arg0
)
11036 && (tem
= negate_expr (arg1
)) != arg1
11037 && !TREE_OVERFLOW (tem
))
11038 return fold_build2_loc (loc
, MULT_EXPR
, type
,
11039 fold_convert_loc (loc
, type
,
11040 negate_expr (arg0
)),
11043 /* (a * (1 << b)) is (a << b) */
11044 if (TREE_CODE (arg1
) == LSHIFT_EXPR
11045 && integer_onep (TREE_OPERAND (arg1
, 0)))
11046 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op0
,
11047 TREE_OPERAND (arg1
, 1));
11048 if (TREE_CODE (arg0
) == LSHIFT_EXPR
11049 && integer_onep (TREE_OPERAND (arg0
, 0)))
11050 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op1
,
11051 TREE_OPERAND (arg0
, 1));
11053 /* (A + A) * C -> A * 2 * C */
11054 if (TREE_CODE (arg0
) == PLUS_EXPR
11055 && TREE_CODE (arg1
) == INTEGER_CST
11056 && operand_equal_p (TREE_OPERAND (arg0
, 0),
11057 TREE_OPERAND (arg0
, 1), 0))
11058 return fold_build2_loc (loc
, MULT_EXPR
, type
,
11059 omit_one_operand_loc (loc
, type
,
11060 TREE_OPERAND (arg0
, 0),
11061 TREE_OPERAND (arg0
, 1)),
11062 fold_build2_loc (loc
, MULT_EXPR
, type
,
11063 build_int_cst (type
, 2) , arg1
));
11065 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
11066 sign-changing only. */
11067 if (TREE_CODE (arg1
) == INTEGER_CST
11068 && TREE_CODE (arg0
) == EXACT_DIV_EXPR
11069 && operand_equal_p (arg1
, TREE_OPERAND (arg0
, 1), 0))
11070 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11072 strict_overflow_p
= false;
11073 if (TREE_CODE (arg1
) == INTEGER_CST
11074 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
11075 &strict_overflow_p
)))
11077 if (strict_overflow_p
)
11078 fold_overflow_warning (("assuming signed overflow does not "
11079 "occur when simplifying "
11081 WARN_STRICT_OVERFLOW_MISC
);
11082 return fold_convert_loc (loc
, type
, tem
);
11085 /* Optimize z * conj(z) for integer complex numbers. */
11086 if (TREE_CODE (arg0
) == CONJ_EXPR
11087 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11088 return fold_mult_zconjz (loc
, type
, arg1
);
11089 if (TREE_CODE (arg1
) == CONJ_EXPR
11090 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11091 return fold_mult_zconjz (loc
, type
, arg0
);
11095 /* Maybe fold x * 0 to 0. The expressions aren't the same
11096 when x is NaN, since x * 0 is also NaN. Nor are they the
11097 same in modes with signed zeros, since multiplying a
11098 negative value by 0 gives -0, not +0. */
11099 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
11100 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
11101 && real_zerop (arg1
))
11102 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11103 /* In IEEE floating point, x*1 is not equivalent to x for snans.
11104 Likewise for complex arithmetic with signed zeros. */
11105 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11106 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
11107 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
11108 && real_onep (arg1
))
11109 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11111 /* Transform x * -1.0 into -x. */
11112 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11113 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
11114 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
11115 && real_minus_onep (arg1
))
11116 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
11118 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
11119 the result for floating point types due to rounding so it is applied
11120 only if -fassociative-math was specify. */
11121 if (flag_associative_math
11122 && TREE_CODE (arg0
) == RDIV_EXPR
11123 && TREE_CODE (arg1
) == REAL_CST
11124 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
)
11126 tree tem
= const_binop (MULT_EXPR
, TREE_OPERAND (arg0
, 0),
11129 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
11130 TREE_OPERAND (arg0
, 1));
11133 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
11134 if (operand_equal_p (arg0
, arg1
, 0))
11136 tree tem
= fold_strip_sign_ops (arg0
);
11137 if (tem
!= NULL_TREE
)
11139 tem
= fold_convert_loc (loc
, type
, tem
);
11140 return fold_build2_loc (loc
, MULT_EXPR
, type
, tem
, tem
);
11144 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
11145 This is not the same for NaNs or if signed zeros are
11147 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
11148 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
11149 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11150 && TREE_CODE (arg1
) == COMPLEX_CST
11151 && real_zerop (TREE_REALPART (arg1
)))
11153 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
11154 if (real_onep (TREE_IMAGPART (arg1
)))
11156 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
11157 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
11159 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
11160 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
11162 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
11163 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
11164 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
11168 /* Optimize z * conj(z) for floating point complex numbers.
11169 Guarded by flag_unsafe_math_optimizations as non-finite
11170 imaginary components don't produce scalar results. */
11171 if (flag_unsafe_math_optimizations
11172 && TREE_CODE (arg0
) == CONJ_EXPR
11173 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11174 return fold_mult_zconjz (loc
, type
, arg1
);
11175 if (flag_unsafe_math_optimizations
11176 && TREE_CODE (arg1
) == CONJ_EXPR
11177 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11178 return fold_mult_zconjz (loc
, type
, arg0
);
11180 if (flag_unsafe_math_optimizations
)
11182 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
11183 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
11185 /* Optimizations of root(...)*root(...). */
11186 if (fcode0
== fcode1
&& BUILTIN_ROOT_P (fcode0
))
11189 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11190 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11192 /* Optimize sqrt(x)*sqrt(x) as x. */
11193 if (BUILTIN_SQRT_P (fcode0
)
11194 && operand_equal_p (arg00
, arg10
, 0)
11195 && ! HONOR_SNANS (TYPE_MODE (type
)))
11198 /* Optimize root(x)*root(y) as root(x*y). */
11199 rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11200 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg00
, arg10
);
11201 return build_call_expr_loc (loc
, rootfn
, 1, arg
);
11204 /* Optimize expN(x)*expN(y) as expN(x+y). */
11205 if (fcode0
== fcode1
&& BUILTIN_EXPONENT_P (fcode0
))
11207 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11208 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
11209 CALL_EXPR_ARG (arg0
, 0),
11210 CALL_EXPR_ARG (arg1
, 0));
11211 return build_call_expr_loc (loc
, expfn
, 1, arg
);
11214 /* Optimizations of pow(...)*pow(...). */
11215 if ((fcode0
== BUILT_IN_POW
&& fcode1
== BUILT_IN_POW
)
11216 || (fcode0
== BUILT_IN_POWF
&& fcode1
== BUILT_IN_POWF
)
11217 || (fcode0
== BUILT_IN_POWL
&& fcode1
== BUILT_IN_POWL
))
11219 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11220 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11221 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11222 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
11224 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
11225 if (operand_equal_p (arg01
, arg11
, 0))
11227 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11228 tree arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
11230 return build_call_expr_loc (loc
, powfn
, 2, arg
, arg01
);
11233 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
11234 if (operand_equal_p (arg00
, arg10
, 0))
11236 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11237 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
11239 return build_call_expr_loc (loc
, powfn
, 2, arg00
, arg
);
11243 /* Optimize tan(x)*cos(x) as sin(x). */
11244 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_COS
)
11245 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_COSF
)
11246 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_COSL
)
11247 || (fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_TAN
)
11248 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_TANF
)
11249 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_TANL
))
11250 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11251 CALL_EXPR_ARG (arg1
, 0), 0))
11253 tree sinfn
= mathfn_built_in (type
, BUILT_IN_SIN
);
11255 if (sinfn
!= NULL_TREE
)
11256 return build_call_expr_loc (loc
, sinfn
, 1,
11257 CALL_EXPR_ARG (arg0
, 0));
11260 /* Optimize x*pow(x,c) as pow(x,c+1). */
11261 if (fcode1
== BUILT_IN_POW
11262 || fcode1
== BUILT_IN_POWF
11263 || fcode1
== BUILT_IN_POWL
)
11265 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
11266 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
11267 if (TREE_CODE (arg11
) == REAL_CST
11268 && !TREE_OVERFLOW (arg11
)
11269 && operand_equal_p (arg0
, arg10
, 0))
11271 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
11275 c
= TREE_REAL_CST (arg11
);
11276 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
11277 arg
= build_real (type
, c
);
11278 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11282 /* Optimize pow(x,c)*x as pow(x,c+1). */
11283 if (fcode0
== BUILT_IN_POW
11284 || fcode0
== BUILT_IN_POWF
11285 || fcode0
== BUILT_IN_POWL
)
11287 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11288 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11289 if (TREE_CODE (arg01
) == REAL_CST
11290 && !TREE_OVERFLOW (arg01
)
11291 && operand_equal_p (arg1
, arg00
, 0))
11293 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11297 c
= TREE_REAL_CST (arg01
);
11298 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
11299 arg
= build_real (type
, c
);
11300 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
11304 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
11305 if (!in_gimple_form
11307 && operand_equal_p (arg0
, arg1
, 0))
11309 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
11313 tree arg
= build_real (type
, dconst2
);
11314 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11323 if (integer_all_onesp (arg1
))
11324 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11325 if (integer_zerop (arg1
))
11326 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11327 if (operand_equal_p (arg0
, arg1
, 0))
11328 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11330 /* ~X | X is -1. */
11331 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11332 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11334 t1
= build_zero_cst (type
);
11335 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11336 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11339 /* X | ~X is -1. */
11340 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11341 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11343 t1
= build_zero_cst (type
);
11344 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11345 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11348 /* Canonicalize (X & C1) | C2. */
11349 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11350 && TREE_CODE (arg1
) == INTEGER_CST
11351 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11353 int width
= TYPE_PRECISION (type
), w
;
11354 wide_int c1
= TREE_OPERAND (arg0
, 1);
11355 wide_int c2
= arg1
;
11357 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11358 if ((c1
& c2
) == c1
)
11359 return omit_one_operand_loc (loc
, type
, arg1
,
11360 TREE_OPERAND (arg0
, 0));
11362 wide_int msk
= wi::mask (width
, false,
11363 TYPE_PRECISION (TREE_TYPE (arg1
)));
11365 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11366 if (msk
.and_not (c1
| c2
) == 0)
11367 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11368 TREE_OPERAND (arg0
, 0), arg1
);
11370 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11371 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11372 mode which allows further optimizations. */
11375 wide_int c3
= c1
.and_not (c2
);
11376 for (w
= BITS_PER_UNIT
; w
<= width
; w
<<= 1)
11378 wide_int mask
= wi::mask (w
, false,
11379 TYPE_PRECISION (type
));
11380 if (((c1
| c2
) & mask
) == mask
&& c1
.and_not (mask
) == 0)
11388 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11389 fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11390 TREE_OPERAND (arg0
, 0),
11391 wide_int_to_tree (type
,
11396 /* (X & Y) | Y is (X, Y). */
11397 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11398 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11399 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11400 /* (X & Y) | X is (Y, X). */
11401 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11402 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11403 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11404 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11405 /* X | (X & Y) is (Y, X). */
11406 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11407 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11408 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11409 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11410 /* X | (Y & X) is (Y, X). */
11411 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11412 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11413 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11414 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11416 /* (X & ~Y) | (~X & Y) is X ^ Y */
11417 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11418 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
11420 tree a0
, a1
, l0
, l1
, n0
, n1
;
11422 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11423 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11425 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11426 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11428 n0
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l0
);
11429 n1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l1
);
11431 if ((operand_equal_p (n0
, a0
, 0)
11432 && operand_equal_p (n1
, a1
, 0))
11433 || (operand_equal_p (n0
, a1
, 0)
11434 && operand_equal_p (n1
, a0
, 0)))
11435 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, l0
, n1
);
11438 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11439 if (t1
!= NULL_TREE
)
11442 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11444 This results in more efficient code for machines without a NAND
11445 instruction. Combine will canonicalize to the first form
11446 which will allow use of NAND instructions provided by the
11447 backend if they exist. */
11448 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11449 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11452 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11453 build2 (BIT_AND_EXPR
, type
,
11454 fold_convert_loc (loc
, type
,
11455 TREE_OPERAND (arg0
, 0)),
11456 fold_convert_loc (loc
, type
,
11457 TREE_OPERAND (arg1
, 0))));
11460 /* See if this can be simplified into a rotate first. If that
11461 is unsuccessful continue in the association code. */
11465 if (integer_zerop (arg1
))
11466 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11467 if (integer_all_onesp (arg1
))
11468 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op0
);
11469 if (operand_equal_p (arg0
, arg1
, 0))
11470 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11472 /* ~X ^ X is -1. */
11473 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11474 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11476 t1
= build_zero_cst (type
);
11477 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11478 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11481 /* X ^ ~X is -1. */
11482 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11483 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11485 t1
= build_zero_cst (type
);
11486 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11487 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11490 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11491 with a constant, and the two constants have no bits in common,
11492 we should treat this as a BIT_IOR_EXPR since this may produce more
11493 simplifications. */
11494 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11495 && TREE_CODE (arg1
) == BIT_AND_EXPR
11496 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
11497 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
11498 && wi::bit_and (TREE_OPERAND (arg0
, 1),
11499 TREE_OPERAND (arg1
, 1)) == 0)
11501 code
= BIT_IOR_EXPR
;
11505 /* (X | Y) ^ X -> Y & ~ X*/
11506 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11507 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11509 tree t2
= TREE_OPERAND (arg0
, 1);
11510 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11512 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11513 fold_convert_loc (loc
, type
, t2
),
11514 fold_convert_loc (loc
, type
, t1
));
11518 /* (Y | X) ^ X -> Y & ~ X*/
11519 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11520 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11522 tree t2
= TREE_OPERAND (arg0
, 0);
11523 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11525 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11526 fold_convert_loc (loc
, type
, t2
),
11527 fold_convert_loc (loc
, type
, t1
));
11531 /* X ^ (X | Y) -> Y & ~ X*/
11532 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11533 && operand_equal_p (TREE_OPERAND (arg1
, 0), arg0
, 0))
11535 tree t2
= TREE_OPERAND (arg1
, 1);
11536 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11538 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11539 fold_convert_loc (loc
, type
, t2
),
11540 fold_convert_loc (loc
, type
, t1
));
11544 /* X ^ (Y | X) -> Y & ~ X*/
11545 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11546 && operand_equal_p (TREE_OPERAND (arg1
, 1), arg0
, 0))
11548 tree t2
= TREE_OPERAND (arg1
, 0);
11549 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11551 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11552 fold_convert_loc (loc
, type
, t2
),
11553 fold_convert_loc (loc
, type
, t1
));
11557 /* Convert ~X ^ ~Y to X ^ Y. */
11558 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11559 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11560 return fold_build2_loc (loc
, code
, type
,
11561 fold_convert_loc (loc
, type
,
11562 TREE_OPERAND (arg0
, 0)),
11563 fold_convert_loc (loc
, type
,
11564 TREE_OPERAND (arg1
, 0)));
11566 /* Convert ~X ^ C to X ^ ~C. */
11567 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11568 && TREE_CODE (arg1
) == INTEGER_CST
)
11569 return fold_build2_loc (loc
, code
, type
,
11570 fold_convert_loc (loc
, type
,
11571 TREE_OPERAND (arg0
, 0)),
11572 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, arg1
));
11574 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11575 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11576 && integer_onep (TREE_OPERAND (arg0
, 1))
11577 && integer_onep (arg1
))
11578 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
11579 build_zero_cst (TREE_TYPE (arg0
)));
11581 /* Fold (X & Y) ^ Y as ~X & Y. */
11582 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11583 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11585 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11586 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11587 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11588 fold_convert_loc (loc
, type
, arg1
));
11590 /* Fold (X & Y) ^ X as ~Y & X. */
11591 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11592 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11593 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11595 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11596 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11597 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11598 fold_convert_loc (loc
, type
, arg1
));
11600 /* Fold X ^ (X & Y) as X & ~Y. */
11601 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11602 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11604 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11605 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11606 fold_convert_loc (loc
, type
, arg0
),
11607 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11609 /* Fold X ^ (Y & X) as ~Y & X. */
11610 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11611 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11612 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11614 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11615 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11616 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11617 fold_convert_loc (loc
, type
, arg0
));
11620 /* See if this can be simplified into a rotate first. If that
11621 is unsuccessful continue in the association code. */
11625 if (integer_all_onesp (arg1
))
11626 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11627 if (integer_zerop (arg1
))
11628 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11629 if (operand_equal_p (arg0
, arg1
, 0))
11630 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11632 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
11633 if ((TREE_CODE (arg0
) == BIT_NOT_EXPR
11634 || TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11635 || (TREE_CODE (arg0
) == EQ_EXPR
11636 && integer_zerop (TREE_OPERAND (arg0
, 1))))
11637 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11638 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
11640 /* X & ~X , X & (X == 0), and X & !X are always zero. */
11641 if ((TREE_CODE (arg1
) == BIT_NOT_EXPR
11642 || TREE_CODE (arg1
) == TRUTH_NOT_EXPR
11643 || (TREE_CODE (arg1
) == EQ_EXPR
11644 && integer_zerop (TREE_OPERAND (arg1
, 1))))
11645 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11646 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11648 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11649 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11650 && TREE_CODE (arg1
) == INTEGER_CST
11651 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11653 tree tmp1
= fold_convert_loc (loc
, type
, arg1
);
11654 tree tmp2
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11655 tree tmp3
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11656 tmp2
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp2
, tmp1
);
11657 tmp3
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp3
, tmp1
);
11659 fold_convert_loc (loc
, type
,
11660 fold_build2_loc (loc
, BIT_IOR_EXPR
,
11661 type
, tmp2
, tmp3
));
11664 /* (X | Y) & Y is (X, Y). */
11665 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11666 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11667 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11668 /* (X | Y) & X is (Y, X). */
11669 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11670 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11671 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11672 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11673 /* X & (X | Y) is (Y, X). */
11674 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11675 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11676 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11677 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11678 /* X & (Y | X) is (Y, X). */
11679 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11680 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11681 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11682 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11684 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11685 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11686 && integer_onep (TREE_OPERAND (arg0
, 1))
11687 && integer_onep (arg1
))
11690 tem
= TREE_OPERAND (arg0
, 0);
11691 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11692 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11694 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11695 build_zero_cst (TREE_TYPE (tem
)));
11697 /* Fold ~X & 1 as (X & 1) == 0. */
11698 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11699 && integer_onep (arg1
))
11702 tem
= TREE_OPERAND (arg0
, 0);
11703 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11704 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11706 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11707 build_zero_cst (TREE_TYPE (tem
)));
11709 /* Fold !X & 1 as X == 0. */
11710 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11711 && integer_onep (arg1
))
11713 tem
= TREE_OPERAND (arg0
, 0);
11714 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
11715 build_zero_cst (TREE_TYPE (tem
)));
11718 /* Fold (X ^ Y) & Y as ~X & Y. */
11719 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11720 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11722 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11723 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11724 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11725 fold_convert_loc (loc
, type
, arg1
));
11727 /* Fold (X ^ Y) & X as ~Y & X. */
11728 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11729 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11730 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11732 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11733 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11734 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11735 fold_convert_loc (loc
, type
, arg1
));
11737 /* Fold X & (X ^ Y) as X & ~Y. */
11738 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11739 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11741 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11742 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11743 fold_convert_loc (loc
, type
, arg0
),
11744 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11746 /* Fold X & (Y ^ X) as ~Y & X. */
11747 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11748 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11749 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11751 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11752 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11753 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11754 fold_convert_loc (loc
, type
, arg0
));
11757 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11758 multiple of 1 << CST. */
11759 if (TREE_CODE (arg1
) == INTEGER_CST
)
11761 wide_int cst1
= arg1
;
11762 wide_int ncst1
= -cst1
;
11763 if ((cst1
& ncst1
) == ncst1
11764 && multiple_of_p (type
, arg0
,
11765 wide_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
11766 return fold_convert_loc (loc
, type
, arg0
);
11769 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
11771 if (TREE_CODE (arg1
) == INTEGER_CST
11772 && TREE_CODE (arg0
) == MULT_EXPR
11773 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11775 wide_int warg1
= arg1
;
11776 wide_int masked
= mask_with_tz (type
, warg1
, TREE_OPERAND (arg0
, 1));
11779 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
11781 else if (masked
!= warg1
)
11783 /* Avoid the transform if arg1 is a mask of some
11784 mode which allows further optimizations. */
11785 int pop
= wi::popcount (warg1
);
11786 if (!(pop
>= BITS_PER_UNIT
11787 && exact_log2 (pop
) != -1
11788 && wi::mask (pop
, false, warg1
.get_precision ()) == warg1
))
11789 return fold_build2_loc (loc
, code
, type
, op0
,
11790 wide_int_to_tree (type
, masked
));
11794 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11795 ((A & N) + B) & M -> (A + B) & M
11796 Similarly if (N & M) == 0,
11797 ((A | N) + B) & M -> (A + B) & M
11798 and for - instead of + (or unary - instead of +)
11799 and/or ^ instead of |.
11800 If B is constant and (B & M) == 0, fold into A & M. */
11801 if (TREE_CODE (arg1
) == INTEGER_CST
)
11803 wide_int cst1
= arg1
;
11804 if ((~cst1
!= 0) && (cst1
& (cst1
+ 1)) == 0
11805 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
11806 && (TREE_CODE (arg0
) == PLUS_EXPR
11807 || TREE_CODE (arg0
) == MINUS_EXPR
11808 || TREE_CODE (arg0
) == NEGATE_EXPR
)
11809 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
11810 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
11816 /* Now we know that arg0 is (C + D) or (C - D) or
11817 -C and arg1 (M) is == (1LL << cst) - 1.
11818 Store C into PMOP[0] and D into PMOP[1]. */
11819 pmop
[0] = TREE_OPERAND (arg0
, 0);
11821 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
11823 pmop
[1] = TREE_OPERAND (arg0
, 1);
11827 if ((wi::max_value (TREE_TYPE (arg0
)) & cst1
) != cst1
)
11830 for (; which
>= 0; which
--)
11831 switch (TREE_CODE (pmop
[which
]))
11836 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
11839 cst0
= TREE_OPERAND (pmop
[which
], 1);
11841 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
11846 else if (cst0
!= 0)
11848 /* If C or D is of the form (A & N) where
11849 (N & M) == M, or of the form (A | N) or
11850 (A ^ N) where (N & M) == 0, replace it with A. */
11851 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
11854 /* If C or D is a N where (N & M) == 0, it can be
11855 omitted (assumed 0). */
11856 if ((TREE_CODE (arg0
) == PLUS_EXPR
11857 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
11858 && (cst1
& pmop
[which
]) == 0)
11859 pmop
[which
] = NULL
;
11865 /* Only build anything new if we optimized one or both arguments
11867 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
11868 || (TREE_CODE (arg0
) != NEGATE_EXPR
11869 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
11871 tree utype
= TREE_TYPE (arg0
);
11872 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
11874 /* Perform the operations in a type that has defined
11875 overflow behavior. */
11876 utype
= unsigned_type_for (TREE_TYPE (arg0
));
11877 if (pmop
[0] != NULL
)
11878 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
11879 if (pmop
[1] != NULL
)
11880 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
11883 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
11884 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
11885 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
11887 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
11888 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
11890 else if (pmop
[0] != NULL
)
11892 else if (pmop
[1] != NULL
)
11895 return build_int_cst (type
, 0);
11897 else if (pmop
[0] == NULL
)
11898 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
11900 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
11902 /* TEM is now the new binary +, - or unary - replacement. */
11903 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
11904 fold_convert_loc (loc
, utype
, arg1
));
11905 return fold_convert_loc (loc
, type
, tem
);
11910 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11911 if (t1
!= NULL_TREE
)
11913 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11914 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
11915 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
11917 prec
= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
11919 wide_int mask
= wide_int::from (arg1
, prec
, UNSIGNED
);
11922 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11925 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11927 This results in more efficient code for machines without a NOR
11928 instruction. Combine will canonicalize to the first form
11929 which will allow use of NOR instructions provided by the
11930 backend if they exist. */
11931 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11932 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11934 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11935 build2 (BIT_IOR_EXPR
, type
,
11936 fold_convert_loc (loc
, type
,
11937 TREE_OPERAND (arg0
, 0)),
11938 fold_convert_loc (loc
, type
,
11939 TREE_OPERAND (arg1
, 0))));
11942 /* If arg0 is derived from the address of an object or function, we may
11943 be able to fold this expression using the object or function's
11945 if (POINTER_TYPE_P (TREE_TYPE (arg0
)) && tree_fits_uhwi_p (arg1
))
11947 unsigned HOST_WIDE_INT modulus
, residue
;
11948 unsigned HOST_WIDE_INT low
= tree_to_uhwi (arg1
);
11950 modulus
= get_pointer_modulus_and_residue (arg0
, &residue
,
11951 integer_onep (arg1
));
11953 /* This works because modulus is a power of 2. If this weren't the
11954 case, we'd have to replace it by its greatest power-of-2
11955 divisor: modulus & -modulus. */
11957 return build_int_cst (type
, residue
& low
);
11960 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11961 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11962 if the new mask might be further optimized. */
11963 if ((TREE_CODE (arg0
) == LSHIFT_EXPR
11964 || TREE_CODE (arg0
) == RSHIFT_EXPR
)
11965 && TYPE_PRECISION (TREE_TYPE (arg0
)) <= HOST_BITS_PER_WIDE_INT
11966 && TREE_CODE (arg1
) == INTEGER_CST
11967 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
11968 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) > 0
11969 && (tree_to_uhwi (TREE_OPERAND (arg0
, 1))
11970 < TYPE_PRECISION (TREE_TYPE (arg0
))))
11972 unsigned int shiftc
= tree_to_uhwi (TREE_OPERAND (arg0
, 1));
11973 unsigned HOST_WIDE_INT mask
= TREE_INT_CST_LOW (arg1
);
11974 unsigned HOST_WIDE_INT newmask
, zerobits
= 0;
11975 tree shift_type
= TREE_TYPE (arg0
);
11977 if (TREE_CODE (arg0
) == LSHIFT_EXPR
)
11978 zerobits
= ((((unsigned HOST_WIDE_INT
) 1) << shiftc
) - 1);
11979 else if (TREE_CODE (arg0
) == RSHIFT_EXPR
11980 && TYPE_PRECISION (TREE_TYPE (arg0
))
11981 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg0
))))
11983 prec
= TYPE_PRECISION (TREE_TYPE (arg0
));
11984 tree arg00
= TREE_OPERAND (arg0
, 0);
11985 /* See if more bits can be proven as zero because of
11987 if (TREE_CODE (arg00
) == NOP_EXPR
11988 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00
, 0))))
11990 tree inner_type
= TREE_TYPE (TREE_OPERAND (arg00
, 0));
11991 if (TYPE_PRECISION (inner_type
)
11992 == GET_MODE_PRECISION (TYPE_MODE (inner_type
))
11993 && TYPE_PRECISION (inner_type
) < prec
)
11995 prec
= TYPE_PRECISION (inner_type
);
11996 /* See if we can shorten the right shift. */
11998 shift_type
= inner_type
;
11999 /* Otherwise X >> C1 is all zeros, so we'll optimize
12000 it into (X, 0) later on by making sure zerobits
12004 zerobits
= ~(unsigned HOST_WIDE_INT
) 0;
12007 zerobits
>>= HOST_BITS_PER_WIDE_INT
- shiftc
;
12008 zerobits
<<= prec
- shiftc
;
12010 /* For arithmetic shift if sign bit could be set, zerobits
12011 can contain actually sign bits, so no transformation is
12012 possible, unless MASK masks them all away. In that
12013 case the shift needs to be converted into logical shift. */
12014 if (!TYPE_UNSIGNED (TREE_TYPE (arg0
))
12015 && prec
== TYPE_PRECISION (TREE_TYPE (arg0
)))
12017 if ((mask
& zerobits
) == 0)
12018 shift_type
= unsigned_type_for (TREE_TYPE (arg0
));
12024 /* ((X << 16) & 0xff00) is (X, 0). */
12025 if ((mask
& zerobits
) == mask
)
12026 return omit_one_operand_loc (loc
, type
,
12027 build_int_cst (type
, 0), arg0
);
12029 newmask
= mask
| zerobits
;
12030 if (newmask
!= mask
&& (newmask
& (newmask
+ 1)) == 0)
12032 /* Only do the transformation if NEWMASK is some integer
12034 for (prec
= BITS_PER_UNIT
;
12035 prec
< HOST_BITS_PER_WIDE_INT
; prec
<<= 1)
12036 if (newmask
== (((unsigned HOST_WIDE_INT
) 1) << prec
) - 1)
12038 if (prec
< HOST_BITS_PER_WIDE_INT
12039 || newmask
== ~(unsigned HOST_WIDE_INT
) 0)
12043 if (shift_type
!= TREE_TYPE (arg0
))
12045 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), shift_type
,
12046 fold_convert_loc (loc
, shift_type
,
12047 TREE_OPERAND (arg0
, 0)),
12048 TREE_OPERAND (arg0
, 1));
12049 tem
= fold_convert_loc (loc
, type
, tem
);
12053 newmaskt
= build_int_cst_type (TREE_TYPE (op1
), newmask
);
12054 if (!tree_int_cst_equal (newmaskt
, arg1
))
12055 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tem
, newmaskt
);
12063 /* Don't touch a floating-point divide by zero unless the mode
12064 of the constant can represent infinity. */
12065 if (TREE_CODE (arg1
) == REAL_CST
12066 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
12067 && real_zerop (arg1
))
12070 /* Optimize A / A to 1.0 if we don't care about
12071 NaNs or Infinities. Skip the transformation
12072 for non-real operands. */
12073 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0
))
12074 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
12075 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0
)))
12076 && operand_equal_p (arg0
, arg1
, 0))
12078 tree r
= build_real (TREE_TYPE (arg0
), dconst1
);
12080 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
12083 /* The complex version of the above A / A optimization. */
12084 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
12085 && operand_equal_p (arg0
, arg1
, 0))
12087 tree elem_type
= TREE_TYPE (TREE_TYPE (arg0
));
12088 if (! HONOR_NANS (TYPE_MODE (elem_type
))
12089 && ! HONOR_INFINITIES (TYPE_MODE (elem_type
)))
12091 tree r
= build_real (elem_type
, dconst1
);
12092 /* omit_two_operands will call fold_convert for us. */
12093 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
12097 /* (-A) / (-B) -> A / B */
12098 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
12099 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12100 TREE_OPERAND (arg0
, 0),
12101 negate_expr (arg1
));
12102 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
12103 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12104 negate_expr (arg0
),
12105 TREE_OPERAND (arg1
, 0));
12107 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
12108 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
12109 && real_onep (arg1
))
12110 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12112 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
12113 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
12114 && real_minus_onep (arg1
))
12115 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
,
12116 negate_expr (arg0
)));
12118 /* If ARG1 is a constant, we can convert this to a multiply by the
12119 reciprocal. This does not have the same rounding properties,
12120 so only do this if -freciprocal-math. We can actually
12121 always safely do it if ARG1 is a power of two, but it's hard to
12122 tell if it is or not in a portable manner. */
12124 && (TREE_CODE (arg1
) == REAL_CST
12125 || (TREE_CODE (arg1
) == COMPLEX_CST
12126 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg1
)))
12127 || (TREE_CODE (arg1
) == VECTOR_CST
12128 && VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg1
)))))
12130 if (flag_reciprocal_math
12131 && 0 != (tem
= const_binop (code
, build_one_cst (type
), arg1
)))
12132 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tem
);
12133 /* Find the reciprocal if optimizing and the result is exact.
12134 TODO: Complex reciprocal not implemented. */
12135 if (TREE_CODE (arg1
) != COMPLEX_CST
)
12137 tree inverse
= exact_inverse (TREE_TYPE (arg0
), arg1
);
12140 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, inverse
);
12143 /* Convert A/B/C to A/(B*C). */
12144 if (flag_reciprocal_math
12145 && TREE_CODE (arg0
) == RDIV_EXPR
)
12146 return fold_build2_loc (loc
, RDIV_EXPR
, type
, TREE_OPERAND (arg0
, 0),
12147 fold_build2_loc (loc
, MULT_EXPR
, type
,
12148 TREE_OPERAND (arg0
, 1), arg1
));
12150 /* Convert A/(B/C) to (A/B)*C. */
12151 if (flag_reciprocal_math
12152 && TREE_CODE (arg1
) == RDIV_EXPR
)
12153 return fold_build2_loc (loc
, MULT_EXPR
, type
,
12154 fold_build2_loc (loc
, RDIV_EXPR
, type
, arg0
,
12155 TREE_OPERAND (arg1
, 0)),
12156 TREE_OPERAND (arg1
, 1));
12158 /* Convert C1/(X*C2) into (C1/C2)/X. */
12159 if (flag_reciprocal_math
12160 && TREE_CODE (arg1
) == MULT_EXPR
12161 && TREE_CODE (arg0
) == REAL_CST
12162 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
12164 tree tem
= const_binop (RDIV_EXPR
, arg0
,
12165 TREE_OPERAND (arg1
, 1));
12167 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
12168 TREE_OPERAND (arg1
, 0));
12171 if (flag_unsafe_math_optimizations
)
12173 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
12174 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
12176 /* Optimize sin(x)/cos(x) as tan(x). */
12177 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_COS
)
12178 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_COSF
)
12179 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_COSL
))
12180 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
12181 CALL_EXPR_ARG (arg1
, 0), 0))
12183 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
12185 if (tanfn
!= NULL_TREE
)
12186 return build_call_expr_loc (loc
, tanfn
, 1, CALL_EXPR_ARG (arg0
, 0));
12189 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
12190 if (((fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_SIN
)
12191 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_SINF
)
12192 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_SINL
))
12193 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
12194 CALL_EXPR_ARG (arg1
, 0), 0))
12196 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
12198 if (tanfn
!= NULL_TREE
)
12200 tree tmp
= build_call_expr_loc (loc
, tanfn
, 1,
12201 CALL_EXPR_ARG (arg0
, 0));
12202 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12203 build_real (type
, dconst1
), tmp
);
12207 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
12208 NaNs or Infinities. */
12209 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_TAN
)
12210 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_TANF
)
12211 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_TANL
)))
12213 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12214 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
12216 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
12217 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
12218 && operand_equal_p (arg00
, arg01
, 0))
12220 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
12222 if (cosfn
!= NULL_TREE
)
12223 return build_call_expr_loc (loc
, cosfn
, 1, arg00
);
12227 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
12228 NaNs or Infinities. */
12229 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_SIN
)
12230 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_SINF
)
12231 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_SINL
)))
12233 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12234 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
12236 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
12237 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
12238 && operand_equal_p (arg00
, arg01
, 0))
12240 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
12242 if (cosfn
!= NULL_TREE
)
12244 tree tmp
= build_call_expr_loc (loc
, cosfn
, 1, arg00
);
12245 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
12246 build_real (type
, dconst1
),
12252 /* Optimize pow(x,c)/x as pow(x,c-1). */
12253 if (fcode0
== BUILT_IN_POW
12254 || fcode0
== BUILT_IN_POWF
12255 || fcode0
== BUILT_IN_POWL
)
12257 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
12258 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
12259 if (TREE_CODE (arg01
) == REAL_CST
12260 && !TREE_OVERFLOW (arg01
)
12261 && operand_equal_p (arg1
, arg00
, 0))
12263 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
12267 c
= TREE_REAL_CST (arg01
);
12268 real_arithmetic (&c
, MINUS_EXPR
, &c
, &dconst1
);
12269 arg
= build_real (type
, c
);
12270 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
12274 /* Optimize a/root(b/c) into a*root(c/b). */
12275 if (BUILTIN_ROOT_P (fcode1
))
12277 tree rootarg
= CALL_EXPR_ARG (arg1
, 0);
12279 if (TREE_CODE (rootarg
) == RDIV_EXPR
)
12281 tree rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12282 tree b
= TREE_OPERAND (rootarg
, 0);
12283 tree c
= TREE_OPERAND (rootarg
, 1);
12285 tree tmp
= fold_build2_loc (loc
, RDIV_EXPR
, type
, c
, b
);
12287 tmp
= build_call_expr_loc (loc
, rootfn
, 1, tmp
);
12288 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tmp
);
12292 /* Optimize x/expN(y) into x*expN(-y). */
12293 if (BUILTIN_EXPONENT_P (fcode1
))
12295 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12296 tree arg
= negate_expr (CALL_EXPR_ARG (arg1
, 0));
12297 arg1
= build_call_expr_loc (loc
,
12299 fold_convert_loc (loc
, type
, arg
));
12300 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12303 /* Optimize x/pow(y,z) into x*pow(y,-z). */
12304 if (fcode1
== BUILT_IN_POW
12305 || fcode1
== BUILT_IN_POWF
12306 || fcode1
== BUILT_IN_POWL
)
12308 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12309 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
12310 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
12311 tree neg11
= fold_convert_loc (loc
, type
,
12312 negate_expr (arg11
));
12313 arg1
= build_call_expr_loc (loc
, powfn
, 2, arg10
, neg11
);
12314 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12319 case TRUNC_DIV_EXPR
:
12320 /* Optimize (X & (-A)) / A where A is a power of 2,
12322 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12323 && !TYPE_UNSIGNED (type
) && TREE_CODE (arg1
) == INTEGER_CST
12324 && integer_pow2p (arg1
) && tree_int_cst_sgn (arg1
) > 0)
12326 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (arg1
),
12327 arg1
, TREE_OPERAND (arg0
, 1));
12328 if (sum
&& integer_zerop (sum
)) {
12329 tree pow2
= build_int_cst (integer_type_node
,
12330 wi::exact_log2 (arg1
));
12331 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12332 TREE_OPERAND (arg0
, 0), pow2
);
12338 case FLOOR_DIV_EXPR
:
12339 /* Simplify A / (B << N) where A and B are positive and B is
12340 a power of 2, to A >> (N + log2(B)). */
12341 strict_overflow_p
= false;
12342 if (TREE_CODE (arg1
) == LSHIFT_EXPR
12343 && (TYPE_UNSIGNED (type
)
12344 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12346 tree sval
= TREE_OPERAND (arg1
, 0);
12347 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
12349 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
12350 tree pow2
= build_int_cst (TREE_TYPE (sh_cnt
),
12351 wi::exact_log2 (sval
));
12353 if (strict_overflow_p
)
12354 fold_overflow_warning (("assuming signed overflow does not "
12355 "occur when simplifying A / (B << N)"),
12356 WARN_STRICT_OVERFLOW_MISC
);
12358 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
12360 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12361 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
12365 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
12366 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
12367 if (INTEGRAL_TYPE_P (type
)
12368 && TYPE_UNSIGNED (type
)
12369 && code
== FLOOR_DIV_EXPR
)
12370 return fold_build2_loc (loc
, TRUNC_DIV_EXPR
, type
, op0
, op1
);
12374 case ROUND_DIV_EXPR
:
12375 case CEIL_DIV_EXPR
:
12376 case EXACT_DIV_EXPR
:
12377 if (integer_onep (arg1
))
12378 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12379 if (integer_zerop (arg1
))
12381 /* X / -1 is -X. */
12382 if (!TYPE_UNSIGNED (type
)
12383 && TREE_CODE (arg1
) == INTEGER_CST
12384 && wi::eq_p (arg1
, -1))
12385 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
12387 /* Convert -A / -B to A / B when the type is signed and overflow is
12389 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12390 && TREE_CODE (arg0
) == NEGATE_EXPR
12391 && negate_expr_p (arg1
))
12393 if (INTEGRAL_TYPE_P (type
))
12394 fold_overflow_warning (("assuming signed overflow does not occur "
12395 "when distributing negation across "
12397 WARN_STRICT_OVERFLOW_MISC
);
12398 return fold_build2_loc (loc
, code
, type
,
12399 fold_convert_loc (loc
, type
,
12400 TREE_OPERAND (arg0
, 0)),
12401 fold_convert_loc (loc
, type
,
12402 negate_expr (arg1
)));
12404 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12405 && TREE_CODE (arg1
) == NEGATE_EXPR
12406 && negate_expr_p (arg0
))
12408 if (INTEGRAL_TYPE_P (type
))
12409 fold_overflow_warning (("assuming signed overflow does not occur "
12410 "when distributing negation across "
12412 WARN_STRICT_OVERFLOW_MISC
);
12413 return fold_build2_loc (loc
, code
, type
,
12414 fold_convert_loc (loc
, type
,
12415 negate_expr (arg0
)),
12416 fold_convert_loc (loc
, type
,
12417 TREE_OPERAND (arg1
, 0)));
12420 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12421 operation, EXACT_DIV_EXPR.
12423 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12424 At one time others generated faster code, it's not clear if they do
12425 after the last round to changes to the DIV code in expmed.c. */
12426 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
12427 && multiple_of_p (type
, arg0
, arg1
))
12428 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
, arg0
, arg1
);
12430 strict_overflow_p
= false;
12431 if (TREE_CODE (arg1
) == INTEGER_CST
12432 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12433 &strict_overflow_p
)))
12435 if (strict_overflow_p
)
12436 fold_overflow_warning (("assuming signed overflow does not occur "
12437 "when simplifying division"),
12438 WARN_STRICT_OVERFLOW_MISC
);
12439 return fold_convert_loc (loc
, type
, tem
);
12444 case CEIL_MOD_EXPR
:
12445 case FLOOR_MOD_EXPR
:
12446 case ROUND_MOD_EXPR
:
12447 case TRUNC_MOD_EXPR
:
12448 /* X % 1 is always zero, but be sure to preserve any side
12450 if (integer_onep (arg1
))
12451 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12453 /* X % 0, return X % 0 unchanged so that we can get the
12454 proper warnings and errors. */
12455 if (integer_zerop (arg1
))
12458 /* 0 % X is always zero, but be sure to preserve any side
12459 effects in X. Place this after checking for X == 0. */
12460 if (integer_zerop (arg0
))
12461 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12463 /* X % -1 is zero. */
12464 if (!TYPE_UNSIGNED (type
)
12465 && TREE_CODE (arg1
) == INTEGER_CST
12466 && wi::eq_p (arg1
, -1))
12467 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12469 /* X % -C is the same as X % C. */
12470 if (code
== TRUNC_MOD_EXPR
12471 && TYPE_SIGN (type
) == SIGNED
12472 && TREE_CODE (arg1
) == INTEGER_CST
12473 && !TREE_OVERFLOW (arg1
)
12474 && wi::neg_p (arg1
)
12475 && !TYPE_OVERFLOW_TRAPS (type
)
12476 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
12477 && !sign_bit_p (arg1
, arg1
))
12478 return fold_build2_loc (loc
, code
, type
,
12479 fold_convert_loc (loc
, type
, arg0
),
12480 fold_convert_loc (loc
, type
,
12481 negate_expr (arg1
)));
12483 /* X % -Y is the same as X % Y. */
12484 if (code
== TRUNC_MOD_EXPR
12485 && !TYPE_UNSIGNED (type
)
12486 && TREE_CODE (arg1
) == NEGATE_EXPR
12487 && !TYPE_OVERFLOW_TRAPS (type
))
12488 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, arg0
),
12489 fold_convert_loc (loc
, type
,
12490 TREE_OPERAND (arg1
, 0)));
12492 strict_overflow_p
= false;
12493 if (TREE_CODE (arg1
) == INTEGER_CST
12494 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12495 &strict_overflow_p
)))
12497 if (strict_overflow_p
)
12498 fold_overflow_warning (("assuming signed overflow does not occur "
12499 "when simplifying modulus"),
12500 WARN_STRICT_OVERFLOW_MISC
);
12501 return fold_convert_loc (loc
, type
, tem
);
12504 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12505 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
12506 if ((code
== TRUNC_MOD_EXPR
|| code
== FLOOR_MOD_EXPR
)
12507 && (TYPE_UNSIGNED (type
)
12508 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12511 /* Also optimize A % (C << N) where C is a power of 2,
12512 to A & ((C << N) - 1). */
12513 if (TREE_CODE (arg1
) == LSHIFT_EXPR
)
12514 c
= TREE_OPERAND (arg1
, 0);
12516 if (integer_pow2p (c
) && tree_int_cst_sgn (c
) > 0)
12519 = fold_build2_loc (loc
, MINUS_EXPR
, TREE_TYPE (arg1
), arg1
,
12520 build_int_cst (TREE_TYPE (arg1
), 1));
12521 if (strict_overflow_p
)
12522 fold_overflow_warning (("assuming signed overflow does not "
12523 "occur when simplifying "
12524 "X % (power of two)"),
12525 WARN_STRICT_OVERFLOW_MISC
);
12526 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
12527 fold_convert_loc (loc
, type
, arg0
),
12528 fold_convert_loc (loc
, type
, mask
));
12536 if (integer_all_onesp (arg0
))
12537 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12541 /* Optimize -1 >> x for arithmetic right shifts. */
12542 if (integer_all_onesp (arg0
) && !TYPE_UNSIGNED (type
)
12543 && tree_expr_nonnegative_p (arg1
))
12544 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12545 /* ... fall through ... */
12549 if (integer_zerop (arg1
))
12550 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12551 if (integer_zerop (arg0
))
12552 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12554 /* Prefer vector1 << scalar to vector1 << vector2
12555 if vector2 is uniform. */
12556 if (VECTOR_TYPE_P (TREE_TYPE (arg1
))
12557 && (tem
= uniform_vector_p (arg1
)) != NULL_TREE
)
12558 return fold_build2_loc (loc
, code
, type
, op0
, tem
);
12560 /* Since negative shift count is not well-defined,
12561 don't try to compute it in the compiler. */
12562 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
12565 prec
= element_precision (type
);
12567 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
12568 if (TREE_CODE (op0
) == code
&& tree_fits_uhwi_p (arg1
)
12569 && tree_to_uhwi (arg1
) < prec
12570 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
12571 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) < prec
)
12573 unsigned int low
= (tree_to_uhwi (TREE_OPERAND (arg0
, 1))
12574 + tree_to_uhwi (arg1
));
12576 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12577 being well defined. */
12580 if (code
== LROTATE_EXPR
|| code
== RROTATE_EXPR
)
12582 else if (TYPE_UNSIGNED (type
) || code
== LSHIFT_EXPR
)
12583 return omit_one_operand_loc (loc
, type
, build_zero_cst (type
),
12584 TREE_OPERAND (arg0
, 0));
12589 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12590 build_int_cst (TREE_TYPE (arg1
), low
));
12593 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12594 into x & ((unsigned)-1 >> c) for unsigned types. */
12595 if (((code
== LSHIFT_EXPR
&& TREE_CODE (arg0
) == RSHIFT_EXPR
)
12596 || (TYPE_UNSIGNED (type
)
12597 && code
== RSHIFT_EXPR
&& TREE_CODE (arg0
) == LSHIFT_EXPR
))
12598 && tree_fits_uhwi_p (arg1
)
12599 && tree_to_uhwi (arg1
) < prec
12600 && tree_fits_uhwi_p (TREE_OPERAND (arg0
, 1))
12601 && tree_to_uhwi (TREE_OPERAND (arg0
, 1)) < prec
)
12603 HOST_WIDE_INT low0
= tree_to_uhwi (TREE_OPERAND (arg0
, 1));
12604 HOST_WIDE_INT low1
= tree_to_uhwi (arg1
);
12610 arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12612 lshift
= build_minus_one_cst (type
);
12613 lshift
= const_binop (code
, lshift
, arg1
);
12615 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, arg00
, lshift
);
12619 /* Rewrite an LROTATE_EXPR by a constant into an
12620 RROTATE_EXPR by a new constant. */
12621 if (code
== LROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
)
12623 tree tem
= build_int_cst (TREE_TYPE (arg1
), prec
);
12624 tem
= const_binop (MINUS_EXPR
, tem
, arg1
);
12625 return fold_build2_loc (loc
, RROTATE_EXPR
, type
, op0
, tem
);
12628 /* If we have a rotate of a bit operation with the rotate count and
12629 the second operand of the bit operation both constant,
12630 permute the two operations. */
12631 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12632 && (TREE_CODE (arg0
) == BIT_AND_EXPR
12633 || TREE_CODE (arg0
) == BIT_IOR_EXPR
12634 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12635 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12636 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
12637 fold_build2_loc (loc
, code
, type
,
12638 TREE_OPERAND (arg0
, 0), arg1
),
12639 fold_build2_loc (loc
, code
, type
,
12640 TREE_OPERAND (arg0
, 1), arg1
));
12642 /* Two consecutive rotates adding up to the some integer
12643 multiple of the precision of the type can be ignored. */
12644 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12645 && TREE_CODE (arg0
) == RROTATE_EXPR
12646 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
12647 && wi::umod_trunc (wi::add (arg1
, TREE_OPERAND (arg0
, 1)),
12649 return TREE_OPERAND (arg0
, 0);
12651 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12652 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12653 if the latter can be further optimized. */
12654 if ((code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
12655 && TREE_CODE (arg0
) == BIT_AND_EXPR
12656 && TREE_CODE (arg1
) == INTEGER_CST
12657 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12659 tree mask
= fold_build2_loc (loc
, code
, type
,
12660 fold_convert_loc (loc
, type
,
12661 TREE_OPERAND (arg0
, 1)),
12663 tree shift
= fold_build2_loc (loc
, code
, type
,
12664 fold_convert_loc (loc
, type
,
12665 TREE_OPERAND (arg0
, 0)),
12667 tem
= fold_binary_loc (loc
, BIT_AND_EXPR
, type
, shift
, mask
);
12675 if (operand_equal_p (arg0
, arg1
, 0))
12676 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12677 if (INTEGRAL_TYPE_P (type
)
12678 && operand_equal_p (arg1
, TYPE_MIN_VALUE (type
), OEP_ONLY_CONST
))
12679 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12680 tem
= fold_minmax (loc
, MIN_EXPR
, type
, arg0
, arg1
);
12686 if (operand_equal_p (arg0
, arg1
, 0))
12687 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12688 if (INTEGRAL_TYPE_P (type
)
12689 && TYPE_MAX_VALUE (type
)
12690 && operand_equal_p (arg1
, TYPE_MAX_VALUE (type
), OEP_ONLY_CONST
))
12691 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12692 tem
= fold_minmax (loc
, MAX_EXPR
, type
, arg0
, arg1
);
12697 case TRUTH_ANDIF_EXPR
:
12698 /* Note that the operands of this must be ints
12699 and their values must be 0 or 1.
12700 ("true" is a fixed value perhaps depending on the language.) */
12701 /* If first arg is constant zero, return it. */
12702 if (integer_zerop (arg0
))
12703 return fold_convert_loc (loc
, type
, arg0
);
12704 case TRUTH_AND_EXPR
:
12705 /* If either arg is constant true, drop it. */
12706 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12707 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12708 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
12709 /* Preserve sequence points. */
12710 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12711 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12712 /* If second arg is constant zero, result is zero, but first arg
12713 must be evaluated. */
12714 if (integer_zerop (arg1
))
12715 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12716 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12717 case will be handled here. */
12718 if (integer_zerop (arg0
))
12719 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12721 /* !X && X is always false. */
12722 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12723 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12724 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12725 /* X && !X is always false. */
12726 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12727 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12728 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12730 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12731 means A >= Y && A != MAX, but in this case we know that
12734 if (!TREE_SIDE_EFFECTS (arg0
)
12735 && !TREE_SIDE_EFFECTS (arg1
))
12737 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
12738 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
12739 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
12741 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
12742 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
12743 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
12746 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12752 case TRUTH_ORIF_EXPR
:
12753 /* Note that the operands of this must be ints
12754 and their values must be 0 or true.
12755 ("true" is a fixed value perhaps depending on the language.) */
12756 /* If first arg is constant true, return it. */
12757 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12758 return fold_convert_loc (loc
, type
, arg0
);
12759 case TRUTH_OR_EXPR
:
12760 /* If either arg is constant zero, drop it. */
12761 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
12762 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12763 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
12764 /* Preserve sequence points. */
12765 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12766 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12767 /* If second arg is constant true, result is true, but we must
12768 evaluate first arg. */
12769 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
12770 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12771 /* Likewise for first arg, but note this only occurs here for
12773 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12774 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12776 /* !X || X is always true. */
12777 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12778 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12779 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12780 /* X || !X is always true. */
12781 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12782 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12783 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12785 /* (X && !Y) || (!X && Y) is X ^ Y */
12786 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
12787 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
12789 tree a0
, a1
, l0
, l1
, n0
, n1
;
12791 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
12792 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
12794 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12795 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
12797 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
12798 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
12800 if ((operand_equal_p (n0
, a0
, 0)
12801 && operand_equal_p (n1
, a1
, 0))
12802 || (operand_equal_p (n0
, a1
, 0)
12803 && operand_equal_p (n1
, a0
, 0)))
12804 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
12807 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12813 case TRUTH_XOR_EXPR
:
12814 /* If the second arg is constant zero, drop it. */
12815 if (integer_zerop (arg1
))
12816 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12817 /* If the second arg is constant true, this is a logical inversion. */
12818 if (integer_onep (arg1
))
12820 tem
= invert_truthvalue_loc (loc
, arg0
);
12821 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
12823 /* Identical arguments cancel to zero. */
12824 if (operand_equal_p (arg0
, arg1
, 0))
12825 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12827 /* !X ^ X is always true. */
12828 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12829 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12830 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12832 /* X ^ !X is always true. */
12833 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12834 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12835 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12844 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
12845 if (tem
!= NULL_TREE
)
12848 /* bool_var != 0 becomes bool_var. */
12849 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12850 && code
== NE_EXPR
)
12851 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12853 /* bool_var == 1 becomes bool_var. */
12854 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12855 && code
== EQ_EXPR
)
12856 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12858 /* bool_var != 1 becomes !bool_var. */
12859 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12860 && code
== NE_EXPR
)
12861 return fold_convert_loc (loc
, type
,
12862 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12863 TREE_TYPE (arg0
), arg0
));
12865 /* bool_var == 0 becomes !bool_var. */
12866 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12867 && code
== EQ_EXPR
)
12868 return fold_convert_loc (loc
, type
,
12869 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12870 TREE_TYPE (arg0
), arg0
));
12872 /* !exp != 0 becomes !exp */
12873 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
12874 && code
== NE_EXPR
)
12875 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12877 /* If this is an equality comparison of the address of two non-weak,
12878 unaliased symbols neither of which are extern (since we do not
12879 have access to attributes for externs), then we know the result. */
12880 if (TREE_CODE (arg0
) == ADDR_EXPR
12881 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0
, 0))
12882 && ! DECL_WEAK (TREE_OPERAND (arg0
, 0))
12883 && ! lookup_attribute ("alias",
12884 DECL_ATTRIBUTES (TREE_OPERAND (arg0
, 0)))
12885 && ! DECL_EXTERNAL (TREE_OPERAND (arg0
, 0))
12886 && TREE_CODE (arg1
) == ADDR_EXPR
12887 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1
, 0))
12888 && ! DECL_WEAK (TREE_OPERAND (arg1
, 0))
12889 && ! lookup_attribute ("alias",
12890 DECL_ATTRIBUTES (TREE_OPERAND (arg1
, 0)))
12891 && ! DECL_EXTERNAL (TREE_OPERAND (arg1
, 0)))
12893 /* We know that we're looking at the address of two
12894 non-weak, unaliased, static _DECL nodes.
12896 It is both wasteful and incorrect to call operand_equal_p
12897 to compare the two ADDR_EXPR nodes. It is wasteful in that
12898 all we need to do is test pointer equality for the arguments
12899 to the two ADDR_EXPR nodes. It is incorrect to use
12900 operand_equal_p as that function is NOT equivalent to a
12901 C equality test. It can in fact return false for two
12902 objects which would test as equal using the C equality
12904 bool equal
= TREE_OPERAND (arg0
, 0) == TREE_OPERAND (arg1
, 0);
12905 return constant_boolean_node (equal
12906 ? code
== EQ_EXPR
: code
!= EQ_EXPR
,
12910 /* Similarly for a NEGATE_EXPR. */
12911 if (TREE_CODE (arg0
) == NEGATE_EXPR
12912 && TREE_CODE (arg1
) == INTEGER_CST
12913 && 0 != (tem
= negate_expr (fold_convert_loc (loc
, TREE_TYPE (arg0
),
12915 && TREE_CODE (tem
) == INTEGER_CST
12916 && !TREE_OVERFLOW (tem
))
12917 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
12919 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12920 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12921 && TREE_CODE (arg1
) == INTEGER_CST
12922 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12923 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12924 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg0
),
12925 fold_convert_loc (loc
,
12928 TREE_OPERAND (arg0
, 1)));
12930 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12931 if ((TREE_CODE (arg0
) == PLUS_EXPR
12932 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
12933 || TREE_CODE (arg0
) == MINUS_EXPR
)
12934 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12937 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
12938 || POINTER_TYPE_P (TREE_TYPE (arg0
))))
12940 tree val
= TREE_OPERAND (arg0
, 1);
12941 return omit_two_operands_loc (loc
, type
,
12942 fold_build2_loc (loc
, code
, type
,
12944 build_int_cst (TREE_TYPE (val
),
12946 TREE_OPERAND (arg0
, 0), arg1
);
12949 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12950 if (TREE_CODE (arg0
) == MINUS_EXPR
12951 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == INTEGER_CST
12952 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12955 && wi::extract_uhwi (TREE_OPERAND (arg0
, 0), 0, 1) == 1)
12957 return omit_two_operands_loc (loc
, type
,
12959 ? boolean_true_node
: boolean_false_node
,
12960 TREE_OPERAND (arg0
, 1), arg1
);
12963 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12964 if (TREE_CODE (arg0
) == ABS_EXPR
12965 && (integer_zerop (arg1
) || real_zerop (arg1
)))
12966 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), arg1
);
12968 /* If this is an EQ or NE comparison with zero and ARG0 is
12969 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12970 two operations, but the latter can be done in one less insn
12971 on machines that have only two-operand insns or on which a
12972 constant cannot be the first operand. */
12973 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12974 && integer_zerop (arg1
))
12976 tree arg00
= TREE_OPERAND (arg0
, 0);
12977 tree arg01
= TREE_OPERAND (arg0
, 1);
12978 if (TREE_CODE (arg00
) == LSHIFT_EXPR
12979 && integer_onep (TREE_OPERAND (arg00
, 0)))
12981 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
12982 arg01
, TREE_OPERAND (arg00
, 1));
12983 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12984 build_int_cst (TREE_TYPE (arg0
), 1));
12985 return fold_build2_loc (loc
, code
, type
,
12986 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12989 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
12990 && integer_onep (TREE_OPERAND (arg01
, 0)))
12992 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
12993 arg00
, TREE_OPERAND (arg01
, 1));
12994 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12995 build_int_cst (TREE_TYPE (arg0
), 1));
12996 return fold_build2_loc (loc
, code
, type
,
12997 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
13002 /* If this is an NE or EQ comparison of zero against the result of a
13003 signed MOD operation whose second operand is a power of 2, make
13004 the MOD operation unsigned since it is simpler and equivalent. */
13005 if (integer_zerop (arg1
)
13006 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
13007 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
13008 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
13009 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
13010 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
13011 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
13013 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
13014 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
13015 fold_convert_loc (loc
, newtype
,
13016 TREE_OPERAND (arg0
, 0)),
13017 fold_convert_loc (loc
, newtype
,
13018 TREE_OPERAND (arg0
, 1)));
13020 return fold_build2_loc (loc
, code
, type
, newmod
,
13021 fold_convert_loc (loc
, newtype
, arg1
));
13024 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
13025 C1 is a valid shift constant, and C2 is a power of two, i.e.
13027 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13028 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
13029 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
13031 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13032 && integer_zerop (arg1
))
13034 tree itype
= TREE_TYPE (arg0
);
13035 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
13036 prec
= TYPE_PRECISION (itype
);
13038 /* Check for a valid shift count. */
13039 if (wi::ltu_p (arg001
, prec
))
13041 tree arg01
= TREE_OPERAND (arg0
, 1);
13042 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
13043 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
13044 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
13045 can be rewritten as (X & (C2 << C1)) != 0. */
13046 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
13048 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
13049 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
13050 return fold_build2_loc (loc
, code
, type
, tem
,
13051 fold_convert_loc (loc
, itype
, arg1
));
13053 /* Otherwise, for signed (arithmetic) shifts,
13054 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
13055 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
13056 else if (!TYPE_UNSIGNED (itype
))
13057 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
13058 arg000
, build_int_cst (itype
, 0));
13059 /* Otherwise, of unsigned (logical) shifts,
13060 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
13061 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
13063 return omit_one_operand_loc (loc
, type
,
13064 code
== EQ_EXPR
? integer_one_node
13065 : integer_zero_node
,
13070 /* If we have (A & C) == C where C is a power of 2, convert this into
13071 (A & C) != 0. Similarly for NE_EXPR. */
13072 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13073 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13074 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
13075 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13076 arg0
, fold_convert_loc (loc
, TREE_TYPE (arg0
),
13077 integer_zero_node
));
13079 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
13080 bit, then fold the expression into A < 0 or A >= 0. */
13081 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
, type
);
13085 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
13086 Similarly for NE_EXPR. */
13087 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13088 && TREE_CODE (arg1
) == INTEGER_CST
13089 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
13091 tree notc
= fold_build1_loc (loc
, BIT_NOT_EXPR
,
13092 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
13093 TREE_OPERAND (arg0
, 1));
13095 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
13096 fold_convert_loc (loc
, TREE_TYPE (arg0
), arg1
),
13098 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
13099 if (integer_nonzerop (dandnotc
))
13100 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
13103 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
13104 Similarly for NE_EXPR. */
13105 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
13106 && TREE_CODE (arg1
) == INTEGER_CST
13107 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
13109 tree notd
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
), arg1
);
13111 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
13112 TREE_OPERAND (arg0
, 1),
13113 fold_convert_loc (loc
, TREE_TYPE (arg0
), notd
));
13114 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
13115 if (integer_nonzerop (candnotd
))
13116 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
13119 /* If this is a comparison of a field, we may be able to simplify it. */
13120 if ((TREE_CODE (arg0
) == COMPONENT_REF
13121 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
13122 /* Handle the constant case even without -O
13123 to make sure the warnings are given. */
13124 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
13126 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
13131 /* Optimize comparisons of strlen vs zero to a compare of the
13132 first character of the string vs zero. To wit,
13133 strlen(ptr) == 0 => *ptr == 0
13134 strlen(ptr) != 0 => *ptr != 0
13135 Other cases should reduce to one of these two (or a constant)
13136 due to the return value of strlen being unsigned. */
13137 if (TREE_CODE (arg0
) == CALL_EXPR
13138 && integer_zerop (arg1
))
13140 tree fndecl
= get_callee_fndecl (arg0
);
13143 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
13144 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
13145 && call_expr_nargs (arg0
) == 1
13146 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
13148 tree iref
= build_fold_indirect_ref_loc (loc
,
13149 CALL_EXPR_ARG (arg0
, 0));
13150 return fold_build2_loc (loc
, code
, type
, iref
,
13151 build_int_cst (TREE_TYPE (iref
), 0));
13155 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
13156 of X. Similarly fold (X >> C) == 0 into X >= 0. */
13157 if (TREE_CODE (arg0
) == RSHIFT_EXPR
13158 && integer_zerop (arg1
)
13159 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
13161 tree arg00
= TREE_OPERAND (arg0
, 0);
13162 tree arg01
= TREE_OPERAND (arg0
, 1);
13163 tree itype
= TREE_TYPE (arg00
);
13164 if (wi::eq_p (arg01
, TYPE_PRECISION (itype
) - 1))
13166 if (TYPE_UNSIGNED (itype
))
13168 itype
= signed_type_for (itype
);
13169 arg00
= fold_convert_loc (loc
, itype
, arg00
);
13171 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
13172 type
, arg00
, build_zero_cst (itype
));
13176 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
13177 if (integer_zerop (arg1
)
13178 && TREE_CODE (arg0
) == BIT_XOR_EXPR
)
13179 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
13180 TREE_OPERAND (arg0
, 1));
13182 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
13183 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13184 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
13185 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
13186 build_zero_cst (TREE_TYPE (arg0
)));
13187 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
13188 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13189 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13190 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
13191 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 1),
13192 build_zero_cst (TREE_TYPE (arg0
)));
13194 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
13195 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13196 && TREE_CODE (arg1
) == INTEGER_CST
13197 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
13198 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
13199 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg1
),
13200 TREE_OPERAND (arg0
, 1), arg1
));
13202 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
13203 (X & C) == 0 when C is a single bit. */
13204 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13205 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
13206 && integer_zerop (arg1
)
13207 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
13209 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
13210 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
13211 TREE_OPERAND (arg0
, 1));
13212 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
13214 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13218 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
13219 constant C is a power of two, i.e. a single bit. */
13220 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13221 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
13222 && integer_zerop (arg1
)
13223 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13224 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
13225 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
13227 tree arg00
= TREE_OPERAND (arg0
, 0);
13228 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13229 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
13232 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
13233 when is C is a power of two, i.e. a single bit. */
13234 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13235 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
13236 && integer_zerop (arg1
)
13237 && integer_pow2p (TREE_OPERAND (arg0
, 1))
13238 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
13239 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
13241 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
13242 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
13243 arg000
, TREE_OPERAND (arg0
, 1));
13244 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
13245 tem
, build_int_cst (TREE_TYPE (tem
), 0));
13248 if (integer_zerop (arg1
)
13249 && tree_expr_nonzero_p (arg0
))
13251 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
13252 return omit_one_operand_loc (loc
, type
, res
, arg0
);
13255 /* Fold -X op -Y as X op Y, where op is eq/ne. */
13256 if (TREE_CODE (arg0
) == NEGATE_EXPR
13257 && TREE_CODE (arg1
) == NEGATE_EXPR
)
13258 return fold_build2_loc (loc
, code
, type
,
13259 TREE_OPERAND (arg0
, 0),
13260 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13261 TREE_OPERAND (arg1
, 0)));
13263 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
13264 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13265 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
13267 tree arg00
= TREE_OPERAND (arg0
, 0);
13268 tree arg01
= TREE_OPERAND (arg0
, 1);
13269 tree arg10
= TREE_OPERAND (arg1
, 0);
13270 tree arg11
= TREE_OPERAND (arg1
, 1);
13271 tree itype
= TREE_TYPE (arg0
);
13273 if (operand_equal_p (arg01
, arg11
, 0))
13274 return fold_build2_loc (loc
, code
, type
,
13275 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13276 fold_build2_loc (loc
,
13277 BIT_XOR_EXPR
, itype
,
13280 build_zero_cst (itype
));
13282 if (operand_equal_p (arg01
, arg10
, 0))
13283 return fold_build2_loc (loc
, code
, type
,
13284 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13285 fold_build2_loc (loc
,
13286 BIT_XOR_EXPR
, itype
,
13289 build_zero_cst (itype
));
13291 if (operand_equal_p (arg00
, arg11
, 0))
13292 return fold_build2_loc (loc
, code
, type
,
13293 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13294 fold_build2_loc (loc
,
13295 BIT_XOR_EXPR
, itype
,
13298 build_zero_cst (itype
));
13300 if (operand_equal_p (arg00
, arg10
, 0))
13301 return fold_build2_loc (loc
, code
, type
,
13302 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13303 fold_build2_loc (loc
,
13304 BIT_XOR_EXPR
, itype
,
13307 build_zero_cst (itype
));
13310 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13311 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
13313 tree arg00
= TREE_OPERAND (arg0
, 0);
13314 tree arg01
= TREE_OPERAND (arg0
, 1);
13315 tree arg10
= TREE_OPERAND (arg1
, 0);
13316 tree arg11
= TREE_OPERAND (arg1
, 1);
13317 tree itype
= TREE_TYPE (arg0
);
13319 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
13320 operand_equal_p guarantees no side-effects so we don't need
13321 to use omit_one_operand on Z. */
13322 if (operand_equal_p (arg01
, arg11
, 0))
13323 return fold_build2_loc (loc
, code
, type
, arg00
,
13324 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13326 if (operand_equal_p (arg01
, arg10
, 0))
13327 return fold_build2_loc (loc
, code
, type
, arg00
,
13328 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13330 if (operand_equal_p (arg00
, arg11
, 0))
13331 return fold_build2_loc (loc
, code
, type
, arg01
,
13332 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13334 if (operand_equal_p (arg00
, arg10
, 0))
13335 return fold_build2_loc (loc
, code
, type
, arg01
,
13336 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13339 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
13340 if (TREE_CODE (arg01
) == INTEGER_CST
13341 && TREE_CODE (arg11
) == INTEGER_CST
)
13343 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
13344 fold_convert_loc (loc
, itype
, arg11
));
13345 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
13346 return fold_build2_loc (loc
, code
, type
, tem
,
13347 fold_convert_loc (loc
, itype
, arg10
));
13351 /* Attempt to simplify equality/inequality comparisons of complex
13352 values. Only lower the comparison if the result is known or
13353 can be simplified to a single scalar comparison. */
13354 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
13355 || TREE_CODE (arg0
) == COMPLEX_CST
)
13356 && (TREE_CODE (arg1
) == COMPLEX_EXPR
13357 || TREE_CODE (arg1
) == COMPLEX_CST
))
13359 tree real0
, imag0
, real1
, imag1
;
13362 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
13364 real0
= TREE_OPERAND (arg0
, 0);
13365 imag0
= TREE_OPERAND (arg0
, 1);
13369 real0
= TREE_REALPART (arg0
);
13370 imag0
= TREE_IMAGPART (arg0
);
13373 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
13375 real1
= TREE_OPERAND (arg1
, 0);
13376 imag1
= TREE_OPERAND (arg1
, 1);
13380 real1
= TREE_REALPART (arg1
);
13381 imag1
= TREE_IMAGPART (arg1
);
13384 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
13385 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
13387 if (integer_zerop (rcond
))
13389 if (code
== EQ_EXPR
)
13390 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13392 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
13396 if (code
== NE_EXPR
)
13397 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13399 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
13403 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
13404 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
13406 if (integer_zerop (icond
))
13408 if (code
== EQ_EXPR
)
13409 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13411 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
13415 if (code
== NE_EXPR
)
13416 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13418 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
13429 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
13430 if (tem
!= NULL_TREE
)
13433 /* Transform comparisons of the form X +- C CMP X. */
13434 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
13435 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13436 && ((TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
13437 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
))))
13438 || (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
13439 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))))
13441 tree arg01
= TREE_OPERAND (arg0
, 1);
13442 enum tree_code code0
= TREE_CODE (arg0
);
13445 if (TREE_CODE (arg01
) == REAL_CST
)
13446 is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
13448 is_positive
= tree_int_cst_sgn (arg01
);
13450 /* (X - c) > X becomes false. */
13451 if (code
== GT_EXPR
13452 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13453 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13455 if (TREE_CODE (arg01
) == INTEGER_CST
13456 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13457 fold_overflow_warning (("assuming signed overflow does not "
13458 "occur when assuming that (X - c) > X "
13459 "is always false"),
13460 WARN_STRICT_OVERFLOW_ALL
);
13461 return constant_boolean_node (0, type
);
13464 /* Likewise (X + c) < X becomes false. */
13465 if (code
== LT_EXPR
13466 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13467 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13469 if (TREE_CODE (arg01
) == INTEGER_CST
13470 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13471 fold_overflow_warning (("assuming signed overflow does not "
13472 "occur when assuming that "
13473 "(X + c) < X is always false"),
13474 WARN_STRICT_OVERFLOW_ALL
);
13475 return constant_boolean_node (0, type
);
13478 /* Convert (X - c) <= X to true. */
13479 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13481 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13482 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13484 if (TREE_CODE (arg01
) == INTEGER_CST
13485 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13486 fold_overflow_warning (("assuming signed overflow does not "
13487 "occur when assuming that "
13488 "(X - c) <= X is always true"),
13489 WARN_STRICT_OVERFLOW_ALL
);
13490 return constant_boolean_node (1, type
);
13493 /* Convert (X + c) >= X to true. */
13494 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13496 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13497 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13499 if (TREE_CODE (arg01
) == INTEGER_CST
13500 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13501 fold_overflow_warning (("assuming signed overflow does not "
13502 "occur when assuming that "
13503 "(X + c) >= X is always true"),
13504 WARN_STRICT_OVERFLOW_ALL
);
13505 return constant_boolean_node (1, type
);
13508 if (TREE_CODE (arg01
) == INTEGER_CST
)
13510 /* Convert X + c > X and X - c < X to true for integers. */
13511 if (code
== GT_EXPR
13512 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13513 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13515 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13516 fold_overflow_warning (("assuming signed overflow does "
13517 "not occur when assuming that "
13518 "(X + c) > X is always true"),
13519 WARN_STRICT_OVERFLOW_ALL
);
13520 return constant_boolean_node (1, type
);
13523 if (code
== LT_EXPR
13524 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13525 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13527 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13528 fold_overflow_warning (("assuming signed overflow does "
13529 "not occur when assuming that "
13530 "(X - c) < X is always true"),
13531 WARN_STRICT_OVERFLOW_ALL
);
13532 return constant_boolean_node (1, type
);
13535 /* Convert X + c <= X and X - c >= X to false for integers. */
13536 if (code
== LE_EXPR
13537 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13538 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13540 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13541 fold_overflow_warning (("assuming signed overflow does "
13542 "not occur when assuming that "
13543 "(X + c) <= X is always false"),
13544 WARN_STRICT_OVERFLOW_ALL
);
13545 return constant_boolean_node (0, type
);
13548 if (code
== GE_EXPR
13549 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13550 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13552 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13553 fold_overflow_warning (("assuming signed overflow does "
13554 "not occur when assuming that "
13555 "(X - c) >= X is always false"),
13556 WARN_STRICT_OVERFLOW_ALL
);
13557 return constant_boolean_node (0, type
);
13562 /* Comparisons with the highest or lowest possible integer of
13563 the specified precision will have known values. */
13565 tree arg1_type
= TREE_TYPE (arg1
);
13566 unsigned int prec
= TYPE_PRECISION (arg1_type
);
13568 if (TREE_CODE (arg1
) == INTEGER_CST
13569 && (INTEGRAL_TYPE_P (arg1_type
) || POINTER_TYPE_P (arg1_type
)))
13571 wide_int max
= wi::max_value (arg1_type
);
13572 wide_int signed_max
= wi::max_value (prec
, SIGNED
);
13573 wide_int min
= wi::min_value (arg1_type
);
13575 if (wi::eq_p (arg1
, max
))
13579 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13582 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13585 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13588 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13590 /* The GE_EXPR and LT_EXPR cases above are not normally
13591 reached because of previous transformations. */
13596 else if (wi::eq_p (arg1
, max
- 1))
13600 arg1
= const_binop (PLUS_EXPR
, arg1
,
13601 build_int_cst (TREE_TYPE (arg1
), 1));
13602 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13603 fold_convert_loc (loc
,
13604 TREE_TYPE (arg1
), arg0
),
13607 arg1
= const_binop (PLUS_EXPR
, arg1
,
13608 build_int_cst (TREE_TYPE (arg1
), 1));
13609 return fold_build2_loc (loc
, NE_EXPR
, type
,
13610 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13616 else if (wi::eq_p (arg1
, min
))
13620 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13623 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13626 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13629 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13634 else if (wi::eq_p (arg1
, min
+ 1))
13638 arg1
= const_binop (MINUS_EXPR
, arg1
,
13639 build_int_cst (TREE_TYPE (arg1
), 1));
13640 return fold_build2_loc (loc
, NE_EXPR
, type
,
13641 fold_convert_loc (loc
,
13642 TREE_TYPE (arg1
), arg0
),
13645 arg1
= const_binop (MINUS_EXPR
, arg1
,
13646 build_int_cst (TREE_TYPE (arg1
), 1));
13647 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13648 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13655 else if (wi::eq_p (arg1
, signed_max
)
13656 && TYPE_UNSIGNED (arg1_type
)
13657 /* We will flip the signedness of the comparison operator
13658 associated with the mode of arg1, so the sign bit is
13659 specified by this mode. Check that arg1 is the signed
13660 max associated with this sign bit. */
13661 && prec
== GET_MODE_PRECISION (TYPE_MODE (arg1_type
))
13662 /* signed_type does not work on pointer types. */
13663 && INTEGRAL_TYPE_P (arg1_type
))
13665 /* The following case also applies to X < signed_max+1
13666 and X >= signed_max+1 because previous transformations. */
13667 if (code
== LE_EXPR
|| code
== GT_EXPR
)
13669 tree st
= signed_type_for (arg1_type
);
13670 return fold_build2_loc (loc
,
13671 code
== LE_EXPR
? GE_EXPR
: LT_EXPR
,
13672 type
, fold_convert_loc (loc
, st
, arg0
),
13673 build_int_cst (st
, 0));
13679 /* If we are comparing an ABS_EXPR with a constant, we can
13680 convert all the cases into explicit comparisons, but they may
13681 well not be faster than doing the ABS and one comparison.
13682 But ABS (X) <= C is a range comparison, which becomes a subtraction
13683 and a comparison, and is probably faster. */
13684 if (code
== LE_EXPR
13685 && TREE_CODE (arg1
) == INTEGER_CST
13686 && TREE_CODE (arg0
) == ABS_EXPR
13687 && ! TREE_SIDE_EFFECTS (arg0
)
13688 && (0 != (tem
= negate_expr (arg1
)))
13689 && TREE_CODE (tem
) == INTEGER_CST
13690 && !TREE_OVERFLOW (tem
))
13691 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
13692 build2 (GE_EXPR
, type
,
13693 TREE_OPERAND (arg0
, 0), tem
),
13694 build2 (LE_EXPR
, type
,
13695 TREE_OPERAND (arg0
, 0), arg1
));
13697 /* Convert ABS_EXPR<x> >= 0 to true. */
13698 strict_overflow_p
= false;
13699 if (code
== GE_EXPR
13700 && (integer_zerop (arg1
)
13701 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
13702 && real_zerop (arg1
)))
13703 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13705 if (strict_overflow_p
)
13706 fold_overflow_warning (("assuming signed overflow does not occur "
13707 "when simplifying comparison of "
13708 "absolute value and zero"),
13709 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13710 return omit_one_operand_loc (loc
, type
,
13711 constant_boolean_node (true, type
),
13715 /* Convert ABS_EXPR<x> < 0 to false. */
13716 strict_overflow_p
= false;
13717 if (code
== LT_EXPR
13718 && (integer_zerop (arg1
) || real_zerop (arg1
))
13719 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13721 if (strict_overflow_p
)
13722 fold_overflow_warning (("assuming signed overflow does not occur "
13723 "when simplifying comparison of "
13724 "absolute value and zero"),
13725 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13726 return omit_one_operand_loc (loc
, type
,
13727 constant_boolean_node (false, type
),
13731 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13732 and similarly for >= into !=. */
13733 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13734 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13735 && TREE_CODE (arg1
) == LSHIFT_EXPR
13736 && integer_onep (TREE_OPERAND (arg1
, 0)))
13737 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13738 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13739 TREE_OPERAND (arg1
, 1)),
13740 build_zero_cst (TREE_TYPE (arg0
)));
13742 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
13743 otherwise Y might be >= # of bits in X's type and thus e.g.
13744 (unsigned char) (1 << Y) for Y 15 might be 0.
13745 If the cast is widening, then 1 << Y should have unsigned type,
13746 otherwise if Y is number of bits in the signed shift type minus 1,
13747 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
13748 31 might be 0xffffffff80000000. */
13749 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13750 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13751 && CONVERT_EXPR_P (arg1
)
13752 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
13753 && (TYPE_PRECISION (TREE_TYPE (arg1
))
13754 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0))))
13755 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1
, 0)))
13756 || (TYPE_PRECISION (TREE_TYPE (arg1
))
13757 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1
, 0)))))
13758 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
13760 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13761 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
13762 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13763 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
13764 build_zero_cst (TREE_TYPE (arg0
)));
13769 case UNORDERED_EXPR
:
13777 if (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
13779 t1
= fold_relational_const (code
, type
, arg0
, arg1
);
13780 if (t1
!= NULL_TREE
)
13784 /* If the first operand is NaN, the result is constant. */
13785 if (TREE_CODE (arg0
) == REAL_CST
13786 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0
))
13787 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13789 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13790 ? integer_zero_node
13791 : integer_one_node
;
13792 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
13795 /* If the second operand is NaN, the result is constant. */
13796 if (TREE_CODE (arg1
) == REAL_CST
13797 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
13798 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13800 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13801 ? integer_zero_node
13802 : integer_one_node
;
13803 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
13806 /* Simplify unordered comparison of something with itself. */
13807 if ((code
== UNLE_EXPR
|| code
== UNGE_EXPR
|| code
== UNEQ_EXPR
)
13808 && operand_equal_p (arg0
, arg1
, 0))
13809 return constant_boolean_node (1, type
);
13811 if (code
== LTGT_EXPR
13812 && !flag_trapping_math
13813 && operand_equal_p (arg0
, arg1
, 0))
13814 return constant_boolean_node (0, type
);
13816 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13818 tree targ0
= strip_float_extensions (arg0
);
13819 tree targ1
= strip_float_extensions (arg1
);
13820 tree newtype
= TREE_TYPE (targ0
);
13822 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
13823 newtype
= TREE_TYPE (targ1
);
13825 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
13826 return fold_build2_loc (loc
, code
, type
,
13827 fold_convert_loc (loc
, newtype
, targ0
),
13828 fold_convert_loc (loc
, newtype
, targ1
));
13833 case COMPOUND_EXPR
:
13834 /* When pedantic, a compound expression can be neither an lvalue
13835 nor an integer constant expression. */
13836 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
13838 /* Don't let (0, 0) be null pointer constant. */
13839 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
13840 : fold_convert_loc (loc
, type
, arg1
);
13841 return pedantic_non_lvalue_loc (loc
, tem
);
13844 if ((TREE_CODE (arg0
) == REAL_CST
13845 && TREE_CODE (arg1
) == REAL_CST
)
13846 || (TREE_CODE (arg0
) == INTEGER_CST
13847 && TREE_CODE (arg1
) == INTEGER_CST
))
13848 return build_complex (type
, arg0
, arg1
);
13849 if (TREE_CODE (arg0
) == REALPART_EXPR
13850 && TREE_CODE (arg1
) == IMAGPART_EXPR
13851 && TREE_TYPE (TREE_OPERAND (arg0
, 0)) == type
13852 && operand_equal_p (TREE_OPERAND (arg0
, 0),
13853 TREE_OPERAND (arg1
, 0), 0))
13854 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 0),
13855 TREE_OPERAND (arg1
, 0));
13859 /* An ASSERT_EXPR should never be passed to fold_binary. */
13860 gcc_unreachable ();
13862 case VEC_PACK_TRUNC_EXPR
:
13863 case VEC_PACK_FIX_TRUNC_EXPR
:
13865 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
13868 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
/ 2
13869 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
/ 2);
13870 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13873 elts
= XALLOCAVEC (tree
, nelts
);
13874 if (!vec_cst_ctor_to_array (arg0
, elts
)
13875 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
/ 2))
13878 for (i
= 0; i
< nelts
; i
++)
13880 elts
[i
] = fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
13881 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
13882 TREE_TYPE (type
), elts
[i
]);
13883 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
13887 return build_vector (type
, elts
);
13890 case VEC_WIDEN_MULT_LO_EXPR
:
13891 case VEC_WIDEN_MULT_HI_EXPR
:
13892 case VEC_WIDEN_MULT_EVEN_EXPR
:
13893 case VEC_WIDEN_MULT_ODD_EXPR
:
13895 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
13896 unsigned int out
, ofs
, scale
;
13899 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2
13900 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
* 2);
13901 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13904 elts
= XALLOCAVEC (tree
, nelts
* 4);
13905 if (!vec_cst_ctor_to_array (arg0
, elts
)
13906 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
* 2))
13909 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
13910 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? nelts
: 0;
13911 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
13912 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : nelts
;
13913 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
13914 scale
= 1, ofs
= 0;
13915 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
13916 scale
= 1, ofs
= 1;
13918 for (out
= 0; out
< nelts
; out
++)
13920 unsigned int in1
= (out
<< scale
) + ofs
;
13921 unsigned int in2
= in1
+ nelts
* 2;
13924 t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in1
]);
13925 t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in2
]);
13927 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
13929 elts
[out
] = const_binop (MULT_EXPR
, t1
, t2
);
13930 if (elts
[out
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[out
]))
13934 return build_vector (type
, elts
);
13939 } /* switch (code) */
13942 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
13943 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
13947 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
13949 switch (TREE_CODE (*tp
))
13955 *walk_subtrees
= 0;
13957 /* ... fall through ... */
13964 /* Return whether the sub-tree ST contains a label which is accessible from
13965 outside the sub-tree. */
13968 contains_label_p (tree st
)
13971 (walk_tree_without_duplicates (&st
, contains_label_1
, NULL
) != NULL_TREE
);
13974 /* Fold a ternary expression of code CODE and type TYPE with operands
13975 OP0, OP1, and OP2. Return the folded expression if folding is
13976 successful. Otherwise, return NULL_TREE. */
13979 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
13980 tree op0
, tree op1
, tree op2
)
13983 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
13984 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
13986 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
13987 && TREE_CODE_LENGTH (code
) == 3);
13989 /* Strip any conversions that don't change the mode. This is safe
13990 for every expression, except for a comparison expression because
13991 its signedness is derived from its operands. So, in the latter
13992 case, only strip conversions that don't change the signedness.
13994 Note that this is done as an internal manipulation within the
13995 constant folder, in order to find the simplest representation of
13996 the arguments so that their form can be studied. In any cases,
13997 the appropriate type conversions should be put back in the tree
13998 that will get out of the constant folder. */
14019 case COMPONENT_REF
:
14020 if (TREE_CODE (arg0
) == CONSTRUCTOR
14021 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
14023 unsigned HOST_WIDE_INT idx
;
14025 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
14032 case VEC_COND_EXPR
:
14033 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
14034 so all simple results must be passed through pedantic_non_lvalue. */
14035 if (TREE_CODE (arg0
) == INTEGER_CST
)
14037 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
14038 tem
= integer_zerop (arg0
) ? op2
: op1
;
14039 /* Only optimize constant conditions when the selected branch
14040 has the same type as the COND_EXPR. This avoids optimizing
14041 away "c ? x : throw", where the throw has a void type.
14042 Avoid throwing away that operand which contains label. */
14043 if ((!TREE_SIDE_EFFECTS (unused_op
)
14044 || !contains_label_p (unused_op
))
14045 && (! VOID_TYPE_P (TREE_TYPE (tem
))
14046 || VOID_TYPE_P (type
)))
14047 return pedantic_non_lvalue_loc (loc
, tem
);
14050 else if (TREE_CODE (arg0
) == VECTOR_CST
)
14052 if (integer_all_onesp (arg0
))
14053 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg2
);
14054 if (integer_zerop (arg0
))
14055 return pedantic_omit_one_operand_loc (loc
, type
, arg2
, arg1
);
14057 if ((TREE_CODE (arg1
) == VECTOR_CST
14058 || TREE_CODE (arg1
) == CONSTRUCTOR
)
14059 && (TREE_CODE (arg2
) == VECTOR_CST
14060 || TREE_CODE (arg2
) == CONSTRUCTOR
))
14062 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
14063 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
14064 gcc_assert (nelts
== VECTOR_CST_NELTS (arg0
));
14065 for (i
= 0; i
< nelts
; i
++)
14067 tree val
= VECTOR_CST_ELT (arg0
, i
);
14068 if (integer_all_onesp (val
))
14070 else if (integer_zerop (val
))
14071 sel
[i
] = nelts
+ i
;
14072 else /* Currently unreachable. */
14075 tree t
= fold_vec_perm (type
, arg1
, arg2
, sel
);
14076 if (t
!= NULL_TREE
)
14081 if (operand_equal_p (arg1
, op2
, 0))
14082 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg0
);
14084 /* If we have A op B ? A : C, we may be able to convert this to a
14085 simpler expression, depending on the operation and the values
14086 of B and C. Signed zeros prevent all of these transformations,
14087 for reasons given above each one.
14089 Also try swapping the arguments and inverting the conditional. */
14090 if (COMPARISON_CLASS_P (arg0
)
14091 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
14092 arg1
, TREE_OPERAND (arg0
, 1))
14093 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1
))))
14095 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
14100 if (COMPARISON_CLASS_P (arg0
)
14101 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
14103 TREE_OPERAND (arg0
, 1))
14104 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2
))))
14106 location_t loc0
= expr_location_or (arg0
, loc
);
14107 tem
= fold_invert_truthvalue (loc0
, arg0
);
14108 if (tem
&& COMPARISON_CLASS_P (tem
))
14110 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
14116 /* If the second operand is simpler than the third, swap them
14117 since that produces better jump optimization results. */
14118 if (truth_value_p (TREE_CODE (arg0
))
14119 && tree_swap_operands_p (op1
, op2
, false))
14121 location_t loc0
= expr_location_or (arg0
, loc
);
14122 /* See if this can be inverted. If it can't, possibly because
14123 it was a floating-point inequality comparison, don't do
14125 tem
= fold_invert_truthvalue (loc0
, arg0
);
14127 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
14130 /* Convert A ? 1 : 0 to simply A. */
14131 if ((code
== VEC_COND_EXPR
? integer_all_onesp (op1
)
14132 : (integer_onep (op1
)
14133 && !VECTOR_TYPE_P (type
)))
14134 && integer_zerop (op2
)
14135 /* If we try to convert OP0 to our type, the
14136 call to fold will try to move the conversion inside
14137 a COND, which will recurse. In that case, the COND_EXPR
14138 is probably the best choice, so leave it alone. */
14139 && type
== TREE_TYPE (arg0
))
14140 return pedantic_non_lvalue_loc (loc
, arg0
);
14142 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
14143 over COND_EXPR in cases such as floating point comparisons. */
14144 if (integer_zerop (op1
)
14145 && (code
== VEC_COND_EXPR
? integer_all_onesp (op2
)
14146 : (integer_onep (op2
)
14147 && !VECTOR_TYPE_P (type
)))
14148 && truth_value_p (TREE_CODE (arg0
)))
14149 return pedantic_non_lvalue_loc (loc
,
14150 fold_convert_loc (loc
, type
,
14151 invert_truthvalue_loc (loc
,
14154 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
14155 if (TREE_CODE (arg0
) == LT_EXPR
14156 && integer_zerop (TREE_OPERAND (arg0
, 1))
14157 && integer_zerop (op2
)
14158 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
14160 /* sign_bit_p looks through both zero and sign extensions,
14161 but for this optimization only sign extensions are
14163 tree tem2
= TREE_OPERAND (arg0
, 0);
14164 while (tem
!= tem2
)
14166 if (TREE_CODE (tem2
) != NOP_EXPR
14167 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2
, 0))))
14172 tem2
= TREE_OPERAND (tem2
, 0);
14174 /* sign_bit_p only checks ARG1 bits within A's precision.
14175 If <sign bit of A> has wider type than A, bits outside
14176 of A's precision in <sign bit of A> need to be checked.
14177 If they are all 0, this optimization needs to be done
14178 in unsigned A's type, if they are all 1 in signed A's type,
14179 otherwise this can't be done. */
14181 && TYPE_PRECISION (TREE_TYPE (tem
))
14182 < TYPE_PRECISION (TREE_TYPE (arg1
))
14183 && TYPE_PRECISION (TREE_TYPE (tem
))
14184 < TYPE_PRECISION (type
))
14186 int inner_width
, outer_width
;
14189 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
14190 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
14191 if (outer_width
> TYPE_PRECISION (type
))
14192 outer_width
= TYPE_PRECISION (type
);
14194 wide_int mask
= wi::shifted_mask
14195 (inner_width
, outer_width
- inner_width
, false,
14196 TYPE_PRECISION (TREE_TYPE (arg1
)));
14198 wide_int common
= mask
& arg1
;
14199 if (common
== mask
)
14201 tem_type
= signed_type_for (TREE_TYPE (tem
));
14202 tem
= fold_convert_loc (loc
, tem_type
, tem
);
14204 else if (common
== 0)
14206 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
14207 tem
= fold_convert_loc (loc
, tem_type
, tem
);
14215 fold_convert_loc (loc
, type
,
14216 fold_build2_loc (loc
, BIT_AND_EXPR
,
14217 TREE_TYPE (tem
), tem
,
14218 fold_convert_loc (loc
,
14223 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
14224 already handled above. */
14225 if (TREE_CODE (arg0
) == BIT_AND_EXPR
14226 && integer_onep (TREE_OPERAND (arg0
, 1))
14227 && integer_zerop (op2
)
14228 && integer_pow2p (arg1
))
14230 tree tem
= TREE_OPERAND (arg0
, 0);
14232 if (TREE_CODE (tem
) == RSHIFT_EXPR
14233 && tree_fits_uhwi_p (TREE_OPERAND (tem
, 1))
14234 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
) ==
14235 tree_to_uhwi (TREE_OPERAND (tem
, 1)))
14236 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
14237 TREE_OPERAND (tem
, 0), arg1
);
14240 /* A & N ? N : 0 is simply A & N if N is a power of two. This
14241 is probably obsolete because the first operand should be a
14242 truth value (that's why we have the two cases above), but let's
14243 leave it in until we can confirm this for all front-ends. */
14244 if (integer_zerop (op2
)
14245 && TREE_CODE (arg0
) == NE_EXPR
14246 && integer_zerop (TREE_OPERAND (arg0
, 1))
14247 && integer_pow2p (arg1
)
14248 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
14249 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
14250 arg1
, OEP_ONLY_CONST
))
14251 return pedantic_non_lvalue_loc (loc
,
14252 fold_convert_loc (loc
, type
,
14253 TREE_OPERAND (arg0
, 0)));
14255 /* Disable the transformations below for vectors, since
14256 fold_binary_op_with_conditional_arg may undo them immediately,
14257 yielding an infinite loop. */
14258 if (code
== VEC_COND_EXPR
)
14261 /* Convert A ? B : 0 into A && B if A and B are truth values. */
14262 if (integer_zerop (op2
)
14263 && truth_value_p (TREE_CODE (arg0
))
14264 && truth_value_p (TREE_CODE (arg1
))
14265 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14266 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
? BIT_AND_EXPR
14267 : TRUTH_ANDIF_EXPR
,
14268 type
, fold_convert_loc (loc
, type
, arg0
), arg1
);
14270 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
14271 if (code
== VEC_COND_EXPR
? integer_all_onesp (op2
) : integer_onep (op2
)
14272 && truth_value_p (TREE_CODE (arg0
))
14273 && truth_value_p (TREE_CODE (arg1
))
14274 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14276 location_t loc0
= expr_location_or (arg0
, loc
);
14277 /* Only perform transformation if ARG0 is easily inverted. */
14278 tem
= fold_invert_truthvalue (loc0
, arg0
);
14280 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14283 type
, fold_convert_loc (loc
, type
, tem
),
14287 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
14288 if (integer_zerop (arg1
)
14289 && truth_value_p (TREE_CODE (arg0
))
14290 && truth_value_p (TREE_CODE (op2
))
14291 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14293 location_t loc0
= expr_location_or (arg0
, loc
);
14294 /* Only perform transformation if ARG0 is easily inverted. */
14295 tem
= fold_invert_truthvalue (loc0
, arg0
);
14297 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14298 ? BIT_AND_EXPR
: TRUTH_ANDIF_EXPR
,
14299 type
, fold_convert_loc (loc
, type
, tem
),
14303 /* Convert A ? 1 : B into A || B if A and B are truth values. */
14304 if (code
== VEC_COND_EXPR
? integer_all_onesp (arg1
) : integer_onep (arg1
)
14305 && truth_value_p (TREE_CODE (arg0
))
14306 && truth_value_p (TREE_CODE (op2
))
14307 && (code
== VEC_COND_EXPR
|| !VECTOR_TYPE_P (type
)))
14308 return fold_build2_loc (loc
, code
== VEC_COND_EXPR
14309 ? BIT_IOR_EXPR
: TRUTH_ORIF_EXPR
,
14310 type
, fold_convert_loc (loc
, type
, arg0
), op2
);
14315 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
14316 of fold_ternary on them. */
14317 gcc_unreachable ();
14319 case BIT_FIELD_REF
:
14320 if ((TREE_CODE (arg0
) == VECTOR_CST
14321 || (TREE_CODE (arg0
) == CONSTRUCTOR
14322 && TREE_CODE (TREE_TYPE (arg0
)) == VECTOR_TYPE
))
14323 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
14324 || (TREE_CODE (type
) == VECTOR_TYPE
14325 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
)))))
14327 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
14328 unsigned HOST_WIDE_INT width
= tree_to_uhwi (TYPE_SIZE (eltype
));
14329 unsigned HOST_WIDE_INT n
= tree_to_uhwi (arg1
);
14330 unsigned HOST_WIDE_INT idx
= tree_to_uhwi (op2
);
14333 && (idx
% width
) == 0
14334 && (n
% width
) == 0
14335 && ((idx
+ n
) / width
) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)))
14340 if (TREE_CODE (arg0
) == VECTOR_CST
)
14343 return VECTOR_CST_ELT (arg0
, idx
);
14345 tree
*vals
= XALLOCAVEC (tree
, n
);
14346 for (unsigned i
= 0; i
< n
; ++i
)
14347 vals
[i
] = VECTOR_CST_ELT (arg0
, idx
+ i
);
14348 return build_vector (type
, vals
);
14351 /* Constructor elements can be subvectors. */
14352 unsigned HOST_WIDE_INT k
= 1;
14353 if (CONSTRUCTOR_NELTS (arg0
) != 0)
14355 tree cons_elem
= TREE_TYPE (CONSTRUCTOR_ELT (arg0
, 0)->value
);
14356 if (TREE_CODE (cons_elem
) == VECTOR_TYPE
)
14357 k
= TYPE_VECTOR_SUBPARTS (cons_elem
);
14360 /* We keep an exact subset of the constructor elements. */
14361 if ((idx
% k
) == 0 && (n
% k
) == 0)
14363 if (CONSTRUCTOR_NELTS (arg0
) == 0)
14364 return build_constructor (type
, NULL
);
14369 if (idx
< CONSTRUCTOR_NELTS (arg0
))
14370 return CONSTRUCTOR_ELT (arg0
, idx
)->value
;
14371 return build_zero_cst (type
);
14374 vec
<constructor_elt
, va_gc
> *vals
;
14375 vec_alloc (vals
, n
);
14376 for (unsigned i
= 0;
14377 i
< n
&& idx
+ i
< CONSTRUCTOR_NELTS (arg0
);
14379 CONSTRUCTOR_APPEND_ELT (vals
, NULL_TREE
,
14381 (arg0
, idx
+ i
)->value
);
14382 return build_constructor (type
, vals
);
14384 /* The bitfield references a single constructor element. */
14385 else if (idx
+ n
<= (idx
/ k
+ 1) * k
)
14387 if (CONSTRUCTOR_NELTS (arg0
) <= idx
/ k
)
14388 return build_zero_cst (type
);
14390 return CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
;
14392 return fold_build3_loc (loc
, code
, type
,
14393 CONSTRUCTOR_ELT (arg0
, idx
/ k
)->value
, op1
,
14394 build_int_cst (TREE_TYPE (op2
), (idx
% k
) * width
));
14399 /* A bit-field-ref that referenced the full argument can be stripped. */
14400 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
14401 && TYPE_PRECISION (TREE_TYPE (arg0
)) == tree_to_uhwi (arg1
)
14402 && integer_zerop (op2
))
14403 return fold_convert_loc (loc
, type
, arg0
);
14405 /* On constants we can use native encode/interpret to constant
14406 fold (nearly) all BIT_FIELD_REFs. */
14407 if (CONSTANT_CLASS_P (arg0
)
14408 && can_native_interpret_type_p (type
)
14409 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)))
14410 /* This limitation should not be necessary, we just need to
14411 round this up to mode size. */
14412 && tree_to_uhwi (op1
) % BITS_PER_UNIT
== 0
14413 /* Need bit-shifting of the buffer to relax the following. */
14414 && tree_to_uhwi (op2
) % BITS_PER_UNIT
== 0)
14416 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (op2
);
14417 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (op1
);
14418 unsigned HOST_WIDE_INT clen
;
14419 clen
= tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)));
14420 /* ??? We cannot tell native_encode_expr to start at
14421 some random byte only. So limit us to a reasonable amount
14425 unsigned char *b
= XALLOCAVEC (unsigned char, clen
);
14426 unsigned HOST_WIDE_INT len
= native_encode_expr (arg0
, b
, clen
);
14428 && len
* BITS_PER_UNIT
>= bitpos
+ bitsize
)
14430 tree v
= native_interpret_expr (type
,
14431 b
+ bitpos
/ BITS_PER_UNIT
,
14432 bitsize
/ BITS_PER_UNIT
);
14442 /* For integers we can decompose the FMA if possible. */
14443 if (TREE_CODE (arg0
) == INTEGER_CST
14444 && TREE_CODE (arg1
) == INTEGER_CST
)
14445 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
14446 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
14447 if (integer_zerop (arg2
))
14448 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
14450 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
14452 case VEC_PERM_EXPR
:
14453 if (TREE_CODE (arg2
) == VECTOR_CST
)
14455 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
, mask
;
14456 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
14457 bool need_mask_canon
= false;
14458 bool all_in_vec0
= true;
14459 bool all_in_vec1
= true;
14460 bool maybe_identity
= true;
14461 bool single_arg
= (op0
== op1
);
14462 bool changed
= false;
14464 mask
= single_arg
? (nelts
- 1) : (2 * nelts
- 1);
14465 gcc_assert (nelts
== VECTOR_CST_NELTS (arg2
));
14466 for (i
= 0; i
< nelts
; i
++)
14468 tree val
= VECTOR_CST_ELT (arg2
, i
);
14469 if (TREE_CODE (val
) != INTEGER_CST
)
14472 /* Make sure that the perm value is in an acceptable
14475 if (wi::gtu_p (t
, mask
))
14477 need_mask_canon
= true;
14478 sel
[i
] = t
.to_uhwi () & mask
;
14481 sel
[i
] = t
.to_uhwi ();
14483 if (sel
[i
] < nelts
)
14484 all_in_vec1
= false;
14486 all_in_vec0
= false;
14488 if ((sel
[i
] & (nelts
-1)) != i
)
14489 maybe_identity
= false;
14492 if (maybe_identity
)
14502 else if (all_in_vec1
)
14505 for (i
= 0; i
< nelts
; i
++)
14507 need_mask_canon
= true;
14510 if ((TREE_CODE (op0
) == VECTOR_CST
14511 || TREE_CODE (op0
) == CONSTRUCTOR
)
14512 && (TREE_CODE (op1
) == VECTOR_CST
14513 || TREE_CODE (op1
) == CONSTRUCTOR
))
14515 tree t
= fold_vec_perm (type
, op0
, op1
, sel
);
14516 if (t
!= NULL_TREE
)
14520 if (op0
== op1
&& !single_arg
)
14523 if (need_mask_canon
&& arg2
== op2
)
14525 tree
*tsel
= XALLOCAVEC (tree
, nelts
);
14526 tree eltype
= TREE_TYPE (TREE_TYPE (arg2
));
14527 for (i
= 0; i
< nelts
; i
++)
14528 tsel
[i
] = build_int_cst (eltype
, sel
[i
]);
14529 op2
= build_vector (TREE_TYPE (arg2
), tsel
);
14534 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
14540 } /* switch (code) */
14543 /* Perform constant folding and related simplification of EXPR.
14544 The related simplifications include x*1 => x, x*0 => 0, etc.,
14545 and application of the associative law.
14546 NOP_EXPR conversions may be removed freely (as long as we
14547 are careful not to change the type of the overall expression).
14548 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14549 but we can constant-fold them if they have constant operands. */
14551 #ifdef ENABLE_FOLD_CHECKING
14552 # define fold(x) fold_1 (x)
14553 static tree
fold_1 (tree
);
14559 const tree t
= expr
;
14560 enum tree_code code
= TREE_CODE (t
);
14561 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
14563 location_t loc
= EXPR_LOCATION (expr
);
14565 /* Return right away if a constant. */
14566 if (kind
== tcc_constant
)
14569 /* CALL_EXPR-like objects with variable numbers of operands are
14570 treated specially. */
14571 if (kind
== tcc_vl_exp
)
14573 if (code
== CALL_EXPR
)
14575 tem
= fold_call_expr (loc
, expr
, false);
14576 return tem
? tem
: expr
;
14581 if (IS_EXPR_CODE_CLASS (kind
))
14583 tree type
= TREE_TYPE (t
);
14584 tree op0
, op1
, op2
;
14586 switch (TREE_CODE_LENGTH (code
))
14589 op0
= TREE_OPERAND (t
, 0);
14590 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14591 return tem
? tem
: expr
;
14593 op0
= TREE_OPERAND (t
, 0);
14594 op1
= TREE_OPERAND (t
, 1);
14595 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14596 return tem
? tem
: expr
;
14598 op0
= TREE_OPERAND (t
, 0);
14599 op1
= TREE_OPERAND (t
, 1);
14600 op2
= TREE_OPERAND (t
, 2);
14601 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14602 return tem
? tem
: expr
;
14612 tree op0
= TREE_OPERAND (t
, 0);
14613 tree op1
= TREE_OPERAND (t
, 1);
14615 if (TREE_CODE (op1
) == INTEGER_CST
14616 && TREE_CODE (op0
) == CONSTRUCTOR
14617 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
14619 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (op0
);
14620 unsigned HOST_WIDE_INT end
= vec_safe_length (elts
);
14621 unsigned HOST_WIDE_INT begin
= 0;
14623 /* Find a matching index by means of a binary search. */
14624 while (begin
!= end
)
14626 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
14627 tree index
= (*elts
)[middle
].index
;
14629 if (TREE_CODE (index
) == INTEGER_CST
14630 && tree_int_cst_lt (index
, op1
))
14631 begin
= middle
+ 1;
14632 else if (TREE_CODE (index
) == INTEGER_CST
14633 && tree_int_cst_lt (op1
, index
))
14635 else if (TREE_CODE (index
) == RANGE_EXPR
14636 && tree_int_cst_lt (TREE_OPERAND (index
, 1), op1
))
14637 begin
= middle
+ 1;
14638 else if (TREE_CODE (index
) == RANGE_EXPR
14639 && tree_int_cst_lt (op1
, TREE_OPERAND (index
, 0)))
14642 return (*elts
)[middle
].value
;
14649 /* Return a VECTOR_CST if possible. */
14652 tree type
= TREE_TYPE (t
);
14653 if (TREE_CODE (type
) != VECTOR_TYPE
)
14656 tree
*vec
= XALLOCAVEC (tree
, TYPE_VECTOR_SUBPARTS (type
));
14657 unsigned HOST_WIDE_INT idx
, pos
= 0;
14660 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), idx
, value
)
14662 if (!CONSTANT_CLASS_P (value
))
14664 if (TREE_CODE (value
) == VECTOR_CST
)
14666 for (unsigned i
= 0; i
< VECTOR_CST_NELTS (value
); ++i
)
14667 vec
[pos
++] = VECTOR_CST_ELT (value
, i
);
14670 vec
[pos
++] = value
;
14672 for (; pos
< TYPE_VECTOR_SUBPARTS (type
); ++pos
)
14673 vec
[pos
] = build_zero_cst (TREE_TYPE (type
));
14675 return build_vector (type
, vec
);
14679 return fold (DECL_INITIAL (t
));
14683 } /* switch (code) */
14686 #ifdef ENABLE_FOLD_CHECKING
14689 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
14690 hash_table
<pointer_hash
<const tree_node
> > *);
14691 static void fold_check_failed (const_tree
, const_tree
);
14692 void print_fold_checksum (const_tree
);
14694 /* When --enable-checking=fold, compute a digest of expr before
14695 and after actual fold call to see if fold did not accidentally
14696 change original expr. */
14702 struct md5_ctx ctx
;
14703 unsigned char checksum_before
[16], checksum_after
[16];
14704 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14706 md5_init_ctx (&ctx
);
14707 fold_checksum_tree (expr
, &ctx
, &ht
);
14708 md5_finish_ctx (&ctx
, checksum_before
);
14711 ret
= fold_1 (expr
);
14713 md5_init_ctx (&ctx
);
14714 fold_checksum_tree (expr
, &ctx
, &ht
);
14715 md5_finish_ctx (&ctx
, checksum_after
);
14717 if (memcmp (checksum_before
, checksum_after
, 16))
14718 fold_check_failed (expr
, ret
);
14724 print_fold_checksum (const_tree expr
)
14726 struct md5_ctx ctx
;
14727 unsigned char checksum
[16], cnt
;
14728 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14730 md5_init_ctx (&ctx
);
14731 fold_checksum_tree (expr
, &ctx
, &ht
);
14732 md5_finish_ctx (&ctx
, checksum
);
14733 for (cnt
= 0; cnt
< 16; ++cnt
)
14734 fprintf (stderr
, "%02x", checksum
[cnt
]);
14735 putc ('\n', stderr
);
14739 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
14741 internal_error ("fold check: original tree changed by fold");
14745 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
14746 hash_table
<pointer_hash
<const tree_node
> > *ht
)
14748 const tree_node
**slot
;
14749 enum tree_code code
;
14750 union tree_node buf
;
14756 slot
= ht
->find_slot (expr
, INSERT
);
14760 code
= TREE_CODE (expr
);
14761 if (TREE_CODE_CLASS (code
) == tcc_declaration
14762 && DECL_ASSEMBLER_NAME_SET_P (expr
))
14764 /* Allow DECL_ASSEMBLER_NAME to be modified. */
14765 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14766 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
14767 expr
= (tree
) &buf
;
14769 else if (TREE_CODE_CLASS (code
) == tcc_type
14770 && (TYPE_POINTER_TO (expr
)
14771 || TYPE_REFERENCE_TO (expr
)
14772 || TYPE_CACHED_VALUES_P (expr
)
14773 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
14774 || TYPE_NEXT_VARIANT (expr
)))
14776 /* Allow these fields to be modified. */
14778 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14779 expr
= tmp
= (tree
) &buf
;
14780 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
14781 TYPE_POINTER_TO (tmp
) = NULL
;
14782 TYPE_REFERENCE_TO (tmp
) = NULL
;
14783 TYPE_NEXT_VARIANT (tmp
) = NULL
;
14784 if (TYPE_CACHED_VALUES_P (tmp
))
14786 TYPE_CACHED_VALUES_P (tmp
) = 0;
14787 TYPE_CACHED_VALUES (tmp
) = NULL
;
14790 md5_process_bytes (expr
, tree_size (expr
), ctx
);
14791 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
14792 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
14793 if (TREE_CODE_CLASS (code
) != tcc_type
14794 && TREE_CODE_CLASS (code
) != tcc_declaration
14795 && code
!= TREE_LIST
14796 && code
!= SSA_NAME
14797 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
14798 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
14799 switch (TREE_CODE_CLASS (code
))
14805 md5_process_bytes (TREE_STRING_POINTER (expr
),
14806 TREE_STRING_LENGTH (expr
), ctx
);
14809 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
14810 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
14813 for (i
= 0; i
< (int) VECTOR_CST_NELTS (expr
); ++i
)
14814 fold_checksum_tree (VECTOR_CST_ELT (expr
, i
), ctx
, ht
);
14820 case tcc_exceptional
:
14824 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
14825 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
14826 expr
= TREE_CHAIN (expr
);
14827 goto recursive_label
;
14830 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
14831 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
14837 case tcc_expression
:
14838 case tcc_reference
:
14839 case tcc_comparison
:
14842 case tcc_statement
:
14844 len
= TREE_OPERAND_LENGTH (expr
);
14845 for (i
= 0; i
< len
; ++i
)
14846 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
14848 case tcc_declaration
:
14849 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
14850 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
14851 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
14853 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
14854 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
14855 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
14856 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
14857 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
14860 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
14862 if (TREE_CODE (expr
) == FUNCTION_DECL
)
14864 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
14865 fold_checksum_tree (DECL_ARGUMENTS (expr
), ctx
, ht
);
14867 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
14871 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
14872 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
14873 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
14874 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
14875 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
14876 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
14877 if (INTEGRAL_TYPE_P (expr
)
14878 || SCALAR_FLOAT_TYPE_P (expr
))
14880 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
14881 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
14883 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
14884 if (TREE_CODE (expr
) == RECORD_TYPE
14885 || TREE_CODE (expr
) == UNION_TYPE
14886 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
14887 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
14888 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
14895 /* Helper function for outputting the checksum of a tree T. When
14896 debugging with gdb, you can "define mynext" to be "next" followed
14897 by "call debug_fold_checksum (op0)", then just trace down till the
14900 DEBUG_FUNCTION
void
14901 debug_fold_checksum (const_tree t
)
14904 unsigned char checksum
[16];
14905 struct md5_ctx ctx
;
14906 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14908 md5_init_ctx (&ctx
);
14909 fold_checksum_tree (t
, &ctx
, &ht
);
14910 md5_finish_ctx (&ctx
, checksum
);
14913 for (i
= 0; i
< 16; i
++)
14914 fprintf (stderr
, "%d ", checksum
[i
]);
14916 fprintf (stderr
, "\n");
14921 /* Fold a unary tree expression with code CODE of type TYPE with an
14922 operand OP0. LOC is the location of the resulting expression.
14923 Return a folded expression if successful. Otherwise, return a tree
14924 expression with code CODE of type TYPE with an operand OP0. */
14927 fold_build1_stat_loc (location_t loc
,
14928 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
14931 #ifdef ENABLE_FOLD_CHECKING
14932 unsigned char checksum_before
[16], checksum_after
[16];
14933 struct md5_ctx ctx
;
14934 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14936 md5_init_ctx (&ctx
);
14937 fold_checksum_tree (op0
, &ctx
, &ht
);
14938 md5_finish_ctx (&ctx
, checksum_before
);
14942 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14944 tem
= build1_stat_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
14946 #ifdef ENABLE_FOLD_CHECKING
14947 md5_init_ctx (&ctx
);
14948 fold_checksum_tree (op0
, &ctx
, &ht
);
14949 md5_finish_ctx (&ctx
, checksum_after
);
14951 if (memcmp (checksum_before
, checksum_after
, 16))
14952 fold_check_failed (op0
, tem
);
14957 /* Fold a binary tree expression with code CODE of type TYPE with
14958 operands OP0 and OP1. LOC is the location of the resulting
14959 expression. Return a folded expression if successful. Otherwise,
14960 return a tree expression with code CODE of type TYPE with operands
14964 fold_build2_stat_loc (location_t loc
,
14965 enum tree_code code
, tree type
, tree op0
, tree op1
14969 #ifdef ENABLE_FOLD_CHECKING
14970 unsigned char checksum_before_op0
[16],
14971 checksum_before_op1
[16],
14972 checksum_after_op0
[16],
14973 checksum_after_op1
[16];
14974 struct md5_ctx ctx
;
14975 hash_table
<pointer_hash
<const tree_node
> > ht (32);
14977 md5_init_ctx (&ctx
);
14978 fold_checksum_tree (op0
, &ctx
, &ht
);
14979 md5_finish_ctx (&ctx
, checksum_before_op0
);
14982 md5_init_ctx (&ctx
);
14983 fold_checksum_tree (op1
, &ctx
, &ht
);
14984 md5_finish_ctx (&ctx
, checksum_before_op1
);
14988 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14990 tem
= build2_stat_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
14992 #ifdef ENABLE_FOLD_CHECKING
14993 md5_init_ctx (&ctx
);
14994 fold_checksum_tree (op0
, &ctx
, &ht
);
14995 md5_finish_ctx (&ctx
, checksum_after_op0
);
14998 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14999 fold_check_failed (op0
, tem
);
15001 md5_init_ctx (&ctx
);
15002 fold_checksum_tree (op1
, &ctx
, &ht
);
15003 md5_finish_ctx (&ctx
, checksum_after_op1
);
15005 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
15006 fold_check_failed (op1
, tem
);
15011 /* Fold a ternary tree expression with code CODE of type TYPE with
15012 operands OP0, OP1, and OP2. Return a folded expression if
15013 successful. Otherwise, return a tree expression with code CODE of
15014 type TYPE with operands OP0, OP1, and OP2. */
15017 fold_build3_stat_loc (location_t loc
, enum tree_code code
, tree type
,
15018 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
15021 #ifdef ENABLE_FOLD_CHECKING
15022 unsigned char checksum_before_op0
[16],
15023 checksum_before_op1
[16],
15024 checksum_before_op2
[16],
15025 checksum_after_op0
[16],
15026 checksum_after_op1
[16],
15027 checksum_after_op2
[16];
15028 struct md5_ctx ctx
;
15029 hash_table
<pointer_hash
<const tree_node
> > ht (32);
15031 md5_init_ctx (&ctx
);
15032 fold_checksum_tree (op0
, &ctx
, &ht
);
15033 md5_finish_ctx (&ctx
, checksum_before_op0
);
15036 md5_init_ctx (&ctx
);
15037 fold_checksum_tree (op1
, &ctx
, &ht
);
15038 md5_finish_ctx (&ctx
, checksum_before_op1
);
15041 md5_init_ctx (&ctx
);
15042 fold_checksum_tree (op2
, &ctx
, &ht
);
15043 md5_finish_ctx (&ctx
, checksum_before_op2
);
15047 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
15048 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
15050 tem
= build3_stat_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
15052 #ifdef ENABLE_FOLD_CHECKING
15053 md5_init_ctx (&ctx
);
15054 fold_checksum_tree (op0
, &ctx
, &ht
);
15055 md5_finish_ctx (&ctx
, checksum_after_op0
);
15058 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
15059 fold_check_failed (op0
, tem
);
15061 md5_init_ctx (&ctx
);
15062 fold_checksum_tree (op1
, &ctx
, &ht
);
15063 md5_finish_ctx (&ctx
, checksum_after_op1
);
15066 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
15067 fold_check_failed (op1
, tem
);
15069 md5_init_ctx (&ctx
);
15070 fold_checksum_tree (op2
, &ctx
, &ht
);
15071 md5_finish_ctx (&ctx
, checksum_after_op2
);
15073 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
15074 fold_check_failed (op2
, tem
);
15079 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
15080 arguments in ARGARRAY, and a null static chain.
15081 Return a folded expression if successful. Otherwise, return a CALL_EXPR
15082 of type TYPE from the given operands as constructed by build_call_array. */
15085 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
15086 int nargs
, tree
*argarray
)
15089 #ifdef ENABLE_FOLD_CHECKING
15090 unsigned char checksum_before_fn
[16],
15091 checksum_before_arglist
[16],
15092 checksum_after_fn
[16],
15093 checksum_after_arglist
[16];
15094 struct md5_ctx ctx
;
15095 hash_table
<pointer_hash
<const tree_node
> > ht (32);
15098 md5_init_ctx (&ctx
);
15099 fold_checksum_tree (fn
, &ctx
, &ht
);
15100 md5_finish_ctx (&ctx
, checksum_before_fn
);
15103 md5_init_ctx (&ctx
);
15104 for (i
= 0; i
< nargs
; i
++)
15105 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
15106 md5_finish_ctx (&ctx
, checksum_before_arglist
);
15110 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
15112 #ifdef ENABLE_FOLD_CHECKING
15113 md5_init_ctx (&ctx
);
15114 fold_checksum_tree (fn
, &ctx
, &ht
);
15115 md5_finish_ctx (&ctx
, checksum_after_fn
);
15118 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
15119 fold_check_failed (fn
, tem
);
15121 md5_init_ctx (&ctx
);
15122 for (i
= 0; i
< nargs
; i
++)
15123 fold_checksum_tree (argarray
[i
], &ctx
, &ht
);
15124 md5_finish_ctx (&ctx
, checksum_after_arglist
);
15126 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
15127 fold_check_failed (NULL_TREE
, tem
);
15132 /* Perform constant folding and related simplification of initializer
15133 expression EXPR. These behave identically to "fold_buildN" but ignore
15134 potential run-time traps and exceptions that fold must preserve. */
15136 #define START_FOLD_INIT \
15137 int saved_signaling_nans = flag_signaling_nans;\
15138 int saved_trapping_math = flag_trapping_math;\
15139 int saved_rounding_math = flag_rounding_math;\
15140 int saved_trapv = flag_trapv;\
15141 int saved_folding_initializer = folding_initializer;\
15142 flag_signaling_nans = 0;\
15143 flag_trapping_math = 0;\
15144 flag_rounding_math = 0;\
15146 folding_initializer = 1;
15148 #define END_FOLD_INIT \
15149 flag_signaling_nans = saved_signaling_nans;\
15150 flag_trapping_math = saved_trapping_math;\
15151 flag_rounding_math = saved_rounding_math;\
15152 flag_trapv = saved_trapv;\
15153 folding_initializer = saved_folding_initializer;
15156 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
15157 tree type
, tree op
)
15162 result
= fold_build1_loc (loc
, code
, type
, op
);
15169 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
15170 tree type
, tree op0
, tree op1
)
15175 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
15182 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
15183 int nargs
, tree
*argarray
)
15188 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
15194 #undef START_FOLD_INIT
15195 #undef END_FOLD_INIT
15197 /* Determine if first argument is a multiple of second argument. Return 0 if
15198 it is not, or we cannot easily determined it to be.
15200 An example of the sort of thing we care about (at this point; this routine
15201 could surely be made more general, and expanded to do what the *_DIV_EXPR's
15202 fold cases do now) is discovering that
15204 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15210 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
15212 This code also handles discovering that
15214 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15216 is a multiple of 8 so we don't have to worry about dealing with a
15217 possible remainder.
15219 Note that we *look* inside a SAVE_EXPR only to determine how it was
15220 calculated; it is not safe for fold to do much of anything else with the
15221 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
15222 at run time. For example, the latter example above *cannot* be implemented
15223 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
15224 evaluation time of the original SAVE_EXPR is not necessarily the same at
15225 the time the new expression is evaluated. The only optimization of this
15226 sort that would be valid is changing
15228 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
15232 SAVE_EXPR (I) * SAVE_EXPR (J)
15234 (where the same SAVE_EXPR (J) is used in the original and the
15235 transformed version). */
15238 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
15240 if (operand_equal_p (top
, bottom
, 0))
15243 if (TREE_CODE (type
) != INTEGER_TYPE
)
15246 switch (TREE_CODE (top
))
15249 /* Bitwise and provides a power of two multiple. If the mask is
15250 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
15251 if (!integer_pow2p (bottom
))
15256 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
15257 || multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
15261 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
15262 && multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
15265 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
15269 op1
= TREE_OPERAND (top
, 1);
15270 /* const_binop may not detect overflow correctly,
15271 so check for it explicitly here. */
15272 if (wi::gtu_p (TYPE_PRECISION (TREE_TYPE (size_one_node
)), op1
)
15273 && 0 != (t1
= fold_convert (type
,
15274 const_binop (LSHIFT_EXPR
,
15277 && !TREE_OVERFLOW (t1
))
15278 return multiple_of_p (type
, t1
, bottom
);
15283 /* Can't handle conversions from non-integral or wider integral type. */
15284 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
15285 || (TYPE_PRECISION (type
)
15286 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
15289 /* .. fall through ... */
15292 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
15295 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
15296 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
15299 if (TREE_CODE (bottom
) != INTEGER_CST
15300 || integer_zerop (bottom
)
15301 || (TYPE_UNSIGNED (type
)
15302 && (tree_int_cst_sgn (top
) < 0
15303 || tree_int_cst_sgn (bottom
) < 0)))
15305 return wi::multiple_of_p (wi::to_widest (top
), wi::to_widest (bottom
),
15313 /* Return true if CODE or TYPE is known to be non-negative. */
15316 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
15318 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
15319 && truth_value_p (code
))
15320 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15321 have a signed:1 type (where the value is -1 and 0). */
15326 /* Return true if (CODE OP0) is known to be non-negative. If the return
15327 value is based on the assumption that signed overflow is undefined,
15328 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15329 *STRICT_OVERFLOW_P. */
15332 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15333 bool *strict_overflow_p
)
15335 if (TYPE_UNSIGNED (type
))
15341 /* We can't return 1 if flag_wrapv is set because
15342 ABS_EXPR<INT_MIN> = INT_MIN. */
15343 if (!INTEGRAL_TYPE_P (type
))
15345 if (TYPE_OVERFLOW_UNDEFINED (type
))
15347 *strict_overflow_p
= true;
15352 case NON_LVALUE_EXPR
:
15354 case FIX_TRUNC_EXPR
:
15355 return tree_expr_nonnegative_warnv_p (op0
,
15356 strict_overflow_p
);
15360 tree inner_type
= TREE_TYPE (op0
);
15361 tree outer_type
= type
;
15363 if (TREE_CODE (outer_type
) == REAL_TYPE
)
15365 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15366 return tree_expr_nonnegative_warnv_p (op0
,
15367 strict_overflow_p
);
15368 if (INTEGRAL_TYPE_P (inner_type
))
15370 if (TYPE_UNSIGNED (inner_type
))
15372 return tree_expr_nonnegative_warnv_p (op0
,
15373 strict_overflow_p
);
15376 else if (INTEGRAL_TYPE_P (outer_type
))
15378 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15379 return tree_expr_nonnegative_warnv_p (op0
,
15380 strict_overflow_p
);
15381 if (INTEGRAL_TYPE_P (inner_type
))
15382 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
15383 && TYPE_UNSIGNED (inner_type
);
15389 return tree_simple_nonnegative_warnv_p (code
, type
);
15392 /* We don't know sign of `t', so be conservative and return false. */
15396 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
15397 value is based on the assumption that signed overflow is undefined,
15398 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15399 *STRICT_OVERFLOW_P. */
15402 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15403 tree op1
, bool *strict_overflow_p
)
15405 if (TYPE_UNSIGNED (type
))
15410 case POINTER_PLUS_EXPR
:
15412 if (FLOAT_TYPE_P (type
))
15413 return (tree_expr_nonnegative_warnv_p (op0
,
15415 && tree_expr_nonnegative_warnv_p (op1
,
15416 strict_overflow_p
));
15418 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
15419 both unsigned and at least 2 bits shorter than the result. */
15420 if (TREE_CODE (type
) == INTEGER_TYPE
15421 && TREE_CODE (op0
) == NOP_EXPR
15422 && TREE_CODE (op1
) == NOP_EXPR
)
15424 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
15425 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
15426 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
15427 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
15429 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
15430 TYPE_PRECISION (inner2
)) + 1;
15431 return prec
< TYPE_PRECISION (type
);
15437 if (FLOAT_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
15439 /* x * x is always non-negative for floating point x
15440 or without overflow. */
15441 if (operand_equal_p (op0
, op1
, 0)
15442 || (tree_expr_nonnegative_warnv_p (op0
, strict_overflow_p
)
15443 && tree_expr_nonnegative_warnv_p (op1
, strict_overflow_p
)))
15445 if (TYPE_OVERFLOW_UNDEFINED (type
))
15446 *strict_overflow_p
= true;
15451 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
15452 both unsigned and their total bits is shorter than the result. */
15453 if (TREE_CODE (type
) == INTEGER_TYPE
15454 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
15455 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
15457 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
15458 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
15460 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
15461 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
15464 bool unsigned0
= TYPE_UNSIGNED (inner0
);
15465 bool unsigned1
= TYPE_UNSIGNED (inner1
);
15467 if (TREE_CODE (op0
) == INTEGER_CST
)
15468 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
15470 if (TREE_CODE (op1
) == INTEGER_CST
)
15471 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
15473 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
15474 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
15476 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
15477 ? tree_int_cst_min_precision (op0
, UNSIGNED
)
15478 : TYPE_PRECISION (inner0
);
15480 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
15481 ? tree_int_cst_min_precision (op1
, UNSIGNED
)
15482 : TYPE_PRECISION (inner1
);
15484 return precision0
+ precision1
< TYPE_PRECISION (type
);
15491 return (tree_expr_nonnegative_warnv_p (op0
,
15493 || tree_expr_nonnegative_warnv_p (op1
,
15494 strict_overflow_p
));
15500 case TRUNC_DIV_EXPR
:
15501 case CEIL_DIV_EXPR
:
15502 case FLOOR_DIV_EXPR
:
15503 case ROUND_DIV_EXPR
:
15504 return (tree_expr_nonnegative_warnv_p (op0
,
15506 && tree_expr_nonnegative_warnv_p (op1
,
15507 strict_overflow_p
));
15509 case TRUNC_MOD_EXPR
:
15510 case CEIL_MOD_EXPR
:
15511 case FLOOR_MOD_EXPR
:
15512 case ROUND_MOD_EXPR
:
15513 return tree_expr_nonnegative_warnv_p (op0
,
15514 strict_overflow_p
);
15516 return tree_simple_nonnegative_warnv_p (code
, type
);
15519 /* We don't know sign of `t', so be conservative and return false. */
15523 /* Return true if T is known to be non-negative. If the return
15524 value is based on the assumption that signed overflow is undefined,
15525 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15526 *STRICT_OVERFLOW_P. */
15529 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15531 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15534 switch (TREE_CODE (t
))
15537 return tree_int_cst_sgn (t
) >= 0;
15540 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
15543 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
15546 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15548 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 2),
15549 strict_overflow_p
));
15551 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15554 /* We don't know sign of `t', so be conservative and return false. */
15558 /* Return true if T is known to be non-negative. If the return
15559 value is based on the assumption that signed overflow is undefined,
15560 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15561 *STRICT_OVERFLOW_P. */
15564 tree_call_nonnegative_warnv_p (tree type
, tree fndecl
,
15565 tree arg0
, tree arg1
, bool *strict_overflow_p
)
15567 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
15568 switch (DECL_FUNCTION_CODE (fndecl
))
15570 CASE_FLT_FN (BUILT_IN_ACOS
):
15571 CASE_FLT_FN (BUILT_IN_ACOSH
):
15572 CASE_FLT_FN (BUILT_IN_CABS
):
15573 CASE_FLT_FN (BUILT_IN_COSH
):
15574 CASE_FLT_FN (BUILT_IN_ERFC
):
15575 CASE_FLT_FN (BUILT_IN_EXP
):
15576 CASE_FLT_FN (BUILT_IN_EXP10
):
15577 CASE_FLT_FN (BUILT_IN_EXP2
):
15578 CASE_FLT_FN (BUILT_IN_FABS
):
15579 CASE_FLT_FN (BUILT_IN_FDIM
):
15580 CASE_FLT_FN (BUILT_IN_HYPOT
):
15581 CASE_FLT_FN (BUILT_IN_POW10
):
15582 CASE_INT_FN (BUILT_IN_FFS
):
15583 CASE_INT_FN (BUILT_IN_PARITY
):
15584 CASE_INT_FN (BUILT_IN_POPCOUNT
):
15585 CASE_INT_FN (BUILT_IN_CLZ
):
15586 CASE_INT_FN (BUILT_IN_CLRSB
):
15587 case BUILT_IN_BSWAP32
:
15588 case BUILT_IN_BSWAP64
:
15592 CASE_FLT_FN (BUILT_IN_SQRT
):
15593 /* sqrt(-0.0) is -0.0. */
15594 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
15596 return tree_expr_nonnegative_warnv_p (arg0
,
15597 strict_overflow_p
);
15599 CASE_FLT_FN (BUILT_IN_ASINH
):
15600 CASE_FLT_FN (BUILT_IN_ATAN
):
15601 CASE_FLT_FN (BUILT_IN_ATANH
):
15602 CASE_FLT_FN (BUILT_IN_CBRT
):
15603 CASE_FLT_FN (BUILT_IN_CEIL
):
15604 CASE_FLT_FN (BUILT_IN_ERF
):
15605 CASE_FLT_FN (BUILT_IN_EXPM1
):
15606 CASE_FLT_FN (BUILT_IN_FLOOR
):
15607 CASE_FLT_FN (BUILT_IN_FMOD
):
15608 CASE_FLT_FN (BUILT_IN_FREXP
):
15609 CASE_FLT_FN (BUILT_IN_ICEIL
):
15610 CASE_FLT_FN (BUILT_IN_IFLOOR
):
15611 CASE_FLT_FN (BUILT_IN_IRINT
):
15612 CASE_FLT_FN (BUILT_IN_IROUND
):
15613 CASE_FLT_FN (BUILT_IN_LCEIL
):
15614 CASE_FLT_FN (BUILT_IN_LDEXP
):
15615 CASE_FLT_FN (BUILT_IN_LFLOOR
):
15616 CASE_FLT_FN (BUILT_IN_LLCEIL
):
15617 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
15618 CASE_FLT_FN (BUILT_IN_LLRINT
):
15619 CASE_FLT_FN (BUILT_IN_LLROUND
):
15620 CASE_FLT_FN (BUILT_IN_LRINT
):
15621 CASE_FLT_FN (BUILT_IN_LROUND
):
15622 CASE_FLT_FN (BUILT_IN_MODF
):
15623 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
15624 CASE_FLT_FN (BUILT_IN_RINT
):
15625 CASE_FLT_FN (BUILT_IN_ROUND
):
15626 CASE_FLT_FN (BUILT_IN_SCALB
):
15627 CASE_FLT_FN (BUILT_IN_SCALBLN
):
15628 CASE_FLT_FN (BUILT_IN_SCALBN
):
15629 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
15630 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
15631 CASE_FLT_FN (BUILT_IN_SINH
):
15632 CASE_FLT_FN (BUILT_IN_TANH
):
15633 CASE_FLT_FN (BUILT_IN_TRUNC
):
15634 /* True if the 1st argument is nonnegative. */
15635 return tree_expr_nonnegative_warnv_p (arg0
,
15636 strict_overflow_p
);
15638 CASE_FLT_FN (BUILT_IN_FMAX
):
15639 /* True if the 1st OR 2nd arguments are nonnegative. */
15640 return (tree_expr_nonnegative_warnv_p (arg0
,
15642 || (tree_expr_nonnegative_warnv_p (arg1
,
15643 strict_overflow_p
)));
15645 CASE_FLT_FN (BUILT_IN_FMIN
):
15646 /* True if the 1st AND 2nd arguments are nonnegative. */
15647 return (tree_expr_nonnegative_warnv_p (arg0
,
15649 && (tree_expr_nonnegative_warnv_p (arg1
,
15650 strict_overflow_p
)));
15652 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
15653 /* True if the 2nd argument is nonnegative. */
15654 return tree_expr_nonnegative_warnv_p (arg1
,
15655 strict_overflow_p
);
15657 CASE_FLT_FN (BUILT_IN_POWI
):
15658 /* True if the 1st argument is nonnegative or the second
15659 argument is an even integer. */
15660 if (TREE_CODE (arg1
) == INTEGER_CST
15661 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
15663 return tree_expr_nonnegative_warnv_p (arg0
,
15664 strict_overflow_p
);
15666 CASE_FLT_FN (BUILT_IN_POW
):
15667 /* True if the 1st argument is nonnegative or the second
15668 argument is an even integer valued real. */
15669 if (TREE_CODE (arg1
) == REAL_CST
)
15674 c
= TREE_REAL_CST (arg1
);
15675 n
= real_to_integer (&c
);
15678 REAL_VALUE_TYPE cint
;
15679 real_from_integer (&cint
, VOIDmode
, n
, SIGNED
);
15680 if (real_identical (&c
, &cint
))
15684 return tree_expr_nonnegative_warnv_p (arg0
,
15685 strict_overflow_p
);
15690 return tree_simple_nonnegative_warnv_p (CALL_EXPR
,
15694 /* Return true if T is known to be non-negative. If the return
15695 value is based on the assumption that signed overflow is undefined,
15696 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15697 *STRICT_OVERFLOW_P. */
15700 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15702 enum tree_code code
= TREE_CODE (t
);
15703 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15710 tree temp
= TARGET_EXPR_SLOT (t
);
15711 t
= TARGET_EXPR_INITIAL (t
);
15713 /* If the initializer is non-void, then it's a normal expression
15714 that will be assigned to the slot. */
15715 if (!VOID_TYPE_P (t
))
15716 return tree_expr_nonnegative_warnv_p (t
, strict_overflow_p
);
15718 /* Otherwise, the initializer sets the slot in some way. One common
15719 way is an assignment statement at the end of the initializer. */
15722 if (TREE_CODE (t
) == BIND_EXPR
)
15723 t
= expr_last (BIND_EXPR_BODY (t
));
15724 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
15725 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
15726 t
= expr_last (TREE_OPERAND (t
, 0));
15727 else if (TREE_CODE (t
) == STATEMENT_LIST
)
15732 if (TREE_CODE (t
) == MODIFY_EXPR
15733 && TREE_OPERAND (t
, 0) == temp
)
15734 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15735 strict_overflow_p
);
15742 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
15743 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
15745 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
15746 get_callee_fndecl (t
),
15749 strict_overflow_p
);
15751 case COMPOUND_EXPR
:
15753 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15754 strict_overflow_p
);
15756 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t
, 1)),
15757 strict_overflow_p
);
15759 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 0),
15760 strict_overflow_p
);
15763 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15767 /* We don't know sign of `t', so be conservative and return false. */
15771 /* Return true if T is known to be non-negative. If the return
15772 value is based on the assumption that signed overflow is undefined,
15773 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15774 *STRICT_OVERFLOW_P. */
15777 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15779 enum tree_code code
;
15780 if (t
== error_mark_node
)
15783 code
= TREE_CODE (t
);
15784 switch (TREE_CODE_CLASS (code
))
15787 case tcc_comparison
:
15788 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15790 TREE_OPERAND (t
, 0),
15791 TREE_OPERAND (t
, 1),
15792 strict_overflow_p
);
15795 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15797 TREE_OPERAND (t
, 0),
15798 strict_overflow_p
);
15801 case tcc_declaration
:
15802 case tcc_reference
:
15803 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15811 case TRUTH_AND_EXPR
:
15812 case TRUTH_OR_EXPR
:
15813 case TRUTH_XOR_EXPR
:
15814 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15816 TREE_OPERAND (t
, 0),
15817 TREE_OPERAND (t
, 1),
15818 strict_overflow_p
);
15819 case TRUTH_NOT_EXPR
:
15820 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15822 TREE_OPERAND (t
, 0),
15823 strict_overflow_p
);
15830 case WITH_SIZE_EXPR
:
15832 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15835 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
);
15839 /* Return true if `t' is known to be non-negative. Handle warnings
15840 about undefined signed overflow. */
15843 tree_expr_nonnegative_p (tree t
)
15845 bool ret
, strict_overflow_p
;
15847 strict_overflow_p
= false;
15848 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
15849 if (strict_overflow_p
)
15850 fold_overflow_warning (("assuming signed overflow does not occur when "
15851 "determining that expression is always "
15853 WARN_STRICT_OVERFLOW_MISC
);
15858 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15859 For floating point we further ensure that T is not denormal.
15860 Similar logic is present in nonzero_address in rtlanal.h.
15862 If the return value is based on the assumption that signed overflow
15863 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15864 change *STRICT_OVERFLOW_P. */
15867 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
15868 bool *strict_overflow_p
)
15873 return tree_expr_nonzero_warnv_p (op0
,
15874 strict_overflow_p
);
15878 tree inner_type
= TREE_TYPE (op0
);
15879 tree outer_type
= type
;
15881 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
15882 && tree_expr_nonzero_warnv_p (op0
,
15883 strict_overflow_p
));
15887 case NON_LVALUE_EXPR
:
15888 return tree_expr_nonzero_warnv_p (op0
,
15889 strict_overflow_p
);
15898 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15899 For floating point we further ensure that T is not denormal.
15900 Similar logic is present in nonzero_address in rtlanal.h.
15902 If the return value is based on the assumption that signed overflow
15903 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15904 change *STRICT_OVERFLOW_P. */
15907 tree_binary_nonzero_warnv_p (enum tree_code code
,
15910 tree op1
, bool *strict_overflow_p
)
15912 bool sub_strict_overflow_p
;
15915 case POINTER_PLUS_EXPR
:
15917 if (TYPE_OVERFLOW_UNDEFINED (type
))
15919 /* With the presence of negative values it is hard
15920 to say something. */
15921 sub_strict_overflow_p
= false;
15922 if (!tree_expr_nonnegative_warnv_p (op0
,
15923 &sub_strict_overflow_p
)
15924 || !tree_expr_nonnegative_warnv_p (op1
,
15925 &sub_strict_overflow_p
))
15927 /* One of operands must be positive and the other non-negative. */
15928 /* We don't set *STRICT_OVERFLOW_P here: even if this value
15929 overflows, on a twos-complement machine the sum of two
15930 nonnegative numbers can never be zero. */
15931 return (tree_expr_nonzero_warnv_p (op0
,
15933 || tree_expr_nonzero_warnv_p (op1
,
15934 strict_overflow_p
));
15939 if (TYPE_OVERFLOW_UNDEFINED (type
))
15941 if (tree_expr_nonzero_warnv_p (op0
,
15943 && tree_expr_nonzero_warnv_p (op1
,
15944 strict_overflow_p
))
15946 *strict_overflow_p
= true;
15953 sub_strict_overflow_p
= false;
15954 if (tree_expr_nonzero_warnv_p (op0
,
15955 &sub_strict_overflow_p
)
15956 && tree_expr_nonzero_warnv_p (op1
,
15957 &sub_strict_overflow_p
))
15959 if (sub_strict_overflow_p
)
15960 *strict_overflow_p
= true;
15965 sub_strict_overflow_p
= false;
15966 if (tree_expr_nonzero_warnv_p (op0
,
15967 &sub_strict_overflow_p
))
15969 if (sub_strict_overflow_p
)
15970 *strict_overflow_p
= true;
15972 /* When both operands are nonzero, then MAX must be too. */
15973 if (tree_expr_nonzero_warnv_p (op1
,
15974 strict_overflow_p
))
15977 /* MAX where operand 0 is positive is positive. */
15978 return tree_expr_nonnegative_warnv_p (op0
,
15979 strict_overflow_p
);
15981 /* MAX where operand 1 is positive is positive. */
15982 else if (tree_expr_nonzero_warnv_p (op1
,
15983 &sub_strict_overflow_p
)
15984 && tree_expr_nonnegative_warnv_p (op1
,
15985 &sub_strict_overflow_p
))
15987 if (sub_strict_overflow_p
)
15988 *strict_overflow_p
= true;
15994 return (tree_expr_nonzero_warnv_p (op1
,
15996 || tree_expr_nonzero_warnv_p (op0
,
15997 strict_overflow_p
));
16006 /* Return true when T is an address and is known to be nonzero.
16007 For floating point we further ensure that T is not denormal.
16008 Similar logic is present in nonzero_address in rtlanal.h.
16010 If the return value is based on the assumption that signed overflow
16011 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
16012 change *STRICT_OVERFLOW_P. */
16015 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
16017 bool sub_strict_overflow_p
;
16018 switch (TREE_CODE (t
))
16021 return !integer_zerop (t
);
16025 tree base
= TREE_OPERAND (t
, 0);
16027 if (!DECL_P (base
))
16028 base
= get_base_address (base
);
16033 /* For objects in symbol table check if we know they are non-zero.
16034 Don't do anything for variables and functions before symtab is built;
16035 it is quite possible that they will be declared weak later. */
16036 if (DECL_P (base
) && decl_in_symtab_p (base
))
16038 struct symtab_node
*symbol
;
16040 symbol
= symtab_get_node (base
);
16042 return symbol
->nonzero_address ();
16047 /* Function local objects are never NULL. */
16049 && (DECL_CONTEXT (base
)
16050 && TREE_CODE (DECL_CONTEXT (base
)) == FUNCTION_DECL
16051 && auto_var_in_fn_p (base
, DECL_CONTEXT (base
))))
16054 /* Constants are never weak. */
16055 if (CONSTANT_CLASS_P (base
))
16062 sub_strict_overflow_p
= false;
16063 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
16064 &sub_strict_overflow_p
)
16065 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
16066 &sub_strict_overflow_p
))
16068 if (sub_strict_overflow_p
)
16069 *strict_overflow_p
= true;
16080 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
16081 attempt to fold the expression to a constant without modifying TYPE,
16084 If the expression could be simplified to a constant, then return
16085 the constant. If the expression would not be simplified to a
16086 constant, then return NULL_TREE. */
16089 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
16091 tree tem
= fold_binary (code
, type
, op0
, op1
);
16092 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
16095 /* Given the components of a unary expression CODE, TYPE and OP0,
16096 attempt to fold the expression to a constant without modifying
16099 If the expression could be simplified to a constant, then return
16100 the constant. If the expression would not be simplified to a
16101 constant, then return NULL_TREE. */
16104 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
16106 tree tem
= fold_unary (code
, type
, op0
);
16107 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
16110 /* If EXP represents referencing an element in a constant string
16111 (either via pointer arithmetic or array indexing), return the
16112 tree representing the value accessed, otherwise return NULL. */
16115 fold_read_from_constant_string (tree exp
)
16117 if ((TREE_CODE (exp
) == INDIRECT_REF
16118 || TREE_CODE (exp
) == ARRAY_REF
)
16119 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
16121 tree exp1
= TREE_OPERAND (exp
, 0);
16124 location_t loc
= EXPR_LOCATION (exp
);
16126 if (TREE_CODE (exp
) == INDIRECT_REF
)
16127 string
= string_constant (exp1
, &index
);
16130 tree low_bound
= array_ref_low_bound (exp
);
16131 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
16133 /* Optimize the special-case of a zero lower bound.
16135 We convert the low_bound to sizetype to avoid some problems
16136 with constant folding. (E.g. suppose the lower bound is 1,
16137 and its mode is QI. Without the conversion,l (ARRAY
16138 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
16139 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
16140 if (! integer_zerop (low_bound
))
16141 index
= size_diffop_loc (loc
, index
,
16142 fold_convert_loc (loc
, sizetype
, low_bound
));
16148 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
16149 && TREE_CODE (string
) == STRING_CST
16150 && TREE_CODE (index
) == INTEGER_CST
16151 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
16152 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))))
16154 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))) == 1))
16155 return build_int_cst_type (TREE_TYPE (exp
),
16156 (TREE_STRING_POINTER (string
)
16157 [TREE_INT_CST_LOW (index
)]));
16162 /* Return the tree for neg (ARG0) when ARG0 is known to be either
16163 an integer constant, real, or fixed-point constant.
16165 TYPE is the type of the result. */
16168 fold_negate_const (tree arg0
, tree type
)
16170 tree t
= NULL_TREE
;
16172 switch (TREE_CODE (arg0
))
16177 wide_int val
= wi::neg (arg0
, &overflow
);
16178 t
= force_fit_type (type
, val
, 1,
16179 (overflow
| TREE_OVERFLOW (arg0
))
16180 && !TYPE_UNSIGNED (type
));
16185 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16190 FIXED_VALUE_TYPE f
;
16191 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
16192 &(TREE_FIXED_CST (arg0
)), NULL
,
16193 TYPE_SATURATING (type
));
16194 t
= build_fixed (type
, f
);
16195 /* Propagate overflow flags. */
16196 if (overflow_p
| TREE_OVERFLOW (arg0
))
16197 TREE_OVERFLOW (t
) = 1;
16202 gcc_unreachable ();
16208 /* Return the tree for abs (ARG0) when ARG0 is known to be either
16209 an integer constant or real constant.
16211 TYPE is the type of the result. */
16214 fold_abs_const (tree arg0
, tree type
)
16216 tree t
= NULL_TREE
;
16218 switch (TREE_CODE (arg0
))
16222 /* If the value is unsigned or non-negative, then the absolute value
16223 is the same as the ordinary value. */
16224 if (!wi::neg_p (arg0
, TYPE_SIGN (type
)))
16227 /* If the value is negative, then the absolute value is
16232 wide_int val
= wi::neg (arg0
, &overflow
);
16233 t
= force_fit_type (type
, val
, -1,
16234 overflow
| TREE_OVERFLOW (arg0
));
16240 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
16241 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16247 gcc_unreachable ();
16253 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
16254 constant. TYPE is the type of the result. */
16257 fold_not_const (const_tree arg0
, tree type
)
16259 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
16261 return force_fit_type (type
, wi::bit_not (arg0
), 0, TREE_OVERFLOW (arg0
));
16264 /* Given CODE, a relational operator, the target type, TYPE and two
16265 constant operands OP0 and OP1, return the result of the
16266 relational operation. If the result is not a compile time
16267 constant, then return NULL_TREE. */
16270 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
16272 int result
, invert
;
16274 /* From here on, the only cases we handle are when the result is
16275 known to be a constant. */
16277 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
16279 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
16280 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
16282 /* Handle the cases where either operand is a NaN. */
16283 if (real_isnan (c0
) || real_isnan (c1
))
16293 case UNORDERED_EXPR
:
16307 if (flag_trapping_math
)
16313 gcc_unreachable ();
16316 return constant_boolean_node (result
, type
);
16319 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
16322 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
16324 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
16325 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
16326 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
16329 /* Handle equality/inequality of complex constants. */
16330 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
16332 tree rcond
= fold_relational_const (code
, type
,
16333 TREE_REALPART (op0
),
16334 TREE_REALPART (op1
));
16335 tree icond
= fold_relational_const (code
, type
,
16336 TREE_IMAGPART (op0
),
16337 TREE_IMAGPART (op1
));
16338 if (code
== EQ_EXPR
)
16339 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
16340 else if (code
== NE_EXPR
)
16341 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
16346 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
16348 unsigned count
= VECTOR_CST_NELTS (op0
);
16349 tree
*elts
= XALLOCAVEC (tree
, count
);
16350 gcc_assert (VECTOR_CST_NELTS (op1
) == count
16351 && TYPE_VECTOR_SUBPARTS (type
) == count
);
16353 for (unsigned i
= 0; i
< count
; i
++)
16355 tree elem_type
= TREE_TYPE (type
);
16356 tree elem0
= VECTOR_CST_ELT (op0
, i
);
16357 tree elem1
= VECTOR_CST_ELT (op1
, i
);
16359 tree tem
= fold_relational_const (code
, elem_type
,
16362 if (tem
== NULL_TREE
)
16365 elts
[i
] = build_int_cst (elem_type
, integer_zerop (tem
) ? 0 : -1);
16368 return build_vector (type
, elts
);
16371 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16373 To compute GT, swap the arguments and do LT.
16374 To compute GE, do LT and invert the result.
16375 To compute LE, swap the arguments, do LT and invert the result.
16376 To compute NE, do EQ and invert the result.
16378 Therefore, the code below must handle only EQ and LT. */
16380 if (code
== LE_EXPR
|| code
== GT_EXPR
)
16385 code
= swap_tree_comparison (code
);
16388 /* Note that it is safe to invert for real values here because we
16389 have already handled the one case that it matters. */
16392 if (code
== NE_EXPR
|| code
== GE_EXPR
)
16395 code
= invert_tree_comparison (code
, false);
16398 /* Compute a result for LT or EQ if args permit;
16399 Otherwise return T. */
16400 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
16402 if (code
== EQ_EXPR
)
16403 result
= tree_int_cst_equal (op0
, op1
);
16405 result
= tree_int_cst_lt (op0
, op1
);
16412 return constant_boolean_node (result
, type
);
16415 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16416 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16420 fold_build_cleanup_point_expr (tree type
, tree expr
)
16422 /* If the expression does not have side effects then we don't have to wrap
16423 it with a cleanup point expression. */
16424 if (!TREE_SIDE_EFFECTS (expr
))
16427 /* If the expression is a return, check to see if the expression inside the
16428 return has no side effects or the right hand side of the modify expression
16429 inside the return. If either don't have side effects set we don't need to
16430 wrap the expression in a cleanup point expression. Note we don't check the
16431 left hand side of the modify because it should always be a return decl. */
16432 if (TREE_CODE (expr
) == RETURN_EXPR
)
16434 tree op
= TREE_OPERAND (expr
, 0);
16435 if (!op
|| !TREE_SIDE_EFFECTS (op
))
16437 op
= TREE_OPERAND (op
, 1);
16438 if (!TREE_SIDE_EFFECTS (op
))
16442 return build1 (CLEANUP_POINT_EXPR
, type
, expr
);
16445 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16446 of an indirection through OP0, or NULL_TREE if no simplification is
16450 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
16456 subtype
= TREE_TYPE (sub
);
16457 if (!POINTER_TYPE_P (subtype
))
16460 if (TREE_CODE (sub
) == ADDR_EXPR
)
16462 tree op
= TREE_OPERAND (sub
, 0);
16463 tree optype
= TREE_TYPE (op
);
16464 /* *&CONST_DECL -> to the value of the const decl. */
16465 if (TREE_CODE (op
) == CONST_DECL
)
16466 return DECL_INITIAL (op
);
16467 /* *&p => p; make sure to handle *&"str"[cst] here. */
16468 if (type
== optype
)
16470 tree fop
= fold_read_from_constant_string (op
);
16476 /* *(foo *)&fooarray => fooarray[0] */
16477 else if (TREE_CODE (optype
) == ARRAY_TYPE
16478 && type
== TREE_TYPE (optype
)
16479 && (!in_gimple_form
16480 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16482 tree type_domain
= TYPE_DOMAIN (optype
);
16483 tree min_val
= size_zero_node
;
16484 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16485 min_val
= TYPE_MIN_VALUE (type_domain
);
16487 && TREE_CODE (min_val
) != INTEGER_CST
)
16489 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
16490 NULL_TREE
, NULL_TREE
);
16492 /* *(foo *)&complexfoo => __real__ complexfoo */
16493 else if (TREE_CODE (optype
) == COMPLEX_TYPE
16494 && type
== TREE_TYPE (optype
))
16495 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
16496 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16497 else if (TREE_CODE (optype
) == VECTOR_TYPE
16498 && type
== TREE_TYPE (optype
))
16500 tree part_width
= TYPE_SIZE (type
);
16501 tree index
= bitsize_int (0);
16502 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
16506 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
16507 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
16509 tree op00
= TREE_OPERAND (sub
, 0);
16510 tree op01
= TREE_OPERAND (sub
, 1);
16513 if (TREE_CODE (op00
) == ADDR_EXPR
)
16516 op00
= TREE_OPERAND (op00
, 0);
16517 op00type
= TREE_TYPE (op00
);
16519 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16520 if (TREE_CODE (op00type
) == VECTOR_TYPE
16521 && type
== TREE_TYPE (op00type
))
16523 HOST_WIDE_INT offset
= tree_to_shwi (op01
);
16524 tree part_width
= TYPE_SIZE (type
);
16525 unsigned HOST_WIDE_INT part_widthi
= tree_to_shwi (part_width
)/BITS_PER_UNIT
;
16526 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
16527 tree index
= bitsize_int (indexi
);
16529 if (offset
/ part_widthi
< TYPE_VECTOR_SUBPARTS (op00type
))
16530 return fold_build3_loc (loc
,
16531 BIT_FIELD_REF
, type
, op00
,
16532 part_width
, index
);
16535 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16536 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
16537 && type
== TREE_TYPE (op00type
))
16539 tree size
= TYPE_SIZE_UNIT (type
);
16540 if (tree_int_cst_equal (size
, op01
))
16541 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
16543 /* ((foo *)&fooarray)[1] => fooarray[1] */
16544 else if (TREE_CODE (op00type
) == ARRAY_TYPE
16545 && type
== TREE_TYPE (op00type
))
16547 tree type_domain
= TYPE_DOMAIN (op00type
);
16548 tree min_val
= size_zero_node
;
16549 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16550 min_val
= TYPE_MIN_VALUE (type_domain
);
16551 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
16552 TYPE_SIZE_UNIT (type
));
16553 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
16554 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
16555 NULL_TREE
, NULL_TREE
);
16560 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16561 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
16562 && type
== TREE_TYPE (TREE_TYPE (subtype
))
16563 && (!in_gimple_form
16564 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16567 tree min_val
= size_zero_node
;
16568 sub
= build_fold_indirect_ref_loc (loc
, sub
);
16569 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
16570 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16571 min_val
= TYPE_MIN_VALUE (type_domain
);
16573 && TREE_CODE (min_val
) != INTEGER_CST
)
16575 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
16582 /* Builds an expression for an indirection through T, simplifying some
16586 build_fold_indirect_ref_loc (location_t loc
, tree t
)
16588 tree type
= TREE_TYPE (TREE_TYPE (t
));
16589 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
16594 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
16597 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16600 fold_indirect_ref_loc (location_t loc
, tree t
)
16602 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
16610 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16611 whose result is ignored. The type of the returned tree need not be
16612 the same as the original expression. */
16615 fold_ignored_result (tree t
)
16617 if (!TREE_SIDE_EFFECTS (t
))
16618 return integer_zero_node
;
16621 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
16624 t
= TREE_OPERAND (t
, 0);
16628 case tcc_comparison
:
16629 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16630 t
= TREE_OPERAND (t
, 0);
16631 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
16632 t
= TREE_OPERAND (t
, 1);
16637 case tcc_expression
:
16638 switch (TREE_CODE (t
))
16640 case COMPOUND_EXPR
:
16641 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16643 t
= TREE_OPERAND (t
, 0);
16647 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
16648 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
16650 t
= TREE_OPERAND (t
, 0);
16663 /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
16666 round_up_loc (location_t loc
, tree value
, unsigned int divisor
)
16668 tree div
= NULL_TREE
;
16673 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16674 have to do anything. Only do this when we are not given a const,
16675 because in that case, this check is more expensive than just
16677 if (TREE_CODE (value
) != INTEGER_CST
)
16679 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16681 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16685 /* If divisor is a power of two, simplify this to bit manipulation. */
16686 if (divisor
== (divisor
& -divisor
))
16688 if (TREE_CODE (value
) == INTEGER_CST
)
16690 wide_int val
= value
;
16693 if ((val
& (divisor
- 1)) == 0)
16696 overflow_p
= TREE_OVERFLOW (value
);
16697 val
&= ~(divisor
- 1);
16702 return force_fit_type (TREE_TYPE (value
), val
, -1, overflow_p
);
16708 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
16709 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
16710 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16711 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16717 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16718 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
16719 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16725 /* Likewise, but round down. */
16728 round_down_loc (location_t loc
, tree value
, int divisor
)
16730 tree div
= NULL_TREE
;
16732 gcc_assert (divisor
> 0);
16736 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16737 have to do anything. Only do this when we are not given a const,
16738 because in that case, this check is more expensive than just
16740 if (TREE_CODE (value
) != INTEGER_CST
)
16742 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16744 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16748 /* If divisor is a power of two, simplify this to bit manipulation. */
16749 if (divisor
== (divisor
& -divisor
))
16753 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16754 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16759 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16760 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
16761 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16767 /* Returns the pointer to the base of the object addressed by EXP and
16768 extracts the information about the offset of the access, storing it
16769 to PBITPOS and POFFSET. */
16772 split_address_to_core_and_offset (tree exp
,
16773 HOST_WIDE_INT
*pbitpos
, tree
*poffset
)
16776 enum machine_mode mode
;
16777 int unsignedp
, volatilep
;
16778 HOST_WIDE_INT bitsize
;
16779 location_t loc
= EXPR_LOCATION (exp
);
16781 if (TREE_CODE (exp
) == ADDR_EXPR
)
16783 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
16784 poffset
, &mode
, &unsignedp
, &volatilep
,
16786 core
= build_fold_addr_expr_loc (loc
, core
);
16792 *poffset
= NULL_TREE
;
16798 /* Returns true if addresses of E1 and E2 differ by a constant, false
16799 otherwise. If they do, E1 - E2 is stored in *DIFF. */
16802 ptr_difference_const (tree e1
, tree e2
, HOST_WIDE_INT
*diff
)
16805 HOST_WIDE_INT bitpos1
, bitpos2
;
16806 tree toffset1
, toffset2
, tdiff
, type
;
16808 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
16809 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
16811 if (bitpos1
% BITS_PER_UNIT
!= 0
16812 || bitpos2
% BITS_PER_UNIT
!= 0
16813 || !operand_equal_p (core1
, core2
, 0))
16816 if (toffset1
&& toffset2
)
16818 type
= TREE_TYPE (toffset1
);
16819 if (type
!= TREE_TYPE (toffset2
))
16820 toffset2
= fold_convert (type
, toffset2
);
16822 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
16823 if (!cst_and_fits_in_hwi (tdiff
))
16826 *diff
= int_cst_value (tdiff
);
16828 else if (toffset1
|| toffset2
)
16830 /* If only one of the offsets is non-constant, the difference cannot
16837 *diff
+= (bitpos1
- bitpos2
) / BITS_PER_UNIT
;
16841 /* Simplify the floating point expression EXP when the sign of the
16842 result is not significant. Return NULL_TREE if no simplification
16846 fold_strip_sign_ops (tree exp
)
16849 location_t loc
= EXPR_LOCATION (exp
);
16851 switch (TREE_CODE (exp
))
16855 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16856 return arg0
? arg0
: TREE_OPERAND (exp
, 0);
16860 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp
))))
16862 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16863 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16864 if (arg0
!= NULL_TREE
|| arg1
!= NULL_TREE
)
16865 return fold_build2_loc (loc
, TREE_CODE (exp
), TREE_TYPE (exp
),
16866 arg0
? arg0
: TREE_OPERAND (exp
, 0),
16867 arg1
? arg1
: TREE_OPERAND (exp
, 1));
16870 case COMPOUND_EXPR
:
16871 arg0
= TREE_OPERAND (exp
, 0);
16872 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16874 return fold_build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (exp
), arg0
, arg1
);
16878 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16879 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 2));
16881 return fold_build3_loc (loc
,
16882 COND_EXPR
, TREE_TYPE (exp
), TREE_OPERAND (exp
, 0),
16883 arg0
? arg0
: TREE_OPERAND (exp
, 1),
16884 arg1
? arg1
: TREE_OPERAND (exp
, 2));
16889 const enum built_in_function fcode
= builtin_mathfn_code (exp
);
16892 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
16893 /* Strip copysign function call, return the 1st argument. */
16894 arg0
= CALL_EXPR_ARG (exp
, 0);
16895 arg1
= CALL_EXPR_ARG (exp
, 1);
16896 return omit_one_operand_loc (loc
, TREE_TYPE (exp
), arg0
, arg1
);
16899 /* Strip sign ops from the argument of "odd" math functions. */
16900 if (negate_mathfn_p (fcode
))
16902 arg0
= fold_strip_sign_ops (CALL_EXPR_ARG (exp
, 0));
16904 return build_call_expr_loc (loc
, get_callee_fndecl (exp
), 1, arg0
);