2014-04-15 Richard Biener <rguenther@suse.de>
[official-gcc.git] / gcc / fold-const.c
blob5c2bf256c2a9bee5607b96705ef25e3d1aca392b
1 /* Fold a constant sub-tree into a single node for C-compiler
2 Copyright (C) 1987-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /*@@ This file should be rewritten to use an arbitrary precision
21 @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
22 @@ Perhaps the routines could also be used for bc/dc, and made a lib.
23 @@ The routines that translate from the ap rep should
24 @@ warn if precision et. al. is lost.
25 @@ This would also make life easier when this technology is used
26 @@ for cross-compilers. */
28 /* The entry points in this file are fold, size_int_wide and size_binop.
30 fold takes a tree as argument and returns a simplified tree.
32 size_binop takes a tree code for an arithmetic operation
33 and two operands that are trees, and produces a tree for the
34 result, assuming the type comes from `sizetype'.
36 size_int takes an integer value, and creates a tree constant
37 with type from `sizetype'.
39 Note: Since the folders get called on non-gimple code as well as
40 gimple code, we need to handle GIMPLE tuples as well as their
41 corresponding tree equivalents. */
43 #include "config.h"
44 #include "system.h"
45 #include "coretypes.h"
46 #include "tm.h"
47 #include "flags.h"
48 #include "tree.h"
49 #include "stor-layout.h"
50 #include "calls.h"
51 #include "tree-iterator.h"
52 #include "realmpfr.h"
53 #include "rtl.h"
54 #include "expr.h"
55 #include "tm_p.h"
56 #include "target.h"
57 #include "diagnostic-core.h"
58 #include "intl.h"
59 #include "langhooks.h"
60 #include "md5.h"
61 #include "basic-block.h"
62 #include "tree-ssa-alias.h"
63 #include "internal-fn.h"
64 #include "tree-eh.h"
65 #include "gimple-expr.h"
66 #include "is-a.h"
67 #include "gimple.h"
68 #include "gimplify.h"
69 #include "tree-dfa.h"
70 #include "hash-table.h" /* Required for ENABLE_FOLD_CHECKING. */
72 /* Nonzero if we are folding constants inside an initializer; zero
73 otherwise. */
74 int folding_initializer = 0;
76 /* The following constants represent a bit based encoding of GCC's
77 comparison operators. This encoding simplifies transformations
78 on relational comparison operators, such as AND and OR. */
79 enum comparison_code {
80 COMPCODE_FALSE = 0,
81 COMPCODE_LT = 1,
82 COMPCODE_EQ = 2,
83 COMPCODE_LE = 3,
84 COMPCODE_GT = 4,
85 COMPCODE_LTGT = 5,
86 COMPCODE_GE = 6,
87 COMPCODE_ORD = 7,
88 COMPCODE_UNORD = 8,
89 COMPCODE_UNLT = 9,
90 COMPCODE_UNEQ = 10,
91 COMPCODE_UNLE = 11,
92 COMPCODE_UNGT = 12,
93 COMPCODE_NE = 13,
94 COMPCODE_UNGE = 14,
95 COMPCODE_TRUE = 15
98 static bool negate_mathfn_p (enum built_in_function);
99 static bool negate_expr_p (tree);
100 static tree negate_expr (tree);
101 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
102 static tree associate_trees (location_t, tree, tree, enum tree_code, tree);
103 static tree const_binop (enum tree_code, tree, tree);
104 static enum comparison_code comparison_to_compcode (enum tree_code);
105 static enum tree_code compcode_to_comparison (enum comparison_code);
106 static int operand_equal_for_comparison_p (tree, tree, tree);
107 static int twoval_comparison_p (tree, tree *, tree *, int *);
108 static tree eval_subst (location_t, tree, tree, tree, tree, tree);
109 static tree pedantic_omit_one_operand_loc (location_t, tree, tree, tree);
110 static tree distribute_bit_expr (location_t, enum tree_code, tree, tree, tree);
111 static tree make_bit_field_ref (location_t, tree, tree,
112 HOST_WIDE_INT, HOST_WIDE_INT, int);
113 static tree optimize_bit_field_compare (location_t, enum tree_code,
114 tree, tree, tree);
115 static tree decode_field_reference (location_t, tree, HOST_WIDE_INT *,
116 HOST_WIDE_INT *,
117 enum machine_mode *, int *, int *,
118 tree *, tree *);
119 static int all_ones_mask_p (const_tree, int);
120 static tree sign_bit_p (tree, const_tree);
121 static int simple_operand_p (const_tree);
122 static bool simple_operand_p_2 (tree);
123 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
124 static tree range_predecessor (tree);
125 static tree range_successor (tree);
126 static tree fold_range_test (location_t, enum tree_code, tree, tree, tree);
127 static tree fold_cond_expr_with_comparison (location_t, tree, tree, tree, tree);
128 static tree unextend (tree, int, int, tree);
129 static tree optimize_minmax_comparison (location_t, enum tree_code,
130 tree, tree, tree);
131 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
132 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
133 static tree fold_binary_op_with_conditional_arg (location_t,
134 enum tree_code, tree,
135 tree, tree,
136 tree, tree, int);
137 static tree fold_mathfn_compare (location_t,
138 enum built_in_function, enum tree_code,
139 tree, tree, tree);
140 static tree fold_inf_compare (location_t, enum tree_code, tree, tree, tree);
141 static tree fold_div_compare (location_t, enum tree_code, tree, tree, tree);
142 static bool reorder_operands_p (const_tree, const_tree);
143 static tree fold_negate_const (tree, tree);
144 static tree fold_not_const (const_tree, tree);
145 static tree fold_relational_const (enum tree_code, tree, tree, tree);
146 static tree fold_convert_const (enum tree_code, tree, tree);
148 /* Return EXPR_LOCATION of T if it is not UNKNOWN_LOCATION.
149 Otherwise, return LOC. */
151 static location_t
152 expr_location_or (tree t, location_t loc)
154 location_t tloc = EXPR_LOCATION (t);
155 return tloc == UNKNOWN_LOCATION ? loc : tloc;
158 /* Similar to protected_set_expr_location, but never modify x in place,
159 if location can and needs to be set, unshare it. */
161 static inline tree
162 protected_set_expr_location_unshare (tree x, location_t loc)
164 if (CAN_HAVE_LOCATION_P (x)
165 && EXPR_LOCATION (x) != loc
166 && !(TREE_CODE (x) == SAVE_EXPR
167 || TREE_CODE (x) == TARGET_EXPR
168 || TREE_CODE (x) == BIND_EXPR))
170 x = copy_node (x);
171 SET_EXPR_LOCATION (x, loc);
173 return x;
176 /* If ARG2 divides ARG1 with zero remainder, carries out the division
177 of type CODE and returns the quotient.
178 Otherwise returns NULL_TREE. */
180 tree
181 div_if_zero_remainder (enum tree_code code, const_tree arg1, const_tree arg2)
183 double_int quo, rem;
184 int uns;
186 /* The sign of the division is according to operand two, that
187 does the correct thing for POINTER_PLUS_EXPR where we want
188 a signed division. */
189 uns = TYPE_UNSIGNED (TREE_TYPE (arg2));
191 quo = tree_to_double_int (arg1).divmod (tree_to_double_int (arg2),
192 uns, code, &rem);
194 if (rem.is_zero ())
195 return build_int_cst_wide (TREE_TYPE (arg1), quo.low, quo.high);
197 return NULL_TREE;
200 /* This is nonzero if we should defer warnings about undefined
201 overflow. This facility exists because these warnings are a
202 special case. The code to estimate loop iterations does not want
203 to issue any warnings, since it works with expressions which do not
204 occur in user code. Various bits of cleanup code call fold(), but
205 only use the result if it has certain characteristics (e.g., is a
206 constant); that code only wants to issue a warning if the result is
207 used. */
209 static int fold_deferring_overflow_warnings;
211 /* If a warning about undefined overflow is deferred, this is the
212 warning. Note that this may cause us to turn two warnings into
213 one, but that is fine since it is sufficient to only give one
214 warning per expression. */
216 static const char* fold_deferred_overflow_warning;
218 /* If a warning about undefined overflow is deferred, this is the
219 level at which the warning should be emitted. */
221 static enum warn_strict_overflow_code fold_deferred_overflow_code;
223 /* Start deferring overflow warnings. We could use a stack here to
224 permit nested calls, but at present it is not necessary. */
226 void
227 fold_defer_overflow_warnings (void)
229 ++fold_deferring_overflow_warnings;
232 /* Stop deferring overflow warnings. If there is a pending warning,
233 and ISSUE is true, then issue the warning if appropriate. STMT is
234 the statement with which the warning should be associated (used for
235 location information); STMT may be NULL. CODE is the level of the
236 warning--a warn_strict_overflow_code value. This function will use
237 the smaller of CODE and the deferred code when deciding whether to
238 issue the warning. CODE may be zero to mean to always use the
239 deferred code. */
241 void
242 fold_undefer_overflow_warnings (bool issue, const_gimple stmt, int code)
244 const char *warnmsg;
245 location_t locus;
247 gcc_assert (fold_deferring_overflow_warnings > 0);
248 --fold_deferring_overflow_warnings;
249 if (fold_deferring_overflow_warnings > 0)
251 if (fold_deferred_overflow_warning != NULL
252 && code != 0
253 && code < (int) fold_deferred_overflow_code)
254 fold_deferred_overflow_code = (enum warn_strict_overflow_code) code;
255 return;
258 warnmsg = fold_deferred_overflow_warning;
259 fold_deferred_overflow_warning = NULL;
261 if (!issue || warnmsg == NULL)
262 return;
264 if (gimple_no_warning_p (stmt))
265 return;
267 /* Use the smallest code level when deciding to issue the
268 warning. */
269 if (code == 0 || code > (int) fold_deferred_overflow_code)
270 code = fold_deferred_overflow_code;
272 if (!issue_strict_overflow_warning (code))
273 return;
275 if (stmt == NULL)
276 locus = input_location;
277 else
278 locus = gimple_location (stmt);
279 warning_at (locus, OPT_Wstrict_overflow, "%s", warnmsg);
282 /* Stop deferring overflow warnings, ignoring any deferred
283 warnings. */
285 void
286 fold_undefer_and_ignore_overflow_warnings (void)
288 fold_undefer_overflow_warnings (false, NULL, 0);
291 /* Whether we are deferring overflow warnings. */
293 bool
294 fold_deferring_overflow_warnings_p (void)
296 return fold_deferring_overflow_warnings > 0;
299 /* This is called when we fold something based on the fact that signed
300 overflow is undefined. */
302 static void
303 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
305 if (fold_deferring_overflow_warnings > 0)
307 if (fold_deferred_overflow_warning == NULL
308 || wc < fold_deferred_overflow_code)
310 fold_deferred_overflow_warning = gmsgid;
311 fold_deferred_overflow_code = wc;
314 else if (issue_strict_overflow_warning (wc))
315 warning (OPT_Wstrict_overflow, gmsgid);
318 /* Return true if the built-in mathematical function specified by CODE
319 is odd, i.e. -f(x) == f(-x). */
321 static bool
322 negate_mathfn_p (enum built_in_function code)
324 switch (code)
326 CASE_FLT_FN (BUILT_IN_ASIN):
327 CASE_FLT_FN (BUILT_IN_ASINH):
328 CASE_FLT_FN (BUILT_IN_ATAN):
329 CASE_FLT_FN (BUILT_IN_ATANH):
330 CASE_FLT_FN (BUILT_IN_CASIN):
331 CASE_FLT_FN (BUILT_IN_CASINH):
332 CASE_FLT_FN (BUILT_IN_CATAN):
333 CASE_FLT_FN (BUILT_IN_CATANH):
334 CASE_FLT_FN (BUILT_IN_CBRT):
335 CASE_FLT_FN (BUILT_IN_CPROJ):
336 CASE_FLT_FN (BUILT_IN_CSIN):
337 CASE_FLT_FN (BUILT_IN_CSINH):
338 CASE_FLT_FN (BUILT_IN_CTAN):
339 CASE_FLT_FN (BUILT_IN_CTANH):
340 CASE_FLT_FN (BUILT_IN_ERF):
341 CASE_FLT_FN (BUILT_IN_LLROUND):
342 CASE_FLT_FN (BUILT_IN_LROUND):
343 CASE_FLT_FN (BUILT_IN_ROUND):
344 CASE_FLT_FN (BUILT_IN_SIN):
345 CASE_FLT_FN (BUILT_IN_SINH):
346 CASE_FLT_FN (BUILT_IN_TAN):
347 CASE_FLT_FN (BUILT_IN_TANH):
348 CASE_FLT_FN (BUILT_IN_TRUNC):
349 return true;
351 CASE_FLT_FN (BUILT_IN_LLRINT):
352 CASE_FLT_FN (BUILT_IN_LRINT):
353 CASE_FLT_FN (BUILT_IN_NEARBYINT):
354 CASE_FLT_FN (BUILT_IN_RINT):
355 return !flag_rounding_math;
357 default:
358 break;
360 return false;
363 /* Check whether we may negate an integer constant T without causing
364 overflow. */
366 bool
367 may_negate_without_overflow_p (const_tree t)
369 unsigned HOST_WIDE_INT val;
370 unsigned int prec;
371 tree type;
373 gcc_assert (TREE_CODE (t) == INTEGER_CST);
375 type = TREE_TYPE (t);
376 if (TYPE_UNSIGNED (type))
377 return false;
379 prec = TYPE_PRECISION (type);
380 if (prec > HOST_BITS_PER_WIDE_INT)
382 if (TREE_INT_CST_LOW (t) != 0)
383 return true;
384 prec -= HOST_BITS_PER_WIDE_INT;
385 val = TREE_INT_CST_HIGH (t);
387 else
388 val = TREE_INT_CST_LOW (t);
389 if (prec < HOST_BITS_PER_WIDE_INT)
390 val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
391 return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
394 /* Determine whether an expression T can be cheaply negated using
395 the function negate_expr without introducing undefined overflow. */
397 static bool
398 negate_expr_p (tree t)
400 tree type;
402 if (t == 0)
403 return false;
405 type = TREE_TYPE (t);
407 STRIP_SIGN_NOPS (t);
408 switch (TREE_CODE (t))
410 case INTEGER_CST:
411 if (TYPE_OVERFLOW_WRAPS (type))
412 return true;
414 /* Check that -CST will not overflow type. */
415 return may_negate_without_overflow_p (t);
416 case BIT_NOT_EXPR:
417 return (INTEGRAL_TYPE_P (type)
418 && TYPE_OVERFLOW_WRAPS (type));
420 case FIXED_CST:
421 case NEGATE_EXPR:
422 return true;
424 case REAL_CST:
425 /* We want to canonicalize to positive real constants. Pretend
426 that only negative ones can be easily negated. */
427 return REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
429 case COMPLEX_CST:
430 return negate_expr_p (TREE_REALPART (t))
431 && negate_expr_p (TREE_IMAGPART (t));
433 case VECTOR_CST:
435 if (FLOAT_TYPE_P (TREE_TYPE (type)) || TYPE_OVERFLOW_WRAPS (type))
436 return true;
438 int count = TYPE_VECTOR_SUBPARTS (type), i;
440 for (i = 0; i < count; i++)
441 if (!negate_expr_p (VECTOR_CST_ELT (t, i)))
442 return false;
444 return true;
447 case COMPLEX_EXPR:
448 return negate_expr_p (TREE_OPERAND (t, 0))
449 && negate_expr_p (TREE_OPERAND (t, 1));
451 case CONJ_EXPR:
452 return negate_expr_p (TREE_OPERAND (t, 0));
454 case PLUS_EXPR:
455 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
456 || HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
457 return false;
458 /* -(A + B) -> (-B) - A. */
459 if (negate_expr_p (TREE_OPERAND (t, 1))
460 && reorder_operands_p (TREE_OPERAND (t, 0),
461 TREE_OPERAND (t, 1)))
462 return true;
463 /* -(A + B) -> (-A) - B. */
464 return negate_expr_p (TREE_OPERAND (t, 0));
466 case MINUS_EXPR:
467 /* We can't turn -(A-B) into B-A when we honor signed zeros. */
468 return !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
469 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
470 && reorder_operands_p (TREE_OPERAND (t, 0),
471 TREE_OPERAND (t, 1));
473 case MULT_EXPR:
474 if (TYPE_UNSIGNED (TREE_TYPE (t)))
475 break;
477 /* Fall through. */
479 case RDIV_EXPR:
480 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
481 return negate_expr_p (TREE_OPERAND (t, 1))
482 || negate_expr_p (TREE_OPERAND (t, 0));
483 break;
485 case TRUNC_DIV_EXPR:
486 case ROUND_DIV_EXPR:
487 case EXACT_DIV_EXPR:
488 /* In general we can't negate A / B, because if A is INT_MIN and
489 B is 1, we may turn this into INT_MIN / -1 which is undefined
490 and actually traps on some architectures. But if overflow is
491 undefined, we can negate, because - (INT_MIN / 1) is an
492 overflow. */
493 if (INTEGRAL_TYPE_P (TREE_TYPE (t)))
495 if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
496 break;
497 /* If overflow is undefined then we have to be careful because
498 we ask whether it's ok to associate the negate with the
499 division which is not ok for example for
500 -((a - b) / c) where (-(a - b)) / c may invoke undefined
501 overflow because of negating INT_MIN. So do not use
502 negate_expr_p here but open-code the two important cases. */
503 if (TREE_CODE (TREE_OPERAND (t, 0)) == NEGATE_EXPR
504 || (TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST
505 && may_negate_without_overflow_p (TREE_OPERAND (t, 0))))
506 return true;
508 else if (negate_expr_p (TREE_OPERAND (t, 0)))
509 return true;
510 return negate_expr_p (TREE_OPERAND (t, 1));
512 case NOP_EXPR:
513 /* Negate -((double)float) as (double)(-float). */
514 if (TREE_CODE (type) == REAL_TYPE)
516 tree tem = strip_float_extensions (t);
517 if (tem != t)
518 return negate_expr_p (tem);
520 break;
522 case CALL_EXPR:
523 /* Negate -f(x) as f(-x). */
524 if (negate_mathfn_p (builtin_mathfn_code (t)))
525 return negate_expr_p (CALL_EXPR_ARG (t, 0));
526 break;
528 case RSHIFT_EXPR:
529 /* Optimize -((int)x >> 31) into (unsigned)x >> 31. */
530 if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
532 tree op1 = TREE_OPERAND (t, 1);
533 if (TREE_INT_CST_HIGH (op1) == 0
534 && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
535 == TREE_INT_CST_LOW (op1))
536 return true;
538 break;
540 default:
541 break;
543 return false;
546 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
547 simplification is possible.
548 If negate_expr_p would return true for T, NULL_TREE will never be
549 returned. */
551 static tree
552 fold_negate_expr (location_t loc, tree t)
554 tree type = TREE_TYPE (t);
555 tree tem;
557 switch (TREE_CODE (t))
559 /* Convert - (~A) to A + 1. */
560 case BIT_NOT_EXPR:
561 if (INTEGRAL_TYPE_P (type))
562 return fold_build2_loc (loc, PLUS_EXPR, type, TREE_OPERAND (t, 0),
563 build_one_cst (type));
564 break;
566 case INTEGER_CST:
567 tem = fold_negate_const (t, type);
568 if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
569 || !TYPE_OVERFLOW_TRAPS (type))
570 return tem;
571 break;
573 case REAL_CST:
574 tem = fold_negate_const (t, type);
575 /* Two's complement FP formats, such as c4x, may overflow. */
576 if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
577 return tem;
578 break;
580 case FIXED_CST:
581 tem = fold_negate_const (t, type);
582 return tem;
584 case COMPLEX_CST:
586 tree rpart = negate_expr (TREE_REALPART (t));
587 tree ipart = negate_expr (TREE_IMAGPART (t));
589 if ((TREE_CODE (rpart) == REAL_CST
590 && TREE_CODE (ipart) == REAL_CST)
591 || (TREE_CODE (rpart) == INTEGER_CST
592 && TREE_CODE (ipart) == INTEGER_CST))
593 return build_complex (type, rpart, ipart);
595 break;
597 case VECTOR_CST:
599 int count = TYPE_VECTOR_SUBPARTS (type), i;
600 tree *elts = XALLOCAVEC (tree, count);
602 for (i = 0; i < count; i++)
604 elts[i] = fold_negate_expr (loc, VECTOR_CST_ELT (t, i));
605 if (elts[i] == NULL_TREE)
606 return NULL_TREE;
609 return build_vector (type, elts);
612 case COMPLEX_EXPR:
613 if (negate_expr_p (t))
614 return fold_build2_loc (loc, COMPLEX_EXPR, type,
615 fold_negate_expr (loc, TREE_OPERAND (t, 0)),
616 fold_negate_expr (loc, TREE_OPERAND (t, 1)));
617 break;
619 case CONJ_EXPR:
620 if (negate_expr_p (t))
621 return fold_build1_loc (loc, CONJ_EXPR, type,
622 fold_negate_expr (loc, TREE_OPERAND (t, 0)));
623 break;
625 case NEGATE_EXPR:
626 return TREE_OPERAND (t, 0);
628 case PLUS_EXPR:
629 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
630 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
632 /* -(A + B) -> (-B) - A. */
633 if (negate_expr_p (TREE_OPERAND (t, 1))
634 && reorder_operands_p (TREE_OPERAND (t, 0),
635 TREE_OPERAND (t, 1)))
637 tem = negate_expr (TREE_OPERAND (t, 1));
638 return fold_build2_loc (loc, MINUS_EXPR, type,
639 tem, TREE_OPERAND (t, 0));
642 /* -(A + B) -> (-A) - B. */
643 if (negate_expr_p (TREE_OPERAND (t, 0)))
645 tem = negate_expr (TREE_OPERAND (t, 0));
646 return fold_build2_loc (loc, MINUS_EXPR, type,
647 tem, TREE_OPERAND (t, 1));
650 break;
652 case MINUS_EXPR:
653 /* - (A - B) -> B - A */
654 if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
655 && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
656 && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
657 return fold_build2_loc (loc, MINUS_EXPR, type,
658 TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
659 break;
661 case MULT_EXPR:
662 if (TYPE_UNSIGNED (type))
663 break;
665 /* Fall through. */
667 case RDIV_EXPR:
668 if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
670 tem = TREE_OPERAND (t, 1);
671 if (negate_expr_p (tem))
672 return fold_build2_loc (loc, TREE_CODE (t), type,
673 TREE_OPERAND (t, 0), negate_expr (tem));
674 tem = TREE_OPERAND (t, 0);
675 if (negate_expr_p (tem))
676 return fold_build2_loc (loc, TREE_CODE (t), type,
677 negate_expr (tem), TREE_OPERAND (t, 1));
679 break;
681 case TRUNC_DIV_EXPR:
682 case ROUND_DIV_EXPR:
683 case EXACT_DIV_EXPR:
684 /* In general we can't negate A / B, because if A is INT_MIN and
685 B is 1, we may turn this into INT_MIN / -1 which is undefined
686 and actually traps on some architectures. But if overflow is
687 undefined, we can negate, because - (INT_MIN / 1) is an
688 overflow. */
689 if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
691 const char * const warnmsg = G_("assuming signed overflow does not "
692 "occur when negating a division");
693 tem = TREE_OPERAND (t, 1);
694 if (negate_expr_p (tem))
696 if (INTEGRAL_TYPE_P (type)
697 && (TREE_CODE (tem) != INTEGER_CST
698 || integer_onep (tem)))
699 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
700 return fold_build2_loc (loc, TREE_CODE (t), type,
701 TREE_OPERAND (t, 0), negate_expr (tem));
703 /* If overflow is undefined then we have to be careful because
704 we ask whether it's ok to associate the negate with the
705 division which is not ok for example for
706 -((a - b) / c) where (-(a - b)) / c may invoke undefined
707 overflow because of negating INT_MIN. So do not use
708 negate_expr_p here but open-code the two important cases. */
709 tem = TREE_OPERAND (t, 0);
710 if ((INTEGRAL_TYPE_P (type)
711 && (TREE_CODE (tem) == NEGATE_EXPR
712 || (TREE_CODE (tem) == INTEGER_CST
713 && may_negate_without_overflow_p (tem))))
714 || !INTEGRAL_TYPE_P (type))
715 return fold_build2_loc (loc, TREE_CODE (t), type,
716 negate_expr (tem), TREE_OPERAND (t, 1));
718 break;
720 case NOP_EXPR:
721 /* Convert -((double)float) into (double)(-float). */
722 if (TREE_CODE (type) == REAL_TYPE)
724 tem = strip_float_extensions (t);
725 if (tem != t && negate_expr_p (tem))
726 return fold_convert_loc (loc, type, negate_expr (tem));
728 break;
730 case CALL_EXPR:
731 /* Negate -f(x) as f(-x). */
732 if (negate_mathfn_p (builtin_mathfn_code (t))
733 && negate_expr_p (CALL_EXPR_ARG (t, 0)))
735 tree fndecl, arg;
737 fndecl = get_callee_fndecl (t);
738 arg = negate_expr (CALL_EXPR_ARG (t, 0));
739 return build_call_expr_loc (loc, fndecl, 1, arg);
741 break;
743 case RSHIFT_EXPR:
744 /* Optimize -((int)x >> 31) into (unsigned)x >> 31. */
745 if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
747 tree op1 = TREE_OPERAND (t, 1);
748 if (TREE_INT_CST_HIGH (op1) == 0
749 && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
750 == TREE_INT_CST_LOW (op1))
752 tree ntype = TYPE_UNSIGNED (type)
753 ? signed_type_for (type)
754 : unsigned_type_for (type);
755 tree temp = fold_convert_loc (loc, ntype, TREE_OPERAND (t, 0));
756 temp = fold_build2_loc (loc, RSHIFT_EXPR, ntype, temp, op1);
757 return fold_convert_loc (loc, type, temp);
760 break;
762 default:
763 break;
766 return NULL_TREE;
769 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
770 negated in a simpler way. Also allow for T to be NULL_TREE, in which case
771 return NULL_TREE. */
773 static tree
774 negate_expr (tree t)
776 tree type, tem;
777 location_t loc;
779 if (t == NULL_TREE)
780 return NULL_TREE;
782 loc = EXPR_LOCATION (t);
783 type = TREE_TYPE (t);
784 STRIP_SIGN_NOPS (t);
786 tem = fold_negate_expr (loc, t);
787 if (!tem)
788 tem = build1_loc (loc, NEGATE_EXPR, TREE_TYPE (t), t);
789 return fold_convert_loc (loc, type, tem);
792 /* Split a tree IN into a constant, literal and variable parts that could be
793 combined with CODE to make IN. "constant" means an expression with
794 TREE_CONSTANT but that isn't an actual constant. CODE must be a
795 commutative arithmetic operation. Store the constant part into *CONP,
796 the literal in *LITP and return the variable part. If a part isn't
797 present, set it to null. If the tree does not decompose in this way,
798 return the entire tree as the variable part and the other parts as null.
800 If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR. In that
801 case, we negate an operand that was subtracted. Except if it is a
802 literal for which we use *MINUS_LITP instead.
804 If NEGATE_P is true, we are negating all of IN, again except a literal
805 for which we use *MINUS_LITP instead.
807 If IN is itself a literal or constant, return it as appropriate.
809 Note that we do not guarantee that any of the three values will be the
810 same type as IN, but they will have the same signedness and mode. */
812 static tree
813 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
814 tree *minus_litp, int negate_p)
816 tree var = 0;
818 *conp = 0;
819 *litp = 0;
820 *minus_litp = 0;
822 /* Strip any conversions that don't change the machine mode or signedness. */
823 STRIP_SIGN_NOPS (in);
825 if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
826 || TREE_CODE (in) == FIXED_CST)
827 *litp = in;
828 else if (TREE_CODE (in) == code
829 || ((! FLOAT_TYPE_P (TREE_TYPE (in)) || flag_associative_math)
830 && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
831 /* We can associate addition and subtraction together (even
832 though the C standard doesn't say so) for integers because
833 the value is not affected. For reals, the value might be
834 affected, so we can't. */
835 && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
836 || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
838 tree op0 = TREE_OPERAND (in, 0);
839 tree op1 = TREE_OPERAND (in, 1);
840 int neg1_p = TREE_CODE (in) == MINUS_EXPR;
841 int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
843 /* First see if either of the operands is a literal, then a constant. */
844 if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
845 || TREE_CODE (op0) == FIXED_CST)
846 *litp = op0, op0 = 0;
847 else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
848 || TREE_CODE (op1) == FIXED_CST)
849 *litp = op1, neg_litp_p = neg1_p, op1 = 0;
851 if (op0 != 0 && TREE_CONSTANT (op0))
852 *conp = op0, op0 = 0;
853 else if (op1 != 0 && TREE_CONSTANT (op1))
854 *conp = op1, neg_conp_p = neg1_p, op1 = 0;
856 /* If we haven't dealt with either operand, this is not a case we can
857 decompose. Otherwise, VAR is either of the ones remaining, if any. */
858 if (op0 != 0 && op1 != 0)
859 var = in;
860 else if (op0 != 0)
861 var = op0;
862 else
863 var = op1, neg_var_p = neg1_p;
865 /* Now do any needed negations. */
866 if (neg_litp_p)
867 *minus_litp = *litp, *litp = 0;
868 if (neg_conp_p)
869 *conp = negate_expr (*conp);
870 if (neg_var_p)
871 var = negate_expr (var);
873 else if (TREE_CODE (in) == BIT_NOT_EXPR
874 && code == PLUS_EXPR)
876 /* -X - 1 is folded to ~X, undo that here. */
877 *minus_litp = build_one_cst (TREE_TYPE (in));
878 var = negate_expr (TREE_OPERAND (in, 0));
880 else if (TREE_CONSTANT (in))
881 *conp = in;
882 else
883 var = in;
885 if (negate_p)
887 if (*litp)
888 *minus_litp = *litp, *litp = 0;
889 else if (*minus_litp)
890 *litp = *minus_litp, *minus_litp = 0;
891 *conp = negate_expr (*conp);
892 var = negate_expr (var);
895 return var;
898 /* Re-associate trees split by the above function. T1 and T2 are
899 either expressions to associate or null. Return the new
900 expression, if any. LOC is the location of the new expression. If
901 we build an operation, do it in TYPE and with CODE. */
903 static tree
904 associate_trees (location_t loc, tree t1, tree t2, enum tree_code code, tree type)
906 if (t1 == 0)
907 return t2;
908 else if (t2 == 0)
909 return t1;
911 /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
912 try to fold this since we will have infinite recursion. But do
913 deal with any NEGATE_EXPRs. */
914 if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
915 || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
917 if (code == PLUS_EXPR)
919 if (TREE_CODE (t1) == NEGATE_EXPR)
920 return build2_loc (loc, MINUS_EXPR, type,
921 fold_convert_loc (loc, type, t2),
922 fold_convert_loc (loc, type,
923 TREE_OPERAND (t1, 0)));
924 else if (TREE_CODE (t2) == NEGATE_EXPR)
925 return build2_loc (loc, MINUS_EXPR, type,
926 fold_convert_loc (loc, type, t1),
927 fold_convert_loc (loc, type,
928 TREE_OPERAND (t2, 0)));
929 else if (integer_zerop (t2))
930 return fold_convert_loc (loc, type, t1);
932 else if (code == MINUS_EXPR)
934 if (integer_zerop (t2))
935 return fold_convert_loc (loc, type, t1);
938 return build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
939 fold_convert_loc (loc, type, t2));
942 return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, t1),
943 fold_convert_loc (loc, type, t2));
946 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
947 for use in int_const_binop, size_binop and size_diffop. */
949 static bool
950 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
952 if (!INTEGRAL_TYPE_P (type1) && !POINTER_TYPE_P (type1))
953 return false;
954 if (!INTEGRAL_TYPE_P (type2) && !POINTER_TYPE_P (type2))
955 return false;
957 switch (code)
959 case LSHIFT_EXPR:
960 case RSHIFT_EXPR:
961 case LROTATE_EXPR:
962 case RROTATE_EXPR:
963 return true;
965 default:
966 break;
969 return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
970 && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
971 && TYPE_MODE (type1) == TYPE_MODE (type2);
975 /* Combine two integer constants ARG1 and ARG2 under operation CODE
976 to produce a new constant. Return NULL_TREE if we don't know how
977 to evaluate CODE at compile-time. */
979 static tree
980 int_const_binop_1 (enum tree_code code, const_tree arg1, const_tree arg2,
981 int overflowable)
983 double_int op1, op2, res, tmp;
984 tree t;
985 tree type = TREE_TYPE (arg1);
986 bool uns = TYPE_UNSIGNED (type);
987 bool overflow = false;
989 op1 = tree_to_double_int (arg1);
990 op2 = tree_to_double_int (arg2);
992 switch (code)
994 case BIT_IOR_EXPR:
995 res = op1 | op2;
996 break;
998 case BIT_XOR_EXPR:
999 res = op1 ^ op2;
1000 break;
1002 case BIT_AND_EXPR:
1003 res = op1 & op2;
1004 break;
1006 case RSHIFT_EXPR:
1007 res = op1.rshift (op2.to_shwi (), TYPE_PRECISION (type), !uns);
1008 break;
1010 case LSHIFT_EXPR:
1011 /* It's unclear from the C standard whether shifts can overflow.
1012 The following code ignores overflow; perhaps a C standard
1013 interpretation ruling is needed. */
1014 res = op1.lshift (op2.to_shwi (), TYPE_PRECISION (type), !uns);
1015 break;
1017 case RROTATE_EXPR:
1018 res = op1.rrotate (op2.to_shwi (), TYPE_PRECISION (type));
1019 break;
1021 case LROTATE_EXPR:
1022 res = op1.lrotate (op2.to_shwi (), TYPE_PRECISION (type));
1023 break;
1025 case PLUS_EXPR:
1026 res = op1.add_with_sign (op2, false, &overflow);
1027 break;
1029 case MINUS_EXPR:
1030 res = op1.sub_with_overflow (op2, &overflow);
1031 break;
1033 case MULT_EXPR:
1034 res = op1.mul_with_sign (op2, false, &overflow);
1035 break;
1037 case MULT_HIGHPART_EXPR:
1038 if (TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT)
1040 bool dummy_overflow;
1041 if (TYPE_PRECISION (type) != 2 * HOST_BITS_PER_WIDE_INT)
1042 return NULL_TREE;
1043 op1.wide_mul_with_sign (op2, uns, &res, &dummy_overflow);
1045 else
1047 bool dummy_overflow;
1048 /* MULT_HIGHPART_EXPR can't ever oveflow, as the multiplication
1049 is performed in twice the precision of arguments. */
1050 tmp = op1.mul_with_sign (op2, false, &dummy_overflow);
1051 res = tmp.rshift (TYPE_PRECISION (type),
1052 2 * TYPE_PRECISION (type), !uns);
1054 break;
1056 case TRUNC_DIV_EXPR:
1057 case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1058 case EXACT_DIV_EXPR:
1059 /* This is a shortcut for a common special case. */
1060 if (op2.high == 0 && (HOST_WIDE_INT) op2.low > 0
1061 && !TREE_OVERFLOW (arg1)
1062 && !TREE_OVERFLOW (arg2)
1063 && op1.high == 0 && (HOST_WIDE_INT) op1.low >= 0)
1065 if (code == CEIL_DIV_EXPR)
1066 op1.low += op2.low - 1;
1068 res.low = op1.low / op2.low, res.high = 0;
1069 break;
1072 /* ... fall through ... */
1074 case ROUND_DIV_EXPR:
1075 if (op2.is_zero ())
1076 return NULL_TREE;
1077 if (op2.is_one ())
1079 res = op1;
1080 break;
1082 if (op1 == op2 && !op1.is_zero ())
1084 res = double_int_one;
1085 break;
1087 res = op1.divmod_with_overflow (op2, uns, code, &tmp, &overflow);
1088 break;
1090 case TRUNC_MOD_EXPR:
1091 case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1092 /* This is a shortcut for a common special case. */
1093 if (op2.high == 0 && (HOST_WIDE_INT) op2.low > 0
1094 && !TREE_OVERFLOW (arg1)
1095 && !TREE_OVERFLOW (arg2)
1096 && op1.high == 0 && (HOST_WIDE_INT) op1.low >= 0)
1098 if (code == CEIL_MOD_EXPR)
1099 op1.low += op2.low - 1;
1100 res.low = op1.low % op2.low, res.high = 0;
1101 break;
1104 /* ... fall through ... */
1106 case ROUND_MOD_EXPR:
1107 if (op2.is_zero ())
1108 return NULL_TREE;
1110 /* Check for the case the case of INT_MIN % -1 and return
1111 overflow and result = 0. The TImode case is handled properly
1112 in double-int. */
1113 if (TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT
1114 && !uns
1115 && op2.is_minus_one ()
1116 && op1.high == (HOST_WIDE_INT) -1
1117 && (HOST_WIDE_INT) op1.low
1118 == (((HOST_WIDE_INT)-1) << (TYPE_PRECISION (type) - 1)))
1120 overflow = 1;
1121 res = double_int_zero;
1123 else
1124 tmp = op1.divmod_with_overflow (op2, uns, code, &res, &overflow);
1125 break;
1127 case MIN_EXPR:
1128 res = op1.min (op2, uns);
1129 break;
1131 case MAX_EXPR:
1132 res = op1.max (op2, uns);
1133 break;
1135 default:
1136 return NULL_TREE;
1139 t = force_fit_type_double (TREE_TYPE (arg1), res, overflowable,
1140 (!uns && overflow)
1141 | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1143 return t;
1146 tree
1147 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2)
1149 return int_const_binop_1 (code, arg1, arg2, 1);
1152 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1153 constant. We assume ARG1 and ARG2 have the same data type, or at least
1154 are the same kind of constant and the same machine mode. Return zero if
1155 combining the constants is not allowed in the current operating mode. */
1157 static tree
1158 const_binop (enum tree_code code, tree arg1, tree arg2)
1160 /* Sanity check for the recursive cases. */
1161 if (!arg1 || !arg2)
1162 return NULL_TREE;
1164 STRIP_NOPS (arg1);
1165 STRIP_NOPS (arg2);
1167 if (TREE_CODE (arg1) == INTEGER_CST)
1168 return int_const_binop (code, arg1, arg2);
1170 if (TREE_CODE (arg1) == REAL_CST)
1172 enum machine_mode mode;
1173 REAL_VALUE_TYPE d1;
1174 REAL_VALUE_TYPE d2;
1175 REAL_VALUE_TYPE value;
1176 REAL_VALUE_TYPE result;
1177 bool inexact;
1178 tree t, type;
1180 /* The following codes are handled by real_arithmetic. */
1181 switch (code)
1183 case PLUS_EXPR:
1184 case MINUS_EXPR:
1185 case MULT_EXPR:
1186 case RDIV_EXPR:
1187 case MIN_EXPR:
1188 case MAX_EXPR:
1189 break;
1191 default:
1192 return NULL_TREE;
1195 d1 = TREE_REAL_CST (arg1);
1196 d2 = TREE_REAL_CST (arg2);
1198 type = TREE_TYPE (arg1);
1199 mode = TYPE_MODE (type);
1201 /* Don't perform operation if we honor signaling NaNs and
1202 either operand is a NaN. */
1203 if (HONOR_SNANS (mode)
1204 && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1205 return NULL_TREE;
1207 /* Don't perform operation if it would raise a division
1208 by zero exception. */
1209 if (code == RDIV_EXPR
1210 && REAL_VALUES_EQUAL (d2, dconst0)
1211 && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1212 return NULL_TREE;
1214 /* If either operand is a NaN, just return it. Otherwise, set up
1215 for floating-point trap; we return an overflow. */
1216 if (REAL_VALUE_ISNAN (d1))
1217 return arg1;
1218 else if (REAL_VALUE_ISNAN (d2))
1219 return arg2;
1221 inexact = real_arithmetic (&value, code, &d1, &d2);
1222 real_convert (&result, mode, &value);
1224 /* Don't constant fold this floating point operation if
1225 the result has overflowed and flag_trapping_math. */
1226 if (flag_trapping_math
1227 && MODE_HAS_INFINITIES (mode)
1228 && REAL_VALUE_ISINF (result)
1229 && !REAL_VALUE_ISINF (d1)
1230 && !REAL_VALUE_ISINF (d2))
1231 return NULL_TREE;
1233 /* Don't constant fold this floating point operation if the
1234 result may dependent upon the run-time rounding mode and
1235 flag_rounding_math is set, or if GCC's software emulation
1236 is unable to accurately represent the result. */
1237 if ((flag_rounding_math
1238 || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
1239 && (inexact || !real_identical (&result, &value)))
1240 return NULL_TREE;
1242 t = build_real (type, result);
1244 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1245 return t;
1248 if (TREE_CODE (arg1) == FIXED_CST)
1250 FIXED_VALUE_TYPE f1;
1251 FIXED_VALUE_TYPE f2;
1252 FIXED_VALUE_TYPE result;
1253 tree t, type;
1254 int sat_p;
1255 bool overflow_p;
1257 /* The following codes are handled by fixed_arithmetic. */
1258 switch (code)
1260 case PLUS_EXPR:
1261 case MINUS_EXPR:
1262 case MULT_EXPR:
1263 case TRUNC_DIV_EXPR:
1264 f2 = TREE_FIXED_CST (arg2);
1265 break;
1267 case LSHIFT_EXPR:
1268 case RSHIFT_EXPR:
1269 f2.data.high = TREE_INT_CST_HIGH (arg2);
1270 f2.data.low = TREE_INT_CST_LOW (arg2);
1271 f2.mode = SImode;
1272 break;
1274 default:
1275 return NULL_TREE;
1278 f1 = TREE_FIXED_CST (arg1);
1279 type = TREE_TYPE (arg1);
1280 sat_p = TYPE_SATURATING (type);
1281 overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1282 t = build_fixed (type, result);
1283 /* Propagate overflow flags. */
1284 if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1285 TREE_OVERFLOW (t) = 1;
1286 return t;
1289 if (TREE_CODE (arg1) == COMPLEX_CST)
1291 tree type = TREE_TYPE (arg1);
1292 tree r1 = TREE_REALPART (arg1);
1293 tree i1 = TREE_IMAGPART (arg1);
1294 tree r2 = TREE_REALPART (arg2);
1295 tree i2 = TREE_IMAGPART (arg2);
1296 tree real, imag;
1298 switch (code)
1300 case PLUS_EXPR:
1301 case MINUS_EXPR:
1302 real = const_binop (code, r1, r2);
1303 imag = const_binop (code, i1, i2);
1304 break;
1306 case MULT_EXPR:
1307 if (COMPLEX_FLOAT_TYPE_P (type))
1308 return do_mpc_arg2 (arg1, arg2, type,
1309 /* do_nonfinite= */ folding_initializer,
1310 mpc_mul);
1312 real = const_binop (MINUS_EXPR,
1313 const_binop (MULT_EXPR, r1, r2),
1314 const_binop (MULT_EXPR, i1, i2));
1315 imag = const_binop (PLUS_EXPR,
1316 const_binop (MULT_EXPR, r1, i2),
1317 const_binop (MULT_EXPR, i1, r2));
1318 break;
1320 case RDIV_EXPR:
1321 if (COMPLEX_FLOAT_TYPE_P (type))
1322 return do_mpc_arg2 (arg1, arg2, type,
1323 /* do_nonfinite= */ folding_initializer,
1324 mpc_div);
1325 /* Fallthru ... */
1326 case TRUNC_DIV_EXPR:
1327 case CEIL_DIV_EXPR:
1328 case FLOOR_DIV_EXPR:
1329 case ROUND_DIV_EXPR:
1330 if (flag_complex_method == 0)
1332 /* Keep this algorithm in sync with
1333 tree-complex.c:expand_complex_div_straight().
1335 Expand complex division to scalars, straightforward algorithm.
1336 a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
1337 t = br*br + bi*bi
1339 tree magsquared
1340 = const_binop (PLUS_EXPR,
1341 const_binop (MULT_EXPR, r2, r2),
1342 const_binop (MULT_EXPR, i2, i2));
1343 tree t1
1344 = const_binop (PLUS_EXPR,
1345 const_binop (MULT_EXPR, r1, r2),
1346 const_binop (MULT_EXPR, i1, i2));
1347 tree t2
1348 = const_binop (MINUS_EXPR,
1349 const_binop (MULT_EXPR, i1, r2),
1350 const_binop (MULT_EXPR, r1, i2));
1352 real = const_binop (code, t1, magsquared);
1353 imag = const_binop (code, t2, magsquared);
1355 else
1357 /* Keep this algorithm in sync with
1358 tree-complex.c:expand_complex_div_wide().
1360 Expand complex division to scalars, modified algorithm to minimize
1361 overflow with wide input ranges. */
1362 tree compare = fold_build2 (LT_EXPR, boolean_type_node,
1363 fold_abs_const (r2, TREE_TYPE (type)),
1364 fold_abs_const (i2, TREE_TYPE (type)));
1366 if (integer_nonzerop (compare))
1368 /* In the TRUE branch, we compute
1369 ratio = br/bi;
1370 div = (br * ratio) + bi;
1371 tr = (ar * ratio) + ai;
1372 ti = (ai * ratio) - ar;
1373 tr = tr / div;
1374 ti = ti / div; */
1375 tree ratio = const_binop (code, r2, i2);
1376 tree div = const_binop (PLUS_EXPR, i2,
1377 const_binop (MULT_EXPR, r2, ratio));
1378 real = const_binop (MULT_EXPR, r1, ratio);
1379 real = const_binop (PLUS_EXPR, real, i1);
1380 real = const_binop (code, real, div);
1382 imag = const_binop (MULT_EXPR, i1, ratio);
1383 imag = const_binop (MINUS_EXPR, imag, r1);
1384 imag = const_binop (code, imag, div);
1386 else
1388 /* In the FALSE branch, we compute
1389 ratio = d/c;
1390 divisor = (d * ratio) + c;
1391 tr = (b * ratio) + a;
1392 ti = b - (a * ratio);
1393 tr = tr / div;
1394 ti = ti / div; */
1395 tree ratio = const_binop (code, i2, r2);
1396 tree div = const_binop (PLUS_EXPR, r2,
1397 const_binop (MULT_EXPR, i2, ratio));
1399 real = const_binop (MULT_EXPR, i1, ratio);
1400 real = const_binop (PLUS_EXPR, real, r1);
1401 real = const_binop (code, real, div);
1403 imag = const_binop (MULT_EXPR, r1, ratio);
1404 imag = const_binop (MINUS_EXPR, i1, imag);
1405 imag = const_binop (code, imag, div);
1408 break;
1410 default:
1411 return NULL_TREE;
1414 if (real && imag)
1415 return build_complex (type, real, imag);
1418 if (TREE_CODE (arg1) == VECTOR_CST
1419 && TREE_CODE (arg2) == VECTOR_CST)
1421 tree type = TREE_TYPE (arg1);
1422 int count = TYPE_VECTOR_SUBPARTS (type), i;
1423 tree *elts = XALLOCAVEC (tree, count);
1425 for (i = 0; i < count; i++)
1427 tree elem1 = VECTOR_CST_ELT (arg1, i);
1428 tree elem2 = VECTOR_CST_ELT (arg2, i);
1430 elts[i] = const_binop (code, elem1, elem2);
1432 /* It is possible that const_binop cannot handle the given
1433 code and return NULL_TREE */
1434 if (elts[i] == NULL_TREE)
1435 return NULL_TREE;
1438 return build_vector (type, elts);
1441 /* Shifts allow a scalar offset for a vector. */
1442 if (TREE_CODE (arg1) == VECTOR_CST
1443 && TREE_CODE (arg2) == INTEGER_CST)
1445 tree type = TREE_TYPE (arg1);
1446 int count = TYPE_VECTOR_SUBPARTS (type), i;
1447 tree *elts = XALLOCAVEC (tree, count);
1449 if (code == VEC_LSHIFT_EXPR
1450 || code == VEC_RSHIFT_EXPR)
1452 if (!tree_fits_uhwi_p (arg2))
1453 return NULL_TREE;
1455 unsigned HOST_WIDE_INT shiftc = tree_to_uhwi (arg2);
1456 unsigned HOST_WIDE_INT outerc = tree_to_uhwi (TYPE_SIZE (type));
1457 unsigned HOST_WIDE_INT innerc
1458 = tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type)));
1459 if (shiftc >= outerc || (shiftc % innerc) != 0)
1460 return NULL_TREE;
1461 int offset = shiftc / innerc;
1462 /* The direction of VEC_[LR]SHIFT_EXPR is endian dependent.
1463 For reductions, compiler emits VEC_RSHIFT_EXPR always,
1464 for !BYTES_BIG_ENDIAN picks first vector element, but
1465 for BYTES_BIG_ENDIAN last element from the vector. */
1466 if ((code == VEC_RSHIFT_EXPR) ^ (!BYTES_BIG_ENDIAN))
1467 offset = -offset;
1468 tree zero = build_zero_cst (TREE_TYPE (type));
1469 for (i = 0; i < count; i++)
1471 if (i + offset < 0 || i + offset >= count)
1472 elts[i] = zero;
1473 else
1474 elts[i] = VECTOR_CST_ELT (arg1, i + offset);
1477 else
1478 for (i = 0; i < count; i++)
1480 tree elem1 = VECTOR_CST_ELT (arg1, i);
1482 elts[i] = const_binop (code, elem1, arg2);
1484 /* It is possible that const_binop cannot handle the given
1485 code and return NULL_TREE */
1486 if (elts[i] == NULL_TREE)
1487 return NULL_TREE;
1490 return build_vector (type, elts);
1492 return NULL_TREE;
1495 /* Create a sizetype INT_CST node with NUMBER sign extended. KIND
1496 indicates which particular sizetype to create. */
1498 tree
1499 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1501 return build_int_cst (sizetype_tab[(int) kind], number);
1504 /* Combine operands OP1 and OP2 with arithmetic operation CODE. CODE
1505 is a tree code. The type of the result is taken from the operands.
1506 Both must be equivalent integer types, ala int_binop_types_match_p.
1507 If the operands are constant, so is the result. */
1509 tree
1510 size_binop_loc (location_t loc, enum tree_code code, tree arg0, tree arg1)
1512 tree type = TREE_TYPE (arg0);
1514 if (arg0 == error_mark_node || arg1 == error_mark_node)
1515 return error_mark_node;
1517 gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
1518 TREE_TYPE (arg1)));
1520 /* Handle the special case of two integer constants faster. */
1521 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1523 /* And some specific cases even faster than that. */
1524 if (code == PLUS_EXPR)
1526 if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
1527 return arg1;
1528 if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1529 return arg0;
1531 else if (code == MINUS_EXPR)
1533 if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
1534 return arg0;
1536 else if (code == MULT_EXPR)
1538 if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
1539 return arg1;
1542 /* Handle general case of two integer constants. For sizetype
1543 constant calculations we always want to know about overflow,
1544 even in the unsigned case. */
1545 return int_const_binop_1 (code, arg0, arg1, -1);
1548 return fold_build2_loc (loc, code, type, arg0, arg1);
1551 /* Given two values, either both of sizetype or both of bitsizetype,
1552 compute the difference between the two values. Return the value
1553 in signed type corresponding to the type of the operands. */
1555 tree
1556 size_diffop_loc (location_t loc, tree arg0, tree arg1)
1558 tree type = TREE_TYPE (arg0);
1559 tree ctype;
1561 gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
1562 TREE_TYPE (arg1)));
1564 /* If the type is already signed, just do the simple thing. */
1565 if (!TYPE_UNSIGNED (type))
1566 return size_binop_loc (loc, MINUS_EXPR, arg0, arg1);
1568 if (type == sizetype)
1569 ctype = ssizetype;
1570 else if (type == bitsizetype)
1571 ctype = sbitsizetype;
1572 else
1573 ctype = signed_type_for (type);
1575 /* If either operand is not a constant, do the conversions to the signed
1576 type and subtract. The hardware will do the right thing with any
1577 overflow in the subtraction. */
1578 if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1579 return size_binop_loc (loc, MINUS_EXPR,
1580 fold_convert_loc (loc, ctype, arg0),
1581 fold_convert_loc (loc, ctype, arg1));
1583 /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1584 Otherwise, subtract the other way, convert to CTYPE (we know that can't
1585 overflow) and negate (which can't either). Special-case a result
1586 of zero while we're here. */
1587 if (tree_int_cst_equal (arg0, arg1))
1588 return build_int_cst (ctype, 0);
1589 else if (tree_int_cst_lt (arg1, arg0))
1590 return fold_convert_loc (loc, ctype,
1591 size_binop_loc (loc, MINUS_EXPR, arg0, arg1));
1592 else
1593 return size_binop_loc (loc, MINUS_EXPR, build_int_cst (ctype, 0),
1594 fold_convert_loc (loc, ctype,
1595 size_binop_loc (loc,
1596 MINUS_EXPR,
1597 arg1, arg0)));
1600 /* A subroutine of fold_convert_const handling conversions of an
1601 INTEGER_CST to another integer type. */
1603 static tree
1604 fold_convert_const_int_from_int (tree type, const_tree arg1)
1606 tree t;
1608 /* Given an integer constant, make new constant with new type,
1609 appropriately sign-extended or truncated. */
1610 t = force_fit_type_double (type, tree_to_double_int (arg1),
1611 !POINTER_TYPE_P (TREE_TYPE (arg1)),
1612 (TREE_INT_CST_HIGH (arg1) < 0
1613 && (TYPE_UNSIGNED (type)
1614 < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1615 | TREE_OVERFLOW (arg1));
1617 return t;
1620 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1621 to an integer type. */
1623 static tree
1624 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
1626 int overflow = 0;
1627 tree t;
1629 /* The following code implements the floating point to integer
1630 conversion rules required by the Java Language Specification,
1631 that IEEE NaNs are mapped to zero and values that overflow
1632 the target precision saturate, i.e. values greater than
1633 INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1634 are mapped to INT_MIN. These semantics are allowed by the
1635 C and C++ standards that simply state that the behavior of
1636 FP-to-integer conversion is unspecified upon overflow. */
1638 double_int val;
1639 REAL_VALUE_TYPE r;
1640 REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1642 switch (code)
1644 case FIX_TRUNC_EXPR:
1645 real_trunc (&r, VOIDmode, &x);
1646 break;
1648 default:
1649 gcc_unreachable ();
1652 /* If R is NaN, return zero and show we have an overflow. */
1653 if (REAL_VALUE_ISNAN (r))
1655 overflow = 1;
1656 val = double_int_zero;
1659 /* See if R is less than the lower bound or greater than the
1660 upper bound. */
1662 if (! overflow)
1664 tree lt = TYPE_MIN_VALUE (type);
1665 REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
1666 if (REAL_VALUES_LESS (r, l))
1668 overflow = 1;
1669 val = tree_to_double_int (lt);
1673 if (! overflow)
1675 tree ut = TYPE_MAX_VALUE (type);
1676 if (ut)
1678 REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
1679 if (REAL_VALUES_LESS (u, r))
1681 overflow = 1;
1682 val = tree_to_double_int (ut);
1687 if (! overflow)
1688 real_to_integer2 ((HOST_WIDE_INT *) &val.low, &val.high, &r);
1690 t = force_fit_type_double (type, val, -1, overflow | TREE_OVERFLOW (arg1));
1691 return t;
1694 /* A subroutine of fold_convert_const handling conversions of a
1695 FIXED_CST to an integer type. */
1697 static tree
1698 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
1700 tree t;
1701 double_int temp, temp_trunc;
1702 unsigned int mode;
1704 /* Right shift FIXED_CST to temp by fbit. */
1705 temp = TREE_FIXED_CST (arg1).data;
1706 mode = TREE_FIXED_CST (arg1).mode;
1707 if (GET_MODE_FBIT (mode) < HOST_BITS_PER_DOUBLE_INT)
1709 temp = temp.rshift (GET_MODE_FBIT (mode),
1710 HOST_BITS_PER_DOUBLE_INT,
1711 SIGNED_FIXED_POINT_MODE_P (mode));
1713 /* Left shift temp to temp_trunc by fbit. */
1714 temp_trunc = temp.lshift (GET_MODE_FBIT (mode),
1715 HOST_BITS_PER_DOUBLE_INT,
1716 SIGNED_FIXED_POINT_MODE_P (mode));
1718 else
1720 temp = double_int_zero;
1721 temp_trunc = double_int_zero;
1724 /* If FIXED_CST is negative, we need to round the value toward 0.
1725 By checking if the fractional bits are not zero to add 1 to temp. */
1726 if (SIGNED_FIXED_POINT_MODE_P (mode)
1727 && temp_trunc.is_negative ()
1728 && TREE_FIXED_CST (arg1).data != temp_trunc)
1729 temp += double_int_one;
1731 /* Given a fixed-point constant, make new constant with new type,
1732 appropriately sign-extended or truncated. */
1733 t = force_fit_type_double (type, temp, -1,
1734 (temp.is_negative ()
1735 && (TYPE_UNSIGNED (type)
1736 < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1737 | TREE_OVERFLOW (arg1));
1739 return t;
1742 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1743 to another floating point type. */
1745 static tree
1746 fold_convert_const_real_from_real (tree type, const_tree arg1)
1748 REAL_VALUE_TYPE value;
1749 tree t;
1751 real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
1752 t = build_real (type, value);
1754 /* If converting an infinity or NAN to a representation that doesn't
1755 have one, set the overflow bit so that we can produce some kind of
1756 error message at the appropriate point if necessary. It's not the
1757 most user-friendly message, but it's better than nothing. */
1758 if (REAL_VALUE_ISINF (TREE_REAL_CST (arg1))
1759 && !MODE_HAS_INFINITIES (TYPE_MODE (type)))
1760 TREE_OVERFLOW (t) = 1;
1761 else if (REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
1762 && !MODE_HAS_NANS (TYPE_MODE (type)))
1763 TREE_OVERFLOW (t) = 1;
1764 /* Regular overflow, conversion produced an infinity in a mode that
1765 can't represent them. */
1766 else if (!MODE_HAS_INFINITIES (TYPE_MODE (type))
1767 && REAL_VALUE_ISINF (value)
1768 && !REAL_VALUE_ISINF (TREE_REAL_CST (arg1)))
1769 TREE_OVERFLOW (t) = 1;
1770 else
1771 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1772 return t;
1775 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1776 to a floating point type. */
1778 static tree
1779 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
1781 REAL_VALUE_TYPE value;
1782 tree t;
1784 real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
1785 t = build_real (type, value);
1787 TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
1788 return t;
1791 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
1792 to another fixed-point type. */
1794 static tree
1795 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
1797 FIXED_VALUE_TYPE value;
1798 tree t;
1799 bool overflow_p;
1801 overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
1802 TYPE_SATURATING (type));
1803 t = build_fixed (type, value);
1805 /* Propagate overflow flags. */
1806 if (overflow_p | TREE_OVERFLOW (arg1))
1807 TREE_OVERFLOW (t) = 1;
1808 return t;
1811 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
1812 to a fixed-point type. */
1814 static tree
1815 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
1817 FIXED_VALUE_TYPE value;
1818 tree t;
1819 bool overflow_p;
1821 overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
1822 TREE_INT_CST (arg1),
1823 TYPE_UNSIGNED (TREE_TYPE (arg1)),
1824 TYPE_SATURATING (type));
1825 t = build_fixed (type, value);
1827 /* Propagate overflow flags. */
1828 if (overflow_p | TREE_OVERFLOW (arg1))
1829 TREE_OVERFLOW (t) = 1;
1830 return t;
1833 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1834 to a fixed-point type. */
1836 static tree
1837 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
1839 FIXED_VALUE_TYPE value;
1840 tree t;
1841 bool overflow_p;
1843 overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
1844 &TREE_REAL_CST (arg1),
1845 TYPE_SATURATING (type));
1846 t = build_fixed (type, value);
1848 /* Propagate overflow flags. */
1849 if (overflow_p | TREE_OVERFLOW (arg1))
1850 TREE_OVERFLOW (t) = 1;
1851 return t;
1854 /* Attempt to fold type conversion operation CODE of expression ARG1 to
1855 type TYPE. If no simplification can be done return NULL_TREE. */
1857 static tree
1858 fold_convert_const (enum tree_code code, tree type, tree arg1)
1860 if (TREE_TYPE (arg1) == type)
1861 return arg1;
1863 if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
1864 || TREE_CODE (type) == OFFSET_TYPE)
1866 if (TREE_CODE (arg1) == INTEGER_CST)
1867 return fold_convert_const_int_from_int (type, arg1);
1868 else if (TREE_CODE (arg1) == REAL_CST)
1869 return fold_convert_const_int_from_real (code, type, arg1);
1870 else if (TREE_CODE (arg1) == FIXED_CST)
1871 return fold_convert_const_int_from_fixed (type, arg1);
1873 else if (TREE_CODE (type) == REAL_TYPE)
1875 if (TREE_CODE (arg1) == INTEGER_CST)
1876 return build_real_from_int_cst (type, arg1);
1877 else if (TREE_CODE (arg1) == REAL_CST)
1878 return fold_convert_const_real_from_real (type, arg1);
1879 else if (TREE_CODE (arg1) == FIXED_CST)
1880 return fold_convert_const_real_from_fixed (type, arg1);
1882 else if (TREE_CODE (type) == FIXED_POINT_TYPE)
1884 if (TREE_CODE (arg1) == FIXED_CST)
1885 return fold_convert_const_fixed_from_fixed (type, arg1);
1886 else if (TREE_CODE (arg1) == INTEGER_CST)
1887 return fold_convert_const_fixed_from_int (type, arg1);
1888 else if (TREE_CODE (arg1) == REAL_CST)
1889 return fold_convert_const_fixed_from_real (type, arg1);
1891 return NULL_TREE;
1894 /* Construct a vector of zero elements of vector type TYPE. */
1896 static tree
1897 build_zero_vector (tree type)
1899 tree t;
1901 t = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
1902 return build_vector_from_val (type, t);
1905 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR. */
1907 bool
1908 fold_convertible_p (const_tree type, const_tree arg)
1910 tree orig = TREE_TYPE (arg);
1912 if (type == orig)
1913 return true;
1915 if (TREE_CODE (arg) == ERROR_MARK
1916 || TREE_CODE (type) == ERROR_MARK
1917 || TREE_CODE (orig) == ERROR_MARK)
1918 return false;
1920 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
1921 return true;
1923 switch (TREE_CODE (type))
1925 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1926 case POINTER_TYPE: case REFERENCE_TYPE:
1927 case OFFSET_TYPE:
1928 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1929 || TREE_CODE (orig) == OFFSET_TYPE)
1930 return true;
1931 return (TREE_CODE (orig) == VECTOR_TYPE
1932 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1934 case REAL_TYPE:
1935 case FIXED_POINT_TYPE:
1936 case COMPLEX_TYPE:
1937 case VECTOR_TYPE:
1938 case VOID_TYPE:
1939 return TREE_CODE (type) == TREE_CODE (orig);
1941 default:
1942 return false;
1946 /* Convert expression ARG to type TYPE. Used by the middle-end for
1947 simple conversions in preference to calling the front-end's convert. */
1949 tree
1950 fold_convert_loc (location_t loc, tree type, tree arg)
1952 tree orig = TREE_TYPE (arg);
1953 tree tem;
1955 if (type == orig)
1956 return arg;
1958 if (TREE_CODE (arg) == ERROR_MARK
1959 || TREE_CODE (type) == ERROR_MARK
1960 || TREE_CODE (orig) == ERROR_MARK)
1961 return error_mark_node;
1963 switch (TREE_CODE (type))
1965 case POINTER_TYPE:
1966 case REFERENCE_TYPE:
1967 /* Handle conversions between pointers to different address spaces. */
1968 if (POINTER_TYPE_P (orig)
1969 && (TYPE_ADDR_SPACE (TREE_TYPE (type))
1970 != TYPE_ADDR_SPACE (TREE_TYPE (orig))))
1971 return fold_build1_loc (loc, ADDR_SPACE_CONVERT_EXPR, type, arg);
1972 /* fall through */
1974 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1975 case OFFSET_TYPE:
1976 if (TREE_CODE (arg) == INTEGER_CST)
1978 tem = fold_convert_const (NOP_EXPR, type, arg);
1979 if (tem != NULL_TREE)
1980 return tem;
1982 if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
1983 || TREE_CODE (orig) == OFFSET_TYPE)
1984 return fold_build1_loc (loc, NOP_EXPR, type, arg);
1985 if (TREE_CODE (orig) == COMPLEX_TYPE)
1986 return fold_convert_loc (loc, type,
1987 fold_build1_loc (loc, REALPART_EXPR,
1988 TREE_TYPE (orig), arg));
1989 gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
1990 && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
1991 return fold_build1_loc (loc, NOP_EXPR, type, arg);
1993 case REAL_TYPE:
1994 if (TREE_CODE (arg) == INTEGER_CST)
1996 tem = fold_convert_const (FLOAT_EXPR, type, arg);
1997 if (tem != NULL_TREE)
1998 return tem;
2000 else if (TREE_CODE (arg) == REAL_CST)
2002 tem = fold_convert_const (NOP_EXPR, type, arg);
2003 if (tem != NULL_TREE)
2004 return tem;
2006 else if (TREE_CODE (arg) == FIXED_CST)
2008 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2009 if (tem != NULL_TREE)
2010 return tem;
2013 switch (TREE_CODE (orig))
2015 case INTEGER_TYPE:
2016 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2017 case POINTER_TYPE: case REFERENCE_TYPE:
2018 return fold_build1_loc (loc, FLOAT_EXPR, type, arg);
2020 case REAL_TYPE:
2021 return fold_build1_loc (loc, NOP_EXPR, type, arg);
2023 case FIXED_POINT_TYPE:
2024 return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
2026 case COMPLEX_TYPE:
2027 tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2028 return fold_convert_loc (loc, type, tem);
2030 default:
2031 gcc_unreachable ();
2034 case FIXED_POINT_TYPE:
2035 if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
2036 || TREE_CODE (arg) == REAL_CST)
2038 tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2039 if (tem != NULL_TREE)
2040 goto fold_convert_exit;
2043 switch (TREE_CODE (orig))
2045 case FIXED_POINT_TYPE:
2046 case INTEGER_TYPE:
2047 case ENUMERAL_TYPE:
2048 case BOOLEAN_TYPE:
2049 case REAL_TYPE:
2050 return fold_build1_loc (loc, FIXED_CONVERT_EXPR, type, arg);
2052 case COMPLEX_TYPE:
2053 tem = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2054 return fold_convert_loc (loc, type, tem);
2056 default:
2057 gcc_unreachable ();
2060 case COMPLEX_TYPE:
2061 switch (TREE_CODE (orig))
2063 case INTEGER_TYPE:
2064 case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2065 case POINTER_TYPE: case REFERENCE_TYPE:
2066 case REAL_TYPE:
2067 case FIXED_POINT_TYPE:
2068 return fold_build2_loc (loc, COMPLEX_EXPR, type,
2069 fold_convert_loc (loc, TREE_TYPE (type), arg),
2070 fold_convert_loc (loc, TREE_TYPE (type),
2071 integer_zero_node));
2072 case COMPLEX_TYPE:
2074 tree rpart, ipart;
2076 if (TREE_CODE (arg) == COMPLEX_EXPR)
2078 rpart = fold_convert_loc (loc, TREE_TYPE (type),
2079 TREE_OPERAND (arg, 0));
2080 ipart = fold_convert_loc (loc, TREE_TYPE (type),
2081 TREE_OPERAND (arg, 1));
2082 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2085 arg = save_expr (arg);
2086 rpart = fold_build1_loc (loc, REALPART_EXPR, TREE_TYPE (orig), arg);
2087 ipart = fold_build1_loc (loc, IMAGPART_EXPR, TREE_TYPE (orig), arg);
2088 rpart = fold_convert_loc (loc, TREE_TYPE (type), rpart);
2089 ipart = fold_convert_loc (loc, TREE_TYPE (type), ipart);
2090 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart, ipart);
2093 default:
2094 gcc_unreachable ();
2097 case VECTOR_TYPE:
2098 if (integer_zerop (arg))
2099 return build_zero_vector (type);
2100 gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2101 gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2102 || TREE_CODE (orig) == VECTOR_TYPE);
2103 return fold_build1_loc (loc, VIEW_CONVERT_EXPR, type, arg);
2105 case VOID_TYPE:
2106 tem = fold_ignored_result (arg);
2107 return fold_build1_loc (loc, NOP_EXPR, type, tem);
2109 default:
2110 if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2111 return fold_build1_loc (loc, NOP_EXPR, type, arg);
2112 gcc_unreachable ();
2114 fold_convert_exit:
2115 protected_set_expr_location_unshare (tem, loc);
2116 return tem;
2119 /* Return false if expr can be assumed not to be an lvalue, true
2120 otherwise. */
2122 static bool
2123 maybe_lvalue_p (const_tree x)
2125 /* We only need to wrap lvalue tree codes. */
2126 switch (TREE_CODE (x))
2128 case VAR_DECL:
2129 case PARM_DECL:
2130 case RESULT_DECL:
2131 case LABEL_DECL:
2132 case FUNCTION_DECL:
2133 case SSA_NAME:
2135 case COMPONENT_REF:
2136 case MEM_REF:
2137 case INDIRECT_REF:
2138 case ARRAY_REF:
2139 case ARRAY_RANGE_REF:
2140 case BIT_FIELD_REF:
2141 case OBJ_TYPE_REF:
2143 case REALPART_EXPR:
2144 case IMAGPART_EXPR:
2145 case PREINCREMENT_EXPR:
2146 case PREDECREMENT_EXPR:
2147 case SAVE_EXPR:
2148 case TRY_CATCH_EXPR:
2149 case WITH_CLEANUP_EXPR:
2150 case COMPOUND_EXPR:
2151 case MODIFY_EXPR:
2152 case TARGET_EXPR:
2153 case COND_EXPR:
2154 case BIND_EXPR:
2155 break;
2157 default:
2158 /* Assume the worst for front-end tree codes. */
2159 if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2160 break;
2161 return false;
2164 return true;
2167 /* Return an expr equal to X but certainly not valid as an lvalue. */
2169 tree
2170 non_lvalue_loc (location_t loc, tree x)
2172 /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2173 us. */
2174 if (in_gimple_form)
2175 return x;
2177 if (! maybe_lvalue_p (x))
2178 return x;
2179 return build1_loc (loc, NON_LVALUE_EXPR, TREE_TYPE (x), x);
2182 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2183 Zero means allow extended lvalues. */
2185 int pedantic_lvalues;
2187 /* When pedantic, return an expr equal to X but certainly not valid as a
2188 pedantic lvalue. Otherwise, return X. */
2190 static tree
2191 pedantic_non_lvalue_loc (location_t loc, tree x)
2193 if (pedantic_lvalues)
2194 return non_lvalue_loc (loc, x);
2196 return protected_set_expr_location_unshare (x, loc);
2199 /* Given a tree comparison code, return the code that is the logical inverse.
2200 It is generally not safe to do this for floating-point comparisons, except
2201 for EQ_EXPR, NE_EXPR, ORDERED_EXPR and UNORDERED_EXPR, so we return
2202 ERROR_MARK in this case. */
2204 enum tree_code
2205 invert_tree_comparison (enum tree_code code, bool honor_nans)
2207 if (honor_nans && flag_trapping_math && code != EQ_EXPR && code != NE_EXPR
2208 && code != ORDERED_EXPR && code != UNORDERED_EXPR)
2209 return ERROR_MARK;
2211 switch (code)
2213 case EQ_EXPR:
2214 return NE_EXPR;
2215 case NE_EXPR:
2216 return EQ_EXPR;
2217 case GT_EXPR:
2218 return honor_nans ? UNLE_EXPR : LE_EXPR;
2219 case GE_EXPR:
2220 return honor_nans ? UNLT_EXPR : LT_EXPR;
2221 case LT_EXPR:
2222 return honor_nans ? UNGE_EXPR : GE_EXPR;
2223 case LE_EXPR:
2224 return honor_nans ? UNGT_EXPR : GT_EXPR;
2225 case LTGT_EXPR:
2226 return UNEQ_EXPR;
2227 case UNEQ_EXPR:
2228 return LTGT_EXPR;
2229 case UNGT_EXPR:
2230 return LE_EXPR;
2231 case UNGE_EXPR:
2232 return LT_EXPR;
2233 case UNLT_EXPR:
2234 return GE_EXPR;
2235 case UNLE_EXPR:
2236 return GT_EXPR;
2237 case ORDERED_EXPR:
2238 return UNORDERED_EXPR;
2239 case UNORDERED_EXPR:
2240 return ORDERED_EXPR;
2241 default:
2242 gcc_unreachable ();
2246 /* Similar, but return the comparison that results if the operands are
2247 swapped. This is safe for floating-point. */
2249 enum tree_code
2250 swap_tree_comparison (enum tree_code code)
2252 switch (code)
2254 case EQ_EXPR:
2255 case NE_EXPR:
2256 case ORDERED_EXPR:
2257 case UNORDERED_EXPR:
2258 case LTGT_EXPR:
2259 case UNEQ_EXPR:
2260 return code;
2261 case GT_EXPR:
2262 return LT_EXPR;
2263 case GE_EXPR:
2264 return LE_EXPR;
2265 case LT_EXPR:
2266 return GT_EXPR;
2267 case LE_EXPR:
2268 return GE_EXPR;
2269 case UNGT_EXPR:
2270 return UNLT_EXPR;
2271 case UNGE_EXPR:
2272 return UNLE_EXPR;
2273 case UNLT_EXPR:
2274 return UNGT_EXPR;
2275 case UNLE_EXPR:
2276 return UNGE_EXPR;
2277 default:
2278 gcc_unreachable ();
2283 /* Convert a comparison tree code from an enum tree_code representation
2284 into a compcode bit-based encoding. This function is the inverse of
2285 compcode_to_comparison. */
2287 static enum comparison_code
2288 comparison_to_compcode (enum tree_code code)
2290 switch (code)
2292 case LT_EXPR:
2293 return COMPCODE_LT;
2294 case EQ_EXPR:
2295 return COMPCODE_EQ;
2296 case LE_EXPR:
2297 return COMPCODE_LE;
2298 case GT_EXPR:
2299 return COMPCODE_GT;
2300 case NE_EXPR:
2301 return COMPCODE_NE;
2302 case GE_EXPR:
2303 return COMPCODE_GE;
2304 case ORDERED_EXPR:
2305 return COMPCODE_ORD;
2306 case UNORDERED_EXPR:
2307 return COMPCODE_UNORD;
2308 case UNLT_EXPR:
2309 return COMPCODE_UNLT;
2310 case UNEQ_EXPR:
2311 return COMPCODE_UNEQ;
2312 case UNLE_EXPR:
2313 return COMPCODE_UNLE;
2314 case UNGT_EXPR:
2315 return COMPCODE_UNGT;
2316 case LTGT_EXPR:
2317 return COMPCODE_LTGT;
2318 case UNGE_EXPR:
2319 return COMPCODE_UNGE;
2320 default:
2321 gcc_unreachable ();
2325 /* Convert a compcode bit-based encoding of a comparison operator back
2326 to GCC's enum tree_code representation. This function is the
2327 inverse of comparison_to_compcode. */
2329 static enum tree_code
2330 compcode_to_comparison (enum comparison_code code)
2332 switch (code)
2334 case COMPCODE_LT:
2335 return LT_EXPR;
2336 case COMPCODE_EQ:
2337 return EQ_EXPR;
2338 case COMPCODE_LE:
2339 return LE_EXPR;
2340 case COMPCODE_GT:
2341 return GT_EXPR;
2342 case COMPCODE_NE:
2343 return NE_EXPR;
2344 case COMPCODE_GE:
2345 return GE_EXPR;
2346 case COMPCODE_ORD:
2347 return ORDERED_EXPR;
2348 case COMPCODE_UNORD:
2349 return UNORDERED_EXPR;
2350 case COMPCODE_UNLT:
2351 return UNLT_EXPR;
2352 case COMPCODE_UNEQ:
2353 return UNEQ_EXPR;
2354 case COMPCODE_UNLE:
2355 return UNLE_EXPR;
2356 case COMPCODE_UNGT:
2357 return UNGT_EXPR;
2358 case COMPCODE_LTGT:
2359 return LTGT_EXPR;
2360 case COMPCODE_UNGE:
2361 return UNGE_EXPR;
2362 default:
2363 gcc_unreachable ();
2367 /* Return a tree for the comparison which is the combination of
2368 doing the AND or OR (depending on CODE) of the two operations LCODE
2369 and RCODE on the identical operands LL_ARG and LR_ARG. Take into account
2370 the possibility of trapping if the mode has NaNs, and return NULL_TREE
2371 if this makes the transformation invalid. */
2373 tree
2374 combine_comparisons (location_t loc,
2375 enum tree_code code, enum tree_code lcode,
2376 enum tree_code rcode, tree truth_type,
2377 tree ll_arg, tree lr_arg)
2379 bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2380 enum comparison_code lcompcode = comparison_to_compcode (lcode);
2381 enum comparison_code rcompcode = comparison_to_compcode (rcode);
2382 int compcode;
2384 switch (code)
2386 case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2387 compcode = lcompcode & rcompcode;
2388 break;
2390 case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2391 compcode = lcompcode | rcompcode;
2392 break;
2394 default:
2395 return NULL_TREE;
2398 if (!honor_nans)
2400 /* Eliminate unordered comparisons, as well as LTGT and ORD
2401 which are not used unless the mode has NaNs. */
2402 compcode &= ~COMPCODE_UNORD;
2403 if (compcode == COMPCODE_LTGT)
2404 compcode = COMPCODE_NE;
2405 else if (compcode == COMPCODE_ORD)
2406 compcode = COMPCODE_TRUE;
2408 else if (flag_trapping_math)
2410 /* Check that the original operation and the optimized ones will trap
2411 under the same condition. */
2412 bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2413 && (lcompcode != COMPCODE_EQ)
2414 && (lcompcode != COMPCODE_ORD);
2415 bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2416 && (rcompcode != COMPCODE_EQ)
2417 && (rcompcode != COMPCODE_ORD);
2418 bool trap = (compcode & COMPCODE_UNORD) == 0
2419 && (compcode != COMPCODE_EQ)
2420 && (compcode != COMPCODE_ORD);
2422 /* In a short-circuited boolean expression the LHS might be
2423 such that the RHS, if evaluated, will never trap. For
2424 example, in ORD (x, y) && (x < y), we evaluate the RHS only
2425 if neither x nor y is NaN. (This is a mixed blessing: for
2426 example, the expression above will never trap, hence
2427 optimizing it to x < y would be invalid). */
2428 if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2429 || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2430 rtrap = false;
2432 /* If the comparison was short-circuited, and only the RHS
2433 trapped, we may now generate a spurious trap. */
2434 if (rtrap && !ltrap
2435 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2436 return NULL_TREE;
2438 /* If we changed the conditions that cause a trap, we lose. */
2439 if ((ltrap || rtrap) != trap)
2440 return NULL_TREE;
2443 if (compcode == COMPCODE_TRUE)
2444 return constant_boolean_node (true, truth_type);
2445 else if (compcode == COMPCODE_FALSE)
2446 return constant_boolean_node (false, truth_type);
2447 else
2449 enum tree_code tcode;
2451 tcode = compcode_to_comparison ((enum comparison_code) compcode);
2452 return fold_build2_loc (loc, tcode, truth_type, ll_arg, lr_arg);
2456 /* Return nonzero if two operands (typically of the same tree node)
2457 are necessarily equal. If either argument has side-effects this
2458 function returns zero. FLAGS modifies behavior as follows:
2460 If OEP_ONLY_CONST is set, only return nonzero for constants.
2461 This function tests whether the operands are indistinguishable;
2462 it does not test whether they are equal using C's == operation.
2463 The distinction is important for IEEE floating point, because
2464 (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2465 (2) two NaNs may be indistinguishable, but NaN!=NaN.
2467 If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2468 even though it may hold multiple values during a function.
2469 This is because a GCC tree node guarantees that nothing else is
2470 executed between the evaluation of its "operands" (which may often
2471 be evaluated in arbitrary order). Hence if the operands themselves
2472 don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2473 same value in each operand/subexpression. Hence leaving OEP_ONLY_CONST
2474 unset means assuming isochronic (or instantaneous) tree equivalence.
2475 Unless comparing arbitrary expression trees, such as from different
2476 statements, this flag can usually be left unset.
2478 If OEP_PURE_SAME is set, then pure functions with identical arguments
2479 are considered the same. It is used when the caller has other ways
2480 to ensure that global memory is unchanged in between. */
2483 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
2485 /* If either is ERROR_MARK, they aren't equal. */
2486 if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK
2487 || TREE_TYPE (arg0) == error_mark_node
2488 || TREE_TYPE (arg1) == error_mark_node)
2489 return 0;
2491 /* Similar, if either does not have a type (like a released SSA name),
2492 they aren't equal. */
2493 if (!TREE_TYPE (arg0) || !TREE_TYPE (arg1))
2494 return 0;
2496 /* Check equality of integer constants before bailing out due to
2497 precision differences. */
2498 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2499 return tree_int_cst_equal (arg0, arg1);
2501 /* If both types don't have the same signedness, then we can't consider
2502 them equal. We must check this before the STRIP_NOPS calls
2503 because they may change the signedness of the arguments. As pointers
2504 strictly don't have a signedness, require either two pointers or
2505 two non-pointers as well. */
2506 if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
2507 || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
2508 return 0;
2510 /* We cannot consider pointers to different address space equal. */
2511 if (POINTER_TYPE_P (TREE_TYPE (arg0)) && POINTER_TYPE_P (TREE_TYPE (arg1))
2512 && (TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg0)))
2513 != TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (arg1)))))
2514 return 0;
2516 /* If both types don't have the same precision, then it is not safe
2517 to strip NOPs. */
2518 if (element_precision (TREE_TYPE (arg0))
2519 != element_precision (TREE_TYPE (arg1)))
2520 return 0;
2522 STRIP_NOPS (arg0);
2523 STRIP_NOPS (arg1);
2525 /* In case both args are comparisons but with different comparison
2526 code, try to swap the comparison operands of one arg to produce
2527 a match and compare that variant. */
2528 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2529 && COMPARISON_CLASS_P (arg0)
2530 && COMPARISON_CLASS_P (arg1))
2532 enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
2534 if (TREE_CODE (arg0) == swap_code)
2535 return operand_equal_p (TREE_OPERAND (arg0, 0),
2536 TREE_OPERAND (arg1, 1), flags)
2537 && operand_equal_p (TREE_OPERAND (arg0, 1),
2538 TREE_OPERAND (arg1, 0), flags);
2541 if (TREE_CODE (arg0) != TREE_CODE (arg1)
2542 /* NOP_EXPR and CONVERT_EXPR are considered equal. */
2543 && !(CONVERT_EXPR_P (arg0) && CONVERT_EXPR_P (arg1)))
2544 return 0;
2546 /* This is needed for conversions and for COMPONENT_REF.
2547 Might as well play it safe and always test this. */
2548 if (TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2549 || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2550 || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2551 return 0;
2553 /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2554 We don't care about side effects in that case because the SAVE_EXPR
2555 takes care of that for us. In all other cases, two expressions are
2556 equal if they have no side effects. If we have two identical
2557 expressions with side effects that should be treated the same due
2558 to the only side effects being identical SAVE_EXPR's, that will
2559 be detected in the recursive calls below.
2560 If we are taking an invariant address of two identical objects
2561 they are necessarily equal as well. */
2562 if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2563 && (TREE_CODE (arg0) == SAVE_EXPR
2564 || (flags & OEP_CONSTANT_ADDRESS_OF)
2565 || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2566 return 1;
2568 /* Next handle constant cases, those for which we can return 1 even
2569 if ONLY_CONST is set. */
2570 if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2571 switch (TREE_CODE (arg0))
2573 case INTEGER_CST:
2574 return tree_int_cst_equal (arg0, arg1);
2576 case FIXED_CST:
2577 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
2578 TREE_FIXED_CST (arg1));
2580 case REAL_CST:
2581 if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2582 TREE_REAL_CST (arg1)))
2583 return 1;
2586 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
2588 /* If we do not distinguish between signed and unsigned zero,
2589 consider them equal. */
2590 if (real_zerop (arg0) && real_zerop (arg1))
2591 return 1;
2593 return 0;
2595 case VECTOR_CST:
2597 unsigned i;
2599 if (VECTOR_CST_NELTS (arg0) != VECTOR_CST_NELTS (arg1))
2600 return 0;
2602 for (i = 0; i < VECTOR_CST_NELTS (arg0); ++i)
2604 if (!operand_equal_p (VECTOR_CST_ELT (arg0, i),
2605 VECTOR_CST_ELT (arg1, i), flags))
2606 return 0;
2608 return 1;
2611 case COMPLEX_CST:
2612 return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2613 flags)
2614 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2615 flags));
2617 case STRING_CST:
2618 return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2619 && ! memcmp (TREE_STRING_POINTER (arg0),
2620 TREE_STRING_POINTER (arg1),
2621 TREE_STRING_LENGTH (arg0)));
2623 case ADDR_EXPR:
2624 return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2625 TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1)
2626 ? OEP_CONSTANT_ADDRESS_OF : 0);
2627 default:
2628 break;
2631 if (flags & OEP_ONLY_CONST)
2632 return 0;
2634 /* Define macros to test an operand from arg0 and arg1 for equality and a
2635 variant that allows null and views null as being different from any
2636 non-null value. In the latter case, if either is null, the both
2637 must be; otherwise, do the normal comparison. */
2638 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N), \
2639 TREE_OPERAND (arg1, N), flags)
2641 #define OP_SAME_WITH_NULL(N) \
2642 ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2643 ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2645 switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2647 case tcc_unary:
2648 /* Two conversions are equal only if signedness and modes match. */
2649 switch (TREE_CODE (arg0))
2651 CASE_CONVERT:
2652 case FIX_TRUNC_EXPR:
2653 if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2654 != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2655 return 0;
2656 break;
2657 default:
2658 break;
2661 return OP_SAME (0);
2664 case tcc_comparison:
2665 case tcc_binary:
2666 if (OP_SAME (0) && OP_SAME (1))
2667 return 1;
2669 /* For commutative ops, allow the other order. */
2670 return (commutative_tree_code (TREE_CODE (arg0))
2671 && operand_equal_p (TREE_OPERAND (arg0, 0),
2672 TREE_OPERAND (arg1, 1), flags)
2673 && operand_equal_p (TREE_OPERAND (arg0, 1),
2674 TREE_OPERAND (arg1, 0), flags));
2676 case tcc_reference:
2677 /* If either of the pointer (or reference) expressions we are
2678 dereferencing contain a side effect, these cannot be equal,
2679 but their addresses can be. */
2680 if ((flags & OEP_CONSTANT_ADDRESS_OF) == 0
2681 && (TREE_SIDE_EFFECTS (arg0)
2682 || TREE_SIDE_EFFECTS (arg1)))
2683 return 0;
2685 switch (TREE_CODE (arg0))
2687 case INDIRECT_REF:
2688 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2689 return OP_SAME (0);
2691 case REALPART_EXPR:
2692 case IMAGPART_EXPR:
2693 return OP_SAME (0);
2695 case TARGET_MEM_REF:
2696 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2697 /* Require equal extra operands and then fall through to MEM_REF
2698 handling of the two common operands. */
2699 if (!OP_SAME_WITH_NULL (2)
2700 || !OP_SAME_WITH_NULL (3)
2701 || !OP_SAME_WITH_NULL (4))
2702 return 0;
2703 /* Fallthru. */
2704 case MEM_REF:
2705 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2706 /* Require equal access sizes, and similar pointer types.
2707 We can have incomplete types for array references of
2708 variable-sized arrays from the Fortran frontend
2709 though. Also verify the types are compatible. */
2710 return ((TYPE_SIZE (TREE_TYPE (arg0)) == TYPE_SIZE (TREE_TYPE (arg1))
2711 || (TYPE_SIZE (TREE_TYPE (arg0))
2712 && TYPE_SIZE (TREE_TYPE (arg1))
2713 && operand_equal_p (TYPE_SIZE (TREE_TYPE (arg0)),
2714 TYPE_SIZE (TREE_TYPE (arg1)), flags)))
2715 && types_compatible_p (TREE_TYPE (arg0), TREE_TYPE (arg1))
2716 && alias_ptr_types_compatible_p
2717 (TREE_TYPE (TREE_OPERAND (arg0, 1)),
2718 TREE_TYPE (TREE_OPERAND (arg1, 1)))
2719 && OP_SAME (0) && OP_SAME (1));
2721 case ARRAY_REF:
2722 case ARRAY_RANGE_REF:
2723 /* Operands 2 and 3 may be null.
2724 Compare the array index by value if it is constant first as we
2725 may have different types but same value here. */
2726 if (!OP_SAME (0))
2727 return 0;
2728 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2729 return ((tree_int_cst_equal (TREE_OPERAND (arg0, 1),
2730 TREE_OPERAND (arg1, 1))
2731 || OP_SAME (1))
2732 && OP_SAME_WITH_NULL (2)
2733 && OP_SAME_WITH_NULL (3));
2735 case COMPONENT_REF:
2736 /* Handle operand 2 the same as for ARRAY_REF. Operand 0
2737 may be NULL when we're called to compare MEM_EXPRs. */
2738 if (!OP_SAME_WITH_NULL (0)
2739 || !OP_SAME (1))
2740 return 0;
2741 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2742 return OP_SAME_WITH_NULL (2);
2744 case BIT_FIELD_REF:
2745 if (!OP_SAME (0))
2746 return 0;
2747 flags &= ~OEP_CONSTANT_ADDRESS_OF;
2748 return OP_SAME (1) && OP_SAME (2);
2750 default:
2751 return 0;
2754 case tcc_expression:
2755 switch (TREE_CODE (arg0))
2757 case ADDR_EXPR:
2758 case TRUTH_NOT_EXPR:
2759 return OP_SAME (0);
2761 case TRUTH_ANDIF_EXPR:
2762 case TRUTH_ORIF_EXPR:
2763 return OP_SAME (0) && OP_SAME (1);
2765 case FMA_EXPR:
2766 case WIDEN_MULT_PLUS_EXPR:
2767 case WIDEN_MULT_MINUS_EXPR:
2768 if (!OP_SAME (2))
2769 return 0;
2770 /* The multiplcation operands are commutative. */
2771 /* FALLTHRU */
2773 case TRUTH_AND_EXPR:
2774 case TRUTH_OR_EXPR:
2775 case TRUTH_XOR_EXPR:
2776 if (OP_SAME (0) && OP_SAME (1))
2777 return 1;
2779 /* Otherwise take into account this is a commutative operation. */
2780 return (operand_equal_p (TREE_OPERAND (arg0, 0),
2781 TREE_OPERAND (arg1, 1), flags)
2782 && operand_equal_p (TREE_OPERAND (arg0, 1),
2783 TREE_OPERAND (arg1, 0), flags));
2785 case COND_EXPR:
2786 case VEC_COND_EXPR:
2787 case DOT_PROD_EXPR:
2788 return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2790 default:
2791 return 0;
2794 case tcc_vl_exp:
2795 switch (TREE_CODE (arg0))
2797 case CALL_EXPR:
2798 /* If the CALL_EXPRs call different functions, then they
2799 clearly can not be equal. */
2800 if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
2801 flags))
2802 return 0;
2805 unsigned int cef = call_expr_flags (arg0);
2806 if (flags & OEP_PURE_SAME)
2807 cef &= ECF_CONST | ECF_PURE;
2808 else
2809 cef &= ECF_CONST;
2810 if (!cef)
2811 return 0;
2814 /* Now see if all the arguments are the same. */
2816 const_call_expr_arg_iterator iter0, iter1;
2817 const_tree a0, a1;
2818 for (a0 = first_const_call_expr_arg (arg0, &iter0),
2819 a1 = first_const_call_expr_arg (arg1, &iter1);
2820 a0 && a1;
2821 a0 = next_const_call_expr_arg (&iter0),
2822 a1 = next_const_call_expr_arg (&iter1))
2823 if (! operand_equal_p (a0, a1, flags))
2824 return 0;
2826 /* If we get here and both argument lists are exhausted
2827 then the CALL_EXPRs are equal. */
2828 return ! (a0 || a1);
2830 default:
2831 return 0;
2834 case tcc_declaration:
2835 /* Consider __builtin_sqrt equal to sqrt. */
2836 return (TREE_CODE (arg0) == FUNCTION_DECL
2837 && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
2838 && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
2839 && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
2841 default:
2842 return 0;
2845 #undef OP_SAME
2846 #undef OP_SAME_WITH_NULL
2849 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2850 shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2852 When in doubt, return 0. */
2854 static int
2855 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
2857 int unsignedp1, unsignedpo;
2858 tree primarg0, primarg1, primother;
2859 unsigned int correct_width;
2861 if (operand_equal_p (arg0, arg1, 0))
2862 return 1;
2864 if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2865 || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2866 return 0;
2868 /* Discard any conversions that don't change the modes of ARG0 and ARG1
2869 and see if the inner values are the same. This removes any
2870 signedness comparison, which doesn't matter here. */
2871 primarg0 = arg0, primarg1 = arg1;
2872 STRIP_NOPS (primarg0);
2873 STRIP_NOPS (primarg1);
2874 if (operand_equal_p (primarg0, primarg1, 0))
2875 return 1;
2877 /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2878 actual comparison operand, ARG0.
2880 First throw away any conversions to wider types
2881 already present in the operands. */
2883 primarg1 = get_narrower (arg1, &unsignedp1);
2884 primother = get_narrower (other, &unsignedpo);
2886 correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2887 if (unsignedp1 == unsignedpo
2888 && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2889 && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2891 tree type = TREE_TYPE (arg0);
2893 /* Make sure shorter operand is extended the right way
2894 to match the longer operand. */
2895 primarg1 = fold_convert (signed_or_unsigned_type_for
2896 (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2898 if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
2899 return 1;
2902 return 0;
2905 /* See if ARG is an expression that is either a comparison or is performing
2906 arithmetic on comparisons. The comparisons must only be comparing
2907 two different values, which will be stored in *CVAL1 and *CVAL2; if
2908 they are nonzero it means that some operands have already been found.
2909 No variables may be used anywhere else in the expression except in the
2910 comparisons. If SAVE_P is true it means we removed a SAVE_EXPR around
2911 the expression and save_expr needs to be called with CVAL1 and CVAL2.
2913 If this is true, return 1. Otherwise, return zero. */
2915 static int
2916 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
2918 enum tree_code code = TREE_CODE (arg);
2919 enum tree_code_class tclass = TREE_CODE_CLASS (code);
2921 /* We can handle some of the tcc_expression cases here. */
2922 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
2923 tclass = tcc_unary;
2924 else if (tclass == tcc_expression
2925 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2926 || code == COMPOUND_EXPR))
2927 tclass = tcc_binary;
2929 else if (tclass == tcc_expression && code == SAVE_EXPR
2930 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2932 /* If we've already found a CVAL1 or CVAL2, this expression is
2933 two complex to handle. */
2934 if (*cval1 || *cval2)
2935 return 0;
2937 tclass = tcc_unary;
2938 *save_p = 1;
2941 switch (tclass)
2943 case tcc_unary:
2944 return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2946 case tcc_binary:
2947 return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
2948 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2949 cval1, cval2, save_p));
2951 case tcc_constant:
2952 return 1;
2954 case tcc_expression:
2955 if (code == COND_EXPR)
2956 return (twoval_comparison_p (TREE_OPERAND (arg, 0),
2957 cval1, cval2, save_p)
2958 && twoval_comparison_p (TREE_OPERAND (arg, 1),
2959 cval1, cval2, save_p)
2960 && twoval_comparison_p (TREE_OPERAND (arg, 2),
2961 cval1, cval2, save_p));
2962 return 0;
2964 case tcc_comparison:
2965 /* First see if we can handle the first operand, then the second. For
2966 the second operand, we know *CVAL1 can't be zero. It must be that
2967 one side of the comparison is each of the values; test for the
2968 case where this isn't true by failing if the two operands
2969 are the same. */
2971 if (operand_equal_p (TREE_OPERAND (arg, 0),
2972 TREE_OPERAND (arg, 1), 0))
2973 return 0;
2975 if (*cval1 == 0)
2976 *cval1 = TREE_OPERAND (arg, 0);
2977 else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
2979 else if (*cval2 == 0)
2980 *cval2 = TREE_OPERAND (arg, 0);
2981 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
2983 else
2984 return 0;
2986 if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
2988 else if (*cval2 == 0)
2989 *cval2 = TREE_OPERAND (arg, 1);
2990 else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
2992 else
2993 return 0;
2995 return 1;
2997 default:
2998 return 0;
3002 /* ARG is a tree that is known to contain just arithmetic operations and
3003 comparisons. Evaluate the operations in the tree substituting NEW0 for
3004 any occurrence of OLD0 as an operand of a comparison and likewise for
3005 NEW1 and OLD1. */
3007 static tree
3008 eval_subst (location_t loc, tree arg, tree old0, tree new0,
3009 tree old1, tree new1)
3011 tree type = TREE_TYPE (arg);
3012 enum tree_code code = TREE_CODE (arg);
3013 enum tree_code_class tclass = TREE_CODE_CLASS (code);
3015 /* We can handle some of the tcc_expression cases here. */
3016 if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3017 tclass = tcc_unary;
3018 else if (tclass == tcc_expression
3019 && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3020 tclass = tcc_binary;
3022 switch (tclass)
3024 case tcc_unary:
3025 return fold_build1_loc (loc, code, type,
3026 eval_subst (loc, TREE_OPERAND (arg, 0),
3027 old0, new0, old1, new1));
3029 case tcc_binary:
3030 return fold_build2_loc (loc, code, type,
3031 eval_subst (loc, TREE_OPERAND (arg, 0),
3032 old0, new0, old1, new1),
3033 eval_subst (loc, TREE_OPERAND (arg, 1),
3034 old0, new0, old1, new1));
3036 case tcc_expression:
3037 switch (code)
3039 case SAVE_EXPR:
3040 return eval_subst (loc, TREE_OPERAND (arg, 0), old0, new0,
3041 old1, new1);
3043 case COMPOUND_EXPR:
3044 return eval_subst (loc, TREE_OPERAND (arg, 1), old0, new0,
3045 old1, new1);
3047 case COND_EXPR:
3048 return fold_build3_loc (loc, code, type,
3049 eval_subst (loc, TREE_OPERAND (arg, 0),
3050 old0, new0, old1, new1),
3051 eval_subst (loc, TREE_OPERAND (arg, 1),
3052 old0, new0, old1, new1),
3053 eval_subst (loc, TREE_OPERAND (arg, 2),
3054 old0, new0, old1, new1));
3055 default:
3056 break;
3058 /* Fall through - ??? */
3060 case tcc_comparison:
3062 tree arg0 = TREE_OPERAND (arg, 0);
3063 tree arg1 = TREE_OPERAND (arg, 1);
3065 /* We need to check both for exact equality and tree equality. The
3066 former will be true if the operand has a side-effect. In that
3067 case, we know the operand occurred exactly once. */
3069 if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3070 arg0 = new0;
3071 else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3072 arg0 = new1;
3074 if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3075 arg1 = new0;
3076 else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3077 arg1 = new1;
3079 return fold_build2_loc (loc, code, type, arg0, arg1);
3082 default:
3083 return arg;
3087 /* Return a tree for the case when the result of an expression is RESULT
3088 converted to TYPE and OMITTED was previously an operand of the expression
3089 but is now not needed (e.g., we folded OMITTED * 0).
3091 If OMITTED has side effects, we must evaluate it. Otherwise, just do
3092 the conversion of RESULT to TYPE. */
3094 tree
3095 omit_one_operand_loc (location_t loc, tree type, tree result, tree omitted)
3097 tree t = fold_convert_loc (loc, type, result);
3099 /* If the resulting operand is an empty statement, just return the omitted
3100 statement casted to void. */
3101 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3102 return build1_loc (loc, NOP_EXPR, void_type_node,
3103 fold_ignored_result (omitted));
3105 if (TREE_SIDE_EFFECTS (omitted))
3106 return build2_loc (loc, COMPOUND_EXPR, type,
3107 fold_ignored_result (omitted), t);
3109 return non_lvalue_loc (loc, t);
3112 /* Similar, but call pedantic_non_lvalue instead of non_lvalue. */
3114 static tree
3115 pedantic_omit_one_operand_loc (location_t loc, tree type, tree result,
3116 tree omitted)
3118 tree t = fold_convert_loc (loc, type, result);
3120 /* If the resulting operand is an empty statement, just return the omitted
3121 statement casted to void. */
3122 if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3123 return build1_loc (loc, NOP_EXPR, void_type_node,
3124 fold_ignored_result (omitted));
3126 if (TREE_SIDE_EFFECTS (omitted))
3127 return build2_loc (loc, COMPOUND_EXPR, type,
3128 fold_ignored_result (omitted), t);
3130 return pedantic_non_lvalue_loc (loc, t);
3133 /* Return a tree for the case when the result of an expression is RESULT
3134 converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3135 of the expression but are now not needed.
3137 If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3138 If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3139 evaluated before OMITTED2. Otherwise, if neither has side effects,
3140 just do the conversion of RESULT to TYPE. */
3142 tree
3143 omit_two_operands_loc (location_t loc, tree type, tree result,
3144 tree omitted1, tree omitted2)
3146 tree t = fold_convert_loc (loc, type, result);
3148 if (TREE_SIDE_EFFECTS (omitted2))
3149 t = build2_loc (loc, COMPOUND_EXPR, type, omitted2, t);
3150 if (TREE_SIDE_EFFECTS (omitted1))
3151 t = build2_loc (loc, COMPOUND_EXPR, type, omitted1, t);
3153 return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue_loc (loc, t) : t;
3157 /* Return a simplified tree node for the truth-negation of ARG. This
3158 never alters ARG itself. We assume that ARG is an operation that
3159 returns a truth value (0 or 1).
3161 FIXME: one would think we would fold the result, but it causes
3162 problems with the dominator optimizer. */
3164 static tree
3165 fold_truth_not_expr (location_t loc, tree arg)
3167 tree type = TREE_TYPE (arg);
3168 enum tree_code code = TREE_CODE (arg);
3169 location_t loc1, loc2;
3171 /* If this is a comparison, we can simply invert it, except for
3172 floating-point non-equality comparisons, in which case we just
3173 enclose a TRUTH_NOT_EXPR around what we have. */
3175 if (TREE_CODE_CLASS (code) == tcc_comparison)
3177 tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3178 if (FLOAT_TYPE_P (op_type)
3179 && flag_trapping_math
3180 && code != ORDERED_EXPR && code != UNORDERED_EXPR
3181 && code != NE_EXPR && code != EQ_EXPR)
3182 return NULL_TREE;
3184 code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (op_type)));
3185 if (code == ERROR_MARK)
3186 return NULL_TREE;
3188 return build2_loc (loc, code, type, TREE_OPERAND (arg, 0),
3189 TREE_OPERAND (arg, 1));
3192 switch (code)
3194 case INTEGER_CST:
3195 return constant_boolean_node (integer_zerop (arg), type);
3197 case TRUTH_AND_EXPR:
3198 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3199 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3200 return build2_loc (loc, TRUTH_OR_EXPR, type,
3201 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3202 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3204 case TRUTH_OR_EXPR:
3205 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3206 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3207 return build2_loc (loc, TRUTH_AND_EXPR, type,
3208 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3209 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3211 case TRUTH_XOR_EXPR:
3212 /* Here we can invert either operand. We invert the first operand
3213 unless the second operand is a TRUTH_NOT_EXPR in which case our
3214 result is the XOR of the first operand with the inside of the
3215 negation of the second operand. */
3217 if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3218 return build2_loc (loc, TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3219 TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3220 else
3221 return build2_loc (loc, TRUTH_XOR_EXPR, type,
3222 invert_truthvalue_loc (loc, TREE_OPERAND (arg, 0)),
3223 TREE_OPERAND (arg, 1));
3225 case TRUTH_ANDIF_EXPR:
3226 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3227 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3228 return build2_loc (loc, TRUTH_ORIF_EXPR, type,
3229 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3230 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3232 case TRUTH_ORIF_EXPR:
3233 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3234 loc2 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3235 return build2_loc (loc, TRUTH_ANDIF_EXPR, type,
3236 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)),
3237 invert_truthvalue_loc (loc2, TREE_OPERAND (arg, 1)));
3239 case TRUTH_NOT_EXPR:
3240 return TREE_OPERAND (arg, 0);
3242 case COND_EXPR:
3244 tree arg1 = TREE_OPERAND (arg, 1);
3245 tree arg2 = TREE_OPERAND (arg, 2);
3247 loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3248 loc2 = expr_location_or (TREE_OPERAND (arg, 2), loc);
3250 /* A COND_EXPR may have a throw as one operand, which
3251 then has void type. Just leave void operands
3252 as they are. */
3253 return build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg, 0),
3254 VOID_TYPE_P (TREE_TYPE (arg1))
3255 ? arg1 : invert_truthvalue_loc (loc1, arg1),
3256 VOID_TYPE_P (TREE_TYPE (arg2))
3257 ? arg2 : invert_truthvalue_loc (loc2, arg2));
3260 case COMPOUND_EXPR:
3261 loc1 = expr_location_or (TREE_OPERAND (arg, 1), loc);
3262 return build2_loc (loc, COMPOUND_EXPR, type,
3263 TREE_OPERAND (arg, 0),
3264 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 1)));
3266 case NON_LVALUE_EXPR:
3267 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3268 return invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0));
3270 CASE_CONVERT:
3271 if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3272 return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3274 /* ... fall through ... */
3276 case FLOAT_EXPR:
3277 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3278 return build1_loc (loc, TREE_CODE (arg), type,
3279 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3281 case BIT_AND_EXPR:
3282 if (!integer_onep (TREE_OPERAND (arg, 1)))
3283 return NULL_TREE;
3284 return build2_loc (loc, EQ_EXPR, type, arg, build_int_cst (type, 0));
3286 case SAVE_EXPR:
3287 return build1_loc (loc, TRUTH_NOT_EXPR, type, arg);
3289 case CLEANUP_POINT_EXPR:
3290 loc1 = expr_location_or (TREE_OPERAND (arg, 0), loc);
3291 return build1_loc (loc, CLEANUP_POINT_EXPR, type,
3292 invert_truthvalue_loc (loc1, TREE_OPERAND (arg, 0)));
3294 default:
3295 return NULL_TREE;
3299 /* Fold the truth-negation of ARG. This never alters ARG itself. We
3300 assume that ARG is an operation that returns a truth value (0 or 1
3301 for scalars, 0 or -1 for vectors). Return the folded expression if
3302 folding is successful. Otherwise, return NULL_TREE. */
3304 static tree
3305 fold_invert_truthvalue (location_t loc, tree arg)
3307 tree type = TREE_TYPE (arg);
3308 return fold_unary_loc (loc, VECTOR_TYPE_P (type)
3309 ? BIT_NOT_EXPR
3310 : TRUTH_NOT_EXPR,
3311 type, arg);
3314 /* Return a simplified tree node for the truth-negation of ARG. This
3315 never alters ARG itself. We assume that ARG is an operation that
3316 returns a truth value (0 or 1 for scalars, 0 or -1 for vectors). */
3318 tree
3319 invert_truthvalue_loc (location_t loc, tree arg)
3321 if (TREE_CODE (arg) == ERROR_MARK)
3322 return arg;
3324 tree type = TREE_TYPE (arg);
3325 return fold_build1_loc (loc, VECTOR_TYPE_P (type)
3326 ? BIT_NOT_EXPR
3327 : TRUTH_NOT_EXPR,
3328 type, arg);
3331 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3332 operands are another bit-wise operation with a common input. If so,
3333 distribute the bit operations to save an operation and possibly two if
3334 constants are involved. For example, convert
3335 (A | B) & (A | C) into A | (B & C)
3336 Further simplification will occur if B and C are constants.
3338 If this optimization cannot be done, 0 will be returned. */
3340 static tree
3341 distribute_bit_expr (location_t loc, enum tree_code code, tree type,
3342 tree arg0, tree arg1)
3344 tree common;
3345 tree left, right;
3347 if (TREE_CODE (arg0) != TREE_CODE (arg1)
3348 || TREE_CODE (arg0) == code
3349 || (TREE_CODE (arg0) != BIT_AND_EXPR
3350 && TREE_CODE (arg0) != BIT_IOR_EXPR))
3351 return 0;
3353 if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3355 common = TREE_OPERAND (arg0, 0);
3356 left = TREE_OPERAND (arg0, 1);
3357 right = TREE_OPERAND (arg1, 1);
3359 else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3361 common = TREE_OPERAND (arg0, 0);
3362 left = TREE_OPERAND (arg0, 1);
3363 right = TREE_OPERAND (arg1, 0);
3365 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3367 common = TREE_OPERAND (arg0, 1);
3368 left = TREE_OPERAND (arg0, 0);
3369 right = TREE_OPERAND (arg1, 1);
3371 else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3373 common = TREE_OPERAND (arg0, 1);
3374 left = TREE_OPERAND (arg0, 0);
3375 right = TREE_OPERAND (arg1, 0);
3377 else
3378 return 0;
3380 common = fold_convert_loc (loc, type, common);
3381 left = fold_convert_loc (loc, type, left);
3382 right = fold_convert_loc (loc, type, right);
3383 return fold_build2_loc (loc, TREE_CODE (arg0), type, common,
3384 fold_build2_loc (loc, code, type, left, right));
3387 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3388 with code CODE. This optimization is unsafe. */
3389 static tree
3390 distribute_real_division (location_t loc, enum tree_code code, tree type,
3391 tree arg0, tree arg1)
3393 bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3394 bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3396 /* (A / C) +- (B / C) -> (A +- B) / C. */
3397 if (mul0 == mul1
3398 && operand_equal_p (TREE_OPERAND (arg0, 1),
3399 TREE_OPERAND (arg1, 1), 0))
3400 return fold_build2_loc (loc, mul0 ? MULT_EXPR : RDIV_EXPR, type,
3401 fold_build2_loc (loc, code, type,
3402 TREE_OPERAND (arg0, 0),
3403 TREE_OPERAND (arg1, 0)),
3404 TREE_OPERAND (arg0, 1));
3406 /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2). */
3407 if (operand_equal_p (TREE_OPERAND (arg0, 0),
3408 TREE_OPERAND (arg1, 0), 0)
3409 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3410 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3412 REAL_VALUE_TYPE r0, r1;
3413 r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3414 r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3415 if (!mul0)
3416 real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3417 if (!mul1)
3418 real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3419 real_arithmetic (&r0, code, &r0, &r1);
3420 return fold_build2_loc (loc, MULT_EXPR, type,
3421 TREE_OPERAND (arg0, 0),
3422 build_real (type, r0));
3425 return NULL_TREE;
3428 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3429 starting at BITPOS. The field is unsigned if UNSIGNEDP is nonzero. */
3431 static tree
3432 make_bit_field_ref (location_t loc, tree inner, tree type,
3433 HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos, int unsignedp)
3435 tree result, bftype;
3437 if (bitpos == 0)
3439 tree size = TYPE_SIZE (TREE_TYPE (inner));
3440 if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3441 || POINTER_TYPE_P (TREE_TYPE (inner)))
3442 && tree_fits_shwi_p (size)
3443 && tree_to_shwi (size) == bitsize)
3444 return fold_convert_loc (loc, type, inner);
3447 bftype = type;
3448 if (TYPE_PRECISION (bftype) != bitsize
3449 || TYPE_UNSIGNED (bftype) == !unsignedp)
3450 bftype = build_nonstandard_integer_type (bitsize, 0);
3452 result = build3_loc (loc, BIT_FIELD_REF, bftype, inner,
3453 size_int (bitsize), bitsize_int (bitpos));
3455 if (bftype != type)
3456 result = fold_convert_loc (loc, type, result);
3458 return result;
3461 /* Optimize a bit-field compare.
3463 There are two cases: First is a compare against a constant and the
3464 second is a comparison of two items where the fields are at the same
3465 bit position relative to the start of a chunk (byte, halfword, word)
3466 large enough to contain it. In these cases we can avoid the shift
3467 implicit in bitfield extractions.
3469 For constants, we emit a compare of the shifted constant with the
3470 BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3471 compared. For two fields at the same position, we do the ANDs with the
3472 similar mask and compare the result of the ANDs.
3474 CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3475 COMPARE_TYPE is the type of the comparison, and LHS and RHS
3476 are the left and right operands of the comparison, respectively.
3478 If the optimization described above can be done, we return the resulting
3479 tree. Otherwise we return zero. */
3481 static tree
3482 optimize_bit_field_compare (location_t loc, enum tree_code code,
3483 tree compare_type, tree lhs, tree rhs)
3485 HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3486 tree type = TREE_TYPE (lhs);
3487 tree signed_type, unsigned_type;
3488 int const_p = TREE_CODE (rhs) == INTEGER_CST;
3489 enum machine_mode lmode, rmode, nmode;
3490 int lunsignedp, runsignedp;
3491 int lvolatilep = 0, rvolatilep = 0;
3492 tree linner, rinner = NULL_TREE;
3493 tree mask;
3494 tree offset;
3496 /* Get all the information about the extractions being done. If the bit size
3497 if the same as the size of the underlying object, we aren't doing an
3498 extraction at all and so can do nothing. We also don't want to
3499 do anything if the inner expression is a PLACEHOLDER_EXPR since we
3500 then will no longer be able to replace it. */
3501 linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3502 &lunsignedp, &lvolatilep, false);
3503 if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3504 || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR || lvolatilep)
3505 return 0;
3507 if (!const_p)
3509 /* If this is not a constant, we can only do something if bit positions,
3510 sizes, and signedness are the same. */
3511 rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3512 &runsignedp, &rvolatilep, false);
3514 if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3515 || lunsignedp != runsignedp || offset != 0
3516 || TREE_CODE (rinner) == PLACEHOLDER_EXPR || rvolatilep)
3517 return 0;
3520 /* See if we can find a mode to refer to this field. We should be able to,
3521 but fail if we can't. */
3522 nmode = get_best_mode (lbitsize, lbitpos, 0, 0,
3523 const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3524 : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3525 TYPE_ALIGN (TREE_TYPE (rinner))),
3526 word_mode, false);
3527 if (nmode == VOIDmode)
3528 return 0;
3530 /* Set signed and unsigned types of the precision of this mode for the
3531 shifts below. */
3532 signed_type = lang_hooks.types.type_for_mode (nmode, 0);
3533 unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3535 /* Compute the bit position and size for the new reference and our offset
3536 within it. If the new reference is the same size as the original, we
3537 won't optimize anything, so return zero. */
3538 nbitsize = GET_MODE_BITSIZE (nmode);
3539 nbitpos = lbitpos & ~ (nbitsize - 1);
3540 lbitpos -= nbitpos;
3541 if (nbitsize == lbitsize)
3542 return 0;
3544 if (BYTES_BIG_ENDIAN)
3545 lbitpos = nbitsize - lbitsize - lbitpos;
3547 /* Make the mask to be used against the extracted field. */
3548 mask = build_int_cst_type (unsigned_type, -1);
3549 mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize));
3550 mask = const_binop (RSHIFT_EXPR, mask,
3551 size_int (nbitsize - lbitsize - lbitpos));
3553 if (! const_p)
3554 /* If not comparing with constant, just rework the comparison
3555 and return. */
3556 return fold_build2_loc (loc, code, compare_type,
3557 fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3558 make_bit_field_ref (loc, linner,
3559 unsigned_type,
3560 nbitsize, nbitpos,
3562 mask),
3563 fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3564 make_bit_field_ref (loc, rinner,
3565 unsigned_type,
3566 nbitsize, nbitpos,
3568 mask));
3570 /* Otherwise, we are handling the constant case. See if the constant is too
3571 big for the field. Warn and return a tree of for 0 (false) if so. We do
3572 this not only for its own sake, but to avoid having to test for this
3573 error case below. If we didn't, we might generate wrong code.
3575 For unsigned fields, the constant shifted right by the field length should
3576 be all zero. For signed fields, the high-order bits should agree with
3577 the sign bit. */
3579 if (lunsignedp)
3581 if (! integer_zerop (const_binop (RSHIFT_EXPR,
3582 fold_convert_loc (loc,
3583 unsigned_type, rhs),
3584 size_int (lbitsize))))
3586 warning (0, "comparison is always %d due to width of bit-field",
3587 code == NE_EXPR);
3588 return constant_boolean_node (code == NE_EXPR, compare_type);
3591 else
3593 tree tem = const_binop (RSHIFT_EXPR,
3594 fold_convert_loc (loc, signed_type, rhs),
3595 size_int (lbitsize - 1));
3596 if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3598 warning (0, "comparison is always %d due to width of bit-field",
3599 code == NE_EXPR);
3600 return constant_boolean_node (code == NE_EXPR, compare_type);
3604 /* Single-bit compares should always be against zero. */
3605 if (lbitsize == 1 && ! integer_zerop (rhs))
3607 code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3608 rhs = build_int_cst (type, 0);
3611 /* Make a new bitfield reference, shift the constant over the
3612 appropriate number of bits and mask it with the computed mask
3613 (in case this was a signed field). If we changed it, make a new one. */
3614 lhs = make_bit_field_ref (loc, linner, unsigned_type, nbitsize, nbitpos, 1);
3616 rhs = const_binop (BIT_AND_EXPR,
3617 const_binop (LSHIFT_EXPR,
3618 fold_convert_loc (loc, unsigned_type, rhs),
3619 size_int (lbitpos)),
3620 mask);
3622 lhs = build2_loc (loc, code, compare_type,
3623 build2 (BIT_AND_EXPR, unsigned_type, lhs, mask), rhs);
3624 return lhs;
3627 /* Subroutine for fold_truth_andor_1: decode a field reference.
3629 If EXP is a comparison reference, we return the innermost reference.
3631 *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3632 set to the starting bit number.
3634 If the innermost field can be completely contained in a mode-sized
3635 unit, *PMODE is set to that mode. Otherwise, it is set to VOIDmode.
3637 *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3638 otherwise it is not changed.
3640 *PUNSIGNEDP is set to the signedness of the field.
3642 *PMASK is set to the mask used. This is either contained in a
3643 BIT_AND_EXPR or derived from the width of the field.
3645 *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3647 Return 0 if this is not a component reference or is one that we can't
3648 do anything with. */
3650 static tree
3651 decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize,
3652 HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
3653 int *punsignedp, int *pvolatilep,
3654 tree *pmask, tree *pand_mask)
3656 tree outer_type = 0;
3657 tree and_mask = 0;
3658 tree mask, inner, offset;
3659 tree unsigned_type;
3660 unsigned int precision;
3662 /* All the optimizations using this function assume integer fields.
3663 There are problems with FP fields since the type_for_size call
3664 below can fail for, e.g., XFmode. */
3665 if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3666 return 0;
3668 /* We are interested in the bare arrangement of bits, so strip everything
3669 that doesn't affect the machine mode. However, record the type of the
3670 outermost expression if it may matter below. */
3671 if (CONVERT_EXPR_P (exp)
3672 || TREE_CODE (exp) == NON_LVALUE_EXPR)
3673 outer_type = TREE_TYPE (exp);
3674 STRIP_NOPS (exp);
3676 if (TREE_CODE (exp) == BIT_AND_EXPR)
3678 and_mask = TREE_OPERAND (exp, 1);
3679 exp = TREE_OPERAND (exp, 0);
3680 STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3681 if (TREE_CODE (and_mask) != INTEGER_CST)
3682 return 0;
3685 inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3686 punsignedp, pvolatilep, false);
3687 if ((inner == exp && and_mask == 0)
3688 || *pbitsize < 0 || offset != 0
3689 || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3690 return 0;
3692 /* If the number of bits in the reference is the same as the bitsize of
3693 the outer type, then the outer type gives the signedness. Otherwise
3694 (in case of a small bitfield) the signedness is unchanged. */
3695 if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3696 *punsignedp = TYPE_UNSIGNED (outer_type);
3698 /* Compute the mask to access the bitfield. */
3699 unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3700 precision = TYPE_PRECISION (unsigned_type);
3702 mask = build_int_cst_type (unsigned_type, -1);
3704 mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3705 mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize));
3707 /* Merge it with the mask we found in the BIT_AND_EXPR, if any. */
3708 if (and_mask != 0)
3709 mask = fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
3710 fold_convert_loc (loc, unsigned_type, and_mask), mask);
3712 *pmask = mask;
3713 *pand_mask = and_mask;
3714 return inner;
3717 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3718 bit positions. */
3720 static int
3721 all_ones_mask_p (const_tree mask, int size)
3723 tree type = TREE_TYPE (mask);
3724 unsigned int precision = TYPE_PRECISION (type);
3725 tree tmask;
3727 tmask = build_int_cst_type (signed_type_for (type), -1);
3729 return
3730 tree_int_cst_equal (mask,
3731 const_binop (RSHIFT_EXPR,
3732 const_binop (LSHIFT_EXPR, tmask,
3733 size_int (precision - size)),
3734 size_int (precision - size)));
3737 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3738 represents the sign bit of EXP's type. If EXP represents a sign
3739 or zero extension, also test VAL against the unextended type.
3740 The return value is the (sub)expression whose sign bit is VAL,
3741 or NULL_TREE otherwise. */
3743 static tree
3744 sign_bit_p (tree exp, const_tree val)
3746 unsigned HOST_WIDE_INT mask_lo, lo;
3747 HOST_WIDE_INT mask_hi, hi;
3748 int width;
3749 tree t;
3751 /* Tree EXP must have an integral type. */
3752 t = TREE_TYPE (exp);
3753 if (! INTEGRAL_TYPE_P (t))
3754 return NULL_TREE;
3756 /* Tree VAL must be an integer constant. */
3757 if (TREE_CODE (val) != INTEGER_CST
3758 || TREE_OVERFLOW (val))
3759 return NULL_TREE;
3761 width = TYPE_PRECISION (t);
3762 if (width > HOST_BITS_PER_WIDE_INT)
3764 hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
3765 lo = 0;
3767 mask_hi = (HOST_WIDE_INT_M1U >> (HOST_BITS_PER_DOUBLE_INT - width));
3768 mask_lo = -1;
3770 else
3772 hi = 0;
3773 lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
3775 mask_hi = 0;
3776 mask_lo = (HOST_WIDE_INT_M1U >> (HOST_BITS_PER_WIDE_INT - width));
3779 /* We mask off those bits beyond TREE_TYPE (exp) so that we can
3780 treat VAL as if it were unsigned. */
3781 if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
3782 && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
3783 return exp;
3785 /* Handle extension from a narrower type. */
3786 if (TREE_CODE (exp) == NOP_EXPR
3787 && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3788 return sign_bit_p (TREE_OPERAND (exp, 0), val);
3790 return NULL_TREE;
3793 /* Subroutine for fold_truth_andor_1: determine if an operand is simple enough
3794 to be evaluated unconditionally. */
3796 static int
3797 simple_operand_p (const_tree exp)
3799 /* Strip any conversions that don't change the machine mode. */
3800 STRIP_NOPS (exp);
3802 return (CONSTANT_CLASS_P (exp)
3803 || TREE_CODE (exp) == SSA_NAME
3804 || (DECL_P (exp)
3805 && ! TREE_ADDRESSABLE (exp)
3806 && ! TREE_THIS_VOLATILE (exp)
3807 && ! DECL_NONLOCAL (exp)
3808 /* Don't regard global variables as simple. They may be
3809 allocated in ways unknown to the compiler (shared memory,
3810 #pragma weak, etc). */
3811 && ! TREE_PUBLIC (exp)
3812 && ! DECL_EXTERNAL (exp)
3813 /* Weakrefs are not safe to be read, since they can be NULL.
3814 They are !TREE_PUBLIC && !DECL_EXTERNAL but still
3815 have DECL_WEAK flag set. */
3816 && (! VAR_OR_FUNCTION_DECL_P (exp) || ! DECL_WEAK (exp))
3817 /* Loading a static variable is unduly expensive, but global
3818 registers aren't expensive. */
3819 && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3822 /* Subroutine for fold_truth_andor: determine if an operand is simple enough
3823 to be evaluated unconditionally.
3824 I addition to simple_operand_p, we assume that comparisons, conversions,
3825 and logic-not operations are simple, if their operands are simple, too. */
3827 static bool
3828 simple_operand_p_2 (tree exp)
3830 enum tree_code code;
3832 if (TREE_SIDE_EFFECTS (exp)
3833 || tree_could_trap_p (exp))
3834 return false;
3836 while (CONVERT_EXPR_P (exp))
3837 exp = TREE_OPERAND (exp, 0);
3839 code = TREE_CODE (exp);
3841 if (TREE_CODE_CLASS (code) == tcc_comparison)
3842 return (simple_operand_p (TREE_OPERAND (exp, 0))
3843 && simple_operand_p (TREE_OPERAND (exp, 1)));
3845 if (code == TRUTH_NOT_EXPR)
3846 return simple_operand_p_2 (TREE_OPERAND (exp, 0));
3848 return simple_operand_p (exp);
3852 /* The following functions are subroutines to fold_range_test and allow it to
3853 try to change a logical combination of comparisons into a range test.
3855 For example, both
3856 X == 2 || X == 3 || X == 4 || X == 5
3858 X >= 2 && X <= 5
3859 are converted to
3860 (unsigned) (X - 2) <= 3
3862 We describe each set of comparisons as being either inside or outside
3863 a range, using a variable named like IN_P, and then describe the
3864 range with a lower and upper bound. If one of the bounds is omitted,
3865 it represents either the highest or lowest value of the type.
3867 In the comments below, we represent a range by two numbers in brackets
3868 preceded by a "+" to designate being inside that range, or a "-" to
3869 designate being outside that range, so the condition can be inverted by
3870 flipping the prefix. An omitted bound is represented by a "-". For
3871 example, "- [-, 10]" means being outside the range starting at the lowest
3872 possible value and ending at 10, in other words, being greater than 10.
3873 The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3874 always false.
3876 We set up things so that the missing bounds are handled in a consistent
3877 manner so neither a missing bound nor "true" and "false" need to be
3878 handled using a special case. */
3880 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3881 of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3882 and UPPER1_P are nonzero if the respective argument is an upper bound
3883 and zero for a lower. TYPE, if nonzero, is the type of the result; it
3884 must be specified for a comparison. ARG1 will be converted to ARG0's
3885 type if both are specified. */
3887 static tree
3888 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
3889 tree arg1, int upper1_p)
3891 tree tem;
3892 int result;
3893 int sgn0, sgn1;
3895 /* If neither arg represents infinity, do the normal operation.
3896 Else, if not a comparison, return infinity. Else handle the special
3897 comparison rules. Note that most of the cases below won't occur, but
3898 are handled for consistency. */
3900 if (arg0 != 0 && arg1 != 0)
3902 tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3903 arg0, fold_convert (TREE_TYPE (arg0), arg1));
3904 STRIP_NOPS (tem);
3905 return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3908 if (TREE_CODE_CLASS (code) != tcc_comparison)
3909 return 0;
3911 /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3912 for neither. In real maths, we cannot assume open ended ranges are
3913 the same. But, this is computer arithmetic, where numbers are finite.
3914 We can therefore make the transformation of any unbounded range with
3915 the value Z, Z being greater than any representable number. This permits
3916 us to treat unbounded ranges as equal. */
3917 sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3918 sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3919 switch (code)
3921 case EQ_EXPR:
3922 result = sgn0 == sgn1;
3923 break;
3924 case NE_EXPR:
3925 result = sgn0 != sgn1;
3926 break;
3927 case LT_EXPR:
3928 result = sgn0 < sgn1;
3929 break;
3930 case LE_EXPR:
3931 result = sgn0 <= sgn1;
3932 break;
3933 case GT_EXPR:
3934 result = sgn0 > sgn1;
3935 break;
3936 case GE_EXPR:
3937 result = sgn0 >= sgn1;
3938 break;
3939 default:
3940 gcc_unreachable ();
3943 return constant_boolean_node (result, type);
3946 /* Helper routine for make_range. Perform one step for it, return
3947 new expression if the loop should continue or NULL_TREE if it should
3948 stop. */
3950 tree
3951 make_range_step (location_t loc, enum tree_code code, tree arg0, tree arg1,
3952 tree exp_type, tree *p_low, tree *p_high, int *p_in_p,
3953 bool *strict_overflow_p)
3955 tree arg0_type = TREE_TYPE (arg0);
3956 tree n_low, n_high, low = *p_low, high = *p_high;
3957 int in_p = *p_in_p, n_in_p;
3959 switch (code)
3961 case TRUTH_NOT_EXPR:
3962 /* We can only do something if the range is testing for zero. */
3963 if (low == NULL_TREE || high == NULL_TREE
3964 || ! integer_zerop (low) || ! integer_zerop (high))
3965 return NULL_TREE;
3966 *p_in_p = ! in_p;
3967 return arg0;
3969 case EQ_EXPR: case NE_EXPR:
3970 case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3971 /* We can only do something if the range is testing for zero
3972 and if the second operand is an integer constant. Note that
3973 saying something is "in" the range we make is done by
3974 complementing IN_P since it will set in the initial case of
3975 being not equal to zero; "out" is leaving it alone. */
3976 if (low == NULL_TREE || high == NULL_TREE
3977 || ! integer_zerop (low) || ! integer_zerop (high)
3978 || TREE_CODE (arg1) != INTEGER_CST)
3979 return NULL_TREE;
3981 switch (code)
3983 case NE_EXPR: /* - [c, c] */
3984 low = high = arg1;
3985 break;
3986 case EQ_EXPR: /* + [c, c] */
3987 in_p = ! in_p, low = high = arg1;
3988 break;
3989 case GT_EXPR: /* - [-, c] */
3990 low = 0, high = arg1;
3991 break;
3992 case GE_EXPR: /* + [c, -] */
3993 in_p = ! in_p, low = arg1, high = 0;
3994 break;
3995 case LT_EXPR: /* - [c, -] */
3996 low = arg1, high = 0;
3997 break;
3998 case LE_EXPR: /* + [-, c] */
3999 in_p = ! in_p, low = 0, high = arg1;
4000 break;
4001 default:
4002 gcc_unreachable ();
4005 /* If this is an unsigned comparison, we also know that EXP is
4006 greater than or equal to zero. We base the range tests we make
4007 on that fact, so we record it here so we can parse existing
4008 range tests. We test arg0_type since often the return type
4009 of, e.g. EQ_EXPR, is boolean. */
4010 if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
4012 if (! merge_ranges (&n_in_p, &n_low, &n_high,
4013 in_p, low, high, 1,
4014 build_int_cst (arg0_type, 0),
4015 NULL_TREE))
4016 return NULL_TREE;
4018 in_p = n_in_p, low = n_low, high = n_high;
4020 /* If the high bound is missing, but we have a nonzero low
4021 bound, reverse the range so it goes from zero to the low bound
4022 minus 1. */
4023 if (high == 0 && low && ! integer_zerop (low))
4025 in_p = ! in_p;
4026 high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
4027 integer_one_node, 0);
4028 low = build_int_cst (arg0_type, 0);
4032 *p_low = low;
4033 *p_high = high;
4034 *p_in_p = in_p;
4035 return arg0;
4037 case NEGATE_EXPR:
4038 /* If flag_wrapv and ARG0_TYPE is signed, make sure
4039 low and high are non-NULL, then normalize will DTRT. */
4040 if (!TYPE_UNSIGNED (arg0_type)
4041 && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4043 if (low == NULL_TREE)
4044 low = TYPE_MIN_VALUE (arg0_type);
4045 if (high == NULL_TREE)
4046 high = TYPE_MAX_VALUE (arg0_type);
4049 /* (-x) IN [a,b] -> x in [-b, -a] */
4050 n_low = range_binop (MINUS_EXPR, exp_type,
4051 build_int_cst (exp_type, 0),
4052 0, high, 1);
4053 n_high = range_binop (MINUS_EXPR, exp_type,
4054 build_int_cst (exp_type, 0),
4055 0, low, 0);
4056 if (n_high != 0 && TREE_OVERFLOW (n_high))
4057 return NULL_TREE;
4058 goto normalize;
4060 case BIT_NOT_EXPR:
4061 /* ~ X -> -X - 1 */
4062 return build2_loc (loc, MINUS_EXPR, exp_type, negate_expr (arg0),
4063 build_int_cst (exp_type, 1));
4065 case PLUS_EXPR:
4066 case MINUS_EXPR:
4067 if (TREE_CODE (arg1) != INTEGER_CST)
4068 return NULL_TREE;
4070 /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4071 move a constant to the other side. */
4072 if (!TYPE_UNSIGNED (arg0_type)
4073 && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4074 return NULL_TREE;
4076 /* If EXP is signed, any overflow in the computation is undefined,
4077 so we don't worry about it so long as our computations on
4078 the bounds don't overflow. For unsigned, overflow is defined
4079 and this is exactly the right thing. */
4080 n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4081 arg0_type, low, 0, arg1, 0);
4082 n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4083 arg0_type, high, 1, arg1, 0);
4084 if ((n_low != 0 && TREE_OVERFLOW (n_low))
4085 || (n_high != 0 && TREE_OVERFLOW (n_high)))
4086 return NULL_TREE;
4088 if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
4089 *strict_overflow_p = true;
4091 normalize:
4092 /* Check for an unsigned range which has wrapped around the maximum
4093 value thus making n_high < n_low, and normalize it. */
4094 if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
4096 low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
4097 integer_one_node, 0);
4098 high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
4099 integer_one_node, 0);
4101 /* If the range is of the form +/- [ x+1, x ], we won't
4102 be able to normalize it. But then, it represents the
4103 whole range or the empty set, so make it
4104 +/- [ -, - ]. */
4105 if (tree_int_cst_equal (n_low, low)
4106 && tree_int_cst_equal (n_high, high))
4107 low = high = 0;
4108 else
4109 in_p = ! in_p;
4111 else
4112 low = n_low, high = n_high;
4114 *p_low = low;
4115 *p_high = high;
4116 *p_in_p = in_p;
4117 return arg0;
4119 CASE_CONVERT:
4120 case NON_LVALUE_EXPR:
4121 if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4122 return NULL_TREE;
4124 if (! INTEGRAL_TYPE_P (arg0_type)
4125 || (low != 0 && ! int_fits_type_p (low, arg0_type))
4126 || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4127 return NULL_TREE;
4129 n_low = low, n_high = high;
4131 if (n_low != 0)
4132 n_low = fold_convert_loc (loc, arg0_type, n_low);
4134 if (n_high != 0)
4135 n_high = fold_convert_loc (loc, arg0_type, n_high);
4137 /* If we're converting arg0 from an unsigned type, to exp,
4138 a signed type, we will be doing the comparison as unsigned.
4139 The tests above have already verified that LOW and HIGH
4140 are both positive.
4142 So we have to ensure that we will handle large unsigned
4143 values the same way that the current signed bounds treat
4144 negative values. */
4146 if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4148 tree high_positive;
4149 tree equiv_type;
4150 /* For fixed-point modes, we need to pass the saturating flag
4151 as the 2nd parameter. */
4152 if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4153 equiv_type
4154 = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type),
4155 TYPE_SATURATING (arg0_type));
4156 else
4157 equiv_type
4158 = lang_hooks.types.type_for_mode (TYPE_MODE (arg0_type), 1);
4160 /* A range without an upper bound is, naturally, unbounded.
4161 Since convert would have cropped a very large value, use
4162 the max value for the destination type. */
4163 high_positive
4164 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4165 : TYPE_MAX_VALUE (arg0_type);
4167 if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4168 high_positive = fold_build2_loc (loc, RSHIFT_EXPR, arg0_type,
4169 fold_convert_loc (loc, arg0_type,
4170 high_positive),
4171 build_int_cst (arg0_type, 1));
4173 /* If the low bound is specified, "and" the range with the
4174 range for which the original unsigned value will be
4175 positive. */
4176 if (low != 0)
4178 if (! merge_ranges (&n_in_p, &n_low, &n_high, 1, n_low, n_high,
4179 1, fold_convert_loc (loc, arg0_type,
4180 integer_zero_node),
4181 high_positive))
4182 return NULL_TREE;
4184 in_p = (n_in_p == in_p);
4186 else
4188 /* Otherwise, "or" the range with the range of the input
4189 that will be interpreted as negative. */
4190 if (! merge_ranges (&n_in_p, &n_low, &n_high, 0, n_low, n_high,
4191 1, fold_convert_loc (loc, arg0_type,
4192 integer_zero_node),
4193 high_positive))
4194 return NULL_TREE;
4196 in_p = (in_p != n_in_p);
4200 *p_low = n_low;
4201 *p_high = n_high;
4202 *p_in_p = in_p;
4203 return arg0;
4205 default:
4206 return NULL_TREE;
4210 /* Given EXP, a logical expression, set the range it is testing into
4211 variables denoted by PIN_P, PLOW, and PHIGH. Return the expression
4212 actually being tested. *PLOW and *PHIGH will be made of the same
4213 type as the returned expression. If EXP is not a comparison, we
4214 will most likely not be returning a useful value and range. Set
4215 *STRICT_OVERFLOW_P to true if the return value is only valid
4216 because signed overflow is undefined; otherwise, do not change
4217 *STRICT_OVERFLOW_P. */
4219 tree
4220 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
4221 bool *strict_overflow_p)
4223 enum tree_code code;
4224 tree arg0, arg1 = NULL_TREE;
4225 tree exp_type, nexp;
4226 int in_p;
4227 tree low, high;
4228 location_t loc = EXPR_LOCATION (exp);
4230 /* Start with simply saying "EXP != 0" and then look at the code of EXP
4231 and see if we can refine the range. Some of the cases below may not
4232 happen, but it doesn't seem worth worrying about this. We "continue"
4233 the outer loop when we've changed something; otherwise we "break"
4234 the switch, which will "break" the while. */
4236 in_p = 0;
4237 low = high = build_int_cst (TREE_TYPE (exp), 0);
4239 while (1)
4241 code = TREE_CODE (exp);
4242 exp_type = TREE_TYPE (exp);
4243 arg0 = NULL_TREE;
4245 if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
4247 if (TREE_OPERAND_LENGTH (exp) > 0)
4248 arg0 = TREE_OPERAND (exp, 0);
4249 if (TREE_CODE_CLASS (code) == tcc_binary
4250 || TREE_CODE_CLASS (code) == tcc_comparison
4251 || (TREE_CODE_CLASS (code) == tcc_expression
4252 && TREE_OPERAND_LENGTH (exp) > 1))
4253 arg1 = TREE_OPERAND (exp, 1);
4255 if (arg0 == NULL_TREE)
4256 break;
4258 nexp = make_range_step (loc, code, arg0, arg1, exp_type, &low,
4259 &high, &in_p, strict_overflow_p);
4260 if (nexp == NULL_TREE)
4261 break;
4262 exp = nexp;
4265 /* If EXP is a constant, we can evaluate whether this is true or false. */
4266 if (TREE_CODE (exp) == INTEGER_CST)
4268 in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4269 exp, 0, low, 0))
4270 && integer_onep (range_binop (LE_EXPR, integer_type_node,
4271 exp, 1, high, 1)));
4272 low = high = 0;
4273 exp = 0;
4276 *pin_p = in_p, *plow = low, *phigh = high;
4277 return exp;
4280 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4281 type, TYPE, return an expression to test if EXP is in (or out of, depending
4282 on IN_P) the range. Return 0 if the test couldn't be created. */
4284 tree
4285 build_range_check (location_t loc, tree type, tree exp, int in_p,
4286 tree low, tree high)
4288 tree etype = TREE_TYPE (exp), value;
4290 #ifdef HAVE_canonicalize_funcptr_for_compare
4291 /* Disable this optimization for function pointer expressions
4292 on targets that require function pointer canonicalization. */
4293 if (HAVE_canonicalize_funcptr_for_compare
4294 && TREE_CODE (etype) == POINTER_TYPE
4295 && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4296 return NULL_TREE;
4297 #endif
4299 if (! in_p)
4301 value = build_range_check (loc, type, exp, 1, low, high);
4302 if (value != 0)
4303 return invert_truthvalue_loc (loc, value);
4305 return 0;
4308 if (low == 0 && high == 0)
4309 return omit_one_operand_loc (loc, type, build_int_cst (type, 1), exp);
4311 if (low == 0)
4312 return fold_build2_loc (loc, LE_EXPR, type, exp,
4313 fold_convert_loc (loc, etype, high));
4315 if (high == 0)
4316 return fold_build2_loc (loc, GE_EXPR, type, exp,
4317 fold_convert_loc (loc, etype, low));
4319 if (operand_equal_p (low, high, 0))
4320 return fold_build2_loc (loc, EQ_EXPR, type, exp,
4321 fold_convert_loc (loc, etype, low));
4323 if (integer_zerop (low))
4325 if (! TYPE_UNSIGNED (etype))
4327 etype = unsigned_type_for (etype);
4328 high = fold_convert_loc (loc, etype, high);
4329 exp = fold_convert_loc (loc, etype, exp);
4331 return build_range_check (loc, type, exp, 1, 0, high);
4334 /* Optimize (c>=1) && (c<=127) into (signed char)c > 0. */
4335 if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4337 unsigned HOST_WIDE_INT lo;
4338 HOST_WIDE_INT hi;
4339 int prec;
4341 prec = TYPE_PRECISION (etype);
4342 if (prec <= HOST_BITS_PER_WIDE_INT)
4344 hi = 0;
4345 lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
4347 else
4349 hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
4350 lo = HOST_WIDE_INT_M1U;
4353 if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
4355 if (TYPE_UNSIGNED (etype))
4357 tree signed_etype = signed_type_for (etype);
4358 if (TYPE_PRECISION (signed_etype) != TYPE_PRECISION (etype))
4359 etype
4360 = build_nonstandard_integer_type (TYPE_PRECISION (etype), 0);
4361 else
4362 etype = signed_etype;
4363 exp = fold_convert_loc (loc, etype, exp);
4365 return fold_build2_loc (loc, GT_EXPR, type, exp,
4366 build_int_cst (etype, 0));
4370 /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4371 This requires wrap-around arithmetics for the type of the expression.
4372 First make sure that arithmetics in this type is valid, then make sure
4373 that it wraps around. */
4374 if (TREE_CODE (etype) == ENUMERAL_TYPE || TREE_CODE (etype) == BOOLEAN_TYPE)
4375 etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4376 TYPE_UNSIGNED (etype));
4378 if (TREE_CODE (etype) == INTEGER_TYPE && !TYPE_OVERFLOW_WRAPS (etype))
4380 tree utype, minv, maxv;
4382 /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4383 for the type in question, as we rely on this here. */
4384 utype = unsigned_type_for (etype);
4385 maxv = fold_convert_loc (loc, utype, TYPE_MAX_VALUE (etype));
4386 maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4387 integer_one_node, 1);
4388 minv = fold_convert_loc (loc, utype, TYPE_MIN_VALUE (etype));
4390 if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4391 minv, 1, maxv, 1)))
4392 etype = utype;
4393 else
4394 return 0;
4397 high = fold_convert_loc (loc, etype, high);
4398 low = fold_convert_loc (loc, etype, low);
4399 exp = fold_convert_loc (loc, etype, exp);
4401 value = const_binop (MINUS_EXPR, high, low);
4404 if (POINTER_TYPE_P (etype))
4406 if (value != 0 && !TREE_OVERFLOW (value))
4408 low = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (low), low);
4409 return build_range_check (loc, type,
4410 fold_build_pointer_plus_loc (loc, exp, low),
4411 1, build_int_cst (etype, 0), value);
4413 return 0;
4416 if (value != 0 && !TREE_OVERFLOW (value))
4417 return build_range_check (loc, type,
4418 fold_build2_loc (loc, MINUS_EXPR, etype, exp, low),
4419 1, build_int_cst (etype, 0), value);
4421 return 0;
4424 /* Return the predecessor of VAL in its type, handling the infinite case. */
4426 static tree
4427 range_predecessor (tree val)
4429 tree type = TREE_TYPE (val);
4431 if (INTEGRAL_TYPE_P (type)
4432 && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4433 return 0;
4434 else
4435 return range_binop (MINUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4438 /* Return the successor of VAL in its type, handling the infinite case. */
4440 static tree
4441 range_successor (tree val)
4443 tree type = TREE_TYPE (val);
4445 if (INTEGRAL_TYPE_P (type)
4446 && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4447 return 0;
4448 else
4449 return range_binop (PLUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4452 /* Given two ranges, see if we can merge them into one. Return 1 if we
4453 can, 0 if we can't. Set the output range into the specified parameters. */
4455 bool
4456 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4457 tree high0, int in1_p, tree low1, tree high1)
4459 int no_overlap;
4460 int subset;
4461 int temp;
4462 tree tem;
4463 int in_p;
4464 tree low, high;
4465 int lowequal = ((low0 == 0 && low1 == 0)
4466 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4467 low0, 0, low1, 0)));
4468 int highequal = ((high0 == 0 && high1 == 0)
4469 || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4470 high0, 1, high1, 1)));
4472 /* Make range 0 be the range that starts first, or ends last if they
4473 start at the same value. Swap them if it isn't. */
4474 if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4475 low0, 0, low1, 0))
4476 || (lowequal
4477 && integer_onep (range_binop (GT_EXPR, integer_type_node,
4478 high1, 1, high0, 1))))
4480 temp = in0_p, in0_p = in1_p, in1_p = temp;
4481 tem = low0, low0 = low1, low1 = tem;
4482 tem = high0, high0 = high1, high1 = tem;
4485 /* Now flag two cases, whether the ranges are disjoint or whether the
4486 second range is totally subsumed in the first. Note that the tests
4487 below are simplified by the ones above. */
4488 no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4489 high0, 1, low1, 0));
4490 subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4491 high1, 1, high0, 1));
4493 /* We now have four cases, depending on whether we are including or
4494 excluding the two ranges. */
4495 if (in0_p && in1_p)
4497 /* If they don't overlap, the result is false. If the second range
4498 is a subset it is the result. Otherwise, the range is from the start
4499 of the second to the end of the first. */
4500 if (no_overlap)
4501 in_p = 0, low = high = 0;
4502 else if (subset)
4503 in_p = 1, low = low1, high = high1;
4504 else
4505 in_p = 1, low = low1, high = high0;
4508 else if (in0_p && ! in1_p)
4510 /* If they don't overlap, the result is the first range. If they are
4511 equal, the result is false. If the second range is a subset of the
4512 first, and the ranges begin at the same place, we go from just after
4513 the end of the second range to the end of the first. If the second
4514 range is not a subset of the first, or if it is a subset and both
4515 ranges end at the same place, the range starts at the start of the
4516 first range and ends just before the second range.
4517 Otherwise, we can't describe this as a single range. */
4518 if (no_overlap)
4519 in_p = 1, low = low0, high = high0;
4520 else if (lowequal && highequal)
4521 in_p = 0, low = high = 0;
4522 else if (subset && lowequal)
4524 low = range_successor (high1);
4525 high = high0;
4526 in_p = 1;
4527 if (low == 0)
4529 /* We are in the weird situation where high0 > high1 but
4530 high1 has no successor. Punt. */
4531 return 0;
4534 else if (! subset || highequal)
4536 low = low0;
4537 high = range_predecessor (low1);
4538 in_p = 1;
4539 if (high == 0)
4541 /* low0 < low1 but low1 has no predecessor. Punt. */
4542 return 0;
4545 else
4546 return 0;
4549 else if (! in0_p && in1_p)
4551 /* If they don't overlap, the result is the second range. If the second
4552 is a subset of the first, the result is false. Otherwise,
4553 the range starts just after the first range and ends at the
4554 end of the second. */
4555 if (no_overlap)
4556 in_p = 1, low = low1, high = high1;
4557 else if (subset || highequal)
4558 in_p = 0, low = high = 0;
4559 else
4561 low = range_successor (high0);
4562 high = high1;
4563 in_p = 1;
4564 if (low == 0)
4566 /* high1 > high0 but high0 has no successor. Punt. */
4567 return 0;
4572 else
4574 /* The case where we are excluding both ranges. Here the complex case
4575 is if they don't overlap. In that case, the only time we have a
4576 range is if they are adjacent. If the second is a subset of the
4577 first, the result is the first. Otherwise, the range to exclude
4578 starts at the beginning of the first range and ends at the end of the
4579 second. */
4580 if (no_overlap)
4582 if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4583 range_successor (high0),
4584 1, low1, 0)))
4585 in_p = 0, low = low0, high = high1;
4586 else
4588 /* Canonicalize - [min, x] into - [-, x]. */
4589 if (low0 && TREE_CODE (low0) == INTEGER_CST)
4590 switch (TREE_CODE (TREE_TYPE (low0)))
4592 case ENUMERAL_TYPE:
4593 if (TYPE_PRECISION (TREE_TYPE (low0))
4594 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4595 break;
4596 /* FALLTHROUGH */
4597 case INTEGER_TYPE:
4598 if (tree_int_cst_equal (low0,
4599 TYPE_MIN_VALUE (TREE_TYPE (low0))))
4600 low0 = 0;
4601 break;
4602 case POINTER_TYPE:
4603 if (TYPE_UNSIGNED (TREE_TYPE (low0))
4604 && integer_zerop (low0))
4605 low0 = 0;
4606 break;
4607 default:
4608 break;
4611 /* Canonicalize - [x, max] into - [x, -]. */
4612 if (high1 && TREE_CODE (high1) == INTEGER_CST)
4613 switch (TREE_CODE (TREE_TYPE (high1)))
4615 case ENUMERAL_TYPE:
4616 if (TYPE_PRECISION (TREE_TYPE (high1))
4617 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4618 break;
4619 /* FALLTHROUGH */
4620 case INTEGER_TYPE:
4621 if (tree_int_cst_equal (high1,
4622 TYPE_MAX_VALUE (TREE_TYPE (high1))))
4623 high1 = 0;
4624 break;
4625 case POINTER_TYPE:
4626 if (TYPE_UNSIGNED (TREE_TYPE (high1))
4627 && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4628 high1, 1,
4629 integer_one_node, 1)))
4630 high1 = 0;
4631 break;
4632 default:
4633 break;
4636 /* The ranges might be also adjacent between the maximum and
4637 minimum values of the given type. For
4638 - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4639 return + [x + 1, y - 1]. */
4640 if (low0 == 0 && high1 == 0)
4642 low = range_successor (high0);
4643 high = range_predecessor (low1);
4644 if (low == 0 || high == 0)
4645 return 0;
4647 in_p = 1;
4649 else
4650 return 0;
4653 else if (subset)
4654 in_p = 0, low = low0, high = high0;
4655 else
4656 in_p = 0, low = low0, high = high1;
4659 *pin_p = in_p, *plow = low, *phigh = high;
4660 return 1;
4664 /* Subroutine of fold, looking inside expressions of the form
4665 A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4666 of the COND_EXPR. This function is being used also to optimize
4667 A op B ? C : A, by reversing the comparison first.
4669 Return a folded expression whose code is not a COND_EXPR
4670 anymore, or NULL_TREE if no folding opportunity is found. */
4672 static tree
4673 fold_cond_expr_with_comparison (location_t loc, tree type,
4674 tree arg0, tree arg1, tree arg2)
4676 enum tree_code comp_code = TREE_CODE (arg0);
4677 tree arg00 = TREE_OPERAND (arg0, 0);
4678 tree arg01 = TREE_OPERAND (arg0, 1);
4679 tree arg1_type = TREE_TYPE (arg1);
4680 tree tem;
4682 STRIP_NOPS (arg1);
4683 STRIP_NOPS (arg2);
4685 /* If we have A op 0 ? A : -A, consider applying the following
4686 transformations:
4688 A == 0? A : -A same as -A
4689 A != 0? A : -A same as A
4690 A >= 0? A : -A same as abs (A)
4691 A > 0? A : -A same as abs (A)
4692 A <= 0? A : -A same as -abs (A)
4693 A < 0? A : -A same as -abs (A)
4695 None of these transformations work for modes with signed
4696 zeros. If A is +/-0, the first two transformations will
4697 change the sign of the result (from +0 to -0, or vice
4698 versa). The last four will fix the sign of the result,
4699 even though the original expressions could be positive or
4700 negative, depending on the sign of A.
4702 Note that all these transformations are correct if A is
4703 NaN, since the two alternatives (A and -A) are also NaNs. */
4704 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4705 && (FLOAT_TYPE_P (TREE_TYPE (arg01))
4706 ? real_zerop (arg01)
4707 : integer_zerop (arg01))
4708 && ((TREE_CODE (arg2) == NEGATE_EXPR
4709 && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4710 /* In the case that A is of the form X-Y, '-A' (arg2) may
4711 have already been folded to Y-X, check for that. */
4712 || (TREE_CODE (arg1) == MINUS_EXPR
4713 && TREE_CODE (arg2) == MINUS_EXPR
4714 && operand_equal_p (TREE_OPERAND (arg1, 0),
4715 TREE_OPERAND (arg2, 1), 0)
4716 && operand_equal_p (TREE_OPERAND (arg1, 1),
4717 TREE_OPERAND (arg2, 0), 0))))
4718 switch (comp_code)
4720 case EQ_EXPR:
4721 case UNEQ_EXPR:
4722 tem = fold_convert_loc (loc, arg1_type, arg1);
4723 return pedantic_non_lvalue_loc (loc,
4724 fold_convert_loc (loc, type,
4725 negate_expr (tem)));
4726 case NE_EXPR:
4727 case LTGT_EXPR:
4728 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4729 case UNGE_EXPR:
4730 case UNGT_EXPR:
4731 if (flag_trapping_math)
4732 break;
4733 /* Fall through. */
4734 case GE_EXPR:
4735 case GT_EXPR:
4736 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4737 arg1 = fold_convert_loc (loc, signed_type_for
4738 (TREE_TYPE (arg1)), arg1);
4739 tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4740 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4741 case UNLE_EXPR:
4742 case UNLT_EXPR:
4743 if (flag_trapping_math)
4744 break;
4745 case LE_EXPR:
4746 case LT_EXPR:
4747 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4748 arg1 = fold_convert_loc (loc, signed_type_for
4749 (TREE_TYPE (arg1)), arg1);
4750 tem = fold_build1_loc (loc, ABS_EXPR, TREE_TYPE (arg1), arg1);
4751 return negate_expr (fold_convert_loc (loc, type, tem));
4752 default:
4753 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4754 break;
4757 /* A != 0 ? A : 0 is simply A, unless A is -0. Likewise
4758 A == 0 ? A : 0 is always 0 unless A is -0. Note that
4759 both transformations are correct when A is NaN: A != 0
4760 is then true, and A == 0 is false. */
4762 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4763 && integer_zerop (arg01) && integer_zerop (arg2))
4765 if (comp_code == NE_EXPR)
4766 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4767 else if (comp_code == EQ_EXPR)
4768 return build_zero_cst (type);
4771 /* Try some transformations of A op B ? A : B.
4773 A == B? A : B same as B
4774 A != B? A : B same as A
4775 A >= B? A : B same as max (A, B)
4776 A > B? A : B same as max (B, A)
4777 A <= B? A : B same as min (A, B)
4778 A < B? A : B same as min (B, A)
4780 As above, these transformations don't work in the presence
4781 of signed zeros. For example, if A and B are zeros of
4782 opposite sign, the first two transformations will change
4783 the sign of the result. In the last four, the original
4784 expressions give different results for (A=+0, B=-0) and
4785 (A=-0, B=+0), but the transformed expressions do not.
4787 The first two transformations are correct if either A or B
4788 is a NaN. In the first transformation, the condition will
4789 be false, and B will indeed be chosen. In the case of the
4790 second transformation, the condition A != B will be true,
4791 and A will be chosen.
4793 The conversions to max() and min() are not correct if B is
4794 a number and A is not. The conditions in the original
4795 expressions will be false, so all four give B. The min()
4796 and max() versions would give a NaN instead. */
4797 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type))
4798 && operand_equal_for_comparison_p (arg01, arg2, arg00)
4799 /* Avoid these transformations if the COND_EXPR may be used
4800 as an lvalue in the C++ front-end. PR c++/19199. */
4801 && (in_gimple_form
4802 || VECTOR_TYPE_P (type)
4803 || (strcmp (lang_hooks.name, "GNU C++") != 0
4804 && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
4805 || ! maybe_lvalue_p (arg1)
4806 || ! maybe_lvalue_p (arg2)))
4808 tree comp_op0 = arg00;
4809 tree comp_op1 = arg01;
4810 tree comp_type = TREE_TYPE (comp_op0);
4812 /* Avoid adding NOP_EXPRs in case this is an lvalue. */
4813 if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4815 comp_type = type;
4816 comp_op0 = arg1;
4817 comp_op1 = arg2;
4820 switch (comp_code)
4822 case EQ_EXPR:
4823 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg2));
4824 case NE_EXPR:
4825 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
4826 case LE_EXPR:
4827 case LT_EXPR:
4828 case UNLE_EXPR:
4829 case UNLT_EXPR:
4830 /* In C++ a ?: expression can be an lvalue, so put the
4831 operand which will be used if they are equal first
4832 so that we can convert this back to the
4833 corresponding COND_EXPR. */
4834 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4836 comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4837 comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4838 tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4839 ? fold_build2_loc (loc, MIN_EXPR, comp_type, comp_op0, comp_op1)
4840 : fold_build2_loc (loc, MIN_EXPR, comp_type,
4841 comp_op1, comp_op0);
4842 return pedantic_non_lvalue_loc (loc,
4843 fold_convert_loc (loc, type, tem));
4845 break;
4846 case GE_EXPR:
4847 case GT_EXPR:
4848 case UNGE_EXPR:
4849 case UNGT_EXPR:
4850 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4852 comp_op0 = fold_convert_loc (loc, comp_type, comp_op0);
4853 comp_op1 = fold_convert_loc (loc, comp_type, comp_op1);
4854 tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4855 ? fold_build2_loc (loc, MAX_EXPR, comp_type, comp_op0, comp_op1)
4856 : fold_build2_loc (loc, MAX_EXPR, comp_type,
4857 comp_op1, comp_op0);
4858 return pedantic_non_lvalue_loc (loc,
4859 fold_convert_loc (loc, type, tem));
4861 break;
4862 case UNEQ_EXPR:
4863 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4864 return pedantic_non_lvalue_loc (loc,
4865 fold_convert_loc (loc, type, arg2));
4866 break;
4867 case LTGT_EXPR:
4868 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4869 return pedantic_non_lvalue_loc (loc,
4870 fold_convert_loc (loc, type, arg1));
4871 break;
4872 default:
4873 gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4874 break;
4878 /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4879 we might still be able to simplify this. For example,
4880 if C1 is one less or one more than C2, this might have started
4881 out as a MIN or MAX and been transformed by this function.
4882 Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE. */
4884 if (INTEGRAL_TYPE_P (type)
4885 && TREE_CODE (arg01) == INTEGER_CST
4886 && TREE_CODE (arg2) == INTEGER_CST)
4887 switch (comp_code)
4889 case EQ_EXPR:
4890 if (TREE_CODE (arg1) == INTEGER_CST)
4891 break;
4892 /* We can replace A with C1 in this case. */
4893 arg1 = fold_convert_loc (loc, type, arg01);
4894 return fold_build3_loc (loc, COND_EXPR, type, arg0, arg1, arg2);
4896 case LT_EXPR:
4897 /* If C1 is C2 + 1, this is min(A, C2), but use ARG00's type for
4898 MIN_EXPR, to preserve the signedness of the comparison. */
4899 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4900 OEP_ONLY_CONST)
4901 && operand_equal_p (arg01,
4902 const_binop (PLUS_EXPR, arg2,
4903 build_int_cst (type, 1)),
4904 OEP_ONLY_CONST))
4906 tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
4907 fold_convert_loc (loc, TREE_TYPE (arg00),
4908 arg2));
4909 return pedantic_non_lvalue_loc (loc,
4910 fold_convert_loc (loc, type, tem));
4912 break;
4914 case LE_EXPR:
4915 /* If C1 is C2 - 1, this is min(A, C2), with the same care
4916 as above. */
4917 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4918 OEP_ONLY_CONST)
4919 && operand_equal_p (arg01,
4920 const_binop (MINUS_EXPR, arg2,
4921 build_int_cst (type, 1)),
4922 OEP_ONLY_CONST))
4924 tem = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (arg00), arg00,
4925 fold_convert_loc (loc, TREE_TYPE (arg00),
4926 arg2));
4927 return pedantic_non_lvalue_loc (loc,
4928 fold_convert_loc (loc, type, tem));
4930 break;
4932 case GT_EXPR:
4933 /* If C1 is C2 - 1, this is max(A, C2), but use ARG00's type for
4934 MAX_EXPR, to preserve the signedness of the comparison. */
4935 if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4936 OEP_ONLY_CONST)
4937 && operand_equal_p (arg01,
4938 const_binop (MINUS_EXPR, arg2,
4939 build_int_cst (type, 1)),
4940 OEP_ONLY_CONST))
4942 tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
4943 fold_convert_loc (loc, TREE_TYPE (arg00),
4944 arg2));
4945 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4947 break;
4949 case GE_EXPR:
4950 /* If C1 is C2 + 1, this is max(A, C2), with the same care as above. */
4951 if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4952 OEP_ONLY_CONST)
4953 && operand_equal_p (arg01,
4954 const_binop (PLUS_EXPR, arg2,
4955 build_int_cst (type, 1)),
4956 OEP_ONLY_CONST))
4958 tem = fold_build2_loc (loc, MAX_EXPR, TREE_TYPE (arg00), arg00,
4959 fold_convert_loc (loc, TREE_TYPE (arg00),
4960 arg2));
4961 return pedantic_non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
4963 break;
4964 case NE_EXPR:
4965 break;
4966 default:
4967 gcc_unreachable ();
4970 return NULL_TREE;
4975 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
4976 #define LOGICAL_OP_NON_SHORT_CIRCUIT \
4977 (BRANCH_COST (optimize_function_for_speed_p (cfun), \
4978 false) >= 2)
4979 #endif
4981 /* EXP is some logical combination of boolean tests. See if we can
4982 merge it into some range test. Return the new tree if so. */
4984 static tree
4985 fold_range_test (location_t loc, enum tree_code code, tree type,
4986 tree op0, tree op1)
4988 int or_op = (code == TRUTH_ORIF_EXPR
4989 || code == TRUTH_OR_EXPR);
4990 int in0_p, in1_p, in_p;
4991 tree low0, low1, low, high0, high1, high;
4992 bool strict_overflow_p = false;
4993 tree tem, lhs, rhs;
4994 const char * const warnmsg = G_("assuming signed overflow does not occur "
4995 "when simplifying range test");
4997 if (!INTEGRAL_TYPE_P (type))
4998 return 0;
5000 lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
5001 rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
5003 /* If this is an OR operation, invert both sides; we will invert
5004 again at the end. */
5005 if (or_op)
5006 in0_p = ! in0_p, in1_p = ! in1_p;
5008 /* If both expressions are the same, if we can merge the ranges, and we
5009 can build the range test, return it or it inverted. If one of the
5010 ranges is always true or always false, consider it to be the same
5011 expression as the other. */
5012 if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
5013 && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
5014 in1_p, low1, high1)
5015 && 0 != (tem = (build_range_check (loc, type,
5016 lhs != 0 ? lhs
5017 : rhs != 0 ? rhs : integer_zero_node,
5018 in_p, low, high))))
5020 if (strict_overflow_p)
5021 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
5022 return or_op ? invert_truthvalue_loc (loc, tem) : tem;
5025 /* On machines where the branch cost is expensive, if this is a
5026 short-circuited branch and the underlying object on both sides
5027 is the same, make a non-short-circuit operation. */
5028 else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5029 && lhs != 0 && rhs != 0
5030 && (code == TRUTH_ANDIF_EXPR
5031 || code == TRUTH_ORIF_EXPR)
5032 && operand_equal_p (lhs, rhs, 0))
5034 /* If simple enough, just rewrite. Otherwise, make a SAVE_EXPR
5035 unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5036 which cases we can't do this. */
5037 if (simple_operand_p (lhs))
5038 return build2_loc (loc, code == TRUTH_ANDIF_EXPR
5039 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5040 type, op0, op1);
5042 else if (!lang_hooks.decls.global_bindings_p ()
5043 && !CONTAINS_PLACEHOLDER_P (lhs))
5045 tree common = save_expr (lhs);
5047 if (0 != (lhs = build_range_check (loc, type, common,
5048 or_op ? ! in0_p : in0_p,
5049 low0, high0))
5050 && (0 != (rhs = build_range_check (loc, type, common,
5051 or_op ? ! in1_p : in1_p,
5052 low1, high1))))
5054 if (strict_overflow_p)
5055 fold_overflow_warning (warnmsg,
5056 WARN_STRICT_OVERFLOW_COMPARISON);
5057 return build2_loc (loc, code == TRUTH_ANDIF_EXPR
5058 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5059 type, lhs, rhs);
5064 return 0;
5067 /* Subroutine for fold_truth_andor_1: C is an INTEGER_CST interpreted as a P
5068 bit value. Arrange things so the extra bits will be set to zero if and
5069 only if C is signed-extended to its full width. If MASK is nonzero,
5070 it is an INTEGER_CST that should be AND'ed with the extra bits. */
5072 static tree
5073 unextend (tree c, int p, int unsignedp, tree mask)
5075 tree type = TREE_TYPE (c);
5076 int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
5077 tree temp;
5079 if (p == modesize || unsignedp)
5080 return c;
5082 /* We work by getting just the sign bit into the low-order bit, then
5083 into the high-order bit, then sign-extend. We then XOR that value
5084 with C. */
5085 temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1));
5086 temp = const_binop (BIT_AND_EXPR, temp, size_int (1));
5088 /* We must use a signed type in order to get an arithmetic right shift.
5089 However, we must also avoid introducing accidental overflows, so that
5090 a subsequent call to integer_zerop will work. Hence we must
5091 do the type conversion here. At this point, the constant is either
5092 zero or one, and the conversion to a signed type can never overflow.
5093 We could get an overflow if this conversion is done anywhere else. */
5094 if (TYPE_UNSIGNED (type))
5095 temp = fold_convert (signed_type_for (type), temp);
5097 temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1));
5098 temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1));
5099 if (mask != 0)
5100 temp = const_binop (BIT_AND_EXPR, temp,
5101 fold_convert (TREE_TYPE (c), mask));
5102 /* If necessary, convert the type back to match the type of C. */
5103 if (TYPE_UNSIGNED (type))
5104 temp = fold_convert (type, temp);
5106 return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp));
5109 /* For an expression that has the form
5110 (A && B) || ~B
5112 (A || B) && ~B,
5113 we can drop one of the inner expressions and simplify to
5114 A || ~B
5116 A && ~B
5117 LOC is the location of the resulting expression. OP is the inner
5118 logical operation; the left-hand side in the examples above, while CMPOP
5119 is the right-hand side. RHS_ONLY is used to prevent us from accidentally
5120 removing a condition that guards another, as in
5121 (A != NULL && A->...) || A == NULL
5122 which we must not transform. If RHS_ONLY is true, only eliminate the
5123 right-most operand of the inner logical operation. */
5125 static tree
5126 merge_truthop_with_opposite_arm (location_t loc, tree op, tree cmpop,
5127 bool rhs_only)
5129 tree type = TREE_TYPE (cmpop);
5130 enum tree_code code = TREE_CODE (cmpop);
5131 enum tree_code truthop_code = TREE_CODE (op);
5132 tree lhs = TREE_OPERAND (op, 0);
5133 tree rhs = TREE_OPERAND (op, 1);
5134 tree orig_lhs = lhs, orig_rhs = rhs;
5135 enum tree_code rhs_code = TREE_CODE (rhs);
5136 enum tree_code lhs_code = TREE_CODE (lhs);
5137 enum tree_code inv_code;
5139 if (TREE_SIDE_EFFECTS (op) || TREE_SIDE_EFFECTS (cmpop))
5140 return NULL_TREE;
5142 if (TREE_CODE_CLASS (code) != tcc_comparison)
5143 return NULL_TREE;
5145 if (rhs_code == truthop_code)
5147 tree newrhs = merge_truthop_with_opposite_arm (loc, rhs, cmpop, rhs_only);
5148 if (newrhs != NULL_TREE)
5150 rhs = newrhs;
5151 rhs_code = TREE_CODE (rhs);
5154 if (lhs_code == truthop_code && !rhs_only)
5156 tree newlhs = merge_truthop_with_opposite_arm (loc, lhs, cmpop, false);
5157 if (newlhs != NULL_TREE)
5159 lhs = newlhs;
5160 lhs_code = TREE_CODE (lhs);
5164 inv_code = invert_tree_comparison (code, HONOR_NANS (TYPE_MODE (type)));
5165 if (inv_code == rhs_code
5166 && operand_equal_p (TREE_OPERAND (rhs, 0), TREE_OPERAND (cmpop, 0), 0)
5167 && operand_equal_p (TREE_OPERAND (rhs, 1), TREE_OPERAND (cmpop, 1), 0))
5168 return lhs;
5169 if (!rhs_only && inv_code == lhs_code
5170 && operand_equal_p (TREE_OPERAND (lhs, 0), TREE_OPERAND (cmpop, 0), 0)
5171 && operand_equal_p (TREE_OPERAND (lhs, 1), TREE_OPERAND (cmpop, 1), 0))
5172 return rhs;
5173 if (rhs != orig_rhs || lhs != orig_lhs)
5174 return fold_build2_loc (loc, truthop_code, TREE_TYPE (cmpop),
5175 lhs, rhs);
5176 return NULL_TREE;
5179 /* Find ways of folding logical expressions of LHS and RHS:
5180 Try to merge two comparisons to the same innermost item.
5181 Look for range tests like "ch >= '0' && ch <= '9'".
5182 Look for combinations of simple terms on machines with expensive branches
5183 and evaluate the RHS unconditionally.
5185 For example, if we have p->a == 2 && p->b == 4 and we can make an
5186 object large enough to span both A and B, we can do this with a comparison
5187 against the object ANDed with the a mask.
5189 If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5190 operations to do this with one comparison.
5192 We check for both normal comparisons and the BIT_AND_EXPRs made this by
5193 function and the one above.
5195 CODE is the logical operation being done. It can be TRUTH_ANDIF_EXPR,
5196 TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5198 TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5199 two operands.
5201 We return the simplified tree or 0 if no optimization is possible. */
5203 static tree
5204 fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
5205 tree lhs, tree rhs)
5207 /* If this is the "or" of two comparisons, we can do something if
5208 the comparisons are NE_EXPR. If this is the "and", we can do something
5209 if the comparisons are EQ_EXPR. I.e.,
5210 (a->b == 2 && a->c == 4) can become (a->new == NEW).
5212 WANTED_CODE is this operation code. For single bit fields, we can
5213 convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5214 comparison for one-bit fields. */
5216 enum tree_code wanted_code;
5217 enum tree_code lcode, rcode;
5218 tree ll_arg, lr_arg, rl_arg, rr_arg;
5219 tree ll_inner, lr_inner, rl_inner, rr_inner;
5220 HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5221 HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5222 HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5223 HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5224 int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5225 enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5226 enum machine_mode lnmode, rnmode;
5227 tree ll_mask, lr_mask, rl_mask, rr_mask;
5228 tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5229 tree l_const, r_const;
5230 tree lntype, rntype, result;
5231 HOST_WIDE_INT first_bit, end_bit;
5232 int volatilep;
5234 /* Start by getting the comparison codes. Fail if anything is volatile.
5235 If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5236 it were surrounded with a NE_EXPR. */
5238 if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5239 return 0;
5241 lcode = TREE_CODE (lhs);
5242 rcode = TREE_CODE (rhs);
5244 if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5246 lhs = build2 (NE_EXPR, truth_type, lhs,
5247 build_int_cst (TREE_TYPE (lhs), 0));
5248 lcode = NE_EXPR;
5251 if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5253 rhs = build2 (NE_EXPR, truth_type, rhs,
5254 build_int_cst (TREE_TYPE (rhs), 0));
5255 rcode = NE_EXPR;
5258 if (TREE_CODE_CLASS (lcode) != tcc_comparison
5259 || TREE_CODE_CLASS (rcode) != tcc_comparison)
5260 return 0;
5262 ll_arg = TREE_OPERAND (lhs, 0);
5263 lr_arg = TREE_OPERAND (lhs, 1);
5264 rl_arg = TREE_OPERAND (rhs, 0);
5265 rr_arg = TREE_OPERAND (rhs, 1);
5267 /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations. */
5268 if (simple_operand_p (ll_arg)
5269 && simple_operand_p (lr_arg))
5271 if (operand_equal_p (ll_arg, rl_arg, 0)
5272 && operand_equal_p (lr_arg, rr_arg, 0))
5274 result = combine_comparisons (loc, code, lcode, rcode,
5275 truth_type, ll_arg, lr_arg);
5276 if (result)
5277 return result;
5279 else if (operand_equal_p (ll_arg, rr_arg, 0)
5280 && operand_equal_p (lr_arg, rl_arg, 0))
5282 result = combine_comparisons (loc, code, lcode,
5283 swap_tree_comparison (rcode),
5284 truth_type, ll_arg, lr_arg);
5285 if (result)
5286 return result;
5290 code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5291 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5293 /* If the RHS can be evaluated unconditionally and its operands are
5294 simple, it wins to evaluate the RHS unconditionally on machines
5295 with expensive branches. In this case, this isn't a comparison
5296 that can be merged. */
5298 if (BRANCH_COST (optimize_function_for_speed_p (cfun),
5299 false) >= 2
5300 && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5301 && simple_operand_p (rl_arg)
5302 && simple_operand_p (rr_arg))
5304 /* Convert (a != 0) || (b != 0) into (a | b) != 0. */
5305 if (code == TRUTH_OR_EXPR
5306 && lcode == NE_EXPR && integer_zerop (lr_arg)
5307 && rcode == NE_EXPR && integer_zerop (rr_arg)
5308 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5309 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5310 return build2_loc (loc, NE_EXPR, truth_type,
5311 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5312 ll_arg, rl_arg),
5313 build_int_cst (TREE_TYPE (ll_arg), 0));
5315 /* Convert (a == 0) && (b == 0) into (a | b) == 0. */
5316 if (code == TRUTH_AND_EXPR
5317 && lcode == EQ_EXPR && integer_zerop (lr_arg)
5318 && rcode == EQ_EXPR && integer_zerop (rr_arg)
5319 && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg)
5320 && INTEGRAL_TYPE_P (TREE_TYPE (ll_arg)))
5321 return build2_loc (loc, EQ_EXPR, truth_type,
5322 build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5323 ll_arg, rl_arg),
5324 build_int_cst (TREE_TYPE (ll_arg), 0));
5327 /* See if the comparisons can be merged. Then get all the parameters for
5328 each side. */
5330 if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5331 || (rcode != EQ_EXPR && rcode != NE_EXPR))
5332 return 0;
5334 volatilep = 0;
5335 ll_inner = decode_field_reference (loc, ll_arg,
5336 &ll_bitsize, &ll_bitpos, &ll_mode,
5337 &ll_unsignedp, &volatilep, &ll_mask,
5338 &ll_and_mask);
5339 lr_inner = decode_field_reference (loc, lr_arg,
5340 &lr_bitsize, &lr_bitpos, &lr_mode,
5341 &lr_unsignedp, &volatilep, &lr_mask,
5342 &lr_and_mask);
5343 rl_inner = decode_field_reference (loc, rl_arg,
5344 &rl_bitsize, &rl_bitpos, &rl_mode,
5345 &rl_unsignedp, &volatilep, &rl_mask,
5346 &rl_and_mask);
5347 rr_inner = decode_field_reference (loc, rr_arg,
5348 &rr_bitsize, &rr_bitpos, &rr_mode,
5349 &rr_unsignedp, &volatilep, &rr_mask,
5350 &rr_and_mask);
5352 /* It must be true that the inner operation on the lhs of each
5353 comparison must be the same if we are to be able to do anything.
5354 Then see if we have constants. If not, the same must be true for
5355 the rhs's. */
5356 if (volatilep || ll_inner == 0 || rl_inner == 0
5357 || ! operand_equal_p (ll_inner, rl_inner, 0))
5358 return 0;
5360 if (TREE_CODE (lr_arg) == INTEGER_CST
5361 && TREE_CODE (rr_arg) == INTEGER_CST)
5362 l_const = lr_arg, r_const = rr_arg;
5363 else if (lr_inner == 0 || rr_inner == 0
5364 || ! operand_equal_p (lr_inner, rr_inner, 0))
5365 return 0;
5366 else
5367 l_const = r_const = 0;
5369 /* If either comparison code is not correct for our logical operation,
5370 fail. However, we can convert a one-bit comparison against zero into
5371 the opposite comparison against that bit being set in the field. */
5373 wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5374 if (lcode != wanted_code)
5376 if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5378 /* Make the left operand unsigned, since we are only interested
5379 in the value of one bit. Otherwise we are doing the wrong
5380 thing below. */
5381 ll_unsignedp = 1;
5382 l_const = ll_mask;
5384 else
5385 return 0;
5388 /* This is analogous to the code for l_const above. */
5389 if (rcode != wanted_code)
5391 if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5393 rl_unsignedp = 1;
5394 r_const = rl_mask;
5396 else
5397 return 0;
5400 /* See if we can find a mode that contains both fields being compared on
5401 the left. If we can't, fail. Otherwise, update all constants and masks
5402 to be relative to a field of that size. */
5403 first_bit = MIN (ll_bitpos, rl_bitpos);
5404 end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5405 lnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5406 TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5407 volatilep);
5408 if (lnmode == VOIDmode)
5409 return 0;
5411 lnbitsize = GET_MODE_BITSIZE (lnmode);
5412 lnbitpos = first_bit & ~ (lnbitsize - 1);
5413 lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5414 xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5416 if (BYTES_BIG_ENDIAN)
5418 xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5419 xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5422 ll_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, ll_mask),
5423 size_int (xll_bitpos));
5424 rl_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc, lntype, rl_mask),
5425 size_int (xrl_bitpos));
5427 if (l_const)
5429 l_const = fold_convert_loc (loc, lntype, l_const);
5430 l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5431 l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos));
5432 if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5433 fold_build1_loc (loc, BIT_NOT_EXPR,
5434 lntype, ll_mask))))
5436 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5438 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5441 if (r_const)
5443 r_const = fold_convert_loc (loc, lntype, r_const);
5444 r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5445 r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos));
5446 if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5447 fold_build1_loc (loc, BIT_NOT_EXPR,
5448 lntype, rl_mask))))
5450 warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5452 return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5456 /* If the right sides are not constant, do the same for it. Also,
5457 disallow this optimization if a size or signedness mismatch occurs
5458 between the left and right sides. */
5459 if (l_const == 0)
5461 if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5462 || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5463 /* Make sure the two fields on the right
5464 correspond to the left without being swapped. */
5465 || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5466 return 0;
5468 first_bit = MIN (lr_bitpos, rr_bitpos);
5469 end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5470 rnmode = get_best_mode (end_bit - first_bit, first_bit, 0, 0,
5471 TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5472 volatilep);
5473 if (rnmode == VOIDmode)
5474 return 0;
5476 rnbitsize = GET_MODE_BITSIZE (rnmode);
5477 rnbitpos = first_bit & ~ (rnbitsize - 1);
5478 rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5479 xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5481 if (BYTES_BIG_ENDIAN)
5483 xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5484 xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5487 lr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5488 rntype, lr_mask),
5489 size_int (xlr_bitpos));
5490 rr_mask = const_binop (LSHIFT_EXPR, fold_convert_loc (loc,
5491 rntype, rr_mask),
5492 size_int (xrr_bitpos));
5494 /* Make a mask that corresponds to both fields being compared.
5495 Do this for both items being compared. If the operands are the
5496 same size and the bits being compared are in the same position
5497 then we can do this by masking both and comparing the masked
5498 results. */
5499 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5500 lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
5501 if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5503 lhs = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5504 ll_unsignedp || rl_unsignedp);
5505 if (! all_ones_mask_p (ll_mask, lnbitsize))
5506 lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5508 rhs = make_bit_field_ref (loc, lr_inner, rntype, rnbitsize, rnbitpos,
5509 lr_unsignedp || rr_unsignedp);
5510 if (! all_ones_mask_p (lr_mask, rnbitsize))
5511 rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5513 return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5516 /* There is still another way we can do something: If both pairs of
5517 fields being compared are adjacent, we may be able to make a wider
5518 field containing them both.
5520 Note that we still must mask the lhs/rhs expressions. Furthermore,
5521 the mask must be shifted to account for the shift done by
5522 make_bit_field_ref. */
5523 if ((ll_bitsize + ll_bitpos == rl_bitpos
5524 && lr_bitsize + lr_bitpos == rr_bitpos)
5525 || (ll_bitpos == rl_bitpos + rl_bitsize
5526 && lr_bitpos == rr_bitpos + rr_bitsize))
5528 tree type;
5530 lhs = make_bit_field_ref (loc, ll_inner, lntype,
5531 ll_bitsize + rl_bitsize,
5532 MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5533 rhs = make_bit_field_ref (loc, lr_inner, rntype,
5534 lr_bitsize + rr_bitsize,
5535 MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5537 ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5538 size_int (MIN (xll_bitpos, xrl_bitpos)));
5539 lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5540 size_int (MIN (xlr_bitpos, xrr_bitpos)));
5542 /* Convert to the smaller type before masking out unwanted bits. */
5543 type = lntype;
5544 if (lntype != rntype)
5546 if (lnbitsize > rnbitsize)
5548 lhs = fold_convert_loc (loc, rntype, lhs);
5549 ll_mask = fold_convert_loc (loc, rntype, ll_mask);
5550 type = rntype;
5552 else if (lnbitsize < rnbitsize)
5554 rhs = fold_convert_loc (loc, lntype, rhs);
5555 lr_mask = fold_convert_loc (loc, lntype, lr_mask);
5556 type = lntype;
5560 if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5561 lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5563 if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5564 rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5566 return build2_loc (loc, wanted_code, truth_type, lhs, rhs);
5569 return 0;
5572 /* Handle the case of comparisons with constants. If there is something in
5573 common between the masks, those bits of the constants must be the same.
5574 If not, the condition is always false. Test for this to avoid generating
5575 incorrect code below. */
5576 result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask);
5577 if (! integer_zerop (result)
5578 && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const),
5579 const_binop (BIT_AND_EXPR, result, r_const)) != 1)
5581 if (wanted_code == NE_EXPR)
5583 warning (0, "%<or%> of unmatched not-equal tests is always 1");
5584 return constant_boolean_node (true, truth_type);
5586 else
5588 warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5589 return constant_boolean_node (false, truth_type);
5593 /* Construct the expression we will return. First get the component
5594 reference we will make. Unless the mask is all ones the width of
5595 that field, perform the mask operation. Then compare with the
5596 merged constant. */
5597 result = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
5598 ll_unsignedp || rl_unsignedp);
5600 ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
5601 if (! all_ones_mask_p (ll_mask, lnbitsize))
5602 result = build2_loc (loc, BIT_AND_EXPR, lntype, result, ll_mask);
5604 return build2_loc (loc, wanted_code, truth_type, result,
5605 const_binop (BIT_IOR_EXPR, l_const, r_const));
5608 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5609 constant. */
5611 static tree
5612 optimize_minmax_comparison (location_t loc, enum tree_code code, tree type,
5613 tree op0, tree op1)
5615 tree arg0 = op0;
5616 enum tree_code op_code;
5617 tree comp_const;
5618 tree minmax_const;
5619 int consts_equal, consts_lt;
5620 tree inner;
5622 STRIP_SIGN_NOPS (arg0);
5624 op_code = TREE_CODE (arg0);
5625 minmax_const = TREE_OPERAND (arg0, 1);
5626 comp_const = fold_convert_loc (loc, TREE_TYPE (arg0), op1);
5627 consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5628 consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5629 inner = TREE_OPERAND (arg0, 0);
5631 /* If something does not permit us to optimize, return the original tree. */
5632 if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5633 || TREE_CODE (comp_const) != INTEGER_CST
5634 || TREE_OVERFLOW (comp_const)
5635 || TREE_CODE (minmax_const) != INTEGER_CST
5636 || TREE_OVERFLOW (minmax_const))
5637 return NULL_TREE;
5639 /* Now handle all the various comparison codes. We only handle EQ_EXPR
5640 and GT_EXPR, doing the rest with recursive calls using logical
5641 simplifications. */
5642 switch (code)
5644 case NE_EXPR: case LT_EXPR: case LE_EXPR:
5646 tree tem
5647 = optimize_minmax_comparison (loc,
5648 invert_tree_comparison (code, false),
5649 type, op0, op1);
5650 if (tem)
5651 return invert_truthvalue_loc (loc, tem);
5652 return NULL_TREE;
5655 case GE_EXPR:
5656 return
5657 fold_build2_loc (loc, TRUTH_ORIF_EXPR, type,
5658 optimize_minmax_comparison
5659 (loc, EQ_EXPR, type, arg0, comp_const),
5660 optimize_minmax_comparison
5661 (loc, GT_EXPR, type, arg0, comp_const));
5663 case EQ_EXPR:
5664 if (op_code == MAX_EXPR && consts_equal)
5665 /* MAX (X, 0) == 0 -> X <= 0 */
5666 return fold_build2_loc (loc, LE_EXPR, type, inner, comp_const);
5668 else if (op_code == MAX_EXPR && consts_lt)
5669 /* MAX (X, 0) == 5 -> X == 5 */
5670 return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5672 else if (op_code == MAX_EXPR)
5673 /* MAX (X, 0) == -1 -> false */
5674 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5676 else if (consts_equal)
5677 /* MIN (X, 0) == 0 -> X >= 0 */
5678 return fold_build2_loc (loc, GE_EXPR, type, inner, comp_const);
5680 else if (consts_lt)
5681 /* MIN (X, 0) == 5 -> false */
5682 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5684 else
5685 /* MIN (X, 0) == -1 -> X == -1 */
5686 return fold_build2_loc (loc, EQ_EXPR, type, inner, comp_const);
5688 case GT_EXPR:
5689 if (op_code == MAX_EXPR && (consts_equal || consts_lt))
5690 /* MAX (X, 0) > 0 -> X > 0
5691 MAX (X, 0) > 5 -> X > 5 */
5692 return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5694 else if (op_code == MAX_EXPR)
5695 /* MAX (X, 0) > -1 -> true */
5696 return omit_one_operand_loc (loc, type, integer_one_node, inner);
5698 else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5699 /* MIN (X, 0) > 0 -> false
5700 MIN (X, 0) > 5 -> false */
5701 return omit_one_operand_loc (loc, type, integer_zero_node, inner);
5703 else
5704 /* MIN (X, 0) > -1 -> X > -1 */
5705 return fold_build2_loc (loc, GT_EXPR, type, inner, comp_const);
5707 default:
5708 return NULL_TREE;
5712 /* T is an integer expression that is being multiplied, divided, or taken a
5713 modulus (CODE says which and what kind of divide or modulus) by a
5714 constant C. See if we can eliminate that operation by folding it with
5715 other operations already in T. WIDE_TYPE, if non-null, is a type that
5716 should be used for the computation if wider than our type.
5718 For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5719 (X * 2) + (Y * 4). We must, however, be assured that either the original
5720 expression would not overflow or that overflow is undefined for the type
5721 in the language in question.
5723 If we return a non-null expression, it is an equivalent form of the
5724 original computation, but need not be in the original type.
5726 We set *STRICT_OVERFLOW_P to true if the return values depends on
5727 signed overflow being undefined. Otherwise we do not change
5728 *STRICT_OVERFLOW_P. */
5730 static tree
5731 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
5732 bool *strict_overflow_p)
5734 /* To avoid exponential search depth, refuse to allow recursion past
5735 three levels. Beyond that (1) it's highly unlikely that we'll find
5736 something interesting and (2) we've probably processed it before
5737 when we built the inner expression. */
5739 static int depth;
5740 tree ret;
5742 if (depth > 3)
5743 return NULL;
5745 depth++;
5746 ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
5747 depth--;
5749 return ret;
5752 static tree
5753 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
5754 bool *strict_overflow_p)
5756 tree type = TREE_TYPE (t);
5757 enum tree_code tcode = TREE_CODE (t);
5758 tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5759 > GET_MODE_SIZE (TYPE_MODE (type)))
5760 ? wide_type : type);
5761 tree t1, t2;
5762 int same_p = tcode == code;
5763 tree op0 = NULL_TREE, op1 = NULL_TREE;
5764 bool sub_strict_overflow_p;
5766 /* Don't deal with constants of zero here; they confuse the code below. */
5767 if (integer_zerop (c))
5768 return NULL_TREE;
5770 if (TREE_CODE_CLASS (tcode) == tcc_unary)
5771 op0 = TREE_OPERAND (t, 0);
5773 if (TREE_CODE_CLASS (tcode) == tcc_binary)
5774 op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5776 /* Note that we need not handle conditional operations here since fold
5777 already handles those cases. So just do arithmetic here. */
5778 switch (tcode)
5780 case INTEGER_CST:
5781 /* For a constant, we can always simplify if we are a multiply
5782 or (for divide and modulus) if it is a multiple of our constant. */
5783 if (code == MULT_EXPR
5784 || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c)))
5785 return const_binop (code, fold_convert (ctype, t),
5786 fold_convert (ctype, c));
5787 break;
5789 CASE_CONVERT: case NON_LVALUE_EXPR:
5790 /* If op0 is an expression ... */
5791 if ((COMPARISON_CLASS_P (op0)
5792 || UNARY_CLASS_P (op0)
5793 || BINARY_CLASS_P (op0)
5794 || VL_EXP_CLASS_P (op0)
5795 || EXPRESSION_CLASS_P (op0))
5796 /* ... and has wrapping overflow, and its type is smaller
5797 than ctype, then we cannot pass through as widening. */
5798 && ((TYPE_OVERFLOW_WRAPS (TREE_TYPE (op0))
5799 && (TYPE_PRECISION (ctype)
5800 > TYPE_PRECISION (TREE_TYPE (op0))))
5801 /* ... or this is a truncation (t is narrower than op0),
5802 then we cannot pass through this narrowing. */
5803 || (TYPE_PRECISION (type)
5804 < TYPE_PRECISION (TREE_TYPE (op0)))
5805 /* ... or signedness changes for division or modulus,
5806 then we cannot pass through this conversion. */
5807 || (code != MULT_EXPR
5808 && (TYPE_UNSIGNED (ctype)
5809 != TYPE_UNSIGNED (TREE_TYPE (op0))))
5810 /* ... or has undefined overflow while the converted to
5811 type has not, we cannot do the operation in the inner type
5812 as that would introduce undefined overflow. */
5813 || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))
5814 && !TYPE_OVERFLOW_UNDEFINED (type))))
5815 break;
5817 /* Pass the constant down and see if we can make a simplification. If
5818 we can, replace this expression with the inner simplification for
5819 possible later conversion to our or some other type. */
5820 if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5821 && TREE_CODE (t2) == INTEGER_CST
5822 && !TREE_OVERFLOW (t2)
5823 && (0 != (t1 = extract_muldiv (op0, t2, code,
5824 code == MULT_EXPR
5825 ? ctype : NULL_TREE,
5826 strict_overflow_p))))
5827 return t1;
5828 break;
5830 case ABS_EXPR:
5831 /* If widening the type changes it from signed to unsigned, then we
5832 must avoid building ABS_EXPR itself as unsigned. */
5833 if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
5835 tree cstype = (*signed_type_for) (ctype);
5836 if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
5837 != 0)
5839 t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
5840 return fold_convert (ctype, t1);
5842 break;
5844 /* If the constant is negative, we cannot simplify this. */
5845 if (tree_int_cst_sgn (c) == -1)
5846 break;
5847 /* FALLTHROUGH */
5848 case NEGATE_EXPR:
5849 /* For division and modulus, type can't be unsigned, as e.g.
5850 (-(x / 2U)) / 2U isn't equal to -((x / 2U) / 2U) for x >= 2.
5851 For signed types, even with wrapping overflow, this is fine. */
5852 if (code != MULT_EXPR && TYPE_UNSIGNED (type))
5853 break;
5854 if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
5855 != 0)
5856 return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
5857 break;
5859 case MIN_EXPR: case MAX_EXPR:
5860 /* If widening the type changes the signedness, then we can't perform
5861 this optimization as that changes the result. */
5862 if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5863 break;
5865 /* MIN (a, b) / 5 -> MIN (a / 5, b / 5) */
5866 sub_strict_overflow_p = false;
5867 if ((t1 = extract_muldiv (op0, c, code, wide_type,
5868 &sub_strict_overflow_p)) != 0
5869 && (t2 = extract_muldiv (op1, c, code, wide_type,
5870 &sub_strict_overflow_p)) != 0)
5872 if (tree_int_cst_sgn (c) < 0)
5873 tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5874 if (sub_strict_overflow_p)
5875 *strict_overflow_p = true;
5876 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5877 fold_convert (ctype, t2));
5879 break;
5881 case LSHIFT_EXPR: case RSHIFT_EXPR:
5882 /* If the second operand is constant, this is a multiplication
5883 or floor division, by a power of two, so we can treat it that
5884 way unless the multiplier or divisor overflows. Signed
5885 left-shift overflow is implementation-defined rather than
5886 undefined in C90, so do not convert signed left shift into
5887 multiplication. */
5888 if (TREE_CODE (op1) == INTEGER_CST
5889 && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
5890 /* const_binop may not detect overflow correctly,
5891 so check for it explicitly here. */
5892 && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5893 && TREE_INT_CST_HIGH (op1) == 0
5894 && 0 != (t1 = fold_convert (ctype,
5895 const_binop (LSHIFT_EXPR,
5896 size_one_node,
5897 op1)))
5898 && !TREE_OVERFLOW (t1))
5899 return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5900 ? MULT_EXPR : FLOOR_DIV_EXPR,
5901 ctype,
5902 fold_convert (ctype, op0),
5903 t1),
5904 c, code, wide_type, strict_overflow_p);
5905 break;
5907 case PLUS_EXPR: case MINUS_EXPR:
5908 /* See if we can eliminate the operation on both sides. If we can, we
5909 can return a new PLUS or MINUS. If we can't, the only remaining
5910 cases where we can do anything are if the second operand is a
5911 constant. */
5912 sub_strict_overflow_p = false;
5913 t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
5914 t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
5915 if (t1 != 0 && t2 != 0
5916 && (code == MULT_EXPR
5917 /* If not multiplication, we can only do this if both operands
5918 are divisible by c. */
5919 || (multiple_of_p (ctype, op0, c)
5920 && multiple_of_p (ctype, op1, c))))
5922 if (sub_strict_overflow_p)
5923 *strict_overflow_p = true;
5924 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5925 fold_convert (ctype, t2));
5928 /* If this was a subtraction, negate OP1 and set it to be an addition.
5929 This simplifies the logic below. */
5930 if (tcode == MINUS_EXPR)
5932 tcode = PLUS_EXPR, op1 = negate_expr (op1);
5933 /* If OP1 was not easily negatable, the constant may be OP0. */
5934 if (TREE_CODE (op0) == INTEGER_CST)
5936 tree tem = op0;
5937 op0 = op1;
5938 op1 = tem;
5939 tem = t1;
5940 t1 = t2;
5941 t2 = tem;
5945 if (TREE_CODE (op1) != INTEGER_CST)
5946 break;
5948 /* If either OP1 or C are negative, this optimization is not safe for
5949 some of the division and remainder types while for others we need
5950 to change the code. */
5951 if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5953 if (code == CEIL_DIV_EXPR)
5954 code = FLOOR_DIV_EXPR;
5955 else if (code == FLOOR_DIV_EXPR)
5956 code = CEIL_DIV_EXPR;
5957 else if (code != MULT_EXPR
5958 && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5959 break;
5962 /* If it's a multiply or a division/modulus operation of a multiple
5963 of our constant, do the operation and verify it doesn't overflow. */
5964 if (code == MULT_EXPR
5965 || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
5967 op1 = const_binop (code, fold_convert (ctype, op1),
5968 fold_convert (ctype, c));
5969 /* We allow the constant to overflow with wrapping semantics. */
5970 if (op1 == 0
5971 || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
5972 break;
5974 else
5975 break;
5977 /* If we have an unsigned type, we cannot widen the operation since it
5978 will change the result if the original computation overflowed. */
5979 if (TYPE_UNSIGNED (ctype) && ctype != type)
5980 break;
5982 /* If we were able to eliminate our operation from the first side,
5983 apply our operation to the second side and reform the PLUS. */
5984 if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5985 return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
5987 /* The last case is if we are a multiply. In that case, we can
5988 apply the distributive law to commute the multiply and addition
5989 if the multiplication of the constants doesn't overflow
5990 and overflow is defined. With undefined overflow
5991 op0 * c might overflow, while (op0 + orig_op1) * c doesn't. */
5992 if (code == MULT_EXPR && TYPE_OVERFLOW_WRAPS (ctype))
5993 return fold_build2 (tcode, ctype,
5994 fold_build2 (code, ctype,
5995 fold_convert (ctype, op0),
5996 fold_convert (ctype, c)),
5997 op1);
5999 break;
6001 case MULT_EXPR:
6002 /* We have a special case here if we are doing something like
6003 (C * 8) % 4 since we know that's zero. */
6004 if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
6005 || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
6006 /* If the multiplication can overflow we cannot optimize this. */
6007 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t))
6008 && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
6009 && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
6011 *strict_overflow_p = true;
6012 return omit_one_operand (type, integer_zero_node, op0);
6015 /* ... fall through ... */
6017 case TRUNC_DIV_EXPR: case CEIL_DIV_EXPR: case FLOOR_DIV_EXPR:
6018 case ROUND_DIV_EXPR: case EXACT_DIV_EXPR:
6019 /* If we can extract our operation from the LHS, do so and return a
6020 new operation. Likewise for the RHS from a MULT_EXPR. Otherwise,
6021 do something only if the second operand is a constant. */
6022 if (same_p
6023 && (t1 = extract_muldiv (op0, c, code, wide_type,
6024 strict_overflow_p)) != 0)
6025 return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6026 fold_convert (ctype, op1));
6027 else if (tcode == MULT_EXPR && code == MULT_EXPR
6028 && (t1 = extract_muldiv (op1, c, code, wide_type,
6029 strict_overflow_p)) != 0)
6030 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6031 fold_convert (ctype, t1));
6032 else if (TREE_CODE (op1) != INTEGER_CST)
6033 return 0;
6035 /* If these are the same operation types, we can associate them
6036 assuming no overflow. */
6037 if (tcode == code)
6039 double_int mul;
6040 bool overflow_p;
6041 unsigned prec = TYPE_PRECISION (ctype);
6042 bool uns = TYPE_UNSIGNED (ctype);
6043 double_int diop1 = tree_to_double_int (op1).ext (prec, uns);
6044 double_int dic = tree_to_double_int (c).ext (prec, uns);
6045 mul = diop1.mul_with_sign (dic, false, &overflow_p);
6046 overflow_p = ((!uns && overflow_p)
6047 | TREE_OVERFLOW (c) | TREE_OVERFLOW (op1));
6048 if (!double_int_fits_to_tree_p (ctype, mul)
6049 && ((uns && tcode != MULT_EXPR) || !uns))
6050 overflow_p = 1;
6051 if (!overflow_p)
6052 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6053 double_int_to_tree (ctype, mul));
6056 /* If these operations "cancel" each other, we have the main
6057 optimizations of this pass, which occur when either constant is a
6058 multiple of the other, in which case we replace this with either an
6059 operation or CODE or TCODE.
6061 If we have an unsigned type, we cannot do this since it will change
6062 the result if the original computation overflowed. */
6063 if (TYPE_OVERFLOW_UNDEFINED (ctype)
6064 && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
6065 || (tcode == MULT_EXPR
6066 && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
6067 && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
6068 && code != MULT_EXPR)))
6070 if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c)))
6072 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6073 *strict_overflow_p = true;
6074 return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6075 fold_convert (ctype,
6076 const_binop (TRUNC_DIV_EXPR,
6077 op1, c)));
6079 else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1)))
6081 if (TYPE_OVERFLOW_UNDEFINED (ctype))
6082 *strict_overflow_p = true;
6083 return fold_build2 (code, ctype, fold_convert (ctype, op0),
6084 fold_convert (ctype,
6085 const_binop (TRUNC_DIV_EXPR,
6086 c, op1)));
6089 break;
6091 default:
6092 break;
6095 return 0;
6098 /* Return a node which has the indicated constant VALUE (either 0 or
6099 1 for scalars or {-1,-1,..} or {0,0,...} for vectors),
6100 and is of the indicated TYPE. */
6102 tree
6103 constant_boolean_node (bool value, tree type)
6105 if (type == integer_type_node)
6106 return value ? integer_one_node : integer_zero_node;
6107 else if (type == boolean_type_node)
6108 return value ? boolean_true_node : boolean_false_node;
6109 else if (TREE_CODE (type) == VECTOR_TYPE)
6110 return build_vector_from_val (type,
6111 build_int_cst (TREE_TYPE (type),
6112 value ? -1 : 0));
6113 else
6114 return fold_convert (type, value ? integer_one_node : integer_zero_node);
6118 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6119 Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'. Here
6120 CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6121 expression, and ARG to `a'. If COND_FIRST_P is nonzero, then the
6122 COND is the first argument to CODE; otherwise (as in the example
6123 given here), it is the second argument. TYPE is the type of the
6124 original expression. Return NULL_TREE if no simplification is
6125 possible. */
6127 static tree
6128 fold_binary_op_with_conditional_arg (location_t loc,
6129 enum tree_code code,
6130 tree type, tree op0, tree op1,
6131 tree cond, tree arg, int cond_first_p)
6133 tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
6134 tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6135 tree test, true_value, false_value;
6136 tree lhs = NULL_TREE;
6137 tree rhs = NULL_TREE;
6138 enum tree_code cond_code = COND_EXPR;
6140 if (TREE_CODE (cond) == COND_EXPR
6141 || TREE_CODE (cond) == VEC_COND_EXPR)
6143 test = TREE_OPERAND (cond, 0);
6144 true_value = TREE_OPERAND (cond, 1);
6145 false_value = TREE_OPERAND (cond, 2);
6146 /* If this operand throws an expression, then it does not make
6147 sense to try to perform a logical or arithmetic operation
6148 involving it. */
6149 if (VOID_TYPE_P (TREE_TYPE (true_value)))
6150 lhs = true_value;
6151 if (VOID_TYPE_P (TREE_TYPE (false_value)))
6152 rhs = false_value;
6154 else
6156 tree testtype = TREE_TYPE (cond);
6157 test = cond;
6158 true_value = constant_boolean_node (true, testtype);
6159 false_value = constant_boolean_node (false, testtype);
6162 if (TREE_CODE (TREE_TYPE (test)) == VECTOR_TYPE)
6163 cond_code = VEC_COND_EXPR;
6165 /* This transformation is only worthwhile if we don't have to wrap ARG
6166 in a SAVE_EXPR and the operation can be simplified without recursing
6167 on at least one of the branches once its pushed inside the COND_EXPR. */
6168 if (!TREE_CONSTANT (arg)
6169 && (TREE_SIDE_EFFECTS (arg)
6170 || TREE_CODE (arg) == COND_EXPR || TREE_CODE (arg) == VEC_COND_EXPR
6171 || TREE_CONSTANT (true_value) || TREE_CONSTANT (false_value)))
6172 return NULL_TREE;
6174 arg = fold_convert_loc (loc, arg_type, arg);
6175 if (lhs == 0)
6177 true_value = fold_convert_loc (loc, cond_type, true_value);
6178 if (cond_first_p)
6179 lhs = fold_build2_loc (loc, code, type, true_value, arg);
6180 else
6181 lhs = fold_build2_loc (loc, code, type, arg, true_value);
6183 if (rhs == 0)
6185 false_value = fold_convert_loc (loc, cond_type, false_value);
6186 if (cond_first_p)
6187 rhs = fold_build2_loc (loc, code, type, false_value, arg);
6188 else
6189 rhs = fold_build2_loc (loc, code, type, arg, false_value);
6192 /* Check that we have simplified at least one of the branches. */
6193 if (!TREE_CONSTANT (arg) && !TREE_CONSTANT (lhs) && !TREE_CONSTANT (rhs))
6194 return NULL_TREE;
6196 return fold_build3_loc (loc, cond_code, type, test, lhs, rhs);
6200 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6202 If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6203 TYPE, X + ADDEND is the same as X. If NEGATE, return true if X -
6204 ADDEND is the same as X.
6206 X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6207 and finite. The problematic cases are when X is zero, and its mode
6208 has signed zeros. In the case of rounding towards -infinity,
6209 X - 0 is not the same as X because 0 - 0 is -0. In other rounding
6210 modes, X + 0 is not the same as X because -0 + 0 is 0. */
6212 bool
6213 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6215 if (!real_zerop (addend))
6216 return false;
6218 /* Don't allow the fold with -fsignaling-nans. */
6219 if (HONOR_SNANS (TYPE_MODE (type)))
6220 return false;
6222 /* Allow the fold if zeros aren't signed, or their sign isn't important. */
6223 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
6224 return true;
6226 /* In a vector or complex, we would need to check the sign of all zeros. */
6227 if (TREE_CODE (addend) != REAL_CST)
6228 return false;
6230 /* Treat x + -0 as x - 0 and x - -0 as x + 0. */
6231 if (REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6232 negate = !negate;
6234 /* The mode has signed zeros, and we have to honor their sign.
6235 In this situation, there is only one case we can return true for.
6236 X - 0 is the same as X unless rounding towards -infinity is
6237 supported. */
6238 return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
6241 /* Subroutine of fold() that checks comparisons of built-in math
6242 functions against real constants.
6244 FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6245 operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR. TYPE
6246 is the type of the result and ARG0 and ARG1 are the operands of the
6247 comparison. ARG1 must be a TREE_REAL_CST.
6249 The function returns the constant folded tree if a simplification
6250 can be made, and NULL_TREE otherwise. */
6252 static tree
6253 fold_mathfn_compare (location_t loc,
6254 enum built_in_function fcode, enum tree_code code,
6255 tree type, tree arg0, tree arg1)
6257 REAL_VALUE_TYPE c;
6259 if (BUILTIN_SQRT_P (fcode))
6261 tree arg = CALL_EXPR_ARG (arg0, 0);
6262 enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
6264 c = TREE_REAL_CST (arg1);
6265 if (REAL_VALUE_NEGATIVE (c))
6267 /* sqrt(x) < y is always false, if y is negative. */
6268 if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
6269 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
6271 /* sqrt(x) > y is always true, if y is negative and we
6272 don't care about NaNs, i.e. negative values of x. */
6273 if (code == NE_EXPR || !HONOR_NANS (mode))
6274 return omit_one_operand_loc (loc, type, integer_one_node, arg);
6276 /* sqrt(x) > y is the same as x >= 0, if y is negative. */
6277 return fold_build2_loc (loc, GE_EXPR, type, arg,
6278 build_real (TREE_TYPE (arg), dconst0));
6280 else if (code == GT_EXPR || code == GE_EXPR)
6282 REAL_VALUE_TYPE c2;
6284 REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6285 real_convert (&c2, mode, &c2);
6287 if (REAL_VALUE_ISINF (c2))
6289 /* sqrt(x) > y is x == +Inf, when y is very large. */
6290 if (HONOR_INFINITIES (mode))
6291 return fold_build2_loc (loc, EQ_EXPR, type, arg,
6292 build_real (TREE_TYPE (arg), c2));
6294 /* sqrt(x) > y is always false, when y is very large
6295 and we don't care about infinities. */
6296 return omit_one_operand_loc (loc, type, integer_zero_node, arg);
6299 /* sqrt(x) > c is the same as x > c*c. */
6300 return fold_build2_loc (loc, code, type, arg,
6301 build_real (TREE_TYPE (arg), c2));
6303 else if (code == LT_EXPR || code == LE_EXPR)
6305 REAL_VALUE_TYPE c2;
6307 REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6308 real_convert (&c2, mode, &c2);
6310 if (REAL_VALUE_ISINF (c2))
6312 /* sqrt(x) < y is always true, when y is a very large
6313 value and we don't care about NaNs or Infinities. */
6314 if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
6315 return omit_one_operand_loc (loc, type, integer_one_node, arg);
6317 /* sqrt(x) < y is x != +Inf when y is very large and we
6318 don't care about NaNs. */
6319 if (! HONOR_NANS (mode))
6320 return fold_build2_loc (loc, NE_EXPR, type, arg,
6321 build_real (TREE_TYPE (arg), c2));
6323 /* sqrt(x) < y is x >= 0 when y is very large and we
6324 don't care about Infinities. */
6325 if (! HONOR_INFINITIES (mode))
6326 return fold_build2_loc (loc, GE_EXPR, type, arg,
6327 build_real (TREE_TYPE (arg), dconst0));
6329 /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large. */
6330 arg = save_expr (arg);
6331 return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
6332 fold_build2_loc (loc, GE_EXPR, type, arg,
6333 build_real (TREE_TYPE (arg),
6334 dconst0)),
6335 fold_build2_loc (loc, NE_EXPR, type, arg,
6336 build_real (TREE_TYPE (arg),
6337 c2)));
6340 /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs. */
6341 if (! HONOR_NANS (mode))
6342 return fold_build2_loc (loc, code, type, arg,
6343 build_real (TREE_TYPE (arg), c2));
6345 /* sqrt(x) < c is the same as x >= 0 && x < c*c. */
6346 arg = save_expr (arg);
6347 return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
6348 fold_build2_loc (loc, GE_EXPR, type, arg,
6349 build_real (TREE_TYPE (arg),
6350 dconst0)),
6351 fold_build2_loc (loc, code, type, arg,
6352 build_real (TREE_TYPE (arg),
6353 c2)));
6357 return NULL_TREE;
6360 /* Subroutine of fold() that optimizes comparisons against Infinities,
6361 either +Inf or -Inf.
6363 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6364 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6365 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6367 The function returns the constant folded tree if a simplification
6368 can be made, and NULL_TREE otherwise. */
6370 static tree
6371 fold_inf_compare (location_t loc, enum tree_code code, tree type,
6372 tree arg0, tree arg1)
6374 enum machine_mode mode;
6375 REAL_VALUE_TYPE max;
6376 tree temp;
6377 bool neg;
6379 mode = TYPE_MODE (TREE_TYPE (arg0));
6381 /* For negative infinity swap the sense of the comparison. */
6382 neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6383 if (neg)
6384 code = swap_tree_comparison (code);
6386 switch (code)
6388 case GT_EXPR:
6389 /* x > +Inf is always false, if with ignore sNANs. */
6390 if (HONOR_SNANS (mode))
6391 return NULL_TREE;
6392 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6394 case LE_EXPR:
6395 /* x <= +Inf is always true, if we don't case about NaNs. */
6396 if (! HONOR_NANS (mode))
6397 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6399 /* x <= +Inf is the same as x == x, i.e. isfinite(x). */
6400 arg0 = save_expr (arg0);
6401 return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg0);
6403 case EQ_EXPR:
6404 case GE_EXPR:
6405 /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX. */
6406 real_maxval (&max, neg, mode);
6407 return fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
6408 arg0, build_real (TREE_TYPE (arg0), max));
6410 case LT_EXPR:
6411 /* x < +Inf is always equal to x <= DBL_MAX. */
6412 real_maxval (&max, neg, mode);
6413 return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
6414 arg0, build_real (TREE_TYPE (arg0), max));
6416 case NE_EXPR:
6417 /* x != +Inf is always equal to !(x > DBL_MAX). */
6418 real_maxval (&max, neg, mode);
6419 if (! HONOR_NANS (mode))
6420 return fold_build2_loc (loc, neg ? GE_EXPR : LE_EXPR, type,
6421 arg0, build_real (TREE_TYPE (arg0), max));
6423 temp = fold_build2_loc (loc, neg ? LT_EXPR : GT_EXPR, type,
6424 arg0, build_real (TREE_TYPE (arg0), max));
6425 return fold_build1_loc (loc, TRUTH_NOT_EXPR, type, temp);
6427 default:
6428 break;
6431 return NULL_TREE;
6434 /* Subroutine of fold() that optimizes comparisons of a division by
6435 a nonzero integer constant against an integer constant, i.e.
6436 X/C1 op C2.
6438 CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6439 GE_EXPR or LE_EXPR. TYPE is the type of the result and ARG0 and ARG1
6440 are the operands of the comparison. ARG1 must be a TREE_REAL_CST.
6442 The function returns the constant folded tree if a simplification
6443 can be made, and NULL_TREE otherwise. */
6445 static tree
6446 fold_div_compare (location_t loc,
6447 enum tree_code code, tree type, tree arg0, tree arg1)
6449 tree prod, tmp, hi, lo;
6450 tree arg00 = TREE_OPERAND (arg0, 0);
6451 tree arg01 = TREE_OPERAND (arg0, 1);
6452 double_int val;
6453 bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
6454 bool neg_overflow;
6455 bool overflow;
6457 /* We have to do this the hard way to detect unsigned overflow.
6458 prod = int_const_binop (MULT_EXPR, arg01, arg1); */
6459 val = TREE_INT_CST (arg01)
6460 .mul_with_sign (TREE_INT_CST (arg1), unsigned_p, &overflow);
6461 prod = force_fit_type_double (TREE_TYPE (arg00), val, -1, overflow);
6462 neg_overflow = false;
6464 if (unsigned_p)
6466 tmp = int_const_binop (MINUS_EXPR, arg01,
6467 build_int_cst (TREE_TYPE (arg01), 1));
6468 lo = prod;
6470 /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp). */
6471 val = TREE_INT_CST (prod)
6472 .add_with_sign (TREE_INT_CST (tmp), unsigned_p, &overflow);
6473 hi = force_fit_type_double (TREE_TYPE (arg00), val,
6474 -1, overflow | TREE_OVERFLOW (prod));
6476 else if (tree_int_cst_sgn (arg01) >= 0)
6478 tmp = int_const_binop (MINUS_EXPR, arg01,
6479 build_int_cst (TREE_TYPE (arg01), 1));
6480 switch (tree_int_cst_sgn (arg1))
6482 case -1:
6483 neg_overflow = true;
6484 lo = int_const_binop (MINUS_EXPR, prod, tmp);
6485 hi = prod;
6486 break;
6488 case 0:
6489 lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6490 hi = tmp;
6491 break;
6493 case 1:
6494 hi = int_const_binop (PLUS_EXPR, prod, tmp);
6495 lo = prod;
6496 break;
6498 default:
6499 gcc_unreachable ();
6502 else
6504 /* A negative divisor reverses the relational operators. */
6505 code = swap_tree_comparison (code);
6507 tmp = int_const_binop (PLUS_EXPR, arg01,
6508 build_int_cst (TREE_TYPE (arg01), 1));
6509 switch (tree_int_cst_sgn (arg1))
6511 case -1:
6512 hi = int_const_binop (MINUS_EXPR, prod, tmp);
6513 lo = prod;
6514 break;
6516 case 0:
6517 hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6518 lo = tmp;
6519 break;
6521 case 1:
6522 neg_overflow = true;
6523 lo = int_const_binop (PLUS_EXPR, prod, tmp);
6524 hi = prod;
6525 break;
6527 default:
6528 gcc_unreachable ();
6532 switch (code)
6534 case EQ_EXPR:
6535 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6536 return omit_one_operand_loc (loc, type, integer_zero_node, arg00);
6537 if (TREE_OVERFLOW (hi))
6538 return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6539 if (TREE_OVERFLOW (lo))
6540 return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6541 return build_range_check (loc, type, arg00, 1, lo, hi);
6543 case NE_EXPR:
6544 if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6545 return omit_one_operand_loc (loc, type, integer_one_node, arg00);
6546 if (TREE_OVERFLOW (hi))
6547 return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6548 if (TREE_OVERFLOW (lo))
6549 return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6550 return build_range_check (loc, type, arg00, 0, lo, hi);
6552 case LT_EXPR:
6553 if (TREE_OVERFLOW (lo))
6555 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6556 return omit_one_operand_loc (loc, type, tmp, arg00);
6558 return fold_build2_loc (loc, LT_EXPR, type, arg00, lo);
6560 case LE_EXPR:
6561 if (TREE_OVERFLOW (hi))
6563 tmp = neg_overflow ? integer_zero_node : integer_one_node;
6564 return omit_one_operand_loc (loc, type, tmp, arg00);
6566 return fold_build2_loc (loc, LE_EXPR, type, arg00, hi);
6568 case GT_EXPR:
6569 if (TREE_OVERFLOW (hi))
6571 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6572 return omit_one_operand_loc (loc, type, tmp, arg00);
6574 return fold_build2_loc (loc, GT_EXPR, type, arg00, hi);
6576 case GE_EXPR:
6577 if (TREE_OVERFLOW (lo))
6579 tmp = neg_overflow ? integer_one_node : integer_zero_node;
6580 return omit_one_operand_loc (loc, type, tmp, arg00);
6582 return fold_build2_loc (loc, GE_EXPR, type, arg00, lo);
6584 default:
6585 break;
6588 return NULL_TREE;
6592 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6593 equality/inequality test, then return a simplified form of the test
6594 using a sign testing. Otherwise return NULL. TYPE is the desired
6595 result type. */
6597 static tree
6598 fold_single_bit_test_into_sign_test (location_t loc,
6599 enum tree_code code, tree arg0, tree arg1,
6600 tree result_type)
6602 /* If this is testing a single bit, we can optimize the test. */
6603 if ((code == NE_EXPR || code == EQ_EXPR)
6604 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6605 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6607 /* If we have (A & C) != 0 where C is the sign bit of A, convert
6608 this into A < 0. Similarly for (A & C) == 0 into A >= 0. */
6609 tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6611 if (arg00 != NULL_TREE
6612 /* This is only a win if casting to a signed type is cheap,
6613 i.e. when arg00's type is not a partial mode. */
6614 && TYPE_PRECISION (TREE_TYPE (arg00))
6615 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg00))))
6617 tree stype = signed_type_for (TREE_TYPE (arg00));
6618 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6619 result_type,
6620 fold_convert_loc (loc, stype, arg00),
6621 build_int_cst (stype, 0));
6625 return NULL_TREE;
6628 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6629 equality/inequality test, then return a simplified form of
6630 the test using shifts and logical operations. Otherwise return
6631 NULL. TYPE is the desired result type. */
6633 tree
6634 fold_single_bit_test (location_t loc, enum tree_code code,
6635 tree arg0, tree arg1, tree result_type)
6637 /* If this is testing a single bit, we can optimize the test. */
6638 if ((code == NE_EXPR || code == EQ_EXPR)
6639 && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6640 && integer_pow2p (TREE_OPERAND (arg0, 1)))
6642 tree inner = TREE_OPERAND (arg0, 0);
6643 tree type = TREE_TYPE (arg0);
6644 int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6645 enum machine_mode operand_mode = TYPE_MODE (type);
6646 int ops_unsigned;
6647 tree signed_type, unsigned_type, intermediate_type;
6648 tree tem, one;
6650 /* First, see if we can fold the single bit test into a sign-bit
6651 test. */
6652 tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1,
6653 result_type);
6654 if (tem)
6655 return tem;
6657 /* Otherwise we have (A & C) != 0 where C is a single bit,
6658 convert that into ((A >> C2) & 1). Where C2 = log2(C).
6659 Similarly for (A & C) == 0. */
6661 /* If INNER is a right shift of a constant and it plus BITNUM does
6662 not overflow, adjust BITNUM and INNER. */
6663 if (TREE_CODE (inner) == RSHIFT_EXPR
6664 && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6665 && tree_fits_uhwi_p (TREE_OPERAND (inner, 1))
6666 && bitnum < TYPE_PRECISION (type)
6667 && (tree_to_uhwi (TREE_OPERAND (inner, 1))
6668 < (unsigned) (TYPE_PRECISION (type) - bitnum)))
6670 bitnum += tree_to_uhwi (TREE_OPERAND (inner, 1));
6671 inner = TREE_OPERAND (inner, 0);
6674 /* If we are going to be able to omit the AND below, we must do our
6675 operations as unsigned. If we must use the AND, we have a choice.
6676 Normally unsigned is faster, but for some machines signed is. */
6677 #ifdef LOAD_EXTEND_OP
6678 ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND
6679 && !flag_syntax_only) ? 0 : 1;
6680 #else
6681 ops_unsigned = 1;
6682 #endif
6684 signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6685 unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6686 intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6687 inner = fold_convert_loc (loc, intermediate_type, inner);
6689 if (bitnum != 0)
6690 inner = build2 (RSHIFT_EXPR, intermediate_type,
6691 inner, size_int (bitnum));
6693 one = build_int_cst (intermediate_type, 1);
6695 if (code == EQ_EXPR)
6696 inner = fold_build2_loc (loc, BIT_XOR_EXPR, intermediate_type, inner, one);
6698 /* Put the AND last so it can combine with more things. */
6699 inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
6701 /* Make sure to return the proper type. */
6702 inner = fold_convert_loc (loc, result_type, inner);
6704 return inner;
6706 return NULL_TREE;
6709 /* Check whether we are allowed to reorder operands arg0 and arg1,
6710 such that the evaluation of arg1 occurs before arg0. */
6712 static bool
6713 reorder_operands_p (const_tree arg0, const_tree arg1)
6715 if (! flag_evaluation_order)
6716 return true;
6717 if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6718 return true;
6719 return ! TREE_SIDE_EFFECTS (arg0)
6720 && ! TREE_SIDE_EFFECTS (arg1);
6723 /* Test whether it is preferable two swap two operands, ARG0 and
6724 ARG1, for example because ARG0 is an integer constant and ARG1
6725 isn't. If REORDER is true, only recommend swapping if we can
6726 evaluate the operands in reverse order. */
6728 bool
6729 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
6731 STRIP_SIGN_NOPS (arg0);
6732 STRIP_SIGN_NOPS (arg1);
6734 if (TREE_CODE (arg1) == INTEGER_CST)
6735 return 0;
6736 if (TREE_CODE (arg0) == INTEGER_CST)
6737 return 1;
6739 if (TREE_CODE (arg1) == REAL_CST)
6740 return 0;
6741 if (TREE_CODE (arg0) == REAL_CST)
6742 return 1;
6744 if (TREE_CODE (arg1) == FIXED_CST)
6745 return 0;
6746 if (TREE_CODE (arg0) == FIXED_CST)
6747 return 1;
6749 if (TREE_CODE (arg1) == COMPLEX_CST)
6750 return 0;
6751 if (TREE_CODE (arg0) == COMPLEX_CST)
6752 return 1;
6754 if (TREE_CONSTANT (arg1))
6755 return 0;
6756 if (TREE_CONSTANT (arg0))
6757 return 1;
6759 if (optimize_function_for_size_p (cfun))
6760 return 0;
6762 if (reorder && flag_evaluation_order
6763 && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6764 return 0;
6766 /* It is preferable to swap two SSA_NAME to ensure a canonical form
6767 for commutative and comparison operators. Ensuring a canonical
6768 form allows the optimizers to find additional redundancies without
6769 having to explicitly check for both orderings. */
6770 if (TREE_CODE (arg0) == SSA_NAME
6771 && TREE_CODE (arg1) == SSA_NAME
6772 && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6773 return 1;
6775 /* Put SSA_NAMEs last. */
6776 if (TREE_CODE (arg1) == SSA_NAME)
6777 return 0;
6778 if (TREE_CODE (arg0) == SSA_NAME)
6779 return 1;
6781 /* Put variables last. */
6782 if (DECL_P (arg1))
6783 return 0;
6784 if (DECL_P (arg0))
6785 return 1;
6787 return 0;
6790 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6791 ARG0 is extended to a wider type. */
6793 static tree
6794 fold_widened_comparison (location_t loc, enum tree_code code,
6795 tree type, tree arg0, tree arg1)
6797 tree arg0_unw = get_unwidened (arg0, NULL_TREE);
6798 tree arg1_unw;
6799 tree shorter_type, outer_type;
6800 tree min, max;
6801 bool above, below;
6803 if (arg0_unw == arg0)
6804 return NULL_TREE;
6805 shorter_type = TREE_TYPE (arg0_unw);
6807 #ifdef HAVE_canonicalize_funcptr_for_compare
6808 /* Disable this optimization if we're casting a function pointer
6809 type on targets that require function pointer canonicalization. */
6810 if (HAVE_canonicalize_funcptr_for_compare
6811 && TREE_CODE (shorter_type) == POINTER_TYPE
6812 && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
6813 return NULL_TREE;
6814 #endif
6816 if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
6817 return NULL_TREE;
6819 arg1_unw = get_unwidened (arg1, NULL_TREE);
6821 /* If possible, express the comparison in the shorter mode. */
6822 if ((code == EQ_EXPR || code == NE_EXPR
6823 || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
6824 && (TREE_TYPE (arg1_unw) == shorter_type
6825 || ((TYPE_PRECISION (shorter_type)
6826 >= TYPE_PRECISION (TREE_TYPE (arg1_unw)))
6827 && (TYPE_UNSIGNED (shorter_type)
6828 == TYPE_UNSIGNED (TREE_TYPE (arg1_unw))))
6829 || (TREE_CODE (arg1_unw) == INTEGER_CST
6830 && (TREE_CODE (shorter_type) == INTEGER_TYPE
6831 || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
6832 && int_fits_type_p (arg1_unw, shorter_type))))
6833 return fold_build2_loc (loc, code, type, arg0_unw,
6834 fold_convert_loc (loc, shorter_type, arg1_unw));
6836 if (TREE_CODE (arg1_unw) != INTEGER_CST
6837 || TREE_CODE (shorter_type) != INTEGER_TYPE
6838 || !int_fits_type_p (arg1_unw, shorter_type))
6839 return NULL_TREE;
6841 /* If we are comparing with the integer that does not fit into the range
6842 of the shorter type, the result is known. */
6843 outer_type = TREE_TYPE (arg1_unw);
6844 min = lower_bound_in_type (outer_type, shorter_type);
6845 max = upper_bound_in_type (outer_type, shorter_type);
6847 above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6848 max, arg1_unw));
6849 below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6850 arg1_unw, min));
6852 switch (code)
6854 case EQ_EXPR:
6855 if (above || below)
6856 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6857 break;
6859 case NE_EXPR:
6860 if (above || below)
6861 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6862 break;
6864 case LT_EXPR:
6865 case LE_EXPR:
6866 if (above)
6867 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6868 else if (below)
6869 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6871 case GT_EXPR:
6872 case GE_EXPR:
6873 if (above)
6874 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
6875 else if (below)
6876 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
6878 default:
6879 break;
6882 return NULL_TREE;
6885 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6886 ARG0 just the signedness is changed. */
6888 static tree
6889 fold_sign_changed_comparison (location_t loc, enum tree_code code, tree type,
6890 tree arg0, tree arg1)
6892 tree arg0_inner;
6893 tree inner_type, outer_type;
6895 if (!CONVERT_EXPR_P (arg0))
6896 return NULL_TREE;
6898 outer_type = TREE_TYPE (arg0);
6899 arg0_inner = TREE_OPERAND (arg0, 0);
6900 inner_type = TREE_TYPE (arg0_inner);
6902 #ifdef HAVE_canonicalize_funcptr_for_compare
6903 /* Disable this optimization if we're casting a function pointer
6904 type on targets that require function pointer canonicalization. */
6905 if (HAVE_canonicalize_funcptr_for_compare
6906 && TREE_CODE (inner_type) == POINTER_TYPE
6907 && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
6908 return NULL_TREE;
6909 #endif
6911 if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
6912 return NULL_TREE;
6914 if (TREE_CODE (arg1) != INTEGER_CST
6915 && !(CONVERT_EXPR_P (arg1)
6916 && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
6917 return NULL_TREE;
6919 if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
6920 && code != NE_EXPR
6921 && code != EQ_EXPR)
6922 return NULL_TREE;
6924 if (POINTER_TYPE_P (inner_type) != POINTER_TYPE_P (outer_type))
6925 return NULL_TREE;
6927 if (TREE_CODE (arg1) == INTEGER_CST)
6928 arg1 = force_fit_type_double (inner_type, tree_to_double_int (arg1),
6929 0, TREE_OVERFLOW (arg1));
6930 else
6931 arg1 = fold_convert_loc (loc, inner_type, arg1);
6933 return fold_build2_loc (loc, code, type, arg0_inner, arg1);
6936 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
6937 step of the array. Reconstructs s and delta in the case of s *
6938 delta being an integer constant (and thus already folded). ADDR is
6939 the address. MULT is the multiplicative expression. If the
6940 function succeeds, the new address expression is returned.
6941 Otherwise NULL_TREE is returned. LOC is the location of the
6942 resulting expression. */
6944 static tree
6945 try_move_mult_to_index (location_t loc, tree addr, tree op1)
6947 tree s, delta, step;
6948 tree ref = TREE_OPERAND (addr, 0), pref;
6949 tree ret, pos;
6950 tree itype;
6951 bool mdim = false;
6953 /* Strip the nops that might be added when converting op1 to sizetype. */
6954 STRIP_NOPS (op1);
6956 /* Canonicalize op1 into a possibly non-constant delta
6957 and an INTEGER_CST s. */
6958 if (TREE_CODE (op1) == MULT_EXPR)
6960 tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
6962 STRIP_NOPS (arg0);
6963 STRIP_NOPS (arg1);
6965 if (TREE_CODE (arg0) == INTEGER_CST)
6967 s = arg0;
6968 delta = arg1;
6970 else if (TREE_CODE (arg1) == INTEGER_CST)
6972 s = arg1;
6973 delta = arg0;
6975 else
6976 return NULL_TREE;
6978 else if (TREE_CODE (op1) == INTEGER_CST)
6980 delta = op1;
6981 s = NULL_TREE;
6983 else
6985 /* Simulate we are delta * 1. */
6986 delta = op1;
6987 s = integer_one_node;
6990 /* Handle &x.array the same as we would handle &x.array[0]. */
6991 if (TREE_CODE (ref) == COMPONENT_REF
6992 && TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE)
6994 tree domain;
6996 /* Remember if this was a multi-dimensional array. */
6997 if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
6998 mdim = true;
7000 domain = TYPE_DOMAIN (TREE_TYPE (ref));
7001 if (! domain)
7002 goto cont;
7003 itype = TREE_TYPE (domain);
7005 step = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ref)));
7006 if (TREE_CODE (step) != INTEGER_CST)
7007 goto cont;
7009 if (s)
7011 if (! tree_int_cst_equal (step, s))
7012 goto cont;
7014 else
7016 /* Try if delta is a multiple of step. */
7017 tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, op1, step);
7018 if (! tmp)
7019 goto cont;
7020 delta = tmp;
7023 /* Only fold here if we can verify we do not overflow one
7024 dimension of a multi-dimensional array. */
7025 if (mdim)
7027 tree tmp;
7029 if (!TYPE_MIN_VALUE (domain)
7030 || !TYPE_MAX_VALUE (domain)
7031 || TREE_CODE (TYPE_MAX_VALUE (domain)) != INTEGER_CST)
7032 goto cont;
7034 tmp = fold_binary_loc (loc, PLUS_EXPR, itype,
7035 fold_convert_loc (loc, itype,
7036 TYPE_MIN_VALUE (domain)),
7037 fold_convert_loc (loc, itype, delta));
7038 if (TREE_CODE (tmp) != INTEGER_CST
7039 || tree_int_cst_lt (TYPE_MAX_VALUE (domain), tmp))
7040 goto cont;
7043 /* We found a suitable component reference. */
7045 pref = TREE_OPERAND (addr, 0);
7046 ret = copy_node (pref);
7047 SET_EXPR_LOCATION (ret, loc);
7049 ret = build4_loc (loc, ARRAY_REF, TREE_TYPE (TREE_TYPE (ref)), ret,
7050 fold_build2_loc
7051 (loc, PLUS_EXPR, itype,
7052 fold_convert_loc (loc, itype,
7053 TYPE_MIN_VALUE
7054 (TYPE_DOMAIN (TREE_TYPE (ref)))),
7055 fold_convert_loc (loc, itype, delta)),
7056 NULL_TREE, NULL_TREE);
7057 return build_fold_addr_expr_loc (loc, ret);
7060 cont:
7062 for (;; ref = TREE_OPERAND (ref, 0))
7064 if (TREE_CODE (ref) == ARRAY_REF)
7066 tree domain;
7068 /* Remember if this was a multi-dimensional array. */
7069 if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
7070 mdim = true;
7072 domain = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
7073 if (! domain)
7074 continue;
7075 itype = TREE_TYPE (domain);
7077 step = array_ref_element_size (ref);
7078 if (TREE_CODE (step) != INTEGER_CST)
7079 continue;
7081 if (s)
7083 if (! tree_int_cst_equal (step, s))
7084 continue;
7086 else
7088 /* Try if delta is a multiple of step. */
7089 tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, op1, step);
7090 if (! tmp)
7091 continue;
7092 delta = tmp;
7095 /* Only fold here if we can verify we do not overflow one
7096 dimension of a multi-dimensional array. */
7097 if (mdim)
7099 tree tmp;
7101 if (TREE_CODE (TREE_OPERAND (ref, 1)) != INTEGER_CST
7102 || !TYPE_MAX_VALUE (domain)
7103 || TREE_CODE (TYPE_MAX_VALUE (domain)) != INTEGER_CST)
7104 continue;
7106 tmp = fold_binary_loc (loc, PLUS_EXPR, itype,
7107 fold_convert_loc (loc, itype,
7108 TREE_OPERAND (ref, 1)),
7109 fold_convert_loc (loc, itype, delta));
7110 if (!tmp
7111 || TREE_CODE (tmp) != INTEGER_CST
7112 || tree_int_cst_lt (TYPE_MAX_VALUE (domain), tmp))
7113 continue;
7116 break;
7118 else
7119 mdim = false;
7121 if (!handled_component_p (ref))
7122 return NULL_TREE;
7125 /* We found the suitable array reference. So copy everything up to it,
7126 and replace the index. */
7128 pref = TREE_OPERAND (addr, 0);
7129 ret = copy_node (pref);
7130 SET_EXPR_LOCATION (ret, loc);
7131 pos = ret;
7133 while (pref != ref)
7135 pref = TREE_OPERAND (pref, 0);
7136 TREE_OPERAND (pos, 0) = copy_node (pref);
7137 pos = TREE_OPERAND (pos, 0);
7140 TREE_OPERAND (pos, 1)
7141 = fold_build2_loc (loc, PLUS_EXPR, itype,
7142 fold_convert_loc (loc, itype, TREE_OPERAND (pos, 1)),
7143 fold_convert_loc (loc, itype, delta));
7144 return fold_build1_loc (loc, ADDR_EXPR, TREE_TYPE (addr), ret);
7148 /* Fold A < X && A + 1 > Y to A < X && A >= Y. Normally A + 1 > Y
7149 means A >= Y && A != MAX, but in this case we know that
7150 A < X <= MAX. INEQ is A + 1 > Y, BOUND is A < X. */
7152 static tree
7153 fold_to_nonsharp_ineq_using_bound (location_t loc, tree ineq, tree bound)
7155 tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
7157 if (TREE_CODE (bound) == LT_EXPR)
7158 a = TREE_OPERAND (bound, 0);
7159 else if (TREE_CODE (bound) == GT_EXPR)
7160 a = TREE_OPERAND (bound, 1);
7161 else
7162 return NULL_TREE;
7164 typea = TREE_TYPE (a);
7165 if (!INTEGRAL_TYPE_P (typea)
7166 && !POINTER_TYPE_P (typea))
7167 return NULL_TREE;
7169 if (TREE_CODE (ineq) == LT_EXPR)
7171 a1 = TREE_OPERAND (ineq, 1);
7172 y = TREE_OPERAND (ineq, 0);
7174 else if (TREE_CODE (ineq) == GT_EXPR)
7176 a1 = TREE_OPERAND (ineq, 0);
7177 y = TREE_OPERAND (ineq, 1);
7179 else
7180 return NULL_TREE;
7182 if (TREE_TYPE (a1) != typea)
7183 return NULL_TREE;
7185 if (POINTER_TYPE_P (typea))
7187 /* Convert the pointer types into integer before taking the difference. */
7188 tree ta = fold_convert_loc (loc, ssizetype, a);
7189 tree ta1 = fold_convert_loc (loc, ssizetype, a1);
7190 diff = fold_binary_loc (loc, MINUS_EXPR, ssizetype, ta1, ta);
7192 else
7193 diff = fold_binary_loc (loc, MINUS_EXPR, typea, a1, a);
7195 if (!diff || !integer_onep (diff))
7196 return NULL_TREE;
7198 return fold_build2_loc (loc, GE_EXPR, type, a, y);
7201 /* Fold a sum or difference of at least one multiplication.
7202 Returns the folded tree or NULL if no simplification could be made. */
7204 static tree
7205 fold_plusminus_mult_expr (location_t loc, enum tree_code code, tree type,
7206 tree arg0, tree arg1)
7208 tree arg00, arg01, arg10, arg11;
7209 tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
7211 /* (A * C) +- (B * C) -> (A+-B) * C.
7212 (A * C) +- A -> A * (C+-1).
7213 We are most concerned about the case where C is a constant,
7214 but other combinations show up during loop reduction. Since
7215 it is not difficult, try all four possibilities. */
7217 if (TREE_CODE (arg0) == MULT_EXPR)
7219 arg00 = TREE_OPERAND (arg0, 0);
7220 arg01 = TREE_OPERAND (arg0, 1);
7222 else if (TREE_CODE (arg0) == INTEGER_CST)
7224 arg00 = build_one_cst (type);
7225 arg01 = arg0;
7227 else
7229 /* We cannot generate constant 1 for fract. */
7230 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7231 return NULL_TREE;
7232 arg00 = arg0;
7233 arg01 = build_one_cst (type);
7235 if (TREE_CODE (arg1) == MULT_EXPR)
7237 arg10 = TREE_OPERAND (arg1, 0);
7238 arg11 = TREE_OPERAND (arg1, 1);
7240 else if (TREE_CODE (arg1) == INTEGER_CST)
7242 arg10 = build_one_cst (type);
7243 /* As we canonicalize A - 2 to A + -2 get rid of that sign for
7244 the purpose of this canonicalization. */
7245 if (TREE_INT_CST_HIGH (arg1) == -1
7246 && negate_expr_p (arg1)
7247 && code == PLUS_EXPR)
7249 arg11 = negate_expr (arg1);
7250 code = MINUS_EXPR;
7252 else
7253 arg11 = arg1;
7255 else
7257 /* We cannot generate constant 1 for fract. */
7258 if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7259 return NULL_TREE;
7260 arg10 = arg1;
7261 arg11 = build_one_cst (type);
7263 same = NULL_TREE;
7265 if (operand_equal_p (arg01, arg11, 0))
7266 same = arg01, alt0 = arg00, alt1 = arg10;
7267 else if (operand_equal_p (arg00, arg10, 0))
7268 same = arg00, alt0 = arg01, alt1 = arg11;
7269 else if (operand_equal_p (arg00, arg11, 0))
7270 same = arg00, alt0 = arg01, alt1 = arg10;
7271 else if (operand_equal_p (arg01, arg10, 0))
7272 same = arg01, alt0 = arg00, alt1 = arg11;
7274 /* No identical multiplicands; see if we can find a common
7275 power-of-two factor in non-power-of-two multiplies. This
7276 can help in multi-dimensional array access. */
7277 else if (tree_fits_shwi_p (arg01)
7278 && tree_fits_shwi_p (arg11))
7280 HOST_WIDE_INT int01, int11, tmp;
7281 bool swap = false;
7282 tree maybe_same;
7283 int01 = tree_to_shwi (arg01);
7284 int11 = tree_to_shwi (arg11);
7286 /* Move min of absolute values to int11. */
7287 if (absu_hwi (int01) < absu_hwi (int11))
7289 tmp = int01, int01 = int11, int11 = tmp;
7290 alt0 = arg00, arg00 = arg10, arg10 = alt0;
7291 maybe_same = arg01;
7292 swap = true;
7294 else
7295 maybe_same = arg11;
7297 if (exact_log2 (absu_hwi (int11)) > 0 && int01 % int11 == 0
7298 /* The remainder should not be a constant, otherwise we
7299 end up folding i * 4 + 2 to (i * 2 + 1) * 2 which has
7300 increased the number of multiplications necessary. */
7301 && TREE_CODE (arg10) != INTEGER_CST)
7303 alt0 = fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (arg00), arg00,
7304 build_int_cst (TREE_TYPE (arg00),
7305 int01 / int11));
7306 alt1 = arg10;
7307 same = maybe_same;
7308 if (swap)
7309 maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7313 if (same)
7314 return fold_build2_loc (loc, MULT_EXPR, type,
7315 fold_build2_loc (loc, code, type,
7316 fold_convert_loc (loc, type, alt0),
7317 fold_convert_loc (loc, type, alt1)),
7318 fold_convert_loc (loc, type, same));
7320 return NULL_TREE;
7323 /* Subroutine of native_encode_expr. Encode the INTEGER_CST
7324 specified by EXPR into the buffer PTR of length LEN bytes.
7325 Return the number of bytes placed in the buffer, or zero
7326 upon failure. */
7328 static int
7329 native_encode_int (const_tree expr, unsigned char *ptr, int len)
7331 tree type = TREE_TYPE (expr);
7332 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7333 int byte, offset, word, words;
7334 unsigned char value;
7336 if (total_bytes > len)
7337 return 0;
7338 words = total_bytes / UNITS_PER_WORD;
7340 for (byte = 0; byte < total_bytes; byte++)
7342 int bitpos = byte * BITS_PER_UNIT;
7343 if (bitpos < HOST_BITS_PER_WIDE_INT)
7344 value = (unsigned char) (TREE_INT_CST_LOW (expr) >> bitpos);
7345 else
7346 value = (unsigned char) (TREE_INT_CST_HIGH (expr)
7347 >> (bitpos - HOST_BITS_PER_WIDE_INT));
7349 if (total_bytes > UNITS_PER_WORD)
7351 word = byte / UNITS_PER_WORD;
7352 if (WORDS_BIG_ENDIAN)
7353 word = (words - 1) - word;
7354 offset = word * UNITS_PER_WORD;
7355 if (BYTES_BIG_ENDIAN)
7356 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7357 else
7358 offset += byte % UNITS_PER_WORD;
7360 else
7361 offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7362 ptr[offset] = value;
7364 return total_bytes;
7368 /* Subroutine of native_encode_expr. Encode the FIXED_CST
7369 specified by EXPR into the buffer PTR of length LEN bytes.
7370 Return the number of bytes placed in the buffer, or zero
7371 upon failure. */
7373 static int
7374 native_encode_fixed (const_tree expr, unsigned char *ptr, int len)
7376 tree type = TREE_TYPE (expr);
7377 enum machine_mode mode = TYPE_MODE (type);
7378 int total_bytes = GET_MODE_SIZE (mode);
7379 FIXED_VALUE_TYPE value;
7380 tree i_value, i_type;
7382 if (total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7383 return 0;
7385 i_type = lang_hooks.types.type_for_size (GET_MODE_BITSIZE (mode), 1);
7387 if (NULL_TREE == i_type
7388 || TYPE_PRECISION (i_type) != total_bytes)
7389 return 0;
7391 value = TREE_FIXED_CST (expr);
7392 i_value = double_int_to_tree (i_type, value.data);
7394 return native_encode_int (i_value, ptr, len);
7398 /* Subroutine of native_encode_expr. Encode the REAL_CST
7399 specified by EXPR into the buffer PTR of length LEN bytes.
7400 Return the number of bytes placed in the buffer, or zero
7401 upon failure. */
7403 static int
7404 native_encode_real (const_tree expr, unsigned char *ptr, int len)
7406 tree type = TREE_TYPE (expr);
7407 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7408 int byte, offset, word, words, bitpos;
7409 unsigned char value;
7411 /* There are always 32 bits in each long, no matter the size of
7412 the hosts long. We handle floating point representations with
7413 up to 192 bits. */
7414 long tmp[6];
7416 if (total_bytes > len)
7417 return 0;
7418 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7420 real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7422 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7423 bitpos += BITS_PER_UNIT)
7425 byte = (bitpos / BITS_PER_UNIT) & 3;
7426 value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7428 if (UNITS_PER_WORD < 4)
7430 word = byte / UNITS_PER_WORD;
7431 if (WORDS_BIG_ENDIAN)
7432 word = (words - 1) - word;
7433 offset = word * UNITS_PER_WORD;
7434 if (BYTES_BIG_ENDIAN)
7435 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7436 else
7437 offset += byte % UNITS_PER_WORD;
7439 else
7440 offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7441 ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)] = value;
7443 return total_bytes;
7446 /* Subroutine of native_encode_expr. Encode the COMPLEX_CST
7447 specified by EXPR into the buffer PTR of length LEN bytes.
7448 Return the number of bytes placed in the buffer, or zero
7449 upon failure. */
7451 static int
7452 native_encode_complex (const_tree expr, unsigned char *ptr, int len)
7454 int rsize, isize;
7455 tree part;
7457 part = TREE_REALPART (expr);
7458 rsize = native_encode_expr (part, ptr, len);
7459 if (rsize == 0)
7460 return 0;
7461 part = TREE_IMAGPART (expr);
7462 isize = native_encode_expr (part, ptr+rsize, len-rsize);
7463 if (isize != rsize)
7464 return 0;
7465 return rsize + isize;
7469 /* Subroutine of native_encode_expr. Encode the VECTOR_CST
7470 specified by EXPR into the buffer PTR of length LEN bytes.
7471 Return the number of bytes placed in the buffer, or zero
7472 upon failure. */
7474 static int
7475 native_encode_vector (const_tree expr, unsigned char *ptr, int len)
7477 unsigned i, count;
7478 int size, offset;
7479 tree itype, elem;
7481 offset = 0;
7482 count = VECTOR_CST_NELTS (expr);
7483 itype = TREE_TYPE (TREE_TYPE (expr));
7484 size = GET_MODE_SIZE (TYPE_MODE (itype));
7485 for (i = 0; i < count; i++)
7487 elem = VECTOR_CST_ELT (expr, i);
7488 if (native_encode_expr (elem, ptr+offset, len-offset) != size)
7489 return 0;
7490 offset += size;
7492 return offset;
7496 /* Subroutine of native_encode_expr. Encode the STRING_CST
7497 specified by EXPR into the buffer PTR of length LEN bytes.
7498 Return the number of bytes placed in the buffer, or zero
7499 upon failure. */
7501 static int
7502 native_encode_string (const_tree expr, unsigned char *ptr, int len)
7504 tree type = TREE_TYPE (expr);
7505 HOST_WIDE_INT total_bytes;
7507 if (TREE_CODE (type) != ARRAY_TYPE
7508 || TREE_CODE (TREE_TYPE (type)) != INTEGER_TYPE
7509 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (type))) != BITS_PER_UNIT
7510 || !tree_fits_shwi_p (TYPE_SIZE_UNIT (type)))
7511 return 0;
7512 total_bytes = tree_to_shwi (TYPE_SIZE_UNIT (type));
7513 if (total_bytes > len)
7514 return 0;
7515 if (TREE_STRING_LENGTH (expr) < total_bytes)
7517 memcpy (ptr, TREE_STRING_POINTER (expr), TREE_STRING_LENGTH (expr));
7518 memset (ptr + TREE_STRING_LENGTH (expr), 0,
7519 total_bytes - TREE_STRING_LENGTH (expr));
7521 else
7522 memcpy (ptr, TREE_STRING_POINTER (expr), total_bytes);
7523 return total_bytes;
7527 /* Subroutine of fold_view_convert_expr. Encode the INTEGER_CST,
7528 REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7529 buffer PTR of length LEN bytes. Return the number of bytes
7530 placed in the buffer, or zero upon failure. */
7533 native_encode_expr (const_tree expr, unsigned char *ptr, int len)
7535 switch (TREE_CODE (expr))
7537 case INTEGER_CST:
7538 return native_encode_int (expr, ptr, len);
7540 case REAL_CST:
7541 return native_encode_real (expr, ptr, len);
7543 case FIXED_CST:
7544 return native_encode_fixed (expr, ptr, len);
7546 case COMPLEX_CST:
7547 return native_encode_complex (expr, ptr, len);
7549 case VECTOR_CST:
7550 return native_encode_vector (expr, ptr, len);
7552 case STRING_CST:
7553 return native_encode_string (expr, ptr, len);
7555 default:
7556 return 0;
7561 /* Subroutine of native_interpret_expr. Interpret the contents of
7562 the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7563 If the buffer cannot be interpreted, return NULL_TREE. */
7565 static tree
7566 native_interpret_int (tree type, const unsigned char *ptr, int len)
7568 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7569 double_int result;
7571 if (total_bytes > len
7572 || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7573 return NULL_TREE;
7575 result = double_int::from_buffer (ptr, total_bytes);
7577 return double_int_to_tree (type, result);
7581 /* Subroutine of native_interpret_expr. Interpret the contents of
7582 the buffer PTR of length LEN as a FIXED_CST of type TYPE.
7583 If the buffer cannot be interpreted, return NULL_TREE. */
7585 static tree
7586 native_interpret_fixed (tree type, const unsigned char *ptr, int len)
7588 int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7589 double_int result;
7590 FIXED_VALUE_TYPE fixed_value;
7592 if (total_bytes > len
7593 || total_bytes * BITS_PER_UNIT > HOST_BITS_PER_DOUBLE_INT)
7594 return NULL_TREE;
7596 result = double_int::from_buffer (ptr, total_bytes);
7597 fixed_value = fixed_from_double_int (result, TYPE_MODE (type));
7599 return build_fixed (type, fixed_value);
7603 /* Subroutine of native_interpret_expr. Interpret the contents of
7604 the buffer PTR of length LEN as a REAL_CST of type TYPE.
7605 If the buffer cannot be interpreted, return NULL_TREE. */
7607 static tree
7608 native_interpret_real (tree type, const unsigned char *ptr, int len)
7610 enum machine_mode mode = TYPE_MODE (type);
7611 int total_bytes = GET_MODE_SIZE (mode);
7612 int byte, offset, word, words, bitpos;
7613 unsigned char value;
7614 /* There are always 32 bits in each long, no matter the size of
7615 the hosts long. We handle floating point representations with
7616 up to 192 bits. */
7617 REAL_VALUE_TYPE r;
7618 long tmp[6];
7620 total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7621 if (total_bytes > len || total_bytes > 24)
7622 return NULL_TREE;
7623 words = (32 / BITS_PER_UNIT) / UNITS_PER_WORD;
7625 memset (tmp, 0, sizeof (tmp));
7626 for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7627 bitpos += BITS_PER_UNIT)
7629 byte = (bitpos / BITS_PER_UNIT) & 3;
7630 if (UNITS_PER_WORD < 4)
7632 word = byte / UNITS_PER_WORD;
7633 if (WORDS_BIG_ENDIAN)
7634 word = (words - 1) - word;
7635 offset = word * UNITS_PER_WORD;
7636 if (BYTES_BIG_ENDIAN)
7637 offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7638 else
7639 offset += byte % UNITS_PER_WORD;
7641 else
7642 offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7643 value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7645 tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7648 real_from_target (&r, tmp, mode);
7649 return build_real (type, r);
7653 /* Subroutine of native_interpret_expr. Interpret the contents of
7654 the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7655 If the buffer cannot be interpreted, return NULL_TREE. */
7657 static tree
7658 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7660 tree etype, rpart, ipart;
7661 int size;
7663 etype = TREE_TYPE (type);
7664 size = GET_MODE_SIZE (TYPE_MODE (etype));
7665 if (size * 2 > len)
7666 return NULL_TREE;
7667 rpart = native_interpret_expr (etype, ptr, size);
7668 if (!rpart)
7669 return NULL_TREE;
7670 ipart = native_interpret_expr (etype, ptr+size, size);
7671 if (!ipart)
7672 return NULL_TREE;
7673 return build_complex (type, rpart, ipart);
7677 /* Subroutine of native_interpret_expr. Interpret the contents of
7678 the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7679 If the buffer cannot be interpreted, return NULL_TREE. */
7681 static tree
7682 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7684 tree etype, elem;
7685 int i, size, count;
7686 tree *elements;
7688 etype = TREE_TYPE (type);
7689 size = GET_MODE_SIZE (TYPE_MODE (etype));
7690 count = TYPE_VECTOR_SUBPARTS (type);
7691 if (size * count > len)
7692 return NULL_TREE;
7694 elements = XALLOCAVEC (tree, count);
7695 for (i = count - 1; i >= 0; i--)
7697 elem = native_interpret_expr (etype, ptr+(i*size), size);
7698 if (!elem)
7699 return NULL_TREE;
7700 elements[i] = elem;
7702 return build_vector (type, elements);
7706 /* Subroutine of fold_view_convert_expr. Interpret the contents of
7707 the buffer PTR of length LEN as a constant of type TYPE. For
7708 INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7709 we return a REAL_CST, etc... If the buffer cannot be interpreted,
7710 return NULL_TREE. */
7712 tree
7713 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7715 switch (TREE_CODE (type))
7717 case INTEGER_TYPE:
7718 case ENUMERAL_TYPE:
7719 case BOOLEAN_TYPE:
7720 case POINTER_TYPE:
7721 case REFERENCE_TYPE:
7722 return native_interpret_int (type, ptr, len);
7724 case REAL_TYPE:
7725 return native_interpret_real (type, ptr, len);
7727 case FIXED_POINT_TYPE:
7728 return native_interpret_fixed (type, ptr, len);
7730 case COMPLEX_TYPE:
7731 return native_interpret_complex (type, ptr, len);
7733 case VECTOR_TYPE:
7734 return native_interpret_vector (type, ptr, len);
7736 default:
7737 return NULL_TREE;
7741 /* Returns true if we can interpret the contents of a native encoding
7742 as TYPE. */
7744 static bool
7745 can_native_interpret_type_p (tree type)
7747 switch (TREE_CODE (type))
7749 case INTEGER_TYPE:
7750 case ENUMERAL_TYPE:
7751 case BOOLEAN_TYPE:
7752 case POINTER_TYPE:
7753 case REFERENCE_TYPE:
7754 case FIXED_POINT_TYPE:
7755 case REAL_TYPE:
7756 case COMPLEX_TYPE:
7757 case VECTOR_TYPE:
7758 return true;
7759 default:
7760 return false;
7764 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7765 TYPE at compile-time. If we're unable to perform the conversion
7766 return NULL_TREE. */
7768 static tree
7769 fold_view_convert_expr (tree type, tree expr)
7771 /* We support up to 512-bit values (for V8DFmode). */
7772 unsigned char buffer[64];
7773 int len;
7775 /* Check that the host and target are sane. */
7776 if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7777 return NULL_TREE;
7779 len = native_encode_expr (expr, buffer, sizeof (buffer));
7780 if (len == 0)
7781 return NULL_TREE;
7783 return native_interpret_expr (type, buffer, len);
7786 /* Build an expression for the address of T. Folds away INDIRECT_REF
7787 to avoid confusing the gimplify process. */
7789 tree
7790 build_fold_addr_expr_with_type_loc (location_t loc, tree t, tree ptrtype)
7792 /* The size of the object is not relevant when talking about its address. */
7793 if (TREE_CODE (t) == WITH_SIZE_EXPR)
7794 t = TREE_OPERAND (t, 0);
7796 if (TREE_CODE (t) == INDIRECT_REF)
7798 t = TREE_OPERAND (t, 0);
7800 if (TREE_TYPE (t) != ptrtype)
7801 t = build1_loc (loc, NOP_EXPR, ptrtype, t);
7803 else if (TREE_CODE (t) == MEM_REF
7804 && integer_zerop (TREE_OPERAND (t, 1)))
7805 return TREE_OPERAND (t, 0);
7806 else if (TREE_CODE (t) == MEM_REF
7807 && TREE_CODE (TREE_OPERAND (t, 0)) == INTEGER_CST)
7808 return fold_binary (POINTER_PLUS_EXPR, ptrtype,
7809 TREE_OPERAND (t, 0),
7810 convert_to_ptrofftype (TREE_OPERAND (t, 1)));
7811 else if (TREE_CODE (t) == VIEW_CONVERT_EXPR)
7813 t = build_fold_addr_expr_loc (loc, TREE_OPERAND (t, 0));
7815 if (TREE_TYPE (t) != ptrtype)
7816 t = fold_convert_loc (loc, ptrtype, t);
7818 else
7819 t = build1_loc (loc, ADDR_EXPR, ptrtype, t);
7821 return t;
7824 /* Build an expression for the address of T. */
7826 tree
7827 build_fold_addr_expr_loc (location_t loc, tree t)
7829 tree ptrtype = build_pointer_type (TREE_TYPE (t));
7831 return build_fold_addr_expr_with_type_loc (loc, t, ptrtype);
7834 static bool vec_cst_ctor_to_array (tree, tree *);
7836 /* Fold a unary expression of code CODE and type TYPE with operand
7837 OP0. Return the folded expression if folding is successful.
7838 Otherwise, return NULL_TREE. */
7840 tree
7841 fold_unary_loc (location_t loc, enum tree_code code, tree type, tree op0)
7843 tree tem;
7844 tree arg0;
7845 enum tree_code_class kind = TREE_CODE_CLASS (code);
7847 gcc_assert (IS_EXPR_CODE_CLASS (kind)
7848 && TREE_CODE_LENGTH (code) == 1);
7850 arg0 = op0;
7851 if (arg0)
7853 if (CONVERT_EXPR_CODE_P (code)
7854 || code == FLOAT_EXPR || code == ABS_EXPR || code == NEGATE_EXPR)
7856 /* Don't use STRIP_NOPS, because signedness of argument type
7857 matters. */
7858 STRIP_SIGN_NOPS (arg0);
7860 else
7862 /* Strip any conversions that don't change the mode. This
7863 is safe for every expression, except for a comparison
7864 expression because its signedness is derived from its
7865 operands.
7867 Note that this is done as an internal manipulation within
7868 the constant folder, in order to find the simplest
7869 representation of the arguments so that their form can be
7870 studied. In any cases, the appropriate type conversions
7871 should be put back in the tree that will get out of the
7872 constant folder. */
7873 STRIP_NOPS (arg0);
7877 if (TREE_CODE_CLASS (code) == tcc_unary)
7879 if (TREE_CODE (arg0) == COMPOUND_EXPR)
7880 return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7881 fold_build1_loc (loc, code, type,
7882 fold_convert_loc (loc, TREE_TYPE (op0),
7883 TREE_OPERAND (arg0, 1))));
7884 else if (TREE_CODE (arg0) == COND_EXPR)
7886 tree arg01 = TREE_OPERAND (arg0, 1);
7887 tree arg02 = TREE_OPERAND (arg0, 2);
7888 if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7889 arg01 = fold_build1_loc (loc, code, type,
7890 fold_convert_loc (loc,
7891 TREE_TYPE (op0), arg01));
7892 if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7893 arg02 = fold_build1_loc (loc, code, type,
7894 fold_convert_loc (loc,
7895 TREE_TYPE (op0), arg02));
7896 tem = fold_build3_loc (loc, COND_EXPR, type, TREE_OPERAND (arg0, 0),
7897 arg01, arg02);
7899 /* If this was a conversion, and all we did was to move into
7900 inside the COND_EXPR, bring it back out. But leave it if
7901 it is a conversion from integer to integer and the
7902 result precision is no wider than a word since such a
7903 conversion is cheap and may be optimized away by combine,
7904 while it couldn't if it were outside the COND_EXPR. Then return
7905 so we don't get into an infinite recursion loop taking the
7906 conversion out and then back in. */
7908 if ((CONVERT_EXPR_CODE_P (code)
7909 || code == NON_LVALUE_EXPR)
7910 && TREE_CODE (tem) == COND_EXPR
7911 && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7912 && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7913 && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7914 && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7915 && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7916 == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7917 && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7918 && (INTEGRAL_TYPE_P
7919 (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7920 && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7921 || flag_syntax_only))
7922 tem = build1_loc (loc, code, type,
7923 build3 (COND_EXPR,
7924 TREE_TYPE (TREE_OPERAND
7925 (TREE_OPERAND (tem, 1), 0)),
7926 TREE_OPERAND (tem, 0),
7927 TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7928 TREE_OPERAND (TREE_OPERAND (tem, 2),
7929 0)));
7930 return tem;
7934 switch (code)
7936 case PAREN_EXPR:
7937 /* Re-association barriers around constants and other re-association
7938 barriers can be removed. */
7939 if (CONSTANT_CLASS_P (op0)
7940 || TREE_CODE (op0) == PAREN_EXPR)
7941 return fold_convert_loc (loc, type, op0);
7942 return NULL_TREE;
7944 CASE_CONVERT:
7945 case FLOAT_EXPR:
7946 case FIX_TRUNC_EXPR:
7947 if (TREE_TYPE (op0) == type)
7948 return op0;
7950 if (COMPARISON_CLASS_P (op0))
7952 /* If we have (type) (a CMP b) and type is an integral type, return
7953 new expression involving the new type. Canonicalize
7954 (type) (a CMP b) to (a CMP b) ? (type) true : (type) false for
7955 non-integral type.
7956 Do not fold the result as that would not simplify further, also
7957 folding again results in recursions. */
7958 if (TREE_CODE (type) == BOOLEAN_TYPE)
7959 return build2_loc (loc, TREE_CODE (op0), type,
7960 TREE_OPERAND (op0, 0),
7961 TREE_OPERAND (op0, 1));
7962 else if (!INTEGRAL_TYPE_P (type) && !VOID_TYPE_P (type)
7963 && TREE_CODE (type) != VECTOR_TYPE)
7964 return build3_loc (loc, COND_EXPR, type, op0,
7965 constant_boolean_node (true, type),
7966 constant_boolean_node (false, type));
7969 /* Handle cases of two conversions in a row. */
7970 if (CONVERT_EXPR_P (op0))
7972 tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
7973 tree inter_type = TREE_TYPE (op0);
7974 int inside_int = INTEGRAL_TYPE_P (inside_type);
7975 int inside_ptr = POINTER_TYPE_P (inside_type);
7976 int inside_float = FLOAT_TYPE_P (inside_type);
7977 int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
7978 unsigned int inside_prec = TYPE_PRECISION (inside_type);
7979 int inside_unsignedp = TYPE_UNSIGNED (inside_type);
7980 int inter_int = INTEGRAL_TYPE_P (inter_type);
7981 int inter_ptr = POINTER_TYPE_P (inter_type);
7982 int inter_float = FLOAT_TYPE_P (inter_type);
7983 int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
7984 unsigned int inter_prec = TYPE_PRECISION (inter_type);
7985 int inter_unsignedp = TYPE_UNSIGNED (inter_type);
7986 int final_int = INTEGRAL_TYPE_P (type);
7987 int final_ptr = POINTER_TYPE_P (type);
7988 int final_float = FLOAT_TYPE_P (type);
7989 int final_vec = TREE_CODE (type) == VECTOR_TYPE;
7990 unsigned int final_prec = TYPE_PRECISION (type);
7991 int final_unsignedp = TYPE_UNSIGNED (type);
7993 /* In addition to the cases of two conversions in a row
7994 handled below, if we are converting something to its own
7995 type via an object of identical or wider precision, neither
7996 conversion is needed. */
7997 if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
7998 && (((inter_int || inter_ptr) && final_int)
7999 || (inter_float && final_float))
8000 && inter_prec >= final_prec)
8001 return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
8003 /* Likewise, if the intermediate and initial types are either both
8004 float or both integer, we don't need the middle conversion if the
8005 former is wider than the latter and doesn't change the signedness
8006 (for integers). Avoid this if the final type is a pointer since
8007 then we sometimes need the middle conversion. Likewise if the
8008 final type has a precision not equal to the size of its mode. */
8009 if (((inter_int && inside_int)
8010 || (inter_float && inside_float)
8011 || (inter_vec && inside_vec))
8012 && inter_prec >= inside_prec
8013 && (inter_float || inter_vec
8014 || inter_unsignedp == inside_unsignedp)
8015 && ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
8016 && TYPE_MODE (type) == TYPE_MODE (inter_type))
8017 && ! final_ptr
8018 && (! final_vec || inter_prec == inside_prec))
8019 return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
8021 /* If we have a sign-extension of a zero-extended value, we can
8022 replace that by a single zero-extension. Likewise if the
8023 final conversion does not change precision we can drop the
8024 intermediate conversion. */
8025 if (inside_int && inter_int && final_int
8026 && ((inside_prec < inter_prec && inter_prec < final_prec
8027 && inside_unsignedp && !inter_unsignedp)
8028 || final_prec == inter_prec))
8029 return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
8031 /* Two conversions in a row are not needed unless:
8032 - some conversion is floating-point (overstrict for now), or
8033 - some conversion is a vector (overstrict for now), or
8034 - the intermediate type is narrower than both initial and
8035 final, or
8036 - the intermediate type and innermost type differ in signedness,
8037 and the outermost type is wider than the intermediate, or
8038 - the initial type is a pointer type and the precisions of the
8039 intermediate and final types differ, or
8040 - the final type is a pointer type and the precisions of the
8041 initial and intermediate types differ. */
8042 if (! inside_float && ! inter_float && ! final_float
8043 && ! inside_vec && ! inter_vec && ! final_vec
8044 && (inter_prec >= inside_prec || inter_prec >= final_prec)
8045 && ! (inside_int && inter_int
8046 && inter_unsignedp != inside_unsignedp
8047 && inter_prec < final_prec)
8048 && ((inter_unsignedp && inter_prec > inside_prec)
8049 == (final_unsignedp && final_prec > inter_prec))
8050 && ! (inside_ptr && inter_prec != final_prec)
8051 && ! (final_ptr && inside_prec != inter_prec)
8052 && ! (final_prec != GET_MODE_PRECISION (TYPE_MODE (type))
8053 && TYPE_MODE (type) == TYPE_MODE (inter_type)))
8054 return fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 0));
8057 /* Handle (T *)&A.B.C for A being of type T and B and C
8058 living at offset zero. This occurs frequently in
8059 C++ upcasting and then accessing the base. */
8060 if (TREE_CODE (op0) == ADDR_EXPR
8061 && POINTER_TYPE_P (type)
8062 && handled_component_p (TREE_OPERAND (op0, 0)))
8064 HOST_WIDE_INT bitsize, bitpos;
8065 tree offset;
8066 enum machine_mode mode;
8067 int unsignedp, volatilep;
8068 tree base = TREE_OPERAND (op0, 0);
8069 base = get_inner_reference (base, &bitsize, &bitpos, &offset,
8070 &mode, &unsignedp, &volatilep, false);
8071 /* If the reference was to a (constant) zero offset, we can use
8072 the address of the base if it has the same base type
8073 as the result type and the pointer type is unqualified. */
8074 if (! offset && bitpos == 0
8075 && (TYPE_MAIN_VARIANT (TREE_TYPE (type))
8076 == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
8077 && TYPE_QUALS (type) == TYPE_UNQUALIFIED)
8078 return fold_convert_loc (loc, type,
8079 build_fold_addr_expr_loc (loc, base));
8082 if (TREE_CODE (op0) == MODIFY_EXPR
8083 && TREE_CONSTANT (TREE_OPERAND (op0, 1))
8084 /* Detect assigning a bitfield. */
8085 && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
8086 && DECL_BIT_FIELD
8087 (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
8089 /* Don't leave an assignment inside a conversion
8090 unless assigning a bitfield. */
8091 tem = fold_build1_loc (loc, code, type, TREE_OPERAND (op0, 1));
8092 /* First do the assignment, then return converted constant. */
8093 tem = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
8094 TREE_NO_WARNING (tem) = 1;
8095 TREE_USED (tem) = 1;
8096 return tem;
8099 /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
8100 constants (if x has signed type, the sign bit cannot be set
8101 in c). This folds extension into the BIT_AND_EXPR.
8102 ??? We don't do it for BOOLEAN_TYPE or ENUMERAL_TYPE because they
8103 very likely don't have maximal range for their precision and this
8104 transformation effectively doesn't preserve non-maximal ranges. */
8105 if (TREE_CODE (type) == INTEGER_TYPE
8106 && TREE_CODE (op0) == BIT_AND_EXPR
8107 && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
8109 tree and_expr = op0;
8110 tree and0 = TREE_OPERAND (and_expr, 0);
8111 tree and1 = TREE_OPERAND (and_expr, 1);
8112 int change = 0;
8114 if (TYPE_UNSIGNED (TREE_TYPE (and_expr))
8115 || (TYPE_PRECISION (type)
8116 <= TYPE_PRECISION (TREE_TYPE (and_expr))))
8117 change = 1;
8118 else if (TYPE_PRECISION (TREE_TYPE (and1))
8119 <= HOST_BITS_PER_WIDE_INT
8120 && tree_fits_uhwi_p (and1))
8122 unsigned HOST_WIDE_INT cst;
8124 cst = tree_to_uhwi (and1);
8125 cst &= HOST_WIDE_INT_M1U
8126 << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
8127 change = (cst == 0);
8128 #ifdef LOAD_EXTEND_OP
8129 if (change
8130 && !flag_syntax_only
8131 && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
8132 == ZERO_EXTEND))
8134 tree uns = unsigned_type_for (TREE_TYPE (and0));
8135 and0 = fold_convert_loc (loc, uns, and0);
8136 and1 = fold_convert_loc (loc, uns, and1);
8138 #endif
8140 if (change)
8142 tem = force_fit_type_double (type, tree_to_double_int (and1),
8143 0, TREE_OVERFLOW (and1));
8144 return fold_build2_loc (loc, BIT_AND_EXPR, type,
8145 fold_convert_loc (loc, type, and0), tem);
8149 /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
8150 when one of the new casts will fold away. Conservatively we assume
8151 that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
8152 if (POINTER_TYPE_P (type)
8153 && TREE_CODE (arg0) == POINTER_PLUS_EXPR
8154 && (!TYPE_RESTRICT (type) || TYPE_RESTRICT (TREE_TYPE (arg0)))
8155 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8156 || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
8157 || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
8159 tree arg00 = TREE_OPERAND (arg0, 0);
8160 tree arg01 = TREE_OPERAND (arg0, 1);
8162 return fold_build_pointer_plus_loc
8163 (loc, fold_convert_loc (loc, type, arg00), arg01);
8166 /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
8167 of the same precision, and X is an integer type not narrower than
8168 types T1 or T2, i.e. the cast (T2)X isn't an extension. */
8169 if (INTEGRAL_TYPE_P (type)
8170 && TREE_CODE (op0) == BIT_NOT_EXPR
8171 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8172 && CONVERT_EXPR_P (TREE_OPERAND (op0, 0))
8173 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
8175 tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
8176 if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
8177 && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
8178 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
8179 fold_convert_loc (loc, type, tem));
8182 /* Convert (T1)(X * Y) into (T1)X * (T1)Y if T1 is narrower than the
8183 type of X and Y (integer types only). */
8184 if (INTEGRAL_TYPE_P (type)
8185 && TREE_CODE (op0) == MULT_EXPR
8186 && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8187 && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (op0)))
8189 /* Be careful not to introduce new overflows. */
8190 tree mult_type;
8191 if (TYPE_OVERFLOW_WRAPS (type))
8192 mult_type = type;
8193 else
8194 mult_type = unsigned_type_for (type);
8196 if (TYPE_PRECISION (mult_type) < TYPE_PRECISION (TREE_TYPE (op0)))
8198 tem = fold_build2_loc (loc, MULT_EXPR, mult_type,
8199 fold_convert_loc (loc, mult_type,
8200 TREE_OPERAND (op0, 0)),
8201 fold_convert_loc (loc, mult_type,
8202 TREE_OPERAND (op0, 1)));
8203 return fold_convert_loc (loc, type, tem);
8207 tem = fold_convert_const (code, type, op0);
8208 return tem ? tem : NULL_TREE;
8210 case ADDR_SPACE_CONVERT_EXPR:
8211 if (integer_zerop (arg0))
8212 return fold_convert_const (code, type, arg0);
8213 return NULL_TREE;
8215 case FIXED_CONVERT_EXPR:
8216 tem = fold_convert_const (code, type, arg0);
8217 return tem ? tem : NULL_TREE;
8219 case VIEW_CONVERT_EXPR:
8220 if (TREE_TYPE (op0) == type)
8221 return op0;
8222 if (TREE_CODE (op0) == VIEW_CONVERT_EXPR)
8223 return fold_build1_loc (loc, VIEW_CONVERT_EXPR,
8224 type, TREE_OPERAND (op0, 0));
8225 if (TREE_CODE (op0) == MEM_REF)
8226 return fold_build2_loc (loc, MEM_REF, type,
8227 TREE_OPERAND (op0, 0), TREE_OPERAND (op0, 1));
8229 /* For integral conversions with the same precision or pointer
8230 conversions use a NOP_EXPR instead. */
8231 if ((INTEGRAL_TYPE_P (type)
8232 || POINTER_TYPE_P (type))
8233 && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
8234 || POINTER_TYPE_P (TREE_TYPE (op0)))
8235 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
8236 return fold_convert_loc (loc, type, op0);
8238 /* Strip inner integral conversions that do not change the precision. */
8239 if (CONVERT_EXPR_P (op0)
8240 && (INTEGRAL_TYPE_P (TREE_TYPE (op0))
8241 || POINTER_TYPE_P (TREE_TYPE (op0)))
8242 && (INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
8243 || POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0))))
8244 && (TYPE_PRECISION (TREE_TYPE (op0))
8245 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
8246 return fold_build1_loc (loc, VIEW_CONVERT_EXPR,
8247 type, TREE_OPERAND (op0, 0));
8249 return fold_view_convert_expr (type, op0);
8251 case NEGATE_EXPR:
8252 tem = fold_negate_expr (loc, arg0);
8253 if (tem)
8254 return fold_convert_loc (loc, type, tem);
8255 return NULL_TREE;
8257 case ABS_EXPR:
8258 if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
8259 return fold_abs_const (arg0, type);
8260 else if (TREE_CODE (arg0) == NEGATE_EXPR)
8261 return fold_build1_loc (loc, ABS_EXPR, type, TREE_OPERAND (arg0, 0));
8262 /* Convert fabs((double)float) into (double)fabsf(float). */
8263 else if (TREE_CODE (arg0) == NOP_EXPR
8264 && TREE_CODE (type) == REAL_TYPE)
8266 tree targ0 = strip_float_extensions (arg0);
8267 if (targ0 != arg0)
8268 return fold_convert_loc (loc, type,
8269 fold_build1_loc (loc, ABS_EXPR,
8270 TREE_TYPE (targ0),
8271 targ0));
8273 /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on. */
8274 else if (TREE_CODE (arg0) == ABS_EXPR)
8275 return arg0;
8276 else if (tree_expr_nonnegative_p (arg0))
8277 return arg0;
8279 /* Strip sign ops from argument. */
8280 if (TREE_CODE (type) == REAL_TYPE)
8282 tem = fold_strip_sign_ops (arg0);
8283 if (tem)
8284 return fold_build1_loc (loc, ABS_EXPR, type,
8285 fold_convert_loc (loc, type, tem));
8287 return NULL_TREE;
8289 case CONJ_EXPR:
8290 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8291 return fold_convert_loc (loc, type, arg0);
8292 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8294 tree itype = TREE_TYPE (type);
8295 tree rpart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 0));
8296 tree ipart = fold_convert_loc (loc, itype, TREE_OPERAND (arg0, 1));
8297 return fold_build2_loc (loc, COMPLEX_EXPR, type, rpart,
8298 negate_expr (ipart));
8300 if (TREE_CODE (arg0) == COMPLEX_CST)
8302 tree itype = TREE_TYPE (type);
8303 tree rpart = fold_convert_loc (loc, itype, TREE_REALPART (arg0));
8304 tree ipart = fold_convert_loc (loc, itype, TREE_IMAGPART (arg0));
8305 return build_complex (type, rpart, negate_expr (ipart));
8307 if (TREE_CODE (arg0) == CONJ_EXPR)
8308 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
8309 return NULL_TREE;
8311 case BIT_NOT_EXPR:
8312 if (TREE_CODE (arg0) == INTEGER_CST)
8313 return fold_not_const (arg0, type);
8314 else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
8315 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
8316 /* Convert ~ (-A) to A - 1. */
8317 else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
8318 return fold_build2_loc (loc, MINUS_EXPR, type,
8319 fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0)),
8320 build_int_cst (type, 1));
8321 /* Convert ~ (A - 1) or ~ (A + -1) to -A. */
8322 else if (INTEGRAL_TYPE_P (type)
8323 && ((TREE_CODE (arg0) == MINUS_EXPR
8324 && integer_onep (TREE_OPERAND (arg0, 1)))
8325 || (TREE_CODE (arg0) == PLUS_EXPR
8326 && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
8327 return fold_build1_loc (loc, NEGATE_EXPR, type,
8328 fold_convert_loc (loc, type,
8329 TREE_OPERAND (arg0, 0)));
8330 /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify. */
8331 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8332 && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8333 fold_convert_loc (loc, type,
8334 TREE_OPERAND (arg0, 0)))))
8335 return fold_build2_loc (loc, BIT_XOR_EXPR, type, tem,
8336 fold_convert_loc (loc, type,
8337 TREE_OPERAND (arg0, 1)));
8338 else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8339 && (tem = fold_unary_loc (loc, BIT_NOT_EXPR, type,
8340 fold_convert_loc (loc, type,
8341 TREE_OPERAND (arg0, 1)))))
8342 return fold_build2_loc (loc, BIT_XOR_EXPR, type,
8343 fold_convert_loc (loc, type,
8344 TREE_OPERAND (arg0, 0)), tem);
8345 /* Perform BIT_NOT_EXPR on each element individually. */
8346 else if (TREE_CODE (arg0) == VECTOR_CST)
8348 tree *elements;
8349 tree elem;
8350 unsigned count = VECTOR_CST_NELTS (arg0), i;
8352 elements = XALLOCAVEC (tree, count);
8353 for (i = 0; i < count; i++)
8355 elem = VECTOR_CST_ELT (arg0, i);
8356 elem = fold_unary_loc (loc, BIT_NOT_EXPR, TREE_TYPE (type), elem);
8357 if (elem == NULL_TREE)
8358 break;
8359 elements[i] = elem;
8361 if (i == count)
8362 return build_vector (type, elements);
8364 else if (COMPARISON_CLASS_P (arg0)
8365 && (VECTOR_TYPE_P (type)
8366 || (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) == 1)))
8368 tree op_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
8369 enum tree_code subcode = invert_tree_comparison (TREE_CODE (arg0),
8370 HONOR_NANS (TYPE_MODE (op_type)));
8371 if (subcode != ERROR_MARK)
8372 return build2_loc (loc, subcode, type, TREE_OPERAND (arg0, 0),
8373 TREE_OPERAND (arg0, 1));
8377 return NULL_TREE;
8379 case TRUTH_NOT_EXPR:
8380 /* Note that the operand of this must be an int
8381 and its values must be 0 or 1.
8382 ("true" is a fixed value perhaps depending on the language,
8383 but we don't handle values other than 1 correctly yet.) */
8384 tem = fold_truth_not_expr (loc, arg0);
8385 if (!tem)
8386 return NULL_TREE;
8387 return fold_convert_loc (loc, type, tem);
8389 case REALPART_EXPR:
8390 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8391 return fold_convert_loc (loc, type, arg0);
8392 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8393 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
8394 TREE_OPERAND (arg0, 1));
8395 if (TREE_CODE (arg0) == COMPLEX_CST)
8396 return fold_convert_loc (loc, type, TREE_REALPART (arg0));
8397 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8399 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8400 tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8401 fold_build1_loc (loc, REALPART_EXPR, itype,
8402 TREE_OPERAND (arg0, 0)),
8403 fold_build1_loc (loc, REALPART_EXPR, itype,
8404 TREE_OPERAND (arg0, 1)));
8405 return fold_convert_loc (loc, type, tem);
8407 if (TREE_CODE (arg0) == CONJ_EXPR)
8409 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8410 tem = fold_build1_loc (loc, REALPART_EXPR, itype,
8411 TREE_OPERAND (arg0, 0));
8412 return fold_convert_loc (loc, type, tem);
8414 if (TREE_CODE (arg0) == CALL_EXPR)
8416 tree fn = get_callee_fndecl (arg0);
8417 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8418 switch (DECL_FUNCTION_CODE (fn))
8420 CASE_FLT_FN (BUILT_IN_CEXPI):
8421 fn = mathfn_built_in (type, BUILT_IN_COS);
8422 if (fn)
8423 return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8424 break;
8426 default:
8427 break;
8430 return NULL_TREE;
8432 case IMAGPART_EXPR:
8433 if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8434 return build_zero_cst (type);
8435 if (TREE_CODE (arg0) == COMPLEX_EXPR)
8436 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 1),
8437 TREE_OPERAND (arg0, 0));
8438 if (TREE_CODE (arg0) == COMPLEX_CST)
8439 return fold_convert_loc (loc, type, TREE_IMAGPART (arg0));
8440 if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8442 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8443 tem = fold_build2_loc (loc, TREE_CODE (arg0), itype,
8444 fold_build1_loc (loc, IMAGPART_EXPR, itype,
8445 TREE_OPERAND (arg0, 0)),
8446 fold_build1_loc (loc, IMAGPART_EXPR, itype,
8447 TREE_OPERAND (arg0, 1)));
8448 return fold_convert_loc (loc, type, tem);
8450 if (TREE_CODE (arg0) == CONJ_EXPR)
8452 tree itype = TREE_TYPE (TREE_TYPE (arg0));
8453 tem = fold_build1_loc (loc, IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8454 return fold_convert_loc (loc, type, negate_expr (tem));
8456 if (TREE_CODE (arg0) == CALL_EXPR)
8458 tree fn = get_callee_fndecl (arg0);
8459 if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8460 switch (DECL_FUNCTION_CODE (fn))
8462 CASE_FLT_FN (BUILT_IN_CEXPI):
8463 fn = mathfn_built_in (type, BUILT_IN_SIN);
8464 if (fn)
8465 return build_call_expr_loc (loc, fn, 1, CALL_EXPR_ARG (arg0, 0));
8466 break;
8468 default:
8469 break;
8472 return NULL_TREE;
8474 case INDIRECT_REF:
8475 /* Fold *&X to X if X is an lvalue. */
8476 if (TREE_CODE (op0) == ADDR_EXPR)
8478 tree op00 = TREE_OPERAND (op0, 0);
8479 if ((TREE_CODE (op00) == VAR_DECL
8480 || TREE_CODE (op00) == PARM_DECL
8481 || TREE_CODE (op00) == RESULT_DECL)
8482 && !TREE_READONLY (op00))
8483 return op00;
8485 return NULL_TREE;
8487 case VEC_UNPACK_LO_EXPR:
8488 case VEC_UNPACK_HI_EXPR:
8489 case VEC_UNPACK_FLOAT_LO_EXPR:
8490 case VEC_UNPACK_FLOAT_HI_EXPR:
8492 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
8493 tree *elts;
8494 enum tree_code subcode;
8496 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2);
8497 if (TREE_CODE (arg0) != VECTOR_CST)
8498 return NULL_TREE;
8500 elts = XALLOCAVEC (tree, nelts * 2);
8501 if (!vec_cst_ctor_to_array (arg0, elts))
8502 return NULL_TREE;
8504 if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_UNPACK_LO_EXPR
8505 || code == VEC_UNPACK_FLOAT_LO_EXPR))
8506 elts += nelts;
8508 if (code == VEC_UNPACK_LO_EXPR || code == VEC_UNPACK_HI_EXPR)
8509 subcode = NOP_EXPR;
8510 else
8511 subcode = FLOAT_EXPR;
8513 for (i = 0; i < nelts; i++)
8515 elts[i] = fold_convert_const (subcode, TREE_TYPE (type), elts[i]);
8516 if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
8517 return NULL_TREE;
8520 return build_vector (type, elts);
8523 case REDUC_MIN_EXPR:
8524 case REDUC_MAX_EXPR:
8525 case REDUC_PLUS_EXPR:
8527 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
8528 tree *elts;
8529 enum tree_code subcode;
8531 if (TREE_CODE (op0) != VECTOR_CST)
8532 return NULL_TREE;
8534 elts = XALLOCAVEC (tree, nelts);
8535 if (!vec_cst_ctor_to_array (op0, elts))
8536 return NULL_TREE;
8538 switch (code)
8540 case REDUC_MIN_EXPR: subcode = MIN_EXPR; break;
8541 case REDUC_MAX_EXPR: subcode = MAX_EXPR; break;
8542 case REDUC_PLUS_EXPR: subcode = PLUS_EXPR; break;
8543 default: gcc_unreachable ();
8546 for (i = 1; i < nelts; i++)
8548 elts[0] = const_binop (subcode, elts[0], elts[i]);
8549 if (elts[0] == NULL_TREE || !CONSTANT_CLASS_P (elts[0]))
8550 return NULL_TREE;
8551 elts[i] = build_zero_cst (TREE_TYPE (type));
8554 return build_vector (type, elts);
8557 default:
8558 return NULL_TREE;
8559 } /* switch (code) */
8563 /* If the operation was a conversion do _not_ mark a resulting constant
8564 with TREE_OVERFLOW if the original constant was not. These conversions
8565 have implementation defined behavior and retaining the TREE_OVERFLOW
8566 flag here would confuse later passes such as VRP. */
8567 tree
8568 fold_unary_ignore_overflow_loc (location_t loc, enum tree_code code,
8569 tree type, tree op0)
8571 tree res = fold_unary_loc (loc, code, type, op0);
8572 if (res
8573 && TREE_CODE (res) == INTEGER_CST
8574 && TREE_CODE (op0) == INTEGER_CST
8575 && CONVERT_EXPR_CODE_P (code))
8576 TREE_OVERFLOW (res) = TREE_OVERFLOW (op0);
8578 return res;
8581 /* Fold a binary bitwise/truth expression of code CODE and type TYPE with
8582 operands OP0 and OP1. LOC is the location of the resulting expression.
8583 ARG0 and ARG1 are the NOP_STRIPed results of OP0 and OP1.
8584 Return the folded expression if folding is successful. Otherwise,
8585 return NULL_TREE. */
8586 static tree
8587 fold_truth_andor (location_t loc, enum tree_code code, tree type,
8588 tree arg0, tree arg1, tree op0, tree op1)
8590 tree tem;
8592 /* We only do these simplifications if we are optimizing. */
8593 if (!optimize)
8594 return NULL_TREE;
8596 /* Check for things like (A || B) && (A || C). We can convert this
8597 to A || (B && C). Note that either operator can be any of the four
8598 truth and/or operations and the transformation will still be
8599 valid. Also note that we only care about order for the
8600 ANDIF and ORIF operators. If B contains side effects, this
8601 might change the truth-value of A. */
8602 if (TREE_CODE (arg0) == TREE_CODE (arg1)
8603 && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
8604 || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
8605 || TREE_CODE (arg0) == TRUTH_AND_EXPR
8606 || TREE_CODE (arg0) == TRUTH_OR_EXPR)
8607 && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
8609 tree a00 = TREE_OPERAND (arg0, 0);
8610 tree a01 = TREE_OPERAND (arg0, 1);
8611 tree a10 = TREE_OPERAND (arg1, 0);
8612 tree a11 = TREE_OPERAND (arg1, 1);
8613 int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
8614 || TREE_CODE (arg0) == TRUTH_AND_EXPR)
8615 && (code == TRUTH_AND_EXPR
8616 || code == TRUTH_OR_EXPR));
8618 if (operand_equal_p (a00, a10, 0))
8619 return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8620 fold_build2_loc (loc, code, type, a01, a11));
8621 else if (commutative && operand_equal_p (a00, a11, 0))
8622 return fold_build2_loc (loc, TREE_CODE (arg0), type, a00,
8623 fold_build2_loc (loc, code, type, a01, a10));
8624 else if (commutative && operand_equal_p (a01, a10, 0))
8625 return fold_build2_loc (loc, TREE_CODE (arg0), type, a01,
8626 fold_build2_loc (loc, code, type, a00, a11));
8628 /* This case if tricky because we must either have commutative
8629 operators or else A10 must not have side-effects. */
8631 else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
8632 && operand_equal_p (a01, a11, 0))
8633 return fold_build2_loc (loc, TREE_CODE (arg0), type,
8634 fold_build2_loc (loc, code, type, a00, a10),
8635 a01);
8638 /* See if we can build a range comparison. */
8639 if (0 != (tem = fold_range_test (loc, code, type, op0, op1)))
8640 return tem;
8642 if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg0) == TRUTH_ORIF_EXPR)
8643 || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg0) == TRUTH_ANDIF_EXPR))
8645 tem = merge_truthop_with_opposite_arm (loc, arg0, arg1, true);
8646 if (tem)
8647 return fold_build2_loc (loc, code, type, tem, arg1);
8650 if ((code == TRUTH_ANDIF_EXPR && TREE_CODE (arg1) == TRUTH_ORIF_EXPR)
8651 || (code == TRUTH_ORIF_EXPR && TREE_CODE (arg1) == TRUTH_ANDIF_EXPR))
8653 tem = merge_truthop_with_opposite_arm (loc, arg1, arg0, false);
8654 if (tem)
8655 return fold_build2_loc (loc, code, type, arg0, tem);
8658 /* Check for the possibility of merging component references. If our
8659 lhs is another similar operation, try to merge its rhs with our
8660 rhs. Then try to merge our lhs and rhs. */
8661 if (TREE_CODE (arg0) == code
8662 && 0 != (tem = fold_truth_andor_1 (loc, code, type,
8663 TREE_OPERAND (arg0, 1), arg1)))
8664 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
8666 if ((tem = fold_truth_andor_1 (loc, code, type, arg0, arg1)) != 0)
8667 return tem;
8669 if (LOGICAL_OP_NON_SHORT_CIRCUIT
8670 && (code == TRUTH_AND_EXPR
8671 || code == TRUTH_ANDIF_EXPR
8672 || code == TRUTH_OR_EXPR
8673 || code == TRUTH_ORIF_EXPR))
8675 enum tree_code ncode, icode;
8677 ncode = (code == TRUTH_ANDIF_EXPR || code == TRUTH_AND_EXPR)
8678 ? TRUTH_AND_EXPR : TRUTH_OR_EXPR;
8679 icode = ncode == TRUTH_AND_EXPR ? TRUTH_ANDIF_EXPR : TRUTH_ORIF_EXPR;
8681 /* Transform ((A AND-IF B) AND[-IF] C) into (A AND-IF (B AND C)),
8682 or ((A OR-IF B) OR[-IF] C) into (A OR-IF (B OR C))
8683 We don't want to pack more than two leafs to a non-IF AND/OR
8684 expression.
8685 If tree-code of left-hand operand isn't an AND/OR-IF code and not
8686 equal to IF-CODE, then we don't want to add right-hand operand.
8687 If the inner right-hand side of left-hand operand has
8688 side-effects, or isn't simple, then we can't add to it,
8689 as otherwise we might destroy if-sequence. */
8690 if (TREE_CODE (arg0) == icode
8691 && simple_operand_p_2 (arg1)
8692 /* Needed for sequence points to handle trappings, and
8693 side-effects. */
8694 && simple_operand_p_2 (TREE_OPERAND (arg0, 1)))
8696 tem = fold_build2_loc (loc, ncode, type, TREE_OPERAND (arg0, 1),
8697 arg1);
8698 return fold_build2_loc (loc, icode, type, TREE_OPERAND (arg0, 0),
8699 tem);
8701 /* Same as abouve but for (A AND[-IF] (B AND-IF C)) -> ((A AND B) AND-IF C),
8702 or (A OR[-IF] (B OR-IF C) -> ((A OR B) OR-IF C). */
8703 else if (TREE_CODE (arg1) == icode
8704 && simple_operand_p_2 (arg0)
8705 /* Needed for sequence points to handle trappings, and
8706 side-effects. */
8707 && simple_operand_p_2 (TREE_OPERAND (arg1, 0)))
8709 tem = fold_build2_loc (loc, ncode, type,
8710 arg0, TREE_OPERAND (arg1, 0));
8711 return fold_build2_loc (loc, icode, type, tem,
8712 TREE_OPERAND (arg1, 1));
8714 /* Transform (A AND-IF B) into (A AND B), or (A OR-IF B)
8715 into (A OR B).
8716 For sequence point consistancy, we need to check for trapping,
8717 and side-effects. */
8718 else if (code == icode && simple_operand_p_2 (arg0)
8719 && simple_operand_p_2 (arg1))
8720 return fold_build2_loc (loc, ncode, type, arg0, arg1);
8723 return NULL_TREE;
8726 /* Fold a binary expression of code CODE and type TYPE with operands
8727 OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8728 Return the folded expression if folding is successful. Otherwise,
8729 return NULL_TREE. */
8731 static tree
8732 fold_minmax (location_t loc, enum tree_code code, tree type, tree op0, tree op1)
8734 enum tree_code compl_code;
8736 if (code == MIN_EXPR)
8737 compl_code = MAX_EXPR;
8738 else if (code == MAX_EXPR)
8739 compl_code = MIN_EXPR;
8740 else
8741 gcc_unreachable ();
8743 /* MIN (MAX (a, b), b) == b. */
8744 if (TREE_CODE (op0) == compl_code
8745 && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
8746 return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 0));
8748 /* MIN (MAX (b, a), b) == b. */
8749 if (TREE_CODE (op0) == compl_code
8750 && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
8751 && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
8752 return omit_one_operand_loc (loc, type, op1, TREE_OPERAND (op0, 1));
8754 /* MIN (a, MAX (a, b)) == a. */
8755 if (TREE_CODE (op1) == compl_code
8756 && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
8757 && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
8758 return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 1));
8760 /* MIN (a, MAX (b, a)) == a. */
8761 if (TREE_CODE (op1) == compl_code
8762 && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
8763 && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
8764 return omit_one_operand_loc (loc, type, op0, TREE_OPERAND (op1, 0));
8766 return NULL_TREE;
8769 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8770 by changing CODE to reduce the magnitude of constants involved in
8771 ARG0 of the comparison.
8772 Returns a canonicalized comparison tree if a simplification was
8773 possible, otherwise returns NULL_TREE.
8774 Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8775 valid if signed overflow is undefined. */
8777 static tree
8778 maybe_canonicalize_comparison_1 (location_t loc, enum tree_code code, tree type,
8779 tree arg0, tree arg1,
8780 bool *strict_overflow_p)
8782 enum tree_code code0 = TREE_CODE (arg0);
8783 tree t, cst0 = NULL_TREE;
8784 int sgn0;
8785 bool swap = false;
8787 /* Match A +- CST code arg1 and CST code arg1. We can change the
8788 first form only if overflow is undefined. */
8789 if (!((TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8790 /* In principle pointers also have undefined overflow behavior,
8791 but that causes problems elsewhere. */
8792 && !POINTER_TYPE_P (TREE_TYPE (arg0))
8793 && (code0 == MINUS_EXPR
8794 || code0 == PLUS_EXPR)
8795 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8796 || code0 == INTEGER_CST))
8797 return NULL_TREE;
8799 /* Identify the constant in arg0 and its sign. */
8800 if (code0 == INTEGER_CST)
8801 cst0 = arg0;
8802 else
8803 cst0 = TREE_OPERAND (arg0, 1);
8804 sgn0 = tree_int_cst_sgn (cst0);
8806 /* Overflowed constants and zero will cause problems. */
8807 if (integer_zerop (cst0)
8808 || TREE_OVERFLOW (cst0))
8809 return NULL_TREE;
8811 /* See if we can reduce the magnitude of the constant in
8812 arg0 by changing the comparison code. */
8813 if (code0 == INTEGER_CST)
8815 /* CST <= arg1 -> CST-1 < arg1. */
8816 if (code == LE_EXPR && sgn0 == 1)
8817 code = LT_EXPR;
8818 /* -CST < arg1 -> -CST-1 <= arg1. */
8819 else if (code == LT_EXPR && sgn0 == -1)
8820 code = LE_EXPR;
8821 /* CST > arg1 -> CST-1 >= arg1. */
8822 else if (code == GT_EXPR && sgn0 == 1)
8823 code = GE_EXPR;
8824 /* -CST >= arg1 -> -CST-1 > arg1. */
8825 else if (code == GE_EXPR && sgn0 == -1)
8826 code = GT_EXPR;
8827 else
8828 return NULL_TREE;
8829 /* arg1 code' CST' might be more canonical. */
8830 swap = true;
8832 else
8834 /* A - CST < arg1 -> A - CST-1 <= arg1. */
8835 if (code == LT_EXPR
8836 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8837 code = LE_EXPR;
8838 /* A + CST > arg1 -> A + CST-1 >= arg1. */
8839 else if (code == GT_EXPR
8840 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8841 code = GE_EXPR;
8842 /* A + CST <= arg1 -> A + CST-1 < arg1. */
8843 else if (code == LE_EXPR
8844 && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8845 code = LT_EXPR;
8846 /* A - CST >= arg1 -> A - CST-1 > arg1. */
8847 else if (code == GE_EXPR
8848 && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8849 code = GT_EXPR;
8850 else
8851 return NULL_TREE;
8852 *strict_overflow_p = true;
8855 /* Now build the constant reduced in magnitude. But not if that
8856 would produce one outside of its types range. */
8857 if (INTEGRAL_TYPE_P (TREE_TYPE (cst0))
8858 && ((sgn0 == 1
8859 && TYPE_MIN_VALUE (TREE_TYPE (cst0))
8860 && tree_int_cst_equal (cst0, TYPE_MIN_VALUE (TREE_TYPE (cst0))))
8861 || (sgn0 == -1
8862 && TYPE_MAX_VALUE (TREE_TYPE (cst0))
8863 && tree_int_cst_equal (cst0, TYPE_MAX_VALUE (TREE_TYPE (cst0))))))
8864 /* We cannot swap the comparison here as that would cause us to
8865 endlessly recurse. */
8866 return NULL_TREE;
8868 t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8869 cst0, build_int_cst (TREE_TYPE (cst0), 1));
8870 if (code0 != INTEGER_CST)
8871 t = fold_build2_loc (loc, code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8872 t = fold_convert (TREE_TYPE (arg1), t);
8874 /* If swapping might yield to a more canonical form, do so. */
8875 if (swap)
8876 return fold_build2_loc (loc, swap_tree_comparison (code), type, arg1, t);
8877 else
8878 return fold_build2_loc (loc, code, type, t, arg1);
8881 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8882 overflow further. Try to decrease the magnitude of constants involved
8883 by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8884 and put sole constants at the second argument position.
8885 Returns the canonicalized tree if changed, otherwise NULL_TREE. */
8887 static tree
8888 maybe_canonicalize_comparison (location_t loc, enum tree_code code, tree type,
8889 tree arg0, tree arg1)
8891 tree t;
8892 bool strict_overflow_p;
8893 const char * const warnmsg = G_("assuming signed overflow does not occur "
8894 "when reducing constant in comparison");
8896 /* Try canonicalization by simplifying arg0. */
8897 strict_overflow_p = false;
8898 t = maybe_canonicalize_comparison_1 (loc, code, type, arg0, arg1,
8899 &strict_overflow_p);
8900 if (t)
8902 if (strict_overflow_p)
8903 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8904 return t;
8907 /* Try canonicalization by simplifying arg1 using the swapped
8908 comparison. */
8909 code = swap_tree_comparison (code);
8910 strict_overflow_p = false;
8911 t = maybe_canonicalize_comparison_1 (loc, code, type, arg1, arg0,
8912 &strict_overflow_p);
8913 if (t && strict_overflow_p)
8914 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8915 return t;
8918 /* Return whether BASE + OFFSET + BITPOS may wrap around the address
8919 space. This is used to avoid issuing overflow warnings for
8920 expressions like &p->x which can not wrap. */
8922 static bool
8923 pointer_may_wrap_p (tree base, tree offset, HOST_WIDE_INT bitpos)
8925 double_int di_offset, total;
8927 if (!POINTER_TYPE_P (TREE_TYPE (base)))
8928 return true;
8930 if (bitpos < 0)
8931 return true;
8933 if (offset == NULL_TREE)
8934 di_offset = double_int_zero;
8935 else if (TREE_CODE (offset) != INTEGER_CST || TREE_OVERFLOW (offset))
8936 return true;
8937 else
8938 di_offset = TREE_INT_CST (offset);
8940 bool overflow;
8941 double_int units = double_int::from_uhwi (bitpos / BITS_PER_UNIT);
8942 total = di_offset.add_with_sign (units, true, &overflow);
8943 if (overflow)
8944 return true;
8946 if (total.high != 0)
8947 return true;
8949 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (TREE_TYPE (base)));
8950 if (size <= 0)
8951 return true;
8953 /* We can do slightly better for SIZE if we have an ADDR_EXPR of an
8954 array. */
8955 if (TREE_CODE (base) == ADDR_EXPR)
8957 HOST_WIDE_INT base_size;
8959 base_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (base, 0)));
8960 if (base_size > 0 && size < base_size)
8961 size = base_size;
8964 return total.low > (unsigned HOST_WIDE_INT) size;
8967 /* Return the HOST_WIDE_INT least significant bits of T, a sizetype
8968 kind INTEGER_CST. This makes sure to properly sign-extend the
8969 constant. */
8971 static HOST_WIDE_INT
8972 size_low_cst (const_tree t)
8974 double_int d = tree_to_double_int (t);
8975 return d.sext (TYPE_PRECISION (TREE_TYPE (t))).low;
8978 /* Subroutine of fold_binary. This routine performs all of the
8979 transformations that are common to the equality/inequality
8980 operators (EQ_EXPR and NE_EXPR) and the ordering operators
8981 (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR). Callers other than
8982 fold_binary should call fold_binary. Fold a comparison with
8983 tree code CODE and type TYPE with operands OP0 and OP1. Return
8984 the folded comparison or NULL_TREE. */
8986 static tree
8987 fold_comparison (location_t loc, enum tree_code code, tree type,
8988 tree op0, tree op1)
8990 tree arg0, arg1, tem;
8992 arg0 = op0;
8993 arg1 = op1;
8995 STRIP_SIGN_NOPS (arg0);
8996 STRIP_SIGN_NOPS (arg1);
8998 tem = fold_relational_const (code, type, arg0, arg1);
8999 if (tem != NULL_TREE)
9000 return tem;
9002 /* If one arg is a real or integer constant, put it last. */
9003 if (tree_swap_operands_p (arg0, arg1, true))
9004 return fold_build2_loc (loc, swap_tree_comparison (code), type, op1, op0);
9006 /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1. */
9007 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9008 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9009 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9010 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
9011 && (TREE_CODE (arg1) == INTEGER_CST
9012 && !TREE_OVERFLOW (arg1)))
9014 tree const1 = TREE_OPERAND (arg0, 1);
9015 tree const2 = arg1;
9016 tree variable = TREE_OPERAND (arg0, 0);
9017 tree lhs;
9018 int lhs_add;
9019 lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
9021 lhs = fold_build2_loc (loc, lhs_add ? PLUS_EXPR : MINUS_EXPR,
9022 TREE_TYPE (arg1), const2, const1);
9024 /* If the constant operation overflowed this can be
9025 simplified as a comparison against INT_MAX/INT_MIN. */
9026 if (TREE_CODE (lhs) == INTEGER_CST
9027 && TREE_OVERFLOW (lhs))
9029 int const1_sgn = tree_int_cst_sgn (const1);
9030 enum tree_code code2 = code;
9032 /* Get the sign of the constant on the lhs if the
9033 operation were VARIABLE + CONST1. */
9034 if (TREE_CODE (arg0) == MINUS_EXPR)
9035 const1_sgn = -const1_sgn;
9037 /* The sign of the constant determines if we overflowed
9038 INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
9039 Canonicalize to the INT_MIN overflow by swapping the comparison
9040 if necessary. */
9041 if (const1_sgn == -1)
9042 code2 = swap_tree_comparison (code);
9044 /* We now can look at the canonicalized case
9045 VARIABLE + 1 CODE2 INT_MIN
9046 and decide on the result. */
9047 if (code2 == LT_EXPR
9048 || code2 == LE_EXPR
9049 || code2 == EQ_EXPR)
9050 return omit_one_operand_loc (loc, type, boolean_false_node, variable);
9051 else if (code2 == NE_EXPR
9052 || code2 == GE_EXPR
9053 || code2 == GT_EXPR)
9054 return omit_one_operand_loc (loc, type, boolean_true_node, variable);
9057 if (TREE_CODE (lhs) == TREE_CODE (arg1)
9058 && (TREE_CODE (lhs) != INTEGER_CST
9059 || !TREE_OVERFLOW (lhs)))
9061 if (code != EQ_EXPR && code != NE_EXPR)
9062 fold_overflow_warning ("assuming signed overflow does not occur "
9063 "when changing X +- C1 cmp C2 to "
9064 "X cmp C1 +- C2",
9065 WARN_STRICT_OVERFLOW_COMPARISON);
9066 return fold_build2_loc (loc, code, type, variable, lhs);
9070 /* For comparisons of pointers we can decompose it to a compile time
9071 comparison of the base objects and the offsets into the object.
9072 This requires at least one operand being an ADDR_EXPR or a
9073 POINTER_PLUS_EXPR to do more than the operand_equal_p test below. */
9074 if (POINTER_TYPE_P (TREE_TYPE (arg0))
9075 && (TREE_CODE (arg0) == ADDR_EXPR
9076 || TREE_CODE (arg1) == ADDR_EXPR
9077 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
9078 || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
9080 tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
9081 HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
9082 enum machine_mode mode;
9083 int volatilep, unsignedp;
9084 bool indirect_base0 = false, indirect_base1 = false;
9086 /* Get base and offset for the access. Strip ADDR_EXPR for
9087 get_inner_reference, but put it back by stripping INDIRECT_REF
9088 off the base object if possible. indirect_baseN will be true
9089 if baseN is not an address but refers to the object itself. */
9090 base0 = arg0;
9091 if (TREE_CODE (arg0) == ADDR_EXPR)
9093 base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
9094 &bitsize, &bitpos0, &offset0, &mode,
9095 &unsignedp, &volatilep, false);
9096 if (TREE_CODE (base0) == INDIRECT_REF)
9097 base0 = TREE_OPERAND (base0, 0);
9098 else
9099 indirect_base0 = true;
9101 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9103 base0 = TREE_OPERAND (arg0, 0);
9104 STRIP_SIGN_NOPS (base0);
9105 if (TREE_CODE (base0) == ADDR_EXPR)
9107 base0 = TREE_OPERAND (base0, 0);
9108 indirect_base0 = true;
9110 offset0 = TREE_OPERAND (arg0, 1);
9111 if (tree_fits_shwi_p (offset0))
9113 HOST_WIDE_INT off = size_low_cst (offset0);
9114 if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
9115 * BITS_PER_UNIT)
9116 / BITS_PER_UNIT == (HOST_WIDE_INT) off)
9118 bitpos0 = off * BITS_PER_UNIT;
9119 offset0 = NULL_TREE;
9124 base1 = arg1;
9125 if (TREE_CODE (arg1) == ADDR_EXPR)
9127 base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
9128 &bitsize, &bitpos1, &offset1, &mode,
9129 &unsignedp, &volatilep, false);
9130 if (TREE_CODE (base1) == INDIRECT_REF)
9131 base1 = TREE_OPERAND (base1, 0);
9132 else
9133 indirect_base1 = true;
9135 else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
9137 base1 = TREE_OPERAND (arg1, 0);
9138 STRIP_SIGN_NOPS (base1);
9139 if (TREE_CODE (base1) == ADDR_EXPR)
9141 base1 = TREE_OPERAND (base1, 0);
9142 indirect_base1 = true;
9144 offset1 = TREE_OPERAND (arg1, 1);
9145 if (tree_fits_shwi_p (offset1))
9147 HOST_WIDE_INT off = size_low_cst (offset1);
9148 if ((HOST_WIDE_INT) (((unsigned HOST_WIDE_INT) off)
9149 * BITS_PER_UNIT)
9150 / BITS_PER_UNIT == (HOST_WIDE_INT) off)
9152 bitpos1 = off * BITS_PER_UNIT;
9153 offset1 = NULL_TREE;
9158 /* A local variable can never be pointed to by
9159 the default SSA name of an incoming parameter. */
9160 if ((TREE_CODE (arg0) == ADDR_EXPR
9161 && indirect_base0
9162 && TREE_CODE (base0) == VAR_DECL
9163 && auto_var_in_fn_p (base0, current_function_decl)
9164 && !indirect_base1
9165 && TREE_CODE (base1) == SSA_NAME
9166 && SSA_NAME_IS_DEFAULT_DEF (base1)
9167 && TREE_CODE (SSA_NAME_VAR (base1)) == PARM_DECL)
9168 || (TREE_CODE (arg1) == ADDR_EXPR
9169 && indirect_base1
9170 && TREE_CODE (base1) == VAR_DECL
9171 && auto_var_in_fn_p (base1, current_function_decl)
9172 && !indirect_base0
9173 && TREE_CODE (base0) == SSA_NAME
9174 && SSA_NAME_IS_DEFAULT_DEF (base0)
9175 && TREE_CODE (SSA_NAME_VAR (base0)) == PARM_DECL))
9177 if (code == NE_EXPR)
9178 return constant_boolean_node (1, type);
9179 else if (code == EQ_EXPR)
9180 return constant_boolean_node (0, type);
9182 /* If we have equivalent bases we might be able to simplify. */
9183 else if (indirect_base0 == indirect_base1
9184 && operand_equal_p (base0, base1, 0))
9186 /* We can fold this expression to a constant if the non-constant
9187 offset parts are equal. */
9188 if ((offset0 == offset1
9189 || (offset0 && offset1
9190 && operand_equal_p (offset0, offset1, 0)))
9191 && (code == EQ_EXPR
9192 || code == NE_EXPR
9193 || (indirect_base0 && DECL_P (base0))
9194 || POINTER_TYPE_OVERFLOW_UNDEFINED))
9197 if (code != EQ_EXPR
9198 && code != NE_EXPR
9199 && bitpos0 != bitpos1
9200 && (pointer_may_wrap_p (base0, offset0, bitpos0)
9201 || pointer_may_wrap_p (base1, offset1, bitpos1)))
9202 fold_overflow_warning (("assuming pointer wraparound does not "
9203 "occur when comparing P +- C1 with "
9204 "P +- C2"),
9205 WARN_STRICT_OVERFLOW_CONDITIONAL);
9207 switch (code)
9209 case EQ_EXPR:
9210 return constant_boolean_node (bitpos0 == bitpos1, type);
9211 case NE_EXPR:
9212 return constant_boolean_node (bitpos0 != bitpos1, type);
9213 case LT_EXPR:
9214 return constant_boolean_node (bitpos0 < bitpos1, type);
9215 case LE_EXPR:
9216 return constant_boolean_node (bitpos0 <= bitpos1, type);
9217 case GE_EXPR:
9218 return constant_boolean_node (bitpos0 >= bitpos1, type);
9219 case GT_EXPR:
9220 return constant_boolean_node (bitpos0 > bitpos1, type);
9221 default:;
9224 /* We can simplify the comparison to a comparison of the variable
9225 offset parts if the constant offset parts are equal.
9226 Be careful to use signed sizetype here because otherwise we
9227 mess with array offsets in the wrong way. This is possible
9228 because pointer arithmetic is restricted to retain within an
9229 object and overflow on pointer differences is undefined as of
9230 6.5.6/8 and /9 with respect to the signed ptrdiff_t. */
9231 else if (bitpos0 == bitpos1
9232 && ((code == EQ_EXPR || code == NE_EXPR)
9233 || (indirect_base0 && DECL_P (base0))
9234 || POINTER_TYPE_OVERFLOW_UNDEFINED))
9236 /* By converting to signed sizetype we cover middle-end pointer
9237 arithmetic which operates on unsigned pointer types of size
9238 type size and ARRAY_REF offsets which are properly sign or
9239 zero extended from their type in case it is narrower than
9240 sizetype. */
9241 if (offset0 == NULL_TREE)
9242 offset0 = build_int_cst (ssizetype, 0);
9243 else
9244 offset0 = fold_convert_loc (loc, ssizetype, offset0);
9245 if (offset1 == NULL_TREE)
9246 offset1 = build_int_cst (ssizetype, 0);
9247 else
9248 offset1 = fold_convert_loc (loc, ssizetype, offset1);
9250 if (code != EQ_EXPR
9251 && code != NE_EXPR
9252 && (pointer_may_wrap_p (base0, offset0, bitpos0)
9253 || pointer_may_wrap_p (base1, offset1, bitpos1)))
9254 fold_overflow_warning (("assuming pointer wraparound does not "
9255 "occur when comparing P +- C1 with "
9256 "P +- C2"),
9257 WARN_STRICT_OVERFLOW_COMPARISON);
9259 return fold_build2_loc (loc, code, type, offset0, offset1);
9262 /* For non-equal bases we can simplify if they are addresses
9263 of local binding decls or constants. */
9264 else if (indirect_base0 && indirect_base1
9265 /* We know that !operand_equal_p (base0, base1, 0)
9266 because the if condition was false. But make
9267 sure two decls are not the same. */
9268 && base0 != base1
9269 && TREE_CODE (arg0) == ADDR_EXPR
9270 && TREE_CODE (arg1) == ADDR_EXPR
9271 && (((TREE_CODE (base0) == VAR_DECL
9272 || TREE_CODE (base0) == PARM_DECL)
9273 && (targetm.binds_local_p (base0)
9274 || CONSTANT_CLASS_P (base1)))
9275 || CONSTANT_CLASS_P (base0))
9276 && (((TREE_CODE (base1) == VAR_DECL
9277 || TREE_CODE (base1) == PARM_DECL)
9278 && (targetm.binds_local_p (base1)
9279 || CONSTANT_CLASS_P (base0)))
9280 || CONSTANT_CLASS_P (base1)))
9282 if (code == EQ_EXPR)
9283 return omit_two_operands_loc (loc, type, boolean_false_node,
9284 arg0, arg1);
9285 else if (code == NE_EXPR)
9286 return omit_two_operands_loc (loc, type, boolean_true_node,
9287 arg0, arg1);
9289 /* For equal offsets we can simplify to a comparison of the
9290 base addresses. */
9291 else if (bitpos0 == bitpos1
9292 && (indirect_base0
9293 ? base0 != TREE_OPERAND (arg0, 0) : base0 != arg0)
9294 && (indirect_base1
9295 ? base1 != TREE_OPERAND (arg1, 0) : base1 != arg1)
9296 && ((offset0 == offset1)
9297 || (offset0 && offset1
9298 && operand_equal_p (offset0, offset1, 0))))
9300 if (indirect_base0)
9301 base0 = build_fold_addr_expr_loc (loc, base0);
9302 if (indirect_base1)
9303 base1 = build_fold_addr_expr_loc (loc, base1);
9304 return fold_build2_loc (loc, code, type, base0, base1);
9308 /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
9309 X CMP Y +- C2 +- C1 for signed X, Y. This is valid if
9310 the resulting offset is smaller in absolute value than the
9311 original one. */
9312 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9313 && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9314 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9315 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9316 && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
9317 && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9318 && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
9320 tree const1 = TREE_OPERAND (arg0, 1);
9321 tree const2 = TREE_OPERAND (arg1, 1);
9322 tree variable1 = TREE_OPERAND (arg0, 0);
9323 tree variable2 = TREE_OPERAND (arg1, 0);
9324 tree cst;
9325 const char * const warnmsg = G_("assuming signed overflow does not "
9326 "occur when combining constants around "
9327 "a comparison");
9329 /* Put the constant on the side where it doesn't overflow and is
9330 of lower absolute value than before. */
9331 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9332 ? MINUS_EXPR : PLUS_EXPR,
9333 const2, const1);
9334 if (!TREE_OVERFLOW (cst)
9335 && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2))
9337 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9338 return fold_build2_loc (loc, code, type,
9339 variable1,
9340 fold_build2_loc (loc,
9341 TREE_CODE (arg1), TREE_TYPE (arg1),
9342 variable2, cst));
9345 cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
9346 ? MINUS_EXPR : PLUS_EXPR,
9347 const1, const2);
9348 if (!TREE_OVERFLOW (cst)
9349 && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1))
9351 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
9352 return fold_build2_loc (loc, code, type,
9353 fold_build2_loc (loc, TREE_CODE (arg0), TREE_TYPE (arg0),
9354 variable1, cst),
9355 variable2);
9359 /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
9360 signed arithmetic case. That form is created by the compiler
9361 often enough for folding it to be of value. One example is in
9362 computing loop trip counts after Operator Strength Reduction. */
9363 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
9364 && TREE_CODE (arg0) == MULT_EXPR
9365 && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9366 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
9367 && integer_zerop (arg1))
9369 tree const1 = TREE_OPERAND (arg0, 1);
9370 tree const2 = arg1; /* zero */
9371 tree variable1 = TREE_OPERAND (arg0, 0);
9372 enum tree_code cmp_code = code;
9374 /* Handle unfolded multiplication by zero. */
9375 if (integer_zerop (const1))
9376 return fold_build2_loc (loc, cmp_code, type, const1, const2);
9378 fold_overflow_warning (("assuming signed overflow does not occur when "
9379 "eliminating multiplication in comparison "
9380 "with zero"),
9381 WARN_STRICT_OVERFLOW_COMPARISON);
9383 /* If const1 is negative we swap the sense of the comparison. */
9384 if (tree_int_cst_sgn (const1) < 0)
9385 cmp_code = swap_tree_comparison (cmp_code);
9387 return fold_build2_loc (loc, cmp_code, type, variable1, const2);
9390 tem = maybe_canonicalize_comparison (loc, code, type, arg0, arg1);
9391 if (tem)
9392 return tem;
9394 if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
9396 tree targ0 = strip_float_extensions (arg0);
9397 tree targ1 = strip_float_extensions (arg1);
9398 tree newtype = TREE_TYPE (targ0);
9400 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
9401 newtype = TREE_TYPE (targ1);
9403 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
9404 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
9405 return fold_build2_loc (loc, code, type,
9406 fold_convert_loc (loc, newtype, targ0),
9407 fold_convert_loc (loc, newtype, targ1));
9409 /* (-a) CMP (-b) -> b CMP a */
9410 if (TREE_CODE (arg0) == NEGATE_EXPR
9411 && TREE_CODE (arg1) == NEGATE_EXPR)
9412 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg1, 0),
9413 TREE_OPERAND (arg0, 0));
9415 if (TREE_CODE (arg1) == REAL_CST)
9417 REAL_VALUE_TYPE cst;
9418 cst = TREE_REAL_CST (arg1);
9420 /* (-a) CMP CST -> a swap(CMP) (-CST) */
9421 if (TREE_CODE (arg0) == NEGATE_EXPR)
9422 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9423 TREE_OPERAND (arg0, 0),
9424 build_real (TREE_TYPE (arg1),
9425 real_value_negate (&cst)));
9427 /* IEEE doesn't distinguish +0 and -0 in comparisons. */
9428 /* a CMP (-0) -> a CMP 0 */
9429 if (REAL_VALUE_MINUS_ZERO (cst))
9430 return fold_build2_loc (loc, code, type, arg0,
9431 build_real (TREE_TYPE (arg1), dconst0));
9433 /* x != NaN is always true, other ops are always false. */
9434 if (REAL_VALUE_ISNAN (cst)
9435 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
9437 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
9438 return omit_one_operand_loc (loc, type, tem, arg0);
9441 /* Fold comparisons against infinity. */
9442 if (REAL_VALUE_ISINF (cst)
9443 && MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1))))
9445 tem = fold_inf_compare (loc, code, type, arg0, arg1);
9446 if (tem != NULL_TREE)
9447 return tem;
9451 /* If this is a comparison of a real constant with a PLUS_EXPR
9452 or a MINUS_EXPR of a real constant, we can convert it into a
9453 comparison with a revised real constant as long as no overflow
9454 occurs when unsafe_math_optimizations are enabled. */
9455 if (flag_unsafe_math_optimizations
9456 && TREE_CODE (arg1) == REAL_CST
9457 && (TREE_CODE (arg0) == PLUS_EXPR
9458 || TREE_CODE (arg0) == MINUS_EXPR)
9459 && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
9460 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9461 ? MINUS_EXPR : PLUS_EXPR,
9462 arg1, TREE_OPERAND (arg0, 1)))
9463 && !TREE_OVERFLOW (tem))
9464 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
9466 /* Likewise, we can simplify a comparison of a real constant with
9467 a MINUS_EXPR whose first operand is also a real constant, i.e.
9468 (c1 - x) < c2 becomes x > c1-c2. Reordering is allowed on
9469 floating-point types only if -fassociative-math is set. */
9470 if (flag_associative_math
9471 && TREE_CODE (arg1) == REAL_CST
9472 && TREE_CODE (arg0) == MINUS_EXPR
9473 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
9474 && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
9475 arg1))
9476 && !TREE_OVERFLOW (tem))
9477 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9478 TREE_OPERAND (arg0, 1), tem);
9480 /* Fold comparisons against built-in math functions. */
9481 if (TREE_CODE (arg1) == REAL_CST
9482 && flag_unsafe_math_optimizations
9483 && ! flag_errno_math)
9485 enum built_in_function fcode = builtin_mathfn_code (arg0);
9487 if (fcode != END_BUILTINS)
9489 tem = fold_mathfn_compare (loc, fcode, code, type, arg0, arg1);
9490 if (tem != NULL_TREE)
9491 return tem;
9496 if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
9497 && CONVERT_EXPR_P (arg0))
9499 /* If we are widening one operand of an integer comparison,
9500 see if the other operand is similarly being widened. Perhaps we
9501 can do the comparison in the narrower type. */
9502 tem = fold_widened_comparison (loc, code, type, arg0, arg1);
9503 if (tem)
9504 return tem;
9506 /* Or if we are changing signedness. */
9507 tem = fold_sign_changed_comparison (loc, code, type, arg0, arg1);
9508 if (tem)
9509 return tem;
9512 /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9513 constant, we can simplify it. */
9514 if (TREE_CODE (arg1) == INTEGER_CST
9515 && (TREE_CODE (arg0) == MIN_EXPR
9516 || TREE_CODE (arg0) == MAX_EXPR)
9517 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9519 tem = optimize_minmax_comparison (loc, code, type, op0, op1);
9520 if (tem)
9521 return tem;
9524 /* Simplify comparison of something with itself. (For IEEE
9525 floating-point, we can only do some of these simplifications.) */
9526 if (operand_equal_p (arg0, arg1, 0))
9528 switch (code)
9530 case EQ_EXPR:
9531 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9532 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9533 return constant_boolean_node (1, type);
9534 break;
9536 case GE_EXPR:
9537 case LE_EXPR:
9538 if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9539 || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9540 return constant_boolean_node (1, type);
9541 return fold_build2_loc (loc, EQ_EXPR, type, arg0, arg1);
9543 case NE_EXPR:
9544 /* For NE, we can only do this simplification if integer
9545 or we don't honor IEEE floating point NaNs. */
9546 if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9547 && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9548 break;
9549 /* ... fall through ... */
9550 case GT_EXPR:
9551 case LT_EXPR:
9552 return constant_boolean_node (0, type);
9553 default:
9554 gcc_unreachable ();
9558 /* If we are comparing an expression that just has comparisons
9559 of two integer values, arithmetic expressions of those comparisons,
9560 and constants, we can simplify it. There are only three cases
9561 to check: the two values can either be equal, the first can be
9562 greater, or the second can be greater. Fold the expression for
9563 those three values. Since each value must be 0 or 1, we have
9564 eight possibilities, each of which corresponds to the constant 0
9565 or 1 or one of the six possible comparisons.
9567 This handles common cases like (a > b) == 0 but also handles
9568 expressions like ((x > y) - (y > x)) > 0, which supposedly
9569 occur in macroized code. */
9571 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9573 tree cval1 = 0, cval2 = 0;
9574 int save_p = 0;
9576 if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9577 /* Don't handle degenerate cases here; they should already
9578 have been handled anyway. */
9579 && cval1 != 0 && cval2 != 0
9580 && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9581 && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9582 && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9583 && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9584 && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9585 && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9586 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9588 tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9589 tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9591 /* We can't just pass T to eval_subst in case cval1 or cval2
9592 was the same as ARG1. */
9594 tree high_result
9595 = fold_build2_loc (loc, code, type,
9596 eval_subst (loc, arg0, cval1, maxval,
9597 cval2, minval),
9598 arg1);
9599 tree equal_result
9600 = fold_build2_loc (loc, code, type,
9601 eval_subst (loc, arg0, cval1, maxval,
9602 cval2, maxval),
9603 arg1);
9604 tree low_result
9605 = fold_build2_loc (loc, code, type,
9606 eval_subst (loc, arg0, cval1, minval,
9607 cval2, maxval),
9608 arg1);
9610 /* All three of these results should be 0 or 1. Confirm they are.
9611 Then use those values to select the proper code to use. */
9613 if (TREE_CODE (high_result) == INTEGER_CST
9614 && TREE_CODE (equal_result) == INTEGER_CST
9615 && TREE_CODE (low_result) == INTEGER_CST)
9617 /* Make a 3-bit mask with the high-order bit being the
9618 value for `>', the next for '=', and the low for '<'. */
9619 switch ((integer_onep (high_result) * 4)
9620 + (integer_onep (equal_result) * 2)
9621 + integer_onep (low_result))
9623 case 0:
9624 /* Always false. */
9625 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
9626 case 1:
9627 code = LT_EXPR;
9628 break;
9629 case 2:
9630 code = EQ_EXPR;
9631 break;
9632 case 3:
9633 code = LE_EXPR;
9634 break;
9635 case 4:
9636 code = GT_EXPR;
9637 break;
9638 case 5:
9639 code = NE_EXPR;
9640 break;
9641 case 6:
9642 code = GE_EXPR;
9643 break;
9644 case 7:
9645 /* Always true. */
9646 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
9649 if (save_p)
9651 tem = save_expr (build2 (code, type, cval1, cval2));
9652 SET_EXPR_LOCATION (tem, loc);
9653 return tem;
9655 return fold_build2_loc (loc, code, type, cval1, cval2);
9660 /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9661 into a single range test. */
9662 if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9663 || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9664 && TREE_CODE (arg1) == INTEGER_CST
9665 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9666 && !integer_zerop (TREE_OPERAND (arg0, 1))
9667 && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9668 && !TREE_OVERFLOW (arg1))
9670 tem = fold_div_compare (loc, code, type, arg0, arg1);
9671 if (tem != NULL_TREE)
9672 return tem;
9675 /* Fold ~X op ~Y as Y op X. */
9676 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9677 && TREE_CODE (arg1) == BIT_NOT_EXPR)
9679 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9680 return fold_build2_loc (loc, code, type,
9681 fold_convert_loc (loc, cmp_type,
9682 TREE_OPERAND (arg1, 0)),
9683 TREE_OPERAND (arg0, 0));
9686 /* Fold ~X op C as X op' ~C, where op' is the swapped comparison. */
9687 if (TREE_CODE (arg0) == BIT_NOT_EXPR
9688 && (TREE_CODE (arg1) == INTEGER_CST || TREE_CODE (arg1) == VECTOR_CST))
9690 tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9691 return fold_build2_loc (loc, swap_tree_comparison (code), type,
9692 TREE_OPERAND (arg0, 0),
9693 fold_build1_loc (loc, BIT_NOT_EXPR, cmp_type,
9694 fold_convert_loc (loc, cmp_type, arg1)));
9697 return NULL_TREE;
9701 /* Subroutine of fold_binary. Optimize complex multiplications of the
9702 form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2). The
9703 argument EXPR represents the expression "z" of type TYPE. */
9705 static tree
9706 fold_mult_zconjz (location_t loc, tree type, tree expr)
9708 tree itype = TREE_TYPE (type);
9709 tree rpart, ipart, tem;
9711 if (TREE_CODE (expr) == COMPLEX_EXPR)
9713 rpart = TREE_OPERAND (expr, 0);
9714 ipart = TREE_OPERAND (expr, 1);
9716 else if (TREE_CODE (expr) == COMPLEX_CST)
9718 rpart = TREE_REALPART (expr);
9719 ipart = TREE_IMAGPART (expr);
9721 else
9723 expr = save_expr (expr);
9724 rpart = fold_build1_loc (loc, REALPART_EXPR, itype, expr);
9725 ipart = fold_build1_loc (loc, IMAGPART_EXPR, itype, expr);
9728 rpart = save_expr (rpart);
9729 ipart = save_expr (ipart);
9730 tem = fold_build2_loc (loc, PLUS_EXPR, itype,
9731 fold_build2_loc (loc, MULT_EXPR, itype, rpart, rpart),
9732 fold_build2_loc (loc, MULT_EXPR, itype, ipart, ipart));
9733 return fold_build2_loc (loc, COMPLEX_EXPR, type, tem,
9734 build_zero_cst (itype));
9738 /* Subroutine of fold_binary. If P is the value of EXPR, computes
9739 power-of-two M and (arbitrary) N such that M divides (P-N). This condition
9740 guarantees that P and N have the same least significant log2(M) bits.
9741 N is not otherwise constrained. In particular, N is not normalized to
9742 0 <= N < M as is common. In general, the precise value of P is unknown.
9743 M is chosen as large as possible such that constant N can be determined.
9745 Returns M and sets *RESIDUE to N.
9747 If ALLOW_FUNC_ALIGN is true, do take functions' DECL_ALIGN_UNIT into
9748 account. This is not always possible due to PR 35705.
9751 static unsigned HOST_WIDE_INT
9752 get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue,
9753 bool allow_func_align)
9755 enum tree_code code;
9757 *residue = 0;
9759 code = TREE_CODE (expr);
9760 if (code == ADDR_EXPR)
9762 unsigned int bitalign;
9763 get_object_alignment_1 (TREE_OPERAND (expr, 0), &bitalign, residue);
9764 *residue /= BITS_PER_UNIT;
9765 return bitalign / BITS_PER_UNIT;
9767 else if (code == POINTER_PLUS_EXPR)
9769 tree op0, op1;
9770 unsigned HOST_WIDE_INT modulus;
9771 enum tree_code inner_code;
9773 op0 = TREE_OPERAND (expr, 0);
9774 STRIP_NOPS (op0);
9775 modulus = get_pointer_modulus_and_residue (op0, residue,
9776 allow_func_align);
9778 op1 = TREE_OPERAND (expr, 1);
9779 STRIP_NOPS (op1);
9780 inner_code = TREE_CODE (op1);
9781 if (inner_code == INTEGER_CST)
9783 *residue += TREE_INT_CST_LOW (op1);
9784 return modulus;
9786 else if (inner_code == MULT_EXPR)
9788 op1 = TREE_OPERAND (op1, 1);
9789 if (TREE_CODE (op1) == INTEGER_CST)
9791 unsigned HOST_WIDE_INT align;
9793 /* Compute the greatest power-of-2 divisor of op1. */
9794 align = TREE_INT_CST_LOW (op1);
9795 align &= -align;
9797 /* If align is non-zero and less than *modulus, replace
9798 *modulus with align., If align is 0, then either op1 is 0
9799 or the greatest power-of-2 divisor of op1 doesn't fit in an
9800 unsigned HOST_WIDE_INT. In either case, no additional
9801 constraint is imposed. */
9802 if (align)
9803 modulus = MIN (modulus, align);
9805 return modulus;
9810 /* If we get here, we were unable to determine anything useful about the
9811 expression. */
9812 return 1;
9815 /* Helper function for fold_vec_perm. Store elements of VECTOR_CST or
9816 CONSTRUCTOR ARG into array ELTS and return true if successful. */
9818 static bool
9819 vec_cst_ctor_to_array (tree arg, tree *elts)
9821 unsigned int nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg)), i;
9823 if (TREE_CODE (arg) == VECTOR_CST)
9825 for (i = 0; i < VECTOR_CST_NELTS (arg); ++i)
9826 elts[i] = VECTOR_CST_ELT (arg, i);
9828 else if (TREE_CODE (arg) == CONSTRUCTOR)
9830 constructor_elt *elt;
9832 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (arg), i, elt)
9833 if (i >= nelts || TREE_CODE (TREE_TYPE (elt->value)) == VECTOR_TYPE)
9834 return false;
9835 else
9836 elts[i] = elt->value;
9838 else
9839 return false;
9840 for (; i < nelts; i++)
9841 elts[i]
9842 = fold_convert (TREE_TYPE (TREE_TYPE (arg)), integer_zero_node);
9843 return true;
9846 /* Attempt to fold vector permutation of ARG0 and ARG1 vectors using SEL
9847 selector. Return the folded VECTOR_CST or CONSTRUCTOR if successful,
9848 NULL_TREE otherwise. */
9850 static tree
9851 fold_vec_perm (tree type, tree arg0, tree arg1, const unsigned char *sel)
9853 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
9854 tree *elts;
9855 bool need_ctor = false;
9857 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts
9858 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts);
9859 if (TREE_TYPE (TREE_TYPE (arg0)) != TREE_TYPE (type)
9860 || TREE_TYPE (TREE_TYPE (arg1)) != TREE_TYPE (type))
9861 return NULL_TREE;
9863 elts = XALLOCAVEC (tree, nelts * 3);
9864 if (!vec_cst_ctor_to_array (arg0, elts)
9865 || !vec_cst_ctor_to_array (arg1, elts + nelts))
9866 return NULL_TREE;
9868 for (i = 0; i < nelts; i++)
9870 if (!CONSTANT_CLASS_P (elts[sel[i]]))
9871 need_ctor = true;
9872 elts[i + 2 * nelts] = unshare_expr (elts[sel[i]]);
9875 if (need_ctor)
9877 vec<constructor_elt, va_gc> *v;
9878 vec_alloc (v, nelts);
9879 for (i = 0; i < nelts; i++)
9880 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[2 * nelts + i]);
9881 return build_constructor (type, v);
9883 else
9884 return build_vector (type, &elts[2 * nelts]);
9887 /* Try to fold a pointer difference of type TYPE two address expressions of
9888 array references AREF0 and AREF1 using location LOC. Return a
9889 simplified expression for the difference or NULL_TREE. */
9891 static tree
9892 fold_addr_of_array_ref_difference (location_t loc, tree type,
9893 tree aref0, tree aref1)
9895 tree base0 = TREE_OPERAND (aref0, 0);
9896 tree base1 = TREE_OPERAND (aref1, 0);
9897 tree base_offset = build_int_cst (type, 0);
9899 /* If the bases are array references as well, recurse. If the bases
9900 are pointer indirections compute the difference of the pointers.
9901 If the bases are equal, we are set. */
9902 if ((TREE_CODE (base0) == ARRAY_REF
9903 && TREE_CODE (base1) == ARRAY_REF
9904 && (base_offset
9905 = fold_addr_of_array_ref_difference (loc, type, base0, base1)))
9906 || (INDIRECT_REF_P (base0)
9907 && INDIRECT_REF_P (base1)
9908 && (base_offset = fold_binary_loc (loc, MINUS_EXPR, type,
9909 TREE_OPERAND (base0, 0),
9910 TREE_OPERAND (base1, 0))))
9911 || operand_equal_p (base0, base1, 0))
9913 tree op0 = fold_convert_loc (loc, type, TREE_OPERAND (aref0, 1));
9914 tree op1 = fold_convert_loc (loc, type, TREE_OPERAND (aref1, 1));
9915 tree esz = fold_convert_loc (loc, type, array_ref_element_size (aref0));
9916 tree diff = build2 (MINUS_EXPR, type, op0, op1);
9917 return fold_build2_loc (loc, PLUS_EXPR, type,
9918 base_offset,
9919 fold_build2_loc (loc, MULT_EXPR, type,
9920 diff, esz));
9922 return NULL_TREE;
9925 /* If the real or vector real constant CST of type TYPE has an exact
9926 inverse, return it, else return NULL. */
9928 static tree
9929 exact_inverse (tree type, tree cst)
9931 REAL_VALUE_TYPE r;
9932 tree unit_type, *elts;
9933 enum machine_mode mode;
9934 unsigned vec_nelts, i;
9936 switch (TREE_CODE (cst))
9938 case REAL_CST:
9939 r = TREE_REAL_CST (cst);
9941 if (exact_real_inverse (TYPE_MODE (type), &r))
9942 return build_real (type, r);
9944 return NULL_TREE;
9946 case VECTOR_CST:
9947 vec_nelts = VECTOR_CST_NELTS (cst);
9948 elts = XALLOCAVEC (tree, vec_nelts);
9949 unit_type = TREE_TYPE (type);
9950 mode = TYPE_MODE (unit_type);
9952 for (i = 0; i < vec_nelts; i++)
9954 r = TREE_REAL_CST (VECTOR_CST_ELT (cst, i));
9955 if (!exact_real_inverse (mode, &r))
9956 return NULL_TREE;
9957 elts[i] = build_real (unit_type, r);
9960 return build_vector (type, elts);
9962 default:
9963 return NULL_TREE;
9967 /* Mask out the tz least significant bits of X of type TYPE where
9968 tz is the number of trailing zeroes in Y. */
9969 static double_int
9970 mask_with_tz (tree type, double_int x, double_int y)
9972 int tz = y.trailing_zeros ();
9974 if (tz > 0)
9976 double_int mask;
9978 mask = ~double_int::mask (tz);
9979 mask = mask.ext (TYPE_PRECISION (type), TYPE_UNSIGNED (type));
9980 return mask & x;
9982 return x;
9985 /* Return true when T is an address and is known to be nonzero.
9986 For floating point we further ensure that T is not denormal.
9987 Similar logic is present in nonzero_address in rtlanal.h.
9989 If the return value is based on the assumption that signed overflow
9990 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
9991 change *STRICT_OVERFLOW_P. */
9993 static bool
9994 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
9996 tree type = TREE_TYPE (t);
9997 enum tree_code code;
9999 /* Doing something useful for floating point would need more work. */
10000 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
10001 return false;
10003 code = TREE_CODE (t);
10004 switch (TREE_CODE_CLASS (code))
10006 case tcc_unary:
10007 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
10008 strict_overflow_p);
10009 case tcc_binary:
10010 case tcc_comparison:
10011 return tree_binary_nonzero_warnv_p (code, type,
10012 TREE_OPERAND (t, 0),
10013 TREE_OPERAND (t, 1),
10014 strict_overflow_p);
10015 case tcc_constant:
10016 case tcc_declaration:
10017 case tcc_reference:
10018 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
10020 default:
10021 break;
10024 switch (code)
10026 case TRUTH_NOT_EXPR:
10027 return tree_unary_nonzero_warnv_p (code, type, TREE_OPERAND (t, 0),
10028 strict_overflow_p);
10030 case TRUTH_AND_EXPR:
10031 case TRUTH_OR_EXPR:
10032 case TRUTH_XOR_EXPR:
10033 return tree_binary_nonzero_warnv_p (code, type,
10034 TREE_OPERAND (t, 0),
10035 TREE_OPERAND (t, 1),
10036 strict_overflow_p);
10038 case COND_EXPR:
10039 case CONSTRUCTOR:
10040 case OBJ_TYPE_REF:
10041 case ASSERT_EXPR:
10042 case ADDR_EXPR:
10043 case WITH_SIZE_EXPR:
10044 case SSA_NAME:
10045 return tree_single_nonzero_warnv_p (t, strict_overflow_p);
10047 case COMPOUND_EXPR:
10048 case MODIFY_EXPR:
10049 case BIND_EXPR:
10050 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
10051 strict_overflow_p);
10053 case SAVE_EXPR:
10054 return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
10055 strict_overflow_p);
10057 case CALL_EXPR:
10059 tree fndecl = get_callee_fndecl (t);
10060 if (!fndecl) return false;
10061 if (flag_delete_null_pointer_checks && !flag_check_new
10062 && DECL_IS_OPERATOR_NEW (fndecl)
10063 && !TREE_NOTHROW (fndecl))
10064 return true;
10065 if (flag_delete_null_pointer_checks
10066 && lookup_attribute ("returns_nonnull",
10067 TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
10068 return true;
10069 return alloca_call_p (t);
10072 default:
10073 break;
10075 return false;
10078 /* Return true when T is an address and is known to be nonzero.
10079 Handle warnings about undefined signed overflow. */
10081 static bool
10082 tree_expr_nonzero_p (tree t)
10084 bool ret, strict_overflow_p;
10086 strict_overflow_p = false;
10087 ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
10088 if (strict_overflow_p)
10089 fold_overflow_warning (("assuming signed overflow does not occur when "
10090 "determining that expression is always "
10091 "non-zero"),
10092 WARN_STRICT_OVERFLOW_MISC);
10093 return ret;
10096 /* Fold a binary expression of code CODE and type TYPE with operands
10097 OP0 and OP1. LOC is the location of the resulting expression.
10098 Return the folded expression if folding is successful. Otherwise,
10099 return NULL_TREE. */
10101 tree
10102 fold_binary_loc (location_t loc,
10103 enum tree_code code, tree type, tree op0, tree op1)
10105 enum tree_code_class kind = TREE_CODE_CLASS (code);
10106 tree arg0, arg1, tem;
10107 tree t1 = NULL_TREE;
10108 bool strict_overflow_p;
10109 unsigned int prec;
10111 gcc_assert (IS_EXPR_CODE_CLASS (kind)
10112 && TREE_CODE_LENGTH (code) == 2
10113 && op0 != NULL_TREE
10114 && op1 != NULL_TREE);
10116 arg0 = op0;
10117 arg1 = op1;
10119 /* Strip any conversions that don't change the mode. This is
10120 safe for every expression, except for a comparison expression
10121 because its signedness is derived from its operands. So, in
10122 the latter case, only strip conversions that don't change the
10123 signedness. MIN_EXPR/MAX_EXPR also need signedness of arguments
10124 preserved.
10126 Note that this is done as an internal manipulation within the
10127 constant folder, in order to find the simplest representation
10128 of the arguments so that their form can be studied. In any
10129 cases, the appropriate type conversions should be put back in
10130 the tree that will get out of the constant folder. */
10132 if (kind == tcc_comparison || code == MIN_EXPR || code == MAX_EXPR)
10134 STRIP_SIGN_NOPS (arg0);
10135 STRIP_SIGN_NOPS (arg1);
10137 else
10139 STRIP_NOPS (arg0);
10140 STRIP_NOPS (arg1);
10143 /* Note that TREE_CONSTANT isn't enough: static var addresses are
10144 constant but we can't do arithmetic on them. */
10145 if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
10146 || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
10147 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == FIXED_CST)
10148 || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == INTEGER_CST)
10149 || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
10150 || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST)
10151 || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == INTEGER_CST))
10153 if (kind == tcc_binary)
10155 /* Make sure type and arg0 have the same saturating flag. */
10156 gcc_assert (TYPE_SATURATING (type)
10157 == TYPE_SATURATING (TREE_TYPE (arg0)));
10158 tem = const_binop (code, arg0, arg1);
10160 else if (kind == tcc_comparison)
10161 tem = fold_relational_const (code, type, arg0, arg1);
10162 else
10163 tem = NULL_TREE;
10165 if (tem != NULL_TREE)
10167 if (TREE_TYPE (tem) != type)
10168 tem = fold_convert_loc (loc, type, tem);
10169 return tem;
10173 /* If this is a commutative operation, and ARG0 is a constant, move it
10174 to ARG1 to reduce the number of tests below. */
10175 if (commutative_tree_code (code)
10176 && tree_swap_operands_p (arg0, arg1, true))
10177 return fold_build2_loc (loc, code, type, op1, op0);
10179 /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
10181 First check for cases where an arithmetic operation is applied to a
10182 compound, conditional, or comparison operation. Push the arithmetic
10183 operation inside the compound or conditional to see if any folding
10184 can then be done. Convert comparison to conditional for this purpose.
10185 The also optimizes non-constant cases that used to be done in
10186 expand_expr.
10188 Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
10189 one of the operands is a comparison and the other is a comparison, a
10190 BIT_AND_EXPR with the constant 1, or a truth value. In that case, the
10191 code below would make the expression more complex. Change it to a
10192 TRUTH_{AND,OR}_EXPR. Likewise, convert a similar NE_EXPR to
10193 TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR. */
10195 if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
10196 || code == EQ_EXPR || code == NE_EXPR)
10197 && TREE_CODE (type) != VECTOR_TYPE
10198 && ((truth_value_p (TREE_CODE (arg0))
10199 && (truth_value_p (TREE_CODE (arg1))
10200 || (TREE_CODE (arg1) == BIT_AND_EXPR
10201 && integer_onep (TREE_OPERAND (arg1, 1)))))
10202 || (truth_value_p (TREE_CODE (arg1))
10203 && (truth_value_p (TREE_CODE (arg0))
10204 || (TREE_CODE (arg0) == BIT_AND_EXPR
10205 && integer_onep (TREE_OPERAND (arg0, 1)))))))
10207 tem = fold_build2_loc (loc, code == BIT_AND_EXPR ? TRUTH_AND_EXPR
10208 : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
10209 : TRUTH_XOR_EXPR,
10210 boolean_type_node,
10211 fold_convert_loc (loc, boolean_type_node, arg0),
10212 fold_convert_loc (loc, boolean_type_node, arg1));
10214 if (code == EQ_EXPR)
10215 tem = invert_truthvalue_loc (loc, tem);
10217 return fold_convert_loc (loc, type, tem);
10220 if (TREE_CODE_CLASS (code) == tcc_binary
10221 || TREE_CODE_CLASS (code) == tcc_comparison)
10223 if (TREE_CODE (arg0) == COMPOUND_EXPR)
10225 tem = fold_build2_loc (loc, code, type,
10226 fold_convert_loc (loc, TREE_TYPE (op0),
10227 TREE_OPERAND (arg0, 1)), op1);
10228 return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
10229 tem);
10231 if (TREE_CODE (arg1) == COMPOUND_EXPR
10232 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10234 tem = fold_build2_loc (loc, code, type, op0,
10235 fold_convert_loc (loc, TREE_TYPE (op1),
10236 TREE_OPERAND (arg1, 1)));
10237 return build2_loc (loc, COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
10238 tem);
10241 if (TREE_CODE (arg0) == COND_EXPR
10242 || TREE_CODE (arg0) == VEC_COND_EXPR
10243 || COMPARISON_CLASS_P (arg0))
10245 tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
10246 arg0, arg1,
10247 /*cond_first_p=*/1);
10248 if (tem != NULL_TREE)
10249 return tem;
10252 if (TREE_CODE (arg1) == COND_EXPR
10253 || TREE_CODE (arg1) == VEC_COND_EXPR
10254 || COMPARISON_CLASS_P (arg1))
10256 tem = fold_binary_op_with_conditional_arg (loc, code, type, op0, op1,
10257 arg1, arg0,
10258 /*cond_first_p=*/0);
10259 if (tem != NULL_TREE)
10260 return tem;
10264 switch (code)
10266 case MEM_REF:
10267 /* MEM[&MEM[p, CST1], CST2] -> MEM[p, CST1 + CST2]. */
10268 if (TREE_CODE (arg0) == ADDR_EXPR
10269 && TREE_CODE (TREE_OPERAND (arg0, 0)) == MEM_REF)
10271 tree iref = TREE_OPERAND (arg0, 0);
10272 return fold_build2 (MEM_REF, type,
10273 TREE_OPERAND (iref, 0),
10274 int_const_binop (PLUS_EXPR, arg1,
10275 TREE_OPERAND (iref, 1)));
10278 /* MEM[&a.b, CST2] -> MEM[&a, offsetof (a, b) + CST2]. */
10279 if (TREE_CODE (arg0) == ADDR_EXPR
10280 && handled_component_p (TREE_OPERAND (arg0, 0)))
10282 tree base;
10283 HOST_WIDE_INT coffset;
10284 base = get_addr_base_and_unit_offset (TREE_OPERAND (arg0, 0),
10285 &coffset);
10286 if (!base)
10287 return NULL_TREE;
10288 return fold_build2 (MEM_REF, type,
10289 build_fold_addr_expr (base),
10290 int_const_binop (PLUS_EXPR, arg1,
10291 size_int (coffset)));
10294 return NULL_TREE;
10296 case POINTER_PLUS_EXPR:
10297 /* 0 +p index -> (type)index */
10298 if (integer_zerop (arg0))
10299 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10301 /* PTR +p 0 -> PTR */
10302 if (integer_zerop (arg1))
10303 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10305 /* INT +p INT -> (PTR)(INT + INT). Stripping types allows for this. */
10306 if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10307 && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
10308 return fold_convert_loc (loc, type,
10309 fold_build2_loc (loc, PLUS_EXPR, sizetype,
10310 fold_convert_loc (loc, sizetype,
10311 arg1),
10312 fold_convert_loc (loc, sizetype,
10313 arg0)));
10315 /* (PTR +p B) +p A -> PTR +p (B + A) */
10316 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10318 tree inner;
10319 tree arg01 = fold_convert_loc (loc, sizetype, TREE_OPERAND (arg0, 1));
10320 tree arg00 = TREE_OPERAND (arg0, 0);
10321 inner = fold_build2_loc (loc, PLUS_EXPR, sizetype,
10322 arg01, fold_convert_loc (loc, sizetype, arg1));
10323 return fold_convert_loc (loc, type,
10324 fold_build_pointer_plus_loc (loc,
10325 arg00, inner));
10328 /* PTR_CST +p CST -> CST1 */
10329 if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
10330 return fold_build2_loc (loc, PLUS_EXPR, type, arg0,
10331 fold_convert_loc (loc, type, arg1));
10333 /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
10334 of the array. Loop optimizer sometimes produce this type of
10335 expressions. */
10336 if (TREE_CODE (arg0) == ADDR_EXPR)
10338 tem = try_move_mult_to_index (loc, arg0,
10339 fold_convert_loc (loc,
10340 ssizetype, arg1));
10341 if (tem)
10342 return fold_convert_loc (loc, type, tem);
10345 return NULL_TREE;
10347 case PLUS_EXPR:
10348 /* A + (-B) -> A - B */
10349 if (TREE_CODE (arg1) == NEGATE_EXPR
10350 && (flag_sanitize & SANITIZE_SI_OVERFLOW) == 0)
10351 return fold_build2_loc (loc, MINUS_EXPR, type,
10352 fold_convert_loc (loc, type, arg0),
10353 fold_convert_loc (loc, type,
10354 TREE_OPERAND (arg1, 0)));
10355 /* (-A) + B -> B - A */
10356 if (TREE_CODE (arg0) == NEGATE_EXPR
10357 && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1)
10358 && (flag_sanitize & SANITIZE_SI_OVERFLOW) == 0)
10359 return fold_build2_loc (loc, MINUS_EXPR, type,
10360 fold_convert_loc (loc, type, arg1),
10361 fold_convert_loc (loc, type,
10362 TREE_OPERAND (arg0, 0)));
10364 if (INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
10366 /* Convert ~A + 1 to -A. */
10367 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10368 && integer_onep (arg1))
10369 return fold_build1_loc (loc, NEGATE_EXPR, type,
10370 fold_convert_loc (loc, type,
10371 TREE_OPERAND (arg0, 0)));
10373 /* ~X + X is -1. */
10374 if (TREE_CODE (arg0) == BIT_NOT_EXPR
10375 && !TYPE_OVERFLOW_TRAPS (type))
10377 tree tem = TREE_OPERAND (arg0, 0);
10379 STRIP_NOPS (tem);
10380 if (operand_equal_p (tem, arg1, 0))
10382 t1 = build_all_ones_cst (type);
10383 return omit_one_operand_loc (loc, type, t1, arg1);
10387 /* X + ~X is -1. */
10388 if (TREE_CODE (arg1) == BIT_NOT_EXPR
10389 && !TYPE_OVERFLOW_TRAPS (type))
10391 tree tem = TREE_OPERAND (arg1, 0);
10393 STRIP_NOPS (tem);
10394 if (operand_equal_p (arg0, tem, 0))
10396 t1 = build_all_ones_cst (type);
10397 return omit_one_operand_loc (loc, type, t1, arg0);
10401 /* X + (X / CST) * -CST is X % CST. */
10402 if (TREE_CODE (arg1) == MULT_EXPR
10403 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10404 && operand_equal_p (arg0,
10405 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
10407 tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
10408 tree cst1 = TREE_OPERAND (arg1, 1);
10409 tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (cst1),
10410 cst1, cst0);
10411 if (sum && integer_zerop (sum))
10412 return fold_convert_loc (loc, type,
10413 fold_build2_loc (loc, TRUNC_MOD_EXPR,
10414 TREE_TYPE (arg0), arg0,
10415 cst0));
10419 /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the same or
10420 one. Make sure the type is not saturating and has the signedness of
10421 the stripped operands, as fold_plusminus_mult_expr will re-associate.
10422 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
10423 if ((TREE_CODE (arg0) == MULT_EXPR
10424 || TREE_CODE (arg1) == MULT_EXPR)
10425 && !TYPE_SATURATING (type)
10426 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
10427 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
10428 && (!FLOAT_TYPE_P (type) || flag_associative_math))
10430 tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
10431 if (tem)
10432 return tem;
10435 if (! FLOAT_TYPE_P (type))
10437 if (integer_zerop (arg1))
10438 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10440 /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
10441 with a constant, and the two constants have no bits in common,
10442 we should treat this as a BIT_IOR_EXPR since this may produce more
10443 simplifications. */
10444 if (TREE_CODE (arg0) == BIT_AND_EXPR
10445 && TREE_CODE (arg1) == BIT_AND_EXPR
10446 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10447 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
10448 && integer_zerop (const_binop (BIT_AND_EXPR,
10449 TREE_OPERAND (arg0, 1),
10450 TREE_OPERAND (arg1, 1))))
10452 code = BIT_IOR_EXPR;
10453 goto bit_ior;
10456 /* Reassociate (plus (plus (mult) (foo)) (mult)) as
10457 (plus (plus (mult) (mult)) (foo)) so that we can
10458 take advantage of the factoring cases below. */
10459 if (TYPE_OVERFLOW_WRAPS (type)
10460 && (((TREE_CODE (arg0) == PLUS_EXPR
10461 || TREE_CODE (arg0) == MINUS_EXPR)
10462 && TREE_CODE (arg1) == MULT_EXPR)
10463 || ((TREE_CODE (arg1) == PLUS_EXPR
10464 || TREE_CODE (arg1) == MINUS_EXPR)
10465 && TREE_CODE (arg0) == MULT_EXPR)))
10467 tree parg0, parg1, parg, marg;
10468 enum tree_code pcode;
10470 if (TREE_CODE (arg1) == MULT_EXPR)
10471 parg = arg0, marg = arg1;
10472 else
10473 parg = arg1, marg = arg0;
10474 pcode = TREE_CODE (parg);
10475 parg0 = TREE_OPERAND (parg, 0);
10476 parg1 = TREE_OPERAND (parg, 1);
10477 STRIP_NOPS (parg0);
10478 STRIP_NOPS (parg1);
10480 if (TREE_CODE (parg0) == MULT_EXPR
10481 && TREE_CODE (parg1) != MULT_EXPR)
10482 return fold_build2_loc (loc, pcode, type,
10483 fold_build2_loc (loc, PLUS_EXPR, type,
10484 fold_convert_loc (loc, type,
10485 parg0),
10486 fold_convert_loc (loc, type,
10487 marg)),
10488 fold_convert_loc (loc, type, parg1));
10489 if (TREE_CODE (parg0) != MULT_EXPR
10490 && TREE_CODE (parg1) == MULT_EXPR)
10491 return
10492 fold_build2_loc (loc, PLUS_EXPR, type,
10493 fold_convert_loc (loc, type, parg0),
10494 fold_build2_loc (loc, pcode, type,
10495 fold_convert_loc (loc, type, marg),
10496 fold_convert_loc (loc, type,
10497 parg1)));
10500 else
10502 /* See if ARG1 is zero and X + ARG1 reduces to X. */
10503 if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
10504 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10506 /* Likewise if the operands are reversed. */
10507 if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10508 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
10510 /* Convert X + -C into X - C. */
10511 if (TREE_CODE (arg1) == REAL_CST
10512 && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
10514 tem = fold_negate_const (arg1, type);
10515 if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
10516 return fold_build2_loc (loc, MINUS_EXPR, type,
10517 fold_convert_loc (loc, type, arg0),
10518 fold_convert_loc (loc, type, tem));
10521 /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
10522 to __complex__ ( x, y ). This is not the same for SNaNs or
10523 if signed zeros are involved. */
10524 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10525 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10526 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10528 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10529 tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10530 tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10531 bool arg0rz = false, arg0iz = false;
10532 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10533 || (arg0i && (arg0iz = real_zerop (arg0i))))
10535 tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10536 tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10537 if (arg0rz && arg1i && real_zerop (arg1i))
10539 tree rp = arg1r ? arg1r
10540 : build1 (REALPART_EXPR, rtype, arg1);
10541 tree ip = arg0i ? arg0i
10542 : build1 (IMAGPART_EXPR, rtype, arg0);
10543 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10545 else if (arg0iz && arg1r && real_zerop (arg1r))
10547 tree rp = arg0r ? arg0r
10548 : build1 (REALPART_EXPR, rtype, arg0);
10549 tree ip = arg1i ? arg1i
10550 : build1 (IMAGPART_EXPR, rtype, arg1);
10551 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10556 if (flag_unsafe_math_optimizations
10557 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10558 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10559 && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
10560 return tem;
10562 /* Convert x+x into x*2.0. */
10563 if (operand_equal_p (arg0, arg1, 0)
10564 && SCALAR_FLOAT_TYPE_P (type))
10565 return fold_build2_loc (loc, MULT_EXPR, type, arg0,
10566 build_real (type, dconst2));
10568 /* Convert a + (b*c + d*e) into (a + b*c) + d*e.
10569 We associate floats only if the user has specified
10570 -fassociative-math. */
10571 if (flag_associative_math
10572 && TREE_CODE (arg1) == PLUS_EXPR
10573 && TREE_CODE (arg0) != MULT_EXPR)
10575 tree tree10 = TREE_OPERAND (arg1, 0);
10576 tree tree11 = TREE_OPERAND (arg1, 1);
10577 if (TREE_CODE (tree11) == MULT_EXPR
10578 && TREE_CODE (tree10) == MULT_EXPR)
10580 tree tree0;
10581 tree0 = fold_build2_loc (loc, PLUS_EXPR, type, arg0, tree10);
10582 return fold_build2_loc (loc, PLUS_EXPR, type, tree0, tree11);
10585 /* Convert (b*c + d*e) + a into b*c + (d*e +a).
10586 We associate floats only if the user has specified
10587 -fassociative-math. */
10588 if (flag_associative_math
10589 && TREE_CODE (arg0) == PLUS_EXPR
10590 && TREE_CODE (arg1) != MULT_EXPR)
10592 tree tree00 = TREE_OPERAND (arg0, 0);
10593 tree tree01 = TREE_OPERAND (arg0, 1);
10594 if (TREE_CODE (tree01) == MULT_EXPR
10595 && TREE_CODE (tree00) == MULT_EXPR)
10597 tree tree0;
10598 tree0 = fold_build2_loc (loc, PLUS_EXPR, type, tree01, arg1);
10599 return fold_build2_loc (loc, PLUS_EXPR, type, tree00, tree0);
10604 bit_rotate:
10605 /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
10606 is a rotate of A by C1 bits. */
10607 /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
10608 is a rotate of A by B bits. */
10610 enum tree_code code0, code1;
10611 tree rtype;
10612 code0 = TREE_CODE (arg0);
10613 code1 = TREE_CODE (arg1);
10614 if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
10615 || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
10616 && operand_equal_p (TREE_OPERAND (arg0, 0),
10617 TREE_OPERAND (arg1, 0), 0)
10618 && (rtype = TREE_TYPE (TREE_OPERAND (arg0, 0)),
10619 TYPE_UNSIGNED (rtype))
10620 /* Only create rotates in complete modes. Other cases are not
10621 expanded properly. */
10622 && (element_precision (rtype)
10623 == element_precision (TYPE_MODE (rtype))))
10625 tree tree01, tree11;
10626 enum tree_code code01, code11;
10628 tree01 = TREE_OPERAND (arg0, 1);
10629 tree11 = TREE_OPERAND (arg1, 1);
10630 STRIP_NOPS (tree01);
10631 STRIP_NOPS (tree11);
10632 code01 = TREE_CODE (tree01);
10633 code11 = TREE_CODE (tree11);
10634 if (code01 == INTEGER_CST
10635 && code11 == INTEGER_CST
10636 && TREE_INT_CST_HIGH (tree01) == 0
10637 && TREE_INT_CST_HIGH (tree11) == 0
10638 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
10639 == element_precision (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
10641 tem = build2_loc (loc, LROTATE_EXPR,
10642 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10643 TREE_OPERAND (arg0, 0),
10644 code0 == LSHIFT_EXPR ? tree01 : tree11);
10645 return fold_convert_loc (loc, type, tem);
10647 else if (code11 == MINUS_EXPR)
10649 tree tree110, tree111;
10650 tree110 = TREE_OPERAND (tree11, 0);
10651 tree111 = TREE_OPERAND (tree11, 1);
10652 STRIP_NOPS (tree110);
10653 STRIP_NOPS (tree111);
10654 if (TREE_CODE (tree110) == INTEGER_CST
10655 && 0 == compare_tree_int (tree110,
10656 element_precision
10657 (TREE_TYPE (TREE_OPERAND
10658 (arg0, 0))))
10659 && operand_equal_p (tree01, tree111, 0))
10660 return
10661 fold_convert_loc (loc, type,
10662 build2 ((code0 == LSHIFT_EXPR
10663 ? LROTATE_EXPR
10664 : RROTATE_EXPR),
10665 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10666 TREE_OPERAND (arg0, 0), tree01));
10668 else if (code01 == MINUS_EXPR)
10670 tree tree010, tree011;
10671 tree010 = TREE_OPERAND (tree01, 0);
10672 tree011 = TREE_OPERAND (tree01, 1);
10673 STRIP_NOPS (tree010);
10674 STRIP_NOPS (tree011);
10675 if (TREE_CODE (tree010) == INTEGER_CST
10676 && 0 == compare_tree_int (tree010,
10677 element_precision
10678 (TREE_TYPE (TREE_OPERAND
10679 (arg0, 0))))
10680 && operand_equal_p (tree11, tree011, 0))
10681 return fold_convert_loc
10682 (loc, type,
10683 build2 ((code0 != LSHIFT_EXPR
10684 ? LROTATE_EXPR
10685 : RROTATE_EXPR),
10686 TREE_TYPE (TREE_OPERAND (arg0, 0)),
10687 TREE_OPERAND (arg0, 0), tree11));
10692 associate:
10693 /* In most languages, can't associate operations on floats through
10694 parentheses. Rather than remember where the parentheses were, we
10695 don't associate floats at all, unless the user has specified
10696 -fassociative-math.
10697 And, we need to make sure type is not saturating. */
10699 if ((! FLOAT_TYPE_P (type) || flag_associative_math)
10700 && !TYPE_SATURATING (type))
10702 tree var0, con0, lit0, minus_lit0;
10703 tree var1, con1, lit1, minus_lit1;
10704 tree atype = type;
10705 bool ok = true;
10707 /* Split both trees into variables, constants, and literals. Then
10708 associate each group together, the constants with literals,
10709 then the result with variables. This increases the chances of
10710 literals being recombined later and of generating relocatable
10711 expressions for the sum of a constant and literal. */
10712 var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
10713 var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
10714 code == MINUS_EXPR);
10716 /* Recombine MINUS_EXPR operands by using PLUS_EXPR. */
10717 if (code == MINUS_EXPR)
10718 code = PLUS_EXPR;
10720 /* With undefined overflow prefer doing association in a type
10721 which wraps on overflow, if that is one of the operand types. */
10722 if ((POINTER_TYPE_P (type) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10723 || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
10725 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
10726 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
10727 atype = TREE_TYPE (arg0);
10728 else if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
10729 && TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg1)))
10730 atype = TREE_TYPE (arg1);
10731 gcc_assert (TYPE_PRECISION (atype) == TYPE_PRECISION (type));
10734 /* With undefined overflow we can only associate constants with one
10735 variable, and constants whose association doesn't overflow. */
10736 if ((POINTER_TYPE_P (atype) && POINTER_TYPE_OVERFLOW_UNDEFINED)
10737 || (INTEGRAL_TYPE_P (atype) && !TYPE_OVERFLOW_WRAPS (atype)))
10739 if (var0 && var1)
10741 tree tmp0 = var0;
10742 tree tmp1 = var1;
10744 if (TREE_CODE (tmp0) == NEGATE_EXPR)
10745 tmp0 = TREE_OPERAND (tmp0, 0);
10746 if (CONVERT_EXPR_P (tmp0)
10747 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
10748 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp0, 0)))
10749 <= TYPE_PRECISION (atype)))
10750 tmp0 = TREE_OPERAND (tmp0, 0);
10751 if (TREE_CODE (tmp1) == NEGATE_EXPR)
10752 tmp1 = TREE_OPERAND (tmp1, 0);
10753 if (CONVERT_EXPR_P (tmp1)
10754 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
10755 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (tmp1, 0)))
10756 <= TYPE_PRECISION (atype)))
10757 tmp1 = TREE_OPERAND (tmp1, 0);
10758 /* The only case we can still associate with two variables
10759 is if they are the same, modulo negation and bit-pattern
10760 preserving conversions. */
10761 if (!operand_equal_p (tmp0, tmp1, 0))
10762 ok = false;
10766 /* Only do something if we found more than two objects. Otherwise,
10767 nothing has changed and we risk infinite recursion. */
10768 if (ok
10769 && (2 < ((var0 != 0) + (var1 != 0)
10770 + (con0 != 0) + (con1 != 0)
10771 + (lit0 != 0) + (lit1 != 0)
10772 + (minus_lit0 != 0) + (minus_lit1 != 0))))
10774 bool any_overflows = false;
10775 if (lit0) any_overflows |= TREE_OVERFLOW (lit0);
10776 if (lit1) any_overflows |= TREE_OVERFLOW (lit1);
10777 if (minus_lit0) any_overflows |= TREE_OVERFLOW (minus_lit0);
10778 if (minus_lit1) any_overflows |= TREE_OVERFLOW (minus_lit1);
10779 var0 = associate_trees (loc, var0, var1, code, atype);
10780 con0 = associate_trees (loc, con0, con1, code, atype);
10781 lit0 = associate_trees (loc, lit0, lit1, code, atype);
10782 minus_lit0 = associate_trees (loc, minus_lit0, minus_lit1,
10783 code, atype);
10785 /* Preserve the MINUS_EXPR if the negative part of the literal is
10786 greater than the positive part. Otherwise, the multiplicative
10787 folding code (i.e extract_muldiv) may be fooled in case
10788 unsigned constants are subtracted, like in the following
10789 example: ((X*2 + 4) - 8U)/2. */
10790 if (minus_lit0 && lit0)
10792 if (TREE_CODE (lit0) == INTEGER_CST
10793 && TREE_CODE (minus_lit0) == INTEGER_CST
10794 && tree_int_cst_lt (lit0, minus_lit0))
10796 minus_lit0 = associate_trees (loc, minus_lit0, lit0,
10797 MINUS_EXPR, atype);
10798 lit0 = 0;
10800 else
10802 lit0 = associate_trees (loc, lit0, minus_lit0,
10803 MINUS_EXPR, atype);
10804 minus_lit0 = 0;
10808 /* Don't introduce overflows through reassociation. */
10809 if (!any_overflows
10810 && ((lit0 && TREE_OVERFLOW (lit0))
10811 || (minus_lit0 && TREE_OVERFLOW (minus_lit0))))
10812 return NULL_TREE;
10814 if (minus_lit0)
10816 if (con0 == 0)
10817 return
10818 fold_convert_loc (loc, type,
10819 associate_trees (loc, var0, minus_lit0,
10820 MINUS_EXPR, atype));
10821 else
10823 con0 = associate_trees (loc, con0, minus_lit0,
10824 MINUS_EXPR, atype);
10825 return
10826 fold_convert_loc (loc, type,
10827 associate_trees (loc, var0, con0,
10828 PLUS_EXPR, atype));
10832 con0 = associate_trees (loc, con0, lit0, code, atype);
10833 return
10834 fold_convert_loc (loc, type, associate_trees (loc, var0, con0,
10835 code, atype));
10839 return NULL_TREE;
10841 case MINUS_EXPR:
10842 /* Pointer simplifications for subtraction, simple reassociations. */
10843 if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
10845 /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10846 if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
10847 && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10849 tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10850 tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10851 tree arg10 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
10852 tree arg11 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
10853 return fold_build2_loc (loc, PLUS_EXPR, type,
10854 fold_build2_loc (loc, MINUS_EXPR, type,
10855 arg00, arg10),
10856 fold_build2_loc (loc, MINUS_EXPR, type,
10857 arg01, arg11));
10859 /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10860 else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10862 tree arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
10863 tree arg01 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
10864 tree tmp = fold_binary_loc (loc, MINUS_EXPR, type, arg00,
10865 fold_convert_loc (loc, type, arg1));
10866 if (tmp)
10867 return fold_build2_loc (loc, PLUS_EXPR, type, tmp, arg01);
10870 /* A - (-B) -> A + B */
10871 if (TREE_CODE (arg1) == NEGATE_EXPR)
10872 return fold_build2_loc (loc, PLUS_EXPR, type, op0,
10873 fold_convert_loc (loc, type,
10874 TREE_OPERAND (arg1, 0)));
10875 /* (-A) - B -> (-B) - A where B is easily negated and we can swap. */
10876 if (TREE_CODE (arg0) == NEGATE_EXPR
10877 && negate_expr_p (arg1)
10878 && reorder_operands_p (arg0, arg1))
10879 return fold_build2_loc (loc, MINUS_EXPR, type,
10880 fold_convert_loc (loc, type,
10881 negate_expr (arg1)),
10882 fold_convert_loc (loc, type,
10883 TREE_OPERAND (arg0, 0)));
10884 /* Convert -A - 1 to ~A. */
10885 if (TREE_CODE (type) != COMPLEX_TYPE
10886 && TREE_CODE (arg0) == NEGATE_EXPR
10887 && integer_onep (arg1)
10888 && !TYPE_OVERFLOW_TRAPS (type))
10889 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
10890 fold_convert_loc (loc, type,
10891 TREE_OPERAND (arg0, 0)));
10893 /* Convert -1 - A to ~A. */
10894 if (TREE_CODE (type) != COMPLEX_TYPE
10895 && integer_all_onesp (arg0))
10896 return fold_build1_loc (loc, BIT_NOT_EXPR, type, op1);
10899 /* X - (X / Y) * Y is X % Y. */
10900 if ((INTEGRAL_TYPE_P (type) || VECTOR_INTEGER_TYPE_P (type))
10901 && TREE_CODE (arg1) == MULT_EXPR
10902 && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10903 && operand_equal_p (arg0,
10904 TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
10905 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
10906 TREE_OPERAND (arg1, 1), 0))
10907 return
10908 fold_convert_loc (loc, type,
10909 fold_build2_loc (loc, TRUNC_MOD_EXPR, TREE_TYPE (arg0),
10910 arg0, TREE_OPERAND (arg1, 1)));
10912 if (! FLOAT_TYPE_P (type))
10914 if (integer_zerop (arg0))
10915 return negate_expr (fold_convert_loc (loc, type, arg1));
10916 if (integer_zerop (arg1))
10917 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10919 /* Fold A - (A & B) into ~B & A. */
10920 if (!TREE_SIDE_EFFECTS (arg0)
10921 && TREE_CODE (arg1) == BIT_AND_EXPR)
10923 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
10925 tree arg10 = fold_convert_loc (loc, type,
10926 TREE_OPERAND (arg1, 0));
10927 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10928 fold_build1_loc (loc, BIT_NOT_EXPR,
10929 type, arg10),
10930 fold_convert_loc (loc, type, arg0));
10932 if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10934 tree arg11 = fold_convert_loc (loc,
10935 type, TREE_OPERAND (arg1, 1));
10936 return fold_build2_loc (loc, BIT_AND_EXPR, type,
10937 fold_build1_loc (loc, BIT_NOT_EXPR,
10938 type, arg11),
10939 fold_convert_loc (loc, type, arg0));
10943 /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10944 any power of 2 minus 1. */
10945 if (TREE_CODE (arg0) == BIT_AND_EXPR
10946 && TREE_CODE (arg1) == BIT_AND_EXPR
10947 && operand_equal_p (TREE_OPERAND (arg0, 0),
10948 TREE_OPERAND (arg1, 0), 0))
10950 tree mask0 = TREE_OPERAND (arg0, 1);
10951 tree mask1 = TREE_OPERAND (arg1, 1);
10952 tree tem = fold_build1_loc (loc, BIT_NOT_EXPR, type, mask0);
10954 if (operand_equal_p (tem, mask1, 0))
10956 tem = fold_build2_loc (loc, BIT_XOR_EXPR, type,
10957 TREE_OPERAND (arg0, 0), mask1);
10958 return fold_build2_loc (loc, MINUS_EXPR, type, tem, mask1);
10963 /* See if ARG1 is zero and X - ARG1 reduces to X. */
10964 else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
10965 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
10967 /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0). So check whether
10968 ARG0 is zero and X + ARG0 reduces to X, since that would mean
10969 (-ARG1 + ARG0) reduces to -ARG1. */
10970 else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10971 return negate_expr (fold_convert_loc (loc, type, arg1));
10973 /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10974 __complex__ ( x, -y ). This is not the same for SNaNs or if
10975 signed zeros are involved. */
10976 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10977 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10978 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10980 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10981 tree arg0r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0);
10982 tree arg0i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
10983 bool arg0rz = false, arg0iz = false;
10984 if ((arg0r && (arg0rz = real_zerop (arg0r)))
10985 || (arg0i && (arg0iz = real_zerop (arg0i))))
10987 tree arg1r = fold_unary_loc (loc, REALPART_EXPR, rtype, arg1);
10988 tree arg1i = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg1);
10989 if (arg0rz && arg1i && real_zerop (arg1i))
10991 tree rp = fold_build1_loc (loc, NEGATE_EXPR, rtype,
10992 arg1r ? arg1r
10993 : build1 (REALPART_EXPR, rtype, arg1));
10994 tree ip = arg0i ? arg0i
10995 : build1 (IMAGPART_EXPR, rtype, arg0);
10996 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
10998 else if (arg0iz && arg1r && real_zerop (arg1r))
11000 tree rp = arg0r ? arg0r
11001 : build1 (REALPART_EXPR, rtype, arg0);
11002 tree ip = fold_build1_loc (loc, NEGATE_EXPR, rtype,
11003 arg1i ? arg1i
11004 : build1 (IMAGPART_EXPR, rtype, arg1));
11005 return fold_build2_loc (loc, COMPLEX_EXPR, type, rp, ip);
11010 /* Fold &x - &x. This can happen from &x.foo - &x.
11011 This is unsafe for certain floats even in non-IEEE formats.
11012 In IEEE, it is unsafe because it does wrong for NaNs.
11013 Also note that operand_equal_p is always false if an operand
11014 is volatile. */
11016 if ((!FLOAT_TYPE_P (type) || !HONOR_NANS (TYPE_MODE (type)))
11017 && operand_equal_p (arg0, arg1, 0))
11018 return build_zero_cst (type);
11020 /* A - B -> A + (-B) if B is easily negatable. */
11021 if (negate_expr_p (arg1)
11022 && ((FLOAT_TYPE_P (type)
11023 /* Avoid this transformation if B is a positive REAL_CST. */
11024 && (TREE_CODE (arg1) != REAL_CST
11025 || REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
11026 || INTEGRAL_TYPE_P (type)))
11027 return fold_build2_loc (loc, PLUS_EXPR, type,
11028 fold_convert_loc (loc, type, arg0),
11029 fold_convert_loc (loc, type,
11030 negate_expr (arg1)));
11032 /* Try folding difference of addresses. */
11034 HOST_WIDE_INT diff;
11036 if ((TREE_CODE (arg0) == ADDR_EXPR
11037 || TREE_CODE (arg1) == ADDR_EXPR)
11038 && ptr_difference_const (arg0, arg1, &diff))
11039 return build_int_cst_type (type, diff);
11042 /* Fold &a[i] - &a[j] to i-j. */
11043 if (TREE_CODE (arg0) == ADDR_EXPR
11044 && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
11045 && TREE_CODE (arg1) == ADDR_EXPR
11046 && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
11048 tree tem = fold_addr_of_array_ref_difference (loc, type,
11049 TREE_OPERAND (arg0, 0),
11050 TREE_OPERAND (arg1, 0));
11051 if (tem)
11052 return tem;
11055 if (FLOAT_TYPE_P (type)
11056 && flag_unsafe_math_optimizations
11057 && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
11058 && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
11059 && (tem = distribute_real_division (loc, code, type, arg0, arg1)))
11060 return tem;
11062 /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the same or
11063 one. Make sure the type is not saturating and has the signedness of
11064 the stripped operands, as fold_plusminus_mult_expr will re-associate.
11065 ??? The latter condition should use TYPE_OVERFLOW_* flags instead. */
11066 if ((TREE_CODE (arg0) == MULT_EXPR
11067 || TREE_CODE (arg1) == MULT_EXPR)
11068 && !TYPE_SATURATING (type)
11069 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg0))
11070 && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1))
11071 && (!FLOAT_TYPE_P (type) || flag_associative_math))
11073 tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1);
11074 if (tem)
11075 return tem;
11078 goto associate;
11080 case MULT_EXPR:
11081 /* (-A) * (-B) -> A * B */
11082 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
11083 return fold_build2_loc (loc, MULT_EXPR, type,
11084 fold_convert_loc (loc, type,
11085 TREE_OPERAND (arg0, 0)),
11086 fold_convert_loc (loc, type,
11087 negate_expr (arg1)));
11088 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
11089 return fold_build2_loc (loc, MULT_EXPR, type,
11090 fold_convert_loc (loc, type,
11091 negate_expr (arg0)),
11092 fold_convert_loc (loc, type,
11093 TREE_OPERAND (arg1, 0)));
11095 if (! FLOAT_TYPE_P (type))
11097 if (integer_zerop (arg1))
11098 return omit_one_operand_loc (loc, type, arg1, arg0);
11099 if (integer_onep (arg1))
11100 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11101 /* Transform x * -1 into -x. Make sure to do the negation
11102 on the original operand with conversions not stripped
11103 because we can only strip non-sign-changing conversions. */
11104 if (integer_minus_onep (arg1))
11105 return fold_convert_loc (loc, type, negate_expr (op0));
11106 /* Transform x * -C into -x * C if x is easily negatable. */
11107 if (TREE_CODE (arg1) == INTEGER_CST
11108 && tree_int_cst_sgn (arg1) == -1
11109 && negate_expr_p (arg0)
11110 && (tem = negate_expr (arg1)) != arg1
11111 && !TREE_OVERFLOW (tem))
11112 return fold_build2_loc (loc, MULT_EXPR, type,
11113 fold_convert_loc (loc, type,
11114 negate_expr (arg0)),
11115 tem);
11117 /* (a * (1 << b)) is (a << b) */
11118 if (TREE_CODE (arg1) == LSHIFT_EXPR
11119 && integer_onep (TREE_OPERAND (arg1, 0)))
11120 return fold_build2_loc (loc, LSHIFT_EXPR, type, op0,
11121 TREE_OPERAND (arg1, 1));
11122 if (TREE_CODE (arg0) == LSHIFT_EXPR
11123 && integer_onep (TREE_OPERAND (arg0, 0)))
11124 return fold_build2_loc (loc, LSHIFT_EXPR, type, op1,
11125 TREE_OPERAND (arg0, 1));
11127 /* (A + A) * C -> A * 2 * C */
11128 if (TREE_CODE (arg0) == PLUS_EXPR
11129 && TREE_CODE (arg1) == INTEGER_CST
11130 && operand_equal_p (TREE_OPERAND (arg0, 0),
11131 TREE_OPERAND (arg0, 1), 0))
11132 return fold_build2_loc (loc, MULT_EXPR, type,
11133 omit_one_operand_loc (loc, type,
11134 TREE_OPERAND (arg0, 0),
11135 TREE_OPERAND (arg0, 1)),
11136 fold_build2_loc (loc, MULT_EXPR, type,
11137 build_int_cst (type, 2) , arg1));
11139 /* ((T) (X /[ex] C)) * C cancels out if the conversion is
11140 sign-changing only. */
11141 if (TREE_CODE (arg1) == INTEGER_CST
11142 && TREE_CODE (arg0) == EXACT_DIV_EXPR
11143 && operand_equal_p (arg1, TREE_OPERAND (arg0, 1), 0))
11144 return fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11146 strict_overflow_p = false;
11147 if (TREE_CODE (arg1) == INTEGER_CST
11148 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11149 &strict_overflow_p)))
11151 if (strict_overflow_p)
11152 fold_overflow_warning (("assuming signed overflow does not "
11153 "occur when simplifying "
11154 "multiplication"),
11155 WARN_STRICT_OVERFLOW_MISC);
11156 return fold_convert_loc (loc, type, tem);
11159 /* Optimize z * conj(z) for integer complex numbers. */
11160 if (TREE_CODE (arg0) == CONJ_EXPR
11161 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11162 return fold_mult_zconjz (loc, type, arg1);
11163 if (TREE_CODE (arg1) == CONJ_EXPR
11164 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11165 return fold_mult_zconjz (loc, type, arg0);
11167 else
11169 /* Maybe fold x * 0 to 0. The expressions aren't the same
11170 when x is NaN, since x * 0 is also NaN. Nor are they the
11171 same in modes with signed zeros, since multiplying a
11172 negative value by 0 gives -0, not +0. */
11173 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11174 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
11175 && real_zerop (arg1))
11176 return omit_one_operand_loc (loc, type, arg1, arg0);
11177 /* In IEEE floating point, x*1 is not equivalent to x for snans.
11178 Likewise for complex arithmetic with signed zeros. */
11179 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11180 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
11181 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
11182 && real_onep (arg1))
11183 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11185 /* Transform x * -1.0 into -x. */
11186 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11187 && (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
11188 || !COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
11189 && real_minus_onep (arg1))
11190 return fold_convert_loc (loc, type, negate_expr (arg0));
11192 /* Convert (C1/X)*C2 into (C1*C2)/X. This transformation may change
11193 the result for floating point types due to rounding so it is applied
11194 only if -fassociative-math was specify. */
11195 if (flag_associative_math
11196 && TREE_CODE (arg0) == RDIV_EXPR
11197 && TREE_CODE (arg1) == REAL_CST
11198 && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
11200 tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
11201 arg1);
11202 if (tem)
11203 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
11204 TREE_OPERAND (arg0, 1));
11207 /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y. */
11208 if (operand_equal_p (arg0, arg1, 0))
11210 tree tem = fold_strip_sign_ops (arg0);
11211 if (tem != NULL_TREE)
11213 tem = fold_convert_loc (loc, type, tem);
11214 return fold_build2_loc (loc, MULT_EXPR, type, tem, tem);
11218 /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
11219 This is not the same for NaNs or if signed zeros are
11220 involved. */
11221 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11222 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
11223 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
11224 && TREE_CODE (arg1) == COMPLEX_CST
11225 && real_zerop (TREE_REALPART (arg1)))
11227 tree rtype = TREE_TYPE (TREE_TYPE (arg0));
11228 if (real_onep (TREE_IMAGPART (arg1)))
11229 return
11230 fold_build2_loc (loc, COMPLEX_EXPR, type,
11231 negate_expr (fold_build1_loc (loc, IMAGPART_EXPR,
11232 rtype, arg0)),
11233 fold_build1_loc (loc, REALPART_EXPR, rtype, arg0));
11234 else if (real_minus_onep (TREE_IMAGPART (arg1)))
11235 return
11236 fold_build2_loc (loc, COMPLEX_EXPR, type,
11237 fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0),
11238 negate_expr (fold_build1_loc (loc, REALPART_EXPR,
11239 rtype, arg0)));
11242 /* Optimize z * conj(z) for floating point complex numbers.
11243 Guarded by flag_unsafe_math_optimizations as non-finite
11244 imaginary components don't produce scalar results. */
11245 if (flag_unsafe_math_optimizations
11246 && TREE_CODE (arg0) == CONJ_EXPR
11247 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11248 return fold_mult_zconjz (loc, type, arg1);
11249 if (flag_unsafe_math_optimizations
11250 && TREE_CODE (arg1) == CONJ_EXPR
11251 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11252 return fold_mult_zconjz (loc, type, arg0);
11254 if (flag_unsafe_math_optimizations)
11256 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
11257 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
11259 /* Optimizations of root(...)*root(...). */
11260 if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
11262 tree rootfn, arg;
11263 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11264 tree arg10 = CALL_EXPR_ARG (arg1, 0);
11266 /* Optimize sqrt(x)*sqrt(x) as x. */
11267 if (BUILTIN_SQRT_P (fcode0)
11268 && operand_equal_p (arg00, arg10, 0)
11269 && ! HONOR_SNANS (TYPE_MODE (type)))
11270 return arg00;
11272 /* Optimize root(x)*root(y) as root(x*y). */
11273 rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11274 arg = fold_build2_loc (loc, MULT_EXPR, type, arg00, arg10);
11275 return build_call_expr_loc (loc, rootfn, 1, arg);
11278 /* Optimize expN(x)*expN(y) as expN(x+y). */
11279 if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
11281 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11282 tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
11283 CALL_EXPR_ARG (arg0, 0),
11284 CALL_EXPR_ARG (arg1, 0));
11285 return build_call_expr_loc (loc, expfn, 1, arg);
11288 /* Optimizations of pow(...)*pow(...). */
11289 if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
11290 || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
11291 || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
11293 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11294 tree arg01 = CALL_EXPR_ARG (arg0, 1);
11295 tree arg10 = CALL_EXPR_ARG (arg1, 0);
11296 tree arg11 = CALL_EXPR_ARG (arg1, 1);
11298 /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y). */
11299 if (operand_equal_p (arg01, arg11, 0))
11301 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11302 tree arg = fold_build2_loc (loc, MULT_EXPR, type,
11303 arg00, arg10);
11304 return build_call_expr_loc (loc, powfn, 2, arg, arg01);
11307 /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z). */
11308 if (operand_equal_p (arg00, arg10, 0))
11310 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11311 tree arg = fold_build2_loc (loc, PLUS_EXPR, type,
11312 arg01, arg11);
11313 return build_call_expr_loc (loc, powfn, 2, arg00, arg);
11317 /* Optimize tan(x)*cos(x) as sin(x). */
11318 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
11319 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
11320 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
11321 || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
11322 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
11323 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
11324 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11325 CALL_EXPR_ARG (arg1, 0), 0))
11327 tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
11329 if (sinfn != NULL_TREE)
11330 return build_call_expr_loc (loc, sinfn, 1,
11331 CALL_EXPR_ARG (arg0, 0));
11334 /* Optimize x*pow(x,c) as pow(x,c+1). */
11335 if (fcode1 == BUILT_IN_POW
11336 || fcode1 == BUILT_IN_POWF
11337 || fcode1 == BUILT_IN_POWL)
11339 tree arg10 = CALL_EXPR_ARG (arg1, 0);
11340 tree arg11 = CALL_EXPR_ARG (arg1, 1);
11341 if (TREE_CODE (arg11) == REAL_CST
11342 && !TREE_OVERFLOW (arg11)
11343 && operand_equal_p (arg0, arg10, 0))
11345 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11346 REAL_VALUE_TYPE c;
11347 tree arg;
11349 c = TREE_REAL_CST (arg11);
11350 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
11351 arg = build_real (type, c);
11352 return build_call_expr_loc (loc, powfn, 2, arg0, arg);
11356 /* Optimize pow(x,c)*x as pow(x,c+1). */
11357 if (fcode0 == BUILT_IN_POW
11358 || fcode0 == BUILT_IN_POWF
11359 || fcode0 == BUILT_IN_POWL)
11361 tree arg00 = CALL_EXPR_ARG (arg0, 0);
11362 tree arg01 = CALL_EXPR_ARG (arg0, 1);
11363 if (TREE_CODE (arg01) == REAL_CST
11364 && !TREE_OVERFLOW (arg01)
11365 && operand_equal_p (arg1, arg00, 0))
11367 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11368 REAL_VALUE_TYPE c;
11369 tree arg;
11371 c = TREE_REAL_CST (arg01);
11372 real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
11373 arg = build_real (type, c);
11374 return build_call_expr_loc (loc, powfn, 2, arg1, arg);
11378 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x. */
11379 if (!in_gimple_form
11380 && optimize
11381 && operand_equal_p (arg0, arg1, 0))
11383 tree powfn = mathfn_built_in (type, BUILT_IN_POW);
11385 if (powfn)
11387 tree arg = build_real (type, dconst2);
11388 return build_call_expr_loc (loc, powfn, 2, arg0, arg);
11393 goto associate;
11395 case BIT_IOR_EXPR:
11396 bit_ior:
11397 if (integer_all_onesp (arg1))
11398 return omit_one_operand_loc (loc, type, arg1, arg0);
11399 if (integer_zerop (arg1))
11400 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11401 if (operand_equal_p (arg0, arg1, 0))
11402 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11404 /* ~X | X is -1. */
11405 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11406 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11408 t1 = build_zero_cst (type);
11409 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11410 return omit_one_operand_loc (loc, type, t1, arg1);
11413 /* X | ~X is -1. */
11414 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11415 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11417 t1 = build_zero_cst (type);
11418 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11419 return omit_one_operand_loc (loc, type, t1, arg0);
11422 /* Canonicalize (X & C1) | C2. */
11423 if (TREE_CODE (arg0) == BIT_AND_EXPR
11424 && TREE_CODE (arg1) == INTEGER_CST
11425 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11427 double_int c1, c2, c3, msk;
11428 int width = TYPE_PRECISION (type), w;
11429 bool try_simplify = true;
11431 c1 = tree_to_double_int (TREE_OPERAND (arg0, 1));
11432 c2 = tree_to_double_int (arg1);
11434 /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2). */
11435 if ((c1 & c2) == c1)
11436 return omit_one_operand_loc (loc, type, arg1,
11437 TREE_OPERAND (arg0, 0));
11439 msk = double_int::mask (width);
11441 /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2. */
11442 if (msk.and_not (c1 | c2).is_zero ())
11443 return fold_build2_loc (loc, BIT_IOR_EXPR, type,
11444 TREE_OPERAND (arg0, 0), arg1);
11446 /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
11447 unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
11448 mode which allows further optimizations. */
11449 c1 &= msk;
11450 c2 &= msk;
11451 c3 = c1.and_not (c2);
11452 for (w = BITS_PER_UNIT;
11453 w <= width && w <= HOST_BITS_PER_WIDE_INT;
11454 w <<= 1)
11456 unsigned HOST_WIDE_INT mask
11457 = HOST_WIDE_INT_M1U >> (HOST_BITS_PER_WIDE_INT - w);
11458 if (((c1.low | c2.low) & mask) == mask
11459 && (c1.low & ~mask) == 0 && c1.high == 0)
11461 c3 = double_int::from_uhwi (mask);
11462 break;
11466 /* If X is a tree of the form (Y * K1) & K2, this might conflict
11467 with that optimization from the BIT_AND_EXPR optimizations.
11468 This could end up in an infinite recursion. */
11469 if (TREE_CODE (TREE_OPERAND (arg0, 0)) == MULT_EXPR
11470 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
11471 == INTEGER_CST)
11473 tree t = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
11474 double_int masked = mask_with_tz (type, c3, tree_to_double_int (t));
11476 try_simplify = (masked != c1);
11479 if (try_simplify && c3 != c1)
11480 return fold_build2_loc (loc, BIT_IOR_EXPR, type,
11481 fold_build2_loc (loc, BIT_AND_EXPR, type,
11482 TREE_OPERAND (arg0, 0),
11483 double_int_to_tree (type,
11484 c3)),
11485 arg1);
11488 /* (X & Y) | Y is (X, Y). */
11489 if (TREE_CODE (arg0) == BIT_AND_EXPR
11490 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11491 return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
11492 /* (X & Y) | X is (Y, X). */
11493 if (TREE_CODE (arg0) == BIT_AND_EXPR
11494 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11495 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11496 return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
11497 /* X | (X & Y) is (Y, X). */
11498 if (TREE_CODE (arg1) == BIT_AND_EXPR
11499 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
11500 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
11501 return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
11502 /* X | (Y & X) is (Y, X). */
11503 if (TREE_CODE (arg1) == BIT_AND_EXPR
11504 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11505 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11506 return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
11508 /* (X & ~Y) | (~X & Y) is X ^ Y */
11509 if (TREE_CODE (arg0) == BIT_AND_EXPR
11510 && TREE_CODE (arg1) == BIT_AND_EXPR)
11512 tree a0, a1, l0, l1, n0, n1;
11514 a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11515 a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11517 l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11518 l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11520 n0 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l0);
11521 n1 = fold_build1_loc (loc, BIT_NOT_EXPR, type, l1);
11523 if ((operand_equal_p (n0, a0, 0)
11524 && operand_equal_p (n1, a1, 0))
11525 || (operand_equal_p (n0, a1, 0)
11526 && operand_equal_p (n1, a0, 0)))
11527 return fold_build2_loc (loc, BIT_XOR_EXPR, type, l0, n1);
11530 t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
11531 if (t1 != NULL_TREE)
11532 return t1;
11534 /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
11536 This results in more efficient code for machines without a NAND
11537 instruction. Combine will canonicalize to the first form
11538 which will allow use of NAND instructions provided by the
11539 backend if they exist. */
11540 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11541 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11543 return
11544 fold_build1_loc (loc, BIT_NOT_EXPR, type,
11545 build2 (BIT_AND_EXPR, type,
11546 fold_convert_loc (loc, type,
11547 TREE_OPERAND (arg0, 0)),
11548 fold_convert_loc (loc, type,
11549 TREE_OPERAND (arg1, 0))));
11552 /* See if this can be simplified into a rotate first. If that
11553 is unsuccessful continue in the association code. */
11554 goto bit_rotate;
11556 case BIT_XOR_EXPR:
11557 if (integer_zerop (arg1))
11558 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11559 if (integer_all_onesp (arg1))
11560 return fold_build1_loc (loc, BIT_NOT_EXPR, type, op0);
11561 if (operand_equal_p (arg0, arg1, 0))
11562 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11564 /* ~X ^ X is -1. */
11565 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11566 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11568 t1 = build_zero_cst (type);
11569 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11570 return omit_one_operand_loc (loc, type, t1, arg1);
11573 /* X ^ ~X is -1. */
11574 if (TREE_CODE (arg1) == BIT_NOT_EXPR
11575 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11577 t1 = build_zero_cst (type);
11578 t1 = fold_unary_loc (loc, BIT_NOT_EXPR, type, t1);
11579 return omit_one_operand_loc (loc, type, t1, arg0);
11582 /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
11583 with a constant, and the two constants have no bits in common,
11584 we should treat this as a BIT_IOR_EXPR since this may produce more
11585 simplifications. */
11586 if (TREE_CODE (arg0) == BIT_AND_EXPR
11587 && TREE_CODE (arg1) == BIT_AND_EXPR
11588 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11589 && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
11590 && integer_zerop (const_binop (BIT_AND_EXPR,
11591 TREE_OPERAND (arg0, 1),
11592 TREE_OPERAND (arg1, 1))))
11594 code = BIT_IOR_EXPR;
11595 goto bit_ior;
11598 /* (X | Y) ^ X -> Y & ~ X*/
11599 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11600 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11602 tree t2 = TREE_OPERAND (arg0, 1);
11603 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
11604 arg1);
11605 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11606 fold_convert_loc (loc, type, t2),
11607 fold_convert_loc (loc, type, t1));
11608 return t1;
11611 /* (Y | X) ^ X -> Y & ~ X*/
11612 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11613 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11615 tree t2 = TREE_OPERAND (arg0, 0);
11616 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1),
11617 arg1);
11618 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11619 fold_convert_loc (loc, type, t2),
11620 fold_convert_loc (loc, type, t1));
11621 return t1;
11624 /* X ^ (X | Y) -> Y & ~ X*/
11625 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11626 && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
11628 tree t2 = TREE_OPERAND (arg1, 1);
11629 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
11630 arg0);
11631 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11632 fold_convert_loc (loc, type, t2),
11633 fold_convert_loc (loc, type, t1));
11634 return t1;
11637 /* X ^ (Y | X) -> Y & ~ X*/
11638 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11639 && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
11641 tree t2 = TREE_OPERAND (arg1, 0);
11642 t1 = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg0),
11643 arg0);
11644 t1 = fold_build2_loc (loc, BIT_AND_EXPR, type,
11645 fold_convert_loc (loc, type, t2),
11646 fold_convert_loc (loc, type, t1));
11647 return t1;
11650 /* Convert ~X ^ ~Y to X ^ Y. */
11651 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11652 && TREE_CODE (arg1) == BIT_NOT_EXPR)
11653 return fold_build2_loc (loc, code, type,
11654 fold_convert_loc (loc, type,
11655 TREE_OPERAND (arg0, 0)),
11656 fold_convert_loc (loc, type,
11657 TREE_OPERAND (arg1, 0)));
11659 /* Convert ~X ^ C to X ^ ~C. */
11660 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11661 && TREE_CODE (arg1) == INTEGER_CST)
11662 return fold_build2_loc (loc, code, type,
11663 fold_convert_loc (loc, type,
11664 TREE_OPERAND (arg0, 0)),
11665 fold_build1_loc (loc, BIT_NOT_EXPR, type, arg1));
11667 /* Fold (X & 1) ^ 1 as (X & 1) == 0. */
11668 if (TREE_CODE (arg0) == BIT_AND_EXPR
11669 && integer_onep (TREE_OPERAND (arg0, 1))
11670 && integer_onep (arg1))
11671 return fold_build2_loc (loc, EQ_EXPR, type, arg0,
11672 build_zero_cst (TREE_TYPE (arg0)));
11674 /* Fold (X & Y) ^ Y as ~X & Y. */
11675 if (TREE_CODE (arg0) == BIT_AND_EXPR
11676 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11678 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11679 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11680 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11681 fold_convert_loc (loc, type, arg1));
11683 /* Fold (X & Y) ^ X as ~Y & X. */
11684 if (TREE_CODE (arg0) == BIT_AND_EXPR
11685 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11686 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11688 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11689 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11690 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11691 fold_convert_loc (loc, type, arg1));
11693 /* Fold X ^ (X & Y) as X & ~Y. */
11694 if (TREE_CODE (arg1) == BIT_AND_EXPR
11695 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11697 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11698 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11699 fold_convert_loc (loc, type, arg0),
11700 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
11702 /* Fold X ^ (Y & X) as ~Y & X. */
11703 if (TREE_CODE (arg1) == BIT_AND_EXPR
11704 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11705 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11707 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11708 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11709 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11710 fold_convert_loc (loc, type, arg0));
11713 /* See if this can be simplified into a rotate first. If that
11714 is unsuccessful continue in the association code. */
11715 goto bit_rotate;
11717 case BIT_AND_EXPR:
11718 if (integer_all_onesp (arg1))
11719 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11720 if (integer_zerop (arg1))
11721 return omit_one_operand_loc (loc, type, arg1, arg0);
11722 if (operand_equal_p (arg0, arg1, 0))
11723 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
11725 /* ~X & X, (X == 0) & X, and !X & X are always zero. */
11726 if ((TREE_CODE (arg0) == BIT_NOT_EXPR
11727 || TREE_CODE (arg0) == TRUTH_NOT_EXPR
11728 || (TREE_CODE (arg0) == EQ_EXPR
11729 && integer_zerop (TREE_OPERAND (arg0, 1))))
11730 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11731 return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
11733 /* X & ~X , X & (X == 0), and X & !X are always zero. */
11734 if ((TREE_CODE (arg1) == BIT_NOT_EXPR
11735 || TREE_CODE (arg1) == TRUTH_NOT_EXPR
11736 || (TREE_CODE (arg1) == EQ_EXPR
11737 && integer_zerop (TREE_OPERAND (arg1, 1))))
11738 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11739 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
11741 /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2). */
11742 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11743 && TREE_CODE (arg1) == INTEGER_CST
11744 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11746 tree tmp1 = fold_convert_loc (loc, type, arg1);
11747 tree tmp2 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11748 tree tmp3 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11749 tmp2 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp2, tmp1);
11750 tmp3 = fold_build2_loc (loc, BIT_AND_EXPR, type, tmp3, tmp1);
11751 return
11752 fold_convert_loc (loc, type,
11753 fold_build2_loc (loc, BIT_IOR_EXPR,
11754 type, tmp2, tmp3));
11757 /* (X | Y) & Y is (X, Y). */
11758 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11759 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11760 return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 0));
11761 /* (X | Y) & X is (Y, X). */
11762 if (TREE_CODE (arg0) == BIT_IOR_EXPR
11763 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11764 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11765 return omit_one_operand_loc (loc, type, arg1, TREE_OPERAND (arg0, 1));
11766 /* X & (X | Y) is (Y, X). */
11767 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11768 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
11769 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
11770 return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 1));
11771 /* X & (Y | X) is (Y, X). */
11772 if (TREE_CODE (arg1) == BIT_IOR_EXPR
11773 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11774 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11775 return omit_one_operand_loc (loc, type, arg0, TREE_OPERAND (arg1, 0));
11777 /* Fold (X ^ 1) & 1 as (X & 1) == 0. */
11778 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11779 && integer_onep (TREE_OPERAND (arg0, 1))
11780 && integer_onep (arg1))
11782 tree tem2;
11783 tem = TREE_OPERAND (arg0, 0);
11784 tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
11785 tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
11786 tem, tem2);
11787 return fold_build2_loc (loc, EQ_EXPR, type, tem2,
11788 build_zero_cst (TREE_TYPE (tem)));
11790 /* Fold ~X & 1 as (X & 1) == 0. */
11791 if (TREE_CODE (arg0) == BIT_NOT_EXPR
11792 && integer_onep (arg1))
11794 tree tem2;
11795 tem = TREE_OPERAND (arg0, 0);
11796 tem2 = fold_convert_loc (loc, TREE_TYPE (tem), arg1);
11797 tem2 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (tem),
11798 tem, tem2);
11799 return fold_build2_loc (loc, EQ_EXPR, type, tem2,
11800 build_zero_cst (TREE_TYPE (tem)));
11802 /* Fold !X & 1 as X == 0. */
11803 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
11804 && integer_onep (arg1))
11806 tem = TREE_OPERAND (arg0, 0);
11807 return fold_build2_loc (loc, EQ_EXPR, type, tem,
11808 build_zero_cst (TREE_TYPE (tem)));
11811 /* Fold (X ^ Y) & Y as ~X & Y. */
11812 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11813 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
11815 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
11816 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11817 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11818 fold_convert_loc (loc, type, arg1));
11820 /* Fold (X ^ Y) & X as ~Y & X. */
11821 if (TREE_CODE (arg0) == BIT_XOR_EXPR
11822 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11823 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
11825 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
11826 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11827 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11828 fold_convert_loc (loc, type, arg1));
11830 /* Fold X & (X ^ Y) as X & ~Y. */
11831 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11832 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11834 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
11835 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11836 fold_convert_loc (loc, type, arg0),
11837 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem));
11839 /* Fold X & (Y ^ X) as ~Y & X. */
11840 if (TREE_CODE (arg1) == BIT_XOR_EXPR
11841 && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
11842 && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
11844 tem = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
11845 return fold_build2_loc (loc, BIT_AND_EXPR, type,
11846 fold_build1_loc (loc, BIT_NOT_EXPR, type, tem),
11847 fold_convert_loc (loc, type, arg0));
11850 /* Fold (X * Y) & -(1 << CST) to X * Y if Y is a constant
11851 multiple of 1 << CST. */
11852 if (TREE_CODE (arg1) == INTEGER_CST)
11854 double_int cst1 = tree_to_double_int (arg1);
11855 double_int ncst1 = (-cst1).ext (TYPE_PRECISION (TREE_TYPE (arg1)),
11856 TYPE_UNSIGNED (TREE_TYPE (arg1)));
11857 if ((cst1 & ncst1) == ncst1
11858 && multiple_of_p (type, arg0,
11859 double_int_to_tree (TREE_TYPE (arg1), ncst1)))
11860 return fold_convert_loc (loc, type, arg0);
11863 /* Fold (X * CST1) & CST2 to zero if we can, or drop known zero
11864 bits from CST2. */
11865 if (TREE_CODE (arg1) == INTEGER_CST
11866 && TREE_CODE (arg0) == MULT_EXPR
11867 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11869 double_int masked
11870 = mask_with_tz (type, tree_to_double_int (arg1),
11871 tree_to_double_int (TREE_OPERAND (arg0, 1)));
11873 if (masked.is_zero ())
11874 return omit_two_operands_loc (loc, type, build_zero_cst (type),
11875 arg0, arg1);
11876 else if (masked != tree_to_double_int (arg1))
11877 return fold_build2_loc (loc, code, type, op0,
11878 double_int_to_tree (type, masked));
11881 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
11882 ((A & N) + B) & M -> (A + B) & M
11883 Similarly if (N & M) == 0,
11884 ((A | N) + B) & M -> (A + B) & M
11885 and for - instead of + (or unary - instead of +)
11886 and/or ^ instead of |.
11887 If B is constant and (B & M) == 0, fold into A & M. */
11888 if (tree_fits_uhwi_p (arg1))
11890 unsigned HOST_WIDE_INT cst1 = tree_to_uhwi (arg1);
11891 if (~cst1 && (cst1 & (cst1 + 1)) == 0
11892 && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
11893 && (TREE_CODE (arg0) == PLUS_EXPR
11894 || TREE_CODE (arg0) == MINUS_EXPR
11895 || TREE_CODE (arg0) == NEGATE_EXPR)
11896 && (TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0))
11897 || TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE))
11899 tree pmop[2];
11900 int which = 0;
11901 unsigned HOST_WIDE_INT cst0;
11903 /* Now we know that arg0 is (C + D) or (C - D) or
11904 -C and arg1 (M) is == (1LL << cst) - 1.
11905 Store C into PMOP[0] and D into PMOP[1]. */
11906 pmop[0] = TREE_OPERAND (arg0, 0);
11907 pmop[1] = NULL;
11908 if (TREE_CODE (arg0) != NEGATE_EXPR)
11910 pmop[1] = TREE_OPERAND (arg0, 1);
11911 which = 1;
11914 if (!tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (arg0)))
11915 || (tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (arg0)))
11916 & cst1) != cst1)
11917 which = -1;
11919 for (; which >= 0; which--)
11920 switch (TREE_CODE (pmop[which]))
11922 case BIT_AND_EXPR:
11923 case BIT_IOR_EXPR:
11924 case BIT_XOR_EXPR:
11925 if (TREE_CODE (TREE_OPERAND (pmop[which], 1))
11926 != INTEGER_CST)
11927 break;
11928 /* tree_to_[su]hwi not used, because we don't care about
11929 the upper bits. */
11930 cst0 = TREE_INT_CST_LOW (TREE_OPERAND (pmop[which], 1));
11931 cst0 &= cst1;
11932 if (TREE_CODE (pmop[which]) == BIT_AND_EXPR)
11934 if (cst0 != cst1)
11935 break;
11937 else if (cst0 != 0)
11938 break;
11939 /* If C or D is of the form (A & N) where
11940 (N & M) == M, or of the form (A | N) or
11941 (A ^ N) where (N & M) == 0, replace it with A. */
11942 pmop[which] = TREE_OPERAND (pmop[which], 0);
11943 break;
11944 case INTEGER_CST:
11945 /* If C or D is a N where (N & M) == 0, it can be
11946 omitted (assumed 0). */
11947 if ((TREE_CODE (arg0) == PLUS_EXPR
11948 || (TREE_CODE (arg0) == MINUS_EXPR && which == 0))
11949 && (TREE_INT_CST_LOW (pmop[which]) & cst1) == 0)
11950 pmop[which] = NULL;
11951 break;
11952 default:
11953 break;
11956 /* Only build anything new if we optimized one or both arguments
11957 above. */
11958 if (pmop[0] != TREE_OPERAND (arg0, 0)
11959 || (TREE_CODE (arg0) != NEGATE_EXPR
11960 && pmop[1] != TREE_OPERAND (arg0, 1)))
11962 tree utype = TREE_TYPE (arg0);
11963 if (! TYPE_OVERFLOW_WRAPS (TREE_TYPE (arg0)))
11965 /* Perform the operations in a type that has defined
11966 overflow behavior. */
11967 utype = unsigned_type_for (TREE_TYPE (arg0));
11968 if (pmop[0] != NULL)
11969 pmop[0] = fold_convert_loc (loc, utype, pmop[0]);
11970 if (pmop[1] != NULL)
11971 pmop[1] = fold_convert_loc (loc, utype, pmop[1]);
11974 if (TREE_CODE (arg0) == NEGATE_EXPR)
11975 tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[0]);
11976 else if (TREE_CODE (arg0) == PLUS_EXPR)
11978 if (pmop[0] != NULL && pmop[1] != NULL)
11979 tem = fold_build2_loc (loc, PLUS_EXPR, utype,
11980 pmop[0], pmop[1]);
11981 else if (pmop[0] != NULL)
11982 tem = pmop[0];
11983 else if (pmop[1] != NULL)
11984 tem = pmop[1];
11985 else
11986 return build_int_cst (type, 0);
11988 else if (pmop[0] == NULL)
11989 tem = fold_build1_loc (loc, NEGATE_EXPR, utype, pmop[1]);
11990 else
11991 tem = fold_build2_loc (loc, MINUS_EXPR, utype,
11992 pmop[0], pmop[1]);
11993 /* TEM is now the new binary +, - or unary - replacement. */
11994 tem = fold_build2_loc (loc, BIT_AND_EXPR, utype, tem,
11995 fold_convert_loc (loc, utype, arg1));
11996 return fold_convert_loc (loc, type, tem);
12001 t1 = distribute_bit_expr (loc, code, type, arg0, arg1);
12002 if (t1 != NULL_TREE)
12003 return t1;
12004 /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char. */
12005 if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
12006 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
12008 prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
12010 if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
12011 && (~TREE_INT_CST_LOW (arg1)
12012 & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
12013 return
12014 fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12017 /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
12019 This results in more efficient code for machines without a NOR
12020 instruction. Combine will canonicalize to the first form
12021 which will allow use of NOR instructions provided by the
12022 backend if they exist. */
12023 if (TREE_CODE (arg0) == BIT_NOT_EXPR
12024 && TREE_CODE (arg1) == BIT_NOT_EXPR)
12026 return fold_build1_loc (loc, BIT_NOT_EXPR, type,
12027 build2 (BIT_IOR_EXPR, type,
12028 fold_convert_loc (loc, type,
12029 TREE_OPERAND (arg0, 0)),
12030 fold_convert_loc (loc, type,
12031 TREE_OPERAND (arg1, 0))));
12034 /* If arg0 is derived from the address of an object or function, we may
12035 be able to fold this expression using the object or function's
12036 alignment. */
12037 if (POINTER_TYPE_P (TREE_TYPE (arg0)) && tree_fits_uhwi_p (arg1))
12039 unsigned HOST_WIDE_INT modulus, residue;
12040 unsigned HOST_WIDE_INT low = tree_to_uhwi (arg1);
12042 modulus = get_pointer_modulus_and_residue (arg0, &residue,
12043 integer_onep (arg1));
12045 /* This works because modulus is a power of 2. If this weren't the
12046 case, we'd have to replace it by its greatest power-of-2
12047 divisor: modulus & -modulus. */
12048 if (low < modulus)
12049 return build_int_cst (type, residue & low);
12052 /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
12053 (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
12054 if the new mask might be further optimized. */
12055 if ((TREE_CODE (arg0) == LSHIFT_EXPR
12056 || TREE_CODE (arg0) == RSHIFT_EXPR)
12057 && TYPE_PRECISION (TREE_TYPE (arg0)) <= HOST_BITS_PER_WIDE_INT
12058 && TREE_CODE (arg1) == INTEGER_CST
12059 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
12060 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) > 0
12061 && (tree_to_uhwi (TREE_OPERAND (arg0, 1))
12062 < TYPE_PRECISION (TREE_TYPE (arg0))))
12064 unsigned int shiftc = tree_to_uhwi (TREE_OPERAND (arg0, 1));
12065 unsigned HOST_WIDE_INT mask = TREE_INT_CST_LOW (arg1);
12066 unsigned HOST_WIDE_INT newmask, zerobits = 0;
12067 tree shift_type = TREE_TYPE (arg0);
12069 if (TREE_CODE (arg0) == LSHIFT_EXPR)
12070 zerobits = ((((unsigned HOST_WIDE_INT) 1) << shiftc) - 1);
12071 else if (TREE_CODE (arg0) == RSHIFT_EXPR
12072 && TYPE_PRECISION (TREE_TYPE (arg0))
12073 == GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (arg0))))
12075 prec = TYPE_PRECISION (TREE_TYPE (arg0));
12076 tree arg00 = TREE_OPERAND (arg0, 0);
12077 /* See if more bits can be proven as zero because of
12078 zero extension. */
12079 if (TREE_CODE (arg00) == NOP_EXPR
12080 && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
12082 tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
12083 if (TYPE_PRECISION (inner_type)
12084 == GET_MODE_PRECISION (TYPE_MODE (inner_type))
12085 && TYPE_PRECISION (inner_type) < prec)
12087 prec = TYPE_PRECISION (inner_type);
12088 /* See if we can shorten the right shift. */
12089 if (shiftc < prec)
12090 shift_type = inner_type;
12093 zerobits = ~(unsigned HOST_WIDE_INT) 0;
12094 zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
12095 zerobits <<= prec - shiftc;
12096 /* For arithmetic shift if sign bit could be set, zerobits
12097 can contain actually sign bits, so no transformation is
12098 possible, unless MASK masks them all away. In that
12099 case the shift needs to be converted into logical shift. */
12100 if (!TYPE_UNSIGNED (TREE_TYPE (arg0))
12101 && prec == TYPE_PRECISION (TREE_TYPE (arg0)))
12103 if ((mask & zerobits) == 0)
12104 shift_type = unsigned_type_for (TREE_TYPE (arg0));
12105 else
12106 zerobits = 0;
12110 /* ((X << 16) & 0xff00) is (X, 0). */
12111 if ((mask & zerobits) == mask)
12112 return omit_one_operand_loc (loc, type,
12113 build_int_cst (type, 0), arg0);
12115 newmask = mask | zerobits;
12116 if (newmask != mask && (newmask & (newmask + 1)) == 0)
12118 /* Only do the transformation if NEWMASK is some integer
12119 mode's mask. */
12120 for (prec = BITS_PER_UNIT;
12121 prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
12122 if (newmask == (((unsigned HOST_WIDE_INT) 1) << prec) - 1)
12123 break;
12124 if (prec < HOST_BITS_PER_WIDE_INT
12125 || newmask == ~(unsigned HOST_WIDE_INT) 0)
12127 tree newmaskt;
12129 if (shift_type != TREE_TYPE (arg0))
12131 tem = fold_build2_loc (loc, TREE_CODE (arg0), shift_type,
12132 fold_convert_loc (loc, shift_type,
12133 TREE_OPERAND (arg0, 0)),
12134 TREE_OPERAND (arg0, 1));
12135 tem = fold_convert_loc (loc, type, tem);
12137 else
12138 tem = op0;
12139 newmaskt = build_int_cst_type (TREE_TYPE (op1), newmask);
12140 if (!tree_int_cst_equal (newmaskt, arg1))
12141 return fold_build2_loc (loc, BIT_AND_EXPR, type, tem, newmaskt);
12146 goto associate;
12148 case RDIV_EXPR:
12149 /* Don't touch a floating-point divide by zero unless the mode
12150 of the constant can represent infinity. */
12151 if (TREE_CODE (arg1) == REAL_CST
12152 && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
12153 && real_zerop (arg1))
12154 return NULL_TREE;
12156 /* Optimize A / A to 1.0 if we don't care about
12157 NaNs or Infinities. Skip the transformation
12158 for non-real operands. */
12159 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
12160 && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
12161 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
12162 && operand_equal_p (arg0, arg1, 0))
12164 tree r = build_real (TREE_TYPE (arg0), dconst1);
12166 return omit_two_operands_loc (loc, type, r, arg0, arg1);
12169 /* The complex version of the above A / A optimization. */
12170 if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
12171 && operand_equal_p (arg0, arg1, 0))
12173 tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
12174 if (! HONOR_NANS (TYPE_MODE (elem_type))
12175 && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
12177 tree r = build_real (elem_type, dconst1);
12178 /* omit_two_operands will call fold_convert for us. */
12179 return omit_two_operands_loc (loc, type, r, arg0, arg1);
12183 /* (-A) / (-B) -> A / B */
12184 if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
12185 return fold_build2_loc (loc, RDIV_EXPR, type,
12186 TREE_OPERAND (arg0, 0),
12187 negate_expr (arg1));
12188 if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
12189 return fold_build2_loc (loc, RDIV_EXPR, type,
12190 negate_expr (arg0),
12191 TREE_OPERAND (arg1, 0));
12193 /* In IEEE floating point, x/1 is not equivalent to x for snans. */
12194 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
12195 && real_onep (arg1))
12196 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12198 /* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
12199 if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
12200 && real_minus_onep (arg1))
12201 return non_lvalue_loc (loc, fold_convert_loc (loc, type,
12202 negate_expr (arg0)));
12204 /* If ARG1 is a constant, we can convert this to a multiply by the
12205 reciprocal. This does not have the same rounding properties,
12206 so only do this if -freciprocal-math. We can actually
12207 always safely do it if ARG1 is a power of two, but it's hard to
12208 tell if it is or not in a portable manner. */
12209 if (optimize
12210 && (TREE_CODE (arg1) == REAL_CST
12211 || (TREE_CODE (arg1) == COMPLEX_CST
12212 && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg1)))
12213 || (TREE_CODE (arg1) == VECTOR_CST
12214 && VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg1)))))
12216 if (flag_reciprocal_math
12217 && 0 != (tem = const_binop (code, build_one_cst (type), arg1)))
12218 return fold_build2_loc (loc, MULT_EXPR, type, arg0, tem);
12219 /* Find the reciprocal if optimizing and the result is exact.
12220 TODO: Complex reciprocal not implemented. */
12221 if (TREE_CODE (arg1) != COMPLEX_CST)
12223 tree inverse = exact_inverse (TREE_TYPE (arg0), arg1);
12225 if (inverse)
12226 return fold_build2_loc (loc, MULT_EXPR, type, arg0, inverse);
12229 /* Convert A/B/C to A/(B*C). */
12230 if (flag_reciprocal_math
12231 && TREE_CODE (arg0) == RDIV_EXPR)
12232 return fold_build2_loc (loc, RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
12233 fold_build2_loc (loc, MULT_EXPR, type,
12234 TREE_OPERAND (arg0, 1), arg1));
12236 /* Convert A/(B/C) to (A/B)*C. */
12237 if (flag_reciprocal_math
12238 && TREE_CODE (arg1) == RDIV_EXPR)
12239 return fold_build2_loc (loc, MULT_EXPR, type,
12240 fold_build2_loc (loc, RDIV_EXPR, type, arg0,
12241 TREE_OPERAND (arg1, 0)),
12242 TREE_OPERAND (arg1, 1));
12244 /* Convert C1/(X*C2) into (C1/C2)/X. */
12245 if (flag_reciprocal_math
12246 && TREE_CODE (arg1) == MULT_EXPR
12247 && TREE_CODE (arg0) == REAL_CST
12248 && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
12250 tree tem = const_binop (RDIV_EXPR, arg0,
12251 TREE_OPERAND (arg1, 1));
12252 if (tem)
12253 return fold_build2_loc (loc, RDIV_EXPR, type, tem,
12254 TREE_OPERAND (arg1, 0));
12257 if (flag_unsafe_math_optimizations)
12259 enum built_in_function fcode0 = builtin_mathfn_code (arg0);
12260 enum built_in_function fcode1 = builtin_mathfn_code (arg1);
12262 /* Optimize sin(x)/cos(x) as tan(x). */
12263 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
12264 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
12265 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
12266 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
12267 CALL_EXPR_ARG (arg1, 0), 0))
12269 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
12271 if (tanfn != NULL_TREE)
12272 return build_call_expr_loc (loc, tanfn, 1, CALL_EXPR_ARG (arg0, 0));
12275 /* Optimize cos(x)/sin(x) as 1.0/tan(x). */
12276 if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
12277 || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
12278 || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
12279 && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
12280 CALL_EXPR_ARG (arg1, 0), 0))
12282 tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
12284 if (tanfn != NULL_TREE)
12286 tree tmp = build_call_expr_loc (loc, tanfn, 1,
12287 CALL_EXPR_ARG (arg0, 0));
12288 return fold_build2_loc (loc, RDIV_EXPR, type,
12289 build_real (type, dconst1), tmp);
12293 /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
12294 NaNs or Infinities. */
12295 if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
12296 || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
12297 || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
12299 tree arg00 = CALL_EXPR_ARG (arg0, 0);
12300 tree arg01 = CALL_EXPR_ARG (arg1, 0);
12302 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
12303 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
12304 && operand_equal_p (arg00, arg01, 0))
12306 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
12308 if (cosfn != NULL_TREE)
12309 return build_call_expr_loc (loc, cosfn, 1, arg00);
12313 /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
12314 NaNs or Infinities. */
12315 if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
12316 || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
12317 || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
12319 tree arg00 = CALL_EXPR_ARG (arg0, 0);
12320 tree arg01 = CALL_EXPR_ARG (arg1, 0);
12322 if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
12323 && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
12324 && operand_equal_p (arg00, arg01, 0))
12326 tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
12328 if (cosfn != NULL_TREE)
12330 tree tmp = build_call_expr_loc (loc, cosfn, 1, arg00);
12331 return fold_build2_loc (loc, RDIV_EXPR, type,
12332 build_real (type, dconst1),
12333 tmp);
12338 /* Optimize pow(x,c)/x as pow(x,c-1). */
12339 if (fcode0 == BUILT_IN_POW
12340 || fcode0 == BUILT_IN_POWF
12341 || fcode0 == BUILT_IN_POWL)
12343 tree arg00 = CALL_EXPR_ARG (arg0, 0);
12344 tree arg01 = CALL_EXPR_ARG (arg0, 1);
12345 if (TREE_CODE (arg01) == REAL_CST
12346 && !TREE_OVERFLOW (arg01)
12347 && operand_equal_p (arg1, arg00, 0))
12349 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
12350 REAL_VALUE_TYPE c;
12351 tree arg;
12353 c = TREE_REAL_CST (arg01);
12354 real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
12355 arg = build_real (type, c);
12356 return build_call_expr_loc (loc, powfn, 2, arg1, arg);
12360 /* Optimize a/root(b/c) into a*root(c/b). */
12361 if (BUILTIN_ROOT_P (fcode1))
12363 tree rootarg = CALL_EXPR_ARG (arg1, 0);
12365 if (TREE_CODE (rootarg) == RDIV_EXPR)
12367 tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
12368 tree b = TREE_OPERAND (rootarg, 0);
12369 tree c = TREE_OPERAND (rootarg, 1);
12371 tree tmp = fold_build2_loc (loc, RDIV_EXPR, type, c, b);
12373 tmp = build_call_expr_loc (loc, rootfn, 1, tmp);
12374 return fold_build2_loc (loc, MULT_EXPR, type, arg0, tmp);
12378 /* Optimize x/expN(y) into x*expN(-y). */
12379 if (BUILTIN_EXPONENT_P (fcode1))
12381 tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
12382 tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
12383 arg1 = build_call_expr_loc (loc,
12384 expfn, 1,
12385 fold_convert_loc (loc, type, arg));
12386 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
12389 /* Optimize x/pow(y,z) into x*pow(y,-z). */
12390 if (fcode1 == BUILT_IN_POW
12391 || fcode1 == BUILT_IN_POWF
12392 || fcode1 == BUILT_IN_POWL)
12394 tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
12395 tree arg10 = CALL_EXPR_ARG (arg1, 0);
12396 tree arg11 = CALL_EXPR_ARG (arg1, 1);
12397 tree neg11 = fold_convert_loc (loc, type,
12398 negate_expr (arg11));
12399 arg1 = build_call_expr_loc (loc, powfn, 2, arg10, neg11);
12400 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
12403 return NULL_TREE;
12405 case TRUNC_DIV_EXPR:
12406 /* Optimize (X & (-A)) / A where A is a power of 2,
12407 to X >> log2(A) */
12408 if (TREE_CODE (arg0) == BIT_AND_EXPR
12409 && !TYPE_UNSIGNED (type) && TREE_CODE (arg1) == INTEGER_CST
12410 && integer_pow2p (arg1) && tree_int_cst_sgn (arg1) > 0)
12412 tree sum = fold_binary_loc (loc, PLUS_EXPR, TREE_TYPE (arg1),
12413 arg1, TREE_OPERAND (arg0, 1));
12414 if (sum && integer_zerop (sum)) {
12415 unsigned long pow2;
12417 if (TREE_INT_CST_LOW (arg1))
12418 pow2 = exact_log2 (TREE_INT_CST_LOW (arg1));
12419 else
12420 pow2 = exact_log2 (TREE_INT_CST_HIGH (arg1))
12421 + HOST_BITS_PER_WIDE_INT;
12423 return fold_build2_loc (loc, RSHIFT_EXPR, type,
12424 TREE_OPERAND (arg0, 0),
12425 build_int_cst (integer_type_node, pow2));
12429 /* Fall through */
12431 case FLOOR_DIV_EXPR:
12432 /* Simplify A / (B << N) where A and B are positive and B is
12433 a power of 2, to A >> (N + log2(B)). */
12434 strict_overflow_p = false;
12435 if (TREE_CODE (arg1) == LSHIFT_EXPR
12436 && (TYPE_UNSIGNED (type)
12437 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
12439 tree sval = TREE_OPERAND (arg1, 0);
12440 if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
12442 tree sh_cnt = TREE_OPERAND (arg1, 1);
12443 unsigned long pow2;
12445 if (TREE_INT_CST_LOW (sval))
12446 pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
12447 else
12448 pow2 = exact_log2 (TREE_INT_CST_HIGH (sval))
12449 + HOST_BITS_PER_WIDE_INT;
12451 if (strict_overflow_p)
12452 fold_overflow_warning (("assuming signed overflow does not "
12453 "occur when simplifying A / (B << N)"),
12454 WARN_STRICT_OVERFLOW_MISC);
12456 sh_cnt = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (sh_cnt),
12457 sh_cnt,
12458 build_int_cst (TREE_TYPE (sh_cnt),
12459 pow2));
12460 return fold_build2_loc (loc, RSHIFT_EXPR, type,
12461 fold_convert_loc (loc, type, arg0), sh_cnt);
12465 /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
12466 TRUNC_DIV_EXPR. Rewrite into the latter in this case. */
12467 if (INTEGRAL_TYPE_P (type)
12468 && TYPE_UNSIGNED (type)
12469 && code == FLOOR_DIV_EXPR)
12470 return fold_build2_loc (loc, TRUNC_DIV_EXPR, type, op0, op1);
12472 /* Fall through */
12474 case ROUND_DIV_EXPR:
12475 case CEIL_DIV_EXPR:
12476 case EXACT_DIV_EXPR:
12477 if (integer_onep (arg1))
12478 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12479 if (integer_zerop (arg1))
12480 return NULL_TREE;
12481 /* X / -1 is -X. */
12482 if (!TYPE_UNSIGNED (type)
12483 && TREE_CODE (arg1) == INTEGER_CST
12484 && TREE_INT_CST_LOW (arg1) == HOST_WIDE_INT_M1U
12485 && TREE_INT_CST_HIGH (arg1) == -1)
12486 return fold_convert_loc (loc, type, negate_expr (arg0));
12488 /* Convert -A / -B to A / B when the type is signed and overflow is
12489 undefined. */
12490 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12491 && TREE_CODE (arg0) == NEGATE_EXPR
12492 && negate_expr_p (arg1))
12494 if (INTEGRAL_TYPE_P (type))
12495 fold_overflow_warning (("assuming signed overflow does not occur "
12496 "when distributing negation across "
12497 "division"),
12498 WARN_STRICT_OVERFLOW_MISC);
12499 return fold_build2_loc (loc, code, type,
12500 fold_convert_loc (loc, type,
12501 TREE_OPERAND (arg0, 0)),
12502 fold_convert_loc (loc, type,
12503 negate_expr (arg1)));
12505 if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
12506 && TREE_CODE (arg1) == NEGATE_EXPR
12507 && negate_expr_p (arg0))
12509 if (INTEGRAL_TYPE_P (type))
12510 fold_overflow_warning (("assuming signed overflow does not occur "
12511 "when distributing negation across "
12512 "division"),
12513 WARN_STRICT_OVERFLOW_MISC);
12514 return fold_build2_loc (loc, code, type,
12515 fold_convert_loc (loc, type,
12516 negate_expr (arg0)),
12517 fold_convert_loc (loc, type,
12518 TREE_OPERAND (arg1, 0)));
12521 /* If arg0 is a multiple of arg1, then rewrite to the fastest div
12522 operation, EXACT_DIV_EXPR.
12524 Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
12525 At one time others generated faster code, it's not clear if they do
12526 after the last round to changes to the DIV code in expmed.c. */
12527 if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
12528 && multiple_of_p (type, arg0, arg1))
12529 return fold_build2_loc (loc, EXACT_DIV_EXPR, type, arg0, arg1);
12531 strict_overflow_p = false;
12532 if (TREE_CODE (arg1) == INTEGER_CST
12533 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
12534 &strict_overflow_p)))
12536 if (strict_overflow_p)
12537 fold_overflow_warning (("assuming signed overflow does not occur "
12538 "when simplifying division"),
12539 WARN_STRICT_OVERFLOW_MISC);
12540 return fold_convert_loc (loc, type, tem);
12543 return NULL_TREE;
12545 case CEIL_MOD_EXPR:
12546 case FLOOR_MOD_EXPR:
12547 case ROUND_MOD_EXPR:
12548 case TRUNC_MOD_EXPR:
12549 /* X % 1 is always zero, but be sure to preserve any side
12550 effects in X. */
12551 if (integer_onep (arg1))
12552 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12554 /* X % 0, return X % 0 unchanged so that we can get the
12555 proper warnings and errors. */
12556 if (integer_zerop (arg1))
12557 return NULL_TREE;
12559 /* 0 % X is always zero, but be sure to preserve any side
12560 effects in X. Place this after checking for X == 0. */
12561 if (integer_zerop (arg0))
12562 return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
12564 /* X % -1 is zero. */
12565 if (!TYPE_UNSIGNED (type)
12566 && TREE_CODE (arg1) == INTEGER_CST
12567 && TREE_INT_CST_LOW (arg1) == HOST_WIDE_INT_M1U
12568 && TREE_INT_CST_HIGH (arg1) == -1)
12569 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12571 /* X % -C is the same as X % C. */
12572 if (code == TRUNC_MOD_EXPR
12573 && !TYPE_UNSIGNED (type)
12574 && TREE_CODE (arg1) == INTEGER_CST
12575 && !TREE_OVERFLOW (arg1)
12576 && TREE_INT_CST_HIGH (arg1) < 0
12577 && !TYPE_OVERFLOW_TRAPS (type)
12578 /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */
12579 && !sign_bit_p (arg1, arg1))
12580 return fold_build2_loc (loc, code, type,
12581 fold_convert_loc (loc, type, arg0),
12582 fold_convert_loc (loc, type,
12583 negate_expr (arg1)));
12585 /* X % -Y is the same as X % Y. */
12586 if (code == TRUNC_MOD_EXPR
12587 && !TYPE_UNSIGNED (type)
12588 && TREE_CODE (arg1) == NEGATE_EXPR
12589 && !TYPE_OVERFLOW_TRAPS (type))
12590 return fold_build2_loc (loc, code, type, fold_convert_loc (loc, type, arg0),
12591 fold_convert_loc (loc, type,
12592 TREE_OPERAND (arg1, 0)));
12594 strict_overflow_p = false;
12595 if (TREE_CODE (arg1) == INTEGER_CST
12596 && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
12597 &strict_overflow_p)))
12599 if (strict_overflow_p)
12600 fold_overflow_warning (("assuming signed overflow does not occur "
12601 "when simplifying modulus"),
12602 WARN_STRICT_OVERFLOW_MISC);
12603 return fold_convert_loc (loc, type, tem);
12606 /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
12607 i.e. "X % C" into "X & (C - 1)", if X and C are positive. */
12608 if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
12609 && (TYPE_UNSIGNED (type)
12610 || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
12612 tree c = arg1;
12613 /* Also optimize A % (C << N) where C is a power of 2,
12614 to A & ((C << N) - 1). */
12615 if (TREE_CODE (arg1) == LSHIFT_EXPR)
12616 c = TREE_OPERAND (arg1, 0);
12618 if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
12620 tree mask
12621 = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (arg1), arg1,
12622 build_int_cst (TREE_TYPE (arg1), 1));
12623 if (strict_overflow_p)
12624 fold_overflow_warning (("assuming signed overflow does not "
12625 "occur when simplifying "
12626 "X % (power of two)"),
12627 WARN_STRICT_OVERFLOW_MISC);
12628 return fold_build2_loc (loc, BIT_AND_EXPR, type,
12629 fold_convert_loc (loc, type, arg0),
12630 fold_convert_loc (loc, type, mask));
12634 return NULL_TREE;
12636 case LROTATE_EXPR:
12637 case RROTATE_EXPR:
12638 if (integer_all_onesp (arg0))
12639 return omit_one_operand_loc (loc, type, arg0, arg1);
12640 goto shift;
12642 case RSHIFT_EXPR:
12643 /* Optimize -1 >> x for arithmetic right shifts. */
12644 if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type)
12645 && tree_expr_nonnegative_p (arg1))
12646 return omit_one_operand_loc (loc, type, arg0, arg1);
12647 /* ... fall through ... */
12649 case LSHIFT_EXPR:
12650 shift:
12651 if (integer_zerop (arg1))
12652 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12653 if (integer_zerop (arg0))
12654 return omit_one_operand_loc (loc, type, arg0, arg1);
12656 /* Prefer vector1 << scalar to vector1 << vector2
12657 if vector2 is uniform. */
12658 if (VECTOR_TYPE_P (TREE_TYPE (arg1))
12659 && (tem = uniform_vector_p (arg1)) != NULL_TREE)
12660 return fold_build2_loc (loc, code, type, op0, tem);
12662 /* Since negative shift count is not well-defined,
12663 don't try to compute it in the compiler. */
12664 if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
12665 return NULL_TREE;
12667 prec = element_precision (type);
12669 /* Turn (a OP c1) OP c2 into a OP (c1+c2). */
12670 if (TREE_CODE (op0) == code && tree_fits_uhwi_p (arg1)
12671 && tree_to_uhwi (arg1) < prec
12672 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
12673 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) < prec)
12675 unsigned int low = (tree_to_uhwi (TREE_OPERAND (arg0, 1))
12676 + tree_to_uhwi (arg1));
12678 /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
12679 being well defined. */
12680 if (low >= prec)
12682 if (code == LROTATE_EXPR || code == RROTATE_EXPR)
12683 low = low % prec;
12684 else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
12685 return omit_one_operand_loc (loc, type, build_zero_cst (type),
12686 TREE_OPERAND (arg0, 0));
12687 else
12688 low = prec - 1;
12691 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
12692 build_int_cst (TREE_TYPE (arg1), low));
12695 /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
12696 into x & ((unsigned)-1 >> c) for unsigned types. */
12697 if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
12698 || (TYPE_UNSIGNED (type)
12699 && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
12700 && tree_fits_uhwi_p (arg1)
12701 && tree_to_uhwi (arg1) < prec
12702 && tree_fits_uhwi_p (TREE_OPERAND (arg0, 1))
12703 && tree_to_uhwi (TREE_OPERAND (arg0, 1)) < prec)
12705 HOST_WIDE_INT low0 = tree_to_uhwi (TREE_OPERAND (arg0, 1));
12706 HOST_WIDE_INT low1 = tree_to_uhwi (arg1);
12707 tree lshift;
12708 tree arg00;
12710 if (low0 == low1)
12712 arg00 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12714 lshift = build_minus_one_cst (type);
12715 lshift = const_binop (code, lshift, arg1);
12717 return fold_build2_loc (loc, BIT_AND_EXPR, type, arg00, lshift);
12721 /* Rewrite an LROTATE_EXPR by a constant into an
12722 RROTATE_EXPR by a new constant. */
12723 if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
12725 tree tem = build_int_cst (TREE_TYPE (arg1), prec);
12726 tem = const_binop (MINUS_EXPR, tem, arg1);
12727 return fold_build2_loc (loc, RROTATE_EXPR, type, op0, tem);
12730 /* If we have a rotate of a bit operation with the rotate count and
12731 the second operand of the bit operation both constant,
12732 permute the two operations. */
12733 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
12734 && (TREE_CODE (arg0) == BIT_AND_EXPR
12735 || TREE_CODE (arg0) == BIT_IOR_EXPR
12736 || TREE_CODE (arg0) == BIT_XOR_EXPR)
12737 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12738 return fold_build2_loc (loc, TREE_CODE (arg0), type,
12739 fold_build2_loc (loc, code, type,
12740 TREE_OPERAND (arg0, 0), arg1),
12741 fold_build2_loc (loc, code, type,
12742 TREE_OPERAND (arg0, 1), arg1));
12744 /* Two consecutive rotates adding up to the precision of the
12745 type can be ignored. */
12746 if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
12747 && TREE_CODE (arg0) == RROTATE_EXPR
12748 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12749 && TREE_INT_CST_HIGH (arg1) == 0
12750 && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
12751 && ((TREE_INT_CST_LOW (arg1)
12752 + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
12753 == prec))
12754 return TREE_OPERAND (arg0, 0);
12756 /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
12757 (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
12758 if the latter can be further optimized. */
12759 if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
12760 && TREE_CODE (arg0) == BIT_AND_EXPR
12761 && TREE_CODE (arg1) == INTEGER_CST
12762 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12764 tree mask = fold_build2_loc (loc, code, type,
12765 fold_convert_loc (loc, type,
12766 TREE_OPERAND (arg0, 1)),
12767 arg1);
12768 tree shift = fold_build2_loc (loc, code, type,
12769 fold_convert_loc (loc, type,
12770 TREE_OPERAND (arg0, 0)),
12771 arg1);
12772 tem = fold_binary_loc (loc, BIT_AND_EXPR, type, shift, mask);
12773 if (tem)
12774 return tem;
12777 return NULL_TREE;
12779 case MIN_EXPR:
12780 if (operand_equal_p (arg0, arg1, 0))
12781 return omit_one_operand_loc (loc, type, arg0, arg1);
12782 if (INTEGRAL_TYPE_P (type)
12783 && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
12784 return omit_one_operand_loc (loc, type, arg1, arg0);
12785 tem = fold_minmax (loc, MIN_EXPR, type, arg0, arg1);
12786 if (tem)
12787 return tem;
12788 goto associate;
12790 case MAX_EXPR:
12791 if (operand_equal_p (arg0, arg1, 0))
12792 return omit_one_operand_loc (loc, type, arg0, arg1);
12793 if (INTEGRAL_TYPE_P (type)
12794 && TYPE_MAX_VALUE (type)
12795 && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
12796 return omit_one_operand_loc (loc, type, arg1, arg0);
12797 tem = fold_minmax (loc, MAX_EXPR, type, arg0, arg1);
12798 if (tem)
12799 return tem;
12800 goto associate;
12802 case TRUTH_ANDIF_EXPR:
12803 /* Note that the operands of this must be ints
12804 and their values must be 0 or 1.
12805 ("true" is a fixed value perhaps depending on the language.) */
12806 /* If first arg is constant zero, return it. */
12807 if (integer_zerop (arg0))
12808 return fold_convert_loc (loc, type, arg0);
12809 case TRUTH_AND_EXPR:
12810 /* If either arg is constant true, drop it. */
12811 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12812 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12813 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
12814 /* Preserve sequence points. */
12815 && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12816 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12817 /* If second arg is constant zero, result is zero, but first arg
12818 must be evaluated. */
12819 if (integer_zerop (arg1))
12820 return omit_one_operand_loc (loc, type, arg1, arg0);
12821 /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
12822 case will be handled here. */
12823 if (integer_zerop (arg0))
12824 return omit_one_operand_loc (loc, type, arg0, arg1);
12826 /* !X && X is always false. */
12827 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12828 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12829 return omit_one_operand_loc (loc, type, integer_zero_node, arg1);
12830 /* X && !X is always false. */
12831 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12832 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12833 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12835 /* A < X && A + 1 > Y ==> A < X && A >= Y. Normally A + 1 > Y
12836 means A >= Y && A != MAX, but in this case we know that
12837 A < X <= MAX. */
12839 if (!TREE_SIDE_EFFECTS (arg0)
12840 && !TREE_SIDE_EFFECTS (arg1))
12842 tem = fold_to_nonsharp_ineq_using_bound (loc, arg0, arg1);
12843 if (tem && !operand_equal_p (tem, arg0, 0))
12844 return fold_build2_loc (loc, code, type, tem, arg1);
12846 tem = fold_to_nonsharp_ineq_using_bound (loc, arg1, arg0);
12847 if (tem && !operand_equal_p (tem, arg1, 0))
12848 return fold_build2_loc (loc, code, type, arg0, tem);
12851 if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
12852 != NULL_TREE)
12853 return tem;
12855 return NULL_TREE;
12857 case TRUTH_ORIF_EXPR:
12858 /* Note that the operands of this must be ints
12859 and their values must be 0 or true.
12860 ("true" is a fixed value perhaps depending on the language.) */
12861 /* If first arg is constant true, return it. */
12862 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12863 return fold_convert_loc (loc, type, arg0);
12864 case TRUTH_OR_EXPR:
12865 /* If either arg is constant zero, drop it. */
12866 if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
12867 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg1));
12868 if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
12869 /* Preserve sequence points. */
12870 && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
12871 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12872 /* If second arg is constant true, result is true, but we must
12873 evaluate first arg. */
12874 if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
12875 return omit_one_operand_loc (loc, type, arg1, arg0);
12876 /* Likewise for first arg, but note this only occurs here for
12877 TRUTH_OR_EXPR. */
12878 if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
12879 return omit_one_operand_loc (loc, type, arg0, arg1);
12881 /* !X || X is always true. */
12882 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12883 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12884 return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12885 /* X || !X is always true. */
12886 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12887 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12888 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12890 /* (X && !Y) || (!X && Y) is X ^ Y */
12891 if (TREE_CODE (arg0) == TRUTH_AND_EXPR
12892 && TREE_CODE (arg1) == TRUTH_AND_EXPR)
12894 tree a0, a1, l0, l1, n0, n1;
12896 a0 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 0));
12897 a1 = fold_convert_loc (loc, type, TREE_OPERAND (arg1, 1));
12899 l0 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 0));
12900 l1 = fold_convert_loc (loc, type, TREE_OPERAND (arg0, 1));
12902 n0 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l0);
12903 n1 = fold_build1_loc (loc, TRUTH_NOT_EXPR, type, l1);
12905 if ((operand_equal_p (n0, a0, 0)
12906 && operand_equal_p (n1, a1, 0))
12907 || (operand_equal_p (n0, a1, 0)
12908 && operand_equal_p (n1, a0, 0)))
12909 return fold_build2_loc (loc, TRUTH_XOR_EXPR, type, l0, n1);
12912 if ((tem = fold_truth_andor (loc, code, type, arg0, arg1, op0, op1))
12913 != NULL_TREE)
12914 return tem;
12916 return NULL_TREE;
12918 case TRUTH_XOR_EXPR:
12919 /* If the second arg is constant zero, drop it. */
12920 if (integer_zerop (arg1))
12921 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12922 /* If the second arg is constant true, this is a logical inversion. */
12923 if (integer_onep (arg1))
12925 tem = invert_truthvalue_loc (loc, arg0);
12926 return non_lvalue_loc (loc, fold_convert_loc (loc, type, tem));
12928 /* Identical arguments cancel to zero. */
12929 if (operand_equal_p (arg0, arg1, 0))
12930 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
12932 /* !X ^ X is always true. */
12933 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
12934 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
12935 return omit_one_operand_loc (loc, type, integer_one_node, arg1);
12937 /* X ^ !X is always true. */
12938 if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
12939 && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
12940 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
12942 return NULL_TREE;
12944 case EQ_EXPR:
12945 case NE_EXPR:
12946 STRIP_NOPS (arg0);
12947 STRIP_NOPS (arg1);
12949 tem = fold_comparison (loc, code, type, op0, op1);
12950 if (tem != NULL_TREE)
12951 return tem;
12953 /* bool_var != 0 becomes bool_var. */
12954 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12955 && code == NE_EXPR)
12956 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12958 /* bool_var == 1 becomes bool_var. */
12959 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12960 && code == EQ_EXPR)
12961 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12963 /* bool_var != 1 becomes !bool_var. */
12964 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
12965 && code == NE_EXPR)
12966 return fold_convert_loc (loc, type,
12967 fold_build1_loc (loc, TRUTH_NOT_EXPR,
12968 TREE_TYPE (arg0), arg0));
12970 /* bool_var == 0 becomes !bool_var. */
12971 if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
12972 && code == EQ_EXPR)
12973 return fold_convert_loc (loc, type,
12974 fold_build1_loc (loc, TRUTH_NOT_EXPR,
12975 TREE_TYPE (arg0), arg0));
12977 /* !exp != 0 becomes !exp */
12978 if (TREE_CODE (arg0) == TRUTH_NOT_EXPR && integer_zerop (arg1)
12979 && code == NE_EXPR)
12980 return non_lvalue_loc (loc, fold_convert_loc (loc, type, arg0));
12982 /* If this is an equality comparison of the address of two non-weak,
12983 unaliased symbols neither of which are extern (since we do not
12984 have access to attributes for externs), then we know the result. */
12985 if (TREE_CODE (arg0) == ADDR_EXPR
12986 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
12987 && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
12988 && ! lookup_attribute ("alias",
12989 DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
12990 && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
12991 && TREE_CODE (arg1) == ADDR_EXPR
12992 && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
12993 && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
12994 && ! lookup_attribute ("alias",
12995 DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
12996 && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
12998 /* We know that we're looking at the address of two
12999 non-weak, unaliased, static _DECL nodes.
13001 It is both wasteful and incorrect to call operand_equal_p
13002 to compare the two ADDR_EXPR nodes. It is wasteful in that
13003 all we need to do is test pointer equality for the arguments
13004 to the two ADDR_EXPR nodes. It is incorrect to use
13005 operand_equal_p as that function is NOT equivalent to a
13006 C equality test. It can in fact return false for two
13007 objects which would test as equal using the C equality
13008 operator. */
13009 bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
13010 return constant_boolean_node (equal
13011 ? code == EQ_EXPR : code != EQ_EXPR,
13012 type);
13015 /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
13016 a MINUS_EXPR of a constant, we can convert it into a comparison with
13017 a revised constant as long as no overflow occurs. */
13018 if (TREE_CODE (arg1) == INTEGER_CST
13019 && (TREE_CODE (arg0) == PLUS_EXPR
13020 || TREE_CODE (arg0) == MINUS_EXPR)
13021 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
13022 && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
13023 ? MINUS_EXPR : PLUS_EXPR,
13024 fold_convert_loc (loc, TREE_TYPE (arg0),
13025 arg1),
13026 TREE_OPERAND (arg0, 1)))
13027 && !TREE_OVERFLOW (tem))
13028 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
13030 /* Similarly for a NEGATE_EXPR. */
13031 if (TREE_CODE (arg0) == NEGATE_EXPR
13032 && TREE_CODE (arg1) == INTEGER_CST
13033 && 0 != (tem = negate_expr (fold_convert_loc (loc, TREE_TYPE (arg0),
13034 arg1)))
13035 && TREE_CODE (tem) == INTEGER_CST
13036 && !TREE_OVERFLOW (tem))
13037 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), tem);
13039 /* Similarly for a BIT_XOR_EXPR; X ^ C1 == C2 is X == (C1 ^ C2). */
13040 if (TREE_CODE (arg0) == BIT_XOR_EXPR
13041 && TREE_CODE (arg1) == INTEGER_CST
13042 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
13043 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
13044 fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg0),
13045 fold_convert_loc (loc,
13046 TREE_TYPE (arg0),
13047 arg1),
13048 TREE_OPERAND (arg0, 1)));
13050 /* Transform comparisons of the form X +- Y CMP X to Y CMP 0. */
13051 if ((TREE_CODE (arg0) == PLUS_EXPR
13052 || TREE_CODE (arg0) == POINTER_PLUS_EXPR
13053 || TREE_CODE (arg0) == MINUS_EXPR)
13054 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
13055 0)),
13056 arg1, 0)
13057 && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
13058 || POINTER_TYPE_P (TREE_TYPE (arg0))))
13060 tree val = TREE_OPERAND (arg0, 1);
13061 return omit_two_operands_loc (loc, type,
13062 fold_build2_loc (loc, code, type,
13063 val,
13064 build_int_cst (TREE_TYPE (val),
13065 0)),
13066 TREE_OPERAND (arg0, 0), arg1);
13069 /* Transform comparisons of the form C - X CMP X if C % 2 == 1. */
13070 if (TREE_CODE (arg0) == MINUS_EXPR
13071 && TREE_CODE (TREE_OPERAND (arg0, 0)) == INTEGER_CST
13072 && operand_equal_p (tree_strip_nop_conversions (TREE_OPERAND (arg0,
13073 1)),
13074 arg1, 0)
13075 && (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 0)) & 1) == 1)
13077 return omit_two_operands_loc (loc, type,
13078 code == NE_EXPR
13079 ? boolean_true_node : boolean_false_node,
13080 TREE_OPERAND (arg0, 1), arg1);
13083 /* If we have X - Y == 0, we can convert that to X == Y and similarly
13084 for !=. Don't do this for ordered comparisons due to overflow. */
13085 if (TREE_CODE (arg0) == MINUS_EXPR
13086 && integer_zerop (arg1))
13087 return fold_build2_loc (loc, code, type,
13088 TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
13090 /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0. */
13091 if (TREE_CODE (arg0) == ABS_EXPR
13092 && (integer_zerop (arg1) || real_zerop (arg1)))
13093 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0), arg1);
13095 /* If this is an EQ or NE comparison with zero and ARG0 is
13096 (1 << foo) & bar, convert it to (bar >> foo) & 1. Both require
13097 two operations, but the latter can be done in one less insn
13098 on machines that have only two-operand insns or on which a
13099 constant cannot be the first operand. */
13100 if (TREE_CODE (arg0) == BIT_AND_EXPR
13101 && integer_zerop (arg1))
13103 tree arg00 = TREE_OPERAND (arg0, 0);
13104 tree arg01 = TREE_OPERAND (arg0, 1);
13105 if (TREE_CODE (arg00) == LSHIFT_EXPR
13106 && integer_onep (TREE_OPERAND (arg00, 0)))
13108 tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00),
13109 arg01, TREE_OPERAND (arg00, 1));
13110 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
13111 build_int_cst (TREE_TYPE (arg0), 1));
13112 return fold_build2_loc (loc, code, type,
13113 fold_convert_loc (loc, TREE_TYPE (arg1), tem),
13114 arg1);
13116 else if (TREE_CODE (arg01) == LSHIFT_EXPR
13117 && integer_onep (TREE_OPERAND (arg01, 0)))
13119 tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01),
13120 arg00, TREE_OPERAND (arg01, 1));
13121 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem,
13122 build_int_cst (TREE_TYPE (arg0), 1));
13123 return fold_build2_loc (loc, code, type,
13124 fold_convert_loc (loc, TREE_TYPE (arg1), tem),
13125 arg1);
13129 /* If this is an NE or EQ comparison of zero against the result of a
13130 signed MOD operation whose second operand is a power of 2, make
13131 the MOD operation unsigned since it is simpler and equivalent. */
13132 if (integer_zerop (arg1)
13133 && !TYPE_UNSIGNED (TREE_TYPE (arg0))
13134 && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
13135 || TREE_CODE (arg0) == CEIL_MOD_EXPR
13136 || TREE_CODE (arg0) == FLOOR_MOD_EXPR
13137 || TREE_CODE (arg0) == ROUND_MOD_EXPR)
13138 && integer_pow2p (TREE_OPERAND (arg0, 1)))
13140 tree newtype = unsigned_type_for (TREE_TYPE (arg0));
13141 tree newmod = fold_build2_loc (loc, TREE_CODE (arg0), newtype,
13142 fold_convert_loc (loc, newtype,
13143 TREE_OPERAND (arg0, 0)),
13144 fold_convert_loc (loc, newtype,
13145 TREE_OPERAND (arg0, 1)));
13147 return fold_build2_loc (loc, code, type, newmod,
13148 fold_convert_loc (loc, newtype, arg1));
13151 /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
13152 C1 is a valid shift constant, and C2 is a power of two, i.e.
13153 a single bit. */
13154 if (TREE_CODE (arg0) == BIT_AND_EXPR
13155 && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
13156 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
13157 == INTEGER_CST
13158 && integer_pow2p (TREE_OPERAND (arg0, 1))
13159 && integer_zerop (arg1))
13161 tree itype = TREE_TYPE (arg0);
13162 tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
13163 prec = TYPE_PRECISION (itype);
13165 /* Check for a valid shift count. */
13166 if (TREE_INT_CST_HIGH (arg001) == 0
13167 && TREE_INT_CST_LOW (arg001) < prec)
13169 tree arg01 = TREE_OPERAND (arg0, 1);
13170 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
13171 unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
13172 /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
13173 can be rewritten as (X & (C2 << C1)) != 0. */
13174 if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
13176 tem = fold_build2_loc (loc, LSHIFT_EXPR, itype, arg01, arg001);
13177 tem = fold_build2_loc (loc, BIT_AND_EXPR, itype, arg000, tem);
13178 return fold_build2_loc (loc, code, type, tem,
13179 fold_convert_loc (loc, itype, arg1));
13181 /* Otherwise, for signed (arithmetic) shifts,
13182 ((X >> C1) & C2) != 0 is rewritten as X < 0, and
13183 ((X >> C1) & C2) == 0 is rewritten as X >= 0. */
13184 else if (!TYPE_UNSIGNED (itype))
13185 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
13186 arg000, build_int_cst (itype, 0));
13187 /* Otherwise, of unsigned (logical) shifts,
13188 ((X >> C1) & C2) != 0 is rewritten as (X,false), and
13189 ((X >> C1) & C2) == 0 is rewritten as (X,true). */
13190 else
13191 return omit_one_operand_loc (loc, type,
13192 code == EQ_EXPR ? integer_one_node
13193 : integer_zero_node,
13194 arg000);
13198 /* If we have (A & C) == C where C is a power of 2, convert this into
13199 (A & C) != 0. Similarly for NE_EXPR. */
13200 if (TREE_CODE (arg0) == BIT_AND_EXPR
13201 && integer_pow2p (TREE_OPERAND (arg0, 1))
13202 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
13203 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
13204 arg0, fold_convert_loc (loc, TREE_TYPE (arg0),
13205 integer_zero_node));
13207 /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
13208 bit, then fold the expression into A < 0 or A >= 0. */
13209 tem = fold_single_bit_test_into_sign_test (loc, code, arg0, arg1, type);
13210 if (tem)
13211 return tem;
13213 /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
13214 Similarly for NE_EXPR. */
13215 if (TREE_CODE (arg0) == BIT_AND_EXPR
13216 && TREE_CODE (arg1) == INTEGER_CST
13217 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
13219 tree notc = fold_build1_loc (loc, BIT_NOT_EXPR,
13220 TREE_TYPE (TREE_OPERAND (arg0, 1)),
13221 TREE_OPERAND (arg0, 1));
13222 tree dandnotc
13223 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
13224 fold_convert_loc (loc, TREE_TYPE (arg0), arg1),
13225 notc);
13226 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
13227 if (integer_nonzerop (dandnotc))
13228 return omit_one_operand_loc (loc, type, rslt, arg0);
13231 /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
13232 Similarly for NE_EXPR. */
13233 if (TREE_CODE (arg0) == BIT_IOR_EXPR
13234 && TREE_CODE (arg1) == INTEGER_CST
13235 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
13237 tree notd = fold_build1_loc (loc, BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
13238 tree candnotd
13239 = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
13240 TREE_OPERAND (arg0, 1),
13241 fold_convert_loc (loc, TREE_TYPE (arg0), notd));
13242 tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
13243 if (integer_nonzerop (candnotd))
13244 return omit_one_operand_loc (loc, type, rslt, arg0);
13247 /* If this is a comparison of a field, we may be able to simplify it. */
13248 if ((TREE_CODE (arg0) == COMPONENT_REF
13249 || TREE_CODE (arg0) == BIT_FIELD_REF)
13250 /* Handle the constant case even without -O
13251 to make sure the warnings are given. */
13252 && (optimize || TREE_CODE (arg1) == INTEGER_CST))
13254 t1 = optimize_bit_field_compare (loc, code, type, arg0, arg1);
13255 if (t1)
13256 return t1;
13259 /* Optimize comparisons of strlen vs zero to a compare of the
13260 first character of the string vs zero. To wit,
13261 strlen(ptr) == 0 => *ptr == 0
13262 strlen(ptr) != 0 => *ptr != 0
13263 Other cases should reduce to one of these two (or a constant)
13264 due to the return value of strlen being unsigned. */
13265 if (TREE_CODE (arg0) == CALL_EXPR
13266 && integer_zerop (arg1))
13268 tree fndecl = get_callee_fndecl (arg0);
13270 if (fndecl
13271 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
13272 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
13273 && call_expr_nargs (arg0) == 1
13274 && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
13276 tree iref = build_fold_indirect_ref_loc (loc,
13277 CALL_EXPR_ARG (arg0, 0));
13278 return fold_build2_loc (loc, code, type, iref,
13279 build_int_cst (TREE_TYPE (iref), 0));
13283 /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
13284 of X. Similarly fold (X >> C) == 0 into X >= 0. */
13285 if (TREE_CODE (arg0) == RSHIFT_EXPR
13286 && integer_zerop (arg1)
13287 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
13289 tree arg00 = TREE_OPERAND (arg0, 0);
13290 tree arg01 = TREE_OPERAND (arg0, 1);
13291 tree itype = TREE_TYPE (arg00);
13292 if (TREE_INT_CST_HIGH (arg01) == 0
13293 && TREE_INT_CST_LOW (arg01)
13294 == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
13296 if (TYPE_UNSIGNED (itype))
13298 itype = signed_type_for (itype);
13299 arg00 = fold_convert_loc (loc, itype, arg00);
13301 return fold_build2_loc (loc, code == EQ_EXPR ? GE_EXPR : LT_EXPR,
13302 type, arg00, build_zero_cst (itype));
13306 /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y. */
13307 if (integer_zerop (arg1)
13308 && TREE_CODE (arg0) == BIT_XOR_EXPR)
13309 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
13310 TREE_OPERAND (arg0, 1));
13312 /* (X ^ Y) == Y becomes X == 0. We know that Y has no side-effects. */
13313 if (TREE_CODE (arg0) == BIT_XOR_EXPR
13314 && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
13315 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
13316 build_zero_cst (TREE_TYPE (arg0)));
13317 /* Likewise (X ^ Y) == X becomes Y == 0. X has no side-effects. */
13318 if (TREE_CODE (arg0) == BIT_XOR_EXPR
13319 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
13320 && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
13321 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 1),
13322 build_zero_cst (TREE_TYPE (arg0)));
13324 /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2). */
13325 if (TREE_CODE (arg0) == BIT_XOR_EXPR
13326 && TREE_CODE (arg1) == INTEGER_CST
13327 && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
13328 return fold_build2_loc (loc, code, type, TREE_OPERAND (arg0, 0),
13329 fold_build2_loc (loc, BIT_XOR_EXPR, TREE_TYPE (arg1),
13330 TREE_OPERAND (arg0, 1), arg1));
13332 /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
13333 (X & C) == 0 when C is a single bit. */
13334 if (TREE_CODE (arg0) == BIT_AND_EXPR
13335 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
13336 && integer_zerop (arg1)
13337 && integer_pow2p (TREE_OPERAND (arg0, 1)))
13339 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0),
13340 TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
13341 TREE_OPERAND (arg0, 1));
13342 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
13343 type, tem,
13344 fold_convert_loc (loc, TREE_TYPE (arg0),
13345 arg1));
13348 /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
13349 constant C is a power of two, i.e. a single bit. */
13350 if (TREE_CODE (arg0) == BIT_XOR_EXPR
13351 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
13352 && integer_zerop (arg1)
13353 && integer_pow2p (TREE_OPERAND (arg0, 1))
13354 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13355 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
13357 tree arg00 = TREE_OPERAND (arg0, 0);
13358 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
13359 arg00, build_int_cst (TREE_TYPE (arg00), 0));
13362 /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
13363 when is C is a power of two, i.e. a single bit. */
13364 if (TREE_CODE (arg0) == BIT_AND_EXPR
13365 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
13366 && integer_zerop (arg1)
13367 && integer_pow2p (TREE_OPERAND (arg0, 1))
13368 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13369 TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
13371 tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
13372 tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg000),
13373 arg000, TREE_OPERAND (arg0, 1));
13374 return fold_build2_loc (loc, code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
13375 tem, build_int_cst (TREE_TYPE (tem), 0));
13378 if (integer_zerop (arg1)
13379 && tree_expr_nonzero_p (arg0))
13381 tree res = constant_boolean_node (code==NE_EXPR, type);
13382 return omit_one_operand_loc (loc, type, res, arg0);
13385 /* Fold -X op -Y as X op Y, where op is eq/ne. */
13386 if (TREE_CODE (arg0) == NEGATE_EXPR
13387 && TREE_CODE (arg1) == NEGATE_EXPR)
13388 return fold_build2_loc (loc, code, type,
13389 TREE_OPERAND (arg0, 0),
13390 fold_convert_loc (loc, TREE_TYPE (arg0),
13391 TREE_OPERAND (arg1, 0)));
13393 /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries. */
13394 if (TREE_CODE (arg0) == BIT_AND_EXPR
13395 && TREE_CODE (arg1) == BIT_AND_EXPR)
13397 tree arg00 = TREE_OPERAND (arg0, 0);
13398 tree arg01 = TREE_OPERAND (arg0, 1);
13399 tree arg10 = TREE_OPERAND (arg1, 0);
13400 tree arg11 = TREE_OPERAND (arg1, 1);
13401 tree itype = TREE_TYPE (arg0);
13403 if (operand_equal_p (arg01, arg11, 0))
13404 return fold_build2_loc (loc, code, type,
13405 fold_build2_loc (loc, BIT_AND_EXPR, itype,
13406 fold_build2_loc (loc,
13407 BIT_XOR_EXPR, itype,
13408 arg00, arg10),
13409 arg01),
13410 build_zero_cst (itype));
13412 if (operand_equal_p (arg01, arg10, 0))
13413 return fold_build2_loc (loc, code, type,
13414 fold_build2_loc (loc, BIT_AND_EXPR, itype,
13415 fold_build2_loc (loc,
13416 BIT_XOR_EXPR, itype,
13417 arg00, arg11),
13418 arg01),
13419 build_zero_cst (itype));
13421 if (operand_equal_p (arg00, arg11, 0))
13422 return fold_build2_loc (loc, code, type,
13423 fold_build2_loc (loc, BIT_AND_EXPR, itype,
13424 fold_build2_loc (loc,
13425 BIT_XOR_EXPR, itype,
13426 arg01, arg10),
13427 arg00),
13428 build_zero_cst (itype));
13430 if (operand_equal_p (arg00, arg10, 0))
13431 return fold_build2_loc (loc, code, type,
13432 fold_build2_loc (loc, BIT_AND_EXPR, itype,
13433 fold_build2_loc (loc,
13434 BIT_XOR_EXPR, itype,
13435 arg01, arg11),
13436 arg00),
13437 build_zero_cst (itype));
13440 if (TREE_CODE (arg0) == BIT_XOR_EXPR
13441 && TREE_CODE (arg1) == BIT_XOR_EXPR)
13443 tree arg00 = TREE_OPERAND (arg0, 0);
13444 tree arg01 = TREE_OPERAND (arg0, 1);
13445 tree arg10 = TREE_OPERAND (arg1, 0);
13446 tree arg11 = TREE_OPERAND (arg1, 1);
13447 tree itype = TREE_TYPE (arg0);
13449 /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
13450 operand_equal_p guarantees no side-effects so we don't need
13451 to use omit_one_operand on Z. */
13452 if (operand_equal_p (arg01, arg11, 0))
13453 return fold_build2_loc (loc, code, type, arg00,
13454 fold_convert_loc (loc, TREE_TYPE (arg00),
13455 arg10));
13456 if (operand_equal_p (arg01, arg10, 0))
13457 return fold_build2_loc (loc, code, type, arg00,
13458 fold_convert_loc (loc, TREE_TYPE (arg00),
13459 arg11));
13460 if (operand_equal_p (arg00, arg11, 0))
13461 return fold_build2_loc (loc, code, type, arg01,
13462 fold_convert_loc (loc, TREE_TYPE (arg01),
13463 arg10));
13464 if (operand_equal_p (arg00, arg10, 0))
13465 return fold_build2_loc (loc, code, type, arg01,
13466 fold_convert_loc (loc, TREE_TYPE (arg01),
13467 arg11));
13469 /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y. */
13470 if (TREE_CODE (arg01) == INTEGER_CST
13471 && TREE_CODE (arg11) == INTEGER_CST)
13473 tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg01,
13474 fold_convert_loc (loc, itype, arg11));
13475 tem = fold_build2_loc (loc, BIT_XOR_EXPR, itype, arg00, tem);
13476 return fold_build2_loc (loc, code, type, tem,
13477 fold_convert_loc (loc, itype, arg10));
13481 /* Attempt to simplify equality/inequality comparisons of complex
13482 values. Only lower the comparison if the result is known or
13483 can be simplified to a single scalar comparison. */
13484 if ((TREE_CODE (arg0) == COMPLEX_EXPR
13485 || TREE_CODE (arg0) == COMPLEX_CST)
13486 && (TREE_CODE (arg1) == COMPLEX_EXPR
13487 || TREE_CODE (arg1) == COMPLEX_CST))
13489 tree real0, imag0, real1, imag1;
13490 tree rcond, icond;
13492 if (TREE_CODE (arg0) == COMPLEX_EXPR)
13494 real0 = TREE_OPERAND (arg0, 0);
13495 imag0 = TREE_OPERAND (arg0, 1);
13497 else
13499 real0 = TREE_REALPART (arg0);
13500 imag0 = TREE_IMAGPART (arg0);
13503 if (TREE_CODE (arg1) == COMPLEX_EXPR)
13505 real1 = TREE_OPERAND (arg1, 0);
13506 imag1 = TREE_OPERAND (arg1, 1);
13508 else
13510 real1 = TREE_REALPART (arg1);
13511 imag1 = TREE_IMAGPART (arg1);
13514 rcond = fold_binary_loc (loc, code, type, real0, real1);
13515 if (rcond && TREE_CODE (rcond) == INTEGER_CST)
13517 if (integer_zerop (rcond))
13519 if (code == EQ_EXPR)
13520 return omit_two_operands_loc (loc, type, boolean_false_node,
13521 imag0, imag1);
13522 return fold_build2_loc (loc, NE_EXPR, type, imag0, imag1);
13524 else
13526 if (code == NE_EXPR)
13527 return omit_two_operands_loc (loc, type, boolean_true_node,
13528 imag0, imag1);
13529 return fold_build2_loc (loc, EQ_EXPR, type, imag0, imag1);
13533 icond = fold_binary_loc (loc, code, type, imag0, imag1);
13534 if (icond && TREE_CODE (icond) == INTEGER_CST)
13536 if (integer_zerop (icond))
13538 if (code == EQ_EXPR)
13539 return omit_two_operands_loc (loc, type, boolean_false_node,
13540 real0, real1);
13541 return fold_build2_loc (loc, NE_EXPR, type, real0, real1);
13543 else
13545 if (code == NE_EXPR)
13546 return omit_two_operands_loc (loc, type, boolean_true_node,
13547 real0, real1);
13548 return fold_build2_loc (loc, EQ_EXPR, type, real0, real1);
13553 return NULL_TREE;
13555 case LT_EXPR:
13556 case GT_EXPR:
13557 case LE_EXPR:
13558 case GE_EXPR:
13559 tem = fold_comparison (loc, code, type, op0, op1);
13560 if (tem != NULL_TREE)
13561 return tem;
13563 /* Transform comparisons of the form X +- C CMP X. */
13564 if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
13565 && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
13566 && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
13567 && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
13568 || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
13569 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
13571 tree arg01 = TREE_OPERAND (arg0, 1);
13572 enum tree_code code0 = TREE_CODE (arg0);
13573 int is_positive;
13575 if (TREE_CODE (arg01) == REAL_CST)
13576 is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
13577 else
13578 is_positive = tree_int_cst_sgn (arg01);
13580 /* (X - c) > X becomes false. */
13581 if (code == GT_EXPR
13582 && ((code0 == MINUS_EXPR && is_positive >= 0)
13583 || (code0 == PLUS_EXPR && is_positive <= 0)))
13585 if (TREE_CODE (arg01) == INTEGER_CST
13586 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13587 fold_overflow_warning (("assuming signed overflow does not "
13588 "occur when assuming that (X - c) > X "
13589 "is always false"),
13590 WARN_STRICT_OVERFLOW_ALL);
13591 return constant_boolean_node (0, type);
13594 /* Likewise (X + c) < X becomes false. */
13595 if (code == LT_EXPR
13596 && ((code0 == PLUS_EXPR && is_positive >= 0)
13597 || (code0 == MINUS_EXPR && is_positive <= 0)))
13599 if (TREE_CODE (arg01) == INTEGER_CST
13600 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13601 fold_overflow_warning (("assuming signed overflow does not "
13602 "occur when assuming that "
13603 "(X + c) < X is always false"),
13604 WARN_STRICT_OVERFLOW_ALL);
13605 return constant_boolean_node (0, type);
13608 /* Convert (X - c) <= X to true. */
13609 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
13610 && code == LE_EXPR
13611 && ((code0 == MINUS_EXPR && is_positive >= 0)
13612 || (code0 == PLUS_EXPR && is_positive <= 0)))
13614 if (TREE_CODE (arg01) == INTEGER_CST
13615 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13616 fold_overflow_warning (("assuming signed overflow does not "
13617 "occur when assuming that "
13618 "(X - c) <= X is always true"),
13619 WARN_STRICT_OVERFLOW_ALL);
13620 return constant_boolean_node (1, type);
13623 /* Convert (X + c) >= X to true. */
13624 if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
13625 && code == GE_EXPR
13626 && ((code0 == PLUS_EXPR && is_positive >= 0)
13627 || (code0 == MINUS_EXPR && is_positive <= 0)))
13629 if (TREE_CODE (arg01) == INTEGER_CST
13630 && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13631 fold_overflow_warning (("assuming signed overflow does not "
13632 "occur when assuming that "
13633 "(X + c) >= X is always true"),
13634 WARN_STRICT_OVERFLOW_ALL);
13635 return constant_boolean_node (1, type);
13638 if (TREE_CODE (arg01) == INTEGER_CST)
13640 /* Convert X + c > X and X - c < X to true for integers. */
13641 if (code == GT_EXPR
13642 && ((code0 == PLUS_EXPR && is_positive > 0)
13643 || (code0 == MINUS_EXPR && is_positive < 0)))
13645 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13646 fold_overflow_warning (("assuming signed overflow does "
13647 "not occur when assuming that "
13648 "(X + c) > X is always true"),
13649 WARN_STRICT_OVERFLOW_ALL);
13650 return constant_boolean_node (1, type);
13653 if (code == LT_EXPR
13654 && ((code0 == MINUS_EXPR && is_positive > 0)
13655 || (code0 == PLUS_EXPR && is_positive < 0)))
13657 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13658 fold_overflow_warning (("assuming signed overflow does "
13659 "not occur when assuming that "
13660 "(X - c) < X is always true"),
13661 WARN_STRICT_OVERFLOW_ALL);
13662 return constant_boolean_node (1, type);
13665 /* Convert X + c <= X and X - c >= X to false for integers. */
13666 if (code == LE_EXPR
13667 && ((code0 == PLUS_EXPR && is_positive > 0)
13668 || (code0 == MINUS_EXPR && is_positive < 0)))
13670 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13671 fold_overflow_warning (("assuming signed overflow does "
13672 "not occur when assuming that "
13673 "(X + c) <= X is always false"),
13674 WARN_STRICT_OVERFLOW_ALL);
13675 return constant_boolean_node (0, type);
13678 if (code == GE_EXPR
13679 && ((code0 == MINUS_EXPR && is_positive > 0)
13680 || (code0 == PLUS_EXPR && is_positive < 0)))
13682 if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
13683 fold_overflow_warning (("assuming signed overflow does "
13684 "not occur when assuming that "
13685 "(X - c) >= X is always false"),
13686 WARN_STRICT_OVERFLOW_ALL);
13687 return constant_boolean_node (0, type);
13692 /* Comparisons with the highest or lowest possible integer of
13693 the specified precision will have known values. */
13695 tree arg1_type = TREE_TYPE (arg1);
13696 unsigned int width = TYPE_PRECISION (arg1_type);
13698 if (TREE_CODE (arg1) == INTEGER_CST
13699 && width <= HOST_BITS_PER_DOUBLE_INT
13700 && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
13702 HOST_WIDE_INT signed_max_hi;
13703 unsigned HOST_WIDE_INT signed_max_lo;
13704 unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
13706 if (width <= HOST_BITS_PER_WIDE_INT)
13708 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
13709 - 1;
13710 signed_max_hi = 0;
13711 max_hi = 0;
13713 if (TYPE_UNSIGNED (arg1_type))
13715 max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
13716 min_lo = 0;
13717 min_hi = 0;
13719 else
13721 max_lo = signed_max_lo;
13722 min_lo = (HOST_WIDE_INT_M1U << (width - 1));
13723 min_hi = -1;
13726 else
13728 width -= HOST_BITS_PER_WIDE_INT;
13729 signed_max_lo = -1;
13730 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
13731 - 1;
13732 max_lo = -1;
13733 min_lo = 0;
13735 if (TYPE_UNSIGNED (arg1_type))
13737 max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
13738 min_hi = 0;
13740 else
13742 max_hi = signed_max_hi;
13743 min_hi = (HOST_WIDE_INT_M1U << (width - 1));
13747 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
13748 && TREE_INT_CST_LOW (arg1) == max_lo)
13749 switch (code)
13751 case GT_EXPR:
13752 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13754 case GE_EXPR:
13755 return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
13757 case LE_EXPR:
13758 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13760 case LT_EXPR:
13761 return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
13763 /* The GE_EXPR and LT_EXPR cases above are not normally
13764 reached because of previous transformations. */
13766 default:
13767 break;
13769 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13770 == max_hi
13771 && TREE_INT_CST_LOW (arg1) == max_lo - 1)
13772 switch (code)
13774 case GT_EXPR:
13775 arg1 = const_binop (PLUS_EXPR, arg1,
13776 build_int_cst (TREE_TYPE (arg1), 1));
13777 return fold_build2_loc (loc, EQ_EXPR, type,
13778 fold_convert_loc (loc,
13779 TREE_TYPE (arg1), arg0),
13780 arg1);
13781 case LE_EXPR:
13782 arg1 = const_binop (PLUS_EXPR, arg1,
13783 build_int_cst (TREE_TYPE (arg1), 1));
13784 return fold_build2_loc (loc, NE_EXPR, type,
13785 fold_convert_loc (loc, TREE_TYPE (arg1),
13786 arg0),
13787 arg1);
13788 default:
13789 break;
13791 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13792 == min_hi
13793 && TREE_INT_CST_LOW (arg1) == min_lo)
13794 switch (code)
13796 case LT_EXPR:
13797 return omit_one_operand_loc (loc, type, integer_zero_node, arg0);
13799 case LE_EXPR:
13800 return fold_build2_loc (loc, EQ_EXPR, type, op0, op1);
13802 case GE_EXPR:
13803 return omit_one_operand_loc (loc, type, integer_one_node, arg0);
13805 case GT_EXPR:
13806 return fold_build2_loc (loc, NE_EXPR, type, op0, op1);
13808 default:
13809 break;
13811 else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
13812 == min_hi
13813 && TREE_INT_CST_LOW (arg1) == min_lo + 1)
13814 switch (code)
13816 case GE_EXPR:
13817 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
13818 return fold_build2_loc (loc, NE_EXPR, type,
13819 fold_convert_loc (loc,
13820 TREE_TYPE (arg1), arg0),
13821 arg1);
13822 case LT_EXPR:
13823 arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node);
13824 return fold_build2_loc (loc, EQ_EXPR, type,
13825 fold_convert_loc (loc, TREE_TYPE (arg1),
13826 arg0),
13827 arg1);
13828 default:
13829 break;
13832 else if (TREE_INT_CST_HIGH (arg1) == signed_max_hi
13833 && TREE_INT_CST_LOW (arg1) == signed_max_lo
13834 && TYPE_UNSIGNED (arg1_type)
13835 /* We will flip the signedness of the comparison operator
13836 associated with the mode of arg1, so the sign bit is
13837 specified by this mode. Check that arg1 is the signed
13838 max associated with this sign bit. */
13839 && width == GET_MODE_PRECISION (TYPE_MODE (arg1_type))
13840 /* signed_type does not work on pointer types. */
13841 && INTEGRAL_TYPE_P (arg1_type))
13843 /* The following case also applies to X < signed_max+1
13844 and X >= signed_max+1 because previous transformations. */
13845 if (code == LE_EXPR || code == GT_EXPR)
13847 tree st = signed_type_for (arg1_type);
13848 return fold_build2_loc (loc,
13849 code == LE_EXPR ? GE_EXPR : LT_EXPR,
13850 type, fold_convert_loc (loc, st, arg0),
13851 build_int_cst (st, 0));
13857 /* If we are comparing an ABS_EXPR with a constant, we can
13858 convert all the cases into explicit comparisons, but they may
13859 well not be faster than doing the ABS and one comparison.
13860 But ABS (X) <= C is a range comparison, which becomes a subtraction
13861 and a comparison, and is probably faster. */
13862 if (code == LE_EXPR
13863 && TREE_CODE (arg1) == INTEGER_CST
13864 && TREE_CODE (arg0) == ABS_EXPR
13865 && ! TREE_SIDE_EFFECTS (arg0)
13866 && (0 != (tem = negate_expr (arg1)))
13867 && TREE_CODE (tem) == INTEGER_CST
13868 && !TREE_OVERFLOW (tem))
13869 return fold_build2_loc (loc, TRUTH_ANDIF_EXPR, type,
13870 build2 (GE_EXPR, type,
13871 TREE_OPERAND (arg0, 0), tem),
13872 build2 (LE_EXPR, type,
13873 TREE_OPERAND (arg0, 0), arg1));
13875 /* Convert ABS_EXPR<x> >= 0 to true. */
13876 strict_overflow_p = false;
13877 if (code == GE_EXPR
13878 && (integer_zerop (arg1)
13879 || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
13880 && real_zerop (arg1)))
13881 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13883 if (strict_overflow_p)
13884 fold_overflow_warning (("assuming signed overflow does not occur "
13885 "when simplifying comparison of "
13886 "absolute value and zero"),
13887 WARN_STRICT_OVERFLOW_CONDITIONAL);
13888 return omit_one_operand_loc (loc, type,
13889 constant_boolean_node (true, type),
13890 arg0);
13893 /* Convert ABS_EXPR<x> < 0 to false. */
13894 strict_overflow_p = false;
13895 if (code == LT_EXPR
13896 && (integer_zerop (arg1) || real_zerop (arg1))
13897 && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
13899 if (strict_overflow_p)
13900 fold_overflow_warning (("assuming signed overflow does not occur "
13901 "when simplifying comparison of "
13902 "absolute value and zero"),
13903 WARN_STRICT_OVERFLOW_CONDITIONAL);
13904 return omit_one_operand_loc (loc, type,
13905 constant_boolean_node (false, type),
13906 arg0);
13909 /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
13910 and similarly for >= into !=. */
13911 if ((code == LT_EXPR || code == GE_EXPR)
13912 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13913 && TREE_CODE (arg1) == LSHIFT_EXPR
13914 && integer_onep (TREE_OPERAND (arg1, 0)))
13915 return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13916 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13917 TREE_OPERAND (arg1, 1)),
13918 build_zero_cst (TREE_TYPE (arg0)));
13920 /* Similarly for X < (cast) (1 << Y). But cast can't be narrowing,
13921 otherwise Y might be >= # of bits in X's type and thus e.g.
13922 (unsigned char) (1 << Y) for Y 15 might be 0.
13923 If the cast is widening, then 1 << Y should have unsigned type,
13924 otherwise if Y is number of bits in the signed shift type minus 1,
13925 we can't optimize this. E.g. (unsigned long long) (1 << Y) for Y
13926 31 might be 0xffffffff80000000. */
13927 if ((code == LT_EXPR || code == GE_EXPR)
13928 && TYPE_UNSIGNED (TREE_TYPE (arg0))
13929 && CONVERT_EXPR_P (arg1)
13930 && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
13931 && (TYPE_PRECISION (TREE_TYPE (arg1))
13932 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0))))
13933 && (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0)))
13934 || (TYPE_PRECISION (TREE_TYPE (arg1))
13935 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)))))
13936 && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
13938 tem = build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
13939 TREE_OPERAND (TREE_OPERAND (arg1, 0), 1));
13940 return build2_loc (loc, code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
13941 fold_convert_loc (loc, TREE_TYPE (arg0), tem),
13942 build_zero_cst (TREE_TYPE (arg0)));
13945 return NULL_TREE;
13947 case UNORDERED_EXPR:
13948 case ORDERED_EXPR:
13949 case UNLT_EXPR:
13950 case UNLE_EXPR:
13951 case UNGT_EXPR:
13952 case UNGE_EXPR:
13953 case UNEQ_EXPR:
13954 case LTGT_EXPR:
13955 if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
13957 t1 = fold_relational_const (code, type, arg0, arg1);
13958 if (t1 != NULL_TREE)
13959 return t1;
13962 /* If the first operand is NaN, the result is constant. */
13963 if (TREE_CODE (arg0) == REAL_CST
13964 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
13965 && (code != LTGT_EXPR || ! flag_trapping_math))
13967 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13968 ? integer_zero_node
13969 : integer_one_node;
13970 return omit_one_operand_loc (loc, type, t1, arg1);
13973 /* If the second operand is NaN, the result is constant. */
13974 if (TREE_CODE (arg1) == REAL_CST
13975 && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
13976 && (code != LTGT_EXPR || ! flag_trapping_math))
13978 t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
13979 ? integer_zero_node
13980 : integer_one_node;
13981 return omit_one_operand_loc (loc, type, t1, arg0);
13984 /* Simplify unordered comparison of something with itself. */
13985 if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
13986 && operand_equal_p (arg0, arg1, 0))
13987 return constant_boolean_node (1, type);
13989 if (code == LTGT_EXPR
13990 && !flag_trapping_math
13991 && operand_equal_p (arg0, arg1, 0))
13992 return constant_boolean_node (0, type);
13994 /* Fold (double)float1 CMP (double)float2 into float1 CMP float2. */
13996 tree targ0 = strip_float_extensions (arg0);
13997 tree targ1 = strip_float_extensions (arg1);
13998 tree newtype = TREE_TYPE (targ0);
14000 if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
14001 newtype = TREE_TYPE (targ1);
14003 if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
14004 return fold_build2_loc (loc, code, type,
14005 fold_convert_loc (loc, newtype, targ0),
14006 fold_convert_loc (loc, newtype, targ1));
14009 return NULL_TREE;
14011 case COMPOUND_EXPR:
14012 /* When pedantic, a compound expression can be neither an lvalue
14013 nor an integer constant expression. */
14014 if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
14015 return NULL_TREE;
14016 /* Don't let (0, 0) be null pointer constant. */
14017 tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
14018 : fold_convert_loc (loc, type, arg1);
14019 return pedantic_non_lvalue_loc (loc, tem);
14021 case COMPLEX_EXPR:
14022 if ((TREE_CODE (arg0) == REAL_CST
14023 && TREE_CODE (arg1) == REAL_CST)
14024 || (TREE_CODE (arg0) == INTEGER_CST
14025 && TREE_CODE (arg1) == INTEGER_CST))
14026 return build_complex (type, arg0, arg1);
14027 if (TREE_CODE (arg0) == REALPART_EXPR
14028 && TREE_CODE (arg1) == IMAGPART_EXPR
14029 && TREE_TYPE (TREE_OPERAND (arg0, 0)) == type
14030 && operand_equal_p (TREE_OPERAND (arg0, 0),
14031 TREE_OPERAND (arg1, 0), 0))
14032 return omit_one_operand_loc (loc, type, TREE_OPERAND (arg0, 0),
14033 TREE_OPERAND (arg1, 0));
14034 return NULL_TREE;
14036 case ASSERT_EXPR:
14037 /* An ASSERT_EXPR should never be passed to fold_binary. */
14038 gcc_unreachable ();
14040 case VEC_PACK_TRUNC_EXPR:
14041 case VEC_PACK_FIX_TRUNC_EXPR:
14043 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
14044 tree *elts;
14046 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts / 2
14047 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts / 2);
14048 if (TREE_CODE (arg0) != VECTOR_CST || TREE_CODE (arg1) != VECTOR_CST)
14049 return NULL_TREE;
14051 elts = XALLOCAVEC (tree, nelts);
14052 if (!vec_cst_ctor_to_array (arg0, elts)
14053 || !vec_cst_ctor_to_array (arg1, elts + nelts / 2))
14054 return NULL_TREE;
14056 for (i = 0; i < nelts; i++)
14058 elts[i] = fold_convert_const (code == VEC_PACK_TRUNC_EXPR
14059 ? NOP_EXPR : FIX_TRUNC_EXPR,
14060 TREE_TYPE (type), elts[i]);
14061 if (elts[i] == NULL_TREE || !CONSTANT_CLASS_P (elts[i]))
14062 return NULL_TREE;
14065 return build_vector (type, elts);
14068 case VEC_WIDEN_MULT_LO_EXPR:
14069 case VEC_WIDEN_MULT_HI_EXPR:
14070 case VEC_WIDEN_MULT_EVEN_EXPR:
14071 case VEC_WIDEN_MULT_ODD_EXPR:
14073 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type);
14074 unsigned int out, ofs, scale;
14075 tree *elts;
14077 gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)) == nelts * 2
14078 && TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg1)) == nelts * 2);
14079 if (TREE_CODE (arg0) != VECTOR_CST || TREE_CODE (arg1) != VECTOR_CST)
14080 return NULL_TREE;
14082 elts = XALLOCAVEC (tree, nelts * 4);
14083 if (!vec_cst_ctor_to_array (arg0, elts)
14084 || !vec_cst_ctor_to_array (arg1, elts + nelts * 2))
14085 return NULL_TREE;
14087 if (code == VEC_WIDEN_MULT_LO_EXPR)
14088 scale = 0, ofs = BYTES_BIG_ENDIAN ? nelts : 0;
14089 else if (code == VEC_WIDEN_MULT_HI_EXPR)
14090 scale = 0, ofs = BYTES_BIG_ENDIAN ? 0 : nelts;
14091 else if (code == VEC_WIDEN_MULT_EVEN_EXPR)
14092 scale = 1, ofs = 0;
14093 else /* if (code == VEC_WIDEN_MULT_ODD_EXPR) */
14094 scale = 1, ofs = 1;
14096 for (out = 0; out < nelts; out++)
14098 unsigned int in1 = (out << scale) + ofs;
14099 unsigned int in2 = in1 + nelts * 2;
14100 tree t1, t2;
14102 t1 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in1]);
14103 t2 = fold_convert_const (NOP_EXPR, TREE_TYPE (type), elts[in2]);
14105 if (t1 == NULL_TREE || t2 == NULL_TREE)
14106 return NULL_TREE;
14107 elts[out] = const_binop (MULT_EXPR, t1, t2);
14108 if (elts[out] == NULL_TREE || !CONSTANT_CLASS_P (elts[out]))
14109 return NULL_TREE;
14112 return build_vector (type, elts);
14115 default:
14116 return NULL_TREE;
14117 } /* switch (code) */
14120 /* Callback for walk_tree, looking for LABEL_EXPR. Return *TP if it is
14121 a LABEL_EXPR; otherwise return NULL_TREE. Do not check the subtrees
14122 of GOTO_EXPR. */
14124 static tree
14125 contains_label_1 (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
14127 switch (TREE_CODE (*tp))
14129 case LABEL_EXPR:
14130 return *tp;
14132 case GOTO_EXPR:
14133 *walk_subtrees = 0;
14135 /* ... fall through ... */
14137 default:
14138 return NULL_TREE;
14142 /* Return whether the sub-tree ST contains a label which is accessible from
14143 outside the sub-tree. */
14145 static bool
14146 contains_label_p (tree st)
14148 return
14149 (walk_tree_without_duplicates (&st, contains_label_1 , NULL) != NULL_TREE);
14152 /* Fold a ternary expression of code CODE and type TYPE with operands
14153 OP0, OP1, and OP2. Return the folded expression if folding is
14154 successful. Otherwise, return NULL_TREE. */
14156 tree
14157 fold_ternary_loc (location_t loc, enum tree_code code, tree type,
14158 tree op0, tree op1, tree op2)
14160 tree tem;
14161 tree arg0 = NULL_TREE, arg1 = NULL_TREE, arg2 = NULL_TREE;
14162 enum tree_code_class kind = TREE_CODE_CLASS (code);
14164 gcc_assert (IS_EXPR_CODE_CLASS (kind)
14165 && TREE_CODE_LENGTH (code) == 3);
14167 /* Strip any conversions that don't change the mode. This is safe
14168 for every expression, except for a comparison expression because
14169 its signedness is derived from its operands. So, in the latter
14170 case, only strip conversions that don't change the signedness.
14172 Note that this is done as an internal manipulation within the
14173 constant folder, in order to find the simplest representation of
14174 the arguments so that their form can be studied. In any cases,
14175 the appropriate type conversions should be put back in the tree
14176 that will get out of the constant folder. */
14177 if (op0)
14179 arg0 = op0;
14180 STRIP_NOPS (arg0);
14183 if (op1)
14185 arg1 = op1;
14186 STRIP_NOPS (arg1);
14189 if (op2)
14191 arg2 = op2;
14192 STRIP_NOPS (arg2);
14195 switch (code)
14197 case COMPONENT_REF:
14198 if (TREE_CODE (arg0) == CONSTRUCTOR
14199 && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
14201 unsigned HOST_WIDE_INT idx;
14202 tree field, value;
14203 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
14204 if (field == arg1)
14205 return value;
14207 return NULL_TREE;
14209 case COND_EXPR:
14210 case VEC_COND_EXPR:
14211 /* Pedantic ANSI C says that a conditional expression is never an lvalue,
14212 so all simple results must be passed through pedantic_non_lvalue. */
14213 if (TREE_CODE (arg0) == INTEGER_CST)
14215 tree unused_op = integer_zerop (arg0) ? op1 : op2;
14216 tem = integer_zerop (arg0) ? op2 : op1;
14217 /* Only optimize constant conditions when the selected branch
14218 has the same type as the COND_EXPR. This avoids optimizing
14219 away "c ? x : throw", where the throw has a void type.
14220 Avoid throwing away that operand which contains label. */
14221 if ((!TREE_SIDE_EFFECTS (unused_op)
14222 || !contains_label_p (unused_op))
14223 && (! VOID_TYPE_P (TREE_TYPE (tem))
14224 || VOID_TYPE_P (type)))
14225 return pedantic_non_lvalue_loc (loc, tem);
14226 return NULL_TREE;
14228 else if (TREE_CODE (arg0) == VECTOR_CST)
14230 if (integer_all_onesp (arg0))
14231 return pedantic_omit_one_operand_loc (loc, type, arg1, arg2);
14232 if (integer_zerop (arg0))
14233 return pedantic_omit_one_operand_loc (loc, type, arg2, arg1);
14235 if ((TREE_CODE (arg1) == VECTOR_CST
14236 || TREE_CODE (arg1) == CONSTRUCTOR)
14237 && (TREE_CODE (arg2) == VECTOR_CST
14238 || TREE_CODE (arg2) == CONSTRUCTOR))
14240 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i;
14241 unsigned char *sel = XALLOCAVEC (unsigned char, nelts);
14242 gcc_assert (nelts == VECTOR_CST_NELTS (arg0));
14243 for (i = 0; i < nelts; i++)
14245 tree val = VECTOR_CST_ELT (arg0, i);
14246 if (integer_all_onesp (val))
14247 sel[i] = i;
14248 else if (integer_zerop (val))
14249 sel[i] = nelts + i;
14250 else /* Currently unreachable. */
14251 return NULL_TREE;
14253 tree t = fold_vec_perm (type, arg1, arg2, sel);
14254 if (t != NULL_TREE)
14255 return t;
14259 if (operand_equal_p (arg1, op2, 0))
14260 return pedantic_omit_one_operand_loc (loc, type, arg1, arg0);
14262 /* If we have A op B ? A : C, we may be able to convert this to a
14263 simpler expression, depending on the operation and the values
14264 of B and C. Signed zeros prevent all of these transformations,
14265 for reasons given above each one.
14267 Also try swapping the arguments and inverting the conditional. */
14268 if (COMPARISON_CLASS_P (arg0)
14269 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
14270 arg1, TREE_OPERAND (arg0, 1))
14271 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
14273 tem = fold_cond_expr_with_comparison (loc, type, arg0, op1, op2);
14274 if (tem)
14275 return tem;
14278 if (COMPARISON_CLASS_P (arg0)
14279 && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
14280 op2,
14281 TREE_OPERAND (arg0, 1))
14282 && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
14284 location_t loc0 = expr_location_or (arg0, loc);
14285 tem = fold_invert_truthvalue (loc0, arg0);
14286 if (tem && COMPARISON_CLASS_P (tem))
14288 tem = fold_cond_expr_with_comparison (loc, type, tem, op2, op1);
14289 if (tem)
14290 return tem;
14294 /* If the second operand is simpler than the third, swap them
14295 since that produces better jump optimization results. */
14296 if (truth_value_p (TREE_CODE (arg0))
14297 && tree_swap_operands_p (op1, op2, false))
14299 location_t loc0 = expr_location_or (arg0, loc);
14300 /* See if this can be inverted. If it can't, possibly because
14301 it was a floating-point inequality comparison, don't do
14302 anything. */
14303 tem = fold_invert_truthvalue (loc0, arg0);
14304 if (tem)
14305 return fold_build3_loc (loc, code, type, tem, op2, op1);
14308 /* Convert A ? 1 : 0 to simply A. */
14309 if ((code == VEC_COND_EXPR ? integer_all_onesp (op1)
14310 : (integer_onep (op1)
14311 && !VECTOR_TYPE_P (type)))
14312 && integer_zerop (op2)
14313 /* If we try to convert OP0 to our type, the
14314 call to fold will try to move the conversion inside
14315 a COND, which will recurse. In that case, the COND_EXPR
14316 is probably the best choice, so leave it alone. */
14317 && type == TREE_TYPE (arg0))
14318 return pedantic_non_lvalue_loc (loc, arg0);
14320 /* Convert A ? 0 : 1 to !A. This prefers the use of NOT_EXPR
14321 over COND_EXPR in cases such as floating point comparisons. */
14322 if (integer_zerop (op1)
14323 && (code == VEC_COND_EXPR ? integer_all_onesp (op2)
14324 : (integer_onep (op2)
14325 && !VECTOR_TYPE_P (type)))
14326 && truth_value_p (TREE_CODE (arg0)))
14327 return pedantic_non_lvalue_loc (loc,
14328 fold_convert_loc (loc, type,
14329 invert_truthvalue_loc (loc,
14330 arg0)));
14332 /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>). */
14333 if (TREE_CODE (arg0) == LT_EXPR
14334 && integer_zerop (TREE_OPERAND (arg0, 1))
14335 && integer_zerop (op2)
14336 && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
14338 /* sign_bit_p looks through both zero and sign extensions,
14339 but for this optimization only sign extensions are
14340 usable. */
14341 tree tem2 = TREE_OPERAND (arg0, 0);
14342 while (tem != tem2)
14344 if (TREE_CODE (tem2) != NOP_EXPR
14345 || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (tem2, 0))))
14347 tem = NULL_TREE;
14348 break;
14350 tem2 = TREE_OPERAND (tem2, 0);
14352 /* sign_bit_p only checks ARG1 bits within A's precision.
14353 If <sign bit of A> has wider type than A, bits outside
14354 of A's precision in <sign bit of A> need to be checked.
14355 If they are all 0, this optimization needs to be done
14356 in unsigned A's type, if they are all 1 in signed A's type,
14357 otherwise this can't be done. */
14358 if (tem
14359 && TYPE_PRECISION (TREE_TYPE (tem))
14360 < TYPE_PRECISION (TREE_TYPE (arg1))
14361 && TYPE_PRECISION (TREE_TYPE (tem))
14362 < TYPE_PRECISION (type))
14364 unsigned HOST_WIDE_INT mask_lo;
14365 HOST_WIDE_INT mask_hi;
14366 int inner_width, outer_width;
14367 tree tem_type;
14369 inner_width = TYPE_PRECISION (TREE_TYPE (tem));
14370 outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
14371 if (outer_width > TYPE_PRECISION (type))
14372 outer_width = TYPE_PRECISION (type);
14374 if (outer_width > HOST_BITS_PER_WIDE_INT)
14376 mask_hi = (HOST_WIDE_INT_M1U
14377 >> (HOST_BITS_PER_DOUBLE_INT - outer_width));
14378 mask_lo = -1;
14380 else
14382 mask_hi = 0;
14383 mask_lo = (HOST_WIDE_INT_M1U
14384 >> (HOST_BITS_PER_WIDE_INT - outer_width));
14386 if (inner_width > HOST_BITS_PER_WIDE_INT)
14388 mask_hi &= ~(HOST_WIDE_INT_M1U
14389 >> (HOST_BITS_PER_WIDE_INT - inner_width));
14390 mask_lo = 0;
14392 else
14393 mask_lo &= ~(HOST_WIDE_INT_M1U
14394 >> (HOST_BITS_PER_WIDE_INT - inner_width));
14396 if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == mask_hi
14397 && (TREE_INT_CST_LOW (arg1) & mask_lo) == mask_lo)
14399 tem_type = signed_type_for (TREE_TYPE (tem));
14400 tem = fold_convert_loc (loc, tem_type, tem);
14402 else if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == 0
14403 && (TREE_INT_CST_LOW (arg1) & mask_lo) == 0)
14405 tem_type = unsigned_type_for (TREE_TYPE (tem));
14406 tem = fold_convert_loc (loc, tem_type, tem);
14408 else
14409 tem = NULL;
14412 if (tem)
14413 return
14414 fold_convert_loc (loc, type,
14415 fold_build2_loc (loc, BIT_AND_EXPR,
14416 TREE_TYPE (tem), tem,
14417 fold_convert_loc (loc,
14418 TREE_TYPE (tem),
14419 arg1)));
14422 /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N). A & 1 was
14423 already handled above. */
14424 if (TREE_CODE (arg0) == BIT_AND_EXPR
14425 && integer_onep (TREE_OPERAND (arg0, 1))
14426 && integer_zerop (op2)
14427 && integer_pow2p (arg1))
14429 tree tem = TREE_OPERAND (arg0, 0);
14430 STRIP_NOPS (tem);
14431 if (TREE_CODE (tem) == RSHIFT_EXPR
14432 && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
14433 && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
14434 TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
14435 return fold_build2_loc (loc, BIT_AND_EXPR, type,
14436 TREE_OPERAND (tem, 0), arg1);
14439 /* A & N ? N : 0 is simply A & N if N is a power of two. This
14440 is probably obsolete because the first operand should be a
14441 truth value (that's why we have the two cases above), but let's
14442 leave it in until we can confirm this for all front-ends. */
14443 if (integer_zerop (op2)
14444 && TREE_CODE (arg0) == NE_EXPR
14445 && integer_zerop (TREE_OPERAND (arg0, 1))
14446 && integer_pow2p (arg1)
14447 && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
14448 && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
14449 arg1, OEP_ONLY_CONST))
14450 return pedantic_non_lvalue_loc (loc,
14451 fold_convert_loc (loc, type,
14452 TREE_OPERAND (arg0, 0)));
14454 /* Disable the transformations below for vectors, since
14455 fold_binary_op_with_conditional_arg may undo them immediately,
14456 yielding an infinite loop. */
14457 if (code == VEC_COND_EXPR)
14458 return NULL_TREE;
14460 /* Convert A ? B : 0 into A && B if A and B are truth values. */
14461 if (integer_zerop (op2)
14462 && truth_value_p (TREE_CODE (arg0))
14463 && truth_value_p (TREE_CODE (arg1))
14464 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
14465 return fold_build2_loc (loc, code == VEC_COND_EXPR ? BIT_AND_EXPR
14466 : TRUTH_ANDIF_EXPR,
14467 type, fold_convert_loc (loc, type, arg0), arg1);
14469 /* Convert A ? B : 1 into !A || B if A and B are truth values. */
14470 if (code == VEC_COND_EXPR ? integer_all_onesp (op2) : integer_onep (op2)
14471 && truth_value_p (TREE_CODE (arg0))
14472 && truth_value_p (TREE_CODE (arg1))
14473 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
14475 location_t loc0 = expr_location_or (arg0, loc);
14476 /* Only perform transformation if ARG0 is easily inverted. */
14477 tem = fold_invert_truthvalue (loc0, arg0);
14478 if (tem)
14479 return fold_build2_loc (loc, code == VEC_COND_EXPR
14480 ? BIT_IOR_EXPR
14481 : TRUTH_ORIF_EXPR,
14482 type, fold_convert_loc (loc, type, tem),
14483 arg1);
14486 /* Convert A ? 0 : B into !A && B if A and B are truth values. */
14487 if (integer_zerop (arg1)
14488 && truth_value_p (TREE_CODE (arg0))
14489 && truth_value_p (TREE_CODE (op2))
14490 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
14492 location_t loc0 = expr_location_or (arg0, loc);
14493 /* Only perform transformation if ARG0 is easily inverted. */
14494 tem = fold_invert_truthvalue (loc0, arg0);
14495 if (tem)
14496 return fold_build2_loc (loc, code == VEC_COND_EXPR
14497 ? BIT_AND_EXPR : TRUTH_ANDIF_EXPR,
14498 type, fold_convert_loc (loc, type, tem),
14499 op2);
14502 /* Convert A ? 1 : B into A || B if A and B are truth values. */
14503 if (code == VEC_COND_EXPR ? integer_all_onesp (arg1) : integer_onep (arg1)
14504 && truth_value_p (TREE_CODE (arg0))
14505 && truth_value_p (TREE_CODE (op2))
14506 && (code == VEC_COND_EXPR || !VECTOR_TYPE_P (type)))
14507 return fold_build2_loc (loc, code == VEC_COND_EXPR
14508 ? BIT_IOR_EXPR : TRUTH_ORIF_EXPR,
14509 type, fold_convert_loc (loc, type, arg0), op2);
14511 return NULL_TREE;
14513 case CALL_EXPR:
14514 /* CALL_EXPRs used to be ternary exprs. Catch any mistaken uses
14515 of fold_ternary on them. */
14516 gcc_unreachable ();
14518 case BIT_FIELD_REF:
14519 if ((TREE_CODE (arg0) == VECTOR_CST
14520 || (TREE_CODE (arg0) == CONSTRUCTOR
14521 && TREE_CODE (TREE_TYPE (arg0)) == VECTOR_TYPE))
14522 && (type == TREE_TYPE (TREE_TYPE (arg0))
14523 || (TREE_CODE (type) == VECTOR_TYPE
14524 && TREE_TYPE (type) == TREE_TYPE (TREE_TYPE (arg0)))))
14526 tree eltype = TREE_TYPE (TREE_TYPE (arg0));
14527 unsigned HOST_WIDE_INT width = tree_to_uhwi (TYPE_SIZE (eltype));
14528 unsigned HOST_WIDE_INT n = tree_to_uhwi (arg1);
14529 unsigned HOST_WIDE_INT idx = tree_to_uhwi (op2);
14531 if (n != 0
14532 && (idx % width) == 0
14533 && (n % width) == 0
14534 && ((idx + n) / width) <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
14536 idx = idx / width;
14537 n = n / width;
14539 if (TREE_CODE (arg0) == VECTOR_CST)
14541 if (n == 1)
14542 return VECTOR_CST_ELT (arg0, idx);
14544 tree *vals = XALLOCAVEC (tree, n);
14545 for (unsigned i = 0; i < n; ++i)
14546 vals[i] = VECTOR_CST_ELT (arg0, idx + i);
14547 return build_vector (type, vals);
14550 /* Constructor elements can be subvectors. */
14551 unsigned HOST_WIDE_INT k = 1;
14552 if (CONSTRUCTOR_NELTS (arg0) != 0)
14554 tree cons_elem = TREE_TYPE (CONSTRUCTOR_ELT (arg0, 0)->value);
14555 if (TREE_CODE (cons_elem) == VECTOR_TYPE)
14556 k = TYPE_VECTOR_SUBPARTS (cons_elem);
14559 /* We keep an exact subset of the constructor elements. */
14560 if ((idx % k) == 0 && (n % k) == 0)
14562 if (CONSTRUCTOR_NELTS (arg0) == 0)
14563 return build_constructor (type, NULL);
14564 idx /= k;
14565 n /= k;
14566 if (n == 1)
14568 if (idx < CONSTRUCTOR_NELTS (arg0))
14569 return CONSTRUCTOR_ELT (arg0, idx)->value;
14570 return build_zero_cst (type);
14573 vec<constructor_elt, va_gc> *vals;
14574 vec_alloc (vals, n);
14575 for (unsigned i = 0;
14576 i < n && idx + i < CONSTRUCTOR_NELTS (arg0);
14577 ++i)
14578 CONSTRUCTOR_APPEND_ELT (vals, NULL_TREE,
14579 CONSTRUCTOR_ELT
14580 (arg0, idx + i)->value);
14581 return build_constructor (type, vals);
14583 /* The bitfield references a single constructor element. */
14584 else if (idx + n <= (idx / k + 1) * k)
14586 if (CONSTRUCTOR_NELTS (arg0) <= idx / k)
14587 return build_zero_cst (type);
14588 else if (n == k)
14589 return CONSTRUCTOR_ELT (arg0, idx / k)->value;
14590 else
14591 return fold_build3_loc (loc, code, type,
14592 CONSTRUCTOR_ELT (arg0, idx / k)->value, op1,
14593 build_int_cst (TREE_TYPE (op2), (idx % k) * width));
14598 /* A bit-field-ref that referenced the full argument can be stripped. */
14599 if (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
14600 && TYPE_PRECISION (TREE_TYPE (arg0)) == tree_to_uhwi (arg1)
14601 && integer_zerop (op2))
14602 return fold_convert_loc (loc, type, arg0);
14604 /* On constants we can use native encode/interpret to constant
14605 fold (nearly) all BIT_FIELD_REFs. */
14606 if (CONSTANT_CLASS_P (arg0)
14607 && can_native_interpret_type_p (type)
14608 && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (arg0)))
14609 /* This limitation should not be necessary, we just need to
14610 round this up to mode size. */
14611 && tree_to_uhwi (op1) % BITS_PER_UNIT == 0
14612 /* Need bit-shifting of the buffer to relax the following. */
14613 && tree_to_uhwi (op2) % BITS_PER_UNIT == 0)
14615 unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (op2);
14616 unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (op1);
14617 unsigned HOST_WIDE_INT clen;
14618 clen = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (arg0)));
14619 /* ??? We cannot tell native_encode_expr to start at
14620 some random byte only. So limit us to a reasonable amount
14621 of work. */
14622 if (clen <= 4096)
14624 unsigned char *b = XALLOCAVEC (unsigned char, clen);
14625 unsigned HOST_WIDE_INT len = native_encode_expr (arg0, b, clen);
14626 if (len > 0
14627 && len * BITS_PER_UNIT >= bitpos + bitsize)
14629 tree v = native_interpret_expr (type,
14630 b + bitpos / BITS_PER_UNIT,
14631 bitsize / BITS_PER_UNIT);
14632 if (v)
14633 return v;
14638 return NULL_TREE;
14640 case FMA_EXPR:
14641 /* For integers we can decompose the FMA if possible. */
14642 if (TREE_CODE (arg0) == INTEGER_CST
14643 && TREE_CODE (arg1) == INTEGER_CST)
14644 return fold_build2_loc (loc, PLUS_EXPR, type,
14645 const_binop (MULT_EXPR, arg0, arg1), arg2);
14646 if (integer_zerop (arg2))
14647 return fold_build2_loc (loc, MULT_EXPR, type, arg0, arg1);
14649 return fold_fma (loc, type, arg0, arg1, arg2);
14651 case VEC_PERM_EXPR:
14652 if (TREE_CODE (arg2) == VECTOR_CST)
14654 unsigned int nelts = TYPE_VECTOR_SUBPARTS (type), i, mask;
14655 unsigned char *sel = XALLOCAVEC (unsigned char, nelts);
14656 tree t;
14657 bool need_mask_canon = false;
14658 bool all_in_vec0 = true;
14659 bool all_in_vec1 = true;
14660 bool maybe_identity = true;
14661 bool single_arg = (op0 == op1);
14662 bool changed = false;
14664 mask = single_arg ? (nelts - 1) : (2 * nelts - 1);
14665 gcc_assert (nelts == VECTOR_CST_NELTS (arg2));
14666 for (i = 0; i < nelts; i++)
14668 tree val = VECTOR_CST_ELT (arg2, i);
14669 if (TREE_CODE (val) != INTEGER_CST)
14670 return NULL_TREE;
14672 sel[i] = TREE_INT_CST_LOW (val) & mask;
14673 if (TREE_INT_CST_HIGH (val)
14674 || ((unsigned HOST_WIDE_INT)
14675 TREE_INT_CST_LOW (val) != sel[i]))
14676 need_mask_canon = true;
14678 if (sel[i] < nelts)
14679 all_in_vec1 = false;
14680 else
14681 all_in_vec0 = false;
14683 if ((sel[i] & (nelts-1)) != i)
14684 maybe_identity = false;
14687 if (maybe_identity)
14689 if (all_in_vec0)
14690 return op0;
14691 if (all_in_vec1)
14692 return op1;
14695 if (all_in_vec0)
14696 op1 = op0;
14697 else if (all_in_vec1)
14699 op0 = op1;
14700 for (i = 0; i < nelts; i++)
14701 sel[i] -= nelts;
14702 need_mask_canon = true;
14705 if ((TREE_CODE (op0) == VECTOR_CST
14706 || TREE_CODE (op0) == CONSTRUCTOR)
14707 && (TREE_CODE (op1) == VECTOR_CST
14708 || TREE_CODE (op1) == CONSTRUCTOR))
14710 t = fold_vec_perm (type, op0, op1, sel);
14711 if (t != NULL_TREE)
14712 return t;
14715 if (op0 == op1 && !single_arg)
14716 changed = true;
14718 if (need_mask_canon && arg2 == op2)
14720 tree *tsel = XALLOCAVEC (tree, nelts);
14721 tree eltype = TREE_TYPE (TREE_TYPE (arg2));
14722 for (i = 0; i < nelts; i++)
14723 tsel[i] = build_int_cst (eltype, sel[i]);
14724 op2 = build_vector (TREE_TYPE (arg2), tsel);
14725 changed = true;
14728 if (changed)
14729 return build3_loc (loc, VEC_PERM_EXPR, type, op0, op1, op2);
14731 return NULL_TREE;
14733 default:
14734 return NULL_TREE;
14735 } /* switch (code) */
14738 /* Perform constant folding and related simplification of EXPR.
14739 The related simplifications include x*1 => x, x*0 => 0, etc.,
14740 and application of the associative law.
14741 NOP_EXPR conversions may be removed freely (as long as we
14742 are careful not to change the type of the overall expression).
14743 We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
14744 but we can constant-fold them if they have constant operands. */
14746 #ifdef ENABLE_FOLD_CHECKING
14747 # define fold(x) fold_1 (x)
14748 static tree fold_1 (tree);
14749 static
14750 #endif
14751 tree
14752 fold (tree expr)
14754 const tree t = expr;
14755 enum tree_code code = TREE_CODE (t);
14756 enum tree_code_class kind = TREE_CODE_CLASS (code);
14757 tree tem;
14758 location_t loc = EXPR_LOCATION (expr);
14760 /* Return right away if a constant. */
14761 if (kind == tcc_constant)
14762 return t;
14764 /* CALL_EXPR-like objects with variable numbers of operands are
14765 treated specially. */
14766 if (kind == tcc_vl_exp)
14768 if (code == CALL_EXPR)
14770 tem = fold_call_expr (loc, expr, false);
14771 return tem ? tem : expr;
14773 return expr;
14776 if (IS_EXPR_CODE_CLASS (kind))
14778 tree type = TREE_TYPE (t);
14779 tree op0, op1, op2;
14781 switch (TREE_CODE_LENGTH (code))
14783 case 1:
14784 op0 = TREE_OPERAND (t, 0);
14785 tem = fold_unary_loc (loc, code, type, op0);
14786 return tem ? tem : expr;
14787 case 2:
14788 op0 = TREE_OPERAND (t, 0);
14789 op1 = TREE_OPERAND (t, 1);
14790 tem = fold_binary_loc (loc, code, type, op0, op1);
14791 return tem ? tem : expr;
14792 case 3:
14793 op0 = TREE_OPERAND (t, 0);
14794 op1 = TREE_OPERAND (t, 1);
14795 op2 = TREE_OPERAND (t, 2);
14796 tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
14797 return tem ? tem : expr;
14798 default:
14799 break;
14803 switch (code)
14805 case ARRAY_REF:
14807 tree op0 = TREE_OPERAND (t, 0);
14808 tree op1 = TREE_OPERAND (t, 1);
14810 if (TREE_CODE (op1) == INTEGER_CST
14811 && TREE_CODE (op0) == CONSTRUCTOR
14812 && ! type_contains_placeholder_p (TREE_TYPE (op0)))
14814 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (op0);
14815 unsigned HOST_WIDE_INT end = vec_safe_length (elts);
14816 unsigned HOST_WIDE_INT begin = 0;
14818 /* Find a matching index by means of a binary search. */
14819 while (begin != end)
14821 unsigned HOST_WIDE_INT middle = (begin + end) / 2;
14822 tree index = (*elts)[middle].index;
14824 if (TREE_CODE (index) == INTEGER_CST
14825 && tree_int_cst_lt (index, op1))
14826 begin = middle + 1;
14827 else if (TREE_CODE (index) == INTEGER_CST
14828 && tree_int_cst_lt (op1, index))
14829 end = middle;
14830 else if (TREE_CODE (index) == RANGE_EXPR
14831 && tree_int_cst_lt (TREE_OPERAND (index, 1), op1))
14832 begin = middle + 1;
14833 else if (TREE_CODE (index) == RANGE_EXPR
14834 && tree_int_cst_lt (op1, TREE_OPERAND (index, 0)))
14835 end = middle;
14836 else
14837 return (*elts)[middle].value;
14841 return t;
14844 /* Return a VECTOR_CST if possible. */
14845 case CONSTRUCTOR:
14847 tree type = TREE_TYPE (t);
14848 if (TREE_CODE (type) != VECTOR_TYPE)
14849 return t;
14851 tree *vec = XALLOCAVEC (tree, TYPE_VECTOR_SUBPARTS (type));
14852 unsigned HOST_WIDE_INT idx, pos = 0;
14853 tree value;
14855 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), idx, value)
14857 if (!CONSTANT_CLASS_P (value))
14858 return t;
14859 if (TREE_CODE (value) == VECTOR_CST)
14861 for (unsigned i = 0; i < VECTOR_CST_NELTS (value); ++i)
14862 vec[pos++] = VECTOR_CST_ELT (value, i);
14864 else
14865 vec[pos++] = value;
14867 for (; pos < TYPE_VECTOR_SUBPARTS (type); ++pos)
14868 vec[pos] = build_zero_cst (TREE_TYPE (type));
14870 return build_vector (type, vec);
14873 case CONST_DECL:
14874 return fold (DECL_INITIAL (t));
14876 default:
14877 return t;
14878 } /* switch (code) */
14881 #ifdef ENABLE_FOLD_CHECKING
14882 #undef fold
14884 static void fold_checksum_tree (const_tree, struct md5_ctx *,
14885 hash_table <pointer_hash <tree_node> >);
14886 static void fold_check_failed (const_tree, const_tree);
14887 void print_fold_checksum (const_tree);
14889 /* When --enable-checking=fold, compute a digest of expr before
14890 and after actual fold call to see if fold did not accidentally
14891 change original expr. */
14893 tree
14894 fold (tree expr)
14896 tree ret;
14897 struct md5_ctx ctx;
14898 unsigned char checksum_before[16], checksum_after[16];
14899 hash_table <pointer_hash <tree_node> > ht;
14901 ht.create (32);
14902 md5_init_ctx (&ctx);
14903 fold_checksum_tree (expr, &ctx, ht);
14904 md5_finish_ctx (&ctx, checksum_before);
14905 ht.empty ();
14907 ret = fold_1 (expr);
14909 md5_init_ctx (&ctx);
14910 fold_checksum_tree (expr, &ctx, ht);
14911 md5_finish_ctx (&ctx, checksum_after);
14912 ht.dispose ();
14914 if (memcmp (checksum_before, checksum_after, 16))
14915 fold_check_failed (expr, ret);
14917 return ret;
14920 void
14921 print_fold_checksum (const_tree expr)
14923 struct md5_ctx ctx;
14924 unsigned char checksum[16], cnt;
14925 hash_table <pointer_hash <tree_node> > ht;
14927 ht.create (32);
14928 md5_init_ctx (&ctx);
14929 fold_checksum_tree (expr, &ctx, ht);
14930 md5_finish_ctx (&ctx, checksum);
14931 ht.dispose ();
14932 for (cnt = 0; cnt < 16; ++cnt)
14933 fprintf (stderr, "%02x", checksum[cnt]);
14934 putc ('\n', stderr);
14937 static void
14938 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
14940 internal_error ("fold check: original tree changed by fold");
14943 static void
14944 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx,
14945 hash_table <pointer_hash <tree_node> > ht)
14947 tree_node **slot;
14948 enum tree_code code;
14949 union tree_node buf;
14950 int i, len;
14952 recursive_label:
14953 if (expr == NULL)
14954 return;
14955 slot = ht.find_slot (expr, INSERT);
14956 if (*slot != NULL)
14957 return;
14958 *slot = CONST_CAST_TREE (expr);
14959 code = TREE_CODE (expr);
14960 if (TREE_CODE_CLASS (code) == tcc_declaration
14961 && DECL_ASSEMBLER_NAME_SET_P (expr))
14963 /* Allow DECL_ASSEMBLER_NAME to be modified. */
14964 memcpy ((char *) &buf, expr, tree_size (expr));
14965 SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
14966 expr = (tree) &buf;
14968 else if (TREE_CODE_CLASS (code) == tcc_type
14969 && (TYPE_POINTER_TO (expr)
14970 || TYPE_REFERENCE_TO (expr)
14971 || TYPE_CACHED_VALUES_P (expr)
14972 || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
14973 || TYPE_NEXT_VARIANT (expr)))
14975 /* Allow these fields to be modified. */
14976 tree tmp;
14977 memcpy ((char *) &buf, expr, tree_size (expr));
14978 expr = tmp = (tree) &buf;
14979 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
14980 TYPE_POINTER_TO (tmp) = NULL;
14981 TYPE_REFERENCE_TO (tmp) = NULL;
14982 TYPE_NEXT_VARIANT (tmp) = NULL;
14983 if (TYPE_CACHED_VALUES_P (tmp))
14985 TYPE_CACHED_VALUES_P (tmp) = 0;
14986 TYPE_CACHED_VALUES (tmp) = NULL;
14989 md5_process_bytes (expr, tree_size (expr), ctx);
14990 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
14991 fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
14992 if (TREE_CODE_CLASS (code) != tcc_type
14993 && TREE_CODE_CLASS (code) != tcc_declaration
14994 && code != TREE_LIST
14995 && code != SSA_NAME
14996 && CODE_CONTAINS_STRUCT (code, TS_COMMON))
14997 fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
14998 switch (TREE_CODE_CLASS (code))
15000 case tcc_constant:
15001 switch (code)
15003 case STRING_CST:
15004 md5_process_bytes (TREE_STRING_POINTER (expr),
15005 TREE_STRING_LENGTH (expr), ctx);
15006 break;
15007 case COMPLEX_CST:
15008 fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
15009 fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
15010 break;
15011 case VECTOR_CST:
15012 for (i = 0; i < (int) VECTOR_CST_NELTS (expr); ++i)
15013 fold_checksum_tree (VECTOR_CST_ELT (expr, i), ctx, ht);
15014 break;
15015 default:
15016 break;
15018 break;
15019 case tcc_exceptional:
15020 switch (code)
15022 case TREE_LIST:
15023 fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
15024 fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
15025 expr = TREE_CHAIN (expr);
15026 goto recursive_label;
15027 break;
15028 case TREE_VEC:
15029 for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
15030 fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
15031 break;
15032 default:
15033 break;
15035 break;
15036 case tcc_expression:
15037 case tcc_reference:
15038 case tcc_comparison:
15039 case tcc_unary:
15040 case tcc_binary:
15041 case tcc_statement:
15042 case tcc_vl_exp:
15043 len = TREE_OPERAND_LENGTH (expr);
15044 for (i = 0; i < len; ++i)
15045 fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
15046 break;
15047 case tcc_declaration:
15048 fold_checksum_tree (DECL_NAME (expr), ctx, ht);
15049 fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
15050 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
15052 fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
15053 fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
15054 fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
15055 fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
15056 fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
15058 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
15059 fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
15061 if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
15063 fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
15064 fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
15065 fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
15067 break;
15068 case tcc_type:
15069 if (TREE_CODE (expr) == ENUMERAL_TYPE)
15070 fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
15071 fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
15072 fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
15073 fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
15074 fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
15075 if (INTEGRAL_TYPE_P (expr)
15076 || SCALAR_FLOAT_TYPE_P (expr))
15078 fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
15079 fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
15081 fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
15082 if (TREE_CODE (expr) == RECORD_TYPE
15083 || TREE_CODE (expr) == UNION_TYPE
15084 || TREE_CODE (expr) == QUAL_UNION_TYPE)
15085 fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
15086 fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
15087 break;
15088 default:
15089 break;
15093 /* Helper function for outputting the checksum of a tree T. When
15094 debugging with gdb, you can "define mynext" to be "next" followed
15095 by "call debug_fold_checksum (op0)", then just trace down till the
15096 outputs differ. */
15098 DEBUG_FUNCTION void
15099 debug_fold_checksum (const_tree t)
15101 int i;
15102 unsigned char checksum[16];
15103 struct md5_ctx ctx;
15104 hash_table <pointer_hash <tree_node> > ht;
15105 ht.create (32);
15107 md5_init_ctx (&ctx);
15108 fold_checksum_tree (t, &ctx, ht);
15109 md5_finish_ctx (&ctx, checksum);
15110 ht.empty ();
15112 for (i = 0; i < 16; i++)
15113 fprintf (stderr, "%d ", checksum[i]);
15115 fprintf (stderr, "\n");
15118 #endif
15120 /* Fold a unary tree expression with code CODE of type TYPE with an
15121 operand OP0. LOC is the location of the resulting expression.
15122 Return a folded expression if successful. Otherwise, return a tree
15123 expression with code CODE of type TYPE with an operand OP0. */
15125 tree
15126 fold_build1_stat_loc (location_t loc,
15127 enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
15129 tree tem;
15130 #ifdef ENABLE_FOLD_CHECKING
15131 unsigned char checksum_before[16], checksum_after[16];
15132 struct md5_ctx ctx;
15133 hash_table <pointer_hash <tree_node> > ht;
15135 ht.create (32);
15136 md5_init_ctx (&ctx);
15137 fold_checksum_tree (op0, &ctx, ht);
15138 md5_finish_ctx (&ctx, checksum_before);
15139 ht.empty ();
15140 #endif
15142 tem = fold_unary_loc (loc, code, type, op0);
15143 if (!tem)
15144 tem = build1_stat_loc (loc, code, type, op0 PASS_MEM_STAT);
15146 #ifdef ENABLE_FOLD_CHECKING
15147 md5_init_ctx (&ctx);
15148 fold_checksum_tree (op0, &ctx, ht);
15149 md5_finish_ctx (&ctx, checksum_after);
15150 ht.dispose ();
15152 if (memcmp (checksum_before, checksum_after, 16))
15153 fold_check_failed (op0, tem);
15154 #endif
15155 return tem;
15158 /* Fold a binary tree expression with code CODE of type TYPE with
15159 operands OP0 and OP1. LOC is the location of the resulting
15160 expression. Return a folded expression if successful. Otherwise,
15161 return a tree expression with code CODE of type TYPE with operands
15162 OP0 and OP1. */
15164 tree
15165 fold_build2_stat_loc (location_t loc,
15166 enum tree_code code, tree type, tree op0, tree op1
15167 MEM_STAT_DECL)
15169 tree tem;
15170 #ifdef ENABLE_FOLD_CHECKING
15171 unsigned char checksum_before_op0[16],
15172 checksum_before_op1[16],
15173 checksum_after_op0[16],
15174 checksum_after_op1[16];
15175 struct md5_ctx ctx;
15176 hash_table <pointer_hash <tree_node> > ht;
15178 ht.create (32);
15179 md5_init_ctx (&ctx);
15180 fold_checksum_tree (op0, &ctx, ht);
15181 md5_finish_ctx (&ctx, checksum_before_op0);
15182 ht.empty ();
15184 md5_init_ctx (&ctx);
15185 fold_checksum_tree (op1, &ctx, ht);
15186 md5_finish_ctx (&ctx, checksum_before_op1);
15187 ht.empty ();
15188 #endif
15190 tem = fold_binary_loc (loc, code, type, op0, op1);
15191 if (!tem)
15192 tem = build2_stat_loc (loc, code, type, op0, op1 PASS_MEM_STAT);
15194 #ifdef ENABLE_FOLD_CHECKING
15195 md5_init_ctx (&ctx);
15196 fold_checksum_tree (op0, &ctx, ht);
15197 md5_finish_ctx (&ctx, checksum_after_op0);
15198 ht.empty ();
15200 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
15201 fold_check_failed (op0, tem);
15203 md5_init_ctx (&ctx);
15204 fold_checksum_tree (op1, &ctx, ht);
15205 md5_finish_ctx (&ctx, checksum_after_op1);
15206 ht.dispose ();
15208 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
15209 fold_check_failed (op1, tem);
15210 #endif
15211 return tem;
15214 /* Fold a ternary tree expression with code CODE of type TYPE with
15215 operands OP0, OP1, and OP2. Return a folded expression if
15216 successful. Otherwise, return a tree expression with code CODE of
15217 type TYPE with operands OP0, OP1, and OP2. */
15219 tree
15220 fold_build3_stat_loc (location_t loc, enum tree_code code, tree type,
15221 tree op0, tree op1, tree op2 MEM_STAT_DECL)
15223 tree tem;
15224 #ifdef ENABLE_FOLD_CHECKING
15225 unsigned char checksum_before_op0[16],
15226 checksum_before_op1[16],
15227 checksum_before_op2[16],
15228 checksum_after_op0[16],
15229 checksum_after_op1[16],
15230 checksum_after_op2[16];
15231 struct md5_ctx ctx;
15232 hash_table <pointer_hash <tree_node> > ht;
15234 ht.create (32);
15235 md5_init_ctx (&ctx);
15236 fold_checksum_tree (op0, &ctx, ht);
15237 md5_finish_ctx (&ctx, checksum_before_op0);
15238 ht.empty ();
15240 md5_init_ctx (&ctx);
15241 fold_checksum_tree (op1, &ctx, ht);
15242 md5_finish_ctx (&ctx, checksum_before_op1);
15243 ht.empty ();
15245 md5_init_ctx (&ctx);
15246 fold_checksum_tree (op2, &ctx, ht);
15247 md5_finish_ctx (&ctx, checksum_before_op2);
15248 ht.empty ();
15249 #endif
15251 gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
15252 tem = fold_ternary_loc (loc, code, type, op0, op1, op2);
15253 if (!tem)
15254 tem = build3_stat_loc (loc, code, type, op0, op1, op2 PASS_MEM_STAT);
15256 #ifdef ENABLE_FOLD_CHECKING
15257 md5_init_ctx (&ctx);
15258 fold_checksum_tree (op0, &ctx, ht);
15259 md5_finish_ctx (&ctx, checksum_after_op0);
15260 ht.empty ();
15262 if (memcmp (checksum_before_op0, checksum_after_op0, 16))
15263 fold_check_failed (op0, tem);
15265 md5_init_ctx (&ctx);
15266 fold_checksum_tree (op1, &ctx, ht);
15267 md5_finish_ctx (&ctx, checksum_after_op1);
15268 ht.empty ();
15270 if (memcmp (checksum_before_op1, checksum_after_op1, 16))
15271 fold_check_failed (op1, tem);
15273 md5_init_ctx (&ctx);
15274 fold_checksum_tree (op2, &ctx, ht);
15275 md5_finish_ctx (&ctx, checksum_after_op2);
15276 ht.dispose ();
15278 if (memcmp (checksum_before_op2, checksum_after_op2, 16))
15279 fold_check_failed (op2, tem);
15280 #endif
15281 return tem;
15284 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
15285 arguments in ARGARRAY, and a null static chain.
15286 Return a folded expression if successful. Otherwise, return a CALL_EXPR
15287 of type TYPE from the given operands as constructed by build_call_array. */
15289 tree
15290 fold_build_call_array_loc (location_t loc, tree type, tree fn,
15291 int nargs, tree *argarray)
15293 tree tem;
15294 #ifdef ENABLE_FOLD_CHECKING
15295 unsigned char checksum_before_fn[16],
15296 checksum_before_arglist[16],
15297 checksum_after_fn[16],
15298 checksum_after_arglist[16];
15299 struct md5_ctx ctx;
15300 hash_table <pointer_hash <tree_node> > ht;
15301 int i;
15303 ht.create (32);
15304 md5_init_ctx (&ctx);
15305 fold_checksum_tree (fn, &ctx, ht);
15306 md5_finish_ctx (&ctx, checksum_before_fn);
15307 ht.empty ();
15309 md5_init_ctx (&ctx);
15310 for (i = 0; i < nargs; i++)
15311 fold_checksum_tree (argarray[i], &ctx, ht);
15312 md5_finish_ctx (&ctx, checksum_before_arglist);
15313 ht.empty ();
15314 #endif
15316 tem = fold_builtin_call_array (loc, type, fn, nargs, argarray);
15318 #ifdef ENABLE_FOLD_CHECKING
15319 md5_init_ctx (&ctx);
15320 fold_checksum_tree (fn, &ctx, ht);
15321 md5_finish_ctx (&ctx, checksum_after_fn);
15322 ht.empty ();
15324 if (memcmp (checksum_before_fn, checksum_after_fn, 16))
15325 fold_check_failed (fn, tem);
15327 md5_init_ctx (&ctx);
15328 for (i = 0; i < nargs; i++)
15329 fold_checksum_tree (argarray[i], &ctx, ht);
15330 md5_finish_ctx (&ctx, checksum_after_arglist);
15331 ht.dispose ();
15333 if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
15334 fold_check_failed (NULL_TREE, tem);
15335 #endif
15336 return tem;
15339 /* Perform constant folding and related simplification of initializer
15340 expression EXPR. These behave identically to "fold_buildN" but ignore
15341 potential run-time traps and exceptions that fold must preserve. */
15343 #define START_FOLD_INIT \
15344 int saved_signaling_nans = flag_signaling_nans;\
15345 int saved_trapping_math = flag_trapping_math;\
15346 int saved_rounding_math = flag_rounding_math;\
15347 int saved_trapv = flag_trapv;\
15348 int saved_folding_initializer = folding_initializer;\
15349 flag_signaling_nans = 0;\
15350 flag_trapping_math = 0;\
15351 flag_rounding_math = 0;\
15352 flag_trapv = 0;\
15353 folding_initializer = 1;
15355 #define END_FOLD_INIT \
15356 flag_signaling_nans = saved_signaling_nans;\
15357 flag_trapping_math = saved_trapping_math;\
15358 flag_rounding_math = saved_rounding_math;\
15359 flag_trapv = saved_trapv;\
15360 folding_initializer = saved_folding_initializer;
15362 tree
15363 fold_build1_initializer_loc (location_t loc, enum tree_code code,
15364 tree type, tree op)
15366 tree result;
15367 START_FOLD_INIT;
15369 result = fold_build1_loc (loc, code, type, op);
15371 END_FOLD_INIT;
15372 return result;
15375 tree
15376 fold_build2_initializer_loc (location_t loc, enum tree_code code,
15377 tree type, tree op0, tree op1)
15379 tree result;
15380 START_FOLD_INIT;
15382 result = fold_build2_loc (loc, code, type, op0, op1);
15384 END_FOLD_INIT;
15385 return result;
15388 tree
15389 fold_build_call_array_initializer_loc (location_t loc, tree type, tree fn,
15390 int nargs, tree *argarray)
15392 tree result;
15393 START_FOLD_INIT;
15395 result = fold_build_call_array_loc (loc, type, fn, nargs, argarray);
15397 END_FOLD_INIT;
15398 return result;
15401 #undef START_FOLD_INIT
15402 #undef END_FOLD_INIT
15404 /* Determine if first argument is a multiple of second argument. Return 0 if
15405 it is not, or we cannot easily determined it to be.
15407 An example of the sort of thing we care about (at this point; this routine
15408 could surely be made more general, and expanded to do what the *_DIV_EXPR's
15409 fold cases do now) is discovering that
15411 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15413 is a multiple of
15415 SAVE_EXPR (J * 8)
15417 when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
15419 This code also handles discovering that
15421 SAVE_EXPR (I) * SAVE_EXPR (J * 8)
15423 is a multiple of 8 so we don't have to worry about dealing with a
15424 possible remainder.
15426 Note that we *look* inside a SAVE_EXPR only to determine how it was
15427 calculated; it is not safe for fold to do much of anything else with the
15428 internals of a SAVE_EXPR, since it cannot know when it will be evaluated
15429 at run time. For example, the latter example above *cannot* be implemented
15430 as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
15431 evaluation time of the original SAVE_EXPR is not necessarily the same at
15432 the time the new expression is evaluated. The only optimization of this
15433 sort that would be valid is changing
15435 SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
15437 divided by 8 to
15439 SAVE_EXPR (I) * SAVE_EXPR (J)
15441 (where the same SAVE_EXPR (J) is used in the original and the
15442 transformed version). */
15445 multiple_of_p (tree type, const_tree top, const_tree bottom)
15447 if (operand_equal_p (top, bottom, 0))
15448 return 1;
15450 if (TREE_CODE (type) != INTEGER_TYPE)
15451 return 0;
15453 switch (TREE_CODE (top))
15455 case BIT_AND_EXPR:
15456 /* Bitwise and provides a power of two multiple. If the mask is
15457 a multiple of BOTTOM then TOP is a multiple of BOTTOM. */
15458 if (!integer_pow2p (bottom))
15459 return 0;
15460 /* FALLTHRU */
15462 case MULT_EXPR:
15463 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
15464 || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
15466 case PLUS_EXPR:
15467 case MINUS_EXPR:
15468 return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
15469 && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
15471 case LSHIFT_EXPR:
15472 if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
15474 tree op1, t1;
15476 op1 = TREE_OPERAND (top, 1);
15477 /* const_binop may not detect overflow correctly,
15478 so check for it explicitly here. */
15479 if (TYPE_PRECISION (TREE_TYPE (size_one_node))
15480 > TREE_INT_CST_LOW (op1)
15481 && TREE_INT_CST_HIGH (op1) == 0
15482 && 0 != (t1 = fold_convert (type,
15483 const_binop (LSHIFT_EXPR,
15484 size_one_node,
15485 op1)))
15486 && !TREE_OVERFLOW (t1))
15487 return multiple_of_p (type, t1, bottom);
15489 return 0;
15491 case NOP_EXPR:
15492 /* Can't handle conversions from non-integral or wider integral type. */
15493 if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
15494 || (TYPE_PRECISION (type)
15495 < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
15496 return 0;
15498 /* .. fall through ... */
15500 case SAVE_EXPR:
15501 return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
15503 case COND_EXPR:
15504 return (multiple_of_p (type, TREE_OPERAND (top, 1), bottom)
15505 && multiple_of_p (type, TREE_OPERAND (top, 2), bottom));
15507 case INTEGER_CST:
15508 if (TREE_CODE (bottom) != INTEGER_CST
15509 || integer_zerop (bottom)
15510 || (TYPE_UNSIGNED (type)
15511 && (tree_int_cst_sgn (top) < 0
15512 || tree_int_cst_sgn (bottom) < 0)))
15513 return 0;
15514 return integer_zerop (int_const_binop (TRUNC_MOD_EXPR,
15515 top, bottom));
15517 default:
15518 return 0;
15522 /* Return true if CODE or TYPE is known to be non-negative. */
15524 static bool
15525 tree_simple_nonnegative_warnv_p (enum tree_code code, tree type)
15527 if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
15528 && truth_value_p (code))
15529 /* Truth values evaluate to 0 or 1, which is nonnegative unless we
15530 have a signed:1 type (where the value is -1 and 0). */
15531 return true;
15532 return false;
15535 /* Return true if (CODE OP0) is known to be non-negative. If the return
15536 value is based on the assumption that signed overflow is undefined,
15537 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15538 *STRICT_OVERFLOW_P. */
15540 bool
15541 tree_unary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
15542 bool *strict_overflow_p)
15544 if (TYPE_UNSIGNED (type))
15545 return true;
15547 switch (code)
15549 case ABS_EXPR:
15550 /* We can't return 1 if flag_wrapv is set because
15551 ABS_EXPR<INT_MIN> = INT_MIN. */
15552 if (!INTEGRAL_TYPE_P (type))
15553 return true;
15554 if (TYPE_OVERFLOW_UNDEFINED (type))
15556 *strict_overflow_p = true;
15557 return true;
15559 break;
15561 case NON_LVALUE_EXPR:
15562 case FLOAT_EXPR:
15563 case FIX_TRUNC_EXPR:
15564 return tree_expr_nonnegative_warnv_p (op0,
15565 strict_overflow_p);
15567 case NOP_EXPR:
15569 tree inner_type = TREE_TYPE (op0);
15570 tree outer_type = type;
15572 if (TREE_CODE (outer_type) == REAL_TYPE)
15574 if (TREE_CODE (inner_type) == REAL_TYPE)
15575 return tree_expr_nonnegative_warnv_p (op0,
15576 strict_overflow_p);
15577 if (INTEGRAL_TYPE_P (inner_type))
15579 if (TYPE_UNSIGNED (inner_type))
15580 return true;
15581 return tree_expr_nonnegative_warnv_p (op0,
15582 strict_overflow_p);
15585 else if (INTEGRAL_TYPE_P (outer_type))
15587 if (TREE_CODE (inner_type) == REAL_TYPE)
15588 return tree_expr_nonnegative_warnv_p (op0,
15589 strict_overflow_p);
15590 if (INTEGRAL_TYPE_P (inner_type))
15591 return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
15592 && TYPE_UNSIGNED (inner_type);
15595 break;
15597 default:
15598 return tree_simple_nonnegative_warnv_p (code, type);
15601 /* We don't know sign of `t', so be conservative and return false. */
15602 return false;
15605 /* Return true if (CODE OP0 OP1) is known to be non-negative. If the return
15606 value is based on the assumption that signed overflow is undefined,
15607 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15608 *STRICT_OVERFLOW_P. */
15610 bool
15611 tree_binary_nonnegative_warnv_p (enum tree_code code, tree type, tree op0,
15612 tree op1, bool *strict_overflow_p)
15614 if (TYPE_UNSIGNED (type))
15615 return true;
15617 switch (code)
15619 case POINTER_PLUS_EXPR:
15620 case PLUS_EXPR:
15621 if (FLOAT_TYPE_P (type))
15622 return (tree_expr_nonnegative_warnv_p (op0,
15623 strict_overflow_p)
15624 && tree_expr_nonnegative_warnv_p (op1,
15625 strict_overflow_p));
15627 /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
15628 both unsigned and at least 2 bits shorter than the result. */
15629 if (TREE_CODE (type) == INTEGER_TYPE
15630 && TREE_CODE (op0) == NOP_EXPR
15631 && TREE_CODE (op1) == NOP_EXPR)
15633 tree inner1 = TREE_TYPE (TREE_OPERAND (op0, 0));
15634 tree inner2 = TREE_TYPE (TREE_OPERAND (op1, 0));
15635 if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
15636 && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
15638 unsigned int prec = MAX (TYPE_PRECISION (inner1),
15639 TYPE_PRECISION (inner2)) + 1;
15640 return prec < TYPE_PRECISION (type);
15643 break;
15645 case MULT_EXPR:
15646 if (FLOAT_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
15648 /* x * x is always non-negative for floating point x
15649 or without overflow. */
15650 if (operand_equal_p (op0, op1, 0)
15651 || (tree_expr_nonnegative_warnv_p (op0, strict_overflow_p)
15652 && tree_expr_nonnegative_warnv_p (op1, strict_overflow_p)))
15654 if (TYPE_OVERFLOW_UNDEFINED (type))
15655 *strict_overflow_p = true;
15656 return true;
15660 /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
15661 both unsigned and their total bits is shorter than the result. */
15662 if (TREE_CODE (type) == INTEGER_TYPE
15663 && (TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == INTEGER_CST)
15664 && (TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == INTEGER_CST))
15666 tree inner0 = (TREE_CODE (op0) == NOP_EXPR)
15667 ? TREE_TYPE (TREE_OPERAND (op0, 0))
15668 : TREE_TYPE (op0);
15669 tree inner1 = (TREE_CODE (op1) == NOP_EXPR)
15670 ? TREE_TYPE (TREE_OPERAND (op1, 0))
15671 : TREE_TYPE (op1);
15673 bool unsigned0 = TYPE_UNSIGNED (inner0);
15674 bool unsigned1 = TYPE_UNSIGNED (inner1);
15676 if (TREE_CODE (op0) == INTEGER_CST)
15677 unsigned0 = unsigned0 || tree_int_cst_sgn (op0) >= 0;
15679 if (TREE_CODE (op1) == INTEGER_CST)
15680 unsigned1 = unsigned1 || tree_int_cst_sgn (op1) >= 0;
15682 if (TREE_CODE (inner0) == INTEGER_TYPE && unsigned0
15683 && TREE_CODE (inner1) == INTEGER_TYPE && unsigned1)
15685 unsigned int precision0 = (TREE_CODE (op0) == INTEGER_CST)
15686 ? tree_int_cst_min_precision (op0, /*unsignedp=*/true)
15687 : TYPE_PRECISION (inner0);
15689 unsigned int precision1 = (TREE_CODE (op1) == INTEGER_CST)
15690 ? tree_int_cst_min_precision (op1, /*unsignedp=*/true)
15691 : TYPE_PRECISION (inner1);
15693 return precision0 + precision1 < TYPE_PRECISION (type);
15696 return false;
15698 case BIT_AND_EXPR:
15699 case MAX_EXPR:
15700 return (tree_expr_nonnegative_warnv_p (op0,
15701 strict_overflow_p)
15702 || tree_expr_nonnegative_warnv_p (op1,
15703 strict_overflow_p));
15705 case BIT_IOR_EXPR:
15706 case BIT_XOR_EXPR:
15707 case MIN_EXPR:
15708 case RDIV_EXPR:
15709 case TRUNC_DIV_EXPR:
15710 case CEIL_DIV_EXPR:
15711 case FLOOR_DIV_EXPR:
15712 case ROUND_DIV_EXPR:
15713 return (tree_expr_nonnegative_warnv_p (op0,
15714 strict_overflow_p)
15715 && tree_expr_nonnegative_warnv_p (op1,
15716 strict_overflow_p));
15718 case TRUNC_MOD_EXPR:
15719 case CEIL_MOD_EXPR:
15720 case FLOOR_MOD_EXPR:
15721 case ROUND_MOD_EXPR:
15722 return tree_expr_nonnegative_warnv_p (op0,
15723 strict_overflow_p);
15724 default:
15725 return tree_simple_nonnegative_warnv_p (code, type);
15728 /* We don't know sign of `t', so be conservative and return false. */
15729 return false;
15732 /* Return true if T is known to be non-negative. If the return
15733 value is based on the assumption that signed overflow is undefined,
15734 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15735 *STRICT_OVERFLOW_P. */
15737 bool
15738 tree_single_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15740 if (TYPE_UNSIGNED (TREE_TYPE (t)))
15741 return true;
15743 switch (TREE_CODE (t))
15745 case INTEGER_CST:
15746 return tree_int_cst_sgn (t) >= 0;
15748 case REAL_CST:
15749 return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
15751 case FIXED_CST:
15752 return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
15754 case COND_EXPR:
15755 return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15756 strict_overflow_p)
15757 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
15758 strict_overflow_p));
15759 default:
15760 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
15761 TREE_TYPE (t));
15763 /* We don't know sign of `t', so be conservative and return false. */
15764 return false;
15767 /* Return true if T is known to be non-negative. If the return
15768 value is based on the assumption that signed overflow is undefined,
15769 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15770 *STRICT_OVERFLOW_P. */
15772 bool
15773 tree_call_nonnegative_warnv_p (tree type, tree fndecl,
15774 tree arg0, tree arg1, bool *strict_overflow_p)
15776 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
15777 switch (DECL_FUNCTION_CODE (fndecl))
15779 CASE_FLT_FN (BUILT_IN_ACOS):
15780 CASE_FLT_FN (BUILT_IN_ACOSH):
15781 CASE_FLT_FN (BUILT_IN_CABS):
15782 CASE_FLT_FN (BUILT_IN_COSH):
15783 CASE_FLT_FN (BUILT_IN_ERFC):
15784 CASE_FLT_FN (BUILT_IN_EXP):
15785 CASE_FLT_FN (BUILT_IN_EXP10):
15786 CASE_FLT_FN (BUILT_IN_EXP2):
15787 CASE_FLT_FN (BUILT_IN_FABS):
15788 CASE_FLT_FN (BUILT_IN_FDIM):
15789 CASE_FLT_FN (BUILT_IN_HYPOT):
15790 CASE_FLT_FN (BUILT_IN_POW10):
15791 CASE_INT_FN (BUILT_IN_FFS):
15792 CASE_INT_FN (BUILT_IN_PARITY):
15793 CASE_INT_FN (BUILT_IN_POPCOUNT):
15794 CASE_INT_FN (BUILT_IN_CLZ):
15795 CASE_INT_FN (BUILT_IN_CLRSB):
15796 case BUILT_IN_BSWAP32:
15797 case BUILT_IN_BSWAP64:
15798 /* Always true. */
15799 return true;
15801 CASE_FLT_FN (BUILT_IN_SQRT):
15802 /* sqrt(-0.0) is -0.0. */
15803 if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
15804 return true;
15805 return tree_expr_nonnegative_warnv_p (arg0,
15806 strict_overflow_p);
15808 CASE_FLT_FN (BUILT_IN_ASINH):
15809 CASE_FLT_FN (BUILT_IN_ATAN):
15810 CASE_FLT_FN (BUILT_IN_ATANH):
15811 CASE_FLT_FN (BUILT_IN_CBRT):
15812 CASE_FLT_FN (BUILT_IN_CEIL):
15813 CASE_FLT_FN (BUILT_IN_ERF):
15814 CASE_FLT_FN (BUILT_IN_EXPM1):
15815 CASE_FLT_FN (BUILT_IN_FLOOR):
15816 CASE_FLT_FN (BUILT_IN_FMOD):
15817 CASE_FLT_FN (BUILT_IN_FREXP):
15818 CASE_FLT_FN (BUILT_IN_ICEIL):
15819 CASE_FLT_FN (BUILT_IN_IFLOOR):
15820 CASE_FLT_FN (BUILT_IN_IRINT):
15821 CASE_FLT_FN (BUILT_IN_IROUND):
15822 CASE_FLT_FN (BUILT_IN_LCEIL):
15823 CASE_FLT_FN (BUILT_IN_LDEXP):
15824 CASE_FLT_FN (BUILT_IN_LFLOOR):
15825 CASE_FLT_FN (BUILT_IN_LLCEIL):
15826 CASE_FLT_FN (BUILT_IN_LLFLOOR):
15827 CASE_FLT_FN (BUILT_IN_LLRINT):
15828 CASE_FLT_FN (BUILT_IN_LLROUND):
15829 CASE_FLT_FN (BUILT_IN_LRINT):
15830 CASE_FLT_FN (BUILT_IN_LROUND):
15831 CASE_FLT_FN (BUILT_IN_MODF):
15832 CASE_FLT_FN (BUILT_IN_NEARBYINT):
15833 CASE_FLT_FN (BUILT_IN_RINT):
15834 CASE_FLT_FN (BUILT_IN_ROUND):
15835 CASE_FLT_FN (BUILT_IN_SCALB):
15836 CASE_FLT_FN (BUILT_IN_SCALBLN):
15837 CASE_FLT_FN (BUILT_IN_SCALBN):
15838 CASE_FLT_FN (BUILT_IN_SIGNBIT):
15839 CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
15840 CASE_FLT_FN (BUILT_IN_SINH):
15841 CASE_FLT_FN (BUILT_IN_TANH):
15842 CASE_FLT_FN (BUILT_IN_TRUNC):
15843 /* True if the 1st argument is nonnegative. */
15844 return tree_expr_nonnegative_warnv_p (arg0,
15845 strict_overflow_p);
15847 CASE_FLT_FN (BUILT_IN_FMAX):
15848 /* True if the 1st OR 2nd arguments are nonnegative. */
15849 return (tree_expr_nonnegative_warnv_p (arg0,
15850 strict_overflow_p)
15851 || (tree_expr_nonnegative_warnv_p (arg1,
15852 strict_overflow_p)));
15854 CASE_FLT_FN (BUILT_IN_FMIN):
15855 /* True if the 1st AND 2nd arguments are nonnegative. */
15856 return (tree_expr_nonnegative_warnv_p (arg0,
15857 strict_overflow_p)
15858 && (tree_expr_nonnegative_warnv_p (arg1,
15859 strict_overflow_p)));
15861 CASE_FLT_FN (BUILT_IN_COPYSIGN):
15862 /* True if the 2nd argument is nonnegative. */
15863 return tree_expr_nonnegative_warnv_p (arg1,
15864 strict_overflow_p);
15866 CASE_FLT_FN (BUILT_IN_POWI):
15867 /* True if the 1st argument is nonnegative or the second
15868 argument is an even integer. */
15869 if (TREE_CODE (arg1) == INTEGER_CST
15870 && (TREE_INT_CST_LOW (arg1) & 1) == 0)
15871 return true;
15872 return tree_expr_nonnegative_warnv_p (arg0,
15873 strict_overflow_p);
15875 CASE_FLT_FN (BUILT_IN_POW):
15876 /* True if the 1st argument is nonnegative or the second
15877 argument is an even integer valued real. */
15878 if (TREE_CODE (arg1) == REAL_CST)
15880 REAL_VALUE_TYPE c;
15881 HOST_WIDE_INT n;
15883 c = TREE_REAL_CST (arg1);
15884 n = real_to_integer (&c);
15885 if ((n & 1) == 0)
15887 REAL_VALUE_TYPE cint;
15888 real_from_integer (&cint, VOIDmode, n,
15889 n < 0 ? -1 : 0, 0);
15890 if (real_identical (&c, &cint))
15891 return true;
15894 return tree_expr_nonnegative_warnv_p (arg0,
15895 strict_overflow_p);
15897 default:
15898 break;
15900 return tree_simple_nonnegative_warnv_p (CALL_EXPR,
15901 type);
15904 /* Return true if T is known to be non-negative. If the return
15905 value is based on the assumption that signed overflow is undefined,
15906 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15907 *STRICT_OVERFLOW_P. */
15909 static bool
15910 tree_invalid_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15912 enum tree_code code = TREE_CODE (t);
15913 if (TYPE_UNSIGNED (TREE_TYPE (t)))
15914 return true;
15916 switch (code)
15918 case TARGET_EXPR:
15920 tree temp = TARGET_EXPR_SLOT (t);
15921 t = TARGET_EXPR_INITIAL (t);
15923 /* If the initializer is non-void, then it's a normal expression
15924 that will be assigned to the slot. */
15925 if (!VOID_TYPE_P (t))
15926 return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
15928 /* Otherwise, the initializer sets the slot in some way. One common
15929 way is an assignment statement at the end of the initializer. */
15930 while (1)
15932 if (TREE_CODE (t) == BIND_EXPR)
15933 t = expr_last (BIND_EXPR_BODY (t));
15934 else if (TREE_CODE (t) == TRY_FINALLY_EXPR
15935 || TREE_CODE (t) == TRY_CATCH_EXPR)
15936 t = expr_last (TREE_OPERAND (t, 0));
15937 else if (TREE_CODE (t) == STATEMENT_LIST)
15938 t = expr_last (t);
15939 else
15940 break;
15942 if (TREE_CODE (t) == MODIFY_EXPR
15943 && TREE_OPERAND (t, 0) == temp)
15944 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15945 strict_overflow_p);
15947 return false;
15950 case CALL_EXPR:
15952 tree arg0 = call_expr_nargs (t) > 0 ? CALL_EXPR_ARG (t, 0) : NULL_TREE;
15953 tree arg1 = call_expr_nargs (t) > 1 ? CALL_EXPR_ARG (t, 1) : NULL_TREE;
15955 return tree_call_nonnegative_warnv_p (TREE_TYPE (t),
15956 get_callee_fndecl (t),
15957 arg0,
15958 arg1,
15959 strict_overflow_p);
15961 case COMPOUND_EXPR:
15962 case MODIFY_EXPR:
15963 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
15964 strict_overflow_p);
15965 case BIND_EXPR:
15966 return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
15967 strict_overflow_p);
15968 case SAVE_EXPR:
15969 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
15970 strict_overflow_p);
15972 default:
15973 return tree_simple_nonnegative_warnv_p (TREE_CODE (t),
15974 TREE_TYPE (t));
15977 /* We don't know sign of `t', so be conservative and return false. */
15978 return false;
15981 /* Return true if T is known to be non-negative. If the return
15982 value is based on the assumption that signed overflow is undefined,
15983 set *STRICT_OVERFLOW_P to true; otherwise, don't change
15984 *STRICT_OVERFLOW_P. */
15986 bool
15987 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
15989 enum tree_code code;
15990 if (t == error_mark_node)
15991 return false;
15993 code = TREE_CODE (t);
15994 switch (TREE_CODE_CLASS (code))
15996 case tcc_binary:
15997 case tcc_comparison:
15998 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
15999 TREE_TYPE (t),
16000 TREE_OPERAND (t, 0),
16001 TREE_OPERAND (t, 1),
16002 strict_overflow_p);
16004 case tcc_unary:
16005 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
16006 TREE_TYPE (t),
16007 TREE_OPERAND (t, 0),
16008 strict_overflow_p);
16010 case tcc_constant:
16011 case tcc_declaration:
16012 case tcc_reference:
16013 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
16015 default:
16016 break;
16019 switch (code)
16021 case TRUTH_AND_EXPR:
16022 case TRUTH_OR_EXPR:
16023 case TRUTH_XOR_EXPR:
16024 return tree_binary_nonnegative_warnv_p (TREE_CODE (t),
16025 TREE_TYPE (t),
16026 TREE_OPERAND (t, 0),
16027 TREE_OPERAND (t, 1),
16028 strict_overflow_p);
16029 case TRUTH_NOT_EXPR:
16030 return tree_unary_nonnegative_warnv_p (TREE_CODE (t),
16031 TREE_TYPE (t),
16032 TREE_OPERAND (t, 0),
16033 strict_overflow_p);
16035 case COND_EXPR:
16036 case CONSTRUCTOR:
16037 case OBJ_TYPE_REF:
16038 case ASSERT_EXPR:
16039 case ADDR_EXPR:
16040 case WITH_SIZE_EXPR:
16041 case SSA_NAME:
16042 return tree_single_nonnegative_warnv_p (t, strict_overflow_p);
16044 default:
16045 return tree_invalid_nonnegative_warnv_p (t, strict_overflow_p);
16049 /* Return true if `t' is known to be non-negative. Handle warnings
16050 about undefined signed overflow. */
16052 bool
16053 tree_expr_nonnegative_p (tree t)
16055 bool ret, strict_overflow_p;
16057 strict_overflow_p = false;
16058 ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
16059 if (strict_overflow_p)
16060 fold_overflow_warning (("assuming signed overflow does not occur when "
16061 "determining that expression is always "
16062 "non-negative"),
16063 WARN_STRICT_OVERFLOW_MISC);
16064 return ret;
16068 /* Return true when (CODE OP0) is an address and is known to be nonzero.
16069 For floating point we further ensure that T is not denormal.
16070 Similar logic is present in nonzero_address in rtlanal.h.
16072 If the return value is based on the assumption that signed overflow
16073 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
16074 change *STRICT_OVERFLOW_P. */
16076 bool
16077 tree_unary_nonzero_warnv_p (enum tree_code code, tree type, tree op0,
16078 bool *strict_overflow_p)
16080 switch (code)
16082 case ABS_EXPR:
16083 return tree_expr_nonzero_warnv_p (op0,
16084 strict_overflow_p);
16086 case NOP_EXPR:
16088 tree inner_type = TREE_TYPE (op0);
16089 tree outer_type = type;
16091 return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
16092 && tree_expr_nonzero_warnv_p (op0,
16093 strict_overflow_p));
16095 break;
16097 case NON_LVALUE_EXPR:
16098 return tree_expr_nonzero_warnv_p (op0,
16099 strict_overflow_p);
16101 default:
16102 break;
16105 return false;
16108 /* Return true when (CODE OP0 OP1) is an address and is known to be nonzero.
16109 For floating point we further ensure that T is not denormal.
16110 Similar logic is present in nonzero_address in rtlanal.h.
16112 If the return value is based on the assumption that signed overflow
16113 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
16114 change *STRICT_OVERFLOW_P. */
16116 bool
16117 tree_binary_nonzero_warnv_p (enum tree_code code,
16118 tree type,
16119 tree op0,
16120 tree op1, bool *strict_overflow_p)
16122 bool sub_strict_overflow_p;
16123 switch (code)
16125 case POINTER_PLUS_EXPR:
16126 case PLUS_EXPR:
16127 if (TYPE_OVERFLOW_UNDEFINED (type))
16129 /* With the presence of negative values it is hard
16130 to say something. */
16131 sub_strict_overflow_p = false;
16132 if (!tree_expr_nonnegative_warnv_p (op0,
16133 &sub_strict_overflow_p)
16134 || !tree_expr_nonnegative_warnv_p (op1,
16135 &sub_strict_overflow_p))
16136 return false;
16137 /* One of operands must be positive and the other non-negative. */
16138 /* We don't set *STRICT_OVERFLOW_P here: even if this value
16139 overflows, on a twos-complement machine the sum of two
16140 nonnegative numbers can never be zero. */
16141 return (tree_expr_nonzero_warnv_p (op0,
16142 strict_overflow_p)
16143 || tree_expr_nonzero_warnv_p (op1,
16144 strict_overflow_p));
16146 break;
16148 case MULT_EXPR:
16149 if (TYPE_OVERFLOW_UNDEFINED (type))
16151 if (tree_expr_nonzero_warnv_p (op0,
16152 strict_overflow_p)
16153 && tree_expr_nonzero_warnv_p (op1,
16154 strict_overflow_p))
16156 *strict_overflow_p = true;
16157 return true;
16160 break;
16162 case MIN_EXPR:
16163 sub_strict_overflow_p = false;
16164 if (tree_expr_nonzero_warnv_p (op0,
16165 &sub_strict_overflow_p)
16166 && tree_expr_nonzero_warnv_p (op1,
16167 &sub_strict_overflow_p))
16169 if (sub_strict_overflow_p)
16170 *strict_overflow_p = true;
16172 break;
16174 case MAX_EXPR:
16175 sub_strict_overflow_p = false;
16176 if (tree_expr_nonzero_warnv_p (op0,
16177 &sub_strict_overflow_p))
16179 if (sub_strict_overflow_p)
16180 *strict_overflow_p = true;
16182 /* When both operands are nonzero, then MAX must be too. */
16183 if (tree_expr_nonzero_warnv_p (op1,
16184 strict_overflow_p))
16185 return true;
16187 /* MAX where operand 0 is positive is positive. */
16188 return tree_expr_nonnegative_warnv_p (op0,
16189 strict_overflow_p);
16191 /* MAX where operand 1 is positive is positive. */
16192 else if (tree_expr_nonzero_warnv_p (op1,
16193 &sub_strict_overflow_p)
16194 && tree_expr_nonnegative_warnv_p (op1,
16195 &sub_strict_overflow_p))
16197 if (sub_strict_overflow_p)
16198 *strict_overflow_p = true;
16199 return true;
16201 break;
16203 case BIT_IOR_EXPR:
16204 return (tree_expr_nonzero_warnv_p (op1,
16205 strict_overflow_p)
16206 || tree_expr_nonzero_warnv_p (op0,
16207 strict_overflow_p));
16209 default:
16210 break;
16213 return false;
16216 /* Return true when T is an address and is known to be nonzero.
16217 For floating point we further ensure that T is not denormal.
16218 Similar logic is present in nonzero_address in rtlanal.h.
16220 If the return value is based on the assumption that signed overflow
16221 is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
16222 change *STRICT_OVERFLOW_P. */
16224 bool
16225 tree_single_nonzero_warnv_p (tree t, bool *strict_overflow_p)
16227 bool sub_strict_overflow_p;
16228 switch (TREE_CODE (t))
16230 case INTEGER_CST:
16231 return !integer_zerop (t);
16233 case ADDR_EXPR:
16235 tree base = TREE_OPERAND (t, 0);
16236 if (!DECL_P (base))
16237 base = get_base_address (base);
16239 if (!base)
16240 return false;
16242 /* Weak declarations may link to NULL. Other things may also be NULL
16243 so protect with -fdelete-null-pointer-checks; but not variables
16244 allocated on the stack. */
16245 if (DECL_P (base)
16246 && (flag_delete_null_pointer_checks
16247 || (DECL_CONTEXT (base)
16248 && TREE_CODE (DECL_CONTEXT (base)) == FUNCTION_DECL
16249 && auto_var_in_fn_p (base, DECL_CONTEXT (base)))))
16250 return !VAR_OR_FUNCTION_DECL_P (base) || !DECL_WEAK (base);
16252 /* Constants are never weak. */
16253 if (CONSTANT_CLASS_P (base))
16254 return true;
16256 return false;
16259 case COND_EXPR:
16260 sub_strict_overflow_p = false;
16261 if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
16262 &sub_strict_overflow_p)
16263 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
16264 &sub_strict_overflow_p))
16266 if (sub_strict_overflow_p)
16267 *strict_overflow_p = true;
16268 return true;
16270 break;
16272 default:
16273 break;
16275 return false;
16278 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
16279 attempt to fold the expression to a constant without modifying TYPE,
16280 OP0 or OP1.
16282 If the expression could be simplified to a constant, then return
16283 the constant. If the expression would not be simplified to a
16284 constant, then return NULL_TREE. */
16286 tree
16287 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
16289 tree tem = fold_binary (code, type, op0, op1);
16290 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
16293 /* Given the components of a unary expression CODE, TYPE and OP0,
16294 attempt to fold the expression to a constant without modifying
16295 TYPE or OP0.
16297 If the expression could be simplified to a constant, then return
16298 the constant. If the expression would not be simplified to a
16299 constant, then return NULL_TREE. */
16301 tree
16302 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
16304 tree tem = fold_unary (code, type, op0);
16305 return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
16308 /* If EXP represents referencing an element in a constant string
16309 (either via pointer arithmetic or array indexing), return the
16310 tree representing the value accessed, otherwise return NULL. */
16312 tree
16313 fold_read_from_constant_string (tree exp)
16315 if ((TREE_CODE (exp) == INDIRECT_REF
16316 || TREE_CODE (exp) == ARRAY_REF)
16317 && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
16319 tree exp1 = TREE_OPERAND (exp, 0);
16320 tree index;
16321 tree string;
16322 location_t loc = EXPR_LOCATION (exp);
16324 if (TREE_CODE (exp) == INDIRECT_REF)
16325 string = string_constant (exp1, &index);
16326 else
16328 tree low_bound = array_ref_low_bound (exp);
16329 index = fold_convert_loc (loc, sizetype, TREE_OPERAND (exp, 1));
16331 /* Optimize the special-case of a zero lower bound.
16333 We convert the low_bound to sizetype to avoid some problems
16334 with constant folding. (E.g. suppose the lower bound is 1,
16335 and its mode is QI. Without the conversion,l (ARRAY
16336 +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
16337 +INDEX), which becomes (ARRAY+255+INDEX). Oops!) */
16338 if (! integer_zerop (low_bound))
16339 index = size_diffop_loc (loc, index,
16340 fold_convert_loc (loc, sizetype, low_bound));
16342 string = exp1;
16345 if (string
16346 && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
16347 && TREE_CODE (string) == STRING_CST
16348 && TREE_CODE (index) == INTEGER_CST
16349 && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
16350 && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
16351 == MODE_INT)
16352 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
16353 return build_int_cst_type (TREE_TYPE (exp),
16354 (TREE_STRING_POINTER (string)
16355 [TREE_INT_CST_LOW (index)]));
16357 return NULL;
16360 /* Return the tree for neg (ARG0) when ARG0 is known to be either
16361 an integer constant, real, or fixed-point constant.
16363 TYPE is the type of the result. */
16365 static tree
16366 fold_negate_const (tree arg0, tree type)
16368 tree t = NULL_TREE;
16370 switch (TREE_CODE (arg0))
16372 case INTEGER_CST:
16374 double_int val = tree_to_double_int (arg0);
16375 bool overflow;
16376 val = val.neg_with_overflow (&overflow);
16377 t = force_fit_type_double (type, val, 1,
16378 (overflow | TREE_OVERFLOW (arg0))
16379 && !TYPE_UNSIGNED (type));
16380 break;
16383 case REAL_CST:
16384 t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
16385 break;
16387 case FIXED_CST:
16389 FIXED_VALUE_TYPE f;
16390 bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
16391 &(TREE_FIXED_CST (arg0)), NULL,
16392 TYPE_SATURATING (type));
16393 t = build_fixed (type, f);
16394 /* Propagate overflow flags. */
16395 if (overflow_p | TREE_OVERFLOW (arg0))
16396 TREE_OVERFLOW (t) = 1;
16397 break;
16400 default:
16401 gcc_unreachable ();
16404 return t;
16407 /* Return the tree for abs (ARG0) when ARG0 is known to be either
16408 an integer constant or real constant.
16410 TYPE is the type of the result. */
16412 tree
16413 fold_abs_const (tree arg0, tree type)
16415 tree t = NULL_TREE;
16417 switch (TREE_CODE (arg0))
16419 case INTEGER_CST:
16421 double_int val = tree_to_double_int (arg0);
16423 /* If the value is unsigned or non-negative, then the absolute value
16424 is the same as the ordinary value. */
16425 if (TYPE_UNSIGNED (type)
16426 || !val.is_negative ())
16427 t = arg0;
16429 /* If the value is negative, then the absolute value is
16430 its negation. */
16431 else
16433 bool overflow;
16434 val = val.neg_with_overflow (&overflow);
16435 t = force_fit_type_double (type, val, -1,
16436 overflow | TREE_OVERFLOW (arg0));
16439 break;
16441 case REAL_CST:
16442 if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
16443 t = build_real (type, real_value_negate (&TREE_REAL_CST (arg0)));
16444 else
16445 t = arg0;
16446 break;
16448 default:
16449 gcc_unreachable ();
16452 return t;
16455 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
16456 constant. TYPE is the type of the result. */
16458 static tree
16459 fold_not_const (const_tree arg0, tree type)
16461 double_int val;
16463 gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
16465 val = ~tree_to_double_int (arg0);
16466 return force_fit_type_double (type, val, 0, TREE_OVERFLOW (arg0));
16469 /* Given CODE, a relational operator, the target type, TYPE and two
16470 constant operands OP0 and OP1, return the result of the
16471 relational operation. If the result is not a compile time
16472 constant, then return NULL_TREE. */
16474 static tree
16475 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
16477 int result, invert;
16479 /* From here on, the only cases we handle are when the result is
16480 known to be a constant. */
16482 if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
16484 const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
16485 const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
16487 /* Handle the cases where either operand is a NaN. */
16488 if (real_isnan (c0) || real_isnan (c1))
16490 switch (code)
16492 case EQ_EXPR:
16493 case ORDERED_EXPR:
16494 result = 0;
16495 break;
16497 case NE_EXPR:
16498 case UNORDERED_EXPR:
16499 case UNLT_EXPR:
16500 case UNLE_EXPR:
16501 case UNGT_EXPR:
16502 case UNGE_EXPR:
16503 case UNEQ_EXPR:
16504 result = 1;
16505 break;
16507 case LT_EXPR:
16508 case LE_EXPR:
16509 case GT_EXPR:
16510 case GE_EXPR:
16511 case LTGT_EXPR:
16512 if (flag_trapping_math)
16513 return NULL_TREE;
16514 result = 0;
16515 break;
16517 default:
16518 gcc_unreachable ();
16521 return constant_boolean_node (result, type);
16524 return constant_boolean_node (real_compare (code, c0, c1), type);
16527 if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
16529 const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
16530 const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
16531 return constant_boolean_node (fixed_compare (code, c0, c1), type);
16534 /* Handle equality/inequality of complex constants. */
16535 if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
16537 tree rcond = fold_relational_const (code, type,
16538 TREE_REALPART (op0),
16539 TREE_REALPART (op1));
16540 tree icond = fold_relational_const (code, type,
16541 TREE_IMAGPART (op0),
16542 TREE_IMAGPART (op1));
16543 if (code == EQ_EXPR)
16544 return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
16545 else if (code == NE_EXPR)
16546 return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
16547 else
16548 return NULL_TREE;
16551 if (TREE_CODE (op0) == VECTOR_CST && TREE_CODE (op1) == VECTOR_CST)
16553 unsigned count = VECTOR_CST_NELTS (op0);
16554 tree *elts = XALLOCAVEC (tree, count);
16555 gcc_assert (VECTOR_CST_NELTS (op1) == count
16556 && TYPE_VECTOR_SUBPARTS (type) == count);
16558 for (unsigned i = 0; i < count; i++)
16560 tree elem_type = TREE_TYPE (type);
16561 tree elem0 = VECTOR_CST_ELT (op0, i);
16562 tree elem1 = VECTOR_CST_ELT (op1, i);
16564 tree tem = fold_relational_const (code, elem_type,
16565 elem0, elem1);
16567 if (tem == NULL_TREE)
16568 return NULL_TREE;
16570 elts[i] = build_int_cst (elem_type, integer_zerop (tem) ? 0 : -1);
16573 return build_vector (type, elts);
16576 /* From here on we only handle LT, LE, GT, GE, EQ and NE.
16578 To compute GT, swap the arguments and do LT.
16579 To compute GE, do LT and invert the result.
16580 To compute LE, swap the arguments, do LT and invert the result.
16581 To compute NE, do EQ and invert the result.
16583 Therefore, the code below must handle only EQ and LT. */
16585 if (code == LE_EXPR || code == GT_EXPR)
16587 tree tem = op0;
16588 op0 = op1;
16589 op1 = tem;
16590 code = swap_tree_comparison (code);
16593 /* Note that it is safe to invert for real values here because we
16594 have already handled the one case that it matters. */
16596 invert = 0;
16597 if (code == NE_EXPR || code == GE_EXPR)
16599 invert = 1;
16600 code = invert_tree_comparison (code, false);
16603 /* Compute a result for LT or EQ if args permit;
16604 Otherwise return T. */
16605 if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
16607 if (code == EQ_EXPR)
16608 result = tree_int_cst_equal (op0, op1);
16609 else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
16610 result = INT_CST_LT_UNSIGNED (op0, op1);
16611 else
16612 result = INT_CST_LT (op0, op1);
16614 else
16615 return NULL_TREE;
16617 if (invert)
16618 result ^= 1;
16619 return constant_boolean_node (result, type);
16622 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
16623 indicated TYPE. If no CLEANUP_POINT_EXPR is necessary, return EXPR
16624 itself. */
16626 tree
16627 fold_build_cleanup_point_expr (tree type, tree expr)
16629 /* If the expression does not have side effects then we don't have to wrap
16630 it with a cleanup point expression. */
16631 if (!TREE_SIDE_EFFECTS (expr))
16632 return expr;
16634 /* If the expression is a return, check to see if the expression inside the
16635 return has no side effects or the right hand side of the modify expression
16636 inside the return. If either don't have side effects set we don't need to
16637 wrap the expression in a cleanup point expression. Note we don't check the
16638 left hand side of the modify because it should always be a return decl. */
16639 if (TREE_CODE (expr) == RETURN_EXPR)
16641 tree op = TREE_OPERAND (expr, 0);
16642 if (!op || !TREE_SIDE_EFFECTS (op))
16643 return expr;
16644 op = TREE_OPERAND (op, 1);
16645 if (!TREE_SIDE_EFFECTS (op))
16646 return expr;
16649 return build1 (CLEANUP_POINT_EXPR, type, expr);
16652 /* Given a pointer value OP0 and a type TYPE, return a simplified version
16653 of an indirection through OP0, or NULL_TREE if no simplification is
16654 possible. */
16656 tree
16657 fold_indirect_ref_1 (location_t loc, tree type, tree op0)
16659 tree sub = op0;
16660 tree subtype;
16662 STRIP_NOPS (sub);
16663 subtype = TREE_TYPE (sub);
16664 if (!POINTER_TYPE_P (subtype))
16665 return NULL_TREE;
16667 if (TREE_CODE (sub) == ADDR_EXPR)
16669 tree op = TREE_OPERAND (sub, 0);
16670 tree optype = TREE_TYPE (op);
16671 /* *&CONST_DECL -> to the value of the const decl. */
16672 if (TREE_CODE (op) == CONST_DECL)
16673 return DECL_INITIAL (op);
16674 /* *&p => p; make sure to handle *&"str"[cst] here. */
16675 if (type == optype)
16677 tree fop = fold_read_from_constant_string (op);
16678 if (fop)
16679 return fop;
16680 else
16681 return op;
16683 /* *(foo *)&fooarray => fooarray[0] */
16684 else if (TREE_CODE (optype) == ARRAY_TYPE
16685 && type == TREE_TYPE (optype)
16686 && (!in_gimple_form
16687 || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
16689 tree type_domain = TYPE_DOMAIN (optype);
16690 tree min_val = size_zero_node;
16691 if (type_domain && TYPE_MIN_VALUE (type_domain))
16692 min_val = TYPE_MIN_VALUE (type_domain);
16693 if (in_gimple_form
16694 && TREE_CODE (min_val) != INTEGER_CST)
16695 return NULL_TREE;
16696 return build4_loc (loc, ARRAY_REF, type, op, min_val,
16697 NULL_TREE, NULL_TREE);
16699 /* *(foo *)&complexfoo => __real__ complexfoo */
16700 else if (TREE_CODE (optype) == COMPLEX_TYPE
16701 && type == TREE_TYPE (optype))
16702 return fold_build1_loc (loc, REALPART_EXPR, type, op);
16703 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
16704 else if (TREE_CODE (optype) == VECTOR_TYPE
16705 && type == TREE_TYPE (optype))
16707 tree part_width = TYPE_SIZE (type);
16708 tree index = bitsize_int (0);
16709 return fold_build3_loc (loc, BIT_FIELD_REF, type, op, part_width, index);
16713 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
16714 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
16716 tree op00 = TREE_OPERAND (sub, 0);
16717 tree op01 = TREE_OPERAND (sub, 1);
16719 STRIP_NOPS (op00);
16720 if (TREE_CODE (op00) == ADDR_EXPR)
16722 tree op00type;
16723 op00 = TREE_OPERAND (op00, 0);
16724 op00type = TREE_TYPE (op00);
16726 /* ((foo*)&vectorfoo)[1] => BIT_FIELD_REF<vectorfoo,...> */
16727 if (TREE_CODE (op00type) == VECTOR_TYPE
16728 && type == TREE_TYPE (op00type))
16730 HOST_WIDE_INT offset = tree_to_shwi (op01);
16731 tree part_width = TYPE_SIZE (type);
16732 unsigned HOST_WIDE_INT part_widthi = tree_to_shwi (part_width)/BITS_PER_UNIT;
16733 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
16734 tree index = bitsize_int (indexi);
16736 if (offset / part_widthi < TYPE_VECTOR_SUBPARTS (op00type))
16737 return fold_build3_loc (loc,
16738 BIT_FIELD_REF, type, op00,
16739 part_width, index);
16742 /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
16743 else if (TREE_CODE (op00type) == COMPLEX_TYPE
16744 && type == TREE_TYPE (op00type))
16746 tree size = TYPE_SIZE_UNIT (type);
16747 if (tree_int_cst_equal (size, op01))
16748 return fold_build1_loc (loc, IMAGPART_EXPR, type, op00);
16750 /* ((foo *)&fooarray)[1] => fooarray[1] */
16751 else if (TREE_CODE (op00type) == ARRAY_TYPE
16752 && type == TREE_TYPE (op00type))
16754 tree type_domain = TYPE_DOMAIN (op00type);
16755 tree min_val = size_zero_node;
16756 if (type_domain && TYPE_MIN_VALUE (type_domain))
16757 min_val = TYPE_MIN_VALUE (type_domain);
16758 op01 = size_binop_loc (loc, EXACT_DIV_EXPR, op01,
16759 TYPE_SIZE_UNIT (type));
16760 op01 = size_binop_loc (loc, PLUS_EXPR, op01, min_val);
16761 return build4_loc (loc, ARRAY_REF, type, op00, op01,
16762 NULL_TREE, NULL_TREE);
16767 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
16768 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
16769 && type == TREE_TYPE (TREE_TYPE (subtype))
16770 && (!in_gimple_form
16771 || TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST))
16773 tree type_domain;
16774 tree min_val = size_zero_node;
16775 sub = build_fold_indirect_ref_loc (loc, sub);
16776 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
16777 if (type_domain && TYPE_MIN_VALUE (type_domain))
16778 min_val = TYPE_MIN_VALUE (type_domain);
16779 if (in_gimple_form
16780 && TREE_CODE (min_val) != INTEGER_CST)
16781 return NULL_TREE;
16782 return build4_loc (loc, ARRAY_REF, type, sub, min_val, NULL_TREE,
16783 NULL_TREE);
16786 return NULL_TREE;
16789 /* Builds an expression for an indirection through T, simplifying some
16790 cases. */
16792 tree
16793 build_fold_indirect_ref_loc (location_t loc, tree t)
16795 tree type = TREE_TYPE (TREE_TYPE (t));
16796 tree sub = fold_indirect_ref_1 (loc, type, t);
16798 if (sub)
16799 return sub;
16801 return build1_loc (loc, INDIRECT_REF, type, t);
16804 /* Given an INDIRECT_REF T, return either T or a simplified version. */
16806 tree
16807 fold_indirect_ref_loc (location_t loc, tree t)
16809 tree sub = fold_indirect_ref_1 (loc, TREE_TYPE (t), TREE_OPERAND (t, 0));
16811 if (sub)
16812 return sub;
16813 else
16814 return t;
16817 /* Strip non-trapping, non-side-effecting tree nodes from an expression
16818 whose result is ignored. The type of the returned tree need not be
16819 the same as the original expression. */
16821 tree
16822 fold_ignored_result (tree t)
16824 if (!TREE_SIDE_EFFECTS (t))
16825 return integer_zero_node;
16827 for (;;)
16828 switch (TREE_CODE_CLASS (TREE_CODE (t)))
16830 case tcc_unary:
16831 t = TREE_OPERAND (t, 0);
16832 break;
16834 case tcc_binary:
16835 case tcc_comparison:
16836 if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
16837 t = TREE_OPERAND (t, 0);
16838 else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
16839 t = TREE_OPERAND (t, 1);
16840 else
16841 return t;
16842 break;
16844 case tcc_expression:
16845 switch (TREE_CODE (t))
16847 case COMPOUND_EXPR:
16848 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
16849 return t;
16850 t = TREE_OPERAND (t, 0);
16851 break;
16853 case COND_EXPR:
16854 if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
16855 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
16856 return t;
16857 t = TREE_OPERAND (t, 0);
16858 break;
16860 default:
16861 return t;
16863 break;
16865 default:
16866 return t;
16870 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
16871 This can only be applied to objects of a sizetype. */
16873 tree
16874 round_up_loc (location_t loc, tree value, int divisor)
16876 tree div = NULL_TREE;
16878 gcc_assert (divisor > 0);
16879 if (divisor == 1)
16880 return value;
16882 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16883 have to do anything. Only do this when we are not given a const,
16884 because in that case, this check is more expensive than just
16885 doing it. */
16886 if (TREE_CODE (value) != INTEGER_CST)
16888 div = build_int_cst (TREE_TYPE (value), divisor);
16890 if (multiple_of_p (TREE_TYPE (value), value, div))
16891 return value;
16894 /* If divisor is a power of two, simplify this to bit manipulation. */
16895 if (divisor == (divisor & -divisor))
16897 if (TREE_CODE (value) == INTEGER_CST)
16899 double_int val = tree_to_double_int (value);
16900 bool overflow_p;
16902 if ((val.low & (divisor - 1)) == 0)
16903 return value;
16905 overflow_p = TREE_OVERFLOW (value);
16906 val.low &= ~(divisor - 1);
16907 val.low += divisor;
16908 if (val.low == 0)
16910 val.high++;
16911 if (val.high == 0)
16912 overflow_p = true;
16915 return force_fit_type_double (TREE_TYPE (value), val,
16916 -1, overflow_p);
16918 else
16920 tree t;
16922 t = build_int_cst (TREE_TYPE (value), divisor - 1);
16923 value = size_binop_loc (loc, PLUS_EXPR, value, t);
16924 t = build_int_cst (TREE_TYPE (value), -divisor);
16925 value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
16928 else
16930 if (!div)
16931 div = build_int_cst (TREE_TYPE (value), divisor);
16932 value = size_binop_loc (loc, CEIL_DIV_EXPR, value, div);
16933 value = size_binop_loc (loc, MULT_EXPR, value, div);
16936 return value;
16939 /* Likewise, but round down. */
16941 tree
16942 round_down_loc (location_t loc, tree value, int divisor)
16944 tree div = NULL_TREE;
16946 gcc_assert (divisor > 0);
16947 if (divisor == 1)
16948 return value;
16950 /* See if VALUE is already a multiple of DIVISOR. If so, we don't
16951 have to do anything. Only do this when we are not given a const,
16952 because in that case, this check is more expensive than just
16953 doing it. */
16954 if (TREE_CODE (value) != INTEGER_CST)
16956 div = build_int_cst (TREE_TYPE (value), divisor);
16958 if (multiple_of_p (TREE_TYPE (value), value, div))
16959 return value;
16962 /* If divisor is a power of two, simplify this to bit manipulation. */
16963 if (divisor == (divisor & -divisor))
16965 tree t;
16967 t = build_int_cst (TREE_TYPE (value), -divisor);
16968 value = size_binop_loc (loc, BIT_AND_EXPR, value, t);
16970 else
16972 if (!div)
16973 div = build_int_cst (TREE_TYPE (value), divisor);
16974 value = size_binop_loc (loc, FLOOR_DIV_EXPR, value, div);
16975 value = size_binop_loc (loc, MULT_EXPR, value, div);
16978 return value;
16981 /* Returns the pointer to the base of the object addressed by EXP and
16982 extracts the information about the offset of the access, storing it
16983 to PBITPOS and POFFSET. */
16985 static tree
16986 split_address_to_core_and_offset (tree exp,
16987 HOST_WIDE_INT *pbitpos, tree *poffset)
16989 tree core;
16990 enum machine_mode mode;
16991 int unsignedp, volatilep;
16992 HOST_WIDE_INT bitsize;
16993 location_t loc = EXPR_LOCATION (exp);
16995 if (TREE_CODE (exp) == ADDR_EXPR)
16997 core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
16998 poffset, &mode, &unsignedp, &volatilep,
16999 false);
17000 core = build_fold_addr_expr_loc (loc, core);
17002 else
17004 core = exp;
17005 *pbitpos = 0;
17006 *poffset = NULL_TREE;
17009 return core;
17012 /* Returns true if addresses of E1 and E2 differ by a constant, false
17013 otherwise. If they do, E1 - E2 is stored in *DIFF. */
17015 bool
17016 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
17018 tree core1, core2;
17019 HOST_WIDE_INT bitpos1, bitpos2;
17020 tree toffset1, toffset2, tdiff, type;
17022 core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
17023 core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
17025 if (bitpos1 % BITS_PER_UNIT != 0
17026 || bitpos2 % BITS_PER_UNIT != 0
17027 || !operand_equal_p (core1, core2, 0))
17028 return false;
17030 if (toffset1 && toffset2)
17032 type = TREE_TYPE (toffset1);
17033 if (type != TREE_TYPE (toffset2))
17034 toffset2 = fold_convert (type, toffset2);
17036 tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
17037 if (!cst_and_fits_in_hwi (tdiff))
17038 return false;
17040 *diff = int_cst_value (tdiff);
17042 else if (toffset1 || toffset2)
17044 /* If only one of the offsets is non-constant, the difference cannot
17045 be a constant. */
17046 return false;
17048 else
17049 *diff = 0;
17051 *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
17052 return true;
17055 /* Simplify the floating point expression EXP when the sign of the
17056 result is not significant. Return NULL_TREE if no simplification
17057 is possible. */
17059 tree
17060 fold_strip_sign_ops (tree exp)
17062 tree arg0, arg1;
17063 location_t loc = EXPR_LOCATION (exp);
17065 switch (TREE_CODE (exp))
17067 case ABS_EXPR:
17068 case NEGATE_EXPR:
17069 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
17070 return arg0 ? arg0 : TREE_OPERAND (exp, 0);
17072 case MULT_EXPR:
17073 case RDIV_EXPR:
17074 if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
17075 return NULL_TREE;
17076 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
17077 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
17078 if (arg0 != NULL_TREE || arg1 != NULL_TREE)
17079 return fold_build2_loc (loc, TREE_CODE (exp), TREE_TYPE (exp),
17080 arg0 ? arg0 : TREE_OPERAND (exp, 0),
17081 arg1 ? arg1 : TREE_OPERAND (exp, 1));
17082 break;
17084 case COMPOUND_EXPR:
17085 arg0 = TREE_OPERAND (exp, 0);
17086 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
17087 if (arg1)
17088 return fold_build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
17089 break;
17091 case COND_EXPR:
17092 arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
17093 arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
17094 if (arg0 || arg1)
17095 return fold_build3_loc (loc,
17096 COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
17097 arg0 ? arg0 : TREE_OPERAND (exp, 1),
17098 arg1 ? arg1 : TREE_OPERAND (exp, 2));
17099 break;
17101 case CALL_EXPR:
17103 const enum built_in_function fcode = builtin_mathfn_code (exp);
17104 switch (fcode)
17106 CASE_FLT_FN (BUILT_IN_COPYSIGN):
17107 /* Strip copysign function call, return the 1st argument. */
17108 arg0 = CALL_EXPR_ARG (exp, 0);
17109 arg1 = CALL_EXPR_ARG (exp, 1);
17110 return omit_one_operand_loc (loc, TREE_TYPE (exp), arg0, arg1);
17112 default:
17113 /* Strip sign ops from the argument of "odd" math functions. */
17114 if (negate_mathfn_p (fcode))
17116 arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
17117 if (arg0)
17118 return build_call_expr_loc (loc, get_callee_fndecl (exp), 1, arg0);
17120 break;
17123 break;
17125 default:
17126 break;
17128 return NULL_TREE;