OSDN Git Service

Fix oversight.
[pf3gnuchains/gcc-fork.git] / gcc / fold-const.c
1 /* Fold a constant sub-tree into a single node for C-compiler
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 /*@@ This file should be rewritten to use an arbitrary precision
23   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
24   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
25   @@ The routines that translate from the ap rep should
26   @@ warn if precision et. al. is lost.
27   @@ This would also make life easier when this technology is used
28   @@ for cross-compilers.  */
29
30 /* The entry points in this file are fold, size_int_wide, size_binop
31    and force_fit_type_double.
32
33    fold takes a tree as argument and returns a simplified tree.
34
35    size_binop takes a tree code for an arithmetic operation
36    and two operands that are trees, and produces a tree for the
37    result, assuming the type comes from `sizetype'.
38
39    size_int takes an integer value, and creates a tree constant
40    with type from `sizetype'.
41
42    force_fit_type_double takes a constant, an overflowable flag and a
43    prior overflow indicator.  It forces the value to fit the type and
44    sets TREE_OVERFLOW.
45
46    Note: Since the folders get called on non-gimple code as well as
47    gimple code, we need to handle GIMPLE tuples as well as their
48    corresponding tree equivalents.  */
49
50 #include "config.h"
51 #include "system.h"
52 #include "coretypes.h"
53 #include "tm.h"
54 #include "flags.h"
55 #include "tree.h"
56 #include "real.h"
57 #include "fixed-value.h"
58 #include "rtl.h"
59 #include "expr.h"
60 #include "tm_p.h"
61 #include "toplev.h"
62 #include "intl.h"
63 #include "ggc.h"
64 #include "hashtab.h"
65 #include "langhooks.h"
66 #include "md5.h"
67
68 /* Nonzero if we are folding constants inside an initializer; zero
69    otherwise.  */
70 int folding_initializer = 0;
71
72 /* The following constants represent a bit based encoding of GCC's
73    comparison operators.  This encoding simplifies transformations
74    on relational comparison operators, such as AND and OR.  */
75 enum comparison_code {
76   COMPCODE_FALSE = 0,
77   COMPCODE_LT = 1,
78   COMPCODE_EQ = 2,
79   COMPCODE_LE = 3,
80   COMPCODE_GT = 4,
81   COMPCODE_LTGT = 5,
82   COMPCODE_GE = 6,
83   COMPCODE_ORD = 7,
84   COMPCODE_UNORD = 8,
85   COMPCODE_UNLT = 9,
86   COMPCODE_UNEQ = 10,
87   COMPCODE_UNLE = 11,
88   COMPCODE_UNGT = 12,
89   COMPCODE_NE = 13,
90   COMPCODE_UNGE = 14,
91   COMPCODE_TRUE = 15
92 };
93
94 static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
95 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
96 static bool negate_mathfn_p (enum built_in_function);
97 static bool negate_expr_p (tree);
98 static tree negate_expr (tree);
99 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
100 static tree associate_trees (tree, tree, enum tree_code, tree);
101 static tree const_binop (enum tree_code, tree, tree, int);
102 static enum comparison_code comparison_to_compcode (enum tree_code);
103 static enum tree_code compcode_to_comparison (enum comparison_code);
104 static tree combine_comparisons (enum tree_code, enum tree_code,
105                                  enum tree_code, tree, tree, tree);
106 static int truth_value_p (enum tree_code);
107 static int operand_equal_for_comparison_p (tree, tree, tree);
108 static int twoval_comparison_p (tree, tree *, tree *, int *);
109 static tree eval_subst (tree, tree, tree, tree, tree);
110 static tree pedantic_omit_one_operand (tree, tree, tree);
111 static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
112 static tree make_bit_field_ref (tree, tree, int, int, int);
113 static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
114 static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
115                                     enum machine_mode *, int *, int *,
116                                     tree *, tree *);
117 static int all_ones_mask_p (const_tree, int);
118 static tree sign_bit_p (tree, const_tree);
119 static int simple_operand_p (const_tree);
120 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
121 static tree range_predecessor (tree);
122 static tree range_successor (tree);
123 static tree make_range (tree, int *, tree *, tree *, bool *);
124 static tree build_range_check (tree, tree, int, tree, tree);
125 static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
126                          tree);
127 static tree fold_range_test (enum tree_code, tree, tree, tree);
128 static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
129 static tree unextend (tree, int, int, tree);
130 static tree fold_truthop (enum tree_code, tree, tree, tree);
131 static tree optimize_minmax_comparison (enum tree_code, tree, tree, tree);
132 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
133 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
134 static tree fold_binary_op_with_conditional_arg (enum tree_code, tree,
135                                                  tree, tree,
136                                                  tree, tree, int);
137 static bool fold_real_zero_addition_p (const_tree, const_tree, int);
138 static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
139                                  tree, tree, tree);
140 static tree fold_inf_compare (enum tree_code, tree, tree, tree);
141 static tree fold_div_compare (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 (tree, tree);
145 static tree fold_relational_const (enum tree_code, tree, tree, tree);
146
147
148 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
149    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
150    and SUM1.  Then this yields nonzero if overflow occurred during the
151    addition.
152
153    Overflow occurs if A and B have the same sign, but A and SUM differ in
154    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
155    sign.  */
156 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
157 \f
158 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
159    We do that by representing the two-word integer in 4 words, with only
160    HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
161    number.  The value of the word is LOWPART + HIGHPART * BASE.  */
162
163 #define LOWPART(x) \
164   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
165 #define HIGHPART(x) \
166   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
167 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
168
169 /* Unpack a two-word integer into 4 words.
170    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
171    WORDS points to the array of HOST_WIDE_INTs.  */
172
173 static void
174 encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
175 {
176   words[0] = LOWPART (low);
177   words[1] = HIGHPART (low);
178   words[2] = LOWPART (hi);
179   words[3] = HIGHPART (hi);
180 }
181
182 /* Pack an array of 4 words into a two-word integer.
183    WORDS points to the array of words.
184    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
185
186 static void
187 decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
188         HOST_WIDE_INT *hi)
189 {
190   *low = words[0] + words[1] * BASE;
191   *hi = words[2] + words[3] * BASE;
192 }
193 \f
194 /* Force the double-word integer L1, H1 to be within the range of the
195    integer type TYPE.  Stores the properly truncated and sign-extended
196    double-word integer in *LV, *HV.  Returns true if the operation
197    overflows, that is, argument and result are different.  */
198
199 int
200 fit_double_type (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
201                  unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, const_tree type)
202 {
203   unsigned HOST_WIDE_INT low0 = l1;
204   HOST_WIDE_INT high0 = h1;
205   unsigned int prec;
206   int sign_extended_type;
207
208   if (POINTER_TYPE_P (type)
209       || TREE_CODE (type) == OFFSET_TYPE)
210     prec = POINTER_SIZE;
211   else
212     prec = TYPE_PRECISION (type);
213
214   /* Size types *are* sign extended.  */
215   sign_extended_type = (!TYPE_UNSIGNED (type)
216                         || (TREE_CODE (type) == INTEGER_TYPE
217                             && TYPE_IS_SIZETYPE (type)));
218
219   /* First clear all bits that are beyond the type's precision.  */
220   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
221     ;
222   else if (prec > HOST_BITS_PER_WIDE_INT)
223     h1 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
224   else
225     {
226       h1 = 0;
227       if (prec < HOST_BITS_PER_WIDE_INT)
228         l1 &= ~((HOST_WIDE_INT) (-1) << prec);
229     }
230
231   /* Then do sign extension if necessary.  */
232   if (!sign_extended_type)
233     /* No sign extension */;
234   else if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
235     /* Correct width already.  */;
236   else if (prec > HOST_BITS_PER_WIDE_INT)
237     {
238       /* Sign extend top half? */
239       if (h1 & ((unsigned HOST_WIDE_INT)1
240                 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
241         h1 |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
242     }
243   else if (prec == HOST_BITS_PER_WIDE_INT)
244     {
245       if ((HOST_WIDE_INT)l1 < 0)
246         h1 = -1;
247     }
248   else
249     {
250       /* Sign extend bottom half? */
251       if (l1 & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
252         {
253           h1 = -1;
254           l1 |= (HOST_WIDE_INT)(-1) << prec;
255         }
256     }
257
258   *lv = l1;
259   *hv = h1;
260
261   /* If the value didn't fit, signal overflow.  */
262   return l1 != low0 || h1 != high0;
263 }
264
265 /* We force the double-int HIGH:LOW to the range of the type TYPE by
266    sign or zero extending it.
267    OVERFLOWABLE indicates if we are interested
268    in overflow of the value, when >0 we are only interested in signed
269    overflow, for <0 we are interested in any overflow.  OVERFLOWED
270    indicates whether overflow has already occurred.  CONST_OVERFLOWED
271    indicates whether constant overflow has already occurred.  We force
272    T's value to be within range of T's type (by setting to 0 or 1 all
273    the bits outside the type's range).  We set TREE_OVERFLOWED if,
274         OVERFLOWED is nonzero,
275         or OVERFLOWABLE is >0 and signed overflow occurs
276         or OVERFLOWABLE is <0 and any overflow occurs
277    We return a new tree node for the extended double-int.  The node
278    is shared if no overflow flags are set.  */
279
280 tree
281 force_fit_type_double (tree type, unsigned HOST_WIDE_INT low,
282                        HOST_WIDE_INT high, int overflowable,
283                        bool overflowed)
284 {
285   int sign_extended_type;
286   bool overflow;
287
288   /* Size types *are* sign extended.  */
289   sign_extended_type = (!TYPE_UNSIGNED (type)
290                         || (TREE_CODE (type) == INTEGER_TYPE
291                             && TYPE_IS_SIZETYPE (type)));
292
293   overflow = fit_double_type (low, high, &low, &high, type);
294
295   /* If we need to set overflow flags, return a new unshared node.  */
296   if (overflowed || overflow)
297     {
298       if (overflowed
299           || overflowable < 0
300           || (overflowable > 0 && sign_extended_type))
301         {
302           tree t = make_node (INTEGER_CST);
303           TREE_INT_CST_LOW (t) = low;
304           TREE_INT_CST_HIGH (t) = high;
305           TREE_TYPE (t) = type;
306           TREE_OVERFLOW (t) = 1;
307           return t;
308         }
309     }
310
311   /* Else build a shared node.  */
312   return build_int_cst_wide (type, low, high);
313 }
314 \f
315 /* Add two doubleword integers with doubleword result.
316    Return nonzero if the operation overflows according to UNSIGNED_P.
317    Each argument is given as two `HOST_WIDE_INT' pieces.
318    One argument is L1 and H1; the other, L2 and H2.
319    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
320
321 int
322 add_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
323                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
324                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
325                       bool unsigned_p)
326 {
327   unsigned HOST_WIDE_INT l;
328   HOST_WIDE_INT h;
329
330   l = l1 + l2;
331   h = h1 + h2 + (l < l1);
332
333   *lv = l;
334   *hv = h;
335
336   if (unsigned_p)
337     return (unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1;
338   else
339     return OVERFLOW_SUM_SIGN (h1, h2, h);
340 }
341
342 /* Negate a doubleword integer with doubleword result.
343    Return nonzero if the operation overflows, assuming it's signed.
344    The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
345    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
346
347 int
348 neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
349             unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
350 {
351   if (l1 == 0)
352     {
353       *lv = 0;
354       *hv = - h1;
355       return (*hv & h1) < 0;
356     }
357   else
358     {
359       *lv = -l1;
360       *hv = ~h1;
361       return 0;
362     }
363 }
364 \f
365 /* Multiply two doubleword integers with doubleword result.
366    Return nonzero if the operation overflows according to UNSIGNED_P.
367    Each argument is given as two `HOST_WIDE_INT' pieces.
368    One argument is L1 and H1; the other, L2 and H2.
369    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
370
371 int
372 mul_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
373                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
374                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
375                       bool unsigned_p)
376 {
377   HOST_WIDE_INT arg1[4];
378   HOST_WIDE_INT arg2[4];
379   HOST_WIDE_INT prod[4 * 2];
380   unsigned HOST_WIDE_INT carry;
381   int i, j, k;
382   unsigned HOST_WIDE_INT toplow, neglow;
383   HOST_WIDE_INT tophigh, neghigh;
384
385   encode (arg1, l1, h1);
386   encode (arg2, l2, h2);
387
388   memset (prod, 0, sizeof prod);
389
390   for (i = 0; i < 4; i++)
391     {
392       carry = 0;
393       for (j = 0; j < 4; j++)
394         {
395           k = i + j;
396           /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000.  */
397           carry += arg1[i] * arg2[j];
398           /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF.  */
399           carry += prod[k];
400           prod[k] = LOWPART (carry);
401           carry = HIGHPART (carry);
402         }
403       prod[i + 4] = carry;
404     }
405
406   decode (prod, lv, hv);
407   decode (prod + 4, &toplow, &tophigh);
408
409   /* Unsigned overflow is immediate.  */
410   if (unsigned_p)
411     return (toplow | tophigh) != 0;
412
413   /* Check for signed overflow by calculating the signed representation of the
414      top half of the result; it should agree with the low half's sign bit.  */
415   if (h1 < 0)
416     {
417       neg_double (l2, h2, &neglow, &neghigh);
418       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
419     }
420   if (h2 < 0)
421     {
422       neg_double (l1, h1, &neglow, &neghigh);
423       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
424     }
425   return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
426 }
427 \f
428 /* Shift the doubleword integer in L1, H1 left by COUNT places
429    keeping only PREC bits of result.
430    Shift right if COUNT is negative.
431    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
432    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
433
434 void
435 lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
436                HOST_WIDE_INT count, unsigned int prec,
437                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, int arith)
438 {
439   unsigned HOST_WIDE_INT signmask;
440
441   if (count < 0)
442     {
443       rshift_double (l1, h1, -count, prec, lv, hv, arith);
444       return;
445     }
446
447   if (SHIFT_COUNT_TRUNCATED)
448     count %= prec;
449
450   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
451     {
452       /* Shifting by the host word size is undefined according to the
453          ANSI standard, so we must handle this as a special case.  */
454       *hv = 0;
455       *lv = 0;
456     }
457   else if (count >= HOST_BITS_PER_WIDE_INT)
458     {
459       *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
460       *lv = 0;
461     }
462   else
463     {
464       *hv = (((unsigned HOST_WIDE_INT) h1 << count)
465              | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
466       *lv = l1 << count;
467     }
468
469   /* Sign extend all bits that are beyond the precision.  */
470
471   signmask = -((prec > HOST_BITS_PER_WIDE_INT
472                 ? ((unsigned HOST_WIDE_INT) *hv
473                    >> (prec - HOST_BITS_PER_WIDE_INT - 1))
474                 : (*lv >> (prec - 1))) & 1);
475
476   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
477     ;
478   else if (prec >= HOST_BITS_PER_WIDE_INT)
479     {
480       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
481       *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
482     }
483   else
484     {
485       *hv = signmask;
486       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
487       *lv |= signmask << prec;
488     }
489 }
490
491 /* Shift the doubleword integer in L1, H1 right by COUNT places
492    keeping only PREC bits of result.  COUNT must be positive.
493    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
494    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
495
496 void
497 rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
498                HOST_WIDE_INT count, unsigned int prec,
499                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
500                int arith)
501 {
502   unsigned HOST_WIDE_INT signmask;
503
504   signmask = (arith
505               ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
506               : 0);
507
508   if (SHIFT_COUNT_TRUNCATED)
509     count %= prec;
510
511   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
512     {
513       /* Shifting by the host word size is undefined according to the
514          ANSI standard, so we must handle this as a special case.  */
515       *hv = 0;
516       *lv = 0;
517     }
518   else if (count >= HOST_BITS_PER_WIDE_INT)
519     {
520       *hv = 0;
521       *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
522     }
523   else
524     {
525       *hv = (unsigned HOST_WIDE_INT) h1 >> count;
526       *lv = ((l1 >> count)
527              | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
528     }
529
530   /* Zero / sign extend all bits that are beyond the precision.  */
531
532   if (count >= (HOST_WIDE_INT)prec)
533     {
534       *hv = signmask;
535       *lv = signmask;
536     }
537   else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT)
538     ;
539   else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
540     {
541       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
542       *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
543     }
544   else
545     {
546       *hv = signmask;
547       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
548       *lv |= signmask << (prec - count);
549     }
550 }
551 \f
552 /* Rotate the doubleword integer in L1, H1 left by COUNT places
553    keeping only PREC bits of result.
554    Rotate right if COUNT is negative.
555    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
556
557 void
558 lrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
559                 HOST_WIDE_INT count, unsigned int prec,
560                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
561 {
562   unsigned HOST_WIDE_INT s1l, s2l;
563   HOST_WIDE_INT s1h, s2h;
564
565   count %= prec;
566   if (count < 0)
567     count += prec;
568
569   lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
570   rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
571   *lv = s1l | s2l;
572   *hv = s1h | s2h;
573 }
574
575 /* Rotate the doubleword integer in L1, H1 left by COUNT places
576    keeping only PREC bits of result.  COUNT must be positive.
577    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
578
579 void
580 rrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
581                 HOST_WIDE_INT count, unsigned int prec,
582                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
583 {
584   unsigned HOST_WIDE_INT s1l, s2l;
585   HOST_WIDE_INT s1h, s2h;
586
587   count %= prec;
588   if (count < 0)
589     count += prec;
590
591   rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
592   lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
593   *lv = s1l | s2l;
594   *hv = s1h | s2h;
595 }
596 \f
597 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
598    for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
599    CODE is a tree code for a kind of division, one of
600    TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
601    or EXACT_DIV_EXPR
602    It controls how the quotient is rounded to an integer.
603    Return nonzero if the operation overflows.
604    UNS nonzero says do unsigned division.  */
605
606 int
607 div_and_round_double (enum tree_code code, int uns,
608                       unsigned HOST_WIDE_INT lnum_orig, /* num == numerator == dividend */
609                       HOST_WIDE_INT hnum_orig,
610                       unsigned HOST_WIDE_INT lden_orig, /* den == denominator == divisor */
611                       HOST_WIDE_INT hden_orig,
612                       unsigned HOST_WIDE_INT *lquo,
613                       HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
614                       HOST_WIDE_INT *hrem)
615 {
616   int quo_neg = 0;
617   HOST_WIDE_INT num[4 + 1];     /* extra element for scaling.  */
618   HOST_WIDE_INT den[4], quo[4];
619   int i, j;
620   unsigned HOST_WIDE_INT work;
621   unsigned HOST_WIDE_INT carry = 0;
622   unsigned HOST_WIDE_INT lnum = lnum_orig;
623   HOST_WIDE_INT hnum = hnum_orig;
624   unsigned HOST_WIDE_INT lden = lden_orig;
625   HOST_WIDE_INT hden = hden_orig;
626   int overflow = 0;
627
628   if (hden == 0 && lden == 0)
629     overflow = 1, lden = 1;
630
631   /* Calculate quotient sign and convert operands to unsigned.  */
632   if (!uns)
633     {
634       if (hnum < 0)
635         {
636           quo_neg = ~ quo_neg;
637           /* (minimum integer) / (-1) is the only overflow case.  */
638           if (neg_double (lnum, hnum, &lnum, &hnum)
639               && ((HOST_WIDE_INT) lden & hden) == -1)
640             overflow = 1;
641         }
642       if (hden < 0)
643         {
644           quo_neg = ~ quo_neg;
645           neg_double (lden, hden, &lden, &hden);
646         }
647     }
648
649   if (hnum == 0 && hden == 0)
650     {                           /* single precision */
651       *hquo = *hrem = 0;
652       /* This unsigned division rounds toward zero.  */
653       *lquo = lnum / lden;
654       goto finish_up;
655     }
656
657   if (hnum == 0)
658     {                           /* trivial case: dividend < divisor */
659       /* hden != 0 already checked.  */
660       *hquo = *lquo = 0;
661       *hrem = hnum;
662       *lrem = lnum;
663       goto finish_up;
664     }
665
666   memset (quo, 0, sizeof quo);
667
668   memset (num, 0, sizeof num);  /* to zero 9th element */
669   memset (den, 0, sizeof den);
670
671   encode (num, lnum, hnum);
672   encode (den, lden, hden);
673
674   /* Special code for when the divisor < BASE.  */
675   if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
676     {
677       /* hnum != 0 already checked.  */
678       for (i = 4 - 1; i >= 0; i--)
679         {
680           work = num[i] + carry * BASE;
681           quo[i] = work / lden;
682           carry = work % lden;
683         }
684     }
685   else
686     {
687       /* Full double precision division,
688          with thanks to Don Knuth's "Seminumerical Algorithms".  */
689       int num_hi_sig, den_hi_sig;
690       unsigned HOST_WIDE_INT quo_est, scale;
691
692       /* Find the highest nonzero divisor digit.  */
693       for (i = 4 - 1;; i--)
694         if (den[i] != 0)
695           {
696             den_hi_sig = i;
697             break;
698           }
699
700       /* Insure that the first digit of the divisor is at least BASE/2.
701          This is required by the quotient digit estimation algorithm.  */
702
703       scale = BASE / (den[den_hi_sig] + 1);
704       if (scale > 1)
705         {               /* scale divisor and dividend */
706           carry = 0;
707           for (i = 0; i <= 4 - 1; i++)
708             {
709               work = (num[i] * scale) + carry;
710               num[i] = LOWPART (work);
711               carry = HIGHPART (work);
712             }
713
714           num[4] = carry;
715           carry = 0;
716           for (i = 0; i <= 4 - 1; i++)
717             {
718               work = (den[i] * scale) + carry;
719               den[i] = LOWPART (work);
720               carry = HIGHPART (work);
721               if (den[i] != 0) den_hi_sig = i;
722             }
723         }
724
725       num_hi_sig = 4;
726
727       /* Main loop */
728       for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
729         {
730           /* Guess the next quotient digit, quo_est, by dividing the first
731              two remaining dividend digits by the high order quotient digit.
732              quo_est is never low and is at most 2 high.  */
733           unsigned HOST_WIDE_INT tmp;
734
735           num_hi_sig = i + den_hi_sig + 1;
736           work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
737           if (num[num_hi_sig] != den[den_hi_sig])
738             quo_est = work / den[den_hi_sig];
739           else
740             quo_est = BASE - 1;
741
742           /* Refine quo_est so it's usually correct, and at most one high.  */
743           tmp = work - quo_est * den[den_hi_sig];
744           if (tmp < BASE
745               && (den[den_hi_sig - 1] * quo_est
746                   > (tmp * BASE + num[num_hi_sig - 2])))
747             quo_est--;
748
749           /* Try QUO_EST as the quotient digit, by multiplying the
750              divisor by QUO_EST and subtracting from the remaining dividend.
751              Keep in mind that QUO_EST is the I - 1st digit.  */
752
753           carry = 0;
754           for (j = 0; j <= den_hi_sig; j++)
755             {
756               work = quo_est * den[j] + carry;
757               carry = HIGHPART (work);
758               work = num[i + j] - LOWPART (work);
759               num[i + j] = LOWPART (work);
760               carry += HIGHPART (work) != 0;
761             }
762
763           /* If quo_est was high by one, then num[i] went negative and
764              we need to correct things.  */
765           if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
766             {
767               quo_est--;
768               carry = 0;                /* add divisor back in */
769               for (j = 0; j <= den_hi_sig; j++)
770                 {
771                   work = num[i + j] + den[j] + carry;
772                   carry = HIGHPART (work);
773                   num[i + j] = LOWPART (work);
774                 }
775
776               num [num_hi_sig] += carry;
777             }
778
779           /* Store the quotient digit.  */
780           quo[i] = quo_est;
781         }
782     }
783
784   decode (quo, lquo, hquo);
785
786  finish_up:
787   /* If result is negative, make it so.  */
788   if (quo_neg)
789     neg_double (*lquo, *hquo, lquo, hquo);
790
791   /* Compute trial remainder:  rem = num - (quo * den)  */
792   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
793   neg_double (*lrem, *hrem, lrem, hrem);
794   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
795
796   switch (code)
797     {
798     case TRUNC_DIV_EXPR:
799     case TRUNC_MOD_EXPR:        /* round toward zero */
800     case EXACT_DIV_EXPR:        /* for this one, it shouldn't matter */
801       return overflow;
802
803     case FLOOR_DIV_EXPR:
804     case FLOOR_MOD_EXPR:        /* round toward negative infinity */
805       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
806         {
807           /* quo = quo - 1;  */
808           add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT)  -1,
809                       lquo, hquo);
810         }
811       else
812         return overflow;
813       break;
814
815     case CEIL_DIV_EXPR:
816     case CEIL_MOD_EXPR:         /* round toward positive infinity */
817       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
818         {
819           add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
820                       lquo, hquo);
821         }
822       else
823         return overflow;
824       break;
825
826     case ROUND_DIV_EXPR:
827     case ROUND_MOD_EXPR:        /* round to closest integer */
828       {
829         unsigned HOST_WIDE_INT labs_rem = *lrem;
830         HOST_WIDE_INT habs_rem = *hrem;
831         unsigned HOST_WIDE_INT labs_den = lden, ltwice;
832         HOST_WIDE_INT habs_den = hden, htwice;
833
834         /* Get absolute values.  */
835         if (*hrem < 0)
836           neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
837         if (hden < 0)
838           neg_double (lden, hden, &labs_den, &habs_den);
839
840         /* If (2 * abs (lrem) >= abs (lden)) */
841         mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
842                     labs_rem, habs_rem, &ltwice, &htwice);
843
844         if (((unsigned HOST_WIDE_INT) habs_den
845              < (unsigned HOST_WIDE_INT) htwice)
846             || (((unsigned HOST_WIDE_INT) habs_den
847                  == (unsigned HOST_WIDE_INT) htwice)
848                 && (labs_den < ltwice)))
849           {
850             if (*hquo < 0)
851               /* quo = quo - 1;  */
852               add_double (*lquo, *hquo,
853                           (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
854             else
855               /* quo = quo + 1; */
856               add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
857                           lquo, hquo);
858           }
859         else
860           return overflow;
861       }
862       break;
863
864     default:
865       gcc_unreachable ();
866     }
867
868   /* Compute true remainder:  rem = num - (quo * den)  */
869   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
870   neg_double (*lrem, *hrem, lrem, hrem);
871   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
872   return overflow;
873 }
874
875 /* If ARG2 divides ARG1 with zero remainder, carries out the division
876    of type CODE and returns the quotient.
877    Otherwise returns NULL_TREE.  */
878
879 static tree
880 div_if_zero_remainder (enum tree_code code, const_tree arg1, const_tree arg2)
881 {
882   unsigned HOST_WIDE_INT int1l, int2l;
883   HOST_WIDE_INT int1h, int2h;
884   unsigned HOST_WIDE_INT quol, reml;
885   HOST_WIDE_INT quoh, remh;
886   tree type = TREE_TYPE (arg1);
887   int uns = TYPE_UNSIGNED (type);
888
889   int1l = TREE_INT_CST_LOW (arg1);
890   int1h = TREE_INT_CST_HIGH (arg1);
891   /* &obj[0] + -128 really should be compiled as &obj[-8] rather than
892      &obj[some_exotic_number].  */
893   if (POINTER_TYPE_P (type))
894     {
895       uns = false;
896       type = signed_type_for (type);
897       fit_double_type (int1l, int1h, &int1l, &int1h,
898                        type);
899     }
900   else
901     fit_double_type (int1l, int1h, &int1l, &int1h, type);
902   int2l = TREE_INT_CST_LOW (arg2);
903   int2h = TREE_INT_CST_HIGH (arg2);
904
905   div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
906                         &quol, &quoh, &reml, &remh);
907   if (remh != 0 || reml != 0)
908     return NULL_TREE;
909
910   return build_int_cst_wide (type, quol, quoh);
911 }
912 \f
913 /* This is nonzero if we should defer warnings about undefined
914    overflow.  This facility exists because these warnings are a
915    special case.  The code to estimate loop iterations does not want
916    to issue any warnings, since it works with expressions which do not
917    occur in user code.  Various bits of cleanup code call fold(), but
918    only use the result if it has certain characteristics (e.g., is a
919    constant); that code only wants to issue a warning if the result is
920    used.  */
921
922 static int fold_deferring_overflow_warnings;
923
924 /* If a warning about undefined overflow is deferred, this is the
925    warning.  Note that this may cause us to turn two warnings into
926    one, but that is fine since it is sufficient to only give one
927    warning per expression.  */
928
929 static const char* fold_deferred_overflow_warning;
930
931 /* If a warning about undefined overflow is deferred, this is the
932    level at which the warning should be emitted.  */
933
934 static enum warn_strict_overflow_code fold_deferred_overflow_code;
935
936 /* Start deferring overflow warnings.  We could use a stack here to
937    permit nested calls, but at present it is not necessary.  */
938
939 void
940 fold_defer_overflow_warnings (void)
941 {
942   ++fold_deferring_overflow_warnings;
943 }
944
945 /* Stop deferring overflow warnings.  If there is a pending warning,
946    and ISSUE is true, then issue the warning if appropriate.  STMT is
947    the statement with which the warning should be associated (used for
948    location information); STMT may be NULL.  CODE is the level of the
949    warning--a warn_strict_overflow_code value.  This function will use
950    the smaller of CODE and the deferred code when deciding whether to
951    issue the warning.  CODE may be zero to mean to always use the
952    deferred code.  */
953
954 void
955 fold_undefer_overflow_warnings (bool issue, const_tree stmt, int code)
956 {
957   const char *warnmsg;
958   location_t locus;
959
960   gcc_assert (fold_deferring_overflow_warnings > 0);
961   --fold_deferring_overflow_warnings;
962   if (fold_deferring_overflow_warnings > 0)
963     {
964       if (fold_deferred_overflow_warning != NULL
965           && code != 0
966           && code < (int) fold_deferred_overflow_code)
967         fold_deferred_overflow_code = code;
968       return;
969     }
970
971   warnmsg = fold_deferred_overflow_warning;
972   fold_deferred_overflow_warning = NULL;
973
974   if (!issue || warnmsg == NULL)
975     return;
976
977   if (stmt != NULL_TREE && TREE_NO_WARNING (stmt))
978     return;
979
980   /* Use the smallest code level when deciding to issue the
981      warning.  */
982   if (code == 0 || code > (int) fold_deferred_overflow_code)
983     code = fold_deferred_overflow_code;
984
985   if (!issue_strict_overflow_warning (code))
986     return;
987
988   if (stmt == NULL_TREE || !expr_has_location (stmt))
989     locus = input_location;
990   else
991     locus = expr_location (stmt);
992   warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg);
993 }
994
995 /* Stop deferring overflow warnings, ignoring any deferred
996    warnings.  */
997
998 void
999 fold_undefer_and_ignore_overflow_warnings (void)
1000 {
1001   fold_undefer_overflow_warnings (false, NULL_TREE, 0);
1002 }
1003
1004 /* Whether we are deferring overflow warnings.  */
1005
1006 bool
1007 fold_deferring_overflow_warnings_p (void)
1008 {
1009   return fold_deferring_overflow_warnings > 0;
1010 }
1011
1012 /* This is called when we fold something based on the fact that signed
1013    overflow is undefined.  */
1014
1015 static void
1016 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
1017 {
1018   gcc_assert (!flag_wrapv && !flag_trapv);
1019   if (fold_deferring_overflow_warnings > 0)
1020     {
1021       if (fold_deferred_overflow_warning == NULL
1022           || wc < fold_deferred_overflow_code)
1023         {
1024           fold_deferred_overflow_warning = gmsgid;
1025           fold_deferred_overflow_code = wc;
1026         }
1027     }
1028   else if (issue_strict_overflow_warning (wc))
1029     warning (OPT_Wstrict_overflow, gmsgid);
1030 }
1031 \f
1032 /* Return true if the built-in mathematical function specified by CODE
1033    is odd, i.e. -f(x) == f(-x).  */
1034
1035 static bool
1036 negate_mathfn_p (enum built_in_function code)
1037 {
1038   switch (code)
1039     {
1040     CASE_FLT_FN (BUILT_IN_ASIN):
1041     CASE_FLT_FN (BUILT_IN_ASINH):
1042     CASE_FLT_FN (BUILT_IN_ATAN):
1043     CASE_FLT_FN (BUILT_IN_ATANH):
1044     CASE_FLT_FN (BUILT_IN_CASIN):
1045     CASE_FLT_FN (BUILT_IN_CASINH):
1046     CASE_FLT_FN (BUILT_IN_CATAN):
1047     CASE_FLT_FN (BUILT_IN_CATANH):
1048     CASE_FLT_FN (BUILT_IN_CBRT):
1049     CASE_FLT_FN (BUILT_IN_CPROJ):
1050     CASE_FLT_FN (BUILT_IN_CSIN):
1051     CASE_FLT_FN (BUILT_IN_CSINH):
1052     CASE_FLT_FN (BUILT_IN_CTAN):
1053     CASE_FLT_FN (BUILT_IN_CTANH):
1054     CASE_FLT_FN (BUILT_IN_ERF):
1055     CASE_FLT_FN (BUILT_IN_LLROUND):
1056     CASE_FLT_FN (BUILT_IN_LROUND):
1057     CASE_FLT_FN (BUILT_IN_ROUND):
1058     CASE_FLT_FN (BUILT_IN_SIN):
1059     CASE_FLT_FN (BUILT_IN_SINH):
1060     CASE_FLT_FN (BUILT_IN_TAN):
1061     CASE_FLT_FN (BUILT_IN_TANH):
1062     CASE_FLT_FN (BUILT_IN_TRUNC):
1063       return true;
1064
1065     CASE_FLT_FN (BUILT_IN_LLRINT):
1066     CASE_FLT_FN (BUILT_IN_LRINT):
1067     CASE_FLT_FN (BUILT_IN_NEARBYINT):
1068     CASE_FLT_FN (BUILT_IN_RINT):
1069       return !flag_rounding_math;
1070     
1071     default:
1072       break;
1073     }
1074   return false;
1075 }
1076
1077 /* Check whether we may negate an integer constant T without causing
1078    overflow.  */
1079
1080 bool
1081 may_negate_without_overflow_p (const_tree t)
1082 {
1083   unsigned HOST_WIDE_INT val;
1084   unsigned int prec;
1085   tree type;
1086
1087   gcc_assert (TREE_CODE (t) == INTEGER_CST);
1088
1089   type = TREE_TYPE (t);
1090   if (TYPE_UNSIGNED (type))
1091     return false;
1092
1093   prec = TYPE_PRECISION (type);
1094   if (prec > HOST_BITS_PER_WIDE_INT)
1095     {
1096       if (TREE_INT_CST_LOW (t) != 0)
1097         return true;
1098       prec -= HOST_BITS_PER_WIDE_INT;
1099       val = TREE_INT_CST_HIGH (t);
1100     }
1101   else
1102     val = TREE_INT_CST_LOW (t);
1103   if (prec < HOST_BITS_PER_WIDE_INT)
1104     val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1105   return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
1106 }
1107
1108 /* Determine whether an expression T can be cheaply negated using
1109    the function negate_expr without introducing undefined overflow.  */
1110
1111 static bool
1112 negate_expr_p (tree t)
1113 {
1114   tree type;
1115
1116   if (t == 0)
1117     return false;
1118
1119   type = TREE_TYPE (t);
1120
1121   STRIP_SIGN_NOPS (t);
1122   switch (TREE_CODE (t))
1123     {
1124     case INTEGER_CST:
1125       if (TYPE_OVERFLOW_WRAPS (type))
1126         return true;
1127
1128       /* Check that -CST will not overflow type.  */
1129       return may_negate_without_overflow_p (t);
1130     case BIT_NOT_EXPR:
1131       return (INTEGRAL_TYPE_P (type)
1132               && TYPE_OVERFLOW_WRAPS (type));
1133
1134     case FIXED_CST:
1135     case REAL_CST:
1136     case NEGATE_EXPR:
1137       return true;
1138
1139     case COMPLEX_CST:
1140       return negate_expr_p (TREE_REALPART (t))
1141              && negate_expr_p (TREE_IMAGPART (t));
1142
1143     case COMPLEX_EXPR:
1144       return negate_expr_p (TREE_OPERAND (t, 0))
1145              && negate_expr_p (TREE_OPERAND (t, 1));
1146
1147     case CONJ_EXPR:
1148       return negate_expr_p (TREE_OPERAND (t, 0));
1149
1150     case PLUS_EXPR:
1151       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1152           || HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
1153         return false;
1154       /* -(A + B) -> (-B) - A.  */
1155       if (negate_expr_p (TREE_OPERAND (t, 1))
1156           && reorder_operands_p (TREE_OPERAND (t, 0),
1157                                  TREE_OPERAND (t, 1)))
1158         return true;
1159       /* -(A + B) -> (-A) - B.  */
1160       return negate_expr_p (TREE_OPERAND (t, 0));
1161
1162     case MINUS_EXPR:
1163       /* We can't turn -(A-B) into B-A when we honor signed zeros.  */
1164       return !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1165              && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
1166              && reorder_operands_p (TREE_OPERAND (t, 0),
1167                                     TREE_OPERAND (t, 1));
1168
1169     case MULT_EXPR:
1170       if (TYPE_UNSIGNED (TREE_TYPE (t)))
1171         break;
1172
1173       /* Fall through.  */
1174
1175     case RDIV_EXPR:
1176       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
1177         return negate_expr_p (TREE_OPERAND (t, 1))
1178                || negate_expr_p (TREE_OPERAND (t, 0));
1179       break;
1180
1181     case TRUNC_DIV_EXPR:
1182     case ROUND_DIV_EXPR:
1183     case FLOOR_DIV_EXPR:
1184     case CEIL_DIV_EXPR:
1185     case EXACT_DIV_EXPR:
1186       /* In general we can't negate A / B, because if A is INT_MIN and
1187          B is 1, we may turn this into INT_MIN / -1 which is undefined
1188          and actually traps on some architectures.  But if overflow is
1189          undefined, we can negate, because - (INT_MIN / 1) is an
1190          overflow.  */
1191       if (INTEGRAL_TYPE_P (TREE_TYPE (t))
1192           && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
1193         break;
1194       return negate_expr_p (TREE_OPERAND (t, 1))
1195              || negate_expr_p (TREE_OPERAND (t, 0));
1196
1197     case NOP_EXPR:
1198       /* Negate -((double)float) as (double)(-float).  */
1199       if (TREE_CODE (type) == REAL_TYPE)
1200         {
1201           tree tem = strip_float_extensions (t);
1202           if (tem != t)
1203             return negate_expr_p (tem);
1204         }
1205       break;
1206
1207     case CALL_EXPR:
1208       /* Negate -f(x) as f(-x).  */
1209       if (negate_mathfn_p (builtin_mathfn_code (t)))
1210         return negate_expr_p (CALL_EXPR_ARG (t, 0));
1211       break;
1212
1213     case RSHIFT_EXPR:
1214       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1215       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1216         {
1217           tree op1 = TREE_OPERAND (t, 1);
1218           if (TREE_INT_CST_HIGH (op1) == 0
1219               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1220                  == TREE_INT_CST_LOW (op1))
1221             return true;
1222         }
1223       break;
1224
1225     default:
1226       break;
1227     }
1228   return false;
1229 }
1230
1231 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
1232    simplification is possible.
1233    If negate_expr_p would return true for T, NULL_TREE will never be
1234    returned.  */
1235
1236 static tree
1237 fold_negate_expr (tree t)
1238 {
1239   tree type = TREE_TYPE (t);
1240   tree tem;
1241
1242   switch (TREE_CODE (t))
1243     {
1244     /* Convert - (~A) to A + 1.  */
1245     case BIT_NOT_EXPR:
1246       if (INTEGRAL_TYPE_P (type))
1247         return fold_build2 (PLUS_EXPR, type, TREE_OPERAND (t, 0),
1248                             build_int_cst (type, 1));
1249       break;
1250       
1251     case INTEGER_CST:
1252       tem = fold_negate_const (t, type);
1253       if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
1254           || !TYPE_OVERFLOW_TRAPS (type))
1255         return tem;
1256       break;
1257
1258     case REAL_CST:
1259       tem = fold_negate_const (t, type);
1260       /* Two's complement FP formats, such as c4x, may overflow.  */
1261       if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
1262         return tem;
1263       break;
1264
1265     case FIXED_CST:
1266       tem = fold_negate_const (t, type);
1267       return tem;
1268
1269     case COMPLEX_CST:
1270       {
1271         tree rpart = negate_expr (TREE_REALPART (t));
1272         tree ipart = negate_expr (TREE_IMAGPART (t));
1273
1274         if ((TREE_CODE (rpart) == REAL_CST
1275              && TREE_CODE (ipart) == REAL_CST)
1276             || (TREE_CODE (rpart) == INTEGER_CST
1277                 && TREE_CODE (ipart) == INTEGER_CST))
1278           return build_complex (type, rpart, ipart);
1279       }
1280       break;
1281
1282     case COMPLEX_EXPR:
1283       if (negate_expr_p (t))
1284         return fold_build2 (COMPLEX_EXPR, type,
1285                             fold_negate_expr (TREE_OPERAND (t, 0)),
1286                             fold_negate_expr (TREE_OPERAND (t, 1)));
1287       break;
1288       
1289     case CONJ_EXPR:
1290       if (negate_expr_p (t))
1291         return fold_build1 (CONJ_EXPR, type,
1292                             fold_negate_expr (TREE_OPERAND (t, 0)));
1293       break;
1294
1295     case NEGATE_EXPR:
1296       return TREE_OPERAND (t, 0);
1297
1298     case PLUS_EXPR:
1299       if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1300           && !HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
1301         {
1302           /* -(A + B) -> (-B) - A.  */
1303           if (negate_expr_p (TREE_OPERAND (t, 1))
1304               && reorder_operands_p (TREE_OPERAND (t, 0),
1305                                      TREE_OPERAND (t, 1)))
1306             {
1307               tem = negate_expr (TREE_OPERAND (t, 1));
1308               return fold_build2 (MINUS_EXPR, type,
1309                                   tem, TREE_OPERAND (t, 0));
1310             }
1311
1312           /* -(A + B) -> (-A) - B.  */
1313           if (negate_expr_p (TREE_OPERAND (t, 0)))
1314             {
1315               tem = negate_expr (TREE_OPERAND (t, 0));
1316               return fold_build2 (MINUS_EXPR, type,
1317                                   tem, TREE_OPERAND (t, 1));
1318             }
1319         }
1320       break;
1321
1322     case MINUS_EXPR:
1323       /* - (A - B) -> B - A  */
1324       if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1325           && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
1326           && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
1327         return fold_build2 (MINUS_EXPR, type,
1328                             TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
1329       break;
1330
1331     case MULT_EXPR:
1332       if (TYPE_UNSIGNED (type))
1333         break;
1334
1335       /* Fall through.  */
1336
1337     case RDIV_EXPR:
1338       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
1339         {
1340           tem = TREE_OPERAND (t, 1);
1341           if (negate_expr_p (tem))
1342             return fold_build2 (TREE_CODE (t), type,
1343                                 TREE_OPERAND (t, 0), negate_expr (tem));
1344           tem = TREE_OPERAND (t, 0);
1345           if (negate_expr_p (tem))
1346             return fold_build2 (TREE_CODE (t), type,
1347                                 negate_expr (tem), TREE_OPERAND (t, 1));
1348         }
1349       break;
1350
1351     case TRUNC_DIV_EXPR:
1352     case ROUND_DIV_EXPR:
1353     case FLOOR_DIV_EXPR:
1354     case CEIL_DIV_EXPR:
1355     case EXACT_DIV_EXPR:
1356       /* In general we can't negate A / B, because if A is INT_MIN and
1357          B is 1, we may turn this into INT_MIN / -1 which is undefined
1358          and actually traps on some architectures.  But if overflow is
1359          undefined, we can negate, because - (INT_MIN / 1) is an
1360          overflow.  */
1361       if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
1362         {
1363           const char * const warnmsg = G_("assuming signed overflow does not "
1364                                           "occur when negating a division");
1365           tem = TREE_OPERAND (t, 1);
1366           if (negate_expr_p (tem))
1367             {
1368               if (INTEGRAL_TYPE_P (type)
1369                   && (TREE_CODE (tem) != INTEGER_CST
1370                       || integer_onep (tem)))
1371                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
1372               return fold_build2 (TREE_CODE (t), type,
1373                                   TREE_OPERAND (t, 0), negate_expr (tem));
1374             }
1375           tem = TREE_OPERAND (t, 0);
1376           if (negate_expr_p (tem))
1377             {
1378               if (INTEGRAL_TYPE_P (type)
1379                   && (TREE_CODE (tem) != INTEGER_CST
1380                       || tree_int_cst_equal (tem, TYPE_MIN_VALUE (type))))
1381                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
1382               return fold_build2 (TREE_CODE (t), type,
1383                                   negate_expr (tem), TREE_OPERAND (t, 1));
1384             }
1385         }
1386       break;
1387
1388     case NOP_EXPR:
1389       /* Convert -((double)float) into (double)(-float).  */
1390       if (TREE_CODE (type) == REAL_TYPE)
1391         {
1392           tem = strip_float_extensions (t);
1393           if (tem != t && negate_expr_p (tem))
1394             return fold_convert (type, negate_expr (tem));
1395         }
1396       break;
1397
1398     case CALL_EXPR:
1399       /* Negate -f(x) as f(-x).  */
1400       if (negate_mathfn_p (builtin_mathfn_code (t))
1401           && negate_expr_p (CALL_EXPR_ARG (t, 0)))
1402         {
1403           tree fndecl, arg;
1404
1405           fndecl = get_callee_fndecl (t);
1406           arg = negate_expr (CALL_EXPR_ARG (t, 0));
1407           return build_call_expr (fndecl, 1, arg);
1408         }
1409       break;
1410
1411     case RSHIFT_EXPR:
1412       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1413       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1414         {
1415           tree op1 = TREE_OPERAND (t, 1);
1416           if (TREE_INT_CST_HIGH (op1) == 0
1417               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1418                  == TREE_INT_CST_LOW (op1))
1419             {
1420               tree ntype = TYPE_UNSIGNED (type)
1421                            ? signed_type_for (type)
1422                            : unsigned_type_for (type);
1423               tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
1424               temp = fold_build2 (RSHIFT_EXPR, ntype, temp, op1);
1425               return fold_convert (type, temp);
1426             }
1427         }
1428       break;
1429
1430     default:
1431       break;
1432     }
1433
1434   return NULL_TREE;
1435 }
1436
1437 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
1438    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
1439    return NULL_TREE. */
1440
1441 static tree
1442 negate_expr (tree t)
1443 {
1444   tree type, tem;
1445
1446   if (t == NULL_TREE)
1447     return NULL_TREE;
1448
1449   type = TREE_TYPE (t);
1450   STRIP_SIGN_NOPS (t);
1451
1452   tem = fold_negate_expr (t);
1453   if (!tem)
1454     tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
1455   return fold_convert (type, tem);
1456 }
1457 \f
1458 /* Split a tree IN into a constant, literal and variable parts that could be
1459    combined with CODE to make IN.  "constant" means an expression with
1460    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
1461    commutative arithmetic operation.  Store the constant part into *CONP,
1462    the literal in *LITP and return the variable part.  If a part isn't
1463    present, set it to null.  If the tree does not decompose in this way,
1464    return the entire tree as the variable part and the other parts as null.
1465
1466    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
1467    case, we negate an operand that was subtracted.  Except if it is a
1468    literal for which we use *MINUS_LITP instead.
1469
1470    If NEGATE_P is true, we are negating all of IN, again except a literal
1471    for which we use *MINUS_LITP instead.
1472
1473    If IN is itself a literal or constant, return it as appropriate.
1474
1475    Note that we do not guarantee that any of the three values will be the
1476    same type as IN, but they will have the same signedness and mode.  */
1477
1478 static tree
1479 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
1480             tree *minus_litp, int negate_p)
1481 {
1482   tree var = 0;
1483
1484   *conp = 0;
1485   *litp = 0;
1486   *minus_litp = 0;
1487
1488   /* Strip any conversions that don't change the machine mode or signedness.  */
1489   STRIP_SIGN_NOPS (in);
1490
1491   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
1492       || TREE_CODE (in) == FIXED_CST)
1493     *litp = in;
1494   else if (TREE_CODE (in) == code
1495            || (! FLOAT_TYPE_P (TREE_TYPE (in))
1496                && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
1497                /* We can associate addition and subtraction together (even
1498                   though the C standard doesn't say so) for integers because
1499                   the value is not affected.  For reals, the value might be
1500                   affected, so we can't.  */
1501                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1502                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1503     {
1504       tree op0 = TREE_OPERAND (in, 0);
1505       tree op1 = TREE_OPERAND (in, 1);
1506       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
1507       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
1508
1509       /* First see if either of the operands is a literal, then a constant.  */
1510       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
1511           || TREE_CODE (op0) == FIXED_CST)
1512         *litp = op0, op0 = 0;
1513       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
1514                || TREE_CODE (op1) == FIXED_CST)
1515         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
1516
1517       if (op0 != 0 && TREE_CONSTANT (op0))
1518         *conp = op0, op0 = 0;
1519       else if (op1 != 0 && TREE_CONSTANT (op1))
1520         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
1521
1522       /* If we haven't dealt with either operand, this is not a case we can
1523          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
1524       if (op0 != 0 && op1 != 0)
1525         var = in;
1526       else if (op0 != 0)
1527         var = op0;
1528       else
1529         var = op1, neg_var_p = neg1_p;
1530
1531       /* Now do any needed negations.  */
1532       if (neg_litp_p)
1533         *minus_litp = *litp, *litp = 0;
1534       if (neg_conp_p)
1535         *conp = negate_expr (*conp);
1536       if (neg_var_p)
1537         var = negate_expr (var);
1538     }
1539   else if (TREE_CONSTANT (in))
1540     *conp = in;
1541   else
1542     var = in;
1543
1544   if (negate_p)
1545     {
1546       if (*litp)
1547         *minus_litp = *litp, *litp = 0;
1548       else if (*minus_litp)
1549         *litp = *minus_litp, *minus_litp = 0;
1550       *conp = negate_expr (*conp);
1551       var = negate_expr (var);
1552     }
1553
1554   return var;
1555 }
1556
1557 /* Re-associate trees split by the above function.  T1 and T2 are either
1558    expressions to associate or null.  Return the new expression, if any.  If
1559    we build an operation, do it in TYPE and with CODE.  */
1560
1561 static tree
1562 associate_trees (tree t1, tree t2, enum tree_code code, tree type)
1563 {
1564   if (t1 == 0)
1565     return t2;
1566   else if (t2 == 0)
1567     return t1;
1568
1569   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1570      try to fold this since we will have infinite recursion.  But do
1571      deal with any NEGATE_EXPRs.  */
1572   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1573       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1574     {
1575       if (code == PLUS_EXPR)
1576         {
1577           if (TREE_CODE (t1) == NEGATE_EXPR)
1578             return build2 (MINUS_EXPR, type, fold_convert (type, t2),
1579                            fold_convert (type, TREE_OPERAND (t1, 0)));
1580           else if (TREE_CODE (t2) == NEGATE_EXPR)
1581             return build2 (MINUS_EXPR, type, fold_convert (type, t1),
1582                            fold_convert (type, TREE_OPERAND (t2, 0)));
1583           else if (integer_zerop (t2))
1584             return fold_convert (type, t1);
1585         }
1586       else if (code == MINUS_EXPR)
1587         {
1588           if (integer_zerop (t2))
1589             return fold_convert (type, t1);
1590         }
1591
1592       return build2 (code, type, fold_convert (type, t1),
1593                      fold_convert (type, t2));
1594     }
1595
1596   return fold_build2 (code, type, fold_convert (type, t1),
1597                       fold_convert (type, t2));
1598 }
1599 \f
1600 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
1601    for use in int_const_binop, size_binop and size_diffop.  */
1602
1603 static bool
1604 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
1605 {
1606   if (TREE_CODE (type1) != INTEGER_TYPE && !POINTER_TYPE_P (type1))
1607     return false;
1608   if (TREE_CODE (type2) != INTEGER_TYPE && !POINTER_TYPE_P (type2))
1609     return false;
1610
1611   switch (code)
1612     {
1613     case LSHIFT_EXPR:
1614     case RSHIFT_EXPR:
1615     case LROTATE_EXPR:
1616     case RROTATE_EXPR:
1617       return true;
1618
1619     default:
1620       break;
1621     }
1622
1623   return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
1624          && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
1625          && TYPE_MODE (type1) == TYPE_MODE (type2);
1626 }
1627
1628
1629 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1630    to produce a new constant.  Return NULL_TREE if we don't know how
1631    to evaluate CODE at compile-time.
1632
1633    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1634
1635 tree
1636 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2, int notrunc)
1637 {
1638   unsigned HOST_WIDE_INT int1l, int2l;
1639   HOST_WIDE_INT int1h, int2h;
1640   unsigned HOST_WIDE_INT low;
1641   HOST_WIDE_INT hi;
1642   unsigned HOST_WIDE_INT garbagel;
1643   HOST_WIDE_INT garbageh;
1644   tree t;
1645   tree type = TREE_TYPE (arg1);
1646   int uns = TYPE_UNSIGNED (type);
1647   int is_sizetype
1648     = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
1649   int overflow = 0;
1650
1651   int1l = TREE_INT_CST_LOW (arg1);
1652   int1h = TREE_INT_CST_HIGH (arg1);
1653   int2l = TREE_INT_CST_LOW (arg2);
1654   int2h = TREE_INT_CST_HIGH (arg2);
1655
1656   switch (code)
1657     {
1658     case BIT_IOR_EXPR:
1659       low = int1l | int2l, hi = int1h | int2h;
1660       break;
1661
1662     case BIT_XOR_EXPR:
1663       low = int1l ^ int2l, hi = int1h ^ int2h;
1664       break;
1665
1666     case BIT_AND_EXPR:
1667       low = int1l & int2l, hi = int1h & int2h;
1668       break;
1669
1670     case RSHIFT_EXPR:
1671       int2l = -int2l;
1672     case LSHIFT_EXPR:
1673       /* It's unclear from the C standard whether shifts can overflow.
1674          The following code ignores overflow; perhaps a C standard
1675          interpretation ruling is needed.  */
1676       lshift_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1677                      &low, &hi, !uns);
1678       break;
1679
1680     case RROTATE_EXPR:
1681       int2l = - int2l;
1682     case LROTATE_EXPR:
1683       lrotate_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1684                       &low, &hi);
1685       break;
1686
1687     case PLUS_EXPR:
1688       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1689       break;
1690
1691     case MINUS_EXPR:
1692       neg_double (int2l, int2h, &low, &hi);
1693       add_double (int1l, int1h, low, hi, &low, &hi);
1694       overflow = OVERFLOW_SUM_SIGN (hi, int2h, int1h);
1695       break;
1696
1697     case MULT_EXPR:
1698       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1699       break;
1700
1701     case TRUNC_DIV_EXPR:
1702     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1703     case EXACT_DIV_EXPR:
1704       /* This is a shortcut for a common special case.  */
1705       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1706           && !TREE_OVERFLOW (arg1)
1707           && !TREE_OVERFLOW (arg2)
1708           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1709         {
1710           if (code == CEIL_DIV_EXPR)
1711             int1l += int2l - 1;
1712
1713           low = int1l / int2l, hi = 0;
1714           break;
1715         }
1716
1717       /* ... fall through ...  */
1718
1719     case ROUND_DIV_EXPR:
1720       if (int2h == 0 && int2l == 0)
1721         return NULL_TREE;
1722       if (int2h == 0 && int2l == 1)
1723         {
1724           low = int1l, hi = int1h;
1725           break;
1726         }
1727       if (int1l == int2l && int1h == int2h
1728           && ! (int1l == 0 && int1h == 0))
1729         {
1730           low = 1, hi = 0;
1731           break;
1732         }
1733       overflow = div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1734                                        &low, &hi, &garbagel, &garbageh);
1735       break;
1736
1737     case TRUNC_MOD_EXPR:
1738     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1739       /* This is a shortcut for a common special case.  */
1740       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1741           && !TREE_OVERFLOW (arg1)
1742           && !TREE_OVERFLOW (arg2)
1743           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1744         {
1745           if (code == CEIL_MOD_EXPR)
1746             int1l += int2l - 1;
1747           low = int1l % int2l, hi = 0;
1748           break;
1749         }
1750
1751       /* ... fall through ...  */
1752
1753     case ROUND_MOD_EXPR:
1754       if (int2h == 0 && int2l == 0)
1755         return NULL_TREE;
1756       overflow = div_and_round_double (code, uns,
1757                                        int1l, int1h, int2l, int2h,
1758                                        &garbagel, &garbageh, &low, &hi);
1759       break;
1760
1761     case MIN_EXPR:
1762     case MAX_EXPR:
1763       if (uns)
1764         low = (((unsigned HOST_WIDE_INT) int1h
1765                 < (unsigned HOST_WIDE_INT) int2h)
1766                || (((unsigned HOST_WIDE_INT) int1h
1767                     == (unsigned HOST_WIDE_INT) int2h)
1768                    && int1l < int2l));
1769       else
1770         low = (int1h < int2h
1771                || (int1h == int2h && int1l < int2l));
1772
1773       if (low == (code == MIN_EXPR))
1774         low = int1l, hi = int1h;
1775       else
1776         low = int2l, hi = int2h;
1777       break;
1778
1779     default:
1780       return NULL_TREE;
1781     }
1782
1783   if (notrunc)
1784     {
1785       t = build_int_cst_wide (TREE_TYPE (arg1), low, hi);
1786
1787       /* Propagate overflow flags ourselves.  */
1788       if (((!uns || is_sizetype) && overflow)
1789           | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1790         {
1791           t = copy_node (t);
1792           TREE_OVERFLOW (t) = 1;
1793         }
1794     }
1795   else
1796     t = force_fit_type_double (TREE_TYPE (arg1), low, hi, 1,
1797                                ((!uns || is_sizetype) && overflow)
1798                                | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1799
1800   return t;
1801 }
1802
1803 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1804    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1805    are the same kind of constant and the same machine mode.  Return zero if
1806    combining the constants is not allowed in the current operating mode.
1807
1808    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1809
1810 static tree
1811 const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1812 {
1813   /* Sanity check for the recursive cases.  */
1814   if (!arg1 || !arg2)
1815     return NULL_TREE;
1816
1817   STRIP_NOPS (arg1);
1818   STRIP_NOPS (arg2);
1819
1820   if (TREE_CODE (arg1) == INTEGER_CST)
1821     return int_const_binop (code, arg1, arg2, notrunc);
1822
1823   if (TREE_CODE (arg1) == REAL_CST)
1824     {
1825       enum machine_mode mode;
1826       REAL_VALUE_TYPE d1;
1827       REAL_VALUE_TYPE d2;
1828       REAL_VALUE_TYPE value;
1829       REAL_VALUE_TYPE result;
1830       bool inexact;
1831       tree t, type;
1832
1833       /* The following codes are handled by real_arithmetic.  */
1834       switch (code)
1835         {
1836         case PLUS_EXPR:
1837         case MINUS_EXPR:
1838         case MULT_EXPR:
1839         case RDIV_EXPR:
1840         case MIN_EXPR:
1841         case MAX_EXPR:
1842           break;
1843
1844         default:
1845           return NULL_TREE;
1846         }
1847
1848       d1 = TREE_REAL_CST (arg1);
1849       d2 = TREE_REAL_CST (arg2);
1850
1851       type = TREE_TYPE (arg1);
1852       mode = TYPE_MODE (type);
1853
1854       /* Don't perform operation if we honor signaling NaNs and
1855          either operand is a NaN.  */
1856       if (HONOR_SNANS (mode)
1857           && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1858         return NULL_TREE;
1859
1860       /* Don't perform operation if it would raise a division
1861          by zero exception.  */
1862       if (code == RDIV_EXPR
1863           && REAL_VALUES_EQUAL (d2, dconst0)
1864           && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1865         return NULL_TREE;
1866
1867       /* If either operand is a NaN, just return it.  Otherwise, set up
1868          for floating-point trap; we return an overflow.  */
1869       if (REAL_VALUE_ISNAN (d1))
1870         return arg1;
1871       else if (REAL_VALUE_ISNAN (d2))
1872         return arg2;
1873
1874       inexact = real_arithmetic (&value, code, &d1, &d2);
1875       real_convert (&result, mode, &value);
1876
1877       /* Don't constant fold this floating point operation if
1878          the result has overflowed and flag_trapping_math.  */
1879       if (flag_trapping_math
1880           && MODE_HAS_INFINITIES (mode)
1881           && REAL_VALUE_ISINF (result)
1882           && !REAL_VALUE_ISINF (d1)
1883           && !REAL_VALUE_ISINF (d2))
1884         return NULL_TREE;
1885
1886       /* Don't constant fold this floating point operation if the
1887          result may dependent upon the run-time rounding mode and
1888          flag_rounding_math is set, or if GCC's software emulation
1889          is unable to accurately represent the result.  */
1890       if ((flag_rounding_math
1891            || (REAL_MODE_FORMAT_COMPOSITE_P (mode)
1892                && !flag_unsafe_math_optimizations))
1893           && (inexact || !real_identical (&result, &value)))
1894         return NULL_TREE;
1895
1896       t = build_real (type, result);
1897
1898       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1899       return t;
1900     }
1901
1902   if (TREE_CODE (arg1) == FIXED_CST)
1903     {
1904       FIXED_VALUE_TYPE f1;
1905       FIXED_VALUE_TYPE f2;
1906       FIXED_VALUE_TYPE result;
1907       tree t, type;
1908       int sat_p;
1909       bool overflow_p;
1910
1911       /* The following codes are handled by fixed_arithmetic.  */
1912       switch (code)
1913         {
1914         case PLUS_EXPR:
1915         case MINUS_EXPR:
1916         case MULT_EXPR:
1917         case TRUNC_DIV_EXPR:
1918           f2 = TREE_FIXED_CST (arg2);
1919           break;
1920
1921         case LSHIFT_EXPR:
1922         case RSHIFT_EXPR:
1923           f2.data.high = TREE_INT_CST_HIGH (arg2);
1924           f2.data.low = TREE_INT_CST_LOW (arg2);
1925           f2.mode = SImode;
1926           break;
1927
1928         default:
1929           return NULL_TREE;
1930         }
1931
1932       f1 = TREE_FIXED_CST (arg1);
1933       type = TREE_TYPE (arg1);
1934       sat_p = TYPE_SATURATING (type);
1935       overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1936       t = build_fixed (type, result);
1937       /* Propagate overflow flags.  */
1938       if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1939         {
1940           TREE_OVERFLOW (t) = 1;
1941           TREE_CONSTANT_OVERFLOW (t) = 1;
1942         }
1943       else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
1944         TREE_CONSTANT_OVERFLOW (t) = 1;
1945       return t;
1946     }
1947
1948   if (TREE_CODE (arg1) == COMPLEX_CST)
1949     {
1950       tree type = TREE_TYPE (arg1);
1951       tree r1 = TREE_REALPART (arg1);
1952       tree i1 = TREE_IMAGPART (arg1);
1953       tree r2 = TREE_REALPART (arg2);
1954       tree i2 = TREE_IMAGPART (arg2);
1955       tree real, imag;
1956
1957       switch (code)
1958         {
1959         case PLUS_EXPR:
1960         case MINUS_EXPR:
1961           real = const_binop (code, r1, r2, notrunc);
1962           imag = const_binop (code, i1, i2, notrunc);
1963           break;
1964
1965         case MULT_EXPR:
1966           real = const_binop (MINUS_EXPR,
1967                               const_binop (MULT_EXPR, r1, r2, notrunc),
1968                               const_binop (MULT_EXPR, i1, i2, notrunc),
1969                               notrunc);
1970           imag = const_binop (PLUS_EXPR,
1971                               const_binop (MULT_EXPR, r1, i2, notrunc),
1972                               const_binop (MULT_EXPR, i1, r2, notrunc),
1973                               notrunc);
1974           break;
1975
1976         case RDIV_EXPR:
1977           {
1978             tree magsquared
1979               = const_binop (PLUS_EXPR,
1980                              const_binop (MULT_EXPR, r2, r2, notrunc),
1981                              const_binop (MULT_EXPR, i2, i2, notrunc),
1982                              notrunc);
1983             tree t1
1984               = const_binop (PLUS_EXPR,
1985                              const_binop (MULT_EXPR, r1, r2, notrunc),
1986                              const_binop (MULT_EXPR, i1, i2, notrunc),
1987                              notrunc);
1988             tree t2
1989               = const_binop (MINUS_EXPR,
1990                              const_binop (MULT_EXPR, i1, r2, notrunc),
1991                              const_binop (MULT_EXPR, r1, i2, notrunc),
1992                              notrunc);
1993
1994             if (INTEGRAL_TYPE_P (TREE_TYPE (r1)))
1995               code = TRUNC_DIV_EXPR;
1996
1997             real = const_binop (code, t1, magsquared, notrunc);
1998             imag = const_binop (code, t2, magsquared, notrunc);
1999           }
2000           break;
2001
2002         default:
2003           return NULL_TREE;
2004         }
2005
2006       if (real && imag)
2007         return build_complex (type, real, imag);
2008     }
2009
2010   return NULL_TREE;
2011 }
2012
2013 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
2014    indicates which particular sizetype to create.  */
2015
2016 tree
2017 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
2018 {
2019   return build_int_cst (sizetype_tab[(int) kind], number);
2020 }
2021 \f
2022 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
2023    is a tree code.  The type of the result is taken from the operands.
2024    Both must be equivalent integer types, ala int_binop_types_match_p.
2025    If the operands are constant, so is the result.  */
2026
2027 tree
2028 size_binop (enum tree_code code, tree arg0, tree arg1)
2029 {
2030   tree type = TREE_TYPE (arg0);
2031
2032   if (arg0 == error_mark_node || arg1 == error_mark_node)
2033     return error_mark_node;
2034
2035   gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
2036                                        TREE_TYPE (arg1)));
2037
2038   /* Handle the special case of two integer constants faster.  */
2039   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2040     {
2041       /* And some specific cases even faster than that.  */
2042       if (code == PLUS_EXPR)
2043         {
2044           if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
2045             return arg1;
2046           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
2047             return arg0;
2048         }
2049       else if (code == MINUS_EXPR)
2050         {
2051           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
2052             return arg0;
2053         }
2054       else if (code == MULT_EXPR)
2055         {
2056           if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
2057             return arg1;
2058         }
2059
2060       /* Handle general case of two integer constants.  */
2061       return int_const_binop (code, arg0, arg1, 0);
2062     }
2063
2064   return fold_build2 (code, type, arg0, arg1);
2065 }
2066
2067 /* Given two values, either both of sizetype or both of bitsizetype,
2068    compute the difference between the two values.  Return the value
2069    in signed type corresponding to the type of the operands.  */
2070
2071 tree
2072 size_diffop (tree arg0, tree arg1)
2073 {
2074   tree type = TREE_TYPE (arg0);
2075   tree ctype;
2076
2077   gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
2078                                        TREE_TYPE (arg1)));
2079
2080   /* If the type is already signed, just do the simple thing.  */
2081   if (!TYPE_UNSIGNED (type))
2082     return size_binop (MINUS_EXPR, arg0, arg1);
2083
2084   if (type == sizetype)
2085     ctype = ssizetype;
2086   else if (type == bitsizetype)
2087     ctype = sbitsizetype;
2088   else
2089     ctype = signed_type_for (type);
2090
2091   /* If either operand is not a constant, do the conversions to the signed
2092      type and subtract.  The hardware will do the right thing with any
2093      overflow in the subtraction.  */
2094   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
2095     return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
2096                        fold_convert (ctype, arg1));
2097
2098   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
2099      Otherwise, subtract the other way, convert to CTYPE (we know that can't
2100      overflow) and negate (which can't either).  Special-case a result
2101      of zero while we're here.  */
2102   if (tree_int_cst_equal (arg0, arg1))
2103     return build_int_cst (ctype, 0);
2104   else if (tree_int_cst_lt (arg1, arg0))
2105     return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
2106   else
2107     return size_binop (MINUS_EXPR, build_int_cst (ctype, 0),
2108                        fold_convert (ctype, size_binop (MINUS_EXPR,
2109                                                         arg1, arg0)));
2110 }
2111 \f
2112 /* A subroutine of fold_convert_const handling conversions of an
2113    INTEGER_CST to another integer type.  */
2114
2115 static tree
2116 fold_convert_const_int_from_int (tree type, const_tree arg1)
2117 {
2118   tree t;
2119
2120   /* Given an integer constant, make new constant with new type,
2121      appropriately sign-extended or truncated.  */
2122   t = force_fit_type_double (type, TREE_INT_CST_LOW (arg1),
2123                              TREE_INT_CST_HIGH (arg1),
2124                              /* Don't set the overflow when
2125                                 converting a pointer  */
2126                              !POINTER_TYPE_P (TREE_TYPE (arg1)),
2127                              (TREE_INT_CST_HIGH (arg1) < 0
2128                               && (TYPE_UNSIGNED (type)
2129                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
2130                              | TREE_OVERFLOW (arg1));
2131
2132   return t;
2133 }
2134
2135 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2136    to an integer type.  */
2137
2138 static tree
2139 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
2140 {
2141   int overflow = 0;
2142   tree t;
2143
2144   /* The following code implements the floating point to integer
2145      conversion rules required by the Java Language Specification,
2146      that IEEE NaNs are mapped to zero and values that overflow
2147      the target precision saturate, i.e. values greater than
2148      INT_MAX are mapped to INT_MAX, and values less than INT_MIN
2149      are mapped to INT_MIN.  These semantics are allowed by the
2150      C and C++ standards that simply state that the behavior of
2151      FP-to-integer conversion is unspecified upon overflow.  */
2152
2153   HOST_WIDE_INT high, low;
2154   REAL_VALUE_TYPE r;
2155   REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
2156
2157   switch (code)
2158     {
2159     case FIX_TRUNC_EXPR:
2160       real_trunc (&r, VOIDmode, &x);
2161       break;
2162
2163     default:
2164       gcc_unreachable ();
2165     }
2166
2167   /* If R is NaN, return zero and show we have an overflow.  */
2168   if (REAL_VALUE_ISNAN (r))
2169     {
2170       overflow = 1;
2171       high = 0;
2172       low = 0;
2173     }
2174
2175   /* See if R is less than the lower bound or greater than the
2176      upper bound.  */
2177
2178   if (! overflow)
2179     {
2180       tree lt = TYPE_MIN_VALUE (type);
2181       REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
2182       if (REAL_VALUES_LESS (r, l))
2183         {
2184           overflow = 1;
2185           high = TREE_INT_CST_HIGH (lt);
2186           low = TREE_INT_CST_LOW (lt);
2187         }
2188     }
2189
2190   if (! overflow)
2191     {
2192       tree ut = TYPE_MAX_VALUE (type);
2193       if (ut)
2194         {
2195           REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
2196           if (REAL_VALUES_LESS (u, r))
2197             {
2198               overflow = 1;
2199               high = TREE_INT_CST_HIGH (ut);
2200               low = TREE_INT_CST_LOW (ut);
2201             }
2202         }
2203     }
2204
2205   if (! overflow)
2206     REAL_VALUE_TO_INT (&low, &high, r);
2207
2208   t = force_fit_type_double (type, low, high, -1,
2209                              overflow | TREE_OVERFLOW (arg1));
2210   return t;
2211 }
2212
2213 /* A subroutine of fold_convert_const handling conversions of a
2214    FIXED_CST to an integer type.  */
2215
2216 static tree
2217 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
2218 {
2219   tree t;
2220   double_int temp, temp_trunc;
2221   unsigned int mode;
2222
2223   /* Right shift FIXED_CST to temp by fbit.  */
2224   temp = TREE_FIXED_CST (arg1).data;
2225   mode = TREE_FIXED_CST (arg1).mode;
2226   if (GET_MODE_FBIT (mode) < 2 * HOST_BITS_PER_WIDE_INT)
2227     {
2228       lshift_double (temp.low, temp.high,
2229                      - GET_MODE_FBIT (mode), 2 * HOST_BITS_PER_WIDE_INT,
2230                      &temp.low, &temp.high, SIGNED_FIXED_POINT_MODE_P (mode));
2231
2232       /* Left shift temp to temp_trunc by fbit.  */
2233       lshift_double (temp.low, temp.high,
2234                      GET_MODE_FBIT (mode), 2 * HOST_BITS_PER_WIDE_INT,
2235                      &temp_trunc.low, &temp_trunc.high,
2236                      SIGNED_FIXED_POINT_MODE_P (mode));
2237     }
2238   else
2239     {
2240       temp.low = 0;
2241       temp.high = 0;
2242       temp_trunc.low = 0;
2243       temp_trunc.high = 0;
2244     }
2245
2246   /* If FIXED_CST is negative, we need to round the value toward 0.
2247      By checking if the fractional bits are not zero to add 1 to temp.  */
2248   if (SIGNED_FIXED_POINT_MODE_P (mode) && temp_trunc.high < 0
2249       && !double_int_equal_p (TREE_FIXED_CST (arg1).data, temp_trunc))
2250     {
2251       double_int one;
2252       one.low = 1;
2253       one.high = 0;
2254       temp = double_int_add (temp, one);
2255     }
2256
2257   /* Given a fixed-point constant, make new constant with new type,
2258      appropriately sign-extended or truncated.  */
2259   t = force_fit_type_double (type, temp.low, temp.high, -1,
2260                              (temp.high < 0
2261                               && (TYPE_UNSIGNED (type)
2262                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
2263                              | TREE_OVERFLOW (arg1));
2264
2265   return t;
2266 }
2267
2268 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2269    to another floating point type.  */
2270
2271 static tree
2272 fold_convert_const_real_from_real (tree type, const_tree arg1)
2273 {
2274   REAL_VALUE_TYPE value;
2275   tree t;
2276
2277   real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
2278   t = build_real (type, value);
2279
2280   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2281   return t;
2282 }
2283
2284 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2285    to a floating point type.  */
2286
2287 static tree
2288 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
2289 {
2290   REAL_VALUE_TYPE value;
2291   tree t;
2292
2293   real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
2294   t = build_real (type, value);
2295
2296   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2297   TREE_CONSTANT_OVERFLOW (t)
2298     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2299   return t;
2300 }
2301
2302 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2303    to another fixed-point type.  */
2304
2305 static tree
2306 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
2307 {
2308   FIXED_VALUE_TYPE value;
2309   tree t;
2310   bool overflow_p;
2311
2312   overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
2313                               TYPE_SATURATING (type));
2314   t = build_fixed (type, value);
2315
2316   /* Propagate overflow flags.  */
2317   if (overflow_p | TREE_OVERFLOW (arg1))
2318     {
2319       TREE_OVERFLOW (t) = 1;
2320       TREE_CONSTANT_OVERFLOW (t) = 1;
2321     }
2322   else if (TREE_CONSTANT_OVERFLOW (arg1))
2323     TREE_CONSTANT_OVERFLOW (t) = 1;
2324   return t;
2325 }
2326
2327 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2328    to a fixed-point type.  */
2329
2330 static tree
2331 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
2332 {
2333   FIXED_VALUE_TYPE value;
2334   tree t;
2335   bool overflow_p;
2336
2337   overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
2338                                        TREE_INT_CST (arg1),
2339                                        TYPE_UNSIGNED (TREE_TYPE (arg1)),
2340                                        TYPE_SATURATING (type));
2341   t = build_fixed (type, value);
2342
2343   /* Propagate overflow flags.  */
2344   if (overflow_p | TREE_OVERFLOW (arg1))
2345     {
2346       TREE_OVERFLOW (t) = 1;
2347       TREE_CONSTANT_OVERFLOW (t) = 1;
2348     }
2349   else if (TREE_CONSTANT_OVERFLOW (arg1))
2350     TREE_CONSTANT_OVERFLOW (t) = 1;
2351   return t;
2352 }
2353
2354 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2355    to a fixed-point type.  */
2356
2357 static tree
2358 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
2359 {
2360   FIXED_VALUE_TYPE value;
2361   tree t;
2362   bool overflow_p;
2363
2364   overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
2365                                         &TREE_REAL_CST (arg1),
2366                                         TYPE_SATURATING (type));
2367   t = build_fixed (type, value);
2368
2369   /* Propagate overflow flags.  */
2370   if (overflow_p | TREE_OVERFLOW (arg1))
2371     {
2372       TREE_OVERFLOW (t) = 1;
2373       TREE_CONSTANT_OVERFLOW (t) = 1;
2374     }
2375   else if (TREE_CONSTANT_OVERFLOW (arg1))
2376     TREE_CONSTANT_OVERFLOW (t) = 1;
2377   return t;
2378 }
2379
2380 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2381    type TYPE.  If no simplification can be done return NULL_TREE.  */
2382
2383 static tree
2384 fold_convert_const (enum tree_code code, tree type, tree arg1)
2385 {
2386   if (TREE_TYPE (arg1) == type)
2387     return arg1;
2388
2389   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
2390     {
2391       if (TREE_CODE (arg1) == INTEGER_CST)
2392         return fold_convert_const_int_from_int (type, arg1);
2393       else if (TREE_CODE (arg1) == REAL_CST)
2394         return fold_convert_const_int_from_real (code, type, arg1);
2395       else if (TREE_CODE (arg1) == FIXED_CST)
2396         return fold_convert_const_int_from_fixed (type, arg1);
2397     }
2398   else if (TREE_CODE (type) == REAL_TYPE)
2399     {
2400       if (TREE_CODE (arg1) == INTEGER_CST)
2401         return build_real_from_int_cst (type, arg1);
2402       else if (TREE_CODE (arg1) == REAL_CST)
2403         return fold_convert_const_real_from_real (type, arg1);
2404       else if (TREE_CODE (arg1) == FIXED_CST)
2405         return fold_convert_const_real_from_fixed (type, arg1);
2406     }
2407   else if (TREE_CODE (type) == FIXED_POINT_TYPE)
2408     {
2409       if (TREE_CODE (arg1) == FIXED_CST)
2410         return fold_convert_const_fixed_from_fixed (type, arg1);
2411       else if (TREE_CODE (arg1) == INTEGER_CST)
2412         return fold_convert_const_fixed_from_int (type, arg1);
2413       else if (TREE_CODE (arg1) == REAL_CST)
2414         return fold_convert_const_fixed_from_real (type, arg1);
2415     }
2416   return NULL_TREE;
2417 }
2418
2419 /* Construct a vector of zero elements of vector type TYPE.  */
2420
2421 static tree
2422 build_zero_vector (tree type)
2423 {
2424   tree elem, list;
2425   int i, units;
2426
2427   elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2428   units = TYPE_VECTOR_SUBPARTS (type);
2429   
2430   list = NULL_TREE;
2431   for (i = 0; i < units; i++)
2432     list = tree_cons (NULL_TREE, elem, list);
2433   return build_vector (type, list);
2434 }
2435
2436 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR.  */
2437
2438 bool
2439 fold_convertible_p (const_tree type, const_tree arg)
2440 {
2441   tree orig = TREE_TYPE (arg);
2442
2443   if (type == orig)
2444     return true;
2445
2446   if (TREE_CODE (arg) == ERROR_MARK
2447       || TREE_CODE (type) == ERROR_MARK
2448       || TREE_CODE (orig) == ERROR_MARK)
2449     return false;
2450
2451   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2452     return true;
2453
2454   switch (TREE_CODE (type))
2455     {
2456     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2457     case POINTER_TYPE: case REFERENCE_TYPE:
2458     case OFFSET_TYPE:
2459       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2460           || TREE_CODE (orig) == OFFSET_TYPE)
2461         return true;
2462       return (TREE_CODE (orig) == VECTOR_TYPE
2463               && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2464
2465     default:
2466       return TREE_CODE (type) == TREE_CODE (orig);
2467     }
2468 }
2469
2470 /* Convert expression ARG to type TYPE.  Used by the middle-end for
2471    simple conversions in preference to calling the front-end's convert.  */
2472
2473 tree
2474 fold_convert (tree type, tree arg)
2475 {
2476   tree orig = TREE_TYPE (arg);
2477   tree tem;
2478
2479   if (type == orig)
2480     return arg;
2481
2482   if (TREE_CODE (arg) == ERROR_MARK
2483       || TREE_CODE (type) == ERROR_MARK
2484       || TREE_CODE (orig) == ERROR_MARK)
2485     return error_mark_node;
2486
2487   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2488     return fold_build1 (NOP_EXPR, type, arg);
2489
2490   switch (TREE_CODE (type))
2491     {
2492     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2493     case POINTER_TYPE: case REFERENCE_TYPE:
2494     case OFFSET_TYPE:
2495       if (TREE_CODE (arg) == INTEGER_CST)
2496         {
2497           tem = fold_convert_const (NOP_EXPR, type, arg);
2498           if (tem != NULL_TREE)
2499             return tem;
2500         }
2501       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2502           || TREE_CODE (orig) == OFFSET_TYPE)
2503         return fold_build1 (NOP_EXPR, type, arg);
2504       if (TREE_CODE (orig) == COMPLEX_TYPE)
2505         {
2506           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2507           return fold_convert (type, tem);
2508         }
2509       gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
2510                   && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2511       return fold_build1 (NOP_EXPR, type, arg);
2512
2513     case REAL_TYPE:
2514       if (TREE_CODE (arg) == INTEGER_CST)
2515         {
2516           tem = fold_convert_const (FLOAT_EXPR, type, arg);
2517           if (tem != NULL_TREE)
2518             return tem;
2519         }
2520       else if (TREE_CODE (arg) == REAL_CST)
2521         {
2522           tem = fold_convert_const (NOP_EXPR, type, arg);
2523           if (tem != NULL_TREE)
2524             return tem;
2525         }
2526       else if (TREE_CODE (arg) == FIXED_CST)
2527         {
2528           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2529           if (tem != NULL_TREE)
2530             return tem;
2531         }
2532
2533       switch (TREE_CODE (orig))
2534         {
2535         case INTEGER_TYPE:
2536         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2537         case POINTER_TYPE: case REFERENCE_TYPE:
2538           return fold_build1 (FLOAT_EXPR, type, arg);
2539
2540         case REAL_TYPE:
2541           return fold_build1 (NOP_EXPR, type, arg);
2542
2543         case FIXED_POINT_TYPE:
2544           return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
2545
2546         case COMPLEX_TYPE:
2547           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2548           return fold_convert (type, tem);
2549
2550         default:
2551           gcc_unreachable ();
2552         }
2553
2554     case FIXED_POINT_TYPE:
2555       if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
2556           || TREE_CODE (arg) == REAL_CST)
2557         {
2558           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2559           if (tem != NULL_TREE)
2560             return tem;
2561         }
2562
2563       switch (TREE_CODE (orig))
2564         {
2565         case FIXED_POINT_TYPE:
2566         case INTEGER_TYPE:
2567         case ENUMERAL_TYPE:
2568         case BOOLEAN_TYPE:
2569         case REAL_TYPE:
2570           return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
2571
2572         case COMPLEX_TYPE:
2573           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2574           return fold_convert (type, tem);
2575
2576         default:
2577           gcc_unreachable ();
2578         }
2579
2580     case COMPLEX_TYPE:
2581       switch (TREE_CODE (orig))
2582         {
2583         case INTEGER_TYPE:
2584         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2585         case POINTER_TYPE: case REFERENCE_TYPE:
2586         case REAL_TYPE:
2587         case FIXED_POINT_TYPE:
2588           return build2 (COMPLEX_EXPR, type,
2589                          fold_convert (TREE_TYPE (type), arg),
2590                          fold_convert (TREE_TYPE (type), integer_zero_node));
2591         case COMPLEX_TYPE:
2592           {
2593             tree rpart, ipart;
2594
2595             if (TREE_CODE (arg) == COMPLEX_EXPR)
2596               {
2597                 rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
2598                 ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
2599                 return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2600               }
2601
2602             arg = save_expr (arg);
2603             rpart = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2604             ipart = fold_build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg);
2605             rpart = fold_convert (TREE_TYPE (type), rpart);
2606             ipart = fold_convert (TREE_TYPE (type), ipart);
2607             return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2608           }
2609
2610         default:
2611           gcc_unreachable ();
2612         }
2613
2614     case VECTOR_TYPE:
2615       if (integer_zerop (arg))
2616         return build_zero_vector (type);
2617       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2618       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2619                   || TREE_CODE (orig) == VECTOR_TYPE);
2620       return fold_build1 (VIEW_CONVERT_EXPR, type, arg);
2621
2622     case VOID_TYPE:
2623       tem = fold_ignored_result (arg);
2624       if (TREE_CODE (tem) == GIMPLE_MODIFY_STMT)
2625         return tem;
2626       return fold_build1 (NOP_EXPR, type, tem);
2627
2628     default:
2629       gcc_unreachable ();
2630     }
2631 }
2632 \f
2633 /* Return false if expr can be assumed not to be an lvalue, true
2634    otherwise.  */
2635
2636 static bool
2637 maybe_lvalue_p (const_tree x)
2638 {
2639   /* We only need to wrap lvalue tree codes.  */
2640   switch (TREE_CODE (x))
2641   {
2642   case VAR_DECL:
2643   case PARM_DECL:
2644   case RESULT_DECL:
2645   case LABEL_DECL:
2646   case FUNCTION_DECL:
2647   case SSA_NAME:
2648
2649   case COMPONENT_REF:
2650   case INDIRECT_REF:
2651   case ALIGN_INDIRECT_REF:
2652   case MISALIGNED_INDIRECT_REF:
2653   case ARRAY_REF:
2654   case ARRAY_RANGE_REF:
2655   case BIT_FIELD_REF:
2656   case OBJ_TYPE_REF:
2657
2658   case REALPART_EXPR:
2659   case IMAGPART_EXPR:
2660   case PREINCREMENT_EXPR:
2661   case PREDECREMENT_EXPR:
2662   case SAVE_EXPR:
2663   case TRY_CATCH_EXPR:
2664   case WITH_CLEANUP_EXPR:
2665   case COMPOUND_EXPR:
2666   case MODIFY_EXPR:
2667   case GIMPLE_MODIFY_STMT:
2668   case TARGET_EXPR:
2669   case COND_EXPR:
2670   case BIND_EXPR:
2671   case MIN_EXPR:
2672   case MAX_EXPR:
2673     break;
2674
2675   default:
2676     /* Assume the worst for front-end tree codes.  */
2677     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2678       break;
2679     return false;
2680   }
2681
2682   return true;
2683 }
2684
2685 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2686
2687 tree
2688 non_lvalue (tree x)
2689 {
2690   /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2691      us.  */
2692   if (in_gimple_form)
2693     return x;
2694
2695   if (! maybe_lvalue_p (x))
2696     return x;
2697   return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2698 }
2699
2700 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2701    Zero means allow extended lvalues.  */
2702
2703 int pedantic_lvalues;
2704
2705 /* When pedantic, return an expr equal to X but certainly not valid as a
2706    pedantic lvalue.  Otherwise, return X.  */
2707
2708 static tree
2709 pedantic_non_lvalue (tree x)
2710 {
2711   if (pedantic_lvalues)
2712     return non_lvalue (x);
2713   else
2714     return x;
2715 }
2716 \f
2717 /* Given a tree comparison code, return the code that is the logical inverse
2718    of the given code.  It is not safe to do this for floating-point
2719    comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2720    as well: if reversing the comparison is unsafe, return ERROR_MARK.  */
2721
2722 enum tree_code
2723 invert_tree_comparison (enum tree_code code, bool honor_nans)
2724 {
2725   if (honor_nans && flag_trapping_math)
2726     return ERROR_MARK;
2727
2728   switch (code)
2729     {
2730     case EQ_EXPR:
2731       return NE_EXPR;
2732     case NE_EXPR:
2733       return EQ_EXPR;
2734     case GT_EXPR:
2735       return honor_nans ? UNLE_EXPR : LE_EXPR;
2736     case GE_EXPR:
2737       return honor_nans ? UNLT_EXPR : LT_EXPR;
2738     case LT_EXPR:
2739       return honor_nans ? UNGE_EXPR : GE_EXPR;
2740     case LE_EXPR:
2741       return honor_nans ? UNGT_EXPR : GT_EXPR;
2742     case LTGT_EXPR:
2743       return UNEQ_EXPR;
2744     case UNEQ_EXPR:
2745       return LTGT_EXPR;
2746     case UNGT_EXPR:
2747       return LE_EXPR;
2748     case UNGE_EXPR:
2749       return LT_EXPR;
2750     case UNLT_EXPR:
2751       return GE_EXPR;
2752     case UNLE_EXPR:
2753       return GT_EXPR;
2754     case ORDERED_EXPR:
2755       return UNORDERED_EXPR;
2756     case UNORDERED_EXPR:
2757       return ORDERED_EXPR;
2758     default:
2759       gcc_unreachable ();
2760     }
2761 }
2762
2763 /* Similar, but return the comparison that results if the operands are
2764    swapped.  This is safe for floating-point.  */
2765
2766 enum tree_code
2767 swap_tree_comparison (enum tree_code code)
2768 {
2769   switch (code)
2770     {
2771     case EQ_EXPR:
2772     case NE_EXPR:
2773     case ORDERED_EXPR:
2774     case UNORDERED_EXPR:
2775     case LTGT_EXPR:
2776     case UNEQ_EXPR:
2777       return code;
2778     case GT_EXPR:
2779       return LT_EXPR;
2780     case GE_EXPR:
2781       return LE_EXPR;
2782     case LT_EXPR:
2783       return GT_EXPR;
2784     case LE_EXPR:
2785       return GE_EXPR;
2786     case UNGT_EXPR:
2787       return UNLT_EXPR;
2788     case UNGE_EXPR:
2789       return UNLE_EXPR;
2790     case UNLT_EXPR:
2791       return UNGT_EXPR;
2792     case UNLE_EXPR:
2793       return UNGE_EXPR;
2794     default:
2795       gcc_unreachable ();
2796     }
2797 }
2798
2799
2800 /* Convert a comparison tree code from an enum tree_code representation
2801    into a compcode bit-based encoding.  This function is the inverse of
2802    compcode_to_comparison.  */
2803
2804 static enum comparison_code
2805 comparison_to_compcode (enum tree_code code)
2806 {
2807   switch (code)
2808     {
2809     case LT_EXPR:
2810       return COMPCODE_LT;
2811     case EQ_EXPR:
2812       return COMPCODE_EQ;
2813     case LE_EXPR:
2814       return COMPCODE_LE;
2815     case GT_EXPR:
2816       return COMPCODE_GT;
2817     case NE_EXPR:
2818       return COMPCODE_NE;
2819     case GE_EXPR:
2820       return COMPCODE_GE;
2821     case ORDERED_EXPR:
2822       return COMPCODE_ORD;
2823     case UNORDERED_EXPR:
2824       return COMPCODE_UNORD;
2825     case UNLT_EXPR:
2826       return COMPCODE_UNLT;
2827     case UNEQ_EXPR:
2828       return COMPCODE_UNEQ;
2829     case UNLE_EXPR:
2830       return COMPCODE_UNLE;
2831     case UNGT_EXPR:
2832       return COMPCODE_UNGT;
2833     case LTGT_EXPR:
2834       return COMPCODE_LTGT;
2835     case UNGE_EXPR:
2836       return COMPCODE_UNGE;
2837     default:
2838       gcc_unreachable ();
2839     }
2840 }
2841
2842 /* Convert a compcode bit-based encoding of a comparison operator back
2843    to GCC's enum tree_code representation.  This function is the
2844    inverse of comparison_to_compcode.  */
2845
2846 static enum tree_code
2847 compcode_to_comparison (enum comparison_code code)
2848 {
2849   switch (code)
2850     {
2851     case COMPCODE_LT:
2852       return LT_EXPR;
2853     case COMPCODE_EQ:
2854       return EQ_EXPR;
2855     case COMPCODE_LE:
2856       return LE_EXPR;
2857     case COMPCODE_GT:
2858       return GT_EXPR;
2859     case COMPCODE_NE:
2860       return NE_EXPR;
2861     case COMPCODE_GE:
2862       return GE_EXPR;
2863     case COMPCODE_ORD:
2864       return ORDERED_EXPR;
2865     case COMPCODE_UNORD:
2866       return UNORDERED_EXPR;
2867     case COMPCODE_UNLT:
2868       return UNLT_EXPR;
2869     case COMPCODE_UNEQ:
2870       return UNEQ_EXPR;
2871     case COMPCODE_UNLE:
2872       return UNLE_EXPR;
2873     case COMPCODE_UNGT:
2874       return UNGT_EXPR;
2875     case COMPCODE_LTGT:
2876       return LTGT_EXPR;
2877     case COMPCODE_UNGE:
2878       return UNGE_EXPR;
2879     default:
2880       gcc_unreachable ();
2881     }
2882 }
2883
2884 /* Return a tree for the comparison which is the combination of
2885    doing the AND or OR (depending on CODE) of the two operations LCODE
2886    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2887    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2888    if this makes the transformation invalid.  */
2889
2890 tree
2891 combine_comparisons (enum tree_code code, enum tree_code lcode,
2892                      enum tree_code rcode, tree truth_type,
2893                      tree ll_arg, tree lr_arg)
2894 {
2895   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2896   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2897   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2898   enum comparison_code compcode;
2899
2900   switch (code)
2901     {
2902     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2903       compcode = lcompcode & rcompcode;
2904       break;
2905
2906     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2907       compcode = lcompcode | rcompcode;
2908       break;
2909
2910     default:
2911       return NULL_TREE;
2912     }
2913
2914   if (!honor_nans)
2915     {
2916       /* Eliminate unordered comparisons, as well as LTGT and ORD
2917          which are not used unless the mode has NaNs.  */
2918       compcode &= ~COMPCODE_UNORD;
2919       if (compcode == COMPCODE_LTGT)
2920         compcode = COMPCODE_NE;
2921       else if (compcode == COMPCODE_ORD)
2922         compcode = COMPCODE_TRUE;
2923     }
2924    else if (flag_trapping_math)
2925      {
2926         /* Check that the original operation and the optimized ones will trap
2927            under the same condition.  */
2928         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2929                      && (lcompcode != COMPCODE_EQ)
2930                      && (lcompcode != COMPCODE_ORD);
2931         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2932                      && (rcompcode != COMPCODE_EQ)
2933                      && (rcompcode != COMPCODE_ORD);
2934         bool trap = (compcode & COMPCODE_UNORD) == 0
2935                     && (compcode != COMPCODE_EQ)
2936                     && (compcode != COMPCODE_ORD);
2937
2938         /* In a short-circuited boolean expression the LHS might be
2939            such that the RHS, if evaluated, will never trap.  For
2940            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2941            if neither x nor y is NaN.  (This is a mixed blessing: for
2942            example, the expression above will never trap, hence
2943            optimizing it to x < y would be invalid).  */
2944         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2945             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2946           rtrap = false;
2947
2948         /* If the comparison was short-circuited, and only the RHS
2949            trapped, we may now generate a spurious trap.  */
2950         if (rtrap && !ltrap
2951             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2952           return NULL_TREE;
2953
2954         /* If we changed the conditions that cause a trap, we lose.  */
2955         if ((ltrap || rtrap) != trap)
2956           return NULL_TREE;
2957       }
2958
2959   if (compcode == COMPCODE_TRUE)
2960     return constant_boolean_node (true, truth_type);
2961   else if (compcode == COMPCODE_FALSE)
2962     return constant_boolean_node (false, truth_type);
2963   else
2964     return fold_build2 (compcode_to_comparison (compcode),
2965                         truth_type, ll_arg, lr_arg);
2966 }
2967
2968 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2969
2970 static int
2971 truth_value_p (enum tree_code code)
2972 {
2973   return (TREE_CODE_CLASS (code) == tcc_comparison
2974           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2975           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2976           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2977 }
2978 \f
2979 /* Return nonzero if two operands (typically of the same tree node)
2980    are necessarily equal.  If either argument has side-effects this
2981    function returns zero.  FLAGS modifies behavior as follows:
2982
2983    If OEP_ONLY_CONST is set, only return nonzero for constants.
2984    This function tests whether the operands are indistinguishable;
2985    it does not test whether they are equal using C's == operation.
2986    The distinction is important for IEEE floating point, because
2987    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2988    (2) two NaNs may be indistinguishable, but NaN!=NaN.
2989
2990    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2991    even though it may hold multiple values during a function.
2992    This is because a GCC tree node guarantees that nothing else is
2993    executed between the evaluation of its "operands" (which may often
2994    be evaluated in arbitrary order).  Hence if the operands themselves
2995    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2996    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
2997    unset means assuming isochronic (or instantaneous) tree equivalence.
2998    Unless comparing arbitrary expression trees, such as from different
2999    statements, this flag can usually be left unset.
3000
3001    If OEP_PURE_SAME is set, then pure functions with identical arguments
3002    are considered the same.  It is used when the caller has other ways
3003    to ensure that global memory is unchanged in between.  */
3004
3005 int
3006 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
3007 {
3008   /* If either is ERROR_MARK, they aren't equal.  */
3009   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
3010     return 0;
3011
3012   /* If both types don't have the same signedness, then we can't consider
3013      them equal.  We must check this before the STRIP_NOPS calls
3014      because they may change the signedness of the arguments.  */
3015   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1)))
3016     return 0;
3017
3018   /* If both types don't have the same precision, then it is not safe
3019      to strip NOPs.  */
3020   if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
3021     return 0;
3022
3023   STRIP_NOPS (arg0);
3024   STRIP_NOPS (arg1);
3025
3026   /* In case both args are comparisons but with different comparison
3027      code, try to swap the comparison operands of one arg to produce
3028      a match and compare that variant.  */
3029   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3030       && COMPARISON_CLASS_P (arg0)
3031       && COMPARISON_CLASS_P (arg1))
3032     {
3033       enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
3034
3035       if (TREE_CODE (arg0) == swap_code)
3036         return operand_equal_p (TREE_OPERAND (arg0, 0),
3037                                 TREE_OPERAND (arg1, 1), flags)
3038                && operand_equal_p (TREE_OPERAND (arg0, 1),
3039                                    TREE_OPERAND (arg1, 0), flags);
3040     }
3041
3042   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3043       /* This is needed for conversions and for COMPONENT_REF.
3044          Might as well play it safe and always test this.  */
3045       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
3046       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
3047       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
3048     return 0;
3049
3050   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
3051      We don't care about side effects in that case because the SAVE_EXPR
3052      takes care of that for us. In all other cases, two expressions are
3053      equal if they have no side effects.  If we have two identical
3054      expressions with side effects that should be treated the same due
3055      to the only side effects being identical SAVE_EXPR's, that will
3056      be detected in the recursive calls below.  */
3057   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
3058       && (TREE_CODE (arg0) == SAVE_EXPR
3059           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
3060     return 1;
3061
3062   /* Next handle constant cases, those for which we can return 1 even
3063      if ONLY_CONST is set.  */
3064   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
3065     switch (TREE_CODE (arg0))
3066       {
3067       case INTEGER_CST:
3068         return tree_int_cst_equal (arg0, arg1);
3069
3070       case FIXED_CST:
3071         return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
3072                                        TREE_FIXED_CST (arg1));
3073
3074       case REAL_CST:
3075         if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
3076                                    TREE_REAL_CST (arg1)))
3077           return 1;
3078
3079         
3080         if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
3081           {
3082             /* If we do not distinguish between signed and unsigned zero,
3083                consider them equal.  */
3084             if (real_zerop (arg0) && real_zerop (arg1))
3085               return 1;
3086           }
3087         return 0;
3088
3089       case VECTOR_CST:
3090         {
3091           tree v1, v2;
3092
3093           v1 = TREE_VECTOR_CST_ELTS (arg0);
3094           v2 = TREE_VECTOR_CST_ELTS (arg1);
3095           while (v1 && v2)
3096             {
3097               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
3098                                     flags))
3099                 return 0;
3100               v1 = TREE_CHAIN (v1);
3101               v2 = TREE_CHAIN (v2);
3102             }
3103
3104           return v1 == v2;
3105         }
3106
3107       case COMPLEX_CST:
3108         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
3109                                  flags)
3110                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
3111                                     flags));
3112
3113       case STRING_CST:
3114         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
3115                 && ! memcmp (TREE_STRING_POINTER (arg0),
3116                               TREE_STRING_POINTER (arg1),
3117                               TREE_STRING_LENGTH (arg0)));
3118
3119       case ADDR_EXPR:
3120         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
3121                                 0);
3122       default:
3123         break;
3124       }
3125
3126   if (flags & OEP_ONLY_CONST)
3127     return 0;
3128
3129 /* Define macros to test an operand from arg0 and arg1 for equality and a
3130    variant that allows null and views null as being different from any
3131    non-null value.  In the latter case, if either is null, the both
3132    must be; otherwise, do the normal comparison.  */
3133 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),     \
3134                                     TREE_OPERAND (arg1, N), flags)
3135
3136 #define OP_SAME_WITH_NULL(N)                            \
3137   ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3138    ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3139
3140   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
3141     {
3142     case tcc_unary:
3143       /* Two conversions are equal only if signedness and modes match.  */
3144       switch (TREE_CODE (arg0))
3145         {
3146         case NOP_EXPR:
3147         case CONVERT_EXPR:
3148         case FIX_TRUNC_EXPR:
3149           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
3150               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
3151             return 0;
3152           break;
3153         default:
3154           break;
3155         }
3156
3157       return OP_SAME (0);
3158
3159
3160     case tcc_comparison:
3161     case tcc_binary:
3162       if (OP_SAME (0) && OP_SAME (1))
3163         return 1;
3164
3165       /* For commutative ops, allow the other order.  */
3166       return (commutative_tree_code (TREE_CODE (arg0))
3167               && operand_equal_p (TREE_OPERAND (arg0, 0),
3168                                   TREE_OPERAND (arg1, 1), flags)
3169               && operand_equal_p (TREE_OPERAND (arg0, 1),
3170                                   TREE_OPERAND (arg1, 0), flags));
3171
3172     case tcc_reference:
3173       /* If either of the pointer (or reference) expressions we are
3174          dereferencing contain a side effect, these cannot be equal.  */
3175       if (TREE_SIDE_EFFECTS (arg0)
3176           || TREE_SIDE_EFFECTS (arg1))
3177         return 0;
3178
3179       switch (TREE_CODE (arg0))
3180         {
3181         case INDIRECT_REF:
3182         case ALIGN_INDIRECT_REF:
3183         case MISALIGNED_INDIRECT_REF:
3184         case REALPART_EXPR:
3185         case IMAGPART_EXPR:
3186           return OP_SAME (0);
3187
3188         case ARRAY_REF:
3189         case ARRAY_RANGE_REF:
3190           /* Operands 2 and 3 may be null.
3191              Compare the array index by value if it is constant first as we
3192              may have different types but same value here.  */
3193           return (OP_SAME (0)
3194                   && (tree_int_cst_equal (TREE_OPERAND (arg0, 1),
3195                                           TREE_OPERAND (arg1, 1))
3196                       || OP_SAME (1))
3197                   && OP_SAME_WITH_NULL (2)
3198                   && OP_SAME_WITH_NULL (3));
3199
3200         case COMPONENT_REF:
3201           /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
3202              may be NULL when we're called to compare MEM_EXPRs.  */
3203           return OP_SAME_WITH_NULL (0)
3204                  && OP_SAME (1)
3205                  && OP_SAME_WITH_NULL (2);
3206
3207         case BIT_FIELD_REF:
3208           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3209
3210         default:
3211           return 0;
3212         }
3213
3214     case tcc_expression:
3215       switch (TREE_CODE (arg0))
3216         {
3217         case ADDR_EXPR:
3218         case TRUTH_NOT_EXPR:
3219           return OP_SAME (0);
3220
3221         case TRUTH_ANDIF_EXPR:
3222         case TRUTH_ORIF_EXPR:
3223           return OP_SAME (0) && OP_SAME (1);
3224
3225         case TRUTH_AND_EXPR:
3226         case TRUTH_OR_EXPR:
3227         case TRUTH_XOR_EXPR:
3228           if (OP_SAME (0) && OP_SAME (1))
3229             return 1;
3230
3231           /* Otherwise take into account this is a commutative operation.  */
3232           return (operand_equal_p (TREE_OPERAND (arg0, 0),
3233                                    TREE_OPERAND (arg1, 1), flags)
3234                   && operand_equal_p (TREE_OPERAND (arg0, 1),
3235                                       TREE_OPERAND (arg1, 0), flags));
3236
3237         default:
3238           return 0;
3239         }
3240
3241     case tcc_vl_exp:
3242       switch (TREE_CODE (arg0))
3243         {
3244         case CALL_EXPR:
3245           /* If the CALL_EXPRs call different functions, then they
3246              clearly can not be equal.  */
3247           if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
3248                                  flags))
3249             return 0;
3250
3251           {
3252             unsigned int cef = call_expr_flags (arg0);
3253             if (flags & OEP_PURE_SAME)
3254               cef &= ECF_CONST | ECF_PURE;
3255             else
3256               cef &= ECF_CONST;
3257             if (!cef)
3258               return 0;
3259           }
3260
3261           /* Now see if all the arguments are the same.  */
3262           {
3263             const_call_expr_arg_iterator iter0, iter1;
3264             const_tree a0, a1;
3265             for (a0 = first_const_call_expr_arg (arg0, &iter0),
3266                    a1 = first_const_call_expr_arg (arg1, &iter1);
3267                  a0 && a1;
3268                  a0 = next_const_call_expr_arg (&iter0),
3269                    a1 = next_const_call_expr_arg (&iter1))
3270               if (! operand_equal_p (a0, a1, flags))
3271                 return 0;
3272
3273             /* If we get here and both argument lists are exhausted
3274                then the CALL_EXPRs are equal.  */
3275             return ! (a0 || a1);
3276           }
3277         default:
3278           return 0;
3279         }
3280
3281     case tcc_declaration:
3282       /* Consider __builtin_sqrt equal to sqrt.  */
3283       return (TREE_CODE (arg0) == FUNCTION_DECL
3284               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
3285               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
3286               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
3287
3288     default:
3289       return 0;
3290     }
3291
3292 #undef OP_SAME
3293 #undef OP_SAME_WITH_NULL
3294 }
3295 \f
3296 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3297    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3298
3299    When in doubt, return 0.  */
3300
3301 static int
3302 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
3303 {
3304   int unsignedp1, unsignedpo;
3305   tree primarg0, primarg1, primother;
3306   unsigned int correct_width;
3307
3308   if (operand_equal_p (arg0, arg1, 0))
3309     return 1;
3310
3311   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
3312       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
3313     return 0;
3314
3315   /* Discard any conversions that don't change the modes of ARG0 and ARG1
3316      and see if the inner values are the same.  This removes any
3317      signedness comparison, which doesn't matter here.  */
3318   primarg0 = arg0, primarg1 = arg1;
3319   STRIP_NOPS (primarg0);
3320   STRIP_NOPS (primarg1);
3321   if (operand_equal_p (primarg0, primarg1, 0))
3322     return 1;
3323
3324   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3325      actual comparison operand, ARG0.
3326
3327      First throw away any conversions to wider types
3328      already present in the operands.  */
3329
3330   primarg1 = get_narrower (arg1, &unsignedp1);
3331   primother = get_narrower (other, &unsignedpo);
3332
3333   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
3334   if (unsignedp1 == unsignedpo
3335       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
3336       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
3337     {
3338       tree type = TREE_TYPE (arg0);
3339
3340       /* Make sure shorter operand is extended the right way
3341          to match the longer operand.  */
3342       primarg1 = fold_convert (signed_or_unsigned_type_for
3343                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
3344
3345       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
3346         return 1;
3347     }
3348
3349   return 0;
3350 }
3351 \f
3352 /* See if ARG is an expression that is either a comparison or is performing
3353    arithmetic on comparisons.  The comparisons must only be comparing
3354    two different values, which will be stored in *CVAL1 and *CVAL2; if
3355    they are nonzero it means that some operands have already been found.
3356    No variables may be used anywhere else in the expression except in the
3357    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
3358    the expression and save_expr needs to be called with CVAL1 and CVAL2.
3359
3360    If this is true, return 1.  Otherwise, return zero.  */
3361
3362 static int
3363 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
3364 {
3365   enum tree_code code = TREE_CODE (arg);
3366   enum tree_code_class class = TREE_CODE_CLASS (code);
3367
3368   /* We can handle some of the tcc_expression cases here.  */
3369   if (class == tcc_expression && code == TRUTH_NOT_EXPR)
3370     class = tcc_unary;
3371   else if (class == tcc_expression
3372            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
3373                || code == COMPOUND_EXPR))
3374     class = tcc_binary;
3375
3376   else if (class == tcc_expression && code == SAVE_EXPR
3377            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
3378     {
3379       /* If we've already found a CVAL1 or CVAL2, this expression is
3380          two complex to handle.  */
3381       if (*cval1 || *cval2)
3382         return 0;
3383
3384       class = tcc_unary;
3385       *save_p = 1;
3386     }
3387
3388   switch (class)
3389     {
3390     case tcc_unary:
3391       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
3392
3393     case tcc_binary:
3394       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
3395               && twoval_comparison_p (TREE_OPERAND (arg, 1),
3396                                       cval1, cval2, save_p));
3397
3398     case tcc_constant:
3399       return 1;
3400
3401     case tcc_expression:
3402       if (code == COND_EXPR)
3403         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
3404                                      cval1, cval2, save_p)
3405                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3406                                         cval1, cval2, save_p)
3407                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
3408                                         cval1, cval2, save_p));
3409       return 0;
3410
3411     case tcc_comparison:
3412       /* First see if we can handle the first operand, then the second.  For
3413          the second operand, we know *CVAL1 can't be zero.  It must be that
3414          one side of the comparison is each of the values; test for the
3415          case where this isn't true by failing if the two operands
3416          are the same.  */
3417
3418       if (operand_equal_p (TREE_OPERAND (arg, 0),
3419                            TREE_OPERAND (arg, 1), 0))
3420         return 0;
3421
3422       if (*cval1 == 0)
3423         *cval1 = TREE_OPERAND (arg, 0);
3424       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
3425         ;
3426       else if (*cval2 == 0)
3427         *cval2 = TREE_OPERAND (arg, 0);
3428       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
3429         ;
3430       else
3431         return 0;
3432
3433       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
3434         ;
3435       else if (*cval2 == 0)
3436         *cval2 = TREE_OPERAND (arg, 1);
3437       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
3438         ;
3439       else
3440         return 0;
3441
3442       return 1;
3443
3444     default:
3445       return 0;
3446     }
3447 }
3448 \f
3449 /* ARG is a tree that is known to contain just arithmetic operations and
3450    comparisons.  Evaluate the operations in the tree substituting NEW0 for
3451    any occurrence of OLD0 as an operand of a comparison and likewise for
3452    NEW1 and OLD1.  */
3453
3454 static tree
3455 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
3456 {
3457   tree type = TREE_TYPE (arg);
3458   enum tree_code code = TREE_CODE (arg);
3459   enum tree_code_class class = TREE_CODE_CLASS (code);
3460
3461   /* We can handle some of the tcc_expression cases here.  */
3462   if (class == tcc_expression && code == TRUTH_NOT_EXPR)
3463     class = tcc_unary;
3464   else if (class == tcc_expression
3465            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3466     class = tcc_binary;
3467
3468   switch (class)
3469     {
3470     case tcc_unary:
3471       return fold_build1 (code, type,
3472                           eval_subst (TREE_OPERAND (arg, 0),
3473                                       old0, new0, old1, new1));
3474
3475     case tcc_binary:
3476       return fold_build2 (code, type,
3477                           eval_subst (TREE_OPERAND (arg, 0),
3478                                       old0, new0, old1, new1),
3479                           eval_subst (TREE_OPERAND (arg, 1),
3480                                       old0, new0, old1, new1));
3481
3482     case tcc_expression:
3483       switch (code)
3484         {
3485         case SAVE_EXPR:
3486           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
3487
3488         case COMPOUND_EXPR:
3489           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
3490
3491         case COND_EXPR:
3492           return fold_build3 (code, type,
3493                               eval_subst (TREE_OPERAND (arg, 0),
3494                                           old0, new0, old1, new1),
3495                               eval_subst (TREE_OPERAND (arg, 1),
3496                                           old0, new0, old1, new1),
3497                               eval_subst (TREE_OPERAND (arg, 2),
3498                                           old0, new0, old1, new1));
3499         default:
3500           break;
3501         }
3502       /* Fall through - ???  */
3503
3504     case tcc_comparison:
3505       {
3506         tree arg0 = TREE_OPERAND (arg, 0);
3507         tree arg1 = TREE_OPERAND (arg, 1);
3508
3509         /* We need to check both for exact equality and tree equality.  The
3510            former will be true if the operand has a side-effect.  In that
3511            case, we know the operand occurred exactly once.  */
3512
3513         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3514           arg0 = new0;
3515         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3516           arg0 = new1;
3517
3518         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3519           arg1 = new0;
3520         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3521           arg1 = new1;
3522
3523         return fold_build2 (code, type, arg0, arg1);
3524       }
3525
3526     default:
3527       return arg;
3528     }
3529 }
3530 \f
3531 /* Return a tree for the case when the result of an expression is RESULT
3532    converted to TYPE and OMITTED was previously an operand of the expression
3533    but is now not needed (e.g., we folded OMITTED * 0).
3534
3535    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
3536    the conversion of RESULT to TYPE.  */
3537
3538 tree
3539 omit_one_operand (tree type, tree result, tree omitted)
3540 {
3541   tree t = fold_convert (type, result);
3542
3543   /* If the resulting operand is an empty statement, just return the omitted
3544      statement casted to void. */
3545   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3546     return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
3547
3548   if (TREE_SIDE_EFFECTS (omitted))
3549     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3550
3551   return non_lvalue (t);
3552 }
3553
3554 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
3555
3556 static tree
3557 pedantic_omit_one_operand (tree type, tree result, tree omitted)
3558 {
3559   tree t = fold_convert (type, result);
3560
3561   /* If the resulting operand is an empty statement, just return the omitted
3562      statement casted to void. */
3563   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3564     return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
3565
3566   if (TREE_SIDE_EFFECTS (omitted))
3567     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3568
3569   return pedantic_non_lvalue (t);
3570 }
3571
3572 /* Return a tree for the case when the result of an expression is RESULT
3573    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3574    of the expression but are now not needed.
3575
3576    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3577    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3578    evaluated before OMITTED2.  Otherwise, if neither has side effects,
3579    just do the conversion of RESULT to TYPE.  */
3580
3581 tree
3582 omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
3583 {
3584   tree t = fold_convert (type, result);
3585
3586   if (TREE_SIDE_EFFECTS (omitted2))
3587     t = build2 (COMPOUND_EXPR, type, omitted2, t);
3588   if (TREE_SIDE_EFFECTS (omitted1))
3589     t = build2 (COMPOUND_EXPR, type, omitted1, t);
3590
3591   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
3592 }
3593
3594 \f
3595 /* Return a simplified tree node for the truth-negation of ARG.  This
3596    never alters ARG itself.  We assume that ARG is an operation that
3597    returns a truth value (0 or 1).
3598
3599    FIXME: one would think we would fold the result, but it causes
3600    problems with the dominator optimizer.  */
3601
3602 tree
3603 fold_truth_not_expr (tree arg)
3604 {
3605   tree type = TREE_TYPE (arg);
3606   enum tree_code code = TREE_CODE (arg);
3607
3608   /* If this is a comparison, we can simply invert it, except for
3609      floating-point non-equality comparisons, in which case we just
3610      enclose a TRUTH_NOT_EXPR around what we have.  */
3611
3612   if (TREE_CODE_CLASS (code) == tcc_comparison)
3613     {
3614       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3615       if (FLOAT_TYPE_P (op_type)
3616           && flag_trapping_math
3617           && code != ORDERED_EXPR && code != UNORDERED_EXPR
3618           && code != NE_EXPR && code != EQ_EXPR)
3619         return NULL_TREE;
3620       else
3621         {
3622           code = invert_tree_comparison (code,
3623                                          HONOR_NANS (TYPE_MODE (op_type)));
3624           if (code == ERROR_MARK)
3625             return NULL_TREE;
3626           else
3627             return build2 (code, type,
3628                            TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
3629         }
3630     }
3631
3632   switch (code)
3633     {
3634     case INTEGER_CST:
3635       return constant_boolean_node (integer_zerop (arg), type);
3636
3637     case TRUTH_AND_EXPR:
3638       return build2 (TRUTH_OR_EXPR, type,
3639                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3640                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3641
3642     case TRUTH_OR_EXPR:
3643       return build2 (TRUTH_AND_EXPR, type,
3644                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3645                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3646
3647     case TRUTH_XOR_EXPR:
3648       /* Here we can invert either operand.  We invert the first operand
3649          unless the second operand is a TRUTH_NOT_EXPR in which case our
3650          result is the XOR of the first operand with the inside of the
3651          negation of the second operand.  */
3652
3653       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3654         return build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3655                        TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3656       else
3657         return build2 (TRUTH_XOR_EXPR, type,
3658                        invert_truthvalue (TREE_OPERAND (arg, 0)),
3659                        TREE_OPERAND (arg, 1));
3660
3661     case TRUTH_ANDIF_EXPR:
3662       return build2 (TRUTH_ORIF_EXPR, type,
3663                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3664                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3665
3666     case TRUTH_ORIF_EXPR:
3667       return build2 (TRUTH_ANDIF_EXPR, type,
3668                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3669                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3670
3671     case TRUTH_NOT_EXPR:
3672       return TREE_OPERAND (arg, 0);
3673
3674     case COND_EXPR:
3675       {
3676         tree arg1 = TREE_OPERAND (arg, 1);
3677         tree arg2 = TREE_OPERAND (arg, 2);
3678         /* A COND_EXPR may have a throw as one operand, which
3679            then has void type.  Just leave void operands
3680            as they are.  */
3681         return build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
3682                        VOID_TYPE_P (TREE_TYPE (arg1))
3683                        ? arg1 : invert_truthvalue (arg1),
3684                        VOID_TYPE_P (TREE_TYPE (arg2))
3685                        ? arg2 : invert_truthvalue (arg2));
3686       }
3687
3688     case COMPOUND_EXPR:
3689       return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
3690                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3691
3692     case NON_LVALUE_EXPR:
3693       return invert_truthvalue (TREE_OPERAND (arg, 0));
3694
3695     case NOP_EXPR:
3696       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3697         return build1 (TRUTH_NOT_EXPR, type, arg);
3698
3699     case CONVERT_EXPR:
3700     case FLOAT_EXPR:
3701       return build1 (TREE_CODE (arg), type,
3702                      invert_truthvalue (TREE_OPERAND (arg, 0)));
3703
3704     case BIT_AND_EXPR:
3705       if (!integer_onep (TREE_OPERAND (arg, 1)))
3706         break;
3707       return build2 (EQ_EXPR, type, arg,
3708                      build_int_cst (type, 0));
3709
3710     case SAVE_EXPR:
3711       return build1 (TRUTH_NOT_EXPR, type, arg);
3712
3713     case CLEANUP_POINT_EXPR:
3714       return build1 (CLEANUP_POINT_EXPR, type,
3715                      invert_truthvalue (TREE_OPERAND (arg, 0)));
3716
3717     default:
3718       break;
3719     }
3720
3721   return NULL_TREE;
3722 }
3723
3724 /* Return a simplified tree node for the truth-negation of ARG.  This
3725    never alters ARG itself.  We assume that ARG is an operation that
3726    returns a truth value (0 or 1).
3727
3728    FIXME: one would think we would fold the result, but it causes
3729    problems with the dominator optimizer.  */
3730
3731 tree
3732 invert_truthvalue (tree arg)
3733 {
3734   tree tem;
3735
3736   if (TREE_CODE (arg) == ERROR_MARK)
3737     return arg;
3738
3739   tem = fold_truth_not_expr (arg);
3740   if (!tem)
3741     tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3742
3743   return tem;
3744 }
3745
3746 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3747    operands are another bit-wise operation with a common input.  If so,
3748    distribute the bit operations to save an operation and possibly two if
3749    constants are involved.  For example, convert
3750         (A | B) & (A | C) into A | (B & C)
3751    Further simplification will occur if B and C are constants.
3752
3753    If this optimization cannot be done, 0 will be returned.  */
3754
3755 static tree
3756 distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
3757 {
3758   tree common;
3759   tree left, right;
3760
3761   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3762       || TREE_CODE (arg0) == code
3763       || (TREE_CODE (arg0) != BIT_AND_EXPR
3764           && TREE_CODE (arg0) != BIT_IOR_EXPR))
3765     return 0;
3766
3767   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3768     {
3769       common = TREE_OPERAND (arg0, 0);
3770       left = TREE_OPERAND (arg0, 1);
3771       right = TREE_OPERAND (arg1, 1);
3772     }
3773   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3774     {
3775       common = TREE_OPERAND (arg0, 0);
3776       left = TREE_OPERAND (arg0, 1);
3777       right = TREE_OPERAND (arg1, 0);
3778     }
3779   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3780     {
3781       common = TREE_OPERAND (arg0, 1);
3782       left = TREE_OPERAND (arg0, 0);
3783       right = TREE_OPERAND (arg1, 1);
3784     }
3785   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3786     {
3787       common = TREE_OPERAND (arg0, 1);
3788       left = TREE_OPERAND (arg0, 0);
3789       right = TREE_OPERAND (arg1, 0);
3790     }
3791   else
3792     return 0;
3793
3794   return fold_build2 (TREE_CODE (arg0), type, common,
3795                       fold_build2 (code, type, left, right));
3796 }
3797
3798 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3799    with code CODE.  This optimization is unsafe.  */
3800 static tree
3801 distribute_real_division (enum tree_code code, tree type, tree arg0, tree arg1)
3802 {
3803   bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3804   bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3805
3806   /* (A / C) +- (B / C) -> (A +- B) / C.  */
3807   if (mul0 == mul1
3808       && operand_equal_p (TREE_OPERAND (arg0, 1),
3809                        TREE_OPERAND (arg1, 1), 0))
3810     return fold_build2 (mul0 ? MULT_EXPR : RDIV_EXPR, type,
3811                         fold_build2 (code, type,
3812                                      TREE_OPERAND (arg0, 0),
3813                                      TREE_OPERAND (arg1, 0)),
3814                         TREE_OPERAND (arg0, 1));
3815
3816   /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2).  */
3817   if (operand_equal_p (TREE_OPERAND (arg0, 0),
3818                        TREE_OPERAND (arg1, 0), 0)
3819       && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3820       && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3821     {
3822       REAL_VALUE_TYPE r0, r1;
3823       r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3824       r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3825       if (!mul0)
3826         real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3827       if (!mul1)
3828         real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3829       real_arithmetic (&r0, code, &r0, &r1);
3830       return fold_build2 (MULT_EXPR, type,
3831                           TREE_OPERAND (arg0, 0),
3832                           build_real (type, r0));
3833     }
3834
3835   return NULL_TREE;
3836 }
3837 \f
3838 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3839    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
3840
3841 static tree
3842 make_bit_field_ref (tree inner, tree type, int bitsize, int bitpos,
3843                     int unsignedp)
3844 {
3845   tree result;
3846
3847   if (bitpos == 0)
3848     {
3849       tree size = TYPE_SIZE (TREE_TYPE (inner));
3850       if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3851            || POINTER_TYPE_P (TREE_TYPE (inner)))
3852           && host_integerp (size, 0) 
3853           && tree_low_cst (size, 0) == bitsize)
3854         return fold_convert (type, inner);
3855     }
3856
3857   result = build3 (BIT_FIELD_REF, type, inner,
3858                    size_int (bitsize), bitsize_int (bitpos));
3859
3860   BIT_FIELD_REF_UNSIGNED (result) = unsignedp;
3861
3862   return result;
3863 }
3864
3865 /* Optimize a bit-field compare.
3866
3867    There are two cases:  First is a compare against a constant and the
3868    second is a comparison of two items where the fields are at the same
3869    bit position relative to the start of a chunk (byte, halfword, word)
3870    large enough to contain it.  In these cases we can avoid the shift
3871    implicit in bitfield extractions.
3872
3873    For constants, we emit a compare of the shifted constant with the
3874    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3875    compared.  For two fields at the same position, we do the ANDs with the
3876    similar mask and compare the result of the ANDs.
3877
3878    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3879    COMPARE_TYPE is the type of the comparison, and LHS and RHS
3880    are the left and right operands of the comparison, respectively.
3881
3882    If the optimization described above can be done, we return the resulting
3883    tree.  Otherwise we return zero.  */
3884
3885 static tree
3886 optimize_bit_field_compare (enum tree_code code, tree compare_type,
3887                             tree lhs, tree rhs)
3888 {
3889   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3890   tree type = TREE_TYPE (lhs);
3891   tree signed_type, unsigned_type;
3892   int const_p = TREE_CODE (rhs) == INTEGER_CST;
3893   enum machine_mode lmode, rmode, nmode;
3894   int lunsignedp, runsignedp;
3895   int lvolatilep = 0, rvolatilep = 0;
3896   tree linner, rinner = NULL_TREE;
3897   tree mask;
3898   tree offset;
3899
3900   /* Get all the information about the extractions being done.  If the bit size
3901      if the same as the size of the underlying object, we aren't doing an
3902      extraction at all and so can do nothing.  We also don't want to
3903      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3904      then will no longer be able to replace it.  */
3905   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3906                                 &lunsignedp, &lvolatilep, false);
3907   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3908       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3909     return 0;
3910
3911  if (!const_p)
3912    {
3913      /* If this is not a constant, we can only do something if bit positions,
3914         sizes, and signedness are the same.  */
3915      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3916                                    &runsignedp, &rvolatilep, false);
3917
3918      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3919          || lunsignedp != runsignedp || offset != 0
3920          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3921        return 0;
3922    }
3923
3924   /* See if we can find a mode to refer to this field.  We should be able to,
3925      but fail if we can't.  */
3926   nmode = get_best_mode (lbitsize, lbitpos,
3927                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3928                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3929                                 TYPE_ALIGN (TREE_TYPE (rinner))),
3930                          word_mode, lvolatilep || rvolatilep);
3931   if (nmode == VOIDmode)
3932     return 0;
3933
3934   /* Set signed and unsigned types of the precision of this mode for the
3935      shifts below.  */
3936   signed_type = lang_hooks.types.type_for_mode (nmode, 0);
3937   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3938
3939   /* Compute the bit position and size for the new reference and our offset
3940      within it. If the new reference is the same size as the original, we
3941      won't optimize anything, so return zero.  */
3942   nbitsize = GET_MODE_BITSIZE (nmode);
3943   nbitpos = lbitpos & ~ (nbitsize - 1);
3944   lbitpos -= nbitpos;
3945   if (nbitsize == lbitsize)
3946     return 0;
3947
3948   if (BYTES_BIG_ENDIAN)
3949     lbitpos = nbitsize - lbitsize - lbitpos;
3950
3951   /* Make the mask to be used against the extracted field.  */
3952   mask = build_int_cst_type (unsigned_type, -1);
3953   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
3954   mask = const_binop (RSHIFT_EXPR, mask,
3955                       size_int (nbitsize - lbitsize - lbitpos), 0);
3956
3957   if (! const_p)
3958     /* If not comparing with constant, just rework the comparison
3959        and return.  */
3960     return fold_build2 (code, compare_type,
3961                         fold_build2 (BIT_AND_EXPR, unsigned_type,
3962                                      make_bit_field_ref (linner,
3963                                                          unsigned_type,
3964                                                          nbitsize, nbitpos,
3965                                                          1),
3966                                      mask),
3967                         fold_build2 (BIT_AND_EXPR, unsigned_type,
3968                                      make_bit_field_ref (rinner,
3969                                                          unsigned_type,
3970                                                          nbitsize, nbitpos,
3971                                                          1),
3972                                      mask));
3973
3974   /* Otherwise, we are handling the constant case. See if the constant is too
3975      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3976      this not only for its own sake, but to avoid having to test for this
3977      error case below.  If we didn't, we might generate wrong code.
3978
3979      For unsigned fields, the constant shifted right by the field length should
3980      be all zero.  For signed fields, the high-order bits should agree with
3981      the sign bit.  */
3982
3983   if (lunsignedp)
3984     {
3985       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3986                                         fold_convert (unsigned_type, rhs),
3987                                         size_int (lbitsize), 0)))
3988         {
3989           warning (0, "comparison is always %d due to width of bit-field",
3990                    code == NE_EXPR);
3991           return constant_boolean_node (code == NE_EXPR, compare_type);
3992         }
3993     }
3994   else
3995     {
3996       tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
3997                               size_int (lbitsize - 1), 0);
3998       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3999         {
4000           warning (0, "comparison is always %d due to width of bit-field",
4001                    code == NE_EXPR);
4002           return constant_boolean_node (code == NE_EXPR, compare_type);
4003         }
4004     }
4005
4006   /* Single-bit compares should always be against zero.  */
4007   if (lbitsize == 1 && ! integer_zerop (rhs))
4008     {
4009       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
4010       rhs = build_int_cst (type, 0);
4011     }
4012
4013   /* Make a new bitfield reference, shift the constant over the
4014      appropriate number of bits and mask it with the computed mask
4015      (in case this was a signed field).  If we changed it, make a new one.  */
4016   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
4017   if (lvolatilep)
4018     {
4019       TREE_SIDE_EFFECTS (lhs) = 1;
4020       TREE_THIS_VOLATILE (lhs) = 1;
4021     }
4022
4023   rhs = const_binop (BIT_AND_EXPR,
4024                      const_binop (LSHIFT_EXPR,
4025                                   fold_convert (unsigned_type, rhs),
4026                                   size_int (lbitpos), 0),
4027                      mask, 0);
4028
4029   return build2 (code, compare_type,
4030                  build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
4031                  rhs);
4032 }
4033 \f
4034 /* Subroutine for fold_truthop: decode a field reference.
4035
4036    If EXP is a comparison reference, we return the innermost reference.
4037
4038    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
4039    set to the starting bit number.
4040
4041    If the innermost field can be completely contained in a mode-sized
4042    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
4043
4044    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
4045    otherwise it is not changed.
4046
4047    *PUNSIGNEDP is set to the signedness of the field.
4048
4049    *PMASK is set to the mask used.  This is either contained in a
4050    BIT_AND_EXPR or derived from the width of the field.
4051
4052    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
4053
4054    Return 0 if this is not a component reference or is one that we can't
4055    do anything with.  */
4056
4057 static tree
4058 decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
4059                         HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
4060                         int *punsignedp, int *pvolatilep,
4061                         tree *pmask, tree *pand_mask)
4062 {
4063   tree outer_type = 0;
4064   tree and_mask = 0;
4065   tree mask, inner, offset;
4066   tree unsigned_type;
4067   unsigned int precision;
4068
4069   /* All the optimizations using this function assume integer fields.
4070      There are problems with FP fields since the type_for_size call
4071      below can fail for, e.g., XFmode.  */
4072   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
4073     return 0;
4074
4075   /* We are interested in the bare arrangement of bits, so strip everything
4076      that doesn't affect the machine mode.  However, record the type of the
4077      outermost expression if it may matter below.  */
4078   if (TREE_CODE (exp) == NOP_EXPR
4079       || TREE_CODE (exp) == CONVERT_EXPR
4080       || TREE_CODE (exp) == NON_LVALUE_EXPR)
4081     outer_type = TREE_TYPE (exp);
4082   STRIP_NOPS (exp);
4083
4084   if (TREE_CODE (exp) == BIT_AND_EXPR)
4085     {
4086       and_mask = TREE_OPERAND (exp, 1);
4087       exp = TREE_OPERAND (exp, 0);
4088       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
4089       if (TREE_CODE (and_mask) != INTEGER_CST)
4090         return 0;
4091     }
4092
4093   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
4094                                punsignedp, pvolatilep, false);
4095   if ((inner == exp && and_mask == 0)
4096       || *pbitsize < 0 || offset != 0
4097       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
4098     return 0;
4099
4100   /* If the number of bits in the reference is the same as the bitsize of
4101      the outer type, then the outer type gives the signedness. Otherwise
4102      (in case of a small bitfield) the signedness is unchanged.  */
4103   if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
4104     *punsignedp = TYPE_UNSIGNED (outer_type);
4105
4106   /* Compute the mask to access the bitfield.  */
4107   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
4108   precision = TYPE_PRECISION (unsigned_type);
4109
4110   mask = build_int_cst_type (unsigned_type, -1);
4111
4112   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
4113   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
4114
4115   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
4116   if (and_mask != 0)
4117     mask = fold_build2 (BIT_AND_EXPR, unsigned_type,
4118                         fold_convert (unsigned_type, and_mask), mask);
4119
4120   *pmask = mask;
4121   *pand_mask = and_mask;
4122   return inner;
4123 }
4124
4125 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
4126    bit positions.  */
4127
4128 static int
4129 all_ones_mask_p (const_tree mask, int size)
4130 {
4131   tree type = TREE_TYPE (mask);
4132   unsigned int precision = TYPE_PRECISION (type);
4133   tree tmask;
4134
4135   tmask = build_int_cst_type (signed_type_for (type), -1);
4136
4137   return
4138     tree_int_cst_equal (mask,
4139                         const_binop (RSHIFT_EXPR,
4140                                      const_binop (LSHIFT_EXPR, tmask,
4141                                                   size_int (precision - size),
4142                                                   0),
4143                                      size_int (precision - size), 0));
4144 }
4145
4146 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
4147    represents the sign bit of EXP's type.  If EXP represents a sign
4148    or zero extension, also test VAL against the unextended type.
4149    The return value is the (sub)expression whose sign bit is VAL,
4150    or NULL_TREE otherwise.  */
4151
4152 static tree
4153 sign_bit_p (tree exp, const_tree val)
4154 {
4155   unsigned HOST_WIDE_INT mask_lo, lo;
4156   HOST_WIDE_INT mask_hi, hi;
4157   int width;
4158   tree t;
4159
4160   /* Tree EXP must have an integral type.  */
4161   t = TREE_TYPE (exp);
4162   if (! INTEGRAL_TYPE_P (t))
4163     return NULL_TREE;
4164
4165   /* Tree VAL must be an integer constant.  */
4166   if (TREE_CODE (val) != INTEGER_CST
4167       || TREE_OVERFLOW (val))
4168     return NULL_TREE;
4169
4170   width = TYPE_PRECISION (t);
4171   if (width > HOST_BITS_PER_WIDE_INT)
4172     {
4173       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
4174       lo = 0;
4175
4176       mask_hi = ((unsigned HOST_WIDE_INT) -1
4177                  >> (2 * HOST_BITS_PER_WIDE_INT - width));
4178       mask_lo = -1;
4179     }
4180   else
4181     {
4182       hi = 0;
4183       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
4184
4185       mask_hi = 0;
4186       mask_lo = ((unsigned HOST_WIDE_INT) -1
4187                  >> (HOST_BITS_PER_WIDE_INT - width));
4188     }
4189
4190   /* We mask off those bits beyond TREE_TYPE (exp) so that we can
4191      treat VAL as if it were unsigned.  */
4192   if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
4193       && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
4194     return exp;
4195
4196   /* Handle extension from a narrower type.  */
4197   if (TREE_CODE (exp) == NOP_EXPR
4198       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
4199     return sign_bit_p (TREE_OPERAND (exp, 0), val);
4200
4201   return NULL_TREE;
4202 }
4203
4204 /* Subroutine for fold_truthop: determine if an operand is simple enough
4205    to be evaluated unconditionally.  */
4206
4207 static int
4208 simple_operand_p (const_tree exp)
4209 {
4210   /* Strip any conversions that don't change the machine mode.  */
4211   STRIP_NOPS (exp);
4212
4213   return (CONSTANT_CLASS_P (exp)
4214           || TREE_CODE (exp) == SSA_NAME
4215           || (DECL_P (exp)
4216               && ! TREE_ADDRESSABLE (exp)
4217               && ! TREE_THIS_VOLATILE (exp)
4218               && ! DECL_NONLOCAL (exp)
4219               /* Don't regard global variables as simple.  They may be
4220                  allocated in ways unknown to the compiler (shared memory,
4221                  #pragma weak, etc).  */
4222               && ! TREE_PUBLIC (exp)
4223               && ! DECL_EXTERNAL (exp)
4224               /* Loading a static variable is unduly expensive, but global
4225                  registers aren't expensive.  */
4226               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
4227 }
4228 \f
4229 /* The following functions are subroutines to fold_range_test and allow it to
4230    try to change a logical combination of comparisons into a range test.
4231
4232    For example, both
4233         X == 2 || X == 3 || X == 4 || X == 5
4234    and
4235         X >= 2 && X <= 5
4236    are converted to
4237         (unsigned) (X - 2) <= 3
4238
4239    We describe each set of comparisons as being either inside or outside
4240    a range, using a variable named like IN_P, and then describe the
4241    range with a lower and upper bound.  If one of the bounds is omitted,
4242    it represents either the highest or lowest value of the type.
4243
4244    In the comments below, we represent a range by two numbers in brackets
4245    preceded by a "+" to designate being inside that range, or a "-" to
4246    designate being outside that range, so the condition can be inverted by
4247    flipping the prefix.  An omitted bound is represented by a "-".  For
4248    example, "- [-, 10]" means being outside the range starting at the lowest
4249    possible value and ending at 10, in other words, being greater than 10.
4250    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4251    always false.
4252
4253    We set up things so that the missing bounds are handled in a consistent
4254    manner so neither a missing bound nor "true" and "false" need to be
4255    handled using a special case.  */
4256
4257 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4258    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4259    and UPPER1_P are nonzero if the respective argument is an upper bound
4260    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
4261    must be specified for a comparison.  ARG1 will be converted to ARG0's
4262    type if both are specified.  */
4263
4264 static tree
4265 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
4266              tree arg1, int upper1_p)
4267 {
4268   tree tem;
4269   int result;
4270   int sgn0, sgn1;
4271
4272   /* If neither arg represents infinity, do the normal operation.
4273      Else, if not a comparison, return infinity.  Else handle the special
4274      comparison rules. Note that most of the cases below won't occur, but
4275      are handled for consistency.  */
4276
4277   if (arg0 != 0 && arg1 != 0)
4278     {
4279       tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
4280                          arg0, fold_convert (TREE_TYPE (arg0), arg1));
4281       STRIP_NOPS (tem);
4282       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
4283     }
4284
4285   if (TREE_CODE_CLASS (code) != tcc_comparison)
4286     return 0;
4287
4288   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4289      for neither.  In real maths, we cannot assume open ended ranges are
4290      the same. But, this is computer arithmetic, where numbers are finite.
4291      We can therefore make the transformation of any unbounded range with
4292      the value Z, Z being greater than any representable number. This permits
4293      us to treat unbounded ranges as equal.  */
4294   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
4295   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
4296   switch (code)
4297     {
4298     case EQ_EXPR:
4299       result = sgn0 == sgn1;
4300       break;
4301     case NE_EXPR:
4302       result = sgn0 != sgn1;
4303       break;
4304     case LT_EXPR:
4305       result = sgn0 < sgn1;
4306       break;
4307     case LE_EXPR:
4308       result = sgn0 <= sgn1;
4309       break;
4310     case GT_EXPR:
4311       result = sgn0 > sgn1;
4312       break;
4313     case GE_EXPR:
4314       result = sgn0 >= sgn1;
4315       break;
4316     default:
4317       gcc_unreachable ();
4318     }
4319
4320   return constant_boolean_node (result, type);
4321 }
4322 \f
4323 /* Given EXP, a logical expression, set the range it is testing into
4324    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
4325    actually being tested.  *PLOW and *PHIGH will be made of the same
4326    type as the returned expression.  If EXP is not a comparison, we
4327    will most likely not be returning a useful value and range.  Set
4328    *STRICT_OVERFLOW_P to true if the return value is only valid
4329    because signed overflow is undefined; otherwise, do not change
4330    *STRICT_OVERFLOW_P.  */
4331
4332 static tree
4333 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
4334             bool *strict_overflow_p)
4335 {
4336   enum tree_code code;
4337   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
4338   tree exp_type = NULL_TREE, arg0_type = NULL_TREE;
4339   int in_p, n_in_p;
4340   tree low, high, n_low, n_high;
4341
4342   /* Start with simply saying "EXP != 0" and then look at the code of EXP
4343      and see if we can refine the range.  Some of the cases below may not
4344      happen, but it doesn't seem worth worrying about this.  We "continue"
4345      the outer loop when we've changed something; otherwise we "break"
4346      the switch, which will "break" the while.  */
4347
4348   in_p = 0;
4349   low = high = build_int_cst (TREE_TYPE (exp), 0);
4350
4351   while (1)
4352     {
4353       code = TREE_CODE (exp);
4354       exp_type = TREE_TYPE (exp);
4355
4356       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
4357         {
4358           if (TREE_OPERAND_LENGTH (exp) > 0)
4359             arg0 = TREE_OPERAND (exp, 0);
4360           if (TREE_CODE_CLASS (code) == tcc_comparison
4361               || TREE_CODE_CLASS (code) == tcc_unary
4362               || TREE_CODE_CLASS (code) == tcc_binary)
4363             arg0_type = TREE_TYPE (arg0);
4364           if (TREE_CODE_CLASS (code) == tcc_binary
4365               || TREE_CODE_CLASS (code) == tcc_comparison
4366               || (TREE_CODE_CLASS (code) == tcc_expression
4367                   && TREE_OPERAND_LENGTH (exp) > 1))
4368             arg1 = TREE_OPERAND (exp, 1);
4369         }
4370
4371       switch (code)
4372         {
4373         case TRUTH_NOT_EXPR:
4374           in_p = ! in_p, exp = arg0;
4375           continue;
4376
4377         case EQ_EXPR: case NE_EXPR:
4378         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
4379           /* We can only do something if the range is testing for zero
4380              and if the second operand is an integer constant.  Note that
4381              saying something is "in" the range we make is done by
4382              complementing IN_P since it will set in the initial case of
4383              being not equal to zero; "out" is leaving it alone.  */
4384           if (low == 0 || high == 0
4385               || ! integer_zerop (low) || ! integer_zerop (high)
4386               || TREE_CODE (arg1) != INTEGER_CST)
4387             break;
4388
4389           switch (code)
4390             {
4391             case NE_EXPR:  /* - [c, c]  */
4392               low = high = arg1;
4393               break;
4394             case EQ_EXPR:  /* + [c, c]  */
4395               in_p = ! in_p, low = high = arg1;
4396               break;
4397             case GT_EXPR:  /* - [-, c] */
4398               low = 0, high = arg1;
4399               break;
4400             case GE_EXPR:  /* + [c, -] */
4401               in_p = ! in_p, low = arg1, high = 0;
4402               break;
4403             case LT_EXPR:  /* - [c, -] */
4404               low = arg1, high = 0;
4405               break;
4406             case LE_EXPR:  /* + [-, c] */
4407               in_p = ! in_p, low = 0, high = arg1;
4408               break;
4409             default:
4410               gcc_unreachable ();
4411             }
4412
4413           /* If this is an unsigned comparison, we also know that EXP is
4414              greater than or equal to zero.  We base the range tests we make
4415              on that fact, so we record it here so we can parse existing
4416              range tests.  We test arg0_type since often the return type
4417              of, e.g. EQ_EXPR, is boolean.  */
4418           if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
4419             {
4420               if (! merge_ranges (&n_in_p, &n_low, &n_high,
4421                                   in_p, low, high, 1,
4422                                   build_int_cst (arg0_type, 0),
4423                                   NULL_TREE))
4424                 break;
4425
4426               in_p = n_in_p, low = n_low, high = n_high;
4427
4428               /* If the high bound is missing, but we have a nonzero low
4429                  bound, reverse the range so it goes from zero to the low bound
4430                  minus 1.  */
4431               if (high == 0 && low && ! integer_zerop (low))
4432                 {
4433                   in_p = ! in_p;
4434                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
4435                                       integer_one_node, 0);
4436                   low = build_int_cst (arg0_type, 0);
4437                 }
4438             }
4439
4440           exp = arg0;
4441           continue;
4442
4443         case NEGATE_EXPR:
4444           /* (-x) IN [a,b] -> x in [-b, -a]  */
4445           n_low = range_binop (MINUS_EXPR, exp_type,
4446                                build_int_cst (exp_type, 0),
4447                                0, high, 1);
4448           n_high = range_binop (MINUS_EXPR, exp_type,
4449                                 build_int_cst (exp_type, 0),
4450                                 0, low, 0);
4451           low = n_low, high = n_high;
4452           exp = arg0;
4453           continue;
4454
4455         case BIT_NOT_EXPR:
4456           /* ~ X -> -X - 1  */
4457           exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
4458                         build_int_cst (exp_type, 1));
4459           continue;
4460
4461         case PLUS_EXPR:  case MINUS_EXPR:
4462           if (TREE_CODE (arg1) != INTEGER_CST)
4463             break;
4464
4465           /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4466              move a constant to the other side.  */
4467           if (!TYPE_UNSIGNED (arg0_type)
4468               && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4469             break;
4470
4471           /* If EXP is signed, any overflow in the computation is undefined,
4472              so we don't worry about it so long as our computations on
4473              the bounds don't overflow.  For unsigned, overflow is defined
4474              and this is exactly the right thing.  */
4475           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4476                                arg0_type, low, 0, arg1, 0);
4477           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4478                                 arg0_type, high, 1, arg1, 0);
4479           if ((n_low != 0 && TREE_OVERFLOW (n_low))
4480               || (n_high != 0 && TREE_OVERFLOW (n_high)))
4481             break;
4482
4483           if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
4484             *strict_overflow_p = true;
4485
4486           /* Check for an unsigned range which has wrapped around the maximum
4487              value thus making n_high < n_low, and normalize it.  */
4488           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
4489             {
4490               low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
4491                                  integer_one_node, 0);
4492               high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
4493                                   integer_one_node, 0);
4494
4495               /* If the range is of the form +/- [ x+1, x ], we won't
4496                  be able to normalize it.  But then, it represents the
4497                  whole range or the empty set, so make it
4498                  +/- [ -, - ].  */
4499               if (tree_int_cst_equal (n_low, low)
4500                   && tree_int_cst_equal (n_high, high))
4501                 low = high = 0;
4502               else
4503                 in_p = ! in_p;
4504             }
4505           else
4506             low = n_low, high = n_high;
4507
4508           exp = arg0;
4509           continue;
4510
4511         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
4512           if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4513             break;
4514
4515           if (! INTEGRAL_TYPE_P (arg0_type)
4516               || (low != 0 && ! int_fits_type_p (low, arg0_type))
4517               || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4518             break;
4519
4520           n_low = low, n_high = high;
4521
4522           if (n_low != 0)
4523             n_low = fold_convert (arg0_type, n_low);
4524
4525           if (n_high != 0)
4526             n_high = fold_convert (arg0_type, n_high);
4527
4528
4529           /* If we're converting arg0 from an unsigned type, to exp,
4530              a signed type,  we will be doing the comparison as unsigned.
4531              The tests above have already verified that LOW and HIGH
4532              are both positive.
4533
4534              So we have to ensure that we will handle large unsigned
4535              values the same way that the current signed bounds treat
4536              negative values.  */
4537
4538           if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4539             {
4540               tree high_positive;
4541               tree equiv_type;
4542               /* For fixed-point modes, we need to pass the saturating flag
4543                  as the 2nd parameter.  */
4544               if (ALL_FIXED_POINT_MODE_P (TYPE_MODE (arg0_type)))
4545                 equiv_type = lang_hooks.types.type_for_mode
4546                              (TYPE_MODE (arg0_type),
4547                               TYPE_SATURATING (arg0_type));
4548               else
4549                 equiv_type = lang_hooks.types.type_for_mode
4550                              (TYPE_MODE (arg0_type), 1);
4551
4552               /* A range without an upper bound is, naturally, unbounded.
4553                  Since convert would have cropped a very large value, use
4554                  the max value for the destination type.  */
4555               high_positive
4556                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4557                 : TYPE_MAX_VALUE (arg0_type);
4558
4559               if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4560                 high_positive = fold_build2 (RSHIFT_EXPR, arg0_type,
4561                                              fold_convert (arg0_type,
4562                                                            high_positive),
4563                                              build_int_cst (arg0_type, 1));
4564
4565               /* If the low bound is specified, "and" the range with the
4566                  range for which the original unsigned value will be
4567                  positive.  */
4568               if (low != 0)
4569                 {
4570                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
4571                                       1, n_low, n_high, 1,
4572                                       fold_convert (arg0_type,
4573                                                     integer_zero_node),
4574                                       high_positive))
4575                     break;
4576
4577                   in_p = (n_in_p == in_p);
4578                 }
4579               else
4580                 {
4581                   /* Otherwise, "or" the range with the range of the input
4582                      that will be interpreted as negative.  */
4583                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
4584                                       0, n_low, n_high, 1,
4585                                       fold_convert (arg0_type,
4586                                                     integer_zero_node),
4587                                       high_positive))
4588                     break;
4589
4590                   in_p = (in_p != n_in_p);
4591                 }
4592             }
4593
4594           exp = arg0;
4595           low = n_low, high = n_high;
4596           continue;
4597
4598         default:
4599           break;
4600         }
4601
4602       break;
4603     }
4604
4605   /* If EXP is a constant, we can evaluate whether this is true or false.  */
4606   if (TREE_CODE (exp) == INTEGER_CST)
4607     {
4608       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4609                                                  exp, 0, low, 0))
4610                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
4611                                                     exp, 1, high, 1)));
4612       low = high = 0;
4613       exp = 0;
4614     }
4615
4616   *pin_p = in_p, *plow = low, *phigh = high;
4617   return exp;
4618 }
4619 \f
4620 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4621    type, TYPE, return an expression to test if EXP is in (or out of, depending
4622    on IN_P) the range.  Return 0 if the test couldn't be created.  */
4623
4624 static tree
4625 build_range_check (tree type, tree exp, int in_p, tree low, tree high)
4626 {
4627   tree etype = TREE_TYPE (exp);
4628   tree value;
4629
4630 #ifdef HAVE_canonicalize_funcptr_for_compare
4631   /* Disable this optimization for function pointer expressions
4632      on targets that require function pointer canonicalization.  */
4633   if (HAVE_canonicalize_funcptr_for_compare
4634       && TREE_CODE (etype) == POINTER_TYPE
4635       && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4636     return NULL_TREE;
4637 #endif
4638
4639   if (! in_p)
4640     {
4641       value = build_range_check (type, exp, 1, low, high);
4642       if (value != 0)
4643         return invert_truthvalue (value);
4644
4645       return 0;
4646     }
4647
4648   if (low == 0 && high == 0)
4649     return build_int_cst (type, 1);
4650
4651   if (low == 0)
4652     return fold_build2 (LE_EXPR, type, exp,
4653                         fold_convert (etype, high));
4654
4655   if (high == 0)
4656     return fold_build2 (GE_EXPR, type, exp,
4657                         fold_convert (etype, low));
4658
4659   if (operand_equal_p (low, high, 0))
4660     return fold_build2 (EQ_EXPR, type, exp,
4661                         fold_convert (etype, low));
4662
4663   if (integer_zerop (low))
4664     {
4665       if (! TYPE_UNSIGNED (etype))
4666         {
4667           etype = unsigned_type_for (etype);
4668           high = fold_convert (etype, high);
4669           exp = fold_convert (etype, exp);
4670         }
4671       return build_range_check (type, exp, 1, 0, high);
4672     }
4673
4674   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
4675   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4676     {
4677       unsigned HOST_WIDE_INT lo;
4678       HOST_WIDE_INT hi;
4679       int prec;
4680
4681       prec = TYPE_PRECISION (etype);
4682       if (prec <= HOST_BITS_PER_WIDE_INT)
4683         {
4684           hi = 0;
4685           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
4686         }
4687       else
4688         {
4689           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
4690           lo = (unsigned HOST_WIDE_INT) -1;
4691         }
4692
4693       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
4694         {
4695           if (TYPE_UNSIGNED (etype))
4696             {
4697               etype = signed_type_for (etype);
4698               exp = fold_convert (etype, exp);
4699             }
4700           return fold_build2 (GT_EXPR, type, exp,
4701                               build_int_cst (etype, 0));
4702         }
4703     }
4704
4705   /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4706      This requires wrap-around arithmetics for the type of the expression.  */
4707   switch (TREE_CODE (etype))
4708     {
4709     case INTEGER_TYPE:
4710       /* There is no requirement that LOW be within the range of ETYPE
4711          if the latter is a subtype.  It must, however, be within the base
4712          type of ETYPE.  So be sure we do the subtraction in that type.  */
4713       if (TREE_TYPE (etype))
4714         etype = TREE_TYPE (etype);
4715       break;
4716
4717     case ENUMERAL_TYPE:
4718     case BOOLEAN_TYPE:
4719       etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4720                                               TYPE_UNSIGNED (etype));
4721       break;
4722
4723     default:
4724       break;
4725     }
4726
4727   /* If we don't have wrap-around arithmetics upfront, try to force it.  */
4728   if (TREE_CODE (etype) == INTEGER_TYPE
4729       && !TYPE_OVERFLOW_WRAPS (etype))
4730     {
4731       tree utype, minv, maxv;
4732
4733       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4734          for the type in question, as we rely on this here.  */
4735       utype = unsigned_type_for (etype);
4736       maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
4737       maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4738                           integer_one_node, 1);
4739       minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
4740
4741       if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4742                                       minv, 1, maxv, 1)))
4743         etype = utype;
4744       else
4745         return 0;
4746     }
4747
4748   high = fold_convert (etype, high);
4749   low = fold_convert (etype, low);
4750   exp = fold_convert (etype, exp);
4751
4752   value = const_binop (MINUS_EXPR, high, low, 0);
4753
4754
4755   if (POINTER_TYPE_P (etype))
4756     {
4757       if (value != 0 && !TREE_OVERFLOW (value))
4758         {
4759           low = fold_convert (sizetype, low);
4760           low = fold_build1 (NEGATE_EXPR, sizetype, low);
4761           return build_range_check (type,
4762                                     fold_build2 (POINTER_PLUS_EXPR, etype, exp, low),
4763                                     1, build_int_cst (etype, 0), value);
4764         }
4765       return 0;
4766     }
4767
4768   if (value != 0 && !TREE_OVERFLOW (value))
4769     return build_range_check (type,
4770                               fold_build2 (MINUS_EXPR, etype, exp, low),
4771                               1, build_int_cst (etype, 0), value);
4772
4773   return 0;
4774 }
4775 \f
4776 /* Return the predecessor of VAL in its type, handling the infinite case.  */
4777
4778 static tree
4779 range_predecessor (tree val)
4780 {
4781   tree type = TREE_TYPE (val);
4782
4783   if (INTEGRAL_TYPE_P (type)
4784       && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4785     return 0;
4786   else
4787     return range_binop (MINUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4788 }
4789
4790 /* Return the successor of VAL in its type, handling the infinite case.  */
4791
4792 static tree
4793 range_successor (tree val)
4794 {
4795   tree type = TREE_TYPE (val);
4796
4797   if (INTEGRAL_TYPE_P (type)
4798       && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4799     return 0;
4800   else
4801     return range_binop (PLUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4802 }
4803
4804 /* Given two ranges, see if we can merge them into one.  Return 1 if we
4805    can, 0 if we can't.  Set the output range into the specified parameters.  */
4806
4807 static int
4808 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4809               tree high0, int in1_p, tree low1, tree high1)
4810 {
4811   int no_overlap;
4812   int subset;
4813   int temp;
4814   tree tem;
4815   int in_p;
4816   tree low, high;
4817   int lowequal = ((low0 == 0 && low1 == 0)
4818                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4819                                                 low0, 0, low1, 0)));
4820   int highequal = ((high0 == 0 && high1 == 0)
4821                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4822                                                  high0, 1, high1, 1)));
4823
4824   /* Make range 0 be the range that starts first, or ends last if they
4825      start at the same value.  Swap them if it isn't.  */
4826   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4827                                  low0, 0, low1, 0))
4828       || (lowequal
4829           && integer_onep (range_binop (GT_EXPR, integer_type_node,
4830                                         high1, 1, high0, 1))))
4831     {
4832       temp = in0_p, in0_p = in1_p, in1_p = temp;
4833       tem = low0, low0 = low1, low1 = tem;
4834       tem = high0, high0 = high1, high1 = tem;
4835     }
4836
4837   /* Now flag two cases, whether the ranges are disjoint or whether the
4838      second range is totally subsumed in the first.  Note that the tests
4839      below are simplified by the ones above.  */
4840   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4841                                           high0, 1, low1, 0));
4842   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4843                                       high1, 1, high0, 1));
4844
4845   /* We now have four cases, depending on whether we are including or
4846      excluding the two ranges.  */
4847   if (in0_p && in1_p)
4848     {
4849       /* If they don't overlap, the result is false.  If the second range
4850          is a subset it is the result.  Otherwise, the range is from the start
4851          of the second to the end of the first.  */
4852       if (no_overlap)
4853         in_p = 0, low = high = 0;
4854       else if (subset)
4855         in_p = 1, low = low1, high = high1;
4856       else
4857         in_p = 1, low = low1, high = high0;
4858     }
4859
4860   else if (in0_p && ! in1_p)
4861     {
4862       /* If they don't overlap, the result is the first range.  If they are
4863          equal, the result is false.  If the second range is a subset of the
4864          first, and the ranges begin at the same place, we go from just after
4865          the end of the second range to the end of the first.  If the second
4866          range is not a subset of the first, or if it is a subset and both
4867          ranges end at the same place, the range starts at the start of the
4868          first range and ends just before the second range.
4869          Otherwise, we can't describe this as a single range.  */
4870       if (no_overlap)
4871         in_p = 1, low = low0, high = high0;
4872       else if (lowequal && highequal)
4873         in_p = 0, low = high = 0;
4874       else if (subset && lowequal)
4875         {
4876           low = range_successor (high1);
4877           high = high0;
4878           in_p = 1;
4879           if (low == 0)
4880             {
4881               /* We are in the weird situation where high0 > high1 but
4882                  high1 has no successor.  Punt.  */
4883               return 0;
4884             }
4885         }
4886       else if (! subset || highequal)
4887         {
4888           low = low0;
4889           high = range_predecessor (low1);
4890           in_p = 1;
4891           if (high == 0)
4892             {
4893               /* low0 < low1 but low1 has no predecessor.  Punt.  */
4894               return 0;
4895             }
4896         }
4897       else
4898         return 0;
4899     }
4900
4901   else if (! in0_p && in1_p)
4902     {
4903       /* If they don't overlap, the result is the second range.  If the second
4904          is a subset of the first, the result is false.  Otherwise,
4905          the range starts just after the first range and ends at the
4906          end of the second.  */
4907       if (no_overlap)
4908         in_p = 1, low = low1, high = high1;
4909       else if (subset || highequal)
4910         in_p = 0, low = high = 0;
4911       else
4912         {
4913           low = range_successor (high0);
4914           high = high1;
4915           in_p = 1;
4916           if (low == 0)
4917             {
4918               /* high1 > high0 but high0 has no successor.  Punt.  */
4919               return 0;
4920             }
4921         }
4922     }
4923
4924   else
4925     {
4926       /* The case where we are excluding both ranges.  Here the complex case
4927          is if they don't overlap.  In that case, the only time we have a
4928          range is if they are adjacent.  If the second is a subset of the
4929          first, the result is the first.  Otherwise, the range to exclude
4930          starts at the beginning of the first range and ends at the end of the
4931          second.  */
4932       if (no_overlap)
4933         {
4934           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4935                                          range_successor (high0),
4936                                          1, low1, 0)))
4937             in_p = 0, low = low0, high = high1;
4938           else
4939             {
4940               /* Canonicalize - [min, x] into - [-, x].  */
4941               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4942                 switch (TREE_CODE (TREE_TYPE (low0)))
4943                   {
4944                   case ENUMERAL_TYPE:
4945                     if (TYPE_PRECISION (TREE_TYPE (low0))
4946                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4947                       break;
4948                     /* FALLTHROUGH */
4949                   case INTEGER_TYPE:
4950                     if (tree_int_cst_equal (low0,
4951                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4952                       low0 = 0;
4953                     break;
4954                   case POINTER_TYPE:
4955                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4956                         && integer_zerop (low0))
4957                       low0 = 0;
4958                     break;
4959                   default:
4960                     break;
4961                   }
4962
4963               /* Canonicalize - [x, max] into - [x, -].  */
4964               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4965                 switch (TREE_CODE (TREE_TYPE (high1)))
4966                   {
4967                   case ENUMERAL_TYPE:
4968                     if (TYPE_PRECISION (TREE_TYPE (high1))
4969                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4970                       break;
4971                     /* FALLTHROUGH */
4972                   case INTEGER_TYPE:
4973                     if (tree_int_cst_equal (high1,
4974                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4975                       high1 = 0;
4976                     break;
4977                   case POINTER_TYPE:
4978                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4979                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4980                                                        high1, 1,
4981                                                        integer_one_node, 1)))
4982                       high1 = 0;
4983                     break;
4984                   default:
4985                     break;
4986                   }
4987
4988               /* The ranges might be also adjacent between the maximum and
4989                  minimum values of the given type.  For
4990                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4991                  return + [x + 1, y - 1].  */
4992               if (low0 == 0 && high1 == 0)
4993                 {
4994                   low = range_successor (high0);
4995                   high = range_predecessor (low1);
4996                   if (low == 0 || high == 0)
4997                     return 0;
4998
4999                   in_p = 1;
5000                 }
5001               else
5002                 return 0;
5003             }
5004         }
5005       else if (subset)
5006         in_p = 0, low = low0, high = high0;
5007       else
5008         in_p = 0, low = low0, high = high1;
5009     }
5010
5011   *pin_p = in_p, *plow = low, *phigh = high;
5012   return 1;
5013 }
5014 \f
5015
5016 /* Subroutine of fold, looking inside expressions of the form
5017    A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
5018    of the COND_EXPR.  This function is being used also to optimize
5019    A op B ? C : A, by reversing the comparison first.
5020
5021    Return a folded expression whose code is not a COND_EXPR
5022    anymore, or NULL_TREE if no folding opportunity is found.  */
5023
5024 static tree
5025 fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
5026 {
5027   enum tree_code comp_code = TREE_CODE (arg0);
5028   tree arg00 = TREE_OPERAND (arg0, 0);
5029   tree arg01 = TREE_OPERAND (arg0, 1);
5030   tree arg1_type = TREE_TYPE (arg1);
5031   tree tem;
5032
5033   STRIP_NOPS (arg1);
5034   STRIP_NOPS (arg2);
5035
5036   /* If we have A op 0 ? A : -A, consider applying the following
5037      transformations:
5038
5039      A == 0? A : -A    same as -A
5040      A != 0? A : -A    same as A
5041      A >= 0? A : -A    same as abs (A)
5042      A > 0?  A : -A    same as abs (A)
5043      A <= 0? A : -A    same as -abs (A)
5044      A < 0?  A : -A    same as -abs (A)
5045
5046      None of these transformations work for modes with signed
5047      zeros.  If A is +/-0, the first two transformations will
5048      change the sign of the result (from +0 to -0, or vice
5049      versa).  The last four will fix the sign of the result,
5050      even though the original expressions could be positive or
5051      negative, depending on the sign of A.
5052
5053      Note that all these transformations are correct if A is
5054      NaN, since the two alternatives (A and -A) are also NaNs.  */
5055   if ((FLOAT_TYPE_P (TREE_TYPE (arg01))
5056        ? real_zerop (arg01)
5057        : integer_zerop (arg01))
5058       && ((TREE_CODE (arg2) == NEGATE_EXPR
5059            && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
5060              /* In the case that A is of the form X-Y, '-A' (arg2) may
5061                 have already been folded to Y-X, check for that. */
5062           || (TREE_CODE (arg1) == MINUS_EXPR
5063               && TREE_CODE (arg2) == MINUS_EXPR
5064               && operand_equal_p (TREE_OPERAND (arg1, 0),
5065                                   TREE_OPERAND (arg2, 1), 0)
5066               && operand_equal_p (TREE_OPERAND (arg1, 1),
5067                                   TREE_OPERAND (arg2, 0), 0))))
5068     switch (comp_code)
5069       {
5070       case EQ_EXPR:
5071       case UNEQ_EXPR:
5072         tem = fold_convert (arg1_type, arg1);
5073         return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
5074       case NE_EXPR:
5075       case LTGT_EXPR:
5076         return pedantic_non_lvalue (fold_convert (type, arg1));
5077       case UNGE_EXPR:
5078       case UNGT_EXPR:
5079         if (flag_trapping_math)
5080           break;
5081         /* Fall through.  */
5082       case GE_EXPR:
5083       case GT_EXPR:
5084         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
5085           arg1 = fold_convert (signed_type_for
5086                                (TREE_TYPE (arg1)), arg1);
5087         tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
5088         return pedantic_non_lvalue (fold_convert (type, tem));
5089       case UNLE_EXPR:
5090       case UNLT_EXPR:
5091         if (flag_trapping_math)
5092           break;
5093       case LE_EXPR:
5094       case LT_EXPR:
5095         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
5096           arg1 = fold_convert (signed_type_for
5097                                (TREE_TYPE (arg1)), arg1);
5098         tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
5099         return negate_expr (fold_convert (type, tem));
5100       default:
5101         gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
5102         break;
5103       }
5104
5105   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
5106      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
5107      both transformations are correct when A is NaN: A != 0
5108      is then true, and A == 0 is false.  */
5109
5110   if (integer_zerop (arg01) && integer_zerop (arg2))
5111     {
5112       if (comp_code == NE_EXPR)
5113         return pedantic_non_lvalue (fold_convert (type, arg1));
5114       else if (comp_code == EQ_EXPR)
5115         return build_int_cst (type, 0);
5116     }
5117
5118   /* Try some transformations of A op B ? A : B.
5119
5120      A == B? A : B    same as B
5121      A != B? A : B    same as A
5122      A >= B? A : B    same as max (A, B)
5123      A > B?  A : B    same as max (B, A)
5124      A <= B? A : B    same as min (A, B)
5125      A < B?  A : B    same as min (B, A)
5126
5127      As above, these transformations don't work in the presence
5128      of signed zeros.  For example, if A and B are zeros of
5129      opposite sign, the first two transformations will change
5130      the sign of the result.  In the last four, the original
5131      expressions give different results for (A=+0, B=-0) and
5132      (A=-0, B=+0), but the transformed expressions do not.
5133
5134      The first two transformations are correct if either A or B
5135      is a NaN.  In the first transformation, the condition will
5136      be false, and B will indeed be chosen.  In the case of the
5137      second transformation, the condition A != B will be true,
5138      and A will be chosen.
5139
5140      The conversions to max() and min() are not correct if B is
5141      a number and A is not.  The conditions in the original
5142      expressions will be false, so all four give B.  The min()
5143      and max() versions would give a NaN instead.  */
5144   if (operand_equal_for_comparison_p (arg01, arg2, arg00)
5145       /* Avoid these transformations if the COND_EXPR may be used
5146          as an lvalue in the C++ front-end.  PR c++/19199.  */
5147       && (in_gimple_form
5148           || (strcmp (lang_hooks.name, "GNU C++") != 0
5149               && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
5150           || ! maybe_lvalue_p (arg1)
5151           || ! maybe_lvalue_p (arg2)))
5152     {
5153       tree comp_op0 = arg00;
5154       tree comp_op1 = arg01;
5155       tree comp_type = TREE_TYPE (comp_op0);
5156
5157       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
5158       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
5159         {
5160           comp_type = type;
5161           comp_op0 = arg1;
5162           comp_op1 = arg2;
5163         }
5164
5165       switch (comp_code)
5166         {
5167         case EQ_EXPR:
5168           return pedantic_non_lvalue (fold_convert (type, arg2));
5169         case NE_EXPR:
5170           return pedantic_non_lvalue (fold_convert (type, arg1));
5171         case LE_EXPR:
5172         case LT_EXPR:
5173         case UNLE_EXPR:
5174         case UNLT_EXPR:
5175           /* In C++ a ?: expression can be an lvalue, so put the
5176              operand which will be used if they are equal first
5177              so that we can convert this back to the
5178              corresponding COND_EXPR.  */
5179           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5180             {
5181               comp_op0 = fold_convert (comp_type, comp_op0);
5182               comp_op1 = fold_convert (comp_type, comp_op1);
5183               tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
5184                     ? fold_build2 (MIN_EXPR, comp_type, comp_op0, comp_op1)
5185                     : fold_build2 (MIN_EXPR, comp_type, comp_op1, comp_op0);
5186               return pedantic_non_lvalue (fold_convert (type, tem));
5187             }
5188           break;
5189         case GE_EXPR:
5190         case GT_EXPR:
5191         case UNGE_EXPR:
5192         case UNGT_EXPR:
5193           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5194             {
5195               comp_op0 = fold_convert (comp_type, comp_op0);
5196               comp_op1 = fold_convert (comp_type, comp_op1);
5197               tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
5198                     ? fold_build2 (MAX_EXPR, comp_type, comp_op0, comp_op1)
5199                     : fold_build2 (MAX_EXPR, comp_type, comp_op1, comp_op0);
5200               return pedantic_non_lvalue (fold_convert (type, tem));
5201             }
5202           break;
5203         case UNEQ_EXPR:
5204           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5205             return pedantic_non_lvalue (fold_convert (type, arg2));
5206           break;
5207         case LTGT_EXPR:
5208           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
5209             return pedantic_non_lvalue (fold_convert (type, arg1));
5210           break;
5211         default:
5212           gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
5213           break;
5214         }
5215     }
5216
5217   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
5218      we might still be able to simplify this.  For example,
5219      if C1 is one less or one more than C2, this might have started
5220      out as a MIN or MAX and been transformed by this function.
5221      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
5222
5223   if (INTEGRAL_TYPE_P (type)
5224       && TREE_CODE (arg01) == INTEGER_CST
5225       && TREE_CODE (arg2) == INTEGER_CST)
5226     switch (comp_code)
5227       {
5228       case EQ_EXPR:
5229         /* We can replace A with C1 in this case.  */
5230         arg1 = fold_convert (type, arg01);
5231         return fold_build3 (COND_EXPR, type, arg0, arg1, arg2);
5232
5233       case LT_EXPR:
5234         /* If C1 is C2 + 1, this is min(A, C2).  */
5235         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5236                                OEP_ONLY_CONST)
5237             && operand_equal_p (arg01,
5238                                 const_binop (PLUS_EXPR, arg2,
5239                                              build_int_cst (type, 1), 0),
5240                                 OEP_ONLY_CONST))
5241           return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
5242                                                    type,
5243                                                    fold_convert (type, arg1),
5244                                                    arg2));
5245         break;
5246
5247       case LE_EXPR:
5248         /* If C1 is C2 - 1, this is min(A, C2).  */
5249         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5250                                OEP_ONLY_CONST)
5251             && operand_equal_p (arg01,
5252                                 const_binop (MINUS_EXPR, arg2,
5253                                              build_int_cst (type, 1), 0),
5254                                 OEP_ONLY_CONST))
5255           return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
5256                                                    type,
5257                                                    fold_convert (type, arg1),
5258                                                    arg2));
5259         break;
5260
5261       case GT_EXPR:
5262         /* If C1 is C2 - 1, this is max(A, C2).  */
5263         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
5264                                OEP_ONLY_CONST)
5265             && operand_equal_p (arg01,
5266                                 const_binop (MINUS_EXPR, arg2,
5267                                              build_int_cst (type, 1), 0),
5268                                 OEP_ONLY_CONST))
5269           return pedantic_non_lvalue (fold_build2 (MAX_EXPR,
5270                                                    type,
5271                                                    fold_convert (type, arg1),
5272                                                    arg2));
5273         break;
5274
5275       case GE_EXPR:
5276         /* If C1 is C2 + 1, this is max(A, C2).  */
5277         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
5278                                OEP_ONLY_CONST)
5279             && operand_equal_p (arg01,
5280                                 const_binop (PLUS_EXPR, arg2,
5281                                              build_int_cst (type, 1), 0),
5282                                 OEP_ONLY_CONST))
5283           return pedantic_non_lvalue (fold_build2 (MAX_EXPR,
5284                                                    type,
5285                                                    fold_convert (type, arg1),
5286                                                    arg2));
5287         break;
5288       case NE_EXPR:
5289         break;
5290       default:
5291         gcc_unreachable ();
5292       }
5293
5294   return NULL_TREE;
5295 }
5296
5297
5298 \f
5299 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
5300 #define LOGICAL_OP_NON_SHORT_CIRCUIT (BRANCH_COST >= 2)
5301 #endif
5302
5303 /* EXP is some logical combination of boolean tests.  See if we can
5304    merge it into some range test.  Return the new tree if so.  */
5305
5306 static tree
5307 fold_range_test (enum tree_code code, tree type, tree op0, tree op1)
5308 {
5309   int or_op = (code == TRUTH_ORIF_EXPR
5310                || code == TRUTH_OR_EXPR);
5311   int in0_p, in1_p, in_p;
5312   tree low0, low1, low, high0, high1, high;
5313   bool strict_overflow_p = false;
5314   tree lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
5315   tree rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
5316   tree tem;
5317   const char * const warnmsg = G_("assuming signed overflow does not occur "
5318                                   "when simplifying range test");
5319
5320   /* If this is an OR operation, invert both sides; we will invert
5321      again at the end.  */
5322   if (or_op)
5323     in0_p = ! in0_p, in1_p = ! in1_p;
5324
5325   /* If both expressions are the same, if we can merge the ranges, and we
5326      can build the range test, return it or it inverted.  If one of the
5327      ranges is always true or always false, consider it to be the same
5328      expression as the other.  */
5329   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
5330       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
5331                        in1_p, low1, high1)
5332       && 0 != (tem = (build_range_check (type,
5333                                          lhs != 0 ? lhs
5334                                          : rhs != 0 ? rhs : integer_zero_node,
5335                                          in_p, low, high))))
5336     {
5337       if (strict_overflow_p)
5338         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
5339       return or_op ? invert_truthvalue (tem) : tem;
5340     }
5341
5342   /* On machines where the branch cost is expensive, if this is a
5343      short-circuited branch and the underlying object on both sides
5344      is the same, make a non-short-circuit operation.  */
5345   else if (LOGICAL_OP_NON_SHORT_CIRCUIT
5346            && lhs != 0 && rhs != 0
5347            && (code == TRUTH_ANDIF_EXPR
5348                || code == TRUTH_ORIF_EXPR)
5349            && operand_equal_p (lhs, rhs, 0))
5350     {
5351       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
5352          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
5353          which cases we can't do this.  */
5354       if (simple_operand_p (lhs))
5355         return build2 (code == TRUTH_ANDIF_EXPR
5356                        ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5357                        type, op0, op1);
5358
5359       else if (lang_hooks.decls.global_bindings_p () == 0
5360                && ! CONTAINS_PLACEHOLDER_P (lhs))
5361         {
5362           tree common = save_expr (lhs);
5363
5364           if (0 != (lhs = build_range_check (type, common,
5365                                              or_op ? ! in0_p : in0_p,
5366                                              low0, high0))
5367               && (0 != (rhs = build_range_check (type, common,
5368                                                  or_op ? ! in1_p : in1_p,
5369                                                  low1, high1))))
5370             {
5371               if (strict_overflow_p)
5372                 fold_overflow_warning (warnmsg,
5373                                        WARN_STRICT_OVERFLOW_COMPARISON);
5374               return build2 (code == TRUTH_ANDIF_EXPR
5375                              ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
5376                              type, lhs, rhs);
5377             }
5378         }
5379     }
5380
5381   return 0;
5382 }
5383 \f
5384 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
5385    bit value.  Arrange things so the extra bits will be set to zero if and
5386    only if C is signed-extended to its full width.  If MASK is nonzero,
5387    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
5388
5389 static tree
5390 unextend (tree c, int p, int unsignedp, tree mask)
5391 {
5392   tree type = TREE_TYPE (c);
5393   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
5394   tree temp;
5395
5396   if (p == modesize || unsignedp)
5397     return c;
5398
5399   /* We work by getting just the sign bit into the low-order bit, then
5400      into the high-order bit, then sign-extend.  We then XOR that value
5401      with C.  */
5402   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
5403   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
5404
5405   /* We must use a signed type in order to get an arithmetic right shift.
5406      However, we must also avoid introducing accidental overflows, so that
5407      a subsequent call to integer_zerop will work.  Hence we must
5408      do the type conversion here.  At this point, the constant is either
5409      zero or one, and the conversion to a signed type can never overflow.
5410      We could get an overflow if this conversion is done anywhere else.  */
5411   if (TYPE_UNSIGNED (type))
5412     temp = fold_convert (signed_type_for (type), temp);
5413
5414   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
5415   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
5416   if (mask != 0)
5417     temp = const_binop (BIT_AND_EXPR, temp,
5418                         fold_convert (TREE_TYPE (c), mask), 0);
5419   /* If necessary, convert the type back to match the type of C.  */
5420   if (TYPE_UNSIGNED (type))
5421     temp = fold_convert (type, temp);
5422
5423   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
5424 }
5425 \f
5426 /* Find ways of folding logical expressions of LHS and RHS:
5427    Try to merge two comparisons to the same innermost item.
5428    Look for range tests like "ch >= '0' && ch <= '9'".
5429    Look for combinations of simple terms on machines with expensive branches
5430    and evaluate the RHS unconditionally.
5431
5432    For example, if we have p->a == 2 && p->b == 4 and we can make an
5433    object large enough to span both A and B, we can do this with a comparison
5434    against the object ANDed with the a mask.
5435
5436    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5437    operations to do this with one comparison.
5438
5439    We check for both normal comparisons and the BIT_AND_EXPRs made this by
5440    function and the one above.
5441
5442    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
5443    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5444
5445    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5446    two operands.
5447
5448    We return the simplified tree or 0 if no optimization is possible.  */
5449
5450 static tree
5451 fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
5452 {
5453   /* If this is the "or" of two comparisons, we can do something if
5454      the comparisons are NE_EXPR.  If this is the "and", we can do something
5455      if the comparisons are EQ_EXPR.  I.e.,
5456         (a->b == 2 && a->c == 4) can become (a->new == NEW).
5457
5458      WANTED_CODE is this operation code.  For single bit fields, we can
5459      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5460      comparison for one-bit fields.  */
5461
5462   enum tree_code wanted_code;
5463   enum tree_code lcode, rcode;
5464   tree ll_arg, lr_arg, rl_arg, rr_arg;
5465   tree ll_inner, lr_inner, rl_inner, rr_inner;
5466   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5467   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5468   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5469   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5470   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5471   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5472   enum machine_mode lnmode, rnmode;
5473   tree ll_mask, lr_mask, rl_mask, rr_mask;
5474   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5475   tree l_const, r_const;
5476   tree lntype, rntype, result;
5477   int first_bit, end_bit;
5478   int volatilep;
5479   tree orig_lhs = lhs, orig_rhs = rhs;
5480   enum tree_code orig_code = code;
5481
5482   /* Start by getting the comparison codes.  Fail if anything is volatile.
5483      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5484      it were surrounded with a NE_EXPR.  */
5485
5486   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5487     return 0;
5488
5489   lcode = TREE_CODE (lhs);
5490   rcode = TREE_CODE (rhs);
5491
5492   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5493     {
5494       lhs = build2 (NE_EXPR, truth_type, lhs,
5495                     build_int_cst (TREE_TYPE (lhs), 0));
5496       lcode = NE_EXPR;
5497     }
5498
5499   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5500     {
5501       rhs = build2 (NE_EXPR, truth_type, rhs,
5502                     build_int_cst (TREE_TYPE (rhs), 0));
5503       rcode = NE_EXPR;
5504     }
5505
5506   if (TREE_CODE_CLASS (lcode) != tcc_comparison
5507       || TREE_CODE_CLASS (rcode) != tcc_comparison)
5508     return 0;
5509
5510   ll_arg = TREE_OPERAND (lhs, 0);
5511   lr_arg = TREE_OPERAND (lhs, 1);
5512   rl_arg = TREE_OPERAND (rhs, 0);
5513   rr_arg = TREE_OPERAND (rhs, 1);
5514
5515   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
5516   if (simple_operand_p (ll_arg)
5517       && simple_operand_p (lr_arg))
5518     {
5519       tree result;
5520       if (operand_equal_p (ll_arg, rl_arg, 0)
5521           && operand_equal_p (lr_arg, rr_arg, 0))
5522         {
5523           result = combine_comparisons (code, lcode, rcode,
5524                                         truth_type, ll_arg, lr_arg);
5525           if (result)
5526             return result;
5527         }
5528       else if (operand_equal_p (ll_arg, rr_arg, 0)
5529                && operand_equal_p (lr_arg, rl_arg, 0))
5530         {
5531           result = combine_comparisons (code, lcode,
5532                                         swap_tree_comparison (rcode),
5533                                         truth_type, ll_arg, lr_arg);
5534           if (result)
5535             return result;
5536         }
5537     }
5538
5539   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5540           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5541
5542   /* If the RHS can be evaluated unconditionally and its operands are
5543      simple, it wins to evaluate the RHS unconditionally on machines
5544      with expensive branches.  In this case, this isn't a comparison
5545      that can be merged.  Avoid doing this if the RHS is a floating-point
5546      comparison since those can trap.  */
5547
5548   if (BRANCH_COST >= 2
5549       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5550       && simple_operand_p (rl_arg)
5551       && simple_operand_p (rr_arg))
5552     {
5553       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
5554       if (code == TRUTH_OR_EXPR
5555           && lcode == NE_EXPR && integer_zerop (lr_arg)
5556           && rcode == NE_EXPR && integer_zerop (rr_arg)
5557           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
5558         return build2 (NE_EXPR, truth_type,
5559                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5560                                ll_arg, rl_arg),
5561                        build_int_cst (TREE_TYPE (ll_arg), 0));
5562
5563       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
5564       if (code == TRUTH_AND_EXPR
5565           && lcode == EQ_EXPR && integer_zerop (lr_arg)
5566           && rcode == EQ_EXPR && integer_zerop (rr_arg)
5567           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
5568         return build2 (EQ_EXPR, truth_type,
5569                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5570                                ll_arg, rl_arg),
5571                        build_int_cst (TREE_TYPE (ll_arg), 0));
5572
5573       if (LOGICAL_OP_NON_SHORT_CIRCUIT)
5574         {
5575           if (code != orig_code || lhs != orig_lhs || rhs != orig_rhs)
5576             return build2 (code, truth_type, lhs, rhs);
5577           return NULL_TREE;
5578         }
5579     }
5580
5581   /* See if the comparisons can be merged.  Then get all the parameters for
5582      each side.  */
5583
5584   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5585       || (rcode != EQ_EXPR && rcode != NE_EXPR))
5586     return 0;
5587
5588   volatilep = 0;
5589   ll_inner = decode_field_reference (ll_arg,
5590                                      &ll_bitsize, &ll_bitpos, &ll_mode,
5591                                      &ll_unsignedp, &volatilep, &ll_mask,
5592                                      &ll_and_mask);
5593   lr_inner = decode_field_reference (lr_arg,
5594                                      &lr_bitsize, &lr_bitpos, &lr_mode,
5595                                      &lr_unsignedp, &volatilep, &lr_mask,
5596                                      &lr_and_mask);
5597   rl_inner = decode_field_reference (rl_arg,
5598                                      &rl_bitsize, &rl_bitpos, &rl_mode,
5599                                      &rl_unsignedp, &volatilep, &rl_mask,
5600                                      &rl_and_mask);
5601   rr_inner = decode_field_reference (rr_arg,
5602                                      &rr_bitsize, &rr_bitpos, &rr_mode,
5603                                      &rr_unsignedp, &volatilep, &rr_mask,
5604                                      &rr_and_mask);
5605
5606   /* It must be true that the inner operation on the lhs of each
5607      comparison must be the same if we are to be able to do anything.
5608      Then see if we have constants.  If not, the same must be true for
5609      the rhs's.  */
5610   if (volatilep || ll_inner == 0 || rl_inner == 0
5611       || ! operand_equal_p (ll_inner, rl_inner, 0))
5612     return 0;
5613
5614   if (TREE_CODE (lr_arg) == INTEGER_CST
5615       && TREE_CODE (rr_arg) == INTEGER_CST)
5616     l_const = lr_arg, r_const = rr_arg;
5617   else if (lr_inner == 0 || rr_inner == 0
5618            || ! operand_equal_p (lr_inner, rr_inner, 0))
5619     return 0;
5620   else
5621     l_const = r_const = 0;
5622
5623   /* If either comparison code is not correct for our logical operation,
5624      fail.  However, we can convert a one-bit comparison against zero into
5625      the opposite comparison against that bit being set in the field.  */
5626
5627   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5628   if (lcode != wanted_code)
5629     {
5630       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5631         {
5632           /* Make the left operand unsigned, since we are only interested
5633              in the value of one bit.  Otherwise we are doing the wrong
5634              thing below.  */
5635           ll_unsignedp = 1;
5636           l_const = ll_mask;
5637         }
5638       else
5639         return 0;
5640     }
5641
5642   /* This is analogous to the code for l_const above.  */
5643   if (rcode != wanted_code)
5644     {
5645       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5646         {
5647           rl_unsignedp = 1;
5648           r_const = rl_mask;
5649         }
5650       else
5651         return 0;
5652     }
5653
5654   /* See if we can find a mode that contains both fields being compared on
5655      the left.  If we can't, fail.  Otherwise, update all constants and masks
5656      to be relative to a field of that size.  */
5657   first_bit = MIN (ll_bitpos, rl_bitpos);
5658   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5659   lnmode = get_best_mode (end_bit - first_bit, first_bit,
5660                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5661                           volatilep);
5662   if (lnmode == VOIDmode)
5663     return 0;
5664
5665   lnbitsize = GET_MODE_BITSIZE (lnmode);
5666   lnbitpos = first_bit & ~ (lnbitsize - 1);
5667   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5668   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5669
5670   if (BYTES_BIG_ENDIAN)
5671     {
5672       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5673       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5674     }
5675
5676   ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
5677                          size_int (xll_bitpos), 0);
5678   rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
5679                          size_int (xrl_bitpos), 0);
5680
5681   if (l_const)
5682     {
5683       l_const = fold_convert (lntype, l_const);
5684       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5685       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
5686       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5687                                         fold_build1 (BIT_NOT_EXPR,
5688                                                      lntype, ll_mask),
5689                                         0)))
5690         {
5691           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5692
5693           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5694         }
5695     }
5696   if (r_const)
5697     {
5698       r_const = fold_convert (lntype, r_const);
5699       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5700       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
5701       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5702                                         fold_build1 (BIT_NOT_EXPR,
5703                                                      lntype, rl_mask),
5704                                         0)))
5705         {
5706           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5707
5708           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5709         }
5710     }
5711
5712   /* If the right sides are not constant, do the same for it.  Also,
5713      disallow this optimization if a size or signedness mismatch occurs
5714      between the left and right sides.  */
5715   if (l_const == 0)
5716     {
5717       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5718           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5719           /* Make sure the two fields on the right
5720              correspond to the left without being swapped.  */
5721           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5722         return 0;
5723
5724       first_bit = MIN (lr_bitpos, rr_bitpos);
5725       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5726       rnmode = get_best_mode (end_bit - first_bit, first_bit,
5727                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5728                               volatilep);
5729       if (rnmode == VOIDmode)
5730         return 0;
5731
5732       rnbitsize = GET_MODE_BITSIZE (rnmode);
5733       rnbitpos = first_bit & ~ (rnbitsize - 1);
5734       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5735       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5736
5737       if (BYTES_BIG_ENDIAN)
5738         {
5739           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5740           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5741         }
5742
5743       lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
5744                              size_int (xlr_bitpos), 0);
5745       rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
5746                              size_int (xrr_bitpos), 0);
5747
5748       /* Make a mask that corresponds to both fields being compared.
5749          Do this for both items being compared.  If the operands are the
5750          same size and the bits being compared are in the same position
5751          then we can do this by masking both and comparing the masked
5752          results.  */
5753       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5754       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
5755       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5756         {
5757           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5758                                     ll_unsignedp || rl_unsignedp);
5759           if (! all_ones_mask_p (ll_mask, lnbitsize))
5760             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5761
5762           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
5763                                     lr_unsignedp || rr_unsignedp);
5764           if (! all_ones_mask_p (lr_mask, rnbitsize))
5765             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5766
5767           return build2 (wanted_code, truth_type, lhs, rhs);
5768         }
5769
5770       /* There is still another way we can do something:  If both pairs of
5771          fields being compared are adjacent, we may be able to make a wider
5772          field containing them both.
5773
5774          Note that we still must mask the lhs/rhs expressions.  Furthermore,
5775          the mask must be shifted to account for the shift done by
5776          make_bit_field_ref.  */
5777       if ((ll_bitsize + ll_bitpos == rl_bitpos
5778            && lr_bitsize + lr_bitpos == rr_bitpos)
5779           || (ll_bitpos == rl_bitpos + rl_bitsize
5780               && lr_bitpos == rr_bitpos + rr_bitsize))
5781         {
5782           tree type;
5783
5784           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
5785                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5786           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
5787                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5788
5789           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5790                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
5791           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5792                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
5793
5794           /* Convert to the smaller type before masking out unwanted bits.  */
5795           type = lntype;
5796           if (lntype != rntype)
5797             {
5798               if (lnbitsize > rnbitsize)
5799                 {
5800                   lhs = fold_convert (rntype, lhs);
5801                   ll_mask = fold_convert (rntype, ll_mask);
5802                   type = rntype;
5803                 }
5804               else if (lnbitsize < rnbitsize)
5805                 {
5806                   rhs = fold_convert (lntype, rhs);
5807                   lr_mask = fold_convert (lntype, lr_mask);
5808                   type = lntype;
5809                 }
5810             }
5811
5812           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5813             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5814
5815           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5816             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5817
5818           return build2 (wanted_code, truth_type, lhs, rhs);
5819         }
5820
5821       return 0;
5822     }
5823
5824   /* Handle the case of comparisons with constants.  If there is something in
5825      common between the masks, those bits of the constants must be the same.
5826      If not, the condition is always false.  Test for this to avoid generating
5827      incorrect code below.  */
5828   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
5829   if (! integer_zerop (result)
5830       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
5831                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
5832     {
5833       if (wanted_code == NE_EXPR)
5834         {
5835           warning (0, "%<or%> of unmatched not-equal tests is always 1");
5836           return constant_boolean_node (true, truth_type);
5837         }
5838       else
5839         {
5840           warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5841           return constant_boolean_node (false, truth_type);
5842         }
5843     }
5844
5845   /* Construct the expression we will return.  First get the component
5846      reference we will make.  Unless the mask is all ones the width of
5847      that field, perform the mask operation.  Then compare with the
5848      merged constant.  */
5849   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5850                                ll_unsignedp || rl_unsignedp);
5851
5852   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5853   if (! all_ones_mask_p (ll_mask, lnbitsize))
5854     result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
5855
5856   return build2 (wanted_code, truth_type, result,
5857                  const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
5858 }
5859 \f
5860 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5861    constant.  */
5862
5863 static tree
5864 optimize_minmax_comparison (enum tree_code code, tree type, tree op0, tree op1)
5865 {
5866   tree arg0 = op0;
5867   enum tree_code op_code;
5868   tree comp_const = op1;
5869   tree minmax_const;
5870   int consts_equal, consts_lt;
5871   tree inner;
5872
5873   STRIP_SIGN_NOPS (arg0);
5874
5875   op_code = TREE_CODE (arg0);
5876   minmax_const = TREE_OPERAND (arg0, 1);
5877   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5878   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5879   inner = TREE_OPERAND (arg0, 0);
5880
5881   /* If something does not permit us to optimize, return the original tree.  */
5882   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5883       || TREE_CODE (comp_const) != INTEGER_CST
5884       || TREE_OVERFLOW (comp_const)
5885       || TREE_CODE (minmax_const) != INTEGER_CST
5886       || TREE_OVERFLOW (minmax_const))
5887     return NULL_TREE;
5888
5889   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
5890      and GT_EXPR, doing the rest with recursive calls using logical
5891      simplifications.  */
5892   switch (code)
5893     {
5894     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
5895       {
5896         tree tem = optimize_minmax_comparison (invert_tree_comparison (code, false),
5897                                           type, op0, op1);
5898         if (tem)
5899           return invert_truthvalue (tem);
5900         return NULL_TREE;
5901       }
5902
5903     case GE_EXPR:
5904       return
5905         fold_build2 (TRUTH_ORIF_EXPR, type,
5906                      optimize_minmax_comparison
5907                      (EQ_EXPR, type, arg0, comp_const),
5908                      optimize_minmax_comparison
5909                      (GT_EXPR, type, arg0, comp_const));
5910
5911     case EQ_EXPR:
5912       if (op_code == MAX_EXPR && consts_equal)
5913         /* MAX (X, 0) == 0  ->  X <= 0  */
5914         return fold_build2 (LE_EXPR, type, inner, comp_const);
5915
5916       else if (op_code == MAX_EXPR && consts_lt)
5917         /* MAX (X, 0) == 5  ->  X == 5   */
5918         return fold_build2 (EQ_EXPR, type, inner, comp_const);
5919
5920       else if (op_code == MAX_EXPR)
5921         /* MAX (X, 0) == -1  ->  false  */
5922         return omit_one_operand (type, integer_zero_node, inner);
5923
5924       else if (consts_equal)
5925         /* MIN (X, 0) == 0  ->  X >= 0  */
5926         return fold_build2 (GE_EXPR, type, inner, comp_const);
5927
5928       else if (consts_lt)
5929         /* MIN (X, 0) == 5  ->  false  */
5930         return omit_one_operand (type, integer_zero_node, inner);
5931
5932       else
5933         /* MIN (X, 0) == -1  ->  X == -1  */
5934         return fold_build2 (EQ_EXPR, type, inner, comp_const);
5935
5936     case GT_EXPR:
5937       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
5938         /* MAX (X, 0) > 0  ->  X > 0
5939            MAX (X, 0) > 5  ->  X > 5  */
5940         return fold_build2 (GT_EXPR, type, inner, comp_const);
5941
5942       else if (op_code == MAX_EXPR)
5943         /* MAX (X, 0) > -1  ->  true  */
5944         return omit_one_operand (type, integer_one_node, inner);
5945
5946       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5947         /* MIN (X, 0) > 0  ->  false
5948            MIN (X, 0) > 5  ->  false  */
5949         return omit_one_operand (type, integer_zero_node, inner);
5950
5951       else
5952         /* MIN (X, 0) > -1  ->  X > -1  */
5953         return fold_build2 (GT_EXPR, type, inner, comp_const);
5954
5955     default:
5956       return NULL_TREE;
5957     }
5958 }
5959 \f
5960 /* T is an integer expression that is being multiplied, divided, or taken a
5961    modulus (CODE says which and what kind of divide or modulus) by a
5962    constant C.  See if we can eliminate that operation by folding it with
5963    other operations already in T.  WIDE_TYPE, if non-null, is a type that
5964    should be used for the computation if wider than our type.
5965
5966    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5967    (X * 2) + (Y * 4).  We must, however, be assured that either the original
5968    expression would not overflow or that overflow is undefined for the type
5969    in the language in question.
5970
5971    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
5972    the machine has a multiply-accumulate insn or that this is part of an
5973    addressing calculation.
5974
5975    If we return a non-null expression, it is an equivalent form of the
5976    original computation, but need not be in the original type.
5977
5978    We set *STRICT_OVERFLOW_P to true if the return values depends on
5979    signed overflow being undefined.  Otherwise we do not change
5980    *STRICT_OVERFLOW_P.  */
5981
5982 static tree
5983 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
5984                 bool *strict_overflow_p)
5985 {
5986   /* To avoid exponential search depth, refuse to allow recursion past
5987      three levels.  Beyond that (1) it's highly unlikely that we'll find
5988      something interesting and (2) we've probably processed it before
5989      when we built the inner expression.  */
5990
5991   static int depth;
5992   tree ret;
5993
5994   if (depth > 3)
5995     return NULL;
5996
5997   depth++;
5998   ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
5999   depth--;
6000
6001   return ret;
6002 }
6003
6004 static tree
6005 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
6006                   bool *strict_overflow_p)
6007 {
6008   tree type = TREE_TYPE (t);
6009   enum tree_code tcode = TREE_CODE (t);
6010   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
6011                                    > GET_MODE_SIZE (TYPE_MODE (type)))
6012                 ? wide_type : type);
6013   tree t1, t2;
6014   int same_p = tcode == code;
6015   tree op0 = NULL_TREE, op1 = NULL_TREE;
6016   bool sub_strict_overflow_p;
6017
6018   /* Don't deal with constants of zero here; they confuse the code below.  */
6019   if (integer_zerop (c))
6020     return NULL_TREE;
6021
6022   if (TREE_CODE_CLASS (tcode) == tcc_unary)
6023     op0 = TREE_OPERAND (t, 0);
6024
6025   if (TREE_CODE_CLASS (tcode) == tcc_binary)
6026     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
6027
6028   /* Note that we need not handle conditional operations here since fold
6029      already handles those cases.  So just do arithmetic here.  */
6030   switch (tcode)
6031     {
6032     case INTEGER_CST:
6033       /* For a constant, we can always simplify if we are a multiply
6034          or (for divide and modulus) if it is a multiple of our constant.  */
6035       if (code == MULT_EXPR
6036           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
6037         return const_binop (code, fold_convert (ctype, t),
6038                             fold_convert (ctype, c), 0);
6039       break;
6040
6041     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
6042       /* If op0 is an expression ...  */
6043       if ((COMPARISON_CLASS_P (op0)
6044            || UNARY_CLASS_P (op0)
6045            || BINARY_CLASS_P (op0)
6046            || VL_EXP_CLASS_P (op0)
6047            || EXPRESSION_CLASS_P (op0))
6048           /* ... and is unsigned, and its type is smaller than ctype,
6049              then we cannot pass through as widening.  */
6050           && ((TYPE_UNSIGNED (TREE_TYPE (op0))
6051                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
6052                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
6053                && (GET_MODE_SIZE (TYPE_MODE (ctype))
6054                    > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
6055               /* ... or this is a truncation (t is narrower than op0),
6056                  then we cannot pass through this narrowing.  */
6057               || (GET_MODE_SIZE (TYPE_MODE (type))
6058                   < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))))
6059               /* ... or signedness changes for division or modulus,
6060                  then we cannot pass through this conversion.  */
6061               || (code != MULT_EXPR
6062                   && (TYPE_UNSIGNED (ctype)
6063                       != TYPE_UNSIGNED (TREE_TYPE (op0))))
6064               /* ... or has undefined overflow while the converted to
6065                  type has not, we cannot do the operation in the inner type
6066                  as that would introduce undefined overflow.  */
6067               || (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (op0))
6068                   && !TYPE_OVERFLOW_UNDEFINED (type))))
6069         break;
6070
6071       /* Pass the constant down and see if we can make a simplification.  If
6072          we can, replace this expression with the inner simplification for
6073          possible later conversion to our or some other type.  */
6074       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
6075           && TREE_CODE (t2) == INTEGER_CST
6076           && !TREE_OVERFLOW (t2)
6077           && (0 != (t1 = extract_muldiv (op0, t2, code,
6078                                          code == MULT_EXPR
6079                                          ? ctype : NULL_TREE,
6080                                          strict_overflow_p))))
6081         return t1;
6082       break;
6083
6084     case ABS_EXPR:
6085       /* If widening the type changes it from signed to unsigned, then we
6086          must avoid building ABS_EXPR itself as unsigned.  */
6087       if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
6088         {
6089           tree cstype = (*signed_type_for) (ctype);
6090           if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
6091               != 0)
6092             {
6093               t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
6094               return fold_convert (ctype, t1);
6095             }
6096           break;
6097         }
6098       /* If the constant is negative, we cannot simplify this.  */
6099       if (tree_int_cst_sgn (c) == -1)
6100         break;
6101       /* FALLTHROUGH */
6102     case NEGATE_EXPR:
6103       if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
6104           != 0)
6105         return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
6106       break;
6107
6108     case MIN_EXPR:  case MAX_EXPR:
6109       /* If widening the type changes the signedness, then we can't perform
6110          this optimization as that changes the result.  */
6111       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
6112         break;
6113
6114       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
6115       sub_strict_overflow_p = false;
6116       if ((t1 = extract_muldiv (op0, c, code, wide_type,
6117                                 &sub_strict_overflow_p)) != 0
6118           && (t2 = extract_muldiv (op1, c, code, wide_type,
6119                                    &sub_strict_overflow_p)) != 0)
6120         {
6121           if (tree_int_cst_sgn (c) < 0)
6122             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
6123           if (sub_strict_overflow_p)
6124             *strict_overflow_p = true;
6125           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6126                               fold_convert (ctype, t2));
6127         }
6128       break;
6129
6130     case LSHIFT_EXPR:  case RSHIFT_EXPR:
6131       /* If the second operand is constant, this is a multiplication
6132          or floor division, by a power of two, so we can treat it that
6133          way unless the multiplier or divisor overflows.  Signed
6134          left-shift overflow is implementation-defined rather than
6135          undefined in C90, so do not convert signed left shift into
6136          multiplication.  */
6137       if (TREE_CODE (op1) == INTEGER_CST
6138           && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
6139           /* const_binop may not detect overflow correctly,
6140              so check for it explicitly here.  */
6141           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
6142           && TREE_INT_CST_HIGH (op1) == 0
6143           && 0 != (t1 = fold_convert (ctype,
6144                                       const_binop (LSHIFT_EXPR,
6145                                                    size_one_node,
6146                                                    op1, 0)))
6147           && !TREE_OVERFLOW (t1))
6148         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
6149                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
6150                                        ctype, fold_convert (ctype, op0), t1),
6151                                c, code, wide_type, strict_overflow_p);
6152       break;
6153
6154     case PLUS_EXPR:  case MINUS_EXPR:
6155       /* See if we can eliminate the operation on both sides.  If we can, we
6156          can return a new PLUS or MINUS.  If we can't, the only remaining
6157          cases where we can do anything are if the second operand is a
6158          constant.  */
6159       sub_strict_overflow_p = false;
6160       t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
6161       t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
6162       if (t1 != 0 && t2 != 0
6163           && (code == MULT_EXPR
6164               /* If not multiplication, we can only do this if both operands
6165                  are divisible by c.  */
6166               || (multiple_of_p (ctype, op0, c)
6167                   && multiple_of_p (ctype, op1, c))))
6168         {
6169           if (sub_strict_overflow_p)
6170             *strict_overflow_p = true;
6171           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6172                               fold_convert (ctype, t2));
6173         }
6174
6175       /* If this was a subtraction, negate OP1 and set it to be an addition.
6176          This simplifies the logic below.  */
6177       if (tcode == MINUS_EXPR)
6178         tcode = PLUS_EXPR, op1 = negate_expr (op1);
6179
6180       if (TREE_CODE (op1) != INTEGER_CST)
6181         break;
6182
6183       /* If either OP1 or C are negative, this optimization is not safe for
6184          some of the division and remainder types while for others we need
6185          to change the code.  */
6186       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
6187         {
6188           if (code == CEIL_DIV_EXPR)
6189             code = FLOOR_DIV_EXPR;
6190           else if (code == FLOOR_DIV_EXPR)
6191             code = CEIL_DIV_EXPR;
6192           else if (code != MULT_EXPR
6193                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
6194             break;
6195         }
6196
6197       /* If it's a multiply or a division/modulus operation of a multiple
6198          of our constant, do the operation and verify it doesn't overflow.  */
6199       if (code == MULT_EXPR
6200           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6201         {
6202           op1 = const_binop (code, fold_convert (ctype, op1),
6203                              fold_convert (ctype, c), 0);
6204           /* We allow the constant to overflow with wrapping semantics.  */
6205           if (op1 == 0
6206               || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
6207             break;
6208         }
6209       else
6210         break;
6211
6212       /* If we have an unsigned type is not a sizetype, we cannot widen
6213          the operation since it will change the result if the original
6214          computation overflowed.  */
6215       if (TYPE_UNSIGNED (ctype)
6216           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
6217           && ctype != type)
6218         break;
6219
6220       /* If we were able to eliminate our operation from the first side,
6221          apply our operation to the second side and reform the PLUS.  */
6222       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
6223         return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
6224
6225       /* The last case is if we are a multiply.  In that case, we can
6226          apply the distributive law to commute the multiply and addition
6227          if the multiplication of the constants doesn't overflow.  */
6228       if (code == MULT_EXPR)
6229         return fold_build2 (tcode, ctype,
6230                             fold_build2 (code, ctype,
6231                                          fold_convert (ctype, op0),
6232                                          fold_convert (ctype, c)),
6233                             op1);
6234
6235       break;
6236
6237     case MULT_EXPR:
6238       /* We have a special case here if we are doing something like
6239          (C * 8) % 4 since we know that's zero.  */
6240       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
6241            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
6242           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
6243           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6244         return omit_one_operand (type, integer_zero_node, op0);
6245
6246       /* ... fall through ...  */
6247
6248     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
6249     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
6250       /* If we can extract our operation from the LHS, do so and return a
6251          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
6252          do something only if the second operand is a constant.  */
6253       if (same_p
6254           && (t1 = extract_muldiv (op0, c, code, wide_type,
6255                                    strict_overflow_p)) != 0)
6256         return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
6257                             fold_convert (ctype, op1));
6258       else if (tcode == MULT_EXPR && code == MULT_EXPR
6259                && (t1 = extract_muldiv (op1, c, code, wide_type,
6260                                         strict_overflow_p)) != 0)
6261         return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6262                             fold_convert (ctype, t1));
6263       else if (TREE_CODE (op1) != INTEGER_CST)
6264         return 0;
6265
6266       /* If these are the same operation types, we can associate them
6267          assuming no overflow.  */
6268       if (tcode == code
6269           && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
6270                                      fold_convert (ctype, c), 0))
6271           && !TREE_OVERFLOW (t1))
6272         return fold_build2 (tcode, ctype, fold_convert (ctype, op0), t1);
6273
6274       /* If these operations "cancel" each other, we have the main
6275          optimizations of this pass, which occur when either constant is a
6276          multiple of the other, in which case we replace this with either an
6277          operation or CODE or TCODE.
6278
6279          If we have an unsigned type that is not a sizetype, we cannot do
6280          this since it will change the result if the original computation
6281          overflowed.  */
6282       if ((TYPE_OVERFLOW_UNDEFINED (ctype)
6283            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
6284           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
6285               || (tcode == MULT_EXPR
6286                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
6287                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR
6288                   && code != MULT_EXPR)))
6289         {
6290           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
6291             {
6292               if (TYPE_OVERFLOW_UNDEFINED (ctype))
6293                 *strict_overflow_p = true;
6294               return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
6295                                   fold_convert (ctype,
6296                                                 const_binop (TRUNC_DIV_EXPR,
6297                                                              op1, c, 0)));
6298             }
6299           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
6300             {
6301               if (TYPE_OVERFLOW_UNDEFINED (ctype))
6302                 *strict_overflow_p = true;
6303               return fold_build2 (code, ctype, fold_convert (ctype, op0),
6304                                   fold_convert (ctype,
6305                                                 const_binop (TRUNC_DIV_EXPR,
6306                                                              c, op1, 0)));
6307             }
6308         }
6309       break;
6310
6311     default:
6312       break;
6313     }
6314
6315   return 0;
6316 }
6317 \f
6318 /* Return a node which has the indicated constant VALUE (either 0 or
6319    1), and is of the indicated TYPE.  */
6320
6321 tree
6322 constant_boolean_node (int value, tree type)
6323 {
6324   if (type == integer_type_node)
6325     return value ? integer_one_node : integer_zero_node;
6326   else if (type == boolean_type_node)
6327     return value ? boolean_true_node : boolean_false_node;
6328   else
6329     return build_int_cst (type, value);
6330 }
6331
6332
6333 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
6334    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
6335    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
6336    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
6337    COND is the first argument to CODE; otherwise (as in the example
6338    given here), it is the second argument.  TYPE is the type of the
6339    original expression.  Return NULL_TREE if no simplification is
6340    possible.  */
6341
6342 static tree
6343 fold_binary_op_with_conditional_arg (enum tree_code code,
6344                                      tree type, tree op0, tree op1,
6345                                      tree cond, tree arg, int cond_first_p)
6346 {
6347   tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
6348   tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
6349   tree test, true_value, false_value;
6350   tree lhs = NULL_TREE;
6351   tree rhs = NULL_TREE;
6352
6353   /* This transformation is only worthwhile if we don't have to wrap
6354      arg in a SAVE_EXPR, and the operation can be simplified on at least
6355      one of the branches once its pushed inside the COND_EXPR.  */
6356   if (!TREE_CONSTANT (arg))
6357     return NULL_TREE;
6358
6359   if (TREE_CODE (cond) == COND_EXPR)
6360     {
6361       test = TREE_OPERAND (cond, 0);
6362       true_value = TREE_OPERAND (cond, 1);
6363       false_value = TREE_OPERAND (cond, 2);
6364       /* If this operand throws an expression, then it does not make
6365          sense to try to perform a logical or arithmetic operation
6366          involving it.  */
6367       if (VOID_TYPE_P (TREE_TYPE (true_value)))
6368         lhs = true_value;
6369       if (VOID_TYPE_P (TREE_TYPE (false_value)))
6370         rhs = false_value;
6371     }
6372   else
6373     {
6374       tree testtype = TREE_TYPE (cond);
6375       test = cond;
6376       true_value = constant_boolean_node (true, testtype);
6377       false_value = constant_boolean_node (false, testtype);
6378     }
6379
6380   arg = fold_convert (arg_type, arg);
6381   if (lhs == 0)
6382     {
6383       true_value = fold_convert (cond_type, true_value);
6384       if (cond_first_p)
6385         lhs = fold_build2 (code, type, true_value, arg);
6386       else
6387         lhs = fold_build2 (code, type, arg, true_value);
6388     }
6389   if (rhs == 0)
6390     {
6391       false_value = fold_convert (cond_type, false_value);
6392       if (cond_first_p)
6393         rhs = fold_build2 (code, type, false_value, arg);
6394       else
6395         rhs = fold_build2 (code, type, arg, false_value);
6396     }
6397
6398   test = fold_build3 (COND_EXPR, type, test, lhs, rhs);
6399   return fold_convert (type, test);
6400 }
6401
6402 \f
6403 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6404
6405    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6406    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
6407    ADDEND is the same as X.
6408
6409    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6410    and finite.  The problematic cases are when X is zero, and its mode
6411    has signed zeros.  In the case of rounding towards -infinity,
6412    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
6413    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
6414
6415 static bool
6416 fold_real_zero_addition_p (const_tree type, const_tree addend, int negate)
6417 {
6418   if (!real_zerop (addend))
6419     return false;
6420
6421   /* Don't allow the fold with -fsignaling-nans.  */
6422   if (HONOR_SNANS (TYPE_MODE (type)))
6423     return false;
6424
6425   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
6426   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
6427     return true;
6428
6429   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
6430   if (TREE_CODE (addend) == REAL_CST
6431       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6432     negate = !negate;
6433
6434   /* The mode has signed zeros, and we have to honor their sign.
6435      In this situation, there is only one case we can return true for.
6436      X - 0 is the same as X unless rounding towards -infinity is
6437      supported.  */
6438   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
6439 }
6440
6441 /* Subroutine of fold() that checks comparisons of built-in math
6442    functions against real constants.
6443
6444    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6445    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
6446    is the type of the result and ARG0 and ARG1 are the operands of the
6447    comparison.  ARG1 must be a TREE_REAL_CST.
6448
6449    The function returns the constant folded tree if a simplification
6450    can be made, and NULL_TREE otherwise.  */
6451
6452 static tree
6453 fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
6454                      tree type, tree arg0, tree arg1)
6455 {
6456   REAL_VALUE_TYPE c;
6457
6458   if (BUILTIN_SQRT_P (fcode))
6459     {
6460       tree arg = CALL_EXPR_ARG (arg0, 0);
6461       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
6462
6463       c = TREE_REAL_CST (arg1);
6464       if (REAL_VALUE_NEGATIVE (c))
6465         {
6466           /* sqrt(x) < y is always false, if y is negative.  */
6467           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
6468             return omit_one_operand (type, integer_zero_node, arg);
6469
6470           /* sqrt(x) > y is always true, if y is negative and we
6471              don't care about NaNs, i.e. negative values of x.  */
6472           if (code == NE_EXPR || !HONOR_NANS (mode))
6473             return omit_one_operand (type, integer_one_node, arg);
6474
6475           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
6476           return fold_build2 (GE_EXPR, type, arg,
6477                               build_real (TREE_TYPE (arg), dconst0));
6478         }
6479       else if (code == GT_EXPR || code == GE_EXPR)
6480         {
6481           REAL_VALUE_TYPE c2;
6482
6483           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6484           real_convert (&c2, mode, &c2);
6485
6486           if (REAL_VALUE_ISINF (c2))
6487             {
6488               /* sqrt(x) > y is x == +Inf, when y is very large.  */
6489               if (HONOR_INFINITIES (mode))
6490                 return fold_build2 (EQ_EXPR, type, arg,
6491                                     build_real (TREE_TYPE (arg), c2));
6492
6493               /* sqrt(x) > y is always false, when y is very large
6494                  and we don't care about infinities.  */
6495               return omit_one_operand (type, integer_zero_node, arg);
6496             }
6497
6498           /* sqrt(x) > c is the same as x > c*c.  */
6499           return fold_build2 (code, type, arg,
6500                               build_real (TREE_TYPE (arg), c2));
6501         }
6502       else if (code == LT_EXPR || code == LE_EXPR)
6503         {
6504           REAL_VALUE_TYPE c2;
6505
6506           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6507           real_convert (&c2, mode, &c2);
6508
6509           if (REAL_VALUE_ISINF (c2))
6510             {
6511               /* sqrt(x) < y is always true, when y is a very large
6512                  value and we don't care about NaNs or Infinities.  */
6513               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
6514                 return omit_one_operand (type, integer_one_node, arg);
6515
6516               /* sqrt(x) < y is x != +Inf when y is very large and we
6517                  don't care about NaNs.  */
6518               if (! HONOR_NANS (mode))
6519                 return fold_build2 (NE_EXPR, type, arg,
6520                                     build_real (TREE_TYPE (arg), c2));
6521
6522               /* sqrt(x) < y is x >= 0 when y is very large and we
6523                  don't care about Infinities.  */
6524               if (! HONOR_INFINITIES (mode))
6525                 return fold_build2 (GE_EXPR, type, arg,
6526                                     build_real (TREE_TYPE (arg), dconst0));
6527
6528               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
6529               if (lang_hooks.decls.global_bindings_p () != 0
6530                   || CONTAINS_PLACEHOLDER_P (arg))
6531                 return NULL_TREE;
6532
6533               arg = save_expr (arg);
6534               return fold_build2 (TRUTH_ANDIF_EXPR, type,
6535                                   fold_build2 (GE_EXPR, type, arg,
6536                                                build_real (TREE_TYPE (arg),
6537                                                            dconst0)),
6538                                   fold_build2 (NE_EXPR, type, arg,
6539                                                build_real (TREE_TYPE (arg),
6540                                                            c2)));
6541             }
6542
6543           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
6544           if (! HONOR_NANS (mode))
6545             return fold_build2 (code, type, arg,
6546                                 build_real (TREE_TYPE (arg), c2));
6547
6548           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
6549           if (lang_hooks.decls.global_bindings_p () == 0
6550               && ! CONTAINS_PLACEHOLDER_P (arg))
6551             {
6552               arg = save_expr (arg);
6553               return fold_build2 (TRUTH_ANDIF_EXPR, type,
6554                                   fold_build2 (GE_EXPR, type, arg,
6555                                                build_real (TREE_TYPE (arg),
6556                                                            dconst0)),
6557                                   fold_build2 (code, type, arg,
6558                                                build_real (TREE_TYPE (arg),
6559                                                            c2)));
6560             }
6561         }
6562     }
6563
6564   return NULL_TREE;
6565 }
6566
6567 /* Subroutine of fold() that optimizes comparisons against Infinities,
6568    either +Inf or -Inf.
6569
6570    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6571    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6572    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6573
6574    The function returns the constant folded tree if a simplification
6575    can be made, and NULL_TREE otherwise.  */
6576
6577 static tree
6578 fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6579 {
6580   enum machine_mode mode;
6581   REAL_VALUE_TYPE max;
6582   tree temp;
6583   bool neg;
6584
6585   mode = TYPE_MODE (TREE_TYPE (arg0));
6586
6587   /* For negative infinity swap the sense of the comparison.  */
6588   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6589   if (neg)
6590     code = swap_tree_comparison (code);
6591
6592   switch (code)
6593     {
6594     case GT_EXPR:
6595       /* x > +Inf is always false, if with ignore sNANs.  */
6596       if (HONOR_SNANS (mode))
6597         return NULL_TREE;
6598       return omit_one_operand (type, integer_zero_node, arg0);
6599
6600     case LE_EXPR:
6601       /* x <= +Inf is always true, if we don't case about NaNs.  */
6602       if (! HONOR_NANS (mode))
6603         return omit_one_operand (type, integer_one_node, arg0);
6604
6605       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
6606       if (lang_hooks.decls.global_bindings_p () == 0
6607           && ! CONTAINS_PLACEHOLDER_P (arg0))
6608         {
6609           arg0 = save_expr (arg0);
6610           return fold_build2 (EQ_EXPR, type, arg0, arg0);
6611         }
6612       break;
6613
6614     case EQ_EXPR:
6615     case GE_EXPR:
6616       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
6617       real_maxval (&max, neg, mode);
6618       return fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6619                           arg0, build_real (TREE_TYPE (arg0), max));
6620
6621     case LT_EXPR:
6622       /* x < +Inf is always equal to x <= DBL_MAX.  */
6623       real_maxval (&max, neg, mode);
6624       return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6625                           arg0, build_real (TREE_TYPE (arg0), max));
6626
6627     case NE_EXPR:
6628       /* x != +Inf is always equal to !(x > DBL_MAX).  */
6629       real_maxval (&max, neg, mode);
6630       if (! HONOR_NANS (mode))
6631         return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6632                             arg0, build_real (TREE_TYPE (arg0), max));
6633
6634       temp = fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6635                           arg0, build_real (TREE_TYPE (arg0), max));
6636       return fold_build1 (TRUTH_NOT_EXPR, type, temp);
6637
6638     default:
6639       break;
6640     }
6641
6642   return NULL_TREE;
6643 }
6644
6645 /* Subroutine of fold() that optimizes comparisons of a division by
6646    a nonzero integer constant against an integer constant, i.e.
6647    X/C1 op C2.
6648
6649    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6650    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6651    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6652
6653    The function returns the constant folded tree if a simplification
6654    can be made, and NULL_TREE otherwise.  */
6655
6656 static tree
6657 fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6658 {
6659   tree prod, tmp, hi, lo;
6660   tree arg00 = TREE_OPERAND (arg0, 0);
6661   tree arg01 = TREE_OPERAND (arg0, 1);
6662   unsigned HOST_WIDE_INT lpart;
6663   HOST_WIDE_INT hpart;
6664   bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
6665   bool neg_overflow;
6666   int overflow;
6667
6668   /* We have to do this the hard way to detect unsigned overflow.
6669      prod = int_const_binop (MULT_EXPR, arg01, arg1, 0);  */
6670   overflow = mul_double_with_sign (TREE_INT_CST_LOW (arg01),
6671                                    TREE_INT_CST_HIGH (arg01),
6672                                    TREE_INT_CST_LOW (arg1),
6673                                    TREE_INT_CST_HIGH (arg1),
6674                                    &lpart, &hpart, unsigned_p);
6675   prod = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
6676                                 -1, overflow);
6677   neg_overflow = false;
6678
6679   if (unsigned_p)
6680     {
6681       tmp = int_const_binop (MINUS_EXPR, arg01,
6682                              build_int_cst (TREE_TYPE (arg01), 1), 0);
6683       lo = prod;
6684
6685       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0).  */
6686       overflow = add_double_with_sign (TREE_INT_CST_LOW (prod),
6687                                        TREE_INT_CST_HIGH (prod),
6688                                        TREE_INT_CST_LOW (tmp),
6689                                        TREE_INT_CST_HIGH (tmp),
6690                                        &lpart, &hpart, unsigned_p);
6691       hi = force_fit_type_double (TREE_TYPE (arg00), lpart, hpart,
6692                                   -1, overflow | TREE_OVERFLOW (prod));
6693     }
6694   else if (tree_int_cst_sgn (arg01) >= 0)
6695     {
6696       tmp = int_const_binop (MINUS_EXPR, arg01,
6697                              build_int_cst (TREE_TYPE (arg01), 1), 0);
6698       switch (tree_int_cst_sgn (arg1))
6699         {
6700         case -1:
6701           neg_overflow = true;
6702           lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6703           hi = prod;
6704           break;
6705
6706         case  0:
6707           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6708           hi = tmp;
6709           break;
6710
6711         case  1:
6712           hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6713           lo = prod;
6714           break;
6715
6716         default:
6717           gcc_unreachable ();
6718         }
6719     }
6720   else
6721     {
6722       /* A negative divisor reverses the relational operators.  */
6723       code = swap_tree_comparison (code);
6724
6725       tmp = int_const_binop (PLUS_EXPR, arg01,
6726                              build_int_cst (TREE_TYPE (arg01), 1), 0);
6727       switch (tree_int_cst_sgn (arg1))
6728         {
6729         case -1:
6730           hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6731           lo = prod;
6732           break;
6733
6734         case  0:
6735           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6736           lo = tmp;
6737           break;
6738
6739         case  1:
6740           neg_overflow = true;
6741           lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6742           hi = prod;
6743           break;
6744
6745         default:
6746           gcc_unreachable ();
6747         }
6748     }
6749
6750   switch (code)
6751     {
6752     case EQ_EXPR:
6753       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6754         return omit_one_operand (type, integer_zero_node, arg00);
6755       if (TREE_OVERFLOW (hi))
6756         return fold_build2 (GE_EXPR, type, arg00, lo);
6757       if (TREE_OVERFLOW (lo))
6758         return fold_build2 (LE_EXPR, type, arg00, hi);
6759       return build_range_check (type, arg00, 1, lo, hi);
6760
6761     case NE_EXPR:
6762       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6763         return omit_one_operand (type, integer_one_node, arg00);
6764       if (TREE_OVERFLOW (hi))
6765         return fold_build2 (LT_EXPR, type, arg00, lo);
6766       if (TREE_OVERFLOW (lo))
6767         return fold_build2 (GT_EXPR, type, arg00, hi);
6768       return build_range_check (type, arg00, 0, lo, hi);
6769
6770     case LT_EXPR:
6771       if (TREE_OVERFLOW (lo))
6772         {
6773           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6774           return omit_one_operand (type, tmp, arg00);
6775         }
6776       return fold_build2 (LT_EXPR, type, arg00, lo);
6777
6778     case LE_EXPR:
6779       if (TREE_OVERFLOW (hi))
6780         {
6781           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6782           return omit_one_operand (type, tmp, arg00);
6783         }
6784       return fold_build2 (LE_EXPR, type, arg00, hi);
6785
6786     case GT_EXPR:
6787       if (TREE_OVERFLOW (hi))
6788         {
6789           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6790           return omit_one_operand (type, tmp, arg00);
6791         }
6792       return fold_build2 (GT_EXPR, type, arg00, hi);
6793
6794     case GE_EXPR:
6795       if (TREE_OVERFLOW (lo))
6796         {
6797           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6798           return omit_one_operand (type, tmp, arg00);
6799         }
6800       return fold_build2 (GE_EXPR, type, arg00, lo);
6801
6802     default:
6803       break;
6804     }
6805
6806   return NULL_TREE;
6807 }
6808
6809
6810 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6811    equality/inequality test, then return a simplified form of the test
6812    using a sign testing.  Otherwise return NULL.  TYPE is the desired
6813    result type.  */
6814
6815 static tree
6816 fold_single_bit_test_into_sign_test (enum tree_code code, tree arg0, tree arg1,
6817                                      tree result_type)
6818 {
6819   /* If this is testing a single bit, we can optimize the test.  */
6820   if ((code == NE_EXPR || code == EQ_EXPR)
6821       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6822       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6823     {
6824       /* If we have (A & C) != 0 where C is the sign bit of A, convert
6825          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
6826       tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6827
6828       if (arg00 != NULL_TREE
6829           /* This is only a win if casting to a signed type is cheap,
6830              i.e. when arg00's type is not a partial mode.  */
6831           && TYPE_PRECISION (TREE_TYPE (arg00))
6832              == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
6833         {
6834           tree stype = signed_type_for (TREE_TYPE (arg00));
6835           return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6836                               result_type, fold_convert (stype, arg00),
6837                               build_int_cst (stype, 0));
6838         }
6839     }
6840
6841   return NULL_TREE;
6842 }
6843
6844 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6845    equality/inequality test, then return a simplified form of
6846    the test using shifts and logical operations.  Otherwise return
6847    NULL.  TYPE is the desired result type.  */
6848
6849 tree
6850 fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
6851                       tree result_type)
6852 {
6853   /* If this is testing a single bit, we can optimize the test.  */
6854   if ((code == NE_EXPR || code == EQ_EXPR)
6855       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6856       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6857     {
6858       tree inner = TREE_OPERAND (arg0, 0);
6859       tree type = TREE_TYPE (arg0);
6860       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6861       enum machine_mode operand_mode = TYPE_MODE (type);
6862       int ops_unsigned;
6863       tree signed_type, unsigned_type, intermediate_type;
6864       tree tem, one;
6865
6866       /* First, see if we can fold the single bit test into a sign-bit
6867          test.  */
6868       tem = fold_single_bit_test_into_sign_test (code, arg0, arg1,
6869                                                  result_type);
6870       if (tem)
6871         return tem;
6872
6873       /* Otherwise we have (A & C) != 0 where C is a single bit,
6874          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
6875          Similarly for (A & C) == 0.  */
6876
6877       /* If INNER is a right shift of a constant and it plus BITNUM does
6878          not overflow, adjust BITNUM and INNER.  */
6879       if (TREE_CODE (inner) == RSHIFT_EXPR
6880           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6881           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
6882           && bitnum < TYPE_PRECISION (type)
6883           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
6884                                    bitnum - TYPE_PRECISION (type)))
6885         {
6886           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
6887           inner = TREE_OPERAND (inner, 0);
6888         }
6889
6890       /* If we are going to be able to omit the AND below, we must do our
6891          operations as unsigned.  If we must use the AND, we have a choice.
6892          Normally unsigned is faster, but for some machines signed is.  */
6893 #ifdef LOAD_EXTEND_OP
6894       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND 
6895                       && !flag_syntax_only) ? 0 : 1;
6896 #else
6897       ops_unsigned = 1;
6898 #endif
6899
6900       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6901       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6902       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6903       inner = fold_convert (intermediate_type, inner);
6904
6905       if (bitnum != 0)
6906         inner = build2 (RSHIFT_EXPR, intermediate_type,
6907                         inner, size_int (bitnum));
6908
6909       one = build_int_cst (intermediate_type, 1);
6910
6911       if (code == EQ_EXPR)
6912         inner = fold_build2 (BIT_XOR_EXPR, intermediate_type, inner, one);
6913
6914       /* Put the AND last so it can combine with more things.  */
6915       inner = build2 (BIT_AND_EXPR, intermediate_type, inner, one);
6916
6917       /* Make sure to return the proper type.  */
6918       inner = fold_convert (result_type, inner);
6919
6920       return inner;
6921     }
6922   return NULL_TREE;
6923 }
6924
6925 /* Check whether we are allowed to reorder operands arg0 and arg1,
6926    such that the evaluation of arg1 occurs before arg0.  */
6927
6928 static bool
6929 reorder_operands_p (const_tree arg0, const_tree arg1)
6930 {
6931   if (! flag_evaluation_order)
6932       return true;
6933   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6934     return true;
6935   return ! TREE_SIDE_EFFECTS (arg0)
6936          && ! TREE_SIDE_EFFECTS (arg1);
6937 }
6938
6939 /* Test whether it is preferable two swap two operands, ARG0 and
6940    ARG1, for example because ARG0 is an integer constant and ARG1
6941    isn't.  If REORDER is true, only recommend swapping if we can
6942    evaluate the operands in reverse order.  */
6943
6944 bool
6945 tree_swap_operands_p (const_tree arg0, const_tree arg1, bool reorder)
6946 {
6947   STRIP_SIGN_NOPS (arg0);
6948   STRIP_SIGN_NOPS (arg1);
6949
6950   if (TREE_CODE (arg1) == INTEGER_CST)
6951     return 0;
6952   if (TREE_CODE (arg0) == INTEGER_CST)
6953     return 1;
6954
6955   if (TREE_CODE (arg1) == REAL_CST)
6956     return 0;
6957   if (TREE_CODE (arg0) == REAL_CST)
6958     return 1;
6959
6960   if (TREE_CODE (arg1) == FIXED_CST)
6961     return 0;
6962   if (TREE_CODE (arg0) == FIXED_CST)
6963     return 1;
6964
6965   if (TREE_CODE (arg1) == COMPLEX_CST)
6966     return 0;
6967   if (TREE_CODE (arg0) == COMPLEX_CST)
6968     return 1;
6969
6970   if (TREE_CONSTANT (arg1))
6971     return 0;
6972   if (TREE_CONSTANT (arg0))
6973     return 1;
6974
6975   if (optimize_size)
6976     return 0;
6977
6978   if (reorder && flag_evaluation_order
6979       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6980     return 0;
6981
6982   /* It is preferable to swap two SSA_NAME to ensure a canonical form
6983      for commutative and comparison operators.  Ensuring a canonical
6984      form allows the optimizers to find additional redundancies without
6985      having to explicitly check for both orderings.  */
6986   if (TREE_CODE (arg0) == SSA_NAME
6987       && TREE_CODE (arg1) == SSA_NAME
6988       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6989     return 1;
6990
6991   /* Put SSA_NAMEs last.  */
6992   if (TREE_CODE (arg1) == SSA_NAME)
6993     return 0;
6994   if (TREE_CODE (arg0) == SSA_NAME)
6995     return 1;
6996
6997   /* Put variables last.  */
6998   if (DECL_P (arg1))
6999     return 0;
7000   if (DECL_P (arg0))
7001     return 1;
7002
7003   return 0;
7004 }
7005
7006 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
7007    ARG0 is extended to a wider type.  */
7008
7009 static tree
7010 fold_widened_comparison (enum tree_code code, tree type, tree arg0, tree arg1)
7011 {
7012   tree arg0_unw = get_unwidened (arg0, NULL_TREE);
7013   tree arg1_unw;
7014   tree shorter_type, outer_type;
7015   tree min, max;
7016   bool above, below;
7017
7018   if (arg0_unw == arg0)
7019     return NULL_TREE;
7020   shorter_type = TREE_TYPE (arg0_unw);
7021
7022 #ifdef HAVE_canonicalize_funcptr_for_compare
7023   /* Disable this optimization if we're casting a function pointer
7024      type on targets that require function pointer canonicalization.  */
7025   if (HAVE_canonicalize_funcptr_for_compare
7026       && TREE_CODE (shorter_type) == POINTER_TYPE
7027       && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
7028     return NULL_TREE;
7029 #endif
7030
7031   if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
7032     return NULL_TREE;
7033
7034   arg1_unw = get_unwidened (arg1, shorter_type);
7035
7036   /* If possible, express the comparison in the shorter mode.  */
7037   if ((code == EQ_EXPR || code == NE_EXPR
7038        || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
7039       && (TREE_TYPE (arg1_unw) == shorter_type
7040           || (TREE_CODE (arg1_unw) == INTEGER_CST
7041               && (TREE_CODE (shorter_type) == INTEGER_TYPE
7042                   || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
7043               && int_fits_type_p (arg1_unw, shorter_type))))
7044     return fold_build2 (code, type, arg0_unw,
7045                        fold_convert (shorter_type, arg1_unw));
7046
7047   if (TREE_CODE (arg1_unw) != INTEGER_CST
7048       || TREE_CODE (shorter_type) != INTEGER_TYPE
7049       || !int_fits_type_p (arg1_unw, shorter_type))
7050     return NULL_TREE;
7051
7052   /* If we are comparing with the integer that does not fit into the range
7053      of the shorter type, the result is known.  */
7054   outer_type = TREE_TYPE (arg1_unw);
7055   min = lower_bound_in_type (outer_type, shorter_type);
7056   max = upper_bound_in_type (outer_type, shorter_type);
7057
7058   above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
7059                                                    max, arg1_unw));
7060   below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
7061                                                    arg1_unw, min));
7062
7063   switch (code)
7064     {
7065     case EQ_EXPR:
7066       if (above || below)
7067         return omit_one_operand (type, integer_zero_node, arg0);
7068       break;
7069
7070     case NE_EXPR:
7071       if (above || below)
7072         return omit_one_operand (type, integer_one_node, arg0);
7073       break;
7074
7075     case LT_EXPR:
7076     case LE_EXPR:
7077       if (above)
7078         return omit_one_operand (type, integer_one_node, arg0);
7079       else if (below)
7080         return omit_one_operand (type, integer_zero_node, arg0);
7081
7082     case GT_EXPR:
7083     case GE_EXPR:
7084       if (above)
7085         return omit_one_operand (type, integer_zero_node, arg0);
7086       else if (below)
7087         return omit_one_operand (type, integer_one_node, arg0);
7088
7089     default:
7090       break;
7091     }
7092
7093   return NULL_TREE;
7094 }
7095
7096 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
7097    ARG0 just the signedness is changed.  */
7098
7099 static tree
7100 fold_sign_changed_comparison (enum tree_code code, tree type,
7101                               tree arg0, tree arg1)
7102 {
7103   tree arg0_inner;
7104   tree inner_type, outer_type;
7105
7106   if (TREE_CODE (arg0) != NOP_EXPR
7107       && TREE_CODE (arg0) != CONVERT_EXPR)
7108     return NULL_TREE;
7109
7110   outer_type = TREE_TYPE (arg0);
7111   arg0_inner = TREE_OPERAND (arg0, 0);
7112   inner_type = TREE_TYPE (arg0_inner);
7113
7114 #ifdef HAVE_canonicalize_funcptr_for_compare
7115   /* Disable this optimization if we're casting a function pointer
7116      type on targets that require function pointer canonicalization.  */
7117   if (HAVE_canonicalize_funcptr_for_compare
7118       && TREE_CODE (inner_type) == POINTER_TYPE
7119       && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
7120     return NULL_TREE;
7121 #endif
7122
7123   if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
7124     return NULL_TREE;
7125
7126   if (TREE_CODE (arg1) != INTEGER_CST
7127       && !((TREE_CODE (arg1) == NOP_EXPR
7128             || TREE_CODE (arg1) == CONVERT_EXPR)
7129            && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
7130     return NULL_TREE;
7131
7132   if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
7133       && code != NE_EXPR
7134       && code != EQ_EXPR)
7135     return NULL_TREE;
7136
7137   if (TREE_CODE (arg1) == INTEGER_CST)
7138     arg1 = force_fit_type_double (inner_type, TREE_INT_CST_LOW (arg1),
7139                                   TREE_INT_CST_HIGH (arg1), 0,
7140                                   TREE_OVERFLOW (arg1));
7141   else
7142     arg1 = fold_convert (inner_type, arg1);
7143
7144   return fold_build2 (code, type, arg0_inner, arg1);
7145 }
7146
7147 /* Tries to replace &a[idx] p+ s * delta with &a[idx + delta], if s is
7148    step of the array.  Reconstructs s and delta in the case of s * delta
7149    being an integer constant (and thus already folded).
7150    ADDR is the address. MULT is the multiplicative expression.
7151    If the function succeeds, the new address expression is returned.  Otherwise
7152    NULL_TREE is returned.  */
7153
7154 static tree
7155 try_move_mult_to_index (tree addr, tree op1)
7156 {
7157   tree s, delta, step;
7158   tree ref = TREE_OPERAND (addr, 0), pref;
7159   tree ret, pos;
7160   tree itype;
7161   bool mdim = false;
7162
7163   /*  Strip the nops that might be added when converting op1 to sizetype. */
7164   STRIP_NOPS (op1);
7165
7166   /* Canonicalize op1 into a possibly non-constant delta
7167      and an INTEGER_CST s.  */
7168   if (TREE_CODE (op1) == MULT_EXPR)
7169     {
7170       tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
7171
7172       STRIP_NOPS (arg0);
7173       STRIP_NOPS (arg1);
7174   
7175       if (TREE_CODE (arg0) == INTEGER_CST)
7176         {
7177           s = arg0;
7178           delta = arg1;
7179         }
7180       else if (TREE_CODE (arg1) == INTEGER_CST)
7181         {
7182           s = arg1;
7183           delta = arg0;
7184         }
7185       else
7186         return NULL_TREE;
7187     }
7188   else if (TREE_CODE (op1) == INTEGER_CST)
7189     {
7190       delta = op1;
7191       s = NULL_TREE;
7192     }
7193   else
7194     {
7195       /* Simulate we are delta * 1.  */
7196       delta = op1;
7197       s = integer_one_node;
7198     }
7199
7200   for (;; ref = TREE_OPERAND (ref, 0))
7201     {
7202       if (TREE_CODE (ref) == ARRAY_REF)
7203         {
7204           /* Remember if this was a multi-dimensional array.  */
7205           if (TREE_CODE (TREE_OPERAND (ref, 0)) == ARRAY_REF)
7206             mdim = true;
7207
7208           itype = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
7209           if (! itype)
7210             continue;
7211
7212           step = array_ref_element_size (ref);
7213           if (TREE_CODE (step) != INTEGER_CST)
7214             continue;
7215
7216           if (s)
7217             {
7218               if (! tree_int_cst_equal (step, s))
7219                 continue;
7220             }
7221           else
7222             {
7223               /* Try if delta is a multiple of step.  */
7224               tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, delta, step);
7225               if (! tmp)
7226                 continue;
7227               delta = tmp;
7228             }
7229
7230           /* Only fold here if we can verify we do not overflow one
7231              dimension of a multi-dimensional array.  */
7232           if (mdim)
7233             {
7234               tree tmp;
7235
7236               if (TREE_CODE (TREE_OPERAND (ref, 1)) != INTEGER_CST
7237                   || !INTEGRAL_TYPE_P (itype)
7238                   || !TYPE_MAX_VALUE (itype)
7239                   || TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST)
7240                 continue;
7241
7242               tmp = fold_binary (PLUS_EXPR, itype,
7243                                  fold_convert (itype,
7244                                                TREE_OPERAND (ref, 1)),
7245                                  fold_convert (itype, delta));
7246               if (!tmp
7247                   || TREE_CODE (tmp) != INTEGER_CST
7248                   || tree_int_cst_lt (TYPE_MAX_VALUE (itype), tmp))
7249                 continue;
7250             }
7251
7252           break;
7253         }
7254       else
7255         mdim = false;
7256
7257       if (!handled_component_p (ref))
7258         return NULL_TREE;
7259     }
7260
7261   /* We found the suitable array reference.  So copy everything up to it,
7262      and replace the index.  */
7263
7264   pref = TREE_OPERAND (addr, 0);
7265   ret = copy_node (pref);
7266   pos = ret;
7267
7268   while (pref != ref)
7269     {
7270       pref = TREE_OPERAND (pref, 0);
7271       TREE_OPERAND (pos, 0) = copy_node (pref);
7272       pos = TREE_OPERAND (pos, 0);
7273     }
7274
7275   TREE_OPERAND (pos, 1) = fold_build2 (PLUS_EXPR, itype,
7276                                        fold_convert (itype,
7277                                                      TREE_OPERAND (pos, 1)),
7278                                        fold_convert (itype, delta));
7279
7280   return fold_build1 (ADDR_EXPR, TREE_TYPE (addr), ret);
7281 }
7282
7283
7284 /* Fold A < X && A + 1 > Y to A < X && A >= Y.  Normally A + 1 > Y
7285    means A >= Y && A != MAX, but in this case we know that
7286    A < X <= MAX.  INEQ is A + 1 > Y, BOUND is A < X.  */
7287
7288 static tree
7289 fold_to_nonsharp_ineq_using_bound (tree ineq, tree bound)
7290 {
7291   tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
7292
7293   if (TREE_CODE (bound) == LT_EXPR)
7294     a = TREE_OPERAND (bound, 0);
7295   else if (TREE_CODE (bound) == GT_EXPR)
7296     a = TREE_OPERAND (bound, 1);
7297   else
7298     return NULL_TREE;
7299
7300   typea = TREE_TYPE (a);
7301   if (!INTEGRAL_TYPE_P (typea)
7302       && !POINTER_TYPE_P (typea))
7303     return NULL_TREE;
7304
7305   if (TREE_CODE (ineq) == LT_EXPR)
7306     {
7307       a1 = TREE_OPERAND (ineq, 1);
7308       y = TREE_OPERAND (ineq, 0);
7309     }
7310   else if (TREE_CODE (ineq) == GT_EXPR)
7311     {
7312       a1 = TREE_OPERAND (ineq, 0);
7313       y = TREE_OPERAND (ineq, 1);
7314     }
7315   else
7316     return NULL_TREE;
7317
7318   if (TREE_TYPE (a1) != typea)
7319     return NULL_TREE;
7320
7321   if (POINTER_TYPE_P (typea))
7322     {
7323       /* Convert the pointer types into integer before taking the difference.  */
7324       tree ta = fold_convert (ssizetype, a);
7325       tree ta1 = fold_convert (ssizetype, a1);
7326       diff = fold_binary (MINUS_EXPR, ssizetype, ta1, ta);
7327     }
7328   else
7329    diff = fold_binary (MINUS_EXPR, typea, a1, a);
7330
7331   if (!diff || !integer_onep (diff))
7332    return NULL_TREE;
7333
7334   return fold_build2 (GE_EXPR, type, a, y);
7335 }
7336
7337 /* Fold a sum or difference of at least one multiplication.
7338    Returns the folded tree or NULL if no simplification could be made.  */
7339
7340 static tree
7341 fold_plusminus_mult_expr (enum tree_code code, tree type, tree arg0, tree arg1)
7342 {
7343   tree arg00, arg01, arg10, arg11;
7344   tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
7345
7346   /* (A * C) +- (B * C) -> (A+-B) * C.
7347      (A * C) +- A -> A * (C+-1).
7348      We are most concerned about the case where C is a constant,
7349      but other combinations show up during loop reduction.  Since
7350      it is not difficult, try all four possibilities.  */
7351
7352   if (TREE_CODE (arg0) == MULT_EXPR)
7353     {
7354       arg00 = TREE_OPERAND (arg0, 0);
7355       arg01 = TREE_OPERAND (arg0, 1);
7356     }
7357   else if (TREE_CODE (arg0) == INTEGER_CST)
7358     {
7359       arg00 = build_one_cst (type);
7360       arg01 = arg0;
7361     }
7362   else
7363     {
7364       /* We cannot generate constant 1 for fract.  */
7365       if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7366         return NULL_TREE;
7367       arg00 = arg0;
7368       arg01 = build_one_cst (type);
7369     }
7370   if (TREE_CODE (arg1) == MULT_EXPR)
7371     {
7372       arg10 = TREE_OPERAND (arg1, 0);
7373       arg11 = TREE_OPERAND (arg1, 1);
7374     }
7375   else if (TREE_CODE (arg1) == INTEGER_CST)
7376     {
7377       arg10 = build_one_cst (type);
7378       arg11 = arg1;
7379     }
7380   else
7381     {
7382       /* We cannot generate constant 1 for fract.  */
7383       if (ALL_FRACT_MODE_P (TYPE_MODE (type)))
7384         return NULL_TREE;
7385       arg10 = arg1;
7386       arg11 = build_one_cst (type);
7387     }
7388   same = NULL_TREE;
7389
7390   if (operand_equal_p (arg01, arg11, 0))
7391     same = arg01, alt0 = arg00, alt1 = arg10;
7392   else if (operand_equal_p (arg00, arg10, 0))
7393     same = arg00, alt0 = arg01, alt1 = arg11;
7394   else if (operand_equal_p (arg00, arg11, 0))
7395     same = arg00, alt0 = arg01, alt1 = arg10;
7396   else if (operand_equal_p (arg01, arg10, 0))
7397     same = arg01, alt0 = arg00, alt1 = arg11;
7398
7399   /* No identical multiplicands; see if we can find a common
7400      power-of-two factor in non-power-of-two multiplies.  This
7401      can help in multi-dimensional array access.  */
7402   else if (host_integerp (arg01, 0)
7403            && host_integerp (arg11, 0))
7404     {
7405       HOST_WIDE_INT int01, int11, tmp;
7406       bool swap = false;
7407       tree maybe_same;
7408       int01 = TREE_INT_CST_LOW (arg01);
7409       int11 = TREE_INT_CST_LOW (arg11);
7410
7411       /* Move min of absolute values to int11.  */
7412       if ((int01 >= 0 ? int01 : -int01)
7413           < (int11 >= 0 ? int11 : -int11))
7414         {
7415           tmp = int01, int01 = int11, int11 = tmp;
7416           alt0 = arg00, arg00 = arg10, arg10 = alt0;
7417           maybe_same = arg01;
7418           swap = true;
7419         }
7420       else
7421         maybe_same = arg11;
7422
7423       if (exact_log2 (abs (int11)) > 0 && int01 % int11 == 0)
7424         {
7425           alt0 = fold_build2 (MULT_EXPR, TREE_TYPE (arg00), arg00,
7426                               build_int_cst (TREE_TYPE (arg00),
7427                                              int01 / int11));
7428           alt1 = arg10;
7429           same = maybe_same;
7430           if (swap)
7431             maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7432         }
7433     }
7434
7435   if (same)
7436     return fold_build2 (MULT_EXPR, type,
7437                         fold_build2 (code, type,
7438                                      fold_convert (type, alt0),
7439                                      fold_convert (type, alt1)),
7440                         fold_convert (type, same));
7441
7442   return NULL_TREE;
7443 }
7444
7445 /* Subroutine of native_encode_expr.  Encode the INTEGER_CST
7446    specified by EXPR into the buffer PTR of length LEN bytes.
7447    Return the number of bytes placed in the buffer, or zero
7448    upon failure.  */
7449
7450 static int
7451 native_encode_int (const_tree expr, unsigned char *ptr, int len)
7452 {
7453   tree type = TREE_TYPE (expr);
7454   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7455   int byte, offset, word, words;
7456   unsigned char value;
7457
7458   if (total_bytes > len)
7459     return 0;
7460   words = total_bytes / UNITS_PER_WORD;
7461
7462   for (byte = 0; byte < total_bytes; byte++)
7463     {
7464       int bitpos = byte * BITS_PER_UNIT;
7465       if (bitpos < HOST_BITS_PER_WIDE_INT)
7466         value = (unsigned char) (TREE_INT_CST_LOW (expr) >> bitpos);
7467       else
7468         value = (unsigned char) (TREE_INT_CST_HIGH (expr)
7469                                  >> (bitpos - HOST_BITS_PER_WIDE_INT));
7470
7471       if (total_bytes > UNITS_PER_WORD)
7472         {
7473           word = byte / UNITS_PER_WORD;
7474           if (WORDS_BIG_ENDIAN)
7475             word = (words - 1) - word;
7476           offset = word * UNITS_PER_WORD;
7477           if (BYTES_BIG_ENDIAN)
7478             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7479           else
7480             offset += byte % UNITS_PER_WORD;
7481         }
7482       else
7483         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7484       ptr[offset] = value;
7485     }
7486   return total_bytes;
7487 }
7488
7489
7490 /* Subroutine of native_encode_expr.  Encode the REAL_CST
7491    specified by EXPR into the buffer PTR of length LEN bytes.
7492    Return the number of bytes placed in the buffer, or zero
7493    upon failure.  */
7494
7495 static int
7496 native_encode_real (const_tree expr, unsigned char *ptr, int len)
7497 {
7498   tree type = TREE_TYPE (expr);
7499   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7500   int byte, offset, word, words, bitpos;
7501   unsigned char value;
7502
7503   /* There are always 32 bits in each long, no matter the size of
7504      the hosts long.  We handle floating point representations with
7505      up to 192 bits.  */
7506   long tmp[6];
7507
7508   if (total_bytes > len)
7509     return 0;
7510   words = 32 / UNITS_PER_WORD;
7511
7512   real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7513
7514   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7515        bitpos += BITS_PER_UNIT)
7516     {
7517       byte = (bitpos / BITS_PER_UNIT) & 3;
7518       value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7519
7520       if (UNITS_PER_WORD < 4)
7521         {
7522           word = byte / UNITS_PER_WORD;
7523           if (WORDS_BIG_ENDIAN)
7524             word = (words - 1) - word;
7525           offset = word * UNITS_PER_WORD;
7526           if (BYTES_BIG_ENDIAN)
7527             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7528           else
7529             offset += byte % UNITS_PER_WORD;
7530         }
7531       else
7532         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7533       ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)] = value;
7534     }
7535   return total_bytes;
7536 }
7537
7538 /* Subroutine of native_encode_expr.  Encode the COMPLEX_CST
7539    specified by EXPR into the buffer PTR of length LEN bytes.
7540    Return the number of bytes placed in the buffer, or zero
7541    upon failure.  */
7542
7543 static int
7544 native_encode_complex (const_tree expr, unsigned char *ptr, int len)
7545 {
7546   int rsize, isize;
7547   tree part;
7548
7549   part = TREE_REALPART (expr);
7550   rsize = native_encode_expr (part, ptr, len);
7551   if (rsize == 0)
7552     return 0;
7553   part = TREE_IMAGPART (expr);
7554   isize = native_encode_expr (part, ptr+rsize, len-rsize);
7555   if (isize != rsize)
7556     return 0;
7557   return rsize + isize;
7558 }
7559
7560
7561 /* Subroutine of native_encode_expr.  Encode the VECTOR_CST
7562    specified by EXPR into the buffer PTR of length LEN bytes.
7563    Return the number of bytes placed in the buffer, or zero
7564    upon failure.  */
7565
7566 static int
7567 native_encode_vector (const_tree expr, unsigned char *ptr, int len)
7568 {
7569   int i, size, offset, count;
7570   tree itype, elem, elements;
7571
7572   offset = 0;
7573   elements = TREE_VECTOR_CST_ELTS (expr);
7574   count = TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr));
7575   itype = TREE_TYPE (TREE_TYPE (expr));
7576   size = GET_MODE_SIZE (TYPE_MODE (itype));
7577   for (i = 0; i < count; i++)
7578     {
7579       if (elements)
7580         {
7581           elem = TREE_VALUE (elements);
7582           elements = TREE_CHAIN (elements);
7583         }
7584       else
7585         elem = NULL_TREE;
7586
7587       if (elem)
7588         {
7589           if (native_encode_expr (elem, ptr+offset, len-offset) != size)
7590             return 0;
7591         }
7592       else
7593         {
7594           if (offset + size > len)
7595             return 0;
7596           memset (ptr+offset, 0, size);
7597         }
7598       offset += size;
7599     }
7600   return offset;
7601 }
7602
7603
7604 /* Subroutine of fold_view_convert_expr.  Encode the INTEGER_CST,
7605    REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7606    buffer PTR of length LEN bytes.  Return the number of bytes
7607    placed in the buffer, or zero upon failure.  */
7608
7609 int
7610 native_encode_expr (const_tree expr, unsigned char *ptr, int len)
7611 {
7612   switch (TREE_CODE (expr))
7613     {
7614     case INTEGER_CST:
7615       return native_encode_int (expr, ptr, len);
7616
7617     case REAL_CST:
7618       return native_encode_real (expr, ptr, len);
7619
7620     case COMPLEX_CST:
7621       return native_encode_complex (expr, ptr, len);
7622
7623     case VECTOR_CST:
7624       return native_encode_vector (expr, ptr, len);
7625
7626     default:
7627       return 0;
7628     }
7629 }
7630
7631
7632 /* Subroutine of native_interpret_expr.  Interpret the contents of
7633    the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7634    If the buffer cannot be interpreted, return NULL_TREE.  */
7635
7636 static tree
7637 native_interpret_int (tree type, const unsigned char *ptr, int len)
7638 {
7639   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7640   int byte, offset, word, words;
7641   unsigned char value;
7642   unsigned int HOST_WIDE_INT lo = 0;
7643   HOST_WIDE_INT hi = 0;
7644
7645   if (total_bytes > len)
7646     return NULL_TREE;
7647   if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
7648     return NULL_TREE;
7649   words = total_bytes / UNITS_PER_WORD;
7650
7651   for (byte = 0; byte < total_bytes; byte++)
7652     {
7653       int bitpos = byte * BITS_PER_UNIT;
7654       if (total_bytes > UNITS_PER_WORD)
7655         {
7656           word = byte / UNITS_PER_WORD;
7657           if (WORDS_BIG_ENDIAN)
7658             word = (words - 1) - word;
7659           offset = word * UNITS_PER_WORD;
7660           if (BYTES_BIG_ENDIAN)
7661             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7662           else
7663             offset += byte % UNITS_PER_WORD;
7664         }
7665       else
7666         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7667       value = ptr[offset];
7668
7669       if (bitpos < HOST_BITS_PER_WIDE_INT)
7670         lo |= (unsigned HOST_WIDE_INT) value << bitpos;
7671       else
7672         hi |= (unsigned HOST_WIDE_INT) value
7673               << (bitpos - HOST_BITS_PER_WIDE_INT);
7674     }
7675
7676   return build_int_cst_wide_type (type, lo, hi);
7677 }
7678
7679
7680 /* Subroutine of native_interpret_expr.  Interpret the contents of
7681    the buffer PTR of length LEN as a REAL_CST of type TYPE.
7682    If the buffer cannot be interpreted, return NULL_TREE.  */
7683
7684 static tree
7685 native_interpret_real (tree type, const unsigned char *ptr, int len)
7686 {
7687   enum machine_mode mode = TYPE_MODE (type);
7688   int total_bytes = GET_MODE_SIZE (mode);
7689   int byte, offset, word, words, bitpos;
7690   unsigned char value;
7691   /* There are always 32 bits in each long, no matter the size of
7692      the hosts long.  We handle floating point representations with
7693      up to 192 bits.  */
7694   REAL_VALUE_TYPE r;
7695   long tmp[6];
7696
7697   total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7698   if (total_bytes > len || total_bytes > 24)
7699     return NULL_TREE;
7700   words = 32 / UNITS_PER_WORD;
7701
7702   memset (tmp, 0, sizeof (tmp));
7703   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7704        bitpos += BITS_PER_UNIT)
7705     {
7706       byte = (bitpos / BITS_PER_UNIT) & 3;
7707       if (UNITS_PER_WORD < 4)
7708         {
7709           word = byte / UNITS_PER_WORD;
7710           if (WORDS_BIG_ENDIAN)
7711             word = (words - 1) - word;
7712           offset = word * UNITS_PER_WORD;
7713           if (BYTES_BIG_ENDIAN)
7714             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7715           else
7716             offset += byte % UNITS_PER_WORD;
7717         }
7718       else
7719         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7720       value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7721
7722       tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7723     }
7724
7725   real_from_target (&r, tmp, mode);
7726   return build_real (type, r);
7727 }
7728
7729
7730 /* Subroutine of native_interpret_expr.  Interpret the contents of
7731    the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7732    If the buffer cannot be interpreted, return NULL_TREE.  */
7733
7734 static tree
7735 native_interpret_complex (tree type, const unsigned char *ptr, int len)
7736 {
7737   tree etype, rpart, ipart;
7738   int size;
7739
7740   etype = TREE_TYPE (type);
7741   size = GET_MODE_SIZE (TYPE_MODE (etype));
7742   if (size * 2 > len)
7743     return NULL_TREE;
7744   rpart = native_interpret_expr (etype, ptr, size);
7745   if (!rpart)
7746     return NULL_TREE;
7747   ipart = native_interpret_expr (etype, ptr+size, size);
7748   if (!ipart)
7749     return NULL_TREE;
7750   return build_complex (type, rpart, ipart);
7751 }
7752
7753
7754 /* Subroutine of native_interpret_expr.  Interpret the contents of
7755    the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7756    If the buffer cannot be interpreted, return NULL_TREE.  */
7757
7758 static tree
7759 native_interpret_vector (tree type, const unsigned char *ptr, int len)
7760 {
7761   tree etype, elem, elements;
7762   int i, size, count;
7763
7764   etype = TREE_TYPE (type);
7765   size = GET_MODE_SIZE (TYPE_MODE (etype));
7766   count = TYPE_VECTOR_SUBPARTS (type);
7767   if (size * count > len)
7768     return NULL_TREE;
7769
7770   elements = NULL_TREE;
7771   for (i = count - 1; i >= 0; i--)
7772     {
7773       elem = native_interpret_expr (etype, ptr+(i*size), size);
7774       if (!elem)
7775         return NULL_TREE;
7776       elements = tree_cons (NULL_TREE, elem, elements);
7777     }
7778   return build_vector (type, elements);
7779 }
7780
7781
7782 /* Subroutine of fold_view_convert_expr.  Interpret the contents of
7783    the buffer PTR of length LEN as a constant of type TYPE.  For
7784    INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7785    we return a REAL_CST, etc...  If the buffer cannot be interpreted,
7786    return NULL_TREE.  */
7787
7788 tree
7789 native_interpret_expr (tree type, const unsigned char *ptr, int len)
7790 {
7791   switch (TREE_CODE (type))
7792     {
7793     case INTEGER_TYPE:
7794     case ENUMERAL_TYPE:
7795     case BOOLEAN_TYPE:
7796       return native_interpret_int (type, ptr, len);
7797
7798     case REAL_TYPE:
7799       return native_interpret_real (type, ptr, len);
7800
7801     case COMPLEX_TYPE:
7802       return native_interpret_complex (type, ptr, len);
7803
7804     case VECTOR_TYPE:
7805       return native_interpret_vector (type, ptr, len);
7806
7807     default:
7808       return NULL_TREE;
7809     }
7810 }
7811
7812
7813 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7814    TYPE at compile-time.  If we're unable to perform the conversion
7815    return NULL_TREE.  */
7816
7817 static tree
7818 fold_view_convert_expr (tree type, tree expr)
7819 {
7820   /* We support up to 512-bit values (for V8DFmode).  */
7821   unsigned char buffer[64];
7822   int len;
7823
7824   /* Check that the host and target are sane.  */
7825   if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7826     return NULL_TREE;
7827
7828   len = native_encode_expr (expr, buffer, sizeof (buffer));
7829   if (len == 0)
7830     return NULL_TREE;
7831
7832   return native_interpret_expr (type, buffer, len);
7833 }
7834
7835 /* Build an expression for the address of T.  Folds away INDIRECT_REF
7836    to avoid confusing the gimplify process.  When IN_FOLD is true
7837    avoid modifications of T.  */
7838
7839 static tree
7840 build_fold_addr_expr_with_type_1 (tree t, tree ptrtype, bool in_fold)
7841 {
7842   /* The size of the object is not relevant when talking about its address.  */
7843   if (TREE_CODE (t) == WITH_SIZE_EXPR)
7844     t = TREE_OPERAND (t, 0);
7845
7846   /* Note: doesn't apply to ALIGN_INDIRECT_REF */
7847   if (TREE_CODE (t) == INDIRECT_REF
7848       || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
7849     {
7850       t = TREE_OPERAND (t, 0);
7851
7852       if (TREE_TYPE (t) != ptrtype)
7853         t = build1 (NOP_EXPR, ptrtype, t);
7854     }
7855   else if (!in_fold)
7856     {
7857       tree base = t;
7858
7859       while (handled_component_p (base))
7860         base = TREE_OPERAND (base, 0);
7861
7862       if (DECL_P (base))
7863         TREE_ADDRESSABLE (base) = 1;
7864
7865       t = build1 (ADDR_EXPR, ptrtype, t);
7866     }
7867   else
7868     t = build1 (ADDR_EXPR, ptrtype, t);
7869
7870   return t;
7871 }
7872
7873 /* Build an expression for the address of T with type PTRTYPE.  This
7874    function modifies the input parameter 'T' by sometimes setting the
7875    TREE_ADDRESSABLE flag.  */
7876
7877 tree
7878 build_fold_addr_expr_with_type (tree t, tree ptrtype)
7879 {
7880   return build_fold_addr_expr_with_type_1 (t, ptrtype, false);
7881 }
7882
7883 /* Build an expression for the address of T.  This function modifies
7884    the input parameter 'T' by sometimes setting the TREE_ADDRESSABLE
7885    flag.  When called from fold functions, use fold_addr_expr instead.  */
7886
7887 tree
7888 build_fold_addr_expr (tree t)
7889 {
7890   return build_fold_addr_expr_with_type_1 (t, 
7891                                            build_pointer_type (TREE_TYPE (t)),
7892                                            false);
7893 }
7894
7895 /* Same as build_fold_addr_expr, builds an expression for the address
7896    of T, but avoids touching the input node 't'.  Fold functions
7897    should use this version.  */
7898
7899 static tree
7900 fold_addr_expr (tree t)
7901 {
7902   tree ptrtype = build_pointer_type (TREE_TYPE (t));
7903
7904   return build_fold_addr_expr_with_type_1 (t, ptrtype, true);
7905 }
7906
7907 /* Fold a unary expression of code CODE and type TYPE with operand
7908    OP0.  Return the folded expression if folding is successful.
7909    Otherwise, return NULL_TREE.  */
7910
7911 tree
7912 fold_unary (enum tree_code code, tree type, tree op0)
7913 {
7914   tree tem;
7915   tree arg0;
7916   enum tree_code_class kind = TREE_CODE_CLASS (code);
7917
7918   gcc_assert (IS_EXPR_CODE_CLASS (kind)
7919               && TREE_CODE_LENGTH (code) == 1);
7920
7921   arg0 = op0;
7922   if (arg0)
7923     {
7924       if (code == NOP_EXPR || code == CONVERT_EXPR
7925           || code == FLOAT_EXPR || code == ABS_EXPR)
7926         {
7927           /* Don't use STRIP_NOPS, because signedness of argument type
7928              matters.  */
7929           STRIP_SIGN_NOPS (arg0);
7930         }
7931       else
7932         {
7933           /* Strip any conversions that don't change the mode.  This
7934              is safe for every expression, except for a comparison
7935              expression because its signedness is derived from its
7936              operands.
7937
7938              Note that this is done as an internal manipulation within
7939              the constant folder, in order to find the simplest
7940              representation of the arguments so that their form can be
7941              studied.  In any cases, the appropriate type conversions
7942              should be put back in the tree that will get out of the
7943              constant folder.  */
7944           STRIP_NOPS (arg0);
7945         }
7946     }
7947
7948   if (TREE_CODE_CLASS (code) == tcc_unary)
7949     {
7950       if (TREE_CODE (arg0) == COMPOUND_EXPR)
7951         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7952                        fold_build1 (code, type, TREE_OPERAND (arg0, 1)));
7953       else if (TREE_CODE (arg0) == COND_EXPR)
7954         {
7955           tree arg01 = TREE_OPERAND (arg0, 1);
7956           tree arg02 = TREE_OPERAND (arg0, 2);
7957           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7958             arg01 = fold_build1 (code, type, arg01);
7959           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7960             arg02 = fold_build1 (code, type, arg02);
7961           tem = fold_build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
7962                              arg01, arg02);
7963
7964           /* If this was a conversion, and all we did was to move into
7965              inside the COND_EXPR, bring it back out.  But leave it if
7966              it is a conversion from integer to integer and the
7967              result precision is no wider than a word since such a
7968              conversion is cheap and may be optimized away by combine,
7969              while it couldn't if it were outside the COND_EXPR.  Then return
7970              so we don't get into an infinite recursion loop taking the
7971              conversion out and then back in.  */
7972
7973           if ((code == NOP_EXPR || code == CONVERT_EXPR
7974                || code == NON_LVALUE_EXPR)
7975               && TREE_CODE (tem) == COND_EXPR
7976               && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7977               && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7978               && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7979               && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7980               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7981                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7982               && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7983                      && (INTEGRAL_TYPE_P
7984                          (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7985                      && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7986                   || flag_syntax_only))
7987             tem = build1 (code, type,
7988                           build3 (COND_EXPR,
7989                                   TREE_TYPE (TREE_OPERAND
7990                                              (TREE_OPERAND (tem, 1), 0)),
7991                                   TREE_OPERAND (tem, 0),
7992                                   TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7993                                   TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
7994           return tem;
7995         }
7996       else if (COMPARISON_CLASS_P (arg0))
7997         {
7998           if (TREE_CODE (type) == BOOLEAN_TYPE)
7999             {
8000               arg0 = copy_node (arg0);
8001               TREE_TYPE (arg0) = type;
8002               return arg0;
8003             }
8004           else if (TREE_CODE (type) != INTEGER_TYPE)
8005             return fold_build3 (COND_EXPR, type, arg0,
8006                                 fold_build1 (code, type,
8007                                              integer_one_node),
8008                                 fold_build1 (code, type,
8009                                              integer_zero_node));
8010         }
8011    }
8012
8013   switch (code)
8014     {
8015     case NOP_EXPR:
8016     case FLOAT_EXPR:
8017     case CONVERT_EXPR:
8018     case FIX_TRUNC_EXPR:
8019       if (TREE_TYPE (op0) == type)
8020         return op0;
8021       
8022       /* If we have (type) (a CMP b) and type is an integral type, return
8023          new expression involving the new type.  */
8024       if (COMPARISON_CLASS_P (op0) && INTEGRAL_TYPE_P (type))
8025         return fold_build2 (TREE_CODE (op0), type, TREE_OPERAND (op0, 0),
8026                             TREE_OPERAND (op0, 1));
8027
8028       /* Handle cases of two conversions in a row.  */
8029       if (TREE_CODE (op0) == NOP_EXPR
8030           || TREE_CODE (op0) == CONVERT_EXPR)
8031         {
8032           tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
8033           tree inter_type = TREE_TYPE (op0);
8034           int inside_int = INTEGRAL_TYPE_P (inside_type);
8035           int inside_ptr = POINTER_TYPE_P (inside_type);
8036           int inside_float = FLOAT_TYPE_P (inside_type);
8037           int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
8038           unsigned int inside_prec = TYPE_PRECISION (inside_type);
8039           int inside_unsignedp = TYPE_UNSIGNED (inside_type);
8040           int inter_int = INTEGRAL_TYPE_P (inter_type);
8041           int inter_ptr = POINTER_TYPE_P (inter_type);
8042           int inter_float = FLOAT_TYPE_P (inter_type);
8043           int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
8044           unsigned int inter_prec = TYPE_PRECISION (inter_type);
8045           int inter_unsignedp = TYPE_UNSIGNED (inter_type);
8046           int final_int = INTEGRAL_TYPE_P (type);
8047           int final_ptr = POINTER_TYPE_P (type);
8048           int final_float = FLOAT_TYPE_P (type);
8049           int final_vec = TREE_CODE (type) == VECTOR_TYPE;
8050           unsigned int final_prec = TYPE_PRECISION (type);
8051           int final_unsignedp = TYPE_UNSIGNED (type);
8052
8053           /* In addition to the cases of two conversions in a row
8054              handled below, if we are converting something to its own
8055              type via an object of identical or wider precision, neither
8056              conversion is needed.  */
8057           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
8058               && (((inter_int || inter_ptr) && final_int)
8059                   || (inter_float && final_float))
8060               && inter_prec >= final_prec)
8061             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8062
8063           /* Likewise, if the intermediate and final types are either both
8064              float or both integer, we don't need the middle conversion if
8065              it is wider than the final type and doesn't change the signedness
8066              (for integers).  Avoid this if the final type is a pointer
8067              since then we sometimes need the inner conversion.  Likewise if
8068              the outer has a precision not equal to the size of its mode.  */
8069           if (((inter_int && inside_int)
8070                || (inter_float && inside_float)
8071                || (inter_vec && inside_vec))
8072               && inter_prec >= inside_prec
8073               && (inter_float || inter_vec
8074                   || inter_unsignedp == inside_unsignedp)
8075               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
8076                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
8077               && ! final_ptr
8078               && (! final_vec || inter_prec == inside_prec))
8079             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8080
8081           /* If we have a sign-extension of a zero-extended value, we can
8082              replace that by a single zero-extension.  */
8083           if (inside_int && inter_int && final_int
8084               && inside_prec < inter_prec && inter_prec < final_prec
8085               && inside_unsignedp && !inter_unsignedp)
8086             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8087
8088           /* Two conversions in a row are not needed unless:
8089              - some conversion is floating-point (overstrict for now), or
8090              - some conversion is a vector (overstrict for now), or
8091              - the intermediate type is narrower than both initial and
8092                final, or
8093              - the intermediate type and innermost type differ in signedness,
8094                and the outermost type is wider than the intermediate, or
8095              - the initial type is a pointer type and the precisions of the
8096                intermediate and final types differ, or
8097              - the final type is a pointer type and the precisions of the
8098                initial and intermediate types differ.
8099              - the initial type is a pointer to an array and the final type
8100                not.  */
8101           if (! inside_float && ! inter_float && ! final_float
8102               && ! inside_vec && ! inter_vec && ! final_vec
8103               && (inter_prec >= inside_prec || inter_prec >= final_prec)
8104               && ! (inside_int && inter_int
8105                     && inter_unsignedp != inside_unsignedp
8106                     && inter_prec < final_prec)
8107               && ((inter_unsignedp && inter_prec > inside_prec)
8108                   == (final_unsignedp && final_prec > inter_prec))
8109               && ! (inside_ptr && inter_prec != final_prec)
8110               && ! (final_ptr && inside_prec != inter_prec)
8111               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
8112                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
8113               && ! (inside_ptr && final_ptr
8114                     && TREE_CODE (TREE_TYPE (inside_type)) == ARRAY_TYPE
8115                     && TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE))
8116             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
8117         }
8118
8119       /* Handle (T *)&A.B.C for A being of type T and B and C
8120          living at offset zero.  This occurs frequently in
8121          C++ upcasting and then accessing the base.  */
8122       if (TREE_CODE (op0) == ADDR_EXPR
8123           && POINTER_TYPE_P (type)
8124           && handled_component_p (TREE_OPERAND (op0, 0)))
8125         {
8126           HOST_WIDE_INT bitsize, bitpos;
8127           tree offset;
8128           enum machine_mode mode;
8129           int unsignedp, volatilep;
8130           tree base = TREE_OPERAND (op0, 0);
8131           base = get_inner_reference (base, &bitsize, &bitpos, &offset,
8132                                       &mode, &unsignedp, &volatilep, false);
8133           /* If the reference was to a (constant) zero offset, we can use
8134              the address of the base if it has the same base type
8135              as the result type.  */
8136           if (! offset && bitpos == 0
8137               && TYPE_MAIN_VARIANT (TREE_TYPE (type))
8138                   == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
8139             return fold_convert (type, fold_addr_expr (base));
8140         }
8141
8142       if ((TREE_CODE (op0) == MODIFY_EXPR
8143            || TREE_CODE (op0) == GIMPLE_MODIFY_STMT)
8144           && TREE_CONSTANT (GENERIC_TREE_OPERAND (op0, 1))
8145           /* Detect assigning a bitfield.  */
8146           && !(TREE_CODE (GENERIC_TREE_OPERAND (op0, 0)) == COMPONENT_REF
8147                && DECL_BIT_FIELD
8148                (TREE_OPERAND (GENERIC_TREE_OPERAND (op0, 0), 1))))
8149         {
8150           /* Don't leave an assignment inside a conversion
8151              unless assigning a bitfield.  */
8152           tem = fold_build1 (code, type, GENERIC_TREE_OPERAND (op0, 1));
8153           /* First do the assignment, then return converted constant.  */
8154           tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
8155           TREE_NO_WARNING (tem) = 1;
8156           TREE_USED (tem) = 1;
8157           return tem;
8158         }
8159
8160       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
8161          constants (if x has signed type, the sign bit cannot be set
8162          in c).  This folds extension into the BIT_AND_EXPR.  */
8163       if (INTEGRAL_TYPE_P (type)
8164           && TREE_CODE (type) != BOOLEAN_TYPE
8165           && TREE_CODE (op0) == BIT_AND_EXPR
8166           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
8167         {
8168           tree and = op0;
8169           tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
8170           int change = 0;
8171
8172           if (TYPE_UNSIGNED (TREE_TYPE (and))
8173               || (TYPE_PRECISION (type)
8174                   <= TYPE_PRECISION (TREE_TYPE (and))))
8175             change = 1;
8176           else if (TYPE_PRECISION (TREE_TYPE (and1))
8177                    <= HOST_BITS_PER_WIDE_INT
8178                    && host_integerp (and1, 1))
8179             {
8180               unsigned HOST_WIDE_INT cst;
8181
8182               cst = tree_low_cst (and1, 1);
8183               cst &= (HOST_WIDE_INT) -1
8184                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
8185               change = (cst == 0);
8186 #ifdef LOAD_EXTEND_OP
8187               if (change
8188                   && !flag_syntax_only
8189                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
8190                       == ZERO_EXTEND))
8191                 {
8192                   tree uns = unsigned_type_for (TREE_TYPE (and0));
8193                   and0 = fold_convert (uns, and0);
8194                   and1 = fold_convert (uns, and1);
8195                 }
8196 #endif
8197             }
8198           if (change)
8199             {
8200               tem = force_fit_type_double (type, TREE_INT_CST_LOW (and1),
8201                                            TREE_INT_CST_HIGH (and1), 0,
8202                                            TREE_OVERFLOW (and1));
8203               return fold_build2 (BIT_AND_EXPR, type,
8204                                   fold_convert (type, and0), tem);
8205             }
8206         }
8207
8208       /* Convert (T1)(X p+ Y) into ((T1)X p+ Y), for pointer type,
8209          when one of the new casts will fold away. Conservatively we assume
8210          that this happens when X or Y is NOP_EXPR or Y is INTEGER_CST. */
8211       if (POINTER_TYPE_P (type)
8212           && TREE_CODE (arg0) == POINTER_PLUS_EXPR
8213           && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8214               || TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
8215               || TREE_CODE (TREE_OPERAND (arg0, 1)) == NOP_EXPR))
8216         {
8217           tree arg00 = TREE_OPERAND (arg0, 0);
8218           tree arg01 = TREE_OPERAND (arg0, 1);
8219
8220           return fold_build2 (TREE_CODE (arg0), type, fold_convert (type, arg00),
8221                               fold_convert (sizetype, arg01));
8222         }
8223
8224       /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
8225          of the same precision, and X is an integer type not narrower than
8226          types T1 or T2, i.e. the cast (T2)X isn't an extension.  */
8227       if (INTEGRAL_TYPE_P (type)
8228           && TREE_CODE (op0) == BIT_NOT_EXPR
8229           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8230           && (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
8231               || TREE_CODE (TREE_OPERAND (op0, 0)) == CONVERT_EXPR)
8232           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
8233         {
8234           tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
8235           if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
8236               && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
8237             return fold_build1 (BIT_NOT_EXPR, type, fold_convert (type, tem));
8238         }
8239
8240       tem = fold_convert_const (code, type, op0);
8241       return tem ? tem : NULL_TREE;
8242
8243     case FIXED_CONVERT_EXPR:
8244       tem = fold_convert_const (code, type, arg0);
8245       return tem ? tem : NULL_TREE;
8246
8247     case VIEW_CONVERT_EXPR:
8248       if (TREE_TYPE (op0) == type)
8249         return op0;
8250       if (TREE_CODE (op0) == VIEW_CONVERT_EXPR
8251           || (TREE_CODE (op0) == NOP_EXPR
8252               && INTEGRAL_TYPE_P (TREE_TYPE (op0))
8253               && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
8254               && TYPE_PRECISION (TREE_TYPE (op0))
8255                  == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
8256         return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
8257       return fold_view_convert_expr (type, op0);
8258
8259     case NEGATE_EXPR:
8260       tem = fold_negate_expr (arg0);
8261       if (tem)
8262         return fold_convert (type, tem);
8263       return NULL_TREE;
8264
8265     case ABS_EXPR:
8266       if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
8267         return fold_abs_const (arg0, type);
8268       else if (TREE_CODE (arg0) == NEGATE_EXPR)
8269         return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
8270       /* Convert fabs((double)float) into (double)fabsf(float).  */
8271       else if (TREE_CODE (arg0) == NOP_EXPR
8272                && TREE_CODE (type) == REAL_TYPE)
8273         {
8274           tree targ0 = strip_float_extensions (arg0);
8275           if (targ0 != arg0)
8276             return fold_convert (type, fold_build1 (ABS_EXPR,
8277                                                     TREE_TYPE (targ0),
8278                                                     targ0));
8279         }
8280       /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on.  */
8281       else if (TREE_CODE (arg0) == ABS_EXPR)
8282         return arg0;
8283       else if (tree_expr_nonnegative_p (arg0))
8284         return arg0;
8285
8286       /* Strip sign ops from argument.  */
8287       if (TREE_CODE (type) == REAL_TYPE)
8288         {
8289           tem = fold_strip_sign_ops (arg0);
8290           if (tem)
8291             return fold_build1 (ABS_EXPR, type, fold_convert (type, tem));
8292         }
8293       return NULL_TREE;
8294
8295     case CONJ_EXPR:
8296       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8297         return fold_convert (type, arg0);
8298       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8299         {
8300           tree itype = TREE_TYPE (type);
8301           tree rpart = fold_convert (itype, TREE_OPERAND (arg0, 0));
8302           tree ipart = fold_convert (itype, TREE_OPERAND (arg0, 1));
8303           return fold_build2 (COMPLEX_EXPR, type, rpart, negate_expr (ipart));
8304         }
8305       if (TREE_CODE (arg0) == COMPLEX_CST)
8306         {
8307           tree itype = TREE_TYPE (type);
8308           tree rpart = fold_convert (itype, TREE_REALPART (arg0));
8309           tree ipart = fold_convert (itype, TREE_IMAGPART (arg0));
8310           return build_complex (type, rpart, negate_expr (ipart));
8311         }
8312       if (TREE_CODE (arg0) == CONJ_EXPR)
8313         return fold_convert (type, TREE_OPERAND (arg0, 0));
8314       return NULL_TREE;
8315
8316     case BIT_NOT_EXPR:
8317       if (TREE_CODE (arg0) == INTEGER_CST)
8318         return fold_not_const (arg0, type);
8319       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
8320         return TREE_OPERAND (op0, 0);
8321       /* Convert ~ (-A) to A - 1.  */
8322       else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
8323         return fold_build2 (MINUS_EXPR, type,
8324                             fold_convert (type, TREE_OPERAND (arg0, 0)),
8325                             build_int_cst (type, 1));
8326       /* Convert ~ (A - 1) or ~ (A + -1) to -A.  */
8327       else if (INTEGRAL_TYPE_P (type)
8328                && ((TREE_CODE (arg0) == MINUS_EXPR
8329                     && integer_onep (TREE_OPERAND (arg0, 1)))
8330                    || (TREE_CODE (arg0) == PLUS_EXPR
8331                        && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
8332         return fold_build1 (NEGATE_EXPR, type,
8333                             fold_convert (type, TREE_OPERAND (arg0, 0)));
8334       /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify.  */
8335       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8336                && (tem = fold_unary (BIT_NOT_EXPR, type,
8337                                      fold_convert (type,
8338                                                    TREE_OPERAND (arg0, 0)))))
8339         return fold_build2 (BIT_XOR_EXPR, type, tem,
8340                             fold_convert (type, TREE_OPERAND (arg0, 1)));
8341       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
8342                && (tem = fold_unary (BIT_NOT_EXPR, type,
8343                                      fold_convert (type,
8344                                                    TREE_OPERAND (arg0, 1)))))
8345         return fold_build2 (BIT_XOR_EXPR, type,
8346                             fold_convert (type, TREE_OPERAND (arg0, 0)), tem);
8347       /* Perform BIT_NOT_EXPR on each element individually.  */
8348       else if (TREE_CODE (arg0) == VECTOR_CST)
8349         {
8350           tree elements = TREE_VECTOR_CST_ELTS (arg0), elem, list = NULL_TREE;
8351           int count = TYPE_VECTOR_SUBPARTS (type), i;
8352
8353           for (i = 0; i < count; i++)
8354             {
8355               if (elements)
8356                 {
8357                   elem = TREE_VALUE (elements);
8358                   elem = fold_unary (BIT_NOT_EXPR, TREE_TYPE (type), elem);
8359                   if (elem == NULL_TREE)
8360                     break;
8361                   elements = TREE_CHAIN (elements);
8362                 }
8363               else
8364                 elem = build_int_cst (TREE_TYPE (type), -1);
8365               list = tree_cons (NULL_TREE, elem, list);
8366             }
8367           if (i == count)
8368             return build_vector (type, nreverse (list));
8369         }
8370
8371       return NULL_TREE;
8372
8373     case TRUTH_NOT_EXPR:
8374       /* The argument to invert_truthvalue must have Boolean type.  */
8375       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
8376           arg0 = fold_convert (boolean_type_node, arg0);
8377
8378       /* Note that the operand of this must be an int
8379          and its values must be 0 or 1.
8380          ("true" is a fixed value perhaps depending on the language,
8381          but we don't handle values other than 1 correctly yet.)  */
8382       tem = fold_truth_not_expr (arg0);
8383       if (!tem)
8384         return NULL_TREE;
8385       return fold_convert (type, tem);
8386
8387     case REALPART_EXPR:
8388       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8389         return fold_convert (type, arg0);
8390       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8391         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
8392                                  TREE_OPERAND (arg0, 1));
8393       if (TREE_CODE (arg0) == COMPLEX_CST)
8394         return fold_convert (type, TREE_REALPART (arg0));
8395       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8396         {
8397           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8398           tem = fold_build2 (TREE_CODE (arg0), itype,
8399                              fold_build1 (REALPART_EXPR, itype,
8400                                           TREE_OPERAND (arg0, 0)),
8401                              fold_build1 (REALPART_EXPR, itype,
8402                                           TREE_OPERAND (arg0, 1)));
8403           return fold_convert (type, tem);
8404         }
8405       if (TREE_CODE (arg0) == CONJ_EXPR)
8406         {
8407           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8408           tem = fold_build1 (REALPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8409           return fold_convert (type, tem);
8410         }
8411       if (TREE_CODE (arg0) == CALL_EXPR)
8412         {
8413           tree fn = get_callee_fndecl (arg0);
8414           if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8415             switch (DECL_FUNCTION_CODE (fn))
8416               {
8417               CASE_FLT_FN (BUILT_IN_CEXPI):
8418                 fn = mathfn_built_in (type, BUILT_IN_COS);
8419                 if (fn)
8420                   return build_call_expr (fn, 1, CALL_EXPR_ARG (arg0, 0));
8421                 break;
8422
8423               default:
8424                 break;
8425               }
8426         }
8427       return NULL_TREE;
8428
8429     case IMAGPART_EXPR:
8430       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
8431         return fold_convert (type, integer_zero_node);
8432       if (TREE_CODE (arg0) == COMPLEX_EXPR)
8433         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
8434                                  TREE_OPERAND (arg0, 0));
8435       if (TREE_CODE (arg0) == COMPLEX_CST)
8436         return fold_convert (type, TREE_IMAGPART (arg0));
8437       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8438         {
8439           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8440           tem = fold_build2 (TREE_CODE (arg0), itype,
8441                              fold_build1 (IMAGPART_EXPR, itype,
8442                                           TREE_OPERAND (arg0, 0)),
8443                              fold_build1 (IMAGPART_EXPR, itype,
8444                                           TREE_OPERAND (arg0, 1)));
8445           return fold_convert (type, tem);
8446         }
8447       if (TREE_CODE (arg0) == CONJ_EXPR)
8448         {
8449           tree itype = TREE_TYPE (TREE_TYPE (arg0));
8450           tem = fold_build1 (IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
8451           return fold_convert (type, negate_expr (tem));
8452         }
8453       if (TREE_CODE (arg0) == CALL_EXPR)
8454         {
8455           tree fn = get_callee_fndecl (arg0);
8456           if (fn && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL)
8457             switch (DECL_FUNCTION_CODE (fn))
8458               {
8459               CASE_FLT_FN (BUILT_IN_CEXPI):
8460                 fn = mathfn_built_in (type, BUILT_IN_SIN);
8461                 if (fn)
8462                   return build_call_expr (fn, 1, CALL_EXPR_ARG (arg0, 0));
8463                 break;
8464
8465               default:
8466                 break;
8467               }
8468         }
8469       return NULL_TREE;
8470
8471     default:
8472       return NULL_TREE;
8473     } /* switch (code) */
8474 }
8475
8476 /* Fold a binary expression of code CODE and type TYPE with operands
8477    OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
8478    Return the folded expression if folding is successful.  Otherwise,
8479    return NULL_TREE.  */
8480
8481 static tree
8482 fold_minmax (enum tree_code code, tree type, tree op0, tree op1)
8483 {
8484   enum tree_code compl_code;
8485
8486   if (code == MIN_EXPR)
8487     compl_code = MAX_EXPR;
8488   else if (code == MAX_EXPR)
8489     compl_code = MIN_EXPR;
8490   else
8491     gcc_unreachable ();
8492
8493   /* MIN (MAX (a, b), b) == b.  */
8494   if (TREE_CODE (op0) == compl_code
8495       && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
8496     return omit_one_operand (type, op1, TREE_OPERAND (op0, 0));
8497
8498   /* MIN (MAX (b, a), b) == b.  */
8499   if (TREE_CODE (op0) == compl_code
8500       && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
8501       && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
8502     return omit_one_operand (type, op1, TREE_OPERAND (op0, 1));
8503
8504   /* MIN (a, MAX (a, b)) == a.  */
8505   if (TREE_CODE (op1) == compl_code
8506       && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
8507       && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
8508     return omit_one_operand (type, op0, TREE_OPERAND (op1, 1));
8509
8510   /* MIN (a, MAX (b, a)) == a.  */
8511   if (TREE_CODE (op1) == compl_code
8512       && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
8513       && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
8514     return omit_one_operand (type, op0, TREE_OPERAND (op1, 0));
8515
8516   return NULL_TREE;
8517 }
8518
8519 /* Helper that tries to canonicalize the comparison ARG0 CODE ARG1
8520    by changing CODE to reduce the magnitude of constants involved in
8521    ARG0 of the comparison.
8522    Returns a canonicalized comparison tree if a simplification was
8523    possible, otherwise returns NULL_TREE.
8524    Set *STRICT_OVERFLOW_P to true if the canonicalization is only
8525    valid if signed overflow is undefined.  */
8526
8527 static tree
8528 maybe_canonicalize_comparison_1 (enum tree_code code, tree type,
8529                                  tree arg0, tree arg1,
8530                                  bool *strict_overflow_p)
8531 {
8532   enum tree_code code0 = TREE_CODE (arg0);
8533   tree t, cst0 = NULL_TREE;
8534   int sgn0;
8535   bool swap = false;
8536
8537   /* Match A +- CST code arg1 and CST code arg1.  */
8538   if (!(((code0 == MINUS_EXPR
8539           || code0 == PLUS_EXPR)
8540          && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8541         || code0 == INTEGER_CST))
8542     return NULL_TREE;
8543
8544   /* Identify the constant in arg0 and its sign.  */
8545   if (code0 == INTEGER_CST)
8546     cst0 = arg0;
8547   else
8548     cst0 = TREE_OPERAND (arg0, 1);
8549   sgn0 = tree_int_cst_sgn (cst0);
8550
8551   /* Overflowed constants and zero will cause problems.  */
8552   if (integer_zerop (cst0)
8553       || TREE_OVERFLOW (cst0))
8554     return NULL_TREE;
8555
8556   /* See if we can reduce the magnitude of the constant in
8557      arg0 by changing the comparison code.  */
8558   if (code0 == INTEGER_CST)
8559     {
8560       /* CST <= arg1  ->  CST-1 < arg1.  */
8561       if (code == LE_EXPR && sgn0 == 1)
8562         code = LT_EXPR;
8563       /* -CST < arg1  ->  -CST-1 <= arg1.  */
8564       else if (code == LT_EXPR && sgn0 == -1)
8565         code = LE_EXPR;
8566       /* CST > arg1  ->  CST-1 >= arg1.  */
8567       else if (code == GT_EXPR && sgn0 == 1)
8568         code = GE_EXPR;
8569       /* -CST >= arg1  ->  -CST-1 > arg1.  */
8570       else if (code == GE_EXPR && sgn0 == -1)
8571         code = GT_EXPR;
8572       else
8573         return NULL_TREE;
8574       /* arg1 code' CST' might be more canonical.  */
8575       swap = true;
8576     }
8577   else
8578     {
8579       /* A - CST < arg1  ->  A - CST-1 <= arg1.  */
8580       if (code == LT_EXPR
8581           && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8582         code = LE_EXPR;
8583       /* A + CST > arg1  ->  A + CST-1 >= arg1.  */
8584       else if (code == GT_EXPR
8585                && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8586         code = GE_EXPR;
8587       /* A + CST <= arg1  ->  A + CST-1 < arg1.  */
8588       else if (code == LE_EXPR
8589                && code0 == ((sgn0 == -1) ? MINUS_EXPR : PLUS_EXPR))
8590         code = LT_EXPR;
8591       /* A - CST >= arg1  ->  A - CST-1 > arg1.  */
8592       else if (code == GE_EXPR
8593                && code0 == ((sgn0 == -1) ? PLUS_EXPR : MINUS_EXPR))
8594         code = GT_EXPR;
8595       else
8596         return NULL_TREE;
8597       *strict_overflow_p = true;
8598     }
8599
8600   /* Now build the constant reduced in magnitude.  */
8601   t = int_const_binop (sgn0 == -1 ? PLUS_EXPR : MINUS_EXPR,
8602                        cst0, build_int_cst (TREE_TYPE (cst0), 1), 0);
8603   if (code0 != INTEGER_CST)
8604     t = fold_build2 (code0, TREE_TYPE (arg0), TREE_OPERAND (arg0, 0), t);
8605
8606   /* If swapping might yield to a more canonical form, do so.  */
8607   if (swap)
8608     return fold_build2 (swap_tree_comparison (code), type, arg1, t);
8609   else
8610     return fold_build2 (code, type, t, arg1);
8611 }
8612
8613 /* Canonicalize the comparison ARG0 CODE ARG1 with type TYPE with undefined
8614    overflow further.  Try to decrease the magnitude of constants involved
8615    by changing LE_EXPR and GE_EXPR to LT_EXPR and GT_EXPR or vice versa
8616    and put sole constants at the second argument position.
8617    Returns the canonicalized tree if changed, otherwise NULL_TREE.  */
8618
8619 static tree
8620 maybe_canonicalize_comparison (enum tree_code code, tree type,
8621                                tree arg0, tree arg1)
8622 {
8623   tree t;
8624   bool strict_overflow_p;
8625   const char * const warnmsg = G_("assuming signed overflow does not occur "
8626                                   "when reducing constant in comparison");
8627
8628   /* In principle pointers also have undefined overflow behavior,
8629      but that causes problems elsewhere.  */
8630   if (!TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8631       || POINTER_TYPE_P (TREE_TYPE (arg0)))
8632     return NULL_TREE;
8633
8634   /* Try canonicalization by simplifying arg0.  */
8635   strict_overflow_p = false;
8636   t = maybe_canonicalize_comparison_1 (code, type, arg0, arg1,
8637                                        &strict_overflow_p);
8638   if (t)
8639     {
8640       if (strict_overflow_p)
8641         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8642       return t;
8643     }
8644
8645   /* Try canonicalization by simplifying arg1 using the swapped
8646      comparison.  */
8647   code = swap_tree_comparison (code);
8648   strict_overflow_p = false;
8649   t = maybe_canonicalize_comparison_1 (code, type, arg1, arg0,
8650                                        &strict_overflow_p);
8651   if (t && strict_overflow_p)
8652     fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MAGNITUDE);
8653   return t;
8654 }
8655
8656 /* Subroutine of fold_binary.  This routine performs all of the
8657    transformations that are common to the equality/inequality
8658    operators (EQ_EXPR and NE_EXPR) and the ordering operators
8659    (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR).  Callers other than
8660    fold_binary should call fold_binary.  Fold a comparison with
8661    tree code CODE and type TYPE with operands OP0 and OP1.  Return
8662    the folded comparison or NULL_TREE.  */
8663
8664 static tree
8665 fold_comparison (enum tree_code code, tree type, tree op0, tree op1)
8666 {
8667   tree arg0, arg1, tem;
8668
8669   arg0 = op0;
8670   arg1 = op1;
8671
8672   STRIP_SIGN_NOPS (arg0);
8673   STRIP_SIGN_NOPS (arg1);
8674
8675   tem = fold_relational_const (code, type, arg0, arg1);
8676   if (tem != NULL_TREE)
8677     return tem;
8678
8679   /* If one arg is a real or integer constant, put it last.  */
8680   if (tree_swap_operands_p (arg0, arg1, true))
8681     return fold_build2 (swap_tree_comparison (code), type, op1, op0);
8682
8683   /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1.  */
8684   if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8685       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8686           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8687           && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
8688       && (TREE_CODE (arg1) == INTEGER_CST
8689           && !TREE_OVERFLOW (arg1)))
8690     {
8691       tree const1 = TREE_OPERAND (arg0, 1);
8692       tree const2 = arg1;
8693       tree variable = TREE_OPERAND (arg0, 0);
8694       tree lhs;
8695       int lhs_add;
8696       lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
8697
8698       lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
8699                          TREE_TYPE (arg1), const2, const1);
8700
8701       /* If the constant operation overflowed this can be
8702          simplified as a comparison against INT_MAX/INT_MIN.  */
8703       if (TREE_CODE (lhs) == INTEGER_CST
8704           && TREE_OVERFLOW (lhs))
8705         {
8706           int const1_sgn = tree_int_cst_sgn (const1);
8707           enum tree_code code2 = code;
8708
8709           /* Get the sign of the constant on the lhs if the
8710              operation were VARIABLE + CONST1.  */
8711           if (TREE_CODE (arg0) == MINUS_EXPR)
8712             const1_sgn = -const1_sgn;
8713
8714           /* The sign of the constant determines if we overflowed
8715              INT_MAX (const1_sgn == -1) or INT_MIN (const1_sgn == 1).
8716              Canonicalize to the INT_MIN overflow by swapping the comparison
8717              if necessary.  */
8718           if (const1_sgn == -1)
8719             code2 = swap_tree_comparison (code);
8720
8721           /* We now can look at the canonicalized case
8722                VARIABLE + 1  CODE2  INT_MIN
8723              and decide on the result.  */
8724           if (code2 == LT_EXPR
8725               || code2 == LE_EXPR
8726               || code2 == EQ_EXPR)
8727             return omit_one_operand (type, boolean_false_node, variable);
8728           else if (code2 == NE_EXPR
8729                    || code2 == GE_EXPR
8730                    || code2 == GT_EXPR)
8731             return omit_one_operand (type, boolean_true_node, variable);
8732         }
8733
8734       if (TREE_CODE (lhs) == TREE_CODE (arg1)
8735           && (TREE_CODE (lhs) != INTEGER_CST
8736               || !TREE_OVERFLOW (lhs)))
8737         {
8738           fold_overflow_warning (("assuming signed overflow does not occur "
8739                                   "when changing X +- C1 cmp C2 to "
8740                                   "X cmp C1 +- C2"),
8741                                  WARN_STRICT_OVERFLOW_COMPARISON);
8742           return fold_build2 (code, type, variable, lhs);
8743         }
8744     }
8745
8746   /* For comparisons of pointers we can decompose it to a compile time
8747      comparison of the base objects and the offsets into the object.
8748      This requires at least one operand being an ADDR_EXPR or a
8749      POINTER_PLUS_EXPR to do more than the operand_equal_p test below.  */
8750   if (POINTER_TYPE_P (TREE_TYPE (arg0))
8751       && (TREE_CODE (arg0) == ADDR_EXPR
8752           || TREE_CODE (arg1) == ADDR_EXPR
8753           || TREE_CODE (arg0) == POINTER_PLUS_EXPR
8754           || TREE_CODE (arg1) == POINTER_PLUS_EXPR))
8755     {
8756       tree base0, base1, offset0 = NULL_TREE, offset1 = NULL_TREE;
8757       HOST_WIDE_INT bitsize, bitpos0 = 0, bitpos1 = 0;
8758       enum machine_mode mode;
8759       int volatilep, unsignedp;
8760       bool indirect_base0 = false;
8761
8762       /* Get base and offset for the access.  Strip ADDR_EXPR for
8763          get_inner_reference, but put it back by stripping INDIRECT_REF
8764          off the base object if possible.  */
8765       base0 = arg0;
8766       if (TREE_CODE (arg0) == ADDR_EXPR)
8767         {
8768           base0 = get_inner_reference (TREE_OPERAND (arg0, 0),
8769                                        &bitsize, &bitpos0, &offset0, &mode,
8770                                        &unsignedp, &volatilep, false);
8771           if (TREE_CODE (base0) == INDIRECT_REF)
8772             base0 = TREE_OPERAND (base0, 0);
8773           else
8774             indirect_base0 = true;
8775         }
8776       else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
8777         {
8778           base0 = TREE_OPERAND (arg0, 0);
8779           offset0 = TREE_OPERAND (arg0, 1);
8780         }
8781
8782       base1 = arg1;
8783       if (TREE_CODE (arg1) == ADDR_EXPR)
8784         {
8785           base1 = get_inner_reference (TREE_OPERAND (arg1, 0),
8786                                        &bitsize, &bitpos1, &offset1, &mode,
8787                                        &unsignedp, &volatilep, false);
8788           /* We have to make sure to have an indirect/non-indirect base1
8789              just the same as we did for base0.  */
8790           if (TREE_CODE (base1) == INDIRECT_REF
8791               && !indirect_base0)
8792             base1 = TREE_OPERAND (base1, 0);
8793           else if (!indirect_base0)
8794             base1 = NULL_TREE;
8795         }
8796       else if (TREE_CODE (arg1) == POINTER_PLUS_EXPR)
8797         {
8798           base1 = TREE_OPERAND (arg1, 0);
8799           offset1 = TREE_OPERAND (arg1, 1);
8800         }
8801       else if (indirect_base0)
8802         base1 = NULL_TREE;
8803
8804       /* If we have equivalent bases we might be able to simplify.  */
8805       if (base0 && base1
8806           && operand_equal_p (base0, base1, 0))
8807         {
8808           /* We can fold this expression to a constant if the non-constant
8809              offset parts are equal.  */
8810           if (offset0 == offset1
8811               || (offset0 && offset1
8812                   && operand_equal_p (offset0, offset1, 0)))
8813             {
8814               switch (code)
8815                 {
8816                 case EQ_EXPR:
8817                   return build_int_cst (boolean_type_node, bitpos0 == bitpos1);
8818                 case NE_EXPR:
8819                   return build_int_cst (boolean_type_node, bitpos0 != bitpos1);
8820                 case LT_EXPR:
8821                   return build_int_cst (boolean_type_node, bitpos0 < bitpos1);
8822                 case LE_EXPR:
8823                   return build_int_cst (boolean_type_node, bitpos0 <= bitpos1);
8824                 case GE_EXPR:
8825                   return build_int_cst (boolean_type_node, bitpos0 >= bitpos1);
8826                 case GT_EXPR:
8827                   return build_int_cst (boolean_type_node, bitpos0 > bitpos1);
8828                 default:;
8829                 }
8830             }
8831           /* We can simplify the comparison to a comparison of the variable
8832              offset parts if the constant offset parts are equal.
8833              Be careful to use signed size type here because otherwise we
8834              mess with array offsets in the wrong way.  This is possible
8835              because pointer arithmetic is restricted to retain within an
8836              object and overflow on pointer differences is undefined as of
8837              6.5.6/8 and /9 with respect to the signed ptrdiff_t.  */
8838           else if (bitpos0 == bitpos1)
8839             {
8840               tree signed_size_type_node;
8841               signed_size_type_node = signed_type_for (size_type_node);
8842
8843               /* By converting to signed size type we cover middle-end pointer
8844                  arithmetic which operates on unsigned pointer types of size
8845                  type size and ARRAY_REF offsets which are properly sign or
8846                  zero extended from their type in case it is narrower than
8847                  size type.  */
8848               if (offset0 == NULL_TREE)
8849                 offset0 = build_int_cst (signed_size_type_node, 0);
8850               else
8851                 offset0 = fold_convert (signed_size_type_node, offset0);
8852               if (offset1 == NULL_TREE)
8853                 offset1 = build_int_cst (signed_size_type_node, 0);
8854               else
8855                 offset1 = fold_convert (signed_size_type_node, offset1);
8856
8857               return fold_build2 (code, type, offset0, offset1);
8858             }
8859         }
8860     }
8861
8862   /* Transform comparisons of the form X +- C1 CMP Y +- C2 to
8863      X CMP Y +- C2 +- C1 for signed X, Y.  This is valid if
8864      the resulting offset is smaller in absolute value than the
8865      original one.  */
8866   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8867       && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8868       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8869           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
8870       && (TREE_CODE (arg1) == PLUS_EXPR || TREE_CODE (arg1) == MINUS_EXPR)
8871       && (TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
8872           && !TREE_OVERFLOW (TREE_OPERAND (arg1, 1))))
8873     {
8874       tree const1 = TREE_OPERAND (arg0, 1);
8875       tree const2 = TREE_OPERAND (arg1, 1);
8876       tree variable1 = TREE_OPERAND (arg0, 0);
8877       tree variable2 = TREE_OPERAND (arg1, 0);
8878       tree cst;
8879       const char * const warnmsg = G_("assuming signed overflow does not "
8880                                       "occur when combining constants around "
8881                                       "a comparison");
8882
8883       /* Put the constant on the side where it doesn't overflow and is
8884          of lower absolute value than before.  */
8885       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
8886                              ? MINUS_EXPR : PLUS_EXPR,
8887                              const2, const1, 0);
8888       if (!TREE_OVERFLOW (cst)
8889           && tree_int_cst_compare (const2, cst) == tree_int_cst_sgn (const2))
8890         {
8891           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
8892           return fold_build2 (code, type,
8893                               variable1,
8894                               fold_build2 (TREE_CODE (arg1), TREE_TYPE (arg1),
8895                                            variable2, cst));
8896         }
8897
8898       cst = int_const_binop (TREE_CODE (arg0) == TREE_CODE (arg1)
8899                              ? MINUS_EXPR : PLUS_EXPR,
8900                              const1, const2, 0);
8901       if (!TREE_OVERFLOW (cst)
8902           && tree_int_cst_compare (const1, cst) == tree_int_cst_sgn (const1))
8903         {
8904           fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
8905           return fold_build2 (code, type,
8906                               fold_build2 (TREE_CODE (arg0), TREE_TYPE (arg0),
8907                                            variable1, cst),
8908                               variable2);
8909         }
8910     }
8911
8912   /* Transform comparisons of the form X * C1 CMP 0 to X CMP 0 in the
8913      signed arithmetic case.  That form is created by the compiler
8914      often enough for folding it to be of value.  One example is in
8915      computing loop trip counts after Operator Strength Reduction.  */
8916   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg0))
8917       && TREE_CODE (arg0) == MULT_EXPR
8918       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8919           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1)))
8920       && integer_zerop (arg1))
8921     {
8922       tree const1 = TREE_OPERAND (arg0, 1);
8923       tree const2 = arg1;                       /* zero */
8924       tree variable1 = TREE_OPERAND (arg0, 0);
8925       enum tree_code cmp_code = code;
8926
8927       gcc_assert (!integer_zerop (const1));
8928
8929       fold_overflow_warning (("assuming signed overflow does not occur when "
8930                               "eliminating multiplication in comparison "
8931                               "with zero"),
8932                              WARN_STRICT_OVERFLOW_COMPARISON);
8933
8934       /* If const1 is negative we swap the sense of the comparison.  */
8935       if (tree_int_cst_sgn (const1) < 0)
8936         cmp_code = swap_tree_comparison (cmp_code);
8937
8938       return fold_build2 (cmp_code, type, variable1, const2);
8939     }
8940
8941   tem = maybe_canonicalize_comparison (code, type, op0, op1);
8942   if (tem)
8943     return tem;
8944
8945   if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
8946     {
8947       tree targ0 = strip_float_extensions (arg0);
8948       tree targ1 = strip_float_extensions (arg1);
8949       tree newtype = TREE_TYPE (targ0);
8950
8951       if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8952         newtype = TREE_TYPE (targ1);
8953
8954       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8955       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8956         return fold_build2 (code, type, fold_convert (newtype, targ0),
8957                             fold_convert (newtype, targ1));
8958
8959       /* (-a) CMP (-b) -> b CMP a  */
8960       if (TREE_CODE (arg0) == NEGATE_EXPR
8961           && TREE_CODE (arg1) == NEGATE_EXPR)
8962         return fold_build2 (code, type, TREE_OPERAND (arg1, 0),
8963                             TREE_OPERAND (arg0, 0));
8964
8965       if (TREE_CODE (arg1) == REAL_CST)
8966         {
8967           REAL_VALUE_TYPE cst;
8968           cst = TREE_REAL_CST (arg1);
8969
8970           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
8971           if (TREE_CODE (arg0) == NEGATE_EXPR)
8972             return fold_build2 (swap_tree_comparison (code), type,
8973                                 TREE_OPERAND (arg0, 0),
8974                                 build_real (TREE_TYPE (arg1),
8975                                             REAL_VALUE_NEGATE (cst)));
8976
8977           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
8978           /* a CMP (-0) -> a CMP 0  */
8979           if (REAL_VALUE_MINUS_ZERO (cst))
8980             return fold_build2 (code, type, arg0,
8981                                 build_real (TREE_TYPE (arg1), dconst0));
8982
8983           /* x != NaN is always true, other ops are always false.  */
8984           if (REAL_VALUE_ISNAN (cst)
8985               && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
8986             {
8987               tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
8988               return omit_one_operand (type, tem, arg0);
8989             }
8990
8991           /* Fold comparisons against infinity.  */
8992           if (REAL_VALUE_ISINF (cst))
8993             {
8994               tem = fold_inf_compare (code, type, arg0, arg1);
8995               if (tem != NULL_TREE)
8996                 return tem;
8997             }
8998         }
8999
9000       /* If this is a comparison of a real constant with a PLUS_EXPR
9001          or a MINUS_EXPR of a real constant, we can convert it into a
9002          comparison with a revised real constant as long as no overflow
9003          occurs when unsafe_math_optimizations are enabled.  */
9004       if (flag_unsafe_math_optimizations
9005           && TREE_CODE (arg1) == REAL_CST
9006           && (TREE_CODE (arg0) == PLUS_EXPR
9007               || TREE_CODE (arg0) == MINUS_EXPR)
9008           && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
9009           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9010                                       ? MINUS_EXPR : PLUS_EXPR,
9011                                       arg1, TREE_OPERAND (arg0, 1), 0))
9012           && !TREE_OVERFLOW (tem))
9013         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
9014
9015       /* Likewise, we can simplify a comparison of a real constant with
9016          a MINUS_EXPR whose first operand is also a real constant, i.e.
9017          (c1 - x) < c2 becomes x > c1-c2.  Reordering is allowed on 
9018          floating-point types only if -fassociative-math is set.  */
9019       if (flag_associative_math
9020           && TREE_CODE (arg1) == REAL_CST
9021           && TREE_CODE (arg0) == MINUS_EXPR
9022           && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
9023           && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
9024                                       arg1, 0))
9025           && !TREE_OVERFLOW (tem))
9026         return fold_build2 (swap_tree_comparison (code), type,
9027                             TREE_OPERAND (arg0, 1), tem);
9028
9029       /* Fold comparisons against built-in math functions.  */
9030       if (TREE_CODE (arg1) == REAL_CST
9031           && flag_unsafe_math_optimizations
9032           && ! flag_errno_math)
9033         {
9034           enum built_in_function fcode = builtin_mathfn_code (arg0);
9035
9036           if (fcode != END_BUILTINS)
9037             {
9038               tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
9039               if (tem != NULL_TREE)
9040                 return tem;
9041             }
9042         }
9043     }
9044
9045   if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
9046       && (TREE_CODE (arg0) == NOP_EXPR
9047           || TREE_CODE (arg0) == CONVERT_EXPR))
9048     {
9049       /* If we are widening one operand of an integer comparison,
9050          see if the other operand is similarly being widened.  Perhaps we
9051          can do the comparison in the narrower type.  */
9052       tem = fold_widened_comparison (code, type, arg0, arg1);
9053       if (tem)
9054         return tem;
9055
9056       /* Or if we are changing signedness.  */
9057       tem = fold_sign_changed_comparison (code, type, arg0, arg1);
9058       if (tem)
9059         return tem;
9060     }
9061
9062   /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9063      constant, we can simplify it.  */
9064   if (TREE_CODE (arg1) == INTEGER_CST
9065       && (TREE_CODE (arg0) == MIN_EXPR
9066           || TREE_CODE (arg0) == MAX_EXPR)
9067       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9068     {
9069       tem = optimize_minmax_comparison (code, type, op0, op1);
9070       if (tem)
9071         return tem;
9072     }
9073
9074   /* Simplify comparison of something with itself.  (For IEEE
9075      floating-point, we can only do some of these simplifications.)  */
9076   if (operand_equal_p (arg0, arg1, 0))
9077     {
9078       switch (code)
9079         {
9080         case EQ_EXPR:
9081           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9082               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9083             return constant_boolean_node (1, type);
9084           break;
9085
9086         case GE_EXPR:
9087         case LE_EXPR:
9088           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9089               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9090             return constant_boolean_node (1, type);
9091           return fold_build2 (EQ_EXPR, type, arg0, arg1);
9092
9093         case NE_EXPR:
9094           /* For NE, we can only do this simplification if integer
9095              or we don't honor IEEE floating point NaNs.  */
9096           if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9097               && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9098             break;
9099           /* ... fall through ...  */
9100         case GT_EXPR:
9101         case LT_EXPR:
9102           return constant_boolean_node (0, type);
9103         default:
9104           gcc_unreachable ();
9105         }
9106     }
9107
9108   /* If we are comparing an expression that just has comparisons
9109      of two integer values, arithmetic expressions of those comparisons,
9110      and constants, we can simplify it.  There are only three cases
9111      to check: the two values can either be equal, the first can be
9112      greater, or the second can be greater.  Fold the expression for
9113      those three values.  Since each value must be 0 or 1, we have
9114      eight possibilities, each of which corresponds to the constant 0
9115      or 1 or one of the six possible comparisons.
9116
9117      This handles common cases like (a > b) == 0 but also handles
9118      expressions like  ((x > y) - (y > x)) > 0, which supposedly
9119      occur in macroized code.  */
9120
9121   if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9122     {
9123       tree cval1 = 0, cval2 = 0;
9124       int save_p = 0;
9125
9126       if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9127           /* Don't handle degenerate cases here; they should already
9128              have been handled anyway.  */
9129           && cval1 != 0 && cval2 != 0
9130           && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9131           && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9132           && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9133           && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9134           && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9135           && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9136                                 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9137         {
9138           tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9139           tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9140
9141           /* We can't just pass T to eval_subst in case cval1 or cval2
9142              was the same as ARG1.  */
9143
9144           tree high_result
9145                 = fold_build2 (code, type,
9146                                eval_subst (arg0, cval1, maxval,
9147                                            cval2, minval),
9148                                arg1);
9149           tree equal_result
9150                 = fold_build2 (code, type,
9151                                eval_subst (arg0, cval1, maxval,
9152                                            cval2, maxval),
9153                                arg1);
9154           tree low_result
9155                 = fold_build2 (code, type,
9156                                eval_subst (arg0, cval1, minval,
9157                                            cval2, maxval),
9158                                arg1);
9159
9160           /* All three of these results should be 0 or 1.  Confirm they are.
9161              Then use those values to select the proper code to use.  */
9162
9163           if (TREE_CODE (high_result) == INTEGER_CST
9164               && TREE_CODE (equal_result) == INTEGER_CST
9165               && TREE_CODE (low_result) == INTEGER_CST)
9166             {
9167               /* Make a 3-bit mask with the high-order bit being the
9168                  value for `>', the next for '=', and the low for '<'.  */
9169               switch ((integer_onep (high_result) * 4)
9170                       + (integer_onep (equal_result) * 2)
9171                       + integer_onep (low_result))
9172                 {
9173                 case 0:
9174                   /* Always false.  */
9175                   return omit_one_operand (type, integer_zero_node, arg0);
9176                 case 1:
9177                   code = LT_EXPR;
9178                   break;
9179                 case 2:
9180                   code = EQ_EXPR;
9181                   break;
9182                 case 3:
9183                   code = LE_EXPR;
9184                   break;
9185                 case 4:
9186                   code = GT_EXPR;
9187                   break;
9188                 case 5:
9189                   code = NE_EXPR;
9190                   break;
9191                 case 6:
9192                   code = GE_EXPR;
9193                   break;
9194                 case 7:
9195                   /* Always true.  */
9196                   return omit_one_operand (type, integer_one_node, arg0);
9197                 }
9198
9199               if (save_p)
9200                 return save_expr (build2 (code, type, cval1, cval2));
9201               return fold_build2 (code, type, cval1, cval2);
9202             }
9203         }
9204     }
9205
9206   /* Fold a comparison of the address of COMPONENT_REFs with the same
9207      type and component to a comparison of the address of the base
9208      object.  In short, &x->a OP &y->a to x OP y and
9209      &x->a OP &y.a to x OP &y  */
9210   if (TREE_CODE (arg0) == ADDR_EXPR
9211       && TREE_CODE (TREE_OPERAND (arg0, 0)) == COMPONENT_REF
9212       && TREE_CODE (arg1) == ADDR_EXPR
9213       && TREE_CODE (TREE_OPERAND (arg1, 0)) == COMPONENT_REF)
9214     {
9215       tree cref0 = TREE_OPERAND (arg0, 0);
9216       tree cref1 = TREE_OPERAND (arg1, 0);
9217       if (TREE_OPERAND (cref0, 1) == TREE_OPERAND (cref1, 1))
9218         {
9219           tree op0 = TREE_OPERAND (cref0, 0);
9220           tree op1 = TREE_OPERAND (cref1, 0);
9221           return fold_build2 (code, type,
9222                               fold_addr_expr (op0),
9223                               fold_addr_expr (op1));
9224         }
9225     }
9226
9227   /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9228      into a single range test.  */
9229   if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9230        || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9231       && TREE_CODE (arg1) == INTEGER_CST
9232       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9233       && !integer_zerop (TREE_OPERAND (arg0, 1))
9234       && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9235       && !TREE_OVERFLOW (arg1))
9236     {
9237       tem = fold_div_compare (code, type, arg0, arg1);
9238       if (tem != NULL_TREE)
9239         return tem;
9240     }
9241
9242   /* Fold ~X op ~Y as Y op X.  */
9243   if (TREE_CODE (arg0) == BIT_NOT_EXPR
9244       && TREE_CODE (arg1) == BIT_NOT_EXPR)
9245     {
9246       tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9247       return fold_build2 (code, type,
9248                           fold_convert (cmp_type, TREE_OPERAND (arg1, 0)),
9249                           TREE_OPERAND (arg0, 0));
9250     }
9251
9252   /* Fold ~X op C as X op' ~C, where op' is the swapped comparison.  */
9253   if (TREE_CODE (arg0) == BIT_NOT_EXPR
9254       && TREE_CODE (arg1) == INTEGER_CST)
9255     {
9256       tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
9257       return fold_build2 (swap_tree_comparison (code), type,
9258                           TREE_OPERAND (arg0, 0),
9259                           fold_build1 (BIT_NOT_EXPR, cmp_type,
9260                                        fold_convert (cmp_type, arg1)));
9261     }
9262
9263   return NULL_TREE;
9264 }
9265
9266
9267 /* Subroutine of fold_binary.  Optimize complex multiplications of the
9268    form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2).  The
9269    argument EXPR represents the expression "z" of type TYPE.  */
9270
9271 static tree
9272 fold_mult_zconjz (tree type, tree expr)
9273 {
9274   tree itype = TREE_TYPE (type);
9275   tree rpart, ipart, tem;
9276
9277   if (TREE_CODE (expr) == COMPLEX_EXPR)
9278     {
9279       rpart = TREE_OPERAND (expr, 0);
9280       ipart = TREE_OPERAND (expr, 1);
9281     }
9282   else if (TREE_CODE (expr) == COMPLEX_CST)
9283     {
9284       rpart = TREE_REALPART (expr);
9285       ipart = TREE_IMAGPART (expr);
9286     }
9287   else
9288     {
9289       expr = save_expr (expr);
9290       rpart = fold_build1 (REALPART_EXPR, itype, expr);
9291       ipart = fold_build1 (IMAGPART_EXPR, itype, expr);
9292     }
9293
9294   rpart = save_expr (rpart);
9295   ipart = save_expr (ipart);
9296   tem = fold_build2 (PLUS_EXPR, itype,
9297                      fold_build2 (MULT_EXPR, itype, rpart, rpart),
9298                      fold_build2 (MULT_EXPR, itype, ipart, ipart));
9299   return fold_build2 (COMPLEX_EXPR, type, tem,
9300                       fold_convert (itype, integer_zero_node));
9301 }
9302
9303
9304 /* Subroutine of fold_binary.  If P is the value of EXPR, computes
9305    power-of-two M and (arbitrary) N such that M divides (P-N).  This condition
9306    guarantees that P and N have the same least significant log2(M) bits.
9307    N is not otherwise constrained.  In particular, N is not normalized to
9308    0 <= N < M as is common.  In general, the precise value of P is unknown.
9309    M is chosen as large as possible such that constant N can be determined.
9310
9311    Returns M and sets *RESIDUE to N.  */
9312
9313 static unsigned HOST_WIDE_INT
9314 get_pointer_modulus_and_residue (tree expr, unsigned HOST_WIDE_INT *residue)
9315 {
9316   enum tree_code code;
9317
9318   *residue = 0;
9319
9320   code = TREE_CODE (expr);
9321   if (code == ADDR_EXPR)
9322     {
9323       expr = TREE_OPERAND (expr, 0);
9324       if (handled_component_p (expr))
9325         {
9326           HOST_WIDE_INT bitsize, bitpos;
9327           tree offset;
9328           enum machine_mode mode;
9329           int unsignedp, volatilep;
9330
9331           expr = get_inner_reference (expr, &bitsize, &bitpos, &offset,
9332                                       &mode, &unsignedp, &volatilep, false);
9333           *residue = bitpos / BITS_PER_UNIT;
9334           if (offset)
9335             {
9336               if (TREE_CODE (offset) == INTEGER_CST)
9337                 *residue += TREE_INT_CST_LOW (offset);
9338               else
9339                 /* We don't handle more complicated offset expressions.  */
9340                 return 1;
9341             }
9342         }
9343
9344       if (DECL_P (expr))
9345         return DECL_ALIGN_UNIT (expr);
9346     }
9347   else if (code == POINTER_PLUS_EXPR)
9348     {
9349       tree op0, op1;
9350       unsigned HOST_WIDE_INT modulus;
9351       enum tree_code inner_code;
9352       
9353       op0 = TREE_OPERAND (expr, 0);
9354       STRIP_NOPS (op0);
9355       modulus = get_pointer_modulus_and_residue (op0, residue);
9356
9357       op1 = TREE_OPERAND (expr, 1);
9358       STRIP_NOPS (op1);
9359       inner_code = TREE_CODE (op1);
9360       if (inner_code == INTEGER_CST)
9361         {
9362           *residue += TREE_INT_CST_LOW (op1);
9363           return modulus;
9364         }
9365       else if (inner_code == MULT_EXPR)
9366         {
9367           op1 = TREE_OPERAND (op1, 1);
9368           if (TREE_CODE (op1) == INTEGER_CST)
9369             {
9370               unsigned HOST_WIDE_INT align;
9371               
9372               /* Compute the greatest power-of-2 divisor of op1.  */
9373               align = TREE_INT_CST_LOW (op1);
9374               align &= -align;
9375
9376               /* If align is non-zero and less than *modulus, replace
9377                  *modulus with align., If align is 0, then either op1 is 0
9378                  or the greatest power-of-2 divisor of op1 doesn't fit in an
9379                  unsigned HOST_WIDE_INT.  In either case, no additional
9380                  constraint is imposed.  */
9381               if (align)
9382                 modulus = MIN (modulus, align);
9383
9384               return modulus;
9385             }
9386         }
9387     }
9388
9389     /* If we get here, we were unable to determine anything useful about the
9390        expression.  */
9391     return 1;
9392 }
9393
9394
9395 /* Fold a binary expression of code CODE and type TYPE with operands
9396    OP0 and OP1.  Return the folded expression if folding is
9397    successful.  Otherwise, return NULL_TREE.  */
9398
9399 tree
9400 fold_binary (enum tree_code code, tree type, tree op0, tree op1)
9401 {
9402   enum tree_code_class kind = TREE_CODE_CLASS (code);
9403   tree arg0, arg1, tem;
9404   tree t1 = NULL_TREE;
9405   bool strict_overflow_p;
9406
9407   gcc_assert ((IS_EXPR_CODE_CLASS (kind)
9408                || IS_GIMPLE_STMT_CODE_CLASS (kind))
9409               && TREE_CODE_LENGTH (code) == 2
9410               && op0 != NULL_TREE
9411               && op1 != NULL_TREE);
9412
9413   arg0 = op0;
9414   arg1 = op1;
9415
9416   /* Strip any conversions that don't change the mode.  This is
9417      safe for every expression, except for a comparison expression
9418      because its signedness is derived from its operands.  So, in
9419      the latter case, only strip conversions that don't change the
9420      signedness.
9421
9422      Note that this is done as an internal manipulation within the
9423      constant folder, in order to find the simplest representation
9424      of the arguments so that their form can be studied.  In any
9425      cases, the appropriate type conversions should be put back in
9426      the tree that will get out of the constant folder.  */
9427
9428   if (kind == tcc_comparison)
9429     {
9430       STRIP_SIGN_NOPS (arg0);
9431       STRIP_SIGN_NOPS (arg1);
9432     }
9433   else
9434     {
9435       STRIP_NOPS (arg0);
9436       STRIP_NOPS (arg1);
9437     }
9438
9439   /* Note that TREE_CONSTANT isn't enough: static var addresses are
9440      constant but we can't do arithmetic on them.  */
9441   if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9442       || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
9443       || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == FIXED_CST)
9444       || (TREE_CODE (arg0) == FIXED_CST && TREE_CODE (arg1) == INTEGER_CST)
9445       || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
9446       || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST))
9447     {
9448       if (kind == tcc_binary)
9449         {
9450           /* Make sure type and arg0 have the same saturating flag.  */
9451           gcc_assert (TYPE_SATURATING (type)
9452                       == TYPE_SATURATING (TREE_TYPE (arg0)));
9453           tem = const_binop (code, arg0, arg1, 0);
9454         }
9455       else if (kind == tcc_comparison)
9456         tem = fold_relational_const (code, type, arg0, arg1);
9457       else
9458         tem = NULL_TREE;
9459
9460       if (tem != NULL_TREE)
9461         {
9462           if (TREE_TYPE (tem) != type)
9463             tem = fold_convert (type, tem);
9464           return tem;
9465         }
9466     }
9467
9468   /* If this is a commutative operation, and ARG0 is a constant, move it
9469      to ARG1 to reduce the number of tests below.  */
9470   if (commutative_tree_code (code)
9471       && tree_swap_operands_p (arg0, arg1, true))
9472     return fold_build2 (code, type, op1, op0);
9473
9474   /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
9475
9476      First check for cases where an arithmetic operation is applied to a
9477      compound, conditional, or comparison operation.  Push the arithmetic
9478      operation inside the compound or conditional to see if any folding
9479      can then be done.  Convert comparison to conditional for this purpose.
9480      The also optimizes non-constant cases that used to be done in
9481      expand_expr.
9482
9483      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
9484      one of the operands is a comparison and the other is a comparison, a
9485      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
9486      code below would make the expression more complex.  Change it to a
9487      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
9488      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
9489
9490   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
9491        || code == EQ_EXPR || code == NE_EXPR)
9492       && ((truth_value_p (TREE_CODE (arg0))
9493            && (truth_value_p (TREE_CODE (arg1))
9494                || (TREE_CODE (arg1) == BIT_AND_EXPR
9495                    && integer_onep (TREE_OPERAND (arg1, 1)))))
9496           || (truth_value_p (TREE_CODE (arg1))
9497               && (truth_value_p (TREE_CODE (arg0))
9498                   || (TREE_CODE (arg0) == BIT_AND_EXPR
9499                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
9500     {
9501       tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
9502                          : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
9503                          : TRUTH_XOR_EXPR,
9504                          boolean_type_node,
9505                          fold_convert (boolean_type_node, arg0),
9506                          fold_convert (boolean_type_node, arg1));
9507
9508       if (code == EQ_EXPR)
9509         tem = invert_truthvalue (tem);
9510
9511       return fold_convert (type, tem);
9512     }
9513
9514   if (TREE_CODE_CLASS (code) == tcc_binary
9515       || TREE_CODE_CLASS (code) == tcc_comparison)
9516     {
9517       if (TREE_CODE (arg0) == COMPOUND_EXPR)
9518         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
9519                        fold_build2 (code, type,
9520                                     fold_convert (TREE_TYPE (op0),
9521                                                   TREE_OPERAND (arg0, 1)),
9522                                     op1));
9523       if (TREE_CODE (arg1) == COMPOUND_EXPR
9524           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9525         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
9526                        fold_build2 (code, type, op0,
9527                                     fold_convert (TREE_TYPE (op1),
9528                                                   TREE_OPERAND (arg1, 1))));
9529
9530       if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
9531         {
9532           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
9533                                                      arg0, arg1, 
9534                                                      /*cond_first_p=*/1);
9535           if (tem != NULL_TREE)
9536             return tem;
9537         }
9538
9539       if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
9540         {
9541           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
9542                                                      arg1, arg0, 
9543                                                      /*cond_first_p=*/0);
9544           if (tem != NULL_TREE)
9545             return tem;
9546         }
9547     }
9548
9549   switch (code)
9550     {
9551     case POINTER_PLUS_EXPR:
9552       /* 0 +p index -> (type)index */
9553       if (integer_zerop (arg0))
9554         return non_lvalue (fold_convert (type, arg1));
9555
9556       /* PTR +p 0 -> PTR */
9557       if (integer_zerop (arg1))
9558         return non_lvalue (fold_convert (type, arg0));
9559
9560       /* INT +p INT -> (PTR)(INT + INT).  Stripping types allows for this. */
9561       if (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9562            && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9563         return fold_convert (type, fold_build2 (PLUS_EXPR, sizetype,
9564                                                 fold_convert (sizetype, arg1),
9565                                                 fold_convert (sizetype, arg0)));
9566
9567       /* index +p PTR -> PTR +p index */
9568       if (POINTER_TYPE_P (TREE_TYPE (arg1))
9569           && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9570         return fold_build2 (POINTER_PLUS_EXPR, type,
9571                             fold_convert (type, arg1),
9572                             fold_convert (sizetype, arg0));
9573
9574       /* (PTR +p B) +p A -> PTR +p (B + A) */
9575       if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
9576         {
9577           tree inner;
9578           tree arg01 = fold_convert (sizetype, TREE_OPERAND (arg0, 1));
9579           tree arg00 = TREE_OPERAND (arg0, 0);
9580           inner = fold_build2 (PLUS_EXPR, sizetype,
9581                                arg01, fold_convert (sizetype, arg1));
9582           return fold_convert (type,
9583                                fold_build2 (POINTER_PLUS_EXPR,
9584                                             TREE_TYPE (arg00), arg00, inner));
9585         }
9586
9587       /* PTR_CST +p CST -> CST1 */
9588       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
9589         return fold_build2 (PLUS_EXPR, type, arg0, fold_convert (type, arg1));
9590
9591      /* Try replacing &a[i1] +p c * i2 with &a[i1 + i2], if c is step
9592         of the array.  Loop optimizer sometimes produce this type of
9593         expressions.  */
9594       if (TREE_CODE (arg0) == ADDR_EXPR)
9595         {
9596           tem = try_move_mult_to_index (arg0, fold_convert (sizetype, arg1));
9597           if (tem)
9598             return fold_convert (type, tem);
9599         }
9600
9601       return NULL_TREE;
9602
9603     case PLUS_EXPR:
9604       /* PTR + INT -> (INT)(PTR p+ INT) */
9605       if (POINTER_TYPE_P (TREE_TYPE (arg0))
9606           && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
9607         return fold_convert (type, fold_build2 (POINTER_PLUS_EXPR,
9608                                                 TREE_TYPE (arg0),
9609                                                 arg0,
9610                                                 fold_convert (sizetype, arg1)));
9611       /* INT + PTR -> (INT)(PTR p+ INT) */
9612       if (POINTER_TYPE_P (TREE_TYPE (arg1))
9613           && INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
9614         return fold_convert (type, fold_build2 (POINTER_PLUS_EXPR,
9615                                                 TREE_TYPE (arg1),
9616                                                 arg1,
9617                                                 fold_convert (sizetype, arg0)));
9618       /* A + (-B) -> A - B */
9619       if (TREE_CODE (arg1) == NEGATE_EXPR)
9620         return fold_build2 (MINUS_EXPR, type,
9621                             fold_convert (type, arg0),
9622                             fold_convert (type, TREE_OPERAND (arg1, 0)));
9623       /* (-A) + B -> B - A */
9624       if (TREE_CODE (arg0) == NEGATE_EXPR
9625           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
9626         return fold_build2 (MINUS_EXPR, type,
9627                             fold_convert (type, arg1),
9628                             fold_convert (type, TREE_OPERAND (arg0, 0)));
9629
9630       if (INTEGRAL_TYPE_P (type))
9631         {
9632           /* Convert ~A + 1 to -A.  */
9633           if (TREE_CODE (arg0) == BIT_NOT_EXPR
9634               && integer_onep (arg1))
9635             return fold_build1 (NEGATE_EXPR, type, TREE_OPERAND (arg0, 0));
9636
9637           /* ~X + X is -1.  */
9638           if (TREE_CODE (arg0) == BIT_NOT_EXPR
9639               && !TYPE_OVERFLOW_TRAPS (type))
9640             {
9641               tree tem = TREE_OPERAND (arg0, 0);
9642
9643               STRIP_NOPS (tem);
9644               if (operand_equal_p (tem, arg1, 0))
9645                 {
9646                   t1 = build_int_cst_type (type, -1);
9647                   return omit_one_operand (type, t1, arg1);
9648                 }
9649             }
9650
9651           /* X + ~X is -1.  */
9652           if (TREE_CODE (arg1) == BIT_NOT_EXPR
9653               && !TYPE_OVERFLOW_TRAPS (type))
9654             {
9655               tree tem = TREE_OPERAND (arg1, 0);
9656
9657               STRIP_NOPS (tem);
9658               if (operand_equal_p (arg0, tem, 0))
9659                 {
9660                   t1 = build_int_cst_type (type, -1);
9661                   return omit_one_operand (type, t1, arg0);
9662                 }
9663             }
9664
9665           /* X + (X / CST) * -CST is X % CST.  */
9666           if (TREE_CODE (arg1) == MULT_EXPR
9667               && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
9668               && operand_equal_p (arg0,
9669                                   TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0))
9670             {
9671               tree cst0 = TREE_OPERAND (TREE_OPERAND (arg1, 0), 1);
9672               tree cst1 = TREE_OPERAND (arg1, 1);
9673               tree sum = fold_binary (PLUS_EXPR, TREE_TYPE (cst1), cst1, cst0);
9674               if (sum && integer_zerop (sum))
9675                 return fold_convert (type,
9676                                      fold_build2 (TRUNC_MOD_EXPR,
9677                                                   TREE_TYPE (arg0), arg0, cst0));
9678             }
9679         }
9680
9681       /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the
9682          same or one.  Make sure type is not saturating.
9683          fold_plusminus_mult_expr will re-associate.  */
9684       if ((TREE_CODE (arg0) == MULT_EXPR
9685            || TREE_CODE (arg1) == MULT_EXPR)
9686           && !TYPE_SATURATING (type)
9687           && (!FLOAT_TYPE_P (type) || flag_associative_math))
9688         {
9689           tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
9690           if (tem)
9691             return tem;
9692         }
9693
9694       if (! FLOAT_TYPE_P (type))
9695         {
9696           if (integer_zerop (arg1))
9697             return non_lvalue (fold_convert (type, arg0));
9698
9699           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
9700              with a constant, and the two constants have no bits in common,
9701              we should treat this as a BIT_IOR_EXPR since this may produce more
9702              simplifications.  */
9703           if (TREE_CODE (arg0) == BIT_AND_EXPR
9704               && TREE_CODE (arg1) == BIT_AND_EXPR
9705               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9706               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9707               && integer_zerop (const_binop (BIT_AND_EXPR,
9708                                              TREE_OPERAND (arg0, 1),
9709                                              TREE_OPERAND (arg1, 1), 0)))
9710             {
9711               code = BIT_IOR_EXPR;
9712               goto bit_ior;
9713             }
9714
9715           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
9716              (plus (plus (mult) (mult)) (foo)) so that we can
9717              take advantage of the factoring cases below.  */
9718           if (((TREE_CODE (arg0) == PLUS_EXPR
9719                 || TREE_CODE (arg0) == MINUS_EXPR)
9720                && TREE_CODE (arg1) == MULT_EXPR)
9721               || ((TREE_CODE (arg1) == PLUS_EXPR
9722                    || TREE_CODE (arg1) == MINUS_EXPR)
9723                   && TREE_CODE (arg0) == MULT_EXPR))
9724             {
9725               tree parg0, parg1, parg, marg;
9726               enum tree_code pcode;
9727
9728               if (TREE_CODE (arg1) == MULT_EXPR)
9729                 parg = arg0, marg = arg1;
9730               else
9731                 parg = arg1, marg = arg0;
9732               pcode = TREE_CODE (parg);
9733               parg0 = TREE_OPERAND (parg, 0);
9734               parg1 = TREE_OPERAND (parg, 1);
9735               STRIP_NOPS (parg0);
9736               STRIP_NOPS (parg1);
9737
9738               if (TREE_CODE (parg0) == MULT_EXPR
9739                   && TREE_CODE (parg1) != MULT_EXPR)
9740                 return fold_build2 (pcode, type,
9741                                     fold_build2 (PLUS_EXPR, type,
9742                                                  fold_convert (type, parg0),
9743                                                  fold_convert (type, marg)),
9744                                     fold_convert (type, parg1));
9745               if (TREE_CODE (parg0) != MULT_EXPR
9746                   && TREE_CODE (parg1) == MULT_EXPR)
9747                 return fold_build2 (PLUS_EXPR, type,
9748                                     fold_convert (type, parg0),
9749                                     fold_build2 (pcode, type,
9750                                                  fold_convert (type, marg),
9751                                                  fold_convert (type,
9752                                                                parg1)));
9753             }
9754         }
9755       else
9756         {
9757           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
9758           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
9759             return non_lvalue (fold_convert (type, arg0));
9760
9761           /* Likewise if the operands are reversed.  */
9762           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
9763             return non_lvalue (fold_convert (type, arg1));
9764
9765           /* Convert X + -C into X - C.  */
9766           if (TREE_CODE (arg1) == REAL_CST
9767               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
9768             {
9769               tem = fold_negate_const (arg1, type);
9770               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
9771                 return fold_build2 (MINUS_EXPR, type,
9772                                     fold_convert (type, arg0),
9773                                     fold_convert (type, tem));
9774             }
9775
9776           /* Fold __complex__ ( x, 0 ) + __complex__ ( 0, y )
9777              to __complex__ ( x, y ).  This is not the same for SNaNs or
9778              if signed zeros are involved.  */
9779           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9780               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
9781               && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
9782             {
9783               tree rtype = TREE_TYPE (TREE_TYPE (arg0));
9784               tree arg0r = fold_unary (REALPART_EXPR, rtype, arg0);
9785               tree arg0i = fold_unary (IMAGPART_EXPR, rtype, arg0);
9786               bool arg0rz = false, arg0iz = false;
9787               if ((arg0r && (arg0rz = real_zerop (arg0r)))
9788                   || (arg0i && (arg0iz = real_zerop (arg0i))))
9789                 {
9790                   tree arg1r = fold_unary (REALPART_EXPR, rtype, arg1);
9791                   tree arg1i = fold_unary (IMAGPART_EXPR, rtype, arg1);
9792                   if (arg0rz && arg1i && real_zerop (arg1i))
9793                     {
9794                       tree rp = arg1r ? arg1r
9795                                   : build1 (REALPART_EXPR, rtype, arg1);
9796                       tree ip = arg0i ? arg0i
9797                                   : build1 (IMAGPART_EXPR, rtype, arg0);
9798                       return fold_build2 (COMPLEX_EXPR, type, rp, ip);
9799                     }
9800                   else if (arg0iz && arg1r && real_zerop (arg1r))
9801                     {
9802                       tree rp = arg0r ? arg0r
9803                                   : build1 (REALPART_EXPR, rtype, arg0);
9804                       tree ip = arg1i ? arg1i
9805                                   : build1 (IMAGPART_EXPR, rtype, arg1);
9806                       return fold_build2 (COMPLEX_EXPR, type, rp, ip);
9807                     }
9808                 }
9809             }
9810
9811           if (flag_unsafe_math_optimizations
9812               && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
9813               && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
9814               && (tem = distribute_real_division (code, type, arg0, arg1)))
9815             return tem;
9816
9817           /* Convert x+x into x*2.0.  */
9818           if (operand_equal_p (arg0, arg1, 0)
9819               && SCALAR_FLOAT_TYPE_P (type))
9820             return fold_build2 (MULT_EXPR, type, arg0,
9821                                 build_real (type, dconst2));
9822
9823           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.  
9824              We associate floats only if the user has specified
9825              -fassociative-math.  */
9826           if (flag_associative_math
9827               && TREE_CODE (arg1) == PLUS_EXPR
9828               && TREE_CODE (arg0) != MULT_EXPR)
9829             {
9830               tree tree10 = TREE_OPERAND (arg1, 0);
9831               tree tree11 = TREE_OPERAND (arg1, 1);
9832               if (TREE_CODE (tree11) == MULT_EXPR
9833                   && TREE_CODE (tree10) == MULT_EXPR)
9834                 {
9835                   tree tree0;
9836                   tree0 = fold_build2 (PLUS_EXPR, type, arg0, tree10);
9837                   return fold_build2 (PLUS_EXPR, type, tree0, tree11);
9838                 }
9839             }
9840           /* Convert (b*c + d*e) + a into b*c + (d*e +a).  
9841              We associate floats only if the user has specified
9842              -fassociative-math.  */
9843           if (flag_associative_math
9844               && TREE_CODE (arg0) == PLUS_EXPR
9845               && TREE_CODE (arg1) != MULT_EXPR)
9846             {
9847               tree tree00 = TREE_OPERAND (arg0, 0);
9848               tree tree01 = TREE_OPERAND (arg0, 1);
9849               if (TREE_CODE (tree01) == MULT_EXPR
9850                   && TREE_CODE (tree00) == MULT_EXPR)
9851                 {
9852                   tree tree0;
9853                   tree0 = fold_build2 (PLUS_EXPR, type, tree01, arg1);
9854                   return fold_build2 (PLUS_EXPR, type, tree00, tree0);
9855                 }
9856             }
9857         }
9858
9859      bit_rotate:
9860       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
9861          is a rotate of A by C1 bits.  */
9862       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
9863          is a rotate of A by B bits.  */
9864       {
9865         enum tree_code code0, code1;
9866         code0 = TREE_CODE (arg0);
9867         code1 = TREE_CODE (arg1);
9868         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
9869              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
9870             && operand_equal_p (TREE_OPERAND (arg0, 0),
9871                                 TREE_OPERAND (arg1, 0), 0)
9872             && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
9873           {
9874             tree tree01, tree11;
9875             enum tree_code code01, code11;
9876
9877             tree01 = TREE_OPERAND (arg0, 1);
9878             tree11 = TREE_OPERAND (arg1, 1);
9879             STRIP_NOPS (tree01);
9880             STRIP_NOPS (tree11);
9881             code01 = TREE_CODE (tree01);
9882             code11 = TREE_CODE (tree11);
9883             if (code01 == INTEGER_CST
9884                 && code11 == INTEGER_CST
9885                 && TREE_INT_CST_HIGH (tree01) == 0
9886                 && TREE_INT_CST_HIGH (tree11) == 0
9887                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
9888                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
9889               return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
9890                              code0 == LSHIFT_EXPR ? tree01 : tree11);
9891             else if (code11 == MINUS_EXPR)
9892               {
9893                 tree tree110, tree111;
9894                 tree110 = TREE_OPERAND (tree11, 0);
9895                 tree111 = TREE_OPERAND (tree11, 1);
9896                 STRIP_NOPS (tree110);
9897                 STRIP_NOPS (tree111);
9898                 if (TREE_CODE (tree110) == INTEGER_CST
9899                     && 0 == compare_tree_int (tree110,
9900                                               TYPE_PRECISION
9901                                               (TREE_TYPE (TREE_OPERAND
9902                                                           (arg0, 0))))
9903                     && operand_equal_p (tree01, tree111, 0))
9904                   return build2 ((code0 == LSHIFT_EXPR
9905                                   ? LROTATE_EXPR
9906                                   : RROTATE_EXPR),
9907                                  type, TREE_OPERAND (arg0, 0), tree01);
9908               }
9909             else if (code01 == MINUS_EXPR)
9910               {
9911                 tree tree010, tree011;
9912                 tree010 = TREE_OPERAND (tree01, 0);
9913                 tree011 = TREE_OPERAND (tree01, 1);
9914                 STRIP_NOPS (tree010);
9915                 STRIP_NOPS (tree011);
9916                 if (TREE_CODE (tree010) == INTEGER_CST
9917                     && 0 == compare_tree_int (tree010,
9918                                               TYPE_PRECISION
9919                                               (TREE_TYPE (TREE_OPERAND
9920                                                           (arg0, 0))))
9921                     && operand_equal_p (tree11, tree011, 0))
9922                   return build2 ((code0 != LSHIFT_EXPR
9923                                   ? LROTATE_EXPR
9924                                   : RROTATE_EXPR),
9925                                  type, TREE_OPERAND (arg0, 0), tree11);
9926               }
9927           }
9928       }
9929
9930     associate:
9931       /* In most languages, can't associate operations on floats through
9932          parentheses.  Rather than remember where the parentheses were, we
9933          don't associate floats at all, unless the user has specified
9934          -fassociative-math.
9935          And, we need to make sure type is not saturating.  */
9936
9937       if ((! FLOAT_TYPE_P (type) || flag_associative_math)
9938           && !TYPE_SATURATING (type))
9939         {
9940           tree var0, con0, lit0, minus_lit0;
9941           tree var1, con1, lit1, minus_lit1;
9942           bool ok = true;
9943
9944           /* Split both trees into variables, constants, and literals.  Then
9945              associate each group together, the constants with literals,
9946              then the result with variables.  This increases the chances of
9947              literals being recombined later and of generating relocatable
9948              expressions for the sum of a constant and literal.  */
9949           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
9950           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
9951                              code == MINUS_EXPR);
9952
9953           /* With undefined overflow we can only associate constants
9954              with one variable.  */
9955           if ((POINTER_TYPE_P (type)
9956                || (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_WRAPS (type)))
9957               && var0 && var1)
9958             {
9959               tree tmp0 = var0;
9960               tree tmp1 = var1;
9961
9962               if (TREE_CODE (tmp0) == NEGATE_EXPR)
9963                 tmp0 = TREE_OPERAND (tmp0, 0);
9964               if (TREE_CODE (tmp1) == NEGATE_EXPR)
9965                 tmp1 = TREE_OPERAND (tmp1, 0);
9966               /* The only case we can still associate with two variables
9967                  is if they are the same, modulo negation.  */
9968               if (!operand_equal_p (tmp0, tmp1, 0))
9969                 ok = false;
9970             }
9971
9972           /* Only do something if we found more than two objects.  Otherwise,
9973              nothing has changed and we risk infinite recursion.  */
9974           if (ok
9975               && (2 < ((var0 != 0) + (var1 != 0)
9976                        + (con0 != 0) + (con1 != 0)
9977                        + (lit0 != 0) + (lit1 != 0)
9978                        + (minus_lit0 != 0) + (minus_lit1 != 0))))
9979             {
9980               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
9981               if (code == MINUS_EXPR)
9982                 code = PLUS_EXPR;
9983
9984               var0 = associate_trees (var0, var1, code, type);
9985               con0 = associate_trees (con0, con1, code, type);
9986               lit0 = associate_trees (lit0, lit1, code, type);
9987               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
9988
9989               /* Preserve the MINUS_EXPR if the negative part of the literal is
9990                  greater than the positive part.  Otherwise, the multiplicative
9991                  folding code (i.e extract_muldiv) may be fooled in case
9992                  unsigned constants are subtracted, like in the following
9993                  example: ((X*2 + 4) - 8U)/2.  */
9994               if (minus_lit0 && lit0)
9995                 {
9996                   if (TREE_CODE (lit0) == INTEGER_CST
9997                       && TREE_CODE (minus_lit0) == INTEGER_CST
9998                       && tree_int_cst_lt (lit0, minus_lit0))
9999                     {
10000                       minus_lit0 = associate_trees (minus_lit0, lit0,
10001                                                     MINUS_EXPR, type);
10002                       lit0 = 0;
10003                     }
10004                   else
10005                     {
10006                       lit0 = associate_trees (lit0, minus_lit0,
10007                                               MINUS_EXPR, type);
10008                       minus_lit0 = 0;
10009                     }
10010                 }
10011               if (minus_lit0)
10012                 {
10013                   if (con0 == 0)
10014                     return fold_convert (type,
10015                                          associate_trees (var0, minus_lit0,
10016                                                           MINUS_EXPR, type));
10017                   else
10018                     {
10019                       con0 = associate_trees (con0, minus_lit0,
10020                                               MINUS_EXPR, type);
10021                       return fold_convert (type,
10022                                            associate_trees (var0, con0,
10023                                                             PLUS_EXPR, type));
10024                     }
10025                 }
10026
10027               con0 = associate_trees (con0, lit0, code, type);
10028               return fold_convert (type, associate_trees (var0, con0,
10029                                                           code, type));
10030             }
10031         }
10032
10033       return NULL_TREE;
10034
10035     case MINUS_EXPR:
10036       /* Pointer simplifications for subtraction, simple reassociations. */
10037       if (POINTER_TYPE_P (TREE_TYPE (arg1)) && POINTER_TYPE_P (TREE_TYPE (arg0)))
10038         {
10039           /* (PTR0 p+ A) - (PTR1 p+ B) -> (PTR0 - PTR1) + (A - B) */
10040           if (TREE_CODE (arg0) == POINTER_PLUS_EXPR
10041               && TREE_CODE (arg1) == POINTER_PLUS_EXPR)
10042             {
10043               tree arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
10044               tree arg01 = fold_convert (type, TREE_OPERAND (arg0, 1));
10045               tree arg10 = fold_convert (type, TREE_OPERAND (arg1, 0));
10046               tree arg11 = fold_convert (type, TREE_OPERAND (arg1, 1));
10047               return fold_build2 (PLUS_EXPR, type,
10048                                   fold_build2 (MINUS_EXPR, type, arg00, arg10),
10049                                   fold_build2 (MINUS_EXPR, type, arg01, arg11));
10050             }
10051           /* (PTR0 p+ A) - PTR1 -> (PTR0 - PTR1) + A, assuming PTR0 - PTR1 simplifies. */
10052           else if (TREE_CODE (arg0) == POINTER_PLUS_EXPR)
10053             {
10054               tree arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
10055               tree arg01 = fold_convert (type, TREE_OPERAND (arg0, 1));
10056               tree tmp = fold_binary (MINUS_EXPR, type, arg00, fold_convert (type, arg1));
10057               if (tmp)
10058                 return fold_build2 (PLUS_EXPR, type, tmp, arg01);
10059             }
10060         }
10061       /* A - (-B) -> A + B */
10062       if (TREE_CODE (arg1) == NEGATE_EXPR)
10063         return fold_build2 (PLUS_EXPR, type, op0,
10064                             fold_convert (type, TREE_OPERAND (arg1, 0)));
10065       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
10066       if (TREE_CODE (arg0) == NEGATE_EXPR
10067           && (FLOAT_TYPE_P (type)
10068               || INTEGRAL_TYPE_P (type))
10069           && negate_expr_p (arg1)
10070           && reorder_operands_p (arg0, arg1))
10071         return fold_build2 (MINUS_EXPR, type,
10072                             fold_convert (type, negate_expr (arg1)),
10073                             fold_convert (type, TREE_OPERAND (arg0, 0)));
10074       /* Convert -A - 1 to ~A.  */
10075       if (INTEGRAL_TYPE_P (type)
10076           && TREE_CODE (arg0) == NEGATE_EXPR
10077           && integer_onep (arg1)
10078           && !TYPE_OVERFLOW_TRAPS (type))
10079         return fold_build1 (BIT_NOT_EXPR, type,
10080                             fold_convert (type, TREE_OPERAND (arg0, 0)));
10081
10082       /* Convert -1 - A to ~A.  */
10083       if (INTEGRAL_TYPE_P (type)
10084           && integer_all_onesp (arg0))
10085         return fold_build1 (BIT_NOT_EXPR, type, op1);
10086
10087
10088       /* X - (X / CST) * CST is X % CST.  */
10089       if (INTEGRAL_TYPE_P (type)
10090           && TREE_CODE (arg1) == MULT_EXPR
10091           && TREE_CODE (TREE_OPERAND (arg1, 0)) == TRUNC_DIV_EXPR
10092           && operand_equal_p (arg0,
10093                               TREE_OPERAND (TREE_OPERAND (arg1, 0), 0), 0)
10094           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg1, 0), 1),
10095                               TREE_OPERAND (arg1, 1), 0))
10096         return fold_convert (type,
10097                              fold_build2 (TRUNC_MOD_EXPR, TREE_TYPE (arg0),
10098                                           arg0, TREE_OPERAND (arg1, 1)));
10099
10100       if (! FLOAT_TYPE_P (type))
10101         {
10102           if (integer_zerop (arg0))
10103             return negate_expr (fold_convert (type, arg1));
10104           if (integer_zerop (arg1))
10105             return non_lvalue (fold_convert (type, arg0));
10106
10107           /* Fold A - (A & B) into ~B & A.  */
10108           if (!TREE_SIDE_EFFECTS (arg0)
10109               && TREE_CODE (arg1) == BIT_AND_EXPR)
10110             {
10111               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
10112                 {
10113                   tree arg10 = fold_convert (type, TREE_OPERAND (arg1, 0));
10114                   return fold_build2 (BIT_AND_EXPR, type,
10115                                       fold_build1 (BIT_NOT_EXPR, type, arg10),
10116                                       fold_convert (type, arg0));
10117                 }
10118               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10119                 {
10120                   tree arg11 = fold_convert (type, TREE_OPERAND (arg1, 1));
10121                   return fold_build2 (BIT_AND_EXPR, type,
10122                                       fold_build1 (BIT_NOT_EXPR, type, arg11),
10123                                       fold_convert (type, arg0));
10124                 }
10125             }
10126
10127           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
10128              any power of 2 minus 1.  */
10129           if (TREE_CODE (arg0) == BIT_AND_EXPR
10130               && TREE_CODE (arg1) == BIT_AND_EXPR
10131               && operand_equal_p (TREE_OPERAND (arg0, 0),
10132                                   TREE_OPERAND (arg1, 0), 0))
10133             {
10134               tree mask0 = TREE_OPERAND (arg0, 1);
10135               tree mask1 = TREE_OPERAND (arg1, 1);
10136               tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
10137
10138               if (operand_equal_p (tem, mask1, 0))
10139                 {
10140                   tem = fold_build2 (BIT_XOR_EXPR, type,
10141                                      TREE_OPERAND (arg0, 0), mask1);
10142                   return fold_build2 (MINUS_EXPR, type, tem, mask1);
10143                 }
10144             }
10145         }
10146
10147       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
10148       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
10149         return non_lvalue (fold_convert (type, arg0));
10150
10151       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
10152          ARG0 is zero and X + ARG0 reduces to X, since that would mean
10153          (-ARG1 + ARG0) reduces to -ARG1.  */
10154       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
10155         return negate_expr (fold_convert (type, arg1));
10156
10157       /* Fold __complex__ ( x, 0 ) - __complex__ ( 0, y ) to
10158          __complex__ ( x, -y ).  This is not the same for SNaNs or if
10159          signed zeros are involved.  */
10160       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10161           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10162           && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0)))
10163         {
10164           tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10165           tree arg0r = fold_unary (REALPART_EXPR, rtype, arg0);
10166           tree arg0i = fold_unary (IMAGPART_EXPR, rtype, arg0);
10167           bool arg0rz = false, arg0iz = false;
10168           if ((arg0r && (arg0rz = real_zerop (arg0r)))
10169               || (arg0i && (arg0iz = real_zerop (arg0i))))
10170             {
10171               tree arg1r = fold_unary (REALPART_EXPR, rtype, arg1);
10172               tree arg1i = fold_unary (IMAGPART_EXPR, rtype, arg1);
10173               if (arg0rz && arg1i && real_zerop (arg1i))
10174                 {
10175                   tree rp = fold_build1 (NEGATE_EXPR, rtype,
10176                                          arg1r ? arg1r
10177                                          : build1 (REALPART_EXPR, rtype, arg1));
10178                   tree ip = arg0i ? arg0i
10179                     : build1 (IMAGPART_EXPR, rtype, arg0);
10180                   return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10181                 }
10182               else if (arg0iz && arg1r && real_zerop (arg1r))
10183                 {
10184                   tree rp = arg0r ? arg0r
10185                     : build1 (REALPART_EXPR, rtype, arg0);
10186                   tree ip = fold_build1 (NEGATE_EXPR, rtype,
10187                                          arg1i ? arg1i
10188                                          : build1 (IMAGPART_EXPR, rtype, arg1));
10189                   return fold_build2 (COMPLEX_EXPR, type, rp, ip);
10190                 }
10191             }
10192         }
10193
10194       /* Fold &x - &x.  This can happen from &x.foo - &x.
10195          This is unsafe for certain floats even in non-IEEE formats.
10196          In IEEE, it is unsafe because it does wrong for NaNs.
10197          Also note that operand_equal_p is always false if an operand
10198          is volatile.  */
10199
10200       if ((!FLOAT_TYPE_P (type) || !HONOR_NANS (TYPE_MODE (type)))
10201           && operand_equal_p (arg0, arg1, 0))
10202         return fold_convert (type, integer_zero_node);
10203
10204       /* A - B -> A + (-B) if B is easily negatable.  */
10205       if (negate_expr_p (arg1)
10206           && ((FLOAT_TYPE_P (type)
10207                /* Avoid this transformation if B is a positive REAL_CST.  */
10208                && (TREE_CODE (arg1) != REAL_CST
10209                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
10210               || INTEGRAL_TYPE_P (type)))
10211         return fold_build2 (PLUS_EXPR, type,
10212                             fold_convert (type, arg0),
10213                             fold_convert (type, negate_expr (arg1)));
10214
10215       /* Try folding difference of addresses.  */
10216       {
10217         HOST_WIDE_INT diff;
10218
10219         if ((TREE_CODE (arg0) == ADDR_EXPR
10220              || TREE_CODE (arg1) == ADDR_EXPR)
10221             && ptr_difference_const (arg0, arg1, &diff))
10222           return build_int_cst_type (type, diff);
10223       }
10224
10225       /* Fold &a[i] - &a[j] to i-j.  */
10226       if (TREE_CODE (arg0) == ADDR_EXPR
10227           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
10228           && TREE_CODE (arg1) == ADDR_EXPR
10229           && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
10230         {
10231           tree aref0 = TREE_OPERAND (arg0, 0);
10232           tree aref1 = TREE_OPERAND (arg1, 0);
10233           if (operand_equal_p (TREE_OPERAND (aref0, 0),
10234                                TREE_OPERAND (aref1, 0), 0))
10235             {
10236               tree op0 = fold_convert (type, TREE_OPERAND (aref0, 1));
10237               tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
10238               tree esz = array_ref_element_size (aref0);
10239               tree diff = build2 (MINUS_EXPR, type, op0, op1);
10240               return fold_build2 (MULT_EXPR, type, diff,
10241                                   fold_convert (type, esz));
10242                                   
10243             }
10244         }
10245
10246       if (flag_unsafe_math_optimizations
10247           && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
10248           && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
10249           && (tem = distribute_real_division (code, type, arg0, arg1)))
10250         return tem;
10251
10252       /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the
10253          same or one.  Make sure type is not saturating.
10254          fold_plusminus_mult_expr will re-associate.  */
10255       if ((TREE_CODE (arg0) == MULT_EXPR
10256            || TREE_CODE (arg1) == MULT_EXPR)
10257           && !TYPE_SATURATING (type)
10258           && (!FLOAT_TYPE_P (type) || flag_associative_math))
10259         {
10260           tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
10261           if (tem)
10262             return tem;
10263         }
10264
10265       goto associate;
10266
10267     case MULT_EXPR:
10268       /* (-A) * (-B) -> A * B  */
10269       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
10270         return fold_build2 (MULT_EXPR, type,
10271                             fold_convert (type, TREE_OPERAND (arg0, 0)),
10272                             fold_convert (type, negate_expr (arg1)));
10273       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
10274         return fold_build2 (MULT_EXPR, type,
10275                             fold_convert (type, negate_expr (arg0)),
10276                             fold_convert (type, TREE_OPERAND (arg1, 0)));
10277
10278       if (! FLOAT_TYPE_P (type))
10279         {
10280           if (integer_zerop (arg1))
10281             return omit_one_operand (type, arg1, arg0);
10282           if (integer_onep (arg1))
10283             return non_lvalue (fold_convert (type, arg0));
10284           /* Transform x * -1 into -x.  Make sure to do the negation
10285              on the original operand with conversions not stripped
10286              because we can only strip non-sign-changing conversions.  */
10287           if (integer_all_onesp (arg1))
10288             return fold_convert (type, negate_expr (op0));
10289           /* Transform x * -C into -x * C if x is easily negatable.  */
10290           if (TREE_CODE (arg1) == INTEGER_CST
10291               && tree_int_cst_sgn (arg1) == -1
10292               && negate_expr_p (arg0)
10293               && (tem = negate_expr (arg1)) != arg1
10294               && !TREE_OVERFLOW (tem))
10295             return fold_build2 (MULT_EXPR, type,
10296                                 fold_convert (type, negate_expr (arg0)), tem);
10297
10298           /* (a * (1 << b)) is (a << b)  */
10299           if (TREE_CODE (arg1) == LSHIFT_EXPR
10300               && integer_onep (TREE_OPERAND (arg1, 0)))
10301             return fold_build2 (LSHIFT_EXPR, type, op0,
10302                                 TREE_OPERAND (arg1, 1));
10303           if (TREE_CODE (arg0) == LSHIFT_EXPR
10304               && integer_onep (TREE_OPERAND (arg0, 0)))
10305             return fold_build2 (LSHIFT_EXPR, type, op1,
10306                                 TREE_OPERAND (arg0, 1));
10307
10308           strict_overflow_p = false;
10309           if (TREE_CODE (arg1) == INTEGER_CST
10310               && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10311                                              &strict_overflow_p)))
10312             {
10313               if (strict_overflow_p)
10314                 fold_overflow_warning (("assuming signed overflow does not "
10315                                         "occur when simplifying "
10316                                         "multiplication"),
10317                                        WARN_STRICT_OVERFLOW_MISC);
10318               return fold_convert (type, tem);
10319             }
10320
10321           /* Optimize z * conj(z) for integer complex numbers.  */
10322           if (TREE_CODE (arg0) == CONJ_EXPR
10323               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10324             return fold_mult_zconjz (type, arg1);
10325           if (TREE_CODE (arg1) == CONJ_EXPR
10326               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10327             return fold_mult_zconjz (type, arg0);
10328         }
10329       else
10330         {
10331           /* Maybe fold x * 0 to 0.  The expressions aren't the same
10332              when x is NaN, since x * 0 is also NaN.  Nor are they the
10333              same in modes with signed zeros, since multiplying a
10334              negative value by 0 gives -0, not +0.  */
10335           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10336               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10337               && real_zerop (arg1))
10338             return omit_one_operand (type, arg1, arg0);
10339           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
10340           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10341               && real_onep (arg1))
10342             return non_lvalue (fold_convert (type, arg0));
10343
10344           /* Transform x * -1.0 into -x.  */
10345           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
10346               && real_minus_onep (arg1))
10347             return fold_convert (type, negate_expr (arg0));
10348
10349           /* Convert (C1/X)*C2 into (C1*C2)/X.  This transformation may change
10350              the result for floating point types due to rounding so it is applied
10351              only if -fassociative-math was specify.  */
10352           if (flag_associative_math
10353               && TREE_CODE (arg0) == RDIV_EXPR
10354               && TREE_CODE (arg1) == REAL_CST
10355               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
10356             {
10357               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
10358                                       arg1, 0);
10359               if (tem)
10360                 return fold_build2 (RDIV_EXPR, type, tem,
10361                                     TREE_OPERAND (arg0, 1));
10362             }
10363
10364           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
10365           if (operand_equal_p (arg0, arg1, 0))
10366             {
10367               tree tem = fold_strip_sign_ops (arg0);
10368               if (tem != NULL_TREE)
10369                 {
10370                   tem = fold_convert (type, tem);
10371                   return fold_build2 (MULT_EXPR, type, tem, tem);
10372                 }
10373             }
10374
10375           /* Fold z * +-I to __complex__ (-+__imag z, +-__real z).
10376              This is not the same for NaNs or if signed zeros are
10377              involved.  */
10378           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
10379               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
10380               && COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
10381               && TREE_CODE (arg1) == COMPLEX_CST
10382               && real_zerop (TREE_REALPART (arg1)))
10383             {
10384               tree rtype = TREE_TYPE (TREE_TYPE (arg0));
10385               if (real_onep (TREE_IMAGPART (arg1)))
10386                 return fold_build2 (COMPLEX_EXPR, type,
10387                                     negate_expr (fold_build1 (IMAGPART_EXPR,
10388                                                               rtype, arg0)),
10389                                     fold_build1 (REALPART_EXPR, rtype, arg0));
10390               else if (real_minus_onep (TREE_IMAGPART (arg1)))
10391                 return fold_build2 (COMPLEX_EXPR, type,
10392                                     fold_build1 (IMAGPART_EXPR, rtype, arg0),
10393                                     negate_expr (fold_build1 (REALPART_EXPR,
10394                                                               rtype, arg0)));
10395             }
10396
10397           /* Optimize z * conj(z) for floating point complex numbers.
10398              Guarded by flag_unsafe_math_optimizations as non-finite
10399              imaginary components don't produce scalar results.  */
10400           if (flag_unsafe_math_optimizations
10401               && TREE_CODE (arg0) == CONJ_EXPR
10402               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10403             return fold_mult_zconjz (type, arg1);
10404           if (flag_unsafe_math_optimizations
10405               && TREE_CODE (arg1) == CONJ_EXPR
10406               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10407             return fold_mult_zconjz (type, arg0);
10408
10409           if (flag_unsafe_math_optimizations)
10410             {
10411               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
10412               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
10413
10414               /* Optimizations of root(...)*root(...).  */
10415               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
10416                 {
10417                   tree rootfn, arg;
10418                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10419                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10420
10421                   /* Optimize sqrt(x)*sqrt(x) as x.  */
10422                   if (BUILTIN_SQRT_P (fcode0)
10423                       && operand_equal_p (arg00, arg10, 0)
10424                       && ! HONOR_SNANS (TYPE_MODE (type)))
10425                     return arg00;
10426
10427                   /* Optimize root(x)*root(y) as root(x*y).  */
10428                   rootfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10429                   arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
10430                   return build_call_expr (rootfn, 1, arg);
10431                 }
10432
10433               /* Optimize expN(x)*expN(y) as expN(x+y).  */
10434               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
10435                 {
10436                   tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10437                   tree arg = fold_build2 (PLUS_EXPR, type,
10438                                           CALL_EXPR_ARG (arg0, 0),
10439                                           CALL_EXPR_ARG (arg1, 0));
10440                   return build_call_expr (expfn, 1, arg);
10441                 }
10442
10443               /* Optimizations of pow(...)*pow(...).  */
10444               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
10445                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
10446                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
10447                 {
10448                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10449                   tree arg01 = CALL_EXPR_ARG (arg0, 1);
10450                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10451                   tree arg11 = CALL_EXPR_ARG (arg1, 1);
10452
10453                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
10454                   if (operand_equal_p (arg01, arg11, 0))
10455                     {
10456                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10457                       tree arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
10458                       return build_call_expr (powfn, 2, arg, arg01);
10459                     }
10460
10461                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
10462                   if (operand_equal_p (arg00, arg10, 0))
10463                     {
10464                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10465                       tree arg = fold_build2 (PLUS_EXPR, type, arg01, arg11);
10466                       return build_call_expr (powfn, 2, arg00, arg);
10467                     }
10468                 }
10469
10470               /* Optimize tan(x)*cos(x) as sin(x).  */
10471               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
10472                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
10473                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
10474                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
10475                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
10476                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
10477                   && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
10478                                       CALL_EXPR_ARG (arg1, 0), 0))
10479                 {
10480                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
10481
10482                   if (sinfn != NULL_TREE)
10483                     return build_call_expr (sinfn, 1, CALL_EXPR_ARG (arg0, 0));
10484                 }
10485
10486               /* Optimize x*pow(x,c) as pow(x,c+1).  */
10487               if (fcode1 == BUILT_IN_POW
10488                   || fcode1 == BUILT_IN_POWF
10489                   || fcode1 == BUILT_IN_POWL)
10490                 {
10491                   tree arg10 = CALL_EXPR_ARG (arg1, 0);
10492                   tree arg11 = CALL_EXPR_ARG (arg1, 1);
10493                   if (TREE_CODE (arg11) == REAL_CST
10494                       && !TREE_OVERFLOW (arg11)
10495                       && operand_equal_p (arg0, arg10, 0))
10496                     {
10497                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
10498                       REAL_VALUE_TYPE c;
10499                       tree arg;
10500
10501                       c = TREE_REAL_CST (arg11);
10502                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10503                       arg = build_real (type, c);
10504                       return build_call_expr (powfn, 2, arg0, arg);
10505                     }
10506                 }
10507
10508               /* Optimize pow(x,c)*x as pow(x,c+1).  */
10509               if (fcode0 == BUILT_IN_POW
10510                   || fcode0 == BUILT_IN_POWF
10511                   || fcode0 == BUILT_IN_POWL)
10512                 {
10513                   tree arg00 = CALL_EXPR_ARG (arg0, 0);
10514                   tree arg01 = CALL_EXPR_ARG (arg0, 1);
10515                   if (TREE_CODE (arg01) == REAL_CST
10516                       && !TREE_OVERFLOW (arg01)
10517                       && operand_equal_p (arg1, arg00, 0))
10518                     {
10519                       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
10520                       REAL_VALUE_TYPE c;
10521                       tree arg;
10522
10523                       c = TREE_REAL_CST (arg01);
10524                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
10525                       arg = build_real (type, c);
10526                       return build_call_expr (powfn, 2, arg1, arg);
10527                     }
10528                 }
10529
10530               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
10531               if (! optimize_size
10532                   && operand_equal_p (arg0, arg1, 0))
10533                 {
10534                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
10535
10536                   if (powfn)
10537                     {
10538                       tree arg = build_real (type, dconst2);
10539                       return build_call_expr (powfn, 2, arg0, arg);
10540                     }
10541                 }
10542             }
10543         }
10544       goto associate;
10545
10546     case BIT_IOR_EXPR:
10547     bit_ior:
10548       if (integer_all_onesp (arg1))
10549         return omit_one_operand (type, arg1, arg0);
10550       if (integer_zerop (arg1))
10551         return non_lvalue (fold_convert (type, arg0));
10552       if (operand_equal_p (arg0, arg1, 0))
10553         return non_lvalue (fold_convert (type, arg0));
10554
10555       /* ~X | X is -1.  */
10556       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10557           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10558         {
10559           t1 = fold_convert (type, integer_zero_node);
10560           t1 = fold_unary (BIT_NOT_EXPR, type, t1);
10561           return omit_one_operand (type, t1, arg1);
10562         }
10563
10564       /* X | ~X is -1.  */
10565       if (TREE_CODE (arg1) == BIT_NOT_EXPR
10566           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10567         {
10568           t1 = fold_convert (type, integer_zero_node);
10569           t1 = fold_unary (BIT_NOT_EXPR, type, t1);
10570           return omit_one_operand (type, t1, arg0);
10571         }
10572
10573       /* Canonicalize (X & C1) | C2.  */
10574       if (TREE_CODE (arg0) == BIT_AND_EXPR
10575           && TREE_CODE (arg1) == INTEGER_CST
10576           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10577         {
10578           unsigned HOST_WIDE_INT hi1, lo1, hi2, lo2, hi3, lo3, mlo, mhi;
10579           int width = TYPE_PRECISION (type), w;
10580           hi1 = TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1));
10581           lo1 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
10582           hi2 = TREE_INT_CST_HIGH (arg1);
10583           lo2 = TREE_INT_CST_LOW (arg1);
10584
10585           /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).  */
10586           if ((hi1 & hi2) == hi1 && (lo1 & lo2) == lo1)
10587             return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
10588
10589           if (width > HOST_BITS_PER_WIDE_INT)
10590             {
10591               mhi = (unsigned HOST_WIDE_INT) -1 
10592                     >> (2 * HOST_BITS_PER_WIDE_INT - width);
10593               mlo = -1;
10594             }
10595           else
10596             {
10597               mhi = 0;
10598               mlo = (unsigned HOST_WIDE_INT) -1
10599                     >> (HOST_BITS_PER_WIDE_INT - width);
10600             }
10601
10602           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
10603           if ((~(hi1 | hi2) & mhi) == 0 && (~(lo1 | lo2) & mlo) == 0)
10604             return fold_build2 (BIT_IOR_EXPR, type,
10605                                 TREE_OPERAND (arg0, 0), arg1);
10606
10607           /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2,
10608              unless (C1 & ~C2) | (C2 & C3) for some C3 is a mask of some
10609              mode which allows further optimizations.  */
10610           hi1 &= mhi;
10611           lo1 &= mlo;
10612           hi2 &= mhi;
10613           lo2 &= mlo;
10614           hi3 = hi1 & ~hi2;
10615           lo3 = lo1 & ~lo2;
10616           for (w = BITS_PER_UNIT;
10617                w <= width && w <= HOST_BITS_PER_WIDE_INT;
10618                w <<= 1)
10619             {
10620               unsigned HOST_WIDE_INT mask
10621                 = (unsigned HOST_WIDE_INT) -1 >> (HOST_BITS_PER_WIDE_INT - w);
10622               if (((lo1 | lo2) & mask) == mask
10623                   && (lo1 & ~mask) == 0 && hi1 == 0)
10624                 {
10625                   hi3 = 0;
10626                   lo3 = mask;
10627                   break;
10628                 }
10629             }
10630           if (hi3 != hi1 || lo3 != lo1)
10631             return fold_build2 (BIT_IOR_EXPR, type,
10632                                 fold_build2 (BIT_AND_EXPR, type,
10633                                              TREE_OPERAND (arg0, 0),
10634                                              build_int_cst_wide (type,
10635                                                                  lo3, hi3)),
10636                                 arg1);
10637         }
10638
10639       /* (X & Y) | Y is (X, Y).  */
10640       if (TREE_CODE (arg0) == BIT_AND_EXPR
10641           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10642         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
10643       /* (X & Y) | X is (Y, X).  */
10644       if (TREE_CODE (arg0) == BIT_AND_EXPR
10645           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10646           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10647         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
10648       /* X | (X & Y) is (Y, X).  */
10649       if (TREE_CODE (arg1) == BIT_AND_EXPR
10650           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
10651           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
10652         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
10653       /* X | (Y & X) is (Y, X).  */
10654       if (TREE_CODE (arg1) == BIT_AND_EXPR
10655           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10656           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10657         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
10658
10659       t1 = distribute_bit_expr (code, type, arg0, arg1);
10660       if (t1 != NULL_TREE)
10661         return t1;
10662
10663       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
10664
10665          This results in more efficient code for machines without a NAND
10666          instruction.  Combine will canonicalize to the first form
10667          which will allow use of NAND instructions provided by the
10668          backend if they exist.  */
10669       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10670           && TREE_CODE (arg1) == BIT_NOT_EXPR)
10671         {
10672           return fold_build1 (BIT_NOT_EXPR, type,
10673                               build2 (BIT_AND_EXPR, type,
10674                                       TREE_OPERAND (arg0, 0),
10675                                       TREE_OPERAND (arg1, 0)));
10676         }
10677
10678       /* See if this can be simplified into a rotate first.  If that
10679          is unsuccessful continue in the association code.  */
10680       goto bit_rotate;
10681
10682     case BIT_XOR_EXPR:
10683       if (integer_zerop (arg1))
10684         return non_lvalue (fold_convert (type, arg0));
10685       if (integer_all_onesp (arg1))
10686         return fold_build1 (BIT_NOT_EXPR, type, op0);
10687       if (operand_equal_p (arg0, arg1, 0))
10688         return omit_one_operand (type, integer_zero_node, arg0);
10689
10690       /* ~X ^ X is -1.  */
10691       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10692           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10693         {
10694           t1 = fold_convert (type, integer_zero_node);
10695           t1 = fold_unary (BIT_NOT_EXPR, type, t1);
10696           return omit_one_operand (type, t1, arg1);
10697         }
10698
10699       /* X ^ ~X is -1.  */
10700       if (TREE_CODE (arg1) == BIT_NOT_EXPR
10701           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10702         {
10703           t1 = fold_convert (type, integer_zero_node);
10704           t1 = fold_unary (BIT_NOT_EXPR, type, t1);
10705           return omit_one_operand (type, t1, arg0);
10706         }
10707
10708       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
10709          with a constant, and the two constants have no bits in common,
10710          we should treat this as a BIT_IOR_EXPR since this may produce more
10711          simplifications.  */
10712       if (TREE_CODE (arg0) == BIT_AND_EXPR
10713           && TREE_CODE (arg1) == BIT_AND_EXPR
10714           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10715           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
10716           && integer_zerop (const_binop (BIT_AND_EXPR,
10717                                          TREE_OPERAND (arg0, 1),
10718                                          TREE_OPERAND (arg1, 1), 0)))
10719         {
10720           code = BIT_IOR_EXPR;
10721           goto bit_ior;
10722         }
10723
10724       /* (X | Y) ^ X -> Y & ~ X*/
10725       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10726           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10727         {
10728           tree t2 = TREE_OPERAND (arg0, 1);
10729           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
10730                             arg1);
10731           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
10732                             fold_convert (type, t1));
10733           return t1;
10734         }
10735
10736       /* (Y | X) ^ X -> Y & ~ X*/
10737       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10738           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10739         {
10740           tree t2 = TREE_OPERAND (arg0, 0);
10741           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
10742                             arg1);
10743           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
10744                             fold_convert (type, t1));
10745           return t1;
10746         }
10747
10748       /* X ^ (X | Y) -> Y & ~ X*/
10749       if (TREE_CODE (arg1) == BIT_IOR_EXPR
10750           && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
10751         {
10752           tree t2 = TREE_OPERAND (arg1, 1);
10753           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
10754                             arg0);
10755           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
10756                             fold_convert (type, t1));
10757           return t1;
10758         }
10759
10760       /* X ^ (Y | X) -> Y & ~ X*/
10761       if (TREE_CODE (arg1) == BIT_IOR_EXPR
10762           && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
10763         {
10764           tree t2 = TREE_OPERAND (arg1, 0);
10765           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
10766                             arg0);
10767           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
10768                             fold_convert (type, t1));
10769           return t1;
10770         }
10771         
10772       /* Convert ~X ^ ~Y to X ^ Y.  */
10773       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10774           && TREE_CODE (arg1) == BIT_NOT_EXPR)
10775         return fold_build2 (code, type,
10776                             fold_convert (type, TREE_OPERAND (arg0, 0)),
10777                             fold_convert (type, TREE_OPERAND (arg1, 0)));
10778
10779       /* Convert ~X ^ C to X ^ ~C.  */
10780       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10781           && TREE_CODE (arg1) == INTEGER_CST)
10782         return fold_build2 (code, type,
10783                             fold_convert (type, TREE_OPERAND (arg0, 0)),
10784                             fold_build1 (BIT_NOT_EXPR, type, arg1));
10785
10786       /* Fold (X & 1) ^ 1 as (X & 1) == 0.  */
10787       if (TREE_CODE (arg0) == BIT_AND_EXPR
10788           && integer_onep (TREE_OPERAND (arg0, 1))
10789           && integer_onep (arg1))
10790         return fold_build2 (EQ_EXPR, type, arg0,
10791                             build_int_cst (TREE_TYPE (arg0), 0));
10792
10793       /* Fold (X & Y) ^ Y as ~X & Y.  */
10794       if (TREE_CODE (arg0) == BIT_AND_EXPR
10795           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10796         {
10797           tem = fold_convert (type, TREE_OPERAND (arg0, 0));
10798           return fold_build2 (BIT_AND_EXPR, type, 
10799                               fold_build1 (BIT_NOT_EXPR, type, tem),
10800                               fold_convert (type, arg1));
10801         }
10802       /* Fold (X & Y) ^ X as ~Y & X.  */
10803       if (TREE_CODE (arg0) == BIT_AND_EXPR
10804           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10805           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10806         {
10807           tem = fold_convert (type, TREE_OPERAND (arg0, 1));
10808           return fold_build2 (BIT_AND_EXPR, type,
10809                               fold_build1 (BIT_NOT_EXPR, type, tem),
10810                               fold_convert (type, arg1));
10811         }
10812       /* Fold X ^ (X & Y) as X & ~Y.  */
10813       if (TREE_CODE (arg1) == BIT_AND_EXPR
10814           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10815         {
10816           tem = fold_convert (type, TREE_OPERAND (arg1, 1));
10817           return fold_build2 (BIT_AND_EXPR, type,
10818                               fold_convert (type, arg0),
10819                               fold_build1 (BIT_NOT_EXPR, type, tem));
10820         }
10821       /* Fold X ^ (Y & X) as ~Y & X.  */
10822       if (TREE_CODE (arg1) == BIT_AND_EXPR
10823           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10824           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10825         {
10826           tem = fold_convert (type, TREE_OPERAND (arg1, 0));
10827           return fold_build2 (BIT_AND_EXPR, type,
10828                               fold_build1 (BIT_NOT_EXPR, type, tem),
10829                               fold_convert (type, arg0));
10830         }
10831
10832       /* See if this can be simplified into a rotate first.  If that
10833          is unsuccessful continue in the association code.  */
10834       goto bit_rotate;
10835
10836     case BIT_AND_EXPR:
10837       if (integer_all_onesp (arg1))
10838         return non_lvalue (fold_convert (type, arg0));
10839       if (integer_zerop (arg1))
10840         return omit_one_operand (type, arg1, arg0);
10841       if (operand_equal_p (arg0, arg1, 0))
10842         return non_lvalue (fold_convert (type, arg0));
10843
10844       /* ~X & X is always zero.  */
10845       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10846           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10847         return omit_one_operand (type, integer_zero_node, arg1);
10848
10849       /* X & ~X is always zero.  */
10850       if (TREE_CODE (arg1) == BIT_NOT_EXPR
10851           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10852         return omit_one_operand (type, integer_zero_node, arg0);
10853
10854       /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2).  */
10855       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10856           && TREE_CODE (arg1) == INTEGER_CST
10857           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10858         {
10859           tree tmp1 = fold_convert (TREE_TYPE (arg0), arg1);
10860           tree tmp2 = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10861                                    TREE_OPERAND (arg0, 0), tmp1);
10862           tree tmp3 = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10863                                    TREE_OPERAND (arg0, 1), tmp1);
10864           return fold_convert (type,
10865                                fold_build2 (BIT_IOR_EXPR, TREE_TYPE (arg0),
10866                                             tmp2, tmp3));
10867         }
10868
10869       /* (X | Y) & Y is (X, Y).  */
10870       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10871           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10872         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
10873       /* (X | Y) & X is (Y, X).  */
10874       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10875           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10876           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10877         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
10878       /* X & (X | Y) is (Y, X).  */
10879       if (TREE_CODE (arg1) == BIT_IOR_EXPR
10880           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
10881           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
10882         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
10883       /* X & (Y | X) is (Y, X).  */
10884       if (TREE_CODE (arg1) == BIT_IOR_EXPR
10885           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10886           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10887         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
10888
10889       /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
10890       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10891           && integer_onep (TREE_OPERAND (arg0, 1))
10892           && integer_onep (arg1))
10893         {
10894           tem = TREE_OPERAND (arg0, 0);
10895           return fold_build2 (EQ_EXPR, type,
10896                               fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
10897                                            build_int_cst (TREE_TYPE (tem), 1)),
10898                               build_int_cst (TREE_TYPE (tem), 0));
10899         }
10900       /* Fold ~X & 1 as (X & 1) == 0.  */
10901       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10902           && integer_onep (arg1))
10903         {
10904           tem = TREE_OPERAND (arg0, 0);
10905           return fold_build2 (EQ_EXPR, type,
10906                               fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
10907                                            build_int_cst (TREE_TYPE (tem), 1)),
10908                               build_int_cst (TREE_TYPE (tem), 0));
10909         }
10910
10911       /* Fold (X ^ Y) & Y as ~X & Y.  */
10912       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10913           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10914         {
10915           tem = fold_convert (type, TREE_OPERAND (arg0, 0));
10916           return fold_build2 (BIT_AND_EXPR, type, 
10917                               fold_build1 (BIT_NOT_EXPR, type, tem),
10918                               fold_convert (type, arg1));
10919         }
10920       /* Fold (X ^ Y) & X as ~Y & X.  */
10921       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10922           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10923           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10924         {
10925           tem = fold_convert (type, TREE_OPERAND (arg0, 1));
10926           return fold_build2 (BIT_AND_EXPR, type,
10927                               fold_build1 (BIT_NOT_EXPR, type, tem),
10928                               fold_convert (type, arg1));
10929         }
10930       /* Fold X & (X ^ Y) as X & ~Y.  */
10931       if (TREE_CODE (arg1) == BIT_XOR_EXPR
10932           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10933         {
10934           tem = fold_convert (type, TREE_OPERAND (arg1, 1));
10935           return fold_build2 (BIT_AND_EXPR, type,
10936                               fold_convert (type, arg0),
10937                               fold_build1 (BIT_NOT_EXPR, type, tem));
10938         }
10939       /* Fold X & (Y ^ X) as ~Y & X.  */
10940       if (TREE_CODE (arg1) == BIT_XOR_EXPR
10941           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
10942           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
10943         {
10944           tem = fold_convert (type, TREE_OPERAND (arg1, 0));
10945           return fold_build2 (BIT_AND_EXPR, type,
10946                               fold_build1 (BIT_NOT_EXPR, type, tem),
10947                               fold_convert (type, arg0));
10948         }
10949
10950       t1 = distribute_bit_expr (code, type, arg0, arg1);
10951       if (t1 != NULL_TREE)
10952         return t1;
10953       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
10954       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
10955           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
10956         {
10957           unsigned int prec
10958             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
10959
10960           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
10961               && (~TREE_INT_CST_LOW (arg1)
10962                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
10963             return fold_convert (type, TREE_OPERAND (arg0, 0));
10964         }
10965
10966       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
10967
10968          This results in more efficient code for machines without a NOR
10969          instruction.  Combine will canonicalize to the first form
10970          which will allow use of NOR instructions provided by the
10971          backend if they exist.  */
10972       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10973           && TREE_CODE (arg1) == BIT_NOT_EXPR)
10974         {
10975           return fold_build1 (BIT_NOT_EXPR, type,
10976                               build2 (BIT_IOR_EXPR, type,
10977                                       fold_convert (type,
10978                                                     TREE_OPERAND (arg0, 0)),
10979                                       fold_convert (type,
10980                                                     TREE_OPERAND (arg1, 0))));
10981         }
10982
10983       /* If arg0 is derived from the address of an object or function, we may
10984          be able to fold this expression using the object or function's
10985          alignment.  */
10986       if (POINTER_TYPE_P (TREE_TYPE (arg0)) && host_integerp (arg1, 1))
10987         {
10988           unsigned HOST_WIDE_INT modulus, residue;
10989           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (arg1);
10990
10991           modulus = get_pointer_modulus_and_residue (arg0, &residue);
10992
10993           /* This works because modulus is a power of 2.  If this weren't the
10994              case, we'd have to replace it by its greatest power-of-2
10995              divisor: modulus & -modulus.  */
10996           if (low < modulus)
10997             return build_int_cst (type, residue & low);
10998         }
10999
11000       /* Fold (X << C1) & C2 into (X << C1) & (C2 | ((1 << C1) - 1))
11001               (X >> C1) & C2 into (X >> C1) & (C2 | ~((type) -1 >> C1))
11002          if the new mask might be further optimized.  */
11003       if ((TREE_CODE (arg0) == LSHIFT_EXPR
11004            || TREE_CODE (arg0) == RSHIFT_EXPR)
11005           && host_integerp (TREE_OPERAND (arg0, 1), 1)
11006           && host_integerp (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)))
11007           && tree_low_cst (TREE_OPERAND (arg0, 1), 1)
11008              < TYPE_PRECISION (TREE_TYPE (arg0))
11009           && TYPE_PRECISION (TREE_TYPE (arg0)) <= HOST_BITS_PER_WIDE_INT
11010           && tree_low_cst (TREE_OPERAND (arg0, 1), 1) > 0)
11011         {
11012           unsigned int shiftc = tree_low_cst (TREE_OPERAND (arg0, 1), 1);
11013           unsigned HOST_WIDE_INT mask
11014             = tree_low_cst (arg1, TYPE_UNSIGNED (TREE_TYPE (arg1)));
11015           unsigned HOST_WIDE_INT newmask, zerobits = 0;
11016           tree shift_type = TREE_TYPE (arg0);
11017
11018           if (TREE_CODE (arg0) == LSHIFT_EXPR)
11019             zerobits = ((((unsigned HOST_WIDE_INT) 1) << shiftc) - 1);
11020           else if (TREE_CODE (arg0) == RSHIFT_EXPR
11021                    && TYPE_PRECISION (TREE_TYPE (arg0))
11022                       == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg0))))
11023             {
11024               unsigned int prec = TYPE_PRECISION (TREE_TYPE (arg0));
11025               tree arg00 = TREE_OPERAND (arg0, 0);
11026               /* See if more bits can be proven as zero because of
11027                  zero extension.  */
11028               if (TREE_CODE (arg00) == NOP_EXPR
11029                   && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg00, 0))))
11030                 {
11031                   tree inner_type = TREE_TYPE (TREE_OPERAND (arg00, 0));
11032                   if (TYPE_PRECISION (inner_type)
11033                       == GET_MODE_BITSIZE (TYPE_MODE (inner_type))
11034                       && TYPE_PRECISION (inner_type) < prec)
11035                     {
11036                       prec = TYPE_PRECISION (inner_type);
11037                       /* See if we can shorten the right shift.  */
11038                       if (shiftc < prec)
11039                         shift_type = inner_type;
11040                     }
11041                 }
11042               zerobits = ~(unsigned HOST_WIDE_INT) 0;
11043               zerobits >>= HOST_BITS_PER_WIDE_INT - shiftc;
11044               zerobits <<= prec - shiftc;
11045               /* For arithmetic shift if sign bit could be set, zerobits
11046                  can contain actually sign bits, so no transformation is
11047                  possible, unless MASK masks them all away.  In that
11048                  case the shift needs to be converted into logical shift.  */
11049               if (!TYPE_UNSIGNED (TREE_TYPE (arg0))
11050                   && prec == TYPE_PRECISION (TREE_TYPE (arg0)))
11051                 {
11052                   if ((mask & zerobits) == 0)
11053                     shift_type = unsigned_type_for (TREE_TYPE (arg0));
11054                   else
11055                     zerobits = 0;
11056                 }
11057             }
11058
11059           /* ((X << 16) & 0xff00) is (X, 0).  */
11060           if ((mask & zerobits) == mask)
11061             return omit_one_operand (type, build_int_cst (type, 0), arg0);
11062
11063           newmask = mask | zerobits;
11064           if (newmask != mask && (newmask & (newmask + 1)) == 0)
11065             {
11066               unsigned int prec;
11067
11068               /* Only do the transformation if NEWMASK is some integer
11069                  mode's mask.  */
11070               for (prec = BITS_PER_UNIT;
11071                    prec < HOST_BITS_PER_WIDE_INT; prec <<= 1)
11072                 if (newmask == (((unsigned HOST_WIDE_INT) 1) << prec) - 1)
11073                   break;
11074               if (prec < HOST_BITS_PER_WIDE_INT
11075                   || newmask == ~(unsigned HOST_WIDE_INT) 0)
11076                 {
11077                   if (shift_type != TREE_TYPE (arg0))
11078                     {
11079                       tem = fold_build2 (TREE_CODE (arg0), shift_type,
11080                                          fold_convert (shift_type,
11081                                                        TREE_OPERAND (arg0, 0)),
11082                                          TREE_OPERAND (arg0, 1));
11083                       tem = fold_convert (type, tem);
11084                     }
11085                   else
11086                     tem = op0;
11087                   return fold_build2 (BIT_AND_EXPR, type, tem,
11088                                       build_int_cst_type (TREE_TYPE (op1),
11089                                                           newmask));
11090                 }
11091             }
11092         }
11093
11094       goto associate;
11095
11096     case RDIV_EXPR:
11097       /* Don't touch a floating-point divide by zero unless the mode
11098          of the constant can represent infinity.  */
11099       if (TREE_CODE (arg1) == REAL_CST
11100           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
11101           && real_zerop (arg1))
11102         return NULL_TREE;
11103
11104       /* Optimize A / A to 1.0 if we don't care about
11105          NaNs or Infinities.  Skip the transformation
11106          for non-real operands.  */
11107       if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
11108           && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11109           && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
11110           && operand_equal_p (arg0, arg1, 0))
11111         {
11112           tree r = build_real (TREE_TYPE (arg0), dconst1);
11113
11114           return omit_two_operands (type, r, arg0, arg1);
11115         }
11116
11117       /* The complex version of the above A / A optimization.  */
11118       if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
11119           && operand_equal_p (arg0, arg1, 0))
11120         {
11121           tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
11122           if (! HONOR_NANS (TYPE_MODE (elem_type))
11123               && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
11124             {
11125               tree r = build_real (elem_type, dconst1);
11126               /* omit_two_operands will call fold_convert for us.  */
11127               return omit_two_operands (type, r, arg0, arg1);
11128             }
11129         }
11130
11131       /* (-A) / (-B) -> A / B  */
11132       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
11133         return fold_build2 (RDIV_EXPR, type,
11134                             TREE_OPERAND (arg0, 0),
11135                             negate_expr (arg1));
11136       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
11137         return fold_build2 (RDIV_EXPR, type,
11138                             negate_expr (arg0),
11139                             TREE_OPERAND (arg1, 0));
11140
11141       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
11142       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11143           && real_onep (arg1))
11144         return non_lvalue (fold_convert (type, arg0));
11145
11146       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
11147       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
11148           && real_minus_onep (arg1))
11149         return non_lvalue (fold_convert (type, negate_expr (arg0)));
11150
11151       /* If ARG1 is a constant, we can convert this to a multiply by the
11152          reciprocal.  This does not have the same rounding properties,
11153          so only do this if -freciprocal-math.  We can actually
11154          always safely do it if ARG1 is a power of two, but it's hard to
11155          tell if it is or not in a portable manner.  */
11156       if (TREE_CODE (arg1) == REAL_CST)
11157         {
11158           if (flag_reciprocal_math
11159               && 0 != (tem = const_binop (code, build_real (type, dconst1),
11160                                           arg1, 0)))
11161             return fold_build2 (MULT_EXPR, type, arg0, tem);
11162           /* Find the reciprocal if optimizing and the result is exact.  */
11163           if (optimize)
11164             {
11165               REAL_VALUE_TYPE r;
11166               r = TREE_REAL_CST (arg1);
11167               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
11168                 {
11169                   tem = build_real (type, r);
11170                   return fold_build2 (MULT_EXPR, type,
11171                                       fold_convert (type, arg0), tem);
11172                 }
11173             }
11174         }
11175       /* Convert A/B/C to A/(B*C).  */ 
11176       if (flag_reciprocal_math
11177           && TREE_CODE (arg0) == RDIV_EXPR)
11178         return fold_build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
11179                             fold_build2 (MULT_EXPR, type,
11180                                          TREE_OPERAND (arg0, 1), arg1));
11181
11182       /* Convert A/(B/C) to (A/B)*C.  */
11183       if (flag_reciprocal_math
11184           && TREE_CODE (arg1) == RDIV_EXPR)
11185         return fold_build2 (MULT_EXPR, type,
11186                             fold_build2 (RDIV_EXPR, type, arg0,
11187                                          TREE_OPERAND (arg1, 0)),
11188                             TREE_OPERAND (arg1, 1));
11189
11190       /* Convert C1/(X*C2) into (C1/C2)/X.  */
11191       if (flag_reciprocal_math
11192           && TREE_CODE (arg1) == MULT_EXPR
11193           && TREE_CODE (arg0) == REAL_CST
11194           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
11195         {
11196           tree tem = const_binop (RDIV_EXPR, arg0,
11197                                   TREE_OPERAND (arg1, 1), 0);
11198           if (tem)
11199             return fold_build2 (RDIV_EXPR, type, tem,
11200                                 TREE_OPERAND (arg1, 0));
11201         }
11202
11203       if (flag_unsafe_math_optimizations)
11204         {
11205           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
11206           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
11207
11208           /* Optimize sin(x)/cos(x) as tan(x).  */
11209           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
11210                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
11211                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
11212               && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11213                                   CALL_EXPR_ARG (arg1, 0), 0))
11214             {
11215               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11216
11217               if (tanfn != NULL_TREE)
11218                 return build_call_expr (tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11219             }
11220
11221           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
11222           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
11223                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
11224                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
11225               && operand_equal_p (CALL_EXPR_ARG (arg0, 0),
11226                                   CALL_EXPR_ARG (arg1, 0), 0))
11227             {
11228               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
11229
11230               if (tanfn != NULL_TREE)
11231                 {
11232                   tree tmp = build_call_expr (tanfn, 1, CALL_EXPR_ARG (arg0, 0));
11233                   return fold_build2 (RDIV_EXPR, type,
11234                                       build_real (type, dconst1), tmp);
11235                 }
11236             }
11237
11238           /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
11239              NaNs or Infinities.  */
11240           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
11241                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
11242                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
11243             {
11244               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11245               tree arg01 = CALL_EXPR_ARG (arg1, 0);
11246
11247               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11248                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11249                   && operand_equal_p (arg00, arg01, 0))
11250                 {
11251                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11252
11253                   if (cosfn != NULL_TREE)
11254                     return build_call_expr (cosfn, 1, arg00);
11255                 }
11256             }
11257
11258           /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
11259              NaNs or Infinities.  */
11260           if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
11261                || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
11262                || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
11263             {
11264               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11265               tree arg01 = CALL_EXPR_ARG (arg1, 0);
11266
11267               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
11268                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
11269                   && operand_equal_p (arg00, arg01, 0))
11270                 {
11271                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
11272
11273                   if (cosfn != NULL_TREE)
11274                     {
11275                       tree tmp = build_call_expr (cosfn, 1, arg00);
11276                       return fold_build2 (RDIV_EXPR, type,
11277                                           build_real (type, dconst1),
11278                                           tmp);
11279                     }
11280                 }
11281             }
11282
11283           /* Optimize pow(x,c)/x as pow(x,c-1).  */
11284           if (fcode0 == BUILT_IN_POW
11285               || fcode0 == BUILT_IN_POWF
11286               || fcode0 == BUILT_IN_POWL)
11287             {
11288               tree arg00 = CALL_EXPR_ARG (arg0, 0);
11289               tree arg01 = CALL_EXPR_ARG (arg0, 1);
11290               if (TREE_CODE (arg01) == REAL_CST
11291                   && !TREE_OVERFLOW (arg01)
11292                   && operand_equal_p (arg1, arg00, 0))
11293                 {
11294                   tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
11295                   REAL_VALUE_TYPE c;
11296                   tree arg;
11297
11298                   c = TREE_REAL_CST (arg01);
11299                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
11300                   arg = build_real (type, c);
11301                   return build_call_expr (powfn, 2, arg1, arg);
11302                 }
11303             }
11304
11305           /* Optimize a/root(b/c) into a*root(c/b).  */
11306           if (BUILTIN_ROOT_P (fcode1))
11307             {
11308               tree rootarg = CALL_EXPR_ARG (arg1, 0);
11309
11310               if (TREE_CODE (rootarg) == RDIV_EXPR)
11311                 {
11312                   tree rootfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11313                   tree b = TREE_OPERAND (rootarg, 0);
11314                   tree c = TREE_OPERAND (rootarg, 1);
11315
11316                   tree tmp = fold_build2 (RDIV_EXPR, type, c, b);
11317
11318                   tmp = build_call_expr (rootfn, 1, tmp);
11319                   return fold_build2 (MULT_EXPR, type, arg0, tmp);
11320                 }
11321             }
11322
11323           /* Optimize x/expN(y) into x*expN(-y).  */
11324           if (BUILTIN_EXPONENT_P (fcode1))
11325             {
11326               tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11327               tree arg = negate_expr (CALL_EXPR_ARG (arg1, 0));
11328               arg1 = build_call_expr (expfn, 1, fold_convert (type, arg));
11329               return fold_build2 (MULT_EXPR, type, arg0, arg1);
11330             }
11331
11332           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
11333           if (fcode1 == BUILT_IN_POW
11334               || fcode1 == BUILT_IN_POWF
11335               || fcode1 == BUILT_IN_POWL)
11336             {
11337               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg1), 0);
11338               tree arg10 = CALL_EXPR_ARG (arg1, 0);
11339               tree arg11 = CALL_EXPR_ARG (arg1, 1);
11340               tree neg11 = fold_convert (type, negate_expr (arg11));
11341               arg1 = build_call_expr (powfn, 2, arg10, neg11);
11342               return fold_build2 (MULT_EXPR, type, arg0, arg1);
11343             }
11344         }
11345       return NULL_TREE;
11346
11347     case TRUNC_DIV_EXPR:
11348     case FLOOR_DIV_EXPR:
11349       /* Simplify A / (B << N) where A and B are positive and B is
11350          a power of 2, to A >> (N + log2(B)).  */
11351       strict_overflow_p = false;
11352       if (TREE_CODE (arg1) == LSHIFT_EXPR
11353           && (TYPE_UNSIGNED (type)
11354               || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11355         {
11356           tree sval = TREE_OPERAND (arg1, 0);
11357           if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
11358             {
11359               tree sh_cnt = TREE_OPERAND (arg1, 1);
11360               unsigned long pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
11361
11362               if (strict_overflow_p)
11363                 fold_overflow_warning (("assuming signed overflow does not "
11364                                         "occur when simplifying A / (B << N)"),
11365                                        WARN_STRICT_OVERFLOW_MISC);
11366
11367               sh_cnt = fold_build2 (PLUS_EXPR, TREE_TYPE (sh_cnt),
11368                                     sh_cnt, build_int_cst (NULL_TREE, pow2));
11369               return fold_build2 (RSHIFT_EXPR, type,
11370                                   fold_convert (type, arg0), sh_cnt);
11371             }
11372         }
11373
11374       /* For unsigned integral types, FLOOR_DIV_EXPR is the same as
11375          TRUNC_DIV_EXPR.  Rewrite into the latter in this case.  */
11376       if (INTEGRAL_TYPE_P (type)
11377           && TYPE_UNSIGNED (type)
11378           && code == FLOOR_DIV_EXPR)
11379         return fold_build2 (TRUNC_DIV_EXPR, type, op0, op1);
11380
11381       /* Fall thru */
11382
11383     case ROUND_DIV_EXPR:
11384     case CEIL_DIV_EXPR:
11385     case EXACT_DIV_EXPR:
11386       if (integer_onep (arg1))
11387         return non_lvalue (fold_convert (type, arg0));
11388       if (integer_zerop (arg1))
11389         return NULL_TREE;
11390       /* X / -1 is -X.  */
11391       if (!TYPE_UNSIGNED (type)
11392           && TREE_CODE (arg1) == INTEGER_CST
11393           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
11394           && TREE_INT_CST_HIGH (arg1) == -1)
11395         return fold_convert (type, negate_expr (arg0));
11396
11397       /* Convert -A / -B to A / B when the type is signed and overflow is
11398          undefined.  */
11399       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
11400           && TREE_CODE (arg0) == NEGATE_EXPR
11401           && negate_expr_p (arg1))
11402         {
11403           if (INTEGRAL_TYPE_P (type))
11404             fold_overflow_warning (("assuming signed overflow does not occur "
11405                                     "when distributing negation across "
11406                                     "division"),
11407                                    WARN_STRICT_OVERFLOW_MISC);
11408           return fold_build2 (code, type,
11409                               fold_convert (type, TREE_OPERAND (arg0, 0)),
11410                               negate_expr (arg1));
11411         }
11412       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
11413           && TREE_CODE (arg1) == NEGATE_EXPR
11414           && negate_expr_p (arg0))
11415         {
11416           if (INTEGRAL_TYPE_P (type))
11417             fold_overflow_warning (("assuming signed overflow does not occur "
11418                                     "when distributing negation across "
11419                                     "division"),
11420                                    WARN_STRICT_OVERFLOW_MISC);
11421           return fold_build2 (code, type, negate_expr (arg0),
11422                               TREE_OPERAND (arg1, 0));
11423         }
11424
11425       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
11426          operation, EXACT_DIV_EXPR.
11427
11428          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
11429          At one time others generated faster code, it's not clear if they do
11430          after the last round to changes to the DIV code in expmed.c.  */
11431       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
11432           && multiple_of_p (type, arg0, arg1))
11433         return fold_build2 (EXACT_DIV_EXPR, type, arg0, arg1);
11434
11435       strict_overflow_p = false;
11436       if (TREE_CODE (arg1) == INTEGER_CST
11437           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11438                                          &strict_overflow_p)))
11439         {
11440           if (strict_overflow_p)
11441             fold_overflow_warning (("assuming signed overflow does not occur "
11442                                     "when simplifying division"),
11443                                    WARN_STRICT_OVERFLOW_MISC);
11444           return fold_convert (type, tem);
11445         }
11446
11447       return NULL_TREE;
11448
11449     case CEIL_MOD_EXPR:
11450     case FLOOR_MOD_EXPR:
11451     case ROUND_MOD_EXPR:
11452     case TRUNC_MOD_EXPR:
11453       /* X % 1 is always zero, but be sure to preserve any side
11454          effects in X.  */
11455       if (integer_onep (arg1))
11456         return omit_one_operand (type, integer_zero_node, arg0);
11457
11458       /* X % 0, return X % 0 unchanged so that we can get the
11459          proper warnings and errors.  */
11460       if (integer_zerop (arg1))
11461         return NULL_TREE;
11462
11463       /* 0 % X is always zero, but be sure to preserve any side
11464          effects in X.  Place this after checking for X == 0.  */
11465       if (integer_zerop (arg0))
11466         return omit_one_operand (type, integer_zero_node, arg1);
11467
11468       /* X % -1 is zero.  */
11469       if (!TYPE_UNSIGNED (type)
11470           && TREE_CODE (arg1) == INTEGER_CST
11471           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
11472           && TREE_INT_CST_HIGH (arg1) == -1)
11473         return omit_one_operand (type, integer_zero_node, arg0);
11474
11475       /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
11476          i.e. "X % C" into "X & (C - 1)", if X and C are positive.  */
11477       strict_overflow_p = false;
11478       if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
11479           && (TYPE_UNSIGNED (type)
11480               || tree_expr_nonnegative_warnv_p (op0, &strict_overflow_p)))
11481         {
11482           tree c = arg1;
11483           /* Also optimize A % (C << N)  where C is a power of 2,
11484              to A & ((C << N) - 1).  */
11485           if (TREE_CODE (arg1) == LSHIFT_EXPR)
11486             c = TREE_OPERAND (arg1, 0);
11487
11488           if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
11489             {
11490               tree mask = fold_build2 (MINUS_EXPR, TREE_TYPE (arg1), arg1,
11491                                        build_int_cst (TREE_TYPE (arg1), 1));
11492               if (strict_overflow_p)
11493                 fold_overflow_warning (("assuming signed overflow does not "
11494                                         "occur when simplifying "
11495                                         "X % (power of two)"),
11496                                        WARN_STRICT_OVERFLOW_MISC);
11497               return fold_build2 (BIT_AND_EXPR, type,
11498                                   fold_convert (type, arg0),
11499                                   fold_convert (type, mask));
11500             }
11501         }
11502
11503       /* X % -C is the same as X % C.  */
11504       if (code == TRUNC_MOD_EXPR
11505           && !TYPE_UNSIGNED (type)
11506           && TREE_CODE (arg1) == INTEGER_CST
11507           && !TREE_OVERFLOW (arg1)
11508           && TREE_INT_CST_HIGH (arg1) < 0
11509           && !TYPE_OVERFLOW_TRAPS (type)
11510           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
11511           && !sign_bit_p (arg1, arg1))
11512         return fold_build2 (code, type, fold_convert (type, arg0),
11513                             fold_convert (type, negate_expr (arg1)));
11514
11515       /* X % -Y is the same as X % Y.  */
11516       if (code == TRUNC_MOD_EXPR
11517           && !TYPE_UNSIGNED (type)
11518           && TREE_CODE (arg1) == NEGATE_EXPR
11519           && !TYPE_OVERFLOW_TRAPS (type))
11520         return fold_build2 (code, type, fold_convert (type, arg0),
11521                             fold_convert (type, TREE_OPERAND (arg1, 0)));
11522
11523       if (TREE_CODE (arg1) == INTEGER_CST
11524           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
11525                                          &strict_overflow_p)))
11526         {
11527           if (strict_overflow_p)
11528             fold_overflow_warning (("assuming signed overflow does not occur "
11529                                     "when simplifying modulos"),
11530                                    WARN_STRICT_OVERFLOW_MISC);
11531           return fold_convert (type, tem);
11532         }
11533
11534       return NULL_TREE;
11535
11536     case LROTATE_EXPR:
11537     case RROTATE_EXPR:
11538       if (integer_all_onesp (arg0))
11539         return omit_one_operand (type, arg0, arg1);
11540       goto shift;
11541
11542     case RSHIFT_EXPR:
11543       /* Optimize -1 >> x for arithmetic right shifts.  */
11544       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
11545         return omit_one_operand (type, arg0, arg1);
11546       /* ... fall through ...  */
11547
11548     case LSHIFT_EXPR:
11549     shift:
11550       if (integer_zerop (arg1))
11551         return non_lvalue (fold_convert (type, arg0));
11552       if (integer_zerop (arg0))
11553         return omit_one_operand (type, arg0, arg1);
11554
11555       /* Since negative shift count is not well-defined,
11556          don't try to compute it in the compiler.  */
11557       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
11558         return NULL_TREE;
11559
11560       /* Turn (a OP c1) OP c2 into a OP (c1+c2).  */
11561       if (TREE_CODE (op0) == code && host_integerp (arg1, false)
11562           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
11563           && host_integerp (TREE_OPERAND (arg0, 1), false)
11564           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
11565         {
11566           HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
11567                                + TREE_INT_CST_LOW (arg1));
11568
11569           /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
11570              being well defined.  */
11571           if (low >= TYPE_PRECISION (type))
11572             {
11573               if (code == LROTATE_EXPR || code == RROTATE_EXPR)
11574                 low = low % TYPE_PRECISION (type);
11575               else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
11576                 return build_int_cst (type, 0);
11577               else
11578                 low = TYPE_PRECISION (type) - 1;
11579             }
11580
11581           return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
11582                               build_int_cst (type, low));
11583         }
11584
11585       /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
11586          into x & ((unsigned)-1 >> c) for unsigned types.  */
11587       if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
11588            || (TYPE_UNSIGNED (type)
11589                && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
11590           && host_integerp (arg1, false)
11591           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
11592           && host_integerp (TREE_OPERAND (arg0, 1), false)
11593           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
11594         {
11595           HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
11596           HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
11597           tree lshift;
11598           tree arg00;
11599
11600           if (low0 == low1)
11601             {
11602               arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
11603
11604               lshift = build_int_cst (type, -1);
11605               lshift = int_const_binop (code, lshift, arg1, 0);
11606
11607               return fold_build2 (BIT_AND_EXPR, type, arg00, lshift);
11608             }
11609         }
11610
11611       /* Rewrite an LROTATE_EXPR by a constant into an
11612          RROTATE_EXPR by a new constant.  */
11613       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
11614         {
11615           tree tem = build_int_cst (TREE_TYPE (arg1),
11616                                     GET_MODE_BITSIZE (TYPE_MODE (type)));
11617           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
11618           return fold_build2 (RROTATE_EXPR, type, op0, tem);
11619         }
11620
11621       /* If we have a rotate of a bit operation with the rotate count and
11622          the second operand of the bit operation both constant,
11623          permute the two operations.  */
11624       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
11625           && (TREE_CODE (arg0) == BIT_AND_EXPR
11626               || TREE_CODE (arg0) == BIT_IOR_EXPR
11627               || TREE_CODE (arg0) == BIT_XOR_EXPR)
11628           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11629         return fold_build2 (TREE_CODE (arg0), type,
11630                             fold_build2 (code, type,
11631                                          TREE_OPERAND (arg0, 0), arg1),
11632                             fold_build2 (code, type,
11633                                          TREE_OPERAND (arg0, 1), arg1));
11634
11635       /* Two consecutive rotates adding up to the width of the mode can
11636          be ignored.  */
11637       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
11638           && TREE_CODE (arg0) == RROTATE_EXPR
11639           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11640           && TREE_INT_CST_HIGH (arg1) == 0
11641           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
11642           && ((TREE_INT_CST_LOW (arg1)
11643                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
11644               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
11645         return TREE_OPERAND (arg0, 0);
11646
11647       /* Fold (X & C2) << C1 into (X << C1) & (C2 << C1)
11648               (X & C2) >> C1 into (X >> C1) & (C2 >> C1)
11649          if the latter can be further optimized.  */
11650       if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR)
11651           && TREE_CODE (arg0) == BIT_AND_EXPR
11652           && TREE_CODE (arg1) == INTEGER_CST
11653           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11654         {
11655           tree mask = fold_build2 (code, type,
11656                                    fold_convert (type, TREE_OPERAND (arg0, 1)),
11657                                    arg1);
11658           tree shift = fold_build2 (code, type,
11659                                     fold_convert (type, TREE_OPERAND (arg0, 0)),
11660                                     arg1);
11661           tem = fold_binary (BIT_AND_EXPR, type, shift, mask);
11662           if (tem)
11663             return tem;
11664         }
11665
11666       return NULL_TREE;
11667
11668     case MIN_EXPR:
11669       if (operand_equal_p (arg0, arg1, 0))
11670         return omit_one_operand (type, arg0, arg1);
11671       if (INTEGRAL_TYPE_P (type)
11672           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
11673         return omit_one_operand (type, arg1, arg0);
11674       tem = fold_minmax (MIN_EXPR, type, arg0, arg1);
11675       if (tem)
11676         return tem;
11677       goto associate;
11678
11679     case MAX_EXPR:
11680       if (operand_equal_p (arg0, arg1, 0))
11681         return omit_one_operand (type, arg0, arg1);
11682       if (INTEGRAL_TYPE_P (type)
11683           && TYPE_MAX_VALUE (type)
11684           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
11685         return omit_one_operand (type, arg1, arg0);
11686       tem = fold_minmax (MAX_EXPR, type, arg0, arg1);
11687       if (tem)
11688         return tem;
11689       goto associate;
11690
11691     case TRUTH_ANDIF_EXPR:
11692       /* Note that the operands of this must be ints
11693          and their values must be 0 or 1.
11694          ("true" is a fixed value perhaps depending on the language.)  */
11695       /* If first arg is constant zero, return it.  */
11696       if (integer_zerop (arg0))
11697         return fold_convert (type, arg0);
11698     case TRUTH_AND_EXPR:
11699       /* If either arg is constant true, drop it.  */
11700       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
11701         return non_lvalue (fold_convert (type, arg1));
11702       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
11703           /* Preserve sequence points.  */
11704           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
11705         return non_lvalue (fold_convert (type, arg0));
11706       /* If second arg is constant zero, result is zero, but first arg
11707          must be evaluated.  */
11708       if (integer_zerop (arg1))
11709         return omit_one_operand (type, arg1, arg0);
11710       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
11711          case will be handled here.  */
11712       if (integer_zerop (arg0))
11713         return omit_one_operand (type, arg0, arg1);
11714
11715       /* !X && X is always false.  */
11716       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
11717           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11718         return omit_one_operand (type, integer_zero_node, arg1);
11719       /* X && !X is always false.  */
11720       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
11721           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11722         return omit_one_operand (type, integer_zero_node, arg0);
11723
11724       /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
11725          means A >= Y && A != MAX, but in this case we know that
11726          A < X <= MAX.  */
11727
11728       if (!TREE_SIDE_EFFECTS (arg0)
11729           && !TREE_SIDE_EFFECTS (arg1))
11730         {
11731           tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
11732           if (tem && !operand_equal_p (tem, arg0, 0))
11733             return fold_build2 (code, type, tem, arg1);
11734
11735           tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
11736           if (tem && !operand_equal_p (tem, arg1, 0))
11737             return fold_build2 (code, type, arg0, tem);
11738         }
11739
11740     truth_andor:
11741       /* We only do these simplifications if we are optimizing.  */
11742       if (!optimize)
11743         return NULL_TREE;
11744
11745       /* Check for things like (A || B) && (A || C).  We can convert this
11746          to A || (B && C).  Note that either operator can be any of the four
11747          truth and/or operations and the transformation will still be
11748          valid.   Also note that we only care about order for the
11749          ANDIF and ORIF operators.  If B contains side effects, this
11750          might change the truth-value of A.  */
11751       if (TREE_CODE (arg0) == TREE_CODE (arg1)
11752           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
11753               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
11754               || TREE_CODE (arg0) == TRUTH_AND_EXPR
11755               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
11756           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
11757         {
11758           tree a00 = TREE_OPERAND (arg0, 0);
11759           tree a01 = TREE_OPERAND (arg0, 1);
11760           tree a10 = TREE_OPERAND (arg1, 0);
11761           tree a11 = TREE_OPERAND (arg1, 1);
11762           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
11763                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
11764                              && (code == TRUTH_AND_EXPR
11765                                  || code == TRUTH_OR_EXPR));
11766
11767           if (operand_equal_p (a00, a10, 0))
11768             return fold_build2 (TREE_CODE (arg0), type, a00,
11769                                 fold_build2 (code, type, a01, a11));
11770           else if (commutative && operand_equal_p (a00, a11, 0))
11771             return fold_build2 (TREE_CODE (arg0), type, a00,
11772                                 fold_build2 (code, type, a01, a10));
11773           else if (commutative && operand_equal_p (a01, a10, 0))
11774             return fold_build2 (TREE_CODE (arg0), type, a01,
11775                                 fold_build2 (code, type, a00, a11));
11776
11777           /* This case if tricky because we must either have commutative
11778              operators or else A10 must not have side-effects.  */
11779
11780           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
11781                    && operand_equal_p (a01, a11, 0))
11782             return fold_build2 (TREE_CODE (arg0), type,
11783                                 fold_build2 (code, type, a00, a10),
11784                                 a01);
11785         }
11786
11787       /* See if we can build a range comparison.  */
11788       if (0 != (tem = fold_range_test (code, type, op0, op1)))
11789         return tem;
11790
11791       /* Check for the possibility of merging component references.  If our
11792          lhs is another similar operation, try to merge its rhs with our
11793          rhs.  Then try to merge our lhs and rhs.  */
11794       if (TREE_CODE (arg0) == code
11795           && 0 != (tem = fold_truthop (code, type,
11796                                        TREE_OPERAND (arg0, 1), arg1)))
11797         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
11798
11799       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
11800         return tem;
11801
11802       return NULL_TREE;
11803
11804     case TRUTH_ORIF_EXPR:
11805       /* Note that the operands of this must be ints
11806          and their values must be 0 or true.
11807          ("true" is a fixed value perhaps depending on the language.)  */
11808       /* If first arg is constant true, return it.  */
11809       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
11810         return fold_convert (type, arg0);
11811     case TRUTH_OR_EXPR:
11812       /* If either arg is constant zero, drop it.  */
11813       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
11814         return non_lvalue (fold_convert (type, arg1));
11815       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
11816           /* Preserve sequence points.  */
11817           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
11818         return non_lvalue (fold_convert (type, arg0));
11819       /* If second arg is constant true, result is true, but we must
11820          evaluate first arg.  */
11821       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
11822         return omit_one_operand (type, arg1, arg0);
11823       /* Likewise for first arg, but note this only occurs here for
11824          TRUTH_OR_EXPR.  */
11825       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
11826         return omit_one_operand (type, arg0, arg1);
11827
11828       /* !X || X is always true.  */
11829       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
11830           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11831         return omit_one_operand (type, integer_one_node, arg1);
11832       /* X || !X is always true.  */
11833       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
11834           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11835         return omit_one_operand (type, integer_one_node, arg0);
11836
11837       goto truth_andor;
11838
11839     case TRUTH_XOR_EXPR:
11840       /* If the second arg is constant zero, drop it.  */
11841       if (integer_zerop (arg1))
11842         return non_lvalue (fold_convert (type, arg0));
11843       /* If the second arg is constant true, this is a logical inversion.  */
11844       if (integer_onep (arg1))
11845         {
11846           /* Only call invert_truthvalue if operand is a truth value.  */
11847           if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
11848             tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
11849           else
11850             tem = invert_truthvalue (arg0);
11851           return non_lvalue (fold_convert (type, tem));
11852         }
11853       /* Identical arguments cancel to zero.  */
11854       if (operand_equal_p (arg0, arg1, 0))
11855         return omit_one_operand (type, integer_zero_node, arg0);
11856
11857       /* !X ^ X is always true.  */
11858       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
11859           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
11860         return omit_one_operand (type, integer_one_node, arg1);
11861
11862       /* X ^ !X is always true.  */
11863       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
11864           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
11865         return omit_one_operand (type, integer_one_node, arg0);
11866
11867       return NULL_TREE;
11868
11869     case EQ_EXPR:
11870     case NE_EXPR:
11871       tem = fold_comparison (code, type, op0, op1);
11872       if (tem != NULL_TREE)
11873         return tem;
11874
11875       /* bool_var != 0 becomes bool_var. */
11876       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
11877           && code == NE_EXPR)
11878         return non_lvalue (fold_convert (type, arg0));
11879
11880       /* bool_var == 1 becomes bool_var. */
11881       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
11882           && code == EQ_EXPR)
11883         return non_lvalue (fold_convert (type, arg0));
11884
11885       /* bool_var != 1 becomes !bool_var. */
11886       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
11887           && code == NE_EXPR)
11888         return fold_build1 (TRUTH_NOT_EXPR, type, fold_convert (type, arg0));
11889
11890       /* bool_var == 0 becomes !bool_var. */
11891       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
11892           && code == EQ_EXPR)
11893         return fold_build1 (TRUTH_NOT_EXPR, type, fold_convert (type, arg0));
11894
11895       /* If this is an equality comparison of the address of two non-weak,
11896          unaliased symbols neither of which are extern (since we do not
11897          have access to attributes for externs), then we know the result.  */
11898       if (TREE_CODE (arg0) == ADDR_EXPR
11899           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
11900           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
11901           && ! lookup_attribute ("alias",
11902                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
11903           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
11904           && TREE_CODE (arg1) == ADDR_EXPR
11905           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
11906           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
11907           && ! lookup_attribute ("alias",
11908                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
11909           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
11910         {
11911           /* We know that we're looking at the address of two
11912              non-weak, unaliased, static _DECL nodes.
11913
11914              It is both wasteful and incorrect to call operand_equal_p
11915              to compare the two ADDR_EXPR nodes.  It is wasteful in that
11916              all we need to do is test pointer equality for the arguments
11917              to the two ADDR_EXPR nodes.  It is incorrect to use
11918              operand_equal_p as that function is NOT equivalent to a
11919              C equality test.  It can in fact return false for two
11920              objects which would test as equal using the C equality
11921              operator.  */
11922           bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
11923           return constant_boolean_node (equal
11924                                         ? code == EQ_EXPR : code != EQ_EXPR,
11925                                         type);
11926         }
11927
11928       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
11929          a MINUS_EXPR of a constant, we can convert it into a comparison with
11930          a revised constant as long as no overflow occurs.  */
11931       if (TREE_CODE (arg1) == INTEGER_CST
11932           && (TREE_CODE (arg0) == PLUS_EXPR
11933               || TREE_CODE (arg0) == MINUS_EXPR)
11934           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11935           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
11936                                       ? MINUS_EXPR : PLUS_EXPR,
11937                                       fold_convert (TREE_TYPE (arg0), arg1),
11938                                       TREE_OPERAND (arg0, 1), 0))
11939           && !TREE_OVERFLOW (tem))
11940         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
11941
11942       /* Similarly for a NEGATE_EXPR.  */
11943       if (TREE_CODE (arg0) == NEGATE_EXPR
11944           && TREE_CODE (arg1) == INTEGER_CST
11945           && 0 != (tem = negate_expr (arg1))
11946           && TREE_CODE (tem) == INTEGER_CST
11947           && !TREE_OVERFLOW (tem))
11948         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
11949
11950       /* Similarly for a BIT_XOR_EXPR;  X ^ C1 == C2 is X == (C1 ^ C2).  */
11951       if (TREE_CODE (arg0) == BIT_XOR_EXPR
11952           && TREE_CODE (arg1) == INTEGER_CST
11953           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
11954         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
11955                             fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg0),
11956                                          fold_convert (TREE_TYPE (arg0), arg1),
11957                                          TREE_OPERAND (arg0, 1)));
11958
11959       /* Transform comparisons of the form X +- C CMP X.  */
11960       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
11961           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
11962           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
11963           && (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
11964               || POINTER_TYPE_P (TREE_TYPE (arg0))))
11965         {
11966           tree cst = TREE_OPERAND (arg0, 1);
11967
11968           if (code == EQ_EXPR
11969               && !integer_zerop (cst))
11970             return omit_two_operands (type, boolean_false_node,
11971                                       TREE_OPERAND (arg0, 0), arg1);
11972           else
11973             return omit_two_operands (type, boolean_true_node,
11974                                       TREE_OPERAND (arg0, 0), arg1);
11975         }
11976
11977       /* If we have X - Y == 0, we can convert that to X == Y and similarly
11978          for !=.  Don't do this for ordered comparisons due to overflow.  */
11979       if (TREE_CODE (arg0) == MINUS_EXPR
11980           && integer_zerop (arg1))
11981         return fold_build2 (code, type,
11982                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
11983
11984       /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.  */
11985       if (TREE_CODE (arg0) == ABS_EXPR
11986           && (integer_zerop (arg1) || real_zerop (arg1)))
11987         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), arg1);
11988
11989       /* If this is an EQ or NE comparison with zero and ARG0 is
11990          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
11991          two operations, but the latter can be done in one less insn
11992          on machines that have only two-operand insns or on which a
11993          constant cannot be the first operand.  */
11994       if (TREE_CODE (arg0) == BIT_AND_EXPR
11995           && integer_zerop (arg1))
11996         {
11997           tree arg00 = TREE_OPERAND (arg0, 0);
11998           tree arg01 = TREE_OPERAND (arg0, 1);
11999           if (TREE_CODE (arg00) == LSHIFT_EXPR
12000               && integer_onep (TREE_OPERAND (arg00, 0)))
12001             {
12002               tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
12003                                       arg01, TREE_OPERAND (arg00, 1));
12004               tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12005                                  build_int_cst (TREE_TYPE (arg0), 1));
12006               return fold_build2 (code, type,
12007                                   fold_convert (TREE_TYPE (arg1), tem), arg1);
12008             }
12009           else if (TREE_CODE (arg01) == LSHIFT_EXPR
12010                    && integer_onep (TREE_OPERAND (arg01, 0)))
12011             {
12012               tree tem = fold_build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
12013                                       arg00, TREE_OPERAND (arg01, 1));
12014               tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0), tem,
12015                                  build_int_cst (TREE_TYPE (arg0), 1));
12016               return fold_build2 (code, type,
12017                                   fold_convert (TREE_TYPE (arg1), tem), arg1);
12018             }
12019         }
12020
12021       /* If this is an NE or EQ comparison of zero against the result of a
12022          signed MOD operation whose second operand is a power of 2, make
12023          the MOD operation unsigned since it is simpler and equivalent.  */
12024       if (integer_zerop (arg1)
12025           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
12026           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
12027               || TREE_CODE (arg0) == CEIL_MOD_EXPR
12028               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
12029               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
12030           && integer_pow2p (TREE_OPERAND (arg0, 1)))
12031         {
12032           tree newtype = unsigned_type_for (TREE_TYPE (arg0));
12033           tree newmod = fold_build2 (TREE_CODE (arg0), newtype,
12034                                      fold_convert (newtype,
12035                                                    TREE_OPERAND (arg0, 0)),
12036                                      fold_convert (newtype,
12037                                                    TREE_OPERAND (arg0, 1)));
12038
12039           return fold_build2 (code, type, newmod,
12040                               fold_convert (newtype, arg1));
12041         }
12042
12043       /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
12044          C1 is a valid shift constant, and C2 is a power of two, i.e.
12045          a single bit.  */
12046       if (TREE_CODE (arg0) == BIT_AND_EXPR
12047           && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
12048           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
12049              == INTEGER_CST
12050           && integer_pow2p (TREE_OPERAND (arg0, 1))
12051           && integer_zerop (arg1))
12052         {
12053           tree itype = TREE_TYPE (arg0);
12054           unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
12055           tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
12056
12057           /* Check for a valid shift count.  */
12058           if (TREE_INT_CST_HIGH (arg001) == 0
12059               && TREE_INT_CST_LOW (arg001) < prec)
12060             {
12061               tree arg01 = TREE_OPERAND (arg0, 1);
12062               tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12063               unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
12064               /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
12065                  can be rewritten as (X & (C2 << C1)) != 0.  */
12066               if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
12067                 {
12068                   tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
12069                   tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
12070                   return fold_build2 (code, type, tem, arg1);
12071                 }
12072               /* Otherwise, for signed (arithmetic) shifts,
12073                  ((X >> C1) & C2) != 0 is rewritten as X < 0, and
12074                  ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
12075               else if (!TYPE_UNSIGNED (itype))
12076                 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
12077                                     arg000, build_int_cst (itype, 0));
12078               /* Otherwise, of unsigned (logical) shifts,
12079                  ((X >> C1) & C2) != 0 is rewritten as (X,false), and
12080                  ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
12081               else
12082                 return omit_one_operand (type,
12083                                          code == EQ_EXPR ? integer_one_node
12084                                                          : integer_zero_node,
12085                                          arg000);
12086             }
12087         }
12088
12089       /* If this is an NE comparison of zero with an AND of one, remove the
12090          comparison since the AND will give the correct value.  */
12091       if (code == NE_EXPR
12092           && integer_zerop (arg1)
12093           && TREE_CODE (arg0) == BIT_AND_EXPR
12094           && integer_onep (TREE_OPERAND (arg0, 1)))
12095         return fold_convert (type, arg0);
12096
12097       /* If we have (A & C) == C where C is a power of 2, convert this into
12098          (A & C) != 0.  Similarly for NE_EXPR.  */
12099       if (TREE_CODE (arg0) == BIT_AND_EXPR
12100           && integer_pow2p (TREE_OPERAND (arg0, 1))
12101           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12102         return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12103                             arg0, fold_convert (TREE_TYPE (arg0),
12104                                                 integer_zero_node));
12105
12106       /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
12107          bit, then fold the expression into A < 0 or A >= 0.  */
12108       tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
12109       if (tem)
12110         return tem;
12111
12112       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
12113          Similarly for NE_EXPR.  */
12114       if (TREE_CODE (arg0) == BIT_AND_EXPR
12115           && TREE_CODE (arg1) == INTEGER_CST
12116           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12117         {
12118           tree notc = fold_build1 (BIT_NOT_EXPR,
12119                                    TREE_TYPE (TREE_OPERAND (arg0, 1)),
12120                                    TREE_OPERAND (arg0, 1));
12121           tree dandnotc = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12122                                        arg1, notc);
12123           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12124           if (integer_nonzerop (dandnotc))
12125             return omit_one_operand (type, rslt, arg0);
12126         }
12127
12128       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
12129          Similarly for NE_EXPR.  */
12130       if (TREE_CODE (arg0) == BIT_IOR_EXPR
12131           && TREE_CODE (arg1) == INTEGER_CST
12132           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12133         {
12134           tree notd = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
12135           tree candnotd = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12136                                        TREE_OPERAND (arg0, 1), notd);
12137           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
12138           if (integer_nonzerop (candnotd))
12139             return omit_one_operand (type, rslt, arg0);
12140         }
12141
12142       /* If this is a comparison of a field, we may be able to simplify it.  */
12143       if ((TREE_CODE (arg0) == COMPONENT_REF
12144            || TREE_CODE (arg0) == BIT_FIELD_REF)
12145           /* Handle the constant case even without -O
12146              to make sure the warnings are given.  */
12147           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
12148         {
12149           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
12150           if (t1)
12151             return t1;
12152         }
12153
12154       /* Optimize comparisons of strlen vs zero to a compare of the
12155          first character of the string vs zero.  To wit,
12156                 strlen(ptr) == 0   =>  *ptr == 0
12157                 strlen(ptr) != 0   =>  *ptr != 0
12158          Other cases should reduce to one of these two (or a constant)
12159          due to the return value of strlen being unsigned.  */
12160       if (TREE_CODE (arg0) == CALL_EXPR
12161           && integer_zerop (arg1))
12162         {
12163           tree fndecl = get_callee_fndecl (arg0);
12164
12165           if (fndecl
12166               && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
12167               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
12168               && call_expr_nargs (arg0) == 1
12169               && TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (arg0, 0))) == POINTER_TYPE)
12170             {
12171               tree iref = build_fold_indirect_ref (CALL_EXPR_ARG (arg0, 0));
12172               return fold_build2 (code, type, iref,
12173                                   build_int_cst (TREE_TYPE (iref), 0));
12174             }
12175         }
12176
12177       /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
12178          of X.  Similarly fold (X >> C) == 0 into X >= 0.  */
12179       if (TREE_CODE (arg0) == RSHIFT_EXPR
12180           && integer_zerop (arg1)
12181           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12182         {
12183           tree arg00 = TREE_OPERAND (arg0, 0);
12184           tree arg01 = TREE_OPERAND (arg0, 1);
12185           tree itype = TREE_TYPE (arg00);
12186           if (TREE_INT_CST_HIGH (arg01) == 0
12187               && TREE_INT_CST_LOW (arg01)
12188                  == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
12189             {
12190               if (TYPE_UNSIGNED (itype))
12191                 {
12192                   itype = signed_type_for (itype);
12193                   arg00 = fold_convert (itype, arg00);
12194                 }
12195               return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
12196                                   type, arg00, build_int_cst (itype, 0));
12197             }
12198         }
12199
12200       /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y.  */
12201       if (integer_zerop (arg1)
12202           && TREE_CODE (arg0) == BIT_XOR_EXPR)
12203         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12204                             TREE_OPERAND (arg0, 1));
12205
12206       /* (X ^ Y) == Y becomes X == 0.  We know that Y has no side-effects.  */
12207       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12208           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
12209         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12210                             build_int_cst (TREE_TYPE (arg1), 0));
12211       /* Likewise (X ^ Y) == X becomes Y == 0.  X has no side-effects.  */
12212       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12213           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12214           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
12215         return fold_build2 (code, type, TREE_OPERAND (arg0, 1),
12216                             build_int_cst (TREE_TYPE (arg1), 0));
12217
12218       /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).  */
12219       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12220           && TREE_CODE (arg1) == INTEGER_CST
12221           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
12222         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
12223                             fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg1),
12224                                          TREE_OPERAND (arg0, 1), arg1));
12225
12226       /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
12227          (X & C) == 0 when C is a single bit.  */
12228       if (TREE_CODE (arg0) == BIT_AND_EXPR
12229           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
12230           && integer_zerop (arg1)
12231           && integer_pow2p (TREE_OPERAND (arg0, 1)))
12232         {
12233           tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
12234                              TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
12235                              TREE_OPERAND (arg0, 1));
12236           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
12237                               type, tem, arg1);
12238         }
12239
12240       /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
12241          constant C is a power of two, i.e. a single bit.  */
12242       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12243           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
12244           && integer_zerop (arg1)
12245           && integer_pow2p (TREE_OPERAND (arg0, 1))
12246           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12247                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12248         {
12249           tree arg00 = TREE_OPERAND (arg0, 0);
12250           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12251                               arg00, build_int_cst (TREE_TYPE (arg00), 0));
12252         }
12253
12254       /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
12255          when is C is a power of two, i.e. a single bit.  */
12256       if (TREE_CODE (arg0) == BIT_AND_EXPR
12257           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
12258           && integer_zerop (arg1)
12259           && integer_pow2p (TREE_OPERAND (arg0, 1))
12260           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
12261                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
12262         {
12263           tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
12264           tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg000),
12265                              arg000, TREE_OPERAND (arg0, 1));
12266           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
12267                               tem, build_int_cst (TREE_TYPE (tem), 0));
12268         }
12269
12270       if (integer_zerop (arg1)
12271           && tree_expr_nonzero_p (arg0))
12272         {
12273           tree res = constant_boolean_node (code==NE_EXPR, type);
12274           return omit_one_operand (type, res, arg0);
12275         }
12276
12277       /* Fold -X op -Y as X op Y, where op is eq/ne.  */
12278       if (TREE_CODE (arg0) == NEGATE_EXPR
12279           && TREE_CODE (arg1) == NEGATE_EXPR)
12280         return fold_build2 (code, type,
12281                             TREE_OPERAND (arg0, 0),
12282                             TREE_OPERAND (arg1, 0));
12283
12284       /* Fold (X & C) op (Y & C) as (X ^ Y) & C op 0", and symmetries.  */
12285       if (TREE_CODE (arg0) == BIT_AND_EXPR
12286           && TREE_CODE (arg1) == BIT_AND_EXPR)
12287         {
12288           tree arg00 = TREE_OPERAND (arg0, 0);
12289           tree arg01 = TREE_OPERAND (arg0, 1);
12290           tree arg10 = TREE_OPERAND (arg1, 0);
12291           tree arg11 = TREE_OPERAND (arg1, 1);
12292           tree itype = TREE_TYPE (arg0);
12293
12294           if (operand_equal_p (arg01, arg11, 0))
12295             return fold_build2 (code, type,
12296                                 fold_build2 (BIT_AND_EXPR, itype,
12297                                              fold_build2 (BIT_XOR_EXPR, itype,
12298                                                           arg00, arg10),
12299                                              arg01),
12300                                 build_int_cst (itype, 0));
12301
12302           if (operand_equal_p (arg01, arg10, 0))
12303             return fold_build2 (code, type,
12304                                 fold_build2 (BIT_AND_EXPR, itype,
12305                                              fold_build2 (BIT_XOR_EXPR, itype,
12306                                                           arg00, arg11),
12307                                              arg01),
12308                                 build_int_cst (itype, 0));
12309
12310           if (operand_equal_p (arg00, arg11, 0))
12311             return fold_build2 (code, type,
12312                                 fold_build2 (BIT_AND_EXPR, itype,
12313                                              fold_build2 (BIT_XOR_EXPR, itype,
12314                                                           arg01, arg10),
12315                                              arg00),
12316                                 build_int_cst (itype, 0));
12317
12318           if (operand_equal_p (arg00, arg10, 0))
12319             return fold_build2 (code, type,
12320                                 fold_build2 (BIT_AND_EXPR, itype,
12321                                              fold_build2 (BIT_XOR_EXPR, itype,
12322                                                           arg01, arg11),
12323                                              arg00),
12324                                 build_int_cst (itype, 0));
12325         }
12326
12327       if (TREE_CODE (arg0) == BIT_XOR_EXPR
12328           && TREE_CODE (arg1) == BIT_XOR_EXPR)
12329         {
12330           tree arg00 = TREE_OPERAND (arg0, 0);
12331           tree arg01 = TREE_OPERAND (arg0, 1);
12332           tree arg10 = TREE_OPERAND (arg1, 0);
12333           tree arg11 = TREE_OPERAND (arg1, 1);
12334           tree itype = TREE_TYPE (arg0);
12335
12336           /* Optimize (X ^ Z) op (Y ^ Z) as X op Y, and symmetries.
12337              operand_equal_p guarantees no side-effects so we don't need
12338              to use omit_one_operand on Z.  */
12339           if (operand_equal_p (arg01, arg11, 0))
12340             return fold_build2 (code, type, arg00, arg10);
12341           if (operand_equal_p (arg01, arg10, 0))
12342             return fold_build2 (code, type, arg00, arg11);
12343           if (operand_equal_p (arg00, arg11, 0))
12344             return fold_build2 (code, type, arg01, arg10);
12345           if (operand_equal_p (arg00, arg10, 0))
12346             return fold_build2 (code, type, arg01, arg11);
12347
12348           /* Optimize (X ^ C1) op (Y ^ C2) as (X ^ (C1 ^ C2)) op Y.  */
12349           if (TREE_CODE (arg01) == INTEGER_CST
12350               && TREE_CODE (arg11) == INTEGER_CST)
12351             return fold_build2 (code, type,
12352                                 fold_build2 (BIT_XOR_EXPR, itype, arg00,
12353                                              fold_build2 (BIT_XOR_EXPR, itype,
12354                                                           arg01, arg11)),
12355                                 arg10);
12356         }
12357
12358       /* Attempt to simplify equality/inequality comparisons of complex
12359          values.  Only lower the comparison if the result is known or
12360          can be simplified to a single scalar comparison.  */
12361       if ((TREE_CODE (arg0) == COMPLEX_EXPR
12362            || TREE_CODE (arg0) == COMPLEX_CST)
12363           && (TREE_CODE (arg1) == COMPLEX_EXPR
12364               || TREE_CODE (arg1) == COMPLEX_CST))
12365         {
12366           tree real0, imag0, real1, imag1;
12367           tree rcond, icond;
12368
12369           if (TREE_CODE (arg0) == COMPLEX_EXPR)
12370             {
12371               real0 = TREE_OPERAND (arg0, 0);
12372               imag0 = TREE_OPERAND (arg0, 1);
12373             }
12374           else
12375             {
12376               real0 = TREE_REALPART (arg0);
12377               imag0 = TREE_IMAGPART (arg0);
12378             }
12379
12380           if (TREE_CODE (arg1) == COMPLEX_EXPR)
12381             {
12382               real1 = TREE_OPERAND (arg1, 0);
12383               imag1 = TREE_OPERAND (arg1, 1);
12384             }
12385           else
12386             {
12387               real1 = TREE_REALPART (arg1);
12388               imag1 = TREE_IMAGPART (arg1);
12389             }
12390
12391           rcond = fold_binary (code, type, real0, real1);
12392           if (rcond && TREE_CODE (rcond) == INTEGER_CST)
12393             {
12394               if (integer_zerop (rcond))
12395                 {
12396                   if (code == EQ_EXPR)
12397                     return omit_two_operands (type, boolean_false_node,
12398                                               imag0, imag1);
12399                   return fold_build2 (NE_EXPR, type, imag0, imag1);
12400                 }
12401               else
12402                 {
12403                   if (code == NE_EXPR)
12404                     return omit_two_operands (type, boolean_true_node,
12405                                               imag0, imag1);
12406                   return fold_build2 (EQ_EXPR, type, imag0, imag1);
12407                 }
12408             }
12409
12410           icond = fold_binary (code, type, imag0, imag1);
12411           if (icond && TREE_CODE (icond) == INTEGER_CST)
12412             {
12413               if (integer_zerop (icond))
12414                 {
12415                   if (code == EQ_EXPR)
12416                     return omit_two_operands (type, boolean_false_node,
12417                                               real0, real1);
12418                   return fold_build2 (NE_EXPR, type, real0, real1);
12419                 }
12420               else
12421                 {
12422                   if (code == NE_EXPR)
12423                     return omit_two_operands (type, boolean_true_node,
12424                                               real0, real1);
12425                   return fold_build2 (EQ_EXPR, type, real0, real1);
12426                 }
12427             }
12428         }
12429
12430       return NULL_TREE;
12431
12432     case LT_EXPR:
12433     case GT_EXPR:
12434     case LE_EXPR:
12435     case GE_EXPR:
12436       tem = fold_comparison (code, type, op0, op1);
12437       if (tem != NULL_TREE)
12438         return tem;
12439
12440       /* Transform comparisons of the form X +- C CMP X.  */
12441       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
12442           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
12443           && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
12444                && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
12445               || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
12446                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
12447         {
12448           tree arg01 = TREE_OPERAND (arg0, 1);
12449           enum tree_code code0 = TREE_CODE (arg0);
12450           int is_positive;
12451
12452           if (TREE_CODE (arg01) == REAL_CST)
12453             is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
12454           else
12455             is_positive = tree_int_cst_sgn (arg01);
12456
12457           /* (X - c) > X becomes false.  */
12458           if (code == GT_EXPR
12459               && ((code0 == MINUS_EXPR && is_positive >= 0)
12460                   || (code0 == PLUS_EXPR && is_positive <= 0)))
12461             {
12462               if (TREE_CODE (arg01) == INTEGER_CST
12463                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12464                 fold_overflow_warning (("assuming signed overflow does not "
12465                                         "occur when assuming that (X - c) > X "
12466                                         "is always false"),
12467                                        WARN_STRICT_OVERFLOW_ALL);
12468               return constant_boolean_node (0, type);
12469             }
12470
12471           /* Likewise (X + c) < X becomes false.  */
12472           if (code == LT_EXPR
12473               && ((code0 == PLUS_EXPR && is_positive >= 0)
12474                   || (code0 == MINUS_EXPR && is_positive <= 0)))
12475             {
12476               if (TREE_CODE (arg01) == INTEGER_CST
12477                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12478                 fold_overflow_warning (("assuming signed overflow does not "
12479                                         "occur when assuming that "
12480                                         "(X + c) < X is always false"),
12481                                        WARN_STRICT_OVERFLOW_ALL);
12482               return constant_boolean_node (0, type);
12483             }
12484
12485           /* Convert (X - c) <= X to true.  */
12486           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
12487               && code == LE_EXPR
12488               && ((code0 == MINUS_EXPR && is_positive >= 0)
12489                   || (code0 == PLUS_EXPR && is_positive <= 0)))
12490             {
12491               if (TREE_CODE (arg01) == INTEGER_CST
12492                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12493                 fold_overflow_warning (("assuming signed overflow does not "
12494                                         "occur when assuming that "
12495                                         "(X - c) <= X is always true"),
12496                                        WARN_STRICT_OVERFLOW_ALL);
12497               return constant_boolean_node (1, type);
12498             }
12499
12500           /* Convert (X + c) >= X to true.  */
12501           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
12502               && code == GE_EXPR
12503               && ((code0 == PLUS_EXPR && is_positive >= 0)
12504                   || (code0 == MINUS_EXPR && is_positive <= 0)))
12505             {
12506               if (TREE_CODE (arg01) == INTEGER_CST
12507                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12508                 fold_overflow_warning (("assuming signed overflow does not "
12509                                         "occur when assuming that "
12510                                         "(X + c) >= X is always true"),
12511                                        WARN_STRICT_OVERFLOW_ALL);
12512               return constant_boolean_node (1, type);
12513             }
12514
12515           if (TREE_CODE (arg01) == INTEGER_CST)
12516             {
12517               /* Convert X + c > X and X - c < X to true for integers.  */
12518               if (code == GT_EXPR
12519                   && ((code0 == PLUS_EXPR && is_positive > 0)
12520                       || (code0 == MINUS_EXPR && is_positive < 0)))
12521                 {
12522                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12523                     fold_overflow_warning (("assuming signed overflow does "
12524                                             "not occur when assuming that "
12525                                             "(X + c) > X is always true"),
12526                                            WARN_STRICT_OVERFLOW_ALL);
12527                   return constant_boolean_node (1, type);
12528                 }
12529
12530               if (code == LT_EXPR
12531                   && ((code0 == MINUS_EXPR && is_positive > 0)
12532                       || (code0 == PLUS_EXPR && is_positive < 0)))
12533                 {
12534                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12535                     fold_overflow_warning (("assuming signed overflow does "
12536                                             "not occur when assuming that "
12537                                             "(X - c) < X is always true"),
12538                                            WARN_STRICT_OVERFLOW_ALL);
12539                   return constant_boolean_node (1, type);
12540                 }
12541
12542               /* Convert X + c <= X and X - c >= X to false for integers.  */
12543               if (code == LE_EXPR
12544                   && ((code0 == PLUS_EXPR && is_positive > 0)
12545                       || (code0 == MINUS_EXPR && is_positive < 0)))
12546                 {
12547                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12548                     fold_overflow_warning (("assuming signed overflow does "
12549                                             "not occur when assuming that "
12550                                             "(X + c) <= X is always false"),
12551                                            WARN_STRICT_OVERFLOW_ALL);
12552                   return constant_boolean_node (0, type);
12553                 }
12554
12555               if (code == GE_EXPR
12556                   && ((code0 == MINUS_EXPR && is_positive > 0)
12557                       || (code0 == PLUS_EXPR && is_positive < 0)))
12558                 {
12559                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
12560                     fold_overflow_warning (("assuming signed overflow does "
12561                                             "not occur when assuming that "
12562                                             "(X - c) >= X is always false"),
12563                                            WARN_STRICT_OVERFLOW_ALL);
12564                   return constant_boolean_node (0, type);
12565                 }
12566             }
12567         }
12568
12569       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
12570          This transformation affects the cases which are handled in later
12571          optimizations involving comparisons with non-negative constants.  */
12572       if (TREE_CODE (arg1) == INTEGER_CST
12573           && TREE_CODE (arg0) != INTEGER_CST
12574           && tree_int_cst_sgn (arg1) > 0)
12575         {
12576           if (code == GE_EXPR)
12577             {
12578               arg1 = const_binop (MINUS_EXPR, arg1,
12579                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
12580               return fold_build2 (GT_EXPR, type, arg0,
12581                                   fold_convert (TREE_TYPE (arg0), arg1));
12582             }
12583           if (code == LT_EXPR)
12584             {
12585               arg1 = const_binop (MINUS_EXPR, arg1,
12586                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
12587               return fold_build2 (LE_EXPR, type, arg0,
12588                                   fold_convert (TREE_TYPE (arg0), arg1));
12589             }
12590         }
12591
12592       /* Comparisons with the highest or lowest possible integer of
12593          the specified precision will have known values.  */
12594       {
12595         tree arg1_type = TREE_TYPE (arg1);
12596         unsigned int width = TYPE_PRECISION (arg1_type);
12597
12598         if (TREE_CODE (arg1) == INTEGER_CST
12599             && !TREE_OVERFLOW (arg1)
12600             && width <= 2 * HOST_BITS_PER_WIDE_INT
12601             && (INTEGRAL_TYPE_P (arg1_type) || POINTER_TYPE_P (arg1_type)))
12602           {
12603             HOST_WIDE_INT signed_max_hi;
12604             unsigned HOST_WIDE_INT signed_max_lo;
12605             unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
12606
12607             if (width <= HOST_BITS_PER_WIDE_INT)
12608               {
12609                 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
12610                                 - 1;
12611                 signed_max_hi = 0;
12612                 max_hi = 0;
12613
12614                 if (TYPE_UNSIGNED (arg1_type))
12615                   {
12616                     max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
12617                     min_lo = 0;
12618                     min_hi = 0;
12619                   }
12620                 else
12621                   {
12622                     max_lo = signed_max_lo;
12623                     min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
12624                     min_hi = -1;
12625                   }
12626               }
12627             else
12628               {
12629                 width -= HOST_BITS_PER_WIDE_INT;
12630                 signed_max_lo = -1;
12631                 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
12632                                 - 1;
12633                 max_lo = -1;
12634                 min_lo = 0;
12635
12636                 if (TYPE_UNSIGNED (arg1_type))
12637                   {
12638                     max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
12639                     min_hi = 0;
12640                   }
12641                 else
12642                   {
12643                     max_hi = signed_max_hi;
12644                     min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
12645                   }
12646               }
12647
12648             if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
12649                 && TREE_INT_CST_LOW (arg1) == max_lo)
12650               switch (code)
12651                 {
12652                 case GT_EXPR:
12653                   return omit_one_operand (type, integer_zero_node, arg0);
12654
12655                 case GE_EXPR:
12656                   return fold_build2 (EQ_EXPR, type, op0, op1);
12657
12658                 case LE_EXPR:
12659                   return omit_one_operand (type, integer_one_node, arg0);
12660
12661                 case LT_EXPR:
12662                   return fold_build2 (NE_EXPR, type, op0, op1);
12663
12664                 /* The GE_EXPR and LT_EXPR cases above are not normally
12665                    reached because of previous transformations.  */
12666
12667                 default:
12668                   break;
12669                 }
12670             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
12671                      == max_hi
12672                      && TREE_INT_CST_LOW (arg1) == max_lo - 1)
12673               switch (code)
12674                 {
12675                 case GT_EXPR:
12676                   arg1 = const_binop (PLUS_EXPR, arg1,
12677                                       build_int_cst (TREE_TYPE (arg1), 1), 0);
12678                   return fold_build2 (EQ_EXPR, type,
12679                                       fold_convert (TREE_TYPE (arg1), arg0),
12680                                       arg1);
12681                 case LE_EXPR:
12682                   arg1 = const_binop (PLUS_EXPR, arg1,
12683                                       build_int_cst (TREE_TYPE (arg1), 1), 0);
12684                   return fold_build2 (NE_EXPR, type,
12685                                       fold_convert (TREE_TYPE (arg1), arg0),
12686                                       arg1);
12687                 default:
12688                   break;
12689                 }
12690             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
12691                      == min_hi
12692                      && TREE_INT_CST_LOW (arg1) == min_lo)
12693               switch (code)
12694                 {
12695                 case LT_EXPR:
12696                   return omit_one_operand (type, integer_zero_node, arg0);
12697
12698                 case LE_EXPR:
12699                   return fold_build2 (EQ_EXPR, type, op0, op1);
12700
12701                 case GE_EXPR:
12702                   return omit_one_operand (type, integer_one_node, arg0);
12703
12704                 case GT_EXPR:
12705                   return fold_build2 (NE_EXPR, type, op0, op1);
12706
12707                 default:
12708                   break;
12709                 }
12710             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
12711                      == min_hi
12712                      && TREE_INT_CST_LOW (arg1) == min_lo + 1)
12713               switch (code)
12714                 {
12715                 case GE_EXPR:
12716                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
12717                   return fold_build2 (NE_EXPR, type,
12718                                       fold_convert (TREE_TYPE (arg1), arg0),
12719                                       arg1);
12720                 case LT_EXPR:
12721                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
12722                   return fold_build2 (EQ_EXPR, type,
12723                                       fold_convert (TREE_TYPE (arg1), arg0),
12724                                       arg1);
12725                 default:
12726                   break;
12727                 }
12728
12729             else if (TREE_INT_CST_HIGH (arg1) == signed_max_hi
12730                      && TREE_INT_CST_LOW (arg1) == signed_max_lo
12731                      && TYPE_UNSIGNED (arg1_type)
12732                      /* We will flip the signedness of the comparison operator
12733                         associated with the mode of arg1, so the sign bit is
12734                         specified by this mode.  Check that arg1 is the signed
12735                         max associated with this sign bit.  */
12736                      && width == GET_MODE_BITSIZE (TYPE_MODE (arg1_type))
12737                      /* signed_type does not work on pointer types.  */
12738                      && INTEGRAL_TYPE_P (arg1_type))
12739               {
12740                 /* The following case also applies to X < signed_max+1
12741                    and X >= signed_max+1 because previous transformations.  */
12742                 if (code == LE_EXPR || code == GT_EXPR)
12743                   {
12744                     tree st;
12745                     st = signed_type_for (TREE_TYPE (arg1));
12746                     return fold_build2 (code == LE_EXPR ? GE_EXPR : LT_EXPR,
12747                                         type, fold_convert (st, arg0),
12748                                         build_int_cst (st, 0));
12749                   }
12750               }
12751           }
12752       }
12753
12754       /* If we are comparing an ABS_EXPR with a constant, we can
12755          convert all the cases into explicit comparisons, but they may
12756          well not be faster than doing the ABS and one comparison.
12757          But ABS (X) <= C is a range comparison, which becomes a subtraction
12758          and a comparison, and is probably faster.  */
12759       if (code == LE_EXPR
12760           && TREE_CODE (arg1) == INTEGER_CST
12761           && TREE_CODE (arg0) == ABS_EXPR
12762           && ! TREE_SIDE_EFFECTS (arg0)
12763           && (0 != (tem = negate_expr (arg1)))
12764           && TREE_CODE (tem) == INTEGER_CST
12765           && !TREE_OVERFLOW (tem))
12766         return fold_build2 (TRUTH_ANDIF_EXPR, type,
12767                             build2 (GE_EXPR, type,
12768                                     TREE_OPERAND (arg0, 0), tem),
12769                             build2 (LE_EXPR, type,
12770                                     TREE_OPERAND (arg0, 0), arg1));
12771
12772       /* Convert ABS_EXPR<x> >= 0 to true.  */
12773       strict_overflow_p = false;
12774       if (code == GE_EXPR
12775           && (integer_zerop (arg1)
12776               || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
12777                   && real_zerop (arg1)))
12778           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
12779         {
12780           if (strict_overflow_p)
12781             fold_overflow_warning (("assuming signed overflow does not occur "
12782                                     "when simplifying comparison of "
12783                                     "absolute value and zero"),
12784                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
12785           return omit_one_operand (type, integer_one_node, arg0);
12786         }
12787
12788       /* Convert ABS_EXPR<x> < 0 to false.  */
12789       strict_overflow_p = false;
12790       if (code == LT_EXPR
12791           && (integer_zerop (arg1) || real_zerop (arg1))
12792           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
12793         {
12794           if (strict_overflow_p)
12795             fold_overflow_warning (("assuming signed overflow does not occur "
12796                                     "when simplifying comparison of "
12797                                     "absolute value and zero"),
12798                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
12799           return omit_one_operand (type, integer_zero_node, arg0);
12800         }
12801
12802       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
12803          and similarly for >= into !=.  */
12804       if ((code == LT_EXPR || code == GE_EXPR)
12805           && TYPE_UNSIGNED (TREE_TYPE (arg0))
12806           && TREE_CODE (arg1) == LSHIFT_EXPR
12807           && integer_onep (TREE_OPERAND (arg1, 0)))
12808         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
12809                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
12810                                TREE_OPERAND (arg1, 1)),
12811                        build_int_cst (TREE_TYPE (arg0), 0));
12812
12813       if ((code == LT_EXPR || code == GE_EXPR)
12814           && TYPE_UNSIGNED (TREE_TYPE (arg0))
12815           && (TREE_CODE (arg1) == NOP_EXPR
12816               || TREE_CODE (arg1) == CONVERT_EXPR)
12817           && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
12818           && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
12819         return
12820           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
12821                   fold_convert (TREE_TYPE (arg0),
12822                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
12823                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
12824                                                       1))),
12825                   build_int_cst (TREE_TYPE (arg0), 0));
12826
12827       return NULL_TREE;
12828
12829     case UNORDERED_EXPR:
12830     case ORDERED_EXPR:
12831     case UNLT_EXPR:
12832     case UNLE_EXPR:
12833     case UNGT_EXPR:
12834     case UNGE_EXPR:
12835     case UNEQ_EXPR:
12836     case LTGT_EXPR:
12837       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
12838         {
12839           t1 = fold_relational_const (code, type, arg0, arg1);
12840           if (t1 != NULL_TREE)
12841             return t1;
12842         }
12843
12844       /* If the first operand is NaN, the result is constant.  */
12845       if (TREE_CODE (arg0) == REAL_CST
12846           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
12847           && (code != LTGT_EXPR || ! flag_trapping_math))
12848         {
12849           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
12850                ? integer_zero_node
12851                : integer_one_node;
12852           return omit_one_operand (type, t1, arg1);
12853         }
12854
12855       /* If the second operand is NaN, the result is constant.  */
12856       if (TREE_CODE (arg1) == REAL_CST
12857           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
12858           && (code != LTGT_EXPR || ! flag_trapping_math))
12859         {
12860           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
12861                ? integer_zero_node
12862                : integer_one_node;
12863           return omit_one_operand (type, t1, arg0);
12864         }
12865
12866       /* Simplify unordered comparison of something with itself.  */
12867       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
12868           && operand_equal_p (arg0, arg1, 0))
12869         return constant_boolean_node (1, type);
12870
12871       if (code == LTGT_EXPR
12872           && !flag_trapping_math
12873           && operand_equal_p (arg0, arg1, 0))
12874         return constant_boolean_node (0, type);
12875
12876       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
12877       {
12878         tree targ0 = strip_float_extensions (arg0);
12879         tree targ1 = strip_float_extensions (arg1);
12880         tree newtype = TREE_TYPE (targ0);
12881
12882         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
12883           newtype = TREE_TYPE (targ1);
12884
12885         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
12886           return fold_build2 (code, type, fold_convert (newtype, targ0),
12887                               fold_convert (newtype, targ1));
12888       }
12889
12890       return NULL_TREE;
12891
12892     case COMPOUND_EXPR:
12893       /* When pedantic, a compound expression can be neither an lvalue
12894          nor an integer constant expression.  */
12895       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
12896         return NULL_TREE;
12897       /* Don't let (0, 0) be null pointer constant.  */
12898       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
12899                                  : fold_convert (type, arg1);
12900       return pedantic_non_lvalue (tem);
12901
12902     case COMPLEX_EXPR:
12903       if ((TREE_CODE (arg0) == REAL_CST
12904            && TREE_CODE (arg1) == REAL_CST)
12905           || (TREE_CODE (arg0) == INTEGER_CST
12906               && TREE_CODE (arg1) == INTEGER_CST))
12907         return build_complex (type, arg0, arg1);
12908       return NULL_TREE;
12909
12910     case ASSERT_EXPR:
12911       /* An ASSERT_EXPR should never be passed to fold_binary.  */
12912       gcc_unreachable ();
12913
12914     default:
12915       return NULL_TREE;
12916     } /* switch (code) */
12917 }
12918
12919 /* Callback for walk_tree, looking for LABEL_EXPR.
12920    Returns tree TP if it is LABEL_EXPR. Otherwise it returns NULL_TREE.
12921    Do not check the sub-tree of GOTO_EXPR.  */
12922
12923 static tree
12924 contains_label_1 (tree *tp,
12925                   int *walk_subtrees,
12926                   void *data ATTRIBUTE_UNUSED)
12927 {
12928   switch (TREE_CODE (*tp))
12929     {
12930     case LABEL_EXPR:
12931       return *tp;
12932     case GOTO_EXPR:
12933       *walk_subtrees = 0;
12934     /* no break */
12935     default:
12936       return NULL_TREE;
12937     }
12938 }
12939
12940 /* Checks whether the sub-tree ST contains a label LABEL_EXPR which is
12941    accessible from outside the sub-tree. Returns NULL_TREE if no
12942    addressable label is found.  */
12943
12944 static bool
12945 contains_label_p (tree st)
12946 {
12947   return (walk_tree (&st, contains_label_1 , NULL, NULL) != NULL_TREE);
12948 }
12949
12950 /* Fold a ternary expression of code CODE and type TYPE with operands
12951    OP0, OP1, and OP2.  Return the folded expression if folding is
12952    successful.  Otherwise, return NULL_TREE.  */
12953
12954 tree
12955 fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
12956 {
12957   tree tem;
12958   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
12959   enum tree_code_class kind = TREE_CODE_CLASS (code);
12960
12961   gcc_assert (IS_EXPR_CODE_CLASS (kind)
12962               && TREE_CODE_LENGTH (code) == 3);
12963
12964   /* Strip any conversions that don't change the mode.  This is safe
12965      for every expression, except for a comparison expression because
12966      its signedness is derived from its operands.  So, in the latter
12967      case, only strip conversions that don't change the signedness.
12968
12969      Note that this is done as an internal manipulation within the
12970      constant folder, in order to find the simplest representation of
12971      the arguments so that their form can be studied.  In any cases,
12972      the appropriate type conversions should be put back in the tree
12973      that will get out of the constant folder.  */
12974   if (op0)
12975     {
12976       arg0 = op0;
12977       STRIP_NOPS (arg0);
12978     }
12979
12980   if (op1)
12981     {
12982       arg1 = op1;
12983       STRIP_NOPS (arg1);
12984     }
12985
12986   switch (code)
12987     {
12988     case COMPONENT_REF:
12989       if (TREE_CODE (arg0) == CONSTRUCTOR
12990           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
12991         {
12992           unsigned HOST_WIDE_INT idx;
12993           tree field, value;
12994           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
12995             if (field == arg1)
12996               return value;
12997         }
12998       return NULL_TREE;
12999
13000     case COND_EXPR:
13001       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
13002          so all simple results must be passed through pedantic_non_lvalue.  */
13003       if (TREE_CODE (arg0) == INTEGER_CST)
13004         {
13005           tree unused_op = integer_zerop (arg0) ? op1 : op2;
13006           tem = integer_zerop (arg0) ? op2 : op1;
13007           /* Only optimize constant conditions when the selected branch
13008              has the same type as the COND_EXPR.  This avoids optimizing
13009              away "c ? x : throw", where the throw has a void type.
13010              Avoid throwing away that operand which contains label.  */
13011           if ((!TREE_SIDE_EFFECTS (unused_op)
13012                || !contains_label_p (unused_op))
13013               && (! VOID_TYPE_P (TREE_TYPE (tem))
13014                   || VOID_TYPE_P (type)))
13015             return pedantic_non_lvalue (tem);
13016           return NULL_TREE;
13017         }
13018       if (operand_equal_p (arg1, op2, 0))
13019         return pedantic_omit_one_operand (type, arg1, arg0);
13020
13021       /* If we have A op B ? A : C, we may be able to convert this to a
13022          simpler expression, depending on the operation and the values
13023          of B and C.  Signed zeros prevent all of these transformations,
13024          for reasons given above each one.
13025
13026          Also try swapping the arguments and inverting the conditional.  */
13027       if (COMPARISON_CLASS_P (arg0)
13028           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13029                                              arg1, TREE_OPERAND (arg0, 1))
13030           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
13031         {
13032           tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
13033           if (tem)
13034             return tem;
13035         }
13036
13037       if (COMPARISON_CLASS_P (arg0)
13038           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
13039                                              op2,
13040                                              TREE_OPERAND (arg0, 1))
13041           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
13042         {
13043           tem = fold_truth_not_expr (arg0);
13044           if (tem && COMPARISON_CLASS_P (tem))
13045             {
13046               tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
13047               if (tem)
13048                 return tem;
13049             }
13050         }
13051
13052       /* If the second operand is simpler than the third, swap them
13053          since that produces better jump optimization results.  */
13054       if (truth_value_p (TREE_CODE (arg0))
13055           && tree_swap_operands_p (op1, op2, false))
13056         {
13057           /* See if this can be inverted.  If it can't, possibly because
13058              it was a floating-point inequality comparison, don't do
13059              anything.  */
13060           tem = fold_truth_not_expr (arg0);
13061           if (tem)
13062             return fold_build3 (code, type, tem, op2, op1);
13063         }
13064
13065       /* Convert A ? 1 : 0 to simply A.  */
13066       if (integer_onep (op1)
13067           && integer_zerop (op2)
13068           /* If we try to convert OP0 to our type, the
13069              call to fold will try to move the conversion inside
13070              a COND, which will recurse.  In that case, the COND_EXPR
13071              is probably the best choice, so leave it alone.  */
13072           && type == TREE_TYPE (arg0))
13073         return pedantic_non_lvalue (arg0);
13074
13075       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
13076          over COND_EXPR in cases such as floating point comparisons.  */
13077       if (integer_zerop (op1)
13078           && integer_onep (op2)
13079           && truth_value_p (TREE_CODE (arg0)))
13080         return pedantic_non_lvalue (fold_convert (type,
13081                                                   invert_truthvalue (arg0)));
13082
13083       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
13084       if (TREE_CODE (arg0) == LT_EXPR
13085           && integer_zerop (TREE_OPERAND (arg0, 1))
13086           && integer_zerop (op2)
13087           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
13088         {
13089           /* sign_bit_p only checks ARG1 bits within A's precision.
13090              If <sign bit of A> has wider type than A, bits outside
13091              of A's precision in <sign bit of A> need to be checked.
13092              If they are all 0, this optimization needs to be done
13093              in unsigned A's type, if they are all 1 in signed A's type,
13094              otherwise this can't be done.  */
13095           if (TYPE_PRECISION (TREE_TYPE (tem))
13096               < TYPE_PRECISION (TREE_TYPE (arg1))
13097               && TYPE_PRECISION (TREE_TYPE (tem))
13098                  < TYPE_PRECISION (type))
13099             {
13100               unsigned HOST_WIDE_INT mask_lo;
13101               HOST_WIDE_INT mask_hi;
13102               int inner_width, outer_width;
13103               tree tem_type;
13104
13105               inner_width = TYPE_PRECISION (TREE_TYPE (tem));
13106               outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
13107               if (outer_width > TYPE_PRECISION (type))
13108                 outer_width = TYPE_PRECISION (type);
13109
13110               if (outer_width > HOST_BITS_PER_WIDE_INT)
13111                 {
13112                   mask_hi = ((unsigned HOST_WIDE_INT) -1
13113                              >> (2 * HOST_BITS_PER_WIDE_INT - outer_width));
13114                   mask_lo = -1;
13115                 }
13116               else
13117                 {
13118                   mask_hi = 0;
13119                   mask_lo = ((unsigned HOST_WIDE_INT) -1
13120                              >> (HOST_BITS_PER_WIDE_INT - outer_width));
13121                 }
13122               if (inner_width > HOST_BITS_PER_WIDE_INT)
13123                 {
13124                   mask_hi &= ~((unsigned HOST_WIDE_INT) -1
13125                                >> (HOST_BITS_PER_WIDE_INT - inner_width));
13126                   mask_lo = 0;
13127                 }
13128               else
13129                 mask_lo &= ~((unsigned HOST_WIDE_INT) -1
13130                              >> (HOST_BITS_PER_WIDE_INT - inner_width));
13131
13132               if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == mask_hi
13133                   && (TREE_INT_CST_LOW (arg1) & mask_lo) == mask_lo)
13134                 {
13135                   tem_type = signed_type_for (TREE_TYPE (tem));
13136                   tem = fold_convert (tem_type, tem);
13137                 }
13138               else if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == 0
13139                        && (TREE_INT_CST_LOW (arg1) & mask_lo) == 0)
13140                 {
13141                   tem_type = unsigned_type_for (TREE_TYPE (tem));
13142                   tem = fold_convert (tem_type, tem);
13143                 }
13144               else
13145                 tem = NULL;
13146             }
13147
13148           if (tem)
13149             return fold_convert (type,
13150                                  fold_build2 (BIT_AND_EXPR,
13151                                               TREE_TYPE (tem), tem,
13152                                               fold_convert (TREE_TYPE (tem),
13153                                                             arg1)));
13154         }
13155
13156       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
13157          already handled above.  */
13158       if (TREE_CODE (arg0) == BIT_AND_EXPR
13159           && integer_onep (TREE_OPERAND (arg0, 1))
13160           && integer_zerop (op2)
13161           && integer_pow2p (arg1))
13162         {
13163           tree tem = TREE_OPERAND (arg0, 0);
13164           STRIP_NOPS (tem);
13165           if (TREE_CODE (tem) == RSHIFT_EXPR
13166               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
13167               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
13168                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
13169             return fold_build2 (BIT_AND_EXPR, type,
13170                                 TREE_OPERAND (tem, 0), arg1);
13171         }
13172
13173       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
13174          is probably obsolete because the first operand should be a
13175          truth value (that's why we have the two cases above), but let's
13176          leave it in until we can confirm this for all front-ends.  */
13177       if (integer_zerop (op2)
13178           && TREE_CODE (arg0) == NE_EXPR
13179           && integer_zerop (TREE_OPERAND (arg0, 1))
13180           && integer_pow2p (arg1)
13181           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
13182           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
13183                               arg1, OEP_ONLY_CONST))
13184         return pedantic_non_lvalue (fold_convert (type,
13185                                                   TREE_OPERAND (arg0, 0)));
13186
13187       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
13188       if (integer_zerop (op2)
13189           && truth_value_p (TREE_CODE (arg0))
13190           && truth_value_p (TREE_CODE (arg1)))
13191         return fold_build2 (TRUTH_ANDIF_EXPR, type,
13192                             fold_convert (type, arg0),
13193                             arg1);
13194
13195       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
13196       if (integer_onep (op2)
13197           && truth_value_p (TREE_CODE (arg0))
13198           && truth_value_p (TREE_CODE (arg1)))
13199         {
13200           /* Only perform transformation if ARG0 is easily inverted.  */
13201           tem = fold_truth_not_expr (arg0);
13202           if (tem)
13203             return fold_build2 (TRUTH_ORIF_EXPR, type,
13204                                 fold_convert (type, tem),
13205                                 arg1);
13206         }
13207
13208       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
13209       if (integer_zerop (arg1)
13210           && truth_value_p (TREE_CODE (arg0))
13211           && truth_value_p (TREE_CODE (op2)))
13212         {
13213           /* Only perform transformation if ARG0 is easily inverted.  */
13214           tem = fold_truth_not_expr (arg0);
13215           if (tem)
13216             return fold_build2 (TRUTH_ANDIF_EXPR, type,
13217                                 fold_convert (type, tem),
13218                                 op2);
13219         }
13220
13221       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
13222       if (integer_onep (arg1)
13223           && truth_value_p (TREE_CODE (arg0))
13224           && truth_value_p (TREE_CODE (op2)))
13225         return fold_build2 (TRUTH_ORIF_EXPR, type,
13226                             fold_convert (type, arg0),
13227                             op2);
13228
13229       return NULL_TREE;
13230
13231     case CALL_EXPR:
13232       /* CALL_EXPRs used to be ternary exprs.  Catch any mistaken uses
13233          of fold_ternary on them.  */
13234       gcc_unreachable ();
13235
13236     case BIT_FIELD_REF:
13237       if ((TREE_CODE (arg0) == VECTOR_CST
13238            || (TREE_CODE (arg0) == CONSTRUCTOR && TREE_CONSTANT (arg0)))
13239           && type == TREE_TYPE (TREE_TYPE (arg0))
13240           && host_integerp (arg1, 1)
13241           && host_integerp (op2, 1))
13242         {
13243           unsigned HOST_WIDE_INT width = tree_low_cst (arg1, 1);
13244           unsigned HOST_WIDE_INT idx = tree_low_cst (op2, 1);
13245
13246           if (width != 0
13247               && simple_cst_equal (arg1, TYPE_SIZE (type)) == 1
13248               && (idx % width) == 0
13249               && (idx = idx / width)
13250                  < TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
13251             {
13252               tree elements = NULL_TREE;
13253
13254               if (TREE_CODE (arg0) == VECTOR_CST)
13255                 elements = TREE_VECTOR_CST_ELTS (arg0);
13256               else
13257                 {
13258                   unsigned HOST_WIDE_INT idx;
13259                   tree value;
13260
13261                   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (arg0), idx, value)
13262                     elements = tree_cons (NULL_TREE, value, elements);
13263                 }
13264               while (idx-- > 0 && elements)
13265                 elements = TREE_CHAIN (elements);
13266               if (elements)
13267                 return TREE_VALUE (elements);
13268               else
13269                 return fold_convert (type, integer_zero_node);
13270             }
13271         }
13272       return NULL_TREE;
13273
13274     default:
13275       return NULL_TREE;
13276     } /* switch (code) */
13277 }
13278
13279 /* Perform constant folding and related simplification of EXPR.
13280    The related simplifications include x*1 => x, x*0 => 0, etc.,
13281    and application of the associative law.
13282    NOP_EXPR conversions may be removed freely (as long as we
13283    are careful not to change the type of the overall expression).
13284    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
13285    but we can constant-fold them if they have constant operands.  */
13286
13287 #ifdef ENABLE_FOLD_CHECKING
13288 # define fold(x) fold_1 (x)
13289 static tree fold_1 (tree);
13290 static
13291 #endif
13292 tree
13293 fold (tree expr)
13294 {
13295   const tree t = expr;
13296   enum tree_code code = TREE_CODE (t);
13297   enum tree_code_class kind = TREE_CODE_CLASS (code);
13298   tree tem;
13299
13300   /* Return right away if a constant.  */
13301   if (kind == tcc_constant)
13302     return t;
13303
13304   /* CALL_EXPR-like objects with variable numbers of operands are
13305      treated specially.  */
13306   if (kind == tcc_vl_exp)
13307     {
13308       if (code == CALL_EXPR)
13309         {
13310           tem = fold_call_expr (expr, false);
13311           return tem ? tem : expr;
13312         }
13313       return expr;
13314     }
13315
13316   if (IS_EXPR_CODE_CLASS (kind)
13317       || IS_GIMPLE_STMT_CODE_CLASS (kind))
13318     {
13319       tree type = TREE_TYPE (t);
13320       tree op0, op1, op2;
13321
13322       switch (TREE_CODE_LENGTH (code))
13323         {
13324         case 1:
13325           op0 = TREE_OPERAND (t, 0);
13326           tem = fold_unary (code, type, op0);
13327           return tem ? tem : expr;
13328         case 2:
13329           op0 = TREE_OPERAND (t, 0);
13330           op1 = TREE_OPERAND (t, 1);
13331           tem = fold_binary (code, type, op0, op1);
13332           return tem ? tem : expr;
13333         case 3:
13334           op0 = TREE_OPERAND (t, 0);
13335           op1 = TREE_OPERAND (t, 1);
13336           op2 = TREE_OPERAND (t, 2);
13337           tem = fold_ternary (code, type, op0, op1, op2);
13338           return tem ? tem : expr;
13339         default:
13340           break;
13341         }
13342     }
13343
13344   switch (code)
13345     {
13346     case CONST_DECL:
13347       return fold (DECL_INITIAL (t));
13348
13349     default:
13350       return t;
13351     } /* switch (code) */
13352 }
13353
13354 #ifdef ENABLE_FOLD_CHECKING
13355 #undef fold
13356
13357 static void fold_checksum_tree (const_tree, struct md5_ctx *, htab_t);
13358 static void fold_check_failed (const_tree, const_tree);
13359 void print_fold_checksum (const_tree);
13360
13361 /* When --enable-checking=fold, compute a digest of expr before
13362    and after actual fold call to see if fold did not accidentally
13363    change original expr.  */
13364
13365 tree
13366 fold (tree expr)
13367 {
13368   tree ret;
13369   struct md5_ctx ctx;
13370   unsigned char checksum_before[16], checksum_after[16];
13371   htab_t ht;
13372
13373   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13374   md5_init_ctx (&ctx);
13375   fold_checksum_tree (expr, &ctx, ht);
13376   md5_finish_ctx (&ctx, checksum_before);
13377   htab_empty (ht);
13378
13379   ret = fold_1 (expr);
13380
13381   md5_init_ctx (&ctx);
13382   fold_checksum_tree (expr, &ctx, ht);
13383   md5_finish_ctx (&ctx, checksum_after);
13384   htab_delete (ht);
13385
13386   if (memcmp (checksum_before, checksum_after, 16))
13387     fold_check_failed (expr, ret);
13388
13389   return ret;
13390 }
13391
13392 void
13393 print_fold_checksum (const_tree expr)
13394 {
13395   struct md5_ctx ctx;
13396   unsigned char checksum[16], cnt;
13397   htab_t ht;
13398
13399   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13400   md5_init_ctx (&ctx);
13401   fold_checksum_tree (expr, &ctx, ht);
13402   md5_finish_ctx (&ctx, checksum);
13403   htab_delete (ht);
13404   for (cnt = 0; cnt < 16; ++cnt)
13405     fprintf (stderr, "%02x", checksum[cnt]);
13406   putc ('\n', stderr);
13407 }
13408
13409 static void
13410 fold_check_failed (const_tree expr ATTRIBUTE_UNUSED, const_tree ret ATTRIBUTE_UNUSED)
13411 {
13412   internal_error ("fold check: original tree changed by fold");
13413 }
13414
13415 static void
13416 fold_checksum_tree (const_tree expr, struct md5_ctx *ctx, htab_t ht)
13417 {
13418   const void **slot;
13419   enum tree_code code;
13420   struct tree_function_decl buf;
13421   int i, len;
13422   
13423 recursive_label:
13424
13425   gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
13426                <= sizeof (struct tree_function_decl))
13427               && sizeof (struct tree_type) <= sizeof (struct tree_function_decl));
13428   if (expr == NULL)
13429     return;
13430   slot = (const void **) htab_find_slot (ht, expr, INSERT);
13431   if (*slot != NULL)
13432     return;
13433   *slot = expr;
13434   code = TREE_CODE (expr);
13435   if (TREE_CODE_CLASS (code) == tcc_declaration
13436       && DECL_ASSEMBLER_NAME_SET_P (expr))
13437     {
13438       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
13439       memcpy ((char *) &buf, expr, tree_size (expr));
13440       SET_DECL_ASSEMBLER_NAME ((tree)&buf, NULL);
13441       expr = (tree) &buf;
13442     }
13443   else if (TREE_CODE_CLASS (code) == tcc_type
13444            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)
13445                || TYPE_CACHED_VALUES_P (expr)
13446                || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)))
13447     {
13448       /* Allow these fields to be modified.  */
13449       tree tmp;
13450       memcpy ((char *) &buf, expr, tree_size (expr));
13451       expr = tmp = (tree) &buf;
13452       TYPE_CONTAINS_PLACEHOLDER_INTERNAL (tmp) = 0;
13453       TYPE_POINTER_TO (tmp) = NULL;
13454       TYPE_REFERENCE_TO (tmp) = NULL;
13455       if (TYPE_CACHED_VALUES_P (tmp))
13456         {
13457           TYPE_CACHED_VALUES_P (tmp) = 0;
13458           TYPE_CACHED_VALUES (tmp) = NULL;
13459         }
13460     }
13461   md5_process_bytes (expr, tree_size (expr), ctx);
13462   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
13463   if (TREE_CODE_CLASS (code) != tcc_type
13464       && TREE_CODE_CLASS (code) != tcc_declaration
13465       && code != TREE_LIST
13466       && code != SSA_NAME)
13467     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
13468   switch (TREE_CODE_CLASS (code))
13469     {
13470     case tcc_constant:
13471       switch (code)
13472         {
13473         case STRING_CST:
13474           md5_process_bytes (TREE_STRING_POINTER (expr),
13475                              TREE_STRING_LENGTH (expr), ctx);
13476           break;
13477         case COMPLEX_CST:
13478           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
13479           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
13480           break;
13481         case VECTOR_CST:
13482           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
13483           break;
13484         default:
13485           break;
13486         }
13487       break;
13488     case tcc_exceptional:
13489       switch (code)
13490         {
13491         case TREE_LIST:
13492           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
13493           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
13494           expr = TREE_CHAIN (expr);
13495           goto recursive_label;
13496           break;
13497         case TREE_VEC:
13498           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
13499             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
13500           break;
13501         default:
13502           break;
13503         }
13504       break;
13505     case tcc_expression:
13506     case tcc_reference:
13507     case tcc_comparison:
13508     case tcc_unary:
13509     case tcc_binary:
13510     case tcc_statement:
13511     case tcc_vl_exp:
13512       len = TREE_OPERAND_LENGTH (expr);
13513       for (i = 0; i < len; ++i)
13514         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
13515       break;
13516     case tcc_declaration:
13517       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
13518       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
13519       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
13520         {
13521           fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
13522           fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
13523           fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
13524           fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
13525           fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
13526         }
13527       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
13528         fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
13529           
13530       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
13531         {
13532           fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
13533           fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
13534           fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
13535         }
13536       break;
13537     case tcc_type:
13538       if (TREE_CODE (expr) == ENUMERAL_TYPE)
13539         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
13540       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
13541       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
13542       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
13543       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
13544       if (INTEGRAL_TYPE_P (expr)
13545           || SCALAR_FLOAT_TYPE_P (expr))
13546         {
13547           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
13548           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
13549         }
13550       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
13551       if (TREE_CODE (expr) == RECORD_TYPE
13552           || TREE_CODE (expr) == UNION_TYPE
13553           || TREE_CODE (expr) == QUAL_UNION_TYPE)
13554         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
13555       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
13556       break;
13557     default:
13558       break;
13559     }
13560 }
13561
13562 /* Helper function for outputting the checksum of a tree T.  When
13563    debugging with gdb, you can "define mynext" to be "next" followed
13564    by "call debug_fold_checksum (op0)", then just trace down till the
13565    outputs differ.  */
13566
13567 void
13568 debug_fold_checksum (const_tree t)
13569 {
13570   int i;
13571   unsigned char checksum[16];
13572   struct md5_ctx ctx;
13573   htab_t ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13574   
13575   md5_init_ctx (&ctx);
13576   fold_checksum_tree (t, &ctx, ht);
13577   md5_finish_ctx (&ctx, checksum);
13578   htab_empty (ht);
13579
13580   for (i = 0; i < 16; i++)
13581     fprintf (stderr, "%d ", checksum[i]);
13582
13583   fprintf (stderr, "\n");
13584 }
13585
13586 #endif
13587
13588 /* Fold a unary tree expression with code CODE of type TYPE with an
13589    operand OP0.  Return a folded expression if successful.  Otherwise,
13590    return a tree expression with code CODE of type TYPE with an
13591    operand OP0.  */
13592
13593 tree
13594 fold_build1_stat (enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
13595 {
13596   tree tem;
13597 #ifdef ENABLE_FOLD_CHECKING
13598   unsigned char checksum_before[16], checksum_after[16];
13599   struct md5_ctx ctx;
13600   htab_t ht;
13601
13602   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13603   md5_init_ctx (&ctx);
13604   fold_checksum_tree (op0, &ctx, ht);
13605   md5_finish_ctx (&ctx, checksum_before);
13606   htab_empty (ht);
13607 #endif
13608   
13609   tem = fold_unary (code, type, op0);
13610   if (!tem)
13611     tem = build1_stat (code, type, op0 PASS_MEM_STAT);
13612   
13613 #ifdef ENABLE_FOLD_CHECKING
13614   md5_init_ctx (&ctx);
13615   fold_checksum_tree (op0, &ctx, ht);
13616   md5_finish_ctx (&ctx, checksum_after);
13617   htab_delete (ht);
13618
13619   if (memcmp (checksum_before, checksum_after, 16))
13620     fold_check_failed (op0, tem);
13621 #endif
13622   return tem;
13623 }
13624
13625 /* Fold a binary tree expression with code CODE of type TYPE with
13626    operands OP0 and OP1.  Return a folded expression if successful.
13627    Otherwise, return a tree expression with code CODE of type TYPE
13628    with operands OP0 and OP1.  */
13629
13630 tree
13631 fold_build2_stat (enum tree_code code, tree type, tree op0, tree op1
13632                   MEM_STAT_DECL)
13633 {
13634   tree tem;
13635 #ifdef ENABLE_FOLD_CHECKING
13636   unsigned char checksum_before_op0[16],
13637                 checksum_before_op1[16],
13638                 checksum_after_op0[16],
13639                 checksum_after_op1[16];
13640   struct md5_ctx ctx;
13641   htab_t ht;
13642
13643   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13644   md5_init_ctx (&ctx);
13645   fold_checksum_tree (op0, &ctx, ht);
13646   md5_finish_ctx (&ctx, checksum_before_op0);
13647   htab_empty (ht);
13648
13649   md5_init_ctx (&ctx);
13650   fold_checksum_tree (op1, &ctx, ht);
13651   md5_finish_ctx (&ctx, checksum_before_op1);
13652   htab_empty (ht);
13653 #endif
13654
13655   tem = fold_binary (code, type, op0, op1);
13656   if (!tem)
13657     tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
13658   
13659 #ifdef ENABLE_FOLD_CHECKING
13660   md5_init_ctx (&ctx);
13661   fold_checksum_tree (op0, &ctx, ht);
13662   md5_finish_ctx (&ctx, checksum_after_op0);
13663   htab_empty (ht);
13664
13665   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
13666     fold_check_failed (op0, tem);
13667   
13668   md5_init_ctx (&ctx);
13669   fold_checksum_tree (op1, &ctx, ht);
13670   md5_finish_ctx (&ctx, checksum_after_op1);
13671   htab_delete (ht);
13672
13673   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
13674     fold_check_failed (op1, tem);
13675 #endif
13676   return tem;
13677 }
13678
13679 /* Fold a ternary tree expression with code CODE of type TYPE with
13680    operands OP0, OP1, and OP2.  Return a folded expression if
13681    successful.  Otherwise, return a tree expression with code CODE of
13682    type TYPE with operands OP0, OP1, and OP2.  */
13683
13684 tree
13685 fold_build3_stat (enum tree_code code, tree type, tree op0, tree op1, tree op2
13686              MEM_STAT_DECL)
13687 {
13688   tree tem;
13689 #ifdef ENABLE_FOLD_CHECKING
13690   unsigned char checksum_before_op0[16],
13691                 checksum_before_op1[16],
13692                 checksum_before_op2[16],
13693                 checksum_after_op0[16],
13694                 checksum_after_op1[16],
13695                 checksum_after_op2[16];
13696   struct md5_ctx ctx;
13697   htab_t ht;
13698
13699   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13700   md5_init_ctx (&ctx);
13701   fold_checksum_tree (op0, &ctx, ht);
13702   md5_finish_ctx (&ctx, checksum_before_op0);
13703   htab_empty (ht);
13704
13705   md5_init_ctx (&ctx);
13706   fold_checksum_tree (op1, &ctx, ht);
13707   md5_finish_ctx (&ctx, checksum_before_op1);
13708   htab_empty (ht);
13709
13710   md5_init_ctx (&ctx);
13711   fold_checksum_tree (op2, &ctx, ht);
13712   md5_finish_ctx (&ctx, checksum_before_op2);
13713   htab_empty (ht);
13714 #endif
13715
13716   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
13717   tem = fold_ternary (code, type, op0, op1, op2);
13718   if (!tem)
13719     tem =  build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
13720       
13721 #ifdef ENABLE_FOLD_CHECKING
13722   md5_init_ctx (&ctx);
13723   fold_checksum_tree (op0, &ctx, ht);
13724   md5_finish_ctx (&ctx, checksum_after_op0);
13725   htab_empty (ht);
13726
13727   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
13728     fold_check_failed (op0, tem);
13729   
13730   md5_init_ctx (&ctx);
13731   fold_checksum_tree (op1, &ctx, ht);
13732   md5_finish_ctx (&ctx, checksum_after_op1);
13733   htab_empty (ht);
13734
13735   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
13736     fold_check_failed (op1, tem);
13737   
13738   md5_init_ctx (&ctx);
13739   fold_checksum_tree (op2, &ctx, ht);
13740   md5_finish_ctx (&ctx, checksum_after_op2);
13741   htab_delete (ht);
13742
13743   if (memcmp (checksum_before_op2, checksum_after_op2, 16))
13744     fold_check_failed (op2, tem);
13745 #endif
13746   return tem;
13747 }
13748
13749 /* Fold a CALL_EXPR expression of type TYPE with operands FN and NARGS
13750    arguments in ARGARRAY, and a null static chain.
13751    Return a folded expression if successful.  Otherwise, return a CALL_EXPR
13752    of type TYPE from the given operands as constructed by build_call_array.  */
13753
13754 tree
13755 fold_build_call_array (tree type, tree fn, int nargs, tree *argarray)
13756 {
13757   tree tem;
13758 #ifdef ENABLE_FOLD_CHECKING
13759   unsigned char checksum_before_fn[16],
13760                 checksum_before_arglist[16],
13761                 checksum_after_fn[16],
13762                 checksum_after_arglist[16];
13763   struct md5_ctx ctx;
13764   htab_t ht;
13765   int i;
13766
13767   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
13768   md5_init_ctx (&ctx);
13769   fold_checksum_tree (fn, &ctx, ht);
13770   md5_finish_ctx (&ctx, checksum_before_fn);
13771   htab_empty (ht);
13772
13773   md5_init_ctx (&ctx);
13774   for (i = 0; i < nargs; i++)
13775     fold_checksum_tree (argarray[i], &ctx, ht);
13776   md5_finish_ctx (&ctx, checksum_before_arglist);
13777   htab_empty (ht);
13778 #endif
13779
13780   tem = fold_builtin_call_array (type, fn, nargs, argarray);
13781       
13782 #ifdef ENABLE_FOLD_CHECKING
13783   md5_init_ctx (&ctx);
13784   fold_checksum_tree (fn, &ctx, ht);
13785   md5_finish_ctx (&ctx, checksum_after_fn);
13786   htab_empty (ht);
13787
13788   if (memcmp (checksum_before_fn, checksum_after_fn, 16))
13789     fold_check_failed (fn, tem);
13790   
13791   md5_init_ctx (&ctx);
13792   for (i = 0; i < nargs; i++)
13793     fold_checksum_tree (argarray[i], &ctx, ht);
13794   md5_finish_ctx (&ctx, checksum_after_arglist);
13795   htab_delete (ht);
13796
13797   if (memcmp (checksum_before_arglist, checksum_after_arglist, 16))
13798     fold_check_failed (NULL_TREE, tem);
13799 #endif
13800   return tem;
13801 }
13802
13803 /* Perform constant folding and related simplification of initializer
13804    expression EXPR.  These behave identically to "fold_buildN" but ignore
13805    potential run-time traps and exceptions that fold must preserve.  */
13806
13807 #define START_FOLD_INIT \
13808   int saved_signaling_nans = flag_signaling_nans;\
13809   int saved_trapping_math = flag_trapping_math;\
13810   int saved_rounding_math = flag_rounding_math;\
13811   int saved_trapv = flag_trapv;\
13812   int saved_folding_initializer = folding_initializer;\
13813   flag_signaling_nans = 0;\
13814   flag_trapping_math = 0;\
13815   flag_rounding_math = 0;\
13816   flag_trapv = 0;\
13817   folding_initializer = 1;
13818
13819 #define END_FOLD_INIT \
13820   flag_signaling_nans = saved_signaling_nans;\
13821   flag_trapping_math = saved_trapping_math;\
13822   flag_rounding_math = saved_rounding_math;\
13823   flag_trapv = saved_trapv;\
13824   folding_initializer = saved_folding_initializer;
13825
13826 tree
13827 fold_build1_initializer (enum tree_code code, tree type, tree op)
13828 {
13829   tree result;
13830   START_FOLD_INIT;
13831
13832   result = fold_build1 (code, type, op);
13833
13834   END_FOLD_INIT;
13835   return result;
13836 }
13837
13838 tree
13839 fold_build2_initializer (enum tree_code code, tree type, tree op0, tree op1)
13840 {
13841   tree result;
13842   START_FOLD_INIT;
13843
13844   result = fold_build2 (code, type, op0, op1);
13845
13846   END_FOLD_INIT;
13847   return result;
13848 }
13849
13850 tree
13851 fold_build3_initializer (enum tree_code code, tree type, tree op0, tree op1,
13852                          tree op2)
13853 {
13854   tree result;
13855   START_FOLD_INIT;
13856
13857   result = fold_build3 (code, type, op0, op1, op2);
13858
13859   END_FOLD_INIT;
13860   return result;
13861 }
13862
13863 tree
13864 fold_build_call_array_initializer (tree type, tree fn,
13865                                    int nargs, tree *argarray)
13866 {
13867   tree result;
13868   START_FOLD_INIT;
13869
13870   result = fold_build_call_array (type, fn, nargs, argarray);
13871
13872   END_FOLD_INIT;
13873   return result;
13874 }
13875
13876 #undef START_FOLD_INIT
13877 #undef END_FOLD_INIT
13878
13879 /* Determine if first argument is a multiple of second argument.  Return 0 if
13880    it is not, or we cannot easily determined it to be.
13881
13882    An example of the sort of thing we care about (at this point; this routine
13883    could surely be made more general, and expanded to do what the *_DIV_EXPR's
13884    fold cases do now) is discovering that
13885
13886      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
13887
13888    is a multiple of
13889
13890      SAVE_EXPR (J * 8)
13891
13892    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
13893
13894    This code also handles discovering that
13895
13896      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
13897
13898    is a multiple of 8 so we don't have to worry about dealing with a
13899    possible remainder.
13900
13901    Note that we *look* inside a SAVE_EXPR only to determine how it was
13902    calculated; it is not safe for fold to do much of anything else with the
13903    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
13904    at run time.  For example, the latter example above *cannot* be implemented
13905    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
13906    evaluation time of the original SAVE_EXPR is not necessarily the same at
13907    the time the new expression is evaluated.  The only optimization of this
13908    sort that would be valid is changing
13909
13910      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
13911
13912    divided by 8 to
13913
13914      SAVE_EXPR (I) * SAVE_EXPR (J)
13915
13916    (where the same SAVE_EXPR (J) is used in the original and the
13917    transformed version).  */
13918
13919 int
13920 multiple_of_p (tree type, const_tree top, const_tree bottom)
13921 {
13922   if (operand_equal_p (top, bottom, 0))
13923     return 1;
13924
13925   if (TREE_CODE (type) != INTEGER_TYPE)
13926     return 0;
13927
13928   switch (TREE_CODE (top))
13929     {
13930     case BIT_AND_EXPR:
13931       /* Bitwise and provides a power of two multiple.  If the mask is
13932          a multiple of BOTTOM then TOP is a multiple of BOTTOM.  */
13933       if (!integer_pow2p (bottom))
13934         return 0;
13935       /* FALLTHRU */
13936
13937     case MULT_EXPR:
13938       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
13939               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
13940
13941     case PLUS_EXPR:
13942     case MINUS_EXPR:
13943       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
13944               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
13945
13946     case LSHIFT_EXPR:
13947       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
13948         {
13949           tree op1, t1;
13950
13951           op1 = TREE_OPERAND (top, 1);
13952           /* const_binop may not detect overflow correctly,
13953              so check for it explicitly here.  */
13954           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
13955               > TREE_INT_CST_LOW (op1)
13956               && TREE_INT_CST_HIGH (op1) == 0
13957               && 0 != (t1 = fold_convert (type,
13958                                           const_binop (LSHIFT_EXPR,
13959                                                        size_one_node,
13960                                                        op1, 0)))
13961               && !TREE_OVERFLOW (t1))
13962             return multiple_of_p (type, t1, bottom);
13963         }
13964       return 0;
13965
13966     case NOP_EXPR:
13967       /* Can't handle conversions from non-integral or wider integral type.  */
13968       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
13969           || (TYPE_PRECISION (type)
13970               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
13971         return 0;
13972
13973       /* .. fall through ...  */
13974
13975     case SAVE_EXPR:
13976       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
13977
13978     case INTEGER_CST:
13979       if (TREE_CODE (bottom) != INTEGER_CST
13980           || integer_zerop (bottom)
13981           || (TYPE_UNSIGNED (type)
13982               && (tree_int_cst_sgn (top) < 0
13983                   || tree_int_cst_sgn (bottom) < 0)))
13984         return 0;
13985       return integer_zerop (int_const_binop (TRUNC_MOD_EXPR,
13986                                              top, bottom, 0));
13987
13988     default:
13989       return 0;
13990     }
13991 }
13992
13993 /* Return true if `t' is known to be non-negative.  If the return
13994    value is based on the assumption that signed overflow is undefined,
13995    set *STRICT_OVERFLOW_P to true; otherwise, don't change
13996    *STRICT_OVERFLOW_P.  */
13997
13998 bool
13999 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
14000 {
14001   if (t == error_mark_node)
14002     return false;
14003
14004   if (TYPE_UNSIGNED (TREE_TYPE (t)))
14005     return true;
14006
14007   switch (TREE_CODE (t))
14008     {
14009     case SSA_NAME:
14010       /* Query VRP to see if it has recorded any information about
14011          the range of this object.  */
14012       return ssa_name_nonnegative_p (t);
14013
14014     case ABS_EXPR:
14015       /* We can't return 1 if flag_wrapv is set because
14016          ABS_EXPR<INT_MIN> = INT_MIN.  */
14017       if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
14018         return true;
14019       if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
14020         {
14021           *strict_overflow_p = true;
14022           return true;
14023         }
14024       break;
14025
14026     case INTEGER_CST:
14027       return tree_int_cst_sgn (t) >= 0;
14028
14029     case REAL_CST:
14030       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
14031
14032     case FIXED_CST:
14033       return ! FIXED_VALUE_NEGATIVE (TREE_FIXED_CST (t));
14034
14035     case POINTER_PLUS_EXPR:
14036     case PLUS_EXPR:
14037       if (FLOAT_TYPE_P (TREE_TYPE (t)))
14038         return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14039                                                strict_overflow_p)
14040                 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14041                                                   strict_overflow_p));
14042
14043       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
14044          both unsigned and at least 2 bits shorter than the result.  */
14045       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
14046           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
14047           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
14048         {
14049           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
14050           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
14051           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
14052               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
14053             {
14054               unsigned int prec = MAX (TYPE_PRECISION (inner1),
14055                                        TYPE_PRECISION (inner2)) + 1;
14056               return prec < TYPE_PRECISION (TREE_TYPE (t));
14057             }
14058         }
14059       break;
14060
14061     case MULT_EXPR:
14062       if (FLOAT_TYPE_P (TREE_TYPE (t)))
14063         {
14064           /* x * x for floating point x is always non-negative.  */
14065           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
14066             return true;
14067           return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14068                                                  strict_overflow_p)
14069                   && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14070                                                     strict_overflow_p));
14071         }
14072
14073       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
14074          both unsigned and their total bits is shorter than the result.  */
14075       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
14076           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
14077           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
14078         {
14079           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
14080           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
14081           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
14082               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
14083             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
14084                    < TYPE_PRECISION (TREE_TYPE (t));
14085         }
14086       return false;
14087
14088     case BIT_AND_EXPR:
14089     case MAX_EXPR:
14090       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14091                                              strict_overflow_p)
14092               || tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14093                                                 strict_overflow_p));
14094
14095     case BIT_IOR_EXPR:
14096     case BIT_XOR_EXPR:
14097     case MIN_EXPR:
14098     case RDIV_EXPR:
14099     case TRUNC_DIV_EXPR:
14100     case CEIL_DIV_EXPR:
14101     case FLOOR_DIV_EXPR:
14102     case ROUND_DIV_EXPR:
14103       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14104                                              strict_overflow_p)
14105               && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14106                                                 strict_overflow_p));
14107
14108     case TRUNC_MOD_EXPR:
14109     case CEIL_MOD_EXPR:
14110     case FLOOR_MOD_EXPR:
14111     case ROUND_MOD_EXPR:
14112     case SAVE_EXPR:
14113     case NON_LVALUE_EXPR:
14114     case FLOAT_EXPR:
14115     case FIX_TRUNC_EXPR:
14116       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14117                                             strict_overflow_p);
14118
14119     case COMPOUND_EXPR:
14120     case MODIFY_EXPR:
14121     case GIMPLE_MODIFY_STMT:
14122       return tree_expr_nonnegative_warnv_p (GENERIC_TREE_OPERAND (t, 1),
14123                                             strict_overflow_p);
14124
14125     case BIND_EXPR:
14126       return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
14127                                             strict_overflow_p);
14128
14129     case COND_EXPR:
14130       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14131                                              strict_overflow_p)
14132               && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
14133                                                 strict_overflow_p));
14134
14135     case NOP_EXPR:
14136       {
14137         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
14138         tree outer_type = TREE_TYPE (t);
14139
14140         if (TREE_CODE (outer_type) == REAL_TYPE)
14141           {
14142             if (TREE_CODE (inner_type) == REAL_TYPE)
14143               return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14144                                                     strict_overflow_p);
14145             if (TREE_CODE (inner_type) == INTEGER_TYPE)
14146               {
14147                 if (TYPE_UNSIGNED (inner_type))
14148                   return true;
14149                 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14150                                                       strict_overflow_p);
14151               }
14152           }
14153         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
14154           {
14155             if (TREE_CODE (inner_type) == REAL_TYPE)
14156               return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t,0),
14157                                                     strict_overflow_p);
14158             if (TREE_CODE (inner_type) == INTEGER_TYPE)
14159               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
14160                       && TYPE_UNSIGNED (inner_type);
14161           }
14162       }
14163       break;
14164
14165     case TARGET_EXPR:
14166       {
14167         tree temp = TARGET_EXPR_SLOT (t);
14168         t = TARGET_EXPR_INITIAL (t);
14169
14170         /* If the initializer is non-void, then it's a normal expression
14171            that will be assigned to the slot.  */
14172         if (!VOID_TYPE_P (t))
14173           return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
14174
14175         /* Otherwise, the initializer sets the slot in some way.  One common
14176            way is an assignment statement at the end of the initializer.  */
14177         while (1)
14178           {
14179             if (TREE_CODE (t) == BIND_EXPR)
14180               t = expr_last (BIND_EXPR_BODY (t));
14181             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
14182                      || TREE_CODE (t) == TRY_CATCH_EXPR)
14183               t = expr_last (TREE_OPERAND (t, 0));
14184             else if (TREE_CODE (t) == STATEMENT_LIST)
14185               t = expr_last (t);
14186             else
14187               break;
14188           }
14189         if ((TREE_CODE (t) == MODIFY_EXPR
14190              || TREE_CODE (t) == GIMPLE_MODIFY_STMT)
14191             && GENERIC_TREE_OPERAND (t, 0) == temp)
14192           return tree_expr_nonnegative_warnv_p (GENERIC_TREE_OPERAND (t, 1),
14193                                                 strict_overflow_p);
14194
14195         return false;
14196       }
14197
14198     case CALL_EXPR:
14199       {
14200         tree fndecl = get_callee_fndecl (t);
14201         if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
14202           switch (DECL_FUNCTION_CODE (fndecl))
14203             {
14204             CASE_FLT_FN (BUILT_IN_ACOS):
14205             CASE_FLT_FN (BUILT_IN_ACOSH):
14206             CASE_FLT_FN (BUILT_IN_CABS):
14207             CASE_FLT_FN (BUILT_IN_COSH):
14208             CASE_FLT_FN (BUILT_IN_ERFC):
14209             CASE_FLT_FN (BUILT_IN_EXP):
14210             CASE_FLT_FN (BUILT_IN_EXP10):
14211             CASE_FLT_FN (BUILT_IN_EXP2):
14212             CASE_FLT_FN (BUILT_IN_FABS):
14213             CASE_FLT_FN (BUILT_IN_FDIM):
14214             CASE_FLT_FN (BUILT_IN_HYPOT):
14215             CASE_FLT_FN (BUILT_IN_POW10):
14216             CASE_INT_FN (BUILT_IN_FFS):
14217             CASE_INT_FN (BUILT_IN_PARITY):
14218             CASE_INT_FN (BUILT_IN_POPCOUNT):
14219             case BUILT_IN_BSWAP32:
14220             case BUILT_IN_BSWAP64:
14221               /* Always true.  */
14222               return true;
14223
14224             CASE_FLT_FN (BUILT_IN_SQRT):
14225               /* sqrt(-0.0) is -0.0.  */
14226               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
14227                 return true;
14228               return tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 0),
14229                                                     strict_overflow_p);
14230
14231             CASE_FLT_FN (BUILT_IN_ASINH):
14232             CASE_FLT_FN (BUILT_IN_ATAN):
14233             CASE_FLT_FN (BUILT_IN_ATANH):
14234             CASE_FLT_FN (BUILT_IN_CBRT):
14235             CASE_FLT_FN (BUILT_IN_CEIL):
14236             CASE_FLT_FN (BUILT_IN_ERF):
14237             CASE_FLT_FN (BUILT_IN_EXPM1):
14238             CASE_FLT_FN (BUILT_IN_FLOOR):
14239             CASE_FLT_FN (BUILT_IN_FMOD):
14240             CASE_FLT_FN (BUILT_IN_FREXP):
14241             CASE_FLT_FN (BUILT_IN_LCEIL):
14242             CASE_FLT_FN (BUILT_IN_LDEXP):
14243             CASE_FLT_FN (BUILT_IN_LFLOOR):
14244             CASE_FLT_FN (BUILT_IN_LLCEIL):
14245             CASE_FLT_FN (BUILT_IN_LLFLOOR):
14246             CASE_FLT_FN (BUILT_IN_LLRINT):
14247             CASE_FLT_FN (BUILT_IN_LLROUND):
14248             CASE_FLT_FN (BUILT_IN_LRINT):
14249             CASE_FLT_FN (BUILT_IN_LROUND):
14250             CASE_FLT_FN (BUILT_IN_MODF):
14251             CASE_FLT_FN (BUILT_IN_NEARBYINT):
14252             CASE_FLT_FN (BUILT_IN_RINT):
14253             CASE_FLT_FN (BUILT_IN_ROUND):
14254             CASE_FLT_FN (BUILT_IN_SCALB):
14255             CASE_FLT_FN (BUILT_IN_SCALBLN):
14256             CASE_FLT_FN (BUILT_IN_SCALBN):
14257             CASE_FLT_FN (BUILT_IN_SIGNBIT):
14258             CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
14259             CASE_FLT_FN (BUILT_IN_SINH):
14260             CASE_FLT_FN (BUILT_IN_TANH):
14261             CASE_FLT_FN (BUILT_IN_TRUNC):
14262               /* True if the 1st argument is nonnegative.  */
14263               return tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 0),
14264                                                     strict_overflow_p);
14265
14266             CASE_FLT_FN (BUILT_IN_FMAX):
14267               /* True if the 1st OR 2nd arguments are nonnegative.  */
14268               return (tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 0),
14269                                                      strict_overflow_p)
14270                       || (tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 1),
14271                                                          strict_overflow_p)));
14272
14273             CASE_FLT_FN (BUILT_IN_FMIN):
14274               /* True if the 1st AND 2nd arguments are nonnegative.  */
14275               return (tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 0),
14276                                                      strict_overflow_p)
14277                       && (tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 1),
14278                                                          strict_overflow_p)));
14279
14280             CASE_FLT_FN (BUILT_IN_COPYSIGN):
14281               /* True if the 2nd argument is nonnegative.  */
14282               return tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 1),
14283                                                     strict_overflow_p);
14284
14285             CASE_FLT_FN (BUILT_IN_POWI):
14286               /* True if the 1st argument is nonnegative or the second
14287                  argument is an even integer.  */
14288               if (TREE_CODE (CALL_EXPR_ARG (t, 1)) == INTEGER_CST)
14289                 {
14290                   tree arg1 = CALL_EXPR_ARG (t, 1);
14291                   if ((TREE_INT_CST_LOW (arg1) & 1) == 0)
14292                     return true;
14293                 }
14294               return tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 0),
14295                                                     strict_overflow_p);
14296
14297             CASE_FLT_FN (BUILT_IN_POW):
14298               /* True if the 1st argument is nonnegative or the second
14299                  argument is an even integer valued real.  */
14300               if (TREE_CODE (CALL_EXPR_ARG (t, 1)) == REAL_CST)
14301                 {
14302                   REAL_VALUE_TYPE c;
14303                   HOST_WIDE_INT n;
14304
14305                   c = TREE_REAL_CST (CALL_EXPR_ARG (t, 1));
14306                   n = real_to_integer (&c);
14307                   if ((n & 1) == 0)
14308                     {
14309                       REAL_VALUE_TYPE cint;
14310                       real_from_integer (&cint, VOIDmode, n,
14311                                          n < 0 ? -1 : 0, 0);
14312                       if (real_identical (&c, &cint))
14313                         return true;
14314                     }
14315                 }
14316               return tree_expr_nonnegative_warnv_p (CALL_EXPR_ARG (t, 0),
14317                                                     strict_overflow_p);
14318
14319             default:
14320               break;
14321             }
14322       }
14323
14324       /* ... fall through ...  */
14325
14326     default:
14327       {
14328         tree type = TREE_TYPE (t);
14329         if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
14330             && truth_value_p (TREE_CODE (t)))
14331           /* Truth values evaluate to 0 or 1, which is nonnegative unless we
14332              have a signed:1 type (where the value is -1 and 0).  */
14333           return true;
14334       }
14335     }
14336
14337   /* We don't know sign of `t', so be conservative and return false.  */
14338   return false;
14339 }
14340
14341 /* Return true if `t' is known to be non-negative.  Handle warnings
14342    about undefined signed overflow.  */
14343
14344 bool
14345 tree_expr_nonnegative_p (tree t)
14346 {
14347   bool ret, strict_overflow_p;
14348
14349   strict_overflow_p = false;
14350   ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
14351   if (strict_overflow_p)
14352     fold_overflow_warning (("assuming signed overflow does not occur when "
14353                             "determining that expression is always "
14354                             "non-negative"),
14355                            WARN_STRICT_OVERFLOW_MISC);
14356   return ret;
14357 }
14358
14359 /* Return true when T is an address and is known to be nonzero.
14360    For floating point we further ensure that T is not denormal.
14361    Similar logic is present in nonzero_address in rtlanal.h.
14362
14363    If the return value is based on the assumption that signed overflow
14364    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
14365    change *STRICT_OVERFLOW_P.  */
14366
14367 bool
14368 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
14369 {
14370   tree type = TREE_TYPE (t);
14371   bool sub_strict_overflow_p;
14372
14373   /* Doing something useful for floating point would need more work.  */
14374   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
14375     return false;
14376
14377   switch (TREE_CODE (t))
14378     {
14379     case SSA_NAME:
14380       /* Query VRP to see if it has recorded any information about
14381          the range of this object.  */
14382       return ssa_name_nonzero_p (t);
14383
14384     case ABS_EXPR:
14385       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
14386                                         strict_overflow_p);
14387
14388     case INTEGER_CST:
14389       return !integer_zerop (t);
14390
14391     case POINTER_PLUS_EXPR:
14392     case PLUS_EXPR:
14393       if (TYPE_OVERFLOW_UNDEFINED (type))
14394         {
14395           /* With the presence of negative values it is hard
14396              to say something.  */
14397           sub_strict_overflow_p = false;
14398           if (!tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14399                                               &sub_strict_overflow_p)
14400               || !tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14401                                                  &sub_strict_overflow_p))
14402             return false;
14403           /* One of operands must be positive and the other non-negative.  */
14404           /* We don't set *STRICT_OVERFLOW_P here: even if this value
14405              overflows, on a twos-complement machine the sum of two
14406              nonnegative numbers can never be zero.  */
14407           return (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
14408                                              strict_overflow_p)
14409                   || tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
14410                                                 strict_overflow_p));
14411         }
14412       break;
14413
14414     case MULT_EXPR:
14415       if (TYPE_OVERFLOW_UNDEFINED (type))
14416         {
14417           if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
14418                                          strict_overflow_p)
14419               && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
14420                                             strict_overflow_p))
14421             {
14422               *strict_overflow_p = true;
14423               return true;
14424             }
14425         }
14426       break;
14427
14428     case NOP_EXPR:
14429       {
14430         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
14431         tree outer_type = TREE_TYPE (t);
14432
14433         return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
14434                 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
14435                                               strict_overflow_p));
14436       }
14437       break;
14438
14439    case ADDR_EXPR:
14440       {
14441         tree base = get_base_address (TREE_OPERAND (t, 0));
14442
14443         if (!base)
14444           return false;
14445
14446         /* Weak declarations may link to NULL.  */
14447         if (VAR_OR_FUNCTION_DECL_P (base))
14448           return !DECL_WEAK (base);
14449
14450         /* Constants are never weak.  */
14451         if (CONSTANT_CLASS_P (base))
14452           return true;
14453
14454         return false;
14455       }
14456
14457     case COND_EXPR:
14458       sub_strict_overflow_p = false;
14459       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
14460                                      &sub_strict_overflow_p)
14461           && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
14462                                         &sub_strict_overflow_p))
14463         {
14464           if (sub_strict_overflow_p)
14465             *strict_overflow_p = true;
14466           return true;
14467         }
14468       break;
14469
14470     case MIN_EXPR:
14471       sub_strict_overflow_p = false;
14472       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
14473                                      &sub_strict_overflow_p)
14474           && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
14475                                         &sub_strict_overflow_p))
14476         {
14477           if (sub_strict_overflow_p)
14478             *strict_overflow_p = true;
14479         }
14480       break;
14481
14482     case MAX_EXPR:
14483       sub_strict_overflow_p = false;
14484       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
14485                                      &sub_strict_overflow_p))
14486         {
14487           if (sub_strict_overflow_p)
14488             *strict_overflow_p = true;
14489
14490           /* When both operands are nonzero, then MAX must be too.  */
14491           if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
14492                                          strict_overflow_p))
14493             return true;
14494
14495           /* MAX where operand 0 is positive is positive.  */
14496           return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
14497                                                strict_overflow_p);
14498         }
14499       /* MAX where operand 1 is positive is positive.  */
14500       else if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
14501                                           &sub_strict_overflow_p)
14502                && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
14503                                                  &sub_strict_overflow_p))
14504         {
14505           if (sub_strict_overflow_p)
14506             *strict_overflow_p = true;
14507           return true;
14508         }
14509       break;
14510
14511     case COMPOUND_EXPR:
14512     case MODIFY_EXPR:
14513     case GIMPLE_MODIFY_STMT:
14514     case BIND_EXPR:
14515       return tree_expr_nonzero_warnv_p (GENERIC_TREE_OPERAND (t, 1),
14516                                         strict_overflow_p);
14517
14518     case SAVE_EXPR:
14519     case NON_LVALUE_EXPR:
14520       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
14521                                         strict_overflow_p);
14522
14523     case BIT_IOR_EXPR:
14524       return (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
14525                                         strict_overflow_p)
14526               || tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
14527                                             strict_overflow_p));
14528
14529     case CALL_EXPR:
14530       return alloca_call_p (t);
14531
14532     default:
14533       break;
14534     }
14535   return false;
14536 }
14537
14538 /* Return true when T is an address and is known to be nonzero.
14539    Handle warnings about undefined signed overflow.  */
14540
14541 bool
14542 tree_expr_nonzero_p (tree t)
14543 {
14544   bool ret, strict_overflow_p;
14545
14546   strict_overflow_p = false;
14547   ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
14548   if (strict_overflow_p)
14549     fold_overflow_warning (("assuming signed overflow does not occur when "
14550                             "determining that expression is always "
14551                             "non-zero"),
14552                            WARN_STRICT_OVERFLOW_MISC);
14553   return ret;
14554 }
14555
14556 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
14557    attempt to fold the expression to a constant without modifying TYPE,
14558    OP0 or OP1.
14559
14560    If the expression could be simplified to a constant, then return
14561    the constant.  If the expression would not be simplified to a
14562    constant, then return NULL_TREE.  */
14563
14564 tree
14565 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
14566 {
14567   tree tem = fold_binary (code, type, op0, op1);
14568   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
14569 }
14570
14571 /* Given the components of a unary expression CODE, TYPE and OP0,
14572    attempt to fold the expression to a constant without modifying
14573    TYPE or OP0.
14574
14575    If the expression could be simplified to a constant, then return
14576    the constant.  If the expression would not be simplified to a
14577    constant, then return NULL_TREE.  */
14578
14579 tree
14580 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
14581 {
14582   tree tem = fold_unary (code, type, op0);
14583   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
14584 }
14585
14586 /* If EXP represents referencing an element in a constant string
14587    (either via pointer arithmetic or array indexing), return the
14588    tree representing the value accessed, otherwise return NULL.  */
14589
14590 tree
14591 fold_read_from_constant_string (tree exp)
14592 {
14593   if ((TREE_CODE (exp) == INDIRECT_REF
14594        || TREE_CODE (exp) == ARRAY_REF)
14595       && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
14596     {
14597       tree exp1 = TREE_OPERAND (exp, 0);
14598       tree index;
14599       tree string;
14600
14601       if (TREE_CODE (exp) == INDIRECT_REF)
14602         string = string_constant (exp1, &index);
14603       else
14604         {
14605           tree low_bound = array_ref_low_bound (exp);
14606           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
14607
14608           /* Optimize the special-case of a zero lower bound.
14609
14610              We convert the low_bound to sizetype to avoid some problems
14611              with constant folding.  (E.g. suppose the lower bound is 1,
14612              and its mode is QI.  Without the conversion,l (ARRAY
14613              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
14614              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
14615           if (! integer_zerop (low_bound))
14616             index = size_diffop (index, fold_convert (sizetype, low_bound));
14617
14618           string = exp1;
14619         }
14620
14621       if (string
14622           && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
14623           && TREE_CODE (string) == STRING_CST
14624           && TREE_CODE (index) == INTEGER_CST
14625           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
14626           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
14627               == MODE_INT)
14628           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
14629         return build_int_cst_type (TREE_TYPE (exp),
14630                                    (TREE_STRING_POINTER (string)
14631                                     [TREE_INT_CST_LOW (index)]));
14632     }
14633   return NULL;
14634 }
14635
14636 /* Return the tree for neg (ARG0) when ARG0 is known to be either
14637    an integer constant, real, or fixed-point constant.
14638
14639    TYPE is the type of the result.  */
14640
14641 static tree
14642 fold_negate_const (tree arg0, tree type)
14643 {
14644   tree t = NULL_TREE;
14645
14646   switch (TREE_CODE (arg0))
14647     {
14648     case INTEGER_CST:
14649       {
14650         unsigned HOST_WIDE_INT low;
14651         HOST_WIDE_INT high;
14652         int overflow = neg_double (TREE_INT_CST_LOW (arg0),
14653                                    TREE_INT_CST_HIGH (arg0),
14654                                    &low, &high);
14655         t = force_fit_type_double (type, low, high, 1,
14656                                    (overflow | TREE_OVERFLOW (arg0))
14657                                    && !TYPE_UNSIGNED (type));
14658         break;
14659       }
14660
14661     case REAL_CST:
14662       t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
14663       break;
14664
14665     case FIXED_CST:
14666       {
14667         FIXED_VALUE_TYPE f;
14668         bool overflow_p = fixed_arithmetic (&f, NEGATE_EXPR,
14669                                             &(TREE_FIXED_CST (arg0)), NULL,
14670                                             TYPE_SATURATING (type));
14671         t = build_fixed (type, f);
14672         /* Propagate overflow flags.  */
14673         if (overflow_p | TREE_OVERFLOW (arg0))
14674           {
14675             TREE_OVERFLOW (t) = 1;
14676             TREE_CONSTANT_OVERFLOW (t) = 1;
14677           }
14678         else if (TREE_CONSTANT_OVERFLOW (arg0))
14679           TREE_CONSTANT_OVERFLOW (t) = 1;
14680         break;
14681       }
14682
14683     default:
14684       gcc_unreachable ();
14685     }
14686
14687   return t;
14688 }
14689
14690 /* Return the tree for abs (ARG0) when ARG0 is known to be either
14691    an integer constant or real constant.
14692
14693    TYPE is the type of the result.  */
14694
14695 tree
14696 fold_abs_const (tree arg0, tree type)
14697 {
14698   tree t = NULL_TREE;
14699
14700   switch (TREE_CODE (arg0))
14701     {
14702     case INTEGER_CST:
14703       /* If the value is unsigned, then the absolute value is
14704          the same as the ordinary value.  */
14705       if (TYPE_UNSIGNED (type))
14706         t = arg0;
14707       /* Similarly, if the value is non-negative.  */
14708       else if (INT_CST_LT (integer_minus_one_node, arg0))
14709         t = arg0;
14710       /* If the value is negative, then the absolute value is
14711          its negation.  */
14712       else
14713         {
14714           unsigned HOST_WIDE_INT low;
14715           HOST_WIDE_INT high;
14716           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
14717                                      TREE_INT_CST_HIGH (arg0),
14718                                      &low, &high);
14719           t = force_fit_type_double (type, low, high, -1,
14720                                      overflow | TREE_OVERFLOW (arg0));
14721         }
14722       break;
14723
14724     case REAL_CST:
14725       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
14726         t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
14727       else
14728         t =  arg0;
14729       break;
14730
14731     default:
14732       gcc_unreachable ();
14733     }
14734
14735   return t;
14736 }
14737
14738 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
14739    constant.  TYPE is the type of the result.  */
14740
14741 static tree
14742 fold_not_const (tree arg0, tree type)
14743 {
14744   tree t = NULL_TREE;
14745
14746   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
14747
14748   t = force_fit_type_double (type, ~TREE_INT_CST_LOW (arg0),
14749                              ~TREE_INT_CST_HIGH (arg0), 0,
14750                              TREE_OVERFLOW (arg0));
14751
14752   return t;
14753 }
14754
14755 /* Given CODE, a relational operator, the target type, TYPE and two
14756    constant operands OP0 and OP1, return the result of the
14757    relational operation.  If the result is not a compile time
14758    constant, then return NULL_TREE.  */
14759
14760 static tree
14761 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
14762 {
14763   int result, invert;
14764
14765   /* From here on, the only cases we handle are when the result is
14766      known to be a constant.  */
14767
14768   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
14769     {
14770       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
14771       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
14772
14773       /* Handle the cases where either operand is a NaN.  */
14774       if (real_isnan (c0) || real_isnan (c1))
14775         {
14776           switch (code)
14777             {
14778             case EQ_EXPR:
14779             case ORDERED_EXPR:
14780               result = 0;
14781               break;
14782
14783             case NE_EXPR:
14784             case UNORDERED_EXPR:
14785             case UNLT_EXPR:
14786             case UNLE_EXPR:
14787             case UNGT_EXPR:
14788             case UNGE_EXPR:
14789             case UNEQ_EXPR:
14790               result = 1;
14791               break;
14792
14793             case LT_EXPR:
14794             case LE_EXPR:
14795             case GT_EXPR:
14796             case GE_EXPR:
14797             case LTGT_EXPR:
14798               if (flag_trapping_math)
14799                 return NULL_TREE;
14800               result = 0;
14801               break;
14802
14803             default:
14804               gcc_unreachable ();
14805             }
14806
14807           return constant_boolean_node (result, type);
14808         }
14809
14810       return constant_boolean_node (real_compare (code, c0, c1), type);
14811     }
14812
14813   if (TREE_CODE (op0) == FIXED_CST && TREE_CODE (op1) == FIXED_CST)
14814     {
14815       const FIXED_VALUE_TYPE *c0 = TREE_FIXED_CST_PTR (op0);
14816       const FIXED_VALUE_TYPE *c1 = TREE_FIXED_CST_PTR (op1);
14817       return constant_boolean_node (fixed_compare (code, c0, c1), type);
14818     }
14819
14820   /* Handle equality/inequality of complex constants.  */
14821   if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
14822     {
14823       tree rcond = fold_relational_const (code, type,
14824                                           TREE_REALPART (op0),
14825                                           TREE_REALPART (op1));
14826       tree icond = fold_relational_const (code, type,
14827                                           TREE_IMAGPART (op0),
14828                                           TREE_IMAGPART (op1));
14829       if (code == EQ_EXPR)
14830         return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
14831       else if (code == NE_EXPR)
14832         return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
14833       else
14834         return NULL_TREE;
14835     }
14836
14837   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
14838
14839      To compute GT, swap the arguments and do LT.
14840      To compute GE, do LT and invert the result.
14841      To compute LE, swap the arguments, do LT and invert the result.
14842      To compute NE, do EQ and invert the result.
14843
14844      Therefore, the code below must handle only EQ and LT.  */
14845
14846   if (code == LE_EXPR || code == GT_EXPR)
14847     {
14848       tree tem = op0;
14849       op0 = op1;
14850       op1 = tem;
14851       code = swap_tree_comparison (code);
14852     }
14853
14854   /* Note that it is safe to invert for real values here because we
14855      have already handled the one case that it matters.  */
14856
14857   invert = 0;
14858   if (code == NE_EXPR || code == GE_EXPR)
14859     {
14860       invert = 1;
14861       code = invert_tree_comparison (code, false);
14862     }
14863
14864   /* Compute a result for LT or EQ if args permit;
14865      Otherwise return T.  */
14866   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
14867     {
14868       if (code == EQ_EXPR)
14869         result = tree_int_cst_equal (op0, op1);
14870       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
14871         result = INT_CST_LT_UNSIGNED (op0, op1);
14872       else
14873         result = INT_CST_LT (op0, op1);
14874     }
14875   else
14876     return NULL_TREE;
14877
14878   if (invert)
14879     result ^= 1;
14880   return constant_boolean_node (result, type);
14881 }
14882
14883 /* If necessary, return a CLEANUP_POINT_EXPR for EXPR with the
14884    indicated TYPE.  If no CLEANUP_POINT_EXPR is necessary, return EXPR
14885    itself.  */
14886
14887 tree
14888 fold_build_cleanup_point_expr (tree type, tree expr)
14889 {
14890   /* If the expression does not have side effects then we don't have to wrap
14891      it with a cleanup point expression.  */
14892   if (!TREE_SIDE_EFFECTS (expr))
14893     return expr;
14894
14895   /* If the expression is a return, check to see if the expression inside the
14896      return has no side effects or the right hand side of the modify expression
14897      inside the return. If either don't have side effects set we don't need to
14898      wrap the expression in a cleanup point expression.  Note we don't check the
14899      left hand side of the modify because it should always be a return decl.  */
14900   if (TREE_CODE (expr) == RETURN_EXPR)
14901     {
14902       tree op = TREE_OPERAND (expr, 0);
14903       if (!op || !TREE_SIDE_EFFECTS (op))
14904         return expr;
14905       op = TREE_OPERAND (op, 1);
14906       if (!TREE_SIDE_EFFECTS (op))
14907         return expr;
14908     }
14909   
14910   return build1 (CLEANUP_POINT_EXPR, type, expr);
14911 }
14912
14913 /* Given a pointer value OP0 and a type TYPE, return a simplified version
14914    of an indirection through OP0, or NULL_TREE if no simplification is
14915    possible.  */
14916
14917 tree
14918 fold_indirect_ref_1 (tree type, tree op0)
14919 {
14920   tree sub = op0;
14921   tree subtype;
14922
14923   STRIP_NOPS (sub);
14924   subtype = TREE_TYPE (sub);
14925   if (!POINTER_TYPE_P (subtype))
14926     return NULL_TREE;
14927
14928   if (TREE_CODE (sub) == ADDR_EXPR)
14929     {
14930       tree op = TREE_OPERAND (sub, 0);
14931       tree optype = TREE_TYPE (op);
14932       /* *&CONST_DECL -> to the value of the const decl.  */
14933       if (TREE_CODE (op) == CONST_DECL)
14934         return DECL_INITIAL (op);
14935       /* *&p => p;  make sure to handle *&"str"[cst] here.  */
14936       if (type == optype)
14937         {
14938           tree fop = fold_read_from_constant_string (op);
14939           if (fop)
14940             return fop;
14941           else
14942             return op;
14943         }
14944       /* *(foo *)&fooarray => fooarray[0] */
14945       else if (TREE_CODE (optype) == ARRAY_TYPE
14946                && type == TREE_TYPE (optype))
14947         {
14948           tree type_domain = TYPE_DOMAIN (optype);
14949           tree min_val = size_zero_node;
14950           if (type_domain && TYPE_MIN_VALUE (type_domain))
14951             min_val = TYPE_MIN_VALUE (type_domain);
14952           return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
14953         }
14954       /* *(foo *)&complexfoo => __real__ complexfoo */
14955       else if (TREE_CODE (optype) == COMPLEX_TYPE
14956                && type == TREE_TYPE (optype))
14957         return fold_build1 (REALPART_EXPR, type, op);
14958       /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
14959       else if (TREE_CODE (optype) == VECTOR_TYPE
14960                && type == TREE_TYPE (optype))
14961         {
14962           tree part_width = TYPE_SIZE (type);
14963           tree index = bitsize_int (0);
14964           return fold_build3 (BIT_FIELD_REF, type, op, part_width, index);
14965         }
14966     }
14967
14968   /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
14969   if (TREE_CODE (sub) == POINTER_PLUS_EXPR
14970       && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
14971     {
14972       tree op00 = TREE_OPERAND (sub, 0);
14973       tree op01 = TREE_OPERAND (sub, 1);
14974       tree op00type;
14975
14976       STRIP_NOPS (op00);
14977       op00type = TREE_TYPE (op00);
14978       if (TREE_CODE (op00) == ADDR_EXPR
14979           && TREE_CODE (TREE_TYPE (op00type)) == COMPLEX_TYPE
14980           && type == TREE_TYPE (TREE_TYPE (op00type)))
14981         {
14982           tree size = TYPE_SIZE_UNIT (type);
14983           if (tree_int_cst_equal (size, op01))
14984             return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (op00, 0));
14985         }
14986     }
14987   
14988   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
14989   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
14990       && type == TREE_TYPE (TREE_TYPE (subtype)))
14991     {
14992       tree type_domain;
14993       tree min_val = size_zero_node;
14994       sub = build_fold_indirect_ref (sub);
14995       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
14996       if (type_domain && TYPE_MIN_VALUE (type_domain))
14997         min_val = TYPE_MIN_VALUE (type_domain);
14998       return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
14999     }
15000
15001   return NULL_TREE;
15002 }
15003
15004 /* Builds an expression for an indirection through T, simplifying some
15005    cases.  */
15006
15007 tree
15008 build_fold_indirect_ref (tree t)
15009 {
15010   tree type = TREE_TYPE (TREE_TYPE (t));
15011   tree sub = fold_indirect_ref_1 (type, t);
15012
15013   if (sub)
15014     return sub;
15015   else
15016     return build1 (INDIRECT_REF, type, t);
15017 }
15018
15019 /* Given an INDIRECT_REF T, return either T or a simplified version.  */
15020
15021 tree
15022 fold_indirect_ref (tree t)
15023 {
15024   tree sub = fold_indirect_ref_1 (TREE_TYPE (t), TREE_OPERAND (t, 0));
15025
15026   if (sub)
15027     return sub;
15028   else
15029     return t;
15030 }
15031
15032 /* Strip non-trapping, non-side-effecting tree nodes from an expression
15033    whose result is ignored.  The type of the returned tree need not be
15034    the same as the original expression.  */
15035
15036 tree
15037 fold_ignored_result (tree t)
15038 {
15039   if (!TREE_SIDE_EFFECTS (t))
15040     return integer_zero_node;
15041
15042   for (;;)
15043     switch (TREE_CODE_CLASS (TREE_CODE (t)))
15044       {
15045       case tcc_unary:
15046         t = TREE_OPERAND (t, 0);
15047         break;
15048
15049       case tcc_binary:
15050       case tcc_comparison:
15051         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
15052           t = TREE_OPERAND (t, 0);
15053         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
15054           t = TREE_OPERAND (t, 1);
15055         else
15056           return t;
15057         break;
15058
15059       case tcc_expression:
15060         switch (TREE_CODE (t))
15061           {
15062           case COMPOUND_EXPR:
15063             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
15064               return t;
15065             t = TREE_OPERAND (t, 0);
15066             break;
15067
15068           case COND_EXPR:
15069             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
15070                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
15071               return t;
15072             t = TREE_OPERAND (t, 0);
15073             break;
15074
15075           default:
15076             return t;
15077           }
15078         break;
15079
15080       default:
15081         return t;
15082       }
15083 }
15084
15085 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
15086    This can only be applied to objects of a sizetype.  */
15087
15088 tree
15089 round_up (tree value, int divisor)
15090 {
15091   tree div = NULL_TREE;
15092
15093   gcc_assert (divisor > 0);
15094   if (divisor == 1)
15095     return value;
15096
15097   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
15098      have to do anything.  Only do this when we are not given a const,
15099      because in that case, this check is more expensive than just
15100      doing it.  */
15101   if (TREE_CODE (value) != INTEGER_CST)
15102     {
15103       div = build_int_cst (TREE_TYPE (value), divisor);
15104
15105       if (multiple_of_p (TREE_TYPE (value), value, div))
15106         return value;
15107     }
15108
15109   /* If divisor is a power of two, simplify this to bit manipulation.  */
15110   if (divisor == (divisor & -divisor))
15111     {
15112       if (TREE_CODE (value) == INTEGER_CST)
15113         {
15114           unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (value);
15115           unsigned HOST_WIDE_INT high;
15116           bool overflow_p;
15117
15118           if ((low & (divisor - 1)) == 0)
15119             return value;
15120
15121           overflow_p = TREE_OVERFLOW (value);
15122           high = TREE_INT_CST_HIGH (value);
15123           low &= ~(divisor - 1);
15124           low += divisor;
15125           if (low == 0)
15126             {
15127               high++;
15128               if (high == 0)
15129                 overflow_p = true;
15130             }
15131
15132           return force_fit_type_double (TREE_TYPE (value), low, high,
15133                                         -1, overflow_p);
15134         }
15135       else
15136         {
15137           tree t;
15138
15139           t = build_int_cst (TREE_TYPE (value), divisor - 1);
15140           value = size_binop (PLUS_EXPR, value, t);
15141           t = build_int_cst (TREE_TYPE (value), -divisor);
15142           value = size_binop (BIT_AND_EXPR, value, t);
15143         }
15144     }
15145   else
15146     {
15147       if (!div)
15148         div = build_int_cst (TREE_TYPE (value), divisor);
15149       value = size_binop (CEIL_DIV_EXPR, value, div);
15150       value = size_binop (MULT_EXPR, value, div);
15151     }
15152
15153   return value;
15154 }
15155
15156 /* Likewise, but round down.  */
15157
15158 tree
15159 round_down (tree value, int divisor)
15160 {
15161   tree div = NULL_TREE;
15162
15163   gcc_assert (divisor > 0);
15164   if (divisor == 1)
15165     return value;
15166
15167   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
15168      have to do anything.  Only do this when we are not given a const,
15169      because in that case, this check is more expensive than just
15170      doing it.  */
15171   if (TREE_CODE (value) != INTEGER_CST)
15172     {
15173       div = build_int_cst (TREE_TYPE (value), divisor);
15174
15175       if (multiple_of_p (TREE_TYPE (value), value, div))
15176         return value;
15177     }
15178
15179   /* If divisor is a power of two, simplify this to bit manipulation.  */
15180   if (divisor == (divisor & -divisor))
15181     {
15182       tree t;
15183
15184       t = build_int_cst (TREE_TYPE (value), -divisor);
15185       value = size_binop (BIT_AND_EXPR, value, t);
15186     }
15187   else
15188     {
15189       if (!div)
15190         div = build_int_cst (TREE_TYPE (value), divisor);
15191       value = size_binop (FLOOR_DIV_EXPR, value, div);
15192       value = size_binop (MULT_EXPR, value, div);
15193     }
15194
15195   return value;
15196 }
15197
15198 /* Returns the pointer to the base of the object addressed by EXP and
15199    extracts the information about the offset of the access, storing it
15200    to PBITPOS and POFFSET.  */
15201
15202 static tree
15203 split_address_to_core_and_offset (tree exp,
15204                                   HOST_WIDE_INT *pbitpos, tree *poffset)
15205 {
15206   tree core;
15207   enum machine_mode mode;
15208   int unsignedp, volatilep;
15209   HOST_WIDE_INT bitsize;
15210
15211   if (TREE_CODE (exp) == ADDR_EXPR)
15212     {
15213       core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
15214                                   poffset, &mode, &unsignedp, &volatilep,
15215                                   false);
15216       core = fold_addr_expr (core);
15217     }
15218   else
15219     {
15220       core = exp;
15221       *pbitpos = 0;
15222       *poffset = NULL_TREE;
15223     }
15224
15225   return core;
15226 }
15227
15228 /* Returns true if addresses of E1 and E2 differ by a constant, false
15229    otherwise.  If they do, E1 - E2 is stored in *DIFF.  */
15230
15231 bool
15232 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
15233 {
15234   tree core1, core2;
15235   HOST_WIDE_INT bitpos1, bitpos2;
15236   tree toffset1, toffset2, tdiff, type;
15237
15238   core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
15239   core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
15240
15241   if (bitpos1 % BITS_PER_UNIT != 0
15242       || bitpos2 % BITS_PER_UNIT != 0
15243       || !operand_equal_p (core1, core2, 0))
15244     return false;
15245
15246   if (toffset1 && toffset2)
15247     {
15248       type = TREE_TYPE (toffset1);
15249       if (type != TREE_TYPE (toffset2))
15250         toffset2 = fold_convert (type, toffset2);
15251
15252       tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
15253       if (!cst_and_fits_in_hwi (tdiff))
15254         return false;
15255
15256       *diff = int_cst_value (tdiff);
15257     }
15258   else if (toffset1 || toffset2)
15259     {
15260       /* If only one of the offsets is non-constant, the difference cannot
15261          be a constant.  */
15262       return false;
15263     }
15264   else
15265     *diff = 0;
15266
15267   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
15268   return true;
15269 }
15270
15271 /* Simplify the floating point expression EXP when the sign of the
15272    result is not significant.  Return NULL_TREE if no simplification
15273    is possible.  */
15274
15275 tree
15276 fold_strip_sign_ops (tree exp)
15277 {
15278   tree arg0, arg1;
15279
15280   switch (TREE_CODE (exp))
15281     {
15282     case ABS_EXPR:
15283     case NEGATE_EXPR:
15284       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
15285       return arg0 ? arg0 : TREE_OPERAND (exp, 0);
15286
15287     case MULT_EXPR:
15288     case RDIV_EXPR:
15289       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
15290         return NULL_TREE;
15291       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
15292       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15293       if (arg0 != NULL_TREE || arg1 != NULL_TREE)
15294         return fold_build2 (TREE_CODE (exp), TREE_TYPE (exp),
15295                             arg0 ? arg0 : TREE_OPERAND (exp, 0),
15296                             arg1 ? arg1 : TREE_OPERAND (exp, 1));
15297       break;
15298
15299     case COMPOUND_EXPR:
15300       arg0 = TREE_OPERAND (exp, 0);
15301       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15302       if (arg1)
15303         return fold_build2 (COMPOUND_EXPR, TREE_TYPE (exp), arg0, arg1);
15304       break;
15305       
15306     case COND_EXPR:
15307       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
15308       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 2));
15309       if (arg0 || arg1)
15310         return fold_build3 (COND_EXPR, TREE_TYPE (exp), TREE_OPERAND (exp, 0),
15311                             arg0 ? arg0 : TREE_OPERAND (exp, 1),
15312                             arg1 ? arg1 : TREE_OPERAND (exp, 2));
15313       break;
15314       
15315     case CALL_EXPR:
15316       {
15317         const enum built_in_function fcode = builtin_mathfn_code (exp);
15318         switch (fcode)
15319         {
15320         CASE_FLT_FN (BUILT_IN_COPYSIGN):
15321           /* Strip copysign function call, return the 1st argument. */
15322           arg0 = CALL_EXPR_ARG (exp, 0);
15323           arg1 = CALL_EXPR_ARG (exp, 1);
15324           return omit_one_operand (TREE_TYPE (exp), arg0, arg1);
15325
15326         default:
15327           /* Strip sign ops from the argument of "odd" math functions.  */
15328           if (negate_mathfn_p (fcode))
15329             {
15330               arg0 = fold_strip_sign_ops (CALL_EXPR_ARG (exp, 0));
15331               if (arg0)
15332                 return build_call_expr (get_callee_fndecl (exp), 1, arg0);
15333             }
15334           break;
15335         }
15336       }
15337       break;
15338
15339     default:
15340       break;
15341     }
15342   return NULL_TREE;
15343 }