1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /*@@ This file should be rewritten to use an arbitrary precision
23 @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
24 @@ Perhaps the routines could also be used for bc/dc, and made a lib.
25 @@ The routines that translate from the ap rep should
26 @@ warn if precision et. al. is lost.
27 @@ This would also make life easier when this technology is used
28 @@ for cross-compilers. */
30 /* The entry points in this file are fold, size_int_wide and size_binop.
32 fold takes a tree as argument and returns a simplified tree.
34 size_binop takes a tree code for an arithmetic operation
35 and two operands that are trees, and produces a tree for the
36 result, assuming the type comes from `sizetype'.
38 size_int takes an integer value, and creates a tree constant
39 with type from `sizetype'.
41 Note: Since the folders get called on non-gimple code as well as
42 gimple code, we need to handle GIMPLE tuples as well as their
43 corresponding tree equivalents. */
47 #include "coretypes.h"
56 #include "diagnostic-core.h"
59 #include "hash-table.h"
60 #include "langhooks.h"
63 #include "tree-flow.h"
65 /* Nonzero if we are folding constants inside an initializer; zero
67 int folding_initializer
= 0;
69 /* The following constants represent a bit based encoding of GCC's
70 comparison operators. This encoding simplifies transformations
71 on relational comparison operators, such as AND and OR. */
72 enum comparison_code
{
91 static bool negate_mathfn_p (enum built_in_function
);
92 static bool negate_expr_p (tree
);
93 static tree
negate_expr (tree
);
94 static tree
split_tree (tree
, enum tree_code
, tree
*, tree
*, tree
*, int);
95 static tree
associate_trees (location_t
, tree
, tree
, enum tree_code
, tree
);
96 static tree
const_binop (enum tree_code
, tree
, tree
);
97 static enum comparison_code
comparison_to_compcode (enum tree_code
);
98 static enum tree_code
compcode_to_comparison (enum comparison_code
);
99 static int operand_equal_for_comparison_p (tree
, tree
, tree
);
100 static int twoval_comparison_p (tree
, tree
*, tree
*, int *);
101 static tree
eval_subst (location_t
, tree
, tree
, tree
, tree
, tree
);
102 static tree
pedantic_omit_one_operand_loc (location_t
, tree
, tree
, tree
);
103 static tree
distribute_bit_expr (location_t
, enum tree_code
, tree
, tree
, tree
);
104 static tree
make_bit_field_ref (location_t
, tree
, tree
,
105 HOST_WIDE_INT
, HOST_WIDE_INT
, int);
106 static tree
optimize_bit_field_compare (location_t
, enum tree_code
,
108 static tree
decode_field_reference (location_t
, tree
, HOST_WIDE_INT
*,
110 enum machine_mode
*, int *, int *,
112 static int all_ones_mask_p (const_tree
, int);
113 static tree
sign_bit_p (tree
, const_tree
);
114 static int simple_operand_p (const_tree
);
115 static bool simple_operand_p_2 (tree
);
116 static tree
range_binop (enum tree_code
, tree
, tree
, int, tree
, int);
117 static tree
range_predecessor (tree
);
118 static tree
range_successor (tree
);
119 static tree
fold_range_test (location_t
, enum tree_code
, tree
, tree
, tree
);
120 static tree
fold_cond_expr_with_comparison (location_t
, tree
, tree
, tree
, tree
);
121 static tree
unextend (tree
, int, int, tree
);
122 static tree
optimize_minmax_comparison (location_t
, enum tree_code
,
124 static tree
extract_muldiv (tree
, tree
, enum tree_code
, tree
, bool *);
125 static tree
extract_muldiv_1 (tree
, tree
, enum tree_code
, tree
, bool *);
126 static tree
fold_binary_op_with_conditional_arg (location_t
,
127 enum tree_code
, tree
,
130 static tree
fold_mathfn_compare (location_t
,
131 enum built_in_function
, enum tree_code
,
133 static tree
fold_inf_compare (location_t
, enum tree_code
, tree
, tree
, tree
);
134 static tree
fold_div_compare (location_t
, enum tree_code
, tree
, tree
, tree
);
135 static bool reorder_operands_p (const_tree
, const_tree
);
136 static tree
fold_negate_const (tree
, tree
);
137 static tree
fold_not_const (const_tree
, tree
);
138 static tree
fold_relational_const (enum tree_code
, tree
, tree
, tree
);
139 static tree
fold_convert_const (enum tree_code
, tree
, tree
);
141 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
142 Otherwise, return LOC. */
145 expr_location_or (tree t
, location_t loc
)
147 location_t tloc
= EXPR_LOCATION (t
);
148 return tloc
== UNKNOWN_LOCATION
? loc
: tloc
;
151 /* Similar to protected_set_expr_location, but never modify x in place,
152 if location can and needs to be set, unshare it. */
155 protected_set_expr_location_unshare (tree x
, location_t loc
)
157 if (CAN_HAVE_LOCATION_P (x
)
158 && EXPR_LOCATION (x
) != loc
159 && !(TREE_CODE (x
) == SAVE_EXPR
160 || TREE_CODE (x
) == TARGET_EXPR
161 || TREE_CODE (x
) == BIND_EXPR
))
164 SET_EXPR_LOCATION (x
, loc
);
169 /* If ARG2 divides ARG1 with zero remainder, carries out the division
170 of type CODE and returns the quotient.
171 Otherwise returns NULL_TREE. */
174 div_if_zero_remainder (enum tree_code code
, const_tree arg1
, const_tree arg2
)
179 /* The sign of the division is according to operand two, that
180 does the correct thing for POINTER_PLUS_EXPR where we want
181 a signed division. */
182 uns
= TYPE_UNSIGNED (TREE_TYPE (arg2
));
184 quo
= tree_to_double_int (arg1
).divmod (tree_to_double_int (arg2
),
188 return build_int_cst_wide (TREE_TYPE (arg1
), quo
.low
, quo
.high
);
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
)
362 unsigned HOST_WIDE_INT val
;
366 gcc_assert (TREE_CODE (t
) == INTEGER_CST
);
368 type
= TREE_TYPE (t
);
369 if (TYPE_UNSIGNED (type
))
372 prec
= TYPE_PRECISION (type
);
373 if (prec
> HOST_BITS_PER_WIDE_INT
)
375 if (TREE_INT_CST_LOW (t
) != 0)
377 prec
-= HOST_BITS_PER_WIDE_INT
;
378 val
= TREE_INT_CST_HIGH (t
);
381 val
= TREE_INT_CST_LOW (t
);
382 if (prec
< HOST_BITS_PER_WIDE_INT
)
383 val
&= ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
384 return val
!= ((unsigned HOST_WIDE_INT
) 1 << (prec
- 1));
387 /* Determine whether an expression T can be cheaply negated using
388 the function negate_expr without introducing undefined overflow. */
391 negate_expr_p (tree t
)
398 type
= TREE_TYPE (t
);
401 switch (TREE_CODE (t
))
404 if (TYPE_OVERFLOW_WRAPS (type
))
407 /* Check that -CST will not overflow type. */
408 return may_negate_without_overflow_p (t
);
410 return (INTEGRAL_TYPE_P (type
)
411 && TYPE_OVERFLOW_WRAPS (type
));
418 /* We want to canonicalize to positive real constants. Pretend
419 that only negative ones can be easily negated. */
420 return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
423 return negate_expr_p (TREE_REALPART (t
))
424 && negate_expr_p (TREE_IMAGPART (t
));
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));
469 /* In general we can't negate A / B, because if A is INT_MIN and
470 B is 1, we may turn this into INT_MIN / -1 which is undefined
471 and actually traps on some architectures. But if overflow is
472 undefined, we can negate, because - (INT_MIN / 1) is an
474 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
475 && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
)))
477 return negate_expr_p (TREE_OPERAND (t
, 1))
478 || negate_expr_p (TREE_OPERAND (t
, 0));
481 /* Negate -((double)float) as (double)(-float). */
482 if (TREE_CODE (type
) == REAL_TYPE
)
484 tree tem
= strip_float_extensions (t
);
486 return negate_expr_p (tem
);
491 /* Negate -f(x) as f(-x). */
492 if (negate_mathfn_p (builtin_mathfn_code (t
)))
493 return negate_expr_p (CALL_EXPR_ARG (t
, 0));
497 /* Optimize -((int)x >> 31) into (unsigned)x >> 31. */
498 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
500 tree op1
= TREE_OPERAND (t
, 1);
501 if (TREE_INT_CST_HIGH (op1
) == 0
502 && (unsigned HOST_WIDE_INT
) (TYPE_PRECISION (type
) - 1)
503 == TREE_INT_CST_LOW (op1
))
514 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
515 simplification is possible.
516 If negate_expr_p would return true for T, NULL_TREE will never be
520 fold_negate_expr (location_t loc
, tree t
)
522 tree type
= TREE_TYPE (t
);
525 switch (TREE_CODE (t
))
527 /* Convert - (~A) to A + 1. */
529 if (INTEGRAL_TYPE_P (type
))
530 return fold_build2_loc (loc
, PLUS_EXPR
, type
, TREE_OPERAND (t
, 0),
531 build_int_cst (type
, 1));
535 tem
= fold_negate_const (t
, type
);
536 if (TREE_OVERFLOW (tem
) == TREE_OVERFLOW (t
)
537 || !TYPE_OVERFLOW_TRAPS (type
))
542 tem
= fold_negate_const (t
, type
);
543 /* Two's complement FP formats, such as c4x, may overflow. */
544 if (!TREE_OVERFLOW (tem
) || !flag_trapping_math
)
549 tem
= fold_negate_const (t
, type
);
554 tree rpart
= negate_expr (TREE_REALPART (t
));
555 tree ipart
= negate_expr (TREE_IMAGPART (t
));
557 if ((TREE_CODE (rpart
) == REAL_CST
558 && TREE_CODE (ipart
) == REAL_CST
)
559 || (TREE_CODE (rpart
) == INTEGER_CST
560 && TREE_CODE (ipart
) == INTEGER_CST
))
561 return build_complex (type
, rpart
, ipart
);
566 if (negate_expr_p (t
))
567 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
568 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)),
569 fold_negate_expr (loc
, TREE_OPERAND (t
, 1)));
573 if (negate_expr_p (t
))
574 return fold_build1_loc (loc
, CONJ_EXPR
, type
,
575 fold_negate_expr (loc
, TREE_OPERAND (t
, 0)));
579 return TREE_OPERAND (t
, 0);
582 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
))
583 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
585 /* -(A + B) -> (-B) - A. */
586 if (negate_expr_p (TREE_OPERAND (t
, 1))
587 && reorder_operands_p (TREE_OPERAND (t
, 0),
588 TREE_OPERAND (t
, 1)))
590 tem
= negate_expr (TREE_OPERAND (t
, 1));
591 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
592 tem
, TREE_OPERAND (t
, 0));
595 /* -(A + B) -> (-A) - B. */
596 if (negate_expr_p (TREE_OPERAND (t
, 0)))
598 tem
= negate_expr (TREE_OPERAND (t
, 0));
599 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
600 tem
, TREE_OPERAND (t
, 1));
606 /* - (A - B) -> B - A */
607 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
))
608 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
609 && reorder_operands_p (TREE_OPERAND (t
, 0), TREE_OPERAND (t
, 1)))
610 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
611 TREE_OPERAND (t
, 1), TREE_OPERAND (t
, 0));
615 if (TYPE_UNSIGNED (type
))
621 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
)))
623 tem
= TREE_OPERAND (t
, 1);
624 if (negate_expr_p (tem
))
625 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
626 TREE_OPERAND (t
, 0), negate_expr (tem
));
627 tem
= TREE_OPERAND (t
, 0);
628 if (negate_expr_p (tem
))
629 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
630 negate_expr (tem
), TREE_OPERAND (t
, 1));
639 /* In general we can't negate A / B, because if A is INT_MIN and
640 B is 1, we may turn this into INT_MIN / -1 which is undefined
641 and actually traps on some architectures. But if overflow is
642 undefined, we can negate, because - (INT_MIN / 1) is an
644 if (!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
646 const char * const warnmsg
= G_("assuming signed overflow does not "
647 "occur when negating a division");
648 tem
= TREE_OPERAND (t
, 1);
649 if (negate_expr_p (tem
))
651 if (INTEGRAL_TYPE_P (type
)
652 && (TREE_CODE (tem
) != INTEGER_CST
653 || integer_onep (tem
)))
654 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MISC
);
655 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
656 TREE_OPERAND (t
, 0), negate_expr (tem
));
658 tem
= TREE_OPERAND (t
, 0);
659 if (negate_expr_p (tem
))
661 if (INTEGRAL_TYPE_P (type
)
662 && (TREE_CODE (tem
) != INTEGER_CST
663 || tree_int_cst_equal (tem
, TYPE_MIN_VALUE (type
))))
664 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MISC
);
665 return fold_build2_loc (loc
, TREE_CODE (t
), type
,
666 negate_expr (tem
), TREE_OPERAND (t
, 1));
672 /* Convert -((double)float) into (double)(-float). */
673 if (TREE_CODE (type
) == REAL_TYPE
)
675 tem
= strip_float_extensions (t
);
676 if (tem
!= t
&& negate_expr_p (tem
))
677 return fold_convert_loc (loc
, type
, negate_expr (tem
));
682 /* Negate -f(x) as f(-x). */
683 if (negate_mathfn_p (builtin_mathfn_code (t
))
684 && negate_expr_p (CALL_EXPR_ARG (t
, 0)))
688 fndecl
= get_callee_fndecl (t
);
689 arg
= negate_expr (CALL_EXPR_ARG (t
, 0));
690 return build_call_expr_loc (loc
, fndecl
, 1, arg
);
695 /* Optimize -((int)x >> 31) into (unsigned)x >> 31. */
696 if (TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
)
698 tree op1
= TREE_OPERAND (t
, 1);
699 if (TREE_INT_CST_HIGH (op1
) == 0
700 && (unsigned HOST_WIDE_INT
) (TYPE_PRECISION (type
) - 1)
701 == TREE_INT_CST_LOW (op1
))
703 tree ntype
= TYPE_UNSIGNED (type
)
704 ? signed_type_for (type
)
705 : unsigned_type_for (type
);
706 tree temp
= fold_convert_loc (loc
, ntype
, TREE_OPERAND (t
, 0));
707 temp
= fold_build2_loc (loc
, RSHIFT_EXPR
, ntype
, temp
, op1
);
708 return fold_convert_loc (loc
, type
, temp
);
720 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
721 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
733 loc
= EXPR_LOCATION (t
);
734 type
= TREE_TYPE (t
);
737 tem
= fold_negate_expr (loc
, t
);
739 tem
= build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (t
), t
);
740 return fold_convert_loc (loc
, type
, tem
);
743 /* Split a tree IN into a constant, literal and variable parts that could be
744 combined with CODE to make IN. "constant" means an expression with
745 TREE_CONSTANT but that isn't an actual constant. CODE must be a
746 commutative arithmetic operation. Store the constant part into *CONP,
747 the literal in *LITP and return the variable part. If a part isn't
748 present, set it to null. If the tree does not decompose in this way,
749 return the entire tree as the variable part and the other parts as null.
751 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
752 case, we negate an operand that was subtracted. Except if it is a
753 literal for which we use *MINUS_LITP instead.
755 If NEGATE_P is true, we are negating all of IN, again except a literal
756 for which we use *MINUS_LITP instead.
758 If IN is itself a literal or constant, return it as appropriate.
760 Note that we do not guarantee that any of the three values will be the
761 same type as IN, but they will have the same signedness and mode. */
764 split_tree (tree in
, enum tree_code code
, tree
*conp
, tree
*litp
,
765 tree
*minus_litp
, int negate_p
)
773 /* Strip any conversions that don't change the machine mode or signedness. */
774 STRIP_SIGN_NOPS (in
);
776 if (TREE_CODE (in
) == INTEGER_CST
|| TREE_CODE (in
) == REAL_CST
777 || TREE_CODE (in
) == FIXED_CST
)
779 else if (TREE_CODE (in
) == code
780 || ((! FLOAT_TYPE_P (TREE_TYPE (in
)) || flag_associative_math
)
781 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in
))
782 /* We can associate addition and subtraction together (even
783 though the C standard doesn't say so) for integers because
784 the value is not affected. For reals, the value might be
785 affected, so we can't. */
786 && ((code
== PLUS_EXPR
&& TREE_CODE (in
) == MINUS_EXPR
)
787 || (code
== MINUS_EXPR
&& TREE_CODE (in
) == PLUS_EXPR
))))
789 tree op0
= TREE_OPERAND (in
, 0);
790 tree op1
= TREE_OPERAND (in
, 1);
791 int neg1_p
= TREE_CODE (in
) == MINUS_EXPR
;
792 int neg_litp_p
= 0, neg_conp_p
= 0, neg_var_p
= 0;
794 /* First see if either of the operands is a literal, then a constant. */
795 if (TREE_CODE (op0
) == INTEGER_CST
|| TREE_CODE (op0
) == REAL_CST
796 || TREE_CODE (op0
) == FIXED_CST
)
797 *litp
= op0
, op0
= 0;
798 else if (TREE_CODE (op1
) == INTEGER_CST
|| TREE_CODE (op1
) == REAL_CST
799 || TREE_CODE (op1
) == FIXED_CST
)
800 *litp
= op1
, neg_litp_p
= neg1_p
, op1
= 0;
802 if (op0
!= 0 && TREE_CONSTANT (op0
))
803 *conp
= op0
, op0
= 0;
804 else if (op1
!= 0 && TREE_CONSTANT (op1
))
805 *conp
= op1
, neg_conp_p
= neg1_p
, op1
= 0;
807 /* If we haven't dealt with either operand, this is not a case we can
808 decompose. Otherwise, VAR is either of the ones remaining, if any. */
809 if (op0
!= 0 && op1
!= 0)
814 var
= op1
, neg_var_p
= neg1_p
;
816 /* Now do any needed negations. */
818 *minus_litp
= *litp
, *litp
= 0;
820 *conp
= negate_expr (*conp
);
822 var
= negate_expr (var
);
824 else if (TREE_CONSTANT (in
))
832 *minus_litp
= *litp
, *litp
= 0;
833 else if (*minus_litp
)
834 *litp
= *minus_litp
, *minus_litp
= 0;
835 *conp
= negate_expr (*conp
);
836 var
= negate_expr (var
);
842 /* Re-associate trees split by the above function. T1 and T2 are
843 either expressions to associate or null. Return the new
844 expression, if any. LOC is the location of the new expression. If
845 we build an operation, do it in TYPE and with CODE. */
848 associate_trees (location_t loc
, tree t1
, tree t2
, enum tree_code code
, tree type
)
855 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
856 try to fold this since we will have infinite recursion. But do
857 deal with any NEGATE_EXPRs. */
858 if (TREE_CODE (t1
) == code
|| TREE_CODE (t2
) == code
859 || TREE_CODE (t1
) == MINUS_EXPR
|| TREE_CODE (t2
) == MINUS_EXPR
)
861 if (code
== PLUS_EXPR
)
863 if (TREE_CODE (t1
) == NEGATE_EXPR
)
864 return build2_loc (loc
, MINUS_EXPR
, type
,
865 fold_convert_loc (loc
, type
, t2
),
866 fold_convert_loc (loc
, type
,
867 TREE_OPERAND (t1
, 0)));
868 else if (TREE_CODE (t2
) == NEGATE_EXPR
)
869 return build2_loc (loc
, MINUS_EXPR
, type
,
870 fold_convert_loc (loc
, type
, t1
),
871 fold_convert_loc (loc
, type
,
872 TREE_OPERAND (t2
, 0)));
873 else if (integer_zerop (t2
))
874 return fold_convert_loc (loc
, type
, t1
);
876 else if (code
== MINUS_EXPR
)
878 if (integer_zerop (t2
))
879 return fold_convert_loc (loc
, type
, t1
);
882 return build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
883 fold_convert_loc (loc
, type
, t2
));
886 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, t1
),
887 fold_convert_loc (loc
, type
, t2
));
890 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
891 for use in int_const_binop, size_binop and size_diffop. */
894 int_binop_types_match_p (enum tree_code code
, const_tree type1
, const_tree type2
)
896 if (TREE_CODE (type1
) != INTEGER_TYPE
&& !POINTER_TYPE_P (type1
))
898 if (TREE_CODE (type2
) != INTEGER_TYPE
&& !POINTER_TYPE_P (type2
))
913 return TYPE_UNSIGNED (type1
) == TYPE_UNSIGNED (type2
)
914 && TYPE_PRECISION (type1
) == TYPE_PRECISION (type2
)
915 && TYPE_MODE (type1
) == TYPE_MODE (type2
);
919 /* Combine two integer constants ARG1 and ARG2 under operation CODE
920 to produce a new constant. Return NULL_TREE if we don't know how
921 to evaluate CODE at compile-time. */
924 int_const_binop_1 (enum tree_code code
, const_tree arg1
, const_tree arg2
,
927 double_int op1
, op2
, res
, tmp
;
929 tree type
= TREE_TYPE (arg1
);
930 bool uns
= TYPE_UNSIGNED (type
);
931 bool overflow
= false;
933 op1
= tree_to_double_int (arg1
);
934 op2
= tree_to_double_int (arg2
);
951 res
= op1
.rshift (op2
.to_shwi (), TYPE_PRECISION (type
), !uns
);
955 /* It's unclear from the C standard whether shifts can overflow.
956 The following code ignores overflow; perhaps a C standard
957 interpretation ruling is needed. */
958 res
= op1
.lshift (op2
.to_shwi (), TYPE_PRECISION (type
), !uns
);
962 res
= op1
.rrotate (op2
.to_shwi (), TYPE_PRECISION (type
));
966 res
= op1
.lrotate (op2
.to_shwi (), TYPE_PRECISION (type
));
970 res
= op1
.add_with_sign (op2
, false, &overflow
);
974 res
= op1
.sub_with_overflow (op2
, &overflow
);
978 res
= op1
.mul_with_sign (op2
, false, &overflow
);
981 case MULT_HIGHPART_EXPR
:
982 /* ??? Need quad precision, or an additional shift operand
983 to the multiply primitive, to handle very large highparts. */
984 if (TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
)
987 res
= tmp
.rshift (TYPE_PRECISION (type
), TYPE_PRECISION (type
), !uns
);
991 case FLOOR_DIV_EXPR
: case CEIL_DIV_EXPR
:
993 /* This is a shortcut for a common special case. */
994 if (op2
.high
== 0 && (HOST_WIDE_INT
) op2
.low
> 0
995 && !TREE_OVERFLOW (arg1
)
996 && !TREE_OVERFLOW (arg2
)
997 && op1
.high
== 0 && (HOST_WIDE_INT
) op1
.low
>= 0)
999 if (code
== CEIL_DIV_EXPR
)
1000 op1
.low
+= op2
.low
- 1;
1002 res
.low
= op1
.low
/ op2
.low
, res
.high
= 0;
1006 /* ... fall through ... */
1008 case ROUND_DIV_EXPR
:
1016 if (op1
== op2
&& !op1
.is_zero ())
1018 res
= double_int_one
;
1021 res
= op1
.divmod_with_overflow (op2
, uns
, code
, &tmp
, &overflow
);
1024 case TRUNC_MOD_EXPR
:
1025 case FLOOR_MOD_EXPR
: case CEIL_MOD_EXPR
:
1026 /* This is a shortcut for a common special case. */
1027 if (op2
.high
== 0 && (HOST_WIDE_INT
) op2
.low
> 0
1028 && !TREE_OVERFLOW (arg1
)
1029 && !TREE_OVERFLOW (arg2
)
1030 && op1
.high
== 0 && (HOST_WIDE_INT
) op1
.low
>= 0)
1032 if (code
== CEIL_MOD_EXPR
)
1033 op1
.low
+= op2
.low
- 1;
1034 res
.low
= op1
.low
% op2
.low
, res
.high
= 0;
1038 /* ... fall through ... */
1040 case ROUND_MOD_EXPR
:
1043 tmp
= op1
.divmod_with_overflow (op2
, uns
, code
, &res
, &overflow
);
1047 res
= op1
.min (op2
, uns
);
1051 res
= op1
.max (op2
, uns
);
1058 t
= force_fit_type_double (TREE_TYPE (arg1
), res
, overflowable
,
1060 | TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
));
1066 int_const_binop (enum tree_code code
, const_tree arg1
, const_tree arg2
)
1068 return int_const_binop_1 (code
, arg1
, arg2
, 1);
1071 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1072 constant. We assume ARG1 and ARG2 have the same data type, or at least
1073 are the same kind of constant and the same machine mode. Return zero if
1074 combining the constants is not allowed in the current operating mode. */
1077 const_binop (enum tree_code code
, tree arg1
, tree arg2
)
1079 /* Sanity check for the recursive cases. */
1086 if (TREE_CODE (arg1
) == INTEGER_CST
)
1087 return int_const_binop (code
, arg1
, arg2
);
1089 if (TREE_CODE (arg1
) == REAL_CST
)
1091 enum machine_mode mode
;
1094 REAL_VALUE_TYPE value
;
1095 REAL_VALUE_TYPE result
;
1099 /* The following codes are handled by real_arithmetic. */
1114 d1
= TREE_REAL_CST (arg1
);
1115 d2
= TREE_REAL_CST (arg2
);
1117 type
= TREE_TYPE (arg1
);
1118 mode
= TYPE_MODE (type
);
1120 /* Don't perform operation if we honor signaling NaNs and
1121 either operand is a NaN. */
1122 if (HONOR_SNANS (mode
)
1123 && (REAL_VALUE_ISNAN (d1
) || REAL_VALUE_ISNAN (d2
)))
1126 /* Don't perform operation if it would raise a division
1127 by zero exception. */
1128 if (code
== RDIV_EXPR
1129 && REAL_VALUES_EQUAL (d2
, dconst0
)
1130 && (flag_trapping_math
|| ! MODE_HAS_INFINITIES (mode
)))
1133 /* If either operand is a NaN, just return it. Otherwise, set up
1134 for floating-point trap; we return an overflow. */
1135 if (REAL_VALUE_ISNAN (d1
))
1137 else if (REAL_VALUE_ISNAN (d2
))
1140 inexact
= real_arithmetic (&value
, code
, &d1
, &d2
);
1141 real_convert (&result
, mode
, &value
);
1143 /* Don't constant fold this floating point operation if
1144 the result has overflowed and flag_trapping_math. */
1145 if (flag_trapping_math
1146 && MODE_HAS_INFINITIES (mode
)
1147 && REAL_VALUE_ISINF (result
)
1148 && !REAL_VALUE_ISINF (d1
)
1149 && !REAL_VALUE_ISINF (d2
))
1152 /* Don't constant fold this floating point operation if the
1153 result may dependent upon the run-time rounding mode and
1154 flag_rounding_math is set, or if GCC's software emulation
1155 is unable to accurately represent the result. */
1156 if ((flag_rounding_math
1157 || (MODE_COMPOSITE_P (mode
) && !flag_unsafe_math_optimizations
))
1158 && (inexact
|| !real_identical (&result
, &value
)))
1161 t
= build_real (type
, result
);
1163 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
);
1167 if (TREE_CODE (arg1
) == FIXED_CST
)
1169 FIXED_VALUE_TYPE f1
;
1170 FIXED_VALUE_TYPE f2
;
1171 FIXED_VALUE_TYPE result
;
1176 /* The following codes are handled by fixed_arithmetic. */
1182 case TRUNC_DIV_EXPR
:
1183 f2
= TREE_FIXED_CST (arg2
);
1188 f2
.data
.high
= TREE_INT_CST_HIGH (arg2
);
1189 f2
.data
.low
= TREE_INT_CST_LOW (arg2
);
1197 f1
= TREE_FIXED_CST (arg1
);
1198 type
= TREE_TYPE (arg1
);
1199 sat_p
= TYPE_SATURATING (type
);
1200 overflow_p
= fixed_arithmetic (&result
, code
, &f1
, &f2
, sat_p
);
1201 t
= build_fixed (type
, result
);
1202 /* Propagate overflow flags. */
1203 if (overflow_p
| TREE_OVERFLOW (arg1
) | TREE_OVERFLOW (arg2
))
1204 TREE_OVERFLOW (t
) = 1;
1208 if (TREE_CODE (arg1
) == COMPLEX_CST
)
1210 tree type
= TREE_TYPE (arg1
);
1211 tree r1
= TREE_REALPART (arg1
);
1212 tree i1
= TREE_IMAGPART (arg1
);
1213 tree r2
= TREE_REALPART (arg2
);
1214 tree i2
= TREE_IMAGPART (arg2
);
1221 real
= const_binop (code
, r1
, r2
);
1222 imag
= const_binop (code
, i1
, i2
);
1226 if (COMPLEX_FLOAT_TYPE_P (type
))
1227 return do_mpc_arg2 (arg1
, arg2
, type
,
1228 /* do_nonfinite= */ folding_initializer
,
1231 real
= const_binop (MINUS_EXPR
,
1232 const_binop (MULT_EXPR
, r1
, r2
),
1233 const_binop (MULT_EXPR
, i1
, i2
));
1234 imag
= const_binop (PLUS_EXPR
,
1235 const_binop (MULT_EXPR
, r1
, i2
),
1236 const_binop (MULT_EXPR
, i1
, r2
));
1240 if (COMPLEX_FLOAT_TYPE_P (type
))
1241 return do_mpc_arg2 (arg1
, arg2
, type
,
1242 /* do_nonfinite= */ folding_initializer
,
1245 case TRUNC_DIV_EXPR
:
1247 case FLOOR_DIV_EXPR
:
1248 case ROUND_DIV_EXPR
:
1249 if (flag_complex_method
== 0)
1251 /* Keep this algorithm in sync with
1252 tree-complex.c:expand_complex_div_straight().
1254 Expand complex division to scalars, straightforward algorithm.
1255 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1259 = const_binop (PLUS_EXPR
,
1260 const_binop (MULT_EXPR
, r2
, r2
),
1261 const_binop (MULT_EXPR
, i2
, i2
));
1263 = const_binop (PLUS_EXPR
,
1264 const_binop (MULT_EXPR
, r1
, r2
),
1265 const_binop (MULT_EXPR
, i1
, i2
));
1267 = const_binop (MINUS_EXPR
,
1268 const_binop (MULT_EXPR
, i1
, r2
),
1269 const_binop (MULT_EXPR
, r1
, i2
));
1271 real
= const_binop (code
, t1
, magsquared
);
1272 imag
= const_binop (code
, t2
, magsquared
);
1276 /* Keep this algorithm in sync with
1277 tree-complex.c:expand_complex_div_wide().
1279 Expand complex division to scalars, modified algorithm to minimize
1280 overflow with wide input ranges. */
1281 tree compare
= fold_build2 (LT_EXPR
, boolean_type_node
,
1282 fold_abs_const (r2
, TREE_TYPE (type
)),
1283 fold_abs_const (i2
, TREE_TYPE (type
)));
1285 if (integer_nonzerop (compare
))
1287 /* In the TRUE branch, we compute
1289 div = (br * ratio) + bi;
1290 tr = (ar * ratio) + ai;
1291 ti = (ai * ratio) - ar;
1294 tree ratio
= const_binop (code
, r2
, i2
);
1295 tree div
= const_binop (PLUS_EXPR
, i2
,
1296 const_binop (MULT_EXPR
, r2
, ratio
));
1297 real
= const_binop (MULT_EXPR
, r1
, ratio
);
1298 real
= const_binop (PLUS_EXPR
, real
, i1
);
1299 real
= const_binop (code
, real
, div
);
1301 imag
= const_binop (MULT_EXPR
, i1
, ratio
);
1302 imag
= const_binop (MINUS_EXPR
, imag
, r1
);
1303 imag
= const_binop (code
, imag
, div
);
1307 /* In the FALSE branch, we compute
1309 divisor = (d * ratio) + c;
1310 tr = (b * ratio) + a;
1311 ti = b - (a * ratio);
1314 tree ratio
= const_binop (code
, i2
, r2
);
1315 tree div
= const_binop (PLUS_EXPR
, r2
,
1316 const_binop (MULT_EXPR
, i2
, ratio
));
1318 real
= const_binop (MULT_EXPR
, i1
, ratio
);
1319 real
= const_binop (PLUS_EXPR
, real
, r1
);
1320 real
= const_binop (code
, real
, div
);
1322 imag
= const_binop (MULT_EXPR
, r1
, ratio
);
1323 imag
= const_binop (MINUS_EXPR
, i1
, imag
);
1324 imag
= const_binop (code
, imag
, div
);
1334 return build_complex (type
, real
, imag
);
1337 if (TREE_CODE (arg1
) == VECTOR_CST
1338 && TREE_CODE (arg2
) == VECTOR_CST
)
1340 tree type
= TREE_TYPE(arg1
);
1341 int count
= TYPE_VECTOR_SUBPARTS (type
), i
;
1342 tree
*elts
= XALLOCAVEC (tree
, count
);
1344 for (i
= 0; i
< count
; i
++)
1346 tree elem1
= VECTOR_CST_ELT (arg1
, i
);
1347 tree elem2
= VECTOR_CST_ELT (arg2
, i
);
1349 elts
[i
] = const_binop (code
, elem1
, elem2
);
1351 /* It is possible that const_binop cannot handle the given
1352 code and return NULL_TREE */
1353 if(elts
[i
] == NULL_TREE
)
1357 return build_vector (type
, elts
);
1362 /* Create a size type INT_CST node with NUMBER sign extended. KIND
1363 indicates which particular sizetype to create. */
1366 size_int_kind (HOST_WIDE_INT number
, enum size_type_kind kind
)
1368 return build_int_cst (sizetype_tab
[(int) kind
], number
);
1371 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1372 is a tree code. The type of the result is taken from the operands.
1373 Both must be equivalent integer types, ala int_binop_types_match_p.
1374 If the operands are constant, so is the result. */
1377 size_binop_loc (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
)
1379 tree type
= TREE_TYPE (arg0
);
1381 if (arg0
== error_mark_node
|| arg1
== error_mark_node
)
1382 return error_mark_node
;
1384 gcc_assert (int_binop_types_match_p (code
, TREE_TYPE (arg0
),
1387 /* Handle the special case of two integer constants faster. */
1388 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
1390 /* And some specific cases even faster than that. */
1391 if (code
== PLUS_EXPR
)
1393 if (integer_zerop (arg0
) && !TREE_OVERFLOW (arg0
))
1395 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1398 else if (code
== MINUS_EXPR
)
1400 if (integer_zerop (arg1
) && !TREE_OVERFLOW (arg1
))
1403 else if (code
== MULT_EXPR
)
1405 if (integer_onep (arg0
) && !TREE_OVERFLOW (arg0
))
1409 /* Handle general case of two integer constants. For sizetype
1410 constant calculations we always want to know about overflow,
1411 even in the unsigned case. */
1412 return int_const_binop_1 (code
, arg0
, arg1
, -1);
1415 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
1418 /* Given two values, either both of sizetype or both of bitsizetype,
1419 compute the difference between the two values. Return the value
1420 in signed type corresponding to the type of the operands. */
1423 size_diffop_loc (location_t loc
, tree arg0
, tree arg1
)
1425 tree type
= TREE_TYPE (arg0
);
1428 gcc_assert (int_binop_types_match_p (MINUS_EXPR
, TREE_TYPE (arg0
),
1431 /* If the type is already signed, just do the simple thing. */
1432 if (!TYPE_UNSIGNED (type
))
1433 return size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
);
1435 if (type
== sizetype
)
1437 else if (type
== bitsizetype
)
1438 ctype
= sbitsizetype
;
1440 ctype
= signed_type_for (type
);
1442 /* If either operand is not a constant, do the conversions to the signed
1443 type and subtract. The hardware will do the right thing with any
1444 overflow in the subtraction. */
1445 if (TREE_CODE (arg0
) != INTEGER_CST
|| TREE_CODE (arg1
) != INTEGER_CST
)
1446 return size_binop_loc (loc
, MINUS_EXPR
,
1447 fold_convert_loc (loc
, ctype
, arg0
),
1448 fold_convert_loc (loc
, ctype
, arg1
));
1450 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1451 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1452 overflow) and negate (which can't either). Special-case a result
1453 of zero while we're here. */
1454 if (tree_int_cst_equal (arg0
, arg1
))
1455 return build_int_cst (ctype
, 0);
1456 else if (tree_int_cst_lt (arg1
, arg0
))
1457 return fold_convert_loc (loc
, ctype
,
1458 size_binop_loc (loc
, MINUS_EXPR
, arg0
, arg1
));
1460 return size_binop_loc (loc
, MINUS_EXPR
, build_int_cst (ctype
, 0),
1461 fold_convert_loc (loc
, ctype
,
1462 size_binop_loc (loc
,
1467 /* A subroutine of fold_convert_const handling conversions of an
1468 INTEGER_CST to another integer type. */
1471 fold_convert_const_int_from_int (tree type
, const_tree arg1
)
1475 /* Given an integer constant, make new constant with new type,
1476 appropriately sign-extended or truncated. */
1477 t
= force_fit_type_double (type
, tree_to_double_int (arg1
),
1478 !POINTER_TYPE_P (TREE_TYPE (arg1
)),
1479 (TREE_INT_CST_HIGH (arg1
) < 0
1480 && (TYPE_UNSIGNED (type
)
1481 < TYPE_UNSIGNED (TREE_TYPE (arg1
))))
1482 | TREE_OVERFLOW (arg1
));
1487 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1488 to an integer type. */
1491 fold_convert_const_int_from_real (enum tree_code code
, tree type
, const_tree arg1
)
1496 /* The following code implements the floating point to integer
1497 conversion rules required by the Java Language Specification,
1498 that IEEE NaNs are mapped to zero and values that overflow
1499 the target precision saturate, i.e. values greater than
1500 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1501 are mapped to INT_MIN. These semantics are allowed by the
1502 C and C++ standards that simply state that the behavior of
1503 FP-to-integer conversion is unspecified upon overflow. */
1507 REAL_VALUE_TYPE x
= TREE_REAL_CST (arg1
);
1511 case FIX_TRUNC_EXPR
:
1512 real_trunc (&r
, VOIDmode
, &x
);
1519 /* If R is NaN, return zero and show we have an overflow. */
1520 if (REAL_VALUE_ISNAN (r
))
1523 val
= double_int_zero
;
1526 /* See if R is less than the lower bound or greater than the
1531 tree lt
= TYPE_MIN_VALUE (type
);
1532 REAL_VALUE_TYPE l
= real_value_from_int_cst (NULL_TREE
, lt
);
1533 if (REAL_VALUES_LESS (r
, l
))
1536 val
= tree_to_double_int (lt
);
1542 tree ut
= TYPE_MAX_VALUE (type
);
1545 REAL_VALUE_TYPE u
= real_value_from_int_cst (NULL_TREE
, ut
);
1546 if (REAL_VALUES_LESS (u
, r
))
1549 val
= tree_to_double_int (ut
);
1555 real_to_integer2 ((HOST_WIDE_INT
*) &val
.low
, &val
.high
, &r
);
1557 t
= force_fit_type_double (type
, val
, -1, overflow
| TREE_OVERFLOW (arg1
));
1561 /* A subroutine of fold_convert_const handling conversions of a
1562 FIXED_CST to an integer type. */
1565 fold_convert_const_int_from_fixed (tree type
, const_tree arg1
)
1568 double_int temp
, temp_trunc
;
1571 /* Right shift FIXED_CST to temp by fbit. */
1572 temp
= TREE_FIXED_CST (arg1
).data
;
1573 mode
= TREE_FIXED_CST (arg1
).mode
;
1574 if (GET_MODE_FBIT (mode
) < HOST_BITS_PER_DOUBLE_INT
)
1576 temp
= temp
.rshift (GET_MODE_FBIT (mode
),
1577 HOST_BITS_PER_DOUBLE_INT
,
1578 SIGNED_FIXED_POINT_MODE_P (mode
));
1580 /* Left shift temp to temp_trunc by fbit. */
1581 temp_trunc
= temp
.lshift (GET_MODE_FBIT (mode
),
1582 HOST_BITS_PER_DOUBLE_INT
,
1583 SIGNED_FIXED_POINT_MODE_P (mode
));
1587 temp
= double_int_zero
;
1588 temp_trunc
= double_int_zero
;
1591 /* If FIXED_CST is negative, we need to round the value toward 0.
1592 By checking if the fractional bits are not zero to add 1 to temp. */
1593 if (SIGNED_FIXED_POINT_MODE_P (mode
)
1594 && temp_trunc
.is_negative ()
1595 && TREE_FIXED_CST (arg1
).data
!= temp_trunc
)
1596 temp
+= double_int_one
;
1598 /* Given a fixed-point constant, make new constant with new type,
1599 appropriately sign-extended or truncated. */
1600 t
= force_fit_type_double (type
, temp
, -1,
1601 (temp
.is_negative ()
1602 && (TYPE_UNSIGNED (type
)
1603 < TYPE_UNSIGNED (TREE_TYPE (arg1
))))
1604 | TREE_OVERFLOW (arg1
));
1609 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1610 to another floating point type. */
1613 fold_convert_const_real_from_real (tree type
, const_tree arg1
)
1615 REAL_VALUE_TYPE value
;
1618 real_convert (&value
, TYPE_MODE (type
), &TREE_REAL_CST (arg1
));
1619 t
= build_real (type
, value
);
1621 /* If converting an infinity or NAN to a representation that doesn't
1622 have one, set the overflow bit so that we can produce some kind of
1623 error message at the appropriate point if necessary. It's not the
1624 most user-friendly message, but it's better than nothing. */
1625 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1
))
1626 && !MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1627 TREE_OVERFLOW (t
) = 1;
1628 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
1629 && !MODE_HAS_NANS (TYPE_MODE (type
)))
1630 TREE_OVERFLOW (t
) = 1;
1631 /* Regular overflow, conversion produced an infinity in a mode that
1632 can't represent them. */
1633 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type
))
1634 && REAL_VALUE_ISINF (value
)
1635 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1
)))
1636 TREE_OVERFLOW (t
) = 1;
1638 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
1642 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1643 to a floating point type. */
1646 fold_convert_const_real_from_fixed (tree type
, const_tree arg1
)
1648 REAL_VALUE_TYPE value
;
1651 real_convert_from_fixed (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
));
1652 t
= build_real (type
, value
);
1654 TREE_OVERFLOW (t
) = TREE_OVERFLOW (arg1
);
1658 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1659 to another fixed-point type. */
1662 fold_convert_const_fixed_from_fixed (tree type
, const_tree arg1
)
1664 FIXED_VALUE_TYPE value
;
1668 overflow_p
= fixed_convert (&value
, TYPE_MODE (type
), &TREE_FIXED_CST (arg1
),
1669 TYPE_SATURATING (type
));
1670 t
= build_fixed (type
, value
);
1672 /* Propagate overflow flags. */
1673 if (overflow_p
| TREE_OVERFLOW (arg1
))
1674 TREE_OVERFLOW (t
) = 1;
1678 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
1679 to a fixed-point type. */
1682 fold_convert_const_fixed_from_int (tree type
, const_tree arg1
)
1684 FIXED_VALUE_TYPE value
;
1688 overflow_p
= fixed_convert_from_int (&value
, TYPE_MODE (type
),
1689 TREE_INT_CST (arg1
),
1690 TYPE_UNSIGNED (TREE_TYPE (arg1
)),
1691 TYPE_SATURATING (type
));
1692 t
= build_fixed (type
, value
);
1694 /* Propagate overflow flags. */
1695 if (overflow_p
| TREE_OVERFLOW (arg1
))
1696 TREE_OVERFLOW (t
) = 1;
1700 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1701 to a fixed-point type. */
1704 fold_convert_const_fixed_from_real (tree type
, const_tree arg1
)
1706 FIXED_VALUE_TYPE value
;
1710 overflow_p
= fixed_convert_from_real (&value
, TYPE_MODE (type
),
1711 &TREE_REAL_CST (arg1
),
1712 TYPE_SATURATING (type
));
1713 t
= build_fixed (type
, value
);
1715 /* Propagate overflow flags. */
1716 if (overflow_p
| TREE_OVERFLOW (arg1
))
1717 TREE_OVERFLOW (t
) = 1;
1721 /* Attempt to fold type conversion operation CODE of expression ARG1 to
1722 type TYPE. If no simplification can be done return NULL_TREE. */
1725 fold_convert_const (enum tree_code code
, tree type
, tree arg1
)
1727 if (TREE_TYPE (arg1
) == type
)
1730 if (POINTER_TYPE_P (type
) || INTEGRAL_TYPE_P (type
)
1731 || TREE_CODE (type
) == OFFSET_TYPE
)
1733 if (TREE_CODE (arg1
) == INTEGER_CST
)
1734 return fold_convert_const_int_from_int (type
, arg1
);
1735 else if (TREE_CODE (arg1
) == REAL_CST
)
1736 return fold_convert_const_int_from_real (code
, type
, arg1
);
1737 else if (TREE_CODE (arg1
) == FIXED_CST
)
1738 return fold_convert_const_int_from_fixed (type
, arg1
);
1740 else if (TREE_CODE (type
) == REAL_TYPE
)
1742 if (TREE_CODE (arg1
) == INTEGER_CST
)
1743 return build_real_from_int_cst (type
, arg1
);
1744 else if (TREE_CODE (arg1
) == REAL_CST
)
1745 return fold_convert_const_real_from_real (type
, arg1
);
1746 else if (TREE_CODE (arg1
) == FIXED_CST
)
1747 return fold_convert_const_real_from_fixed (type
, arg1
);
1749 else if (TREE_CODE (type
) == FIXED_POINT_TYPE
)
1751 if (TREE_CODE (arg1
) == FIXED_CST
)
1752 return fold_convert_const_fixed_from_fixed (type
, arg1
);
1753 else if (TREE_CODE (arg1
) == INTEGER_CST
)
1754 return fold_convert_const_fixed_from_int (type
, arg1
);
1755 else if (TREE_CODE (arg1
) == REAL_CST
)
1756 return fold_convert_const_fixed_from_real (type
, arg1
);
1761 /* Construct a vector of zero elements of vector type TYPE. */
1764 build_zero_vector (tree type
)
1768 t
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), integer_zero_node
);
1769 return build_vector_from_val (type
, t
);
1772 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
1775 fold_convertible_p (const_tree type
, const_tree arg
)
1777 tree orig
= TREE_TYPE (arg
);
1782 if (TREE_CODE (arg
) == ERROR_MARK
1783 || TREE_CODE (type
) == ERROR_MARK
1784 || TREE_CODE (orig
) == ERROR_MARK
)
1787 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
1790 switch (TREE_CODE (type
))
1792 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1793 case POINTER_TYPE
: case REFERENCE_TYPE
:
1795 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
1796 || TREE_CODE (orig
) == OFFSET_TYPE
)
1798 return (TREE_CODE (orig
) == VECTOR_TYPE
1799 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
1802 case FIXED_POINT_TYPE
:
1806 return TREE_CODE (type
) == TREE_CODE (orig
);
1813 /* Convert expression ARG to type TYPE. Used by the middle-end for
1814 simple conversions in preference to calling the front-end's convert. */
1817 fold_convert_loc (location_t loc
, tree type
, tree arg
)
1819 tree orig
= TREE_TYPE (arg
);
1825 if (TREE_CODE (arg
) == ERROR_MARK
1826 || TREE_CODE (type
) == ERROR_MARK
1827 || TREE_CODE (orig
) == ERROR_MARK
)
1828 return error_mark_node
;
1830 switch (TREE_CODE (type
))
1833 case REFERENCE_TYPE
:
1834 /* Handle conversions between pointers to different address spaces. */
1835 if (POINTER_TYPE_P (orig
)
1836 && (TYPE_ADDR_SPACE (TREE_TYPE (type
))
1837 != TYPE_ADDR_SPACE (TREE_TYPE (orig
))))
1838 return fold_build1_loc (loc
, ADDR_SPACE_CONVERT_EXPR
, type
, arg
);
1841 case INTEGER_TYPE
: case ENUMERAL_TYPE
: case BOOLEAN_TYPE
:
1843 if (TREE_CODE (arg
) == INTEGER_CST
)
1845 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
1846 if (tem
!= NULL_TREE
)
1849 if (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
1850 || TREE_CODE (orig
) == OFFSET_TYPE
)
1851 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
1852 if (TREE_CODE (orig
) == COMPLEX_TYPE
)
1853 return fold_convert_loc (loc
, type
,
1854 fold_build1_loc (loc
, REALPART_EXPR
,
1855 TREE_TYPE (orig
), arg
));
1856 gcc_assert (TREE_CODE (orig
) == VECTOR_TYPE
1857 && tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
1858 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
1861 if (TREE_CODE (arg
) == INTEGER_CST
)
1863 tem
= fold_convert_const (FLOAT_EXPR
, type
, arg
);
1864 if (tem
!= NULL_TREE
)
1867 else if (TREE_CODE (arg
) == REAL_CST
)
1869 tem
= fold_convert_const (NOP_EXPR
, type
, arg
);
1870 if (tem
!= NULL_TREE
)
1873 else if (TREE_CODE (arg
) == FIXED_CST
)
1875 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
1876 if (tem
!= NULL_TREE
)
1880 switch (TREE_CODE (orig
))
1883 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
1884 case POINTER_TYPE
: case REFERENCE_TYPE
:
1885 return fold_build1_loc (loc
, FLOAT_EXPR
, type
, arg
);
1888 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
1890 case FIXED_POINT_TYPE
:
1891 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
1894 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
1895 return fold_convert_loc (loc
, type
, tem
);
1901 case FIXED_POINT_TYPE
:
1902 if (TREE_CODE (arg
) == FIXED_CST
|| TREE_CODE (arg
) == INTEGER_CST
1903 || TREE_CODE (arg
) == REAL_CST
)
1905 tem
= fold_convert_const (FIXED_CONVERT_EXPR
, type
, arg
);
1906 if (tem
!= NULL_TREE
)
1907 goto fold_convert_exit
;
1910 switch (TREE_CODE (orig
))
1912 case FIXED_POINT_TYPE
:
1917 return fold_build1_loc (loc
, FIXED_CONVERT_EXPR
, type
, arg
);
1920 tem
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
1921 return fold_convert_loc (loc
, type
, tem
);
1928 switch (TREE_CODE (orig
))
1931 case BOOLEAN_TYPE
: case ENUMERAL_TYPE
:
1932 case POINTER_TYPE
: case REFERENCE_TYPE
:
1934 case FIXED_POINT_TYPE
:
1935 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
1936 fold_convert_loc (loc
, TREE_TYPE (type
), arg
),
1937 fold_convert_loc (loc
, TREE_TYPE (type
),
1938 integer_zero_node
));
1943 if (TREE_CODE (arg
) == COMPLEX_EXPR
)
1945 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
),
1946 TREE_OPERAND (arg
, 0));
1947 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
),
1948 TREE_OPERAND (arg
, 1));
1949 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
1952 arg
= save_expr (arg
);
1953 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, TREE_TYPE (orig
), arg
);
1954 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, TREE_TYPE (orig
), arg
);
1955 rpart
= fold_convert_loc (loc
, TREE_TYPE (type
), rpart
);
1956 ipart
= fold_convert_loc (loc
, TREE_TYPE (type
), ipart
);
1957 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
, ipart
);
1965 if (integer_zerop (arg
))
1966 return build_zero_vector (type
);
1967 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type
), TYPE_SIZE (orig
)));
1968 gcc_assert (INTEGRAL_TYPE_P (orig
) || POINTER_TYPE_P (orig
)
1969 || TREE_CODE (orig
) == VECTOR_TYPE
);
1970 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
, type
, arg
);
1973 tem
= fold_ignored_result (arg
);
1974 return fold_build1_loc (loc
, NOP_EXPR
, type
, tem
);
1977 if (TYPE_MAIN_VARIANT (type
) == TYPE_MAIN_VARIANT (orig
))
1978 return fold_build1_loc (loc
, NOP_EXPR
, type
, arg
);
1982 protected_set_expr_location_unshare (tem
, loc
);
1986 /* Return false if expr can be assumed not to be an lvalue, true
1990 maybe_lvalue_p (const_tree x
)
1992 /* We only need to wrap lvalue tree codes. */
1993 switch (TREE_CODE (x
))
2006 case ARRAY_RANGE_REF
:
2012 case PREINCREMENT_EXPR
:
2013 case PREDECREMENT_EXPR
:
2015 case TRY_CATCH_EXPR
:
2016 case WITH_CLEANUP_EXPR
:
2025 /* Assume the worst for front-end tree codes. */
2026 if ((int)TREE_CODE (x
) >= NUM_TREE_CODES
)
2034 /* Return an expr equal to X but certainly not valid as an lvalue. */
2037 non_lvalue_loc (location_t loc
, tree x
)
2039 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2044 if (! maybe_lvalue_p (x
))
2046 return build1_loc (loc
, NON_LVALUE_EXPR
, TREE_TYPE (x
), x
);
2049 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2050 Zero means allow extended lvalues. */
2052 int pedantic_lvalues
;
2054 /* When pedantic, return an expr equal to X but certainly not valid as a
2055 pedantic lvalue. Otherwise, return X. */
2058 pedantic_non_lvalue_loc (location_t loc
, tree x
)
2060 if (pedantic_lvalues
)
2061 return non_lvalue_loc (loc
, x
);
2063 return protected_set_expr_location_unshare (x
, loc
);
2066 /* Given a tree comparison code, return the code that is the logical inverse.
2067 It is generally not safe to do this for floating-point comparisons, except
2068 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2069 ERROR_MARK in this case. */
2072 invert_tree_comparison (enum tree_code code
, bool honor_nans
)
2074 if (honor_nans
&& flag_trapping_math
&& code
!= EQ_EXPR
&& code
!= NE_EXPR
2075 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
)
2085 return honor_nans
? UNLE_EXPR
: LE_EXPR
;
2087 return honor_nans
? UNLT_EXPR
: LT_EXPR
;
2089 return honor_nans
? UNGE_EXPR
: GE_EXPR
;
2091 return honor_nans
? UNGT_EXPR
: GT_EXPR
;
2105 return UNORDERED_EXPR
;
2106 case UNORDERED_EXPR
:
2107 return ORDERED_EXPR
;
2113 /* Similar, but return the comparison that results if the operands are
2114 swapped. This is safe for floating-point. */
2117 swap_tree_comparison (enum tree_code code
)
2124 case UNORDERED_EXPR
:
2150 /* Convert a comparison tree code from an enum tree_code representation
2151 into a compcode bit-based encoding. This function is the inverse of
2152 compcode_to_comparison. */
2154 static enum comparison_code
2155 comparison_to_compcode (enum tree_code code
)
2172 return COMPCODE_ORD
;
2173 case UNORDERED_EXPR
:
2174 return COMPCODE_UNORD
;
2176 return COMPCODE_UNLT
;
2178 return COMPCODE_UNEQ
;
2180 return COMPCODE_UNLE
;
2182 return COMPCODE_UNGT
;
2184 return COMPCODE_LTGT
;
2186 return COMPCODE_UNGE
;
2192 /* Convert a compcode bit-based encoding of a comparison operator back
2193 to GCC's enum tree_code representation. This function is the
2194 inverse of comparison_to_compcode. */
2196 static enum tree_code
2197 compcode_to_comparison (enum comparison_code code
)
2214 return ORDERED_EXPR
;
2215 case COMPCODE_UNORD
:
2216 return UNORDERED_EXPR
;
2234 /* Return a tree for the comparison which is the combination of
2235 doing the AND or OR (depending on CODE) of the two operations LCODE
2236 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2237 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2238 if this makes the transformation invalid. */
2241 combine_comparisons (location_t loc
,
2242 enum tree_code code
, enum tree_code lcode
,
2243 enum tree_code rcode
, tree truth_type
,
2244 tree ll_arg
, tree lr_arg
)
2246 bool honor_nans
= HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg
)));
2247 enum comparison_code lcompcode
= comparison_to_compcode (lcode
);
2248 enum comparison_code rcompcode
= comparison_to_compcode (rcode
);
2253 case TRUTH_AND_EXPR
: case TRUTH_ANDIF_EXPR
:
2254 compcode
= lcompcode
& rcompcode
;
2257 case TRUTH_OR_EXPR
: case TRUTH_ORIF_EXPR
:
2258 compcode
= lcompcode
| rcompcode
;
2267 /* Eliminate unordered comparisons, as well as LTGT and ORD
2268 which are not used unless the mode has NaNs. */
2269 compcode
&= ~COMPCODE_UNORD
;
2270 if (compcode
== COMPCODE_LTGT
)
2271 compcode
= COMPCODE_NE
;
2272 else if (compcode
== COMPCODE_ORD
)
2273 compcode
= COMPCODE_TRUE
;
2275 else if (flag_trapping_math
)
2277 /* Check that the original operation and the optimized ones will trap
2278 under the same condition. */
2279 bool ltrap
= (lcompcode
& COMPCODE_UNORD
) == 0
2280 && (lcompcode
!= COMPCODE_EQ
)
2281 && (lcompcode
!= COMPCODE_ORD
);
2282 bool rtrap
= (rcompcode
& COMPCODE_UNORD
) == 0
2283 && (rcompcode
!= COMPCODE_EQ
)
2284 && (rcompcode
!= COMPCODE_ORD
);
2285 bool trap
= (compcode
& COMPCODE_UNORD
) == 0
2286 && (compcode
!= COMPCODE_EQ
)
2287 && (compcode
!= COMPCODE_ORD
);
2289 /* In a short-circuited boolean expression the LHS might be
2290 such that the RHS, if evaluated, will never trap. For
2291 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2292 if neither x nor y is NaN. (This is a mixed blessing: for
2293 example, the expression above will never trap, hence
2294 optimizing it to x < y would be invalid). */
2295 if ((code
== TRUTH_ORIF_EXPR
&& (lcompcode
& COMPCODE_UNORD
))
2296 || (code
== TRUTH_ANDIF_EXPR
&& !(lcompcode
& COMPCODE_UNORD
)))
2299 /* If the comparison was short-circuited, and only the RHS
2300 trapped, we may now generate a spurious trap. */
2302 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2305 /* If we changed the conditions that cause a trap, we lose. */
2306 if ((ltrap
|| rtrap
) != trap
)
2310 if (compcode
== COMPCODE_TRUE
)
2311 return constant_boolean_node (true, truth_type
);
2312 else if (compcode
== COMPCODE_FALSE
)
2313 return constant_boolean_node (false, truth_type
);
2316 enum tree_code tcode
;
2318 tcode
= compcode_to_comparison ((enum comparison_code
) compcode
);
2319 return fold_build2_loc (loc
, tcode
, truth_type
, ll_arg
, lr_arg
);
2323 /* Return nonzero if two operands (typically of the same tree node)
2324 are necessarily equal. If either argument has side-effects this
2325 function returns zero. FLAGS modifies behavior as follows:
2327 If OEP_ONLY_CONST is set, only return nonzero for constants.
2328 This function tests whether the operands are indistinguishable;
2329 it does not test whether they are equal using C's == operation.
2330 The distinction is important for IEEE floating point, because
2331 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2332 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2334 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2335 even though it may hold multiple values during a function.
2336 This is because a GCC tree node guarantees that nothing else is
2337 executed between the evaluation of its "operands" (which may often
2338 be evaluated in arbitrary order). Hence if the operands themselves
2339 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2340 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2341 unset means assuming isochronic (or instantaneous) tree equivalence.
2342 Unless comparing arbitrary expression trees, such as from different
2343 statements, this flag can usually be left unset.
2345 If OEP_PURE_SAME is set, then pure functions with identical arguments
2346 are considered the same. It is used when the caller has other ways
2347 to ensure that global memory is unchanged in between. */
2350 operand_equal_p (const_tree arg0
, const_tree arg1
, unsigned int flags
)
2352 /* If either is ERROR_MARK, they aren't equal. */
2353 if (TREE_CODE (arg0
) == ERROR_MARK
|| TREE_CODE (arg1
) == ERROR_MARK
2354 || TREE_TYPE (arg0
) == error_mark_node
2355 || TREE_TYPE (arg1
) == error_mark_node
)
2358 /* Similar, if either does not have a type (like a released SSA name),
2359 they aren't equal. */
2360 if (!TREE_TYPE (arg0
) || !TREE_TYPE (arg1
))
2363 /* Check equality of integer constants before bailing out due to
2364 precision differences. */
2365 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
2366 return tree_int_cst_equal (arg0
, arg1
);
2368 /* If both types don't have the same signedness, then we can't consider
2369 them equal. We must check this before the STRIP_NOPS calls
2370 because they may change the signedness of the arguments. As pointers
2371 strictly don't have a signedness, require either two pointers or
2372 two non-pointers as well. */
2373 if (TYPE_UNSIGNED (TREE_TYPE (arg0
)) != TYPE_UNSIGNED (TREE_TYPE (arg1
))
2374 || POINTER_TYPE_P (TREE_TYPE (arg0
)) != POINTER_TYPE_P (TREE_TYPE (arg1
)))
2377 /* We cannot consider pointers to different address space equal. */
2378 if (POINTER_TYPE_P (TREE_TYPE (arg0
)) && POINTER_TYPE_P (TREE_TYPE (arg1
))
2379 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0
)))
2380 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1
)))))
2383 /* If both types don't have the same precision, then it is not safe
2385 if (TYPE_PRECISION (TREE_TYPE (arg0
)) != TYPE_PRECISION (TREE_TYPE (arg1
)))
2391 /* In case both args are comparisons but with different comparison
2392 code, try to swap the comparison operands of one arg to produce
2393 a match and compare that variant. */
2394 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2395 && COMPARISON_CLASS_P (arg0
)
2396 && COMPARISON_CLASS_P (arg1
))
2398 enum tree_code swap_code
= swap_tree_comparison (TREE_CODE (arg1
));
2400 if (TREE_CODE (arg0
) == swap_code
)
2401 return operand_equal_p (TREE_OPERAND (arg0
, 0),
2402 TREE_OPERAND (arg1
, 1), flags
)
2403 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2404 TREE_OPERAND (arg1
, 0), flags
);
2407 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
2408 /* This is needed for conversions and for COMPONENT_REF.
2409 Might as well play it safe and always test this. */
2410 || TREE_CODE (TREE_TYPE (arg0
)) == ERROR_MARK
2411 || TREE_CODE (TREE_TYPE (arg1
)) == ERROR_MARK
2412 || TYPE_MODE (TREE_TYPE (arg0
)) != TYPE_MODE (TREE_TYPE (arg1
)))
2415 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2416 We don't care about side effects in that case because the SAVE_EXPR
2417 takes care of that for us. In all other cases, two expressions are
2418 equal if they have no side effects. If we have two identical
2419 expressions with side effects that should be treated the same due
2420 to the only side effects being identical SAVE_EXPR's, that will
2421 be detected in the recursive calls below.
2422 If we are taking an invariant address of two identical objects
2423 they are necessarily equal as well. */
2424 if (arg0
== arg1
&& ! (flags
& OEP_ONLY_CONST
)
2425 && (TREE_CODE (arg0
) == SAVE_EXPR
2426 || (flags
& OEP_CONSTANT_ADDRESS_OF
)
2427 || (! TREE_SIDE_EFFECTS (arg0
) && ! TREE_SIDE_EFFECTS (arg1
))))
2430 /* Next handle constant cases, those for which we can return 1 even
2431 if ONLY_CONST is set. */
2432 if (TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
))
2433 switch (TREE_CODE (arg0
))
2436 return tree_int_cst_equal (arg0
, arg1
);
2439 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0
),
2440 TREE_FIXED_CST (arg1
));
2443 if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0
),
2444 TREE_REAL_CST (arg1
)))
2448 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
))))
2450 /* If we do not distinguish between signed and unsigned zero,
2451 consider them equal. */
2452 if (real_zerop (arg0
) && real_zerop (arg1
))
2461 if (VECTOR_CST_NELTS (arg0
) != VECTOR_CST_NELTS (arg1
))
2464 for (i
= 0; i
< VECTOR_CST_NELTS (arg0
); ++i
)
2466 if (!operand_equal_p (VECTOR_CST_ELT (arg0
, i
),
2467 VECTOR_CST_ELT (arg1
, i
), flags
))
2474 return (operand_equal_p (TREE_REALPART (arg0
), TREE_REALPART (arg1
),
2476 && operand_equal_p (TREE_IMAGPART (arg0
), TREE_IMAGPART (arg1
),
2480 return (TREE_STRING_LENGTH (arg0
) == TREE_STRING_LENGTH (arg1
)
2481 && ! memcmp (TREE_STRING_POINTER (arg0
),
2482 TREE_STRING_POINTER (arg1
),
2483 TREE_STRING_LENGTH (arg0
)));
2486 return operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0),
2487 TREE_CONSTANT (arg0
) && TREE_CONSTANT (arg1
)
2488 ? OEP_CONSTANT_ADDRESS_OF
: 0);
2493 if (flags
& OEP_ONLY_CONST
)
2496 /* Define macros to test an operand from arg0 and arg1 for equality and a
2497 variant that allows null and views null as being different from any
2498 non-null value. In the latter case, if either is null, the both
2499 must be; otherwise, do the normal comparison. */
2500 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2501 TREE_OPERAND (arg1, N), flags)
2503 #define OP_SAME_WITH_NULL(N) \
2504 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2505 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2507 switch (TREE_CODE_CLASS (TREE_CODE (arg0
)))
2510 /* Two conversions are equal only if signedness and modes match. */
2511 switch (TREE_CODE (arg0
))
2514 case FIX_TRUNC_EXPR
:
2515 if (TYPE_UNSIGNED (TREE_TYPE (arg0
))
2516 != TYPE_UNSIGNED (TREE_TYPE (arg1
)))
2526 case tcc_comparison
:
2528 if (OP_SAME (0) && OP_SAME (1))
2531 /* For commutative ops, allow the other order. */
2532 return (commutative_tree_code (TREE_CODE (arg0
))
2533 && operand_equal_p (TREE_OPERAND (arg0
, 0),
2534 TREE_OPERAND (arg1
, 1), flags
)
2535 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2536 TREE_OPERAND (arg1
, 0), flags
));
2539 /* If either of the pointer (or reference) expressions we are
2540 dereferencing contain a side effect, these cannot be equal. */
2541 if (TREE_SIDE_EFFECTS (arg0
)
2542 || TREE_SIDE_EFFECTS (arg1
))
2545 switch (TREE_CODE (arg0
))
2552 case TARGET_MEM_REF
:
2553 /* Require equal extra operands and then fall through to MEM_REF
2554 handling of the two common operands. */
2555 if (!OP_SAME_WITH_NULL (2)
2556 || !OP_SAME_WITH_NULL (3)
2557 || !OP_SAME_WITH_NULL (4))
2561 /* Require equal access sizes, and similar pointer types.
2562 We can have incomplete types for array references of
2563 variable-sized arrays from the Fortran frontent
2565 return ((TYPE_SIZE (TREE_TYPE (arg0
)) == TYPE_SIZE (TREE_TYPE (arg1
))
2566 || (TYPE_SIZE (TREE_TYPE (arg0
))
2567 && TYPE_SIZE (TREE_TYPE (arg1
))
2568 && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0
)),
2569 TYPE_SIZE (TREE_TYPE (arg1
)), flags
)))
2570 && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg0
, 1)))
2571 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (arg1
, 1))))
2572 && OP_SAME (0) && OP_SAME (1));
2575 case ARRAY_RANGE_REF
:
2576 /* Operands 2 and 3 may be null.
2577 Compare the array index by value if it is constant first as we
2578 may have different types but same value here. */
2580 && (tree_int_cst_equal (TREE_OPERAND (arg0
, 1),
2581 TREE_OPERAND (arg1
, 1))
2583 && OP_SAME_WITH_NULL (2)
2584 && OP_SAME_WITH_NULL (3));
2587 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
2588 may be NULL when we're called to compare MEM_EXPRs. */
2589 return OP_SAME_WITH_NULL (0)
2591 && OP_SAME_WITH_NULL (2);
2594 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2600 case tcc_expression
:
2601 switch (TREE_CODE (arg0
))
2604 case TRUTH_NOT_EXPR
:
2607 case TRUTH_ANDIF_EXPR
:
2608 case TRUTH_ORIF_EXPR
:
2609 return OP_SAME (0) && OP_SAME (1);
2612 case WIDEN_MULT_PLUS_EXPR
:
2613 case WIDEN_MULT_MINUS_EXPR
:
2616 /* The multiplcation operands are commutative. */
2619 case TRUTH_AND_EXPR
:
2621 case TRUTH_XOR_EXPR
:
2622 if (OP_SAME (0) && OP_SAME (1))
2625 /* Otherwise take into account this is a commutative operation. */
2626 return (operand_equal_p (TREE_OPERAND (arg0
, 0),
2627 TREE_OPERAND (arg1
, 1), flags
)
2628 && operand_equal_p (TREE_OPERAND (arg0
, 1),
2629 TREE_OPERAND (arg1
, 0), flags
));
2634 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2641 switch (TREE_CODE (arg0
))
2644 /* If the CALL_EXPRs call different functions, then they
2645 clearly can not be equal. */
2646 if (! operand_equal_p (CALL_EXPR_FN (arg0
), CALL_EXPR_FN (arg1
),
2651 unsigned int cef
= call_expr_flags (arg0
);
2652 if (flags
& OEP_PURE_SAME
)
2653 cef
&= ECF_CONST
| ECF_PURE
;
2660 /* Now see if all the arguments are the same. */
2662 const_call_expr_arg_iterator iter0
, iter1
;
2664 for (a0
= first_const_call_expr_arg (arg0
, &iter0
),
2665 a1
= first_const_call_expr_arg (arg1
, &iter1
);
2667 a0
= next_const_call_expr_arg (&iter0
),
2668 a1
= next_const_call_expr_arg (&iter1
))
2669 if (! operand_equal_p (a0
, a1
, flags
))
2672 /* If we get here and both argument lists are exhausted
2673 then the CALL_EXPRs are equal. */
2674 return ! (a0
|| a1
);
2680 case tcc_declaration
:
2681 /* Consider __builtin_sqrt equal to sqrt. */
2682 return (TREE_CODE (arg0
) == FUNCTION_DECL
2683 && DECL_BUILT_IN (arg0
) && DECL_BUILT_IN (arg1
)
2684 && DECL_BUILT_IN_CLASS (arg0
) == DECL_BUILT_IN_CLASS (arg1
)
2685 && DECL_FUNCTION_CODE (arg0
) == DECL_FUNCTION_CODE (arg1
));
2692 #undef OP_SAME_WITH_NULL
2695 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2696 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2698 When in doubt, return 0. */
2701 operand_equal_for_comparison_p (tree arg0
, tree arg1
, tree other
)
2703 int unsignedp1
, unsignedpo
;
2704 tree primarg0
, primarg1
, primother
;
2705 unsigned int correct_width
;
2707 if (operand_equal_p (arg0
, arg1
, 0))
2710 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
2711 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1
)))
2714 /* Discard any conversions that don't change the modes of ARG0 and ARG1
2715 and see if the inner values are the same. This removes any
2716 signedness comparison, which doesn't matter here. */
2717 primarg0
= arg0
, primarg1
= arg1
;
2718 STRIP_NOPS (primarg0
);
2719 STRIP_NOPS (primarg1
);
2720 if (operand_equal_p (primarg0
, primarg1
, 0))
2723 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2724 actual comparison operand, ARG0.
2726 First throw away any conversions to wider types
2727 already present in the operands. */
2729 primarg1
= get_narrower (arg1
, &unsignedp1
);
2730 primother
= get_narrower (other
, &unsignedpo
);
2732 correct_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
2733 if (unsignedp1
== unsignedpo
2734 && TYPE_PRECISION (TREE_TYPE (primarg1
)) < correct_width
2735 && TYPE_PRECISION (TREE_TYPE (primother
)) < correct_width
)
2737 tree type
= TREE_TYPE (arg0
);
2739 /* Make sure shorter operand is extended the right way
2740 to match the longer operand. */
2741 primarg1
= fold_convert (signed_or_unsigned_type_for
2742 (unsignedp1
, TREE_TYPE (primarg1
)), primarg1
);
2744 if (operand_equal_p (arg0
, fold_convert (type
, primarg1
), 0))
2751 /* See if ARG is an expression that is either a comparison or is performing
2752 arithmetic on comparisons. The comparisons must only be comparing
2753 two different values, which will be stored in *CVAL1 and *CVAL2; if
2754 they are nonzero it means that some operands have already been found.
2755 No variables may be used anywhere else in the expression except in the
2756 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
2757 the expression and save_expr needs to be called with CVAL1 and CVAL2.
2759 If this is true, return 1. Otherwise, return zero. */
2762 twoval_comparison_p (tree arg
, tree
*cval1
, tree
*cval2
, int *save_p
)
2764 enum tree_code code
= TREE_CODE (arg
);
2765 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
2767 /* We can handle some of the tcc_expression cases here. */
2768 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
2770 else if (tclass
== tcc_expression
2771 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
2772 || code
== COMPOUND_EXPR
))
2773 tclass
= tcc_binary
;
2775 else if (tclass
== tcc_expression
&& code
== SAVE_EXPR
2776 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg
, 0)))
2778 /* If we've already found a CVAL1 or CVAL2, this expression is
2779 two complex to handle. */
2780 if (*cval1
|| *cval2
)
2790 return twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
);
2793 return (twoval_comparison_p (TREE_OPERAND (arg
, 0), cval1
, cval2
, save_p
)
2794 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
2795 cval1
, cval2
, save_p
));
2800 case tcc_expression
:
2801 if (code
== COND_EXPR
)
2802 return (twoval_comparison_p (TREE_OPERAND (arg
, 0),
2803 cval1
, cval2
, save_p
)
2804 && twoval_comparison_p (TREE_OPERAND (arg
, 1),
2805 cval1
, cval2
, save_p
)
2806 && twoval_comparison_p (TREE_OPERAND (arg
, 2),
2807 cval1
, cval2
, save_p
));
2810 case tcc_comparison
:
2811 /* First see if we can handle the first operand, then the second. For
2812 the second operand, we know *CVAL1 can't be zero. It must be that
2813 one side of the comparison is each of the values; test for the
2814 case where this isn't true by failing if the two operands
2817 if (operand_equal_p (TREE_OPERAND (arg
, 0),
2818 TREE_OPERAND (arg
, 1), 0))
2822 *cval1
= TREE_OPERAND (arg
, 0);
2823 else if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 0), 0))
2825 else if (*cval2
== 0)
2826 *cval2
= TREE_OPERAND (arg
, 0);
2827 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 0), 0))
2832 if (operand_equal_p (*cval1
, TREE_OPERAND (arg
, 1), 0))
2834 else if (*cval2
== 0)
2835 *cval2
= TREE_OPERAND (arg
, 1);
2836 else if (operand_equal_p (*cval2
, TREE_OPERAND (arg
, 1), 0))
2848 /* ARG is a tree that is known to contain just arithmetic operations and
2849 comparisons. Evaluate the operations in the tree substituting NEW0 for
2850 any occurrence of OLD0 as an operand of a comparison and likewise for
2854 eval_subst (location_t loc
, tree arg
, tree old0
, tree new0
,
2855 tree old1
, tree new1
)
2857 tree type
= TREE_TYPE (arg
);
2858 enum tree_code code
= TREE_CODE (arg
);
2859 enum tree_code_class tclass
= TREE_CODE_CLASS (code
);
2861 /* We can handle some of the tcc_expression cases here. */
2862 if (tclass
== tcc_expression
&& code
== TRUTH_NOT_EXPR
)
2864 else if (tclass
== tcc_expression
2865 && (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_ORIF_EXPR
))
2866 tclass
= tcc_binary
;
2871 return fold_build1_loc (loc
, code
, type
,
2872 eval_subst (loc
, TREE_OPERAND (arg
, 0),
2873 old0
, new0
, old1
, new1
));
2876 return fold_build2_loc (loc
, code
, type
,
2877 eval_subst (loc
, TREE_OPERAND (arg
, 0),
2878 old0
, new0
, old1
, new1
),
2879 eval_subst (loc
, TREE_OPERAND (arg
, 1),
2880 old0
, new0
, old1
, new1
));
2882 case tcc_expression
:
2886 return eval_subst (loc
, TREE_OPERAND (arg
, 0), old0
, new0
,
2890 return eval_subst (loc
, TREE_OPERAND (arg
, 1), old0
, new0
,
2894 return fold_build3_loc (loc
, code
, type
,
2895 eval_subst (loc
, TREE_OPERAND (arg
, 0),
2896 old0
, new0
, old1
, new1
),
2897 eval_subst (loc
, TREE_OPERAND (arg
, 1),
2898 old0
, new0
, old1
, new1
),
2899 eval_subst (loc
, TREE_OPERAND (arg
, 2),
2900 old0
, new0
, old1
, new1
));
2904 /* Fall through - ??? */
2906 case tcc_comparison
:
2908 tree arg0
= TREE_OPERAND (arg
, 0);
2909 tree arg1
= TREE_OPERAND (arg
, 1);
2911 /* We need to check both for exact equality and tree equality. The
2912 former will be true if the operand has a side-effect. In that
2913 case, we know the operand occurred exactly once. */
2915 if (arg0
== old0
|| operand_equal_p (arg0
, old0
, 0))
2917 else if (arg0
== old1
|| operand_equal_p (arg0
, old1
, 0))
2920 if (arg1
== old0
|| operand_equal_p (arg1
, old0
, 0))
2922 else if (arg1
== old1
|| operand_equal_p (arg1
, old1
, 0))
2925 return fold_build2_loc (loc
, code
, type
, arg0
, arg1
);
2933 /* Return a tree for the case when the result of an expression is RESULT
2934 converted to TYPE and OMITTED was previously an operand of the expression
2935 but is now not needed (e.g., we folded OMITTED * 0).
2937 If OMITTED has side effects, we must evaluate it. Otherwise, just do
2938 the conversion of RESULT to TYPE. */
2941 omit_one_operand_loc (location_t loc
, tree type
, tree result
, tree omitted
)
2943 tree t
= fold_convert_loc (loc
, type
, result
);
2945 /* If the resulting operand is an empty statement, just return the omitted
2946 statement casted to void. */
2947 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
2948 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
2949 fold_ignored_result (omitted
));
2951 if (TREE_SIDE_EFFECTS (omitted
))
2952 return build2_loc (loc
, COMPOUND_EXPR
, type
,
2953 fold_ignored_result (omitted
), t
);
2955 return non_lvalue_loc (loc
, t
);
2958 /* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
2961 pedantic_omit_one_operand_loc (location_t loc
, tree type
, tree result
,
2964 tree t
= fold_convert_loc (loc
, type
, result
);
2966 /* If the resulting operand is an empty statement, just return the omitted
2967 statement casted to void. */
2968 if (IS_EMPTY_STMT (t
) && TREE_SIDE_EFFECTS (omitted
))
2969 return build1_loc (loc
, NOP_EXPR
, void_type_node
,
2970 fold_ignored_result (omitted
));
2972 if (TREE_SIDE_EFFECTS (omitted
))
2973 return build2_loc (loc
, COMPOUND_EXPR
, type
,
2974 fold_ignored_result (omitted
), t
);
2976 return pedantic_non_lvalue_loc (loc
, t
);
2979 /* Return a tree for the case when the result of an expression is RESULT
2980 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
2981 of the expression but are now not needed.
2983 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
2984 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
2985 evaluated before OMITTED2. Otherwise, if neither has side effects,
2986 just do the conversion of RESULT to TYPE. */
2989 omit_two_operands_loc (location_t loc
, tree type
, tree result
,
2990 tree omitted1
, tree omitted2
)
2992 tree t
= fold_convert_loc (loc
, type
, result
);
2994 if (TREE_SIDE_EFFECTS (omitted2
))
2995 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted2
, t
);
2996 if (TREE_SIDE_EFFECTS (omitted1
))
2997 t
= build2_loc (loc
, COMPOUND_EXPR
, type
, omitted1
, t
);
2999 return TREE_CODE (t
) != COMPOUND_EXPR
? non_lvalue_loc (loc
, t
) : t
;
3003 /* Return a simplified tree node for the truth-negation of ARG. This
3004 never alters ARG itself. We assume that ARG is an operation that
3005 returns a truth value (0 or 1).
3007 FIXME: one would think we would fold the result, but it causes
3008 problems with the dominator optimizer. */
3011 fold_truth_not_expr (location_t loc
, tree arg
)
3013 tree type
= TREE_TYPE (arg
);
3014 enum tree_code code
= TREE_CODE (arg
);
3015 location_t loc1
, loc2
;
3017 /* If this is a comparison, we can simply invert it, except for
3018 floating-point non-equality comparisons, in which case we just
3019 enclose a TRUTH_NOT_EXPR around what we have. */
3021 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3023 tree op_type
= TREE_TYPE (TREE_OPERAND (arg
, 0));
3024 if (FLOAT_TYPE_P (op_type
)
3025 && flag_trapping_math
3026 && code
!= ORDERED_EXPR
&& code
!= UNORDERED_EXPR
3027 && code
!= NE_EXPR
&& code
!= EQ_EXPR
)
3030 code
= invert_tree_comparison (code
, HONOR_NANS (TYPE_MODE (op_type
)));
3031 if (code
== ERROR_MARK
)
3034 return build2_loc (loc
, code
, type
, TREE_OPERAND (arg
, 0),
3035 TREE_OPERAND (arg
, 1));
3041 return constant_boolean_node (integer_zerop (arg
), type
);
3043 case TRUTH_AND_EXPR
:
3044 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3045 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3046 return build2_loc (loc
, TRUTH_OR_EXPR
, type
,
3047 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3048 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3051 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3052 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3053 return build2_loc (loc
, TRUTH_AND_EXPR
, type
,
3054 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3055 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3057 case TRUTH_XOR_EXPR
:
3058 /* Here we can invert either operand. We invert the first operand
3059 unless the second operand is a TRUTH_NOT_EXPR in which case our
3060 result is the XOR of the first operand with the inside of the
3061 negation of the second operand. */
3063 if (TREE_CODE (TREE_OPERAND (arg
, 1)) == TRUTH_NOT_EXPR
)
3064 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
, TREE_OPERAND (arg
, 0),
3065 TREE_OPERAND (TREE_OPERAND (arg
, 1), 0));
3067 return build2_loc (loc
, TRUTH_XOR_EXPR
, type
,
3068 invert_truthvalue_loc (loc
, TREE_OPERAND (arg
, 0)),
3069 TREE_OPERAND (arg
, 1));
3071 case TRUTH_ANDIF_EXPR
:
3072 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3073 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3074 return build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
3075 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3076 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3078 case TRUTH_ORIF_EXPR
:
3079 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3080 loc2
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3081 return build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
3082 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)),
3083 invert_truthvalue_loc (loc2
, TREE_OPERAND (arg
, 1)));
3085 case TRUTH_NOT_EXPR
:
3086 return TREE_OPERAND (arg
, 0);
3090 tree arg1
= TREE_OPERAND (arg
, 1);
3091 tree arg2
= TREE_OPERAND (arg
, 2);
3093 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3094 loc2
= expr_location_or (TREE_OPERAND (arg
, 2), loc
);
3096 /* A COND_EXPR may have a throw as one operand, which
3097 then has void type. Just leave void operands
3099 return build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg
, 0),
3100 VOID_TYPE_P (TREE_TYPE (arg1
))
3101 ? arg1
: invert_truthvalue_loc (loc1
, arg1
),
3102 VOID_TYPE_P (TREE_TYPE (arg2
))
3103 ? arg2
: invert_truthvalue_loc (loc2
, arg2
));
3107 loc1
= expr_location_or (TREE_OPERAND (arg
, 1), loc
);
3108 return build2_loc (loc
, COMPOUND_EXPR
, type
,
3109 TREE_OPERAND (arg
, 0),
3110 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 1)));
3112 case NON_LVALUE_EXPR
:
3113 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3114 return invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0));
3117 if (TREE_CODE (TREE_TYPE (arg
)) == BOOLEAN_TYPE
)
3118 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3120 /* ... fall through ... */
3123 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3124 return build1_loc (loc
, TREE_CODE (arg
), type
,
3125 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3128 if (!integer_onep (TREE_OPERAND (arg
, 1)))
3130 return build2_loc (loc
, EQ_EXPR
, type
, arg
, build_int_cst (type
, 0));
3133 return build1_loc (loc
, TRUTH_NOT_EXPR
, type
, arg
);
3135 case CLEANUP_POINT_EXPR
:
3136 loc1
= expr_location_or (TREE_OPERAND (arg
, 0), loc
);
3137 return build1_loc (loc
, CLEANUP_POINT_EXPR
, type
,
3138 invert_truthvalue_loc (loc1
, TREE_OPERAND (arg
, 0)));
3145 /* Return a simplified tree node for the truth-negation of ARG. This
3146 never alters ARG itself. We assume that ARG is an operation that
3147 returns a truth value (0 or 1).
3149 FIXME: one would think we would fold the result, but it causes
3150 problems with the dominator optimizer. */
3153 invert_truthvalue_loc (location_t loc
, tree arg
)
3157 if (TREE_CODE (arg
) == ERROR_MARK
)
3160 tem
= fold_truth_not_expr (loc
, arg
);
3162 tem
= build1_loc (loc
, TRUTH_NOT_EXPR
, TREE_TYPE (arg
), arg
);
3167 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3168 operands are another bit-wise operation with a common input. If so,
3169 distribute the bit operations to save an operation and possibly two if
3170 constants are involved. For example, convert
3171 (A | B) & (A | C) into A | (B & C)
3172 Further simplification will occur if B and C are constants.
3174 If this optimization cannot be done, 0 will be returned. */
3177 distribute_bit_expr (location_t loc
, enum tree_code code
, tree type
,
3178 tree arg0
, tree arg1
)
3183 if (TREE_CODE (arg0
) != TREE_CODE (arg1
)
3184 || TREE_CODE (arg0
) == code
3185 || (TREE_CODE (arg0
) != BIT_AND_EXPR
3186 && TREE_CODE (arg0
) != BIT_IOR_EXPR
))
3189 if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 0), 0))
3191 common
= TREE_OPERAND (arg0
, 0);
3192 left
= TREE_OPERAND (arg0
, 1);
3193 right
= TREE_OPERAND (arg1
, 1);
3195 else if (operand_equal_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg1
, 1), 0))
3197 common
= TREE_OPERAND (arg0
, 0);
3198 left
= TREE_OPERAND (arg0
, 1);
3199 right
= TREE_OPERAND (arg1
, 0);
3201 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 0), 0))
3203 common
= TREE_OPERAND (arg0
, 1);
3204 left
= TREE_OPERAND (arg0
, 0);
3205 right
= TREE_OPERAND (arg1
, 1);
3207 else if (operand_equal_p (TREE_OPERAND (arg0
, 1), TREE_OPERAND (arg1
, 1), 0))
3209 common
= TREE_OPERAND (arg0
, 1);
3210 left
= TREE_OPERAND (arg0
, 0);
3211 right
= TREE_OPERAND (arg1
, 0);
3216 common
= fold_convert_loc (loc
, type
, common
);
3217 left
= fold_convert_loc (loc
, type
, left
);
3218 right
= fold_convert_loc (loc
, type
, right
);
3219 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, common
,
3220 fold_build2_loc (loc
, code
, type
, left
, right
));
3223 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3224 with code CODE. This optimization is unsafe. */
3226 distribute_real_division (location_t loc
, enum tree_code code
, tree type
,
3227 tree arg0
, tree arg1
)
3229 bool mul0
= TREE_CODE (arg0
) == MULT_EXPR
;
3230 bool mul1
= TREE_CODE (arg1
) == MULT_EXPR
;
3232 /* (A / C) +- (B / C) -> (A +- B) / C. */
3234 && operand_equal_p (TREE_OPERAND (arg0
, 1),
3235 TREE_OPERAND (arg1
, 1), 0))
3236 return fold_build2_loc (loc
, mul0
? MULT_EXPR
: RDIV_EXPR
, type
,
3237 fold_build2_loc (loc
, code
, type
,
3238 TREE_OPERAND (arg0
, 0),
3239 TREE_OPERAND (arg1
, 0)),
3240 TREE_OPERAND (arg0
, 1));
3242 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3243 if (operand_equal_p (TREE_OPERAND (arg0
, 0),
3244 TREE_OPERAND (arg1
, 0), 0)
3245 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
3246 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
3248 REAL_VALUE_TYPE r0
, r1
;
3249 r0
= TREE_REAL_CST (TREE_OPERAND (arg0
, 1));
3250 r1
= TREE_REAL_CST (TREE_OPERAND (arg1
, 1));
3252 real_arithmetic (&r0
, RDIV_EXPR
, &dconst1
, &r0
);
3254 real_arithmetic (&r1
, RDIV_EXPR
, &dconst1
, &r1
);
3255 real_arithmetic (&r0
, code
, &r0
, &r1
);
3256 return fold_build2_loc (loc
, MULT_EXPR
, type
,
3257 TREE_OPERAND (arg0
, 0),
3258 build_real (type
, r0
));
3264 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3265 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
3268 make_bit_field_ref (location_t loc
, tree inner
, tree type
,
3269 HOST_WIDE_INT bitsize
, HOST_WIDE_INT bitpos
, int unsignedp
)
3271 tree result
, bftype
;
3275 tree size
= TYPE_SIZE (TREE_TYPE (inner
));
3276 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner
))
3277 || POINTER_TYPE_P (TREE_TYPE (inner
)))
3278 && host_integerp (size
, 0)
3279 && tree_low_cst (size
, 0) == bitsize
)
3280 return fold_convert_loc (loc
, type
, inner
);
3284 if (TYPE_PRECISION (bftype
) != bitsize
3285 || TYPE_UNSIGNED (bftype
) == !unsignedp
)
3286 bftype
= build_nonstandard_integer_type (bitsize
, 0);
3288 result
= build3_loc (loc
, BIT_FIELD_REF
, bftype
, inner
,
3289 size_int (bitsize
), bitsize_int (bitpos
));
3292 result
= fold_convert_loc (loc
, type
, result
);
3297 /* Optimize a bit-field compare.
3299 There are two cases: First is a compare against a constant and the
3300 second is a comparison of two items where the fields are at the same
3301 bit position relative to the start of a chunk (byte, halfword, word)
3302 large enough to contain it. In these cases we can avoid the shift
3303 implicit in bitfield extractions.
3305 For constants, we emit a compare of the shifted constant with the
3306 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3307 compared. For two fields at the same position, we do the ANDs with the
3308 similar mask and compare the result of the ANDs.
3310 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3311 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3312 are the left and right operands of the comparison, respectively.
3314 If the optimization described above can be done, we return the resulting
3315 tree. Otherwise we return zero. */
3318 optimize_bit_field_compare (location_t loc
, enum tree_code code
,
3319 tree compare_type
, tree lhs
, tree rhs
)
3321 HOST_WIDE_INT lbitpos
, lbitsize
, rbitpos
, rbitsize
, nbitpos
, nbitsize
;
3322 tree type
= TREE_TYPE (lhs
);
3323 tree signed_type
, unsigned_type
;
3324 int const_p
= TREE_CODE (rhs
) == INTEGER_CST
;
3325 enum machine_mode lmode
, rmode
, nmode
;
3326 int lunsignedp
, runsignedp
;
3327 int lvolatilep
= 0, rvolatilep
= 0;
3328 tree linner
, rinner
= NULL_TREE
;
3332 /* In the strict volatile bitfields case, doing code changes here may prevent
3333 other optimizations, in particular in a SLOW_BYTE_ACCESS setting. */
3334 if (flag_strict_volatile_bitfields
> 0)
3337 /* Get all the information about the extractions being done. If the bit size
3338 if the same as the size of the underlying object, we aren't doing an
3339 extraction at all and so can do nothing. We also don't want to
3340 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3341 then will no longer be able to replace it. */
3342 linner
= get_inner_reference (lhs
, &lbitsize
, &lbitpos
, &offset
, &lmode
,
3343 &lunsignedp
, &lvolatilep
, false);
3344 if (linner
== lhs
|| lbitsize
== GET_MODE_BITSIZE (lmode
) || lbitsize
< 0
3345 || offset
!= 0 || TREE_CODE (linner
) == PLACEHOLDER_EXPR
)
3350 /* If this is not a constant, we can only do something if bit positions,
3351 sizes, and signedness are the same. */
3352 rinner
= get_inner_reference (rhs
, &rbitsize
, &rbitpos
, &offset
, &rmode
,
3353 &runsignedp
, &rvolatilep
, false);
3355 if (rinner
== rhs
|| lbitpos
!= rbitpos
|| lbitsize
!= rbitsize
3356 || lunsignedp
!= runsignedp
|| offset
!= 0
3357 || TREE_CODE (rinner
) == PLACEHOLDER_EXPR
)
3361 /* See if we can find a mode to refer to this field. We should be able to,
3362 but fail if we can't. */
3364 && GET_MODE_BITSIZE (lmode
) > 0
3365 && flag_strict_volatile_bitfields
> 0)
3368 nmode
= get_best_mode (lbitsize
, lbitpos
, 0, 0,
3369 const_p
? TYPE_ALIGN (TREE_TYPE (linner
))
3370 : MIN (TYPE_ALIGN (TREE_TYPE (linner
)),
3371 TYPE_ALIGN (TREE_TYPE (rinner
))),
3372 word_mode
, lvolatilep
|| rvolatilep
);
3373 if (nmode
== VOIDmode
)
3376 /* Set signed and unsigned types of the precision of this mode for the
3378 signed_type
= lang_hooks
.types
.type_for_mode (nmode
, 0);
3379 unsigned_type
= lang_hooks
.types
.type_for_mode (nmode
, 1);
3381 /* Compute the bit position and size for the new reference and our offset
3382 within it. If the new reference is the same size as the original, we
3383 won't optimize anything, so return zero. */
3384 nbitsize
= GET_MODE_BITSIZE (nmode
);
3385 nbitpos
= lbitpos
& ~ (nbitsize
- 1);
3387 if (nbitsize
== lbitsize
)
3390 if (BYTES_BIG_ENDIAN
)
3391 lbitpos
= nbitsize
- lbitsize
- lbitpos
;
3393 /* Make the mask to be used against the extracted field. */
3394 mask
= build_int_cst_type (unsigned_type
, -1);
3395 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (nbitsize
- lbitsize
));
3396 mask
= const_binop (RSHIFT_EXPR
, mask
,
3397 size_int (nbitsize
- lbitsize
- lbitpos
));
3400 /* If not comparing with constant, just rework the comparison
3402 return fold_build2_loc (loc
, code
, compare_type
,
3403 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3404 make_bit_field_ref (loc
, linner
,
3409 fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3410 make_bit_field_ref (loc
, rinner
,
3416 /* Otherwise, we are handling the constant case. See if the constant is too
3417 big for the field. Warn and return a tree of for 0 (false) if so. We do
3418 this not only for its own sake, but to avoid having to test for this
3419 error case below. If we didn't, we might generate wrong code.
3421 For unsigned fields, the constant shifted right by the field length should
3422 be all zero. For signed fields, the high-order bits should agree with
3427 if (! integer_zerop (const_binop (RSHIFT_EXPR
,
3428 fold_convert_loc (loc
,
3429 unsigned_type
, rhs
),
3430 size_int (lbitsize
))))
3432 warning (0, "comparison is always %d due to width of bit-field",
3434 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3439 tree tem
= const_binop (RSHIFT_EXPR
,
3440 fold_convert_loc (loc
, signed_type
, rhs
),
3441 size_int (lbitsize
- 1));
3442 if (! integer_zerop (tem
) && ! integer_all_onesp (tem
))
3444 warning (0, "comparison is always %d due to width of bit-field",
3446 return constant_boolean_node (code
== NE_EXPR
, compare_type
);
3450 /* Single-bit compares should always be against zero. */
3451 if (lbitsize
== 1 && ! integer_zerop (rhs
))
3453 code
= code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
;
3454 rhs
= build_int_cst (type
, 0);
3457 /* Make a new bitfield reference, shift the constant over the
3458 appropriate number of bits and mask it with the computed mask
3459 (in case this was a signed field). If we changed it, make a new one. */
3460 lhs
= make_bit_field_ref (loc
, linner
, unsigned_type
, nbitsize
, nbitpos
, 1);
3463 TREE_SIDE_EFFECTS (lhs
) = 1;
3464 TREE_THIS_VOLATILE (lhs
) = 1;
3467 rhs
= const_binop (BIT_AND_EXPR
,
3468 const_binop (LSHIFT_EXPR
,
3469 fold_convert_loc (loc
, unsigned_type
, rhs
),
3470 size_int (lbitpos
)),
3473 lhs
= build2_loc (loc
, code
, compare_type
,
3474 build2 (BIT_AND_EXPR
, unsigned_type
, lhs
, mask
), rhs
);
3478 /* Subroutine for fold_truth_andor_1: decode a field reference.
3480 If EXP is a comparison reference, we return the innermost reference.
3482 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3483 set to the starting bit number.
3485 If the innermost field can be completely contained in a mode-sized
3486 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
3488 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3489 otherwise it is not changed.
3491 *PUNSIGNEDP is set to the signedness of the field.
3493 *PMASK is set to the mask used. This is either contained in a
3494 BIT_AND_EXPR or derived from the width of the field.
3496 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3498 Return 0 if this is not a component reference or is one that we can't
3499 do anything with. */
3502 decode_field_reference (location_t loc
, tree exp
, HOST_WIDE_INT
*pbitsize
,
3503 HOST_WIDE_INT
*pbitpos
, enum machine_mode
*pmode
,
3504 int *punsignedp
, int *pvolatilep
,
3505 tree
*pmask
, tree
*pand_mask
)
3507 tree outer_type
= 0;
3509 tree mask
, inner
, offset
;
3511 unsigned int precision
;
3513 /* All the optimizations using this function assume integer fields.
3514 There are problems with FP fields since the type_for_size call
3515 below can fail for, e.g., XFmode. */
3516 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp
)))
3519 /* We are interested in the bare arrangement of bits, so strip everything
3520 that doesn't affect the machine mode. However, record the type of the
3521 outermost expression if it may matter below. */
3522 if (CONVERT_EXPR_P (exp
)
3523 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
3524 outer_type
= TREE_TYPE (exp
);
3527 if (TREE_CODE (exp
) == BIT_AND_EXPR
)
3529 and_mask
= TREE_OPERAND (exp
, 1);
3530 exp
= TREE_OPERAND (exp
, 0);
3531 STRIP_NOPS (exp
); STRIP_NOPS (and_mask
);
3532 if (TREE_CODE (and_mask
) != INTEGER_CST
)
3536 inner
= get_inner_reference (exp
, pbitsize
, pbitpos
, &offset
, pmode
,
3537 punsignedp
, pvolatilep
, false);
3538 if ((inner
== exp
&& and_mask
== 0)
3539 || *pbitsize
< 0 || offset
!= 0
3540 || TREE_CODE (inner
) == PLACEHOLDER_EXPR
)
3543 /* If the number of bits in the reference is the same as the bitsize of
3544 the outer type, then the outer type gives the signedness. Otherwise
3545 (in case of a small bitfield) the signedness is unchanged. */
3546 if (outer_type
&& *pbitsize
== TYPE_PRECISION (outer_type
))
3547 *punsignedp
= TYPE_UNSIGNED (outer_type
);
3549 /* Compute the mask to access the bitfield. */
3550 unsigned_type
= lang_hooks
.types
.type_for_size (*pbitsize
, 1);
3551 precision
= TYPE_PRECISION (unsigned_type
);
3553 mask
= build_int_cst_type (unsigned_type
, -1);
3555 mask
= const_binop (LSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
3556 mask
= const_binop (RSHIFT_EXPR
, mask
, size_int (precision
- *pbitsize
));
3558 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
3560 mask
= fold_build2_loc (loc
, BIT_AND_EXPR
, unsigned_type
,
3561 fold_convert_loc (loc
, unsigned_type
, and_mask
), mask
);
3564 *pand_mask
= and_mask
;
3568 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3572 all_ones_mask_p (const_tree mask
, int size
)
3574 tree type
= TREE_TYPE (mask
);
3575 unsigned int precision
= TYPE_PRECISION (type
);
3578 tmask
= build_int_cst_type (signed_type_for (type
), -1);
3581 tree_int_cst_equal (mask
,
3582 const_binop (RSHIFT_EXPR
,
3583 const_binop (LSHIFT_EXPR
, tmask
,
3584 size_int (precision
- size
)),
3585 size_int (precision
- size
)));
3588 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3589 represents the sign bit of EXP's type. If EXP represents a sign
3590 or zero extension, also test VAL against the unextended type.
3591 The return value is the (sub)expression whose sign bit is VAL,
3592 or NULL_TREE otherwise. */
3595 sign_bit_p (tree exp
, const_tree val
)
3597 unsigned HOST_WIDE_INT mask_lo
, lo
;
3598 HOST_WIDE_INT mask_hi
, hi
;
3602 /* Tree EXP must have an integral type. */
3603 t
= TREE_TYPE (exp
);
3604 if (! INTEGRAL_TYPE_P (t
))
3607 /* Tree VAL must be an integer constant. */
3608 if (TREE_CODE (val
) != INTEGER_CST
3609 || TREE_OVERFLOW (val
))
3612 width
= TYPE_PRECISION (t
);
3613 if (width
> HOST_BITS_PER_WIDE_INT
)
3615 hi
= (unsigned HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
- 1);
3618 mask_hi
= ((unsigned HOST_WIDE_INT
) -1
3619 >> (HOST_BITS_PER_DOUBLE_INT
- width
));
3625 lo
= (unsigned HOST_WIDE_INT
) 1 << (width
- 1);
3628 mask_lo
= ((unsigned HOST_WIDE_INT
) -1
3629 >> (HOST_BITS_PER_WIDE_INT
- width
));
3632 /* We mask off those bits beyond TREE_TYPE (exp) so that we can
3633 treat VAL as if it were unsigned. */
3634 if ((TREE_INT_CST_HIGH (val
) & mask_hi
) == hi
3635 && (TREE_INT_CST_LOW (val
) & mask_lo
) == lo
)
3638 /* Handle extension from a narrower type. */
3639 if (TREE_CODE (exp
) == NOP_EXPR
3640 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp
, 0))) < width
)
3641 return sign_bit_p (TREE_OPERAND (exp
, 0), val
);
3646 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
3647 to be evaluated unconditionally. */
3650 simple_operand_p (const_tree exp
)
3652 /* Strip any conversions that don't change the machine mode. */
3655 return (CONSTANT_CLASS_P (exp
)
3656 || TREE_CODE (exp
) == SSA_NAME
3658 && ! TREE_ADDRESSABLE (exp
)
3659 && ! TREE_THIS_VOLATILE (exp
)
3660 && ! DECL_NONLOCAL (exp
)
3661 /* Don't regard global variables as simple. They may be
3662 allocated in ways unknown to the compiler (shared memory,
3663 #pragma weak, etc). */
3664 && ! TREE_PUBLIC (exp
)
3665 && ! DECL_EXTERNAL (exp
)
3666 /* Loading a static variable is unduly expensive, but global
3667 registers aren't expensive. */
3668 && (! TREE_STATIC (exp
) || DECL_REGISTER (exp
))));
3671 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
3672 to be evaluated unconditionally.
3673 I addition to simple_operand_p, we assume that comparisons, conversions,
3674 and logic-not operations are simple, if their operands are simple, too. */
3677 simple_operand_p_2 (tree exp
)
3679 enum tree_code code
;
3681 if (TREE_SIDE_EFFECTS (exp
)
3682 || tree_could_trap_p (exp
))
3685 while (CONVERT_EXPR_P (exp
))
3686 exp
= TREE_OPERAND (exp
, 0);
3688 code
= TREE_CODE (exp
);
3690 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
3691 return (simple_operand_p (TREE_OPERAND (exp
, 0))
3692 && simple_operand_p (TREE_OPERAND (exp
, 1)));
3694 if (code
== TRUTH_NOT_EXPR
)
3695 return simple_operand_p_2 (TREE_OPERAND (exp
, 0));
3697 return simple_operand_p (exp
);
3701 /* The following functions are subroutines to fold_range_test and allow it to
3702 try to change a logical combination of comparisons into a range test.
3705 X == 2 || X == 3 || X == 4 || X == 5
3709 (unsigned) (X - 2) <= 3
3711 We describe each set of comparisons as being either inside or outside
3712 a range, using a variable named like IN_P, and then describe the
3713 range with a lower and upper bound. If one of the bounds is omitted,
3714 it represents either the highest or lowest value of the type.
3716 In the comments below, we represent a range by two numbers in brackets
3717 preceded by a "+" to designate being inside that range, or a "-" to
3718 designate being outside that range, so the condition can be inverted by
3719 flipping the prefix. An omitted bound is represented by a "-". For
3720 example, "- [-, 10]" means being outside the range starting at the lowest
3721 possible value and ending at 10, in other words, being greater than 10.
3722 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3725 We set up things so that the missing bounds are handled in a consistent
3726 manner so neither a missing bound nor "true" and "false" need to be
3727 handled using a special case. */
3729 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3730 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3731 and UPPER1_P are nonzero if the respective argument is an upper bound
3732 and zero for a lower. TYPE, if nonzero, is the type of the result; it
3733 must be specified for a comparison. ARG1 will be converted to ARG0's
3734 type if both are specified. */
3737 range_binop (enum tree_code code
, tree type
, tree arg0
, int upper0_p
,
3738 tree arg1
, int upper1_p
)
3744 /* If neither arg represents infinity, do the normal operation.
3745 Else, if not a comparison, return infinity. Else handle the special
3746 comparison rules. Note that most of the cases below won't occur, but
3747 are handled for consistency. */
3749 if (arg0
!= 0 && arg1
!= 0)
3751 tem
= fold_build2 (code
, type
!= 0 ? type
: TREE_TYPE (arg0
),
3752 arg0
, fold_convert (TREE_TYPE (arg0
), arg1
));
3754 return TREE_CODE (tem
) == INTEGER_CST
? tem
: 0;
3757 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
3760 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3761 for neither. In real maths, we cannot assume open ended ranges are
3762 the same. But, this is computer arithmetic, where numbers are finite.
3763 We can therefore make the transformation of any unbounded range with
3764 the value Z, Z being greater than any representable number. This permits
3765 us to treat unbounded ranges as equal. */
3766 sgn0
= arg0
!= 0 ? 0 : (upper0_p
? 1 : -1);
3767 sgn1
= arg1
!= 0 ? 0 : (upper1_p
? 1 : -1);
3771 result
= sgn0
== sgn1
;
3774 result
= sgn0
!= sgn1
;
3777 result
= sgn0
< sgn1
;
3780 result
= sgn0
<= sgn1
;
3783 result
= sgn0
> sgn1
;
3786 result
= sgn0
>= sgn1
;
3792 return constant_boolean_node (result
, type
);
3795 /* Helper routine for make_range. Perform one step for it, return
3796 new expression if the loop should continue or NULL_TREE if it should
3800 make_range_step (location_t loc
, enum tree_code code
, tree arg0
, tree arg1
,
3801 tree exp_type
, tree
*p_low
, tree
*p_high
, int *p_in_p
,
3802 bool *strict_overflow_p
)
3804 tree arg0_type
= TREE_TYPE (arg0
);
3805 tree n_low
, n_high
, low
= *p_low
, high
= *p_high
;
3806 int in_p
= *p_in_p
, n_in_p
;
3810 case TRUTH_NOT_EXPR
:
3814 case EQ_EXPR
: case NE_EXPR
:
3815 case LT_EXPR
: case LE_EXPR
: case GE_EXPR
: case GT_EXPR
:
3816 /* We can only do something if the range is testing for zero
3817 and if the second operand is an integer constant. Note that
3818 saying something is "in" the range we make is done by
3819 complementing IN_P since it will set in the initial case of
3820 being not equal to zero; "out" is leaving it alone. */
3821 if (low
== NULL_TREE
|| high
== NULL_TREE
3822 || ! integer_zerop (low
) || ! integer_zerop (high
)
3823 || TREE_CODE (arg1
) != INTEGER_CST
)
3828 case NE_EXPR
: /* - [c, c] */
3831 case EQ_EXPR
: /* + [c, c] */
3832 in_p
= ! in_p
, low
= high
= arg1
;
3834 case GT_EXPR
: /* - [-, c] */
3835 low
= 0, high
= arg1
;
3837 case GE_EXPR
: /* + [c, -] */
3838 in_p
= ! in_p
, low
= arg1
, high
= 0;
3840 case LT_EXPR
: /* - [c, -] */
3841 low
= arg1
, high
= 0;
3843 case LE_EXPR
: /* + [-, c] */
3844 in_p
= ! in_p
, low
= 0, high
= arg1
;
3850 /* If this is an unsigned comparison, we also know that EXP is
3851 greater than or equal to zero. We base the range tests we make
3852 on that fact, so we record it here so we can parse existing
3853 range tests. We test arg0_type since often the return type
3854 of, e.g. EQ_EXPR, is boolean. */
3855 if (TYPE_UNSIGNED (arg0_type
) && (low
== 0 || high
== 0))
3857 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
,
3859 build_int_cst (arg0_type
, 0),
3863 in_p
= n_in_p
, low
= n_low
, high
= n_high
;
3865 /* If the high bound is missing, but we have a nonzero low
3866 bound, reverse the range so it goes from zero to the low bound
3868 if (high
== 0 && low
&& ! integer_zerop (low
))
3871 high
= range_binop (MINUS_EXPR
, NULL_TREE
, low
, 0,
3872 integer_one_node
, 0);
3873 low
= build_int_cst (arg0_type
, 0);
3883 /* If flag_wrapv and ARG0_TYPE is signed, make sure
3884 low and high are non-NULL, then normalize will DTRT. */
3885 if (!TYPE_UNSIGNED (arg0_type
)
3886 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
3888 if (low
== NULL_TREE
)
3889 low
= TYPE_MIN_VALUE (arg0_type
);
3890 if (high
== NULL_TREE
)
3891 high
= TYPE_MAX_VALUE (arg0_type
);
3894 /* (-x) IN [a,b] -> x in [-b, -a] */
3895 n_low
= range_binop (MINUS_EXPR
, exp_type
,
3896 build_int_cst (exp_type
, 0),
3898 n_high
= range_binop (MINUS_EXPR
, exp_type
,
3899 build_int_cst (exp_type
, 0),
3901 if (n_high
!= 0 && TREE_OVERFLOW (n_high
))
3907 return build2_loc (loc
, MINUS_EXPR
, exp_type
, negate_expr (arg0
),
3908 build_int_cst (exp_type
, 1));
3912 if (TREE_CODE (arg1
) != INTEGER_CST
)
3915 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
3916 move a constant to the other side. */
3917 if (!TYPE_UNSIGNED (arg0_type
)
3918 && !TYPE_OVERFLOW_UNDEFINED (arg0_type
))
3921 /* If EXP is signed, any overflow in the computation is undefined,
3922 so we don't worry about it so long as our computations on
3923 the bounds don't overflow. For unsigned, overflow is defined
3924 and this is exactly the right thing. */
3925 n_low
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
3926 arg0_type
, low
, 0, arg1
, 0);
3927 n_high
= range_binop (code
== MINUS_EXPR
? PLUS_EXPR
: MINUS_EXPR
,
3928 arg0_type
, high
, 1, arg1
, 0);
3929 if ((n_low
!= 0 && TREE_OVERFLOW (n_low
))
3930 || (n_high
!= 0 && TREE_OVERFLOW (n_high
)))
3933 if (TYPE_OVERFLOW_UNDEFINED (arg0_type
))
3934 *strict_overflow_p
= true;
3937 /* Check for an unsigned range which has wrapped around the maximum
3938 value thus making n_high < n_low, and normalize it. */
3939 if (n_low
&& n_high
&& tree_int_cst_lt (n_high
, n_low
))
3941 low
= range_binop (PLUS_EXPR
, arg0_type
, n_high
, 0,
3942 integer_one_node
, 0);
3943 high
= range_binop (MINUS_EXPR
, arg0_type
, n_low
, 0,
3944 integer_one_node
, 0);
3946 /* If the range is of the form +/- [ x+1, x ], we won't
3947 be able to normalize it. But then, it represents the
3948 whole range or the empty set, so make it
3950 if (tree_int_cst_equal (n_low
, low
)
3951 && tree_int_cst_equal (n_high
, high
))
3957 low
= n_low
, high
= n_high
;
3965 case NON_LVALUE_EXPR
:
3966 if (TYPE_PRECISION (arg0_type
) > TYPE_PRECISION (exp_type
))
3969 if (! INTEGRAL_TYPE_P (arg0_type
)
3970 || (low
!= 0 && ! int_fits_type_p (low
, arg0_type
))
3971 || (high
!= 0 && ! int_fits_type_p (high
, arg0_type
)))
3974 n_low
= low
, n_high
= high
;
3977 n_low
= fold_convert_loc (loc
, arg0_type
, n_low
);
3980 n_high
= fold_convert_loc (loc
, arg0_type
, n_high
);
3982 /* If we're converting arg0 from an unsigned type, to exp,
3983 a signed type, we will be doing the comparison as unsigned.
3984 The tests above have already verified that LOW and HIGH
3987 So we have to ensure that we will handle large unsigned
3988 values the same way that the current signed bounds treat
3991 if (!TYPE_UNSIGNED (exp_type
) && TYPE_UNSIGNED (arg0_type
))
3995 /* For fixed-point modes, we need to pass the saturating flag
3996 as the 2nd parameter. */
3997 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type
)))
3999 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
),
4000 TYPE_SATURATING (arg0_type
));
4003 = lang_hooks
.types
.type_for_mode (TYPE_MODE (arg0_type
), 1);
4005 /* A range without an upper bound is, naturally, unbounded.
4006 Since convert would have cropped a very large value, use
4007 the max value for the destination type. */
4009 = TYPE_MAX_VALUE (equiv_type
) ? TYPE_MAX_VALUE (equiv_type
)
4010 : TYPE_MAX_VALUE (arg0_type
);
4012 if (TYPE_PRECISION (exp_type
) == TYPE_PRECISION (arg0_type
))
4013 high_positive
= fold_build2_loc (loc
, RSHIFT_EXPR
, arg0_type
,
4014 fold_convert_loc (loc
, arg0_type
,
4016 build_int_cst (arg0_type
, 1));
4018 /* If the low bound is specified, "and" the range with the
4019 range for which the original unsigned value will be
4023 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 1, n_low
, n_high
,
4024 1, fold_convert_loc (loc
, arg0_type
,
4029 in_p
= (n_in_p
== in_p
);
4033 /* Otherwise, "or" the range with the range of the input
4034 that will be interpreted as negative. */
4035 if (! merge_ranges (&n_in_p
, &n_low
, &n_high
, 0, n_low
, n_high
,
4036 1, fold_convert_loc (loc
, arg0_type
,
4041 in_p
= (in_p
!= n_in_p
);
4055 /* Given EXP, a logical expression, set the range it is testing into
4056 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4057 actually being tested. *PLOW and *PHIGH will be made of the same
4058 type as the returned expression. If EXP is not a comparison, we
4059 will most likely not be returning a useful value and range. Set
4060 *STRICT_OVERFLOW_P to true if the return value is only valid
4061 because signed overflow is undefined; otherwise, do not change
4062 *STRICT_OVERFLOW_P. */
4065 make_range (tree exp
, int *pin_p
, tree
*plow
, tree
*phigh
,
4066 bool *strict_overflow_p
)
4068 enum tree_code code
;
4069 tree arg0
, arg1
= NULL_TREE
;
4070 tree exp_type
, nexp
;
4073 location_t loc
= EXPR_LOCATION (exp
);
4075 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4076 and see if we can refine the range. Some of the cases below may not
4077 happen, but it doesn't seem worth worrying about this. We "continue"
4078 the outer loop when we've changed something; otherwise we "break"
4079 the switch, which will "break" the while. */
4082 low
= high
= build_int_cst (TREE_TYPE (exp
), 0);
4086 code
= TREE_CODE (exp
);
4087 exp_type
= TREE_TYPE (exp
);
4090 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code
)))
4092 if (TREE_OPERAND_LENGTH (exp
) > 0)
4093 arg0
= TREE_OPERAND (exp
, 0);
4094 if (TREE_CODE_CLASS (code
) == tcc_binary
4095 || TREE_CODE_CLASS (code
) == tcc_comparison
4096 || (TREE_CODE_CLASS (code
) == tcc_expression
4097 && TREE_OPERAND_LENGTH (exp
) > 1))
4098 arg1
= TREE_OPERAND (exp
, 1);
4100 if (arg0
== NULL_TREE
)
4103 nexp
= make_range_step (loc
, code
, arg0
, arg1
, exp_type
, &low
,
4104 &high
, &in_p
, strict_overflow_p
);
4105 if (nexp
== NULL_TREE
)
4110 /* If EXP is a constant, we can evaluate whether this is true or false. */
4111 if (TREE_CODE (exp
) == INTEGER_CST
)
4113 in_p
= in_p
== (integer_onep (range_binop (GE_EXPR
, integer_type_node
,
4115 && integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4121 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4125 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4126 type, TYPE, return an expression to test if EXP is in (or out of, depending
4127 on IN_P) the range. Return 0 if the test couldn't be created. */
4130 build_range_check (location_t loc
, tree type
, tree exp
, int in_p
,
4131 tree low
, tree high
)
4133 tree etype
= TREE_TYPE (exp
), value
;
4135 #ifdef HAVE_canonicalize_funcptr_for_compare
4136 /* Disable this optimization for function pointer expressions
4137 on targets that require function pointer canonicalization. */
4138 if (HAVE_canonicalize_funcptr_for_compare
4139 && TREE_CODE (etype
) == POINTER_TYPE
4140 && TREE_CODE (TREE_TYPE (etype
)) == FUNCTION_TYPE
)
4146 value
= build_range_check (loc
, type
, exp
, 1, low
, high
);
4148 return invert_truthvalue_loc (loc
, value
);
4153 if (low
== 0 && high
== 0)
4154 return build_int_cst (type
, 1);
4157 return fold_build2_loc (loc
, LE_EXPR
, type
, exp
,
4158 fold_convert_loc (loc
, etype
, high
));
4161 return fold_build2_loc (loc
, GE_EXPR
, type
, exp
,
4162 fold_convert_loc (loc
, etype
, low
));
4164 if (operand_equal_p (low
, high
, 0))
4165 return fold_build2_loc (loc
, EQ_EXPR
, type
, exp
,
4166 fold_convert_loc (loc
, etype
, low
));
4168 if (integer_zerop (low
))
4170 if (! TYPE_UNSIGNED (etype
))
4172 etype
= unsigned_type_for (etype
);
4173 high
= fold_convert_loc (loc
, etype
, high
);
4174 exp
= fold_convert_loc (loc
, etype
, exp
);
4176 return build_range_check (loc
, type
, exp
, 1, 0, high
);
4179 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4180 if (integer_onep (low
) && TREE_CODE (high
) == INTEGER_CST
)
4182 unsigned HOST_WIDE_INT lo
;
4186 prec
= TYPE_PRECISION (etype
);
4187 if (prec
<= HOST_BITS_PER_WIDE_INT
)
4190 lo
= ((unsigned HOST_WIDE_INT
) 1 << (prec
- 1)) - 1;
4194 hi
= ((HOST_WIDE_INT
) 1 << (prec
- HOST_BITS_PER_WIDE_INT
- 1)) - 1;
4195 lo
= (unsigned HOST_WIDE_INT
) -1;
4198 if (TREE_INT_CST_HIGH (high
) == hi
&& TREE_INT_CST_LOW (high
) == lo
)
4200 if (TYPE_UNSIGNED (etype
))
4202 tree signed_etype
= signed_type_for (etype
);
4203 if (TYPE_PRECISION (signed_etype
) != TYPE_PRECISION (etype
))
4205 = build_nonstandard_integer_type (TYPE_PRECISION (etype
), 0);
4207 etype
= signed_etype
;
4208 exp
= fold_convert_loc (loc
, etype
, exp
);
4210 return fold_build2_loc (loc
, GT_EXPR
, type
, exp
,
4211 build_int_cst (etype
, 0));
4215 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4216 This requires wrap-around arithmetics for the type of the expression.
4217 First make sure that arithmetics in this type is valid, then make sure
4218 that it wraps around. */
4219 if (TREE_CODE (etype
) == ENUMERAL_TYPE
|| TREE_CODE (etype
) == BOOLEAN_TYPE
)
4220 etype
= lang_hooks
.types
.type_for_size (TYPE_PRECISION (etype
),
4221 TYPE_UNSIGNED (etype
));
4223 if (TREE_CODE (etype
) == INTEGER_TYPE
&& !TYPE_OVERFLOW_WRAPS (etype
))
4225 tree utype
, minv
, maxv
;
4227 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4228 for the type in question, as we rely on this here. */
4229 utype
= unsigned_type_for (etype
);
4230 maxv
= fold_convert_loc (loc
, utype
, TYPE_MAX_VALUE (etype
));
4231 maxv
= range_binop (PLUS_EXPR
, NULL_TREE
, maxv
, 1,
4232 integer_one_node
, 1);
4233 minv
= fold_convert_loc (loc
, utype
, TYPE_MIN_VALUE (etype
));
4235 if (integer_zerop (range_binop (NE_EXPR
, integer_type_node
,
4242 high
= fold_convert_loc (loc
, etype
, high
);
4243 low
= fold_convert_loc (loc
, etype
, low
);
4244 exp
= fold_convert_loc (loc
, etype
, exp
);
4246 value
= const_binop (MINUS_EXPR
, high
, low
);
4249 if (POINTER_TYPE_P (etype
))
4251 if (value
!= 0 && !TREE_OVERFLOW (value
))
4253 low
= fold_build1_loc (loc
, NEGATE_EXPR
, TREE_TYPE (low
), low
);
4254 return build_range_check (loc
, type
,
4255 fold_build_pointer_plus_loc (loc
, exp
, low
),
4256 1, build_int_cst (etype
, 0), value
);
4261 if (value
!= 0 && !TREE_OVERFLOW (value
))
4262 return build_range_check (loc
, type
,
4263 fold_build2_loc (loc
, MINUS_EXPR
, etype
, exp
, low
),
4264 1, build_int_cst (etype
, 0), value
);
4269 /* Return the predecessor of VAL in its type, handling the infinite case. */
4272 range_predecessor (tree val
)
4274 tree type
= TREE_TYPE (val
);
4276 if (INTEGRAL_TYPE_P (type
)
4277 && operand_equal_p (val
, TYPE_MIN_VALUE (type
), 0))
4280 return range_binop (MINUS_EXPR
, NULL_TREE
, val
, 0, integer_one_node
, 0);
4283 /* Return the successor of VAL in its type, handling the infinite case. */
4286 range_successor (tree val
)
4288 tree type
= TREE_TYPE (val
);
4290 if (INTEGRAL_TYPE_P (type
)
4291 && operand_equal_p (val
, TYPE_MAX_VALUE (type
), 0))
4294 return range_binop (PLUS_EXPR
, NULL_TREE
, val
, 0, integer_one_node
, 0);
4297 /* Given two ranges, see if we can merge them into one. Return 1 if we
4298 can, 0 if we can't. Set the output range into the specified parameters. */
4301 merge_ranges (int *pin_p
, tree
*plow
, tree
*phigh
, int in0_p
, tree low0
,
4302 tree high0
, int in1_p
, tree low1
, tree high1
)
4310 int lowequal
= ((low0
== 0 && low1
== 0)
4311 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4312 low0
, 0, low1
, 0)));
4313 int highequal
= ((high0
== 0 && high1
== 0)
4314 || integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4315 high0
, 1, high1
, 1)));
4317 /* Make range 0 be the range that starts first, or ends last if they
4318 start at the same value. Swap them if it isn't. */
4319 if (integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4322 && integer_onep (range_binop (GT_EXPR
, integer_type_node
,
4323 high1
, 1, high0
, 1))))
4325 temp
= in0_p
, in0_p
= in1_p
, in1_p
= temp
;
4326 tem
= low0
, low0
= low1
, low1
= tem
;
4327 tem
= high0
, high0
= high1
, high1
= tem
;
4330 /* Now flag two cases, whether the ranges are disjoint or whether the
4331 second range is totally subsumed in the first. Note that the tests
4332 below are simplified by the ones above. */
4333 no_overlap
= integer_onep (range_binop (LT_EXPR
, integer_type_node
,
4334 high0
, 1, low1
, 0));
4335 subset
= integer_onep (range_binop (LE_EXPR
, integer_type_node
,
4336 high1
, 1, high0
, 1));
4338 /* We now have four cases, depending on whether we are including or
4339 excluding the two ranges. */
4342 /* If they don't overlap, the result is false. If the second range
4343 is a subset it is the result. Otherwise, the range is from the start
4344 of the second to the end of the first. */
4346 in_p
= 0, low
= high
= 0;
4348 in_p
= 1, low
= low1
, high
= high1
;
4350 in_p
= 1, low
= low1
, high
= high0
;
4353 else if (in0_p
&& ! in1_p
)
4355 /* If they don't overlap, the result is the first range. If they are
4356 equal, the result is false. If the second range is a subset of the
4357 first, and the ranges begin at the same place, we go from just after
4358 the end of the second range to the end of the first. If the second
4359 range is not a subset of the first, or if it is a subset and both
4360 ranges end at the same place, the range starts at the start of the
4361 first range and ends just before the second range.
4362 Otherwise, we can't describe this as a single range. */
4364 in_p
= 1, low
= low0
, high
= high0
;
4365 else if (lowequal
&& highequal
)
4366 in_p
= 0, low
= high
= 0;
4367 else if (subset
&& lowequal
)
4369 low
= range_successor (high1
);
4374 /* We are in the weird situation where high0 > high1 but
4375 high1 has no successor. Punt. */
4379 else if (! subset
|| highequal
)
4382 high
= range_predecessor (low1
);
4386 /* low0 < low1 but low1 has no predecessor. Punt. */
4394 else if (! in0_p
&& in1_p
)
4396 /* If they don't overlap, the result is the second range. If the second
4397 is a subset of the first, the result is false. Otherwise,
4398 the range starts just after the first range and ends at the
4399 end of the second. */
4401 in_p
= 1, low
= low1
, high
= high1
;
4402 else if (subset
|| highequal
)
4403 in_p
= 0, low
= high
= 0;
4406 low
= range_successor (high0
);
4411 /* high1 > high0 but high0 has no successor. Punt. */
4419 /* The case where we are excluding both ranges. Here the complex case
4420 is if they don't overlap. In that case, the only time we have a
4421 range is if they are adjacent. If the second is a subset of the
4422 first, the result is the first. Otherwise, the range to exclude
4423 starts at the beginning of the first range and ends at the end of the
4427 if (integer_onep (range_binop (EQ_EXPR
, integer_type_node
,
4428 range_successor (high0
),
4430 in_p
= 0, low
= low0
, high
= high1
;
4433 /* Canonicalize - [min, x] into - [-, x]. */
4434 if (low0
&& TREE_CODE (low0
) == INTEGER_CST
)
4435 switch (TREE_CODE (TREE_TYPE (low0
)))
4438 if (TYPE_PRECISION (TREE_TYPE (low0
))
4439 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0
))))
4443 if (tree_int_cst_equal (low0
,
4444 TYPE_MIN_VALUE (TREE_TYPE (low0
))))
4448 if (TYPE_UNSIGNED (TREE_TYPE (low0
))
4449 && integer_zerop (low0
))
4456 /* Canonicalize - [x, max] into - [x, -]. */
4457 if (high1
&& TREE_CODE (high1
) == INTEGER_CST
)
4458 switch (TREE_CODE (TREE_TYPE (high1
)))
4461 if (TYPE_PRECISION (TREE_TYPE (high1
))
4462 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1
))))
4466 if (tree_int_cst_equal (high1
,
4467 TYPE_MAX_VALUE (TREE_TYPE (high1
))))
4471 if (TYPE_UNSIGNED (TREE_TYPE (high1
))
4472 && integer_zerop (range_binop (PLUS_EXPR
, NULL_TREE
,
4474 integer_one_node
, 1)))
4481 /* The ranges might be also adjacent between the maximum and
4482 minimum values of the given type. For
4483 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4484 return + [x + 1, y - 1]. */
4485 if (low0
== 0 && high1
== 0)
4487 low
= range_successor (high0
);
4488 high
= range_predecessor (low1
);
4489 if (low
== 0 || high
== 0)
4499 in_p
= 0, low
= low0
, high
= high0
;
4501 in_p
= 0, low
= low0
, high
= high1
;
4504 *pin_p
= in_p
, *plow
= low
, *phigh
= high
;
4509 /* Subroutine of fold, looking inside expressions of the form
4510 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4511 of the COND_EXPR. This function is being used also to optimize
4512 A op B ? C : A, by reversing the comparison first.
4514 Return a folded expression whose code is not a COND_EXPR
4515 anymore, or NULL_TREE if no folding opportunity is found. */
4518 fold_cond_expr_with_comparison (location_t loc
, tree type
,
4519 tree arg0
, tree arg1
, tree arg2
)
4521 enum tree_code comp_code
= TREE_CODE (arg0
);
4522 tree arg00
= TREE_OPERAND (arg0
, 0);
4523 tree arg01
= TREE_OPERAND (arg0
, 1);
4524 tree arg1_type
= TREE_TYPE (arg1
);
4530 /* If we have A op 0 ? A : -A, consider applying the following
4533 A == 0? A : -A same as -A
4534 A != 0? A : -A same as A
4535 A >= 0? A : -A same as abs (A)
4536 A > 0? A : -A same as abs (A)
4537 A <= 0? A : -A same as -abs (A)
4538 A < 0? A : -A same as -abs (A)
4540 None of these transformations work for modes with signed
4541 zeros. If A is +/-0, the first two transformations will
4542 change the sign of the result (from +0 to -0, or vice
4543 versa). The last four will fix the sign of the result,
4544 even though the original expressions could be positive or
4545 negative, depending on the sign of A.
4547 Note that all these transformations are correct if A is
4548 NaN, since the two alternatives (A and -A) are also NaNs. */
4549 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
4550 && (FLOAT_TYPE_P (TREE_TYPE (arg01
))
4551 ? real_zerop (arg01
)
4552 : integer_zerop (arg01
))
4553 && ((TREE_CODE (arg2
) == NEGATE_EXPR
4554 && operand_equal_p (TREE_OPERAND (arg2
, 0), arg1
, 0))
4555 /* In the case that A is of the form X-Y, '-A' (arg2) may
4556 have already been folded to Y-X, check for that. */
4557 || (TREE_CODE (arg1
) == MINUS_EXPR
4558 && TREE_CODE (arg2
) == MINUS_EXPR
4559 && operand_equal_p (TREE_OPERAND (arg1
, 0),
4560 TREE_OPERAND (arg2
, 1), 0)
4561 && operand_equal_p (TREE_OPERAND (arg1
, 1),
4562 TREE_OPERAND (arg2
, 0), 0))))
4567 tem
= fold_convert_loc (loc
, arg1_type
, arg1
);
4568 return pedantic_non_lvalue_loc (loc
,
4569 fold_convert_loc (loc
, type
,
4570 negate_expr (tem
)));
4573 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
4576 if (flag_trapping_math
)
4581 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
4582 arg1
= fold_convert_loc (loc
, signed_type_for
4583 (TREE_TYPE (arg1
)), arg1
);
4584 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
4585 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
4588 if (flag_trapping_math
)
4592 if (TYPE_UNSIGNED (TREE_TYPE (arg1
)))
4593 arg1
= fold_convert_loc (loc
, signed_type_for
4594 (TREE_TYPE (arg1
)), arg1
);
4595 tem
= fold_build1_loc (loc
, ABS_EXPR
, TREE_TYPE (arg1
), arg1
);
4596 return negate_expr (fold_convert_loc (loc
, type
, tem
));
4598 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
4602 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
4603 A == 0 ? A : 0 is always 0 unless A is -0. Note that
4604 both transformations are correct when A is NaN: A != 0
4605 is then true, and A == 0 is false. */
4607 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
4608 && integer_zerop (arg01
) && integer_zerop (arg2
))
4610 if (comp_code
== NE_EXPR
)
4611 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
4612 else if (comp_code
== EQ_EXPR
)
4613 return build_int_cst (type
, 0);
4616 /* Try some transformations of A op B ? A : B.
4618 A == B? A : B same as B
4619 A != B? A : B same as A
4620 A >= B? A : B same as max (A, B)
4621 A > B? A : B same as max (B, A)
4622 A <= B? A : B same as min (A, B)
4623 A < B? A : B same as min (B, A)
4625 As above, these transformations don't work in the presence
4626 of signed zeros. For example, if A and B are zeros of
4627 opposite sign, the first two transformations will change
4628 the sign of the result. In the last four, the original
4629 expressions give different results for (A=+0, B=-0) and
4630 (A=-0, B=+0), but the transformed expressions do not.
4632 The first two transformations are correct if either A or B
4633 is a NaN. In the first transformation, the condition will
4634 be false, and B will indeed be chosen. In the case of the
4635 second transformation, the condition A != B will be true,
4636 and A will be chosen.
4638 The conversions to max() and min() are not correct if B is
4639 a number and A is not. The conditions in the original
4640 expressions will be false, so all four give B. The min()
4641 and max() versions would give a NaN instead. */
4642 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
))
4643 && operand_equal_for_comparison_p (arg01
, arg2
, arg00
)
4644 /* Avoid these transformations if the COND_EXPR may be used
4645 as an lvalue in the C++ front-end. PR c++/19199. */
4647 || (strcmp (lang_hooks
.name
, "GNU C++") != 0
4648 && strcmp (lang_hooks
.name
, "GNU Objective-C++") != 0)
4649 || ! maybe_lvalue_p (arg1
)
4650 || ! maybe_lvalue_p (arg2
)))
4652 tree comp_op0
= arg00
;
4653 tree comp_op1
= arg01
;
4654 tree comp_type
= TREE_TYPE (comp_op0
);
4656 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
4657 if (TYPE_MAIN_VARIANT (comp_type
) == TYPE_MAIN_VARIANT (type
))
4667 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg2
));
4669 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
4674 /* In C++ a ?: expression can be an lvalue, so put the
4675 operand which will be used if they are equal first
4676 so that we can convert this back to the
4677 corresponding COND_EXPR. */
4678 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
4680 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
4681 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
4682 tem
= (comp_code
== LE_EXPR
|| comp_code
== UNLE_EXPR
)
4683 ? fold_build2_loc (loc
, MIN_EXPR
, comp_type
, comp_op0
, comp_op1
)
4684 : fold_build2_loc (loc
, MIN_EXPR
, comp_type
,
4685 comp_op1
, comp_op0
);
4686 return pedantic_non_lvalue_loc (loc
,
4687 fold_convert_loc (loc
, type
, tem
));
4694 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
4696 comp_op0
= fold_convert_loc (loc
, comp_type
, comp_op0
);
4697 comp_op1
= fold_convert_loc (loc
, comp_type
, comp_op1
);
4698 tem
= (comp_code
== GE_EXPR
|| comp_code
== UNGE_EXPR
)
4699 ? fold_build2_loc (loc
, MAX_EXPR
, comp_type
, comp_op0
, comp_op1
)
4700 : fold_build2_loc (loc
, MAX_EXPR
, comp_type
,
4701 comp_op1
, comp_op0
);
4702 return pedantic_non_lvalue_loc (loc
,
4703 fold_convert_loc (loc
, type
, tem
));
4707 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
4708 return pedantic_non_lvalue_loc (loc
,
4709 fold_convert_loc (loc
, type
, arg2
));
4712 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
))))
4713 return pedantic_non_lvalue_loc (loc
,
4714 fold_convert_loc (loc
, type
, arg1
));
4717 gcc_assert (TREE_CODE_CLASS (comp_code
) == tcc_comparison
);
4722 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4723 we might still be able to simplify this. For example,
4724 if C1 is one less or one more than C2, this might have started
4725 out as a MIN or MAX and been transformed by this function.
4726 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
4728 if (INTEGRAL_TYPE_P (type
)
4729 && TREE_CODE (arg01
) == INTEGER_CST
4730 && TREE_CODE (arg2
) == INTEGER_CST
)
4734 if (TREE_CODE (arg1
) == INTEGER_CST
)
4736 /* We can replace A with C1 in this case. */
4737 arg1
= fold_convert_loc (loc
, type
, arg01
);
4738 return fold_build3_loc (loc
, COND_EXPR
, type
, arg0
, arg1
, arg2
);
4741 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
4742 MIN_EXPR, to preserve the signedness of the comparison. */
4743 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
),
4745 && operand_equal_p (arg01
,
4746 const_binop (PLUS_EXPR
, arg2
,
4747 build_int_cst (type
, 1)),
4750 tem
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (arg00
), arg00
,
4751 fold_convert_loc (loc
, TREE_TYPE (arg00
),
4753 return pedantic_non_lvalue_loc (loc
,
4754 fold_convert_loc (loc
, type
, tem
));
4759 /* If C1 is C2 - 1, this is min(A, C2), with the same care
4761 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
),
4763 && operand_equal_p (arg01
,
4764 const_binop (MINUS_EXPR
, arg2
,
4765 build_int_cst (type
, 1)),
4768 tem
= fold_build2_loc (loc
, MIN_EXPR
, TREE_TYPE (arg00
), arg00
,
4769 fold_convert_loc (loc
, TREE_TYPE (arg00
),
4771 return pedantic_non_lvalue_loc (loc
,
4772 fold_convert_loc (loc
, type
, tem
));
4777 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
4778 MAX_EXPR, to preserve the signedness of the comparison. */
4779 if (! operand_equal_p (arg2
, TYPE_MIN_VALUE (type
),
4781 && operand_equal_p (arg01
,
4782 const_binop (MINUS_EXPR
, arg2
,
4783 build_int_cst (type
, 1)),
4786 tem
= fold_build2_loc (loc
, MAX_EXPR
, TREE_TYPE (arg00
), arg00
,
4787 fold_convert_loc (loc
, TREE_TYPE (arg00
),
4789 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
4794 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
4795 if (! operand_equal_p (arg2
, TYPE_MAX_VALUE (type
),
4797 && operand_equal_p (arg01
,
4798 const_binop (PLUS_EXPR
, arg2
,
4799 build_int_cst (type
, 1)),
4802 tem
= fold_build2_loc (loc
, MAX_EXPR
, TREE_TYPE (arg00
), arg00
,
4803 fold_convert_loc (loc
, TREE_TYPE (arg00
),
4805 return pedantic_non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
4819 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
4820 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
4821 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
4825 /* EXP is some logical combination of boolean tests. See if we can
4826 merge it into some range test. Return the new tree if so. */
4829 fold_range_test (location_t loc
, enum tree_code code
, tree type
,
4832 int or_op
= (code
== TRUTH_ORIF_EXPR
4833 || code
== TRUTH_OR_EXPR
);
4834 int in0_p
, in1_p
, in_p
;
4835 tree low0
, low1
, low
, high0
, high1
, high
;
4836 bool strict_overflow_p
= false;
4837 tree lhs
= make_range (op0
, &in0_p
, &low0
, &high0
, &strict_overflow_p
);
4838 tree rhs
= make_range (op1
, &in1_p
, &low1
, &high1
, &strict_overflow_p
);
4840 const char * const warnmsg
= G_("assuming signed overflow does not occur "
4841 "when simplifying range test");
4843 /* If this is an OR operation, invert both sides; we will invert
4844 again at the end. */
4846 in0_p
= ! in0_p
, in1_p
= ! in1_p
;
4848 /* If both expressions are the same, if we can merge the ranges, and we
4849 can build the range test, return it or it inverted. If one of the
4850 ranges is always true or always false, consider it to be the same
4851 expression as the other. */
4852 if ((lhs
== 0 || rhs
== 0 || operand_equal_p (lhs
, rhs
, 0))
4853 && merge_ranges (&in_p
, &low
, &high
, in0_p
, low0
, high0
,
4855 && 0 != (tem
= (build_range_check (loc
, type
,
4857 : rhs
!= 0 ? rhs
: integer_zero_node
,
4860 if (strict_overflow_p
)
4861 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
4862 return or_op
? invert_truthvalue_loc (loc
, tem
) : tem
;
4865 /* On machines where the branch cost is expensive, if this is a
4866 short-circuited branch and the underlying object on both sides
4867 is the same, make a non-short-circuit operation. */
4868 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
4869 && lhs
!= 0 && rhs
!= 0
4870 && (code
== TRUTH_ANDIF_EXPR
4871 || code
== TRUTH_ORIF_EXPR
)
4872 && operand_equal_p (lhs
, rhs
, 0))
4874 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
4875 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4876 which cases we can't do this. */
4877 if (simple_operand_p (lhs
))
4878 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
4879 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
4882 else if (!lang_hooks
.decls
.global_bindings_p ()
4883 && !CONTAINS_PLACEHOLDER_P (lhs
))
4885 tree common
= save_expr (lhs
);
4887 if (0 != (lhs
= build_range_check (loc
, type
, common
,
4888 or_op
? ! in0_p
: in0_p
,
4890 && (0 != (rhs
= build_range_check (loc
, type
, common
,
4891 or_op
? ! in1_p
: in1_p
,
4894 if (strict_overflow_p
)
4895 fold_overflow_warning (warnmsg
,
4896 WARN_STRICT_OVERFLOW_COMPARISON
);
4897 return build2_loc (loc
, code
== TRUTH_ANDIF_EXPR
4898 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
,
4907 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
4908 bit value. Arrange things so the extra bits will be set to zero if and
4909 only if C is signed-extended to its full width. If MASK is nonzero,
4910 it is an INTEGER_CST that should be AND'ed with the extra bits. */
4913 unextend (tree c
, int p
, int unsignedp
, tree mask
)
4915 tree type
= TREE_TYPE (c
);
4916 int modesize
= GET_MODE_BITSIZE (TYPE_MODE (type
));
4919 if (p
== modesize
|| unsignedp
)
4922 /* We work by getting just the sign bit into the low-order bit, then
4923 into the high-order bit, then sign-extend. We then XOR that value
4925 temp
= const_binop (RSHIFT_EXPR
, c
, size_int (p
- 1));
4926 temp
= const_binop (BIT_AND_EXPR
, temp
, size_int (1));
4928 /* We must use a signed type in order to get an arithmetic right shift.
4929 However, we must also avoid introducing accidental overflows, so that
4930 a subsequent call to integer_zerop will work. Hence we must
4931 do the type conversion here. At this point, the constant is either
4932 zero or one, and the conversion to a signed type can never overflow.
4933 We could get an overflow if this conversion is done anywhere else. */
4934 if (TYPE_UNSIGNED (type
))
4935 temp
= fold_convert (signed_type_for (type
), temp
);
4937 temp
= const_binop (LSHIFT_EXPR
, temp
, size_int (modesize
- 1));
4938 temp
= const_binop (RSHIFT_EXPR
, temp
, size_int (modesize
- p
- 1));
4940 temp
= const_binop (BIT_AND_EXPR
, temp
,
4941 fold_convert (TREE_TYPE (c
), mask
));
4942 /* If necessary, convert the type back to match the type of C. */
4943 if (TYPE_UNSIGNED (type
))
4944 temp
= fold_convert (type
, temp
);
4946 return fold_convert (type
, const_binop (BIT_XOR_EXPR
, c
, temp
));
4949 /* For an expression that has the form
4953 we can drop one of the inner expressions and simplify to
4957 LOC is the location of the resulting expression. OP is the inner
4958 logical operation; the left-hand side in the examples above, while CMPOP
4959 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
4960 removing a condition that guards another, as in
4961 (A != NULL && A->...) || A == NULL
4962 which we must not transform. If RHS_ONLY is true, only eliminate the
4963 right-most operand of the inner logical operation. */
4966 merge_truthop_with_opposite_arm (location_t loc
, tree op
, tree cmpop
,
4969 tree type
= TREE_TYPE (cmpop
);
4970 enum tree_code code
= TREE_CODE (cmpop
);
4971 enum tree_code truthop_code
= TREE_CODE (op
);
4972 tree lhs
= TREE_OPERAND (op
, 0);
4973 tree rhs
= TREE_OPERAND (op
, 1);
4974 tree orig_lhs
= lhs
, orig_rhs
= rhs
;
4975 enum tree_code rhs_code
= TREE_CODE (rhs
);
4976 enum tree_code lhs_code
= TREE_CODE (lhs
);
4977 enum tree_code inv_code
;
4979 if (TREE_SIDE_EFFECTS (op
) || TREE_SIDE_EFFECTS (cmpop
))
4982 if (TREE_CODE_CLASS (code
) != tcc_comparison
)
4985 if (rhs_code
== truthop_code
)
4987 tree newrhs
= merge_truthop_with_opposite_arm (loc
, rhs
, cmpop
, rhs_only
);
4988 if (newrhs
!= NULL_TREE
)
4991 rhs_code
= TREE_CODE (rhs
);
4994 if (lhs_code
== truthop_code
&& !rhs_only
)
4996 tree newlhs
= merge_truthop_with_opposite_arm (loc
, lhs
, cmpop
, false);
4997 if (newlhs
!= NULL_TREE
)
5000 lhs_code
= TREE_CODE (lhs
);
5004 inv_code
= invert_tree_comparison (code
, HONOR_NANS (TYPE_MODE (type
)));
5005 if (inv_code
== rhs_code
5006 && operand_equal_p (TREE_OPERAND (rhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5007 && operand_equal_p (TREE_OPERAND (rhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5009 if (!rhs_only
&& inv_code
== lhs_code
5010 && operand_equal_p (TREE_OPERAND (lhs
, 0), TREE_OPERAND (cmpop
, 0), 0)
5011 && operand_equal_p (TREE_OPERAND (lhs
, 1), TREE_OPERAND (cmpop
, 1), 0))
5013 if (rhs
!= orig_rhs
|| lhs
!= orig_lhs
)
5014 return fold_build2_loc (loc
, truthop_code
, TREE_TYPE (cmpop
),
5019 /* Find ways of folding logical expressions of LHS and RHS:
5020 Try to merge two comparisons to the same innermost item.
5021 Look for range tests like "ch >= '0' && ch <= '9'".
5022 Look for combinations of simple terms on machines with expensive branches
5023 and evaluate the RHS unconditionally.
5025 For example, if we have p->a == 2 && p->b == 4 and we can make an
5026 object large enough to span both A and B, we can do this with a comparison
5027 against the object ANDed with the a mask.
5029 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5030 operations to do this with one comparison.
5032 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5033 function and the one above.
5035 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5036 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5038 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5041 We return the simplified tree or 0 if no optimization is possible. */
5044 fold_truth_andor_1 (location_t loc
, enum tree_code code
, tree truth_type
,
5047 /* If this is the "or" of two comparisons, we can do something if
5048 the comparisons are NE_EXPR. If this is the "and", we can do something
5049 if the comparisons are EQ_EXPR. I.e.,
5050 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5052 WANTED_CODE is this operation code. For single bit fields, we can
5053 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5054 comparison for one-bit fields. */
5056 enum tree_code wanted_code
;
5057 enum tree_code lcode
, rcode
;
5058 tree ll_arg
, lr_arg
, rl_arg
, rr_arg
;
5059 tree ll_inner
, lr_inner
, rl_inner
, rr_inner
;
5060 HOST_WIDE_INT ll_bitsize
, ll_bitpos
, lr_bitsize
, lr_bitpos
;
5061 HOST_WIDE_INT rl_bitsize
, rl_bitpos
, rr_bitsize
, rr_bitpos
;
5062 HOST_WIDE_INT xll_bitpos
, xlr_bitpos
, xrl_bitpos
, xrr_bitpos
;
5063 HOST_WIDE_INT lnbitsize
, lnbitpos
, rnbitsize
, rnbitpos
;
5064 int ll_unsignedp
, lr_unsignedp
, rl_unsignedp
, rr_unsignedp
;
5065 enum machine_mode ll_mode
, lr_mode
, rl_mode
, rr_mode
;
5066 enum machine_mode lnmode
, rnmode
;
5067 tree ll_mask
, lr_mask
, rl_mask
, rr_mask
;
5068 tree ll_and_mask
, lr_and_mask
, rl_and_mask
, rr_and_mask
;
5069 tree l_const
, r_const
;
5070 tree lntype
, rntype
, result
;
5071 HOST_WIDE_INT first_bit
, end_bit
;
5074 /* Start by getting the comparison codes. Fail if anything is volatile.
5075 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5076 it were surrounded with a NE_EXPR. */
5078 if (TREE_SIDE_EFFECTS (lhs
) || TREE_SIDE_EFFECTS (rhs
))
5081 lcode
= TREE_CODE (lhs
);
5082 rcode
= TREE_CODE (rhs
);
5084 if (lcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (lhs
, 1)))
5086 lhs
= build2 (NE_EXPR
, truth_type
, lhs
,
5087 build_int_cst (TREE_TYPE (lhs
), 0));
5091 if (rcode
== BIT_AND_EXPR
&& integer_onep (TREE_OPERAND (rhs
, 1)))
5093 rhs
= build2 (NE_EXPR
, truth_type
, rhs
,
5094 build_int_cst (TREE_TYPE (rhs
), 0));
5098 if (TREE_CODE_CLASS (lcode
) != tcc_comparison
5099 || TREE_CODE_CLASS (rcode
) != tcc_comparison
)
5102 ll_arg
= TREE_OPERAND (lhs
, 0);
5103 lr_arg
= TREE_OPERAND (lhs
, 1);
5104 rl_arg
= TREE_OPERAND (rhs
, 0);
5105 rr_arg
= TREE_OPERAND (rhs
, 1);
5107 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5108 if (simple_operand_p (ll_arg
)
5109 && simple_operand_p (lr_arg
))
5111 if (operand_equal_p (ll_arg
, rl_arg
, 0)
5112 && operand_equal_p (lr_arg
, rr_arg
, 0))
5114 result
= combine_comparisons (loc
, code
, lcode
, rcode
,
5115 truth_type
, ll_arg
, lr_arg
);
5119 else if (operand_equal_p (ll_arg
, rr_arg
, 0)
5120 && operand_equal_p (lr_arg
, rl_arg
, 0))
5122 result
= combine_comparisons (loc
, code
, lcode
,
5123 swap_tree_comparison (rcode
),
5124 truth_type
, ll_arg
, lr_arg
);
5130 code
= ((code
== TRUTH_AND_EXPR
|| code
== TRUTH_ANDIF_EXPR
)
5131 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
);
5133 /* If the RHS can be evaluated unconditionally and its operands are
5134 simple, it wins to evaluate the RHS unconditionally on machines
5135 with expensive branches. In this case, this isn't a comparison
5136 that can be merged. */
5138 if (BRANCH_COST (optimize_function_for_speed_p (cfun
),
5140 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg
))
5141 && simple_operand_p (rl_arg
)
5142 && simple_operand_p (rr_arg
))
5144 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5145 if (code
== TRUTH_OR_EXPR
5146 && lcode
== NE_EXPR
&& integer_zerop (lr_arg
)
5147 && rcode
== NE_EXPR
&& integer_zerop (rr_arg
)
5148 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5149 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5150 return build2_loc (loc
, NE_EXPR
, truth_type
,
5151 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5153 build_int_cst (TREE_TYPE (ll_arg
), 0));
5155 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5156 if (code
== TRUTH_AND_EXPR
5157 && lcode
== EQ_EXPR
&& integer_zerop (lr_arg
)
5158 && rcode
== EQ_EXPR
&& integer_zerop (rr_arg
)
5159 && TREE_TYPE (ll_arg
) == TREE_TYPE (rl_arg
)
5160 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg
)))
5161 return build2_loc (loc
, EQ_EXPR
, truth_type
,
5162 build2 (BIT_IOR_EXPR
, TREE_TYPE (ll_arg
),
5164 build_int_cst (TREE_TYPE (ll_arg
), 0));
5167 /* See if the comparisons can be merged. Then get all the parameters for
5170 if ((lcode
!= EQ_EXPR
&& lcode
!= NE_EXPR
)
5171 || (rcode
!= EQ_EXPR
&& rcode
!= NE_EXPR
))
5175 ll_inner
= decode_field_reference (loc
, ll_arg
,
5176 &ll_bitsize
, &ll_bitpos
, &ll_mode
,
5177 &ll_unsignedp
, &volatilep
, &ll_mask
,
5179 lr_inner
= decode_field_reference (loc
, lr_arg
,
5180 &lr_bitsize
, &lr_bitpos
, &lr_mode
,
5181 &lr_unsignedp
, &volatilep
, &lr_mask
,
5183 rl_inner
= decode_field_reference (loc
, rl_arg
,
5184 &rl_bitsize
, &rl_bitpos
, &rl_mode
,
5185 &rl_unsignedp
, &volatilep
, &rl_mask
,
5187 rr_inner
= decode_field_reference (loc
, rr_arg
,
5188 &rr_bitsize
, &rr_bitpos
, &rr_mode
,
5189 &rr_unsignedp
, &volatilep
, &rr_mask
,
5192 /* It must be true that the inner operation on the lhs of each
5193 comparison must be the same if we are to be able to do anything.
5194 Then see if we have constants. If not, the same must be true for
5196 if (volatilep
|| ll_inner
== 0 || rl_inner
== 0
5197 || ! operand_equal_p (ll_inner
, rl_inner
, 0))
5200 if (TREE_CODE (lr_arg
) == INTEGER_CST
5201 && TREE_CODE (rr_arg
) == INTEGER_CST
)
5202 l_const
= lr_arg
, r_const
= rr_arg
;
5203 else if (lr_inner
== 0 || rr_inner
== 0
5204 || ! operand_equal_p (lr_inner
, rr_inner
, 0))
5207 l_const
= r_const
= 0;
5209 /* If either comparison code is not correct for our logical operation,
5210 fail. However, we can convert a one-bit comparison against zero into
5211 the opposite comparison against that bit being set in the field. */
5213 wanted_code
= (code
== TRUTH_AND_EXPR
? EQ_EXPR
: NE_EXPR
);
5214 if (lcode
!= wanted_code
)
5216 if (l_const
&& integer_zerop (l_const
) && integer_pow2p (ll_mask
))
5218 /* Make the left operand unsigned, since we are only interested
5219 in the value of one bit. Otherwise we are doing the wrong
5228 /* This is analogous to the code for l_const above. */
5229 if (rcode
!= wanted_code
)
5231 if (r_const
&& integer_zerop (r_const
) && integer_pow2p (rl_mask
))
5240 /* See if we can find a mode that contains both fields being compared on
5241 the left. If we can't, fail. Otherwise, update all constants and masks
5242 to be relative to a field of that size. */
5243 first_bit
= MIN (ll_bitpos
, rl_bitpos
);
5244 end_bit
= MAX (ll_bitpos
+ ll_bitsize
, rl_bitpos
+ rl_bitsize
);
5245 lnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5246 TYPE_ALIGN (TREE_TYPE (ll_inner
)), word_mode
,
5248 if (lnmode
== VOIDmode
)
5251 lnbitsize
= GET_MODE_BITSIZE (lnmode
);
5252 lnbitpos
= first_bit
& ~ (lnbitsize
- 1);
5253 lntype
= lang_hooks
.types
.type_for_size (lnbitsize
, 1);
5254 xll_bitpos
= ll_bitpos
- lnbitpos
, xrl_bitpos
= rl_bitpos
- lnbitpos
;
5256 if (BYTES_BIG_ENDIAN
)
5258 xll_bitpos
= lnbitsize
- xll_bitpos
- ll_bitsize
;
5259 xrl_bitpos
= lnbitsize
- xrl_bitpos
- rl_bitsize
;
5262 ll_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, ll_mask
),
5263 size_int (xll_bitpos
));
5264 rl_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
, lntype
, rl_mask
),
5265 size_int (xrl_bitpos
));
5269 l_const
= fold_convert_loc (loc
, lntype
, l_const
);
5270 l_const
= unextend (l_const
, ll_bitsize
, ll_unsignedp
, ll_and_mask
);
5271 l_const
= const_binop (LSHIFT_EXPR
, l_const
, size_int (xll_bitpos
));
5272 if (! integer_zerop (const_binop (BIT_AND_EXPR
, l_const
,
5273 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5276 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5278 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5283 r_const
= fold_convert_loc (loc
, lntype
, r_const
);
5284 r_const
= unextend (r_const
, rl_bitsize
, rl_unsignedp
, rl_and_mask
);
5285 r_const
= const_binop (LSHIFT_EXPR
, r_const
, size_int (xrl_bitpos
));
5286 if (! integer_zerop (const_binop (BIT_AND_EXPR
, r_const
,
5287 fold_build1_loc (loc
, BIT_NOT_EXPR
,
5290 warning (0, "comparison is always %d", wanted_code
== NE_EXPR
);
5292 return constant_boolean_node (wanted_code
== NE_EXPR
, truth_type
);
5296 /* If the right sides are not constant, do the same for it. Also,
5297 disallow this optimization if a size or signedness mismatch occurs
5298 between the left and right sides. */
5301 if (ll_bitsize
!= lr_bitsize
|| rl_bitsize
!= rr_bitsize
5302 || ll_unsignedp
!= lr_unsignedp
|| rl_unsignedp
!= rr_unsignedp
5303 /* Make sure the two fields on the right
5304 correspond to the left without being swapped. */
5305 || ll_bitpos
- rl_bitpos
!= lr_bitpos
- rr_bitpos
)
5308 first_bit
= MIN (lr_bitpos
, rr_bitpos
);
5309 end_bit
= MAX (lr_bitpos
+ lr_bitsize
, rr_bitpos
+ rr_bitsize
);
5310 rnmode
= get_best_mode (end_bit
- first_bit
, first_bit
, 0, 0,
5311 TYPE_ALIGN (TREE_TYPE (lr_inner
)), word_mode
,
5313 if (rnmode
== VOIDmode
)
5316 rnbitsize
= GET_MODE_BITSIZE (rnmode
);
5317 rnbitpos
= first_bit
& ~ (rnbitsize
- 1);
5318 rntype
= lang_hooks
.types
.type_for_size (rnbitsize
, 1);
5319 xlr_bitpos
= lr_bitpos
- rnbitpos
, xrr_bitpos
= rr_bitpos
- rnbitpos
;
5321 if (BYTES_BIG_ENDIAN
)
5323 xlr_bitpos
= rnbitsize
- xlr_bitpos
- lr_bitsize
;
5324 xrr_bitpos
= rnbitsize
- xrr_bitpos
- rr_bitsize
;
5327 lr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5329 size_int (xlr_bitpos
));
5330 rr_mask
= const_binop (LSHIFT_EXPR
, fold_convert_loc (loc
,
5332 size_int (xrr_bitpos
));
5334 /* Make a mask that corresponds to both fields being compared.
5335 Do this for both items being compared. If the operands are the
5336 same size and the bits being compared are in the same position
5337 then we can do this by masking both and comparing the masked
5339 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5340 lr_mask
= const_binop (BIT_IOR_EXPR
, lr_mask
, rr_mask
);
5341 if (lnbitsize
== rnbitsize
&& xll_bitpos
== xlr_bitpos
)
5343 lhs
= make_bit_field_ref (loc
, ll_inner
, lntype
, lnbitsize
, lnbitpos
,
5344 ll_unsignedp
|| rl_unsignedp
);
5345 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5346 lhs
= build2 (BIT_AND_EXPR
, lntype
, lhs
, ll_mask
);
5348 rhs
= make_bit_field_ref (loc
, lr_inner
, rntype
, rnbitsize
, rnbitpos
,
5349 lr_unsignedp
|| rr_unsignedp
);
5350 if (! all_ones_mask_p (lr_mask
, rnbitsize
))
5351 rhs
= build2 (BIT_AND_EXPR
, rntype
, rhs
, lr_mask
);
5353 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5356 /* There is still another way we can do something: If both pairs of
5357 fields being compared are adjacent, we may be able to make a wider
5358 field containing them both.
5360 Note that we still must mask the lhs/rhs expressions. Furthermore,
5361 the mask must be shifted to account for the shift done by
5362 make_bit_field_ref. */
5363 if ((ll_bitsize
+ ll_bitpos
== rl_bitpos
5364 && lr_bitsize
+ lr_bitpos
== rr_bitpos
)
5365 || (ll_bitpos
== rl_bitpos
+ rl_bitsize
5366 && lr_bitpos
== rr_bitpos
+ rr_bitsize
))
5370 lhs
= make_bit_field_ref (loc
, ll_inner
, lntype
,
5371 ll_bitsize
+ rl_bitsize
,
5372 MIN (ll_bitpos
, rl_bitpos
), ll_unsignedp
);
5373 rhs
= make_bit_field_ref (loc
, lr_inner
, rntype
,
5374 lr_bitsize
+ rr_bitsize
,
5375 MIN (lr_bitpos
, rr_bitpos
), lr_unsignedp
);
5377 ll_mask
= const_binop (RSHIFT_EXPR
, ll_mask
,
5378 size_int (MIN (xll_bitpos
, xrl_bitpos
)));
5379 lr_mask
= const_binop (RSHIFT_EXPR
, lr_mask
,
5380 size_int (MIN (xlr_bitpos
, xrr_bitpos
)));
5382 /* Convert to the smaller type before masking out unwanted bits. */
5384 if (lntype
!= rntype
)
5386 if (lnbitsize
> rnbitsize
)
5388 lhs
= fold_convert_loc (loc
, rntype
, lhs
);
5389 ll_mask
= fold_convert_loc (loc
, rntype
, ll_mask
);
5392 else if (lnbitsize
< rnbitsize
)
5394 rhs
= fold_convert_loc (loc
, lntype
, rhs
);
5395 lr_mask
= fold_convert_loc (loc
, lntype
, lr_mask
);
5400 if (! all_ones_mask_p (ll_mask
, ll_bitsize
+ rl_bitsize
))
5401 lhs
= build2 (BIT_AND_EXPR
, type
, lhs
, ll_mask
);
5403 if (! all_ones_mask_p (lr_mask
, lr_bitsize
+ rr_bitsize
))
5404 rhs
= build2 (BIT_AND_EXPR
, type
, rhs
, lr_mask
);
5406 return build2_loc (loc
, wanted_code
, truth_type
, lhs
, rhs
);
5412 /* Handle the case of comparisons with constants. If there is something in
5413 common between the masks, those bits of the constants must be the same.
5414 If not, the condition is always false. Test for this to avoid generating
5415 incorrect code below. */
5416 result
= const_binop (BIT_AND_EXPR
, ll_mask
, rl_mask
);
5417 if (! integer_zerop (result
)
5418 && simple_cst_equal (const_binop (BIT_AND_EXPR
, result
, l_const
),
5419 const_binop (BIT_AND_EXPR
, result
, r_const
)) != 1)
5421 if (wanted_code
== NE_EXPR
)
5423 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5424 return constant_boolean_node (true, truth_type
);
5428 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5429 return constant_boolean_node (false, truth_type
);
5433 /* Construct the expression we will return. First get the component
5434 reference we will make. Unless the mask is all ones the width of
5435 that field, perform the mask operation. Then compare with the
5437 result
= make_bit_field_ref (loc
, ll_inner
, lntype
, lnbitsize
, lnbitpos
,
5438 ll_unsignedp
|| rl_unsignedp
);
5440 ll_mask
= const_binop (BIT_IOR_EXPR
, ll_mask
, rl_mask
);
5441 if (! all_ones_mask_p (ll_mask
, lnbitsize
))
5442 result
= build2_loc (loc
, BIT_AND_EXPR
, lntype
, result
, ll_mask
);
5444 return build2_loc (loc
, wanted_code
, truth_type
, result
,
5445 const_binop (BIT_IOR_EXPR
, l_const
, r_const
));
5448 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5452 optimize_minmax_comparison (location_t loc
, enum tree_code code
, tree type
,
5456 enum tree_code op_code
;
5459 int consts_equal
, consts_lt
;
5462 STRIP_SIGN_NOPS (arg0
);
5464 op_code
= TREE_CODE (arg0
);
5465 minmax_const
= TREE_OPERAND (arg0
, 1);
5466 comp_const
= fold_convert_loc (loc
, TREE_TYPE (arg0
), op1
);
5467 consts_equal
= tree_int_cst_equal (minmax_const
, comp_const
);
5468 consts_lt
= tree_int_cst_lt (minmax_const
, comp_const
);
5469 inner
= TREE_OPERAND (arg0
, 0);
5471 /* If something does not permit us to optimize, return the original tree. */
5472 if ((op_code
!= MIN_EXPR
&& op_code
!= MAX_EXPR
)
5473 || TREE_CODE (comp_const
) != INTEGER_CST
5474 || TREE_OVERFLOW (comp_const
)
5475 || TREE_CODE (minmax_const
) != INTEGER_CST
5476 || TREE_OVERFLOW (minmax_const
))
5479 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5480 and GT_EXPR, doing the rest with recursive calls using logical
5484 case NE_EXPR
: case LT_EXPR
: case LE_EXPR
:
5487 = optimize_minmax_comparison (loc
,
5488 invert_tree_comparison (code
, false),
5491 return invert_truthvalue_loc (loc
, tem
);
5497 fold_build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
5498 optimize_minmax_comparison
5499 (loc
, EQ_EXPR
, type
, arg0
, comp_const
),
5500 optimize_minmax_comparison
5501 (loc
, GT_EXPR
, type
, arg0
, comp_const
));
5504 if (op_code
== MAX_EXPR
&& consts_equal
)
5505 /* MAX (X, 0) == 0 -> X <= 0 */
5506 return fold_build2_loc (loc
, LE_EXPR
, type
, inner
, comp_const
);
5508 else if (op_code
== MAX_EXPR
&& consts_lt
)
5509 /* MAX (X, 0) == 5 -> X == 5 */
5510 return fold_build2_loc (loc
, EQ_EXPR
, type
, inner
, comp_const
);
5512 else if (op_code
== MAX_EXPR
)
5513 /* MAX (X, 0) == -1 -> false */
5514 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5516 else if (consts_equal
)
5517 /* MIN (X, 0) == 0 -> X >= 0 */
5518 return fold_build2_loc (loc
, GE_EXPR
, type
, inner
, comp_const
);
5521 /* MIN (X, 0) == 5 -> false */
5522 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5525 /* MIN (X, 0) == -1 -> X == -1 */
5526 return fold_build2_loc (loc
, EQ_EXPR
, type
, inner
, comp_const
);
5529 if (op_code
== MAX_EXPR
&& (consts_equal
|| consts_lt
))
5530 /* MAX (X, 0) > 0 -> X > 0
5531 MAX (X, 0) > 5 -> X > 5 */
5532 return fold_build2_loc (loc
, GT_EXPR
, type
, inner
, comp_const
);
5534 else if (op_code
== MAX_EXPR
)
5535 /* MAX (X, 0) > -1 -> true */
5536 return omit_one_operand_loc (loc
, type
, integer_one_node
, inner
);
5538 else if (op_code
== MIN_EXPR
&& (consts_equal
|| consts_lt
))
5539 /* MIN (X, 0) > 0 -> false
5540 MIN (X, 0) > 5 -> false */
5541 return omit_one_operand_loc (loc
, type
, integer_zero_node
, inner
);
5544 /* MIN (X, 0) > -1 -> X > -1 */
5545 return fold_build2_loc (loc
, GT_EXPR
, type
, inner
, comp_const
);
5552 /* T is an integer expression that is being multiplied, divided, or taken a
5553 modulus (CODE says which and what kind of divide or modulus) by a
5554 constant C. See if we can eliminate that operation by folding it with
5555 other operations already in T. WIDE_TYPE, if non-null, is a type that
5556 should be used for the computation if wider than our type.
5558 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5559 (X * 2) + (Y * 4). We must, however, be assured that either the original
5560 expression would not overflow or that overflow is undefined for the type
5561 in the language in question.
5563 If we return a non-null expression, it is an equivalent form of the
5564 original computation, but need not be in the original type.
5566 We set *STRICT_OVERFLOW_P to true if the return values depends on
5567 signed overflow being undefined. Otherwise we do not change
5568 *STRICT_OVERFLOW_P. */
5571 extract_muldiv (tree t
, tree c
, enum tree_code code
, tree wide_type
,
5572 bool *strict_overflow_p
)
5574 /* To avoid exponential search depth, refuse to allow recursion past
5575 three levels. Beyond that (1) it's highly unlikely that we'll find
5576 something interesting and (2) we've probably processed it before
5577 when we built the inner expression. */
5586 ret
= extract_muldiv_1 (t
, c
, code
, wide_type
, strict_overflow_p
);
5593 extract_muldiv_1 (tree t
, tree c
, enum tree_code code
, tree wide_type
,
5594 bool *strict_overflow_p
)
5596 tree type
= TREE_TYPE (t
);
5597 enum tree_code tcode
= TREE_CODE (t
);
5598 tree ctype
= (wide_type
!= 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type
))
5599 > GET_MODE_SIZE (TYPE_MODE (type
)))
5600 ? wide_type
: type
);
5602 int same_p
= tcode
== code
;
5603 tree op0
= NULL_TREE
, op1
= NULL_TREE
;
5604 bool sub_strict_overflow_p
;
5606 /* Don't deal with constants of zero here; they confuse the code below. */
5607 if (integer_zerop (c
))
5610 if (TREE_CODE_CLASS (tcode
) == tcc_unary
)
5611 op0
= TREE_OPERAND (t
, 0);
5613 if (TREE_CODE_CLASS (tcode
) == tcc_binary
)
5614 op0
= TREE_OPERAND (t
, 0), op1
= TREE_OPERAND (t
, 1);
5616 /* Note that we need not handle conditional operations here since fold
5617 already handles those cases. So just do arithmetic here. */
5621 /* For a constant, we can always simplify if we are a multiply
5622 or (for divide and modulus) if it is a multiple of our constant. */
5623 if (code
== MULT_EXPR
5624 || integer_zerop (const_binop (TRUNC_MOD_EXPR
, t
, c
)))
5625 return const_binop (code
, fold_convert (ctype
, t
),
5626 fold_convert (ctype
, c
));
5629 CASE_CONVERT
: case NON_LVALUE_EXPR
:
5630 /* If op0 is an expression ... */
5631 if ((COMPARISON_CLASS_P (op0
)
5632 || UNARY_CLASS_P (op0
)
5633 || BINARY_CLASS_P (op0
)
5634 || VL_EXP_CLASS_P (op0
)
5635 || EXPRESSION_CLASS_P (op0
))
5636 /* ... and has wrapping overflow, and its type is smaller
5637 than ctype, then we cannot pass through as widening. */
5638 && ((TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0
))
5639 && (TYPE_PRECISION (ctype
)
5640 > TYPE_PRECISION (TREE_TYPE (op0
))))
5641 /* ... or this is a truncation (t is narrower than op0),
5642 then we cannot pass through this narrowing. */
5643 || (TYPE_PRECISION (type
)
5644 < TYPE_PRECISION (TREE_TYPE (op0
)))
5645 /* ... or signedness changes for division or modulus,
5646 then we cannot pass through this conversion. */
5647 || (code
!= MULT_EXPR
5648 && (TYPE_UNSIGNED (ctype
)
5649 != TYPE_UNSIGNED (TREE_TYPE (op0
))))
5650 /* ... or has undefined overflow while the converted to
5651 type has not, we cannot do the operation in the inner type
5652 as that would introduce undefined overflow. */
5653 || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0
))
5654 && !TYPE_OVERFLOW_UNDEFINED (type
))))
5657 /* Pass the constant down and see if we can make a simplification. If
5658 we can, replace this expression with the inner simplification for
5659 possible later conversion to our or some other type. */
5660 if ((t2
= fold_convert (TREE_TYPE (op0
), c
)) != 0
5661 && TREE_CODE (t2
) == INTEGER_CST
5662 && !TREE_OVERFLOW (t2
)
5663 && (0 != (t1
= extract_muldiv (op0
, t2
, code
,
5665 ? ctype
: NULL_TREE
,
5666 strict_overflow_p
))))
5671 /* If widening the type changes it from signed to unsigned, then we
5672 must avoid building ABS_EXPR itself as unsigned. */
5673 if (TYPE_UNSIGNED (ctype
) && !TYPE_UNSIGNED (type
))
5675 tree cstype
= (*signed_type_for
) (ctype
);
5676 if ((t1
= extract_muldiv (op0
, c
, code
, cstype
, strict_overflow_p
))
5679 t1
= fold_build1 (tcode
, cstype
, fold_convert (cstype
, t1
));
5680 return fold_convert (ctype
, t1
);
5684 /* If the constant is negative, we cannot simplify this. */
5685 if (tree_int_cst_sgn (c
) == -1)
5689 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
, strict_overflow_p
))
5691 return fold_build1 (tcode
, ctype
, fold_convert (ctype
, t1
));
5694 case MIN_EXPR
: case MAX_EXPR
:
5695 /* If widening the type changes the signedness, then we can't perform
5696 this optimization as that changes the result. */
5697 if (TYPE_UNSIGNED (ctype
) != TYPE_UNSIGNED (type
))
5700 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
5701 sub_strict_overflow_p
= false;
5702 if ((t1
= extract_muldiv (op0
, c
, code
, wide_type
,
5703 &sub_strict_overflow_p
)) != 0
5704 && (t2
= extract_muldiv (op1
, c
, code
, wide_type
,
5705 &sub_strict_overflow_p
)) != 0)
5707 if (tree_int_cst_sgn (c
) < 0)
5708 tcode
= (tcode
== MIN_EXPR
? MAX_EXPR
: MIN_EXPR
);
5709 if (sub_strict_overflow_p
)
5710 *strict_overflow_p
= true;
5711 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
5712 fold_convert (ctype
, t2
));
5716 case LSHIFT_EXPR
: case RSHIFT_EXPR
:
5717 /* If the second operand is constant, this is a multiplication
5718 or floor division, by a power of two, so we can treat it that
5719 way unless the multiplier or divisor overflows. Signed
5720 left-shift overflow is implementation-defined rather than
5721 undefined in C90, so do not convert signed left shift into
5723 if (TREE_CODE (op1
) == INTEGER_CST
5724 && (tcode
== RSHIFT_EXPR
|| TYPE_UNSIGNED (TREE_TYPE (op0
)))
5725 /* const_binop may not detect overflow correctly,
5726 so check for it explicitly here. */
5727 && TYPE_PRECISION (TREE_TYPE (size_one_node
)) > TREE_INT_CST_LOW (op1
)
5728 && TREE_INT_CST_HIGH (op1
) == 0
5729 && 0 != (t1
= fold_convert (ctype
,
5730 const_binop (LSHIFT_EXPR
,
5733 && !TREE_OVERFLOW (t1
))
5734 return extract_muldiv (build2 (tcode
== LSHIFT_EXPR
5735 ? MULT_EXPR
: FLOOR_DIV_EXPR
,
5737 fold_convert (ctype
, op0
),
5739 c
, code
, wide_type
, strict_overflow_p
);
5742 case PLUS_EXPR
: case MINUS_EXPR
:
5743 /* See if we can eliminate the operation on both sides. If we can, we
5744 can return a new PLUS or MINUS. If we can't, the only remaining
5745 cases where we can do anything are if the second operand is a
5747 sub_strict_overflow_p
= false;
5748 t1
= extract_muldiv (op0
, c
, code
, wide_type
, &sub_strict_overflow_p
);
5749 t2
= extract_muldiv (op1
, c
, code
, wide_type
, &sub_strict_overflow_p
);
5750 if (t1
!= 0 && t2
!= 0
5751 && (code
== MULT_EXPR
5752 /* If not multiplication, we can only do this if both operands
5753 are divisible by c. */
5754 || (multiple_of_p (ctype
, op0
, c
)
5755 && multiple_of_p (ctype
, op1
, c
))))
5757 if (sub_strict_overflow_p
)
5758 *strict_overflow_p
= true;
5759 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
5760 fold_convert (ctype
, t2
));
5763 /* If this was a subtraction, negate OP1 and set it to be an addition.
5764 This simplifies the logic below. */
5765 if (tcode
== MINUS_EXPR
)
5767 tcode
= PLUS_EXPR
, op1
= negate_expr (op1
);
5768 /* If OP1 was not easily negatable, the constant may be OP0. */
5769 if (TREE_CODE (op0
) == INTEGER_CST
)
5780 if (TREE_CODE (op1
) != INTEGER_CST
)
5783 /* If either OP1 or C are negative, this optimization is not safe for
5784 some of the division and remainder types while for others we need
5785 to change the code. */
5786 if (tree_int_cst_sgn (op1
) < 0 || tree_int_cst_sgn (c
) < 0)
5788 if (code
== CEIL_DIV_EXPR
)
5789 code
= FLOOR_DIV_EXPR
;
5790 else if (code
== FLOOR_DIV_EXPR
)
5791 code
= CEIL_DIV_EXPR
;
5792 else if (code
!= MULT_EXPR
5793 && code
!= CEIL_MOD_EXPR
&& code
!= FLOOR_MOD_EXPR
)
5797 /* If it's a multiply or a division/modulus operation of a multiple
5798 of our constant, do the operation and verify it doesn't overflow. */
5799 if (code
== MULT_EXPR
5800 || integer_zerop (const_binop (TRUNC_MOD_EXPR
, op1
, c
)))
5802 op1
= const_binop (code
, fold_convert (ctype
, op1
),
5803 fold_convert (ctype
, c
));
5804 /* We allow the constant to overflow with wrapping semantics. */
5806 || (TREE_OVERFLOW (op1
) && !TYPE_OVERFLOW_WRAPS (ctype
)))
5812 /* If we have an unsigned type is not a sizetype, we cannot widen
5813 the operation since it will change the result if the original
5814 computation overflowed. */
5815 if (TYPE_UNSIGNED (ctype
)
5819 /* If we were able to eliminate our operation from the first side,
5820 apply our operation to the second side and reform the PLUS. */
5821 if (t1
!= 0 && (TREE_CODE (t1
) != code
|| code
== MULT_EXPR
))
5822 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
), op1
);
5824 /* The last case is if we are a multiply. In that case, we can
5825 apply the distributive law to commute the multiply and addition
5826 if the multiplication of the constants doesn't overflow. */
5827 if (code
== MULT_EXPR
)
5828 return fold_build2 (tcode
, ctype
,
5829 fold_build2 (code
, ctype
,
5830 fold_convert (ctype
, op0
),
5831 fold_convert (ctype
, c
)),
5837 /* We have a special case here if we are doing something like
5838 (C * 8) % 4 since we know that's zero. */
5839 if ((code
== TRUNC_MOD_EXPR
|| code
== CEIL_MOD_EXPR
5840 || code
== FLOOR_MOD_EXPR
|| code
== ROUND_MOD_EXPR
)
5841 /* If the multiplication can overflow we cannot optimize this. */
5842 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t
))
5843 && TREE_CODE (TREE_OPERAND (t
, 1)) == INTEGER_CST
5844 && integer_zerop (const_binop (TRUNC_MOD_EXPR
, op1
, c
)))
5846 *strict_overflow_p
= true;
5847 return omit_one_operand (type
, integer_zero_node
, op0
);
5850 /* ... fall through ... */
5852 case TRUNC_DIV_EXPR
: case CEIL_DIV_EXPR
: case FLOOR_DIV_EXPR
:
5853 case ROUND_DIV_EXPR
: case EXACT_DIV_EXPR
:
5854 /* If we can extract our operation from the LHS, do so and return a
5855 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
5856 do something only if the second operand is a constant. */
5858 && (t1
= extract_muldiv (op0
, c
, code
, wide_type
,
5859 strict_overflow_p
)) != 0)
5860 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, t1
),
5861 fold_convert (ctype
, op1
));
5862 else if (tcode
== MULT_EXPR
&& code
== MULT_EXPR
5863 && (t1
= extract_muldiv (op1
, c
, code
, wide_type
,
5864 strict_overflow_p
)) != 0)
5865 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
5866 fold_convert (ctype
, t1
));
5867 else if (TREE_CODE (op1
) != INTEGER_CST
)
5870 /* If these are the same operation types, we can associate them
5871 assuming no overflow. */
5876 unsigned prec
= TYPE_PRECISION (ctype
);
5877 bool uns
= TYPE_UNSIGNED (ctype
);
5878 double_int diop1
= tree_to_double_int (op1
).ext (prec
, uns
);
5879 double_int dic
= tree_to_double_int (c
).ext (prec
, uns
);
5880 mul
= diop1
.mul_with_sign (dic
, false, &overflow_p
);
5881 overflow_p
= ((!uns
&& overflow_p
)
5882 | TREE_OVERFLOW (c
) | TREE_OVERFLOW (op1
));
5883 if (!double_int_fits_to_tree_p (ctype
, mul
)
5884 && ((uns
&& tcode
!= MULT_EXPR
) || !uns
))
5887 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
5888 double_int_to_tree (ctype
, mul
));
5891 /* If these operations "cancel" each other, we have the main
5892 optimizations of this pass, which occur when either constant is a
5893 multiple of the other, in which case we replace this with either an
5894 operation or CODE or TCODE.
5896 If we have an unsigned type, we cannot do this since it will change
5897 the result if the original computation overflowed. */
5898 if (TYPE_OVERFLOW_UNDEFINED (ctype
)
5899 && ((code
== MULT_EXPR
&& tcode
== EXACT_DIV_EXPR
)
5900 || (tcode
== MULT_EXPR
5901 && code
!= TRUNC_MOD_EXPR
&& code
!= CEIL_MOD_EXPR
5902 && code
!= FLOOR_MOD_EXPR
&& code
!= ROUND_MOD_EXPR
5903 && code
!= MULT_EXPR
)))
5905 if (integer_zerop (const_binop (TRUNC_MOD_EXPR
, op1
, c
)))
5907 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
5908 *strict_overflow_p
= true;
5909 return fold_build2 (tcode
, ctype
, fold_convert (ctype
, op0
),
5910 fold_convert (ctype
,
5911 const_binop (TRUNC_DIV_EXPR
,
5914 else if (integer_zerop (const_binop (TRUNC_MOD_EXPR
, c
, op1
)))
5916 if (TYPE_OVERFLOW_UNDEFINED (ctype
))
5917 *strict_overflow_p
= true;
5918 return fold_build2 (code
, ctype
, fold_convert (ctype
, op0
),
5919 fold_convert (ctype
,
5920 const_binop (TRUNC_DIV_EXPR
,
5933 /* Return a node which has the indicated constant VALUE (either 0 or
5934 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
5935 and is of the indicated TYPE. */
5938 constant_boolean_node (bool value
, tree type
)
5940 if (type
== integer_type_node
)
5941 return value
? integer_one_node
: integer_zero_node
;
5942 else if (type
== boolean_type_node
)
5943 return value
? boolean_true_node
: boolean_false_node
;
5944 else if (TREE_CODE (type
) == VECTOR_TYPE
)
5945 return build_vector_from_val (type
,
5946 build_int_cst (TREE_TYPE (type
),
5949 return fold_convert (type
, value
? integer_one_node
: integer_zero_node
);
5953 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
5954 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
5955 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
5956 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
5957 COND is the first argument to CODE; otherwise (as in the example
5958 given here), it is the second argument. TYPE is the type of the
5959 original expression. Return NULL_TREE if no simplification is
5963 fold_binary_op_with_conditional_arg (location_t loc
,
5964 enum tree_code code
,
5965 tree type
, tree op0
, tree op1
,
5966 tree cond
, tree arg
, int cond_first_p
)
5968 tree cond_type
= cond_first_p
? TREE_TYPE (op0
) : TREE_TYPE (op1
);
5969 tree arg_type
= cond_first_p
? TREE_TYPE (op1
) : TREE_TYPE (op0
);
5970 tree test
, true_value
, false_value
;
5971 tree lhs
= NULL_TREE
;
5972 tree rhs
= NULL_TREE
;
5973 enum tree_code cond_code
= COND_EXPR
;
5975 if (TREE_CODE (cond
) == COND_EXPR
5976 || TREE_CODE (cond
) == VEC_COND_EXPR
)
5978 test
= TREE_OPERAND (cond
, 0);
5979 true_value
= TREE_OPERAND (cond
, 1);
5980 false_value
= TREE_OPERAND (cond
, 2);
5981 /* If this operand throws an expression, then it does not make
5982 sense to try to perform a logical or arithmetic operation
5984 if (VOID_TYPE_P (TREE_TYPE (true_value
)))
5986 if (VOID_TYPE_P (TREE_TYPE (false_value
)))
5991 tree testtype
= TREE_TYPE (cond
);
5993 true_value
= constant_boolean_node (true, testtype
);
5994 false_value
= constant_boolean_node (false, testtype
);
5997 if (TREE_CODE (TREE_TYPE (test
)) == VECTOR_TYPE
)
5998 cond_code
= VEC_COND_EXPR
;
6000 /* This transformation is only worthwhile if we don't have to wrap ARG
6001 in a SAVE_EXPR and the operation can be simplified without recursing
6002 on at least one of the branches once its pushed inside the COND_EXPR. */
6003 if (!TREE_CONSTANT (arg
)
6004 && (TREE_SIDE_EFFECTS (arg
)
6005 || TREE_CODE (arg
) == COND_EXPR
|| TREE_CODE (arg
) == VEC_COND_EXPR
6006 || TREE_CONSTANT (true_value
) || TREE_CONSTANT (false_value
)))
6009 arg
= fold_convert_loc (loc
, arg_type
, arg
);
6012 true_value
= fold_convert_loc (loc
, cond_type
, true_value
);
6014 lhs
= fold_build2_loc (loc
, code
, type
, true_value
, arg
);
6016 lhs
= fold_build2_loc (loc
, code
, type
, arg
, true_value
);
6020 false_value
= fold_convert_loc (loc
, cond_type
, false_value
);
6022 rhs
= fold_build2_loc (loc
, code
, type
, false_value
, arg
);
6024 rhs
= fold_build2_loc (loc
, code
, type
, arg
, false_value
);
6027 /* Check that we have simplified at least one of the branches. */
6028 if (!TREE_CONSTANT (arg
) && !TREE_CONSTANT (lhs
) && !TREE_CONSTANT (rhs
))
6031 return fold_build3_loc (loc
, cond_code
, type
, test
, lhs
, rhs
);
6035 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6037 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6038 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6039 ADDEND is the same as X.
6041 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6042 and finite. The problematic cases are when X is zero, and its mode
6043 has signed zeros. In the case of rounding towards -infinity,
6044 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6045 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6048 fold_real_zero_addition_p (const_tree type
, const_tree addend
, int negate
)
6050 if (!real_zerop (addend
))
6053 /* Don't allow the fold with -fsignaling-nans. */
6054 if (HONOR_SNANS (TYPE_MODE (type
)))
6057 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6058 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
6061 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6062 if (TREE_CODE (addend
) == REAL_CST
6063 && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend
)))
6066 /* The mode has signed zeros, and we have to honor their sign.
6067 In this situation, there is only one case we can return true for.
6068 X - 0 is the same as X unless rounding towards -infinity is
6070 return negate
&& !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type
));
6073 /* Subroutine of fold() that checks comparisons of built-in math
6074 functions against real constants.
6076 FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6077 operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR. TYPE
6078 is the type of the result and ARG0 and ARG1 are the operands of the
6079 comparison. ARG1 must be a TREE_REAL_CST.
6081 The function returns the constant folded tree if a simplification
6082 can be made, and NULL_TREE otherwise. */
6085 fold_mathfn_compare (location_t loc
,
6086 enum built_in_function fcode
, enum tree_code code
,
6087 tree type
, tree arg0
, tree arg1
)
6091 if (BUILTIN_SQRT_P (fcode
))
6093 tree arg
= CALL_EXPR_ARG (arg0
, 0);
6094 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (arg0
));
6096 c
= TREE_REAL_CST (arg1
);
6097 if (REAL_VALUE_NEGATIVE (c
))
6099 /* sqrt(x) < y is always false, if y is negative. */
6100 if (code
== EQ_EXPR
|| code
== LT_EXPR
|| code
== LE_EXPR
)
6101 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
6103 /* sqrt(x) > y is always true, if y is negative and we
6104 don't care about NaNs, i.e. negative values of x. */
6105 if (code
== NE_EXPR
|| !HONOR_NANS (mode
))
6106 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
6108 /* sqrt(x) > y is the same as x >= 0, if y is negative. */
6109 return fold_build2_loc (loc
, GE_EXPR
, type
, arg
,
6110 build_real (TREE_TYPE (arg
), dconst0
));
6112 else if (code
== GT_EXPR
|| code
== GE_EXPR
)
6116 REAL_ARITHMETIC (c2
, MULT_EXPR
, c
, c
);
6117 real_convert (&c2
, mode
, &c2
);
6119 if (REAL_VALUE_ISINF (c2
))
6121 /* sqrt(x) > y is x == +Inf, when y is very large. */
6122 if (HONOR_INFINITIES (mode
))
6123 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg
,
6124 build_real (TREE_TYPE (arg
), c2
));
6126 /* sqrt(x) > y is always false, when y is very large
6127 and we don't care about infinities. */
6128 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg
);
6131 /* sqrt(x) > c is the same as x > c*c. */
6132 return fold_build2_loc (loc
, code
, type
, arg
,
6133 build_real (TREE_TYPE (arg
), c2
));
6135 else if (code
== LT_EXPR
|| code
== LE_EXPR
)
6139 REAL_ARITHMETIC (c2
, MULT_EXPR
, c
, c
);
6140 real_convert (&c2
, mode
, &c2
);
6142 if (REAL_VALUE_ISINF (c2
))
6144 /* sqrt(x) < y is always true, when y is a very large
6145 value and we don't care about NaNs or Infinities. */
6146 if (! HONOR_NANS (mode
) && ! HONOR_INFINITIES (mode
))
6147 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg
);
6149 /* sqrt(x) < y is x != +Inf when y is very large and we
6150 don't care about NaNs. */
6151 if (! HONOR_NANS (mode
))
6152 return fold_build2_loc (loc
, NE_EXPR
, type
, arg
,
6153 build_real (TREE_TYPE (arg
), c2
));
6155 /* sqrt(x) < y is x >= 0 when y is very large and we
6156 don't care about Infinities. */
6157 if (! HONOR_INFINITIES (mode
))
6158 return fold_build2_loc (loc
, GE_EXPR
, type
, arg
,
6159 build_real (TREE_TYPE (arg
), dconst0
));
6161 /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large. */
6162 arg
= save_expr (arg
);
6163 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
6164 fold_build2_loc (loc
, GE_EXPR
, type
, arg
,
6165 build_real (TREE_TYPE (arg
),
6167 fold_build2_loc (loc
, NE_EXPR
, type
, arg
,
6168 build_real (TREE_TYPE (arg
),
6172 /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs. */
6173 if (! HONOR_NANS (mode
))
6174 return fold_build2_loc (loc
, code
, type
, arg
,
6175 build_real (TREE_TYPE (arg
), c2
));
6177 /* sqrt(x) < c is the same as x >= 0 && x < c*c. */
6178 arg
= save_expr (arg
);
6179 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
6180 fold_build2_loc (loc
, GE_EXPR
, type
, arg
,
6181 build_real (TREE_TYPE (arg
),
6183 fold_build2_loc (loc
, code
, type
, arg
,
6184 build_real (TREE_TYPE (arg
),
6192 /* Subroutine of fold() that optimizes comparisons against Infinities,
6193 either +Inf or -Inf.
6195 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6196 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6197 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6199 The function returns the constant folded tree if a simplification
6200 can be made, and NULL_TREE otherwise. */
6203 fold_inf_compare (location_t loc
, enum tree_code code
, tree type
,
6204 tree arg0
, tree arg1
)
6206 enum machine_mode mode
;
6207 REAL_VALUE_TYPE max
;
6211 mode
= TYPE_MODE (TREE_TYPE (arg0
));
6213 /* For negative infinity swap the sense of the comparison. */
6214 neg
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
));
6216 code
= swap_tree_comparison (code
);
6221 /* x > +Inf is always false, if with ignore sNANs. */
6222 if (HONOR_SNANS (mode
))
6224 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6227 /* x <= +Inf is always true, if we don't case about NaNs. */
6228 if (! HONOR_NANS (mode
))
6229 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6231 /* x <= +Inf is the same as x == x, i.e. isfinite(x). */
6232 arg0
= save_expr (arg0
);
6233 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
, arg0
);
6237 /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX. */
6238 real_maxval (&max
, neg
, mode
);
6239 return fold_build2_loc (loc
, neg
? LT_EXPR
: GT_EXPR
, type
,
6240 arg0
, build_real (TREE_TYPE (arg0
), max
));
6243 /* x < +Inf is always equal to x <= DBL_MAX. */
6244 real_maxval (&max
, neg
, mode
);
6245 return fold_build2_loc (loc
, neg
? GE_EXPR
: LE_EXPR
, type
,
6246 arg0
, build_real (TREE_TYPE (arg0
), max
));
6249 /* x != +Inf is always equal to !(x > DBL_MAX). */
6250 real_maxval (&max
, neg
, mode
);
6251 if (! HONOR_NANS (mode
))
6252 return fold_build2_loc (loc
, neg
? GE_EXPR
: LE_EXPR
, type
,
6253 arg0
, build_real (TREE_TYPE (arg0
), max
));
6255 temp
= fold_build2_loc (loc
, neg
? LT_EXPR
: GT_EXPR
, type
,
6256 arg0
, build_real (TREE_TYPE (arg0
), max
));
6257 return fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, temp
);
6266 /* Subroutine of fold() that optimizes comparisons of a division by
6267 a nonzero integer constant against an integer constant, i.e.
6270 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6271 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6272 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6274 The function returns the constant folded tree if a simplification
6275 can be made, and NULL_TREE otherwise. */
6278 fold_div_compare (location_t loc
,
6279 enum tree_code code
, tree type
, tree arg0
, tree arg1
)
6281 tree prod
, tmp
, hi
, lo
;
6282 tree arg00
= TREE_OPERAND (arg0
, 0);
6283 tree arg01
= TREE_OPERAND (arg0
, 1);
6285 bool unsigned_p
= TYPE_UNSIGNED (TREE_TYPE (arg0
));
6289 /* We have to do this the hard way to detect unsigned overflow.
6290 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6291 val
= TREE_INT_CST (arg01
)
6292 .mul_with_sign (TREE_INT_CST (arg1
), unsigned_p
, &overflow
);
6293 prod
= force_fit_type_double (TREE_TYPE (arg00
), val
, -1, overflow
);
6294 neg_overflow
= false;
6298 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6299 build_int_cst (TREE_TYPE (arg01
), 1));
6302 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6303 val
= TREE_INT_CST (prod
)
6304 .add_with_sign (TREE_INT_CST (tmp
), unsigned_p
, &overflow
);
6305 hi
= force_fit_type_double (TREE_TYPE (arg00
), val
,
6306 -1, overflow
| TREE_OVERFLOW (prod
));
6308 else if (tree_int_cst_sgn (arg01
) >= 0)
6310 tmp
= int_const_binop (MINUS_EXPR
, arg01
,
6311 build_int_cst (TREE_TYPE (arg01
), 1));
6312 switch (tree_int_cst_sgn (arg1
))
6315 neg_overflow
= true;
6316 lo
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6321 lo
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6326 hi
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6336 /* A negative divisor reverses the relational operators. */
6337 code
= swap_tree_comparison (code
);
6339 tmp
= int_const_binop (PLUS_EXPR
, arg01
,
6340 build_int_cst (TREE_TYPE (arg01
), 1));
6341 switch (tree_int_cst_sgn (arg1
))
6344 hi
= int_const_binop (MINUS_EXPR
, prod
, tmp
);
6349 hi
= fold_negate_const (tmp
, TREE_TYPE (arg0
));
6354 neg_overflow
= true;
6355 lo
= int_const_binop (PLUS_EXPR
, prod
, tmp
);
6367 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6368 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg00
);
6369 if (TREE_OVERFLOW (hi
))
6370 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6371 if (TREE_OVERFLOW (lo
))
6372 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6373 return build_range_check (loc
, type
, arg00
, 1, lo
, hi
);
6376 if (TREE_OVERFLOW (lo
) && TREE_OVERFLOW (hi
))
6377 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg00
);
6378 if (TREE_OVERFLOW (hi
))
6379 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6380 if (TREE_OVERFLOW (lo
))
6381 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6382 return build_range_check (loc
, type
, arg00
, 0, lo
, hi
);
6385 if (TREE_OVERFLOW (lo
))
6387 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6388 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6390 return fold_build2_loc (loc
, LT_EXPR
, type
, arg00
, lo
);
6393 if (TREE_OVERFLOW (hi
))
6395 tmp
= neg_overflow
? integer_zero_node
: integer_one_node
;
6396 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6398 return fold_build2_loc (loc
, LE_EXPR
, type
, arg00
, hi
);
6401 if (TREE_OVERFLOW (hi
))
6403 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6404 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6406 return fold_build2_loc (loc
, GT_EXPR
, type
, arg00
, hi
);
6409 if (TREE_OVERFLOW (lo
))
6411 tmp
= neg_overflow
? integer_one_node
: integer_zero_node
;
6412 return omit_one_operand_loc (loc
, type
, tmp
, arg00
);
6414 return fold_build2_loc (loc
, GE_EXPR
, type
, arg00
, lo
);
6424 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6425 equality/inequality test, then return a simplified form of the test
6426 using a sign testing. Otherwise return NULL. TYPE is the desired
6430 fold_single_bit_test_into_sign_test (location_t loc
,
6431 enum tree_code code
, tree arg0
, tree arg1
,
6434 /* If this is testing a single bit, we can optimize the test. */
6435 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6436 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6437 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6439 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6440 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6441 tree arg00
= sign_bit_p (TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1));
6443 if (arg00
!= NULL_TREE
6444 /* This is only a win if casting to a signed type is cheap,
6445 i.e. when arg00's type is not a partial mode. */
6446 && TYPE_PRECISION (TREE_TYPE (arg00
))
6447 == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00
))))
6449 tree stype
= signed_type_for (TREE_TYPE (arg00
));
6450 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
6452 fold_convert_loc (loc
, stype
, arg00
),
6453 build_int_cst (stype
, 0));
6460 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6461 equality/inequality test, then return a simplified form of
6462 the test using shifts and logical operations. Otherwise return
6463 NULL. TYPE is the desired result type. */
6466 fold_single_bit_test (location_t loc
, enum tree_code code
,
6467 tree arg0
, tree arg1
, tree result_type
)
6469 /* If this is testing a single bit, we can optimize the test. */
6470 if ((code
== NE_EXPR
|| code
== EQ_EXPR
)
6471 && TREE_CODE (arg0
) == BIT_AND_EXPR
&& integer_zerop (arg1
)
6472 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
6474 tree inner
= TREE_OPERAND (arg0
, 0);
6475 tree type
= TREE_TYPE (arg0
);
6476 int bitnum
= tree_log2 (TREE_OPERAND (arg0
, 1));
6477 enum machine_mode operand_mode
= TYPE_MODE (type
);
6479 tree signed_type
, unsigned_type
, intermediate_type
;
6482 /* First, see if we can fold the single bit test into a sign-bit
6484 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
,
6489 /* Otherwise we have (A & C) != 0 where C is a single bit,
6490 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6491 Similarly for (A & C) == 0. */
6493 /* If INNER is a right shift of a constant and it plus BITNUM does
6494 not overflow, adjust BITNUM and INNER. */
6495 if (TREE_CODE (inner
) == RSHIFT_EXPR
6496 && TREE_CODE (TREE_OPERAND (inner
, 1)) == INTEGER_CST
6497 && TREE_INT_CST_HIGH (TREE_OPERAND (inner
, 1)) == 0
6498 && bitnum
< TYPE_PRECISION (type
)
6499 && 0 > compare_tree_int (TREE_OPERAND (inner
, 1),
6500 bitnum
- TYPE_PRECISION (type
)))
6502 bitnum
+= TREE_INT_CST_LOW (TREE_OPERAND (inner
, 1));
6503 inner
= TREE_OPERAND (inner
, 0);
6506 /* If we are going to be able to omit the AND below, we must do our
6507 operations as unsigned. If we must use the AND, we have a choice.
6508 Normally unsigned is faster, but for some machines signed is. */
6509 #ifdef LOAD_EXTEND_OP
6510 ops_unsigned
= (LOAD_EXTEND_OP (operand_mode
) == SIGN_EXTEND
6511 && !flag_syntax_only
) ? 0 : 1;
6516 signed_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 0);
6517 unsigned_type
= lang_hooks
.types
.type_for_mode (operand_mode
, 1);
6518 intermediate_type
= ops_unsigned
? unsigned_type
: signed_type
;
6519 inner
= fold_convert_loc (loc
, intermediate_type
, inner
);
6522 inner
= build2 (RSHIFT_EXPR
, intermediate_type
,
6523 inner
, size_int (bitnum
));
6525 one
= build_int_cst (intermediate_type
, 1);
6527 if (code
== EQ_EXPR
)
6528 inner
= fold_build2_loc (loc
, BIT_XOR_EXPR
, intermediate_type
, inner
, one
);
6530 /* Put the AND last so it can combine with more things. */
6531 inner
= build2 (BIT_AND_EXPR
, intermediate_type
, inner
, one
);
6533 /* Make sure to return the proper type. */
6534 inner
= fold_convert_loc (loc
, result_type
, inner
);
6541 /* Check whether we are allowed to reorder operands arg0 and arg1,
6542 such that the evaluation of arg1 occurs before arg0. */
6545 reorder_operands_p (const_tree arg0
, const_tree arg1
)
6547 if (! flag_evaluation_order
)
6549 if (TREE_CONSTANT (arg0
) || TREE_CONSTANT (arg1
))
6551 return ! TREE_SIDE_EFFECTS (arg0
)
6552 && ! TREE_SIDE_EFFECTS (arg1
);
6555 /* Test whether it is preferable two swap two operands, ARG0 and
6556 ARG1, for example because ARG0 is an integer constant and ARG1
6557 isn't. If REORDER is true, only recommend swapping if we can
6558 evaluate the operands in reverse order. */
6561 tree_swap_operands_p (const_tree arg0
, const_tree arg1
, bool reorder
)
6563 STRIP_SIGN_NOPS (arg0
);
6564 STRIP_SIGN_NOPS (arg1
);
6566 if (TREE_CODE (arg1
) == INTEGER_CST
)
6568 if (TREE_CODE (arg0
) == INTEGER_CST
)
6571 if (TREE_CODE (arg1
) == REAL_CST
)
6573 if (TREE_CODE (arg0
) == REAL_CST
)
6576 if (TREE_CODE (arg1
) == FIXED_CST
)
6578 if (TREE_CODE (arg0
) == FIXED_CST
)
6581 if (TREE_CODE (arg1
) == COMPLEX_CST
)
6583 if (TREE_CODE (arg0
) == COMPLEX_CST
)
6586 if (TREE_CONSTANT (arg1
))
6588 if (TREE_CONSTANT (arg0
))
6591 if (optimize_function_for_size_p (cfun
))
6594 if (reorder
&& flag_evaluation_order
6595 && (TREE_SIDE_EFFECTS (arg0
) || TREE_SIDE_EFFECTS (arg1
)))
6598 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6599 for commutative and comparison operators. Ensuring a canonical
6600 form allows the optimizers to find additional redundancies without
6601 having to explicitly check for both orderings. */
6602 if (TREE_CODE (arg0
) == SSA_NAME
6603 && TREE_CODE (arg1
) == SSA_NAME
6604 && SSA_NAME_VERSION (arg0
) > SSA_NAME_VERSION (arg1
))
6607 /* Put SSA_NAMEs last. */
6608 if (TREE_CODE (arg1
) == SSA_NAME
)
6610 if (TREE_CODE (arg0
) == SSA_NAME
)
6613 /* Put variables last. */
6622 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6623 ARG0 is extended to a wider type. */
6626 fold_widened_comparison (location_t loc
, enum tree_code code
,
6627 tree type
, tree arg0
, tree arg1
)
6629 tree arg0_unw
= get_unwidened (arg0
, NULL_TREE
);
6631 tree shorter_type
, outer_type
;
6635 if (arg0_unw
== arg0
)
6637 shorter_type
= TREE_TYPE (arg0_unw
);
6639 #ifdef HAVE_canonicalize_funcptr_for_compare
6640 /* Disable this optimization if we're casting a function pointer
6641 type on targets that require function pointer canonicalization. */
6642 if (HAVE_canonicalize_funcptr_for_compare
6643 && TREE_CODE (shorter_type
) == POINTER_TYPE
6644 && TREE_CODE (TREE_TYPE (shorter_type
)) == FUNCTION_TYPE
)
6648 if (TYPE_PRECISION (TREE_TYPE (arg0
)) <= TYPE_PRECISION (shorter_type
))
6651 arg1_unw
= get_unwidened (arg1
, NULL_TREE
);
6653 /* If possible, express the comparison in the shorter mode. */
6654 if ((code
== EQ_EXPR
|| code
== NE_EXPR
6655 || TYPE_UNSIGNED (TREE_TYPE (arg0
)) == TYPE_UNSIGNED (shorter_type
))
6656 && (TREE_TYPE (arg1_unw
) == shorter_type
6657 || ((TYPE_PRECISION (shorter_type
)
6658 >= TYPE_PRECISION (TREE_TYPE (arg1_unw
)))
6659 && (TYPE_UNSIGNED (shorter_type
)
6660 == TYPE_UNSIGNED (TREE_TYPE (arg1_unw
))))
6661 || (TREE_CODE (arg1_unw
) == INTEGER_CST
6662 && (TREE_CODE (shorter_type
) == INTEGER_TYPE
6663 || TREE_CODE (shorter_type
) == BOOLEAN_TYPE
)
6664 && int_fits_type_p (arg1_unw
, shorter_type
))))
6665 return fold_build2_loc (loc
, code
, type
, arg0_unw
,
6666 fold_convert_loc (loc
, shorter_type
, arg1_unw
));
6668 if (TREE_CODE (arg1_unw
) != INTEGER_CST
6669 || TREE_CODE (shorter_type
) != INTEGER_TYPE
6670 || !int_fits_type_p (arg1_unw
, shorter_type
))
6673 /* If we are comparing with the integer that does not fit into the range
6674 of the shorter type, the result is known. */
6675 outer_type
= TREE_TYPE (arg1_unw
);
6676 min
= lower_bound_in_type (outer_type
, shorter_type
);
6677 max
= upper_bound_in_type (outer_type
, shorter_type
);
6679 above
= integer_nonzerop (fold_relational_const (LT_EXPR
, type
,
6681 below
= integer_nonzerop (fold_relational_const (LT_EXPR
, type
,
6688 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6693 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6699 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6701 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6706 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
6708 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
6717 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6718 ARG0 just the signedness is changed. */
6721 fold_sign_changed_comparison (location_t loc
, enum tree_code code
, tree type
,
6722 tree arg0
, tree arg1
)
6725 tree inner_type
, outer_type
;
6727 if (!CONVERT_EXPR_P (arg0
))
6730 outer_type
= TREE_TYPE (arg0
);
6731 arg0_inner
= TREE_OPERAND (arg0
, 0);
6732 inner_type
= TREE_TYPE (arg0_inner
);
6734 #ifdef HAVE_canonicalize_funcptr_for_compare
6735 /* Disable this optimization if we're casting a function pointer
6736 type on targets that require function pointer canonicalization. */
6737 if (HAVE_canonicalize_funcptr_for_compare
6738 && TREE_CODE (inner_type
) == POINTER_TYPE
6739 && TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
)
6743 if (TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
6746 if (TREE_CODE (arg1
) != INTEGER_CST
6747 && !(CONVERT_EXPR_P (arg1
)
6748 && TREE_TYPE (TREE_OPERAND (arg1
, 0)) == inner_type
))
6751 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
6756 if (POINTER_TYPE_P (inner_type
) != POINTER_TYPE_P (outer_type
))
6759 if (TREE_CODE (arg1
) == INTEGER_CST
)
6760 arg1
= force_fit_type_double (inner_type
, tree_to_double_int (arg1
),
6761 0, TREE_OVERFLOW (arg1
));
6763 arg1
= fold_convert_loc (loc
, inner_type
, arg1
);
6765 return fold_build2_loc (loc
, code
, type
, arg0_inner
, arg1
);
6768 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
6769 step of the array. Reconstructs s and delta in the case of s *
6770 delta being an integer constant (and thus already folded). ADDR is
6771 the address. MULT is the multiplicative expression. If the
6772 function succeeds, the new address expression is returned.
6773 Otherwise NULL_TREE is returned. LOC is the location of the
6774 resulting expression. */
6777 try_move_mult_to_index (location_t loc
, tree addr
, tree op1
)
6779 tree s
, delta
, step
;
6780 tree ref
= TREE_OPERAND (addr
, 0), pref
;
6785 /* Strip the nops that might be added when converting op1 to sizetype. */
6788 /* Canonicalize op1 into a possibly non-constant delta
6789 and an INTEGER_CST s. */
6790 if (TREE_CODE (op1
) == MULT_EXPR
)
6792 tree arg0
= TREE_OPERAND (op1
, 0), arg1
= TREE_OPERAND (op1
, 1);
6797 if (TREE_CODE (arg0
) == INTEGER_CST
)
6802 else if (TREE_CODE (arg1
) == INTEGER_CST
)
6810 else if (TREE_CODE (op1
) == INTEGER_CST
)
6817 /* Simulate we are delta * 1. */
6819 s
= integer_one_node
;
6822 /* Handle &x.array the same as we would handle &x.array[0]. */
6823 if (TREE_CODE (ref
) == COMPONENT_REF
6824 && TREE_CODE (TREE_TYPE (ref
)) == ARRAY_TYPE
)
6828 /* Remember if this was a multi-dimensional array. */
6829 if (TREE_CODE (TREE_OPERAND (ref
, 0)) == ARRAY_REF
)
6832 domain
= TYPE_DOMAIN (TREE_TYPE (ref
));
6835 itype
= TREE_TYPE (domain
);
6837 step
= TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ref
)));
6838 if (TREE_CODE (step
) != INTEGER_CST
)
6843 if (! tree_int_cst_equal (step
, s
))
6848 /* Try if delta is a multiple of step. */
6849 tree tmp
= div_if_zero_remainder (EXACT_DIV_EXPR
, op1
, step
);
6855 /* Only fold here if we can verify we do not overflow one
6856 dimension of a multi-dimensional array. */
6861 if (!TYPE_MIN_VALUE (domain
)
6862 || !TYPE_MAX_VALUE (domain
)
6863 || TREE_CODE (TYPE_MAX_VALUE (domain
)) != INTEGER_CST
)
6866 tmp
= fold_binary_loc (loc
, PLUS_EXPR
, itype
,
6867 fold_convert_loc (loc
, itype
,
6868 TYPE_MIN_VALUE (domain
)),
6869 fold_convert_loc (loc
, itype
, delta
));
6870 if (TREE_CODE (tmp
) != INTEGER_CST
6871 || tree_int_cst_lt (TYPE_MAX_VALUE (domain
), tmp
))
6875 /* We found a suitable component reference. */
6877 pref
= TREE_OPERAND (addr
, 0);
6878 ret
= copy_node (pref
);
6879 SET_EXPR_LOCATION (ret
, loc
);
6881 ret
= build4_loc (loc
, ARRAY_REF
, TREE_TYPE (TREE_TYPE (ref
)), ret
,
6883 (loc
, PLUS_EXPR
, itype
,
6884 fold_convert_loc (loc
, itype
,
6886 (TYPE_DOMAIN (TREE_TYPE (ref
)))),
6887 fold_convert_loc (loc
, itype
, delta
)),
6888 NULL_TREE
, NULL_TREE
);
6889 return build_fold_addr_expr_loc (loc
, ret
);
6894 for (;; ref
= TREE_OPERAND (ref
, 0))
6896 if (TREE_CODE (ref
) == ARRAY_REF
)
6900 /* Remember if this was a multi-dimensional array. */
6901 if (TREE_CODE (TREE_OPERAND (ref
, 0)) == ARRAY_REF
)
6904 domain
= TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref
, 0)));
6907 itype
= TREE_TYPE (domain
);
6909 step
= array_ref_element_size (ref
);
6910 if (TREE_CODE (step
) != INTEGER_CST
)
6915 if (! tree_int_cst_equal (step
, s
))
6920 /* Try if delta is a multiple of step. */
6921 tree tmp
= div_if_zero_remainder (EXACT_DIV_EXPR
, op1
, step
);
6927 /* Only fold here if we can verify we do not overflow one
6928 dimension of a multi-dimensional array. */
6933 if (TREE_CODE (TREE_OPERAND (ref
, 1)) != INTEGER_CST
6934 || !TYPE_MAX_VALUE (domain
)
6935 || TREE_CODE (TYPE_MAX_VALUE (domain
)) != INTEGER_CST
)
6938 tmp
= fold_binary_loc (loc
, PLUS_EXPR
, itype
,
6939 fold_convert_loc (loc
, itype
,
6940 TREE_OPERAND (ref
, 1)),
6941 fold_convert_loc (loc
, itype
, delta
));
6943 || TREE_CODE (tmp
) != INTEGER_CST
6944 || tree_int_cst_lt (TYPE_MAX_VALUE (domain
), tmp
))
6953 if (!handled_component_p (ref
))
6957 /* We found the suitable array reference. So copy everything up to it,
6958 and replace the index. */
6960 pref
= TREE_OPERAND (addr
, 0);
6961 ret
= copy_node (pref
);
6962 SET_EXPR_LOCATION (ret
, loc
);
6967 pref
= TREE_OPERAND (pref
, 0);
6968 TREE_OPERAND (pos
, 0) = copy_node (pref
);
6969 pos
= TREE_OPERAND (pos
, 0);
6972 TREE_OPERAND (pos
, 1)
6973 = fold_build2_loc (loc
, PLUS_EXPR
, itype
,
6974 fold_convert_loc (loc
, itype
, TREE_OPERAND (pos
, 1)),
6975 fold_convert_loc (loc
, itype
, delta
));
6976 return fold_build1_loc (loc
, ADDR_EXPR
, TREE_TYPE (addr
), ret
);
6980 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
6981 means A >= Y && A != MAX, but in this case we know that
6982 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
6985 fold_to_nonsharp_ineq_using_bound (location_t loc
, tree ineq
, tree bound
)
6987 tree a
, typea
, type
= TREE_TYPE (ineq
), a1
, diff
, y
;
6989 if (TREE_CODE (bound
) == LT_EXPR
)
6990 a
= TREE_OPERAND (bound
, 0);
6991 else if (TREE_CODE (bound
) == GT_EXPR
)
6992 a
= TREE_OPERAND (bound
, 1);
6996 typea
= TREE_TYPE (a
);
6997 if (!INTEGRAL_TYPE_P (typea
)
6998 && !POINTER_TYPE_P (typea
))
7001 if (TREE_CODE (ineq
) == LT_EXPR
)
7003 a1
= TREE_OPERAND (ineq
, 1);
7004 y
= TREE_OPERAND (ineq
, 0);
7006 else if (TREE_CODE (ineq
) == GT_EXPR
)
7008 a1
= TREE_OPERAND (ineq
, 0);
7009 y
= TREE_OPERAND (ineq
, 1);
7014 if (TREE_TYPE (a1
) != typea
)
7017 if (POINTER_TYPE_P (typea
))
7019 /* Convert the pointer types into integer before taking the difference. */
7020 tree ta
= fold_convert_loc (loc
, ssizetype
, a
);
7021 tree ta1
= fold_convert_loc (loc
, ssizetype
, a1
);
7022 diff
= fold_binary_loc (loc
, MINUS_EXPR
, ssizetype
, ta1
, ta
);
7025 diff
= fold_binary_loc (loc
, MINUS_EXPR
, typea
, a1
, a
);
7027 if (!diff
|| !integer_onep (diff
))
7030 return fold_build2_loc (loc
, GE_EXPR
, type
, a
, y
);
7033 /* Fold a sum or difference of at least one multiplication.
7034 Returns the folded tree or NULL if no simplification could be made. */
7037 fold_plusminus_mult_expr (location_t loc
, enum tree_code code
, tree type
,
7038 tree arg0
, tree arg1
)
7040 tree arg00
, arg01
, arg10
, arg11
;
7041 tree alt0
= NULL_TREE
, alt1
= NULL_TREE
, same
;
7043 /* (A * C) +- (B * C) -> (A+-B) * C.
7044 (A * C) +- A -> A * (C+-1).
7045 We are most concerned about the case where C is a constant,
7046 but other combinations show up during loop reduction. Since
7047 it is not difficult, try all four possibilities. */
7049 if (TREE_CODE (arg0
) == MULT_EXPR
)
7051 arg00
= TREE_OPERAND (arg0
, 0);
7052 arg01
= TREE_OPERAND (arg0
, 1);
7054 else if (TREE_CODE (arg0
) == INTEGER_CST
)
7056 arg00
= build_one_cst (type
);
7061 /* We cannot generate constant 1 for fract. */
7062 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
7065 arg01
= build_one_cst (type
);
7067 if (TREE_CODE (arg1
) == MULT_EXPR
)
7069 arg10
= TREE_OPERAND (arg1
, 0);
7070 arg11
= TREE_OPERAND (arg1
, 1);
7072 else if (TREE_CODE (arg1
) == INTEGER_CST
)
7074 arg10
= build_one_cst (type
);
7075 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7076 the purpose of this canonicalization. */
7077 if (TREE_INT_CST_HIGH (arg1
) == -1
7078 && negate_expr_p (arg1
)
7079 && code
== PLUS_EXPR
)
7081 arg11
= negate_expr (arg1
);
7089 /* We cannot generate constant 1 for fract. */
7090 if (ALL_FRACT_MODE_P (TYPE_MODE (type
)))
7093 arg11
= build_one_cst (type
);
7097 if (operand_equal_p (arg01
, arg11
, 0))
7098 same
= arg01
, alt0
= arg00
, alt1
= arg10
;
7099 else if (operand_equal_p (arg00
, arg10
, 0))
7100 same
= arg00
, alt0
= arg01
, alt1
= arg11
;
7101 else if (operand_equal_p (arg00
, arg11
, 0))
7102 same
= arg00
, alt0
= arg01
, alt1
= arg10
;
7103 else if (operand_equal_p (arg01
, arg10
, 0))
7104 same
= arg01
, alt0
= arg00
, alt1
= arg11
;
7106 /* No identical multiplicands; see if we can find a common
7107 power-of-two factor in non-power-of-two multiplies. This
7108 can help in multi-dimensional array access. */
7109 else if (host_integerp (arg01
, 0)
7110 && host_integerp (arg11
, 0))
7112 HOST_WIDE_INT int01
, int11
, tmp
;
7115 int01
= TREE_INT_CST_LOW (arg01
);
7116 int11
= TREE_INT_CST_LOW (arg11
);
7118 /* Move min of absolute values to int11. */
7119 if (absu_hwi (int01
) < absu_hwi (int11
))
7121 tmp
= int01
, int01
= int11
, int11
= tmp
;
7122 alt0
= arg00
, arg00
= arg10
, arg10
= alt0
;
7129 if (exact_log2 (absu_hwi (int11
)) > 0 && int01
% int11
== 0
7130 /* The remainder should not be a constant, otherwise we
7131 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7132 increased the number of multiplications necessary. */
7133 && TREE_CODE (arg10
) != INTEGER_CST
)
7135 alt0
= fold_build2_loc (loc
, MULT_EXPR
, TREE_TYPE (arg00
), arg00
,
7136 build_int_cst (TREE_TYPE (arg00
),
7141 maybe_same
= alt0
, alt0
= alt1
, alt1
= maybe_same
;
7146 return fold_build2_loc (loc
, MULT_EXPR
, type
,
7147 fold_build2_loc (loc
, code
, type
,
7148 fold_convert_loc (loc
, type
, alt0
),
7149 fold_convert_loc (loc
, type
, alt1
)),
7150 fold_convert_loc (loc
, type
, same
));
7155 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7156 specified by EXPR into the buffer PTR of length LEN bytes.
7157 Return the number of bytes placed in the buffer, or zero
7161 native_encode_int (const_tree expr
, unsigned char *ptr
, int len
)
7163 tree type
= TREE_TYPE (expr
);
7164 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7165 int byte
, offset
, word
, words
;
7166 unsigned char value
;
7168 if (total_bytes
> len
)
7170 words
= total_bytes
/ UNITS_PER_WORD
;
7172 for (byte
= 0; byte
< total_bytes
; byte
++)
7174 int bitpos
= byte
* BITS_PER_UNIT
;
7175 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
7176 value
= (unsigned char) (TREE_INT_CST_LOW (expr
) >> bitpos
);
7178 value
= (unsigned char) (TREE_INT_CST_HIGH (expr
)
7179 >> (bitpos
- HOST_BITS_PER_WIDE_INT
));
7181 if (total_bytes
> UNITS_PER_WORD
)
7183 word
= byte
/ UNITS_PER_WORD
;
7184 if (WORDS_BIG_ENDIAN
)
7185 word
= (words
- 1) - word
;
7186 offset
= word
* UNITS_PER_WORD
;
7187 if (BYTES_BIG_ENDIAN
)
7188 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7190 offset
+= byte
% UNITS_PER_WORD
;
7193 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
7194 ptr
[offset
] = value
;
7200 /* Subroutine of native_encode_expr. Encode the REAL_CST
7201 specified by EXPR into the buffer PTR of length LEN bytes.
7202 Return the number of bytes placed in the buffer, or zero
7206 native_encode_real (const_tree expr
, unsigned char *ptr
, int len
)
7208 tree type
= TREE_TYPE (expr
);
7209 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7210 int byte
, offset
, word
, words
, bitpos
;
7211 unsigned char value
;
7213 /* There are always 32 bits in each long, no matter the size of
7214 the hosts long. We handle floating point representations with
7218 if (total_bytes
> len
)
7220 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7222 real_to_target (tmp
, TREE_REAL_CST_PTR (expr
), TYPE_MODE (type
));
7224 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7225 bitpos
+= BITS_PER_UNIT
)
7227 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7228 value
= (unsigned char) (tmp
[bitpos
/ 32] >> (bitpos
& 31));
7230 if (UNITS_PER_WORD
< 4)
7232 word
= byte
/ UNITS_PER_WORD
;
7233 if (WORDS_BIG_ENDIAN
)
7234 word
= (words
- 1) - word
;
7235 offset
= word
* UNITS_PER_WORD
;
7236 if (BYTES_BIG_ENDIAN
)
7237 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7239 offset
+= byte
% UNITS_PER_WORD
;
7242 offset
= BYTES_BIG_ENDIAN
? 3 - byte
: byte
;
7243 ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)] = value
;
7248 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7249 specified by EXPR into the buffer PTR of length LEN bytes.
7250 Return the number of bytes placed in the buffer, or zero
7254 native_encode_complex (const_tree expr
, unsigned char *ptr
, int len
)
7259 part
= TREE_REALPART (expr
);
7260 rsize
= native_encode_expr (part
, ptr
, len
);
7263 part
= TREE_IMAGPART (expr
);
7264 isize
= native_encode_expr (part
, ptr
+rsize
, len
-rsize
);
7267 return rsize
+ isize
;
7271 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7272 specified by EXPR into the buffer PTR of length LEN bytes.
7273 Return the number of bytes placed in the buffer, or zero
7277 native_encode_vector (const_tree expr
, unsigned char *ptr
, int len
)
7284 count
= VECTOR_CST_NELTS (expr
);
7285 itype
= TREE_TYPE (TREE_TYPE (expr
));
7286 size
= GET_MODE_SIZE (TYPE_MODE (itype
));
7287 for (i
= 0; i
< count
; i
++)
7289 elem
= VECTOR_CST_ELT (expr
, i
);
7290 if (native_encode_expr (elem
, ptr
+offset
, len
-offset
) != size
)
7298 /* Subroutine of native_encode_expr. Encode the STRING_CST
7299 specified by EXPR into the buffer PTR of length LEN bytes.
7300 Return the number of bytes placed in the buffer, or zero
7304 native_encode_string (const_tree expr
, unsigned char *ptr
, int len
)
7306 tree type
= TREE_TYPE (expr
);
7307 HOST_WIDE_INT total_bytes
;
7309 if (TREE_CODE (type
) != ARRAY_TYPE
7310 || TREE_CODE (TREE_TYPE (type
)) != INTEGER_TYPE
7311 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type
))) != BITS_PER_UNIT
7312 || !host_integerp (TYPE_SIZE_UNIT (type
), 0))
7314 total_bytes
= tree_low_cst (TYPE_SIZE_UNIT (type
), 0);
7315 if (total_bytes
> len
)
7317 if (TREE_STRING_LENGTH (expr
) < total_bytes
)
7319 memcpy (ptr
, TREE_STRING_POINTER (expr
), TREE_STRING_LENGTH (expr
));
7320 memset (ptr
+ TREE_STRING_LENGTH (expr
), 0,
7321 total_bytes
- TREE_STRING_LENGTH (expr
));
7324 memcpy (ptr
, TREE_STRING_POINTER (expr
), total_bytes
);
7329 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7330 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7331 buffer PTR of length LEN bytes. Return the number of bytes
7332 placed in the buffer, or zero upon failure. */
7335 native_encode_expr (const_tree expr
, unsigned char *ptr
, int len
)
7337 switch (TREE_CODE (expr
))
7340 return native_encode_int (expr
, ptr
, len
);
7343 return native_encode_real (expr
, ptr
, len
);
7346 return native_encode_complex (expr
, ptr
, len
);
7349 return native_encode_vector (expr
, ptr
, len
);
7352 return native_encode_string (expr
, ptr
, len
);
7360 /* Subroutine of native_interpret_expr. Interpret the contents of
7361 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7362 If the buffer cannot be interpreted, return NULL_TREE. */
7365 native_interpret_int (tree type
, const unsigned char *ptr
, int len
)
7367 int total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7368 int byte
, offset
, word
, words
;
7369 unsigned char value
;
7372 if (total_bytes
> len
)
7374 if (total_bytes
* BITS_PER_UNIT
> HOST_BITS_PER_DOUBLE_INT
)
7377 result
= double_int_zero
;
7378 words
= total_bytes
/ UNITS_PER_WORD
;
7380 for (byte
= 0; byte
< total_bytes
; byte
++)
7382 int bitpos
= byte
* BITS_PER_UNIT
;
7383 if (total_bytes
> UNITS_PER_WORD
)
7385 word
= byte
/ UNITS_PER_WORD
;
7386 if (WORDS_BIG_ENDIAN
)
7387 word
= (words
- 1) - word
;
7388 offset
= word
* UNITS_PER_WORD
;
7389 if (BYTES_BIG_ENDIAN
)
7390 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7392 offset
+= byte
% UNITS_PER_WORD
;
7395 offset
= BYTES_BIG_ENDIAN
? (total_bytes
- 1) - byte
: byte
;
7396 value
= ptr
[offset
];
7398 if (bitpos
< HOST_BITS_PER_WIDE_INT
)
7399 result
.low
|= (unsigned HOST_WIDE_INT
) value
<< bitpos
;
7401 result
.high
|= (unsigned HOST_WIDE_INT
) value
7402 << (bitpos
- HOST_BITS_PER_WIDE_INT
);
7405 return double_int_to_tree (type
, result
);
7409 /* Subroutine of native_interpret_expr. Interpret the contents of
7410 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7411 If the buffer cannot be interpreted, return NULL_TREE. */
7414 native_interpret_real (tree type
, const unsigned char *ptr
, int len
)
7416 enum machine_mode mode
= TYPE_MODE (type
);
7417 int total_bytes
= GET_MODE_SIZE (mode
);
7418 int byte
, offset
, word
, words
, bitpos
;
7419 unsigned char value
;
7420 /* There are always 32 bits in each long, no matter the size of
7421 the hosts long. We handle floating point representations with
7426 total_bytes
= GET_MODE_SIZE (TYPE_MODE (type
));
7427 if (total_bytes
> len
|| total_bytes
> 24)
7429 words
= (32 / BITS_PER_UNIT
) / UNITS_PER_WORD
;
7431 memset (tmp
, 0, sizeof (tmp
));
7432 for (bitpos
= 0; bitpos
< total_bytes
* BITS_PER_UNIT
;
7433 bitpos
+= BITS_PER_UNIT
)
7435 byte
= (bitpos
/ BITS_PER_UNIT
) & 3;
7436 if (UNITS_PER_WORD
< 4)
7438 word
= byte
/ UNITS_PER_WORD
;
7439 if (WORDS_BIG_ENDIAN
)
7440 word
= (words
- 1) - word
;
7441 offset
= word
* UNITS_PER_WORD
;
7442 if (BYTES_BIG_ENDIAN
)
7443 offset
+= (UNITS_PER_WORD
- 1) - (byte
% UNITS_PER_WORD
);
7445 offset
+= byte
% UNITS_PER_WORD
;
7448 offset
= BYTES_BIG_ENDIAN
? 3 - byte
: byte
;
7449 value
= ptr
[offset
+ ((bitpos
/ BITS_PER_UNIT
) & ~3)];
7451 tmp
[bitpos
/ 32] |= (unsigned long)value
<< (bitpos
& 31);
7454 real_from_target (&r
, tmp
, mode
);
7455 return build_real (type
, r
);
7459 /* Subroutine of native_interpret_expr. Interpret the contents of
7460 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7461 If the buffer cannot be interpreted, return NULL_TREE. */
7464 native_interpret_complex (tree type
, const unsigned char *ptr
, int len
)
7466 tree etype
, rpart
, ipart
;
7469 etype
= TREE_TYPE (type
);
7470 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7473 rpart
= native_interpret_expr (etype
, ptr
, size
);
7476 ipart
= native_interpret_expr (etype
, ptr
+size
, size
);
7479 return build_complex (type
, rpart
, ipart
);
7483 /* Subroutine of native_interpret_expr. Interpret the contents of
7484 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7485 If the buffer cannot be interpreted, return NULL_TREE. */
7488 native_interpret_vector (tree type
, const unsigned char *ptr
, int len
)
7494 etype
= TREE_TYPE (type
);
7495 size
= GET_MODE_SIZE (TYPE_MODE (etype
));
7496 count
= TYPE_VECTOR_SUBPARTS (type
);
7497 if (size
* count
> len
)
7500 elements
= XALLOCAVEC (tree
, count
);
7501 for (i
= count
- 1; i
>= 0; i
--)
7503 elem
= native_interpret_expr (etype
, ptr
+(i
*size
), size
);
7508 return build_vector (type
, elements
);
7512 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7513 the buffer PTR of length LEN as a constant of type TYPE. For
7514 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7515 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7516 return NULL_TREE. */
7519 native_interpret_expr (tree type
, const unsigned char *ptr
, int len
)
7521 switch (TREE_CODE (type
))
7527 case REFERENCE_TYPE
:
7528 return native_interpret_int (type
, ptr
, len
);
7531 return native_interpret_real (type
, ptr
, len
);
7534 return native_interpret_complex (type
, ptr
, len
);
7537 return native_interpret_vector (type
, ptr
, len
);
7544 /* Returns true if we can interpret the contents of a native encoding
7548 can_native_interpret_type_p (tree type
)
7550 switch (TREE_CODE (type
))
7556 case REFERENCE_TYPE
:
7566 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7567 TYPE at compile-time. If we're unable to perform the conversion
7568 return NULL_TREE. */
7571 fold_view_convert_expr (tree type
, tree expr
)
7573 /* We support up to 512-bit values (for V8DFmode). */
7574 unsigned char buffer
[64];
7577 /* Check that the host and target are sane. */
7578 if (CHAR_BIT
!= 8 || BITS_PER_UNIT
!= 8)
7581 len
= native_encode_expr (expr
, buffer
, sizeof (buffer
));
7585 return native_interpret_expr (type
, buffer
, len
);
7588 /* Build an expression for the address of T. Folds away INDIRECT_REF
7589 to avoid confusing the gimplify process. */
7592 build_fold_addr_expr_with_type_loc (location_t loc
, tree t
, tree ptrtype
)
7594 /* The size of the object is not relevant when talking about its address. */
7595 if (TREE_CODE (t
) == WITH_SIZE_EXPR
)
7596 t
= TREE_OPERAND (t
, 0);
7598 if (TREE_CODE (t
) == INDIRECT_REF
)
7600 t
= TREE_OPERAND (t
, 0);
7602 if (TREE_TYPE (t
) != ptrtype
)
7603 t
= build1_loc (loc
, NOP_EXPR
, ptrtype
, t
);
7605 else if (TREE_CODE (t
) == MEM_REF
7606 && integer_zerop (TREE_OPERAND (t
, 1)))
7607 return TREE_OPERAND (t
, 0);
7608 else if (TREE_CODE (t
) == MEM_REF
7609 && TREE_CODE (TREE_OPERAND (t
, 0)) == INTEGER_CST
)
7610 return fold_binary (POINTER_PLUS_EXPR
, ptrtype
,
7611 TREE_OPERAND (t
, 0),
7612 convert_to_ptrofftype (TREE_OPERAND (t
, 1)));
7613 else if (TREE_CODE (t
) == VIEW_CONVERT_EXPR
)
7615 t
= build_fold_addr_expr_loc (loc
, TREE_OPERAND (t
, 0));
7617 if (TREE_TYPE (t
) != ptrtype
)
7618 t
= fold_convert_loc (loc
, ptrtype
, t
);
7621 t
= build1_loc (loc
, ADDR_EXPR
, ptrtype
, t
);
7626 /* Build an expression for the address of T. */
7629 build_fold_addr_expr_loc (location_t loc
, tree t
)
7631 tree ptrtype
= build_pointer_type (TREE_TYPE (t
));
7633 return build_fold_addr_expr_with_type_loc (loc
, t
, ptrtype
);
7636 static bool vec_cst_ctor_to_array (tree
, tree
*);
7638 /* Fold a unary expression of code CODE and type TYPE with operand
7639 OP0. Return the folded expression if folding is successful.
7640 Otherwise, return NULL_TREE. */
7643 fold_unary_loc (location_t loc
, enum tree_code code
, tree type
, tree op0
)
7647 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
7649 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
7650 && TREE_CODE_LENGTH (code
) == 1);
7655 if (CONVERT_EXPR_CODE_P (code
)
7656 || code
== FLOAT_EXPR
|| code
== ABS_EXPR
|| code
== NEGATE_EXPR
)
7658 /* Don't use STRIP_NOPS, because signedness of argument type
7660 STRIP_SIGN_NOPS (arg0
);
7664 /* Strip any conversions that don't change the mode. This
7665 is safe for every expression, except for a comparison
7666 expression because its signedness is derived from its
7669 Note that this is done as an internal manipulation within
7670 the constant folder, in order to find the simplest
7671 representation of the arguments so that their form can be
7672 studied. In any cases, the appropriate type conversions
7673 should be put back in the tree that will get out of the
7679 if (TREE_CODE_CLASS (code
) == tcc_unary
)
7681 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
7682 return build2 (COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7683 fold_build1_loc (loc
, code
, type
,
7684 fold_convert_loc (loc
, TREE_TYPE (op0
),
7685 TREE_OPERAND (arg0
, 1))));
7686 else if (TREE_CODE (arg0
) == COND_EXPR
)
7688 tree arg01
= TREE_OPERAND (arg0
, 1);
7689 tree arg02
= TREE_OPERAND (arg0
, 2);
7690 if (! VOID_TYPE_P (TREE_TYPE (arg01
)))
7691 arg01
= fold_build1_loc (loc
, code
, type
,
7692 fold_convert_loc (loc
,
7693 TREE_TYPE (op0
), arg01
));
7694 if (! VOID_TYPE_P (TREE_TYPE (arg02
)))
7695 arg02
= fold_build1_loc (loc
, code
, type
,
7696 fold_convert_loc (loc
,
7697 TREE_TYPE (op0
), arg02
));
7698 tem
= fold_build3_loc (loc
, COND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
7701 /* If this was a conversion, and all we did was to move into
7702 inside the COND_EXPR, bring it back out. But leave it if
7703 it is a conversion from integer to integer and the
7704 result precision is no wider than a word since such a
7705 conversion is cheap and may be optimized away by combine,
7706 while it couldn't if it were outside the COND_EXPR. Then return
7707 so we don't get into an infinite recursion loop taking the
7708 conversion out and then back in. */
7710 if ((CONVERT_EXPR_CODE_P (code
)
7711 || code
== NON_LVALUE_EXPR
)
7712 && TREE_CODE (tem
) == COND_EXPR
7713 && TREE_CODE (TREE_OPERAND (tem
, 1)) == code
7714 && TREE_CODE (TREE_OPERAND (tem
, 2)) == code
7715 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 1))
7716 && ! VOID_TYPE_P (TREE_OPERAND (tem
, 2))
7717 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))
7718 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 2), 0)))
7719 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7721 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem
, 1), 0))))
7722 && TYPE_PRECISION (TREE_TYPE (tem
)) <= BITS_PER_WORD
)
7723 || flag_syntax_only
))
7724 tem
= build1_loc (loc
, code
, type
,
7726 TREE_TYPE (TREE_OPERAND
7727 (TREE_OPERAND (tem
, 1), 0)),
7728 TREE_OPERAND (tem
, 0),
7729 TREE_OPERAND (TREE_OPERAND (tem
, 1), 0),
7730 TREE_OPERAND (TREE_OPERAND (tem
, 2),
7739 /* Re-association barriers around constants and other re-association
7740 barriers can be removed. */
7741 if (CONSTANT_CLASS_P (op0
)
7742 || TREE_CODE (op0
) == PAREN_EXPR
)
7743 return fold_convert_loc (loc
, type
, op0
);
7748 case FIX_TRUNC_EXPR
:
7749 if (TREE_TYPE (op0
) == type
)
7752 if (COMPARISON_CLASS_P (op0
))
7754 /* If we have (type) (a CMP b) and type is an integral type, return
7755 new expression involving the new type. Canonicalize
7756 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7758 Do not fold the result as that would not simplify further, also
7759 folding again results in recursions. */
7760 if (TREE_CODE (type
) == BOOLEAN_TYPE
)
7761 return build2_loc (loc
, TREE_CODE (op0
), type
,
7762 TREE_OPERAND (op0
, 0),
7763 TREE_OPERAND (op0
, 1));
7764 else if (!INTEGRAL_TYPE_P (type
) && !VOID_TYPE_P (type
)
7765 && TREE_CODE (type
) != VECTOR_TYPE
)
7766 return build3_loc (loc
, COND_EXPR
, type
, op0
,
7767 constant_boolean_node (true, type
),
7768 constant_boolean_node (false, type
));
7771 /* Handle cases of two conversions in a row. */
7772 if (CONVERT_EXPR_P (op0
))
7774 tree inside_type
= TREE_TYPE (TREE_OPERAND (op0
, 0));
7775 tree inter_type
= TREE_TYPE (op0
);
7776 int inside_int
= INTEGRAL_TYPE_P (inside_type
);
7777 int inside_ptr
= POINTER_TYPE_P (inside_type
);
7778 int inside_float
= FLOAT_TYPE_P (inside_type
);
7779 int inside_vec
= TREE_CODE (inside_type
) == VECTOR_TYPE
;
7780 unsigned int inside_prec
= TYPE_PRECISION (inside_type
);
7781 int inside_unsignedp
= TYPE_UNSIGNED (inside_type
);
7782 int inter_int
= INTEGRAL_TYPE_P (inter_type
);
7783 int inter_ptr
= POINTER_TYPE_P (inter_type
);
7784 int inter_float
= FLOAT_TYPE_P (inter_type
);
7785 int inter_vec
= TREE_CODE (inter_type
) == VECTOR_TYPE
;
7786 unsigned int inter_prec
= TYPE_PRECISION (inter_type
);
7787 int inter_unsignedp
= TYPE_UNSIGNED (inter_type
);
7788 int final_int
= INTEGRAL_TYPE_P (type
);
7789 int final_ptr
= POINTER_TYPE_P (type
);
7790 int final_float
= FLOAT_TYPE_P (type
);
7791 int final_vec
= TREE_CODE (type
) == VECTOR_TYPE
;
7792 unsigned int final_prec
= TYPE_PRECISION (type
);
7793 int final_unsignedp
= TYPE_UNSIGNED (type
);
7795 /* In addition to the cases of two conversions in a row
7796 handled below, if we are converting something to its own
7797 type via an object of identical or wider precision, neither
7798 conversion is needed. */
7799 if (TYPE_MAIN_VARIANT (inside_type
) == TYPE_MAIN_VARIANT (type
)
7800 && (((inter_int
|| inter_ptr
) && final_int
)
7801 || (inter_float
&& final_float
))
7802 && inter_prec
>= final_prec
)
7803 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7805 /* Likewise, if the intermediate and initial types are either both
7806 float or both integer, we don't need the middle conversion if the
7807 former is wider than the latter and doesn't change the signedness
7808 (for integers). Avoid this if the final type is a pointer since
7809 then we sometimes need the middle conversion. Likewise if the
7810 final type has a precision not equal to the size of its mode. */
7811 if (((inter_int
&& inside_int
)
7812 || (inter_float
&& inside_float
)
7813 || (inter_vec
&& inside_vec
))
7814 && inter_prec
>= inside_prec
7815 && (inter_float
|| inter_vec
7816 || inter_unsignedp
== inside_unsignedp
)
7817 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
7818 && TYPE_MODE (type
) == TYPE_MODE (inter_type
))
7820 && (! final_vec
|| inter_prec
== inside_prec
))
7821 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7823 /* If we have a sign-extension of a zero-extended value, we can
7824 replace that by a single zero-extension. Likewise if the
7825 final conversion does not change precision we can drop the
7826 intermediate conversion. */
7827 if (inside_int
&& inter_int
&& final_int
7828 && ((inside_prec
< inter_prec
&& inter_prec
< final_prec
7829 && inside_unsignedp
&& !inter_unsignedp
)
7830 || final_prec
== inter_prec
))
7831 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7833 /* Two conversions in a row are not needed unless:
7834 - some conversion is floating-point (overstrict for now), or
7835 - some conversion is a vector (overstrict for now), or
7836 - the intermediate type is narrower than both initial and
7838 - the intermediate type and innermost type differ in signedness,
7839 and the outermost type is wider than the intermediate, or
7840 - the initial type is a pointer type and the precisions of the
7841 intermediate and final types differ, or
7842 - the final type is a pointer type and the precisions of the
7843 initial and intermediate types differ. */
7844 if (! inside_float
&& ! inter_float
&& ! final_float
7845 && ! inside_vec
&& ! inter_vec
&& ! final_vec
7846 && (inter_prec
>= inside_prec
|| inter_prec
>= final_prec
)
7847 && ! (inside_int
&& inter_int
7848 && inter_unsignedp
!= inside_unsignedp
7849 && inter_prec
< final_prec
)
7850 && ((inter_unsignedp
&& inter_prec
> inside_prec
)
7851 == (final_unsignedp
&& final_prec
> inter_prec
))
7852 && ! (inside_ptr
&& inter_prec
!= final_prec
)
7853 && ! (final_ptr
&& inside_prec
!= inter_prec
)
7854 && ! (final_prec
!= GET_MODE_PRECISION (TYPE_MODE (type
))
7855 && TYPE_MODE (type
) == TYPE_MODE (inter_type
)))
7856 return fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 0));
7859 /* Handle (T *)&A.B.C for A being of type T and B and C
7860 living at offset zero. This occurs frequently in
7861 C++ upcasting and then accessing the base. */
7862 if (TREE_CODE (op0
) == ADDR_EXPR
7863 && POINTER_TYPE_P (type
)
7864 && handled_component_p (TREE_OPERAND (op0
, 0)))
7866 HOST_WIDE_INT bitsize
, bitpos
;
7868 enum machine_mode mode
;
7869 int unsignedp
, volatilep
;
7870 tree base
= TREE_OPERAND (op0
, 0);
7871 base
= get_inner_reference (base
, &bitsize
, &bitpos
, &offset
,
7872 &mode
, &unsignedp
, &volatilep
, false);
7873 /* If the reference was to a (constant) zero offset, we can use
7874 the address of the base if it has the same base type
7875 as the result type and the pointer type is unqualified. */
7876 if (! offset
&& bitpos
== 0
7877 && (TYPE_MAIN_VARIANT (TREE_TYPE (type
))
7878 == TYPE_MAIN_VARIANT (TREE_TYPE (base
)))
7879 && TYPE_QUALS (type
) == TYPE_UNQUALIFIED
)
7880 return fold_convert_loc (loc
, type
,
7881 build_fold_addr_expr_loc (loc
, base
));
7884 if (TREE_CODE (op0
) == MODIFY_EXPR
7885 && TREE_CONSTANT (TREE_OPERAND (op0
, 1))
7886 /* Detect assigning a bitfield. */
7887 && !(TREE_CODE (TREE_OPERAND (op0
, 0)) == COMPONENT_REF
7889 (TREE_OPERAND (TREE_OPERAND (op0
, 0), 1))))
7891 /* Don't leave an assignment inside a conversion
7892 unless assigning a bitfield. */
7893 tem
= fold_build1_loc (loc
, code
, type
, TREE_OPERAND (op0
, 1));
7894 /* First do the assignment, then return converted constant. */
7895 tem
= build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (tem
), op0
, tem
);
7896 TREE_NO_WARNING (tem
) = 1;
7897 TREE_USED (tem
) = 1;
7901 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7902 constants (if x has signed type, the sign bit cannot be set
7903 in c). This folds extension into the BIT_AND_EXPR.
7904 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
7905 very likely don't have maximal range for their precision and this
7906 transformation effectively doesn't preserve non-maximal ranges. */
7907 if (TREE_CODE (type
) == INTEGER_TYPE
7908 && TREE_CODE (op0
) == BIT_AND_EXPR
7909 && TREE_CODE (TREE_OPERAND (op0
, 1)) == INTEGER_CST
)
7911 tree and_expr
= op0
;
7912 tree and0
= TREE_OPERAND (and_expr
, 0);
7913 tree and1
= TREE_OPERAND (and_expr
, 1);
7916 if (TYPE_UNSIGNED (TREE_TYPE (and_expr
))
7917 || (TYPE_PRECISION (type
)
7918 <= TYPE_PRECISION (TREE_TYPE (and_expr
))))
7920 else if (TYPE_PRECISION (TREE_TYPE (and1
))
7921 <= HOST_BITS_PER_WIDE_INT
7922 && host_integerp (and1
, 1))
7924 unsigned HOST_WIDE_INT cst
;
7926 cst
= tree_low_cst (and1
, 1);
7927 cst
&= (HOST_WIDE_INT
) -1
7928 << (TYPE_PRECISION (TREE_TYPE (and1
)) - 1);
7929 change
= (cst
== 0);
7930 #ifdef LOAD_EXTEND_OP
7932 && !flag_syntax_only
7933 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0
)))
7936 tree uns
= unsigned_type_for (TREE_TYPE (and0
));
7937 and0
= fold_convert_loc (loc
, uns
, and0
);
7938 and1
= fold_convert_loc (loc
, uns
, and1
);
7944 tem
= force_fit_type_double (type
, tree_to_double_int (and1
),
7945 0, TREE_OVERFLOW (and1
));
7946 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
7947 fold_convert_loc (loc
, type
, and0
), tem
);
7951 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
7952 when one of the new casts will fold away. Conservatively we assume
7953 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
7954 if (POINTER_TYPE_P (type
)
7955 && TREE_CODE (arg0
) == POINTER_PLUS_EXPR
7956 && (!TYPE_RESTRICT (type
) || TYPE_RESTRICT (TREE_TYPE (arg0
)))
7957 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
7958 || TREE_CODE (TREE_OPERAND (arg0
, 0)) == NOP_EXPR
7959 || TREE_CODE (TREE_OPERAND (arg0
, 1)) == NOP_EXPR
))
7961 tree arg00
= TREE_OPERAND (arg0
, 0);
7962 tree arg01
= TREE_OPERAND (arg0
, 1);
7964 return fold_build_pointer_plus_loc
7965 (loc
, fold_convert_loc (loc
, type
, arg00
), arg01
);
7968 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7969 of the same precision, and X is an integer type not narrower than
7970 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
7971 if (INTEGRAL_TYPE_P (type
)
7972 && TREE_CODE (op0
) == BIT_NOT_EXPR
7973 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7974 && CONVERT_EXPR_P (TREE_OPERAND (op0
, 0))
7975 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
7977 tem
= TREE_OPERAND (TREE_OPERAND (op0
, 0), 0);
7978 if (INTEGRAL_TYPE_P (TREE_TYPE (tem
))
7979 && TYPE_PRECISION (type
) <= TYPE_PRECISION (TREE_TYPE (tem
)))
7980 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
7981 fold_convert_loc (loc
, type
, tem
));
7984 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
7985 type of X and Y (integer types only). */
7986 if (INTEGRAL_TYPE_P (type
)
7987 && TREE_CODE (op0
) == MULT_EXPR
7988 && INTEGRAL_TYPE_P (TREE_TYPE (op0
))
7989 && TYPE_PRECISION (type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
7991 /* Be careful not to introduce new overflows. */
7993 if (TYPE_OVERFLOW_WRAPS (type
))
7996 mult_type
= unsigned_type_for (type
);
7998 if (TYPE_PRECISION (mult_type
) < TYPE_PRECISION (TREE_TYPE (op0
)))
8000 tem
= fold_build2_loc (loc
, MULT_EXPR
, mult_type
,
8001 fold_convert_loc (loc
, mult_type
,
8002 TREE_OPERAND (op0
, 0)),
8003 fold_convert_loc (loc
, mult_type
,
8004 TREE_OPERAND (op0
, 1)));
8005 return fold_convert_loc (loc
, type
, tem
);
8009 tem
= fold_convert_const (code
, type
, op0
);
8010 return tem
? tem
: NULL_TREE
;
8012 case ADDR_SPACE_CONVERT_EXPR
:
8013 if (integer_zerop (arg0
))
8014 return fold_convert_const (code
, type
, arg0
);
8017 case FIXED_CONVERT_EXPR
:
8018 tem
= fold_convert_const (code
, type
, arg0
);
8019 return tem
? tem
: NULL_TREE
;
8021 case VIEW_CONVERT_EXPR
:
8022 if (TREE_TYPE (op0
) == type
)
8024 if (TREE_CODE (op0
) == VIEW_CONVERT_EXPR
)
8025 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
,
8026 type
, TREE_OPERAND (op0
, 0));
8027 if (TREE_CODE (op0
) == MEM_REF
)
8028 return fold_build2_loc (loc
, MEM_REF
, type
,
8029 TREE_OPERAND (op0
, 0), TREE_OPERAND (op0
, 1));
8031 /* For integral conversions with the same precision or pointer
8032 conversions use a NOP_EXPR instead. */
8033 if ((INTEGRAL_TYPE_P (type
)
8034 || POINTER_TYPE_P (type
))
8035 && (INTEGRAL_TYPE_P (TREE_TYPE (op0
))
8036 || POINTER_TYPE_P (TREE_TYPE (op0
)))
8037 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (op0
)))
8038 return fold_convert_loc (loc
, type
, op0
);
8040 /* Strip inner integral conversions that do not change the precision. */
8041 if (CONVERT_EXPR_P (op0
)
8042 && (INTEGRAL_TYPE_P (TREE_TYPE (op0
))
8043 || POINTER_TYPE_P (TREE_TYPE (op0
)))
8044 && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0
, 0)))
8045 || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0
, 0))))
8046 && (TYPE_PRECISION (TREE_TYPE (op0
))
8047 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0
, 0)))))
8048 return fold_build1_loc (loc
, VIEW_CONVERT_EXPR
,
8049 type
, TREE_OPERAND (op0
, 0));
8051 return fold_view_convert_expr (type
, op0
);
8054 tem
= fold_negate_expr (loc
, arg0
);
8056 return fold_convert_loc (loc
, type
, tem
);
8060 if (TREE_CODE (arg0
) == INTEGER_CST
|| TREE_CODE (arg0
) == REAL_CST
)
8061 return fold_abs_const (arg0
, type
);
8062 else if (TREE_CODE (arg0
) == NEGATE_EXPR
)
8063 return fold_build1_loc (loc
, ABS_EXPR
, type
, TREE_OPERAND (arg0
, 0));
8064 /* Convert fabs((double)float) into (double)fabsf(float). */
8065 else if (TREE_CODE (arg0
) == NOP_EXPR
8066 && TREE_CODE (type
) == REAL_TYPE
)
8068 tree targ0
= strip_float_extensions (arg0
);
8070 return fold_convert_loc (loc
, type
,
8071 fold_build1_loc (loc
, ABS_EXPR
,
8075 /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on. */
8076 else if (TREE_CODE (arg0
) == ABS_EXPR
)
8078 else if (tree_expr_nonnegative_p (arg0
))
8081 /* Strip sign ops from argument. */
8082 if (TREE_CODE (type
) == REAL_TYPE
)
8084 tem
= fold_strip_sign_ops (arg0
);
8086 return fold_build1_loc (loc
, ABS_EXPR
, type
,
8087 fold_convert_loc (loc
, type
, tem
));
8092 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8093 return fold_convert_loc (loc
, type
, arg0
);
8094 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8096 tree itype
= TREE_TYPE (type
);
8097 tree rpart
= fold_convert_loc (loc
, itype
, TREE_OPERAND (arg0
, 0));
8098 tree ipart
= fold_convert_loc (loc
, itype
, TREE_OPERAND (arg0
, 1));
8099 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rpart
,
8100 negate_expr (ipart
));
8102 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8104 tree itype
= TREE_TYPE (type
);
8105 tree rpart
= fold_convert_loc (loc
, itype
, TREE_REALPART (arg0
));
8106 tree ipart
= fold_convert_loc (loc
, itype
, TREE_IMAGPART (arg0
));
8107 return build_complex (type
, rpart
, negate_expr (ipart
));
8109 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8110 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
8114 if (TREE_CODE (arg0
) == INTEGER_CST
)
8115 return fold_not_const (arg0
, type
);
8116 else if (TREE_CODE (arg0
) == BIT_NOT_EXPR
)
8117 return fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
8118 /* Convert ~ (-A) to A - 1. */
8119 else if (INTEGRAL_TYPE_P (type
) && TREE_CODE (arg0
) == NEGATE_EXPR
)
8120 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
8121 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0)),
8122 build_int_cst (type
, 1));
8123 /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
8124 else if (INTEGRAL_TYPE_P (type
)
8125 && ((TREE_CODE (arg0
) == MINUS_EXPR
8126 && integer_onep (TREE_OPERAND (arg0
, 1)))
8127 || (TREE_CODE (arg0
) == PLUS_EXPR
8128 && integer_all_onesp (TREE_OPERAND (arg0
, 1)))))
8129 return fold_build1_loc (loc
, NEGATE_EXPR
, type
,
8130 fold_convert_loc (loc
, type
,
8131 TREE_OPERAND (arg0
, 0)));
8132 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8133 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8134 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8135 fold_convert_loc (loc
, type
,
8136 TREE_OPERAND (arg0
, 0)))))
8137 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, tem
,
8138 fold_convert_loc (loc
, type
,
8139 TREE_OPERAND (arg0
, 1)));
8140 else if (TREE_CODE (arg0
) == BIT_XOR_EXPR
8141 && (tem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
,
8142 fold_convert_loc (loc
, type
,
8143 TREE_OPERAND (arg0
, 1)))))
8144 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
8145 fold_convert_loc (loc
, type
,
8146 TREE_OPERAND (arg0
, 0)), tem
);
8147 /* Perform BIT_NOT_EXPR on each element individually. */
8148 else if (TREE_CODE (arg0
) == VECTOR_CST
)
8152 unsigned count
= VECTOR_CST_NELTS (arg0
), i
;
8154 elements
= XALLOCAVEC (tree
, count
);
8155 for (i
= 0; i
< count
; i
++)
8157 elem
= VECTOR_CST_ELT (arg0
, i
);
8158 elem
= fold_unary_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (type
), elem
);
8159 if (elem
== NULL_TREE
)
8164 return build_vector (type
, elements
);
8169 case TRUTH_NOT_EXPR
:
8170 /* The argument to invert_truthvalue must have Boolean type. */
8171 if (TREE_CODE (TREE_TYPE (arg0
)) != BOOLEAN_TYPE
)
8172 arg0
= fold_convert_loc (loc
, boolean_type_node
, arg0
);
8174 /* Note that the operand of this must be an int
8175 and its values must be 0 or 1.
8176 ("true" is a fixed value perhaps depending on the language,
8177 but we don't handle values other than 1 correctly yet.) */
8178 tem
= fold_truth_not_expr (loc
, arg0
);
8181 return fold_convert_loc (loc
, type
, tem
);
8184 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8185 return fold_convert_loc (loc
, type
, arg0
);
8186 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8187 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 0),
8188 TREE_OPERAND (arg0
, 1));
8189 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8190 return fold_convert_loc (loc
, type
, TREE_REALPART (arg0
));
8191 if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8193 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8194 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), itype
,
8195 fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8196 TREE_OPERAND (arg0
, 0)),
8197 fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8198 TREE_OPERAND (arg0
, 1)));
8199 return fold_convert_loc (loc
, type
, tem
);
8201 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8203 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8204 tem
= fold_build1_loc (loc
, REALPART_EXPR
, itype
,
8205 TREE_OPERAND (arg0
, 0));
8206 return fold_convert_loc (loc
, type
, tem
);
8208 if (TREE_CODE (arg0
) == CALL_EXPR
)
8210 tree fn
= get_callee_fndecl (arg0
);
8211 if (fn
&& DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
8212 switch (DECL_FUNCTION_CODE (fn
))
8214 CASE_FLT_FN (BUILT_IN_CEXPI
):
8215 fn
= mathfn_built_in (type
, BUILT_IN_COS
);
8217 return build_call_expr_loc (loc
, fn
, 1, CALL_EXPR_ARG (arg0
, 0));
8227 if (TREE_CODE (TREE_TYPE (arg0
)) != COMPLEX_TYPE
)
8228 return build_zero_cst (type
);
8229 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
8230 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 1),
8231 TREE_OPERAND (arg0
, 0));
8232 if (TREE_CODE (arg0
) == COMPLEX_CST
)
8233 return fold_convert_loc (loc
, type
, TREE_IMAGPART (arg0
));
8234 if (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8236 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8237 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), itype
,
8238 fold_build1_loc (loc
, IMAGPART_EXPR
, itype
,
8239 TREE_OPERAND (arg0
, 0)),
8240 fold_build1_loc (loc
, IMAGPART_EXPR
, itype
,
8241 TREE_OPERAND (arg0
, 1)));
8242 return fold_convert_loc (loc
, type
, tem
);
8244 if (TREE_CODE (arg0
) == CONJ_EXPR
)
8246 tree itype
= TREE_TYPE (TREE_TYPE (arg0
));
8247 tem
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, TREE_OPERAND (arg0
, 0));
8248 return fold_convert_loc (loc
, type
, negate_expr (tem
));
8250 if (TREE_CODE (arg0
) == CALL_EXPR
)
8252 tree fn
= get_callee_fndecl (arg0
);
8253 if (fn
&& DECL_BUILT_IN_CLASS (fn
) == BUILT_IN_NORMAL
)
8254 switch (DECL_FUNCTION_CODE (fn
))
8256 CASE_FLT_FN (BUILT_IN_CEXPI
):
8257 fn
= mathfn_built_in (type
, BUILT_IN_SIN
);
8259 return build_call_expr_loc (loc
, fn
, 1, CALL_EXPR_ARG (arg0
, 0));
8269 /* Fold *&X to X if X is an lvalue. */
8270 if (TREE_CODE (op0
) == ADDR_EXPR
)
8272 tree op00
= TREE_OPERAND (op0
, 0);
8273 if ((TREE_CODE (op00
) == VAR_DECL
8274 || TREE_CODE (op00
) == PARM_DECL
8275 || TREE_CODE (op00
) == RESULT_DECL
)
8276 && !TREE_READONLY (op00
))
8281 case VEC_UNPACK_LO_EXPR
:
8282 case VEC_UNPACK_HI_EXPR
:
8283 case VEC_UNPACK_FLOAT_LO_EXPR
:
8284 case VEC_UNPACK_FLOAT_HI_EXPR
:
8286 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8288 enum tree_code subcode
;
8290 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2);
8291 if (TREE_CODE (arg0
) != VECTOR_CST
)
8294 elts
= XALLOCAVEC (tree
, nelts
* 2);
8295 if (!vec_cst_ctor_to_array (arg0
, elts
))
8298 if ((!BYTES_BIG_ENDIAN
) ^ (code
== VEC_UNPACK_LO_EXPR
8299 || code
== VEC_UNPACK_FLOAT_LO_EXPR
))
8302 if (code
== VEC_UNPACK_LO_EXPR
|| code
== VEC_UNPACK_HI_EXPR
)
8305 subcode
= FLOAT_EXPR
;
8307 for (i
= 0; i
< nelts
; i
++)
8309 elts
[i
] = fold_convert_const (subcode
, TREE_TYPE (type
), elts
[i
]);
8310 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
8314 return build_vector (type
, elts
);
8317 case REDUC_MIN_EXPR
:
8318 case REDUC_MAX_EXPR
:
8319 case REDUC_PLUS_EXPR
:
8321 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
8323 enum tree_code subcode
;
8325 if (TREE_CODE (op0
) != VECTOR_CST
)
8328 elts
= XALLOCAVEC (tree
, nelts
);
8329 if (!vec_cst_ctor_to_array (op0
, elts
))
8334 case REDUC_MIN_EXPR
: subcode
= MIN_EXPR
; break;
8335 case REDUC_MAX_EXPR
: subcode
= MAX_EXPR
; break;
8336 case REDUC_PLUS_EXPR
: subcode
= PLUS_EXPR
; break;
8337 default: gcc_unreachable ();
8340 for (i
= 1; i
< nelts
; i
++)
8342 elts
[0] = const_binop (subcode
, elts
[0], elts
[i
]);
8343 if (elts
[0] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[0]))
8345 elts
[i
] = build_zero_cst (TREE_TYPE (type
));
8348 return build_vector (type
, elts
);
8353 } /* switch (code) */
8357 /* If the operation was a conversion do _not_ mark a resulting constant
8358 with TREE_OVERFLOW if the original constant was not. These conversions
8359 have implementation defined behavior and retaining the TREE_OVERFLOW
8360 flag here would confuse later passes such as VRP. */
8362 fold_unary_ignore_overflow_loc (location_t loc
, enum tree_code code
,
8363 tree type
, tree op0
)
8365 tree res
= fold_unary_loc (loc
, code
, type
, op0
);
8367 && TREE_CODE (res
) == INTEGER_CST
8368 && TREE_CODE (op0
) == INTEGER_CST
8369 && CONVERT_EXPR_CODE_P (code
))
8370 TREE_OVERFLOW (res
) = TREE_OVERFLOW (op0
);
8375 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8376 operands OP0 and OP1. LOC is the location of the resulting expression.
8377 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8378 Return the folded expression if folding is successful. Otherwise,
8379 return NULL_TREE. */
8381 fold_truth_andor (location_t loc
, enum tree_code code
, tree type
,
8382 tree arg0
, tree arg1
, tree op0
, tree op1
)
8386 /* We only do these simplifications if we are optimizing. */
8390 /* Check for things like (A || B) && (A || C). We can convert this
8391 to A || (B && C). Note that either operator can be any of the four
8392 truth and/or operations and the transformation will still be
8393 valid. Also note that we only care about order for the
8394 ANDIF and ORIF operators. If B contains side effects, this
8395 might change the truth-value of A. */
8396 if (TREE_CODE (arg0
) == TREE_CODE (arg1
)
8397 && (TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
8398 || TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
8399 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
8400 || TREE_CODE (arg0
) == TRUTH_OR_EXPR
)
8401 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0
, 1)))
8403 tree a00
= TREE_OPERAND (arg0
, 0);
8404 tree a01
= TREE_OPERAND (arg0
, 1);
8405 tree a10
= TREE_OPERAND (arg1
, 0);
8406 tree a11
= TREE_OPERAND (arg1
, 1);
8407 int commutative
= ((TREE_CODE (arg0
) == TRUTH_OR_EXPR
8408 || TREE_CODE (arg0
) == TRUTH_AND_EXPR
)
8409 && (code
== TRUTH_AND_EXPR
8410 || code
== TRUTH_OR_EXPR
));
8412 if (operand_equal_p (a00
, a10
, 0))
8413 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8414 fold_build2_loc (loc
, code
, type
, a01
, a11
));
8415 else if (commutative
&& operand_equal_p (a00
, a11
, 0))
8416 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a00
,
8417 fold_build2_loc (loc
, code
, type
, a01
, a10
));
8418 else if (commutative
&& operand_equal_p (a01
, a10
, 0))
8419 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
, a01
,
8420 fold_build2_loc (loc
, code
, type
, a00
, a11
));
8422 /* This case if tricky because we must either have commutative
8423 operators or else A10 must not have side-effects. */
8425 else if ((commutative
|| ! TREE_SIDE_EFFECTS (a10
))
8426 && operand_equal_p (a01
, a11
, 0))
8427 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
8428 fold_build2_loc (loc
, code
, type
, a00
, a10
),
8432 /* See if we can build a range comparison. */
8433 if (0 != (tem
= fold_range_test (loc
, code
, type
, op0
, op1
)))
8436 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ORIF_EXPR
)
8437 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg0
) == TRUTH_ANDIF_EXPR
))
8439 tem
= merge_truthop_with_opposite_arm (loc
, arg0
, arg1
, true);
8441 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
8444 if ((code
== TRUTH_ANDIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ORIF_EXPR
)
8445 || (code
== TRUTH_ORIF_EXPR
&& TREE_CODE (arg1
) == TRUTH_ANDIF_EXPR
))
8447 tem
= merge_truthop_with_opposite_arm (loc
, arg1
, arg0
, false);
8449 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
8452 /* Check for the possibility of merging component references. If our
8453 lhs is another similar operation, try to merge its rhs with our
8454 rhs. Then try to merge our lhs and rhs. */
8455 if (TREE_CODE (arg0
) == code
8456 && 0 != (tem
= fold_truth_andor_1 (loc
, code
, type
,
8457 TREE_OPERAND (arg0
, 1), arg1
)))
8458 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
8460 if ((tem
= fold_truth_andor_1 (loc
, code
, type
, arg0
, arg1
)) != 0)
8463 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8464 && (code
== TRUTH_AND_EXPR
8465 || code
== TRUTH_ANDIF_EXPR
8466 || code
== TRUTH_OR_EXPR
8467 || code
== TRUTH_ORIF_EXPR
))
8469 enum tree_code ncode
, icode
;
8471 ncode
= (code
== TRUTH_ANDIF_EXPR
|| code
== TRUTH_AND_EXPR
)
8472 ? TRUTH_AND_EXPR
: TRUTH_OR_EXPR
;
8473 icode
= ncode
== TRUTH_AND_EXPR
? TRUTH_ANDIF_EXPR
: TRUTH_ORIF_EXPR
;
8475 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8476 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8477 We don't want to pack more than two leafs to a non-IF AND/OR
8479 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8480 equal to IF-CODE, then we don't want to add right-hand operand.
8481 If the inner right-hand side of left-hand operand has
8482 side-effects, or isn't simple, then we can't add to it,
8483 as otherwise we might destroy if-sequence. */
8484 if (TREE_CODE (arg0
) == icode
8485 && simple_operand_p_2 (arg1
)
8486 /* Needed for sequence points to handle trappings, and
8488 && simple_operand_p_2 (TREE_OPERAND (arg0
, 1)))
8490 tem
= fold_build2_loc (loc
, ncode
, type
, TREE_OPERAND (arg0
, 1),
8492 return fold_build2_loc (loc
, icode
, type
, TREE_OPERAND (arg0
, 0),
8495 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8496 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8497 else if (TREE_CODE (arg1
) == icode
8498 && simple_operand_p_2 (arg0
)
8499 /* Needed for sequence points to handle trappings, and
8501 && simple_operand_p_2 (TREE_OPERAND (arg1
, 0)))
8503 tem
= fold_build2_loc (loc
, ncode
, type
,
8504 arg0
, TREE_OPERAND (arg1
, 0));
8505 return fold_build2_loc (loc
, icode
, type
, tem
,
8506 TREE_OPERAND (arg1
, 1));
8508 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8510 For sequence point consistancy, we need to check for trapping,
8511 and side-effects. */
8512 else if (code
== icode
&& simple_operand_p_2 (arg0
)
8513 && simple_operand_p_2 (arg1
))
8514 return fold_build2_loc (loc
, ncode
, type
, arg0
, arg1
);
8520 /* Fold a binary expression of code CODE and type TYPE with operands
8521 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8522 Return the folded expression if folding is successful. Otherwise,
8523 return NULL_TREE. */
8526 fold_minmax (location_t loc
, enum tree_code code
, tree type
, tree op0
, tree op1
)
8528 enum tree_code compl_code
;
8530 if (code
== MIN_EXPR
)
8531 compl_code
= MAX_EXPR
;
8532 else if (code
== MAX_EXPR
)
8533 compl_code
= MIN_EXPR
;
8537 /* MIN (MAX (a, b), b) == b. */
8538 if (TREE_CODE (op0
) == compl_code
8539 && operand_equal_p (TREE_OPERAND (op0
, 1), op1
, 0))
8540 return omit_one_operand_loc (loc
, type
, op1
, TREE_OPERAND (op0
, 0));
8542 /* MIN (MAX (b, a), b) == b. */
8543 if (TREE_CODE (op0
) == compl_code
8544 && operand_equal_p (TREE_OPERAND (op0
, 0), op1
, 0)
8545 && reorder_operands_p (TREE_OPERAND (op0
, 1), op1
))
8546 return omit_one_operand_loc (loc
, type
, op1
, TREE_OPERAND (op0
, 1));
8548 /* MIN (a, MAX (a, b)) == a. */
8549 if (TREE_CODE (op1
) == compl_code
8550 && operand_equal_p (op0
, TREE_OPERAND (op1
, 0), 0)
8551 && reorder_operands_p (op0
, TREE_OPERAND (op1
, 1)))
8552 return omit_one_operand_loc (loc
, type
, op0
, TREE_OPERAND (op1
, 1));
8554 /* MIN (a, MAX (b, a)) == a. */
8555 if (TREE_CODE (op1
) == compl_code
8556 && operand_equal_p (op0
, TREE_OPERAND (op1
, 1), 0)
8557 && reorder_operands_p (op0
, TREE_OPERAND (op1
, 0)))
8558 return omit_one_operand_loc (loc
, type
, op0
, TREE_OPERAND (op1
, 0));
8563 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8564 by changing CODE to reduce the magnitude of constants involved in
8565 ARG0 of the comparison.
8566 Returns a canonicalized comparison tree if a simplification was
8567 possible, otherwise returns NULL_TREE.
8568 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8569 valid if signed overflow is undefined. */
8572 maybe_canonicalize_comparison_1 (location_t loc
, enum tree_code code
, tree type
,
8573 tree arg0
, tree arg1
,
8574 bool *strict_overflow_p
)
8576 enum tree_code code0
= TREE_CODE (arg0
);
8577 tree t
, cst0
= NULL_TREE
;
8581 /* Match A +- CST code arg1 and CST code arg1. We can change the
8582 first form only if overflow is undefined. */
8583 if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
8584 /* In principle pointers also have undefined overflow behavior,
8585 but that causes problems elsewhere. */
8586 && !POINTER_TYPE_P (TREE_TYPE (arg0
))
8587 && (code0
== MINUS_EXPR
8588 || code0
== PLUS_EXPR
)
8589 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
8590 || code0
== INTEGER_CST
))
8593 /* Identify the constant in arg0 and its sign. */
8594 if (code0
== INTEGER_CST
)
8597 cst0
= TREE_OPERAND (arg0
, 1);
8598 sgn0
= tree_int_cst_sgn (cst0
);
8600 /* Overflowed constants and zero will cause problems. */
8601 if (integer_zerop (cst0
)
8602 || TREE_OVERFLOW (cst0
))
8605 /* See if we can reduce the magnitude of the constant in
8606 arg0 by changing the comparison code. */
8607 if (code0
== INTEGER_CST
)
8609 /* CST <= arg1 -> CST-1 < arg1. */
8610 if (code
== LE_EXPR
&& sgn0
== 1)
8612 /* -CST < arg1 -> -CST-1 <= arg1. */
8613 else if (code
== LT_EXPR
&& sgn0
== -1)
8615 /* CST > arg1 -> CST-1 >= arg1. */
8616 else if (code
== GT_EXPR
&& sgn0
== 1)
8618 /* -CST >= arg1 -> -CST-1 > arg1. */
8619 else if (code
== GE_EXPR
&& sgn0
== -1)
8623 /* arg1 code' CST' might be more canonical. */
8628 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8630 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8632 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8633 else if (code
== GT_EXPR
8634 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8636 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8637 else if (code
== LE_EXPR
8638 && code0
== ((sgn0
== -1) ? MINUS_EXPR
: PLUS_EXPR
))
8640 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8641 else if (code
== GE_EXPR
8642 && code0
== ((sgn0
== -1) ? PLUS_EXPR
: MINUS_EXPR
))
8646 *strict_overflow_p
= true;
8649 /* Now build the constant reduced in magnitude. But not if that
8650 would produce one outside of its types range. */
8651 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0
))
8653 && TYPE_MIN_VALUE (TREE_TYPE (cst0
))
8654 && tree_int_cst_equal (cst0
, TYPE_MIN_VALUE (TREE_TYPE (cst0
))))
8656 && TYPE_MAX_VALUE (TREE_TYPE (cst0
))
8657 && tree_int_cst_equal (cst0
, TYPE_MAX_VALUE (TREE_TYPE (cst0
))))))
8658 /* We cannot swap the comparison here as that would cause us to
8659 endlessly recurse. */
8662 t
= int_const_binop (sgn0
== -1 ? PLUS_EXPR
: MINUS_EXPR
,
8663 cst0
, build_int_cst (TREE_TYPE (cst0
), 1));
8664 if (code0
!= INTEGER_CST
)
8665 t
= fold_build2_loc (loc
, code0
, TREE_TYPE (arg0
), TREE_OPERAND (arg0
, 0), t
);
8666 t
= fold_convert (TREE_TYPE (arg1
), t
);
8668 /* If swapping might yield to a more canonical form, do so. */
8670 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, arg1
, t
);
8672 return fold_build2_loc (loc
, code
, type
, t
, arg1
);
8675 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8676 overflow further. Try to decrease the magnitude of constants involved
8677 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8678 and put sole constants at the second argument position.
8679 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8682 maybe_canonicalize_comparison (location_t loc
, enum tree_code code
, tree type
,
8683 tree arg0
, tree arg1
)
8686 bool strict_overflow_p
;
8687 const char * const warnmsg
= G_("assuming signed overflow does not occur "
8688 "when reducing constant in comparison");
8690 /* Try canonicalization by simplifying arg0. */
8691 strict_overflow_p
= false;
8692 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg0
, arg1
,
8693 &strict_overflow_p
);
8696 if (strict_overflow_p
)
8697 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8701 /* Try canonicalization by simplifying arg1 using the swapped
8703 code
= swap_tree_comparison (code
);
8704 strict_overflow_p
= false;
8705 t
= maybe_canonicalize_comparison_1 (loc
, code
, type
, arg1
, arg0
,
8706 &strict_overflow_p
);
8707 if (t
&& strict_overflow_p
)
8708 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_MAGNITUDE
);
8712 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8713 space. This is used to avoid issuing overflow warnings for
8714 expressions like &p->x which can not wrap. */
8717 pointer_may_wrap_p (tree base
, tree offset
, HOST_WIDE_INT bitpos
)
8719 double_int di_offset
, total
;
8721 if (!POINTER_TYPE_P (TREE_TYPE (base
)))
8727 if (offset
== NULL_TREE
)
8728 di_offset
= double_int_zero
;
8729 else if (TREE_CODE (offset
) != INTEGER_CST
|| TREE_OVERFLOW (offset
))
8732 di_offset
= TREE_INT_CST (offset
);
8735 double_int units
= double_int::from_uhwi (bitpos
/ BITS_PER_UNIT
);
8736 total
= di_offset
.add_with_sign (units
, true, &overflow
);
8740 if (total
.high
!= 0)
8743 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (TREE_TYPE (base
)));
8747 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8749 if (TREE_CODE (base
) == ADDR_EXPR
)
8751 HOST_WIDE_INT base_size
;
8753 base_size
= int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base
, 0)));
8754 if (base_size
> 0 && size
< base_size
)
8758 return total
.low
> (unsigned HOST_WIDE_INT
) size
;
8761 /* Subroutine of fold_binary. This routine performs all of the
8762 transformations that are common to the equality/inequality
8763 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8764 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8765 fold_binary should call fold_binary. Fold a comparison with
8766 tree code CODE and type TYPE with operands OP0 and OP1. Return
8767 the folded comparison or NULL_TREE. */
8770 fold_comparison (location_t loc
, enum tree_code code
, tree type
,
8773 tree arg0
, arg1
, tem
;
8778 STRIP_SIGN_NOPS (arg0
);
8779 STRIP_SIGN_NOPS (arg1
);
8781 tem
= fold_relational_const (code
, type
, arg0
, arg1
);
8782 if (tem
!= NULL_TREE
)
8785 /* If one arg is a real or integer constant, put it last. */
8786 if (tree_swap_operands_p (arg0
, arg1
, true))
8787 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
, op1
, op0
);
8789 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1. */
8790 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
8791 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
8792 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
8793 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
8794 && (TREE_CODE (arg1
) == INTEGER_CST
8795 && !TREE_OVERFLOW (arg1
)))
8797 tree const1
= TREE_OPERAND (arg0
, 1);
8799 tree variable
= TREE_OPERAND (arg0
, 0);
8802 lhs_add
= TREE_CODE (arg0
) != PLUS_EXPR
;
8804 lhs
= fold_build2_loc (loc
, lhs_add
? PLUS_EXPR
: MINUS_EXPR
,
8805 TREE_TYPE (arg1
), const2
, const1
);
8807 /* If the constant operation overflowed this can be
8808 simplified as a comparison against INT_MAX/INT_MIN. */
8809 if (TREE_CODE (lhs
) == INTEGER_CST
8810 && TREE_OVERFLOW (lhs
))
8812 int const1_sgn
= tree_int_cst_sgn (const1
);
8813 enum tree_code code2
= code
;
8815 /* Get the sign of the constant on the lhs if the
8816 operation were VARIABLE + CONST1. */
8817 if (TREE_CODE (arg0
) == MINUS_EXPR
)
8818 const1_sgn
= -const1_sgn
;
8820 /* The sign of the constant determines if we overflowed
8821 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8822 Canonicalize to the INT_MIN overflow by swapping the comparison
8824 if (const1_sgn
== -1)
8825 code2
= swap_tree_comparison (code
);
8827 /* We now can look at the canonicalized case
8828 VARIABLE + 1 CODE2 INT_MIN
8829 and decide on the result. */
8830 if (code2
== LT_EXPR
8832 || code2
== EQ_EXPR
)
8833 return omit_one_operand_loc (loc
, type
, boolean_false_node
, variable
);
8834 else if (code2
== NE_EXPR
8836 || code2
== GT_EXPR
)
8837 return omit_one_operand_loc (loc
, type
, boolean_true_node
, variable
);
8840 if (TREE_CODE (lhs
) == TREE_CODE (arg1
)
8841 && (TREE_CODE (lhs
) != INTEGER_CST
8842 || !TREE_OVERFLOW (lhs
)))
8844 if (code
!= EQ_EXPR
&& code
!= NE_EXPR
)
8845 fold_overflow_warning ("assuming signed overflow does not occur "
8846 "when changing X +- C1 cmp C2 to "
8848 WARN_STRICT_OVERFLOW_COMPARISON
);
8849 return fold_build2_loc (loc
, code
, type
, variable
, lhs
);
8853 /* For comparisons of pointers we can decompose it to a compile time
8854 comparison of the base objects and the offsets into the object.
8855 This requires at least one operand being an ADDR_EXPR or a
8856 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
8857 if (POINTER_TYPE_P (TREE_TYPE (arg0
))
8858 && (TREE_CODE (arg0
) == ADDR_EXPR
8859 || TREE_CODE (arg1
) == ADDR_EXPR
8860 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
8861 || TREE_CODE (arg1
) == POINTER_PLUS_EXPR
))
8863 tree base0
, base1
, offset0
= NULL_TREE
, offset1
= NULL_TREE
;
8864 HOST_WIDE_INT bitsize
, bitpos0
= 0, bitpos1
= 0;
8865 enum machine_mode mode
;
8866 int volatilep
, unsignedp
;
8867 bool indirect_base0
= false, indirect_base1
= false;
8869 /* Get base and offset for the access. Strip ADDR_EXPR for
8870 get_inner_reference, but put it back by stripping INDIRECT_REF
8871 off the base object if possible. indirect_baseN will be true
8872 if baseN is not an address but refers to the object itself. */
8874 if (TREE_CODE (arg0
) == ADDR_EXPR
)
8876 base0
= get_inner_reference (TREE_OPERAND (arg0
, 0),
8877 &bitsize
, &bitpos0
, &offset0
, &mode
,
8878 &unsignedp
, &volatilep
, false);
8879 if (TREE_CODE (base0
) == INDIRECT_REF
)
8880 base0
= TREE_OPERAND (base0
, 0);
8882 indirect_base0
= true;
8884 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
8886 base0
= TREE_OPERAND (arg0
, 0);
8887 STRIP_SIGN_NOPS (base0
);
8888 if (TREE_CODE (base0
) == ADDR_EXPR
)
8890 base0
= TREE_OPERAND (base0
, 0);
8891 indirect_base0
= true;
8893 offset0
= TREE_OPERAND (arg0
, 1);
8894 if (host_integerp (offset0
, 0))
8896 HOST_WIDE_INT off
= size_low_cst (offset0
);
8897 if ((HOST_WIDE_INT
) (((unsigned HOST_WIDE_INT
) off
)
8899 / BITS_PER_UNIT
== (HOST_WIDE_INT
) off
)
8901 bitpos0
= off
* BITS_PER_UNIT
;
8902 offset0
= NULL_TREE
;
8908 if (TREE_CODE (arg1
) == ADDR_EXPR
)
8910 base1
= get_inner_reference (TREE_OPERAND (arg1
, 0),
8911 &bitsize
, &bitpos1
, &offset1
, &mode
,
8912 &unsignedp
, &volatilep
, false);
8913 if (TREE_CODE (base1
) == INDIRECT_REF
)
8914 base1
= TREE_OPERAND (base1
, 0);
8916 indirect_base1
= true;
8918 else if (TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
8920 base1
= TREE_OPERAND (arg1
, 0);
8921 STRIP_SIGN_NOPS (base1
);
8922 if (TREE_CODE (base1
) == ADDR_EXPR
)
8924 base1
= TREE_OPERAND (base1
, 0);
8925 indirect_base1
= true;
8927 offset1
= TREE_OPERAND (arg1
, 1);
8928 if (host_integerp (offset1
, 0))
8930 HOST_WIDE_INT off
= size_low_cst (offset1
);
8931 if ((HOST_WIDE_INT
) (((unsigned HOST_WIDE_INT
) off
)
8933 / BITS_PER_UNIT
== (HOST_WIDE_INT
) off
)
8935 bitpos1
= off
* BITS_PER_UNIT
;
8936 offset1
= NULL_TREE
;
8941 /* A local variable can never be pointed to by
8942 the default SSA name of an incoming parameter. */
8943 if ((TREE_CODE (arg0
) == ADDR_EXPR
8945 && TREE_CODE (base0
) == VAR_DECL
8946 && auto_var_in_fn_p (base0
, current_function_decl
)
8948 && TREE_CODE (base1
) == SSA_NAME
8949 && SSA_NAME_IS_DEFAULT_DEF (base1
)
8950 && TREE_CODE (SSA_NAME_VAR (base1
)) == PARM_DECL
)
8951 || (TREE_CODE (arg1
) == ADDR_EXPR
8953 && TREE_CODE (base1
) == VAR_DECL
8954 && auto_var_in_fn_p (base1
, current_function_decl
)
8956 && TREE_CODE (base0
) == SSA_NAME
8957 && SSA_NAME_IS_DEFAULT_DEF (base0
)
8958 && TREE_CODE (SSA_NAME_VAR (base0
)) == PARM_DECL
))
8960 if (code
== NE_EXPR
)
8961 return constant_boolean_node (1, type
);
8962 else if (code
== EQ_EXPR
)
8963 return constant_boolean_node (0, type
);
8965 /* If we have equivalent bases we might be able to simplify. */
8966 else if (indirect_base0
== indirect_base1
8967 && operand_equal_p (base0
, base1
, 0))
8969 /* We can fold this expression to a constant if the non-constant
8970 offset parts are equal. */
8971 if ((offset0
== offset1
8972 || (offset0
&& offset1
8973 && operand_equal_p (offset0
, offset1
, 0)))
8976 || (indirect_base0
&& DECL_P (base0
))
8977 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
8982 && bitpos0
!= bitpos1
8983 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
8984 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
8985 fold_overflow_warning (("assuming pointer wraparound does not "
8986 "occur when comparing P +- C1 with "
8988 WARN_STRICT_OVERFLOW_CONDITIONAL
);
8993 return constant_boolean_node (bitpos0
== bitpos1
, type
);
8995 return constant_boolean_node (bitpos0
!= bitpos1
, type
);
8997 return constant_boolean_node (bitpos0
< bitpos1
, type
);
8999 return constant_boolean_node (bitpos0
<= bitpos1
, type
);
9001 return constant_boolean_node (bitpos0
>= bitpos1
, type
);
9003 return constant_boolean_node (bitpos0
> bitpos1
, type
);
9007 /* We can simplify the comparison to a comparison of the variable
9008 offset parts if the constant offset parts are equal.
9009 Be careful to use signed size type here because otherwise we
9010 mess with array offsets in the wrong way. This is possible
9011 because pointer arithmetic is restricted to retain within an
9012 object and overflow on pointer differences is undefined as of
9013 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
9014 else if (bitpos0
== bitpos1
9015 && ((code
== EQ_EXPR
|| code
== NE_EXPR
)
9016 || (indirect_base0
&& DECL_P (base0
))
9017 || POINTER_TYPE_OVERFLOW_UNDEFINED
))
9019 /* By converting to signed size type we cover middle-end pointer
9020 arithmetic which operates on unsigned pointer types of size
9021 type size and ARRAY_REF offsets which are properly sign or
9022 zero extended from their type in case it is narrower than
9024 if (offset0
== NULL_TREE
)
9025 offset0
= build_int_cst (ssizetype
, 0);
9027 offset0
= fold_convert_loc (loc
, ssizetype
, offset0
);
9028 if (offset1
== NULL_TREE
)
9029 offset1
= build_int_cst (ssizetype
, 0);
9031 offset1
= fold_convert_loc (loc
, ssizetype
, offset1
);
9035 && (pointer_may_wrap_p (base0
, offset0
, bitpos0
)
9036 || pointer_may_wrap_p (base1
, offset1
, bitpos1
)))
9037 fold_overflow_warning (("assuming pointer wraparound does not "
9038 "occur when comparing P +- C1 with "
9040 WARN_STRICT_OVERFLOW_COMPARISON
);
9042 return fold_build2_loc (loc
, code
, type
, offset0
, offset1
);
9045 /* For non-equal bases we can simplify if they are addresses
9046 of local binding decls or constants. */
9047 else if (indirect_base0
&& indirect_base1
9048 /* We know that !operand_equal_p (base0, base1, 0)
9049 because the if condition was false. But make
9050 sure two decls are not the same. */
9052 && TREE_CODE (arg0
) == ADDR_EXPR
9053 && TREE_CODE (arg1
) == ADDR_EXPR
9054 && (((TREE_CODE (base0
) == VAR_DECL
9055 || TREE_CODE (base0
) == PARM_DECL
)
9056 && (targetm
.binds_local_p (base0
)
9057 || CONSTANT_CLASS_P (base1
)))
9058 || CONSTANT_CLASS_P (base0
))
9059 && (((TREE_CODE (base1
) == VAR_DECL
9060 || TREE_CODE (base1
) == PARM_DECL
)
9061 && (targetm
.binds_local_p (base1
)
9062 || CONSTANT_CLASS_P (base0
)))
9063 || CONSTANT_CLASS_P (base1
)))
9065 if (code
== EQ_EXPR
)
9066 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
9068 else if (code
== NE_EXPR
)
9069 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
9072 /* For equal offsets we can simplify to a comparison of the
9074 else if (bitpos0
== bitpos1
9076 ? base0
!= TREE_OPERAND (arg0
, 0) : base0
!= arg0
)
9078 ? base1
!= TREE_OPERAND (arg1
, 0) : base1
!= arg1
)
9079 && ((offset0
== offset1
)
9080 || (offset0
&& offset1
9081 && operand_equal_p (offset0
, offset1
, 0))))
9084 base0
= build_fold_addr_expr_loc (loc
, base0
);
9086 base1
= build_fold_addr_expr_loc (loc
, base1
);
9087 return fold_build2_loc (loc
, code
, type
, base0
, base1
);
9091 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9092 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9093 the resulting offset is smaller in absolute value than the
9095 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
9096 && (TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
9097 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9098 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
9099 && (TREE_CODE (arg1
) == PLUS_EXPR
|| TREE_CODE (arg1
) == MINUS_EXPR
)
9100 && (TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
9101 && !TREE_OVERFLOW (TREE_OPERAND (arg1
, 1))))
9103 tree const1
= TREE_OPERAND (arg0
, 1);
9104 tree const2
= TREE_OPERAND (arg1
, 1);
9105 tree variable1
= TREE_OPERAND (arg0
, 0);
9106 tree variable2
= TREE_OPERAND (arg1
, 0);
9108 const char * const warnmsg
= G_("assuming signed overflow does not "
9109 "occur when combining constants around "
9112 /* Put the constant on the side where it doesn't overflow and is
9113 of lower absolute value than before. */
9114 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
9115 ? MINUS_EXPR
: PLUS_EXPR
,
9117 if (!TREE_OVERFLOW (cst
)
9118 && tree_int_cst_compare (const2
, cst
) == tree_int_cst_sgn (const2
))
9120 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
9121 return fold_build2_loc (loc
, code
, type
,
9123 fold_build2_loc (loc
,
9124 TREE_CODE (arg1
), TREE_TYPE (arg1
),
9128 cst
= int_const_binop (TREE_CODE (arg0
) == TREE_CODE (arg1
)
9129 ? MINUS_EXPR
: PLUS_EXPR
,
9131 if (!TREE_OVERFLOW (cst
)
9132 && tree_int_cst_compare (const1
, cst
) == tree_int_cst_sgn (const1
))
9134 fold_overflow_warning (warnmsg
, WARN_STRICT_OVERFLOW_COMPARISON
);
9135 return fold_build2_loc (loc
, code
, type
,
9136 fold_build2_loc (loc
, TREE_CODE (arg0
), TREE_TYPE (arg0
),
9142 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9143 signed arithmetic case. That form is created by the compiler
9144 often enough for folding it to be of value. One example is in
9145 computing loop trip counts after Operator Strength Reduction. */
9146 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0
))
9147 && TREE_CODE (arg0
) == MULT_EXPR
9148 && (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9149 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1)))
9150 && integer_zerop (arg1
))
9152 tree const1
= TREE_OPERAND (arg0
, 1);
9153 tree const2
= arg1
; /* zero */
9154 tree variable1
= TREE_OPERAND (arg0
, 0);
9155 enum tree_code cmp_code
= code
;
9157 /* Handle unfolded multiplication by zero. */
9158 if (integer_zerop (const1
))
9159 return fold_build2_loc (loc
, cmp_code
, type
, const1
, const2
);
9161 fold_overflow_warning (("assuming signed overflow does not occur when "
9162 "eliminating multiplication in comparison "
9164 WARN_STRICT_OVERFLOW_COMPARISON
);
9166 /* If const1 is negative we swap the sense of the comparison. */
9167 if (tree_int_cst_sgn (const1
) < 0)
9168 cmp_code
= swap_tree_comparison (cmp_code
);
9170 return fold_build2_loc (loc
, cmp_code
, type
, variable1
, const2
);
9173 tem
= maybe_canonicalize_comparison (loc
, code
, type
, arg0
, arg1
);
9177 if (FLOAT_TYPE_P (TREE_TYPE (arg0
)))
9179 tree targ0
= strip_float_extensions (arg0
);
9180 tree targ1
= strip_float_extensions (arg1
);
9181 tree newtype
= TREE_TYPE (targ0
);
9183 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
9184 newtype
= TREE_TYPE (targ1
);
9186 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9187 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
9188 return fold_build2_loc (loc
, code
, type
,
9189 fold_convert_loc (loc
, newtype
, targ0
),
9190 fold_convert_loc (loc
, newtype
, targ1
));
9192 /* (-a) CMP (-b) -> b CMP a */
9193 if (TREE_CODE (arg0
) == NEGATE_EXPR
9194 && TREE_CODE (arg1
) == NEGATE_EXPR
)
9195 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg1
, 0),
9196 TREE_OPERAND (arg0
, 0));
9198 if (TREE_CODE (arg1
) == REAL_CST
)
9200 REAL_VALUE_TYPE cst
;
9201 cst
= TREE_REAL_CST (arg1
);
9203 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9204 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
9205 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9206 TREE_OPERAND (arg0
, 0),
9207 build_real (TREE_TYPE (arg1
),
9208 real_value_negate (&cst
)));
9210 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9211 /* a CMP (-0) -> a CMP 0 */
9212 if (REAL_VALUE_MINUS_ZERO (cst
))
9213 return fold_build2_loc (loc
, code
, type
, arg0
,
9214 build_real (TREE_TYPE (arg1
), dconst0
));
9216 /* x != NaN is always true, other ops are always false. */
9217 if (REAL_VALUE_ISNAN (cst
)
9218 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1
))))
9220 tem
= (code
== NE_EXPR
) ? integer_one_node
: integer_zero_node
;
9221 return omit_one_operand_loc (loc
, type
, tem
, arg0
);
9224 /* Fold comparisons against infinity. */
9225 if (REAL_VALUE_ISINF (cst
)
9226 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
))))
9228 tem
= fold_inf_compare (loc
, code
, type
, arg0
, arg1
);
9229 if (tem
!= NULL_TREE
)
9234 /* If this is a comparison of a real constant with a PLUS_EXPR
9235 or a MINUS_EXPR of a real constant, we can convert it into a
9236 comparison with a revised real constant as long as no overflow
9237 occurs when unsafe_math_optimizations are enabled. */
9238 if (flag_unsafe_math_optimizations
9239 && TREE_CODE (arg1
) == REAL_CST
9240 && (TREE_CODE (arg0
) == PLUS_EXPR
9241 || TREE_CODE (arg0
) == MINUS_EXPR
)
9242 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
9243 && 0 != (tem
= const_binop (TREE_CODE (arg0
) == PLUS_EXPR
9244 ? MINUS_EXPR
: PLUS_EXPR
,
9245 arg1
, TREE_OPERAND (arg0
, 1)))
9246 && !TREE_OVERFLOW (tem
))
9247 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
9249 /* Likewise, we can simplify a comparison of a real constant with
9250 a MINUS_EXPR whose first operand is also a real constant, i.e.
9251 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9252 floating-point types only if -fassociative-math is set. */
9253 if (flag_associative_math
9254 && TREE_CODE (arg1
) == REAL_CST
9255 && TREE_CODE (arg0
) == MINUS_EXPR
9256 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
9257 && 0 != (tem
= const_binop (MINUS_EXPR
, TREE_OPERAND (arg0
, 0),
9259 && !TREE_OVERFLOW (tem
))
9260 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9261 TREE_OPERAND (arg0
, 1), tem
);
9263 /* Fold comparisons against built-in math functions. */
9264 if (TREE_CODE (arg1
) == REAL_CST
9265 && flag_unsafe_math_optimizations
9266 && ! flag_errno_math
)
9268 enum built_in_function fcode
= builtin_mathfn_code (arg0
);
9270 if (fcode
!= END_BUILTINS
)
9272 tem
= fold_mathfn_compare (loc
, fcode
, code
, type
, arg0
, arg1
);
9273 if (tem
!= NULL_TREE
)
9279 if (TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
9280 && CONVERT_EXPR_P (arg0
))
9282 /* If we are widening one operand of an integer comparison,
9283 see if the other operand is similarly being widened. Perhaps we
9284 can do the comparison in the narrower type. */
9285 tem
= fold_widened_comparison (loc
, code
, type
, arg0
, arg1
);
9289 /* Or if we are changing signedness. */
9290 tem
= fold_sign_changed_comparison (loc
, code
, type
, arg0
, arg1
);
9295 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9296 constant, we can simplify it. */
9297 if (TREE_CODE (arg1
) == INTEGER_CST
9298 && (TREE_CODE (arg0
) == MIN_EXPR
9299 || TREE_CODE (arg0
) == MAX_EXPR
)
9300 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
9302 tem
= optimize_minmax_comparison (loc
, code
, type
, op0
, op1
);
9307 /* Simplify comparison of something with itself. (For IEEE
9308 floating-point, we can only do some of these simplifications.) */
9309 if (operand_equal_p (arg0
, arg1
, 0))
9314 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
))
9315 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9316 return constant_boolean_node (1, type
);
9321 if (! FLOAT_TYPE_P (TREE_TYPE (arg0
))
9322 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9323 return constant_boolean_node (1, type
);
9324 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
, arg1
);
9327 /* For NE, we can only do this simplification if integer
9328 or we don't honor IEEE floating point NaNs. */
9329 if (FLOAT_TYPE_P (TREE_TYPE (arg0
))
9330 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
))))
9332 /* ... fall through ... */
9335 return constant_boolean_node (0, type
);
9341 /* If we are comparing an expression that just has comparisons
9342 of two integer values, arithmetic expressions of those comparisons,
9343 and constants, we can simplify it. There are only three cases
9344 to check: the two values can either be equal, the first can be
9345 greater, or the second can be greater. Fold the expression for
9346 those three values. Since each value must be 0 or 1, we have
9347 eight possibilities, each of which corresponds to the constant 0
9348 or 1 or one of the six possible comparisons.
9350 This handles common cases like (a > b) == 0 but also handles
9351 expressions like ((x > y) - (y > x)) > 0, which supposedly
9352 occur in macroized code. */
9354 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) != INTEGER_CST
)
9356 tree cval1
= 0, cval2
= 0;
9359 if (twoval_comparison_p (arg0
, &cval1
, &cval2
, &save_p
)
9360 /* Don't handle degenerate cases here; they should already
9361 have been handled anyway. */
9362 && cval1
!= 0 && cval2
!= 0
9363 && ! (TREE_CONSTANT (cval1
) && TREE_CONSTANT (cval2
))
9364 && TREE_TYPE (cval1
) == TREE_TYPE (cval2
)
9365 && INTEGRAL_TYPE_P (TREE_TYPE (cval1
))
9366 && TYPE_MAX_VALUE (TREE_TYPE (cval1
))
9367 && TYPE_MAX_VALUE (TREE_TYPE (cval2
))
9368 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1
)),
9369 TYPE_MAX_VALUE (TREE_TYPE (cval2
)), 0))
9371 tree maxval
= TYPE_MAX_VALUE (TREE_TYPE (cval1
));
9372 tree minval
= TYPE_MIN_VALUE (TREE_TYPE (cval1
));
9374 /* We can't just pass T to eval_subst in case cval1 or cval2
9375 was the same as ARG1. */
9378 = fold_build2_loc (loc
, code
, type
,
9379 eval_subst (loc
, arg0
, cval1
, maxval
,
9383 = fold_build2_loc (loc
, code
, type
,
9384 eval_subst (loc
, arg0
, cval1
, maxval
,
9388 = fold_build2_loc (loc
, code
, type
,
9389 eval_subst (loc
, arg0
, cval1
, minval
,
9393 /* All three of these results should be 0 or 1. Confirm they are.
9394 Then use those values to select the proper code to use. */
9396 if (TREE_CODE (high_result
) == INTEGER_CST
9397 && TREE_CODE (equal_result
) == INTEGER_CST
9398 && TREE_CODE (low_result
) == INTEGER_CST
)
9400 /* Make a 3-bit mask with the high-order bit being the
9401 value for `>', the next for '=', and the low for '<'. */
9402 switch ((integer_onep (high_result
) * 4)
9403 + (integer_onep (equal_result
) * 2)
9404 + integer_onep (low_result
))
9408 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
9429 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
9434 tem
= save_expr (build2 (code
, type
, cval1
, cval2
));
9435 SET_EXPR_LOCATION (tem
, loc
);
9438 return fold_build2_loc (loc
, code
, type
, cval1
, cval2
);
9443 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9444 into a single range test. */
9445 if ((TREE_CODE (arg0
) == TRUNC_DIV_EXPR
9446 || TREE_CODE (arg0
) == EXACT_DIV_EXPR
)
9447 && TREE_CODE (arg1
) == INTEGER_CST
9448 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
9449 && !integer_zerop (TREE_OPERAND (arg0
, 1))
9450 && !TREE_OVERFLOW (TREE_OPERAND (arg0
, 1))
9451 && !TREE_OVERFLOW (arg1
))
9453 tem
= fold_div_compare (loc
, code
, type
, arg0
, arg1
);
9454 if (tem
!= NULL_TREE
)
9458 /* Fold ~X op ~Y as Y op X. */
9459 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9460 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
9462 tree cmp_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
9463 return fold_build2_loc (loc
, code
, type
,
9464 fold_convert_loc (loc
, cmp_type
,
9465 TREE_OPERAND (arg1
, 0)),
9466 TREE_OPERAND (arg0
, 0));
9469 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9470 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
9471 && TREE_CODE (arg1
) == INTEGER_CST
)
9473 tree cmp_type
= TREE_TYPE (TREE_OPERAND (arg0
, 0));
9474 return fold_build2_loc (loc
, swap_tree_comparison (code
), type
,
9475 TREE_OPERAND (arg0
, 0),
9476 fold_build1_loc (loc
, BIT_NOT_EXPR
, cmp_type
,
9477 fold_convert_loc (loc
, cmp_type
, arg1
)));
9484 /* Subroutine of fold_binary. Optimize complex multiplications of the
9485 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9486 argument EXPR represents the expression "z" of type TYPE. */
9489 fold_mult_zconjz (location_t loc
, tree type
, tree expr
)
9491 tree itype
= TREE_TYPE (type
);
9492 tree rpart
, ipart
, tem
;
9494 if (TREE_CODE (expr
) == COMPLEX_EXPR
)
9496 rpart
= TREE_OPERAND (expr
, 0);
9497 ipart
= TREE_OPERAND (expr
, 1);
9499 else if (TREE_CODE (expr
) == COMPLEX_CST
)
9501 rpart
= TREE_REALPART (expr
);
9502 ipart
= TREE_IMAGPART (expr
);
9506 expr
= save_expr (expr
);
9507 rpart
= fold_build1_loc (loc
, REALPART_EXPR
, itype
, expr
);
9508 ipart
= fold_build1_loc (loc
, IMAGPART_EXPR
, itype
, expr
);
9511 rpart
= save_expr (rpart
);
9512 ipart
= save_expr (ipart
);
9513 tem
= fold_build2_loc (loc
, PLUS_EXPR
, itype
,
9514 fold_build2_loc (loc
, MULT_EXPR
, itype
, rpart
, rpart
),
9515 fold_build2_loc (loc
, MULT_EXPR
, itype
, ipart
, ipart
));
9516 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, tem
,
9517 build_zero_cst (itype
));
9521 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9522 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9523 guarantees that P and N have the same least significant log2(M) bits.
9524 N is not otherwise constrained. In particular, N is not normalized to
9525 0 <= N < M as is common. In general, the precise value of P is unknown.
9526 M is chosen as large as possible such that constant N can be determined.
9528 Returns M and sets *RESIDUE to N.
9530 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9531 account. This is not always possible due to PR 35705.
9534 static unsigned HOST_WIDE_INT
9535 get_pointer_modulus_and_residue (tree expr
, unsigned HOST_WIDE_INT
*residue
,
9536 bool allow_func_align
)
9538 enum tree_code code
;
9542 code
= TREE_CODE (expr
);
9543 if (code
== ADDR_EXPR
)
9545 unsigned int bitalign
;
9546 get_object_alignment_1 (TREE_OPERAND (expr
, 0), &bitalign
, residue
);
9547 *residue
/= BITS_PER_UNIT
;
9548 return bitalign
/ BITS_PER_UNIT
;
9550 else if (code
== POINTER_PLUS_EXPR
)
9553 unsigned HOST_WIDE_INT modulus
;
9554 enum tree_code inner_code
;
9556 op0
= TREE_OPERAND (expr
, 0);
9558 modulus
= get_pointer_modulus_and_residue (op0
, residue
,
9561 op1
= TREE_OPERAND (expr
, 1);
9563 inner_code
= TREE_CODE (op1
);
9564 if (inner_code
== INTEGER_CST
)
9566 *residue
+= TREE_INT_CST_LOW (op1
);
9569 else if (inner_code
== MULT_EXPR
)
9571 op1
= TREE_OPERAND (op1
, 1);
9572 if (TREE_CODE (op1
) == INTEGER_CST
)
9574 unsigned HOST_WIDE_INT align
;
9576 /* Compute the greatest power-of-2 divisor of op1. */
9577 align
= TREE_INT_CST_LOW (op1
);
9580 /* If align is non-zero and less than *modulus, replace
9581 *modulus with align., If align is 0, then either op1 is 0
9582 or the greatest power-of-2 divisor of op1 doesn't fit in an
9583 unsigned HOST_WIDE_INT. In either case, no additional
9584 constraint is imposed. */
9586 modulus
= MIN (modulus
, align
);
9593 /* If we get here, we were unable to determine anything useful about the
9598 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
9599 CONSTRUCTOR ARG into array ELTS and return true if successful. */
9602 vec_cst_ctor_to_array (tree arg
, tree
*elts
)
9604 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg
)), i
;
9606 if (TREE_CODE (arg
) == VECTOR_CST
)
9608 for (i
= 0; i
< VECTOR_CST_NELTS (arg
); ++i
)
9609 elts
[i
] = VECTOR_CST_ELT (arg
, i
);
9611 else if (TREE_CODE (arg
) == CONSTRUCTOR
)
9613 constructor_elt
*elt
;
9615 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg
), i
, elt
)
9616 if (i
>= nelts
|| TREE_CODE (TREE_TYPE (elt
->value
)) == VECTOR_TYPE
)
9619 elts
[i
] = elt
->value
;
9623 for (; i
< nelts
; i
++)
9625 = fold_convert (TREE_TYPE (TREE_TYPE (arg
)), integer_zero_node
);
9629 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
9630 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
9631 NULL_TREE otherwise. */
9634 fold_vec_perm (tree type
, tree arg0
, tree arg1
, const unsigned char *sel
)
9636 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
9638 bool need_ctor
= false;
9640 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
9641 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
);
9642 if (TREE_TYPE (TREE_TYPE (arg0
)) != TREE_TYPE (type
)
9643 || TREE_TYPE (TREE_TYPE (arg1
)) != TREE_TYPE (type
))
9646 elts
= XALLOCAVEC (tree
, nelts
* 3);
9647 if (!vec_cst_ctor_to_array (arg0
, elts
)
9648 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
))
9651 for (i
= 0; i
< nelts
; i
++)
9653 if (!CONSTANT_CLASS_P (elts
[sel
[i
]]))
9655 elts
[i
+ 2 * nelts
] = unshare_expr (elts
[sel
[i
]]);
9660 vec
<constructor_elt
, va_gc
> *v
;
9661 vec_alloc (v
, nelts
);
9662 for (i
= 0; i
< nelts
; i
++)
9663 CONSTRUCTOR_APPEND_ELT (v
, NULL_TREE
, elts
[2 * nelts
+ i
]);
9664 return build_constructor (type
, v
);
9667 return build_vector (type
, &elts
[2 * nelts
]);
9670 /* Try to fold a pointer difference of type TYPE two address expressions of
9671 array references AREF0 and AREF1 using location LOC. Return a
9672 simplified expression for the difference or NULL_TREE. */
9675 fold_addr_of_array_ref_difference (location_t loc
, tree type
,
9676 tree aref0
, tree aref1
)
9678 tree base0
= TREE_OPERAND (aref0
, 0);
9679 tree base1
= TREE_OPERAND (aref1
, 0);
9680 tree base_offset
= build_int_cst (type
, 0);
9682 /* If the bases are array references as well, recurse. If the bases
9683 are pointer indirections compute the difference of the pointers.
9684 If the bases are equal, we are set. */
9685 if ((TREE_CODE (base0
) == ARRAY_REF
9686 && TREE_CODE (base1
) == ARRAY_REF
9688 = fold_addr_of_array_ref_difference (loc
, type
, base0
, base1
)))
9689 || (INDIRECT_REF_P (base0
)
9690 && INDIRECT_REF_P (base1
)
9691 && (base_offset
= fold_binary_loc (loc
, MINUS_EXPR
, type
,
9692 TREE_OPERAND (base0
, 0),
9693 TREE_OPERAND (base1
, 0))))
9694 || operand_equal_p (base0
, base1
, 0))
9696 tree op0
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref0
, 1));
9697 tree op1
= fold_convert_loc (loc
, type
, TREE_OPERAND (aref1
, 1));
9698 tree esz
= fold_convert_loc (loc
, type
, array_ref_element_size (aref0
));
9699 tree diff
= build2 (MINUS_EXPR
, type
, op0
, op1
);
9700 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
9702 fold_build2_loc (loc
, MULT_EXPR
, type
,
9708 /* If the real or vector real constant CST of type TYPE has an exact
9709 inverse, return it, else return NULL. */
9712 exact_inverse (tree type
, tree cst
)
9715 tree unit_type
, *elts
;
9716 enum machine_mode mode
;
9717 unsigned vec_nelts
, i
;
9719 switch (TREE_CODE (cst
))
9722 r
= TREE_REAL_CST (cst
);
9724 if (exact_real_inverse (TYPE_MODE (type
), &r
))
9725 return build_real (type
, r
);
9730 vec_nelts
= VECTOR_CST_NELTS (cst
);
9731 elts
= XALLOCAVEC (tree
, vec_nelts
);
9732 unit_type
= TREE_TYPE (type
);
9733 mode
= TYPE_MODE (unit_type
);
9735 for (i
= 0; i
< vec_nelts
; i
++)
9737 r
= TREE_REAL_CST (VECTOR_CST_ELT (cst
, i
));
9738 if (!exact_real_inverse (mode
, &r
))
9740 elts
[i
] = build_real (unit_type
, r
);
9743 return build_vector (type
, elts
);
9750 /* Fold a binary expression of code CODE and type TYPE with operands
9751 OP0 and OP1. LOC is the location of the resulting expression.
9752 Return the folded expression if folding is successful. Otherwise,
9753 return NULL_TREE. */
9756 fold_binary_loc (location_t loc
,
9757 enum tree_code code
, tree type
, tree op0
, tree op1
)
9759 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
9760 tree arg0
, arg1
, tem
;
9761 tree t1
= NULL_TREE
;
9762 bool strict_overflow_p
;
9764 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
9765 && TREE_CODE_LENGTH (code
) == 2
9767 && op1
!= NULL_TREE
);
9772 /* Strip any conversions that don't change the mode. This is
9773 safe for every expression, except for a comparison expression
9774 because its signedness is derived from its operands. So, in
9775 the latter case, only strip conversions that don't change the
9776 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
9779 Note that this is done as an internal manipulation within the
9780 constant folder, in order to find the simplest representation
9781 of the arguments so that their form can be studied. In any
9782 cases, the appropriate type conversions should be put back in
9783 the tree that will get out of the constant folder. */
9785 if (kind
== tcc_comparison
|| code
== MIN_EXPR
|| code
== MAX_EXPR
)
9787 STRIP_SIGN_NOPS (arg0
);
9788 STRIP_SIGN_NOPS (arg1
);
9796 /* Note that TREE_CONSTANT isn't enough: static var addresses are
9797 constant but we can't do arithmetic on them. */
9798 if ((TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
9799 || (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
9800 || (TREE_CODE (arg0
) == FIXED_CST
&& TREE_CODE (arg1
) == FIXED_CST
)
9801 || (TREE_CODE (arg0
) == FIXED_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
9802 || (TREE_CODE (arg0
) == COMPLEX_CST
&& TREE_CODE (arg1
) == COMPLEX_CST
)
9803 || (TREE_CODE (arg0
) == VECTOR_CST
&& TREE_CODE (arg1
) == VECTOR_CST
))
9805 if (kind
== tcc_binary
)
9807 /* Make sure type and arg0 have the same saturating flag. */
9808 gcc_assert (TYPE_SATURATING (type
)
9809 == TYPE_SATURATING (TREE_TYPE (arg0
)));
9810 tem
= const_binop (code
, arg0
, arg1
);
9812 else if (kind
== tcc_comparison
)
9813 tem
= fold_relational_const (code
, type
, arg0
, arg1
);
9817 if (tem
!= NULL_TREE
)
9819 if (TREE_TYPE (tem
) != type
)
9820 tem
= fold_convert_loc (loc
, type
, tem
);
9825 /* If this is a commutative operation, and ARG0 is a constant, move it
9826 to ARG1 to reduce the number of tests below. */
9827 if (commutative_tree_code (code
)
9828 && tree_swap_operands_p (arg0
, arg1
, true))
9829 return fold_build2_loc (loc
, code
, type
, op1
, op0
);
9831 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9833 First check for cases where an arithmetic operation is applied to a
9834 compound, conditional, or comparison operation. Push the arithmetic
9835 operation inside the compound or conditional to see if any folding
9836 can then be done. Convert comparison to conditional for this purpose.
9837 The also optimizes non-constant cases that used to be done in
9840 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9841 one of the operands is a comparison and the other is a comparison, a
9842 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
9843 code below would make the expression more complex. Change it to a
9844 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
9845 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
9847 if ((code
== BIT_AND_EXPR
|| code
== BIT_IOR_EXPR
9848 || code
== EQ_EXPR
|| code
== NE_EXPR
)
9849 && TREE_CODE (type
) != VECTOR_TYPE
9850 && ((truth_value_p (TREE_CODE (arg0
))
9851 && (truth_value_p (TREE_CODE (arg1
))
9852 || (TREE_CODE (arg1
) == BIT_AND_EXPR
9853 && integer_onep (TREE_OPERAND (arg1
, 1)))))
9854 || (truth_value_p (TREE_CODE (arg1
))
9855 && (truth_value_p (TREE_CODE (arg0
))
9856 || (TREE_CODE (arg0
) == BIT_AND_EXPR
9857 && integer_onep (TREE_OPERAND (arg0
, 1)))))))
9859 tem
= fold_build2_loc (loc
, code
== BIT_AND_EXPR
? TRUTH_AND_EXPR
9860 : code
== BIT_IOR_EXPR
? TRUTH_OR_EXPR
9863 fold_convert_loc (loc
, boolean_type_node
, arg0
),
9864 fold_convert_loc (loc
, boolean_type_node
, arg1
));
9866 if (code
== EQ_EXPR
)
9867 tem
= invert_truthvalue_loc (loc
, tem
);
9869 return fold_convert_loc (loc
, type
, tem
);
9872 if (TREE_CODE_CLASS (code
) == tcc_binary
9873 || TREE_CODE_CLASS (code
) == tcc_comparison
)
9875 if (TREE_CODE (arg0
) == COMPOUND_EXPR
)
9877 tem
= fold_build2_loc (loc
, code
, type
,
9878 fold_convert_loc (loc
, TREE_TYPE (op0
),
9879 TREE_OPERAND (arg0
, 1)), op1
);
9880 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg0
, 0),
9883 if (TREE_CODE (arg1
) == COMPOUND_EXPR
9884 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
9886 tem
= fold_build2_loc (loc
, code
, type
, op0
,
9887 fold_convert_loc (loc
, TREE_TYPE (op1
),
9888 TREE_OPERAND (arg1
, 1)));
9889 return build2_loc (loc
, COMPOUND_EXPR
, type
, TREE_OPERAND (arg1
, 0),
9893 if (TREE_CODE (arg0
) == COND_EXPR
9894 || TREE_CODE (arg0
) == VEC_COND_EXPR
9895 || COMPARISON_CLASS_P (arg0
))
9897 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9899 /*cond_first_p=*/1);
9900 if (tem
!= NULL_TREE
)
9904 if (TREE_CODE (arg1
) == COND_EXPR
9905 || TREE_CODE (arg1
) == VEC_COND_EXPR
9906 || COMPARISON_CLASS_P (arg1
))
9908 tem
= fold_binary_op_with_conditional_arg (loc
, code
, type
, op0
, op1
,
9910 /*cond_first_p=*/0);
9911 if (tem
!= NULL_TREE
)
9919 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
9920 if (TREE_CODE (arg0
) == ADDR_EXPR
9921 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == MEM_REF
)
9923 tree iref
= TREE_OPERAND (arg0
, 0);
9924 return fold_build2 (MEM_REF
, type
,
9925 TREE_OPERAND (iref
, 0),
9926 int_const_binop (PLUS_EXPR
, arg1
,
9927 TREE_OPERAND (iref
, 1)));
9930 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
9931 if (TREE_CODE (arg0
) == ADDR_EXPR
9932 && handled_component_p (TREE_OPERAND (arg0
, 0)))
9935 HOST_WIDE_INT coffset
;
9936 base
= get_addr_base_and_unit_offset (TREE_OPERAND (arg0
, 0),
9940 return fold_build2 (MEM_REF
, type
,
9941 build_fold_addr_expr (base
),
9942 int_const_binop (PLUS_EXPR
, arg1
,
9943 size_int (coffset
)));
9948 case POINTER_PLUS_EXPR
:
9949 /* 0 +p index -> (type)index */
9950 if (integer_zerop (arg0
))
9951 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
9953 /* PTR +p 0 -> PTR */
9954 if (integer_zerop (arg1
))
9955 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
9957 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
9958 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1
))
9959 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
)))
9960 return fold_convert_loc (loc
, type
,
9961 fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
9962 fold_convert_loc (loc
, sizetype
,
9964 fold_convert_loc (loc
, sizetype
,
9967 /* (PTR +p B) +p A -> PTR +p (B + A) */
9968 if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
9971 tree arg01
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (arg0
, 1));
9972 tree arg00
= TREE_OPERAND (arg0
, 0);
9973 inner
= fold_build2_loc (loc
, PLUS_EXPR
, sizetype
,
9974 arg01
, fold_convert_loc (loc
, sizetype
, arg1
));
9975 return fold_convert_loc (loc
, type
,
9976 fold_build_pointer_plus_loc (loc
,
9980 /* PTR_CST +p CST -> CST1 */
9981 if (TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
9982 return fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
,
9983 fold_convert_loc (loc
, type
, arg1
));
9985 /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
9986 of the array. Loop optimizer sometimes produce this type of
9988 if (TREE_CODE (arg0
) == ADDR_EXPR
)
9990 tem
= try_move_mult_to_index (loc
, arg0
,
9991 fold_convert_loc (loc
,
9994 return fold_convert_loc (loc
, type
, tem
);
10000 /* A + (-B) -> A - B */
10001 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
10002 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10003 fold_convert_loc (loc
, type
, arg0
),
10004 fold_convert_loc (loc
, type
,
10005 TREE_OPERAND (arg1
, 0)));
10006 /* (-A) + B -> B - A */
10007 if (TREE_CODE (arg0
) == NEGATE_EXPR
10008 && reorder_operands_p (TREE_OPERAND (arg0
, 0), arg1
))
10009 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10010 fold_convert_loc (loc
, type
, arg1
),
10011 fold_convert_loc (loc
, type
,
10012 TREE_OPERAND (arg0
, 0)));
10014 if (INTEGRAL_TYPE_P (type
))
10016 /* Convert ~A + 1 to -A. */
10017 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10018 && integer_onep (arg1
))
10019 return fold_build1_loc (loc
, NEGATE_EXPR
, type
,
10020 fold_convert_loc (loc
, type
,
10021 TREE_OPERAND (arg0
, 0)));
10023 /* ~X + X is -1. */
10024 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
10025 && !TYPE_OVERFLOW_TRAPS (type
))
10027 tree tem
= TREE_OPERAND (arg0
, 0);
10030 if (operand_equal_p (tem
, arg1
, 0))
10032 t1
= build_int_cst_type (type
, -1);
10033 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
10037 /* X + ~X is -1. */
10038 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
10039 && !TYPE_OVERFLOW_TRAPS (type
))
10041 tree tem
= TREE_OPERAND (arg1
, 0);
10044 if (operand_equal_p (arg0
, tem
, 0))
10046 t1
= build_int_cst_type (type
, -1);
10047 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
10051 /* X + (X / CST) * -CST is X % CST. */
10052 if (TREE_CODE (arg1
) == MULT_EXPR
10053 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10054 && operand_equal_p (arg0
,
10055 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0))
10057 tree cst0
= TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1);
10058 tree cst1
= TREE_OPERAND (arg1
, 1);
10059 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (cst1
),
10061 if (sum
&& integer_zerop (sum
))
10062 return fold_convert_loc (loc
, type
,
10063 fold_build2_loc (loc
, TRUNC_MOD_EXPR
,
10064 TREE_TYPE (arg0
), arg0
,
10069 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
10070 one. Make sure the type is not saturating and has the signedness of
10071 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10072 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10073 if ((TREE_CODE (arg0
) == MULT_EXPR
10074 || TREE_CODE (arg1
) == MULT_EXPR
)
10075 && !TYPE_SATURATING (type
)
10076 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10077 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10078 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10080 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10085 if (! FLOAT_TYPE_P (type
))
10087 if (integer_zerop (arg1
))
10088 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10090 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10091 with a constant, and the two constants have no bits in common,
10092 we should treat this as a BIT_IOR_EXPR since this may produce more
10093 simplifications. */
10094 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10095 && TREE_CODE (arg1
) == BIT_AND_EXPR
10096 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
10097 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
10098 && integer_zerop (const_binop (BIT_AND_EXPR
,
10099 TREE_OPERAND (arg0
, 1),
10100 TREE_OPERAND (arg1
, 1))))
10102 code
= BIT_IOR_EXPR
;
10106 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10107 (plus (plus (mult) (mult)) (foo)) so that we can
10108 take advantage of the factoring cases below. */
10109 if (TYPE_OVERFLOW_WRAPS (type
)
10110 && (((TREE_CODE (arg0
) == PLUS_EXPR
10111 || TREE_CODE (arg0
) == MINUS_EXPR
)
10112 && TREE_CODE (arg1
) == MULT_EXPR
)
10113 || ((TREE_CODE (arg1
) == PLUS_EXPR
10114 || TREE_CODE (arg1
) == MINUS_EXPR
)
10115 && TREE_CODE (arg0
) == MULT_EXPR
)))
10117 tree parg0
, parg1
, parg
, marg
;
10118 enum tree_code pcode
;
10120 if (TREE_CODE (arg1
) == MULT_EXPR
)
10121 parg
= arg0
, marg
= arg1
;
10123 parg
= arg1
, marg
= arg0
;
10124 pcode
= TREE_CODE (parg
);
10125 parg0
= TREE_OPERAND (parg
, 0);
10126 parg1
= TREE_OPERAND (parg
, 1);
10127 STRIP_NOPS (parg0
);
10128 STRIP_NOPS (parg1
);
10130 if (TREE_CODE (parg0
) == MULT_EXPR
10131 && TREE_CODE (parg1
) != MULT_EXPR
)
10132 return fold_build2_loc (loc
, pcode
, type
,
10133 fold_build2_loc (loc
, PLUS_EXPR
, type
,
10134 fold_convert_loc (loc
, type
,
10136 fold_convert_loc (loc
, type
,
10138 fold_convert_loc (loc
, type
, parg1
));
10139 if (TREE_CODE (parg0
) != MULT_EXPR
10140 && TREE_CODE (parg1
) == MULT_EXPR
)
10142 fold_build2_loc (loc
, PLUS_EXPR
, type
,
10143 fold_convert_loc (loc
, type
, parg0
),
10144 fold_build2_loc (loc
, pcode
, type
,
10145 fold_convert_loc (loc
, type
, marg
),
10146 fold_convert_loc (loc
, type
,
10152 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10153 if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 0))
10154 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10156 /* Likewise if the operands are reversed. */
10157 if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10158 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
10160 /* Convert X + -C into X - C. */
10161 if (TREE_CODE (arg1
) == REAL_CST
10162 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
)))
10164 tem
= fold_negate_const (arg1
, type
);
10165 if (!TREE_OVERFLOW (arg1
) || !flag_trapping_math
)
10166 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10167 fold_convert_loc (loc
, type
, arg0
),
10168 fold_convert_loc (loc
, type
, tem
));
10171 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10172 to __complex__ ( x, y ). This is not the same for SNaNs or
10173 if signed zeros are involved. */
10174 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10175 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10176 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10178 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10179 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10180 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10181 bool arg0rz
= false, arg0iz
= false;
10182 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10183 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10185 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10186 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10187 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10189 tree rp
= arg1r
? arg1r
10190 : build1 (REALPART_EXPR
, rtype
, arg1
);
10191 tree ip
= arg0i
? arg0i
10192 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10193 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10195 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10197 tree rp
= arg0r
? arg0r
10198 : build1 (REALPART_EXPR
, rtype
, arg0
);
10199 tree ip
= arg1i
? arg1i
10200 : build1 (IMAGPART_EXPR
, rtype
, arg1
);
10201 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10206 if (flag_unsafe_math_optimizations
10207 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10208 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10209 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10212 /* Convert x+x into x*2.0. */
10213 if (operand_equal_p (arg0
, arg1
, 0)
10214 && SCALAR_FLOAT_TYPE_P (type
))
10215 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
,
10216 build_real (type
, dconst2
));
10218 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10219 We associate floats only if the user has specified
10220 -fassociative-math. */
10221 if (flag_associative_math
10222 && TREE_CODE (arg1
) == PLUS_EXPR
10223 && TREE_CODE (arg0
) != MULT_EXPR
)
10225 tree tree10
= TREE_OPERAND (arg1
, 0);
10226 tree tree11
= TREE_OPERAND (arg1
, 1);
10227 if (TREE_CODE (tree11
) == MULT_EXPR
10228 && TREE_CODE (tree10
) == MULT_EXPR
)
10231 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, arg0
, tree10
);
10232 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree0
, tree11
);
10235 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10236 We associate floats only if the user has specified
10237 -fassociative-math. */
10238 if (flag_associative_math
10239 && TREE_CODE (arg0
) == PLUS_EXPR
10240 && TREE_CODE (arg1
) != MULT_EXPR
)
10242 tree tree00
= TREE_OPERAND (arg0
, 0);
10243 tree tree01
= TREE_OPERAND (arg0
, 1);
10244 if (TREE_CODE (tree01
) == MULT_EXPR
10245 && TREE_CODE (tree00
) == MULT_EXPR
)
10248 tree0
= fold_build2_loc (loc
, PLUS_EXPR
, type
, tree01
, arg1
);
10249 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tree00
, tree0
);
10255 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10256 is a rotate of A by C1 bits. */
10257 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10258 is a rotate of A by B bits. */
10260 enum tree_code code0
, code1
;
10262 code0
= TREE_CODE (arg0
);
10263 code1
= TREE_CODE (arg1
);
10264 if (((code0
== RSHIFT_EXPR
&& code1
== LSHIFT_EXPR
)
10265 || (code1
== RSHIFT_EXPR
&& code0
== LSHIFT_EXPR
))
10266 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10267 TREE_OPERAND (arg1
, 0), 0)
10268 && (rtype
= TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10269 TYPE_UNSIGNED (rtype
))
10270 /* Only create rotates in complete modes. Other cases are not
10271 expanded properly. */
10272 && TYPE_PRECISION (rtype
) == GET_MODE_PRECISION (TYPE_MODE (rtype
)))
10274 tree tree01
, tree11
;
10275 enum tree_code code01
, code11
;
10277 tree01
= TREE_OPERAND (arg0
, 1);
10278 tree11
= TREE_OPERAND (arg1
, 1);
10279 STRIP_NOPS (tree01
);
10280 STRIP_NOPS (tree11
);
10281 code01
= TREE_CODE (tree01
);
10282 code11
= TREE_CODE (tree11
);
10283 if (code01
== INTEGER_CST
10284 && code11
== INTEGER_CST
10285 && TREE_INT_CST_HIGH (tree01
) == 0
10286 && TREE_INT_CST_HIGH (tree11
) == 0
10287 && ((TREE_INT_CST_LOW (tree01
) + TREE_INT_CST_LOW (tree11
))
10288 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)))))
10290 tem
= build2_loc (loc
, LROTATE_EXPR
,
10291 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10292 TREE_OPERAND (arg0
, 0),
10293 code0
== LSHIFT_EXPR
? tree01
: tree11
);
10294 return fold_convert_loc (loc
, type
, tem
);
10296 else if (code11
== MINUS_EXPR
)
10298 tree tree110
, tree111
;
10299 tree110
= TREE_OPERAND (tree11
, 0);
10300 tree111
= TREE_OPERAND (tree11
, 1);
10301 STRIP_NOPS (tree110
);
10302 STRIP_NOPS (tree111
);
10303 if (TREE_CODE (tree110
) == INTEGER_CST
10304 && 0 == compare_tree_int (tree110
,
10306 (TREE_TYPE (TREE_OPERAND
10308 && operand_equal_p (tree01
, tree111
, 0))
10310 fold_convert_loc (loc
, type
,
10311 build2 ((code0
== LSHIFT_EXPR
10314 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10315 TREE_OPERAND (arg0
, 0), tree01
));
10317 else if (code01
== MINUS_EXPR
)
10319 tree tree010
, tree011
;
10320 tree010
= TREE_OPERAND (tree01
, 0);
10321 tree011
= TREE_OPERAND (tree01
, 1);
10322 STRIP_NOPS (tree010
);
10323 STRIP_NOPS (tree011
);
10324 if (TREE_CODE (tree010
) == INTEGER_CST
10325 && 0 == compare_tree_int (tree010
,
10327 (TREE_TYPE (TREE_OPERAND
10329 && operand_equal_p (tree11
, tree011
, 0))
10330 return fold_convert_loc
10332 build2 ((code0
!= LSHIFT_EXPR
10335 TREE_TYPE (TREE_OPERAND (arg0
, 0)),
10336 TREE_OPERAND (arg0
, 0), tree11
));
10342 /* In most languages, can't associate operations on floats through
10343 parentheses. Rather than remember where the parentheses were, we
10344 don't associate floats at all, unless the user has specified
10345 -fassociative-math.
10346 And, we need to make sure type is not saturating. */
10348 if ((! FLOAT_TYPE_P (type
) || flag_associative_math
)
10349 && !TYPE_SATURATING (type
))
10351 tree var0
, con0
, lit0
, minus_lit0
;
10352 tree var1
, con1
, lit1
, minus_lit1
;
10355 /* Split both trees into variables, constants, and literals. Then
10356 associate each group together, the constants with literals,
10357 then the result with variables. This increases the chances of
10358 literals being recombined later and of generating relocatable
10359 expressions for the sum of a constant and literal. */
10360 var0
= split_tree (arg0
, code
, &con0
, &lit0
, &minus_lit0
, 0);
10361 var1
= split_tree (arg1
, code
, &con1
, &lit1
, &minus_lit1
,
10362 code
== MINUS_EXPR
);
10364 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10365 if (code
== MINUS_EXPR
)
10368 /* With undefined overflow we can only associate constants with one
10369 variable, and constants whose association doesn't overflow. */
10370 if ((POINTER_TYPE_P (type
) && POINTER_TYPE_OVERFLOW_UNDEFINED
)
10371 || (INTEGRAL_TYPE_P (type
) && !TYPE_OVERFLOW_WRAPS (type
)))
10378 if (TREE_CODE (tmp0
) == NEGATE_EXPR
)
10379 tmp0
= TREE_OPERAND (tmp0
, 0);
10380 if (CONVERT_EXPR_P (tmp0
)
10381 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
10382 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0
, 0)))
10383 <= TYPE_PRECISION (type
)))
10384 tmp0
= TREE_OPERAND (tmp0
, 0);
10385 if (TREE_CODE (tmp1
) == NEGATE_EXPR
)
10386 tmp1
= TREE_OPERAND (tmp1
, 0);
10387 if (CONVERT_EXPR_P (tmp1
)
10388 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
10389 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1
, 0)))
10390 <= TYPE_PRECISION (type
)))
10391 tmp1
= TREE_OPERAND (tmp1
, 0);
10392 /* The only case we can still associate with two variables
10393 is if they are the same, modulo negation and bit-pattern
10394 preserving conversions. */
10395 if (!operand_equal_p (tmp0
, tmp1
, 0))
10399 if (ok
&& lit0
&& lit1
)
10401 tree tmp0
= fold_convert (type
, lit0
);
10402 tree tmp1
= fold_convert (type
, lit1
);
10404 if (!TREE_OVERFLOW (tmp0
) && !TREE_OVERFLOW (tmp1
)
10405 && TREE_OVERFLOW (fold_build2 (code
, type
, tmp0
, tmp1
)))
10410 /* Only do something if we found more than two objects. Otherwise,
10411 nothing has changed and we risk infinite recursion. */
10413 && (2 < ((var0
!= 0) + (var1
!= 0)
10414 + (con0
!= 0) + (con1
!= 0)
10415 + (lit0
!= 0) + (lit1
!= 0)
10416 + (minus_lit0
!= 0) + (minus_lit1
!= 0))))
10418 var0
= associate_trees (loc
, var0
, var1
, code
, type
);
10419 con0
= associate_trees (loc
, con0
, con1
, code
, type
);
10420 lit0
= associate_trees (loc
, lit0
, lit1
, code
, type
);
10421 minus_lit0
= associate_trees (loc
, minus_lit0
, minus_lit1
, code
, type
);
10423 /* Preserve the MINUS_EXPR if the negative part of the literal is
10424 greater than the positive part. Otherwise, the multiplicative
10425 folding code (i.e extract_muldiv) may be fooled in case
10426 unsigned constants are subtracted, like in the following
10427 example: ((X*2 + 4) - 8U)/2. */
10428 if (minus_lit0
&& lit0
)
10430 if (TREE_CODE (lit0
) == INTEGER_CST
10431 && TREE_CODE (minus_lit0
) == INTEGER_CST
10432 && tree_int_cst_lt (lit0
, minus_lit0
))
10434 minus_lit0
= associate_trees (loc
, minus_lit0
, lit0
,
10440 lit0
= associate_trees (loc
, lit0
, minus_lit0
,
10449 fold_convert_loc (loc
, type
,
10450 associate_trees (loc
, var0
, minus_lit0
,
10451 MINUS_EXPR
, type
));
10454 con0
= associate_trees (loc
, con0
, minus_lit0
,
10457 fold_convert_loc (loc
, type
,
10458 associate_trees (loc
, var0
, con0
,
10463 con0
= associate_trees (loc
, con0
, lit0
, code
, type
);
10465 fold_convert_loc (loc
, type
, associate_trees (loc
, var0
, con0
,
10473 /* Pointer simplifications for subtraction, simple reassociations. */
10474 if (POINTER_TYPE_P (TREE_TYPE (arg1
)) && POINTER_TYPE_P (TREE_TYPE (arg0
)))
10476 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10477 if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
10478 && TREE_CODE (arg1
) == POINTER_PLUS_EXPR
)
10480 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10481 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10482 tree arg10
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
10483 tree arg11
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
10484 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10485 fold_build2_loc (loc
, MINUS_EXPR
, type
,
10487 fold_build2_loc (loc
, MINUS_EXPR
, type
,
10490 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10491 else if (TREE_CODE (arg0
) == POINTER_PLUS_EXPR
)
10493 tree arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
10494 tree arg01
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
10495 tree tmp
= fold_binary_loc (loc
, MINUS_EXPR
, type
, arg00
,
10496 fold_convert_loc (loc
, type
, arg1
));
10498 return fold_build2_loc (loc
, PLUS_EXPR
, type
, tmp
, arg01
);
10501 /* A - (-B) -> A + B */
10502 if (TREE_CODE (arg1
) == NEGATE_EXPR
)
10503 return fold_build2_loc (loc
, PLUS_EXPR
, type
, op0
,
10504 fold_convert_loc (loc
, type
,
10505 TREE_OPERAND (arg1
, 0)));
10506 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10507 if (TREE_CODE (arg0
) == NEGATE_EXPR
10508 && (FLOAT_TYPE_P (type
)
10509 || INTEGRAL_TYPE_P (type
))
10510 && negate_expr_p (arg1
)
10511 && reorder_operands_p (arg0
, arg1
))
10512 return fold_build2_loc (loc
, MINUS_EXPR
, type
,
10513 fold_convert_loc (loc
, type
,
10514 negate_expr (arg1
)),
10515 fold_convert_loc (loc
, type
,
10516 TREE_OPERAND (arg0
, 0)));
10517 /* Convert -A - 1 to ~A. */
10518 if (INTEGRAL_TYPE_P (type
)
10519 && TREE_CODE (arg0
) == NEGATE_EXPR
10520 && integer_onep (arg1
)
10521 && !TYPE_OVERFLOW_TRAPS (type
))
10522 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
10523 fold_convert_loc (loc
, type
,
10524 TREE_OPERAND (arg0
, 0)));
10526 /* Convert -1 - A to ~A. */
10527 if (INTEGRAL_TYPE_P (type
)
10528 && integer_all_onesp (arg0
))
10529 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op1
);
10532 /* X - (X / CST) * CST is X % CST. */
10533 if (INTEGRAL_TYPE_P (type
)
10534 && TREE_CODE (arg1
) == MULT_EXPR
10535 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == TRUNC_DIV_EXPR
10536 && operand_equal_p (arg0
,
10537 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0), 0)
10538 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1),
10539 TREE_OPERAND (arg1
, 1), 0))
10541 fold_convert_loc (loc
, type
,
10542 fold_build2_loc (loc
, TRUNC_MOD_EXPR
, TREE_TYPE (arg0
),
10543 arg0
, TREE_OPERAND (arg1
, 1)));
10545 if (! FLOAT_TYPE_P (type
))
10547 if (integer_zerop (arg0
))
10548 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10549 if (integer_zerop (arg1
))
10550 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10552 /* Fold A - (A & B) into ~B & A. */
10553 if (!TREE_SIDE_EFFECTS (arg0
)
10554 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
10556 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0))
10558 tree arg10
= fold_convert_loc (loc
, type
,
10559 TREE_OPERAND (arg1
, 0));
10560 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10561 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10563 fold_convert_loc (loc
, type
, arg0
));
10565 if (operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10567 tree arg11
= fold_convert_loc (loc
,
10568 type
, TREE_OPERAND (arg1
, 1));
10569 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
10570 fold_build1_loc (loc
, BIT_NOT_EXPR
,
10572 fold_convert_loc (loc
, type
, arg0
));
10576 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10577 any power of 2 minus 1. */
10578 if (TREE_CODE (arg0
) == BIT_AND_EXPR
10579 && TREE_CODE (arg1
) == BIT_AND_EXPR
10580 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10581 TREE_OPERAND (arg1
, 0), 0))
10583 tree mask0
= TREE_OPERAND (arg0
, 1);
10584 tree mask1
= TREE_OPERAND (arg1
, 1);
10585 tree tem
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, mask0
);
10587 if (operand_equal_p (tem
, mask1
, 0))
10589 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, type
,
10590 TREE_OPERAND (arg0
, 0), mask1
);
10591 return fold_build2_loc (loc
, MINUS_EXPR
, type
, tem
, mask1
);
10596 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10597 else if (fold_real_zero_addition_p (TREE_TYPE (arg0
), arg1
, 1))
10598 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10600 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10601 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10602 (-ARG1 + ARG0) reduces to -ARG1. */
10603 else if (fold_real_zero_addition_p (TREE_TYPE (arg1
), arg0
, 0))
10604 return negate_expr (fold_convert_loc (loc
, type
, arg1
));
10606 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10607 __complex__ ( x, -y ). This is not the same for SNaNs or if
10608 signed zeros are involved. */
10609 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10610 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10611 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10613 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10614 tree arg0r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg0
);
10615 tree arg0i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
);
10616 bool arg0rz
= false, arg0iz
= false;
10617 if ((arg0r
&& (arg0rz
= real_zerop (arg0r
)))
10618 || (arg0i
&& (arg0iz
= real_zerop (arg0i
))))
10620 tree arg1r
= fold_unary_loc (loc
, REALPART_EXPR
, rtype
, arg1
);
10621 tree arg1i
= fold_unary_loc (loc
, IMAGPART_EXPR
, rtype
, arg1
);
10622 if (arg0rz
&& arg1i
&& real_zerop (arg1i
))
10624 tree rp
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10626 : build1 (REALPART_EXPR
, rtype
, arg1
));
10627 tree ip
= arg0i
? arg0i
10628 : build1 (IMAGPART_EXPR
, rtype
, arg0
);
10629 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10631 else if (arg0iz
&& arg1r
&& real_zerop (arg1r
))
10633 tree rp
= arg0r
? arg0r
10634 : build1 (REALPART_EXPR
, rtype
, arg0
);
10635 tree ip
= fold_build1_loc (loc
, NEGATE_EXPR
, rtype
,
10637 : build1 (IMAGPART_EXPR
, rtype
, arg1
));
10638 return fold_build2_loc (loc
, COMPLEX_EXPR
, type
, rp
, ip
);
10643 /* Fold &x - &x. This can happen from &x.foo - &x.
10644 This is unsafe for certain floats even in non-IEEE formats.
10645 In IEEE, it is unsafe because it does wrong for NaNs.
10646 Also note that operand_equal_p is always false if an operand
10649 if ((!FLOAT_TYPE_P (type
) || !HONOR_NANS (TYPE_MODE (type
)))
10650 && operand_equal_p (arg0
, arg1
, 0))
10651 return build_zero_cst (type
);
10653 /* A - B -> A + (-B) if B is easily negatable. */
10654 if (negate_expr_p (arg1
)
10655 && ((FLOAT_TYPE_P (type
)
10656 /* Avoid this transformation if B is a positive REAL_CST. */
10657 && (TREE_CODE (arg1
) != REAL_CST
10658 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1
))))
10659 || INTEGRAL_TYPE_P (type
)))
10660 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
10661 fold_convert_loc (loc
, type
, arg0
),
10662 fold_convert_loc (loc
, type
,
10663 negate_expr (arg1
)));
10665 /* Try folding difference of addresses. */
10667 HOST_WIDE_INT diff
;
10669 if ((TREE_CODE (arg0
) == ADDR_EXPR
10670 || TREE_CODE (arg1
) == ADDR_EXPR
)
10671 && ptr_difference_const (arg0
, arg1
, &diff
))
10672 return build_int_cst_type (type
, diff
);
10675 /* Fold &a[i] - &a[j] to i-j. */
10676 if (TREE_CODE (arg0
) == ADDR_EXPR
10677 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == ARRAY_REF
10678 && TREE_CODE (arg1
) == ADDR_EXPR
10679 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == ARRAY_REF
)
10681 tree tem
= fold_addr_of_array_ref_difference (loc
, type
,
10682 TREE_OPERAND (arg0
, 0),
10683 TREE_OPERAND (arg1
, 0));
10688 if (FLOAT_TYPE_P (type
)
10689 && flag_unsafe_math_optimizations
10690 && (TREE_CODE (arg0
) == RDIV_EXPR
|| TREE_CODE (arg0
) == MULT_EXPR
)
10691 && (TREE_CODE (arg1
) == RDIV_EXPR
|| TREE_CODE (arg1
) == MULT_EXPR
)
10692 && (tem
= distribute_real_division (loc
, code
, type
, arg0
, arg1
)))
10695 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
10696 one. Make sure the type is not saturating and has the signedness of
10697 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10698 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10699 if ((TREE_CODE (arg0
) == MULT_EXPR
10700 || TREE_CODE (arg1
) == MULT_EXPR
)
10701 && !TYPE_SATURATING (type
)
10702 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg0
))
10703 && TYPE_UNSIGNED (type
) == TYPE_UNSIGNED (TREE_TYPE (arg1
))
10704 && (!FLOAT_TYPE_P (type
) || flag_associative_math
))
10706 tree tem
= fold_plusminus_mult_expr (loc
, code
, type
, arg0
, arg1
);
10714 /* (-A) * (-B) -> A * B */
10715 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
10716 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10717 fold_convert_loc (loc
, type
,
10718 TREE_OPERAND (arg0
, 0)),
10719 fold_convert_loc (loc
, type
,
10720 negate_expr (arg1
)));
10721 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
10722 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10723 fold_convert_loc (loc
, type
,
10724 negate_expr (arg0
)),
10725 fold_convert_loc (loc
, type
,
10726 TREE_OPERAND (arg1
, 0)));
10728 if (! FLOAT_TYPE_P (type
))
10730 if (integer_zerop (arg1
))
10731 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10732 if (integer_onep (arg1
))
10733 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10734 /* Transform x * -1 into -x. Make sure to do the negation
10735 on the original operand with conversions not stripped
10736 because we can only strip non-sign-changing conversions. */
10737 if (integer_all_onesp (arg1
))
10738 return fold_convert_loc (loc
, type
, negate_expr (op0
));
10739 /* Transform x * -C into -x * C if x is easily negatable. */
10740 if (TREE_CODE (arg1
) == INTEGER_CST
10741 && tree_int_cst_sgn (arg1
) == -1
10742 && negate_expr_p (arg0
)
10743 && (tem
= negate_expr (arg1
)) != arg1
10744 && !TREE_OVERFLOW (tem
))
10745 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10746 fold_convert_loc (loc
, type
,
10747 negate_expr (arg0
)),
10750 /* (a * (1 << b)) is (a << b) */
10751 if (TREE_CODE (arg1
) == LSHIFT_EXPR
10752 && integer_onep (TREE_OPERAND (arg1
, 0)))
10753 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op0
,
10754 TREE_OPERAND (arg1
, 1));
10755 if (TREE_CODE (arg0
) == LSHIFT_EXPR
10756 && integer_onep (TREE_OPERAND (arg0
, 0)))
10757 return fold_build2_loc (loc
, LSHIFT_EXPR
, type
, op1
,
10758 TREE_OPERAND (arg0
, 1));
10760 /* (A + A) * C -> A * 2 * C */
10761 if (TREE_CODE (arg0
) == PLUS_EXPR
10762 && TREE_CODE (arg1
) == INTEGER_CST
10763 && operand_equal_p (TREE_OPERAND (arg0
, 0),
10764 TREE_OPERAND (arg0
, 1), 0))
10765 return fold_build2_loc (loc
, MULT_EXPR
, type
,
10766 omit_one_operand_loc (loc
, type
,
10767 TREE_OPERAND (arg0
, 0),
10768 TREE_OPERAND (arg0
, 1)),
10769 fold_build2_loc (loc
, MULT_EXPR
, type
,
10770 build_int_cst (type
, 2) , arg1
));
10772 strict_overflow_p
= false;
10773 if (TREE_CODE (arg1
) == INTEGER_CST
10774 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
10775 &strict_overflow_p
)))
10777 if (strict_overflow_p
)
10778 fold_overflow_warning (("assuming signed overflow does not "
10779 "occur when simplifying "
10781 WARN_STRICT_OVERFLOW_MISC
);
10782 return fold_convert_loc (loc
, type
, tem
);
10785 /* Optimize z * conj(z) for integer complex numbers. */
10786 if (TREE_CODE (arg0
) == CONJ_EXPR
10787 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10788 return fold_mult_zconjz (loc
, type
, arg1
);
10789 if (TREE_CODE (arg1
) == CONJ_EXPR
10790 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10791 return fold_mult_zconjz (loc
, type
, arg0
);
10795 /* Maybe fold x * 0 to 0. The expressions aren't the same
10796 when x is NaN, since x * 0 is also NaN. Nor are they the
10797 same in modes with signed zeros, since multiplying a
10798 negative value by 0 gives -0, not +0. */
10799 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
10800 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10801 && real_zerop (arg1
))
10802 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
10803 /* In IEEE floating point, x*1 is not equivalent to x for snans.
10804 Likewise for complex arithmetic with signed zeros. */
10805 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10806 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10807 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10808 && real_onep (arg1
))
10809 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
10811 /* Transform x * -1.0 into -x. */
10812 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
10813 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10814 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
)))
10815 && real_minus_onep (arg1
))
10816 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
10818 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
10819 the result for floating point types due to rounding so it is applied
10820 only if -fassociative-math was specify. */
10821 if (flag_associative_math
10822 && TREE_CODE (arg0
) == RDIV_EXPR
10823 && TREE_CODE (arg1
) == REAL_CST
10824 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == REAL_CST
)
10826 tree tem
= const_binop (MULT_EXPR
, TREE_OPERAND (arg0
, 0),
10829 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
10830 TREE_OPERAND (arg0
, 1));
10833 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
10834 if (operand_equal_p (arg0
, arg1
, 0))
10836 tree tem
= fold_strip_sign_ops (arg0
);
10837 if (tem
!= NULL_TREE
)
10839 tem
= fold_convert_loc (loc
, type
, tem
);
10840 return fold_build2_loc (loc
, MULT_EXPR
, type
, tem
, tem
);
10844 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10845 This is not the same for NaNs or if signed zeros are
10847 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
10848 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0
)))
10849 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
10850 && TREE_CODE (arg1
) == COMPLEX_CST
10851 && real_zerop (TREE_REALPART (arg1
)))
10853 tree rtype
= TREE_TYPE (TREE_TYPE (arg0
));
10854 if (real_onep (TREE_IMAGPART (arg1
)))
10856 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10857 negate_expr (fold_build1_loc (loc
, IMAGPART_EXPR
,
10859 fold_build1_loc (loc
, REALPART_EXPR
, rtype
, arg0
));
10860 else if (real_minus_onep (TREE_IMAGPART (arg1
)))
10862 fold_build2_loc (loc
, COMPLEX_EXPR
, type
,
10863 fold_build1_loc (loc
, IMAGPART_EXPR
, rtype
, arg0
),
10864 negate_expr (fold_build1_loc (loc
, REALPART_EXPR
,
10868 /* Optimize z * conj(z) for floating point complex numbers.
10869 Guarded by flag_unsafe_math_optimizations as non-finite
10870 imaginary components don't produce scalar results. */
10871 if (flag_unsafe_math_optimizations
10872 && TREE_CODE (arg0
) == CONJ_EXPR
10873 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
10874 return fold_mult_zconjz (loc
, type
, arg1
);
10875 if (flag_unsafe_math_optimizations
10876 && TREE_CODE (arg1
) == CONJ_EXPR
10877 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
10878 return fold_mult_zconjz (loc
, type
, arg0
);
10880 if (flag_unsafe_math_optimizations
)
10882 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
10883 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
10885 /* Optimizations of root(...)*root(...). */
10886 if (fcode0
== fcode1
&& BUILTIN_ROOT_P (fcode0
))
10889 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
10890 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
10892 /* Optimize sqrt(x)*sqrt(x) as x. */
10893 if (BUILTIN_SQRT_P (fcode0
)
10894 && operand_equal_p (arg00
, arg10
, 0)
10895 && ! HONOR_SNANS (TYPE_MODE (type
)))
10898 /* Optimize root(x)*root(y) as root(x*y). */
10899 rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
10900 arg
= fold_build2_loc (loc
, MULT_EXPR
, type
, arg00
, arg10
);
10901 return build_call_expr_loc (loc
, rootfn
, 1, arg
);
10904 /* Optimize expN(x)*expN(y) as expN(x+y). */
10905 if (fcode0
== fcode1
&& BUILTIN_EXPONENT_P (fcode0
))
10907 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
10908 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
10909 CALL_EXPR_ARG (arg0
, 0),
10910 CALL_EXPR_ARG (arg1
, 0));
10911 return build_call_expr_loc (loc
, expfn
, 1, arg
);
10914 /* Optimizations of pow(...)*pow(...). */
10915 if ((fcode0
== BUILT_IN_POW
&& fcode1
== BUILT_IN_POW
)
10916 || (fcode0
== BUILT_IN_POWF
&& fcode1
== BUILT_IN_POWF
)
10917 || (fcode0
== BUILT_IN_POWL
&& fcode1
== BUILT_IN_POWL
))
10919 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
10920 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
10921 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
10922 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
10924 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
10925 if (operand_equal_p (arg01
, arg11
, 0))
10927 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
10928 tree arg
= fold_build2_loc (loc
, MULT_EXPR
, type
,
10930 return build_call_expr_loc (loc
, powfn
, 2, arg
, arg01
);
10933 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
10934 if (operand_equal_p (arg00
, arg10
, 0))
10936 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
10937 tree arg
= fold_build2_loc (loc
, PLUS_EXPR
, type
,
10939 return build_call_expr_loc (loc
, powfn
, 2, arg00
, arg
);
10943 /* Optimize tan(x)*cos(x) as sin(x). */
10944 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_COS
)
10945 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_COSF
)
10946 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_COSL
)
10947 || (fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_TAN
)
10948 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_TANF
)
10949 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_TANL
))
10950 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
10951 CALL_EXPR_ARG (arg1
, 0), 0))
10953 tree sinfn
= mathfn_built_in (type
, BUILT_IN_SIN
);
10955 if (sinfn
!= NULL_TREE
)
10956 return build_call_expr_loc (loc
, sinfn
, 1,
10957 CALL_EXPR_ARG (arg0
, 0));
10960 /* Optimize x*pow(x,c) as pow(x,c+1). */
10961 if (fcode1
== BUILT_IN_POW
10962 || fcode1
== BUILT_IN_POWF
10963 || fcode1
== BUILT_IN_POWL
)
10965 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
10966 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
10967 if (TREE_CODE (arg11
) == REAL_CST
10968 && !TREE_OVERFLOW (arg11
)
10969 && operand_equal_p (arg0
, arg10
, 0))
10971 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
10975 c
= TREE_REAL_CST (arg11
);
10976 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
10977 arg
= build_real (type
, c
);
10978 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
10982 /* Optimize pow(x,c)*x as pow(x,c+1). */
10983 if (fcode0
== BUILT_IN_POW
10984 || fcode0
== BUILT_IN_POWF
10985 || fcode0
== BUILT_IN_POWL
)
10987 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
10988 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
10989 if (TREE_CODE (arg01
) == REAL_CST
10990 && !TREE_OVERFLOW (arg01
)
10991 && operand_equal_p (arg1
, arg00
, 0))
10993 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
10997 c
= TREE_REAL_CST (arg01
);
10998 real_arithmetic (&c
, PLUS_EXPR
, &c
, &dconst1
);
10999 arg
= build_real (type
, c
);
11000 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
11004 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
11005 if (!in_gimple_form
11007 && operand_equal_p (arg0
, arg1
, 0))
11009 tree powfn
= mathfn_built_in (type
, BUILT_IN_POW
);
11013 tree arg
= build_real (type
, dconst2
);
11014 return build_call_expr_loc (loc
, powfn
, 2, arg0
, arg
);
11023 if (integer_all_onesp (arg1
))
11024 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11025 if (integer_zerop (arg1
))
11026 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11027 if (operand_equal_p (arg0
, arg1
, 0))
11028 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11030 /* ~X | X is -1. */
11031 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11032 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11034 t1
= build_zero_cst (type
);
11035 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11036 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11039 /* X | ~X is -1. */
11040 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11041 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11043 t1
= build_zero_cst (type
);
11044 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11045 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11048 /* Canonicalize (X & C1) | C2. */
11049 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11050 && TREE_CODE (arg1
) == INTEGER_CST
11051 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11053 double_int c1
, c2
, c3
, msk
;
11054 int width
= TYPE_PRECISION (type
), w
;
11055 c1
= tree_to_double_int (TREE_OPERAND (arg0
, 1));
11056 c2
= tree_to_double_int (arg1
);
11058 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11059 if ((c1
& c2
) == c1
)
11060 return omit_one_operand_loc (loc
, type
, arg1
,
11061 TREE_OPERAND (arg0
, 0));
11063 msk
= double_int::mask (width
);
11065 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11066 if (msk
.and_not (c1
| c2
).is_zero ())
11067 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11068 TREE_OPERAND (arg0
, 0), arg1
);
11070 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11071 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11072 mode which allows further optimizations. */
11075 c3
= c1
.and_not (c2
);
11076 for (w
= BITS_PER_UNIT
;
11077 w
<= width
&& w
<= HOST_BITS_PER_WIDE_INT
;
11080 unsigned HOST_WIDE_INT mask
11081 = (unsigned HOST_WIDE_INT
) -1 >> (HOST_BITS_PER_WIDE_INT
- w
);
11082 if (((c1
.low
| c2
.low
) & mask
) == mask
11083 && (c1
.low
& ~mask
) == 0 && c1
.high
== 0)
11085 c3
= double_int::from_uhwi (mask
);
11090 return fold_build2_loc (loc
, BIT_IOR_EXPR
, type
,
11091 fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11092 TREE_OPERAND (arg0
, 0),
11093 double_int_to_tree (type
,
11098 /* (X & Y) | Y is (X, Y). */
11099 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11100 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11101 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11102 /* (X & Y) | X is (Y, X). */
11103 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11104 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11105 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11106 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11107 /* X | (X & Y) is (Y, X). */
11108 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11109 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11110 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11111 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11112 /* X | (Y & X) is (Y, X). */
11113 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11114 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11115 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11116 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11118 /* (X & ~Y) | (~X & Y) is X ^ Y */
11119 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11120 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
11122 tree a0
, a1
, l0
, l1
, n0
, n1
;
11124 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11125 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11127 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11128 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11130 n0
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l0
);
11131 n1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, l1
);
11133 if ((operand_equal_p (n0
, a0
, 0)
11134 && operand_equal_p (n1
, a1
, 0))
11135 || (operand_equal_p (n0
, a1
, 0)
11136 && operand_equal_p (n1
, a0
, 0)))
11137 return fold_build2_loc (loc
, BIT_XOR_EXPR
, type
, l0
, n1
);
11140 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11141 if (t1
!= NULL_TREE
)
11144 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11146 This results in more efficient code for machines without a NAND
11147 instruction. Combine will canonicalize to the first form
11148 which will allow use of NAND instructions provided by the
11149 backend if they exist. */
11150 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11151 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11154 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11155 build2 (BIT_AND_EXPR
, type
,
11156 fold_convert_loc (loc
, type
,
11157 TREE_OPERAND (arg0
, 0)),
11158 fold_convert_loc (loc
, type
,
11159 TREE_OPERAND (arg1
, 0))));
11162 /* See if this can be simplified into a rotate first. If that
11163 is unsuccessful continue in the association code. */
11167 if (integer_zerop (arg1
))
11168 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11169 if (integer_all_onesp (arg1
))
11170 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, op0
);
11171 if (operand_equal_p (arg0
, arg1
, 0))
11172 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11174 /* ~X ^ X is -1. */
11175 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11176 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11178 t1
= build_zero_cst (type
);
11179 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11180 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
11183 /* X ^ ~X is -1. */
11184 if (TREE_CODE (arg1
) == BIT_NOT_EXPR
11185 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11187 t1
= build_zero_cst (type
);
11188 t1
= fold_unary_loc (loc
, BIT_NOT_EXPR
, type
, t1
);
11189 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
11192 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11193 with a constant, and the two constants have no bits in common,
11194 we should treat this as a BIT_IOR_EXPR since this may produce more
11195 simplifications. */
11196 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11197 && TREE_CODE (arg1
) == BIT_AND_EXPR
11198 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
11199 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == INTEGER_CST
11200 && integer_zerop (const_binop (BIT_AND_EXPR
,
11201 TREE_OPERAND (arg0
, 1),
11202 TREE_OPERAND (arg1
, 1))))
11204 code
= BIT_IOR_EXPR
;
11208 /* (X | Y) ^ X -> Y & ~ X*/
11209 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11210 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11212 tree t2
= TREE_OPERAND (arg0
, 1);
11213 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11215 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11216 fold_convert_loc (loc
, type
, t2
),
11217 fold_convert_loc (loc
, type
, t1
));
11221 /* (Y | X) ^ X -> Y & ~ X*/
11222 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11223 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11225 tree t2
= TREE_OPERAND (arg0
, 0);
11226 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
),
11228 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11229 fold_convert_loc (loc
, type
, t2
),
11230 fold_convert_loc (loc
, type
, t1
));
11234 /* X ^ (X | Y) -> Y & ~ X*/
11235 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11236 && operand_equal_p (TREE_OPERAND (arg1
, 0), arg0
, 0))
11238 tree t2
= TREE_OPERAND (arg1
, 1);
11239 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11241 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11242 fold_convert_loc (loc
, type
, t2
),
11243 fold_convert_loc (loc
, type
, t1
));
11247 /* X ^ (Y | X) -> Y & ~ X*/
11248 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11249 && operand_equal_p (TREE_OPERAND (arg1
, 1), arg0
, 0))
11251 tree t2
= TREE_OPERAND (arg1
, 0);
11252 t1
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg0
),
11254 t1
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11255 fold_convert_loc (loc
, type
, t2
),
11256 fold_convert_loc (loc
, type
, t1
));
11260 /* Convert ~X ^ ~Y to X ^ Y. */
11261 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11262 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11263 return fold_build2_loc (loc
, code
, type
,
11264 fold_convert_loc (loc
, type
,
11265 TREE_OPERAND (arg0
, 0)),
11266 fold_convert_loc (loc
, type
,
11267 TREE_OPERAND (arg1
, 0)));
11269 /* Convert ~X ^ C to X ^ ~C. */
11270 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11271 && TREE_CODE (arg1
) == INTEGER_CST
)
11272 return fold_build2_loc (loc
, code
, type
,
11273 fold_convert_loc (loc
, type
,
11274 TREE_OPERAND (arg0
, 0)),
11275 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, arg1
));
11277 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11278 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11279 && integer_onep (TREE_OPERAND (arg0
, 1))
11280 && integer_onep (arg1
))
11281 return fold_build2_loc (loc
, EQ_EXPR
, type
, arg0
,
11282 build_zero_cst (TREE_TYPE (arg0
)));
11284 /* Fold (X & Y) ^ Y as ~X & Y. */
11285 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11286 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11288 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11289 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11290 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11291 fold_convert_loc (loc
, type
, arg1
));
11293 /* Fold (X & Y) ^ X as ~Y & X. */
11294 if (TREE_CODE (arg0
) == BIT_AND_EXPR
11295 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11296 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11298 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11299 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11300 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11301 fold_convert_loc (loc
, type
, arg1
));
11303 /* Fold X ^ (X & Y) as X & ~Y. */
11304 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11305 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11307 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11308 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11309 fold_convert_loc (loc
, type
, arg0
),
11310 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11312 /* Fold X ^ (Y & X) as ~Y & X. */
11313 if (TREE_CODE (arg1
) == BIT_AND_EXPR
11314 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11315 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11317 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11318 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11319 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11320 fold_convert_loc (loc
, type
, arg0
));
11323 /* See if this can be simplified into a rotate first. If that
11324 is unsuccessful continue in the association code. */
11328 if (integer_all_onesp (arg1
))
11329 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11330 if (integer_zerop (arg1
))
11331 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
11332 if (operand_equal_p (arg0
, arg1
, 0))
11333 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11335 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
11336 if ((TREE_CODE (arg0
) == BIT_NOT_EXPR
11337 || TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11338 || (TREE_CODE (arg0
) == EQ_EXPR
11339 && integer_zerop (TREE_OPERAND (arg0
, 1))))
11340 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
11341 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
11343 /* X & ~X , X & (X == 0), and X & !X are always zero. */
11344 if ((TREE_CODE (arg1
) == BIT_NOT_EXPR
11345 || TREE_CODE (arg1
) == TRUTH_NOT_EXPR
11346 || (TREE_CODE (arg1
) == EQ_EXPR
11347 && integer_zerop (TREE_OPERAND (arg1
, 1))))
11348 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11349 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
11351 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11352 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11353 && TREE_CODE (arg1
) == INTEGER_CST
11354 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11356 tree tmp1
= fold_convert_loc (loc
, type
, arg1
);
11357 tree tmp2
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11358 tree tmp3
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11359 tmp2
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp2
, tmp1
);
11360 tmp3
= fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tmp3
, tmp1
);
11362 fold_convert_loc (loc
, type
,
11363 fold_build2_loc (loc
, BIT_IOR_EXPR
,
11364 type
, tmp2
, tmp3
));
11367 /* (X | Y) & Y is (X, Y). */
11368 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11369 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11370 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 0));
11371 /* (X | Y) & X is (Y, X). */
11372 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
11373 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11374 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11375 return omit_one_operand_loc (loc
, type
, arg1
, TREE_OPERAND (arg0
, 1));
11376 /* X & (X | Y) is (Y, X). */
11377 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11378 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0)
11379 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 1)))
11380 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 1));
11381 /* X & (Y | X) is (Y, X). */
11382 if (TREE_CODE (arg1
) == BIT_IOR_EXPR
11383 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11384 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11385 return omit_one_operand_loc (loc
, type
, arg0
, TREE_OPERAND (arg1
, 0));
11387 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11388 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11389 && integer_onep (TREE_OPERAND (arg0
, 1))
11390 && integer_onep (arg1
))
11393 tem
= TREE_OPERAND (arg0
, 0);
11394 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11395 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11397 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11398 build_zero_cst (TREE_TYPE (tem
)));
11400 /* Fold ~X & 1 as (X & 1) == 0. */
11401 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11402 && integer_onep (arg1
))
11405 tem
= TREE_OPERAND (arg0
, 0);
11406 tem2
= fold_convert_loc (loc
, TREE_TYPE (tem
), arg1
);
11407 tem2
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (tem
),
11409 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem2
,
11410 build_zero_cst (TREE_TYPE (tem
)));
11412 /* Fold !X & 1 as X == 0. */
11413 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
11414 && integer_onep (arg1
))
11416 tem
= TREE_OPERAND (arg0
, 0);
11417 return fold_build2_loc (loc
, EQ_EXPR
, type
, tem
,
11418 build_zero_cst (TREE_TYPE (tem
)));
11421 /* Fold (X ^ Y) & Y as ~X & Y. */
11422 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11423 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
11425 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11426 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11427 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11428 fold_convert_loc (loc
, type
, arg1
));
11430 /* Fold (X ^ Y) & X as ~Y & X. */
11431 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
11432 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
11433 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
11435 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
11436 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11437 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11438 fold_convert_loc (loc
, type
, arg1
));
11440 /* Fold X & (X ^ Y) as X & ~Y. */
11441 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11442 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
11444 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
11445 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11446 fold_convert_loc (loc
, type
, arg0
),
11447 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
));
11449 /* Fold X & (Y ^ X) as ~Y & X. */
11450 if (TREE_CODE (arg1
) == BIT_XOR_EXPR
11451 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 1), 0)
11452 && reorder_operands_p (arg0
, TREE_OPERAND (arg1
, 0)))
11454 tem
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
11455 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
11456 fold_build1_loc (loc
, BIT_NOT_EXPR
, type
, tem
),
11457 fold_convert_loc (loc
, type
, arg0
));
11460 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11461 multiple of 1 << CST. */
11462 if (TREE_CODE (arg1
) == INTEGER_CST
)
11464 double_int cst1
= tree_to_double_int (arg1
);
11465 double_int ncst1
= (-cst1
).ext(TYPE_PRECISION (TREE_TYPE (arg1
)),
11466 TYPE_UNSIGNED (TREE_TYPE (arg1
)));
11467 if ((cst1
& ncst1
) == ncst1
11468 && multiple_of_p (type
, arg0
,
11469 double_int_to_tree (TREE_TYPE (arg1
), ncst1
)))
11470 return fold_convert_loc (loc
, type
, arg0
);
11473 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
11475 if (TREE_CODE (arg1
) == INTEGER_CST
11476 && TREE_CODE (arg0
) == MULT_EXPR
11477 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
11480 = tree_to_double_int (TREE_OPERAND (arg0
, 1)).trailing_zeros ();
11483 double_int arg1mask
, masked
;
11484 arg1mask
= ~double_int::mask (arg1tz
);
11485 arg1mask
= arg1mask
.ext (TYPE_PRECISION (type
),
11486 TYPE_UNSIGNED (type
));
11487 masked
= arg1mask
& tree_to_double_int (arg1
);
11488 if (masked
.is_zero ())
11489 return omit_two_operands_loc (loc
, type
, build_zero_cst (type
),
11491 else if (masked
!= tree_to_double_int (arg1
))
11492 return fold_build2_loc (loc
, code
, type
, op0
,
11493 double_int_to_tree (type
, masked
));
11497 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11498 ((A & N) + B) & M -> (A + B) & M
11499 Similarly if (N & M) == 0,
11500 ((A | N) + B) & M -> (A + B) & M
11501 and for - instead of + (or unary - instead of +)
11502 and/or ^ instead of |.
11503 If B is constant and (B & M) == 0, fold into A & M. */
11504 if (host_integerp (arg1
, 1))
11506 unsigned HOST_WIDE_INT cst1
= tree_low_cst (arg1
, 1);
11507 if (~cst1
&& (cst1
& (cst1
+ 1)) == 0
11508 && INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
11509 && (TREE_CODE (arg0
) == PLUS_EXPR
11510 || TREE_CODE (arg0
) == MINUS_EXPR
11511 || TREE_CODE (arg0
) == NEGATE_EXPR
)
11512 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
))
11513 || TREE_CODE (TREE_TYPE (arg0
)) == INTEGER_TYPE
))
11517 unsigned HOST_WIDE_INT cst0
;
11519 /* Now we know that arg0 is (C + D) or (C - D) or
11520 -C and arg1 (M) is == (1LL << cst) - 1.
11521 Store C into PMOP[0] and D into PMOP[1]. */
11522 pmop
[0] = TREE_OPERAND (arg0
, 0);
11524 if (TREE_CODE (arg0
) != NEGATE_EXPR
)
11526 pmop
[1] = TREE_OPERAND (arg0
, 1);
11530 if (!host_integerp (TYPE_MAX_VALUE (TREE_TYPE (arg0
)), 1)
11531 || (tree_low_cst (TYPE_MAX_VALUE (TREE_TYPE (arg0
)), 1)
11535 for (; which
>= 0; which
--)
11536 switch (TREE_CODE (pmop
[which
]))
11541 if (TREE_CODE (TREE_OPERAND (pmop
[which
], 1))
11544 /* tree_low_cst not used, because we don't care about
11546 cst0
= TREE_INT_CST_LOW (TREE_OPERAND (pmop
[which
], 1));
11548 if (TREE_CODE (pmop
[which
]) == BIT_AND_EXPR
)
11553 else if (cst0
!= 0)
11555 /* If C or D is of the form (A & N) where
11556 (N & M) == M, or of the form (A | N) or
11557 (A ^ N) where (N & M) == 0, replace it with A. */
11558 pmop
[which
] = TREE_OPERAND (pmop
[which
], 0);
11561 /* If C or D is a N where (N & M) == 0, it can be
11562 omitted (assumed 0). */
11563 if ((TREE_CODE (arg0
) == PLUS_EXPR
11564 || (TREE_CODE (arg0
) == MINUS_EXPR
&& which
== 0))
11565 && (TREE_INT_CST_LOW (pmop
[which
]) & cst1
) == 0)
11566 pmop
[which
] = NULL
;
11572 /* Only build anything new if we optimized one or both arguments
11574 if (pmop
[0] != TREE_OPERAND (arg0
, 0)
11575 || (TREE_CODE (arg0
) != NEGATE_EXPR
11576 && pmop
[1] != TREE_OPERAND (arg0
, 1)))
11578 tree utype
= TREE_TYPE (arg0
);
11579 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0
)))
11581 /* Perform the operations in a type that has defined
11582 overflow behavior. */
11583 utype
= unsigned_type_for (TREE_TYPE (arg0
));
11584 if (pmop
[0] != NULL
)
11585 pmop
[0] = fold_convert_loc (loc
, utype
, pmop
[0]);
11586 if (pmop
[1] != NULL
)
11587 pmop
[1] = fold_convert_loc (loc
, utype
, pmop
[1]);
11590 if (TREE_CODE (arg0
) == NEGATE_EXPR
)
11591 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[0]);
11592 else if (TREE_CODE (arg0
) == PLUS_EXPR
)
11594 if (pmop
[0] != NULL
&& pmop
[1] != NULL
)
11595 tem
= fold_build2_loc (loc
, PLUS_EXPR
, utype
,
11597 else if (pmop
[0] != NULL
)
11599 else if (pmop
[1] != NULL
)
11602 return build_int_cst (type
, 0);
11604 else if (pmop
[0] == NULL
)
11605 tem
= fold_build1_loc (loc
, NEGATE_EXPR
, utype
, pmop
[1]);
11607 tem
= fold_build2_loc (loc
, MINUS_EXPR
, utype
,
11609 /* TEM is now the new binary +, - or unary - replacement. */
11610 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, utype
, tem
,
11611 fold_convert_loc (loc
, utype
, arg1
));
11612 return fold_convert_loc (loc
, type
, tem
);
11617 t1
= distribute_bit_expr (loc
, code
, type
, arg0
, arg1
);
11618 if (t1
!= NULL_TREE
)
11620 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
11621 if (TREE_CODE (arg1
) == INTEGER_CST
&& TREE_CODE (arg0
) == NOP_EXPR
11622 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0
, 0))))
11625 = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0
, 0)));
11627 if (prec
< BITS_PER_WORD
&& prec
< HOST_BITS_PER_WIDE_INT
11628 && (~TREE_INT_CST_LOW (arg1
)
11629 & (((HOST_WIDE_INT
) 1 << prec
) - 1)) == 0)
11631 fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
11634 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
11636 This results in more efficient code for machines without a NOR
11637 instruction. Combine will canonicalize to the first form
11638 which will allow use of NOR instructions provided by the
11639 backend if they exist. */
11640 if (TREE_CODE (arg0
) == BIT_NOT_EXPR
11641 && TREE_CODE (arg1
) == BIT_NOT_EXPR
)
11643 return fold_build1_loc (loc
, BIT_NOT_EXPR
, type
,
11644 build2 (BIT_IOR_EXPR
, type
,
11645 fold_convert_loc (loc
, type
,
11646 TREE_OPERAND (arg0
, 0)),
11647 fold_convert_loc (loc
, type
,
11648 TREE_OPERAND (arg1
, 0))));
11651 /* If arg0 is derived from the address of an object or function, we may
11652 be able to fold this expression using the object or function's
11654 if (POINTER_TYPE_P (TREE_TYPE (arg0
)) && host_integerp (arg1
, 1))
11656 unsigned HOST_WIDE_INT modulus
, residue
;
11657 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (arg1
);
11659 modulus
= get_pointer_modulus_and_residue (arg0
, &residue
,
11660 integer_onep (arg1
));
11662 /* This works because modulus is a power of 2. If this weren't the
11663 case, we'd have to replace it by its greatest power-of-2
11664 divisor: modulus & -modulus. */
11666 return build_int_cst (type
, residue
& low
);
11669 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11670 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11671 if the new mask might be further optimized. */
11672 if ((TREE_CODE (arg0
) == LSHIFT_EXPR
11673 || TREE_CODE (arg0
) == RSHIFT_EXPR
)
11674 && host_integerp (TREE_OPERAND (arg0
, 1), 1)
11675 && host_integerp (arg1
, TYPE_UNSIGNED (TREE_TYPE (arg1
)))
11676 && tree_low_cst (TREE_OPERAND (arg0
, 1), 1)
11677 < TYPE_PRECISION (TREE_TYPE (arg0
))
11678 && TYPE_PRECISION (TREE_TYPE (arg0
)) <= HOST_BITS_PER_WIDE_INT
11679 && tree_low_cst (TREE_OPERAND (arg0
, 1), 1) > 0)
11681 unsigned int shiftc
= tree_low_cst (TREE_OPERAND (arg0
, 1), 1);
11682 unsigned HOST_WIDE_INT mask
11683 = tree_low_cst (arg1
, TYPE_UNSIGNED (TREE_TYPE (arg1
)));
11684 unsigned HOST_WIDE_INT newmask
, zerobits
= 0;
11685 tree shift_type
= TREE_TYPE (arg0
);
11687 if (TREE_CODE (arg0
) == LSHIFT_EXPR
)
11688 zerobits
= ((((unsigned HOST_WIDE_INT
) 1) << shiftc
) - 1);
11689 else if (TREE_CODE (arg0
) == RSHIFT_EXPR
11690 && TYPE_PRECISION (TREE_TYPE (arg0
))
11691 == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg0
))))
11693 unsigned int prec
= TYPE_PRECISION (TREE_TYPE (arg0
));
11694 tree arg00
= TREE_OPERAND (arg0
, 0);
11695 /* See if more bits can be proven as zero because of
11697 if (TREE_CODE (arg00
) == NOP_EXPR
11698 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00
, 0))))
11700 tree inner_type
= TREE_TYPE (TREE_OPERAND (arg00
, 0));
11701 if (TYPE_PRECISION (inner_type
)
11702 == GET_MODE_BITSIZE (TYPE_MODE (inner_type
))
11703 && TYPE_PRECISION (inner_type
) < prec
)
11705 prec
= TYPE_PRECISION (inner_type
);
11706 /* See if we can shorten the right shift. */
11708 shift_type
= inner_type
;
11711 zerobits
= ~(unsigned HOST_WIDE_INT
) 0;
11712 zerobits
>>= HOST_BITS_PER_WIDE_INT
- shiftc
;
11713 zerobits
<<= prec
- shiftc
;
11714 /* For arithmetic shift if sign bit could be set, zerobits
11715 can contain actually sign bits, so no transformation is
11716 possible, unless MASK masks them all away. In that
11717 case the shift needs to be converted into logical shift. */
11718 if (!TYPE_UNSIGNED (TREE_TYPE (arg0
))
11719 && prec
== TYPE_PRECISION (TREE_TYPE (arg0
)))
11721 if ((mask
& zerobits
) == 0)
11722 shift_type
= unsigned_type_for (TREE_TYPE (arg0
));
11728 /* ((X << 16) & 0xff00) is (X, 0). */
11729 if ((mask
& zerobits
) == mask
)
11730 return omit_one_operand_loc (loc
, type
,
11731 build_int_cst (type
, 0), arg0
);
11733 newmask
= mask
| zerobits
;
11734 if (newmask
!= mask
&& (newmask
& (newmask
+ 1)) == 0)
11738 /* Only do the transformation if NEWMASK is some integer
11740 for (prec
= BITS_PER_UNIT
;
11741 prec
< HOST_BITS_PER_WIDE_INT
; prec
<<= 1)
11742 if (newmask
== (((unsigned HOST_WIDE_INT
) 1) << prec
) - 1)
11744 if (prec
< HOST_BITS_PER_WIDE_INT
11745 || newmask
== ~(unsigned HOST_WIDE_INT
) 0)
11749 if (shift_type
!= TREE_TYPE (arg0
))
11751 tem
= fold_build2_loc (loc
, TREE_CODE (arg0
), shift_type
,
11752 fold_convert_loc (loc
, shift_type
,
11753 TREE_OPERAND (arg0
, 0)),
11754 TREE_OPERAND (arg0
, 1));
11755 tem
= fold_convert_loc (loc
, type
, tem
);
11759 newmaskt
= build_int_cst_type (TREE_TYPE (op1
), newmask
);
11760 if (!tree_int_cst_equal (newmaskt
, arg1
))
11761 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, tem
, newmaskt
);
11769 /* Don't touch a floating-point divide by zero unless the mode
11770 of the constant can represent infinity. */
11771 if (TREE_CODE (arg1
) == REAL_CST
11772 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1
)))
11773 && real_zerop (arg1
))
11776 /* Optimize A / A to 1.0 if we don't care about
11777 NaNs or Infinities. Skip the transformation
11778 for non-real operands. */
11779 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11780 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
11781 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0
)))
11782 && operand_equal_p (arg0
, arg1
, 0))
11784 tree r
= build_real (TREE_TYPE (arg0
), dconst1
);
11786 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
11789 /* The complex version of the above A / A optimization. */
11790 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0
))
11791 && operand_equal_p (arg0
, arg1
, 0))
11793 tree elem_type
= TREE_TYPE (TREE_TYPE (arg0
));
11794 if (! HONOR_NANS (TYPE_MODE (elem_type
))
11795 && ! HONOR_INFINITIES (TYPE_MODE (elem_type
)))
11797 tree r
= build_real (elem_type
, dconst1
);
11798 /* omit_two_operands will call fold_convert for us. */
11799 return omit_two_operands_loc (loc
, type
, r
, arg0
, arg1
);
11803 /* (-A) / (-B) -> A / B */
11804 if (TREE_CODE (arg0
) == NEGATE_EXPR
&& negate_expr_p (arg1
))
11805 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11806 TREE_OPERAND (arg0
, 0),
11807 negate_expr (arg1
));
11808 if (TREE_CODE (arg1
) == NEGATE_EXPR
&& negate_expr_p (arg0
))
11809 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11810 negate_expr (arg0
),
11811 TREE_OPERAND (arg1
, 0));
11813 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
11814 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11815 && real_onep (arg1
))
11816 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
11818 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
11819 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
)))
11820 && real_minus_onep (arg1
))
11821 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
,
11822 negate_expr (arg0
)));
11824 /* If ARG1 is a constant, we can convert this to a multiply by the
11825 reciprocal. This does not have the same rounding properties,
11826 so only do this if -freciprocal-math. We can actually
11827 always safely do it if ARG1 is a power of two, but it's hard to
11828 tell if it is or not in a portable manner. */
11830 && (TREE_CODE (arg1
) == REAL_CST
11831 || (TREE_CODE (arg1
) == COMPLEX_CST
11832 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg1
)))
11833 || (TREE_CODE (arg1
) == VECTOR_CST
11834 && VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg1
)))))
11836 if (flag_reciprocal_math
11837 && 0 != (tem
= const_binop (code
, build_one_cst (type
), arg1
)))
11838 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tem
);
11839 /* Find the reciprocal if optimizing and the result is exact.
11840 TODO: Complex reciprocal not implemented. */
11841 if (TREE_CODE (arg1
) != COMPLEX_CST
)
11843 tree inverse
= exact_inverse (TREE_TYPE (arg0
), arg1
);
11846 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, inverse
);
11849 /* Convert A/B/C to A/(B*C). */
11850 if (flag_reciprocal_math
11851 && TREE_CODE (arg0
) == RDIV_EXPR
)
11852 return fold_build2_loc (loc
, RDIV_EXPR
, type
, TREE_OPERAND (arg0
, 0),
11853 fold_build2_loc (loc
, MULT_EXPR
, type
,
11854 TREE_OPERAND (arg0
, 1), arg1
));
11856 /* Convert A/(B/C) to (A/B)*C. */
11857 if (flag_reciprocal_math
11858 && TREE_CODE (arg1
) == RDIV_EXPR
)
11859 return fold_build2_loc (loc
, MULT_EXPR
, type
,
11860 fold_build2_loc (loc
, RDIV_EXPR
, type
, arg0
,
11861 TREE_OPERAND (arg1
, 0)),
11862 TREE_OPERAND (arg1
, 1));
11864 /* Convert C1/(X*C2) into (C1/C2)/X. */
11865 if (flag_reciprocal_math
11866 && TREE_CODE (arg1
) == MULT_EXPR
11867 && TREE_CODE (arg0
) == REAL_CST
11868 && TREE_CODE (TREE_OPERAND (arg1
, 1)) == REAL_CST
)
11870 tree tem
= const_binop (RDIV_EXPR
, arg0
,
11871 TREE_OPERAND (arg1
, 1));
11873 return fold_build2_loc (loc
, RDIV_EXPR
, type
, tem
,
11874 TREE_OPERAND (arg1
, 0));
11877 if (flag_unsafe_math_optimizations
)
11879 enum built_in_function fcode0
= builtin_mathfn_code (arg0
);
11880 enum built_in_function fcode1
= builtin_mathfn_code (arg1
);
11882 /* Optimize sin(x)/cos(x) as tan(x). */
11883 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_COS
)
11884 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_COSF
)
11885 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_COSL
))
11886 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11887 CALL_EXPR_ARG (arg1
, 0), 0))
11889 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
11891 if (tanfn
!= NULL_TREE
)
11892 return build_call_expr_loc (loc
, tanfn
, 1, CALL_EXPR_ARG (arg0
, 0));
11895 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
11896 if (((fcode0
== BUILT_IN_COS
&& fcode1
== BUILT_IN_SIN
)
11897 || (fcode0
== BUILT_IN_COSF
&& fcode1
== BUILT_IN_SINF
)
11898 || (fcode0
== BUILT_IN_COSL
&& fcode1
== BUILT_IN_SINL
))
11899 && operand_equal_p (CALL_EXPR_ARG (arg0
, 0),
11900 CALL_EXPR_ARG (arg1
, 0), 0))
11902 tree tanfn
= mathfn_built_in (type
, BUILT_IN_TAN
);
11904 if (tanfn
!= NULL_TREE
)
11906 tree tmp
= build_call_expr_loc (loc
, tanfn
, 1,
11907 CALL_EXPR_ARG (arg0
, 0));
11908 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11909 build_real (type
, dconst1
), tmp
);
11913 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
11914 NaNs or Infinities. */
11915 if (((fcode0
== BUILT_IN_SIN
&& fcode1
== BUILT_IN_TAN
)
11916 || (fcode0
== BUILT_IN_SINF
&& fcode1
== BUILT_IN_TANF
)
11917 || (fcode0
== BUILT_IN_SINL
&& fcode1
== BUILT_IN_TANL
)))
11919 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11920 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
11922 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
11923 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
11924 && operand_equal_p (arg00
, arg01
, 0))
11926 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
11928 if (cosfn
!= NULL_TREE
)
11929 return build_call_expr_loc (loc
, cosfn
, 1, arg00
);
11933 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
11934 NaNs or Infinities. */
11935 if (((fcode0
== BUILT_IN_TAN
&& fcode1
== BUILT_IN_SIN
)
11936 || (fcode0
== BUILT_IN_TANF
&& fcode1
== BUILT_IN_SINF
)
11937 || (fcode0
== BUILT_IN_TANL
&& fcode1
== BUILT_IN_SINL
)))
11939 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11940 tree arg01
= CALL_EXPR_ARG (arg1
, 0);
11942 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00
)))
11943 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00
)))
11944 && operand_equal_p (arg00
, arg01
, 0))
11946 tree cosfn
= mathfn_built_in (type
, BUILT_IN_COS
);
11948 if (cosfn
!= NULL_TREE
)
11950 tree tmp
= build_call_expr_loc (loc
, cosfn
, 1, arg00
);
11951 return fold_build2_loc (loc
, RDIV_EXPR
, type
,
11952 build_real (type
, dconst1
),
11958 /* Optimize pow(x,c)/x as pow(x,c-1). */
11959 if (fcode0
== BUILT_IN_POW
11960 || fcode0
== BUILT_IN_POWF
11961 || fcode0
== BUILT_IN_POWL
)
11963 tree arg00
= CALL_EXPR_ARG (arg0
, 0);
11964 tree arg01
= CALL_EXPR_ARG (arg0
, 1);
11965 if (TREE_CODE (arg01
) == REAL_CST
11966 && !TREE_OVERFLOW (arg01
)
11967 && operand_equal_p (arg1
, arg00
, 0))
11969 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg0
), 0);
11973 c
= TREE_REAL_CST (arg01
);
11974 real_arithmetic (&c
, MINUS_EXPR
, &c
, &dconst1
);
11975 arg
= build_real (type
, c
);
11976 return build_call_expr_loc (loc
, powfn
, 2, arg1
, arg
);
11980 /* Optimize a/root(b/c) into a*root(c/b). */
11981 if (BUILTIN_ROOT_P (fcode1
))
11983 tree rootarg
= CALL_EXPR_ARG (arg1
, 0);
11985 if (TREE_CODE (rootarg
) == RDIV_EXPR
)
11987 tree rootfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
11988 tree b
= TREE_OPERAND (rootarg
, 0);
11989 tree c
= TREE_OPERAND (rootarg
, 1);
11991 tree tmp
= fold_build2_loc (loc
, RDIV_EXPR
, type
, c
, b
);
11993 tmp
= build_call_expr_loc (loc
, rootfn
, 1, tmp
);
11994 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, tmp
);
11998 /* Optimize x/expN(y) into x*expN(-y). */
11999 if (BUILTIN_EXPONENT_P (fcode1
))
12001 tree expfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12002 tree arg
= negate_expr (CALL_EXPR_ARG (arg1
, 0));
12003 arg1
= build_call_expr_loc (loc
,
12005 fold_convert_loc (loc
, type
, arg
));
12006 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12009 /* Optimize x/pow(y,z) into x*pow(y,-z). */
12010 if (fcode1
== BUILT_IN_POW
12011 || fcode1
== BUILT_IN_POWF
12012 || fcode1
== BUILT_IN_POWL
)
12014 tree powfn
= TREE_OPERAND (CALL_EXPR_FN (arg1
), 0);
12015 tree arg10
= CALL_EXPR_ARG (arg1
, 0);
12016 tree arg11
= CALL_EXPR_ARG (arg1
, 1);
12017 tree neg11
= fold_convert_loc (loc
, type
,
12018 negate_expr (arg11
));
12019 arg1
= build_call_expr_loc (loc
, powfn
, 2, arg10
, neg11
);
12020 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
12025 case TRUNC_DIV_EXPR
:
12026 /* Optimize (X & (-A)) / A where A is a power of 2,
12028 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12029 && !TYPE_UNSIGNED (type
) && TREE_CODE (arg1
) == INTEGER_CST
12030 && integer_pow2p (arg1
) && tree_int_cst_sgn (arg1
) > 0)
12032 tree sum
= fold_binary_loc (loc
, PLUS_EXPR
, TREE_TYPE (arg1
),
12033 arg1
, TREE_OPERAND (arg0
, 1));
12034 if (sum
&& integer_zerop (sum
)) {
12035 unsigned long pow2
;
12037 if (TREE_INT_CST_LOW (arg1
))
12038 pow2
= exact_log2 (TREE_INT_CST_LOW (arg1
));
12040 pow2
= exact_log2 (TREE_INT_CST_HIGH (arg1
))
12041 + HOST_BITS_PER_WIDE_INT
;
12043 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12044 TREE_OPERAND (arg0
, 0),
12045 build_int_cst (integer_type_node
, pow2
));
12051 case FLOOR_DIV_EXPR
:
12052 /* Simplify A / (B << N) where A and B are positive and B is
12053 a power of 2, to A >> (N + log2(B)). */
12054 strict_overflow_p
= false;
12055 if (TREE_CODE (arg1
) == LSHIFT_EXPR
12056 && (TYPE_UNSIGNED (type
)
12057 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12059 tree sval
= TREE_OPERAND (arg1
, 0);
12060 if (integer_pow2p (sval
) && tree_int_cst_sgn (sval
) > 0)
12062 tree sh_cnt
= TREE_OPERAND (arg1
, 1);
12063 unsigned long pow2
;
12065 if (TREE_INT_CST_LOW (sval
))
12066 pow2
= exact_log2 (TREE_INT_CST_LOW (sval
));
12068 pow2
= exact_log2 (TREE_INT_CST_HIGH (sval
))
12069 + HOST_BITS_PER_WIDE_INT
;
12071 if (strict_overflow_p
)
12072 fold_overflow_warning (("assuming signed overflow does not "
12073 "occur when simplifying A / (B << N)"),
12074 WARN_STRICT_OVERFLOW_MISC
);
12076 sh_cnt
= fold_build2_loc (loc
, PLUS_EXPR
, TREE_TYPE (sh_cnt
),
12078 build_int_cst (TREE_TYPE (sh_cnt
),
12080 return fold_build2_loc (loc
, RSHIFT_EXPR
, type
,
12081 fold_convert_loc (loc
, type
, arg0
), sh_cnt
);
12085 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
12086 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
12087 if (INTEGRAL_TYPE_P (type
)
12088 && TYPE_UNSIGNED (type
)
12089 && code
== FLOOR_DIV_EXPR
)
12090 return fold_build2_loc (loc
, TRUNC_DIV_EXPR
, type
, op0
, op1
);
12094 case ROUND_DIV_EXPR
:
12095 case CEIL_DIV_EXPR
:
12096 case EXACT_DIV_EXPR
:
12097 if (integer_onep (arg1
))
12098 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12099 if (integer_zerop (arg1
))
12101 /* X / -1 is -X. */
12102 if (!TYPE_UNSIGNED (type
)
12103 && TREE_CODE (arg1
) == INTEGER_CST
12104 && TREE_INT_CST_LOW (arg1
) == (unsigned HOST_WIDE_INT
) -1
12105 && TREE_INT_CST_HIGH (arg1
) == -1)
12106 return fold_convert_loc (loc
, type
, negate_expr (arg0
));
12108 /* Convert -A / -B to A / B when the type is signed and overflow is
12110 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12111 && TREE_CODE (arg0
) == NEGATE_EXPR
12112 && negate_expr_p (arg1
))
12114 if (INTEGRAL_TYPE_P (type
))
12115 fold_overflow_warning (("assuming signed overflow does not occur "
12116 "when distributing negation across "
12118 WARN_STRICT_OVERFLOW_MISC
);
12119 return fold_build2_loc (loc
, code
, type
,
12120 fold_convert_loc (loc
, type
,
12121 TREE_OPERAND (arg0
, 0)),
12122 fold_convert_loc (loc
, type
,
12123 negate_expr (arg1
)));
12125 if ((!INTEGRAL_TYPE_P (type
) || TYPE_OVERFLOW_UNDEFINED (type
))
12126 && TREE_CODE (arg1
) == NEGATE_EXPR
12127 && negate_expr_p (arg0
))
12129 if (INTEGRAL_TYPE_P (type
))
12130 fold_overflow_warning (("assuming signed overflow does not occur "
12131 "when distributing negation across "
12133 WARN_STRICT_OVERFLOW_MISC
);
12134 return fold_build2_loc (loc
, code
, type
,
12135 fold_convert_loc (loc
, type
,
12136 negate_expr (arg0
)),
12137 fold_convert_loc (loc
, type
,
12138 TREE_OPERAND (arg1
, 0)));
12141 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12142 operation, EXACT_DIV_EXPR.
12144 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12145 At one time others generated faster code, it's not clear if they do
12146 after the last round to changes to the DIV code in expmed.c. */
12147 if ((code
== CEIL_DIV_EXPR
|| code
== FLOOR_DIV_EXPR
)
12148 && multiple_of_p (type
, arg0
, arg1
))
12149 return fold_build2_loc (loc
, EXACT_DIV_EXPR
, type
, arg0
, arg1
);
12151 strict_overflow_p
= false;
12152 if (TREE_CODE (arg1
) == INTEGER_CST
12153 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12154 &strict_overflow_p
)))
12156 if (strict_overflow_p
)
12157 fold_overflow_warning (("assuming signed overflow does not occur "
12158 "when simplifying division"),
12159 WARN_STRICT_OVERFLOW_MISC
);
12160 return fold_convert_loc (loc
, type
, tem
);
12165 case CEIL_MOD_EXPR
:
12166 case FLOOR_MOD_EXPR
:
12167 case ROUND_MOD_EXPR
:
12168 case TRUNC_MOD_EXPR
:
12169 /* X % 1 is always zero, but be sure to preserve any side
12171 if (integer_onep (arg1
))
12172 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12174 /* X % 0, return X % 0 unchanged so that we can get the
12175 proper warnings and errors. */
12176 if (integer_zerop (arg1
))
12179 /* 0 % X is always zero, but be sure to preserve any side
12180 effects in X. Place this after checking for X == 0. */
12181 if (integer_zerop (arg0
))
12182 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12184 /* X % -1 is zero. */
12185 if (!TYPE_UNSIGNED (type
)
12186 && TREE_CODE (arg1
) == INTEGER_CST
12187 && TREE_INT_CST_LOW (arg1
) == (unsigned HOST_WIDE_INT
) -1
12188 && TREE_INT_CST_HIGH (arg1
) == -1)
12189 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12191 /* X % -C is the same as X % C. */
12192 if (code
== TRUNC_MOD_EXPR
12193 && !TYPE_UNSIGNED (type
)
12194 && TREE_CODE (arg1
) == INTEGER_CST
12195 && !TREE_OVERFLOW (arg1
)
12196 && TREE_INT_CST_HIGH (arg1
) < 0
12197 && !TYPE_OVERFLOW_TRAPS (type
)
12198 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
12199 && !sign_bit_p (arg1
, arg1
))
12200 return fold_build2_loc (loc
, code
, type
,
12201 fold_convert_loc (loc
, type
, arg0
),
12202 fold_convert_loc (loc
, type
,
12203 negate_expr (arg1
)));
12205 /* X % -Y is the same as X % Y. */
12206 if (code
== TRUNC_MOD_EXPR
12207 && !TYPE_UNSIGNED (type
)
12208 && TREE_CODE (arg1
) == NEGATE_EXPR
12209 && !TYPE_OVERFLOW_TRAPS (type
))
12210 return fold_build2_loc (loc
, code
, type
, fold_convert_loc (loc
, type
, arg0
),
12211 fold_convert_loc (loc
, type
,
12212 TREE_OPERAND (arg1
, 0)));
12214 strict_overflow_p
= false;
12215 if (TREE_CODE (arg1
) == INTEGER_CST
12216 && 0 != (tem
= extract_muldiv (op0
, arg1
, code
, NULL_TREE
,
12217 &strict_overflow_p
)))
12219 if (strict_overflow_p
)
12220 fold_overflow_warning (("assuming signed overflow does not occur "
12221 "when simplifying modulus"),
12222 WARN_STRICT_OVERFLOW_MISC
);
12223 return fold_convert_loc (loc
, type
, tem
);
12226 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12227 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
12228 if ((code
== TRUNC_MOD_EXPR
|| code
== FLOOR_MOD_EXPR
)
12229 && (TYPE_UNSIGNED (type
)
12230 || tree_expr_nonnegative_warnv_p (op0
, &strict_overflow_p
)))
12233 /* Also optimize A % (C << N) where C is a power of 2,
12234 to A & ((C << N) - 1). */
12235 if (TREE_CODE (arg1
) == LSHIFT_EXPR
)
12236 c
= TREE_OPERAND (arg1
, 0);
12238 if (integer_pow2p (c
) && tree_int_cst_sgn (c
) > 0)
12241 = fold_build2_loc (loc
, MINUS_EXPR
, TREE_TYPE (arg1
), arg1
,
12242 build_int_cst (TREE_TYPE (arg1
), 1));
12243 if (strict_overflow_p
)
12244 fold_overflow_warning (("assuming signed overflow does not "
12245 "occur when simplifying "
12246 "X % (power of two)"),
12247 WARN_STRICT_OVERFLOW_MISC
);
12248 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
12249 fold_convert_loc (loc
, type
, arg0
),
12250 fold_convert_loc (loc
, type
, mask
));
12258 if (integer_all_onesp (arg0
))
12259 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12263 /* Optimize -1 >> x for arithmetic right shifts. */
12264 if (integer_all_onesp (arg0
) && !TYPE_UNSIGNED (type
)
12265 && tree_expr_nonnegative_p (arg1
))
12266 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12267 /* ... fall through ... */
12271 if (integer_zerop (arg1
))
12272 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12273 if (integer_zerop (arg0
))
12274 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12276 /* Since negative shift count is not well-defined,
12277 don't try to compute it in the compiler. */
12278 if (TREE_CODE (arg1
) == INTEGER_CST
&& tree_int_cst_sgn (arg1
) < 0)
12281 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
12282 if (TREE_CODE (op0
) == code
&& host_integerp (arg1
, false)
12283 && TREE_INT_CST_LOW (arg1
) < TYPE_PRECISION (type
)
12284 && host_integerp (TREE_OPERAND (arg0
, 1), false)
12285 && TREE_INT_CST_LOW (TREE_OPERAND (arg0
, 1)) < TYPE_PRECISION (type
))
12287 HOST_WIDE_INT low
= (TREE_INT_CST_LOW (TREE_OPERAND (arg0
, 1))
12288 + TREE_INT_CST_LOW (arg1
));
12290 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12291 being well defined. */
12292 if (low
>= TYPE_PRECISION (type
))
12294 if (code
== LROTATE_EXPR
|| code
== RROTATE_EXPR
)
12295 low
= low
% TYPE_PRECISION (type
);
12296 else if (TYPE_UNSIGNED (type
) || code
== LSHIFT_EXPR
)
12297 return omit_one_operand_loc (loc
, type
, build_int_cst (type
, 0),
12298 TREE_OPERAND (arg0
, 0));
12300 low
= TYPE_PRECISION (type
) - 1;
12303 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12304 build_int_cst (type
, low
));
12307 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12308 into x & ((unsigned)-1 >> c) for unsigned types. */
12309 if (((code
== LSHIFT_EXPR
&& TREE_CODE (arg0
) == RSHIFT_EXPR
)
12310 || (TYPE_UNSIGNED (type
)
12311 && code
== RSHIFT_EXPR
&& TREE_CODE (arg0
) == LSHIFT_EXPR
))
12312 && host_integerp (arg1
, false)
12313 && TREE_INT_CST_LOW (arg1
) < TYPE_PRECISION (type
)
12314 && host_integerp (TREE_OPERAND (arg0
, 1), false)
12315 && TREE_INT_CST_LOW (TREE_OPERAND (arg0
, 1)) < TYPE_PRECISION (type
))
12317 HOST_WIDE_INT low0
= TREE_INT_CST_LOW (TREE_OPERAND (arg0
, 1));
12318 HOST_WIDE_INT low1
= TREE_INT_CST_LOW (arg1
);
12324 arg00
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12326 lshift
= build_int_cst (type
, -1);
12327 lshift
= int_const_binop (code
, lshift
, arg1
);
12329 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
, arg00
, lshift
);
12333 /* Rewrite an LROTATE_EXPR by a constant into an
12334 RROTATE_EXPR by a new constant. */
12335 if (code
== LROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
)
12337 tree tem
= build_int_cst (TREE_TYPE (arg1
),
12338 TYPE_PRECISION (type
));
12339 tem
= const_binop (MINUS_EXPR
, tem
, arg1
);
12340 return fold_build2_loc (loc
, RROTATE_EXPR
, type
, op0
, tem
);
12343 /* If we have a rotate of a bit operation with the rotate count and
12344 the second operand of the bit operation both constant,
12345 permute the two operations. */
12346 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12347 && (TREE_CODE (arg0
) == BIT_AND_EXPR
12348 || TREE_CODE (arg0
) == BIT_IOR_EXPR
12349 || TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12350 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12351 return fold_build2_loc (loc
, TREE_CODE (arg0
), type
,
12352 fold_build2_loc (loc
, code
, type
,
12353 TREE_OPERAND (arg0
, 0), arg1
),
12354 fold_build2_loc (loc
, code
, type
,
12355 TREE_OPERAND (arg0
, 1), arg1
));
12357 /* Two consecutive rotates adding up to the precision of the
12358 type can be ignored. */
12359 if (code
== RROTATE_EXPR
&& TREE_CODE (arg1
) == INTEGER_CST
12360 && TREE_CODE (arg0
) == RROTATE_EXPR
12361 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
12362 && TREE_INT_CST_HIGH (arg1
) == 0
12363 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0
, 1)) == 0
12364 && ((TREE_INT_CST_LOW (arg1
)
12365 + TREE_INT_CST_LOW (TREE_OPERAND (arg0
, 1)))
12366 == (unsigned int) TYPE_PRECISION (type
)))
12367 return TREE_OPERAND (arg0
, 0);
12369 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12370 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12371 if the latter can be further optimized. */
12372 if ((code
== LSHIFT_EXPR
|| code
== RSHIFT_EXPR
)
12373 && TREE_CODE (arg0
) == BIT_AND_EXPR
12374 && TREE_CODE (arg1
) == INTEGER_CST
12375 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12377 tree mask
= fold_build2_loc (loc
, code
, type
,
12378 fold_convert_loc (loc
, type
,
12379 TREE_OPERAND (arg0
, 1)),
12381 tree shift
= fold_build2_loc (loc
, code
, type
,
12382 fold_convert_loc (loc
, type
,
12383 TREE_OPERAND (arg0
, 0)),
12385 tem
= fold_binary_loc (loc
, BIT_AND_EXPR
, type
, shift
, mask
);
12393 if (operand_equal_p (arg0
, arg1
, 0))
12394 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12395 if (INTEGRAL_TYPE_P (type
)
12396 && operand_equal_p (arg1
, TYPE_MIN_VALUE (type
), OEP_ONLY_CONST
))
12397 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12398 tem
= fold_minmax (loc
, MIN_EXPR
, type
, arg0
, arg1
);
12404 if (operand_equal_p (arg0
, arg1
, 0))
12405 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12406 if (INTEGRAL_TYPE_P (type
)
12407 && TYPE_MAX_VALUE (type
)
12408 && operand_equal_p (arg1
, TYPE_MAX_VALUE (type
), OEP_ONLY_CONST
))
12409 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12410 tem
= fold_minmax (loc
, MAX_EXPR
, type
, arg0
, arg1
);
12415 case TRUTH_ANDIF_EXPR
:
12416 /* Note that the operands of this must be ints
12417 and their values must be 0 or 1.
12418 ("true" is a fixed value perhaps depending on the language.) */
12419 /* If first arg is constant zero, return it. */
12420 if (integer_zerop (arg0
))
12421 return fold_convert_loc (loc
, type
, arg0
);
12422 case TRUTH_AND_EXPR
:
12423 /* If either arg is constant true, drop it. */
12424 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12425 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12426 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
)
12427 /* Preserve sequence points. */
12428 && (code
!= TRUTH_ANDIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12429 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12430 /* If second arg is constant zero, result is zero, but first arg
12431 must be evaluated. */
12432 if (integer_zerop (arg1
))
12433 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12434 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12435 case will be handled here. */
12436 if (integer_zerop (arg0
))
12437 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12439 /* !X && X is always false. */
12440 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12441 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12442 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg1
);
12443 /* X && !X is always false. */
12444 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12445 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12446 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12448 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12449 means A >= Y && A != MAX, but in this case we know that
12452 if (!TREE_SIDE_EFFECTS (arg0
)
12453 && !TREE_SIDE_EFFECTS (arg1
))
12455 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg0
, arg1
);
12456 if (tem
&& !operand_equal_p (tem
, arg0
, 0))
12457 return fold_build2_loc (loc
, code
, type
, tem
, arg1
);
12459 tem
= fold_to_nonsharp_ineq_using_bound (loc
, arg1
, arg0
);
12460 if (tem
&& !operand_equal_p (tem
, arg1
, 0))
12461 return fold_build2_loc (loc
, code
, type
, arg0
, tem
);
12464 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12470 case TRUTH_ORIF_EXPR
:
12471 /* Note that the operands of this must be ints
12472 and their values must be 0 or true.
12473 ("true" is a fixed value perhaps depending on the language.) */
12474 /* If first arg is constant true, return it. */
12475 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12476 return fold_convert_loc (loc
, type
, arg0
);
12477 case TRUTH_OR_EXPR
:
12478 /* If either arg is constant zero, drop it. */
12479 if (TREE_CODE (arg0
) == INTEGER_CST
&& integer_zerop (arg0
))
12480 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg1
));
12481 if (TREE_CODE (arg1
) == INTEGER_CST
&& integer_zerop (arg1
)
12482 /* Preserve sequence points. */
12483 && (code
!= TRUTH_ORIF_EXPR
|| ! TREE_SIDE_EFFECTS (arg0
)))
12484 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12485 /* If second arg is constant true, result is true, but we must
12486 evaluate first arg. */
12487 if (TREE_CODE (arg1
) == INTEGER_CST
&& ! integer_zerop (arg1
))
12488 return omit_one_operand_loc (loc
, type
, arg1
, arg0
);
12489 /* Likewise for first arg, but note this only occurs here for
12491 if (TREE_CODE (arg0
) == INTEGER_CST
&& ! integer_zerop (arg0
))
12492 return omit_one_operand_loc (loc
, type
, arg0
, arg1
);
12494 /* !X || X is always true. */
12495 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12496 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12497 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12498 /* X || !X is always true. */
12499 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12500 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12501 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12503 /* (X && !Y) || (!X && Y) is X ^ Y */
12504 if (TREE_CODE (arg0
) == TRUTH_AND_EXPR
12505 && TREE_CODE (arg1
) == TRUTH_AND_EXPR
)
12507 tree a0
, a1
, l0
, l1
, n0
, n1
;
12509 a0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 0));
12510 a1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg1
, 1));
12512 l0
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 0));
12513 l1
= fold_convert_loc (loc
, type
, TREE_OPERAND (arg0
, 1));
12515 n0
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l0
);
12516 n1
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, type
, l1
);
12518 if ((operand_equal_p (n0
, a0
, 0)
12519 && operand_equal_p (n1
, a1
, 0))
12520 || (operand_equal_p (n0
, a1
, 0)
12521 && operand_equal_p (n1
, a0
, 0)))
12522 return fold_build2_loc (loc
, TRUTH_XOR_EXPR
, type
, l0
, n1
);
12525 if ((tem
= fold_truth_andor (loc
, code
, type
, arg0
, arg1
, op0
, op1
))
12531 case TRUTH_XOR_EXPR
:
12532 /* If the second arg is constant zero, drop it. */
12533 if (integer_zerop (arg1
))
12534 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12535 /* If the second arg is constant true, this is a logical inversion. */
12536 if (integer_onep (arg1
))
12538 /* Only call invert_truthvalue if operand is a truth value. */
12539 if (TREE_CODE (TREE_TYPE (arg0
)) != BOOLEAN_TYPE
)
12540 tem
= fold_build1_loc (loc
, TRUTH_NOT_EXPR
, TREE_TYPE (arg0
), arg0
);
12542 tem
= invert_truthvalue_loc (loc
, arg0
);
12543 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, tem
));
12545 /* Identical arguments cancel to zero. */
12546 if (operand_equal_p (arg0
, arg1
, 0))
12547 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
12549 /* !X ^ X is always true. */
12550 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
12551 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0))
12552 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg1
);
12554 /* X ^ !X is always true. */
12555 if (TREE_CODE (arg1
) == TRUTH_NOT_EXPR
12556 && operand_equal_p (arg0
, TREE_OPERAND (arg1
, 0), 0))
12557 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
12566 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
12567 if (tem
!= NULL_TREE
)
12570 /* bool_var != 0 becomes bool_var. */
12571 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12572 && code
== NE_EXPR
)
12573 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12575 /* bool_var == 1 becomes bool_var. */
12576 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12577 && code
== EQ_EXPR
)
12578 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12580 /* bool_var != 1 becomes !bool_var. */
12581 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_onep (arg1
)
12582 && code
== NE_EXPR
)
12583 return fold_convert_loc (loc
, type
,
12584 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12585 TREE_TYPE (arg0
), arg0
));
12587 /* bool_var == 0 becomes !bool_var. */
12588 if (TREE_CODE (TREE_TYPE (arg0
)) == BOOLEAN_TYPE
&& integer_zerop (arg1
)
12589 && code
== EQ_EXPR
)
12590 return fold_convert_loc (loc
, type
,
12591 fold_build1_loc (loc
, TRUTH_NOT_EXPR
,
12592 TREE_TYPE (arg0
), arg0
));
12594 /* !exp != 0 becomes !exp */
12595 if (TREE_CODE (arg0
) == TRUTH_NOT_EXPR
&& integer_zerop (arg1
)
12596 && code
== NE_EXPR
)
12597 return non_lvalue_loc (loc
, fold_convert_loc (loc
, type
, arg0
));
12599 /* If this is an equality comparison of the address of two non-weak,
12600 unaliased symbols neither of which are extern (since we do not
12601 have access to attributes for externs), then we know the result. */
12602 if (TREE_CODE (arg0
) == ADDR_EXPR
12603 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0
, 0))
12604 && ! DECL_WEAK (TREE_OPERAND (arg0
, 0))
12605 && ! lookup_attribute ("alias",
12606 DECL_ATTRIBUTES (TREE_OPERAND (arg0
, 0)))
12607 && ! DECL_EXTERNAL (TREE_OPERAND (arg0
, 0))
12608 && TREE_CODE (arg1
) == ADDR_EXPR
12609 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1
, 0))
12610 && ! DECL_WEAK (TREE_OPERAND (arg1
, 0))
12611 && ! lookup_attribute ("alias",
12612 DECL_ATTRIBUTES (TREE_OPERAND (arg1
, 0)))
12613 && ! DECL_EXTERNAL (TREE_OPERAND (arg1
, 0)))
12615 /* We know that we're looking at the address of two
12616 non-weak, unaliased, static _DECL nodes.
12618 It is both wasteful and incorrect to call operand_equal_p
12619 to compare the two ADDR_EXPR nodes. It is wasteful in that
12620 all we need to do is test pointer equality for the arguments
12621 to the two ADDR_EXPR nodes. It is incorrect to use
12622 operand_equal_p as that function is NOT equivalent to a
12623 C equality test. It can in fact return false for two
12624 objects which would test as equal using the C equality
12626 bool equal
= TREE_OPERAND (arg0
, 0) == TREE_OPERAND (arg1
, 0);
12627 return constant_boolean_node (equal
12628 ? code
== EQ_EXPR
: code
!= EQ_EXPR
,
12632 /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
12633 a MINUS_EXPR of a constant, we can convert it into a comparison with
12634 a revised constant as long as no overflow occurs. */
12635 if (TREE_CODE (arg1
) == INTEGER_CST
12636 && (TREE_CODE (arg0
) == PLUS_EXPR
12637 || TREE_CODE (arg0
) == MINUS_EXPR
)
12638 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
12639 && 0 != (tem
= const_binop (TREE_CODE (arg0
) == PLUS_EXPR
12640 ? MINUS_EXPR
: PLUS_EXPR
,
12641 fold_convert_loc (loc
, TREE_TYPE (arg0
),
12643 TREE_OPERAND (arg0
, 1)))
12644 && !TREE_OVERFLOW (tem
))
12645 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
12647 /* Similarly for a NEGATE_EXPR. */
12648 if (TREE_CODE (arg0
) == NEGATE_EXPR
12649 && TREE_CODE (arg1
) == INTEGER_CST
12650 && 0 != (tem
= negate_expr (fold_convert_loc (loc
, TREE_TYPE (arg0
),
12652 && TREE_CODE (tem
) == INTEGER_CST
12653 && !TREE_OVERFLOW (tem
))
12654 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), tem
);
12656 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
12657 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12658 && TREE_CODE (arg1
) == INTEGER_CST
12659 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12660 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12661 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg0
),
12662 fold_convert_loc (loc
,
12665 TREE_OPERAND (arg0
, 1)));
12667 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
12668 if ((TREE_CODE (arg0
) == PLUS_EXPR
12669 || TREE_CODE (arg0
) == POINTER_PLUS_EXPR
12670 || TREE_CODE (arg0
) == MINUS_EXPR
)
12671 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12674 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
12675 || POINTER_TYPE_P (TREE_TYPE (arg0
))))
12677 tree val
= TREE_OPERAND (arg0
, 1);
12678 return omit_two_operands_loc (loc
, type
,
12679 fold_build2_loc (loc
, code
, type
,
12681 build_int_cst (TREE_TYPE (val
),
12683 TREE_OPERAND (arg0
, 0), arg1
);
12686 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
12687 if (TREE_CODE (arg0
) == MINUS_EXPR
12688 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == INTEGER_CST
12689 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0
,
12692 && (TREE_INT_CST_LOW (TREE_OPERAND (arg0
, 0)) & 1) == 1)
12694 return omit_two_operands_loc (loc
, type
,
12696 ? boolean_true_node
: boolean_false_node
,
12697 TREE_OPERAND (arg0
, 1), arg1
);
12700 /* If we have X - Y == 0, we can convert that to X == Y and similarly
12701 for !=. Don't do this for ordered comparisons due to overflow. */
12702 if (TREE_CODE (arg0
) == MINUS_EXPR
12703 && integer_zerop (arg1
))
12704 return fold_build2_loc (loc
, code
, type
,
12705 TREE_OPERAND (arg0
, 0), TREE_OPERAND (arg0
, 1));
12707 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
12708 if (TREE_CODE (arg0
) == ABS_EXPR
12709 && (integer_zerop (arg1
) || real_zerop (arg1
)))
12710 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0), arg1
);
12712 /* If this is an EQ or NE comparison with zero and ARG0 is
12713 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
12714 two operations, but the latter can be done in one less insn
12715 on machines that have only two-operand insns or on which a
12716 constant cannot be the first operand. */
12717 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12718 && integer_zerop (arg1
))
12720 tree arg00
= TREE_OPERAND (arg0
, 0);
12721 tree arg01
= TREE_OPERAND (arg0
, 1);
12722 if (TREE_CODE (arg00
) == LSHIFT_EXPR
12723 && integer_onep (TREE_OPERAND (arg00
, 0)))
12725 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg00
),
12726 arg01
, TREE_OPERAND (arg00
, 1));
12727 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12728 build_int_cst (TREE_TYPE (arg0
), 1));
12729 return fold_build2_loc (loc
, code
, type
,
12730 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12733 else if (TREE_CODE (arg01
) == LSHIFT_EXPR
12734 && integer_onep (TREE_OPERAND (arg01
, 0)))
12736 tree tem
= fold_build2_loc (loc
, RSHIFT_EXPR
, TREE_TYPE (arg01
),
12737 arg00
, TREE_OPERAND (arg01
, 1));
12738 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
), tem
,
12739 build_int_cst (TREE_TYPE (arg0
), 1));
12740 return fold_build2_loc (loc
, code
, type
,
12741 fold_convert_loc (loc
, TREE_TYPE (arg1
), tem
),
12746 /* If this is an NE or EQ comparison of zero against the result of a
12747 signed MOD operation whose second operand is a power of 2, make
12748 the MOD operation unsigned since it is simpler and equivalent. */
12749 if (integer_zerop (arg1
)
12750 && !TYPE_UNSIGNED (TREE_TYPE (arg0
))
12751 && (TREE_CODE (arg0
) == TRUNC_MOD_EXPR
12752 || TREE_CODE (arg0
) == CEIL_MOD_EXPR
12753 || TREE_CODE (arg0
) == FLOOR_MOD_EXPR
12754 || TREE_CODE (arg0
) == ROUND_MOD_EXPR
)
12755 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
12757 tree newtype
= unsigned_type_for (TREE_TYPE (arg0
));
12758 tree newmod
= fold_build2_loc (loc
, TREE_CODE (arg0
), newtype
,
12759 fold_convert_loc (loc
, newtype
,
12760 TREE_OPERAND (arg0
, 0)),
12761 fold_convert_loc (loc
, newtype
,
12762 TREE_OPERAND (arg0
, 1)));
12764 return fold_build2_loc (loc
, code
, type
, newmod
,
12765 fold_convert_loc (loc
, newtype
, arg1
));
12768 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12769 C1 is a valid shift constant, and C2 is a power of two, i.e.
12771 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12772 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == RSHIFT_EXPR
12773 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1))
12775 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12776 && integer_zerop (arg1
))
12778 tree itype
= TREE_TYPE (arg0
);
12779 unsigned HOST_WIDE_INT prec
= TYPE_PRECISION (itype
);
12780 tree arg001
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1);
12782 /* Check for a valid shift count. */
12783 if (TREE_INT_CST_HIGH (arg001
) == 0
12784 && TREE_INT_CST_LOW (arg001
) < prec
)
12786 tree arg01
= TREE_OPERAND (arg0
, 1);
12787 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
12788 unsigned HOST_WIDE_INT log2
= tree_log2 (arg01
);
12789 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12790 can be rewritten as (X & (C2 << C1)) != 0. */
12791 if ((log2
+ TREE_INT_CST_LOW (arg001
)) < prec
)
12793 tem
= fold_build2_loc (loc
, LSHIFT_EXPR
, itype
, arg01
, arg001
);
12794 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, itype
, arg000
, tem
);
12795 return fold_build2_loc (loc
, code
, type
, tem
,
12796 fold_convert_loc (loc
, itype
, arg1
));
12798 /* Otherwise, for signed (arithmetic) shifts,
12799 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12800 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
12801 else if (!TYPE_UNSIGNED (itype
))
12802 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
, type
,
12803 arg000
, build_int_cst (itype
, 0));
12804 /* Otherwise, of unsigned (logical) shifts,
12805 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12806 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
12808 return omit_one_operand_loc (loc
, type
,
12809 code
== EQ_EXPR
? integer_one_node
12810 : integer_zero_node
,
12815 /* If we have (A & C) == C where C is a power of 2, convert this into
12816 (A & C) != 0. Similarly for NE_EXPR. */
12817 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12818 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12819 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
12820 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
12821 arg0
, fold_convert_loc (loc
, TREE_TYPE (arg0
),
12822 integer_zero_node
));
12824 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12825 bit, then fold the expression into A < 0 or A >= 0. */
12826 tem
= fold_single_bit_test_into_sign_test (loc
, code
, arg0
, arg1
, type
);
12830 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12831 Similarly for NE_EXPR. */
12832 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12833 && TREE_CODE (arg1
) == INTEGER_CST
12834 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12836 tree notc
= fold_build1_loc (loc
, BIT_NOT_EXPR
,
12837 TREE_TYPE (TREE_OPERAND (arg0
, 1)),
12838 TREE_OPERAND (arg0
, 1));
12840 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12841 fold_convert_loc (loc
, TREE_TYPE (arg0
), arg1
),
12843 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
12844 if (integer_nonzerop (dandnotc
))
12845 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
12848 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12849 Similarly for NE_EXPR. */
12850 if (TREE_CODE (arg0
) == BIT_IOR_EXPR
12851 && TREE_CODE (arg1
) == INTEGER_CST
12852 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12854 tree notd
= fold_build1_loc (loc
, BIT_NOT_EXPR
, TREE_TYPE (arg1
), arg1
);
12856 = fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12857 TREE_OPERAND (arg0
, 1),
12858 fold_convert_loc (loc
, TREE_TYPE (arg0
), notd
));
12859 tree rslt
= code
== EQ_EXPR
? integer_zero_node
: integer_one_node
;
12860 if (integer_nonzerop (candnotd
))
12861 return omit_one_operand_loc (loc
, type
, rslt
, arg0
);
12864 /* If this is a comparison of a field, we may be able to simplify it. */
12865 if ((TREE_CODE (arg0
) == COMPONENT_REF
12866 || TREE_CODE (arg0
) == BIT_FIELD_REF
)
12867 /* Handle the constant case even without -O
12868 to make sure the warnings are given. */
12869 && (optimize
|| TREE_CODE (arg1
) == INTEGER_CST
))
12871 t1
= optimize_bit_field_compare (loc
, code
, type
, arg0
, arg1
);
12876 /* Optimize comparisons of strlen vs zero to a compare of the
12877 first character of the string vs zero. To wit,
12878 strlen(ptr) == 0 => *ptr == 0
12879 strlen(ptr) != 0 => *ptr != 0
12880 Other cases should reduce to one of these two (or a constant)
12881 due to the return value of strlen being unsigned. */
12882 if (TREE_CODE (arg0
) == CALL_EXPR
12883 && integer_zerop (arg1
))
12885 tree fndecl
= get_callee_fndecl (arg0
);
12888 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
12889 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_STRLEN
12890 && call_expr_nargs (arg0
) == 1
12891 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0
, 0))) == POINTER_TYPE
)
12893 tree iref
= build_fold_indirect_ref_loc (loc
,
12894 CALL_EXPR_ARG (arg0
, 0));
12895 return fold_build2_loc (loc
, code
, type
, iref
,
12896 build_int_cst (TREE_TYPE (iref
), 0));
12900 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12901 of X. Similarly fold (X >> C) == 0 into X >= 0. */
12902 if (TREE_CODE (arg0
) == RSHIFT_EXPR
12903 && integer_zerop (arg1
)
12904 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12906 tree arg00
= TREE_OPERAND (arg0
, 0);
12907 tree arg01
= TREE_OPERAND (arg0
, 1);
12908 tree itype
= TREE_TYPE (arg00
);
12909 if (TREE_INT_CST_HIGH (arg01
) == 0
12910 && TREE_INT_CST_LOW (arg01
)
12911 == (unsigned HOST_WIDE_INT
) (TYPE_PRECISION (itype
) - 1))
12913 if (TYPE_UNSIGNED (itype
))
12915 itype
= signed_type_for (itype
);
12916 arg00
= fold_convert_loc (loc
, itype
, arg00
);
12918 return fold_build2_loc (loc
, code
== EQ_EXPR
? GE_EXPR
: LT_EXPR
,
12919 type
, arg00
, build_zero_cst (itype
));
12923 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
12924 if (integer_zerop (arg1
)
12925 && TREE_CODE (arg0
) == BIT_XOR_EXPR
)
12926 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12927 TREE_OPERAND (arg0
, 1));
12929 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
12930 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12931 && operand_equal_p (TREE_OPERAND (arg0
, 1), arg1
, 0))
12932 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12933 build_zero_cst (TREE_TYPE (arg0
)));
12934 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
12935 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12936 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
12937 && reorder_operands_p (TREE_OPERAND (arg0
, 1), arg1
))
12938 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 1),
12939 build_zero_cst (TREE_TYPE (arg0
)));
12941 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
12942 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12943 && TREE_CODE (arg1
) == INTEGER_CST
12944 && TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
)
12945 return fold_build2_loc (loc
, code
, type
, TREE_OPERAND (arg0
, 0),
12946 fold_build2_loc (loc
, BIT_XOR_EXPR
, TREE_TYPE (arg1
),
12947 TREE_OPERAND (arg0
, 1), arg1
));
12949 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12950 (X & C) == 0 when C is a single bit. */
12951 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12952 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_NOT_EXPR
12953 && integer_zerop (arg1
)
12954 && integer_pow2p (TREE_OPERAND (arg0
, 1)))
12956 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg0
),
12957 TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0),
12958 TREE_OPERAND (arg0
, 1));
12959 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
,
12961 fold_convert_loc (loc
, TREE_TYPE (arg0
),
12965 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12966 constant C is a power of two, i.e. a single bit. */
12967 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
12968 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
12969 && integer_zerop (arg1
)
12970 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12971 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
12972 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
12974 tree arg00
= TREE_OPERAND (arg0
, 0);
12975 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
12976 arg00
, build_int_cst (TREE_TYPE (arg00
), 0));
12979 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12980 when is C is a power of two, i.e. a single bit. */
12981 if (TREE_CODE (arg0
) == BIT_AND_EXPR
12982 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_XOR_EXPR
12983 && integer_zerop (arg1
)
12984 && integer_pow2p (TREE_OPERAND (arg0
, 1))
12985 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
12986 TREE_OPERAND (arg0
, 1), OEP_ONLY_CONST
))
12988 tree arg000
= TREE_OPERAND (TREE_OPERAND (arg0
, 0), 0);
12989 tem
= fold_build2_loc (loc
, BIT_AND_EXPR
, TREE_TYPE (arg000
),
12990 arg000
, TREE_OPERAND (arg0
, 1));
12991 return fold_build2_loc (loc
, code
== EQ_EXPR
? NE_EXPR
: EQ_EXPR
, type
,
12992 tem
, build_int_cst (TREE_TYPE (tem
), 0));
12995 if (integer_zerop (arg1
)
12996 && tree_expr_nonzero_p (arg0
))
12998 tree res
= constant_boolean_node (code
==NE_EXPR
, type
);
12999 return omit_one_operand_loc (loc
, type
, res
, arg0
);
13002 /* Fold -X op -Y as X op Y, where op is eq/ne. */
13003 if (TREE_CODE (arg0
) == NEGATE_EXPR
13004 && TREE_CODE (arg1
) == NEGATE_EXPR
)
13005 return fold_build2_loc (loc
, code
, type
,
13006 TREE_OPERAND (arg0
, 0),
13007 fold_convert_loc (loc
, TREE_TYPE (arg0
),
13008 TREE_OPERAND (arg1
, 0)));
13010 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
13011 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13012 && TREE_CODE (arg1
) == BIT_AND_EXPR
)
13014 tree arg00
= TREE_OPERAND (arg0
, 0);
13015 tree arg01
= TREE_OPERAND (arg0
, 1);
13016 tree arg10
= TREE_OPERAND (arg1
, 0);
13017 tree arg11
= TREE_OPERAND (arg1
, 1);
13018 tree itype
= TREE_TYPE (arg0
);
13020 if (operand_equal_p (arg01
, arg11
, 0))
13021 return fold_build2_loc (loc
, code
, type
,
13022 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13023 fold_build2_loc (loc
,
13024 BIT_XOR_EXPR
, itype
,
13027 build_zero_cst (itype
));
13029 if (operand_equal_p (arg01
, arg10
, 0))
13030 return fold_build2_loc (loc
, code
, type
,
13031 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13032 fold_build2_loc (loc
,
13033 BIT_XOR_EXPR
, itype
,
13036 build_zero_cst (itype
));
13038 if (operand_equal_p (arg00
, arg11
, 0))
13039 return fold_build2_loc (loc
, code
, type
,
13040 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13041 fold_build2_loc (loc
,
13042 BIT_XOR_EXPR
, itype
,
13045 build_zero_cst (itype
));
13047 if (operand_equal_p (arg00
, arg10
, 0))
13048 return fold_build2_loc (loc
, code
, type
,
13049 fold_build2_loc (loc
, BIT_AND_EXPR
, itype
,
13050 fold_build2_loc (loc
,
13051 BIT_XOR_EXPR
, itype
,
13054 build_zero_cst (itype
));
13057 if (TREE_CODE (arg0
) == BIT_XOR_EXPR
13058 && TREE_CODE (arg1
) == BIT_XOR_EXPR
)
13060 tree arg00
= TREE_OPERAND (arg0
, 0);
13061 tree arg01
= TREE_OPERAND (arg0
, 1);
13062 tree arg10
= TREE_OPERAND (arg1
, 0);
13063 tree arg11
= TREE_OPERAND (arg1
, 1);
13064 tree itype
= TREE_TYPE (arg0
);
13066 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
13067 operand_equal_p guarantees no side-effects so we don't need
13068 to use omit_one_operand on Z. */
13069 if (operand_equal_p (arg01
, arg11
, 0))
13070 return fold_build2_loc (loc
, code
, type
, arg00
,
13071 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13073 if (operand_equal_p (arg01
, arg10
, 0))
13074 return fold_build2_loc (loc
, code
, type
, arg00
,
13075 fold_convert_loc (loc
, TREE_TYPE (arg00
),
13077 if (operand_equal_p (arg00
, arg11
, 0))
13078 return fold_build2_loc (loc
, code
, type
, arg01
,
13079 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13081 if (operand_equal_p (arg00
, arg10
, 0))
13082 return fold_build2_loc (loc
, code
, type
, arg01
,
13083 fold_convert_loc (loc
, TREE_TYPE (arg01
),
13086 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
13087 if (TREE_CODE (arg01
) == INTEGER_CST
13088 && TREE_CODE (arg11
) == INTEGER_CST
)
13090 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg01
,
13091 fold_convert_loc (loc
, itype
, arg11
));
13092 tem
= fold_build2_loc (loc
, BIT_XOR_EXPR
, itype
, arg00
, tem
);
13093 return fold_build2_loc (loc
, code
, type
, tem
,
13094 fold_convert_loc (loc
, itype
, arg10
));
13098 /* Attempt to simplify equality/inequality comparisons of complex
13099 values. Only lower the comparison if the result is known or
13100 can be simplified to a single scalar comparison. */
13101 if ((TREE_CODE (arg0
) == COMPLEX_EXPR
13102 || TREE_CODE (arg0
) == COMPLEX_CST
)
13103 && (TREE_CODE (arg1
) == COMPLEX_EXPR
13104 || TREE_CODE (arg1
) == COMPLEX_CST
))
13106 tree real0
, imag0
, real1
, imag1
;
13109 if (TREE_CODE (arg0
) == COMPLEX_EXPR
)
13111 real0
= TREE_OPERAND (arg0
, 0);
13112 imag0
= TREE_OPERAND (arg0
, 1);
13116 real0
= TREE_REALPART (arg0
);
13117 imag0
= TREE_IMAGPART (arg0
);
13120 if (TREE_CODE (arg1
) == COMPLEX_EXPR
)
13122 real1
= TREE_OPERAND (arg1
, 0);
13123 imag1
= TREE_OPERAND (arg1
, 1);
13127 real1
= TREE_REALPART (arg1
);
13128 imag1
= TREE_IMAGPART (arg1
);
13131 rcond
= fold_binary_loc (loc
, code
, type
, real0
, real1
);
13132 if (rcond
&& TREE_CODE (rcond
) == INTEGER_CST
)
13134 if (integer_zerop (rcond
))
13136 if (code
== EQ_EXPR
)
13137 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13139 return fold_build2_loc (loc
, NE_EXPR
, type
, imag0
, imag1
);
13143 if (code
== NE_EXPR
)
13144 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13146 return fold_build2_loc (loc
, EQ_EXPR
, type
, imag0
, imag1
);
13150 icond
= fold_binary_loc (loc
, code
, type
, imag0
, imag1
);
13151 if (icond
&& TREE_CODE (icond
) == INTEGER_CST
)
13153 if (integer_zerop (icond
))
13155 if (code
== EQ_EXPR
)
13156 return omit_two_operands_loc (loc
, type
, boolean_false_node
,
13158 return fold_build2_loc (loc
, NE_EXPR
, type
, real0
, real1
);
13162 if (code
== NE_EXPR
)
13163 return omit_two_operands_loc (loc
, type
, boolean_true_node
,
13165 return fold_build2_loc (loc
, EQ_EXPR
, type
, real0
, real1
);
13176 tem
= fold_comparison (loc
, code
, type
, op0
, op1
);
13177 if (tem
!= NULL_TREE
)
13180 /* Transform comparisons of the form X +- C CMP X. */
13181 if ((TREE_CODE (arg0
) == PLUS_EXPR
|| TREE_CODE (arg0
) == MINUS_EXPR
)
13182 && operand_equal_p (TREE_OPERAND (arg0
, 0), arg1
, 0)
13183 && ((TREE_CODE (TREE_OPERAND (arg0
, 1)) == REAL_CST
13184 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0
))))
13185 || (TREE_CODE (TREE_OPERAND (arg0
, 1)) == INTEGER_CST
13186 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))))
13188 tree arg01
= TREE_OPERAND (arg0
, 1);
13189 enum tree_code code0
= TREE_CODE (arg0
);
13192 if (TREE_CODE (arg01
) == REAL_CST
)
13193 is_positive
= REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01
)) ? -1 : 1;
13195 is_positive
= tree_int_cst_sgn (arg01
);
13197 /* (X - c) > X becomes false. */
13198 if (code
== GT_EXPR
13199 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13200 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13202 if (TREE_CODE (arg01
) == INTEGER_CST
13203 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13204 fold_overflow_warning (("assuming signed overflow does not "
13205 "occur when assuming that (X - c) > X "
13206 "is always false"),
13207 WARN_STRICT_OVERFLOW_ALL
);
13208 return constant_boolean_node (0, type
);
13211 /* Likewise (X + c) < X becomes false. */
13212 if (code
== LT_EXPR
13213 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13214 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13216 if (TREE_CODE (arg01
) == INTEGER_CST
13217 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13218 fold_overflow_warning (("assuming signed overflow does not "
13219 "occur when assuming that "
13220 "(X + c) < X is always false"),
13221 WARN_STRICT_OVERFLOW_ALL
);
13222 return constant_boolean_node (0, type
);
13225 /* Convert (X - c) <= X to true. */
13226 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13228 && ((code0
== MINUS_EXPR
&& is_positive
>= 0)
13229 || (code0
== PLUS_EXPR
&& is_positive
<= 0)))
13231 if (TREE_CODE (arg01
) == INTEGER_CST
13232 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13233 fold_overflow_warning (("assuming signed overflow does not "
13234 "occur when assuming that "
13235 "(X - c) <= X is always true"),
13236 WARN_STRICT_OVERFLOW_ALL
);
13237 return constant_boolean_node (1, type
);
13240 /* Convert (X + c) >= X to true. */
13241 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1
)))
13243 && ((code0
== PLUS_EXPR
&& is_positive
>= 0)
13244 || (code0
== MINUS_EXPR
&& is_positive
<= 0)))
13246 if (TREE_CODE (arg01
) == INTEGER_CST
13247 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13248 fold_overflow_warning (("assuming signed overflow does not "
13249 "occur when assuming that "
13250 "(X + c) >= X is always true"),
13251 WARN_STRICT_OVERFLOW_ALL
);
13252 return constant_boolean_node (1, type
);
13255 if (TREE_CODE (arg01
) == INTEGER_CST
)
13257 /* Convert X + c > X and X - c < X to true for integers. */
13258 if (code
== GT_EXPR
13259 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13260 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13262 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13263 fold_overflow_warning (("assuming signed overflow does "
13264 "not occur when assuming that "
13265 "(X + c) > X is always true"),
13266 WARN_STRICT_OVERFLOW_ALL
);
13267 return constant_boolean_node (1, type
);
13270 if (code
== LT_EXPR
13271 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13272 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13274 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13275 fold_overflow_warning (("assuming signed overflow does "
13276 "not occur when assuming that "
13277 "(X - c) < X is always true"),
13278 WARN_STRICT_OVERFLOW_ALL
);
13279 return constant_boolean_node (1, type
);
13282 /* Convert X + c <= X and X - c >= X to false for integers. */
13283 if (code
== LE_EXPR
13284 && ((code0
== PLUS_EXPR
&& is_positive
> 0)
13285 || (code0
== MINUS_EXPR
&& is_positive
< 0)))
13287 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13288 fold_overflow_warning (("assuming signed overflow does "
13289 "not occur when assuming that "
13290 "(X + c) <= X is always false"),
13291 WARN_STRICT_OVERFLOW_ALL
);
13292 return constant_boolean_node (0, type
);
13295 if (code
== GE_EXPR
13296 && ((code0
== MINUS_EXPR
&& is_positive
> 0)
13297 || (code0
== PLUS_EXPR
&& is_positive
< 0)))
13299 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1
)))
13300 fold_overflow_warning (("assuming signed overflow does "
13301 "not occur when assuming that "
13302 "(X - c) >= X is always false"),
13303 WARN_STRICT_OVERFLOW_ALL
);
13304 return constant_boolean_node (0, type
);
13309 /* Comparisons with the highest or lowest possible integer of
13310 the specified precision will have known values. */
13312 tree arg1_type
= TREE_TYPE (arg1
);
13313 unsigned int width
= TYPE_PRECISION (arg1_type
);
13315 if (TREE_CODE (arg1
) == INTEGER_CST
13316 && width
<= HOST_BITS_PER_DOUBLE_INT
13317 && (INTEGRAL_TYPE_P (arg1_type
) || POINTER_TYPE_P (arg1_type
)))
13319 HOST_WIDE_INT signed_max_hi
;
13320 unsigned HOST_WIDE_INT signed_max_lo
;
13321 unsigned HOST_WIDE_INT max_hi
, max_lo
, min_hi
, min_lo
;
13323 if (width
<= HOST_BITS_PER_WIDE_INT
)
13325 signed_max_lo
= ((unsigned HOST_WIDE_INT
) 1 << (width
- 1))
13330 if (TYPE_UNSIGNED (arg1_type
))
13332 max_lo
= ((unsigned HOST_WIDE_INT
) 2 << (width
- 1)) - 1;
13338 max_lo
= signed_max_lo
;
13339 min_lo
= ((unsigned HOST_WIDE_INT
) -1 << (width
- 1));
13345 width
-= HOST_BITS_PER_WIDE_INT
;
13346 signed_max_lo
= -1;
13347 signed_max_hi
= ((unsigned HOST_WIDE_INT
) 1 << (width
- 1))
13352 if (TYPE_UNSIGNED (arg1_type
))
13354 max_hi
= ((unsigned HOST_WIDE_INT
) 2 << (width
- 1)) - 1;
13359 max_hi
= signed_max_hi
;
13360 min_hi
= ((unsigned HOST_WIDE_INT
) -1 << (width
- 1));
13364 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (arg1
) == max_hi
13365 && TREE_INT_CST_LOW (arg1
) == max_lo
)
13369 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13372 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13375 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13378 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13380 /* The GE_EXPR and LT_EXPR cases above are not normally
13381 reached because of previous transformations. */
13386 else if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (arg1
)
13388 && TREE_INT_CST_LOW (arg1
) == max_lo
- 1)
13392 arg1
= const_binop (PLUS_EXPR
, arg1
,
13393 build_int_cst (TREE_TYPE (arg1
), 1));
13394 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13395 fold_convert_loc (loc
,
13396 TREE_TYPE (arg1
), arg0
),
13399 arg1
= const_binop (PLUS_EXPR
, arg1
,
13400 build_int_cst (TREE_TYPE (arg1
), 1));
13401 return fold_build2_loc (loc
, NE_EXPR
, type
,
13402 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13408 else if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (arg1
)
13410 && TREE_INT_CST_LOW (arg1
) == min_lo
)
13414 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13417 return fold_build2_loc (loc
, EQ_EXPR
, type
, op0
, op1
);
13420 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13423 return fold_build2_loc (loc
, NE_EXPR
, type
, op0
, op1
);
13428 else if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (arg1
)
13430 && TREE_INT_CST_LOW (arg1
) == min_lo
+ 1)
13434 arg1
= const_binop (MINUS_EXPR
, arg1
, integer_one_node
);
13435 return fold_build2_loc (loc
, NE_EXPR
, type
,
13436 fold_convert_loc (loc
,
13437 TREE_TYPE (arg1
), arg0
),
13440 arg1
= const_binop (MINUS_EXPR
, arg1
, integer_one_node
);
13441 return fold_build2_loc (loc
, EQ_EXPR
, type
,
13442 fold_convert_loc (loc
, TREE_TYPE (arg1
),
13449 else if (TREE_INT_CST_HIGH (arg1
) == signed_max_hi
13450 && TREE_INT_CST_LOW (arg1
) == signed_max_lo
13451 && TYPE_UNSIGNED (arg1_type
)
13452 /* We will flip the signedness of the comparison operator
13453 associated with the mode of arg1, so the sign bit is
13454 specified by this mode. Check that arg1 is the signed
13455 max associated with this sign bit. */
13456 && width
== GET_MODE_BITSIZE (TYPE_MODE (arg1_type
))
13457 /* signed_type does not work on pointer types. */
13458 && INTEGRAL_TYPE_P (arg1_type
))
13460 /* The following case also applies to X < signed_max+1
13461 and X >= signed_max+1 because previous transformations. */
13462 if (code
== LE_EXPR
|| code
== GT_EXPR
)
13465 st
= signed_type_for (TREE_TYPE (arg1
));
13466 return fold_build2_loc (loc
,
13467 code
== LE_EXPR
? GE_EXPR
: LT_EXPR
,
13468 type
, fold_convert_loc (loc
, st
, arg0
),
13469 build_int_cst (st
, 0));
13475 /* If we are comparing an ABS_EXPR with a constant, we can
13476 convert all the cases into explicit comparisons, but they may
13477 well not be faster than doing the ABS and one comparison.
13478 But ABS (X) <= C is a range comparison, which becomes a subtraction
13479 and a comparison, and is probably faster. */
13480 if (code
== LE_EXPR
13481 && TREE_CODE (arg1
) == INTEGER_CST
13482 && TREE_CODE (arg0
) == ABS_EXPR
13483 && ! TREE_SIDE_EFFECTS (arg0
)
13484 && (0 != (tem
= negate_expr (arg1
)))
13485 && TREE_CODE (tem
) == INTEGER_CST
13486 && !TREE_OVERFLOW (tem
))
13487 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
13488 build2 (GE_EXPR
, type
,
13489 TREE_OPERAND (arg0
, 0), tem
),
13490 build2 (LE_EXPR
, type
,
13491 TREE_OPERAND (arg0
, 0), arg1
));
13493 /* Convert ABS_EXPR<x> >= 0 to true. */
13494 strict_overflow_p
= false;
13495 if (code
== GE_EXPR
13496 && (integer_zerop (arg1
)
13497 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0
)))
13498 && real_zerop (arg1
)))
13499 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13501 if (strict_overflow_p
)
13502 fold_overflow_warning (("assuming signed overflow does not occur "
13503 "when simplifying comparison of "
13504 "absolute value and zero"),
13505 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13506 return omit_one_operand_loc (loc
, type
, integer_one_node
, arg0
);
13509 /* Convert ABS_EXPR<x> < 0 to false. */
13510 strict_overflow_p
= false;
13511 if (code
== LT_EXPR
13512 && (integer_zerop (arg1
) || real_zerop (arg1
))
13513 && tree_expr_nonnegative_warnv_p (arg0
, &strict_overflow_p
))
13515 if (strict_overflow_p
)
13516 fold_overflow_warning (("assuming signed overflow does not occur "
13517 "when simplifying comparison of "
13518 "absolute value and zero"),
13519 WARN_STRICT_OVERFLOW_CONDITIONAL
);
13520 return omit_one_operand_loc (loc
, type
, integer_zero_node
, arg0
);
13523 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13524 and similarly for >= into !=. */
13525 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13526 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13527 && TREE_CODE (arg1
) == LSHIFT_EXPR
13528 && integer_onep (TREE_OPERAND (arg1
, 0)))
13529 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13530 build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13531 TREE_OPERAND (arg1
, 1)),
13532 build_zero_cst (TREE_TYPE (arg0
)));
13534 if ((code
== LT_EXPR
|| code
== GE_EXPR
)
13535 && TYPE_UNSIGNED (TREE_TYPE (arg0
))
13536 && CONVERT_EXPR_P (arg1
)
13537 && TREE_CODE (TREE_OPERAND (arg1
, 0)) == LSHIFT_EXPR
13538 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1
, 0), 0)))
13540 tem
= build2 (RSHIFT_EXPR
, TREE_TYPE (arg0
), arg0
,
13541 TREE_OPERAND (TREE_OPERAND (arg1
, 0), 1));
13542 return build2_loc (loc
, code
== LT_EXPR
? EQ_EXPR
: NE_EXPR
, type
,
13543 fold_convert_loc (loc
, TREE_TYPE (arg0
), tem
),
13544 build_zero_cst (TREE_TYPE (arg0
)));
13549 case UNORDERED_EXPR
:
13557 if (TREE_CODE (arg0
) == REAL_CST
&& TREE_CODE (arg1
) == REAL_CST
)
13559 t1
= fold_relational_const (code
, type
, arg0
, arg1
);
13560 if (t1
!= NULL_TREE
)
13564 /* If the first operand is NaN, the result is constant. */
13565 if (TREE_CODE (arg0
) == REAL_CST
13566 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0
))
13567 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13569 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13570 ? integer_zero_node
13571 : integer_one_node
;
13572 return omit_one_operand_loc (loc
, type
, t1
, arg1
);
13575 /* If the second operand is NaN, the result is constant. */
13576 if (TREE_CODE (arg1
) == REAL_CST
13577 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1
))
13578 && (code
!= LTGT_EXPR
|| ! flag_trapping_math
))
13580 t1
= (code
== ORDERED_EXPR
|| code
== LTGT_EXPR
)
13581 ? integer_zero_node
13582 : integer_one_node
;
13583 return omit_one_operand_loc (loc
, type
, t1
, arg0
);
13586 /* Simplify unordered comparison of something with itself. */
13587 if ((code
== UNLE_EXPR
|| code
== UNGE_EXPR
|| code
== UNEQ_EXPR
)
13588 && operand_equal_p (arg0
, arg1
, 0))
13589 return constant_boolean_node (1, type
);
13591 if (code
== LTGT_EXPR
13592 && !flag_trapping_math
13593 && operand_equal_p (arg0
, arg1
, 0))
13594 return constant_boolean_node (0, type
);
13596 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13598 tree targ0
= strip_float_extensions (arg0
);
13599 tree targ1
= strip_float_extensions (arg1
);
13600 tree newtype
= TREE_TYPE (targ0
);
13602 if (TYPE_PRECISION (TREE_TYPE (targ1
)) > TYPE_PRECISION (newtype
))
13603 newtype
= TREE_TYPE (targ1
);
13605 if (TYPE_PRECISION (newtype
) < TYPE_PRECISION (TREE_TYPE (arg0
)))
13606 return fold_build2_loc (loc
, code
, type
,
13607 fold_convert_loc (loc
, newtype
, targ0
),
13608 fold_convert_loc (loc
, newtype
, targ1
));
13613 case COMPOUND_EXPR
:
13614 /* When pedantic, a compound expression can be neither an lvalue
13615 nor an integer constant expression. */
13616 if (TREE_SIDE_EFFECTS (arg0
) || TREE_CONSTANT (arg1
))
13618 /* Don't let (0, 0) be null pointer constant. */
13619 tem
= integer_zerop (arg1
) ? build1 (NOP_EXPR
, type
, arg1
)
13620 : fold_convert_loc (loc
, type
, arg1
);
13621 return pedantic_non_lvalue_loc (loc
, tem
);
13624 if ((TREE_CODE (arg0
) == REAL_CST
13625 && TREE_CODE (arg1
) == REAL_CST
)
13626 || (TREE_CODE (arg0
) == INTEGER_CST
13627 && TREE_CODE (arg1
) == INTEGER_CST
))
13628 return build_complex (type
, arg0
, arg1
);
13629 if (TREE_CODE (arg0
) == REALPART_EXPR
13630 && TREE_CODE (arg1
) == IMAGPART_EXPR
13631 && TREE_TYPE (TREE_OPERAND (arg0
, 0)) == type
13632 && operand_equal_p (TREE_OPERAND (arg0
, 0),
13633 TREE_OPERAND (arg1
, 0), 0))
13634 return omit_one_operand_loc (loc
, type
, TREE_OPERAND (arg0
, 0),
13635 TREE_OPERAND (arg1
, 0));
13639 /* An ASSERT_EXPR should never be passed to fold_binary. */
13640 gcc_unreachable ();
13642 case VEC_PACK_TRUNC_EXPR
:
13643 case VEC_PACK_FIX_TRUNC_EXPR
:
13645 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
;
13648 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
/ 2
13649 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
/ 2);
13650 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13653 elts
= XALLOCAVEC (tree
, nelts
);
13654 if (!vec_cst_ctor_to_array (arg0
, elts
)
13655 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
/ 2))
13658 for (i
= 0; i
< nelts
; i
++)
13660 elts
[i
] = fold_convert_const (code
== VEC_PACK_TRUNC_EXPR
13661 ? NOP_EXPR
: FIX_TRUNC_EXPR
,
13662 TREE_TYPE (type
), elts
[i
]);
13663 if (elts
[i
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[i
]))
13667 return build_vector (type
, elts
);
13670 case VEC_WIDEN_MULT_LO_EXPR
:
13671 case VEC_WIDEN_MULT_HI_EXPR
:
13672 case VEC_WIDEN_MULT_EVEN_EXPR
:
13673 case VEC_WIDEN_MULT_ODD_EXPR
:
13675 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
);
13676 unsigned int out
, ofs
, scale
;
13679 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)) == nelts
* 2
13680 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1
)) == nelts
* 2);
13681 if (TREE_CODE (arg0
) != VECTOR_CST
|| TREE_CODE (arg1
) != VECTOR_CST
)
13684 elts
= XALLOCAVEC (tree
, nelts
* 4);
13685 if (!vec_cst_ctor_to_array (arg0
, elts
)
13686 || !vec_cst_ctor_to_array (arg1
, elts
+ nelts
* 2))
13689 if (code
== VEC_WIDEN_MULT_LO_EXPR
)
13690 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? nelts
: 0;
13691 else if (code
== VEC_WIDEN_MULT_HI_EXPR
)
13692 scale
= 0, ofs
= BYTES_BIG_ENDIAN
? 0 : nelts
;
13693 else if (code
== VEC_WIDEN_MULT_EVEN_EXPR
)
13694 scale
= 1, ofs
= 0;
13695 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
13696 scale
= 1, ofs
= 1;
13698 for (out
= 0; out
< nelts
; out
++)
13700 unsigned int in1
= (out
<< scale
) + ofs
;
13701 unsigned int in2
= in1
+ nelts
* 2;
13704 t1
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in1
]);
13705 t2
= fold_convert_const (NOP_EXPR
, TREE_TYPE (type
), elts
[in2
]);
13707 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
13709 elts
[out
] = const_binop (MULT_EXPR
, t1
, t2
);
13710 if (elts
[out
] == NULL_TREE
|| !CONSTANT_CLASS_P (elts
[out
]))
13714 return build_vector (type
, elts
);
13719 } /* switch (code) */
13722 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
13723 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
13727 contains_label_1 (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
13729 switch (TREE_CODE (*tp
))
13735 *walk_subtrees
= 0;
13737 /* ... fall through ... */
13744 /* Return whether the sub-tree ST contains a label which is accessible from
13745 outside the sub-tree. */
13748 contains_label_p (tree st
)
13751 (walk_tree_without_duplicates (&st
, contains_label_1
, NULL
) != NULL_TREE
);
13754 /* Fold a ternary expression of code CODE and type TYPE with operands
13755 OP0, OP1, and OP2. Return the folded expression if folding is
13756 successful. Otherwise, return NULL_TREE. */
13759 fold_ternary_loc (location_t loc
, enum tree_code code
, tree type
,
13760 tree op0
, tree op1
, tree op2
)
13763 tree arg0
= NULL_TREE
, arg1
= NULL_TREE
, arg2
= NULL_TREE
;
13764 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
13766 gcc_assert (IS_EXPR_CODE_CLASS (kind
)
13767 && TREE_CODE_LENGTH (code
) == 3);
13769 /* Strip any conversions that don't change the mode. This is safe
13770 for every expression, except for a comparison expression because
13771 its signedness is derived from its operands. So, in the latter
13772 case, only strip conversions that don't change the signedness.
13774 Note that this is done as an internal manipulation within the
13775 constant folder, in order to find the simplest representation of
13776 the arguments so that their form can be studied. In any cases,
13777 the appropriate type conversions should be put back in the tree
13778 that will get out of the constant folder. */
13799 case COMPONENT_REF
:
13800 if (TREE_CODE (arg0
) == CONSTRUCTOR
13801 && ! type_contains_placeholder_p (TREE_TYPE (arg0
)))
13803 unsigned HOST_WIDE_INT idx
;
13805 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0
), idx
, field
, value
)
13812 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13813 so all simple results must be passed through pedantic_non_lvalue. */
13814 if (TREE_CODE (arg0
) == INTEGER_CST
)
13816 tree unused_op
= integer_zerop (arg0
) ? op1
: op2
;
13817 tem
= integer_zerop (arg0
) ? op2
: op1
;
13818 /* Only optimize constant conditions when the selected branch
13819 has the same type as the COND_EXPR. This avoids optimizing
13820 away "c ? x : throw", where the throw has a void type.
13821 Avoid throwing away that operand which contains label. */
13822 if ((!TREE_SIDE_EFFECTS (unused_op
)
13823 || !contains_label_p (unused_op
))
13824 && (! VOID_TYPE_P (TREE_TYPE (tem
))
13825 || VOID_TYPE_P (type
)))
13826 return pedantic_non_lvalue_loc (loc
, tem
);
13829 if (operand_equal_p (arg1
, op2
, 0))
13830 return pedantic_omit_one_operand_loc (loc
, type
, arg1
, arg0
);
13832 /* If we have A op B ? A : C, we may be able to convert this to a
13833 simpler expression, depending on the operation and the values
13834 of B and C. Signed zeros prevent all of these transformations,
13835 for reasons given above each one.
13837 Also try swapping the arguments and inverting the conditional. */
13838 if (COMPARISON_CLASS_P (arg0
)
13839 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
13840 arg1
, TREE_OPERAND (arg0
, 1))
13841 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1
))))
13843 tem
= fold_cond_expr_with_comparison (loc
, type
, arg0
, op1
, op2
);
13848 if (COMPARISON_CLASS_P (arg0
)
13849 && operand_equal_for_comparison_p (TREE_OPERAND (arg0
, 0),
13851 TREE_OPERAND (arg0
, 1))
13852 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2
))))
13854 location_t loc0
= expr_location_or (arg0
, loc
);
13855 tem
= fold_truth_not_expr (loc0
, arg0
);
13856 if (tem
&& COMPARISON_CLASS_P (tem
))
13858 tem
= fold_cond_expr_with_comparison (loc
, type
, tem
, op2
, op1
);
13864 /* If the second operand is simpler than the third, swap them
13865 since that produces better jump optimization results. */
13866 if (truth_value_p (TREE_CODE (arg0
))
13867 && tree_swap_operands_p (op1
, op2
, false))
13869 location_t loc0
= expr_location_or (arg0
, loc
);
13870 /* See if this can be inverted. If it can't, possibly because
13871 it was a floating-point inequality comparison, don't do
13873 tem
= fold_truth_not_expr (loc0
, arg0
);
13875 return fold_build3_loc (loc
, code
, type
, tem
, op2
, op1
);
13878 /* Convert A ? 1 : 0 to simply A. */
13879 if (integer_onep (op1
)
13880 && integer_zerop (op2
)
13881 /* If we try to convert OP0 to our type, the
13882 call to fold will try to move the conversion inside
13883 a COND, which will recurse. In that case, the COND_EXPR
13884 is probably the best choice, so leave it alone. */
13885 && type
== TREE_TYPE (arg0
))
13886 return pedantic_non_lvalue_loc (loc
, arg0
);
13888 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
13889 over COND_EXPR in cases such as floating point comparisons. */
13890 if (integer_zerop (op1
)
13891 && integer_onep (op2
)
13892 && truth_value_p (TREE_CODE (arg0
)))
13893 return pedantic_non_lvalue_loc (loc
,
13894 fold_convert_loc (loc
, type
,
13895 invert_truthvalue_loc (loc
,
13898 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
13899 if (TREE_CODE (arg0
) == LT_EXPR
13900 && integer_zerop (TREE_OPERAND (arg0
, 1))
13901 && integer_zerop (op2
)
13902 && (tem
= sign_bit_p (TREE_OPERAND (arg0
, 0), arg1
)))
13904 /* sign_bit_p only checks ARG1 bits within A's precision.
13905 If <sign bit of A> has wider type than A, bits outside
13906 of A's precision in <sign bit of A> need to be checked.
13907 If they are all 0, this optimization needs to be done
13908 in unsigned A's type, if they are all 1 in signed A's type,
13909 otherwise this can't be done. */
13910 if (TYPE_PRECISION (TREE_TYPE (tem
))
13911 < TYPE_PRECISION (TREE_TYPE (arg1
))
13912 && TYPE_PRECISION (TREE_TYPE (tem
))
13913 < TYPE_PRECISION (type
))
13915 unsigned HOST_WIDE_INT mask_lo
;
13916 HOST_WIDE_INT mask_hi
;
13917 int inner_width
, outer_width
;
13920 inner_width
= TYPE_PRECISION (TREE_TYPE (tem
));
13921 outer_width
= TYPE_PRECISION (TREE_TYPE (arg1
));
13922 if (outer_width
> TYPE_PRECISION (type
))
13923 outer_width
= TYPE_PRECISION (type
);
13925 if (outer_width
> HOST_BITS_PER_WIDE_INT
)
13927 mask_hi
= ((unsigned HOST_WIDE_INT
) -1
13928 >> (HOST_BITS_PER_DOUBLE_INT
- outer_width
));
13934 mask_lo
= ((unsigned HOST_WIDE_INT
) -1
13935 >> (HOST_BITS_PER_WIDE_INT
- outer_width
));
13937 if (inner_width
> HOST_BITS_PER_WIDE_INT
)
13939 mask_hi
&= ~((unsigned HOST_WIDE_INT
) -1
13940 >> (HOST_BITS_PER_WIDE_INT
- inner_width
));
13944 mask_lo
&= ~((unsigned HOST_WIDE_INT
) -1
13945 >> (HOST_BITS_PER_WIDE_INT
- inner_width
));
13947 if ((TREE_INT_CST_HIGH (arg1
) & mask_hi
) == mask_hi
13948 && (TREE_INT_CST_LOW (arg1
) & mask_lo
) == mask_lo
)
13950 tem_type
= signed_type_for (TREE_TYPE (tem
));
13951 tem
= fold_convert_loc (loc
, tem_type
, tem
);
13953 else if ((TREE_INT_CST_HIGH (arg1
) & mask_hi
) == 0
13954 && (TREE_INT_CST_LOW (arg1
) & mask_lo
) == 0)
13956 tem_type
= unsigned_type_for (TREE_TYPE (tem
));
13957 tem
= fold_convert_loc (loc
, tem_type
, tem
);
13965 fold_convert_loc (loc
, type
,
13966 fold_build2_loc (loc
, BIT_AND_EXPR
,
13967 TREE_TYPE (tem
), tem
,
13968 fold_convert_loc (loc
,
13973 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
13974 already handled above. */
13975 if (TREE_CODE (arg0
) == BIT_AND_EXPR
13976 && integer_onep (TREE_OPERAND (arg0
, 1))
13977 && integer_zerop (op2
)
13978 && integer_pow2p (arg1
))
13980 tree tem
= TREE_OPERAND (arg0
, 0);
13982 if (TREE_CODE (tem
) == RSHIFT_EXPR
13983 && TREE_CODE (TREE_OPERAND (tem
, 1)) == INTEGER_CST
13984 && (unsigned HOST_WIDE_INT
) tree_log2 (arg1
) ==
13985 TREE_INT_CST_LOW (TREE_OPERAND (tem
, 1)))
13986 return fold_build2_loc (loc
, BIT_AND_EXPR
, type
,
13987 TREE_OPERAND (tem
, 0), arg1
);
13990 /* A & N ? N : 0 is simply A & N if N is a power of two. This
13991 is probably obsolete because the first operand should be a
13992 truth value (that's why we have the two cases above), but let's
13993 leave it in until we can confirm this for all front-ends. */
13994 if (integer_zerop (op2
)
13995 && TREE_CODE (arg0
) == NE_EXPR
13996 && integer_zerop (TREE_OPERAND (arg0
, 1))
13997 && integer_pow2p (arg1
)
13998 && TREE_CODE (TREE_OPERAND (arg0
, 0)) == BIT_AND_EXPR
13999 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0
, 0), 1),
14000 arg1
, OEP_ONLY_CONST
))
14001 return pedantic_non_lvalue_loc (loc
,
14002 fold_convert_loc (loc
, type
,
14003 TREE_OPERAND (arg0
, 0)));
14005 /* Convert A ? B : 0 into A && B if A and B are truth values. */
14006 if (integer_zerop (op2
)
14007 && truth_value_p (TREE_CODE (arg0
))
14008 && truth_value_p (TREE_CODE (arg1
)))
14009 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
14010 fold_convert_loc (loc
, type
, arg0
),
14013 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
14014 if (integer_onep (op2
)
14015 && truth_value_p (TREE_CODE (arg0
))
14016 && truth_value_p (TREE_CODE (arg1
)))
14018 location_t loc0
= expr_location_or (arg0
, loc
);
14019 /* Only perform transformation if ARG0 is easily inverted. */
14020 tem
= fold_truth_not_expr (loc0
, arg0
);
14022 return fold_build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
14023 fold_convert_loc (loc
, type
, tem
),
14027 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
14028 if (integer_zerop (arg1
)
14029 && truth_value_p (TREE_CODE (arg0
))
14030 && truth_value_p (TREE_CODE (op2
)))
14032 location_t loc0
= expr_location_or (arg0
, loc
);
14033 /* Only perform transformation if ARG0 is easily inverted. */
14034 tem
= fold_truth_not_expr (loc0
, arg0
);
14036 return fold_build2_loc (loc
, TRUTH_ANDIF_EXPR
, type
,
14037 fold_convert_loc (loc
, type
, tem
),
14041 /* Convert A ? 1 : B into A || B if A and B are truth values. */
14042 if (integer_onep (arg1
)
14043 && truth_value_p (TREE_CODE (arg0
))
14044 && truth_value_p (TREE_CODE (op2
)))
14045 return fold_build2_loc (loc
, TRUTH_ORIF_EXPR
, type
,
14046 fold_convert_loc (loc
, type
, arg0
),
14051 case VEC_COND_EXPR
:
14052 if (TREE_CODE (arg0
) == VECTOR_CST
)
14054 if (integer_all_onesp (arg0
) && !TREE_SIDE_EFFECTS (op2
))
14055 return pedantic_non_lvalue_loc (loc
, op1
);
14056 if (integer_zerop (arg0
) && !TREE_SIDE_EFFECTS (op1
))
14057 return pedantic_non_lvalue_loc (loc
, op2
);
14062 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
14063 of fold_ternary on them. */
14064 gcc_unreachable ();
14066 case BIT_FIELD_REF
:
14067 if ((TREE_CODE (arg0
) == VECTOR_CST
14068 || (TREE_CODE (arg0
) == CONSTRUCTOR
14069 && TREE_CODE (TREE_TYPE (arg0
)) == VECTOR_TYPE
))
14070 && (type
== TREE_TYPE (TREE_TYPE (arg0
))
14071 || (TREE_CODE (type
) == VECTOR_TYPE
14072 && TREE_TYPE (type
) == TREE_TYPE (TREE_TYPE (arg0
)))))
14074 tree eltype
= TREE_TYPE (TREE_TYPE (arg0
));
14075 unsigned HOST_WIDE_INT width
= tree_low_cst (TYPE_SIZE (eltype
), 1);
14076 unsigned HOST_WIDE_INT n
= tree_low_cst (arg1
, 1);
14077 unsigned HOST_WIDE_INT idx
= tree_low_cst (op2
, 1);
14080 && (idx
% width
) == 0
14081 && (n
% width
) == 0
14082 && ((idx
+ n
) / width
) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0
)))
14086 if (TREE_CODE (type
) == VECTOR_TYPE
)
14088 if (TREE_CODE (arg0
) == VECTOR_CST
)
14090 tree
*vals
= XALLOCAVEC (tree
, n
);
14092 for (i
= 0; i
< n
; ++i
)
14093 vals
[i
] = VECTOR_CST_ELT (arg0
, idx
+ i
);
14094 return build_vector (type
, vals
);
14098 vec
<constructor_elt
, va_gc
> *vals
;
14100 if (CONSTRUCTOR_NELTS (arg0
) == 0)
14101 return build_constructor (type
,
14103 if (TREE_CODE (TREE_TYPE (CONSTRUCTOR_ELT (arg0
,
14107 vec_alloc (vals
, n
);
14109 i
< n
&& idx
+ i
< CONSTRUCTOR_NELTS (arg0
);
14111 CONSTRUCTOR_APPEND_ELT (vals
, NULL_TREE
,
14113 (arg0
, idx
+ i
)->value
);
14114 return build_constructor (type
, vals
);
14120 if (TREE_CODE (arg0
) == VECTOR_CST
)
14121 return VECTOR_CST_ELT (arg0
, idx
);
14122 else if (CONSTRUCTOR_NELTS (arg0
) == 0)
14123 return build_zero_cst (type
);
14124 else if (TREE_CODE (TREE_TYPE (CONSTRUCTOR_ELT (arg0
,
14128 if (idx
< CONSTRUCTOR_NELTS (arg0
))
14129 return CONSTRUCTOR_ELT (arg0
, idx
)->value
;
14130 return build_zero_cst (type
);
14136 /* A bit-field-ref that referenced the full argument can be stripped. */
14137 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0
))
14138 && TYPE_PRECISION (TREE_TYPE (arg0
)) == tree_low_cst (arg1
, 1)
14139 && integer_zerop (op2
))
14140 return fold_convert_loc (loc
, type
, arg0
);
14142 /* On constants we can use native encode/interpret to constant
14143 fold (nearly) all BIT_FIELD_REFs. */
14144 if (CONSTANT_CLASS_P (arg0
)
14145 && can_native_interpret_type_p (type
)
14146 && host_integerp (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)), 1)
14147 /* This limitation should not be necessary, we just need to
14148 round this up to mode size. */
14149 && tree_low_cst (op1
, 1) % BITS_PER_UNIT
== 0
14150 /* Need bit-shifting of the buffer to relax the following. */
14151 && tree_low_cst (op2
, 1) % BITS_PER_UNIT
== 0)
14153 unsigned HOST_WIDE_INT bitpos
= tree_low_cst (op2
, 1);
14154 unsigned HOST_WIDE_INT bitsize
= tree_low_cst (op1
, 1);
14155 unsigned HOST_WIDE_INT clen
;
14156 clen
= tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (arg0
)), 1);
14157 /* ??? We cannot tell native_encode_expr to start at
14158 some random byte only. So limit us to a reasonable amount
14162 unsigned char *b
= XALLOCAVEC (unsigned char, clen
);
14163 unsigned HOST_WIDE_INT len
= native_encode_expr (arg0
, b
, clen
);
14165 && len
* BITS_PER_UNIT
>= bitpos
+ bitsize
)
14167 tree v
= native_interpret_expr (type
,
14168 b
+ bitpos
/ BITS_PER_UNIT
,
14169 bitsize
/ BITS_PER_UNIT
);
14179 /* For integers we can decompose the FMA if possible. */
14180 if (TREE_CODE (arg0
) == INTEGER_CST
14181 && TREE_CODE (arg1
) == INTEGER_CST
)
14182 return fold_build2_loc (loc
, PLUS_EXPR
, type
,
14183 const_binop (MULT_EXPR
, arg0
, arg1
), arg2
);
14184 if (integer_zerop (arg2
))
14185 return fold_build2_loc (loc
, MULT_EXPR
, type
, arg0
, arg1
);
14187 return fold_fma (loc
, type
, arg0
, arg1
, arg2
);
14189 case VEC_PERM_EXPR
:
14190 if (TREE_CODE (arg2
) == VECTOR_CST
)
14192 unsigned int nelts
= TYPE_VECTOR_SUBPARTS (type
), i
, mask
;
14193 unsigned char *sel
= XALLOCAVEC (unsigned char, nelts
);
14195 bool need_mask_canon
= false;
14196 bool all_in_vec0
= true;
14197 bool all_in_vec1
= true;
14198 bool maybe_identity
= true;
14199 bool single_arg
= (op0
== op1
);
14200 bool changed
= false;
14202 mask
= single_arg
? (nelts
- 1) : (2 * nelts
- 1);
14203 gcc_assert (nelts
== VECTOR_CST_NELTS (arg2
));
14204 for (i
= 0; i
< nelts
; i
++)
14206 tree val
= VECTOR_CST_ELT (arg2
, i
);
14207 if (TREE_CODE (val
) != INTEGER_CST
)
14210 sel
[i
] = TREE_INT_CST_LOW (val
) & mask
;
14211 if (TREE_INT_CST_HIGH (val
)
14212 || ((unsigned HOST_WIDE_INT
)
14213 TREE_INT_CST_LOW (val
) != sel
[i
]))
14214 need_mask_canon
= true;
14216 if (sel
[i
] < nelts
)
14217 all_in_vec1
= false;
14219 all_in_vec0
= false;
14221 if ((sel
[i
] & (nelts
-1)) != i
)
14222 maybe_identity
= false;
14225 if (maybe_identity
)
14235 else if (all_in_vec1
)
14238 for (i
= 0; i
< nelts
; i
++)
14240 need_mask_canon
= true;
14243 if ((TREE_CODE (op0
) == VECTOR_CST
14244 || TREE_CODE (op0
) == CONSTRUCTOR
)
14245 && (TREE_CODE (op1
) == VECTOR_CST
14246 || TREE_CODE (op1
) == CONSTRUCTOR
))
14248 t
= fold_vec_perm (type
, op0
, op1
, sel
);
14249 if (t
!= NULL_TREE
)
14253 if (op0
== op1
&& !single_arg
)
14256 if (need_mask_canon
&& arg2
== op2
)
14258 tree
*tsel
= XALLOCAVEC (tree
, nelts
);
14259 tree eltype
= TREE_TYPE (TREE_TYPE (arg2
));
14260 for (i
= 0; i
< nelts
; i
++)
14261 tsel
[i
] = build_int_cst (eltype
, sel
[i
]);
14262 op2
= build_vector (TREE_TYPE (arg2
), tsel
);
14267 return build3_loc (loc
, VEC_PERM_EXPR
, type
, op0
, op1
, op2
);
14273 } /* switch (code) */
14276 /* Perform constant folding and related simplification of EXPR.
14277 The related simplifications include x*1 => x, x*0 => 0, etc.,
14278 and application of the associative law.
14279 NOP_EXPR conversions may be removed freely (as long as we
14280 are careful not to change the type of the overall expression).
14281 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14282 but we can constant-fold them if they have constant operands. */
14284 #ifdef ENABLE_FOLD_CHECKING
14285 # define fold(x) fold_1 (x)
14286 static tree
fold_1 (tree
);
14292 const tree t
= expr
;
14293 enum tree_code code
= TREE_CODE (t
);
14294 enum tree_code_class kind
= TREE_CODE_CLASS (code
);
14296 location_t loc
= EXPR_LOCATION (expr
);
14298 /* Return right away if a constant. */
14299 if (kind
== tcc_constant
)
14302 /* CALL_EXPR-like objects with variable numbers of operands are
14303 treated specially. */
14304 if (kind
== tcc_vl_exp
)
14306 if (code
== CALL_EXPR
)
14308 tem
= fold_call_expr (loc
, expr
, false);
14309 return tem
? tem
: expr
;
14314 if (IS_EXPR_CODE_CLASS (kind
))
14316 tree type
= TREE_TYPE (t
);
14317 tree op0
, op1
, op2
;
14319 switch (TREE_CODE_LENGTH (code
))
14322 op0
= TREE_OPERAND (t
, 0);
14323 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14324 return tem
? tem
: expr
;
14326 op0
= TREE_OPERAND (t
, 0);
14327 op1
= TREE_OPERAND (t
, 1);
14328 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14329 return tem
? tem
: expr
;
14331 op0
= TREE_OPERAND (t
, 0);
14332 op1
= TREE_OPERAND (t
, 1);
14333 op2
= TREE_OPERAND (t
, 2);
14334 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14335 return tem
? tem
: expr
;
14345 tree op0
= TREE_OPERAND (t
, 0);
14346 tree op1
= TREE_OPERAND (t
, 1);
14348 if (TREE_CODE (op1
) == INTEGER_CST
14349 && TREE_CODE (op0
) == CONSTRUCTOR
14350 && ! type_contains_placeholder_p (TREE_TYPE (op0
)))
14352 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (op0
);
14353 unsigned HOST_WIDE_INT end
= vec_safe_length (elts
);
14354 unsigned HOST_WIDE_INT begin
= 0;
14356 /* Find a matching index by means of a binary search. */
14357 while (begin
!= end
)
14359 unsigned HOST_WIDE_INT middle
= (begin
+ end
) / 2;
14360 tree index
= (*elts
)[middle
].index
;
14362 if (TREE_CODE (index
) == INTEGER_CST
14363 && tree_int_cst_lt (index
, op1
))
14364 begin
= middle
+ 1;
14365 else if (TREE_CODE (index
) == INTEGER_CST
14366 && tree_int_cst_lt (op1
, index
))
14368 else if (TREE_CODE (index
) == RANGE_EXPR
14369 && tree_int_cst_lt (TREE_OPERAND (index
, 1), op1
))
14370 begin
= middle
+ 1;
14371 else if (TREE_CODE (index
) == RANGE_EXPR
14372 && tree_int_cst_lt (op1
, TREE_OPERAND (index
, 0)))
14375 return (*elts
)[middle
].value
;
14383 return fold (DECL_INITIAL (t
));
14387 } /* switch (code) */
14390 #ifdef ENABLE_FOLD_CHECKING
14393 static void fold_checksum_tree (const_tree
, struct md5_ctx
*,
14394 hash_table
<pointer_hash
<tree_node
> >);
14395 static void fold_check_failed (const_tree
, const_tree
);
14396 void print_fold_checksum (const_tree
);
14398 /* When --enable-checking=fold, compute a digest of expr before
14399 and after actual fold call to see if fold did not accidentally
14400 change original expr. */
14406 struct md5_ctx ctx
;
14407 unsigned char checksum_before
[16], checksum_after
[16];
14408 hash_table
<pointer_hash
<tree_node
> > ht
;
14411 md5_init_ctx (&ctx
);
14412 fold_checksum_tree (expr
, &ctx
, ht
);
14413 md5_finish_ctx (&ctx
, checksum_before
);
14416 ret
= fold_1 (expr
);
14418 md5_init_ctx (&ctx
);
14419 fold_checksum_tree (expr
, &ctx
, ht
);
14420 md5_finish_ctx (&ctx
, checksum_after
);
14423 if (memcmp (checksum_before
, checksum_after
, 16))
14424 fold_check_failed (expr
, ret
);
14430 print_fold_checksum (const_tree expr
)
14432 struct md5_ctx ctx
;
14433 unsigned char checksum
[16], cnt
;
14434 hash_table
<pointer_hash
<tree_node
> > ht
;
14437 md5_init_ctx (&ctx
);
14438 fold_checksum_tree (expr
, &ctx
, ht
);
14439 md5_finish_ctx (&ctx
, checksum
);
14441 for (cnt
= 0; cnt
< 16; ++cnt
)
14442 fprintf (stderr
, "%02x", checksum
[cnt
]);
14443 putc ('\n', stderr
);
14447 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED
, const_tree ret ATTRIBUTE_UNUSED
)
14449 internal_error ("fold check: original tree changed by fold");
14453 fold_checksum_tree (const_tree expr
, struct md5_ctx
*ctx
,
14454 hash_table
<pointer_hash
<tree_node
> > ht
)
14457 enum tree_code code
;
14458 union tree_node buf
;
14464 slot
= ht
.find_slot (expr
, INSERT
);
14467 *slot
= CONST_CAST_TREE (expr
);
14468 code
= TREE_CODE (expr
);
14469 if (TREE_CODE_CLASS (code
) == tcc_declaration
14470 && DECL_ASSEMBLER_NAME_SET_P (expr
))
14472 /* Allow DECL_ASSEMBLER_NAME to be modified. */
14473 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14474 SET_DECL_ASSEMBLER_NAME ((tree
)&buf
, NULL
);
14475 expr
= (tree
) &buf
;
14477 else if (TREE_CODE_CLASS (code
) == tcc_type
14478 && (TYPE_POINTER_TO (expr
)
14479 || TYPE_REFERENCE_TO (expr
)
14480 || TYPE_CACHED_VALUES_P (expr
)
14481 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr
)
14482 || TYPE_NEXT_VARIANT (expr
)))
14484 /* Allow these fields to be modified. */
14486 memcpy ((char *) &buf
, expr
, tree_size (expr
));
14487 expr
= tmp
= (tree
) &buf
;
14488 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp
) = 0;
14489 TYPE_POINTER_TO (tmp
) = NULL
;
14490 TYPE_REFERENCE_TO (tmp
) = NULL
;
14491 TYPE_NEXT_VARIANT (tmp
) = NULL
;
14492 if (TYPE_CACHED_VALUES_P (tmp
))
14494 TYPE_CACHED_VALUES_P (tmp
) = 0;
14495 TYPE_CACHED_VALUES (tmp
) = NULL
;
14498 md5_process_bytes (expr
, tree_size (expr
), ctx
);
14499 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
14500 fold_checksum_tree (TREE_TYPE (expr
), ctx
, ht
);
14501 if (TREE_CODE_CLASS (code
) != tcc_type
14502 && TREE_CODE_CLASS (code
) != tcc_declaration
14503 && code
!= TREE_LIST
14504 && code
!= SSA_NAME
14505 && CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
14506 fold_checksum_tree (TREE_CHAIN (expr
), ctx
, ht
);
14507 switch (TREE_CODE_CLASS (code
))
14513 md5_process_bytes (TREE_STRING_POINTER (expr
),
14514 TREE_STRING_LENGTH (expr
), ctx
);
14517 fold_checksum_tree (TREE_REALPART (expr
), ctx
, ht
);
14518 fold_checksum_tree (TREE_IMAGPART (expr
), ctx
, ht
);
14521 for (i
= 0; i
< (int) VECTOR_CST_NELTS (expr
); ++i
)
14522 fold_checksum_tree (VECTOR_CST_ELT (expr
, i
), ctx
, ht
);
14528 case tcc_exceptional
:
14532 fold_checksum_tree (TREE_PURPOSE (expr
), ctx
, ht
);
14533 fold_checksum_tree (TREE_VALUE (expr
), ctx
, ht
);
14534 expr
= TREE_CHAIN (expr
);
14535 goto recursive_label
;
14538 for (i
= 0; i
< TREE_VEC_LENGTH (expr
); ++i
)
14539 fold_checksum_tree (TREE_VEC_ELT (expr
, i
), ctx
, ht
);
14545 case tcc_expression
:
14546 case tcc_reference
:
14547 case tcc_comparison
:
14550 case tcc_statement
:
14552 len
= TREE_OPERAND_LENGTH (expr
);
14553 for (i
= 0; i
< len
; ++i
)
14554 fold_checksum_tree (TREE_OPERAND (expr
, i
), ctx
, ht
);
14556 case tcc_declaration
:
14557 fold_checksum_tree (DECL_NAME (expr
), ctx
, ht
);
14558 fold_checksum_tree (DECL_CONTEXT (expr
), ctx
, ht
);
14559 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_COMMON
))
14561 fold_checksum_tree (DECL_SIZE (expr
), ctx
, ht
);
14562 fold_checksum_tree (DECL_SIZE_UNIT (expr
), ctx
, ht
);
14563 fold_checksum_tree (DECL_INITIAL (expr
), ctx
, ht
);
14564 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr
), ctx
, ht
);
14565 fold_checksum_tree (DECL_ATTRIBUTES (expr
), ctx
, ht
);
14567 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_WITH_VIS
))
14568 fold_checksum_tree (DECL_SECTION_NAME (expr
), ctx
, ht
);
14570 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr
), TS_DECL_NON_COMMON
))
14572 fold_checksum_tree (DECL_VINDEX (expr
), ctx
, ht
);
14573 fold_checksum_tree (DECL_RESULT_FLD (expr
), ctx
, ht
);
14574 fold_checksum_tree (DECL_ARGUMENT_FLD (expr
), ctx
, ht
);
14578 if (TREE_CODE (expr
) == ENUMERAL_TYPE
)
14579 fold_checksum_tree (TYPE_VALUES (expr
), ctx
, ht
);
14580 fold_checksum_tree (TYPE_SIZE (expr
), ctx
, ht
);
14581 fold_checksum_tree (TYPE_SIZE_UNIT (expr
), ctx
, ht
);
14582 fold_checksum_tree (TYPE_ATTRIBUTES (expr
), ctx
, ht
);
14583 fold_checksum_tree (TYPE_NAME (expr
), ctx
, ht
);
14584 if (INTEGRAL_TYPE_P (expr
)
14585 || SCALAR_FLOAT_TYPE_P (expr
))
14587 fold_checksum_tree (TYPE_MIN_VALUE (expr
), ctx
, ht
);
14588 fold_checksum_tree (TYPE_MAX_VALUE (expr
), ctx
, ht
);
14590 fold_checksum_tree (TYPE_MAIN_VARIANT (expr
), ctx
, ht
);
14591 if (TREE_CODE (expr
) == RECORD_TYPE
14592 || TREE_CODE (expr
) == UNION_TYPE
14593 || TREE_CODE (expr
) == QUAL_UNION_TYPE
)
14594 fold_checksum_tree (TYPE_BINFO (expr
), ctx
, ht
);
14595 fold_checksum_tree (TYPE_CONTEXT (expr
), ctx
, ht
);
14602 /* Helper function for outputting the checksum of a tree T. When
14603 debugging with gdb, you can "define mynext" to be "next" followed
14604 by "call debug_fold_checksum (op0)", then just trace down till the
14607 DEBUG_FUNCTION
void
14608 debug_fold_checksum (const_tree t
)
14611 unsigned char checksum
[16];
14612 struct md5_ctx ctx
;
14613 hash_table
<pointer_hash
<tree_node
> > ht
;
14616 md5_init_ctx (&ctx
);
14617 fold_checksum_tree (t
, &ctx
, ht
);
14618 md5_finish_ctx (&ctx
, checksum
);
14621 for (i
= 0; i
< 16; i
++)
14622 fprintf (stderr
, "%d ", checksum
[i
]);
14624 fprintf (stderr
, "\n");
14629 /* Fold a unary tree expression with code CODE of type TYPE with an
14630 operand OP0. LOC is the location of the resulting expression.
14631 Return a folded expression if successful. Otherwise, return a tree
14632 expression with code CODE of type TYPE with an operand OP0. */
14635 fold_build1_stat_loc (location_t loc
,
14636 enum tree_code code
, tree type
, tree op0 MEM_STAT_DECL
)
14639 #ifdef ENABLE_FOLD_CHECKING
14640 unsigned char checksum_before
[16], checksum_after
[16];
14641 struct md5_ctx ctx
;
14642 hash_table
<pointer_hash
<tree_node
> > ht
;
14645 md5_init_ctx (&ctx
);
14646 fold_checksum_tree (op0
, &ctx
, ht
);
14647 md5_finish_ctx (&ctx
, checksum_before
);
14651 tem
= fold_unary_loc (loc
, code
, type
, op0
);
14653 tem
= build1_stat_loc (loc
, code
, type
, op0 PASS_MEM_STAT
);
14655 #ifdef ENABLE_FOLD_CHECKING
14656 md5_init_ctx (&ctx
);
14657 fold_checksum_tree (op0
, &ctx
, ht
);
14658 md5_finish_ctx (&ctx
, checksum_after
);
14661 if (memcmp (checksum_before
, checksum_after
, 16))
14662 fold_check_failed (op0
, tem
);
14667 /* Fold a binary tree expression with code CODE of type TYPE with
14668 operands OP0 and OP1. LOC is the location of the resulting
14669 expression. Return a folded expression if successful. Otherwise,
14670 return a tree expression with code CODE of type TYPE with operands
14674 fold_build2_stat_loc (location_t loc
,
14675 enum tree_code code
, tree type
, tree op0
, tree op1
14679 #ifdef ENABLE_FOLD_CHECKING
14680 unsigned char checksum_before_op0
[16],
14681 checksum_before_op1
[16],
14682 checksum_after_op0
[16],
14683 checksum_after_op1
[16];
14684 struct md5_ctx ctx
;
14685 hash_table
<pointer_hash
<tree_node
> > ht
;
14688 md5_init_ctx (&ctx
);
14689 fold_checksum_tree (op0
, &ctx
, ht
);
14690 md5_finish_ctx (&ctx
, checksum_before_op0
);
14693 md5_init_ctx (&ctx
);
14694 fold_checksum_tree (op1
, &ctx
, ht
);
14695 md5_finish_ctx (&ctx
, checksum_before_op1
);
14699 tem
= fold_binary_loc (loc
, code
, type
, op0
, op1
);
14701 tem
= build2_stat_loc (loc
, code
, type
, op0
, op1 PASS_MEM_STAT
);
14703 #ifdef ENABLE_FOLD_CHECKING
14704 md5_init_ctx (&ctx
);
14705 fold_checksum_tree (op0
, &ctx
, ht
);
14706 md5_finish_ctx (&ctx
, checksum_after_op0
);
14709 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14710 fold_check_failed (op0
, tem
);
14712 md5_init_ctx (&ctx
);
14713 fold_checksum_tree (op1
, &ctx
, ht
);
14714 md5_finish_ctx (&ctx
, checksum_after_op1
);
14717 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
14718 fold_check_failed (op1
, tem
);
14723 /* Fold a ternary tree expression with code CODE of type TYPE with
14724 operands OP0, OP1, and OP2. Return a folded expression if
14725 successful. Otherwise, return a tree expression with code CODE of
14726 type TYPE with operands OP0, OP1, and OP2. */
14729 fold_build3_stat_loc (location_t loc
, enum tree_code code
, tree type
,
14730 tree op0
, tree op1
, tree op2 MEM_STAT_DECL
)
14733 #ifdef ENABLE_FOLD_CHECKING
14734 unsigned char checksum_before_op0
[16],
14735 checksum_before_op1
[16],
14736 checksum_before_op2
[16],
14737 checksum_after_op0
[16],
14738 checksum_after_op1
[16],
14739 checksum_after_op2
[16];
14740 struct md5_ctx ctx
;
14741 hash_table
<pointer_hash
<tree_node
> > ht
;
14744 md5_init_ctx (&ctx
);
14745 fold_checksum_tree (op0
, &ctx
, ht
);
14746 md5_finish_ctx (&ctx
, checksum_before_op0
);
14749 md5_init_ctx (&ctx
);
14750 fold_checksum_tree (op1
, &ctx
, ht
);
14751 md5_finish_ctx (&ctx
, checksum_before_op1
);
14754 md5_init_ctx (&ctx
);
14755 fold_checksum_tree (op2
, &ctx
, ht
);
14756 md5_finish_ctx (&ctx
, checksum_before_op2
);
14760 gcc_assert (TREE_CODE_CLASS (code
) != tcc_vl_exp
);
14761 tem
= fold_ternary_loc (loc
, code
, type
, op0
, op1
, op2
);
14763 tem
= build3_stat_loc (loc
, code
, type
, op0
, op1
, op2 PASS_MEM_STAT
);
14765 #ifdef ENABLE_FOLD_CHECKING
14766 md5_init_ctx (&ctx
);
14767 fold_checksum_tree (op0
, &ctx
, ht
);
14768 md5_finish_ctx (&ctx
, checksum_after_op0
);
14771 if (memcmp (checksum_before_op0
, checksum_after_op0
, 16))
14772 fold_check_failed (op0
, tem
);
14774 md5_init_ctx (&ctx
);
14775 fold_checksum_tree (op1
, &ctx
, ht
);
14776 md5_finish_ctx (&ctx
, checksum_after_op1
);
14779 if (memcmp (checksum_before_op1
, checksum_after_op1
, 16))
14780 fold_check_failed (op1
, tem
);
14782 md5_init_ctx (&ctx
);
14783 fold_checksum_tree (op2
, &ctx
, ht
);
14784 md5_finish_ctx (&ctx
, checksum_after_op2
);
14787 if (memcmp (checksum_before_op2
, checksum_after_op2
, 16))
14788 fold_check_failed (op2
, tem
);
14793 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
14794 arguments in ARGARRAY, and a null static chain.
14795 Return a folded expression if successful. Otherwise, return a CALL_EXPR
14796 of type TYPE from the given operands as constructed by build_call_array. */
14799 fold_build_call_array_loc (location_t loc
, tree type
, tree fn
,
14800 int nargs
, tree
*argarray
)
14803 #ifdef ENABLE_FOLD_CHECKING
14804 unsigned char checksum_before_fn
[16],
14805 checksum_before_arglist
[16],
14806 checksum_after_fn
[16],
14807 checksum_after_arglist
[16];
14808 struct md5_ctx ctx
;
14809 hash_table
<pointer_hash
<tree_node
> > ht
;
14813 md5_init_ctx (&ctx
);
14814 fold_checksum_tree (fn
, &ctx
, ht
);
14815 md5_finish_ctx (&ctx
, checksum_before_fn
);
14818 md5_init_ctx (&ctx
);
14819 for (i
= 0; i
< nargs
; i
++)
14820 fold_checksum_tree (argarray
[i
], &ctx
, ht
);
14821 md5_finish_ctx (&ctx
, checksum_before_arglist
);
14825 tem
= fold_builtin_call_array (loc
, type
, fn
, nargs
, argarray
);
14827 #ifdef ENABLE_FOLD_CHECKING
14828 md5_init_ctx (&ctx
);
14829 fold_checksum_tree (fn
, &ctx
, ht
);
14830 md5_finish_ctx (&ctx
, checksum_after_fn
);
14833 if (memcmp (checksum_before_fn
, checksum_after_fn
, 16))
14834 fold_check_failed (fn
, tem
);
14836 md5_init_ctx (&ctx
);
14837 for (i
= 0; i
< nargs
; i
++)
14838 fold_checksum_tree (argarray
[i
], &ctx
, ht
);
14839 md5_finish_ctx (&ctx
, checksum_after_arglist
);
14842 if (memcmp (checksum_before_arglist
, checksum_after_arglist
, 16))
14843 fold_check_failed (NULL_TREE
, tem
);
14848 /* Perform constant folding and related simplification of initializer
14849 expression EXPR. These behave identically to "fold_buildN" but ignore
14850 potential run-time traps and exceptions that fold must preserve. */
14852 #define START_FOLD_INIT \
14853 int saved_signaling_nans = flag_signaling_nans;\
14854 int saved_trapping_math = flag_trapping_math;\
14855 int saved_rounding_math = flag_rounding_math;\
14856 int saved_trapv = flag_trapv;\
14857 int saved_folding_initializer = folding_initializer;\
14858 flag_signaling_nans = 0;\
14859 flag_trapping_math = 0;\
14860 flag_rounding_math = 0;\
14862 folding_initializer = 1;
14864 #define END_FOLD_INIT \
14865 flag_signaling_nans = saved_signaling_nans;\
14866 flag_trapping_math = saved_trapping_math;\
14867 flag_rounding_math = saved_rounding_math;\
14868 flag_trapv = saved_trapv;\
14869 folding_initializer = saved_folding_initializer;
14872 fold_build1_initializer_loc (location_t loc
, enum tree_code code
,
14873 tree type
, tree op
)
14878 result
= fold_build1_loc (loc
, code
, type
, op
);
14885 fold_build2_initializer_loc (location_t loc
, enum tree_code code
,
14886 tree type
, tree op0
, tree op1
)
14891 result
= fold_build2_loc (loc
, code
, type
, op0
, op1
);
14898 fold_build3_initializer_loc (location_t loc
, enum tree_code code
,
14899 tree type
, tree op0
, tree op1
, tree op2
)
14904 result
= fold_build3_loc (loc
, code
, type
, op0
, op1
, op2
);
14911 fold_build_call_array_initializer_loc (location_t loc
, tree type
, tree fn
,
14912 int nargs
, tree
*argarray
)
14917 result
= fold_build_call_array_loc (loc
, type
, fn
, nargs
, argarray
);
14923 #undef START_FOLD_INIT
14924 #undef END_FOLD_INIT
14926 /* Determine if first argument is a multiple of second argument. Return 0 if
14927 it is not, or we cannot easily determined it to be.
14929 An example of the sort of thing we care about (at this point; this routine
14930 could surely be made more general, and expanded to do what the *_DIV_EXPR's
14931 fold cases do now) is discovering that
14933 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14939 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
14941 This code also handles discovering that
14943 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
14945 is a multiple of 8 so we don't have to worry about dealing with a
14946 possible remainder.
14948 Note that we *look* inside a SAVE_EXPR only to determine how it was
14949 calculated; it is not safe for fold to do much of anything else with the
14950 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
14951 at run time. For example, the latter example above *cannot* be implemented
14952 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
14953 evaluation time of the original SAVE_EXPR is not necessarily the same at
14954 the time the new expression is evaluated. The only optimization of this
14955 sort that would be valid is changing
14957 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
14961 SAVE_EXPR (I) * SAVE_EXPR (J)
14963 (where the same SAVE_EXPR (J) is used in the original and the
14964 transformed version). */
14967 multiple_of_p (tree type
, const_tree top
, const_tree bottom
)
14969 if (operand_equal_p (top
, bottom
, 0))
14972 if (TREE_CODE (type
) != INTEGER_TYPE
)
14975 switch (TREE_CODE (top
))
14978 /* Bitwise and provides a power of two multiple. If the mask is
14979 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
14980 if (!integer_pow2p (bottom
))
14985 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
14986 || multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
14990 return (multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
)
14991 && multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
));
14994 if (TREE_CODE (TREE_OPERAND (top
, 1)) == INTEGER_CST
)
14998 op1
= TREE_OPERAND (top
, 1);
14999 /* const_binop may not detect overflow correctly,
15000 so check for it explicitly here. */
15001 if (TYPE_PRECISION (TREE_TYPE (size_one_node
))
15002 > TREE_INT_CST_LOW (op1
)
15003 && TREE_INT_CST_HIGH (op1
) == 0
15004 && 0 != (t1
= fold_convert (type
,
15005 const_binop (LSHIFT_EXPR
,
15008 && !TREE_OVERFLOW (t1
))
15009 return multiple_of_p (type
, t1
, bottom
);
15014 /* Can't handle conversions from non-integral or wider integral type. */
15015 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top
, 0))) != INTEGER_TYPE
)
15016 || (TYPE_PRECISION (type
)
15017 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top
, 0)))))
15020 /* .. fall through ... */
15023 return multiple_of_p (type
, TREE_OPERAND (top
, 0), bottom
);
15026 return (multiple_of_p (type
, TREE_OPERAND (top
, 1), bottom
)
15027 && multiple_of_p (type
, TREE_OPERAND (top
, 2), bottom
));
15030 if (TREE_CODE (bottom
) != INTEGER_CST
15031 || integer_zerop (bottom
)
15032 || (TYPE_UNSIGNED (type
)
15033 && (tree_int_cst_sgn (top
) < 0
15034 || tree_int_cst_sgn (bottom
) < 0)))
15036 return integer_zerop (int_const_binop (TRUNC_MOD_EXPR
,
15044 /* Return true if CODE or TYPE is known to be non-negative. */
15047 tree_simple_nonnegative_warnv_p (enum tree_code code
, tree type
)
15049 if ((TYPE_PRECISION (type
) != 1 || TYPE_UNSIGNED (type
))
15050 && truth_value_p (code
))
15051 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15052 have a signed:1 type (where the value is -1 and 0). */
15057 /* Return true if (CODE OP0) is known to be non-negative. If the return
15058 value is based on the assumption that signed overflow is undefined,
15059 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15060 *STRICT_OVERFLOW_P. */
15063 tree_unary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15064 bool *strict_overflow_p
)
15066 if (TYPE_UNSIGNED (type
))
15072 /* We can't return 1 if flag_wrapv is set because
15073 ABS_EXPR<INT_MIN> = INT_MIN. */
15074 if (!INTEGRAL_TYPE_P (type
))
15076 if (TYPE_OVERFLOW_UNDEFINED (type
))
15078 *strict_overflow_p
= true;
15083 case NON_LVALUE_EXPR
:
15085 case FIX_TRUNC_EXPR
:
15086 return tree_expr_nonnegative_warnv_p (op0
,
15087 strict_overflow_p
);
15091 tree inner_type
= TREE_TYPE (op0
);
15092 tree outer_type
= type
;
15094 if (TREE_CODE (outer_type
) == REAL_TYPE
)
15096 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15097 return tree_expr_nonnegative_warnv_p (op0
,
15098 strict_overflow_p
);
15099 if (TREE_CODE (inner_type
) == INTEGER_TYPE
)
15101 if (TYPE_UNSIGNED (inner_type
))
15103 return tree_expr_nonnegative_warnv_p (op0
,
15104 strict_overflow_p
);
15107 else if (TREE_CODE (outer_type
) == INTEGER_TYPE
)
15109 if (TREE_CODE (inner_type
) == REAL_TYPE
)
15110 return tree_expr_nonnegative_warnv_p (op0
,
15111 strict_overflow_p
);
15112 if (TREE_CODE (inner_type
) == INTEGER_TYPE
)
15113 return TYPE_PRECISION (inner_type
) < TYPE_PRECISION (outer_type
)
15114 && TYPE_UNSIGNED (inner_type
);
15120 return tree_simple_nonnegative_warnv_p (code
, type
);
15123 /* We don't know sign of `t', so be conservative and return false. */
15127 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
15128 value is based on the assumption that signed overflow is undefined,
15129 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15130 *STRICT_OVERFLOW_P. */
15133 tree_binary_nonnegative_warnv_p (enum tree_code code
, tree type
, tree op0
,
15134 tree op1
, bool *strict_overflow_p
)
15136 if (TYPE_UNSIGNED (type
))
15141 case POINTER_PLUS_EXPR
:
15143 if (FLOAT_TYPE_P (type
))
15144 return (tree_expr_nonnegative_warnv_p (op0
,
15146 && tree_expr_nonnegative_warnv_p (op1
,
15147 strict_overflow_p
));
15149 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
15150 both unsigned and at least 2 bits shorter than the result. */
15151 if (TREE_CODE (type
) == INTEGER_TYPE
15152 && TREE_CODE (op0
) == NOP_EXPR
15153 && TREE_CODE (op1
) == NOP_EXPR
)
15155 tree inner1
= TREE_TYPE (TREE_OPERAND (op0
, 0));
15156 tree inner2
= TREE_TYPE (TREE_OPERAND (op1
, 0));
15157 if (TREE_CODE (inner1
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner1
)
15158 && TREE_CODE (inner2
) == INTEGER_TYPE
&& TYPE_UNSIGNED (inner2
))
15160 unsigned int prec
= MAX (TYPE_PRECISION (inner1
),
15161 TYPE_PRECISION (inner2
)) + 1;
15162 return prec
< TYPE_PRECISION (type
);
15168 if (FLOAT_TYPE_P (type
))
15170 /* x * x for floating point x is always non-negative. */
15171 if (operand_equal_p (op0
, op1
, 0))
15173 return (tree_expr_nonnegative_warnv_p (op0
,
15175 && tree_expr_nonnegative_warnv_p (op1
,
15176 strict_overflow_p
));
15179 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
15180 both unsigned and their total bits is shorter than the result. */
15181 if (TREE_CODE (type
) == INTEGER_TYPE
15182 && (TREE_CODE (op0
) == NOP_EXPR
|| TREE_CODE (op0
) == INTEGER_CST
)
15183 && (TREE_CODE (op1
) == NOP_EXPR
|| TREE_CODE (op1
) == INTEGER_CST
))
15185 tree inner0
= (TREE_CODE (op0
) == NOP_EXPR
)
15186 ? TREE_TYPE (TREE_OPERAND (op0
, 0))
15188 tree inner1
= (TREE_CODE (op1
) == NOP_EXPR
)
15189 ? TREE_TYPE (TREE_OPERAND (op1
, 0))
15192 bool unsigned0
= TYPE_UNSIGNED (inner0
);
15193 bool unsigned1
= TYPE_UNSIGNED (inner1
);
15195 if (TREE_CODE (op0
) == INTEGER_CST
)
15196 unsigned0
= unsigned0
|| tree_int_cst_sgn (op0
) >= 0;
15198 if (TREE_CODE (op1
) == INTEGER_CST
)
15199 unsigned1
= unsigned1
|| tree_int_cst_sgn (op1
) >= 0;
15201 if (TREE_CODE (inner0
) == INTEGER_TYPE
&& unsigned0
15202 && TREE_CODE (inner1
) == INTEGER_TYPE
&& unsigned1
)
15204 unsigned int precision0
= (TREE_CODE (op0
) == INTEGER_CST
)
15205 ? tree_int_cst_min_precision (op0
, /*unsignedp=*/true)
15206 : TYPE_PRECISION (inner0
);
15208 unsigned int precision1
= (TREE_CODE (op1
) == INTEGER_CST
)
15209 ? tree_int_cst_min_precision (op1
, /*unsignedp=*/true)
15210 : TYPE_PRECISION (inner1
);
15212 return precision0
+ precision1
< TYPE_PRECISION (type
);
15219 return (tree_expr_nonnegative_warnv_p (op0
,
15221 || tree_expr_nonnegative_warnv_p (op1
,
15222 strict_overflow_p
));
15228 case TRUNC_DIV_EXPR
:
15229 case CEIL_DIV_EXPR
:
15230 case FLOOR_DIV_EXPR
:
15231 case ROUND_DIV_EXPR
:
15232 return (tree_expr_nonnegative_warnv_p (op0
,
15234 && tree_expr_nonnegative_warnv_p (op1
,
15235 strict_overflow_p
));
15237 case TRUNC_MOD_EXPR
:
15238 case CEIL_MOD_EXPR
:
15239 case FLOOR_MOD_EXPR
:
15240 case ROUND_MOD_EXPR
:
15241 return tree_expr_nonnegative_warnv_p (op0
,
15242 strict_overflow_p
);
15244 return tree_simple_nonnegative_warnv_p (code
, type
);
15247 /* We don't know sign of `t', so be conservative and return false. */
15251 /* Return true if T is known to be non-negative. If the return
15252 value is based on the assumption that signed overflow is undefined,
15253 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15254 *STRICT_OVERFLOW_P. */
15257 tree_single_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15259 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15262 switch (TREE_CODE (t
))
15265 return tree_int_cst_sgn (t
) >= 0;
15268 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t
));
15271 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t
));
15274 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15276 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 2),
15277 strict_overflow_p
));
15279 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15282 /* We don't know sign of `t', so be conservative and return false. */
15286 /* Return true if T is known to be non-negative. If the return
15287 value is based on the assumption that signed overflow is undefined,
15288 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15289 *STRICT_OVERFLOW_P. */
15292 tree_call_nonnegative_warnv_p (tree type
, tree fndecl
,
15293 tree arg0
, tree arg1
, bool *strict_overflow_p
)
15295 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
15296 switch (DECL_FUNCTION_CODE (fndecl
))
15298 CASE_FLT_FN (BUILT_IN_ACOS
):
15299 CASE_FLT_FN (BUILT_IN_ACOSH
):
15300 CASE_FLT_FN (BUILT_IN_CABS
):
15301 CASE_FLT_FN (BUILT_IN_COSH
):
15302 CASE_FLT_FN (BUILT_IN_ERFC
):
15303 CASE_FLT_FN (BUILT_IN_EXP
):
15304 CASE_FLT_FN (BUILT_IN_EXP10
):
15305 CASE_FLT_FN (BUILT_IN_EXP2
):
15306 CASE_FLT_FN (BUILT_IN_FABS
):
15307 CASE_FLT_FN (BUILT_IN_FDIM
):
15308 CASE_FLT_FN (BUILT_IN_HYPOT
):
15309 CASE_FLT_FN (BUILT_IN_POW10
):
15310 CASE_INT_FN (BUILT_IN_FFS
):
15311 CASE_INT_FN (BUILT_IN_PARITY
):
15312 CASE_INT_FN (BUILT_IN_POPCOUNT
):
15313 case BUILT_IN_BSWAP32
:
15314 case BUILT_IN_BSWAP64
:
15318 CASE_FLT_FN (BUILT_IN_SQRT
):
15319 /* sqrt(-0.0) is -0.0. */
15320 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type
)))
15322 return tree_expr_nonnegative_warnv_p (arg0
,
15323 strict_overflow_p
);
15325 CASE_FLT_FN (BUILT_IN_ASINH
):
15326 CASE_FLT_FN (BUILT_IN_ATAN
):
15327 CASE_FLT_FN (BUILT_IN_ATANH
):
15328 CASE_FLT_FN (BUILT_IN_CBRT
):
15329 CASE_FLT_FN (BUILT_IN_CEIL
):
15330 CASE_FLT_FN (BUILT_IN_ERF
):
15331 CASE_FLT_FN (BUILT_IN_EXPM1
):
15332 CASE_FLT_FN (BUILT_IN_FLOOR
):
15333 CASE_FLT_FN (BUILT_IN_FMOD
):
15334 CASE_FLT_FN (BUILT_IN_FREXP
):
15335 CASE_FLT_FN (BUILT_IN_ICEIL
):
15336 CASE_FLT_FN (BUILT_IN_IFLOOR
):
15337 CASE_FLT_FN (BUILT_IN_IRINT
):
15338 CASE_FLT_FN (BUILT_IN_IROUND
):
15339 CASE_FLT_FN (BUILT_IN_LCEIL
):
15340 CASE_FLT_FN (BUILT_IN_LDEXP
):
15341 CASE_FLT_FN (BUILT_IN_LFLOOR
):
15342 CASE_FLT_FN (BUILT_IN_LLCEIL
):
15343 CASE_FLT_FN (BUILT_IN_LLFLOOR
):
15344 CASE_FLT_FN (BUILT_IN_LLRINT
):
15345 CASE_FLT_FN (BUILT_IN_LLROUND
):
15346 CASE_FLT_FN (BUILT_IN_LRINT
):
15347 CASE_FLT_FN (BUILT_IN_LROUND
):
15348 CASE_FLT_FN (BUILT_IN_MODF
):
15349 CASE_FLT_FN (BUILT_IN_NEARBYINT
):
15350 CASE_FLT_FN (BUILT_IN_RINT
):
15351 CASE_FLT_FN (BUILT_IN_ROUND
):
15352 CASE_FLT_FN (BUILT_IN_SCALB
):
15353 CASE_FLT_FN (BUILT_IN_SCALBLN
):
15354 CASE_FLT_FN (BUILT_IN_SCALBN
):
15355 CASE_FLT_FN (BUILT_IN_SIGNBIT
):
15356 CASE_FLT_FN (BUILT_IN_SIGNIFICAND
):
15357 CASE_FLT_FN (BUILT_IN_SINH
):
15358 CASE_FLT_FN (BUILT_IN_TANH
):
15359 CASE_FLT_FN (BUILT_IN_TRUNC
):
15360 /* True if the 1st argument is nonnegative. */
15361 return tree_expr_nonnegative_warnv_p (arg0
,
15362 strict_overflow_p
);
15364 CASE_FLT_FN (BUILT_IN_FMAX
):
15365 /* True if the 1st OR 2nd arguments are nonnegative. */
15366 return (tree_expr_nonnegative_warnv_p (arg0
,
15368 || (tree_expr_nonnegative_warnv_p (arg1
,
15369 strict_overflow_p
)));
15371 CASE_FLT_FN (BUILT_IN_FMIN
):
15372 /* True if the 1st AND 2nd arguments are nonnegative. */
15373 return (tree_expr_nonnegative_warnv_p (arg0
,
15375 && (tree_expr_nonnegative_warnv_p (arg1
,
15376 strict_overflow_p
)));
15378 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
15379 /* True if the 2nd argument is nonnegative. */
15380 return tree_expr_nonnegative_warnv_p (arg1
,
15381 strict_overflow_p
);
15383 CASE_FLT_FN (BUILT_IN_POWI
):
15384 /* True if the 1st argument is nonnegative or the second
15385 argument is an even integer. */
15386 if (TREE_CODE (arg1
) == INTEGER_CST
15387 && (TREE_INT_CST_LOW (arg1
) & 1) == 0)
15389 return tree_expr_nonnegative_warnv_p (arg0
,
15390 strict_overflow_p
);
15392 CASE_FLT_FN (BUILT_IN_POW
):
15393 /* True if the 1st argument is nonnegative or the second
15394 argument is an even integer valued real. */
15395 if (TREE_CODE (arg1
) == REAL_CST
)
15400 c
= TREE_REAL_CST (arg1
);
15401 n
= real_to_integer (&c
);
15404 REAL_VALUE_TYPE cint
;
15405 real_from_integer (&cint
, VOIDmode
, n
,
15406 n
< 0 ? -1 : 0, 0);
15407 if (real_identical (&c
, &cint
))
15411 return tree_expr_nonnegative_warnv_p (arg0
,
15412 strict_overflow_p
);
15417 return tree_simple_nonnegative_warnv_p (CALL_EXPR
,
15421 /* Return true if T is known to be non-negative. If the return
15422 value is based on the assumption that signed overflow is undefined,
15423 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15424 *STRICT_OVERFLOW_P. */
15427 tree_invalid_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15429 enum tree_code code
= TREE_CODE (t
);
15430 if (TYPE_UNSIGNED (TREE_TYPE (t
)))
15437 tree temp
= TARGET_EXPR_SLOT (t
);
15438 t
= TARGET_EXPR_INITIAL (t
);
15440 /* If the initializer is non-void, then it's a normal expression
15441 that will be assigned to the slot. */
15442 if (!VOID_TYPE_P (t
))
15443 return tree_expr_nonnegative_warnv_p (t
, strict_overflow_p
);
15445 /* Otherwise, the initializer sets the slot in some way. One common
15446 way is an assignment statement at the end of the initializer. */
15449 if (TREE_CODE (t
) == BIND_EXPR
)
15450 t
= expr_last (BIND_EXPR_BODY (t
));
15451 else if (TREE_CODE (t
) == TRY_FINALLY_EXPR
15452 || TREE_CODE (t
) == TRY_CATCH_EXPR
)
15453 t
= expr_last (TREE_OPERAND (t
, 0));
15454 else if (TREE_CODE (t
) == STATEMENT_LIST
)
15459 if (TREE_CODE (t
) == MODIFY_EXPR
15460 && TREE_OPERAND (t
, 0) == temp
)
15461 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15462 strict_overflow_p
);
15469 tree arg0
= call_expr_nargs (t
) > 0 ? CALL_EXPR_ARG (t
, 0) : NULL_TREE
;
15470 tree arg1
= call_expr_nargs (t
) > 1 ? CALL_EXPR_ARG (t
, 1) : NULL_TREE
;
15472 return tree_call_nonnegative_warnv_p (TREE_TYPE (t
),
15473 get_callee_fndecl (t
),
15476 strict_overflow_p
);
15478 case COMPOUND_EXPR
:
15480 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 1),
15481 strict_overflow_p
);
15483 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t
, 1)),
15484 strict_overflow_p
);
15486 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t
, 0),
15487 strict_overflow_p
);
15490 return tree_simple_nonnegative_warnv_p (TREE_CODE (t
),
15494 /* We don't know sign of `t', so be conservative and return false. */
15498 /* Return true if T is known to be non-negative. If the return
15499 value is based on the assumption that signed overflow is undefined,
15500 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15501 *STRICT_OVERFLOW_P. */
15504 tree_expr_nonnegative_warnv_p (tree t
, bool *strict_overflow_p
)
15506 enum tree_code code
;
15507 if (t
== error_mark_node
)
15510 code
= TREE_CODE (t
);
15511 switch (TREE_CODE_CLASS (code
))
15514 case tcc_comparison
:
15515 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15517 TREE_OPERAND (t
, 0),
15518 TREE_OPERAND (t
, 1),
15519 strict_overflow_p
);
15522 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15524 TREE_OPERAND (t
, 0),
15525 strict_overflow_p
);
15528 case tcc_declaration
:
15529 case tcc_reference
:
15530 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15538 case TRUTH_AND_EXPR
:
15539 case TRUTH_OR_EXPR
:
15540 case TRUTH_XOR_EXPR
:
15541 return tree_binary_nonnegative_warnv_p (TREE_CODE (t
),
15543 TREE_OPERAND (t
, 0),
15544 TREE_OPERAND (t
, 1),
15545 strict_overflow_p
);
15546 case TRUTH_NOT_EXPR
:
15547 return tree_unary_nonnegative_warnv_p (TREE_CODE (t
),
15549 TREE_OPERAND (t
, 0),
15550 strict_overflow_p
);
15557 case WITH_SIZE_EXPR
:
15559 return tree_single_nonnegative_warnv_p (t
, strict_overflow_p
);
15562 return tree_invalid_nonnegative_warnv_p (t
, strict_overflow_p
);
15566 /* Return true if `t' is known to be non-negative. Handle warnings
15567 about undefined signed overflow. */
15570 tree_expr_nonnegative_p (tree t
)
15572 bool ret
, strict_overflow_p
;
15574 strict_overflow_p
= false;
15575 ret
= tree_expr_nonnegative_warnv_p (t
, &strict_overflow_p
);
15576 if (strict_overflow_p
)
15577 fold_overflow_warning (("assuming signed overflow does not occur when "
15578 "determining that expression is always "
15580 WARN_STRICT_OVERFLOW_MISC
);
15585 /* Return true when (CODE OP0) is an address and is known to be nonzero.
15586 For floating point we further ensure that T is not denormal.
15587 Similar logic is present in nonzero_address in rtlanal.h.
15589 If the return value is based on the assumption that signed overflow
15590 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15591 change *STRICT_OVERFLOW_P. */
15594 tree_unary_nonzero_warnv_p (enum tree_code code
, tree type
, tree op0
,
15595 bool *strict_overflow_p
)
15600 return tree_expr_nonzero_warnv_p (op0
,
15601 strict_overflow_p
);
15605 tree inner_type
= TREE_TYPE (op0
);
15606 tree outer_type
= type
;
15608 return (TYPE_PRECISION (outer_type
) >= TYPE_PRECISION (inner_type
)
15609 && tree_expr_nonzero_warnv_p (op0
,
15610 strict_overflow_p
));
15614 case NON_LVALUE_EXPR
:
15615 return tree_expr_nonzero_warnv_p (op0
,
15616 strict_overflow_p
);
15625 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
15626 For floating point we further ensure that T is not denormal.
15627 Similar logic is present in nonzero_address in rtlanal.h.
15629 If the return value is based on the assumption that signed overflow
15630 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15631 change *STRICT_OVERFLOW_P. */
15634 tree_binary_nonzero_warnv_p (enum tree_code code
,
15637 tree op1
, bool *strict_overflow_p
)
15639 bool sub_strict_overflow_p
;
15642 case POINTER_PLUS_EXPR
:
15644 if (TYPE_OVERFLOW_UNDEFINED (type
))
15646 /* With the presence of negative values it is hard
15647 to say something. */
15648 sub_strict_overflow_p
= false;
15649 if (!tree_expr_nonnegative_warnv_p (op0
,
15650 &sub_strict_overflow_p
)
15651 || !tree_expr_nonnegative_warnv_p (op1
,
15652 &sub_strict_overflow_p
))
15654 /* One of operands must be positive and the other non-negative. */
15655 /* We don't set *STRICT_OVERFLOW_P here: even if this value
15656 overflows, on a twos-complement machine the sum of two
15657 nonnegative numbers can never be zero. */
15658 return (tree_expr_nonzero_warnv_p (op0
,
15660 || tree_expr_nonzero_warnv_p (op1
,
15661 strict_overflow_p
));
15666 if (TYPE_OVERFLOW_UNDEFINED (type
))
15668 if (tree_expr_nonzero_warnv_p (op0
,
15670 && tree_expr_nonzero_warnv_p (op1
,
15671 strict_overflow_p
))
15673 *strict_overflow_p
= true;
15680 sub_strict_overflow_p
= false;
15681 if (tree_expr_nonzero_warnv_p (op0
,
15682 &sub_strict_overflow_p
)
15683 && tree_expr_nonzero_warnv_p (op1
,
15684 &sub_strict_overflow_p
))
15686 if (sub_strict_overflow_p
)
15687 *strict_overflow_p
= true;
15692 sub_strict_overflow_p
= false;
15693 if (tree_expr_nonzero_warnv_p (op0
,
15694 &sub_strict_overflow_p
))
15696 if (sub_strict_overflow_p
)
15697 *strict_overflow_p
= true;
15699 /* When both operands are nonzero, then MAX must be too. */
15700 if (tree_expr_nonzero_warnv_p (op1
,
15701 strict_overflow_p
))
15704 /* MAX where operand 0 is positive is positive. */
15705 return tree_expr_nonnegative_warnv_p (op0
,
15706 strict_overflow_p
);
15708 /* MAX where operand 1 is positive is positive. */
15709 else if (tree_expr_nonzero_warnv_p (op1
,
15710 &sub_strict_overflow_p
)
15711 && tree_expr_nonnegative_warnv_p (op1
,
15712 &sub_strict_overflow_p
))
15714 if (sub_strict_overflow_p
)
15715 *strict_overflow_p
= true;
15721 return (tree_expr_nonzero_warnv_p (op1
,
15723 || tree_expr_nonzero_warnv_p (op0
,
15724 strict_overflow_p
));
15733 /* Return true when T is an address and is known to be nonzero.
15734 For floating point we further ensure that T is not denormal.
15735 Similar logic is present in nonzero_address in rtlanal.h.
15737 If the return value is based on the assumption that signed overflow
15738 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15739 change *STRICT_OVERFLOW_P. */
15742 tree_single_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
15744 bool sub_strict_overflow_p
;
15745 switch (TREE_CODE (t
))
15748 return !integer_zerop (t
);
15752 tree base
= TREE_OPERAND (t
, 0);
15753 if (!DECL_P (base
))
15754 base
= get_base_address (base
);
15759 /* Weak declarations may link to NULL. Other things may also be NULL
15760 so protect with -fdelete-null-pointer-checks; but not variables
15761 allocated on the stack. */
15763 && (flag_delete_null_pointer_checks
15764 || (DECL_CONTEXT (base
)
15765 && TREE_CODE (DECL_CONTEXT (base
)) == FUNCTION_DECL
15766 && auto_var_in_fn_p (base
, DECL_CONTEXT (base
)))))
15767 return !VAR_OR_FUNCTION_DECL_P (base
) || !DECL_WEAK (base
);
15769 /* Constants are never weak. */
15770 if (CONSTANT_CLASS_P (base
))
15777 sub_strict_overflow_p
= false;
15778 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
15779 &sub_strict_overflow_p
)
15780 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 2),
15781 &sub_strict_overflow_p
))
15783 if (sub_strict_overflow_p
)
15784 *strict_overflow_p
= true;
15795 /* Return true when T is an address and is known to be nonzero.
15796 For floating point we further ensure that T is not denormal.
15797 Similar logic is present in nonzero_address in rtlanal.h.
15799 If the return value is based on the assumption that signed overflow
15800 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
15801 change *STRICT_OVERFLOW_P. */
15804 tree_expr_nonzero_warnv_p (tree t
, bool *strict_overflow_p
)
15806 tree type
= TREE_TYPE (t
);
15807 enum tree_code code
;
15809 /* Doing something useful for floating point would need more work. */
15810 if (!INTEGRAL_TYPE_P (type
) && !POINTER_TYPE_P (type
))
15813 code
= TREE_CODE (t
);
15814 switch (TREE_CODE_CLASS (code
))
15817 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
15818 strict_overflow_p
);
15820 case tcc_comparison
:
15821 return tree_binary_nonzero_warnv_p (code
, type
,
15822 TREE_OPERAND (t
, 0),
15823 TREE_OPERAND (t
, 1),
15824 strict_overflow_p
);
15826 case tcc_declaration
:
15827 case tcc_reference
:
15828 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
15836 case TRUTH_NOT_EXPR
:
15837 return tree_unary_nonzero_warnv_p (code
, type
, TREE_OPERAND (t
, 0),
15838 strict_overflow_p
);
15840 case TRUTH_AND_EXPR
:
15841 case TRUTH_OR_EXPR
:
15842 case TRUTH_XOR_EXPR
:
15843 return tree_binary_nonzero_warnv_p (code
, type
,
15844 TREE_OPERAND (t
, 0),
15845 TREE_OPERAND (t
, 1),
15846 strict_overflow_p
);
15853 case WITH_SIZE_EXPR
:
15855 return tree_single_nonzero_warnv_p (t
, strict_overflow_p
);
15857 case COMPOUND_EXPR
:
15860 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 1),
15861 strict_overflow_p
);
15864 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t
, 0),
15865 strict_overflow_p
);
15868 return alloca_call_p (t
);
15876 /* Return true when T is an address and is known to be nonzero.
15877 Handle warnings about undefined signed overflow. */
15880 tree_expr_nonzero_p (tree t
)
15882 bool ret
, strict_overflow_p
;
15884 strict_overflow_p
= false;
15885 ret
= tree_expr_nonzero_warnv_p (t
, &strict_overflow_p
);
15886 if (strict_overflow_p
)
15887 fold_overflow_warning (("assuming signed overflow does not occur when "
15888 "determining that expression is always "
15890 WARN_STRICT_OVERFLOW_MISC
);
15894 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
15895 attempt to fold the expression to a constant without modifying TYPE,
15898 If the expression could be simplified to a constant, then return
15899 the constant. If the expression would not be simplified to a
15900 constant, then return NULL_TREE. */
15903 fold_binary_to_constant (enum tree_code code
, tree type
, tree op0
, tree op1
)
15905 tree tem
= fold_binary (code
, type
, op0
, op1
);
15906 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
15909 /* Given the components of a unary expression CODE, TYPE and OP0,
15910 attempt to fold the expression to a constant without modifying
15913 If the expression could be simplified to a constant, then return
15914 the constant. If the expression would not be simplified to a
15915 constant, then return NULL_TREE. */
15918 fold_unary_to_constant (enum tree_code code
, tree type
, tree op0
)
15920 tree tem
= fold_unary (code
, type
, op0
);
15921 return (tem
&& TREE_CONSTANT (tem
)) ? tem
: NULL_TREE
;
15924 /* If EXP represents referencing an element in a constant string
15925 (either via pointer arithmetic or array indexing), return the
15926 tree representing the value accessed, otherwise return NULL. */
15929 fold_read_from_constant_string (tree exp
)
15931 if ((TREE_CODE (exp
) == INDIRECT_REF
15932 || TREE_CODE (exp
) == ARRAY_REF
)
15933 && TREE_CODE (TREE_TYPE (exp
)) == INTEGER_TYPE
)
15935 tree exp1
= TREE_OPERAND (exp
, 0);
15938 location_t loc
= EXPR_LOCATION (exp
);
15940 if (TREE_CODE (exp
) == INDIRECT_REF
)
15941 string
= string_constant (exp1
, &index
);
15944 tree low_bound
= array_ref_low_bound (exp
);
15945 index
= fold_convert_loc (loc
, sizetype
, TREE_OPERAND (exp
, 1));
15947 /* Optimize the special-case of a zero lower bound.
15949 We convert the low_bound to sizetype to avoid some problems
15950 with constant folding. (E.g. suppose the lower bound is 1,
15951 and its mode is QI. Without the conversion,l (ARRAY
15952 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
15953 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
15954 if (! integer_zerop (low_bound
))
15955 index
= size_diffop_loc (loc
, index
,
15956 fold_convert_loc (loc
, sizetype
, low_bound
));
15962 && TYPE_MODE (TREE_TYPE (exp
)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))
15963 && TREE_CODE (string
) == STRING_CST
15964 && TREE_CODE (index
) == INTEGER_CST
15965 && compare_tree_int (index
, TREE_STRING_LENGTH (string
)) < 0
15966 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
))))
15968 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string
)))) == 1))
15969 return build_int_cst_type (TREE_TYPE (exp
),
15970 (TREE_STRING_POINTER (string
)
15971 [TREE_INT_CST_LOW (index
)]));
15976 /* Return the tree for neg (ARG0) when ARG0 is known to be either
15977 an integer constant, real, or fixed-point constant.
15979 TYPE is the type of the result. */
15982 fold_negate_const (tree arg0
, tree type
)
15984 tree t
= NULL_TREE
;
15986 switch (TREE_CODE (arg0
))
15990 double_int val
= tree_to_double_int (arg0
);
15992 val
= val
.neg_with_overflow (&overflow
);
15993 t
= force_fit_type_double (type
, val
, 1,
15994 (overflow
| TREE_OVERFLOW (arg0
))
15995 && !TYPE_UNSIGNED (type
));
16000 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16005 FIXED_VALUE_TYPE f
;
16006 bool overflow_p
= fixed_arithmetic (&f
, NEGATE_EXPR
,
16007 &(TREE_FIXED_CST (arg0
)), NULL
,
16008 TYPE_SATURATING (type
));
16009 t
= build_fixed (type
, f
);
16010 /* Propagate overflow flags. */
16011 if (overflow_p
| TREE_OVERFLOW (arg0
))
16012 TREE_OVERFLOW (t
) = 1;
16017 gcc_unreachable ();
16023 /* Return the tree for abs (ARG0) when ARG0 is known to be either
16024 an integer constant or real constant.
16026 TYPE is the type of the result. */
16029 fold_abs_const (tree arg0
, tree type
)
16031 tree t
= NULL_TREE
;
16033 switch (TREE_CODE (arg0
))
16037 double_int val
= tree_to_double_int (arg0
);
16039 /* If the value is unsigned or non-negative, then the absolute value
16040 is the same as the ordinary value. */
16041 if (TYPE_UNSIGNED (type
)
16042 || !val
.is_negative ())
16045 /* If the value is negative, then the absolute value is
16050 val
= val
.neg_with_overflow (&overflow
);
16051 t
= force_fit_type_double (type
, val
, -1,
16052 overflow
| TREE_OVERFLOW (arg0
));
16058 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0
)))
16059 t
= build_real (type
, real_value_negate (&TREE_REAL_CST (arg0
)));
16065 gcc_unreachable ();
16071 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
16072 constant. TYPE is the type of the result. */
16075 fold_not_const (const_tree arg0
, tree type
)
16079 gcc_assert (TREE_CODE (arg0
) == INTEGER_CST
);
16081 val
= ~tree_to_double_int (arg0
);
16082 return force_fit_type_double (type
, val
, 0, TREE_OVERFLOW (arg0
));
16085 /* Given CODE, a relational operator, the target type, TYPE and two
16086 constant operands OP0 and OP1, return the result of the
16087 relational operation. If the result is not a compile time
16088 constant, then return NULL_TREE. */
16091 fold_relational_const (enum tree_code code
, tree type
, tree op0
, tree op1
)
16093 int result
, invert
;
16095 /* From here on, the only cases we handle are when the result is
16096 known to be a constant. */
16098 if (TREE_CODE (op0
) == REAL_CST
&& TREE_CODE (op1
) == REAL_CST
)
16100 const REAL_VALUE_TYPE
*c0
= TREE_REAL_CST_PTR (op0
);
16101 const REAL_VALUE_TYPE
*c1
= TREE_REAL_CST_PTR (op1
);
16103 /* Handle the cases where either operand is a NaN. */
16104 if (real_isnan (c0
) || real_isnan (c1
))
16114 case UNORDERED_EXPR
:
16128 if (flag_trapping_math
)
16134 gcc_unreachable ();
16137 return constant_boolean_node (result
, type
);
16140 return constant_boolean_node (real_compare (code
, c0
, c1
), type
);
16143 if (TREE_CODE (op0
) == FIXED_CST
&& TREE_CODE (op1
) == FIXED_CST
)
16145 const FIXED_VALUE_TYPE
*c0
= TREE_FIXED_CST_PTR (op0
);
16146 const FIXED_VALUE_TYPE
*c1
= TREE_FIXED_CST_PTR (op1
);
16147 return constant_boolean_node (fixed_compare (code
, c0
, c1
), type
);
16150 /* Handle equality/inequality of complex constants. */
16151 if (TREE_CODE (op0
) == COMPLEX_CST
&& TREE_CODE (op1
) == COMPLEX_CST
)
16153 tree rcond
= fold_relational_const (code
, type
,
16154 TREE_REALPART (op0
),
16155 TREE_REALPART (op1
));
16156 tree icond
= fold_relational_const (code
, type
,
16157 TREE_IMAGPART (op0
),
16158 TREE_IMAGPART (op1
));
16159 if (code
== EQ_EXPR
)
16160 return fold_build2 (TRUTH_ANDIF_EXPR
, type
, rcond
, icond
);
16161 else if (code
== NE_EXPR
)
16162 return fold_build2 (TRUTH_ORIF_EXPR
, type
, rcond
, icond
);
16167 if (TREE_CODE (op0
) == VECTOR_CST
&& TREE_CODE (op1
) == VECTOR_CST
)
16169 unsigned count
= VECTOR_CST_NELTS (op0
);
16170 tree
*elts
= XALLOCAVEC (tree
, count
);
16171 gcc_assert (VECTOR_CST_NELTS (op1
) == count
16172 && TYPE_VECTOR_SUBPARTS (type
) == count
);
16174 for (unsigned i
= 0; i
< count
; i
++)
16176 tree elem_type
= TREE_TYPE (type
);
16177 tree elem0
= VECTOR_CST_ELT (op0
, i
);
16178 tree elem1
= VECTOR_CST_ELT (op1
, i
);
16180 tree tem
= fold_relational_const (code
, elem_type
,
16183 if (tem
== NULL_TREE
)
16186 elts
[i
] = build_int_cst (elem_type
, integer_zerop (tem
) ? 0 : -1);
16189 return build_vector (type
, elts
);
16192 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16194 To compute GT, swap the arguments and do LT.
16195 To compute GE, do LT and invert the result.
16196 To compute LE, swap the arguments, do LT and invert the result.
16197 To compute NE, do EQ and invert the result.
16199 Therefore, the code below must handle only EQ and LT. */
16201 if (code
== LE_EXPR
|| code
== GT_EXPR
)
16206 code
= swap_tree_comparison (code
);
16209 /* Note that it is safe to invert for real values here because we
16210 have already handled the one case that it matters. */
16213 if (code
== NE_EXPR
|| code
== GE_EXPR
)
16216 code
= invert_tree_comparison (code
, false);
16219 /* Compute a result for LT or EQ if args permit;
16220 Otherwise return T. */
16221 if (TREE_CODE (op0
) == INTEGER_CST
&& TREE_CODE (op1
) == INTEGER_CST
)
16223 if (code
== EQ_EXPR
)
16224 result
= tree_int_cst_equal (op0
, op1
);
16225 else if (TYPE_UNSIGNED (TREE_TYPE (op0
)))
16226 result
= INT_CST_LT_UNSIGNED (op0
, op1
);
16228 result
= INT_CST_LT (op0
, op1
);
16235 return constant_boolean_node (result
, type
);
16238 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16239 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16243 fold_build_cleanup_point_expr (tree type
, tree expr
)
16245 /* If the expression does not have side effects then we don't have to wrap
16246 it with a cleanup point expression. */
16247 if (!TREE_SIDE_EFFECTS (expr
))
16250 /* If the expression is a return, check to see if the expression inside the
16251 return has no side effects or the right hand side of the modify expression
16252 inside the return. If either don't have side effects set we don't need to
16253 wrap the expression in a cleanup point expression. Note we don't check the
16254 left hand side of the modify because it should always be a return decl. */
16255 if (TREE_CODE (expr
) == RETURN_EXPR
)
16257 tree op
= TREE_OPERAND (expr
, 0);
16258 if (!op
|| !TREE_SIDE_EFFECTS (op
))
16260 op
= TREE_OPERAND (op
, 1);
16261 if (!TREE_SIDE_EFFECTS (op
))
16265 return build1 (CLEANUP_POINT_EXPR
, type
, expr
);
16268 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16269 of an indirection through OP0, or NULL_TREE if no simplification is
16273 fold_indirect_ref_1 (location_t loc
, tree type
, tree op0
)
16279 subtype
= TREE_TYPE (sub
);
16280 if (!POINTER_TYPE_P (subtype
))
16283 if (TREE_CODE (sub
) == ADDR_EXPR
)
16285 tree op
= TREE_OPERAND (sub
, 0);
16286 tree optype
= TREE_TYPE (op
);
16287 /* *&CONST_DECL -> to the value of the const decl. */
16288 if (TREE_CODE (op
) == CONST_DECL
)
16289 return DECL_INITIAL (op
);
16290 /* *&p => p; make sure to handle *&"str"[cst] here. */
16291 if (type
== optype
)
16293 tree fop
= fold_read_from_constant_string (op
);
16299 /* *(foo *)&fooarray => fooarray[0] */
16300 else if (TREE_CODE (optype
) == ARRAY_TYPE
16301 && type
== TREE_TYPE (optype
)
16302 && (!in_gimple_form
16303 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16305 tree type_domain
= TYPE_DOMAIN (optype
);
16306 tree min_val
= size_zero_node
;
16307 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16308 min_val
= TYPE_MIN_VALUE (type_domain
);
16310 && TREE_CODE (min_val
) != INTEGER_CST
)
16312 return build4_loc (loc
, ARRAY_REF
, type
, op
, min_val
,
16313 NULL_TREE
, NULL_TREE
);
16315 /* *(foo *)&complexfoo => __real__ complexfoo */
16316 else if (TREE_CODE (optype
) == COMPLEX_TYPE
16317 && type
== TREE_TYPE (optype
))
16318 return fold_build1_loc (loc
, REALPART_EXPR
, type
, op
);
16319 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16320 else if (TREE_CODE (optype
) == VECTOR_TYPE
16321 && type
== TREE_TYPE (optype
))
16323 tree part_width
= TYPE_SIZE (type
);
16324 tree index
= bitsize_int (0);
16325 return fold_build3_loc (loc
, BIT_FIELD_REF
, type
, op
, part_width
, index
);
16329 if (TREE_CODE (sub
) == POINTER_PLUS_EXPR
16330 && TREE_CODE (TREE_OPERAND (sub
, 1)) == INTEGER_CST
)
16332 tree op00
= TREE_OPERAND (sub
, 0);
16333 tree op01
= TREE_OPERAND (sub
, 1);
16336 if (TREE_CODE (op00
) == ADDR_EXPR
)
16339 op00
= TREE_OPERAND (op00
, 0);
16340 op00type
= TREE_TYPE (op00
);
16342 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16343 if (TREE_CODE (op00type
) == VECTOR_TYPE
16344 && type
== TREE_TYPE (op00type
))
16346 HOST_WIDE_INT offset
= tree_low_cst (op01
, 0);
16347 tree part_width
= TYPE_SIZE (type
);
16348 unsigned HOST_WIDE_INT part_widthi
= tree_low_cst (part_width
, 0)/BITS_PER_UNIT
;
16349 unsigned HOST_WIDE_INT indexi
= offset
* BITS_PER_UNIT
;
16350 tree index
= bitsize_int (indexi
);
16352 if (offset
/part_widthi
<= TYPE_VECTOR_SUBPARTS (op00type
))
16353 return fold_build3_loc (loc
,
16354 BIT_FIELD_REF
, type
, op00
,
16355 part_width
, index
);
16358 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16359 else if (TREE_CODE (op00type
) == COMPLEX_TYPE
16360 && type
== TREE_TYPE (op00type
))
16362 tree size
= TYPE_SIZE_UNIT (type
);
16363 if (tree_int_cst_equal (size
, op01
))
16364 return fold_build1_loc (loc
, IMAGPART_EXPR
, type
, op00
);
16366 /* ((foo *)&fooarray)[1] => fooarray[1] */
16367 else if (TREE_CODE (op00type
) == ARRAY_TYPE
16368 && type
== TREE_TYPE (op00type
))
16370 tree type_domain
= TYPE_DOMAIN (op00type
);
16371 tree min_val
= size_zero_node
;
16372 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16373 min_val
= TYPE_MIN_VALUE (type_domain
);
16374 op01
= size_binop_loc (loc
, EXACT_DIV_EXPR
, op01
,
16375 TYPE_SIZE_UNIT (type
));
16376 op01
= size_binop_loc (loc
, PLUS_EXPR
, op01
, min_val
);
16377 return build4_loc (loc
, ARRAY_REF
, type
, op00
, op01
,
16378 NULL_TREE
, NULL_TREE
);
16383 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16384 if (TREE_CODE (TREE_TYPE (subtype
)) == ARRAY_TYPE
16385 && type
== TREE_TYPE (TREE_TYPE (subtype
))
16386 && (!in_gimple_form
16387 || TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
))
16390 tree min_val
= size_zero_node
;
16391 sub
= build_fold_indirect_ref_loc (loc
, sub
);
16392 type_domain
= TYPE_DOMAIN (TREE_TYPE (sub
));
16393 if (type_domain
&& TYPE_MIN_VALUE (type_domain
))
16394 min_val
= TYPE_MIN_VALUE (type_domain
);
16396 && TREE_CODE (min_val
) != INTEGER_CST
)
16398 return build4_loc (loc
, ARRAY_REF
, type
, sub
, min_val
, NULL_TREE
,
16405 /* Builds an expression for an indirection through T, simplifying some
16409 build_fold_indirect_ref_loc (location_t loc
, tree t
)
16411 tree type
= TREE_TYPE (TREE_TYPE (t
));
16412 tree sub
= fold_indirect_ref_1 (loc
, type
, t
);
16417 return build1_loc (loc
, INDIRECT_REF
, type
, t
);
16420 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16423 fold_indirect_ref_loc (location_t loc
, tree t
)
16425 tree sub
= fold_indirect_ref_1 (loc
, TREE_TYPE (t
), TREE_OPERAND (t
, 0));
16433 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16434 whose result is ignored. The type of the returned tree need not be
16435 the same as the original expression. */
16438 fold_ignored_result (tree t
)
16440 if (!TREE_SIDE_EFFECTS (t
))
16441 return integer_zero_node
;
16444 switch (TREE_CODE_CLASS (TREE_CODE (t
)))
16447 t
= TREE_OPERAND (t
, 0);
16451 case tcc_comparison
:
16452 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16453 t
= TREE_OPERAND (t
, 0);
16454 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 0)))
16455 t
= TREE_OPERAND (t
, 1);
16460 case tcc_expression
:
16461 switch (TREE_CODE (t
))
16463 case COMPOUND_EXPR
:
16464 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1)))
16466 t
= TREE_OPERAND (t
, 0);
16470 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 1))
16471 || TREE_SIDE_EFFECTS (TREE_OPERAND (t
, 2)))
16473 t
= TREE_OPERAND (t
, 0);
16486 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
16487 This can only be applied to objects of a sizetype. */
16490 round_up_loc (location_t loc
, tree value
, int divisor
)
16492 tree div
= NULL_TREE
;
16494 gcc_assert (divisor
> 0);
16498 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16499 have to do anything. Only do this when we are not given a const,
16500 because in that case, this check is more expensive than just
16502 if (TREE_CODE (value
) != INTEGER_CST
)
16504 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16506 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16510 /* If divisor is a power of two, simplify this to bit manipulation. */
16511 if (divisor
== (divisor
& -divisor
))
16513 if (TREE_CODE (value
) == INTEGER_CST
)
16515 double_int val
= tree_to_double_int (value
);
16518 if ((val
.low
& (divisor
- 1)) == 0)
16521 overflow_p
= TREE_OVERFLOW (value
);
16522 val
.low
&= ~(divisor
- 1);
16523 val
.low
+= divisor
;
16531 return force_fit_type_double (TREE_TYPE (value
), val
,
16538 t
= build_int_cst (TREE_TYPE (value
), divisor
- 1);
16539 value
= size_binop_loc (loc
, PLUS_EXPR
, value
, t
);
16540 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16541 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16547 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16548 value
= size_binop_loc (loc
, CEIL_DIV_EXPR
, value
, div
);
16549 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16555 /* Likewise, but round down. */
16558 round_down_loc (location_t loc
, tree value
, int divisor
)
16560 tree div
= NULL_TREE
;
16562 gcc_assert (divisor
> 0);
16566 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16567 have to do anything. Only do this when we are not given a const,
16568 because in that case, this check is more expensive than just
16570 if (TREE_CODE (value
) != INTEGER_CST
)
16572 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16574 if (multiple_of_p (TREE_TYPE (value
), value
, div
))
16578 /* If divisor is a power of two, simplify this to bit manipulation. */
16579 if (divisor
== (divisor
& -divisor
))
16583 t
= build_int_cst (TREE_TYPE (value
), -divisor
);
16584 value
= size_binop_loc (loc
, BIT_AND_EXPR
, value
, t
);
16589 div
= build_int_cst (TREE_TYPE (value
), divisor
);
16590 value
= size_binop_loc (loc
, FLOOR_DIV_EXPR
, value
, div
);
16591 value
= size_binop_loc (loc
, MULT_EXPR
, value
, div
);
16597 /* Returns the pointer to the base of the object addressed by EXP and
16598 extracts the information about the offset of the access, storing it
16599 to PBITPOS and POFFSET. */
16602 split_address_to_core_and_offset (tree exp
,
16603 HOST_WIDE_INT
*pbitpos
, tree
*poffset
)
16606 enum machine_mode mode
;
16607 int unsignedp
, volatilep
;
16608 HOST_WIDE_INT bitsize
;
16609 location_t loc
= EXPR_LOCATION (exp
);
16611 if (TREE_CODE (exp
) == ADDR_EXPR
)
16613 core
= get_inner_reference (TREE_OPERAND (exp
, 0), &bitsize
, pbitpos
,
16614 poffset
, &mode
, &unsignedp
, &volatilep
,
16616 core
= build_fold_addr_expr_loc (loc
, core
);
16622 *poffset
= NULL_TREE
;
16628 /* Returns true if addresses of E1 and E2 differ by a constant, false
16629 otherwise. If they do, E1 - E2 is stored in *DIFF. */
16632 ptr_difference_const (tree e1
, tree e2
, HOST_WIDE_INT
*diff
)
16635 HOST_WIDE_INT bitpos1
, bitpos2
;
16636 tree toffset1
, toffset2
, tdiff
, type
;
16638 core1
= split_address_to_core_and_offset (e1
, &bitpos1
, &toffset1
);
16639 core2
= split_address_to_core_and_offset (e2
, &bitpos2
, &toffset2
);
16641 if (bitpos1
% BITS_PER_UNIT
!= 0
16642 || bitpos2
% BITS_PER_UNIT
!= 0
16643 || !operand_equal_p (core1
, core2
, 0))
16646 if (toffset1
&& toffset2
)
16648 type
= TREE_TYPE (toffset1
);
16649 if (type
!= TREE_TYPE (toffset2
))
16650 toffset2
= fold_convert (type
, toffset2
);
16652 tdiff
= fold_build2 (MINUS_EXPR
, type
, toffset1
, toffset2
);
16653 if (!cst_and_fits_in_hwi (tdiff
))
16656 *diff
= int_cst_value (tdiff
);
16658 else if (toffset1
|| toffset2
)
16660 /* If only one of the offsets is non-constant, the difference cannot
16667 *diff
+= (bitpos1
- bitpos2
) / BITS_PER_UNIT
;
16671 /* Simplify the floating point expression EXP when the sign of the
16672 result is not significant. Return NULL_TREE if no simplification
16676 fold_strip_sign_ops (tree exp
)
16679 location_t loc
= EXPR_LOCATION (exp
);
16681 switch (TREE_CODE (exp
))
16685 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16686 return arg0
? arg0
: TREE_OPERAND (exp
, 0);
16690 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp
))))
16692 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 0));
16693 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16694 if (arg0
!= NULL_TREE
|| arg1
!= NULL_TREE
)
16695 return fold_build2_loc (loc
, TREE_CODE (exp
), TREE_TYPE (exp
),
16696 arg0
? arg0
: TREE_OPERAND (exp
, 0),
16697 arg1
? arg1
: TREE_OPERAND (exp
, 1));
16700 case COMPOUND_EXPR
:
16701 arg0
= TREE_OPERAND (exp
, 0);
16702 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16704 return fold_build2_loc (loc
, COMPOUND_EXPR
, TREE_TYPE (exp
), arg0
, arg1
);
16708 arg0
= fold_strip_sign_ops (TREE_OPERAND (exp
, 1));
16709 arg1
= fold_strip_sign_ops (TREE_OPERAND (exp
, 2));
16711 return fold_build3_loc (loc
,
16712 COND_EXPR
, TREE_TYPE (exp
), TREE_OPERAND (exp
, 0),
16713 arg0
? arg0
: TREE_OPERAND (exp
, 1),
16714 arg1
? arg1
: TREE_OPERAND (exp
, 2));
16719 const enum built_in_function fcode
= builtin_mathfn_code (exp
);
16722 CASE_FLT_FN (BUILT_IN_COPYSIGN
):
16723 /* Strip copysign function call, return the 1st argument. */
16724 arg0
= CALL_EXPR_ARG (exp
, 0);
16725 arg1
= CALL_EXPR_ARG (exp
, 1);
16726 return omit_one_operand_loc (loc
, TREE_TYPE (exp
), arg0
, arg1
);
16729 /* Strip sign ops from the argument of "odd" math functions. */
16730 if (negate_mathfn_p (fcode
))
16732 arg0
= fold_strip_sign_ops (CALL_EXPR_ARG (exp
, 0));
16734 return build_call_expr_loc (loc
, get_callee_fndecl (exp
), 1, arg0
);