]> CyberLeo.Net >> Repos - FreeBSD/releng/9.0.git/blob - contrib/gcc/fold-const.c
Copy stable/9 to releng/9.0 as part of the FreeBSD 9.0-RELEASE release
[FreeBSD/releng/9.0.git] / contrib / 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 2, 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 COPYING.  If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA.  */
22
23 /*@@ This file should be rewritten to use an arbitrary precision
24   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
25   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
26   @@ The routines that translate from the ap rep should
27   @@ warn if precision et. al. is lost.
28   @@ This would also make life easier when this technology is used
29   @@ for cross-compilers.  */
30
31 /* The entry points in this file are fold, size_int_wide, size_binop
32    and force_fit_type.
33
34    fold takes a tree as argument and returns a simplified tree.
35
36    size_binop takes a tree code for an arithmetic operation
37    and two operands that are trees, and produces a tree for the
38    result, assuming the type comes from `sizetype'.
39
40    size_int takes an integer value, and creates a tree constant
41    with type from `sizetype'.
42
43    force_fit_type takes a constant, an overflowable flag and prior
44    overflow indicators.  It forces the value to fit the type and sets
45    TREE_OVERFLOW and TREE_CONSTANT_OVERFLOW as appropriate.  */
46
47 #include "config.h"
48 #include "system.h"
49 #include "coretypes.h"
50 #include "tm.h"
51 #include "flags.h"
52 #include "tree.h"
53 #include "real.h"
54 #include "rtl.h"
55 #include "expr.h"
56 #include "tm_p.h"
57 #include "toplev.h"
58 #include "intl.h"
59 #include "ggc.h"
60 #include "hashtab.h"
61 #include "langhooks.h"
62 #include "md5.h"
63
64 /* Non-zero if we are folding constants inside an initializer; zero
65    otherwise.  */
66 int folding_initializer = 0;
67
68 /* The following constants represent a bit based encoding of GCC's
69    comparison operators.  This encoding simplifies transformations
70    on relational comparison operators, such as AND and OR.  */
71 enum comparison_code {
72   COMPCODE_FALSE = 0,
73   COMPCODE_LT = 1,
74   COMPCODE_EQ = 2,
75   COMPCODE_LE = 3,
76   COMPCODE_GT = 4,
77   COMPCODE_LTGT = 5,
78   COMPCODE_GE = 6,
79   COMPCODE_ORD = 7,
80   COMPCODE_UNORD = 8,
81   COMPCODE_UNLT = 9,
82   COMPCODE_UNEQ = 10,
83   COMPCODE_UNLE = 11,
84   COMPCODE_UNGT = 12,
85   COMPCODE_NE = 13,
86   COMPCODE_UNGE = 14,
87   COMPCODE_TRUE = 15
88 };
89
90 static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
91 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
92 static bool negate_mathfn_p (enum built_in_function);
93 static bool negate_expr_p (tree);
94 static tree negate_expr (tree);
95 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
96 static tree associate_trees (tree, tree, enum tree_code, tree);
97 static tree const_binop (enum tree_code, tree, tree, int);
98 static enum comparison_code comparison_to_compcode (enum tree_code);
99 static enum tree_code compcode_to_comparison (enum comparison_code);
100 static tree combine_comparisons (enum tree_code, enum tree_code,
101                                  enum tree_code, tree, tree, tree);
102 static int truth_value_p (enum tree_code);
103 static int operand_equal_for_comparison_p (tree, tree, tree);
104 static int twoval_comparison_p (tree, tree *, tree *, int *);
105 static tree eval_subst (tree, tree, tree, tree, tree);
106 static tree pedantic_omit_one_operand (tree, tree, tree);
107 static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
108 static tree make_bit_field_ref (tree, tree, int, int, int);
109 static tree optimize_bit_field_compare (enum tree_code, tree, tree, tree);
110 static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
111                                     enum machine_mode *, int *, int *,
112                                     tree *, tree *);
113 static int all_ones_mask_p (tree, int);
114 static tree sign_bit_p (tree, tree);
115 static int simple_operand_p (tree);
116 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
117 static tree range_predecessor (tree);
118 static tree range_successor (tree);
119 static tree make_range (tree, int *, tree *, tree *, bool *);
120 static tree build_range_check (tree, tree, int, tree, tree);
121 static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
122                          tree);
123 static tree fold_range_test (enum tree_code, tree, tree, tree);
124 static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
125 static tree unextend (tree, int, int, tree);
126 static tree fold_truthop (enum tree_code, tree, tree, tree);
127 static tree optimize_minmax_comparison (enum tree_code, tree, tree, tree);
128 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
129 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
130 static int multiple_of_p (tree, tree, tree);
131 static tree fold_binary_op_with_conditional_arg (enum tree_code, tree,
132                                                  tree, tree,
133                                                  tree, tree, int);
134 static bool fold_real_zero_addition_p (tree, tree, int);
135 static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
136                                  tree, tree, tree);
137 static tree fold_inf_compare (enum tree_code, tree, tree, tree);
138 static tree fold_div_compare (enum tree_code, tree, tree, tree);
139 static bool reorder_operands_p (tree, tree);
140 static tree fold_negate_const (tree, tree);
141 static tree fold_not_const (tree, tree);
142 static tree fold_relational_const (enum tree_code, tree, tree, tree);
143 static int native_encode_expr (tree, unsigned char *, int);
144 static tree native_interpret_expr (tree, unsigned char *, int);
145
146
147 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
148    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
149    and SUM1.  Then this yields nonzero if overflow occurred during the
150    addition.
151
152    Overflow occurs if A and B have the same sign, but A and SUM differ in
153    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
154    sign.  */
155 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
156 \f
157 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
158    We do that by representing the two-word integer in 4 words, with only
159    HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
160    number.  The value of the word is LOWPART + HIGHPART * BASE.  */
161
162 #define LOWPART(x) \
163   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
164 #define HIGHPART(x) \
165   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
166 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
167
168 /* Unpack a two-word integer into 4 words.
169    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
170    WORDS points to the array of HOST_WIDE_INTs.  */
171
172 static void
173 encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
174 {
175   words[0] = LOWPART (low);
176   words[1] = HIGHPART (low);
177   words[2] = LOWPART (hi);
178   words[3] = HIGHPART (hi);
179 }
180
181 /* Pack an array of 4 words into a two-word integer.
182    WORDS points to the array of words.
183    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
184
185 static void
186 decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
187         HOST_WIDE_INT *hi)
188 {
189   *low = words[0] + words[1] * BASE;
190   *hi = words[2] + words[3] * BASE;
191 }
192 \f
193 /* T is an INT_CST node.  OVERFLOWABLE indicates if we are interested
194    in overflow of the value, when >0 we are only interested in signed
195    overflow, for <0 we are interested in any overflow.  OVERFLOWED
196    indicates whether overflow has already occurred.  CONST_OVERFLOWED
197    indicates whether constant overflow has already occurred.  We force
198    T's value to be within range of T's type (by setting to 0 or 1 all
199    the bits outside the type's range).  We set TREE_OVERFLOWED if,
200         OVERFLOWED is nonzero,
201         or OVERFLOWABLE is >0 and signed overflow occurs
202         or OVERFLOWABLE is <0 and any overflow occurs
203    We set TREE_CONSTANT_OVERFLOWED if,
204         CONST_OVERFLOWED is nonzero
205         or we set TREE_OVERFLOWED.
206   We return either the original T, or a copy.  */
207
208 tree
209 force_fit_type (tree t, int overflowable,
210                 bool overflowed, bool overflowed_const)
211 {
212   unsigned HOST_WIDE_INT low;
213   HOST_WIDE_INT high;
214   unsigned int prec;
215   int sign_extended_type;
216
217   gcc_assert (TREE_CODE (t) == INTEGER_CST);
218
219   low = TREE_INT_CST_LOW (t);
220   high = TREE_INT_CST_HIGH (t);
221
222   if (POINTER_TYPE_P (TREE_TYPE (t))
223       || TREE_CODE (TREE_TYPE (t)) == OFFSET_TYPE)
224     prec = POINTER_SIZE;
225   else
226     prec = TYPE_PRECISION (TREE_TYPE (t));
227   /* Size types *are* sign extended.  */
228   sign_extended_type = (!TYPE_UNSIGNED (TREE_TYPE (t))
229                         || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
230                             && TYPE_IS_SIZETYPE (TREE_TYPE (t))));
231
232   /* First clear all bits that are beyond the type's precision.  */
233
234   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
235     ;
236   else if (prec > HOST_BITS_PER_WIDE_INT)
237     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
238   else
239     {
240       high = 0;
241       if (prec < HOST_BITS_PER_WIDE_INT)
242         low &= ~((HOST_WIDE_INT) (-1) << prec);
243     }
244
245   if (!sign_extended_type)
246     /* No sign extension */;
247   else if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
248     /* Correct width already.  */;
249   else if (prec > HOST_BITS_PER_WIDE_INT)
250     {
251       /* Sign extend top half? */
252       if (high & ((unsigned HOST_WIDE_INT)1
253                   << (prec - HOST_BITS_PER_WIDE_INT - 1)))
254         high |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
255     }
256   else if (prec == HOST_BITS_PER_WIDE_INT)
257     {
258       if ((HOST_WIDE_INT)low < 0)
259         high = -1;
260     }
261   else
262     {
263       /* Sign extend bottom half? */
264       if (low & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
265         {
266           high = -1;
267           low |= (HOST_WIDE_INT)(-1) << prec;
268         }
269     }
270
271   /* If the value changed, return a new node.  */
272   if (overflowed || overflowed_const
273       || low != TREE_INT_CST_LOW (t) || high != TREE_INT_CST_HIGH (t))
274     {
275       t = build_int_cst_wide (TREE_TYPE (t), low, high);
276
277       if (overflowed
278           || overflowable < 0
279           || (overflowable > 0 && sign_extended_type))
280         {
281           t = copy_node (t);
282           TREE_OVERFLOW (t) = 1;
283           TREE_CONSTANT_OVERFLOW (t) = 1;
284         }
285       else if (overflowed_const)
286         {
287           t = copy_node (t);
288           TREE_CONSTANT_OVERFLOW (t) = 1;
289         }
290     }
291
292   return t;
293 }
294 \f
295 /* Add two doubleword integers with doubleword result.
296    Return nonzero if the operation overflows according to UNSIGNED_P.
297    Each argument is given as two `HOST_WIDE_INT' pieces.
298    One argument is L1 and H1; the other, L2 and H2.
299    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
300
301 int
302 add_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
303                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
304                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
305                       bool unsigned_p)
306 {
307   unsigned HOST_WIDE_INT l;
308   HOST_WIDE_INT h;
309
310   l = l1 + l2;
311   h = h1 + h2 + (l < l1);
312
313   *lv = l;
314   *hv = h;
315
316   if (unsigned_p)
317     return (unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1;
318   else
319     return OVERFLOW_SUM_SIGN (h1, h2, h);
320 }
321
322 /* Negate a doubleword integer with doubleword result.
323    Return nonzero if the operation overflows, assuming it's signed.
324    The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
325    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
326
327 int
328 neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
329             unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
330 {
331   if (l1 == 0)
332     {
333       *lv = 0;
334       *hv = - h1;
335       return (*hv & h1) < 0;
336     }
337   else
338     {
339       *lv = -l1;
340       *hv = ~h1;
341       return 0;
342     }
343 }
344 \f
345 /* Multiply two doubleword integers with doubleword result.
346    Return nonzero if the operation overflows according to UNSIGNED_P.
347    Each argument is given as two `HOST_WIDE_INT' pieces.
348    One argument is L1 and H1; the other, L2 and H2.
349    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
350
351 int
352 mul_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
353                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
354                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
355                       bool unsigned_p)
356 {
357   HOST_WIDE_INT arg1[4];
358   HOST_WIDE_INT arg2[4];
359   HOST_WIDE_INT prod[4 * 2];
360   unsigned HOST_WIDE_INT carry;
361   int i, j, k;
362   unsigned HOST_WIDE_INT toplow, neglow;
363   HOST_WIDE_INT tophigh, neghigh;
364
365   encode (arg1, l1, h1);
366   encode (arg2, l2, h2);
367
368   memset (prod, 0, sizeof prod);
369
370   for (i = 0; i < 4; i++)
371     {
372       carry = 0;
373       for (j = 0; j < 4; j++)
374         {
375           k = i + j;
376           /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000.  */
377           carry += arg1[i] * arg2[j];
378           /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF.  */
379           carry += prod[k];
380           prod[k] = LOWPART (carry);
381           carry = HIGHPART (carry);
382         }
383       prod[i + 4] = carry;
384     }
385
386   decode (prod, lv, hv);
387   decode (prod + 4, &toplow, &tophigh);
388
389   /* Unsigned overflow is immediate.  */
390   if (unsigned_p)
391     return (toplow | tophigh) != 0;
392
393   /* Check for signed overflow by calculating the signed representation of the
394      top half of the result; it should agree with the low half's sign bit.  */
395   if (h1 < 0)
396     {
397       neg_double (l2, h2, &neglow, &neghigh);
398       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
399     }
400   if (h2 < 0)
401     {
402       neg_double (l1, h1, &neglow, &neghigh);
403       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
404     }
405   return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
406 }
407 \f
408 /* Shift the doubleword integer in L1, H1 left by COUNT places
409    keeping only PREC bits of result.
410    Shift right if COUNT is negative.
411    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
412    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
413
414 void
415 lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
416                HOST_WIDE_INT count, unsigned int prec,
417                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, int arith)
418 {
419   unsigned HOST_WIDE_INT signmask;
420
421   if (count < 0)
422     {
423       rshift_double (l1, h1, -count, prec, lv, hv, arith);
424       return;
425     }
426
427   if (SHIFT_COUNT_TRUNCATED)
428     count %= prec;
429
430   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
431     {
432       /* Shifting by the host word size is undefined according to the
433          ANSI standard, so we must handle this as a special case.  */
434       *hv = 0;
435       *lv = 0;
436     }
437   else if (count >= HOST_BITS_PER_WIDE_INT)
438     {
439       *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
440       *lv = 0;
441     }
442   else
443     {
444       *hv = (((unsigned HOST_WIDE_INT) h1 << count)
445              | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
446       *lv = l1 << count;
447     }
448
449   /* Sign extend all bits that are beyond the precision.  */
450
451   signmask = -((prec > HOST_BITS_PER_WIDE_INT
452                 ? ((unsigned HOST_WIDE_INT) *hv
453                    >> (prec - HOST_BITS_PER_WIDE_INT - 1))
454                 : (*lv >> (prec - 1))) & 1);
455
456   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
457     ;
458   else if (prec >= HOST_BITS_PER_WIDE_INT)
459     {
460       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
461       *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
462     }
463   else
464     {
465       *hv = signmask;
466       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
467       *lv |= signmask << prec;
468     }
469 }
470
471 /* Shift the doubleword integer in L1, H1 right by COUNT places
472    keeping only PREC bits of result.  COUNT must be positive.
473    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
474    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
475
476 void
477 rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
478                HOST_WIDE_INT count, unsigned int prec,
479                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
480                int arith)
481 {
482   unsigned HOST_WIDE_INT signmask;
483
484   signmask = (arith
485               ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
486               : 0);
487
488   if (SHIFT_COUNT_TRUNCATED)
489     count %= prec;
490
491   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
492     {
493       /* Shifting by the host word size is undefined according to the
494          ANSI standard, so we must handle this as a special case.  */
495       *hv = 0;
496       *lv = 0;
497     }
498   else if (count >= HOST_BITS_PER_WIDE_INT)
499     {
500       *hv = 0;
501       *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
502     }
503   else
504     {
505       *hv = (unsigned HOST_WIDE_INT) h1 >> count;
506       *lv = ((l1 >> count)
507              | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
508     }
509
510   /* Zero / sign extend all bits that are beyond the precision.  */
511
512   if (count >= (HOST_WIDE_INT)prec)
513     {
514       *hv = signmask;
515       *lv = signmask;
516     }
517   else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT)
518     ;
519   else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
520     {
521       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
522       *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
523     }
524   else
525     {
526       *hv = signmask;
527       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
528       *lv |= signmask << (prec - count);
529     }
530 }
531 \f
532 /* Rotate the doubleword integer in L1, H1 left by COUNT places
533    keeping only PREC bits of result.
534    Rotate right if COUNT is negative.
535    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
536
537 void
538 lrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
539                 HOST_WIDE_INT count, unsigned int prec,
540                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
541 {
542   unsigned HOST_WIDE_INT s1l, s2l;
543   HOST_WIDE_INT s1h, s2h;
544
545   count %= prec;
546   if (count < 0)
547     count += prec;
548
549   lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
550   rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
551   *lv = s1l | s2l;
552   *hv = s1h | s2h;
553 }
554
555 /* Rotate the doubleword integer in L1, H1 left by COUNT places
556    keeping only PREC bits of result.  COUNT must be positive.
557    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
558
559 void
560 rrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
561                 HOST_WIDE_INT count, unsigned int prec,
562                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
563 {
564   unsigned HOST_WIDE_INT s1l, s2l;
565   HOST_WIDE_INT s1h, s2h;
566
567   count %= prec;
568   if (count < 0)
569     count += prec;
570
571   rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
572   lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
573   *lv = s1l | s2l;
574   *hv = s1h | s2h;
575 }
576 \f
577 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
578    for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
579    CODE is a tree code for a kind of division, one of
580    TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
581    or EXACT_DIV_EXPR
582    It controls how the quotient is rounded to an integer.
583    Return nonzero if the operation overflows.
584    UNS nonzero says do unsigned division.  */
585
586 int
587 div_and_round_double (enum tree_code code, int uns,
588                       unsigned HOST_WIDE_INT lnum_orig, /* num == numerator == dividend */
589                       HOST_WIDE_INT hnum_orig,
590                       unsigned HOST_WIDE_INT lden_orig, /* den == denominator == divisor */
591                       HOST_WIDE_INT hden_orig,
592                       unsigned HOST_WIDE_INT *lquo,
593                       HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
594                       HOST_WIDE_INT *hrem)
595 {
596   int quo_neg = 0;
597   HOST_WIDE_INT num[4 + 1];     /* extra element for scaling.  */
598   HOST_WIDE_INT den[4], quo[4];
599   int i, j;
600   unsigned HOST_WIDE_INT work;
601   unsigned HOST_WIDE_INT carry = 0;
602   unsigned HOST_WIDE_INT lnum = lnum_orig;
603   HOST_WIDE_INT hnum = hnum_orig;
604   unsigned HOST_WIDE_INT lden = lden_orig;
605   HOST_WIDE_INT hden = hden_orig;
606   int overflow = 0;
607
608   if (hden == 0 && lden == 0)
609     overflow = 1, lden = 1;
610
611   /* Calculate quotient sign and convert operands to unsigned.  */
612   if (!uns)
613     {
614       if (hnum < 0)
615         {
616           quo_neg = ~ quo_neg;
617           /* (minimum integer) / (-1) is the only overflow case.  */
618           if (neg_double (lnum, hnum, &lnum, &hnum)
619               && ((HOST_WIDE_INT) lden & hden) == -1)
620             overflow = 1;
621         }
622       if (hden < 0)
623         {
624           quo_neg = ~ quo_neg;
625           neg_double (lden, hden, &lden, &hden);
626         }
627     }
628
629   if (hnum == 0 && hden == 0)
630     {                           /* single precision */
631       *hquo = *hrem = 0;
632       /* This unsigned division rounds toward zero.  */
633       *lquo = lnum / lden;
634       goto finish_up;
635     }
636
637   if (hnum == 0)
638     {                           /* trivial case: dividend < divisor */
639       /* hden != 0 already checked.  */
640       *hquo = *lquo = 0;
641       *hrem = hnum;
642       *lrem = lnum;
643       goto finish_up;
644     }
645
646   memset (quo, 0, sizeof quo);
647
648   memset (num, 0, sizeof num);  /* to zero 9th element */
649   memset (den, 0, sizeof den);
650
651   encode (num, lnum, hnum);
652   encode (den, lden, hden);
653
654   /* Special code for when the divisor < BASE.  */
655   if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
656     {
657       /* hnum != 0 already checked.  */
658       for (i = 4 - 1; i >= 0; i--)
659         {
660           work = num[i] + carry * BASE;
661           quo[i] = work / lden;
662           carry = work % lden;
663         }
664     }
665   else
666     {
667       /* Full double precision division,
668          with thanks to Don Knuth's "Seminumerical Algorithms".  */
669       int num_hi_sig, den_hi_sig;
670       unsigned HOST_WIDE_INT quo_est, scale;
671
672       /* Find the highest nonzero divisor digit.  */
673       for (i = 4 - 1;; i--)
674         if (den[i] != 0)
675           {
676             den_hi_sig = i;
677             break;
678           }
679
680       /* Insure that the first digit of the divisor is at least BASE/2.
681          This is required by the quotient digit estimation algorithm.  */
682
683       scale = BASE / (den[den_hi_sig] + 1);
684       if (scale > 1)
685         {               /* scale divisor and dividend */
686           carry = 0;
687           for (i = 0; i <= 4 - 1; i++)
688             {
689               work = (num[i] * scale) + carry;
690               num[i] = LOWPART (work);
691               carry = HIGHPART (work);
692             }
693
694           num[4] = carry;
695           carry = 0;
696           for (i = 0; i <= 4 - 1; i++)
697             {
698               work = (den[i] * scale) + carry;
699               den[i] = LOWPART (work);
700               carry = HIGHPART (work);
701               if (den[i] != 0) den_hi_sig = i;
702             }
703         }
704
705       num_hi_sig = 4;
706
707       /* Main loop */
708       for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
709         {
710           /* Guess the next quotient digit, quo_est, by dividing the first
711              two remaining dividend digits by the high order quotient digit.
712              quo_est is never low and is at most 2 high.  */
713           unsigned HOST_WIDE_INT tmp;
714
715           num_hi_sig = i + den_hi_sig + 1;
716           work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
717           if (num[num_hi_sig] != den[den_hi_sig])
718             quo_est = work / den[den_hi_sig];
719           else
720             quo_est = BASE - 1;
721
722           /* Refine quo_est so it's usually correct, and at most one high.  */
723           tmp = work - quo_est * den[den_hi_sig];
724           if (tmp < BASE
725               && (den[den_hi_sig - 1] * quo_est
726                   > (tmp * BASE + num[num_hi_sig - 2])))
727             quo_est--;
728
729           /* Try QUO_EST as the quotient digit, by multiplying the
730              divisor by QUO_EST and subtracting from the remaining dividend.
731              Keep in mind that QUO_EST is the I - 1st digit.  */
732
733           carry = 0;
734           for (j = 0; j <= den_hi_sig; j++)
735             {
736               work = quo_est * den[j] + carry;
737               carry = HIGHPART (work);
738               work = num[i + j] - LOWPART (work);
739               num[i + j] = LOWPART (work);
740               carry += HIGHPART (work) != 0;
741             }
742
743           /* If quo_est was high by one, then num[i] went negative and
744              we need to correct things.  */
745           if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
746             {
747               quo_est--;
748               carry = 0;                /* add divisor back in */
749               for (j = 0; j <= den_hi_sig; j++)
750                 {
751                   work = num[i + j] + den[j] + carry;
752                   carry = HIGHPART (work);
753                   num[i + j] = LOWPART (work);
754                 }
755
756               num [num_hi_sig] += carry;
757             }
758
759           /* Store the quotient digit.  */
760           quo[i] = quo_est;
761         }
762     }
763
764   decode (quo, lquo, hquo);
765
766  finish_up:
767   /* If result is negative, make it so.  */
768   if (quo_neg)
769     neg_double (*lquo, *hquo, lquo, hquo);
770
771   /* Compute trial remainder:  rem = num - (quo * den)  */
772   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
773   neg_double (*lrem, *hrem, lrem, hrem);
774   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
775
776   switch (code)
777     {
778     case TRUNC_DIV_EXPR:
779     case TRUNC_MOD_EXPR:        /* round toward zero */
780     case EXACT_DIV_EXPR:        /* for this one, it shouldn't matter */
781       return overflow;
782
783     case FLOOR_DIV_EXPR:
784     case FLOOR_MOD_EXPR:        /* round toward negative infinity */
785       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
786         {
787           /* quo = quo - 1;  */
788           add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT)  -1,
789                       lquo, hquo);
790         }
791       else
792         return overflow;
793       break;
794
795     case CEIL_DIV_EXPR:
796     case CEIL_MOD_EXPR:         /* round toward positive infinity */
797       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
798         {
799           add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
800                       lquo, hquo);
801         }
802       else
803         return overflow;
804       break;
805
806     case ROUND_DIV_EXPR:
807     case ROUND_MOD_EXPR:        /* round to closest integer */
808       {
809         unsigned HOST_WIDE_INT labs_rem = *lrem;
810         HOST_WIDE_INT habs_rem = *hrem;
811         unsigned HOST_WIDE_INT labs_den = lden, ltwice;
812         HOST_WIDE_INT habs_den = hden, htwice;
813
814         /* Get absolute values.  */
815         if (*hrem < 0)
816           neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
817         if (hden < 0)
818           neg_double (lden, hden, &labs_den, &habs_den);
819
820         /* If (2 * abs (lrem) >= abs (lden)) */
821         mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
822                     labs_rem, habs_rem, &ltwice, &htwice);
823
824         if (((unsigned HOST_WIDE_INT) habs_den
825              < (unsigned HOST_WIDE_INT) htwice)
826             || (((unsigned HOST_WIDE_INT) habs_den
827                  == (unsigned HOST_WIDE_INT) htwice)
828                 && (labs_den < ltwice)))
829           {
830             if (*hquo < 0)
831               /* quo = quo - 1;  */
832               add_double (*lquo, *hquo,
833                           (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
834             else
835               /* quo = quo + 1; */
836               add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
837                           lquo, hquo);
838           }
839         else
840           return overflow;
841       }
842       break;
843
844     default:
845       gcc_unreachable ();
846     }
847
848   /* Compute true remainder:  rem = num - (quo * den)  */
849   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
850   neg_double (*lrem, *hrem, lrem, hrem);
851   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
852   return overflow;
853 }
854
855 /* If ARG2 divides ARG1 with zero remainder, carries out the division
856    of type CODE and returns the quotient.
857    Otherwise returns NULL_TREE.  */
858
859 static tree
860 div_if_zero_remainder (enum tree_code code, tree arg1, tree arg2)
861 {
862   unsigned HOST_WIDE_INT int1l, int2l;
863   HOST_WIDE_INT int1h, int2h;
864   unsigned HOST_WIDE_INT quol, reml;
865   HOST_WIDE_INT quoh, remh;
866   tree type = TREE_TYPE (arg1);
867   int uns = TYPE_UNSIGNED (type);
868
869   int1l = TREE_INT_CST_LOW (arg1);
870   int1h = TREE_INT_CST_HIGH (arg1);
871   int2l = TREE_INT_CST_LOW (arg2);
872   int2h = TREE_INT_CST_HIGH (arg2);
873
874   div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
875                         &quol, &quoh, &reml, &remh);
876   if (remh != 0 || reml != 0)
877     return NULL_TREE;
878
879   return build_int_cst_wide (type, quol, quoh);
880 }
881 \f
882 /* This is non-zero if we should defer warnings about undefined
883    overflow.  This facility exists because these warnings are a
884    special case.  The code to estimate loop iterations does not want
885    to issue any warnings, since it works with expressions which do not
886    occur in user code.  Various bits of cleanup code call fold(), but
887    only use the result if it has certain characteristics (e.g., is a
888    constant); that code only wants to issue a warning if the result is
889    used.  */
890
891 static int fold_deferring_overflow_warnings;
892
893 /* If a warning about undefined overflow is deferred, this is the
894    warning.  Note that this may cause us to turn two warnings into
895    one, but that is fine since it is sufficient to only give one
896    warning per expression.  */
897
898 static const char* fold_deferred_overflow_warning;
899
900 /* If a warning about undefined overflow is deferred, this is the
901    level at which the warning should be emitted.  */
902
903 static enum warn_strict_overflow_code fold_deferred_overflow_code;
904
905 /* Start deferring overflow warnings.  We could use a stack here to
906    permit nested calls, but at present it is not necessary.  */
907
908 void
909 fold_defer_overflow_warnings (void)
910 {
911   ++fold_deferring_overflow_warnings;
912 }
913
914 /* Stop deferring overflow warnings.  If there is a pending warning,
915    and ISSUE is true, then issue the warning if appropriate.  STMT is
916    the statement with which the warning should be associated (used for
917    location information); STMT may be NULL.  CODE is the level of the
918    warning--a warn_strict_overflow_code value.  This function will use
919    the smaller of CODE and the deferred code when deciding whether to
920    issue the warning.  CODE may be zero to mean to always use the
921    deferred code.  */
922
923 void
924 fold_undefer_overflow_warnings (bool issue, tree stmt, int code)
925 {
926   const char *warnmsg;
927   location_t locus;
928
929   gcc_assert (fold_deferring_overflow_warnings > 0);
930   --fold_deferring_overflow_warnings;
931   if (fold_deferring_overflow_warnings > 0)
932     {
933       if (fold_deferred_overflow_warning != NULL
934           && code != 0
935           && code < (int) fold_deferred_overflow_code)
936         fold_deferred_overflow_code = code;
937       return;
938     }
939
940   warnmsg = fold_deferred_overflow_warning;
941   fold_deferred_overflow_warning = NULL;
942
943   if (!issue || warnmsg == NULL)
944     return;
945
946   /* Use the smallest code level when deciding to issue the
947      warning.  */
948   if (code == 0 || code > (int) fold_deferred_overflow_code)
949     code = fold_deferred_overflow_code;
950
951   if (!issue_strict_overflow_warning (code))
952     return;
953
954   if (stmt == NULL_TREE || !EXPR_HAS_LOCATION (stmt))
955     locus = input_location;
956   else
957     locus = EXPR_LOCATION (stmt);
958   warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg);
959 }
960
961 /* Stop deferring overflow warnings, ignoring any deferred
962    warnings.  */
963
964 void
965 fold_undefer_and_ignore_overflow_warnings (void)
966 {
967   fold_undefer_overflow_warnings (false, NULL_TREE, 0);
968 }
969
970 /* Whether we are deferring overflow warnings.  */
971
972 bool
973 fold_deferring_overflow_warnings_p (void)
974 {
975   return fold_deferring_overflow_warnings > 0;
976 }
977
978 /* This is called when we fold something based on the fact that signed
979    overflow is undefined.  */
980
981 static void
982 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
983 {
984   gcc_assert (!flag_wrapv && !flag_trapv);
985   if (fold_deferring_overflow_warnings > 0)
986     {
987       if (fold_deferred_overflow_warning == NULL
988           || wc < fold_deferred_overflow_code)
989         {
990           fold_deferred_overflow_warning = gmsgid;
991           fold_deferred_overflow_code = wc;
992         }
993     }
994   else if (issue_strict_overflow_warning (wc))
995     warning (OPT_Wstrict_overflow, gmsgid);
996 }
997 \f
998 /* Return true if the built-in mathematical function specified by CODE
999    is odd, i.e. -f(x) == f(-x).  */
1000
1001 static bool
1002 negate_mathfn_p (enum built_in_function code)
1003 {
1004   switch (code)
1005     {
1006     CASE_FLT_FN (BUILT_IN_ASIN):
1007     CASE_FLT_FN (BUILT_IN_ASINH):
1008     CASE_FLT_FN (BUILT_IN_ATAN):
1009     CASE_FLT_FN (BUILT_IN_ATANH):
1010     CASE_FLT_FN (BUILT_IN_CBRT):
1011     CASE_FLT_FN (BUILT_IN_SIN):
1012     CASE_FLT_FN (BUILT_IN_SINH):
1013     CASE_FLT_FN (BUILT_IN_TAN):
1014     CASE_FLT_FN (BUILT_IN_TANH):
1015       return true;
1016
1017     default:
1018       break;
1019     }
1020   return false;
1021 }
1022
1023 /* Check whether we may negate an integer constant T without causing
1024    overflow.  */
1025
1026 bool
1027 may_negate_without_overflow_p (tree t)
1028 {
1029   unsigned HOST_WIDE_INT val;
1030   unsigned int prec;
1031   tree type;
1032
1033   gcc_assert (TREE_CODE (t) == INTEGER_CST);
1034
1035   type = TREE_TYPE (t);
1036   if (TYPE_UNSIGNED (type))
1037     return false;
1038
1039   prec = TYPE_PRECISION (type);
1040   if (prec > HOST_BITS_PER_WIDE_INT)
1041     {
1042       if (TREE_INT_CST_LOW (t) != 0)
1043         return true;
1044       prec -= HOST_BITS_PER_WIDE_INT;
1045       val = TREE_INT_CST_HIGH (t);
1046     }
1047   else
1048     val = TREE_INT_CST_LOW (t);
1049   if (prec < HOST_BITS_PER_WIDE_INT)
1050     val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1051   return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
1052 }
1053
1054 /* Determine whether an expression T can be cheaply negated using
1055    the function negate_expr without introducing undefined overflow.  */
1056
1057 static bool
1058 negate_expr_p (tree t)
1059 {
1060   tree type;
1061
1062   if (t == 0)
1063     return false;
1064
1065   type = TREE_TYPE (t);
1066
1067   STRIP_SIGN_NOPS (t);
1068   switch (TREE_CODE (t))
1069     {
1070     case INTEGER_CST:
1071       if (TYPE_OVERFLOW_WRAPS (type))
1072         return true;
1073
1074       /* Check that -CST will not overflow type.  */
1075       return may_negate_without_overflow_p (t);
1076     case BIT_NOT_EXPR:
1077       return (INTEGRAL_TYPE_P (type)
1078               && TYPE_OVERFLOW_WRAPS (type));
1079
1080     case REAL_CST:
1081     case NEGATE_EXPR:
1082       return true;
1083
1084     case COMPLEX_CST:
1085       return negate_expr_p (TREE_REALPART (t))
1086              && negate_expr_p (TREE_IMAGPART (t));
1087
1088     case PLUS_EXPR:
1089       if (FLOAT_TYPE_P (type) && !flag_unsafe_math_optimizations)
1090         return false;
1091       /* -(A + B) -> (-B) - A.  */
1092       if (negate_expr_p (TREE_OPERAND (t, 1))
1093           && reorder_operands_p (TREE_OPERAND (t, 0),
1094                                  TREE_OPERAND (t, 1)))
1095         return true;
1096       /* -(A + B) -> (-A) - B.  */
1097       return negate_expr_p (TREE_OPERAND (t, 0));
1098
1099     case MINUS_EXPR:
1100       /* We can't turn -(A-B) into B-A when we honor signed zeros.  */
1101       return (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
1102              && reorder_operands_p (TREE_OPERAND (t, 0),
1103                                     TREE_OPERAND (t, 1));
1104
1105     case MULT_EXPR:
1106       if (TYPE_UNSIGNED (TREE_TYPE (t)))
1107         break;
1108
1109       /* Fall through.  */
1110
1111     case RDIV_EXPR:
1112       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
1113         return negate_expr_p (TREE_OPERAND (t, 1))
1114                || negate_expr_p (TREE_OPERAND (t, 0));
1115       break;
1116
1117     case TRUNC_DIV_EXPR:
1118     case ROUND_DIV_EXPR:
1119     case FLOOR_DIV_EXPR:
1120     case CEIL_DIV_EXPR:
1121     case EXACT_DIV_EXPR:
1122       /* In general we can't negate A / B, because if A is INT_MIN and
1123          B is 1, we may turn this into INT_MIN / -1 which is undefined
1124          and actually traps on some architectures.  But if overflow is
1125          undefined, we can negate, because - (INT_MIN / 1) is an
1126          overflow.  */
1127       if (INTEGRAL_TYPE_P (TREE_TYPE (t))
1128           && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
1129         break;
1130       return negate_expr_p (TREE_OPERAND (t, 1))
1131              || negate_expr_p (TREE_OPERAND (t, 0));
1132
1133     case NOP_EXPR:
1134       /* Negate -((double)float) as (double)(-float).  */
1135       if (TREE_CODE (type) == REAL_TYPE)
1136         {
1137           tree tem = strip_float_extensions (t);
1138           if (tem != t)
1139             return negate_expr_p (tem);
1140         }
1141       break;
1142
1143     case CALL_EXPR:
1144       /* Negate -f(x) as f(-x).  */
1145       if (negate_mathfn_p (builtin_mathfn_code (t)))
1146         return negate_expr_p (TREE_VALUE (TREE_OPERAND (t, 1)));
1147       break;
1148
1149     case RSHIFT_EXPR:
1150       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1151       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1152         {
1153           tree op1 = TREE_OPERAND (t, 1);
1154           if (TREE_INT_CST_HIGH (op1) == 0
1155               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1156                  == TREE_INT_CST_LOW (op1))
1157             return true;
1158         }
1159       break;
1160
1161     default:
1162       break;
1163     }
1164   return false;
1165 }
1166
1167 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
1168    simplification is possible.
1169    If negate_expr_p would return true for T, NULL_TREE will never be
1170    returned.  */
1171
1172 static tree
1173 fold_negate_expr (tree t)
1174 {
1175   tree type = TREE_TYPE (t);
1176   tree tem;
1177
1178   switch (TREE_CODE (t))
1179     {
1180     /* Convert - (~A) to A + 1.  */
1181     case BIT_NOT_EXPR:
1182       if (INTEGRAL_TYPE_P (type))
1183         return fold_build2 (PLUS_EXPR, type, TREE_OPERAND (t, 0),
1184                             build_int_cst (type, 1));
1185       break;
1186       
1187     case INTEGER_CST:
1188       tem = fold_negate_const (t, type);
1189       if (!TREE_OVERFLOW (tem)
1190           || !TYPE_OVERFLOW_TRAPS (type))
1191         return tem;
1192       break;
1193
1194     case REAL_CST:
1195       tem = fold_negate_const (t, type);
1196       /* Two's complement FP formats, such as c4x, may overflow.  */
1197       if (! TREE_OVERFLOW (tem) || ! flag_trapping_math)
1198         return tem;
1199       break;
1200
1201     case COMPLEX_CST:
1202       {
1203         tree rpart = negate_expr (TREE_REALPART (t));
1204         tree ipart = negate_expr (TREE_IMAGPART (t));
1205
1206         if ((TREE_CODE (rpart) == REAL_CST
1207              && TREE_CODE (ipart) == REAL_CST)
1208             || (TREE_CODE (rpart) == INTEGER_CST
1209                 && TREE_CODE (ipart) == INTEGER_CST))
1210           return build_complex (type, rpart, ipart);
1211       }
1212       break;
1213
1214     case NEGATE_EXPR:
1215       return TREE_OPERAND (t, 0);
1216
1217     case PLUS_EXPR:
1218       if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
1219         {
1220           /* -(A + B) -> (-B) - A.  */
1221           if (negate_expr_p (TREE_OPERAND (t, 1))
1222               && reorder_operands_p (TREE_OPERAND (t, 0),
1223                                      TREE_OPERAND (t, 1)))
1224             {
1225               tem = negate_expr (TREE_OPERAND (t, 1));
1226               return fold_build2 (MINUS_EXPR, type,
1227                                   tem, TREE_OPERAND (t, 0));
1228             }
1229
1230           /* -(A + B) -> (-A) - B.  */
1231           if (negate_expr_p (TREE_OPERAND (t, 0)))
1232             {
1233               tem = negate_expr (TREE_OPERAND (t, 0));
1234               return fold_build2 (MINUS_EXPR, type,
1235                                   tem, TREE_OPERAND (t, 1));
1236             }
1237         }
1238       break;
1239
1240     case MINUS_EXPR:
1241       /* - (A - B) -> B - A  */
1242       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
1243           && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
1244         return fold_build2 (MINUS_EXPR, type,
1245                             TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
1246       break;
1247
1248     case MULT_EXPR:
1249       if (TYPE_UNSIGNED (type))
1250         break;
1251
1252       /* Fall through.  */
1253
1254     case RDIV_EXPR:
1255       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
1256         {
1257           tem = TREE_OPERAND (t, 1);
1258           if (negate_expr_p (tem))
1259             return fold_build2 (TREE_CODE (t), type,
1260                                 TREE_OPERAND (t, 0), negate_expr (tem));
1261           tem = TREE_OPERAND (t, 0);
1262           if (negate_expr_p (tem))
1263             return fold_build2 (TREE_CODE (t), type,
1264                                 negate_expr (tem), TREE_OPERAND (t, 1));
1265         }
1266       break;
1267
1268     case TRUNC_DIV_EXPR:
1269     case ROUND_DIV_EXPR:
1270     case FLOOR_DIV_EXPR:
1271     case CEIL_DIV_EXPR:
1272     case EXACT_DIV_EXPR:
1273       /* In general we can't negate A / B, because if A is INT_MIN and
1274          B is 1, we may turn this into INT_MIN / -1 which is undefined
1275          and actually traps on some architectures.  But if overflow is
1276          undefined, we can negate, because - (INT_MIN / 1) is an
1277          overflow.  */
1278       if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
1279         {
1280           const char * const warnmsg = G_("assuming signed overflow does not "
1281                                           "occur when negating a division");
1282           tem = TREE_OPERAND (t, 1);
1283           if (negate_expr_p (tem))
1284             {
1285               if (INTEGRAL_TYPE_P (type)
1286                   && (TREE_CODE (tem) != INTEGER_CST
1287                       || integer_onep (tem)))
1288                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
1289               return fold_build2 (TREE_CODE (t), type,
1290                                   TREE_OPERAND (t, 0), negate_expr (tem));
1291             }
1292           tem = TREE_OPERAND (t, 0);
1293           if (negate_expr_p (tem))
1294             {
1295               if (INTEGRAL_TYPE_P (type)
1296                   && (TREE_CODE (tem) != INTEGER_CST
1297                       || tree_int_cst_equal (tem, TYPE_MIN_VALUE (type))))
1298                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
1299               return fold_build2 (TREE_CODE (t), type,
1300                                   negate_expr (tem), TREE_OPERAND (t, 1));
1301             }
1302         }
1303       break;
1304
1305     case NOP_EXPR:
1306       /* Convert -((double)float) into (double)(-float).  */
1307       if (TREE_CODE (type) == REAL_TYPE)
1308         {
1309           tem = strip_float_extensions (t);
1310           if (tem != t && negate_expr_p (tem))
1311             return negate_expr (tem);
1312         }
1313       break;
1314
1315     case CALL_EXPR:
1316       /* Negate -f(x) as f(-x).  */
1317       if (negate_mathfn_p (builtin_mathfn_code (t))
1318           && negate_expr_p (TREE_VALUE (TREE_OPERAND (t, 1))))
1319         {
1320           tree fndecl, arg, arglist;
1321
1322           fndecl = get_callee_fndecl (t);
1323           arg = negate_expr (TREE_VALUE (TREE_OPERAND (t, 1)));
1324           arglist = build_tree_list (NULL_TREE, arg);
1325           return build_function_call_expr (fndecl, arglist);
1326         }
1327       break;
1328
1329     case RSHIFT_EXPR:
1330       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1331       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1332         {
1333           tree op1 = TREE_OPERAND (t, 1);
1334           if (TREE_INT_CST_HIGH (op1) == 0
1335               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1336                  == TREE_INT_CST_LOW (op1))
1337             {
1338               tree ntype = TYPE_UNSIGNED (type)
1339                            ? lang_hooks.types.signed_type (type)
1340                            : lang_hooks.types.unsigned_type (type);
1341               tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
1342               temp = fold_build2 (RSHIFT_EXPR, ntype, temp, op1);
1343               return fold_convert (type, temp);
1344             }
1345         }
1346       break;
1347
1348     default:
1349       break;
1350     }
1351
1352   return NULL_TREE;
1353 }
1354
1355 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
1356    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
1357    return NULL_TREE. */
1358
1359 static tree
1360 negate_expr (tree t)
1361 {
1362   tree type, tem;
1363
1364   if (t == NULL_TREE)
1365     return NULL_TREE;
1366
1367   type = TREE_TYPE (t);
1368   STRIP_SIGN_NOPS (t);
1369
1370   tem = fold_negate_expr (t);
1371   if (!tem)
1372     tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
1373   return fold_convert (type, tem);
1374 }
1375 \f
1376 /* Split a tree IN into a constant, literal and variable parts that could be
1377    combined with CODE to make IN.  "constant" means an expression with
1378    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
1379    commutative arithmetic operation.  Store the constant part into *CONP,
1380    the literal in *LITP and return the variable part.  If a part isn't
1381    present, set it to null.  If the tree does not decompose in this way,
1382    return the entire tree as the variable part and the other parts as null.
1383
1384    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
1385    case, we negate an operand that was subtracted.  Except if it is a
1386    literal for which we use *MINUS_LITP instead.
1387
1388    If NEGATE_P is true, we are negating all of IN, again except a literal
1389    for which we use *MINUS_LITP instead.
1390
1391    If IN is itself a literal or constant, return it as appropriate.
1392
1393    Note that we do not guarantee that any of the three values will be the
1394    same type as IN, but they will have the same signedness and mode.  */
1395
1396 static tree
1397 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
1398             tree *minus_litp, int negate_p)
1399 {
1400   tree var = 0;
1401
1402   *conp = 0;
1403   *litp = 0;
1404   *minus_litp = 0;
1405
1406   /* Strip any conversions that don't change the machine mode or signedness.  */
1407   STRIP_SIGN_NOPS (in);
1408
1409   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
1410     *litp = in;
1411   else if (TREE_CODE (in) == code
1412            || (! FLOAT_TYPE_P (TREE_TYPE (in))
1413                /* We can associate addition and subtraction together (even
1414                   though the C standard doesn't say so) for integers because
1415                   the value is not affected.  For reals, the value might be
1416                   affected, so we can't.  */
1417                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1418                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1419     {
1420       tree op0 = TREE_OPERAND (in, 0);
1421       tree op1 = TREE_OPERAND (in, 1);
1422       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
1423       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
1424
1425       /* First see if either of the operands is a literal, then a constant.  */
1426       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST)
1427         *litp = op0, op0 = 0;
1428       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST)
1429         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
1430
1431       if (op0 != 0 && TREE_CONSTANT (op0))
1432         *conp = op0, op0 = 0;
1433       else if (op1 != 0 && TREE_CONSTANT (op1))
1434         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
1435
1436       /* If we haven't dealt with either operand, this is not a case we can
1437          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
1438       if (op0 != 0 && op1 != 0)
1439         var = in;
1440       else if (op0 != 0)
1441         var = op0;
1442       else
1443         var = op1, neg_var_p = neg1_p;
1444
1445       /* Now do any needed negations.  */
1446       if (neg_litp_p)
1447         *minus_litp = *litp, *litp = 0;
1448       if (neg_conp_p)
1449         *conp = negate_expr (*conp);
1450       if (neg_var_p)
1451         var = negate_expr (var);
1452     }
1453   else if (TREE_CONSTANT (in))
1454     *conp = in;
1455   else
1456     var = in;
1457
1458   if (negate_p)
1459     {
1460       if (*litp)
1461         *minus_litp = *litp, *litp = 0;
1462       else if (*minus_litp)
1463         *litp = *minus_litp, *minus_litp = 0;
1464       *conp = negate_expr (*conp);
1465       var = negate_expr (var);
1466     }
1467
1468   return var;
1469 }
1470
1471 /* Re-associate trees split by the above function.  T1 and T2 are either
1472    expressions to associate or null.  Return the new expression, if any.  If
1473    we build an operation, do it in TYPE and with CODE.  */
1474
1475 static tree
1476 associate_trees (tree t1, tree t2, enum tree_code code, tree type)
1477 {
1478   if (t1 == 0)
1479     return t2;
1480   else if (t2 == 0)
1481     return t1;
1482
1483   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1484      try to fold this since we will have infinite recursion.  But do
1485      deal with any NEGATE_EXPRs.  */
1486   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1487       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1488     {
1489       if (code == PLUS_EXPR)
1490         {
1491           if (TREE_CODE (t1) == NEGATE_EXPR)
1492             return build2 (MINUS_EXPR, type, fold_convert (type, t2),
1493                            fold_convert (type, TREE_OPERAND (t1, 0)));
1494           else if (TREE_CODE (t2) == NEGATE_EXPR)
1495             return build2 (MINUS_EXPR, type, fold_convert (type, t1),
1496                            fold_convert (type, TREE_OPERAND (t2, 0)));
1497           else if (integer_zerop (t2))
1498             return fold_convert (type, t1);
1499         }
1500       else if (code == MINUS_EXPR)
1501         {
1502           if (integer_zerop (t2))
1503             return fold_convert (type, t1);
1504         }
1505
1506       return build2 (code, type, fold_convert (type, t1),
1507                      fold_convert (type, t2));
1508     }
1509
1510   return fold_build2 (code, type, fold_convert (type, t1),
1511                       fold_convert (type, t2));
1512 }
1513 \f
1514 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1515    to produce a new constant.  Return NULL_TREE if we don't know how
1516    to evaluate CODE at compile-time.
1517
1518    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1519
1520 tree
1521 int_const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1522 {
1523   unsigned HOST_WIDE_INT int1l, int2l;
1524   HOST_WIDE_INT int1h, int2h;
1525   unsigned HOST_WIDE_INT low;
1526   HOST_WIDE_INT hi;
1527   unsigned HOST_WIDE_INT garbagel;
1528   HOST_WIDE_INT garbageh;
1529   tree t;
1530   tree type = TREE_TYPE (arg1);
1531   int uns = TYPE_UNSIGNED (type);
1532   int is_sizetype
1533     = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
1534   int overflow = 0;
1535
1536   int1l = TREE_INT_CST_LOW (arg1);
1537   int1h = TREE_INT_CST_HIGH (arg1);
1538   int2l = TREE_INT_CST_LOW (arg2);
1539   int2h = TREE_INT_CST_HIGH (arg2);
1540
1541   switch (code)
1542     {
1543     case BIT_IOR_EXPR:
1544       low = int1l | int2l, hi = int1h | int2h;
1545       break;
1546
1547     case BIT_XOR_EXPR:
1548       low = int1l ^ int2l, hi = int1h ^ int2h;
1549       break;
1550
1551     case BIT_AND_EXPR:
1552       low = int1l & int2l, hi = int1h & int2h;
1553       break;
1554
1555     case RSHIFT_EXPR:
1556       int2l = -int2l;
1557     case LSHIFT_EXPR:
1558       /* It's unclear from the C standard whether shifts can overflow.
1559          The following code ignores overflow; perhaps a C standard
1560          interpretation ruling is needed.  */
1561       lshift_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1562                      &low, &hi, !uns);
1563       break;
1564
1565     case RROTATE_EXPR:
1566       int2l = - int2l;
1567     case LROTATE_EXPR:
1568       lrotate_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1569                       &low, &hi);
1570       break;
1571
1572     case PLUS_EXPR:
1573       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1574       break;
1575
1576     case MINUS_EXPR:
1577       neg_double (int2l, int2h, &low, &hi);
1578       add_double (int1l, int1h, low, hi, &low, &hi);
1579       overflow = OVERFLOW_SUM_SIGN (hi, int2h, int1h);
1580       break;
1581
1582     case MULT_EXPR:
1583       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1584       break;
1585
1586     case TRUNC_DIV_EXPR:
1587     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1588     case EXACT_DIV_EXPR:
1589       /* This is a shortcut for a common special case.  */
1590       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1591           && ! TREE_CONSTANT_OVERFLOW (arg1)
1592           && ! TREE_CONSTANT_OVERFLOW (arg2)
1593           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1594         {
1595           if (code == CEIL_DIV_EXPR)
1596             int1l += int2l - 1;
1597
1598           low = int1l / int2l, hi = 0;
1599           break;
1600         }
1601
1602       /* ... fall through ...  */
1603
1604     case ROUND_DIV_EXPR:
1605       if (int2h == 0 && int2l == 0)
1606         return NULL_TREE;
1607       if (int2h == 0 && int2l == 1)
1608         {
1609           low = int1l, hi = int1h;
1610           break;
1611         }
1612       if (int1l == int2l && int1h == int2h
1613           && ! (int1l == 0 && int1h == 0))
1614         {
1615           low = 1, hi = 0;
1616           break;
1617         }
1618       overflow = div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1619                                        &low, &hi, &garbagel, &garbageh);
1620       break;
1621
1622     case TRUNC_MOD_EXPR:
1623     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1624       /* This is a shortcut for a common special case.  */
1625       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1626           && ! TREE_CONSTANT_OVERFLOW (arg1)
1627           && ! TREE_CONSTANT_OVERFLOW (arg2)
1628           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1629         {
1630           if (code == CEIL_MOD_EXPR)
1631             int1l += int2l - 1;
1632           low = int1l % int2l, hi = 0;
1633           break;
1634         }
1635
1636       /* ... fall through ...  */
1637
1638     case ROUND_MOD_EXPR:
1639       if (int2h == 0 && int2l == 0)
1640         return NULL_TREE;
1641       overflow = div_and_round_double (code, uns,
1642                                        int1l, int1h, int2l, int2h,
1643                                        &garbagel, &garbageh, &low, &hi);
1644       break;
1645
1646     case MIN_EXPR:
1647     case MAX_EXPR:
1648       if (uns)
1649         low = (((unsigned HOST_WIDE_INT) int1h
1650                 < (unsigned HOST_WIDE_INT) int2h)
1651                || (((unsigned HOST_WIDE_INT) int1h
1652                     == (unsigned HOST_WIDE_INT) int2h)
1653                    && int1l < int2l));
1654       else
1655         low = (int1h < int2h
1656                || (int1h == int2h && int1l < int2l));
1657
1658       if (low == (code == MIN_EXPR))
1659         low = int1l, hi = int1h;
1660       else
1661         low = int2l, hi = int2h;
1662       break;
1663
1664     default:
1665       return NULL_TREE;
1666     }
1667
1668   t = build_int_cst_wide (TREE_TYPE (arg1), low, hi);
1669
1670   if (notrunc)
1671     {
1672       /* Propagate overflow flags ourselves.  */
1673       if (((!uns || is_sizetype) && overflow)
1674           | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1675         {
1676           t = copy_node (t);
1677           TREE_OVERFLOW (t) = 1;
1678           TREE_CONSTANT_OVERFLOW (t) = 1;
1679         }
1680       else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
1681         {
1682           t = copy_node (t);
1683           TREE_CONSTANT_OVERFLOW (t) = 1;
1684         }
1685     }
1686   else
1687     t = force_fit_type (t, 1,
1688                         ((!uns || is_sizetype) && overflow)
1689                         | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2),
1690                         TREE_CONSTANT_OVERFLOW (arg1)
1691                         | TREE_CONSTANT_OVERFLOW (arg2));
1692
1693   return t;
1694 }
1695
1696 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1697    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1698    are the same kind of constant and the same machine mode.  Return zero if
1699    combining the constants is not allowed in the current operating mode.
1700
1701    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1702
1703 static tree
1704 const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1705 {
1706   /* Sanity check for the recursive cases.  */
1707   if (!arg1 || !arg2)
1708     return NULL_TREE;
1709
1710   STRIP_NOPS (arg1);
1711   STRIP_NOPS (arg2);
1712
1713   if (TREE_CODE (arg1) == INTEGER_CST)
1714     return int_const_binop (code, arg1, arg2, notrunc);
1715
1716   if (TREE_CODE (arg1) == REAL_CST)
1717     {
1718       enum machine_mode mode;
1719       REAL_VALUE_TYPE d1;
1720       REAL_VALUE_TYPE d2;
1721       REAL_VALUE_TYPE value;
1722       REAL_VALUE_TYPE result;
1723       bool inexact;
1724       tree t, type;
1725
1726       /* The following codes are handled by real_arithmetic.  */
1727       switch (code)
1728         {
1729         case PLUS_EXPR:
1730         case MINUS_EXPR:
1731         case MULT_EXPR:
1732         case RDIV_EXPR:
1733         case MIN_EXPR:
1734         case MAX_EXPR:
1735           break;
1736
1737         default:
1738           return NULL_TREE;
1739         }
1740
1741       d1 = TREE_REAL_CST (arg1);
1742       d2 = TREE_REAL_CST (arg2);
1743
1744       type = TREE_TYPE (arg1);
1745       mode = TYPE_MODE (type);
1746
1747       /* Don't perform operation if we honor signaling NaNs and
1748          either operand is a NaN.  */
1749       if (HONOR_SNANS (mode)
1750           && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1751         return NULL_TREE;
1752
1753       /* Don't perform operation if it would raise a division
1754          by zero exception.  */
1755       if (code == RDIV_EXPR
1756           && REAL_VALUES_EQUAL (d2, dconst0)
1757           && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1758         return NULL_TREE;
1759
1760       /* If either operand is a NaN, just return it.  Otherwise, set up
1761          for floating-point trap; we return an overflow.  */
1762       if (REAL_VALUE_ISNAN (d1))
1763         return arg1;
1764       else if (REAL_VALUE_ISNAN (d2))
1765         return arg2;
1766
1767       inexact = real_arithmetic (&value, code, &d1, &d2);
1768       real_convert (&result, mode, &value);
1769
1770       /* Don't constant fold this floating point operation if
1771          the result has overflowed and flag_trapping_math.  */
1772       if (flag_trapping_math
1773           && MODE_HAS_INFINITIES (mode)
1774           && REAL_VALUE_ISINF (result)
1775           && !REAL_VALUE_ISINF (d1)
1776           && !REAL_VALUE_ISINF (d2))
1777         return NULL_TREE;
1778
1779       /* Don't constant fold this floating point operation if the
1780          result may dependent upon the run-time rounding mode and
1781          flag_rounding_math is set, or if GCC's software emulation
1782          is unable to accurately represent the result.  */
1783       if ((flag_rounding_math
1784            || (REAL_MODE_FORMAT_COMPOSITE_P (mode)
1785                && !flag_unsafe_math_optimizations))
1786           && (inexact || !real_identical (&result, &value)))
1787         return NULL_TREE;
1788
1789       t = build_real (type, result);
1790
1791       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1792       TREE_CONSTANT_OVERFLOW (t)
1793         = TREE_OVERFLOW (t)
1794           | TREE_CONSTANT_OVERFLOW (arg1)
1795           | TREE_CONSTANT_OVERFLOW (arg2);
1796       return t;
1797     }
1798
1799   if (TREE_CODE (arg1) == COMPLEX_CST)
1800     {
1801       tree type = TREE_TYPE (arg1);
1802       tree r1 = TREE_REALPART (arg1);
1803       tree i1 = TREE_IMAGPART (arg1);
1804       tree r2 = TREE_REALPART (arg2);
1805       tree i2 = TREE_IMAGPART (arg2);
1806       tree real, imag;
1807
1808       switch (code)
1809         {
1810         case PLUS_EXPR:
1811         case MINUS_EXPR:
1812           real = const_binop (code, r1, r2, notrunc);
1813           imag = const_binop (code, i1, i2, notrunc);
1814           break;
1815
1816         case MULT_EXPR:
1817           real = const_binop (MINUS_EXPR,
1818                               const_binop (MULT_EXPR, r1, r2, notrunc),
1819                               const_binop (MULT_EXPR, i1, i2, notrunc),
1820                               notrunc);
1821           imag = const_binop (PLUS_EXPR,
1822                               const_binop (MULT_EXPR, r1, i2, notrunc),
1823                               const_binop (MULT_EXPR, i1, r2, notrunc),
1824                               notrunc);
1825           break;
1826
1827         case RDIV_EXPR:
1828           {
1829             tree magsquared
1830               = const_binop (PLUS_EXPR,
1831                              const_binop (MULT_EXPR, r2, r2, notrunc),
1832                              const_binop (MULT_EXPR, i2, i2, notrunc),
1833                              notrunc);
1834             tree t1
1835               = const_binop (PLUS_EXPR,
1836                              const_binop (MULT_EXPR, r1, r2, notrunc),
1837                              const_binop (MULT_EXPR, i1, i2, notrunc),
1838                              notrunc);
1839             tree t2
1840               = const_binop (MINUS_EXPR,
1841                              const_binop (MULT_EXPR, i1, r2, notrunc),
1842                              const_binop (MULT_EXPR, r1, i2, notrunc),
1843                              notrunc);
1844
1845             if (INTEGRAL_TYPE_P (TREE_TYPE (r1)))
1846               code = TRUNC_DIV_EXPR;
1847
1848             real = const_binop (code, t1, magsquared, notrunc);
1849             imag = const_binop (code, t2, magsquared, notrunc);
1850           }
1851           break;
1852
1853         default:
1854           return NULL_TREE;
1855         }
1856
1857       if (real && imag)
1858         return build_complex (type, real, imag);
1859     }
1860
1861   return NULL_TREE;
1862 }
1863
1864 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
1865    indicates which particular sizetype to create.  */
1866
1867 tree
1868 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
1869 {
1870   return build_int_cst (sizetype_tab[(int) kind], number);
1871 }
1872 \f
1873 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
1874    is a tree code.  The type of the result is taken from the operands.
1875    Both must be the same type integer type and it must be a size type.
1876    If the operands are constant, so is the result.  */
1877
1878 tree
1879 size_binop (enum tree_code code, tree arg0, tree arg1)
1880 {
1881   tree type = TREE_TYPE (arg0);
1882
1883   if (arg0 == error_mark_node || arg1 == error_mark_node)
1884     return error_mark_node;
1885
1886   gcc_assert (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type)
1887               && type == TREE_TYPE (arg1));
1888
1889   /* Handle the special case of two integer constants faster.  */
1890   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
1891     {
1892       /* And some specific cases even faster than that.  */
1893       if (code == PLUS_EXPR && integer_zerop (arg0))
1894         return arg1;
1895       else if ((code == MINUS_EXPR || code == PLUS_EXPR)
1896                && integer_zerop (arg1))
1897         return arg0;
1898       else if (code == MULT_EXPR && integer_onep (arg0))
1899         return arg1;
1900
1901       /* Handle general case of two integer constants.  */
1902       return int_const_binop (code, arg0, arg1, 0);
1903     }
1904
1905   return fold_build2 (code, type, arg0, arg1);
1906 }
1907
1908 /* Given two values, either both of sizetype or both of bitsizetype,
1909    compute the difference between the two values.  Return the value
1910    in signed type corresponding to the type of the operands.  */
1911
1912 tree
1913 size_diffop (tree arg0, tree arg1)
1914 {
1915   tree type = TREE_TYPE (arg0);
1916   tree ctype;
1917
1918   gcc_assert (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type)
1919               && type == TREE_TYPE (arg1));
1920
1921   /* If the type is already signed, just do the simple thing.  */
1922   if (!TYPE_UNSIGNED (type))
1923     return size_binop (MINUS_EXPR, arg0, arg1);
1924
1925   ctype = type == bitsizetype ? sbitsizetype : ssizetype;
1926
1927   /* If either operand is not a constant, do the conversions to the signed
1928      type and subtract.  The hardware will do the right thing with any
1929      overflow in the subtraction.  */
1930   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
1931     return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
1932                        fold_convert (ctype, arg1));
1933
1934   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
1935      Otherwise, subtract the other way, convert to CTYPE (we know that can't
1936      overflow) and negate (which can't either).  Special-case a result
1937      of zero while we're here.  */
1938   if (tree_int_cst_equal (arg0, arg1))
1939     return build_int_cst (ctype, 0);
1940   else if (tree_int_cst_lt (arg1, arg0))
1941     return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
1942   else
1943     return size_binop (MINUS_EXPR, build_int_cst (ctype, 0),
1944                        fold_convert (ctype, size_binop (MINUS_EXPR,
1945                                                         arg1, arg0)));
1946 }
1947 \f
1948 /* A subroutine of fold_convert_const handling conversions of an
1949    INTEGER_CST to another integer type.  */
1950
1951 static tree
1952 fold_convert_const_int_from_int (tree type, tree arg1)
1953 {
1954   tree t;
1955
1956   /* Given an integer constant, make new constant with new type,
1957      appropriately sign-extended or truncated.  */
1958   t = build_int_cst_wide (type, TREE_INT_CST_LOW (arg1),
1959                           TREE_INT_CST_HIGH (arg1));
1960
1961   t = force_fit_type (t,
1962                       /* Don't set the overflow when
1963                          converting a pointer  */
1964                       !POINTER_TYPE_P (TREE_TYPE (arg1)),
1965                       (TREE_INT_CST_HIGH (arg1) < 0
1966                        && (TYPE_UNSIGNED (type)
1967                            < TYPE_UNSIGNED (TREE_TYPE (arg1))))
1968                       | TREE_OVERFLOW (arg1),
1969                       TREE_CONSTANT_OVERFLOW (arg1));
1970
1971   return t;
1972 }
1973
1974 /* A subroutine of fold_convert_const handling conversions a REAL_CST
1975    to an integer type.  */
1976
1977 static tree
1978 fold_convert_const_int_from_real (enum tree_code code, tree type, tree arg1)
1979 {
1980   int overflow = 0;
1981   tree t;
1982
1983   /* The following code implements the floating point to integer
1984      conversion rules required by the Java Language Specification,
1985      that IEEE NaNs are mapped to zero and values that overflow
1986      the target precision saturate, i.e. values greater than
1987      INT_MAX are mapped to INT_MAX, and values less than INT_MIN
1988      are mapped to INT_MIN.  These semantics are allowed by the
1989      C and C++ standards that simply state that the behavior of
1990      FP-to-integer conversion is unspecified upon overflow.  */
1991
1992   HOST_WIDE_INT high, low;
1993   REAL_VALUE_TYPE r;
1994   REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
1995
1996   switch (code)
1997     {
1998     case FIX_TRUNC_EXPR:
1999       real_trunc (&r, VOIDmode, &x);
2000       break;
2001
2002     case FIX_CEIL_EXPR:
2003       real_ceil (&r, VOIDmode, &x);
2004       break;
2005
2006     case FIX_FLOOR_EXPR:
2007       real_floor (&r, VOIDmode, &x);
2008       break;
2009
2010     case FIX_ROUND_EXPR:
2011       real_round (&r, VOIDmode, &x);
2012       break;
2013
2014     default:
2015       gcc_unreachable ();
2016     }
2017
2018   /* If R is NaN, return zero and show we have an overflow.  */
2019   if (REAL_VALUE_ISNAN (r))
2020     {
2021       overflow = 1;
2022       high = 0;
2023       low = 0;
2024     }
2025
2026   /* See if R is less than the lower bound or greater than the
2027      upper bound.  */
2028
2029   if (! overflow)
2030     {
2031       tree lt = TYPE_MIN_VALUE (type);
2032       REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
2033       if (REAL_VALUES_LESS (r, l))
2034         {
2035           overflow = 1;
2036           high = TREE_INT_CST_HIGH (lt);
2037           low = TREE_INT_CST_LOW (lt);
2038         }
2039     }
2040
2041   if (! overflow)
2042     {
2043       tree ut = TYPE_MAX_VALUE (type);
2044       if (ut)
2045         {
2046           REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
2047           if (REAL_VALUES_LESS (u, r))
2048             {
2049               overflow = 1;
2050               high = TREE_INT_CST_HIGH (ut);
2051               low = TREE_INT_CST_LOW (ut);
2052             }
2053         }
2054     }
2055
2056   if (! overflow)
2057     REAL_VALUE_TO_INT (&low, &high, r);
2058
2059   t = build_int_cst_wide (type, low, high);
2060
2061   t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg1),
2062                       TREE_CONSTANT_OVERFLOW (arg1));
2063   return t;
2064 }
2065
2066 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2067    to another floating point type.  */
2068
2069 static tree
2070 fold_convert_const_real_from_real (tree type, tree arg1)
2071 {
2072   REAL_VALUE_TYPE value;
2073   tree t;
2074
2075   real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
2076   t = build_real (type, value);
2077
2078   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2079   TREE_CONSTANT_OVERFLOW (t)
2080     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2081   return t;
2082 }
2083
2084 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2085    type TYPE.  If no simplification can be done return NULL_TREE.  */
2086
2087 static tree
2088 fold_convert_const (enum tree_code code, tree type, tree arg1)
2089 {
2090   if (TREE_TYPE (arg1) == type)
2091     return arg1;
2092
2093   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
2094     {
2095       if (TREE_CODE (arg1) == INTEGER_CST)
2096         return fold_convert_const_int_from_int (type, arg1);
2097       else if (TREE_CODE (arg1) == REAL_CST)
2098         return fold_convert_const_int_from_real (code, type, arg1);
2099     }
2100   else if (TREE_CODE (type) == REAL_TYPE)
2101     {
2102       if (TREE_CODE (arg1) == INTEGER_CST)
2103         return build_real_from_int_cst (type, arg1);
2104       if (TREE_CODE (arg1) == REAL_CST)
2105         return fold_convert_const_real_from_real (type, arg1);
2106     }
2107   return NULL_TREE;
2108 }
2109
2110 /* Construct a vector of zero elements of vector type TYPE.  */
2111
2112 static tree
2113 build_zero_vector (tree type)
2114 {
2115   tree elem, list;
2116   int i, units;
2117
2118   elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2119   units = TYPE_VECTOR_SUBPARTS (type);
2120   
2121   list = NULL_TREE;
2122   for (i = 0; i < units; i++)
2123     list = tree_cons (NULL_TREE, elem, list);
2124   return build_vector (type, list);
2125 }
2126
2127 /* Convert expression ARG to type TYPE.  Used by the middle-end for
2128    simple conversions in preference to calling the front-end's convert.  */
2129
2130 tree
2131 fold_convert (tree type, tree arg)
2132 {
2133   tree orig = TREE_TYPE (arg);
2134   tree tem;
2135
2136   if (type == orig)
2137     return arg;
2138
2139   if (TREE_CODE (arg) == ERROR_MARK
2140       || TREE_CODE (type) == ERROR_MARK
2141       || TREE_CODE (orig) == ERROR_MARK)
2142     return error_mark_node;
2143
2144   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig)
2145       || lang_hooks.types_compatible_p (TYPE_MAIN_VARIANT (type),
2146                                         TYPE_MAIN_VARIANT (orig)))
2147     return fold_build1 (NOP_EXPR, type, arg);
2148
2149   switch (TREE_CODE (type))
2150     {
2151     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2152     case POINTER_TYPE: case REFERENCE_TYPE:
2153     case OFFSET_TYPE:
2154       if (TREE_CODE (arg) == INTEGER_CST)
2155         {
2156           tem = fold_convert_const (NOP_EXPR, type, arg);
2157           if (tem != NULL_TREE)
2158             return tem;
2159         }
2160       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2161           || TREE_CODE (orig) == OFFSET_TYPE)
2162         return fold_build1 (NOP_EXPR, type, arg);
2163       if (TREE_CODE (orig) == COMPLEX_TYPE)
2164         {
2165           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2166           return fold_convert (type, tem);
2167         }
2168       gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
2169                   && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2170       return fold_build1 (NOP_EXPR, type, arg);
2171
2172     case REAL_TYPE:
2173       if (TREE_CODE (arg) == INTEGER_CST)
2174         {
2175           tem = fold_convert_const (FLOAT_EXPR, type, arg);
2176           if (tem != NULL_TREE)
2177             return tem;
2178         }
2179       else if (TREE_CODE (arg) == REAL_CST)
2180         {
2181           tem = fold_convert_const (NOP_EXPR, type, arg);
2182           if (tem != NULL_TREE)
2183             return tem;
2184         }
2185
2186       switch (TREE_CODE (orig))
2187         {
2188         case INTEGER_TYPE:
2189         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2190         case POINTER_TYPE: case REFERENCE_TYPE:
2191           return fold_build1 (FLOAT_EXPR, type, arg);
2192
2193         case REAL_TYPE:
2194           return fold_build1 (NOP_EXPR, type, arg);
2195
2196         case COMPLEX_TYPE:
2197           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2198           return fold_convert (type, tem);
2199
2200         default:
2201           gcc_unreachable ();
2202         }
2203
2204     case COMPLEX_TYPE:
2205       switch (TREE_CODE (orig))
2206         {
2207         case INTEGER_TYPE:
2208         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2209         case POINTER_TYPE: case REFERENCE_TYPE:
2210         case REAL_TYPE:
2211           return build2 (COMPLEX_EXPR, type,
2212                          fold_convert (TREE_TYPE (type), arg),
2213                          fold_convert (TREE_TYPE (type), integer_zero_node));
2214         case COMPLEX_TYPE:
2215           {
2216             tree rpart, ipart;
2217
2218             if (TREE_CODE (arg) == COMPLEX_EXPR)
2219               {
2220                 rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
2221                 ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
2222                 return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2223               }
2224
2225             arg = save_expr (arg);
2226             rpart = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2227             ipart = fold_build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg);
2228             rpart = fold_convert (TREE_TYPE (type), rpart);
2229             ipart = fold_convert (TREE_TYPE (type), ipart);
2230             return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2231           }
2232
2233         default:
2234           gcc_unreachable ();
2235         }
2236
2237     case VECTOR_TYPE:
2238       if (integer_zerop (arg))
2239         return build_zero_vector (type);
2240       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2241       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2242                   || TREE_CODE (orig) == VECTOR_TYPE);
2243       return fold_build1 (VIEW_CONVERT_EXPR, type, arg);
2244
2245     case VOID_TYPE:
2246       return fold_build1 (NOP_EXPR, type, fold_ignored_result (arg));
2247
2248     default:
2249       gcc_unreachable ();
2250     }
2251 }
2252 \f
2253 /* Return false if expr can be assumed not to be an lvalue, true
2254    otherwise.  */
2255
2256 static bool
2257 maybe_lvalue_p (tree x)
2258 {
2259   /* We only need to wrap lvalue tree codes.  */
2260   switch (TREE_CODE (x))
2261   {
2262   case VAR_DECL:
2263   case PARM_DECL:
2264   case RESULT_DECL:
2265   case LABEL_DECL:
2266   case FUNCTION_DECL:
2267   case SSA_NAME:
2268
2269   case COMPONENT_REF:
2270   case INDIRECT_REF:
2271   case ALIGN_INDIRECT_REF:
2272   case MISALIGNED_INDIRECT_REF:
2273   case ARRAY_REF:
2274   case ARRAY_RANGE_REF:
2275   case BIT_FIELD_REF:
2276   case OBJ_TYPE_REF:
2277
2278   case REALPART_EXPR:
2279   case IMAGPART_EXPR:
2280   case PREINCREMENT_EXPR:
2281   case PREDECREMENT_EXPR:
2282   case SAVE_EXPR:
2283   case TRY_CATCH_EXPR:
2284   case WITH_CLEANUP_EXPR:
2285   case COMPOUND_EXPR:
2286   case MODIFY_EXPR:
2287   case TARGET_EXPR:
2288   case COND_EXPR:
2289   case BIND_EXPR:
2290   case MIN_EXPR:
2291   case MAX_EXPR:
2292     break;
2293
2294   default:
2295     /* Assume the worst for front-end tree codes.  */
2296     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2297       break;
2298     return false;
2299   }
2300
2301   return true;
2302 }
2303
2304 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2305
2306 tree
2307 non_lvalue (tree x)
2308 {
2309   /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2310      us.  */
2311   if (in_gimple_form)
2312     return x;
2313
2314   if (! maybe_lvalue_p (x))
2315     return x;
2316   return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2317 }
2318
2319 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2320    Zero means allow extended lvalues.  */
2321
2322 int pedantic_lvalues;
2323
2324 /* When pedantic, return an expr equal to X but certainly not valid as a
2325    pedantic lvalue.  Otherwise, return X.  */
2326
2327 static tree
2328 pedantic_non_lvalue (tree x)
2329 {
2330   if (pedantic_lvalues)
2331     return non_lvalue (x);
2332   else
2333     return x;
2334 }
2335 \f
2336 /* Given a tree comparison code, return the code that is the logical inverse
2337    of the given code.  It is not safe to do this for floating-point
2338    comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2339    as well: if reversing the comparison is unsafe, return ERROR_MARK.  */
2340
2341 enum tree_code
2342 invert_tree_comparison (enum tree_code code, bool honor_nans)
2343 {
2344   if (honor_nans && flag_trapping_math)
2345     return ERROR_MARK;
2346
2347   switch (code)
2348     {
2349     case EQ_EXPR:
2350       return NE_EXPR;
2351     case NE_EXPR:
2352       return EQ_EXPR;
2353     case GT_EXPR:
2354       return honor_nans ? UNLE_EXPR : LE_EXPR;
2355     case GE_EXPR:
2356       return honor_nans ? UNLT_EXPR : LT_EXPR;
2357     case LT_EXPR:
2358       return honor_nans ? UNGE_EXPR : GE_EXPR;
2359     case LE_EXPR:
2360       return honor_nans ? UNGT_EXPR : GT_EXPR;
2361     case LTGT_EXPR:
2362       return UNEQ_EXPR;
2363     case UNEQ_EXPR:
2364       return LTGT_EXPR;
2365     case UNGT_EXPR:
2366       return LE_EXPR;
2367     case UNGE_EXPR:
2368       return LT_EXPR;
2369     case UNLT_EXPR:
2370       return GE_EXPR;
2371     case UNLE_EXPR:
2372       return GT_EXPR;
2373     case ORDERED_EXPR:
2374       return UNORDERED_EXPR;
2375     case UNORDERED_EXPR:
2376       return ORDERED_EXPR;
2377     default:
2378       gcc_unreachable ();
2379     }
2380 }
2381
2382 /* Similar, but return the comparison that results if the operands are
2383    swapped.  This is safe for floating-point.  */
2384
2385 enum tree_code
2386 swap_tree_comparison (enum tree_code code)
2387 {
2388   switch (code)
2389     {
2390     case EQ_EXPR:
2391     case NE_EXPR:
2392     case ORDERED_EXPR:
2393     case UNORDERED_EXPR:
2394     case LTGT_EXPR:
2395     case UNEQ_EXPR:
2396       return code;
2397     case GT_EXPR:
2398       return LT_EXPR;
2399     case GE_EXPR:
2400       return LE_EXPR;
2401     case LT_EXPR:
2402       return GT_EXPR;
2403     case LE_EXPR:
2404       return GE_EXPR;
2405     case UNGT_EXPR:
2406       return UNLT_EXPR;
2407     case UNGE_EXPR:
2408       return UNLE_EXPR;
2409     case UNLT_EXPR:
2410       return UNGT_EXPR;
2411     case UNLE_EXPR:
2412       return UNGE_EXPR;
2413     default:
2414       gcc_unreachable ();
2415     }
2416 }
2417
2418
2419 /* Convert a comparison tree code from an enum tree_code representation
2420    into a compcode bit-based encoding.  This function is the inverse of
2421    compcode_to_comparison.  */
2422
2423 static enum comparison_code
2424 comparison_to_compcode (enum tree_code code)
2425 {
2426   switch (code)
2427     {
2428     case LT_EXPR:
2429       return COMPCODE_LT;
2430     case EQ_EXPR:
2431       return COMPCODE_EQ;
2432     case LE_EXPR:
2433       return COMPCODE_LE;
2434     case GT_EXPR:
2435       return COMPCODE_GT;
2436     case NE_EXPR:
2437       return COMPCODE_NE;
2438     case GE_EXPR:
2439       return COMPCODE_GE;
2440     case ORDERED_EXPR:
2441       return COMPCODE_ORD;
2442     case UNORDERED_EXPR:
2443       return COMPCODE_UNORD;
2444     case UNLT_EXPR:
2445       return COMPCODE_UNLT;
2446     case UNEQ_EXPR:
2447       return COMPCODE_UNEQ;
2448     case UNLE_EXPR:
2449       return COMPCODE_UNLE;
2450     case UNGT_EXPR:
2451       return COMPCODE_UNGT;
2452     case LTGT_EXPR:
2453       return COMPCODE_LTGT;
2454     case UNGE_EXPR:
2455       return COMPCODE_UNGE;
2456     default:
2457       gcc_unreachable ();
2458     }
2459 }
2460
2461 /* Convert a compcode bit-based encoding of a comparison operator back
2462    to GCC's enum tree_code representation.  This function is the
2463    inverse of comparison_to_compcode.  */
2464
2465 static enum tree_code
2466 compcode_to_comparison (enum comparison_code code)
2467 {
2468   switch (code)
2469     {
2470     case COMPCODE_LT:
2471       return LT_EXPR;
2472     case COMPCODE_EQ:
2473       return EQ_EXPR;
2474     case COMPCODE_LE:
2475       return LE_EXPR;
2476     case COMPCODE_GT:
2477       return GT_EXPR;
2478     case COMPCODE_NE:
2479       return NE_EXPR;
2480     case COMPCODE_GE:
2481       return GE_EXPR;
2482     case COMPCODE_ORD:
2483       return ORDERED_EXPR;
2484     case COMPCODE_UNORD:
2485       return UNORDERED_EXPR;
2486     case COMPCODE_UNLT:
2487       return UNLT_EXPR;
2488     case COMPCODE_UNEQ:
2489       return UNEQ_EXPR;
2490     case COMPCODE_UNLE:
2491       return UNLE_EXPR;
2492     case COMPCODE_UNGT:
2493       return UNGT_EXPR;
2494     case COMPCODE_LTGT:
2495       return LTGT_EXPR;
2496     case COMPCODE_UNGE:
2497       return UNGE_EXPR;
2498     default:
2499       gcc_unreachable ();
2500     }
2501 }
2502
2503 /* Return a tree for the comparison which is the combination of
2504    doing the AND or OR (depending on CODE) of the two operations LCODE
2505    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2506    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2507    if this makes the transformation invalid.  */
2508
2509 tree
2510 combine_comparisons (enum tree_code code, enum tree_code lcode,
2511                      enum tree_code rcode, tree truth_type,
2512                      tree ll_arg, tree lr_arg)
2513 {
2514   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2515   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2516   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2517   enum comparison_code compcode;
2518
2519   switch (code)
2520     {
2521     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2522       compcode = lcompcode & rcompcode;
2523       break;
2524
2525     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2526       compcode = lcompcode | rcompcode;
2527       break;
2528
2529     default:
2530       return NULL_TREE;
2531     }
2532
2533   if (!honor_nans)
2534     {
2535       /* Eliminate unordered comparisons, as well as LTGT and ORD
2536          which are not used unless the mode has NaNs.  */
2537       compcode &= ~COMPCODE_UNORD;
2538       if (compcode == COMPCODE_LTGT)
2539         compcode = COMPCODE_NE;
2540       else if (compcode == COMPCODE_ORD)
2541         compcode = COMPCODE_TRUE;
2542     }
2543    else if (flag_trapping_math)
2544      {
2545         /* Check that the original operation and the optimized ones will trap
2546            under the same condition.  */
2547         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2548                      && (lcompcode != COMPCODE_EQ)
2549                      && (lcompcode != COMPCODE_ORD);
2550         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2551                      && (rcompcode != COMPCODE_EQ)
2552                      && (rcompcode != COMPCODE_ORD);
2553         bool trap = (compcode & COMPCODE_UNORD) == 0
2554                     && (compcode != COMPCODE_EQ)
2555                     && (compcode != COMPCODE_ORD);
2556
2557         /* In a short-circuited boolean expression the LHS might be
2558            such that the RHS, if evaluated, will never trap.  For
2559            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2560            if neither x nor y is NaN.  (This is a mixed blessing: for
2561            example, the expression above will never trap, hence
2562            optimizing it to x < y would be invalid).  */
2563         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2564             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2565           rtrap = false;
2566
2567         /* If the comparison was short-circuited, and only the RHS
2568            trapped, we may now generate a spurious trap.  */
2569         if (rtrap && !ltrap
2570             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2571           return NULL_TREE;
2572
2573         /* If we changed the conditions that cause a trap, we lose.  */
2574         if ((ltrap || rtrap) != trap)
2575           return NULL_TREE;
2576       }
2577
2578   if (compcode == COMPCODE_TRUE)
2579     return constant_boolean_node (true, truth_type);
2580   else if (compcode == COMPCODE_FALSE)
2581     return constant_boolean_node (false, truth_type);
2582   else
2583     return fold_build2 (compcode_to_comparison (compcode),
2584                         truth_type, ll_arg, lr_arg);
2585 }
2586
2587 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2588
2589 static int
2590 truth_value_p (enum tree_code code)
2591 {
2592   return (TREE_CODE_CLASS (code) == tcc_comparison
2593           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2594           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2595           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2596 }
2597 \f
2598 /* Return nonzero if two operands (typically of the same tree node)
2599    are necessarily equal.  If either argument has side-effects this
2600    function returns zero.  FLAGS modifies behavior as follows:
2601
2602    If OEP_ONLY_CONST is set, only return nonzero for constants.
2603    This function tests whether the operands are indistinguishable;
2604    it does not test whether they are equal using C's == operation.
2605    The distinction is important for IEEE floating point, because
2606    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
2607    (2) two NaNs may be indistinguishable, but NaN!=NaN.
2608
2609    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
2610    even though it may hold multiple values during a function.
2611    This is because a GCC tree node guarantees that nothing else is
2612    executed between the evaluation of its "operands" (which may often
2613    be evaluated in arbitrary order).  Hence if the operands themselves
2614    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
2615    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
2616    unset means assuming isochronic (or instantaneous) tree equivalence.
2617    Unless comparing arbitrary expression trees, such as from different
2618    statements, this flag can usually be left unset.
2619
2620    If OEP_PURE_SAME is set, then pure functions with identical arguments
2621    are considered the same.  It is used when the caller has other ways
2622    to ensure that global memory is unchanged in between.  */
2623
2624 int
2625 operand_equal_p (tree arg0, tree arg1, unsigned int flags)
2626 {
2627   /* If either is ERROR_MARK, they aren't equal.  */
2628   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
2629     return 0;
2630
2631   /* If both types don't have the same signedness, then we can't consider
2632      them equal.  We must check this before the STRIP_NOPS calls
2633      because they may change the signedness of the arguments.  */
2634   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2635     return 0;
2636
2637   /* If both types don't have the same precision, then it is not safe
2638      to strip NOPs.  */
2639   if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
2640     return 0;
2641
2642   STRIP_NOPS (arg0);
2643   STRIP_NOPS (arg1);
2644
2645   /* In case both args are comparisons but with different comparison
2646      code, try to swap the comparison operands of one arg to produce
2647      a match and compare that variant.  */
2648   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2649       && COMPARISON_CLASS_P (arg0)
2650       && COMPARISON_CLASS_P (arg1))
2651     {
2652       enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
2653
2654       if (TREE_CODE (arg0) == swap_code)
2655         return operand_equal_p (TREE_OPERAND (arg0, 0),
2656                                 TREE_OPERAND (arg1, 1), flags)
2657                && operand_equal_p (TREE_OPERAND (arg0, 1),
2658                                    TREE_OPERAND (arg1, 0), flags);
2659     }
2660
2661   if (TREE_CODE (arg0) != TREE_CODE (arg1)
2662       /* This is needed for conversions and for COMPONENT_REF.
2663          Might as well play it safe and always test this.  */
2664       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
2665       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
2666       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
2667     return 0;
2668
2669   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
2670      We don't care about side effects in that case because the SAVE_EXPR
2671      takes care of that for us. In all other cases, two expressions are
2672      equal if they have no side effects.  If we have two identical
2673      expressions with side effects that should be treated the same due
2674      to the only side effects being identical SAVE_EXPR's, that will
2675      be detected in the recursive calls below.  */
2676   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
2677       && (TREE_CODE (arg0) == SAVE_EXPR
2678           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
2679     return 1;
2680
2681   /* Next handle constant cases, those for which we can return 1 even
2682      if ONLY_CONST is set.  */
2683   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
2684     switch (TREE_CODE (arg0))
2685       {
2686       case INTEGER_CST:
2687         return (! TREE_CONSTANT_OVERFLOW (arg0)
2688                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2689                 && tree_int_cst_equal (arg0, arg1));
2690
2691       case REAL_CST:
2692         return (! TREE_CONSTANT_OVERFLOW (arg0)
2693                 && ! TREE_CONSTANT_OVERFLOW (arg1)
2694                 && REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
2695                                           TREE_REAL_CST (arg1)));
2696
2697       case VECTOR_CST:
2698         {
2699           tree v1, v2;
2700
2701           if (TREE_CONSTANT_OVERFLOW (arg0)
2702               || TREE_CONSTANT_OVERFLOW (arg1))
2703             return 0;
2704
2705           v1 = TREE_VECTOR_CST_ELTS (arg0);
2706           v2 = TREE_VECTOR_CST_ELTS (arg1);
2707           while (v1 && v2)
2708             {
2709               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
2710                                     flags))
2711                 return 0;
2712               v1 = TREE_CHAIN (v1);
2713               v2 = TREE_CHAIN (v2);
2714             }
2715
2716           return v1 == v2;
2717         }
2718
2719       case COMPLEX_CST:
2720         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
2721                                  flags)
2722                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
2723                                     flags));
2724
2725       case STRING_CST:
2726         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
2727                 && ! memcmp (TREE_STRING_POINTER (arg0),
2728                               TREE_STRING_POINTER (arg1),
2729                               TREE_STRING_LENGTH (arg0)));
2730
2731       case ADDR_EXPR:
2732         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
2733                                 0);
2734       default:
2735         break;
2736       }
2737
2738   if (flags & OEP_ONLY_CONST)
2739     return 0;
2740
2741 /* Define macros to test an operand from arg0 and arg1 for equality and a
2742    variant that allows null and views null as being different from any
2743    non-null value.  In the latter case, if either is null, the both
2744    must be; otherwise, do the normal comparison.  */
2745 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),     \
2746                                     TREE_OPERAND (arg1, N), flags)
2747
2748 #define OP_SAME_WITH_NULL(N)                            \
2749   ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
2750    ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
2751
2752   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
2753     {
2754     case tcc_unary:
2755       /* Two conversions are equal only if signedness and modes match.  */
2756       switch (TREE_CODE (arg0))
2757         {
2758         case NOP_EXPR:
2759         case CONVERT_EXPR:
2760         case FIX_CEIL_EXPR:
2761         case FIX_TRUNC_EXPR:
2762         case FIX_FLOOR_EXPR:
2763         case FIX_ROUND_EXPR:
2764           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
2765               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
2766             return 0;
2767           break;
2768         default:
2769           break;
2770         }
2771
2772       return OP_SAME (0);
2773
2774
2775     case tcc_comparison:
2776     case tcc_binary:
2777       if (OP_SAME (0) && OP_SAME (1))
2778         return 1;
2779
2780       /* For commutative ops, allow the other order.  */
2781       return (commutative_tree_code (TREE_CODE (arg0))
2782               && operand_equal_p (TREE_OPERAND (arg0, 0),
2783                                   TREE_OPERAND (arg1, 1), flags)
2784               && operand_equal_p (TREE_OPERAND (arg0, 1),
2785                                   TREE_OPERAND (arg1, 0), flags));
2786
2787     case tcc_reference:
2788       /* If either of the pointer (or reference) expressions we are
2789          dereferencing contain a side effect, these cannot be equal.  */
2790       if (TREE_SIDE_EFFECTS (arg0)
2791           || TREE_SIDE_EFFECTS (arg1))
2792         return 0;
2793
2794       switch (TREE_CODE (arg0))
2795         {
2796         case INDIRECT_REF:
2797         case ALIGN_INDIRECT_REF:
2798         case MISALIGNED_INDIRECT_REF:
2799         case REALPART_EXPR:
2800         case IMAGPART_EXPR:
2801           return OP_SAME (0);
2802
2803         case ARRAY_REF:
2804         case ARRAY_RANGE_REF:
2805           /* Operands 2 and 3 may be null.  */
2806           return (OP_SAME (0)
2807                   && OP_SAME (1)
2808                   && OP_SAME_WITH_NULL (2)
2809                   && OP_SAME_WITH_NULL (3));
2810
2811         case COMPONENT_REF:
2812           /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
2813              may be NULL when we're called to compare MEM_EXPRs.  */
2814           return OP_SAME_WITH_NULL (0)
2815                  && OP_SAME (1)
2816                  && OP_SAME_WITH_NULL (2);
2817
2818         case BIT_FIELD_REF:
2819           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
2820
2821         default:
2822           return 0;
2823         }
2824
2825     case tcc_expression:
2826       switch (TREE_CODE (arg0))
2827         {
2828         case ADDR_EXPR:
2829         case TRUTH_NOT_EXPR:
2830           return OP_SAME (0);
2831
2832         case TRUTH_ANDIF_EXPR:
2833         case TRUTH_ORIF_EXPR:
2834           return OP_SAME (0) && OP_SAME (1);
2835
2836         case TRUTH_AND_EXPR:
2837         case TRUTH_OR_EXPR:
2838         case TRUTH_XOR_EXPR:
2839           if (OP_SAME (0) && OP_SAME (1))
2840             return 1;
2841
2842           /* Otherwise take into account this is a commutative operation.  */
2843           return (operand_equal_p (TREE_OPERAND (arg0, 0),
2844                                    TREE_OPERAND (arg1, 1), flags)
2845                   && operand_equal_p (TREE_OPERAND (arg0, 1),
2846                                       TREE_OPERAND (arg1, 0), flags));
2847
2848         case CALL_EXPR:
2849           /* If the CALL_EXPRs call different functions, then they
2850              clearly can not be equal.  */
2851           if (!OP_SAME (0))
2852             return 0;
2853
2854           {
2855             unsigned int cef = call_expr_flags (arg0);
2856             if (flags & OEP_PURE_SAME)
2857               cef &= ECF_CONST | ECF_PURE;
2858             else
2859               cef &= ECF_CONST;
2860             if (!cef)
2861               return 0;
2862           }
2863
2864           /* Now see if all the arguments are the same.  operand_equal_p
2865              does not handle TREE_LIST, so we walk the operands here
2866              feeding them to operand_equal_p.  */
2867           arg0 = TREE_OPERAND (arg0, 1);
2868           arg1 = TREE_OPERAND (arg1, 1);
2869           while (arg0 && arg1)
2870             {
2871               if (! operand_equal_p (TREE_VALUE (arg0), TREE_VALUE (arg1),
2872                                      flags))
2873                 return 0;
2874
2875               arg0 = TREE_CHAIN (arg0);
2876               arg1 = TREE_CHAIN (arg1);
2877             }
2878
2879           /* If we get here and both argument lists are exhausted
2880              then the CALL_EXPRs are equal.  */
2881           return ! (arg0 || arg1);
2882
2883         default:
2884           return 0;
2885         }
2886
2887     case tcc_declaration:
2888       /* Consider __builtin_sqrt equal to sqrt.  */
2889       return (TREE_CODE (arg0) == FUNCTION_DECL
2890               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
2891               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
2892               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
2893
2894     default:
2895       return 0;
2896     }
2897
2898 #undef OP_SAME
2899 #undef OP_SAME_WITH_NULL
2900 }
2901 \f
2902 /* Similar to operand_equal_p, but see if ARG0 might have been made by
2903    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
2904
2905    When in doubt, return 0.  */
2906
2907 static int
2908 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
2909 {
2910   int unsignedp1, unsignedpo;
2911   tree primarg0, primarg1, primother;
2912   unsigned int correct_width;
2913
2914   if (operand_equal_p (arg0, arg1, 0))
2915     return 1;
2916
2917   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
2918       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
2919     return 0;
2920
2921   /* Discard any conversions that don't change the modes of ARG0 and ARG1
2922      and see if the inner values are the same.  This removes any
2923      signedness comparison, which doesn't matter here.  */
2924   primarg0 = arg0, primarg1 = arg1;
2925   STRIP_NOPS (primarg0);
2926   STRIP_NOPS (primarg1);
2927   if (operand_equal_p (primarg0, primarg1, 0))
2928     return 1;
2929
2930   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
2931      actual comparison operand, ARG0.
2932
2933      First throw away any conversions to wider types
2934      already present in the operands.  */
2935
2936   primarg1 = get_narrower (arg1, &unsignedp1);
2937   primother = get_narrower (other, &unsignedpo);
2938
2939   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
2940   if (unsignedp1 == unsignedpo
2941       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
2942       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
2943     {
2944       tree type = TREE_TYPE (arg0);
2945
2946       /* Make sure shorter operand is extended the right way
2947          to match the longer operand.  */
2948       primarg1 = fold_convert (lang_hooks.types.signed_or_unsigned_type
2949                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
2950
2951       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
2952         return 1;
2953     }
2954
2955   return 0;
2956 }
2957 \f
2958 /* See if ARG is an expression that is either a comparison or is performing
2959    arithmetic on comparisons.  The comparisons must only be comparing
2960    two different values, which will be stored in *CVAL1 and *CVAL2; if
2961    they are nonzero it means that some operands have already been found.
2962    No variables may be used anywhere else in the expression except in the
2963    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
2964    the expression and save_expr needs to be called with CVAL1 and CVAL2.
2965
2966    If this is true, return 1.  Otherwise, return zero.  */
2967
2968 static int
2969 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
2970 {
2971   enum tree_code code = TREE_CODE (arg);
2972   enum tree_code_class class = TREE_CODE_CLASS (code);
2973
2974   /* We can handle some of the tcc_expression cases here.  */
2975   if (class == tcc_expression && code == TRUTH_NOT_EXPR)
2976     class = tcc_unary;
2977   else if (class == tcc_expression
2978            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
2979                || code == COMPOUND_EXPR))
2980     class = tcc_binary;
2981
2982   else if (class == tcc_expression && code == SAVE_EXPR
2983            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
2984     {
2985       /* If we've already found a CVAL1 or CVAL2, this expression is
2986          two complex to handle.  */
2987       if (*cval1 || *cval2)
2988         return 0;
2989
2990       class = tcc_unary;
2991       *save_p = 1;
2992     }
2993
2994   switch (class)
2995     {
2996     case tcc_unary:
2997       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
2998
2999     case tcc_binary:
3000       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
3001               && twoval_comparison_p (TREE_OPERAND (arg, 1),
3002                                       cval1, cval2, save_p));
3003
3004     case tcc_constant:
3005       return 1;
3006
3007     case tcc_expression:
3008       if (code == COND_EXPR)
3009         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
3010                                      cval1, cval2, save_p)
3011                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3012                                         cval1, cval2, save_p)
3013                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
3014                                         cval1, cval2, save_p));
3015       return 0;
3016
3017     case tcc_comparison:
3018       /* First see if we can handle the first operand, then the second.  For
3019          the second operand, we know *CVAL1 can't be zero.  It must be that
3020          one side of the comparison is each of the values; test for the
3021          case where this isn't true by failing if the two operands
3022          are the same.  */
3023
3024       if (operand_equal_p (TREE_OPERAND (arg, 0),
3025                            TREE_OPERAND (arg, 1), 0))
3026         return 0;
3027
3028       if (*cval1 == 0)
3029         *cval1 = TREE_OPERAND (arg, 0);
3030       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
3031         ;
3032       else if (*cval2 == 0)
3033         *cval2 = TREE_OPERAND (arg, 0);
3034       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
3035         ;
3036       else
3037         return 0;
3038
3039       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
3040         ;
3041       else if (*cval2 == 0)
3042         *cval2 = TREE_OPERAND (arg, 1);
3043       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
3044         ;
3045       else
3046         return 0;
3047
3048       return 1;
3049
3050     default:
3051       return 0;
3052     }
3053 }
3054 \f
3055 /* ARG is a tree that is known to contain just arithmetic operations and
3056    comparisons.  Evaluate the operations in the tree substituting NEW0 for
3057    any occurrence of OLD0 as an operand of a comparison and likewise for
3058    NEW1 and OLD1.  */
3059
3060 static tree
3061 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
3062 {
3063   tree type = TREE_TYPE (arg);
3064   enum tree_code code = TREE_CODE (arg);
3065   enum tree_code_class class = TREE_CODE_CLASS (code);
3066
3067   /* We can handle some of the tcc_expression cases here.  */
3068   if (class == tcc_expression && code == TRUTH_NOT_EXPR)
3069     class = tcc_unary;
3070   else if (class == tcc_expression
3071            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3072     class = tcc_binary;
3073
3074   switch (class)
3075     {
3076     case tcc_unary:
3077       return fold_build1 (code, type,
3078                           eval_subst (TREE_OPERAND (arg, 0),
3079                                       old0, new0, old1, new1));
3080
3081     case tcc_binary:
3082       return fold_build2 (code, type,
3083                           eval_subst (TREE_OPERAND (arg, 0),
3084                                       old0, new0, old1, new1),
3085                           eval_subst (TREE_OPERAND (arg, 1),
3086                                       old0, new0, old1, new1));
3087
3088     case tcc_expression:
3089       switch (code)
3090         {
3091         case SAVE_EXPR:
3092           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
3093
3094         case COMPOUND_EXPR:
3095           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
3096
3097         case COND_EXPR:
3098           return fold_build3 (code, type,
3099                               eval_subst (TREE_OPERAND (arg, 0),
3100                                           old0, new0, old1, new1),
3101                               eval_subst (TREE_OPERAND (arg, 1),
3102                                           old0, new0, old1, new1),
3103                               eval_subst (TREE_OPERAND (arg, 2),
3104                                           old0, new0, old1, new1));
3105         default:
3106           break;
3107         }
3108       /* Fall through - ???  */
3109
3110     case tcc_comparison:
3111       {
3112         tree arg0 = TREE_OPERAND (arg, 0);
3113         tree arg1 = TREE_OPERAND (arg, 1);
3114
3115         /* We need to check both for exact equality and tree equality.  The
3116            former will be true if the operand has a side-effect.  In that
3117            case, we know the operand occurred exactly once.  */
3118
3119         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3120           arg0 = new0;
3121         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3122           arg0 = new1;
3123
3124         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3125           arg1 = new0;
3126         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3127           arg1 = new1;
3128
3129         return fold_build2 (code, type, arg0, arg1);
3130       }
3131
3132     default:
3133       return arg;
3134     }
3135 }
3136 \f
3137 /* Return a tree for the case when the result of an expression is RESULT
3138    converted to TYPE and OMITTED was previously an operand of the expression
3139    but is now not needed (e.g., we folded OMITTED * 0).
3140
3141    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
3142    the conversion of RESULT to TYPE.  */
3143
3144 tree
3145 omit_one_operand (tree type, tree result, tree omitted)
3146 {
3147   tree t = fold_convert (type, result);
3148
3149   if (TREE_SIDE_EFFECTS (omitted))
3150     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3151
3152   return non_lvalue (t);
3153 }
3154
3155 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
3156
3157 static tree
3158 pedantic_omit_one_operand (tree type, tree result, tree omitted)
3159 {
3160   tree t = fold_convert (type, result);
3161
3162   if (TREE_SIDE_EFFECTS (omitted))
3163     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3164
3165   return pedantic_non_lvalue (t);
3166 }
3167
3168 /* Return a tree for the case when the result of an expression is RESULT
3169    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3170    of the expression but are now not needed.
3171
3172    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3173    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3174    evaluated before OMITTED2.  Otherwise, if neither has side effects,
3175    just do the conversion of RESULT to TYPE.  */
3176
3177 tree
3178 omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
3179 {
3180   tree t = fold_convert (type, result);
3181
3182   if (TREE_SIDE_EFFECTS (omitted2))
3183     t = build2 (COMPOUND_EXPR, type, omitted2, t);
3184   if (TREE_SIDE_EFFECTS (omitted1))
3185     t = build2 (COMPOUND_EXPR, type, omitted1, t);
3186
3187   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
3188 }
3189
3190 \f
3191 /* Return a simplified tree node for the truth-negation of ARG.  This
3192    never alters ARG itself.  We assume that ARG is an operation that
3193    returns a truth value (0 or 1).
3194
3195    FIXME: one would think we would fold the result, but it causes
3196    problems with the dominator optimizer.  */
3197
3198 tree
3199 fold_truth_not_expr (tree arg)
3200 {
3201   tree type = TREE_TYPE (arg);
3202   enum tree_code code = TREE_CODE (arg);
3203
3204   /* If this is a comparison, we can simply invert it, except for
3205      floating-point non-equality comparisons, in which case we just
3206      enclose a TRUTH_NOT_EXPR around what we have.  */
3207
3208   if (TREE_CODE_CLASS (code) == tcc_comparison)
3209     {
3210       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3211       if (FLOAT_TYPE_P (op_type)
3212           && flag_trapping_math
3213           && code != ORDERED_EXPR && code != UNORDERED_EXPR
3214           && code != NE_EXPR && code != EQ_EXPR)
3215         return NULL_TREE;
3216       else
3217         {
3218           code = invert_tree_comparison (code,
3219                                          HONOR_NANS (TYPE_MODE (op_type)));
3220           if (code == ERROR_MARK)
3221             return NULL_TREE;
3222           else
3223             return build2 (code, type,
3224                            TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
3225         }
3226     }
3227
3228   switch (code)
3229     {
3230     case INTEGER_CST:
3231       return constant_boolean_node (integer_zerop (arg), type);
3232
3233     case TRUTH_AND_EXPR:
3234       return build2 (TRUTH_OR_EXPR, type,
3235                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3236                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3237
3238     case TRUTH_OR_EXPR:
3239       return build2 (TRUTH_AND_EXPR, type,
3240                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3241                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3242
3243     case TRUTH_XOR_EXPR:
3244       /* Here we can invert either operand.  We invert the first operand
3245          unless the second operand is a TRUTH_NOT_EXPR in which case our
3246          result is the XOR of the first operand with the inside of the
3247          negation of the second operand.  */
3248
3249       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3250         return build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3251                        TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3252       else
3253         return build2 (TRUTH_XOR_EXPR, type,
3254                        invert_truthvalue (TREE_OPERAND (arg, 0)),
3255                        TREE_OPERAND (arg, 1));
3256
3257     case TRUTH_ANDIF_EXPR:
3258       return build2 (TRUTH_ORIF_EXPR, type,
3259                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3260                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3261
3262     case TRUTH_ORIF_EXPR:
3263       return build2 (TRUTH_ANDIF_EXPR, type,
3264                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3265                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3266
3267     case TRUTH_NOT_EXPR:
3268       return TREE_OPERAND (arg, 0);
3269
3270     case COND_EXPR:
3271       {
3272         tree arg1 = TREE_OPERAND (arg, 1);
3273         tree arg2 = TREE_OPERAND (arg, 2);
3274         /* A COND_EXPR may have a throw as one operand, which
3275            then has void type.  Just leave void operands
3276            as they are.  */
3277         return build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
3278                        VOID_TYPE_P (TREE_TYPE (arg1))
3279                        ? arg1 : invert_truthvalue (arg1),
3280                        VOID_TYPE_P (TREE_TYPE (arg2))
3281                        ? arg2 : invert_truthvalue (arg2));
3282       }
3283
3284     case COMPOUND_EXPR:
3285       return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
3286                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3287
3288     case NON_LVALUE_EXPR:
3289       return invert_truthvalue (TREE_OPERAND (arg, 0));
3290
3291     case NOP_EXPR:
3292       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3293         return build1 (TRUTH_NOT_EXPR, type, arg);
3294
3295     case CONVERT_EXPR:
3296     case FLOAT_EXPR:
3297       return build1 (TREE_CODE (arg), type,
3298                      invert_truthvalue (TREE_OPERAND (arg, 0)));
3299
3300     case BIT_AND_EXPR:
3301       if (!integer_onep (TREE_OPERAND (arg, 1)))
3302         break;
3303       return build2 (EQ_EXPR, type, arg,
3304                      build_int_cst (type, 0));
3305
3306     case SAVE_EXPR:
3307       return build1 (TRUTH_NOT_EXPR, type, arg);
3308
3309     case CLEANUP_POINT_EXPR:
3310       return build1 (CLEANUP_POINT_EXPR, type,
3311                      invert_truthvalue (TREE_OPERAND (arg, 0)));
3312
3313     default:
3314       break;
3315     }
3316
3317   return NULL_TREE;
3318 }
3319
3320 /* Return a simplified tree node for the truth-negation of ARG.  This
3321    never alters ARG itself.  We assume that ARG is an operation that
3322    returns a truth value (0 or 1).
3323
3324    FIXME: one would think we would fold the result, but it causes
3325    problems with the dominator optimizer.  */
3326
3327 tree
3328 invert_truthvalue (tree arg)
3329 {
3330   tree tem;
3331
3332   if (TREE_CODE (arg) == ERROR_MARK)
3333     return arg;
3334
3335   tem = fold_truth_not_expr (arg);
3336   if (!tem)
3337     tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3338
3339   return tem;
3340 }
3341
3342 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3343    operands are another bit-wise operation with a common input.  If so,
3344    distribute the bit operations to save an operation and possibly two if
3345    constants are involved.  For example, convert
3346         (A | B) & (A | C) into A | (B & C)
3347    Further simplification will occur if B and C are constants.
3348
3349    If this optimization cannot be done, 0 will be returned.  */
3350
3351 static tree
3352 distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
3353 {
3354   tree common;
3355   tree left, right;
3356
3357   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3358       || TREE_CODE (arg0) == code
3359       || (TREE_CODE (arg0) != BIT_AND_EXPR
3360           && TREE_CODE (arg0) != BIT_IOR_EXPR))
3361     return 0;
3362
3363   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3364     {
3365       common = TREE_OPERAND (arg0, 0);
3366       left = TREE_OPERAND (arg0, 1);
3367       right = TREE_OPERAND (arg1, 1);
3368     }
3369   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3370     {
3371       common = TREE_OPERAND (arg0, 0);
3372       left = TREE_OPERAND (arg0, 1);
3373       right = TREE_OPERAND (arg1, 0);
3374     }
3375   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3376     {
3377       common = TREE_OPERAND (arg0, 1);
3378       left = TREE_OPERAND (arg0, 0);
3379       right = TREE_OPERAND (arg1, 1);
3380     }
3381   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3382     {
3383       common = TREE_OPERAND (arg0, 1);
3384       left = TREE_OPERAND (arg0, 0);
3385       right = TREE_OPERAND (arg1, 0);
3386     }
3387   else
3388     return 0;
3389
3390   return fold_build2 (TREE_CODE (arg0), type, common,
3391                       fold_build2 (code, type, left, right));
3392 }
3393
3394 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3395    with code CODE.  This optimization is unsafe.  */
3396 static tree
3397 distribute_real_division (enum tree_code code, tree type, tree arg0, tree arg1)
3398 {
3399   bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3400   bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3401
3402   /* (A / C) +- (B / C) -> (A +- B) / C.  */
3403   if (mul0 == mul1
3404       && operand_equal_p (TREE_OPERAND (arg0, 1),
3405                        TREE_OPERAND (arg1, 1), 0))
3406     return fold_build2 (mul0 ? MULT_EXPR : RDIV_EXPR, type,
3407                         fold_build2 (code, type,
3408                                      TREE_OPERAND (arg0, 0),
3409                                      TREE_OPERAND (arg1, 0)),
3410                         TREE_OPERAND (arg0, 1));
3411
3412   /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2).  */
3413   if (operand_equal_p (TREE_OPERAND (arg0, 0),
3414                        TREE_OPERAND (arg1, 0), 0)
3415       && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3416       && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3417     {
3418       REAL_VALUE_TYPE r0, r1;
3419       r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3420       r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3421       if (!mul0)
3422         real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3423       if (!mul1)
3424         real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3425       real_arithmetic (&r0, code, &r0, &r1);
3426       return fold_build2 (MULT_EXPR, type,
3427                           TREE_OPERAND (arg0, 0),
3428                           build_real (type, r0));
3429     }
3430
3431   return NULL_TREE;
3432 }
3433 \f
3434 /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
3435    starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero.  */
3436
3437 static tree
3438 make_bit_field_ref (tree inner, tree type, int bitsize, int bitpos,
3439                     int unsignedp)
3440 {
3441   tree result;
3442
3443   if (bitpos == 0)
3444     {
3445       tree size = TYPE_SIZE (TREE_TYPE (inner));
3446       if ((INTEGRAL_TYPE_P (TREE_TYPE (inner))
3447            || POINTER_TYPE_P (TREE_TYPE (inner)))
3448           && host_integerp (size, 0) 
3449           && tree_low_cst (size, 0) == bitsize)
3450         return fold_convert (type, inner);
3451     }
3452
3453   result = build3 (BIT_FIELD_REF, type, inner,
3454                    size_int (bitsize), bitsize_int (bitpos));
3455
3456   BIT_FIELD_REF_UNSIGNED (result) = unsignedp;
3457
3458   return result;
3459 }
3460
3461 /* Optimize a bit-field compare.
3462
3463    There are two cases:  First is a compare against a constant and the
3464    second is a comparison of two items where the fields are at the same
3465    bit position relative to the start of a chunk (byte, halfword, word)
3466    large enough to contain it.  In these cases we can avoid the shift
3467    implicit in bitfield extractions.
3468
3469    For constants, we emit a compare of the shifted constant with the
3470    BIT_AND_EXPR of a mask and a byte, halfword, or word of the operand being
3471    compared.  For two fields at the same position, we do the ANDs with the
3472    similar mask and compare the result of the ANDs.
3473
3474    CODE is the comparison code, known to be either NE_EXPR or EQ_EXPR.
3475    COMPARE_TYPE is the type of the comparison, and LHS and RHS
3476    are the left and right operands of the comparison, respectively.
3477
3478    If the optimization described above can be done, we return the resulting
3479    tree.  Otherwise we return zero.  */
3480
3481 static tree
3482 optimize_bit_field_compare (enum tree_code code, tree compare_type,
3483                             tree lhs, tree rhs)
3484 {
3485   HOST_WIDE_INT lbitpos, lbitsize, rbitpos, rbitsize, nbitpos, nbitsize;
3486   tree type = TREE_TYPE (lhs);
3487   tree signed_type, unsigned_type;
3488   int const_p = TREE_CODE (rhs) == INTEGER_CST;
3489   enum machine_mode lmode, rmode, nmode;
3490   int lunsignedp, runsignedp;
3491   int lvolatilep = 0, rvolatilep = 0;
3492   tree linner, rinner = NULL_TREE;
3493   tree mask;
3494   tree offset;
3495
3496   /* Get all the information about the extractions being done.  If the bit size
3497      if the same as the size of the underlying object, we aren't doing an
3498      extraction at all and so can do nothing.  We also don't want to
3499      do anything if the inner expression is a PLACEHOLDER_EXPR since we
3500      then will no longer be able to replace it.  */
3501   linner = get_inner_reference (lhs, &lbitsize, &lbitpos, &offset, &lmode,
3502                                 &lunsignedp, &lvolatilep, false);
3503   if (linner == lhs || lbitsize == GET_MODE_BITSIZE (lmode) || lbitsize < 0
3504       || offset != 0 || TREE_CODE (linner) == PLACEHOLDER_EXPR)
3505     return 0;
3506
3507  if (!const_p)
3508    {
3509      /* If this is not a constant, we can only do something if bit positions,
3510         sizes, and signedness are the same.  */
3511      rinner = get_inner_reference (rhs, &rbitsize, &rbitpos, &offset, &rmode,
3512                                    &runsignedp, &rvolatilep, false);
3513
3514      if (rinner == rhs || lbitpos != rbitpos || lbitsize != rbitsize
3515          || lunsignedp != runsignedp || offset != 0
3516          || TREE_CODE (rinner) == PLACEHOLDER_EXPR)
3517        return 0;
3518    }
3519
3520   /* See if we can find a mode to refer to this field.  We should be able to,
3521      but fail if we can't.  */
3522   nmode = get_best_mode (lbitsize, lbitpos,
3523                          const_p ? TYPE_ALIGN (TREE_TYPE (linner))
3524                          : MIN (TYPE_ALIGN (TREE_TYPE (linner)),
3525                                 TYPE_ALIGN (TREE_TYPE (rinner))),
3526                          word_mode, lvolatilep || rvolatilep);
3527   if (nmode == VOIDmode)
3528     return 0;
3529
3530   /* Set signed and unsigned types of the precision of this mode for the
3531      shifts below.  */
3532   signed_type = lang_hooks.types.type_for_mode (nmode, 0);
3533   unsigned_type = lang_hooks.types.type_for_mode (nmode, 1);
3534
3535   /* Compute the bit position and size for the new reference and our offset
3536      within it. If the new reference is the same size as the original, we
3537      won't optimize anything, so return zero.  */
3538   nbitsize = GET_MODE_BITSIZE (nmode);
3539   nbitpos = lbitpos & ~ (nbitsize - 1);
3540   lbitpos -= nbitpos;
3541   if (nbitsize == lbitsize)
3542     return 0;
3543
3544   if (BYTES_BIG_ENDIAN)
3545     lbitpos = nbitsize - lbitsize - lbitpos;
3546
3547   /* Make the mask to be used against the extracted field.  */
3548   mask = build_int_cst (unsigned_type, -1);
3549   mask = force_fit_type (mask, 0, false, false);
3550   mask = fold_convert (unsigned_type, mask);
3551   mask = const_binop (LSHIFT_EXPR, mask, size_int (nbitsize - lbitsize), 0);
3552   mask = const_binop (RSHIFT_EXPR, mask,
3553                       size_int (nbitsize - lbitsize - lbitpos), 0);
3554
3555   if (! const_p)
3556     /* If not comparing with constant, just rework the comparison
3557        and return.  */
3558     return build2 (code, compare_type,
3559                    build2 (BIT_AND_EXPR, unsigned_type,
3560                            make_bit_field_ref (linner, unsigned_type,
3561                                                nbitsize, nbitpos, 1),
3562                            mask),
3563                    build2 (BIT_AND_EXPR, unsigned_type,
3564                            make_bit_field_ref (rinner, unsigned_type,
3565                                                nbitsize, nbitpos, 1),
3566                            mask));
3567
3568   /* Otherwise, we are handling the constant case. See if the constant is too
3569      big for the field.  Warn and return a tree of for 0 (false) if so.  We do
3570      this not only for its own sake, but to avoid having to test for this
3571      error case below.  If we didn't, we might generate wrong code.
3572
3573      For unsigned fields, the constant shifted right by the field length should
3574      be all zero.  For signed fields, the high-order bits should agree with
3575      the sign bit.  */
3576
3577   if (lunsignedp)
3578     {
3579       if (! integer_zerop (const_binop (RSHIFT_EXPR,
3580                                         fold_convert (unsigned_type, rhs),
3581                                         size_int (lbitsize), 0)))
3582         {
3583           warning (0, "comparison is always %d due to width of bit-field",
3584                    code == NE_EXPR);
3585           return constant_boolean_node (code == NE_EXPR, compare_type);
3586         }
3587     }
3588   else
3589     {
3590       tree tem = const_binop (RSHIFT_EXPR, fold_convert (signed_type, rhs),
3591                               size_int (lbitsize - 1), 0);
3592       if (! integer_zerop (tem) && ! integer_all_onesp (tem))
3593         {
3594           warning (0, "comparison is always %d due to width of bit-field",
3595                    code == NE_EXPR);
3596           return constant_boolean_node (code == NE_EXPR, compare_type);
3597         }
3598     }
3599
3600   /* Single-bit compares should always be against zero.  */
3601   if (lbitsize == 1 && ! integer_zerop (rhs))
3602     {
3603       code = code == EQ_EXPR ? NE_EXPR : EQ_EXPR;
3604       rhs = build_int_cst (type, 0);
3605     }
3606
3607   /* Make a new bitfield reference, shift the constant over the
3608      appropriate number of bits and mask it with the computed mask
3609      (in case this was a signed field).  If we changed it, make a new one.  */
3610   lhs = make_bit_field_ref (linner, unsigned_type, nbitsize, nbitpos, 1);
3611   if (lvolatilep)
3612     {
3613       TREE_SIDE_EFFECTS (lhs) = 1;
3614       TREE_THIS_VOLATILE (lhs) = 1;
3615     }
3616
3617   rhs = const_binop (BIT_AND_EXPR,
3618                      const_binop (LSHIFT_EXPR,
3619                                   fold_convert (unsigned_type, rhs),
3620                                   size_int (lbitpos), 0),
3621                      mask, 0);
3622
3623   return build2 (code, compare_type,
3624                  build2 (BIT_AND_EXPR, unsigned_type, lhs, mask),
3625                  rhs);
3626 }
3627 \f
3628 /* Subroutine for fold_truthop: decode a field reference.
3629
3630    If EXP is a comparison reference, we return the innermost reference.
3631
3632    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3633    set to the starting bit number.
3634
3635    If the innermost field can be completely contained in a mode-sized
3636    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3637
3638    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3639    otherwise it is not changed.
3640
3641    *PUNSIGNEDP is set to the signedness of the field.
3642
3643    *PMASK is set to the mask used.  This is either contained in a
3644    BIT_AND_EXPR or derived from the width of the field.
3645
3646    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3647
3648    Return 0 if this is not a component reference or is one that we can't
3649    do anything with.  */
3650
3651 static tree
3652 decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
3653                         HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
3654                         int *punsignedp, int *pvolatilep,
3655                         tree *pmask, tree *pand_mask)
3656 {
3657   tree outer_type = 0;
3658   tree and_mask = 0;
3659   tree mask, inner, offset;
3660   tree unsigned_type;
3661   unsigned int precision;
3662
3663   /* All the optimizations using this function assume integer fields.
3664      There are problems with FP fields since the type_for_size call
3665      below can fail for, e.g., XFmode.  */
3666   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3667     return 0;
3668
3669   /* We are interested in the bare arrangement of bits, so strip everything
3670      that doesn't affect the machine mode.  However, record the type of the
3671      outermost expression if it may matter below.  */
3672   if (TREE_CODE (exp) == NOP_EXPR
3673       || TREE_CODE (exp) == CONVERT_EXPR
3674       || TREE_CODE (exp) == NON_LVALUE_EXPR)
3675     outer_type = TREE_TYPE (exp);
3676   STRIP_NOPS (exp);
3677
3678   if (TREE_CODE (exp) == BIT_AND_EXPR)
3679     {
3680       and_mask = TREE_OPERAND (exp, 1);
3681       exp = TREE_OPERAND (exp, 0);
3682       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3683       if (TREE_CODE (and_mask) != INTEGER_CST)
3684         return 0;
3685     }
3686
3687   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3688                                punsignedp, pvolatilep, false);
3689   if ((inner == exp && and_mask == 0)
3690       || *pbitsize < 0 || offset != 0
3691       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3692     return 0;
3693
3694   /* If the number of bits in the reference is the same as the bitsize of
3695      the outer type, then the outer type gives the signedness. Otherwise
3696      (in case of a small bitfield) the signedness is unchanged.  */
3697   if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3698     *punsignedp = TYPE_UNSIGNED (outer_type);
3699
3700   /* Compute the mask to access the bitfield.  */
3701   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3702   precision = TYPE_PRECISION (unsigned_type);
3703
3704   mask = build_int_cst (unsigned_type, -1);
3705   mask = force_fit_type (mask, 0, false, false);
3706
3707   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3708   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3709
3710   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3711   if (and_mask != 0)
3712     mask = fold_build2 (BIT_AND_EXPR, unsigned_type,
3713                         fold_convert (unsigned_type, and_mask), mask);
3714
3715   *pmask = mask;
3716   *pand_mask = and_mask;
3717   return inner;
3718 }
3719
3720 /* Return nonzero if MASK represents a mask of SIZE ones in the low-order
3721    bit positions.  */
3722
3723 static int
3724 all_ones_mask_p (tree mask, int size)
3725 {
3726   tree type = TREE_TYPE (mask);
3727   unsigned int precision = TYPE_PRECISION (type);
3728   tree tmask;
3729
3730   tmask = build_int_cst (lang_hooks.types.signed_type (type), -1);
3731   tmask = force_fit_type (tmask, 0, false, false);
3732
3733   return
3734     tree_int_cst_equal (mask,
3735                         const_binop (RSHIFT_EXPR,
3736                                      const_binop (LSHIFT_EXPR, tmask,
3737                                                   size_int (precision - size),
3738                                                   0),
3739                                      size_int (precision - size), 0));
3740 }
3741
3742 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3743    represents the sign bit of EXP's type.  If EXP represents a sign
3744    or zero extension, also test VAL against the unextended type.
3745    The return value is the (sub)expression whose sign bit is VAL,
3746    or NULL_TREE otherwise.  */
3747
3748 static tree
3749 sign_bit_p (tree exp, tree val)
3750 {
3751   unsigned HOST_WIDE_INT mask_lo, lo;
3752   HOST_WIDE_INT mask_hi, hi;
3753   int width;
3754   tree t;
3755
3756   /* Tree EXP must have an integral type.  */
3757   t = TREE_TYPE (exp);
3758   if (! INTEGRAL_TYPE_P (t))
3759     return NULL_TREE;
3760
3761   /* Tree VAL must be an integer constant.  */
3762   if (TREE_CODE (val) != INTEGER_CST
3763       || TREE_CONSTANT_OVERFLOW (val))
3764     return NULL_TREE;
3765
3766   width = TYPE_PRECISION (t);
3767   if (width > HOST_BITS_PER_WIDE_INT)
3768     {
3769       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
3770       lo = 0;
3771
3772       mask_hi = ((unsigned HOST_WIDE_INT) -1
3773                  >> (2 * HOST_BITS_PER_WIDE_INT - width));
3774       mask_lo = -1;
3775     }
3776   else
3777     {
3778       hi = 0;
3779       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
3780
3781       mask_hi = 0;
3782       mask_lo = ((unsigned HOST_WIDE_INT) -1
3783                  >> (HOST_BITS_PER_WIDE_INT - width));
3784     }
3785
3786   /* We mask off those bits beyond TREE_TYPE (exp) so that we can
3787      treat VAL as if it were unsigned.  */
3788   if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
3789       && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
3790     return exp;
3791
3792   /* Handle extension from a narrower type.  */
3793   if (TREE_CODE (exp) == NOP_EXPR
3794       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
3795     return sign_bit_p (TREE_OPERAND (exp, 0), val);
3796
3797   return NULL_TREE;
3798 }
3799
3800 /* Subroutine for fold_truthop: determine if an operand is simple enough
3801    to be evaluated unconditionally.  */
3802
3803 static int
3804 simple_operand_p (tree exp)
3805 {
3806   /* Strip any conversions that don't change the machine mode.  */
3807   STRIP_NOPS (exp);
3808
3809   return (CONSTANT_CLASS_P (exp)
3810           || TREE_CODE (exp) == SSA_NAME
3811           || (DECL_P (exp)
3812               && ! TREE_ADDRESSABLE (exp)
3813               && ! TREE_THIS_VOLATILE (exp)
3814               && ! DECL_NONLOCAL (exp)
3815               /* Don't regard global variables as simple.  They may be
3816                  allocated in ways unknown to the compiler (shared memory,
3817                  #pragma weak, etc).  */
3818               && ! TREE_PUBLIC (exp)
3819               && ! DECL_EXTERNAL (exp)
3820               /* Loading a static variable is unduly expensive, but global
3821                  registers aren't expensive.  */
3822               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
3823 }
3824 \f
3825 /* The following functions are subroutines to fold_range_test and allow it to
3826    try to change a logical combination of comparisons into a range test.
3827
3828    For example, both
3829         X == 2 || X == 3 || X == 4 || X == 5
3830    and
3831         X >= 2 && X <= 5
3832    are converted to
3833         (unsigned) (X - 2) <= 3
3834
3835    We describe each set of comparisons as being either inside or outside
3836    a range, using a variable named like IN_P, and then describe the
3837    range with a lower and upper bound.  If one of the bounds is omitted,
3838    it represents either the highest or lowest value of the type.
3839
3840    In the comments below, we represent a range by two numbers in brackets
3841    preceded by a "+" to designate being inside that range, or a "-" to
3842    designate being outside that range, so the condition can be inverted by
3843    flipping the prefix.  An omitted bound is represented by a "-".  For
3844    example, "- [-, 10]" means being outside the range starting at the lowest
3845    possible value and ending at 10, in other words, being greater than 10.
3846    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
3847    always false.
3848
3849    We set up things so that the missing bounds are handled in a consistent
3850    manner so neither a missing bound nor "true" and "false" need to be
3851    handled using a special case.  */
3852
3853 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
3854    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
3855    and UPPER1_P are nonzero if the respective argument is an upper bound
3856    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
3857    must be specified for a comparison.  ARG1 will be converted to ARG0's
3858    type if both are specified.  */
3859
3860 static tree
3861 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
3862              tree arg1, int upper1_p)
3863 {
3864   tree tem;
3865   int result;
3866   int sgn0, sgn1;
3867
3868   /* If neither arg represents infinity, do the normal operation.
3869      Else, if not a comparison, return infinity.  Else handle the special
3870      comparison rules. Note that most of the cases below won't occur, but
3871      are handled for consistency.  */
3872
3873   if (arg0 != 0 && arg1 != 0)
3874     {
3875       tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
3876                          arg0, fold_convert (TREE_TYPE (arg0), arg1));
3877       STRIP_NOPS (tem);
3878       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
3879     }
3880
3881   if (TREE_CODE_CLASS (code) != tcc_comparison)
3882     return 0;
3883
3884   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
3885      for neither.  In real maths, we cannot assume open ended ranges are
3886      the same. But, this is computer arithmetic, where numbers are finite.
3887      We can therefore make the transformation of any unbounded range with
3888      the value Z, Z being greater than any representable number. This permits
3889      us to treat unbounded ranges as equal.  */
3890   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
3891   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
3892   switch (code)
3893     {
3894     case EQ_EXPR:
3895       result = sgn0 == sgn1;
3896       break;
3897     case NE_EXPR:
3898       result = sgn0 != sgn1;
3899       break;
3900     case LT_EXPR:
3901       result = sgn0 < sgn1;
3902       break;
3903     case LE_EXPR:
3904       result = sgn0 <= sgn1;
3905       break;
3906     case GT_EXPR:
3907       result = sgn0 > sgn1;
3908       break;
3909     case GE_EXPR:
3910       result = sgn0 >= sgn1;
3911       break;
3912     default:
3913       gcc_unreachable ();
3914     }
3915
3916   return constant_boolean_node (result, type);
3917 }
3918 \f
3919 /* Given EXP, a logical expression, set the range it is testing into
3920    variables denoted by PIN_P, PLOW, and PHIGH.  Return the expression
3921    actually being tested.  *PLOW and *PHIGH will be made of the same
3922    type as the returned expression.  If EXP is not a comparison, we
3923    will most likely not be returning a useful value and range.  Set
3924    *STRICT_OVERFLOW_P to true if the return value is only valid
3925    because signed overflow is undefined; otherwise, do not change
3926    *STRICT_OVERFLOW_P.  */
3927
3928 static tree
3929 make_range (tree exp, int *pin_p, tree *plow, tree *phigh,
3930             bool *strict_overflow_p)
3931 {
3932   enum tree_code code;
3933   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
3934   tree exp_type = NULL_TREE, arg0_type = NULL_TREE;
3935   int in_p, n_in_p;
3936   tree low, high, n_low, n_high;
3937
3938   /* Start with simply saying "EXP != 0" and then look at the code of EXP
3939      and see if we can refine the range.  Some of the cases below may not
3940      happen, but it doesn't seem worth worrying about this.  We "continue"
3941      the outer loop when we've changed something; otherwise we "break"
3942      the switch, which will "break" the while.  */
3943
3944   in_p = 0;
3945   low = high = build_int_cst (TREE_TYPE (exp), 0);
3946
3947   while (1)
3948     {
3949       code = TREE_CODE (exp);
3950       exp_type = TREE_TYPE (exp);
3951
3952       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
3953         {
3954           if (TREE_CODE_LENGTH (code) > 0)
3955             arg0 = TREE_OPERAND (exp, 0);
3956           if (TREE_CODE_CLASS (code) == tcc_comparison
3957               || TREE_CODE_CLASS (code) == tcc_unary
3958               || TREE_CODE_CLASS (code) == tcc_binary)
3959             arg0_type = TREE_TYPE (arg0);
3960           if (TREE_CODE_CLASS (code) == tcc_binary
3961               || TREE_CODE_CLASS (code) == tcc_comparison
3962               || (TREE_CODE_CLASS (code) == tcc_expression
3963                   && TREE_CODE_LENGTH (code) > 1))
3964             arg1 = TREE_OPERAND (exp, 1);
3965         }
3966
3967       switch (code)
3968         {
3969         case TRUTH_NOT_EXPR:
3970           in_p = ! in_p, exp = arg0;
3971           continue;
3972
3973         case EQ_EXPR: case NE_EXPR:
3974         case LT_EXPR: case LE_EXPR: case GE_EXPR: case GT_EXPR:
3975           /* We can only do something if the range is testing for zero
3976              and if the second operand is an integer constant.  Note that
3977              saying something is "in" the range we make is done by
3978              complementing IN_P since it will set in the initial case of
3979              being not equal to zero; "out" is leaving it alone.  */
3980           if (low == 0 || high == 0
3981               || ! integer_zerop (low) || ! integer_zerop (high)
3982               || TREE_CODE (arg1) != INTEGER_CST)
3983             break;
3984
3985           switch (code)
3986             {
3987             case NE_EXPR:  /* - [c, c]  */
3988               low = high = arg1;
3989               break;
3990             case EQ_EXPR:  /* + [c, c]  */
3991               in_p = ! in_p, low = high = arg1;
3992               break;
3993             case GT_EXPR:  /* - [-, c] */
3994               low = 0, high = arg1;
3995               break;
3996             case GE_EXPR:  /* + [c, -] */
3997               in_p = ! in_p, low = arg1, high = 0;
3998               break;
3999             case LT_EXPR:  /* - [c, -] */
4000               low = arg1, high = 0;
4001               break;
4002             case LE_EXPR:  /* + [-, c] */
4003               in_p = ! in_p, low = 0, high = arg1;
4004               break;
4005             default:
4006               gcc_unreachable ();
4007             }
4008
4009           /* If this is an unsigned comparison, we also know that EXP is
4010              greater than or equal to zero.  We base the range tests we make
4011              on that fact, so we record it here so we can parse existing
4012              range tests.  We test arg0_type since often the return type
4013              of, e.g. EQ_EXPR, is boolean.  */
4014           if (TYPE_UNSIGNED (arg0_type) && (low == 0 || high == 0))
4015             {
4016               if (! merge_ranges (&n_in_p, &n_low, &n_high,
4017                                   in_p, low, high, 1,
4018                                   build_int_cst (arg0_type, 0),
4019                                   NULL_TREE))
4020                 break;
4021
4022               in_p = n_in_p, low = n_low, high = n_high;
4023
4024               /* If the high bound is missing, but we have a nonzero low
4025                  bound, reverse the range so it goes from zero to the low bound
4026                  minus 1.  */
4027               if (high == 0 && low && ! integer_zerop (low))
4028                 {
4029                   in_p = ! in_p;
4030                   high = range_binop (MINUS_EXPR, NULL_TREE, low, 0,
4031                                       integer_one_node, 0);
4032                   low = build_int_cst (arg0_type, 0);
4033                 }
4034             }
4035
4036           exp = arg0;
4037           continue;
4038
4039         case NEGATE_EXPR:
4040           /* (-x) IN [a,b] -> x in [-b, -a]  */
4041           n_low = range_binop (MINUS_EXPR, exp_type,
4042                                build_int_cst (exp_type, 0),
4043                                0, high, 1);
4044           n_high = range_binop (MINUS_EXPR, exp_type,
4045                                 build_int_cst (exp_type, 0),
4046                                 0, low, 0);
4047           low = n_low, high = n_high;
4048           exp = arg0;
4049           continue;
4050
4051         case BIT_NOT_EXPR:
4052           /* ~ X -> -X - 1  */
4053           exp = build2 (MINUS_EXPR, exp_type, negate_expr (arg0),
4054                         build_int_cst (exp_type, 1));
4055           continue;
4056
4057         case PLUS_EXPR:  case MINUS_EXPR:
4058           if (TREE_CODE (arg1) != INTEGER_CST)
4059             break;
4060
4061           /* If flag_wrapv and ARG0_TYPE is signed, then we cannot
4062              move a constant to the other side.  */
4063           if (!TYPE_UNSIGNED (arg0_type)
4064               && !TYPE_OVERFLOW_UNDEFINED (arg0_type))
4065             break;
4066
4067           /* If EXP is signed, any overflow in the computation is undefined,
4068              so we don't worry about it so long as our computations on
4069              the bounds don't overflow.  For unsigned, overflow is defined
4070              and this is exactly the right thing.  */
4071           n_low = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4072                                arg0_type, low, 0, arg1, 0);
4073           n_high = range_binop (code == MINUS_EXPR ? PLUS_EXPR : MINUS_EXPR,
4074                                 arg0_type, high, 1, arg1, 0);
4075           if ((n_low != 0 && TREE_OVERFLOW (n_low))
4076               || (n_high != 0 && TREE_OVERFLOW (n_high)))
4077             break;
4078
4079           if (TYPE_OVERFLOW_UNDEFINED (arg0_type))
4080             *strict_overflow_p = true;
4081
4082           /* Check for an unsigned range which has wrapped around the maximum
4083              value thus making n_high < n_low, and normalize it.  */
4084           if (n_low && n_high && tree_int_cst_lt (n_high, n_low))
4085             {
4086               low = range_binop (PLUS_EXPR, arg0_type, n_high, 0,
4087                                  integer_one_node, 0);
4088               high = range_binop (MINUS_EXPR, arg0_type, n_low, 0,
4089                                   integer_one_node, 0);
4090
4091               /* If the range is of the form +/- [ x+1, x ], we won't
4092                  be able to normalize it.  But then, it represents the
4093                  whole range or the empty set, so make it
4094                  +/- [ -, - ].  */
4095               if (tree_int_cst_equal (n_low, low)
4096                   && tree_int_cst_equal (n_high, high))
4097                 low = high = 0;
4098               else
4099                 in_p = ! in_p;
4100             }
4101           else
4102             low = n_low, high = n_high;
4103
4104           exp = arg0;
4105           continue;
4106
4107         case NOP_EXPR:  case NON_LVALUE_EXPR:  case CONVERT_EXPR:
4108           if (TYPE_PRECISION (arg0_type) > TYPE_PRECISION (exp_type))
4109             break;
4110
4111           if (! INTEGRAL_TYPE_P (arg0_type)
4112               || (low != 0 && ! int_fits_type_p (low, arg0_type))
4113               || (high != 0 && ! int_fits_type_p (high, arg0_type)))
4114             break;
4115
4116           n_low = low, n_high = high;
4117
4118           if (n_low != 0)
4119             n_low = fold_convert (arg0_type, n_low);
4120
4121           if (n_high != 0)
4122             n_high = fold_convert (arg0_type, n_high);
4123
4124
4125           /* If we're converting arg0 from an unsigned type, to exp,
4126              a signed type,  we will be doing the comparison as unsigned.
4127              The tests above have already verified that LOW and HIGH
4128              are both positive.
4129
4130              So we have to ensure that we will handle large unsigned
4131              values the same way that the current signed bounds treat
4132              negative values.  */
4133
4134           if (!TYPE_UNSIGNED (exp_type) && TYPE_UNSIGNED (arg0_type))
4135             {
4136               tree high_positive;
4137               tree equiv_type = lang_hooks.types.type_for_mode
4138                 (TYPE_MODE (arg0_type), 1);
4139
4140               /* A range without an upper bound is, naturally, unbounded.
4141                  Since convert would have cropped a very large value, use
4142                  the max value for the destination type.  */
4143               high_positive
4144                 = TYPE_MAX_VALUE (equiv_type) ? TYPE_MAX_VALUE (equiv_type)
4145                 : TYPE_MAX_VALUE (arg0_type);
4146
4147               if (TYPE_PRECISION (exp_type) == TYPE_PRECISION (arg0_type))
4148                 high_positive = fold_build2 (RSHIFT_EXPR, arg0_type,
4149                                              fold_convert (arg0_type,
4150                                                            high_positive),
4151                                              fold_convert (arg0_type,
4152                                                            integer_one_node));
4153
4154               /* If the low bound is specified, "and" the range with the
4155                  range for which the original unsigned value will be
4156                  positive.  */
4157               if (low != 0)
4158                 {
4159                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
4160                                       1, n_low, n_high, 1,
4161                                       fold_convert (arg0_type,
4162                                                     integer_zero_node),
4163                                       high_positive))
4164                     break;
4165
4166                   in_p = (n_in_p == in_p);
4167                 }
4168               else
4169                 {
4170                   /* Otherwise, "or" the range with the range of the input
4171                      that will be interpreted as negative.  */
4172                   if (! merge_ranges (&n_in_p, &n_low, &n_high,
4173                                       0, n_low, n_high, 1,
4174                                       fold_convert (arg0_type,
4175                                                     integer_zero_node),
4176                                       high_positive))
4177                     break;
4178
4179                   in_p = (in_p != n_in_p);
4180                 }
4181             }
4182
4183           exp = arg0;
4184           low = n_low, high = n_high;
4185           continue;
4186
4187         default:
4188           break;
4189         }
4190
4191       break;
4192     }
4193
4194   /* If EXP is a constant, we can evaluate whether this is true or false.  */
4195   if (TREE_CODE (exp) == INTEGER_CST)
4196     {
4197       in_p = in_p == (integer_onep (range_binop (GE_EXPR, integer_type_node,
4198                                                  exp, 0, low, 0))
4199                       && integer_onep (range_binop (LE_EXPR, integer_type_node,
4200                                                     exp, 1, high, 1)));
4201       low = high = 0;
4202       exp = 0;
4203     }
4204
4205   *pin_p = in_p, *plow = low, *phigh = high;
4206   return exp;
4207 }
4208 \f
4209 /* Given a range, LOW, HIGH, and IN_P, an expression, EXP, and a result
4210    type, TYPE, return an expression to test if EXP is in (or out of, depending
4211    on IN_P) the range.  Return 0 if the test couldn't be created.  */
4212
4213 static tree
4214 build_range_check (tree type, tree exp, int in_p, tree low, tree high)
4215 {
4216   tree etype = TREE_TYPE (exp);
4217   tree value;
4218
4219 #ifdef HAVE_canonicalize_funcptr_for_compare
4220   /* Disable this optimization for function pointer expressions
4221      on targets that require function pointer canonicalization.  */
4222   if (HAVE_canonicalize_funcptr_for_compare
4223       && TREE_CODE (etype) == POINTER_TYPE
4224       && TREE_CODE (TREE_TYPE (etype)) == FUNCTION_TYPE)
4225     return NULL_TREE;
4226 #endif
4227
4228   if (! in_p)
4229     {
4230       value = build_range_check (type, exp, 1, low, high);
4231       if (value != 0)
4232         return invert_truthvalue (value);
4233
4234       return 0;
4235     }
4236
4237   if (low == 0 && high == 0)
4238     return build_int_cst (type, 1);
4239
4240   if (low == 0)
4241     return fold_build2 (LE_EXPR, type, exp,
4242                         fold_convert (etype, high));
4243
4244   if (high == 0)
4245     return fold_build2 (GE_EXPR, type, exp,
4246                         fold_convert (etype, low));
4247
4248   if (operand_equal_p (low, high, 0))
4249     return fold_build2 (EQ_EXPR, type, exp,
4250                         fold_convert (etype, low));
4251
4252   if (integer_zerop (low))
4253     {
4254       if (! TYPE_UNSIGNED (etype))
4255         {
4256           etype = lang_hooks.types.unsigned_type (etype);
4257           high = fold_convert (etype, high);
4258           exp = fold_convert (etype, exp);
4259         }
4260       return build_range_check (type, exp, 1, 0, high);
4261     }
4262
4263   /* Optimize (c>=1) && (c<=127) into (signed char)c > 0.  */
4264   if (integer_onep (low) && TREE_CODE (high) == INTEGER_CST)
4265     {
4266       unsigned HOST_WIDE_INT lo;
4267       HOST_WIDE_INT hi;
4268       int prec;
4269
4270       prec = TYPE_PRECISION (etype);
4271       if (prec <= HOST_BITS_PER_WIDE_INT)
4272         {
4273           hi = 0;
4274           lo = ((unsigned HOST_WIDE_INT) 1 << (prec - 1)) - 1;
4275         }
4276       else
4277         {
4278           hi = ((HOST_WIDE_INT) 1 << (prec - HOST_BITS_PER_WIDE_INT - 1)) - 1;
4279           lo = (unsigned HOST_WIDE_INT) -1;
4280         }
4281
4282       if (TREE_INT_CST_HIGH (high) == hi && TREE_INT_CST_LOW (high) == lo)
4283         {
4284           if (TYPE_UNSIGNED (etype))
4285             {
4286               etype = lang_hooks.types.signed_type (etype);
4287               exp = fold_convert (etype, exp);
4288             }
4289           return fold_build2 (GT_EXPR, type, exp,
4290                               build_int_cst (etype, 0));
4291         }
4292     }
4293
4294   /* Optimize (c>=low) && (c<=high) into (c-low>=0) && (c-low<=high-low).
4295      This requires wrap-around arithmetics for the type of the expression.  */
4296   switch (TREE_CODE (etype))
4297     {
4298     case INTEGER_TYPE:
4299       /* There is no requirement that LOW be within the range of ETYPE
4300          if the latter is a subtype.  It must, however, be within the base
4301          type of ETYPE.  So be sure we do the subtraction in that type.  */
4302       if (TREE_TYPE (etype))
4303         etype = TREE_TYPE (etype);
4304       break;
4305
4306     case ENUMERAL_TYPE:
4307     case BOOLEAN_TYPE:
4308       etype = lang_hooks.types.type_for_size (TYPE_PRECISION (etype),
4309                                               TYPE_UNSIGNED (etype));
4310       break;
4311
4312     default:
4313       break;
4314     }
4315
4316   /* If we don't have wrap-around arithmetics upfront, try to force it.  */
4317   if (TREE_CODE (etype) == INTEGER_TYPE
4318       && !TYPE_OVERFLOW_WRAPS (etype))
4319     {
4320       tree utype, minv, maxv;
4321
4322       /* Check if (unsigned) INT_MAX + 1 == (unsigned) INT_MIN
4323          for the type in question, as we rely on this here.  */
4324       utype = lang_hooks.types.unsigned_type (etype);
4325       maxv = fold_convert (utype, TYPE_MAX_VALUE (etype));
4326       maxv = range_binop (PLUS_EXPR, NULL_TREE, maxv, 1,
4327                           integer_one_node, 1);
4328       minv = fold_convert (utype, TYPE_MIN_VALUE (etype));
4329
4330       if (integer_zerop (range_binop (NE_EXPR, integer_type_node,
4331                                       minv, 1, maxv, 1)))
4332         etype = utype;
4333       else
4334         return 0;
4335     }
4336
4337   high = fold_convert (etype, high);
4338   low = fold_convert (etype, low);
4339   exp = fold_convert (etype, exp);
4340
4341   value = const_binop (MINUS_EXPR, high, low, 0);
4342
4343   if (value != 0 && !TREE_OVERFLOW (value))
4344     return build_range_check (type,
4345                               fold_build2 (MINUS_EXPR, etype, exp, low),
4346                               1, build_int_cst (etype, 0), value);
4347
4348   return 0;
4349 }
4350 \f
4351 /* Return the predecessor of VAL in its type, handling the infinite case.  */
4352
4353 static tree
4354 range_predecessor (tree val)
4355 {
4356   tree type = TREE_TYPE (val);
4357
4358   if (INTEGRAL_TYPE_P (type)
4359       && operand_equal_p (val, TYPE_MIN_VALUE (type), 0))
4360     return 0;
4361   else
4362     return range_binop (MINUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4363 }
4364
4365 /* Return the successor of VAL in its type, handling the infinite case.  */
4366
4367 static tree
4368 range_successor (tree val)
4369 {
4370   tree type = TREE_TYPE (val);
4371
4372   if (INTEGRAL_TYPE_P (type)
4373       && operand_equal_p (val, TYPE_MAX_VALUE (type), 0))
4374     return 0;
4375   else
4376     return range_binop (PLUS_EXPR, NULL_TREE, val, 0, integer_one_node, 0);
4377 }
4378
4379 /* Given two ranges, see if we can merge them into one.  Return 1 if we
4380    can, 0 if we can't.  Set the output range into the specified parameters.  */
4381
4382 static int
4383 merge_ranges (int *pin_p, tree *plow, tree *phigh, int in0_p, tree low0,
4384               tree high0, int in1_p, tree low1, tree high1)
4385 {
4386   int no_overlap;
4387   int subset;
4388   int temp;
4389   tree tem;
4390   int in_p;
4391   tree low, high;
4392   int lowequal = ((low0 == 0 && low1 == 0)
4393                   || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4394                                                 low0, 0, low1, 0)));
4395   int highequal = ((high0 == 0 && high1 == 0)
4396                    || integer_onep (range_binop (EQ_EXPR, integer_type_node,
4397                                                  high0, 1, high1, 1)));
4398
4399   /* Make range 0 be the range that starts first, or ends last if they
4400      start at the same value.  Swap them if it isn't.  */
4401   if (integer_onep (range_binop (GT_EXPR, integer_type_node,
4402                                  low0, 0, low1, 0))
4403       || (lowequal
4404           && integer_onep (range_binop (GT_EXPR, integer_type_node,
4405                                         high1, 1, high0, 1))))
4406     {
4407       temp = in0_p, in0_p = in1_p, in1_p = temp;
4408       tem = low0, low0 = low1, low1 = tem;
4409       tem = high0, high0 = high1, high1 = tem;
4410     }
4411
4412   /* Now flag two cases, whether the ranges are disjoint or whether the
4413      second range is totally subsumed in the first.  Note that the tests
4414      below are simplified by the ones above.  */
4415   no_overlap = integer_onep (range_binop (LT_EXPR, integer_type_node,
4416                                           high0, 1, low1, 0));
4417   subset = integer_onep (range_binop (LE_EXPR, integer_type_node,
4418                                       high1, 1, high0, 1));
4419
4420   /* We now have four cases, depending on whether we are including or
4421      excluding the two ranges.  */
4422   if (in0_p && in1_p)
4423     {
4424       /* If they don't overlap, the result is false.  If the second range
4425          is a subset it is the result.  Otherwise, the range is from the start
4426          of the second to the end of the first.  */
4427       if (no_overlap)
4428         in_p = 0, low = high = 0;
4429       else if (subset)
4430         in_p = 1, low = low1, high = high1;
4431       else
4432         in_p = 1, low = low1, high = high0;
4433     }
4434
4435   else if (in0_p && ! in1_p)
4436     {
4437       /* If they don't overlap, the result is the first range.  If they are
4438          equal, the result is false.  If the second range is a subset of the
4439          first, and the ranges begin at the same place, we go from just after
4440          the end of the second range to the end of the first.  If the second
4441          range is not a subset of the first, or if it is a subset and both
4442          ranges end at the same place, the range starts at the start of the
4443          first range and ends just before the second range.
4444          Otherwise, we can't describe this as a single range.  */
4445       if (no_overlap)
4446         in_p = 1, low = low0, high = high0;
4447       else if (lowequal && highequal)
4448         in_p = 0, low = high = 0;
4449       else if (subset && lowequal)
4450         {
4451           low = range_successor (high1);
4452           high = high0;
4453           in_p = 1;
4454           if (low == 0)
4455             {
4456               /* We are in the weird situation where high0 > high1 but
4457                  high1 has no successor.  Punt.  */
4458               return 0;
4459             }
4460         }
4461       else if (! subset || highequal)
4462         {
4463           low = low0;
4464           high = range_predecessor (low1);
4465           in_p = 1;
4466           if (high == 0)
4467             {
4468               /* low0 < low1 but low1 has no predecessor.  Punt.  */
4469               return 0;
4470             }
4471         }
4472       else
4473         return 0;
4474     }
4475
4476   else if (! in0_p && in1_p)
4477     {
4478       /* If they don't overlap, the result is the second range.  If the second
4479          is a subset of the first, the result is false.  Otherwise,
4480          the range starts just after the first range and ends at the
4481          end of the second.  */
4482       if (no_overlap)
4483         in_p = 1, low = low1, high = high1;
4484       else if (subset || highequal)
4485         in_p = 0, low = high = 0;
4486       else
4487         {
4488           low = range_successor (high0);
4489           high = high1;
4490           in_p = 1;
4491           if (low == 0)
4492             {
4493               /* high1 > high0 but high0 has no successor.  Punt.  */
4494               return 0;
4495             }
4496         }
4497     }
4498
4499   else
4500     {
4501       /* The case where we are excluding both ranges.  Here the complex case
4502          is if they don't overlap.  In that case, the only time we have a
4503          range is if they are adjacent.  If the second is a subset of the
4504          first, the result is the first.  Otherwise, the range to exclude
4505          starts at the beginning of the first range and ends at the end of the
4506          second.  */
4507       if (no_overlap)
4508         {
4509           if (integer_onep (range_binop (EQ_EXPR, integer_type_node,
4510                                          range_successor (high0),
4511                                          1, low1, 0)))
4512             in_p = 0, low = low0, high = high1;
4513           else
4514             {
4515               /* Canonicalize - [min, x] into - [-, x].  */
4516               if (low0 && TREE_CODE (low0) == INTEGER_CST)
4517                 switch (TREE_CODE (TREE_TYPE (low0)))
4518                   {
4519                   case ENUMERAL_TYPE:
4520                     if (TYPE_PRECISION (TREE_TYPE (low0))
4521                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0))))
4522                       break;
4523                     /* FALLTHROUGH */
4524                   case INTEGER_TYPE:
4525                     if (tree_int_cst_equal (low0,
4526                                             TYPE_MIN_VALUE (TREE_TYPE (low0))))
4527                       low0 = 0;
4528                     break;
4529                   case POINTER_TYPE:
4530                     if (TYPE_UNSIGNED (TREE_TYPE (low0))
4531                         && integer_zerop (low0))
4532                       low0 = 0;
4533                     break;
4534                   default:
4535                     break;
4536                   }
4537
4538               /* Canonicalize - [x, max] into - [x, -].  */
4539               if (high1 && TREE_CODE (high1) == INTEGER_CST)
4540                 switch (TREE_CODE (TREE_TYPE (high1)))
4541                   {
4542                   case ENUMERAL_TYPE:
4543                     if (TYPE_PRECISION (TREE_TYPE (high1))
4544                         != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1))))
4545                       break;
4546                     /* FALLTHROUGH */
4547                   case INTEGER_TYPE:
4548                     if (tree_int_cst_equal (high1,
4549                                             TYPE_MAX_VALUE (TREE_TYPE (high1))))
4550                       high1 = 0;
4551                     break;
4552                   case POINTER_TYPE:
4553                     if (TYPE_UNSIGNED (TREE_TYPE (high1))
4554                         && integer_zerop (range_binop (PLUS_EXPR, NULL_TREE,
4555                                                        high1, 1,
4556                                                        integer_one_node, 1)))
4557                       high1 = 0;
4558                     break;
4559                   default:
4560                     break;
4561                   }
4562
4563               /* The ranges might be also adjacent between the maximum and
4564                  minimum values of the given type.  For
4565                  - [{min,-}, x] and - [y, {max,-}] ranges where x + 1 < y
4566                  return + [x + 1, y - 1].  */
4567               if (low0 == 0 && high1 == 0)
4568                 {
4569                   low = range_successor (high0);
4570                   high = range_predecessor (low1);
4571                   if (low == 0 || high == 0)
4572                     return 0;
4573
4574                   in_p = 1;
4575                 }
4576               else
4577                 return 0;
4578             }
4579         }
4580       else if (subset)
4581         in_p = 0, low = low0, high = high0;
4582       else
4583         in_p = 0, low = low0, high = high1;
4584     }
4585
4586   *pin_p = in_p, *plow = low, *phigh = high;
4587   return 1;
4588 }
4589 \f
4590
4591 /* Subroutine of fold, looking inside expressions of the form
4592    A op B ? A : C, where ARG0, ARG1 and ARG2 are the three operands
4593    of the COND_EXPR.  This function is being used also to optimize
4594    A op B ? C : A, by reversing the comparison first.
4595
4596    Return a folded expression whose code is not a COND_EXPR
4597    anymore, or NULL_TREE if no folding opportunity is found.  */
4598
4599 static tree
4600 fold_cond_expr_with_comparison (tree type, tree arg0, tree arg1, tree arg2)
4601 {
4602   enum tree_code comp_code = TREE_CODE (arg0);
4603   tree arg00 = TREE_OPERAND (arg0, 0);
4604   tree arg01 = TREE_OPERAND (arg0, 1);
4605   tree arg1_type = TREE_TYPE (arg1);
4606   tree tem;
4607
4608   STRIP_NOPS (arg1);
4609   STRIP_NOPS (arg2);
4610
4611   /* If we have A op 0 ? A : -A, consider applying the following
4612      transformations:
4613
4614      A == 0? A : -A    same as -A
4615      A != 0? A : -A    same as A
4616      A >= 0? A : -A    same as abs (A)
4617      A > 0?  A : -A    same as abs (A)
4618      A <= 0? A : -A    same as -abs (A)
4619      A < 0?  A : -A    same as -abs (A)
4620
4621      None of these transformations work for modes with signed
4622      zeros.  If A is +/-0, the first two transformations will
4623      change the sign of the result (from +0 to -0, or vice
4624      versa).  The last four will fix the sign of the result,
4625      even though the original expressions could be positive or
4626      negative, depending on the sign of A.
4627
4628      Note that all these transformations are correct if A is
4629      NaN, since the two alternatives (A and -A) are also NaNs.  */
4630   if ((FLOAT_TYPE_P (TREE_TYPE (arg01))
4631        ? real_zerop (arg01)
4632        : integer_zerop (arg01))
4633       && ((TREE_CODE (arg2) == NEGATE_EXPR
4634            && operand_equal_p (TREE_OPERAND (arg2, 0), arg1, 0))
4635              /* In the case that A is of the form X-Y, '-A' (arg2) may
4636                 have already been folded to Y-X, check for that. */
4637           || (TREE_CODE (arg1) == MINUS_EXPR
4638               && TREE_CODE (arg2) == MINUS_EXPR
4639               && operand_equal_p (TREE_OPERAND (arg1, 0),
4640                                   TREE_OPERAND (arg2, 1), 0)
4641               && operand_equal_p (TREE_OPERAND (arg1, 1),
4642                                   TREE_OPERAND (arg2, 0), 0))))
4643     switch (comp_code)
4644       {
4645       case EQ_EXPR:
4646       case UNEQ_EXPR:
4647         tem = fold_convert (arg1_type, arg1);
4648         return pedantic_non_lvalue (fold_convert (type, negate_expr (tem)));
4649       case NE_EXPR:
4650       case LTGT_EXPR:
4651         return pedantic_non_lvalue (fold_convert (type, arg1));
4652       case UNGE_EXPR:
4653       case UNGT_EXPR:
4654         if (flag_trapping_math)
4655           break;
4656         /* Fall through.  */
4657       case GE_EXPR:
4658       case GT_EXPR:
4659         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4660           arg1 = fold_convert (lang_hooks.types.signed_type
4661                                (TREE_TYPE (arg1)), arg1);
4662         tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
4663         return pedantic_non_lvalue (fold_convert (type, tem));
4664       case UNLE_EXPR:
4665       case UNLT_EXPR:
4666         if (flag_trapping_math)
4667           break;
4668       case LE_EXPR:
4669       case LT_EXPR:
4670         if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
4671           arg1 = fold_convert (lang_hooks.types.signed_type
4672                                (TREE_TYPE (arg1)), arg1);
4673         tem = fold_build1 (ABS_EXPR, TREE_TYPE (arg1), arg1);
4674         return negate_expr (fold_convert (type, tem));
4675       default:
4676         gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4677         break;
4678       }
4679
4680   /* A != 0 ? A : 0 is simply A, unless A is -0.  Likewise
4681      A == 0 ? A : 0 is always 0 unless A is -0.  Note that
4682      both transformations are correct when A is NaN: A != 0
4683      is then true, and A == 0 is false.  */
4684
4685   if (integer_zerop (arg01) && integer_zerop (arg2))
4686     {
4687       if (comp_code == NE_EXPR)
4688         return pedantic_non_lvalue (fold_convert (type, arg1));
4689       else if (comp_code == EQ_EXPR)
4690         return build_int_cst (type, 0);
4691     }
4692
4693   /* Try some transformations of A op B ? A : B.
4694
4695      A == B? A : B    same as B
4696      A != B? A : B    same as A
4697      A >= B? A : B    same as max (A, B)
4698      A > B?  A : B    same as max (B, A)
4699      A <= B? A : B    same as min (A, B)
4700      A < B?  A : B    same as min (B, A)
4701
4702      As above, these transformations don't work in the presence
4703      of signed zeros.  For example, if A and B are zeros of
4704      opposite sign, the first two transformations will change
4705      the sign of the result.  In the last four, the original
4706      expressions give different results for (A=+0, B=-0) and
4707      (A=-0, B=+0), but the transformed expressions do not.
4708
4709      The first two transformations are correct if either A or B
4710      is a NaN.  In the first transformation, the condition will
4711      be false, and B will indeed be chosen.  In the case of the
4712      second transformation, the condition A != B will be true,
4713      and A will be chosen.
4714
4715      The conversions to max() and min() are not correct if B is
4716      a number and A is not.  The conditions in the original
4717      expressions will be false, so all four give B.  The min()
4718      and max() versions would give a NaN instead.  */
4719   if (operand_equal_for_comparison_p (arg01, arg2, arg00)
4720       /* Avoid these transformations if the COND_EXPR may be used
4721          as an lvalue in the C++ front-end.  PR c++/19199.  */
4722       && (in_gimple_form
4723           || (strcmp (lang_hooks.name, "GNU C++") != 0
4724               && strcmp (lang_hooks.name, "GNU Objective-C++") != 0)
4725           || ! maybe_lvalue_p (arg1)
4726           || ! maybe_lvalue_p (arg2)))
4727     {
4728       tree comp_op0 = arg00;
4729       tree comp_op1 = arg01;
4730       tree comp_type = TREE_TYPE (comp_op0);
4731
4732       /* Avoid adding NOP_EXPRs in case this is an lvalue.  */
4733       if (TYPE_MAIN_VARIANT (comp_type) == TYPE_MAIN_VARIANT (type))
4734         {
4735           comp_type = type;
4736           comp_op0 = arg1;
4737           comp_op1 = arg2;
4738         }
4739
4740       switch (comp_code)
4741         {
4742         case EQ_EXPR:
4743           return pedantic_non_lvalue (fold_convert (type, arg2));
4744         case NE_EXPR:
4745           return pedantic_non_lvalue (fold_convert (type, arg1));
4746         case LE_EXPR:
4747         case LT_EXPR:
4748         case UNLE_EXPR:
4749         case UNLT_EXPR:
4750           /* In C++ a ?: expression can be an lvalue, so put the
4751              operand which will be used if they are equal first
4752              so that we can convert this back to the
4753              corresponding COND_EXPR.  */
4754           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4755             {
4756               comp_op0 = fold_convert (comp_type, comp_op0);
4757               comp_op1 = fold_convert (comp_type, comp_op1);
4758               tem = (comp_code == LE_EXPR || comp_code == UNLE_EXPR)
4759                     ? fold_build2 (MIN_EXPR, comp_type, comp_op0, comp_op1)
4760                     : fold_build2 (MIN_EXPR, comp_type, comp_op1, comp_op0);
4761               return pedantic_non_lvalue (fold_convert (type, tem));
4762             }
4763           break;
4764         case GE_EXPR:
4765         case GT_EXPR:
4766         case UNGE_EXPR:
4767         case UNGT_EXPR:
4768           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4769             {
4770               comp_op0 = fold_convert (comp_type, comp_op0);
4771               comp_op1 = fold_convert (comp_type, comp_op1);
4772               tem = (comp_code == GE_EXPR || comp_code == UNGE_EXPR)
4773                     ? fold_build2 (MAX_EXPR, comp_type, comp_op0, comp_op1)
4774                     : fold_build2 (MAX_EXPR, comp_type, comp_op1, comp_op0);
4775               return pedantic_non_lvalue (fold_convert (type, tem));
4776             }
4777           break;
4778         case UNEQ_EXPR:
4779           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4780             return pedantic_non_lvalue (fold_convert (type, arg2));
4781           break;
4782         case LTGT_EXPR:
4783           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1))))
4784             return pedantic_non_lvalue (fold_convert (type, arg1));
4785           break;
4786         default:
4787           gcc_assert (TREE_CODE_CLASS (comp_code) == tcc_comparison);
4788           break;
4789         }
4790     }
4791
4792   /* If this is A op C1 ? A : C2 with C1 and C2 constant integers,
4793      we might still be able to simplify this.  For example,
4794      if C1 is one less or one more than C2, this might have started
4795      out as a MIN or MAX and been transformed by this function.
4796      Only good for INTEGER_TYPEs, because we need TYPE_MAX_VALUE.  */
4797
4798   if (INTEGRAL_TYPE_P (type)
4799       && TREE_CODE (arg01) == INTEGER_CST
4800       && TREE_CODE (arg2) == INTEGER_CST)
4801     switch (comp_code)
4802       {
4803       case EQ_EXPR:
4804         /* We can replace A with C1 in this case.  */
4805         arg1 = fold_convert (type, arg01);
4806         return fold_build3 (COND_EXPR, type, arg0, arg1, arg2);
4807
4808       case LT_EXPR:
4809         /* If C1 is C2 + 1, this is min(A, C2).  */
4810         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4811                                OEP_ONLY_CONST)
4812             && operand_equal_p (arg01,
4813                                 const_binop (PLUS_EXPR, arg2,
4814                                              integer_one_node, 0),
4815                                 OEP_ONLY_CONST))
4816           return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
4817                                                    type, arg1, arg2));
4818         break;
4819
4820       case LE_EXPR:
4821         /* If C1 is C2 - 1, this is min(A, C2).  */
4822         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4823                                OEP_ONLY_CONST)
4824             && operand_equal_p (arg01,
4825                                 const_binop (MINUS_EXPR, arg2,
4826                                              integer_one_node, 0),
4827                                 OEP_ONLY_CONST))
4828           return pedantic_non_lvalue (fold_build2 (MIN_EXPR,
4829                                                    type, arg1, arg2));
4830         break;
4831
4832       case GT_EXPR:
4833         /* If C1 is C2 - 1, this is max(A, C2).  */
4834         if (! operand_equal_p (arg2, TYPE_MIN_VALUE (type),
4835                                OEP_ONLY_CONST)
4836             && operand_equal_p (arg01,
4837                                 const_binop (MINUS_EXPR, arg2,
4838                                              integer_one_node, 0),
4839                                 OEP_ONLY_CONST))
4840           return pedantic_non_lvalue (fold_build2 (MAX_EXPR,
4841                                                    type, arg1, arg2));
4842         break;
4843
4844       case GE_EXPR:
4845         /* If C1 is C2 + 1, this is max(A, C2).  */
4846         if (! operand_equal_p (arg2, TYPE_MAX_VALUE (type),
4847                                OEP_ONLY_CONST)
4848             && operand_equal_p (arg01,
4849                                 const_binop (PLUS_EXPR, arg2,
4850                                              integer_one_node, 0),
4851                                 OEP_ONLY_CONST))
4852           return pedantic_non_lvalue (fold_build2 (MAX_EXPR,
4853                                                    type, arg1, arg2));
4854         break;
4855       case NE_EXPR:
4856         break;
4857       default:
4858         gcc_unreachable ();
4859       }
4860
4861   return NULL_TREE;
4862 }
4863
4864
4865 \f
4866 #ifndef LOGICAL_OP_NON_SHORT_CIRCUIT
4867 #define LOGICAL_OP_NON_SHORT_CIRCUIT (BRANCH_COST >= 2)
4868 #endif
4869
4870 /* EXP is some logical combination of boolean tests.  See if we can
4871    merge it into some range test.  Return the new tree if so.  */
4872
4873 static tree
4874 fold_range_test (enum tree_code code, tree type, tree op0, tree op1)
4875 {
4876   int or_op = (code == TRUTH_ORIF_EXPR
4877                || code == TRUTH_OR_EXPR);
4878   int in0_p, in1_p, in_p;
4879   tree low0, low1, low, high0, high1, high;
4880   bool strict_overflow_p = false;
4881   tree lhs = make_range (op0, &in0_p, &low0, &high0, &strict_overflow_p);
4882   tree rhs = make_range (op1, &in1_p, &low1, &high1, &strict_overflow_p);
4883   tree tem;
4884   const char * const warnmsg = G_("assuming signed overflow does not occur "
4885                                   "when simplifying range test");
4886
4887   /* If this is an OR operation, invert both sides; we will invert
4888      again at the end.  */
4889   if (or_op)
4890     in0_p = ! in0_p, in1_p = ! in1_p;
4891
4892   /* If both expressions are the same, if we can merge the ranges, and we
4893      can build the range test, return it or it inverted.  If one of the
4894      ranges is always true or always false, consider it to be the same
4895      expression as the other.  */
4896   if ((lhs == 0 || rhs == 0 || operand_equal_p (lhs, rhs, 0))
4897       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
4898                        in1_p, low1, high1)
4899       && 0 != (tem = (build_range_check (type,
4900                                          lhs != 0 ? lhs
4901                                          : rhs != 0 ? rhs : integer_zero_node,
4902                                          in_p, low, high))))
4903     {
4904       if (strict_overflow_p)
4905         fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_COMPARISON);
4906       return or_op ? invert_truthvalue (tem) : tem;
4907     }
4908
4909   /* On machines where the branch cost is expensive, if this is a
4910      short-circuited branch and the underlying object on both sides
4911      is the same, make a non-short-circuit operation.  */
4912   else if (LOGICAL_OP_NON_SHORT_CIRCUIT
4913            && lhs != 0 && rhs != 0
4914            && (code == TRUTH_ANDIF_EXPR
4915                || code == TRUTH_ORIF_EXPR)
4916            && operand_equal_p (lhs, rhs, 0))
4917     {
4918       /* If simple enough, just rewrite.  Otherwise, make a SAVE_EXPR
4919          unless we are at top level or LHS contains a PLACEHOLDER_EXPR, in
4920          which cases we can't do this.  */
4921       if (simple_operand_p (lhs))
4922         return build2 (code == TRUTH_ANDIF_EXPR
4923                        ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4924                        type, op0, op1);
4925
4926       else if (lang_hooks.decls.global_bindings_p () == 0
4927                && ! CONTAINS_PLACEHOLDER_P (lhs))
4928         {
4929           tree common = save_expr (lhs);
4930
4931           if (0 != (lhs = build_range_check (type, common,
4932                                              or_op ? ! in0_p : in0_p,
4933                                              low0, high0))
4934               && (0 != (rhs = build_range_check (type, common,
4935                                                  or_op ? ! in1_p : in1_p,
4936                                                  low1, high1))))
4937             {
4938               if (strict_overflow_p)
4939                 fold_overflow_warning (warnmsg,
4940                                        WARN_STRICT_OVERFLOW_COMPARISON);
4941               return build2 (code == TRUTH_ANDIF_EXPR
4942                              ? TRUTH_AND_EXPR : TRUTH_OR_EXPR,
4943                              type, lhs, rhs);
4944             }
4945         }
4946     }
4947
4948   return 0;
4949 }
4950 \f
4951 /* Subroutine for fold_truthop: C is an INTEGER_CST interpreted as a P
4952    bit value.  Arrange things so the extra bits will be set to zero if and
4953    only if C is signed-extended to its full width.  If MASK is nonzero,
4954    it is an INTEGER_CST that should be AND'ed with the extra bits.  */
4955
4956 static tree
4957 unextend (tree c, int p, int unsignedp, tree mask)
4958 {
4959   tree type = TREE_TYPE (c);
4960   int modesize = GET_MODE_BITSIZE (TYPE_MODE (type));
4961   tree temp;
4962
4963   if (p == modesize || unsignedp)
4964     return c;
4965
4966   /* We work by getting just the sign bit into the low-order bit, then
4967      into the high-order bit, then sign-extend.  We then XOR that value
4968      with C.  */
4969   temp = const_binop (RSHIFT_EXPR, c, size_int (p - 1), 0);
4970   temp = const_binop (BIT_AND_EXPR, temp, size_int (1), 0);
4971
4972   /* We must use a signed type in order to get an arithmetic right shift.
4973      However, we must also avoid introducing accidental overflows, so that
4974      a subsequent call to integer_zerop will work.  Hence we must
4975      do the type conversion here.  At this point, the constant is either
4976      zero or one, and the conversion to a signed type can never overflow.
4977      We could get an overflow if this conversion is done anywhere else.  */
4978   if (TYPE_UNSIGNED (type))
4979     temp = fold_convert (lang_hooks.types.signed_type (type), temp);
4980
4981   temp = const_binop (LSHIFT_EXPR, temp, size_int (modesize - 1), 0);
4982   temp = const_binop (RSHIFT_EXPR, temp, size_int (modesize - p - 1), 0);
4983   if (mask != 0)
4984     temp = const_binop (BIT_AND_EXPR, temp,
4985                         fold_convert (TREE_TYPE (c), mask), 0);
4986   /* If necessary, convert the type back to match the type of C.  */
4987   if (TYPE_UNSIGNED (type))
4988     temp = fold_convert (type, temp);
4989
4990   return fold_convert (type, const_binop (BIT_XOR_EXPR, c, temp, 0));
4991 }
4992 \f
4993 /* Find ways of folding logical expressions of LHS and RHS:
4994    Try to merge two comparisons to the same innermost item.
4995    Look for range tests like "ch >= '0' && ch <= '9'".
4996    Look for combinations of simple terms on machines with expensive branches
4997    and evaluate the RHS unconditionally.
4998
4999    For example, if we have p->a == 2 && p->b == 4 and we can make an
5000    object large enough to span both A and B, we can do this with a comparison
5001    against the object ANDed with the a mask.
5002
5003    If we have p->a == q->a && p->b == q->b, we may be able to use bit masking
5004    operations to do this with one comparison.
5005
5006    We check for both normal comparisons and the BIT_AND_EXPRs made this by
5007    function and the one above.
5008
5009    CODE is the logical operation being done.  It can be TRUTH_ANDIF_EXPR,
5010    TRUTH_AND_EXPR, TRUTH_ORIF_EXPR, or TRUTH_OR_EXPR.
5011
5012    TRUTH_TYPE is the type of the logical operand and LHS and RHS are its
5013    two operands.
5014
5015    We return the simplified tree or 0 if no optimization is possible.  */
5016
5017 static tree
5018 fold_truthop (enum tree_code code, tree truth_type, tree lhs, tree rhs)
5019 {
5020   /* If this is the "or" of two comparisons, we can do something if
5021      the comparisons are NE_EXPR.  If this is the "and", we can do something
5022      if the comparisons are EQ_EXPR.  I.e.,
5023         (a->b == 2 && a->c == 4) can become (a->new == NEW).
5024
5025      WANTED_CODE is this operation code.  For single bit fields, we can
5026      convert EQ_EXPR to NE_EXPR so we need not reject the "wrong"
5027      comparison for one-bit fields.  */
5028
5029   enum tree_code wanted_code;
5030   enum tree_code lcode, rcode;
5031   tree ll_arg, lr_arg, rl_arg, rr_arg;
5032   tree ll_inner, lr_inner, rl_inner, rr_inner;
5033   HOST_WIDE_INT ll_bitsize, ll_bitpos, lr_bitsize, lr_bitpos;
5034   HOST_WIDE_INT rl_bitsize, rl_bitpos, rr_bitsize, rr_bitpos;
5035   HOST_WIDE_INT xll_bitpos, xlr_bitpos, xrl_bitpos, xrr_bitpos;
5036   HOST_WIDE_INT lnbitsize, lnbitpos, rnbitsize, rnbitpos;
5037   int ll_unsignedp, lr_unsignedp, rl_unsignedp, rr_unsignedp;
5038   enum machine_mode ll_mode, lr_mode, rl_mode, rr_mode;
5039   enum machine_mode lnmode, rnmode;
5040   tree ll_mask, lr_mask, rl_mask, rr_mask;
5041   tree ll_and_mask, lr_and_mask, rl_and_mask, rr_and_mask;
5042   tree l_const, r_const;
5043   tree lntype, rntype, result;
5044   int first_bit, end_bit;
5045   int volatilep;
5046   tree orig_lhs = lhs, orig_rhs = rhs;
5047   enum tree_code orig_code = code;
5048
5049   /* Start by getting the comparison codes.  Fail if anything is volatile.
5050      If one operand is a BIT_AND_EXPR with the constant one, treat it as if
5051      it were surrounded with a NE_EXPR.  */
5052
5053   if (TREE_SIDE_EFFECTS (lhs) || TREE_SIDE_EFFECTS (rhs))
5054     return 0;
5055
5056   lcode = TREE_CODE (lhs);
5057   rcode = TREE_CODE (rhs);
5058
5059   if (lcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (lhs, 1)))
5060     {
5061       lhs = build2 (NE_EXPR, truth_type, lhs,
5062                     build_int_cst (TREE_TYPE (lhs), 0));
5063       lcode = NE_EXPR;
5064     }
5065
5066   if (rcode == BIT_AND_EXPR && integer_onep (TREE_OPERAND (rhs, 1)))
5067     {
5068       rhs = build2 (NE_EXPR, truth_type, rhs,
5069                     build_int_cst (TREE_TYPE (rhs), 0));
5070       rcode = NE_EXPR;
5071     }
5072
5073   if (TREE_CODE_CLASS (lcode) != tcc_comparison
5074       || TREE_CODE_CLASS (rcode) != tcc_comparison)
5075     return 0;
5076
5077   ll_arg = TREE_OPERAND (lhs, 0);
5078   lr_arg = TREE_OPERAND (lhs, 1);
5079   rl_arg = TREE_OPERAND (rhs, 0);
5080   rr_arg = TREE_OPERAND (rhs, 1);
5081
5082   /* Simplify (x<y) && (x==y) into (x<=y) and related optimizations.  */
5083   if (simple_operand_p (ll_arg)
5084       && simple_operand_p (lr_arg))
5085     {
5086       tree result;
5087       if (operand_equal_p (ll_arg, rl_arg, 0)
5088           && operand_equal_p (lr_arg, rr_arg, 0))
5089         {
5090           result = combine_comparisons (code, lcode, rcode,
5091                                         truth_type, ll_arg, lr_arg);
5092           if (result)
5093             return result;
5094         }
5095       else if (operand_equal_p (ll_arg, rr_arg, 0)
5096                && operand_equal_p (lr_arg, rl_arg, 0))
5097         {
5098           result = combine_comparisons (code, lcode,
5099                                         swap_tree_comparison (rcode),
5100                                         truth_type, ll_arg, lr_arg);
5101           if (result)
5102             return result;
5103         }
5104     }
5105
5106   code = ((code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR)
5107           ? TRUTH_AND_EXPR : TRUTH_OR_EXPR);
5108
5109   /* If the RHS can be evaluated unconditionally and its operands are
5110      simple, it wins to evaluate the RHS unconditionally on machines
5111      with expensive branches.  In this case, this isn't a comparison
5112      that can be merged.  Avoid doing this if the RHS is a floating-point
5113      comparison since those can trap.  */
5114
5115   if (BRANCH_COST >= 2
5116       && ! FLOAT_TYPE_P (TREE_TYPE (rl_arg))
5117       && simple_operand_p (rl_arg)
5118       && simple_operand_p (rr_arg))
5119     {
5120       /* Convert (a != 0) || (b != 0) into (a | b) != 0.  */
5121       if (code == TRUTH_OR_EXPR
5122           && lcode == NE_EXPR && integer_zerop (lr_arg)
5123           && rcode == NE_EXPR && integer_zerop (rr_arg)
5124           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
5125         return build2 (NE_EXPR, truth_type,
5126                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5127                                ll_arg, rl_arg),
5128                        build_int_cst (TREE_TYPE (ll_arg), 0));
5129
5130       /* Convert (a == 0) && (b == 0) into (a | b) == 0.  */
5131       if (code == TRUTH_AND_EXPR
5132           && lcode == EQ_EXPR && integer_zerop (lr_arg)
5133           && rcode == EQ_EXPR && integer_zerop (rr_arg)
5134           && TREE_TYPE (ll_arg) == TREE_TYPE (rl_arg))
5135         return build2 (EQ_EXPR, truth_type,
5136                        build2 (BIT_IOR_EXPR, TREE_TYPE (ll_arg),
5137                                ll_arg, rl_arg),
5138                        build_int_cst (TREE_TYPE (ll_arg), 0));
5139
5140       if (LOGICAL_OP_NON_SHORT_CIRCUIT)
5141         {
5142           if (code != orig_code || lhs != orig_lhs || rhs != orig_rhs)
5143             return build2 (code, truth_type, lhs, rhs);
5144           return NULL_TREE;
5145         }
5146     }
5147
5148   /* See if the comparisons can be merged.  Then get all the parameters for
5149      each side.  */
5150
5151   if ((lcode != EQ_EXPR && lcode != NE_EXPR)
5152       || (rcode != EQ_EXPR && rcode != NE_EXPR))
5153     return 0;
5154
5155   volatilep = 0;
5156   ll_inner = decode_field_reference (ll_arg,
5157                                      &ll_bitsize, &ll_bitpos, &ll_mode,
5158                                      &ll_unsignedp, &volatilep, &ll_mask,
5159                                      &ll_and_mask);
5160   lr_inner = decode_field_reference (lr_arg,
5161                                      &lr_bitsize, &lr_bitpos, &lr_mode,
5162                                      &lr_unsignedp, &volatilep, &lr_mask,
5163                                      &lr_and_mask);
5164   rl_inner = decode_field_reference (rl_arg,
5165                                      &rl_bitsize, &rl_bitpos, &rl_mode,
5166                                      &rl_unsignedp, &volatilep, &rl_mask,
5167                                      &rl_and_mask);
5168   rr_inner = decode_field_reference (rr_arg,
5169                                      &rr_bitsize, &rr_bitpos, &rr_mode,
5170                                      &rr_unsignedp, &volatilep, &rr_mask,
5171                                      &rr_and_mask);
5172
5173   /* It must be true that the inner operation on the lhs of each
5174      comparison must be the same if we are to be able to do anything.
5175      Then see if we have constants.  If not, the same must be true for
5176      the rhs's.  */
5177   if (volatilep || ll_inner == 0 || rl_inner == 0
5178       || ! operand_equal_p (ll_inner, rl_inner, 0))
5179     return 0;
5180
5181   if (TREE_CODE (lr_arg) == INTEGER_CST
5182       && TREE_CODE (rr_arg) == INTEGER_CST)
5183     l_const = lr_arg, r_const = rr_arg;
5184   else if (lr_inner == 0 || rr_inner == 0
5185            || ! operand_equal_p (lr_inner, rr_inner, 0))
5186     return 0;
5187   else
5188     l_const = r_const = 0;
5189
5190   /* If either comparison code is not correct for our logical operation,
5191      fail.  However, we can convert a one-bit comparison against zero into
5192      the opposite comparison against that bit being set in the field.  */
5193
5194   wanted_code = (code == TRUTH_AND_EXPR ? EQ_EXPR : NE_EXPR);
5195   if (lcode != wanted_code)
5196     {
5197       if (l_const && integer_zerop (l_const) && integer_pow2p (ll_mask))
5198         {
5199           /* Make the left operand unsigned, since we are only interested
5200              in the value of one bit.  Otherwise we are doing the wrong
5201              thing below.  */
5202           ll_unsignedp = 1;
5203           l_const = ll_mask;
5204         }
5205       else
5206         return 0;
5207     }
5208
5209   /* This is analogous to the code for l_const above.  */
5210   if (rcode != wanted_code)
5211     {
5212       if (r_const && integer_zerop (r_const) && integer_pow2p (rl_mask))
5213         {
5214           rl_unsignedp = 1;
5215           r_const = rl_mask;
5216         }
5217       else
5218         return 0;
5219     }
5220
5221   /* After this point all optimizations will generate bit-field
5222      references, which we might not want.  */
5223   if (! lang_hooks.can_use_bit_fields_p ())
5224     return 0;
5225
5226   /* See if we can find a mode that contains both fields being compared on
5227      the left.  If we can't, fail.  Otherwise, update all constants and masks
5228      to be relative to a field of that size.  */
5229   first_bit = MIN (ll_bitpos, rl_bitpos);
5230   end_bit = MAX (ll_bitpos + ll_bitsize, rl_bitpos + rl_bitsize);
5231   lnmode = get_best_mode (end_bit - first_bit, first_bit,
5232                           TYPE_ALIGN (TREE_TYPE (ll_inner)), word_mode,
5233                           volatilep);
5234   if (lnmode == VOIDmode)
5235     return 0;
5236
5237   lnbitsize = GET_MODE_BITSIZE (lnmode);
5238   lnbitpos = first_bit & ~ (lnbitsize - 1);
5239   lntype = lang_hooks.types.type_for_size (lnbitsize, 1);
5240   xll_bitpos = ll_bitpos - lnbitpos, xrl_bitpos = rl_bitpos - lnbitpos;
5241
5242   if (BYTES_BIG_ENDIAN)
5243     {
5244       xll_bitpos = lnbitsize - xll_bitpos - ll_bitsize;
5245       xrl_bitpos = lnbitsize - xrl_bitpos - rl_bitsize;
5246     }
5247
5248   ll_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, ll_mask),
5249                          size_int (xll_bitpos), 0);
5250   rl_mask = const_binop (LSHIFT_EXPR, fold_convert (lntype, rl_mask),
5251                          size_int (xrl_bitpos), 0);
5252
5253   if (l_const)
5254     {
5255       l_const = fold_convert (lntype, l_const);
5256       l_const = unextend (l_const, ll_bitsize, ll_unsignedp, ll_and_mask);
5257       l_const = const_binop (LSHIFT_EXPR, l_const, size_int (xll_bitpos), 0);
5258       if (! integer_zerop (const_binop (BIT_AND_EXPR, l_const,
5259                                         fold_build1 (BIT_NOT_EXPR,
5260                                                      lntype, ll_mask),
5261                                         0)))
5262         {
5263           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5264
5265           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5266         }
5267     }
5268   if (r_const)
5269     {
5270       r_const = fold_convert (lntype, r_const);
5271       r_const = unextend (r_const, rl_bitsize, rl_unsignedp, rl_and_mask);
5272       r_const = const_binop (LSHIFT_EXPR, r_const, size_int (xrl_bitpos), 0);
5273       if (! integer_zerop (const_binop (BIT_AND_EXPR, r_const,
5274                                         fold_build1 (BIT_NOT_EXPR,
5275                                                      lntype, rl_mask),
5276                                         0)))
5277         {
5278           warning (0, "comparison is always %d", wanted_code == NE_EXPR);
5279
5280           return constant_boolean_node (wanted_code == NE_EXPR, truth_type);
5281         }
5282     }
5283
5284   /* If the right sides are not constant, do the same for it.  Also,
5285      disallow this optimization if a size or signedness mismatch occurs
5286      between the left and right sides.  */
5287   if (l_const == 0)
5288     {
5289       if (ll_bitsize != lr_bitsize || rl_bitsize != rr_bitsize
5290           || ll_unsignedp != lr_unsignedp || rl_unsignedp != rr_unsignedp
5291           /* Make sure the two fields on the right
5292              correspond to the left without being swapped.  */
5293           || ll_bitpos - rl_bitpos != lr_bitpos - rr_bitpos)
5294         return 0;
5295
5296       first_bit = MIN (lr_bitpos, rr_bitpos);
5297       end_bit = MAX (lr_bitpos + lr_bitsize, rr_bitpos + rr_bitsize);
5298       rnmode = get_best_mode (end_bit - first_bit, first_bit,
5299                               TYPE_ALIGN (TREE_TYPE (lr_inner)), word_mode,
5300                               volatilep);
5301       if (rnmode == VOIDmode)
5302         return 0;
5303
5304       rnbitsize = GET_MODE_BITSIZE (rnmode);
5305       rnbitpos = first_bit & ~ (rnbitsize - 1);
5306       rntype = lang_hooks.types.type_for_size (rnbitsize, 1);
5307       xlr_bitpos = lr_bitpos - rnbitpos, xrr_bitpos = rr_bitpos - rnbitpos;
5308
5309       if (BYTES_BIG_ENDIAN)
5310         {
5311           xlr_bitpos = rnbitsize - xlr_bitpos - lr_bitsize;
5312           xrr_bitpos = rnbitsize - xrr_bitpos - rr_bitsize;
5313         }
5314
5315       lr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, lr_mask),
5316                              size_int (xlr_bitpos), 0);
5317       rr_mask = const_binop (LSHIFT_EXPR, fold_convert (rntype, rr_mask),
5318                              size_int (xrr_bitpos), 0);
5319
5320       /* Make a mask that corresponds to both fields being compared.
5321          Do this for both items being compared.  If the operands are the
5322          same size and the bits being compared are in the same position
5323          then we can do this by masking both and comparing the masked
5324          results.  */
5325       ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5326       lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask, 0);
5327       if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
5328         {
5329           lhs = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5330                                     ll_unsignedp || rl_unsignedp);
5331           if (! all_ones_mask_p (ll_mask, lnbitsize))
5332             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
5333
5334           rhs = make_bit_field_ref (lr_inner, rntype, rnbitsize, rnbitpos,
5335                                     lr_unsignedp || rr_unsignedp);
5336           if (! all_ones_mask_p (lr_mask, rnbitsize))
5337             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
5338
5339           return build2 (wanted_code, truth_type, lhs, rhs);
5340         }
5341
5342       /* There is still another way we can do something:  If both pairs of
5343          fields being compared are adjacent, we may be able to make a wider
5344          field containing them both.
5345
5346          Note that we still must mask the lhs/rhs expressions.  Furthermore,
5347          the mask must be shifted to account for the shift done by
5348          make_bit_field_ref.  */
5349       if ((ll_bitsize + ll_bitpos == rl_bitpos
5350            && lr_bitsize + lr_bitpos == rr_bitpos)
5351           || (ll_bitpos == rl_bitpos + rl_bitsize
5352               && lr_bitpos == rr_bitpos + rr_bitsize))
5353         {
5354           tree type;
5355
5356           lhs = make_bit_field_ref (ll_inner, lntype, ll_bitsize + rl_bitsize,
5357                                     MIN (ll_bitpos, rl_bitpos), ll_unsignedp);
5358           rhs = make_bit_field_ref (lr_inner, rntype, lr_bitsize + rr_bitsize,
5359                                     MIN (lr_bitpos, rr_bitpos), lr_unsignedp);
5360
5361           ll_mask = const_binop (RSHIFT_EXPR, ll_mask,
5362                                  size_int (MIN (xll_bitpos, xrl_bitpos)), 0);
5363           lr_mask = const_binop (RSHIFT_EXPR, lr_mask,
5364                                  size_int (MIN (xlr_bitpos, xrr_bitpos)), 0);
5365
5366           /* Convert to the smaller type before masking out unwanted bits.  */
5367           type = lntype;
5368           if (lntype != rntype)
5369             {
5370               if (lnbitsize > rnbitsize)
5371                 {
5372                   lhs = fold_convert (rntype, lhs);
5373                   ll_mask = fold_convert (rntype, ll_mask);
5374                   type = rntype;
5375                 }
5376               else if (lnbitsize < rnbitsize)
5377                 {
5378                   rhs = fold_convert (lntype, rhs);
5379                   lr_mask = fold_convert (lntype, lr_mask);
5380                   type = lntype;
5381                 }
5382             }
5383
5384           if (! all_ones_mask_p (ll_mask, ll_bitsize + rl_bitsize))
5385             lhs = build2 (BIT_AND_EXPR, type, lhs, ll_mask);
5386
5387           if (! all_ones_mask_p (lr_mask, lr_bitsize + rr_bitsize))
5388             rhs = build2 (BIT_AND_EXPR, type, rhs, lr_mask);
5389
5390           return build2 (wanted_code, truth_type, lhs, rhs);
5391         }
5392
5393       return 0;
5394     }
5395
5396   /* Handle the case of comparisons with constants.  If there is something in
5397      common between the masks, those bits of the constants must be the same.
5398      If not, the condition is always false.  Test for this to avoid generating
5399      incorrect code below.  */
5400   result = const_binop (BIT_AND_EXPR, ll_mask, rl_mask, 0);
5401   if (! integer_zerop (result)
5402       && simple_cst_equal (const_binop (BIT_AND_EXPR, result, l_const, 0),
5403                            const_binop (BIT_AND_EXPR, result, r_const, 0)) != 1)
5404     {
5405       if (wanted_code == NE_EXPR)
5406         {
5407           warning (0, "%<or%> of unmatched not-equal tests is always 1");
5408           return constant_boolean_node (true, truth_type);
5409         }
5410       else
5411         {
5412           warning (0, "%<and%> of mutually exclusive equal-tests is always 0");
5413           return constant_boolean_node (false, truth_type);
5414         }
5415     }
5416
5417   /* Construct the expression we will return.  First get the component
5418      reference we will make.  Unless the mask is all ones the width of
5419      that field, perform the mask operation.  Then compare with the
5420      merged constant.  */
5421   result = make_bit_field_ref (ll_inner, lntype, lnbitsize, lnbitpos,
5422                                ll_unsignedp || rl_unsignedp);
5423
5424   ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask, 0);
5425   if (! all_ones_mask_p (ll_mask, lnbitsize))
5426     result = build2 (BIT_AND_EXPR, lntype, result, ll_mask);
5427
5428   return build2 (wanted_code, truth_type, result,
5429                  const_binop (BIT_IOR_EXPR, l_const, r_const, 0));
5430 }
5431 \f
5432 /* Optimize T, which is a comparison of a MIN_EXPR or MAX_EXPR with a
5433    constant.  */
5434
5435 static tree
5436 optimize_minmax_comparison (enum tree_code code, tree type, tree op0, tree op1)
5437 {
5438   tree arg0 = op0;
5439   enum tree_code op_code;
5440   tree comp_const = op1;
5441   tree minmax_const;
5442   int consts_equal, consts_lt;
5443   tree inner;
5444
5445   STRIP_SIGN_NOPS (arg0);
5446
5447   op_code = TREE_CODE (arg0);
5448   minmax_const = TREE_OPERAND (arg0, 1);
5449   consts_equal = tree_int_cst_equal (minmax_const, comp_const);
5450   consts_lt = tree_int_cst_lt (minmax_const, comp_const);
5451   inner = TREE_OPERAND (arg0, 0);
5452
5453   /* If something does not permit us to optimize, return the original tree.  */
5454   if ((op_code != MIN_EXPR && op_code != MAX_EXPR)
5455       || TREE_CODE (comp_const) != INTEGER_CST
5456       || TREE_CONSTANT_OVERFLOW (comp_const)
5457       || TREE_CODE (minmax_const) != INTEGER_CST
5458       || TREE_CONSTANT_OVERFLOW (minmax_const))
5459     return NULL_TREE;
5460
5461   /* Now handle all the various comparison codes.  We only handle EQ_EXPR
5462      and GT_EXPR, doing the rest with recursive calls using logical
5463      simplifications.  */
5464   switch (code)
5465     {
5466     case NE_EXPR:  case LT_EXPR:  case LE_EXPR:
5467       {
5468         tree tem = optimize_minmax_comparison (invert_tree_comparison (code, false),
5469                                           type, op0, op1);
5470         if (tem)
5471           return invert_truthvalue (tem);
5472         return NULL_TREE;
5473       }
5474
5475     case GE_EXPR:
5476       return
5477         fold_build2 (TRUTH_ORIF_EXPR, type,
5478                      optimize_minmax_comparison
5479                      (EQ_EXPR, type, arg0, comp_const),
5480                      optimize_minmax_comparison
5481                      (GT_EXPR, type, arg0, comp_const));
5482
5483     case EQ_EXPR:
5484       if (op_code == MAX_EXPR && consts_equal)
5485         /* MAX (X, 0) == 0  ->  X <= 0  */
5486         return fold_build2 (LE_EXPR, type, inner, comp_const);
5487
5488       else if (op_code == MAX_EXPR && consts_lt)
5489         /* MAX (X, 0) == 5  ->  X == 5   */
5490         return fold_build2 (EQ_EXPR, type, inner, comp_const);
5491
5492       else if (op_code == MAX_EXPR)
5493         /* MAX (X, 0) == -1  ->  false  */
5494         return omit_one_operand (type, integer_zero_node, inner);
5495
5496       else if (consts_equal)
5497         /* MIN (X, 0) == 0  ->  X >= 0  */
5498         return fold_build2 (GE_EXPR, type, inner, comp_const);
5499
5500       else if (consts_lt)
5501         /* MIN (X, 0) == 5  ->  false  */
5502         return omit_one_operand (type, integer_zero_node, inner);
5503
5504       else
5505         /* MIN (X, 0) == -1  ->  X == -1  */
5506         return fold_build2 (EQ_EXPR, type, inner, comp_const);
5507
5508     case GT_EXPR:
5509       if (op_code == MAX_EXPR && (consts_equal || consts_lt))
5510         /* MAX (X, 0) > 0  ->  X > 0
5511            MAX (X, 0) > 5  ->  X > 5  */
5512         return fold_build2 (GT_EXPR, type, inner, comp_const);
5513
5514       else if (op_code == MAX_EXPR)
5515         /* MAX (X, 0) > -1  ->  true  */
5516         return omit_one_operand (type, integer_one_node, inner);
5517
5518       else if (op_code == MIN_EXPR && (consts_equal || consts_lt))
5519         /* MIN (X, 0) > 0  ->  false
5520            MIN (X, 0) > 5  ->  false  */
5521         return omit_one_operand (type, integer_zero_node, inner);
5522
5523       else
5524         /* MIN (X, 0) > -1  ->  X > -1  */
5525         return fold_build2 (GT_EXPR, type, inner, comp_const);
5526
5527     default:
5528       return NULL_TREE;
5529     }
5530 }
5531 \f
5532 /* T is an integer expression that is being multiplied, divided, or taken a
5533    modulus (CODE says which and what kind of divide or modulus) by a
5534    constant C.  See if we can eliminate that operation by folding it with
5535    other operations already in T.  WIDE_TYPE, if non-null, is a type that
5536    should be used for the computation if wider than our type.
5537
5538    For example, if we are dividing (X * 8) + (Y * 16) by 4, we can return
5539    (X * 2) + (Y * 4).  We must, however, be assured that either the original
5540    expression would not overflow or that overflow is undefined for the type
5541    in the language in question.
5542
5543    We also canonicalize (X + 7) * 4 into X * 4 + 28 in the hope that either
5544    the machine has a multiply-accumulate insn or that this is part of an
5545    addressing calculation.
5546
5547    If we return a non-null expression, it is an equivalent form of the
5548    original computation, but need not be in the original type.
5549
5550    We set *STRICT_OVERFLOW_P to true if the return values depends on
5551    signed overflow being undefined.  Otherwise we do not change
5552    *STRICT_OVERFLOW_P.  */
5553
5554 static tree
5555 extract_muldiv (tree t, tree c, enum tree_code code, tree wide_type,
5556                 bool *strict_overflow_p)
5557 {
5558   /* To avoid exponential search depth, refuse to allow recursion past
5559      three levels.  Beyond that (1) it's highly unlikely that we'll find
5560      something interesting and (2) we've probably processed it before
5561      when we built the inner expression.  */
5562
5563   static int depth;
5564   tree ret;
5565
5566   if (depth > 3)
5567     return NULL;
5568
5569   depth++;
5570   ret = extract_muldiv_1 (t, c, code, wide_type, strict_overflow_p);
5571   depth--;
5572
5573   return ret;
5574 }
5575
5576 static tree
5577 extract_muldiv_1 (tree t, tree c, enum tree_code code, tree wide_type,
5578                   bool *strict_overflow_p)
5579 {
5580   tree type = TREE_TYPE (t);
5581   enum tree_code tcode = TREE_CODE (t);
5582   tree ctype = (wide_type != 0 && (GET_MODE_SIZE (TYPE_MODE (wide_type))
5583                                    > GET_MODE_SIZE (TYPE_MODE (type)))
5584                 ? wide_type : type);
5585   tree t1, t2;
5586   int same_p = tcode == code;
5587   tree op0 = NULL_TREE, op1 = NULL_TREE;
5588   bool sub_strict_overflow_p;
5589
5590   /* Don't deal with constants of zero here; they confuse the code below.  */
5591   if (integer_zerop (c))
5592     return NULL_TREE;
5593
5594   if (TREE_CODE_CLASS (tcode) == tcc_unary)
5595     op0 = TREE_OPERAND (t, 0);
5596
5597   if (TREE_CODE_CLASS (tcode) == tcc_binary)
5598     op0 = TREE_OPERAND (t, 0), op1 = TREE_OPERAND (t, 1);
5599
5600   /* Note that we need not handle conditional operations here since fold
5601      already handles those cases.  So just do arithmetic here.  */
5602   switch (tcode)
5603     {
5604     case INTEGER_CST:
5605       /* For a constant, we can always simplify if we are a multiply
5606          or (for divide and modulus) if it is a multiple of our constant.  */
5607       if (code == MULT_EXPR
5608           || integer_zerop (const_binop (TRUNC_MOD_EXPR, t, c, 0)))
5609         return const_binop (code, fold_convert (ctype, t),
5610                             fold_convert (ctype, c), 0);
5611       break;
5612
5613     case CONVERT_EXPR:  case NON_LVALUE_EXPR:  case NOP_EXPR:
5614       /* If op0 is an expression ...  */
5615       if ((COMPARISON_CLASS_P (op0)
5616            || UNARY_CLASS_P (op0)
5617            || BINARY_CLASS_P (op0)
5618            || EXPRESSION_CLASS_P (op0))
5619           /* ... and is unsigned, and its type is smaller than ctype,
5620              then we cannot pass through as widening.  */
5621           && ((TYPE_UNSIGNED (TREE_TYPE (op0))
5622                && ! (TREE_CODE (TREE_TYPE (op0)) == INTEGER_TYPE
5623                      && TYPE_IS_SIZETYPE (TREE_TYPE (op0)))
5624                && (GET_MODE_SIZE (TYPE_MODE (ctype))
5625                    > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))))
5626               /* ... or this is a truncation (t is narrower than op0),
5627                  then we cannot pass through this narrowing.  */
5628               || (GET_MODE_SIZE (TYPE_MODE (type))
5629                   < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0))))
5630               /* ... or signedness changes for division or modulus,
5631                  then we cannot pass through this conversion.  */
5632               || (code != MULT_EXPR
5633                   && (TYPE_UNSIGNED (ctype)
5634                       != TYPE_UNSIGNED (TREE_TYPE (op0))))))
5635         break;
5636
5637       /* Pass the constant down and see if we can make a simplification.  If
5638          we can, replace this expression with the inner simplification for
5639          possible later conversion to our or some other type.  */
5640       if ((t2 = fold_convert (TREE_TYPE (op0), c)) != 0
5641           && TREE_CODE (t2) == INTEGER_CST
5642           && ! TREE_CONSTANT_OVERFLOW (t2)
5643           && (0 != (t1 = extract_muldiv (op0, t2, code,
5644                                          code == MULT_EXPR
5645                                          ? ctype : NULL_TREE,
5646                                          strict_overflow_p))))
5647         return t1;
5648       break;
5649
5650     case ABS_EXPR:
5651       /* If widening the type changes it from signed to unsigned, then we
5652          must avoid building ABS_EXPR itself as unsigned.  */
5653       if (TYPE_UNSIGNED (ctype) && !TYPE_UNSIGNED (type))
5654         {
5655           tree cstype = (*lang_hooks.types.signed_type) (ctype);
5656           if ((t1 = extract_muldiv (op0, c, code, cstype, strict_overflow_p))
5657               != 0)
5658             {
5659               t1 = fold_build1 (tcode, cstype, fold_convert (cstype, t1));
5660               return fold_convert (ctype, t1);
5661             }
5662           break;
5663         }
5664       /* If the constant is negative, we cannot simplify this.  */
5665       if (tree_int_cst_sgn (c) == -1)
5666         break;
5667       /* FALLTHROUGH */
5668     case NEGATE_EXPR:
5669       if ((t1 = extract_muldiv (op0, c, code, wide_type, strict_overflow_p))
5670           != 0)
5671         return fold_build1 (tcode, ctype, fold_convert (ctype, t1));
5672       break;
5673
5674     case MIN_EXPR:  case MAX_EXPR:
5675       /* If widening the type changes the signedness, then we can't perform
5676          this optimization as that changes the result.  */
5677       if (TYPE_UNSIGNED (ctype) != TYPE_UNSIGNED (type))
5678         break;
5679
5680       /* MIN (a, b) / 5 -> MIN (a / 5, b / 5)  */
5681       sub_strict_overflow_p = false;
5682       if ((t1 = extract_muldiv (op0, c, code, wide_type,
5683                                 &sub_strict_overflow_p)) != 0
5684           && (t2 = extract_muldiv (op1, c, code, wide_type,
5685                                    &sub_strict_overflow_p)) != 0)
5686         {
5687           if (tree_int_cst_sgn (c) < 0)
5688             tcode = (tcode == MIN_EXPR ? MAX_EXPR : MIN_EXPR);
5689           if (sub_strict_overflow_p)
5690             *strict_overflow_p = true;
5691           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5692                               fold_convert (ctype, t2));
5693         }
5694       break;
5695
5696     case LSHIFT_EXPR:  case RSHIFT_EXPR:
5697       /* If the second operand is constant, this is a multiplication
5698          or floor division, by a power of two, so we can treat it that
5699          way unless the multiplier or divisor overflows.  Signed
5700          left-shift overflow is implementation-defined rather than
5701          undefined in C90, so do not convert signed left shift into
5702          multiplication.  */
5703       if (TREE_CODE (op1) == INTEGER_CST
5704           && (tcode == RSHIFT_EXPR || TYPE_UNSIGNED (TREE_TYPE (op0)))
5705           /* const_binop may not detect overflow correctly,
5706              so check for it explicitly here.  */
5707           && TYPE_PRECISION (TREE_TYPE (size_one_node)) > TREE_INT_CST_LOW (op1)
5708           && TREE_INT_CST_HIGH (op1) == 0
5709           && 0 != (t1 = fold_convert (ctype,
5710                                       const_binop (LSHIFT_EXPR,
5711                                                    size_one_node,
5712                                                    op1, 0)))
5713           && ! TREE_OVERFLOW (t1))
5714         return extract_muldiv (build2 (tcode == LSHIFT_EXPR
5715                                        ? MULT_EXPR : FLOOR_DIV_EXPR,
5716                                        ctype, fold_convert (ctype, op0), t1),
5717                                c, code, wide_type, strict_overflow_p);
5718       break;
5719
5720     case PLUS_EXPR:  case MINUS_EXPR:
5721       /* See if we can eliminate the operation on both sides.  If we can, we
5722          can return a new PLUS or MINUS.  If we can't, the only remaining
5723          cases where we can do anything are if the second operand is a
5724          constant.  */
5725       sub_strict_overflow_p = false;
5726       t1 = extract_muldiv (op0, c, code, wide_type, &sub_strict_overflow_p);
5727       t2 = extract_muldiv (op1, c, code, wide_type, &sub_strict_overflow_p);
5728       if (t1 != 0 && t2 != 0
5729           && (code == MULT_EXPR
5730               /* If not multiplication, we can only do this if both operands
5731                  are divisible by c.  */
5732               || (multiple_of_p (ctype, op0, c)
5733                   && multiple_of_p (ctype, op1, c))))
5734         {
5735           if (sub_strict_overflow_p)
5736             *strict_overflow_p = true;
5737           return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5738                               fold_convert (ctype, t2));
5739         }
5740
5741       /* If this was a subtraction, negate OP1 and set it to be an addition.
5742          This simplifies the logic below.  */
5743       if (tcode == MINUS_EXPR)
5744         tcode = PLUS_EXPR, op1 = negate_expr (op1);
5745
5746       if (TREE_CODE (op1) != INTEGER_CST)
5747         break;
5748
5749       /* If either OP1 or C are negative, this optimization is not safe for
5750          some of the division and remainder types while for others we need
5751          to change the code.  */
5752       if (tree_int_cst_sgn (op1) < 0 || tree_int_cst_sgn (c) < 0)
5753         {
5754           if (code == CEIL_DIV_EXPR)
5755             code = FLOOR_DIV_EXPR;
5756           else if (code == FLOOR_DIV_EXPR)
5757             code = CEIL_DIV_EXPR;
5758           else if (code != MULT_EXPR
5759                    && code != CEIL_MOD_EXPR && code != FLOOR_MOD_EXPR)
5760             break;
5761         }
5762
5763       /* If it's a multiply or a division/modulus operation of a multiple
5764          of our constant, do the operation and verify it doesn't overflow.  */
5765       if (code == MULT_EXPR
5766           || integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5767         {
5768           op1 = const_binop (code, fold_convert (ctype, op1),
5769                              fold_convert (ctype, c), 0);
5770           /* We allow the constant to overflow with wrapping semantics.  */
5771           if (op1 == 0
5772               || (TREE_OVERFLOW (op1) && !TYPE_OVERFLOW_WRAPS (ctype)))
5773             break;
5774         }
5775       else
5776         break;
5777
5778       /* If we have an unsigned type is not a sizetype, we cannot widen
5779          the operation since it will change the result if the original
5780          computation overflowed.  */
5781       if (TYPE_UNSIGNED (ctype)
5782           && ! (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype))
5783           && ctype != type)
5784         break;
5785
5786       /* If we were able to eliminate our operation from the first side,
5787          apply our operation to the second side and reform the PLUS.  */
5788       if (t1 != 0 && (TREE_CODE (t1) != code || code == MULT_EXPR))
5789         return fold_build2 (tcode, ctype, fold_convert (ctype, t1), op1);
5790
5791       /* The last case is if we are a multiply.  In that case, we can
5792          apply the distributive law to commute the multiply and addition
5793          if the multiplication of the constants doesn't overflow.  */
5794       if (code == MULT_EXPR)
5795         return fold_build2 (tcode, ctype,
5796                             fold_build2 (code, ctype,
5797                                          fold_convert (ctype, op0),
5798                                          fold_convert (ctype, c)),
5799                             op1);
5800
5801       break;
5802
5803     case MULT_EXPR:
5804       /* We have a special case here if we are doing something like
5805          (C * 8) % 4 since we know that's zero.  */
5806       if ((code == TRUNC_MOD_EXPR || code == CEIL_MOD_EXPR
5807            || code == FLOOR_MOD_EXPR || code == ROUND_MOD_EXPR)
5808           && TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST
5809           && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5810         return omit_one_operand (type, integer_zero_node, op0);
5811
5812       /* ... fall through ...  */
5813
5814     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
5815     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
5816       /* If we can extract our operation from the LHS, do so and return a
5817          new operation.  Likewise for the RHS from a MULT_EXPR.  Otherwise,
5818          do something only if the second operand is a constant.  */
5819       if (same_p
5820           && (t1 = extract_muldiv (op0, c, code, wide_type,
5821                                    strict_overflow_p)) != 0)
5822         return fold_build2 (tcode, ctype, fold_convert (ctype, t1),
5823                             fold_convert (ctype, op1));
5824       else if (tcode == MULT_EXPR && code == MULT_EXPR
5825                && (t1 = extract_muldiv (op1, c, code, wide_type,
5826                                         strict_overflow_p)) != 0)
5827         return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5828                             fold_convert (ctype, t1));
5829       else if (TREE_CODE (op1) != INTEGER_CST)
5830         return 0;
5831
5832       /* If these are the same operation types, we can associate them
5833          assuming no overflow.  */
5834       if (tcode == code
5835           && 0 != (t1 = const_binop (MULT_EXPR, fold_convert (ctype, op1),
5836                                      fold_convert (ctype, c), 0))
5837           && ! TREE_OVERFLOW (t1))
5838         return fold_build2 (tcode, ctype, fold_convert (ctype, op0), t1);
5839
5840       /* If these operations "cancel" each other, we have the main
5841          optimizations of this pass, which occur when either constant is a
5842          multiple of the other, in which case we replace this with either an
5843          operation or CODE or TCODE.
5844
5845          If we have an unsigned type that is not a sizetype, we cannot do
5846          this since it will change the result if the original computation
5847          overflowed.  */
5848       if ((TYPE_OVERFLOW_UNDEFINED (ctype)
5849            || (TREE_CODE (ctype) == INTEGER_TYPE && TYPE_IS_SIZETYPE (ctype)))
5850           && ((code == MULT_EXPR && tcode == EXACT_DIV_EXPR)
5851               || (tcode == MULT_EXPR
5852                   && code != TRUNC_MOD_EXPR && code != CEIL_MOD_EXPR
5853                   && code != FLOOR_MOD_EXPR && code != ROUND_MOD_EXPR)))
5854         {
5855           if (integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
5856             {
5857               if (TYPE_OVERFLOW_UNDEFINED (ctype))
5858                 *strict_overflow_p = true;
5859               return fold_build2 (tcode, ctype, fold_convert (ctype, op0),
5860                                   fold_convert (ctype,
5861                                                 const_binop (TRUNC_DIV_EXPR,
5862                                                              op1, c, 0)));
5863             }
5864           else if (integer_zerop (const_binop (TRUNC_MOD_EXPR, c, op1, 0)))
5865             {
5866               if (TYPE_OVERFLOW_UNDEFINED (ctype))
5867                 *strict_overflow_p = true;
5868               return fold_build2 (code, ctype, fold_convert (ctype, op0),
5869                                   fold_convert (ctype,
5870                                                 const_binop (TRUNC_DIV_EXPR,
5871                                                              c, op1, 0)));
5872             }
5873         }
5874       break;
5875
5876     default:
5877       break;
5878     }
5879
5880   return 0;
5881 }
5882 \f
5883 /* Return a node which has the indicated constant VALUE (either 0 or
5884    1), and is of the indicated TYPE.  */
5885
5886 tree
5887 constant_boolean_node (int value, tree type)
5888 {
5889   if (type == integer_type_node)
5890     return value ? integer_one_node : integer_zero_node;
5891   else if (type == boolean_type_node)
5892     return value ? boolean_true_node : boolean_false_node;
5893   else
5894     return build_int_cst (type, value);
5895 }
5896
5897
5898 /* Return true if expr looks like an ARRAY_REF and set base and
5899    offset to the appropriate trees.  If there is no offset,
5900    offset is set to NULL_TREE.  Base will be canonicalized to
5901    something you can get the element type from using
5902    TREE_TYPE (TREE_TYPE (base)).  Offset will be the offset
5903    in bytes to the base.  */
5904
5905 static bool
5906 extract_array_ref (tree expr, tree *base, tree *offset)
5907 {
5908   /* One canonical form is a PLUS_EXPR with the first
5909      argument being an ADDR_EXPR with a possible NOP_EXPR
5910      attached.  */
5911   if (TREE_CODE (expr) == PLUS_EXPR)
5912     {
5913       tree op0 = TREE_OPERAND (expr, 0);
5914       tree inner_base, dummy1;
5915       /* Strip NOP_EXPRs here because the C frontends and/or
5916          folders present us (int *)&x.a + 4B possibly.  */
5917       STRIP_NOPS (op0);
5918       if (extract_array_ref (op0, &inner_base, &dummy1))
5919         {
5920           *base = inner_base;
5921           if (dummy1 == NULL_TREE)
5922             *offset = TREE_OPERAND (expr, 1);
5923           else
5924             *offset = fold_build2 (PLUS_EXPR, TREE_TYPE (expr),
5925                                    dummy1, TREE_OPERAND (expr, 1));
5926           return true;
5927         }
5928     }
5929   /* Other canonical form is an ADDR_EXPR of an ARRAY_REF,
5930      which we transform into an ADDR_EXPR with appropriate
5931      offset.  For other arguments to the ADDR_EXPR we assume
5932      zero offset and as such do not care about the ADDR_EXPR
5933      type and strip possible nops from it.  */
5934   else if (TREE_CODE (expr) == ADDR_EXPR)
5935     {
5936       tree op0 = TREE_OPERAND (expr, 0);
5937       if (TREE_CODE (op0) == ARRAY_REF)
5938         {
5939           tree idx = TREE_OPERAND (op0, 1);
5940           *base = TREE_OPERAND (op0, 0);
5941           *offset = fold_build2 (MULT_EXPR, TREE_TYPE (idx), idx,
5942                                  array_ref_element_size (op0)); 
5943         }
5944       else
5945         {
5946           /* Handle array-to-pointer decay as &a.  */
5947           if (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE)
5948             *base = TREE_OPERAND (expr, 0);
5949           else
5950             *base = expr;
5951           *offset = NULL_TREE;
5952         }
5953       return true;
5954     }
5955   /* The next canonical form is a VAR_DECL with POINTER_TYPE.  */
5956   else if (SSA_VAR_P (expr)
5957            && TREE_CODE (TREE_TYPE (expr)) == POINTER_TYPE)
5958     {
5959       *base = expr;
5960       *offset = NULL_TREE;
5961       return true;
5962     }
5963
5964   return false;
5965 }
5966
5967
5968 /* Transform `a + (b ? x : y)' into `b ? (a + x) : (a + y)'.
5969    Transform, `a + (x < y)' into `(x < y) ? (a + 1) : (a + 0)'.  Here
5970    CODE corresponds to the `+', COND to the `(b ? x : y)' or `(x < y)'
5971    expression, and ARG to `a'.  If COND_FIRST_P is nonzero, then the
5972    COND is the first argument to CODE; otherwise (as in the example
5973    given here), it is the second argument.  TYPE is the type of the
5974    original expression.  Return NULL_TREE if no simplification is
5975    possible.  */
5976
5977 static tree
5978 fold_binary_op_with_conditional_arg (enum tree_code code,
5979                                      tree type, tree op0, tree op1,
5980                                      tree cond, tree arg, int cond_first_p)
5981 {
5982   tree cond_type = cond_first_p ? TREE_TYPE (op0) : TREE_TYPE (op1);
5983   tree arg_type = cond_first_p ? TREE_TYPE (op1) : TREE_TYPE (op0);
5984   tree test, true_value, false_value;
5985   tree lhs = NULL_TREE;
5986   tree rhs = NULL_TREE;
5987
5988   /* This transformation is only worthwhile if we don't have to wrap
5989      arg in a SAVE_EXPR, and the operation can be simplified on at least
5990      one of the branches once its pushed inside the COND_EXPR.  */
5991   if (!TREE_CONSTANT (arg))
5992     return NULL_TREE;
5993
5994   if (TREE_CODE (cond) == COND_EXPR)
5995     {
5996       test = TREE_OPERAND (cond, 0);
5997       true_value = TREE_OPERAND (cond, 1);
5998       false_value = TREE_OPERAND (cond, 2);
5999       /* If this operand throws an expression, then it does not make
6000          sense to try to perform a logical or arithmetic operation
6001          involving it.  */
6002       if (VOID_TYPE_P (TREE_TYPE (true_value)))
6003         lhs = true_value;
6004       if (VOID_TYPE_P (TREE_TYPE (false_value)))
6005         rhs = false_value;
6006     }
6007   else
6008     {
6009       tree testtype = TREE_TYPE (cond);
6010       test = cond;
6011       true_value = constant_boolean_node (true, testtype);
6012       false_value = constant_boolean_node (false, testtype);
6013     }
6014
6015   arg = fold_convert (arg_type, arg);
6016   if (lhs == 0)
6017     {
6018       true_value = fold_convert (cond_type, true_value);
6019       if (cond_first_p)
6020         lhs = fold_build2 (code, type, true_value, arg);
6021       else
6022         lhs = fold_build2 (code, type, arg, true_value);
6023     }
6024   if (rhs == 0)
6025     {
6026       false_value = fold_convert (cond_type, false_value);
6027       if (cond_first_p)
6028         rhs = fold_build2 (code, type, false_value, arg);
6029       else
6030         rhs = fold_build2 (code, type, arg, false_value);
6031     }
6032
6033   test = fold_build3 (COND_EXPR, type, test, lhs, rhs);
6034   return fold_convert (type, test);
6035 }
6036
6037 \f
6038 /* Subroutine of fold() that checks for the addition of +/- 0.0.
6039
6040    If !NEGATE, return true if ADDEND is +/-0.0 and, for all X of type
6041    TYPE, X + ADDEND is the same as X.  If NEGATE, return true if X -
6042    ADDEND is the same as X.
6043
6044    X + 0 and X - 0 both give X when X is NaN, infinite, or nonzero
6045    and finite.  The problematic cases are when X is zero, and its mode
6046    has signed zeros.  In the case of rounding towards -infinity,
6047    X - 0 is not the same as X because 0 - 0 is -0.  In other rounding
6048    modes, X + 0 is not the same as X because -0 + 0 is 0.  */
6049
6050 static bool
6051 fold_real_zero_addition_p (tree type, tree addend, int negate)
6052 {
6053   if (!real_zerop (addend))
6054     return false;
6055
6056   /* Don't allow the fold with -fsignaling-nans.  */
6057   if (HONOR_SNANS (TYPE_MODE (type)))
6058     return false;
6059
6060   /* Allow the fold if zeros aren't signed, or their sign isn't important.  */
6061   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
6062     return true;
6063
6064   /* Treat x + -0 as x - 0 and x - -0 as x + 0.  */
6065   if (TREE_CODE (addend) == REAL_CST
6066       && REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (addend)))
6067     negate = !negate;
6068
6069   /* The mode has signed zeros, and we have to honor their sign.
6070      In this situation, there is only one case we can return true for.
6071      X - 0 is the same as X unless rounding towards -infinity is
6072      supported.  */
6073   return negate && !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type));
6074 }
6075
6076 /* Subroutine of fold() that checks comparisons of built-in math
6077    functions against real constants.
6078
6079    FCODE is the DECL_FUNCTION_CODE of the built-in, CODE is the comparison
6080    operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR, GE_EXPR or LE_EXPR.  TYPE
6081    is the type of the result and ARG0 and ARG1 are the operands of the
6082    comparison.  ARG1 must be a TREE_REAL_CST.
6083
6084    The function returns the constant folded tree if a simplification
6085    can be made, and NULL_TREE otherwise.  */
6086
6087 static tree
6088 fold_mathfn_compare (enum built_in_function fcode, enum tree_code code,
6089                      tree type, tree arg0, tree arg1)
6090 {
6091   REAL_VALUE_TYPE c;
6092
6093   if (BUILTIN_SQRT_P (fcode))
6094     {
6095       tree arg = TREE_VALUE (TREE_OPERAND (arg0, 1));
6096       enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
6097
6098       c = TREE_REAL_CST (arg1);
6099       if (REAL_VALUE_NEGATIVE (c))
6100         {
6101           /* sqrt(x) < y is always false, if y is negative.  */
6102           if (code == EQ_EXPR || code == LT_EXPR || code == LE_EXPR)
6103             return omit_one_operand (type, integer_zero_node, arg);
6104
6105           /* sqrt(x) > y is always true, if y is negative and we
6106              don't care about NaNs, i.e. negative values of x.  */
6107           if (code == NE_EXPR || !HONOR_NANS (mode))
6108             return omit_one_operand (type, integer_one_node, arg);
6109
6110           /* sqrt(x) > y is the same as x >= 0, if y is negative.  */
6111           return fold_build2 (GE_EXPR, type, arg,
6112                               build_real (TREE_TYPE (arg), dconst0));
6113         }
6114       else if (code == GT_EXPR || code == GE_EXPR)
6115         {
6116           REAL_VALUE_TYPE c2;
6117
6118           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6119           real_convert (&c2, mode, &c2);
6120
6121           if (REAL_VALUE_ISINF (c2))
6122             {
6123               /* sqrt(x) > y is x == +Inf, when y is very large.  */
6124               if (HONOR_INFINITIES (mode))
6125                 return fold_build2 (EQ_EXPR, type, arg,
6126                                     build_real (TREE_TYPE (arg), c2));
6127
6128               /* sqrt(x) > y is always false, when y is very large
6129                  and we don't care about infinities.  */
6130               return omit_one_operand (type, integer_zero_node, arg);
6131             }
6132
6133           /* sqrt(x) > c is the same as x > c*c.  */
6134           return fold_build2 (code, type, arg,
6135                               build_real (TREE_TYPE (arg), c2));
6136         }
6137       else if (code == LT_EXPR || code == LE_EXPR)
6138         {
6139           REAL_VALUE_TYPE c2;
6140
6141           REAL_ARITHMETIC (c2, MULT_EXPR, c, c);
6142           real_convert (&c2, mode, &c2);
6143
6144           if (REAL_VALUE_ISINF (c2))
6145             {
6146               /* sqrt(x) < y is always true, when y is a very large
6147                  value and we don't care about NaNs or Infinities.  */
6148               if (! HONOR_NANS (mode) && ! HONOR_INFINITIES (mode))
6149                 return omit_one_operand (type, integer_one_node, arg);
6150
6151               /* sqrt(x) < y is x != +Inf when y is very large and we
6152                  don't care about NaNs.  */
6153               if (! HONOR_NANS (mode))
6154                 return fold_build2 (NE_EXPR, type, arg,
6155                                     build_real (TREE_TYPE (arg), c2));
6156
6157               /* sqrt(x) < y is x >= 0 when y is very large and we
6158                  don't care about Infinities.  */
6159               if (! HONOR_INFINITIES (mode))
6160                 return fold_build2 (GE_EXPR, type, arg,
6161                                     build_real (TREE_TYPE (arg), dconst0));
6162
6163               /* sqrt(x) < y is x >= 0 && x != +Inf, when y is large.  */
6164               if (lang_hooks.decls.global_bindings_p () != 0
6165                   || CONTAINS_PLACEHOLDER_P (arg))
6166                 return NULL_TREE;
6167
6168               arg = save_expr (arg);
6169               return fold_build2 (TRUTH_ANDIF_EXPR, type,
6170                                   fold_build2 (GE_EXPR, type, arg,
6171                                                build_real (TREE_TYPE (arg),
6172                                                            dconst0)),
6173                                   fold_build2 (NE_EXPR, type, arg,
6174                                                build_real (TREE_TYPE (arg),
6175                                                            c2)));
6176             }
6177
6178           /* sqrt(x) < c is the same as x < c*c, if we ignore NaNs.  */
6179           if (! HONOR_NANS (mode))
6180             return fold_build2 (code, type, arg,
6181                                 build_real (TREE_TYPE (arg), c2));
6182
6183           /* sqrt(x) < c is the same as x >= 0 && x < c*c.  */
6184           if (lang_hooks.decls.global_bindings_p () == 0
6185               && ! CONTAINS_PLACEHOLDER_P (arg))
6186             {
6187               arg = save_expr (arg);
6188               return fold_build2 (TRUTH_ANDIF_EXPR, type,
6189                                   fold_build2 (GE_EXPR, type, arg,
6190                                                build_real (TREE_TYPE (arg),
6191                                                            dconst0)),
6192                                   fold_build2 (code, type, arg,
6193                                                build_real (TREE_TYPE (arg),
6194                                                            c2)));
6195             }
6196         }
6197     }
6198
6199   return NULL_TREE;
6200 }
6201
6202 /* Subroutine of fold() that optimizes comparisons against Infinities,
6203    either +Inf or -Inf.
6204
6205    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6206    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6207    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6208
6209    The function returns the constant folded tree if a simplification
6210    can be made, and NULL_TREE otherwise.  */
6211
6212 static tree
6213 fold_inf_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6214 {
6215   enum machine_mode mode;
6216   REAL_VALUE_TYPE max;
6217   tree temp;
6218   bool neg;
6219
6220   mode = TYPE_MODE (TREE_TYPE (arg0));
6221
6222   /* For negative infinity swap the sense of the comparison.  */
6223   neg = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1));
6224   if (neg)
6225     code = swap_tree_comparison (code);
6226
6227   switch (code)
6228     {
6229     case GT_EXPR:
6230       /* x > +Inf is always false, if with ignore sNANs.  */
6231       if (HONOR_SNANS (mode))
6232         return NULL_TREE;
6233       return omit_one_operand (type, integer_zero_node, arg0);
6234
6235     case LE_EXPR:
6236       /* x <= +Inf is always true, if we don't case about NaNs.  */
6237       if (! HONOR_NANS (mode))
6238         return omit_one_operand (type, integer_one_node, arg0);
6239
6240       /* x <= +Inf is the same as x == x, i.e. isfinite(x).  */
6241       if (lang_hooks.decls.global_bindings_p () == 0
6242           && ! CONTAINS_PLACEHOLDER_P (arg0))
6243         {
6244           arg0 = save_expr (arg0);
6245           return fold_build2 (EQ_EXPR, type, arg0, arg0);
6246         }
6247       break;
6248
6249     case EQ_EXPR:
6250     case GE_EXPR:
6251       /* x == +Inf and x >= +Inf are always equal to x > DBL_MAX.  */
6252       real_maxval (&max, neg, mode);
6253       return fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6254                           arg0, build_real (TREE_TYPE (arg0), max));
6255
6256     case LT_EXPR:
6257       /* x < +Inf is always equal to x <= DBL_MAX.  */
6258       real_maxval (&max, neg, mode);
6259       return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6260                           arg0, build_real (TREE_TYPE (arg0), max));
6261
6262     case NE_EXPR:
6263       /* x != +Inf is always equal to !(x > DBL_MAX).  */
6264       real_maxval (&max, neg, mode);
6265       if (! HONOR_NANS (mode))
6266         return fold_build2 (neg ? GE_EXPR : LE_EXPR, type,
6267                             arg0, build_real (TREE_TYPE (arg0), max));
6268
6269       /* The transformation below creates non-gimple code and thus is
6270          not appropriate if we are in gimple form.  */
6271       if (in_gimple_form)
6272         return NULL_TREE;
6273
6274       temp = fold_build2 (neg ? LT_EXPR : GT_EXPR, type,
6275                           arg0, build_real (TREE_TYPE (arg0), max));
6276       return fold_build1 (TRUTH_NOT_EXPR, type, temp);
6277
6278     default:
6279       break;
6280     }
6281
6282   return NULL_TREE;
6283 }
6284
6285 /* Subroutine of fold() that optimizes comparisons of a division by
6286    a nonzero integer constant against an integer constant, i.e.
6287    X/C1 op C2.
6288
6289    CODE is the comparison operator: EQ_EXPR, NE_EXPR, GT_EXPR, LT_EXPR,
6290    GE_EXPR or LE_EXPR.  TYPE is the type of the result and ARG0 and ARG1
6291    are the operands of the comparison.  ARG1 must be a TREE_REAL_CST.
6292
6293    The function returns the constant folded tree if a simplification
6294    can be made, and NULL_TREE otherwise.  */
6295
6296 static tree
6297 fold_div_compare (enum tree_code code, tree type, tree arg0, tree arg1)
6298 {
6299   tree prod, tmp, hi, lo;
6300   tree arg00 = TREE_OPERAND (arg0, 0);
6301   tree arg01 = TREE_OPERAND (arg0, 1);
6302   unsigned HOST_WIDE_INT lpart;
6303   HOST_WIDE_INT hpart;
6304   bool unsigned_p = TYPE_UNSIGNED (TREE_TYPE (arg0));
6305   bool neg_overflow;
6306   int overflow;
6307
6308   /* We have to do this the hard way to detect unsigned overflow.
6309      prod = int_const_binop (MULT_EXPR, arg01, arg1, 0);  */
6310   overflow = mul_double_with_sign (TREE_INT_CST_LOW (arg01),
6311                                    TREE_INT_CST_HIGH (arg01),
6312                                    TREE_INT_CST_LOW (arg1),
6313                                    TREE_INT_CST_HIGH (arg1),
6314                                    &lpart, &hpart, unsigned_p);
6315   prod = build_int_cst_wide (TREE_TYPE (arg00), lpart, hpart);
6316   prod = force_fit_type (prod, -1, overflow, false);
6317   neg_overflow = false;
6318
6319   if (unsigned_p)
6320     {
6321       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
6322       lo = prod;
6323
6324       /* Likewise hi = int_const_binop (PLUS_EXPR, prod, tmp, 0).  */
6325       overflow = add_double_with_sign (TREE_INT_CST_LOW (prod),
6326                                        TREE_INT_CST_HIGH (prod),
6327                                        TREE_INT_CST_LOW (tmp),
6328                                        TREE_INT_CST_HIGH (tmp),
6329                                        &lpart, &hpart, unsigned_p);
6330       hi = build_int_cst_wide (TREE_TYPE (arg00), lpart, hpart);
6331       hi = force_fit_type (hi, -1, overflow | TREE_OVERFLOW (prod),
6332                            TREE_CONSTANT_OVERFLOW (prod));
6333     }
6334   else if (tree_int_cst_sgn (arg01) >= 0)
6335     {
6336       tmp = int_const_binop (MINUS_EXPR, arg01, integer_one_node, 0);
6337       switch (tree_int_cst_sgn (arg1))
6338         {
6339         case -1:
6340           neg_overflow = true;
6341           lo = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6342           hi = prod;
6343           break;
6344
6345         case  0:
6346           lo = fold_negate_const (tmp, TREE_TYPE (arg0));
6347           hi = tmp;
6348           break;
6349
6350         case  1:
6351           hi = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6352           lo = prod;
6353           break;
6354
6355         default:
6356           gcc_unreachable ();
6357         }
6358     }
6359   else
6360     {
6361       /* A negative divisor reverses the relational operators.  */
6362       code = swap_tree_comparison (code);
6363
6364       tmp = int_const_binop (PLUS_EXPR, arg01, integer_one_node, 0);
6365       switch (tree_int_cst_sgn (arg1))
6366         {
6367         case -1:
6368           hi = int_const_binop (MINUS_EXPR, prod, tmp, 0);
6369           lo = prod;
6370           break;
6371
6372         case  0:
6373           hi = fold_negate_const (tmp, TREE_TYPE (arg0));
6374           lo = tmp;
6375           break;
6376
6377         case  1:
6378           neg_overflow = true;
6379           lo = int_const_binop (PLUS_EXPR, prod, tmp, 0);
6380           hi = prod;
6381           break;
6382
6383         default:
6384           gcc_unreachable ();
6385         }
6386     }
6387
6388   switch (code)
6389     {
6390     case EQ_EXPR:
6391       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6392         return omit_one_operand (type, integer_zero_node, arg00);
6393       if (TREE_OVERFLOW (hi))
6394         return fold_build2 (GE_EXPR, type, arg00, lo);
6395       if (TREE_OVERFLOW (lo))
6396         return fold_build2 (LE_EXPR, type, arg00, hi);
6397       return build_range_check (type, arg00, 1, lo, hi);
6398
6399     case NE_EXPR:
6400       if (TREE_OVERFLOW (lo) && TREE_OVERFLOW (hi))
6401         return omit_one_operand (type, integer_one_node, arg00);
6402       if (TREE_OVERFLOW (hi))
6403         return fold_build2 (LT_EXPR, type, arg00, lo);
6404       if (TREE_OVERFLOW (lo))
6405         return fold_build2 (GT_EXPR, type, arg00, hi);
6406       return build_range_check (type, arg00, 0, lo, hi);
6407
6408     case LT_EXPR:
6409       if (TREE_OVERFLOW (lo))
6410         {
6411           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6412           return omit_one_operand (type, tmp, arg00);
6413         }
6414       return fold_build2 (LT_EXPR, type, arg00, lo);
6415
6416     case LE_EXPR:
6417       if (TREE_OVERFLOW (hi))
6418         {
6419           tmp = neg_overflow ? integer_zero_node : integer_one_node;
6420           return omit_one_operand (type, tmp, arg00);
6421         }
6422       return fold_build2 (LE_EXPR, type, arg00, hi);
6423
6424     case GT_EXPR:
6425       if (TREE_OVERFLOW (hi))
6426         {
6427           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6428           return omit_one_operand (type, tmp, arg00);
6429         }
6430       return fold_build2 (GT_EXPR, type, arg00, hi);
6431
6432     case GE_EXPR:
6433       if (TREE_OVERFLOW (lo))
6434         {
6435           tmp = neg_overflow ? integer_one_node : integer_zero_node;
6436           return omit_one_operand (type, tmp, arg00);
6437         }
6438       return fold_build2 (GE_EXPR, type, arg00, lo);
6439
6440     default:
6441       break;
6442     }
6443
6444   return NULL_TREE;
6445 }
6446
6447
6448 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6449    equality/inequality test, then return a simplified form of the test
6450    using a sign testing.  Otherwise return NULL.  TYPE is the desired
6451    result type.  */
6452
6453 static tree
6454 fold_single_bit_test_into_sign_test (enum tree_code code, tree arg0, tree arg1,
6455                                      tree result_type)
6456 {
6457   /* If this is testing a single bit, we can optimize the test.  */
6458   if ((code == NE_EXPR || code == EQ_EXPR)
6459       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6460       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6461     {
6462       /* If we have (A & C) != 0 where C is the sign bit of A, convert
6463          this into A < 0.  Similarly for (A & C) == 0 into A >= 0.  */
6464       tree arg00 = sign_bit_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
6465
6466       if (arg00 != NULL_TREE
6467           /* This is only a win if casting to a signed type is cheap,
6468              i.e. when arg00's type is not a partial mode.  */
6469           && TYPE_PRECISION (TREE_TYPE (arg00))
6470              == GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg00))))
6471         {
6472           tree stype = lang_hooks.types.signed_type (TREE_TYPE (arg00));
6473           return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
6474                               result_type, fold_convert (stype, arg00),
6475                               build_int_cst (stype, 0));
6476         }
6477     }
6478
6479   return NULL_TREE;
6480 }
6481
6482 /* If CODE with arguments ARG0 and ARG1 represents a single bit
6483    equality/inequality test, then return a simplified form of
6484    the test using shifts and logical operations.  Otherwise return
6485    NULL.  TYPE is the desired result type.  */
6486
6487 tree
6488 fold_single_bit_test (enum tree_code code, tree arg0, tree arg1,
6489                       tree result_type)
6490 {
6491   /* If this is testing a single bit, we can optimize the test.  */
6492   if ((code == NE_EXPR || code == EQ_EXPR)
6493       && TREE_CODE (arg0) == BIT_AND_EXPR && integer_zerop (arg1)
6494       && integer_pow2p (TREE_OPERAND (arg0, 1)))
6495     {
6496       tree inner = TREE_OPERAND (arg0, 0);
6497       tree type = TREE_TYPE (arg0);
6498       int bitnum = tree_log2 (TREE_OPERAND (arg0, 1));
6499       enum machine_mode operand_mode = TYPE_MODE (type);
6500       int ops_unsigned;
6501       tree signed_type, unsigned_type, intermediate_type;
6502       tree tem;
6503
6504       /* First, see if we can fold the single bit test into a sign-bit
6505          test.  */
6506       tem = fold_single_bit_test_into_sign_test (code, arg0, arg1,
6507                                                  result_type);
6508       if (tem)
6509         return tem;
6510
6511       /* Otherwise we have (A & C) != 0 where C is a single bit,
6512          convert that into ((A >> C2) & 1).  Where C2 = log2(C).
6513          Similarly for (A & C) == 0.  */
6514
6515       /* If INNER is a right shift of a constant and it plus BITNUM does
6516          not overflow, adjust BITNUM and INNER.  */
6517       if (TREE_CODE (inner) == RSHIFT_EXPR
6518           && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST
6519           && TREE_INT_CST_HIGH (TREE_OPERAND (inner, 1)) == 0
6520           && bitnum < TYPE_PRECISION (type)
6521           && 0 > compare_tree_int (TREE_OPERAND (inner, 1),
6522                                    bitnum - TYPE_PRECISION (type)))
6523         {
6524           bitnum += TREE_INT_CST_LOW (TREE_OPERAND (inner, 1));
6525           inner = TREE_OPERAND (inner, 0);
6526         }
6527
6528       /* If we are going to be able to omit the AND below, we must do our
6529          operations as unsigned.  If we must use the AND, we have a choice.
6530          Normally unsigned is faster, but for some machines signed is.  */
6531 #ifdef LOAD_EXTEND_OP
6532       ops_unsigned = (LOAD_EXTEND_OP (operand_mode) == SIGN_EXTEND 
6533                       && !flag_syntax_only) ? 0 : 1;
6534 #else
6535       ops_unsigned = 1;
6536 #endif
6537
6538       signed_type = lang_hooks.types.type_for_mode (operand_mode, 0);
6539       unsigned_type = lang_hooks.types.type_for_mode (operand_mode, 1);
6540       intermediate_type = ops_unsigned ? unsigned_type : signed_type;
6541       inner = fold_convert (intermediate_type, inner);
6542
6543       if (bitnum != 0)
6544         inner = build2 (RSHIFT_EXPR, intermediate_type,
6545                         inner, size_int (bitnum));
6546
6547       if (code == EQ_EXPR)
6548         inner = fold_build2 (BIT_XOR_EXPR, intermediate_type,
6549                              inner, integer_one_node);
6550
6551       /* Put the AND last so it can combine with more things.  */
6552       inner = build2 (BIT_AND_EXPR, intermediate_type,
6553                       inner, integer_one_node);
6554
6555       /* Make sure to return the proper type.  */
6556       inner = fold_convert (result_type, inner);
6557
6558       return inner;
6559     }
6560   return NULL_TREE;
6561 }
6562
6563 /* Check whether we are allowed to reorder operands arg0 and arg1,
6564    such that the evaluation of arg1 occurs before arg0.  */
6565
6566 static bool
6567 reorder_operands_p (tree arg0, tree arg1)
6568 {
6569   if (! flag_evaluation_order)
6570       return true;
6571   if (TREE_CONSTANT (arg0) || TREE_CONSTANT (arg1))
6572     return true;
6573   return ! TREE_SIDE_EFFECTS (arg0)
6574          && ! TREE_SIDE_EFFECTS (arg1);
6575 }
6576
6577 /* Test whether it is preferable two swap two operands, ARG0 and
6578    ARG1, for example because ARG0 is an integer constant and ARG1
6579    isn't.  If REORDER is true, only recommend swapping if we can
6580    evaluate the operands in reverse order.  */
6581
6582 bool
6583 tree_swap_operands_p (tree arg0, tree arg1, bool reorder)
6584 {
6585   STRIP_SIGN_NOPS (arg0);
6586   STRIP_SIGN_NOPS (arg1);
6587
6588   if (TREE_CODE (arg1) == INTEGER_CST)
6589     return 0;
6590   if (TREE_CODE (arg0) == INTEGER_CST)
6591     return 1;
6592
6593   if (TREE_CODE (arg1) == REAL_CST)
6594     return 0;
6595   if (TREE_CODE (arg0) == REAL_CST)
6596     return 1;
6597
6598   if (TREE_CODE (arg1) == COMPLEX_CST)
6599     return 0;
6600   if (TREE_CODE (arg0) == COMPLEX_CST)
6601     return 1;
6602
6603   if (TREE_CONSTANT (arg1))
6604     return 0;
6605   if (TREE_CONSTANT (arg0))
6606     return 1;
6607
6608   if (optimize_size)
6609     return 0;
6610
6611   if (reorder && flag_evaluation_order
6612       && (TREE_SIDE_EFFECTS (arg0) || TREE_SIDE_EFFECTS (arg1)))
6613     return 0;
6614
6615   if (DECL_P (arg1))
6616     return 0;
6617   if (DECL_P (arg0))
6618     return 1;
6619
6620   /* It is preferable to swap two SSA_NAME to ensure a canonical form
6621      for commutative and comparison operators.  Ensuring a canonical
6622      form allows the optimizers to find additional redundancies without
6623      having to explicitly check for both orderings.  */
6624   if (TREE_CODE (arg0) == SSA_NAME
6625       && TREE_CODE (arg1) == SSA_NAME
6626       && SSA_NAME_VERSION (arg0) > SSA_NAME_VERSION (arg1))
6627     return 1;
6628
6629   return 0;
6630 }
6631
6632 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where
6633    ARG0 is extended to a wider type.  */
6634
6635 static tree
6636 fold_widened_comparison (enum tree_code code, tree type, tree arg0, tree arg1)
6637 {
6638   tree arg0_unw = get_unwidened (arg0, NULL_TREE);
6639   tree arg1_unw;
6640   tree shorter_type, outer_type;
6641   tree min, max;
6642   bool above, below;
6643
6644   if (arg0_unw == arg0)
6645     return NULL_TREE;
6646   shorter_type = TREE_TYPE (arg0_unw);
6647
6648 #ifdef HAVE_canonicalize_funcptr_for_compare
6649   /* Disable this optimization if we're casting a function pointer
6650      type on targets that require function pointer canonicalization.  */
6651   if (HAVE_canonicalize_funcptr_for_compare
6652       && TREE_CODE (shorter_type) == POINTER_TYPE
6653       && TREE_CODE (TREE_TYPE (shorter_type)) == FUNCTION_TYPE)
6654     return NULL_TREE;
6655 #endif
6656
6657   if (TYPE_PRECISION (TREE_TYPE (arg0)) <= TYPE_PRECISION (shorter_type))
6658     return NULL_TREE;
6659
6660   arg1_unw = get_unwidened (arg1, shorter_type);
6661
6662   /* If possible, express the comparison in the shorter mode.  */
6663   if ((code == EQ_EXPR || code == NE_EXPR
6664        || TYPE_UNSIGNED (TREE_TYPE (arg0)) == TYPE_UNSIGNED (shorter_type))
6665       && (TREE_TYPE (arg1_unw) == shorter_type
6666           || (TREE_CODE (arg1_unw) == INTEGER_CST
6667               && (TREE_CODE (shorter_type) == INTEGER_TYPE
6668                   || TREE_CODE (shorter_type) == BOOLEAN_TYPE)
6669               && int_fits_type_p (arg1_unw, shorter_type))))
6670     return fold_build2 (code, type, arg0_unw,
6671                        fold_convert (shorter_type, arg1_unw));
6672
6673   if (TREE_CODE (arg1_unw) != INTEGER_CST
6674       || TREE_CODE (shorter_type) != INTEGER_TYPE
6675       || !int_fits_type_p (arg1_unw, shorter_type))
6676     return NULL_TREE;
6677
6678   /* If we are comparing with the integer that does not fit into the range
6679      of the shorter type, the result is known.  */
6680   outer_type = TREE_TYPE (arg1_unw);
6681   min = lower_bound_in_type (outer_type, shorter_type);
6682   max = upper_bound_in_type (outer_type, shorter_type);
6683
6684   above = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6685                                                    max, arg1_unw));
6686   below = integer_nonzerop (fold_relational_const (LT_EXPR, type,
6687                                                    arg1_unw, min));
6688
6689   switch (code)
6690     {
6691     case EQ_EXPR:
6692       if (above || below)
6693         return omit_one_operand (type, integer_zero_node, arg0);
6694       break;
6695
6696     case NE_EXPR:
6697       if (above || below)
6698         return omit_one_operand (type, integer_one_node, arg0);
6699       break;
6700
6701     case LT_EXPR:
6702     case LE_EXPR:
6703       if (above)
6704         return omit_one_operand (type, integer_one_node, arg0);
6705       else if (below)
6706         return omit_one_operand (type, integer_zero_node, arg0);
6707
6708     case GT_EXPR:
6709     case GE_EXPR:
6710       if (above)
6711         return omit_one_operand (type, integer_zero_node, arg0);
6712       else if (below)
6713         return omit_one_operand (type, integer_one_node, arg0);
6714
6715     default:
6716       break;
6717     }
6718
6719   return NULL_TREE;
6720 }
6721
6722 /* Fold comparison ARG0 CODE ARG1 (with result in TYPE), where for
6723    ARG0 just the signedness is changed.  */
6724
6725 static tree
6726 fold_sign_changed_comparison (enum tree_code code, tree type,
6727                               tree arg0, tree arg1)
6728 {
6729   tree arg0_inner, tmp;
6730   tree inner_type, outer_type;
6731
6732   if (TREE_CODE (arg0) != NOP_EXPR
6733       && TREE_CODE (arg0) != CONVERT_EXPR)
6734     return NULL_TREE;
6735
6736   outer_type = TREE_TYPE (arg0);
6737   arg0_inner = TREE_OPERAND (arg0, 0);
6738   inner_type = TREE_TYPE (arg0_inner);
6739
6740 #ifdef HAVE_canonicalize_funcptr_for_compare
6741   /* Disable this optimization if we're casting a function pointer
6742      type on targets that require function pointer canonicalization.  */
6743   if (HAVE_canonicalize_funcptr_for_compare
6744       && TREE_CODE (inner_type) == POINTER_TYPE
6745       && TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE)
6746     return NULL_TREE;
6747 #endif
6748
6749   if (TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
6750     return NULL_TREE;
6751
6752   if (TREE_CODE (arg1) != INTEGER_CST
6753       && !((TREE_CODE (arg1) == NOP_EXPR
6754             || TREE_CODE (arg1) == CONVERT_EXPR)
6755            && TREE_TYPE (TREE_OPERAND (arg1, 0)) == inner_type))
6756     return NULL_TREE;
6757
6758   if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
6759       && code != NE_EXPR
6760       && code != EQ_EXPR)
6761     return NULL_TREE;
6762
6763   if (TREE_CODE (arg1) == INTEGER_CST)
6764     {
6765       tmp = build_int_cst_wide (inner_type,
6766                                 TREE_INT_CST_LOW (arg1),
6767                                 TREE_INT_CST_HIGH (arg1));
6768       arg1 = force_fit_type (tmp, 0,
6769                              TREE_OVERFLOW (arg1),
6770                              TREE_CONSTANT_OVERFLOW (arg1));
6771     }
6772   else
6773     arg1 = fold_convert (inner_type, arg1);
6774
6775   return fold_build2 (code, type, arg0_inner, arg1);
6776 }
6777
6778 /* Tries to replace &a[idx] CODE s * delta with &a[idx CODE delta], if s is
6779    step of the array.  Reconstructs s and delta in the case of s * delta
6780    being an integer constant (and thus already folded).
6781    ADDR is the address. MULT is the multiplicative expression.
6782    If the function succeeds, the new address expression is returned.  Otherwise
6783    NULL_TREE is returned.  */
6784
6785 static tree
6786 try_move_mult_to_index (enum tree_code code, tree addr, tree op1)
6787 {
6788   tree s, delta, step;
6789   tree ref = TREE_OPERAND (addr, 0), pref;
6790   tree ret, pos;
6791   tree itype;
6792
6793   /* Canonicalize op1 into a possibly non-constant delta
6794      and an INTEGER_CST s.  */
6795   if (TREE_CODE (op1) == MULT_EXPR)
6796     {
6797       tree arg0 = TREE_OPERAND (op1, 0), arg1 = TREE_OPERAND (op1, 1);
6798
6799       STRIP_NOPS (arg0);
6800       STRIP_NOPS (arg1);
6801   
6802       if (TREE_CODE (arg0) == INTEGER_CST)
6803         {
6804           s = arg0;
6805           delta = arg1;
6806         }
6807       else if (TREE_CODE (arg1) == INTEGER_CST)
6808         {
6809           s = arg1;
6810           delta = arg0;
6811         }
6812       else
6813         return NULL_TREE;
6814     }
6815   else if (TREE_CODE (op1) == INTEGER_CST)
6816     {
6817       delta = op1;
6818       s = NULL_TREE;
6819     }
6820   else
6821     {
6822       /* Simulate we are delta * 1.  */
6823       delta = op1;
6824       s = integer_one_node;
6825     }
6826
6827   for (;; ref = TREE_OPERAND (ref, 0))
6828     {
6829       if (TREE_CODE (ref) == ARRAY_REF)
6830         {
6831           itype = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (ref, 0)));
6832           if (! itype)
6833             continue;
6834
6835           step = array_ref_element_size (ref);
6836           if (TREE_CODE (step) != INTEGER_CST)
6837             continue;
6838
6839           if (s)
6840             {
6841               if (! tree_int_cst_equal (step, s))
6842                 continue;
6843             }
6844           else
6845             {
6846               /* Try if delta is a multiple of step.  */
6847               tree tmp = div_if_zero_remainder (EXACT_DIV_EXPR, delta, step);
6848               if (! tmp)
6849                 continue;
6850               delta = tmp;
6851             }
6852
6853           break;
6854         }
6855
6856       if (!handled_component_p (ref))
6857         return NULL_TREE;
6858     }
6859
6860   /* We found the suitable array reference.  So copy everything up to it,
6861      and replace the index.  */
6862
6863   pref = TREE_OPERAND (addr, 0);
6864   ret = copy_node (pref);
6865   pos = ret;
6866
6867   while (pref != ref)
6868     {
6869       pref = TREE_OPERAND (pref, 0);
6870       TREE_OPERAND (pos, 0) = copy_node (pref);
6871       pos = TREE_OPERAND (pos, 0);
6872     }
6873
6874   TREE_OPERAND (pos, 1) = fold_build2 (code, itype,
6875                                        fold_convert (itype,
6876                                                      TREE_OPERAND (pos, 1)),
6877                                        fold_convert (itype, delta));
6878
6879   return fold_build1 (ADDR_EXPR, TREE_TYPE (addr), ret);
6880 }
6881
6882
6883 /* Fold A < X && A + 1 > Y to A < X && A >= Y.  Normally A + 1 > Y
6884    means A >= Y && A != MAX, but in this case we know that
6885    A < X <= MAX.  INEQ is A + 1 > Y, BOUND is A < X.  */
6886
6887 static tree
6888 fold_to_nonsharp_ineq_using_bound (tree ineq, tree bound)
6889 {
6890   tree a, typea, type = TREE_TYPE (ineq), a1, diff, y;
6891
6892   if (TREE_CODE (bound) == LT_EXPR)
6893     a = TREE_OPERAND (bound, 0);
6894   else if (TREE_CODE (bound) == GT_EXPR)
6895     a = TREE_OPERAND (bound, 1);
6896   else
6897     return NULL_TREE;
6898
6899   typea = TREE_TYPE (a);
6900   if (!INTEGRAL_TYPE_P (typea)
6901       && !POINTER_TYPE_P (typea))
6902     return NULL_TREE;
6903
6904   if (TREE_CODE (ineq) == LT_EXPR)
6905     {
6906       a1 = TREE_OPERAND (ineq, 1);
6907       y = TREE_OPERAND (ineq, 0);
6908     }
6909   else if (TREE_CODE (ineq) == GT_EXPR)
6910     {
6911       a1 = TREE_OPERAND (ineq, 0);
6912       y = TREE_OPERAND (ineq, 1);
6913     }
6914   else
6915     return NULL_TREE;
6916
6917   if (TREE_TYPE (a1) != typea)
6918     return NULL_TREE;
6919
6920   diff = fold_build2 (MINUS_EXPR, typea, a1, a);
6921   if (!integer_onep (diff))
6922     return NULL_TREE;
6923
6924   return fold_build2 (GE_EXPR, type, a, y);
6925 }
6926
6927 /* Fold a sum or difference of at least one multiplication.
6928    Returns the folded tree or NULL if no simplification could be made.  */
6929
6930 static tree
6931 fold_plusminus_mult_expr (enum tree_code code, tree type, tree arg0, tree arg1)
6932 {
6933   tree arg00, arg01, arg10, arg11;
6934   tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
6935
6936   /* (A * C) +- (B * C) -> (A+-B) * C.
6937      (A * C) +- A -> A * (C+-1).
6938      We are most concerned about the case where C is a constant,
6939      but other combinations show up during loop reduction.  Since
6940      it is not difficult, try all four possibilities.  */
6941
6942   if (TREE_CODE (arg0) == MULT_EXPR)
6943     {
6944       arg00 = TREE_OPERAND (arg0, 0);
6945       arg01 = TREE_OPERAND (arg0, 1);
6946     }
6947   else
6948     {
6949       arg00 = arg0;
6950       arg01 = build_one_cst (type);
6951     }
6952   if (TREE_CODE (arg1) == MULT_EXPR)
6953     {
6954       arg10 = TREE_OPERAND (arg1, 0);
6955       arg11 = TREE_OPERAND (arg1, 1);
6956     }
6957   else
6958     {
6959       arg10 = arg1;
6960       arg11 = build_one_cst (type);
6961     }
6962   same = NULL_TREE;
6963
6964   if (operand_equal_p (arg01, arg11, 0))
6965     same = arg01, alt0 = arg00, alt1 = arg10;
6966   else if (operand_equal_p (arg00, arg10, 0))
6967     same = arg00, alt0 = arg01, alt1 = arg11;
6968   else if (operand_equal_p (arg00, arg11, 0))
6969     same = arg00, alt0 = arg01, alt1 = arg10;
6970   else if (operand_equal_p (arg01, arg10, 0))
6971     same = arg01, alt0 = arg00, alt1 = arg11;
6972
6973   /* No identical multiplicands; see if we can find a common
6974      power-of-two factor in non-power-of-two multiplies.  This
6975      can help in multi-dimensional array access.  */
6976   else if (host_integerp (arg01, 0)
6977            && host_integerp (arg11, 0))
6978     {
6979       HOST_WIDE_INT int01, int11, tmp;
6980       bool swap = false;
6981       tree maybe_same;
6982       int01 = TREE_INT_CST_LOW (arg01);
6983       int11 = TREE_INT_CST_LOW (arg11);
6984
6985       /* Move min of absolute values to int11.  */
6986       if ((int01 >= 0 ? int01 : -int01)
6987           < (int11 >= 0 ? int11 : -int11))
6988         {
6989           tmp = int01, int01 = int11, int11 = tmp;
6990           alt0 = arg00, arg00 = arg10, arg10 = alt0;
6991           maybe_same = arg01;
6992           swap = true;
6993         }
6994       else
6995         maybe_same = arg11;
6996
6997       if (exact_log2 (int11) > 0 && int01 % int11 == 0)
6998         {
6999           alt0 = fold_build2 (MULT_EXPR, TREE_TYPE (arg00), arg00,
7000                               build_int_cst (TREE_TYPE (arg00),
7001                                              int01 / int11));
7002           alt1 = arg10;
7003           same = maybe_same;
7004           if (swap)
7005             maybe_same = alt0, alt0 = alt1, alt1 = maybe_same;
7006         }
7007     }
7008
7009   if (same)
7010     return fold_build2 (MULT_EXPR, type,
7011                         fold_build2 (code, type,
7012                                      fold_convert (type, alt0),
7013                                      fold_convert (type, alt1)),
7014                         fold_convert (type, same));
7015
7016   return NULL_TREE;
7017 }
7018
7019 /* Subroutine of native_encode_expr.  Encode the INTEGER_CST
7020    specified by EXPR into the buffer PTR of length LEN bytes.
7021    Return the number of bytes placed in the buffer, or zero
7022    upon failure.  */
7023
7024 static int
7025 native_encode_int (tree expr, unsigned char *ptr, int len)
7026 {
7027   tree type = TREE_TYPE (expr);
7028   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7029   int byte, offset, word, words;
7030   unsigned char value;
7031
7032   if (total_bytes > len)
7033     return 0;
7034   words = total_bytes / UNITS_PER_WORD;
7035
7036   for (byte = 0; byte < total_bytes; byte++)
7037     {
7038       int bitpos = byte * BITS_PER_UNIT;
7039       if (bitpos < HOST_BITS_PER_WIDE_INT)
7040         value = (unsigned char) (TREE_INT_CST_LOW (expr) >> bitpos);
7041       else
7042         value = (unsigned char) (TREE_INT_CST_HIGH (expr)
7043                                  >> (bitpos - HOST_BITS_PER_WIDE_INT));
7044
7045       if (total_bytes > UNITS_PER_WORD)
7046         {
7047           word = byte / UNITS_PER_WORD;
7048           if (WORDS_BIG_ENDIAN)
7049             word = (words - 1) - word;
7050           offset = word * UNITS_PER_WORD;
7051           if (BYTES_BIG_ENDIAN)
7052             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7053           else
7054             offset += byte % UNITS_PER_WORD;
7055         }
7056       else
7057         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7058       ptr[offset] = value;
7059     }
7060   return total_bytes;
7061 }
7062
7063
7064 /* Subroutine of native_encode_expr.  Encode the REAL_CST
7065    specified by EXPR into the buffer PTR of length LEN bytes.
7066    Return the number of bytes placed in the buffer, or zero
7067    upon failure.  */
7068
7069 static int
7070 native_encode_real (tree expr, unsigned char *ptr, int len)
7071 {
7072   tree type = TREE_TYPE (expr);
7073   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7074   int byte, offset, word, words, bitpos;
7075   unsigned char value;
7076
7077   /* There are always 32 bits in each long, no matter the size of
7078      the hosts long.  We handle floating point representations with
7079      up to 192 bits.  */
7080   long tmp[6];
7081
7082   if (total_bytes > len)
7083     return 0;
7084   words = 32 / UNITS_PER_WORD;
7085
7086   real_to_target (tmp, TREE_REAL_CST_PTR (expr), TYPE_MODE (type));
7087
7088   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7089        bitpos += BITS_PER_UNIT)
7090     {
7091       byte = (bitpos / BITS_PER_UNIT) & 3;
7092       value = (unsigned char) (tmp[bitpos / 32] >> (bitpos & 31));
7093
7094       if (UNITS_PER_WORD < 4)
7095         {
7096           word = byte / UNITS_PER_WORD;
7097           if (WORDS_BIG_ENDIAN)
7098             word = (words - 1) - word;
7099           offset = word * UNITS_PER_WORD;
7100           if (BYTES_BIG_ENDIAN)
7101             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7102           else
7103             offset += byte % UNITS_PER_WORD;
7104         }
7105       else
7106         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7107       ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)] = value;
7108     }
7109   return total_bytes;
7110 }
7111
7112 /* Subroutine of native_encode_expr.  Encode the COMPLEX_CST
7113    specified by EXPR into the buffer PTR of length LEN bytes.
7114    Return the number of bytes placed in the buffer, or zero
7115    upon failure.  */
7116
7117 static int
7118 native_encode_complex (tree expr, unsigned char *ptr, int len)
7119 {
7120   int rsize, isize;
7121   tree part;
7122
7123   part = TREE_REALPART (expr);
7124   rsize = native_encode_expr (part, ptr, len);
7125   if (rsize == 0)
7126     return 0;
7127   part = TREE_IMAGPART (expr);
7128   isize = native_encode_expr (part, ptr+rsize, len-rsize);
7129   if (isize != rsize)
7130     return 0;
7131   return rsize + isize;
7132 }
7133
7134
7135 /* Subroutine of native_encode_expr.  Encode the VECTOR_CST
7136    specified by EXPR into the buffer PTR of length LEN bytes.
7137    Return the number of bytes placed in the buffer, or zero
7138    upon failure.  */
7139
7140 static int
7141 native_encode_vector (tree expr, unsigned char *ptr, int len)
7142 {
7143   int i, size, offset, count;
7144   tree itype, elem, elements;
7145
7146   offset = 0;
7147   elements = TREE_VECTOR_CST_ELTS (expr);
7148   count = TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr));
7149   itype = TREE_TYPE (TREE_TYPE (expr));
7150   size = GET_MODE_SIZE (TYPE_MODE (itype));
7151   for (i = 0; i < count; i++)
7152     {
7153       if (elements)
7154         {
7155           elem = TREE_VALUE (elements);
7156           elements = TREE_CHAIN (elements);
7157         }
7158       else
7159         elem = NULL_TREE;
7160
7161       if (elem)
7162         {
7163           if (native_encode_expr (elem, ptr+offset, len-offset) != size)
7164             return 0;
7165         }
7166       else
7167         {
7168           if (offset + size > len)
7169             return 0;
7170           memset (ptr+offset, 0, size);
7171         }
7172       offset += size;
7173     }
7174   return offset;
7175 }
7176
7177
7178 /* Subroutine of fold_view_convert_expr.  Encode the INTEGER_CST,
7179    REAL_CST, COMPLEX_CST or VECTOR_CST specified by EXPR into the
7180    buffer PTR of length LEN bytes.  Return the number of bytes
7181    placed in the buffer, or zero upon failure.  */
7182
7183 static int
7184 native_encode_expr (tree expr, unsigned char *ptr, int len)
7185 {
7186   switch (TREE_CODE (expr))
7187     {
7188     case INTEGER_CST:
7189       return native_encode_int (expr, ptr, len);
7190
7191     case REAL_CST:
7192       return native_encode_real (expr, ptr, len);
7193
7194     case COMPLEX_CST:
7195       return native_encode_complex (expr, ptr, len);
7196
7197     case VECTOR_CST:
7198       return native_encode_vector (expr, ptr, len);
7199
7200     default:
7201       return 0;
7202     }
7203 }
7204
7205
7206 /* Subroutine of native_interpret_expr.  Interpret the contents of
7207    the buffer PTR of length LEN as an INTEGER_CST of type TYPE.
7208    If the buffer cannot be interpreted, return NULL_TREE.  */
7209
7210 static tree
7211 native_interpret_int (tree type, unsigned char *ptr, int len)
7212 {
7213   int total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7214   int byte, offset, word, words;
7215   unsigned char value;
7216   unsigned int HOST_WIDE_INT lo = 0;
7217   HOST_WIDE_INT hi = 0;
7218
7219   if (total_bytes > len)
7220     return NULL_TREE;
7221   if (total_bytes * BITS_PER_UNIT > 2 * HOST_BITS_PER_WIDE_INT)
7222     return NULL_TREE;
7223   words = total_bytes / UNITS_PER_WORD;
7224
7225   for (byte = 0; byte < total_bytes; byte++)
7226     {
7227       int bitpos = byte * BITS_PER_UNIT;
7228       if (total_bytes > UNITS_PER_WORD)
7229         {
7230           word = byte / UNITS_PER_WORD;
7231           if (WORDS_BIG_ENDIAN)
7232             word = (words - 1) - word;
7233           offset = word * UNITS_PER_WORD;
7234           if (BYTES_BIG_ENDIAN)
7235             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7236           else
7237             offset += byte % UNITS_PER_WORD;
7238         }
7239       else
7240         offset = BYTES_BIG_ENDIAN ? (total_bytes - 1) - byte : byte;
7241       value = ptr[offset];
7242
7243       if (bitpos < HOST_BITS_PER_WIDE_INT)
7244         lo |= (unsigned HOST_WIDE_INT) value << bitpos;
7245       else
7246         hi |= (unsigned HOST_WIDE_INT) value
7247               << (bitpos - HOST_BITS_PER_WIDE_INT);
7248     }
7249
7250   return force_fit_type (build_int_cst_wide (type, lo, hi),
7251                          0, false, false);
7252 }
7253
7254
7255 /* Subroutine of native_interpret_expr.  Interpret the contents of
7256    the buffer PTR of length LEN as a REAL_CST of type TYPE.
7257    If the buffer cannot be interpreted, return NULL_TREE.  */
7258
7259 static tree
7260 native_interpret_real (tree type, unsigned char *ptr, int len)
7261 {
7262   enum machine_mode mode = TYPE_MODE (type);
7263   int total_bytes = GET_MODE_SIZE (mode);
7264   int byte, offset, word, words, bitpos;
7265   unsigned char value;
7266   /* There are always 32 bits in each long, no matter the size of
7267      the hosts long.  We handle floating point representations with
7268      up to 192 bits.  */
7269   REAL_VALUE_TYPE r;
7270   long tmp[6];
7271
7272   total_bytes = GET_MODE_SIZE (TYPE_MODE (type));
7273   if (total_bytes > len || total_bytes > 24)
7274     return NULL_TREE;
7275   words = 32 / UNITS_PER_WORD;
7276
7277   memset (tmp, 0, sizeof (tmp));
7278   for (bitpos = 0; bitpos < total_bytes * BITS_PER_UNIT;
7279        bitpos += BITS_PER_UNIT)
7280     {
7281       byte = (bitpos / BITS_PER_UNIT) & 3;
7282       if (UNITS_PER_WORD < 4)
7283         {
7284           word = byte / UNITS_PER_WORD;
7285           if (WORDS_BIG_ENDIAN)
7286             word = (words - 1) - word;
7287           offset = word * UNITS_PER_WORD;
7288           if (BYTES_BIG_ENDIAN)
7289             offset += (UNITS_PER_WORD - 1) - (byte % UNITS_PER_WORD);
7290           else
7291             offset += byte % UNITS_PER_WORD;
7292         }
7293       else
7294         offset = BYTES_BIG_ENDIAN ? 3 - byte : byte;
7295       value = ptr[offset + ((bitpos / BITS_PER_UNIT) & ~3)];
7296
7297       tmp[bitpos / 32] |= (unsigned long)value << (bitpos & 31);
7298     }
7299
7300   real_from_target (&r, tmp, mode);
7301   return build_real (type, r);
7302 }
7303
7304
7305 /* Subroutine of native_interpret_expr.  Interpret the contents of
7306    the buffer PTR of length LEN as a COMPLEX_CST of type TYPE.
7307    If the buffer cannot be interpreted, return NULL_TREE.  */
7308
7309 static tree
7310 native_interpret_complex (tree type, unsigned char *ptr, int len)
7311 {
7312   tree etype, rpart, ipart;
7313   int size;
7314
7315   etype = TREE_TYPE (type);
7316   size = GET_MODE_SIZE (TYPE_MODE (etype));
7317   if (size * 2 > len)
7318     return NULL_TREE;
7319   rpart = native_interpret_expr (etype, ptr, size);
7320   if (!rpart)
7321     return NULL_TREE;
7322   ipart = native_interpret_expr (etype, ptr+size, size);
7323   if (!ipart)
7324     return NULL_TREE;
7325   return build_complex (type, rpart, ipart);
7326 }
7327
7328
7329 /* Subroutine of native_interpret_expr.  Interpret the contents of
7330    the buffer PTR of length LEN as a VECTOR_CST of type TYPE.
7331    If the buffer cannot be interpreted, return NULL_TREE.  */
7332
7333 static tree
7334 native_interpret_vector (tree type, unsigned char *ptr, int len)
7335 {
7336   tree etype, elem, elements;
7337   int i, size, count;
7338
7339   etype = TREE_TYPE (type);
7340   size = GET_MODE_SIZE (TYPE_MODE (etype));
7341   count = TYPE_VECTOR_SUBPARTS (type);
7342   if (size * count > len)
7343     return NULL_TREE;
7344
7345   elements = NULL_TREE;
7346   for (i = count - 1; i >= 0; i--)
7347     {
7348       elem = native_interpret_expr (etype, ptr+(i*size), size);
7349       if (!elem)
7350         return NULL_TREE;
7351       elements = tree_cons (NULL_TREE, elem, elements);
7352     }
7353   return build_vector (type, elements);
7354 }
7355
7356
7357 /* Subroutine of fold_view_convert_expr.  Interpret the contents of
7358    the buffer PTR of length LEN as a constant of type TYPE.  For
7359    INTEGRAL_TYPE_P we return an INTEGER_CST, for SCALAR_FLOAT_TYPE_P
7360    we return a REAL_CST, etc...  If the buffer cannot be interpreted,
7361    return NULL_TREE.  */
7362
7363 static tree
7364 native_interpret_expr (tree type, unsigned char *ptr, int len)
7365 {
7366   switch (TREE_CODE (type))
7367     {
7368     case INTEGER_TYPE:
7369     case ENUMERAL_TYPE:
7370     case BOOLEAN_TYPE:
7371       return native_interpret_int (type, ptr, len);
7372
7373     case REAL_TYPE:
7374       return native_interpret_real (type, ptr, len);
7375
7376     case COMPLEX_TYPE:
7377       return native_interpret_complex (type, ptr, len);
7378
7379     case VECTOR_TYPE:
7380       return native_interpret_vector (type, ptr, len);
7381
7382     default:
7383       return NULL_TREE;
7384     }
7385 }
7386
7387
7388 /* Fold a VIEW_CONVERT_EXPR of a constant expression EXPR to type
7389    TYPE at compile-time.  If we're unable to perform the conversion
7390    return NULL_TREE.  */
7391
7392 static tree
7393 fold_view_convert_expr (tree type, tree expr)
7394 {
7395   /* We support up to 512-bit values (for V8DFmode).  */
7396   unsigned char buffer[64];
7397   int len;
7398
7399   /* Check that the host and target are sane.  */
7400   if (CHAR_BIT != 8 || BITS_PER_UNIT != 8)
7401     return NULL_TREE;
7402
7403   len = native_encode_expr (expr, buffer, sizeof (buffer));
7404   if (len == 0)
7405     return NULL_TREE;
7406
7407   return native_interpret_expr (type, buffer, len);
7408 }
7409
7410
7411 /* Fold a unary expression of code CODE and type TYPE with operand
7412    OP0.  Return the folded expression if folding is successful.
7413    Otherwise, return NULL_TREE.  */
7414
7415 tree
7416 fold_unary (enum tree_code code, tree type, tree op0)
7417 {
7418   tree tem;
7419   tree arg0;
7420   enum tree_code_class kind = TREE_CODE_CLASS (code);
7421
7422   gcc_assert (IS_EXPR_CODE_CLASS (kind)
7423               && TREE_CODE_LENGTH (code) == 1);
7424
7425   arg0 = op0;
7426   if (arg0)
7427     {
7428       if (code == NOP_EXPR || code == CONVERT_EXPR
7429           || code == FLOAT_EXPR || code == ABS_EXPR)
7430         {
7431           /* Don't use STRIP_NOPS, because signedness of argument type
7432              matters.  */
7433           STRIP_SIGN_NOPS (arg0);
7434         }
7435       else
7436         {
7437           /* Strip any conversions that don't change the mode.  This
7438              is safe for every expression, except for a comparison
7439              expression because its signedness is derived from its
7440              operands.
7441
7442              Note that this is done as an internal manipulation within
7443              the constant folder, in order to find the simplest
7444              representation of the arguments so that their form can be
7445              studied.  In any cases, the appropriate type conversions
7446              should be put back in the tree that will get out of the
7447              constant folder.  */
7448           STRIP_NOPS (arg0);
7449         }
7450     }
7451
7452   if (TREE_CODE_CLASS (code) == tcc_unary)
7453     {
7454       if (TREE_CODE (arg0) == COMPOUND_EXPR)
7455         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7456                        fold_build1 (code, type, TREE_OPERAND (arg0, 1)));
7457       else if (TREE_CODE (arg0) == COND_EXPR)
7458         {
7459           tree arg01 = TREE_OPERAND (arg0, 1);
7460           tree arg02 = TREE_OPERAND (arg0, 2);
7461           if (! VOID_TYPE_P (TREE_TYPE (arg01)))
7462             arg01 = fold_build1 (code, type, arg01);
7463           if (! VOID_TYPE_P (TREE_TYPE (arg02)))
7464             arg02 = fold_build1 (code, type, arg02);
7465           tem = fold_build3 (COND_EXPR, type, TREE_OPERAND (arg0, 0),
7466                              arg01, arg02);
7467
7468           /* If this was a conversion, and all we did was to move into
7469              inside the COND_EXPR, bring it back out.  But leave it if
7470              it is a conversion from integer to integer and the
7471              result precision is no wider than a word since such a
7472              conversion is cheap and may be optimized away by combine,
7473              while it couldn't if it were outside the COND_EXPR.  Then return
7474              so we don't get into an infinite recursion loop taking the
7475              conversion out and then back in.  */
7476
7477           if ((code == NOP_EXPR || code == CONVERT_EXPR
7478                || code == NON_LVALUE_EXPR)
7479               && TREE_CODE (tem) == COND_EXPR
7480               && TREE_CODE (TREE_OPERAND (tem, 1)) == code
7481               && TREE_CODE (TREE_OPERAND (tem, 2)) == code
7482               && ! VOID_TYPE_P (TREE_OPERAND (tem, 1))
7483               && ! VOID_TYPE_P (TREE_OPERAND (tem, 2))
7484               && (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))
7485                   == TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 2), 0)))
7486               && (! (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7487                      && (INTEGRAL_TYPE_P
7488                          (TREE_TYPE (TREE_OPERAND (TREE_OPERAND (tem, 1), 0))))
7489                      && TYPE_PRECISION (TREE_TYPE (tem)) <= BITS_PER_WORD)
7490                   || flag_syntax_only))
7491             tem = build1 (code, type,
7492                           build3 (COND_EXPR,
7493                                   TREE_TYPE (TREE_OPERAND
7494                                              (TREE_OPERAND (tem, 1), 0)),
7495                                   TREE_OPERAND (tem, 0),
7496                                   TREE_OPERAND (TREE_OPERAND (tem, 1), 0),
7497                                   TREE_OPERAND (TREE_OPERAND (tem, 2), 0)));
7498           return tem;
7499         }
7500       else if (COMPARISON_CLASS_P (arg0))
7501         {
7502           if (TREE_CODE (type) == BOOLEAN_TYPE)
7503             {
7504               arg0 = copy_node (arg0);
7505               TREE_TYPE (arg0) = type;
7506               return arg0;
7507             }
7508           else if (TREE_CODE (type) != INTEGER_TYPE)
7509             return fold_build3 (COND_EXPR, type, arg0,
7510                                 fold_build1 (code, type,
7511                                              integer_one_node),
7512                                 fold_build1 (code, type,
7513                                              integer_zero_node));
7514         }
7515    }
7516
7517   switch (code)
7518     {
7519     case NOP_EXPR:
7520     case FLOAT_EXPR:
7521     case CONVERT_EXPR:
7522     case FIX_TRUNC_EXPR:
7523     case FIX_CEIL_EXPR:
7524     case FIX_FLOOR_EXPR:
7525     case FIX_ROUND_EXPR:
7526       if (TREE_TYPE (op0) == type)
7527         return op0;
7528       
7529       /* If we have (type) (a CMP b) and type is an integral type, return
7530          new expression involving the new type.  */
7531       if (COMPARISON_CLASS_P (op0) && INTEGRAL_TYPE_P (type))
7532         return fold_build2 (TREE_CODE (op0), type, TREE_OPERAND (op0, 0),
7533                             TREE_OPERAND (op0, 1));
7534
7535       /* Handle cases of two conversions in a row.  */
7536       if (TREE_CODE (op0) == NOP_EXPR
7537           || TREE_CODE (op0) == CONVERT_EXPR)
7538         {
7539           tree inside_type = TREE_TYPE (TREE_OPERAND (op0, 0));
7540           tree inter_type = TREE_TYPE (op0);
7541           int inside_int = INTEGRAL_TYPE_P (inside_type);
7542           int inside_ptr = POINTER_TYPE_P (inside_type);
7543           int inside_float = FLOAT_TYPE_P (inside_type);
7544           int inside_vec = TREE_CODE (inside_type) == VECTOR_TYPE;
7545           unsigned int inside_prec = TYPE_PRECISION (inside_type);
7546           int inside_unsignedp = TYPE_UNSIGNED (inside_type);
7547           int inter_int = INTEGRAL_TYPE_P (inter_type);
7548           int inter_ptr = POINTER_TYPE_P (inter_type);
7549           int inter_float = FLOAT_TYPE_P (inter_type);
7550           int inter_vec = TREE_CODE (inter_type) == VECTOR_TYPE;
7551           unsigned int inter_prec = TYPE_PRECISION (inter_type);
7552           int inter_unsignedp = TYPE_UNSIGNED (inter_type);
7553           int final_int = INTEGRAL_TYPE_P (type);
7554           int final_ptr = POINTER_TYPE_P (type);
7555           int final_float = FLOAT_TYPE_P (type);
7556           int final_vec = TREE_CODE (type) == VECTOR_TYPE;
7557           unsigned int final_prec = TYPE_PRECISION (type);
7558           int final_unsignedp = TYPE_UNSIGNED (type);
7559
7560           /* In addition to the cases of two conversions in a row
7561              handled below, if we are converting something to its own
7562              type via an object of identical or wider precision, neither
7563              conversion is needed.  */
7564           if (TYPE_MAIN_VARIANT (inside_type) == TYPE_MAIN_VARIANT (type)
7565               && (((inter_int || inter_ptr) && final_int)
7566                   || (inter_float && final_float))
7567               && inter_prec >= final_prec)
7568             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
7569
7570           /* Likewise, if the intermediate and final types are either both
7571              float or both integer, we don't need the middle conversion if
7572              it is wider than the final type and doesn't change the signedness
7573              (for integers).  Avoid this if the final type is a pointer
7574              since then we sometimes need the inner conversion.  Likewise if
7575              the outer has a precision not equal to the size of its mode.  */
7576           if ((((inter_int || inter_ptr) && (inside_int || inside_ptr))
7577                || (inter_float && inside_float)
7578                || (inter_vec && inside_vec))
7579               && inter_prec >= inside_prec
7580               && (inter_float || inter_vec
7581                   || inter_unsignedp == inside_unsignedp)
7582               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
7583                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
7584               && ! final_ptr
7585               && (! final_vec || inter_prec == inside_prec))
7586             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
7587
7588           /* If we have a sign-extension of a zero-extended value, we can
7589              replace that by a single zero-extension.  */
7590           if (inside_int && inter_int && final_int
7591               && inside_prec < inter_prec && inter_prec < final_prec
7592               && inside_unsignedp && !inter_unsignedp)
7593             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
7594
7595           /* Two conversions in a row are not needed unless:
7596              - some conversion is floating-point (overstrict for now), or
7597              - some conversion is a vector (overstrict for now), or
7598              - the intermediate type is narrower than both initial and
7599                final, or
7600              - the intermediate type and innermost type differ in signedness,
7601                and the outermost type is wider than the intermediate, or
7602              - the initial type is a pointer type and the precisions of the
7603                intermediate and final types differ, or
7604              - the final type is a pointer type and the precisions of the
7605                initial and intermediate types differ.
7606              - the final type is a pointer type and the initial type not
7607              - the initial type is a pointer to an array and the final type
7608                not.  */
7609           /* Java pointer type conversions generate checks in some
7610              cases, so we explicitly disallow this optimization.  */
7611           if (! inside_float && ! inter_float && ! final_float
7612               && ! inside_vec && ! inter_vec && ! final_vec
7613               && (inter_prec >= inside_prec || inter_prec >= final_prec)
7614               && ! (inside_int && inter_int
7615                     && inter_unsignedp != inside_unsignedp
7616                     && inter_prec < final_prec)
7617               && ((inter_unsignedp && inter_prec > inside_prec)
7618                   == (final_unsignedp && final_prec > inter_prec))
7619               && ! (inside_ptr && inter_prec != final_prec)
7620               && ! (final_ptr && inside_prec != inter_prec)
7621               && ! (final_prec != GET_MODE_BITSIZE (TYPE_MODE (type))
7622                     && TYPE_MODE (type) == TYPE_MODE (inter_type))
7623               && final_ptr == inside_ptr
7624               && ! (inside_ptr
7625                     && TREE_CODE (TREE_TYPE (inside_type)) == ARRAY_TYPE
7626                     && TREE_CODE (TREE_TYPE (type)) != ARRAY_TYPE)
7627               && ! ((strcmp (lang_hooks.name, "GNU Java") == 0)
7628                     && final_ptr))
7629             return fold_build1 (code, type, TREE_OPERAND (op0, 0));
7630         }
7631
7632       /* Handle (T *)&A.B.C for A being of type T and B and C
7633          living at offset zero.  This occurs frequently in
7634          C++ upcasting and then accessing the base.  */
7635       if (TREE_CODE (op0) == ADDR_EXPR
7636           && POINTER_TYPE_P (type)
7637           && handled_component_p (TREE_OPERAND (op0, 0)))
7638         {
7639           HOST_WIDE_INT bitsize, bitpos;
7640           tree offset;
7641           enum machine_mode mode;
7642           int unsignedp, volatilep;
7643           tree base = TREE_OPERAND (op0, 0);
7644           base = get_inner_reference (base, &bitsize, &bitpos, &offset,
7645                                       &mode, &unsignedp, &volatilep, false);
7646           /* If the reference was to a (constant) zero offset, we can use
7647              the address of the base if it has the same base type
7648              as the result type.  */
7649           if (! offset && bitpos == 0
7650               && TYPE_MAIN_VARIANT (TREE_TYPE (type))
7651                   == TYPE_MAIN_VARIANT (TREE_TYPE (base)))
7652             return fold_convert (type, build_fold_addr_expr (base));
7653         }
7654
7655       if (TREE_CODE (op0) == MODIFY_EXPR
7656           && TREE_CONSTANT (TREE_OPERAND (op0, 1))
7657           /* Detect assigning a bitfield.  */
7658           && !(TREE_CODE (TREE_OPERAND (op0, 0)) == COMPONENT_REF
7659                && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (op0, 0), 1))))
7660         {
7661           /* Don't leave an assignment inside a conversion
7662              unless assigning a bitfield.  */
7663           tem = fold_build1 (code, type, TREE_OPERAND (op0, 1));
7664           /* First do the assignment, then return converted constant.  */
7665           tem = build2 (COMPOUND_EXPR, TREE_TYPE (tem), op0, tem);
7666           TREE_NO_WARNING (tem) = 1;
7667           TREE_USED (tem) = 1;
7668           return tem;
7669         }
7670
7671       /* Convert (T)(x & c) into (T)x & (T)c, if c is an integer
7672          constants (if x has signed type, the sign bit cannot be set
7673          in c).  This folds extension into the BIT_AND_EXPR.  */
7674       if (INTEGRAL_TYPE_P (type)
7675           && TREE_CODE (type) != BOOLEAN_TYPE
7676           && TREE_CODE (op0) == BIT_AND_EXPR
7677           && TREE_CODE (TREE_OPERAND (op0, 1)) == INTEGER_CST)
7678         {
7679           tree and = op0;
7680           tree and0 = TREE_OPERAND (and, 0), and1 = TREE_OPERAND (and, 1);
7681           int change = 0;
7682
7683           if (TYPE_UNSIGNED (TREE_TYPE (and))
7684               || (TYPE_PRECISION (type)
7685                   <= TYPE_PRECISION (TREE_TYPE (and))))
7686             change = 1;
7687           else if (TYPE_PRECISION (TREE_TYPE (and1))
7688                    <= HOST_BITS_PER_WIDE_INT
7689                    && host_integerp (and1, 1))
7690             {
7691               unsigned HOST_WIDE_INT cst;
7692
7693               cst = tree_low_cst (and1, 1);
7694               cst &= (HOST_WIDE_INT) -1
7695                      << (TYPE_PRECISION (TREE_TYPE (and1)) - 1);
7696               change = (cst == 0);
7697 #ifdef LOAD_EXTEND_OP
7698               if (change
7699                   && !flag_syntax_only
7700                   && (LOAD_EXTEND_OP (TYPE_MODE (TREE_TYPE (and0)))
7701                       == ZERO_EXTEND))
7702                 {
7703                   tree uns = lang_hooks.types.unsigned_type (TREE_TYPE (and0));
7704                   and0 = fold_convert (uns, and0);
7705                   and1 = fold_convert (uns, and1);
7706                 }
7707 #endif
7708             }
7709           if (change)
7710             {
7711               tem = build_int_cst_wide (type, TREE_INT_CST_LOW (and1),
7712                                         TREE_INT_CST_HIGH (and1));
7713               tem = force_fit_type (tem, 0, TREE_OVERFLOW (and1),
7714                                     TREE_CONSTANT_OVERFLOW (and1));
7715               return fold_build2 (BIT_AND_EXPR, type,
7716                                   fold_convert (type, and0), tem);
7717             }
7718         }
7719
7720       /* Convert (T1)((T2)X op Y) into (T1)X op Y, for pointer types T1 and
7721          T2 being pointers to types of the same size.  */
7722       if (POINTER_TYPE_P (type)
7723           && BINARY_CLASS_P (arg0)
7724           && TREE_CODE (TREE_OPERAND (arg0, 0)) == NOP_EXPR
7725           && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (arg0, 0))))
7726         {
7727           tree arg00 = TREE_OPERAND (arg0, 0);
7728           tree t0 = type;
7729           tree t1 = TREE_TYPE (arg00);
7730           tree tt0 = TREE_TYPE (t0);
7731           tree tt1 = TREE_TYPE (t1);
7732           tree s0 = TYPE_SIZE (tt0);
7733           tree s1 = TYPE_SIZE (tt1);
7734
7735           if (s0 && s1 && operand_equal_p (s0, s1, OEP_ONLY_CONST))
7736             return build2 (TREE_CODE (arg0), t0, fold_convert (t0, arg00),
7737                            TREE_OPERAND (arg0, 1));
7738         }
7739
7740       /* Convert (T1)(~(T2)X) into ~(T1)X if T1 and T2 are integral types
7741          of the same precision, and X is a integer type not narrower than
7742          types T1 or T2, i.e. the cast (T2)X isn't an extension.  */
7743       if (INTEGRAL_TYPE_P (type)
7744           && TREE_CODE (op0) == BIT_NOT_EXPR
7745           && INTEGRAL_TYPE_P (TREE_TYPE (op0))
7746           && (TREE_CODE (TREE_OPERAND (op0, 0)) == NOP_EXPR
7747               || TREE_CODE (TREE_OPERAND (op0, 0)) == CONVERT_EXPR)
7748           && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (op0)))
7749         {
7750           tem = TREE_OPERAND (TREE_OPERAND (op0, 0), 0);
7751           if (INTEGRAL_TYPE_P (TREE_TYPE (tem))
7752               && TYPE_PRECISION (type) <= TYPE_PRECISION (TREE_TYPE (tem)))
7753             return fold_build1 (BIT_NOT_EXPR, type, fold_convert (type, tem));
7754         }
7755
7756       tem = fold_convert_const (code, type, op0);
7757       return tem ? tem : NULL_TREE;
7758
7759     case VIEW_CONVERT_EXPR:
7760       if (TREE_CODE (op0) == VIEW_CONVERT_EXPR)
7761         return fold_build1 (VIEW_CONVERT_EXPR, type, TREE_OPERAND (op0, 0));
7762       return fold_view_convert_expr (type, op0);
7763
7764     case NEGATE_EXPR:
7765       tem = fold_negate_expr (arg0);
7766       if (tem)
7767         return fold_convert (type, tem);
7768       return NULL_TREE;
7769
7770     case ABS_EXPR:
7771       if (TREE_CODE (arg0) == INTEGER_CST || TREE_CODE (arg0) == REAL_CST)
7772         return fold_abs_const (arg0, type);
7773       else if (TREE_CODE (arg0) == NEGATE_EXPR)
7774         return fold_build1 (ABS_EXPR, type, TREE_OPERAND (arg0, 0));
7775       /* Convert fabs((double)float) into (double)fabsf(float).  */
7776       else if (TREE_CODE (arg0) == NOP_EXPR
7777                && TREE_CODE (type) == REAL_TYPE)
7778         {
7779           tree targ0 = strip_float_extensions (arg0);
7780           if (targ0 != arg0)
7781             return fold_convert (type, fold_build1 (ABS_EXPR,
7782                                                     TREE_TYPE (targ0),
7783                                                     targ0));
7784         }
7785       /* ABS_EXPR<ABS_EXPR<x>> = ABS_EXPR<x> even if flag_wrapv is on.  */
7786       else if (TREE_CODE (arg0) == ABS_EXPR)
7787         return arg0;
7788       else if (tree_expr_nonnegative_p (arg0))
7789         return arg0;
7790
7791       /* Strip sign ops from argument.  */
7792       if (TREE_CODE (type) == REAL_TYPE)
7793         {
7794           tem = fold_strip_sign_ops (arg0);
7795           if (tem)
7796             return fold_build1 (ABS_EXPR, type, fold_convert (type, tem));
7797         }
7798       return NULL_TREE;
7799
7800     case CONJ_EXPR:
7801       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7802         return fold_convert (type, arg0);
7803       if (TREE_CODE (arg0) == COMPLEX_EXPR)
7804         {
7805           tree itype = TREE_TYPE (type);
7806           tree rpart = fold_convert (itype, TREE_OPERAND (arg0, 0));
7807           tree ipart = fold_convert (itype, TREE_OPERAND (arg0, 1));
7808           return fold_build2 (COMPLEX_EXPR, type, rpart, negate_expr (ipart));
7809         }
7810       if (TREE_CODE (arg0) == COMPLEX_CST)
7811         {
7812           tree itype = TREE_TYPE (type);
7813           tree rpart = fold_convert (itype, TREE_REALPART (arg0));
7814           tree ipart = fold_convert (itype, TREE_IMAGPART (arg0));
7815           return build_complex (type, rpart, negate_expr (ipart));
7816         }
7817       if (TREE_CODE (arg0) == CONJ_EXPR)
7818         return fold_convert (type, TREE_OPERAND (arg0, 0));
7819       return NULL_TREE;
7820
7821     case BIT_NOT_EXPR:
7822       if (TREE_CODE (arg0) == INTEGER_CST)
7823         return fold_not_const (arg0, type);
7824       else if (TREE_CODE (arg0) == BIT_NOT_EXPR)
7825         return TREE_OPERAND (arg0, 0);
7826       /* Convert ~ (-A) to A - 1.  */
7827       else if (INTEGRAL_TYPE_P (type) && TREE_CODE (arg0) == NEGATE_EXPR)
7828         return fold_build2 (MINUS_EXPR, type, TREE_OPERAND (arg0, 0),
7829                             build_int_cst (type, 1));
7830       /* Convert ~ (A - 1) or ~ (A + -1) to -A.  */
7831       else if (INTEGRAL_TYPE_P (type)
7832                && ((TREE_CODE (arg0) == MINUS_EXPR
7833                     && integer_onep (TREE_OPERAND (arg0, 1)))
7834                    || (TREE_CODE (arg0) == PLUS_EXPR
7835                        && integer_all_onesp (TREE_OPERAND (arg0, 1)))))
7836         return fold_build1 (NEGATE_EXPR, type, TREE_OPERAND (arg0, 0));
7837       /* Convert ~(X ^ Y) to ~X ^ Y or X ^ ~Y if ~X or ~Y simplify.  */
7838       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
7839                && (tem = fold_unary (BIT_NOT_EXPR, type,
7840                                      fold_convert (type,
7841                                                    TREE_OPERAND (arg0, 0)))))
7842         return fold_build2 (BIT_XOR_EXPR, type, tem,
7843                             fold_convert (type, TREE_OPERAND (arg0, 1)));
7844       else if (TREE_CODE (arg0) == BIT_XOR_EXPR
7845                && (tem = fold_unary (BIT_NOT_EXPR, type,
7846                                      fold_convert (type,
7847                                                    TREE_OPERAND (arg0, 1)))))
7848         return fold_build2 (BIT_XOR_EXPR, type,
7849                             fold_convert (type, TREE_OPERAND (arg0, 0)), tem);
7850
7851       return NULL_TREE;
7852
7853     case TRUTH_NOT_EXPR:
7854       /* The argument to invert_truthvalue must have Boolean type.  */
7855       if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
7856           arg0 = fold_convert (boolean_type_node, arg0);
7857
7858       /* Note that the operand of this must be an int
7859          and its values must be 0 or 1.
7860          ("true" is a fixed value perhaps depending on the language,
7861          but we don't handle values other than 1 correctly yet.)  */
7862       tem = fold_truth_not_expr (arg0);
7863       if (!tem)
7864         return NULL_TREE;
7865       return fold_convert (type, tem);
7866
7867     case REALPART_EXPR:
7868       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7869         return fold_convert (type, arg0);
7870       if (TREE_CODE (arg0) == COMPLEX_EXPR)
7871         return omit_one_operand (type, TREE_OPERAND (arg0, 0),
7872                                  TREE_OPERAND (arg0, 1));
7873       if (TREE_CODE (arg0) == COMPLEX_CST)
7874         return fold_convert (type, TREE_REALPART (arg0));
7875       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7876         {
7877           tree itype = TREE_TYPE (TREE_TYPE (arg0));
7878           tem = fold_build2 (TREE_CODE (arg0), itype,
7879                              fold_build1 (REALPART_EXPR, itype,
7880                                           TREE_OPERAND (arg0, 0)),
7881                              fold_build1 (REALPART_EXPR, itype,
7882                                           TREE_OPERAND (arg0, 1)));
7883           return fold_convert (type, tem);
7884         }
7885       if (TREE_CODE (arg0) == CONJ_EXPR)
7886         {
7887           tree itype = TREE_TYPE (TREE_TYPE (arg0));
7888           tem = fold_build1 (REALPART_EXPR, itype, TREE_OPERAND (arg0, 0));
7889           return fold_convert (type, tem);
7890         }
7891       return NULL_TREE;
7892
7893     case IMAGPART_EXPR:
7894       if (TREE_CODE (TREE_TYPE (arg0)) != COMPLEX_TYPE)
7895         return fold_convert (type, integer_zero_node);
7896       if (TREE_CODE (arg0) == COMPLEX_EXPR)
7897         return omit_one_operand (type, TREE_OPERAND (arg0, 1),
7898                                  TREE_OPERAND (arg0, 0));
7899       if (TREE_CODE (arg0) == COMPLEX_CST)
7900         return fold_convert (type, TREE_IMAGPART (arg0));
7901       if (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7902         {
7903           tree itype = TREE_TYPE (TREE_TYPE (arg0));
7904           tem = fold_build2 (TREE_CODE (arg0), itype,
7905                              fold_build1 (IMAGPART_EXPR, itype,
7906                                           TREE_OPERAND (arg0, 0)),
7907                              fold_build1 (IMAGPART_EXPR, itype,
7908                                           TREE_OPERAND (arg0, 1)));
7909           return fold_convert (type, tem);
7910         }
7911       if (TREE_CODE (arg0) == CONJ_EXPR)
7912         {
7913           tree itype = TREE_TYPE (TREE_TYPE (arg0));
7914           tem = fold_build1 (IMAGPART_EXPR, itype, TREE_OPERAND (arg0, 0));
7915           return fold_convert (type, negate_expr (tem));
7916         }
7917       return NULL_TREE;
7918
7919     default:
7920       return NULL_TREE;
7921     } /* switch (code) */
7922 }
7923
7924 /* Fold a binary expression of code CODE and type TYPE with operands
7925    OP0 and OP1, containing either a MIN-MAX or a MAX-MIN combination.
7926    Return the folded expression if folding is successful.  Otherwise,
7927    return NULL_TREE.  */
7928
7929 static tree
7930 fold_minmax (enum tree_code code, tree type, tree op0, tree op1)
7931 {
7932   enum tree_code compl_code;
7933
7934   if (code == MIN_EXPR)
7935     compl_code = MAX_EXPR;
7936   else if (code == MAX_EXPR)
7937     compl_code = MIN_EXPR;
7938   else
7939     gcc_unreachable ();
7940
7941   /* MIN (MAX (a, b), b) == b.  */
7942   if (TREE_CODE (op0) == compl_code
7943       && operand_equal_p (TREE_OPERAND (op0, 1), op1, 0))
7944     return omit_one_operand (type, op1, TREE_OPERAND (op0, 0));
7945
7946   /* MIN (MAX (b, a), b) == b.  */
7947   if (TREE_CODE (op0) == compl_code
7948       && operand_equal_p (TREE_OPERAND (op0, 0), op1, 0)
7949       && reorder_operands_p (TREE_OPERAND (op0, 1), op1))
7950     return omit_one_operand (type, op1, TREE_OPERAND (op0, 1));
7951
7952   /* MIN (a, MAX (a, b)) == a.  */
7953   if (TREE_CODE (op1) == compl_code
7954       && operand_equal_p (op0, TREE_OPERAND (op1, 0), 0)
7955       && reorder_operands_p (op0, TREE_OPERAND (op1, 1)))
7956     return omit_one_operand (type, op0, TREE_OPERAND (op1, 1));
7957
7958   /* MIN (a, MAX (b, a)) == a.  */
7959   if (TREE_CODE (op1) == compl_code
7960       && operand_equal_p (op0, TREE_OPERAND (op1, 1), 0)
7961       && reorder_operands_p (op0, TREE_OPERAND (op1, 0)))
7962     return omit_one_operand (type, op0, TREE_OPERAND (op1, 0));
7963
7964   return NULL_TREE;
7965 }
7966
7967 /* Subroutine of fold_binary.  This routine performs all of the
7968    transformations that are common to the equality/inequality
7969    operators (EQ_EXPR and NE_EXPR) and the ordering operators
7970    (LT_EXPR, LE_EXPR, GE_EXPR and GT_EXPR).  Callers other than
7971    fold_binary should call fold_binary.  Fold a comparison with
7972    tree code CODE and type TYPE with operands OP0 and OP1.  Return
7973    the folded comparison or NULL_TREE.  */
7974
7975 static tree
7976 fold_comparison (enum tree_code code, tree type, tree op0, tree op1)
7977 {
7978   tree arg0, arg1, tem;
7979
7980   arg0 = op0;
7981   arg1 = op1;
7982
7983   STRIP_SIGN_NOPS (arg0);
7984   STRIP_SIGN_NOPS (arg1);
7985
7986   tem = fold_relational_const (code, type, arg0, arg1);
7987   if (tem != NULL_TREE)
7988     return tem;
7989
7990   /* If one arg is a real or integer constant, put it last.  */
7991   if (tree_swap_operands_p (arg0, arg1, true))
7992     return fold_build2 (swap_tree_comparison (code), type, op1, op0);
7993
7994   /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1.  */
7995   if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
7996       && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7997           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
7998           && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
7999       && (TREE_CODE (arg1) == INTEGER_CST
8000           && !TREE_OVERFLOW (arg1)))
8001     {
8002       tree const1 = TREE_OPERAND (arg0, 1);
8003       tree const2 = arg1;
8004       tree variable = TREE_OPERAND (arg0, 0);
8005       tree lhs;
8006       int lhs_add;
8007       lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
8008
8009       lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
8010                          TREE_TYPE (arg1), const2, const1);
8011       if (TREE_CODE (lhs) == TREE_CODE (arg1)
8012           && (TREE_CODE (lhs) != INTEGER_CST
8013               || !TREE_OVERFLOW (lhs)))
8014         {
8015           fold_overflow_warning (("assuming signed overflow does not occur "
8016                                   "when changing X +- C1 cmp C2 to "
8017                                   "X cmp C1 +- C2"),
8018                                  WARN_STRICT_OVERFLOW_COMPARISON);
8019           return fold_build2 (code, type, variable, lhs);
8020         }
8021     }
8022
8023   /* If this is a comparison of two exprs that look like an ARRAY_REF of the
8024      same object, then we can fold this to a comparison of the two offsets in
8025      signed size type.  This is possible because pointer arithmetic is
8026      restricted to retain within an object and overflow on pointer differences
8027      is undefined as of 6.5.6/8 and /9 with respect to the signed ptrdiff_t.
8028
8029      We check flag_wrapv directly because pointers types are unsigned,
8030      and therefore TYPE_OVERFLOW_WRAPS returns true for them.  That is
8031      normally what we want to avoid certain odd overflow cases, but
8032      not here.  */
8033   if (POINTER_TYPE_P (TREE_TYPE (arg0))
8034       && !flag_wrapv
8035       && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (arg0)))
8036     {
8037       tree base0, offset0, base1, offset1;
8038
8039       if (extract_array_ref (arg0, &base0, &offset0)
8040           && extract_array_ref (arg1, &base1, &offset1)
8041           && operand_equal_p (base0, base1, 0))
8042         {
8043           tree signed_size_type_node;
8044           signed_size_type_node = signed_type_for (size_type_node);
8045
8046           /* By converting to signed size type we cover middle-end pointer
8047              arithmetic which operates on unsigned pointer types of size
8048              type size and ARRAY_REF offsets which are properly sign or
8049              zero extended from their type in case it is narrower than
8050              size type.  */
8051           if (offset0 == NULL_TREE)
8052             offset0 = build_int_cst (signed_size_type_node, 0);
8053           else
8054             offset0 = fold_convert (signed_size_type_node, offset0);
8055           if (offset1 == NULL_TREE)
8056             offset1 = build_int_cst (signed_size_type_node, 0);
8057           else
8058             offset1 = fold_convert (signed_size_type_node, offset1);
8059
8060           return fold_build2 (code, type, offset0, offset1);
8061         }
8062     }
8063
8064   if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
8065     {
8066       tree targ0 = strip_float_extensions (arg0);
8067       tree targ1 = strip_float_extensions (arg1);
8068       tree newtype = TREE_TYPE (targ0);
8069
8070       if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
8071         newtype = TREE_TYPE (targ1);
8072
8073       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
8074       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
8075         return fold_build2 (code, type, fold_convert (newtype, targ0),
8076                             fold_convert (newtype, targ1));
8077
8078       /* (-a) CMP (-b) -> b CMP a  */
8079       if (TREE_CODE (arg0) == NEGATE_EXPR
8080           && TREE_CODE (arg1) == NEGATE_EXPR)
8081         return fold_build2 (code, type, TREE_OPERAND (arg1, 0),
8082                             TREE_OPERAND (arg0, 0));
8083
8084       if (TREE_CODE (arg1) == REAL_CST)
8085         {
8086           REAL_VALUE_TYPE cst;
8087           cst = TREE_REAL_CST (arg1);
8088
8089           /* (-a) CMP CST -> a swap(CMP) (-CST)  */
8090           if (TREE_CODE (arg0) == NEGATE_EXPR)
8091             return fold_build2 (swap_tree_comparison (code), type,
8092                                 TREE_OPERAND (arg0, 0),
8093                                 build_real (TREE_TYPE (arg1),
8094                                             REAL_VALUE_NEGATE (cst)));
8095
8096           /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
8097           /* a CMP (-0) -> a CMP 0  */
8098           if (REAL_VALUE_MINUS_ZERO (cst))
8099             return fold_build2 (code, type, arg0,
8100                                 build_real (TREE_TYPE (arg1), dconst0));
8101
8102           /* x != NaN is always true, other ops are always false.  */
8103           if (REAL_VALUE_ISNAN (cst)
8104               && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
8105             {
8106               tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
8107               return omit_one_operand (type, tem, arg0);
8108             }
8109
8110           /* Fold comparisons against infinity.  */
8111           if (REAL_VALUE_ISINF (cst))
8112             {
8113               tem = fold_inf_compare (code, type, arg0, arg1);
8114               if (tem != NULL_TREE)
8115                 return tem;
8116             }
8117         }
8118
8119       /* If this is a comparison of a real constant with a PLUS_EXPR
8120          or a MINUS_EXPR of a real constant, we can convert it into a
8121          comparison with a revised real constant as long as no overflow
8122          occurs when unsafe_math_optimizations are enabled.  */
8123       if (flag_unsafe_math_optimizations
8124           && TREE_CODE (arg1) == REAL_CST
8125           && (TREE_CODE (arg0) == PLUS_EXPR
8126               || TREE_CODE (arg0) == MINUS_EXPR)
8127           && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
8128           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
8129                                       ? MINUS_EXPR : PLUS_EXPR,
8130                                       arg1, TREE_OPERAND (arg0, 1), 0))
8131           && ! TREE_CONSTANT_OVERFLOW (tem))
8132         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
8133
8134       /* Likewise, we can simplify a comparison of a real constant with
8135          a MINUS_EXPR whose first operand is also a real constant, i.e.
8136          (c1 - x) < c2 becomes x > c1-c2.  */
8137       if (flag_unsafe_math_optimizations
8138           && TREE_CODE (arg1) == REAL_CST
8139           && TREE_CODE (arg0) == MINUS_EXPR
8140           && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
8141           && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
8142                                       arg1, 0))
8143           && ! TREE_CONSTANT_OVERFLOW (tem))
8144         return fold_build2 (swap_tree_comparison (code), type,
8145                             TREE_OPERAND (arg0, 1), tem);
8146
8147       /* Fold comparisons against built-in math functions.  */
8148       if (TREE_CODE (arg1) == REAL_CST
8149           && flag_unsafe_math_optimizations
8150           && ! flag_errno_math)
8151         {
8152           enum built_in_function fcode = builtin_mathfn_code (arg0);
8153
8154           if (fcode != END_BUILTINS)
8155             {
8156               tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
8157               if (tem != NULL_TREE)
8158                 return tem;
8159             }
8160         }
8161     }
8162
8163   /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
8164   if (TREE_CONSTANT (arg1)
8165       && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
8166           || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
8167       /* This optimization is invalid for ordered comparisons
8168          if CONST+INCR overflows or if foo+incr might overflow.
8169          This optimization is invalid for floating point due to rounding.
8170          For pointer types we assume overflow doesn't happen.  */
8171       && (POINTER_TYPE_P (TREE_TYPE (arg0))
8172           || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
8173               && (code == EQ_EXPR || code == NE_EXPR))))
8174     {
8175       tree varop, newconst;
8176
8177       if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
8178         {
8179           newconst = fold_build2 (PLUS_EXPR, TREE_TYPE (arg0),
8180                                   arg1, TREE_OPERAND (arg0, 1));
8181           varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
8182                           TREE_OPERAND (arg0, 0),
8183                           TREE_OPERAND (arg0, 1));
8184         }
8185       else
8186         {
8187           newconst = fold_build2 (MINUS_EXPR, TREE_TYPE (arg0),
8188                                   arg1, TREE_OPERAND (arg0, 1));
8189           varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
8190                           TREE_OPERAND (arg0, 0),
8191                           TREE_OPERAND (arg0, 1));
8192         }
8193
8194
8195       /* If VAROP is a reference to a bitfield, we must mask
8196          the constant by the width of the field.  */
8197       if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
8198           && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1))
8199           && host_integerp (DECL_SIZE (TREE_OPERAND
8200                                          (TREE_OPERAND (varop, 0), 1)), 1))
8201         {
8202           tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
8203           HOST_WIDE_INT size = tree_low_cst (DECL_SIZE (fielddecl), 1);
8204           tree folded_compare, shift;
8205
8206           /* First check whether the comparison would come out
8207              always the same.  If we don't do that we would
8208              change the meaning with the masking.  */
8209           folded_compare = fold_build2 (code, type,
8210                                         TREE_OPERAND (varop, 0), arg1);
8211           if (TREE_CODE (folded_compare) == INTEGER_CST)
8212             return omit_one_operand (type, folded_compare, varop);
8213
8214           shift = build_int_cst (NULL_TREE,
8215                                  TYPE_PRECISION (TREE_TYPE (varop)) - size);
8216           shift = fold_convert (TREE_TYPE (varop), shift);
8217           newconst = fold_build2 (LSHIFT_EXPR, TREE_TYPE (varop),
8218                                   newconst, shift);
8219           newconst = fold_build2 (RSHIFT_EXPR, TREE_TYPE (varop),
8220                                   newconst, shift);
8221         }
8222
8223       return fold_build2 (code, type, varop, newconst);
8224     }
8225
8226   if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
8227       && (TREE_CODE (arg0) == NOP_EXPR
8228           || TREE_CODE (arg0) == CONVERT_EXPR))
8229     {
8230       /* If we are widening one operand of an integer comparison,
8231          see if the other operand is similarly being widened.  Perhaps we
8232          can do the comparison in the narrower type.  */
8233       tem = fold_widened_comparison (code, type, arg0, arg1);
8234       if (tem)
8235         return tem;
8236
8237       /* Or if we are changing signedness.  */
8238       tem = fold_sign_changed_comparison (code, type, arg0, arg1);
8239       if (tem)
8240         return tem;
8241     }
8242
8243   /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
8244      constant, we can simplify it.  */
8245   if (TREE_CODE (arg1) == INTEGER_CST
8246       && (TREE_CODE (arg0) == MIN_EXPR
8247           || TREE_CODE (arg0) == MAX_EXPR)
8248       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8249     {
8250       tem = optimize_minmax_comparison (code, type, op0, op1);
8251       if (tem)
8252         return tem;
8253     }
8254
8255   /* Simplify comparison of something with itself.  (For IEEE
8256      floating-point, we can only do some of these simplifications.)  */
8257   if (operand_equal_p (arg0, arg1, 0))
8258     {
8259       switch (code)
8260         {
8261         case EQ_EXPR:
8262           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8263               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8264             return constant_boolean_node (1, type);
8265           break;
8266
8267         case GE_EXPR:
8268         case LE_EXPR:
8269           if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
8270               || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8271             return constant_boolean_node (1, type);
8272           return fold_build2 (EQ_EXPR, type, arg0, arg1);
8273
8274         case NE_EXPR:
8275           /* For NE, we can only do this simplification if integer
8276              or we don't honor IEEE floating point NaNs.  */
8277           if (FLOAT_TYPE_P (TREE_TYPE (arg0))
8278               && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
8279             break;
8280           /* ... fall through ...  */
8281         case GT_EXPR:
8282         case LT_EXPR:
8283           return constant_boolean_node (0, type);
8284         default:
8285           gcc_unreachable ();
8286         }
8287     }
8288
8289   /* If we are comparing an expression that just has comparisons
8290      of two integer values, arithmetic expressions of those comparisons,
8291      and constants, we can simplify it.  There are only three cases
8292      to check: the two values can either be equal, the first can be
8293      greater, or the second can be greater.  Fold the expression for
8294      those three values.  Since each value must be 0 or 1, we have
8295      eight possibilities, each of which corresponds to the constant 0
8296      or 1 or one of the six possible comparisons.
8297
8298      This handles common cases like (a > b) == 0 but also handles
8299      expressions like  ((x > y) - (y > x)) > 0, which supposedly
8300      occur in macroized code.  */
8301
8302   if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
8303     {
8304       tree cval1 = 0, cval2 = 0;
8305       int save_p = 0;
8306
8307       if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
8308           /* Don't handle degenerate cases here; they should already
8309              have been handled anyway.  */
8310           && cval1 != 0 && cval2 != 0
8311           && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
8312           && TREE_TYPE (cval1) == TREE_TYPE (cval2)
8313           && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
8314           && TYPE_MAX_VALUE (TREE_TYPE (cval1))
8315           && TYPE_MAX_VALUE (TREE_TYPE (cval2))
8316           && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
8317                                 TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
8318         {
8319           tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
8320           tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
8321
8322           /* We can't just pass T to eval_subst in case cval1 or cval2
8323              was the same as ARG1.  */
8324
8325           tree high_result
8326                 = fold_build2 (code, type,
8327                                eval_subst (arg0, cval1, maxval,
8328                                            cval2, minval),
8329                                arg1);
8330           tree equal_result
8331                 = fold_build2 (code, type,
8332                                eval_subst (arg0, cval1, maxval,
8333                                            cval2, maxval),
8334                                arg1);
8335           tree low_result
8336                 = fold_build2 (code, type,
8337                                eval_subst (arg0, cval1, minval,
8338                                            cval2, maxval),
8339                                arg1);
8340
8341           /* All three of these results should be 0 or 1.  Confirm they are.
8342              Then use those values to select the proper code to use.  */
8343
8344           if (TREE_CODE (high_result) == INTEGER_CST
8345               && TREE_CODE (equal_result) == INTEGER_CST
8346               && TREE_CODE (low_result) == INTEGER_CST)
8347             {
8348               /* Make a 3-bit mask with the high-order bit being the
8349                  value for `>', the next for '=', and the low for '<'.  */
8350               switch ((integer_onep (high_result) * 4)
8351                       + (integer_onep (equal_result) * 2)
8352                       + integer_onep (low_result))
8353                 {
8354                 case 0:
8355                   /* Always false.  */
8356                   return omit_one_operand (type, integer_zero_node, arg0);
8357                 case 1:
8358                   code = LT_EXPR;
8359                   break;
8360                 case 2:
8361                   code = EQ_EXPR;
8362                   break;
8363                 case 3:
8364                   code = LE_EXPR;
8365                   break;
8366                 case 4:
8367                   code = GT_EXPR;
8368                   break;
8369                 case 5:
8370                   code = NE_EXPR;
8371                   break;
8372                 case 6:
8373                   code = GE_EXPR;
8374                   break;
8375                 case 7:
8376                   /* Always true.  */
8377                   return omit_one_operand (type, integer_one_node, arg0);
8378                 }
8379
8380               if (save_p)
8381                 return save_expr (build2 (code, type, cval1, cval2));
8382               return fold_build2 (code, type, cval1, cval2);
8383             }
8384         }
8385     }
8386
8387   /* Fold a comparison of the address of COMPONENT_REFs with the same
8388      type and component to a comparison of the address of the base
8389      object.  In short, &x->a OP &y->a to x OP y and
8390      &x->a OP &y.a to x OP &y  */
8391   if (TREE_CODE (arg0) == ADDR_EXPR
8392       && TREE_CODE (TREE_OPERAND (arg0, 0)) == COMPONENT_REF
8393       && TREE_CODE (arg1) == ADDR_EXPR
8394       && TREE_CODE (TREE_OPERAND (arg1, 0)) == COMPONENT_REF)
8395     {
8396       tree cref0 = TREE_OPERAND (arg0, 0);
8397       tree cref1 = TREE_OPERAND (arg1, 0);
8398       if (TREE_OPERAND (cref0, 1) == TREE_OPERAND (cref1, 1))
8399         {
8400           tree op0 = TREE_OPERAND (cref0, 0);
8401           tree op1 = TREE_OPERAND (cref1, 0);
8402           return fold_build2 (code, type,
8403                               build_fold_addr_expr (op0),
8404                               build_fold_addr_expr (op1));
8405         }
8406     }
8407
8408   /* We can fold X/C1 op C2 where C1 and C2 are integer constants
8409      into a single range test.  */
8410   if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
8411        || TREE_CODE (arg0) == EXACT_DIV_EXPR)
8412       && TREE_CODE (arg1) == INTEGER_CST
8413       && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8414       && !integer_zerop (TREE_OPERAND (arg0, 1))
8415       && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
8416       && !TREE_OVERFLOW (arg1))
8417     {
8418       tem = fold_div_compare (code, type, arg0, arg1);
8419       if (tem != NULL_TREE)
8420         return tem;
8421     }
8422
8423   return NULL_TREE;
8424 }
8425
8426
8427 /* Subroutine of fold_binary.  Optimize complex multiplications of the
8428    form z * conj(z), as pow(realpart(z),2) + pow(imagpart(z),2).  The
8429    argument EXPR represents the expression "z" of type TYPE.  */
8430
8431 static tree
8432 fold_mult_zconjz (tree type, tree expr)
8433 {
8434   tree itype = TREE_TYPE (type);
8435   tree rpart, ipart, tem;
8436
8437   if (TREE_CODE (expr) == COMPLEX_EXPR)
8438     {
8439       rpart = TREE_OPERAND (expr, 0);
8440       ipart = TREE_OPERAND (expr, 1);
8441     }
8442   else if (TREE_CODE (expr) == COMPLEX_CST)
8443     {
8444       rpart = TREE_REALPART (expr);
8445       ipart = TREE_IMAGPART (expr);
8446     }
8447   else
8448     {
8449       expr = save_expr (expr);
8450       rpart = fold_build1 (REALPART_EXPR, itype, expr);
8451       ipart = fold_build1 (IMAGPART_EXPR, itype, expr);
8452     }
8453
8454   rpart = save_expr (rpart);
8455   ipart = save_expr (ipart);
8456   tem = fold_build2 (PLUS_EXPR, itype,
8457                      fold_build2 (MULT_EXPR, itype, rpart, rpart),
8458                      fold_build2 (MULT_EXPR, itype, ipart, ipart));
8459   return fold_build2 (COMPLEX_EXPR, type, tem,
8460                       fold_convert (itype, integer_zero_node));
8461 }
8462
8463
8464 /* Fold a binary expression of code CODE and type TYPE with operands
8465    OP0 and OP1.  Return the folded expression if folding is
8466    successful.  Otherwise, return NULL_TREE.  */
8467
8468 tree
8469 fold_binary (enum tree_code code, tree type, tree op0, tree op1)
8470 {
8471   enum tree_code_class kind = TREE_CODE_CLASS (code);
8472   tree arg0, arg1, tem;
8473   tree t1 = NULL_TREE;
8474   bool strict_overflow_p;
8475
8476   gcc_assert (IS_EXPR_CODE_CLASS (kind)
8477               && TREE_CODE_LENGTH (code) == 2
8478               && op0 != NULL_TREE
8479               && op1 != NULL_TREE);
8480
8481   arg0 = op0;
8482   arg1 = op1;
8483
8484   /* Strip any conversions that don't change the mode.  This is
8485      safe for every expression, except for a comparison expression
8486      because its signedness is derived from its operands.  So, in
8487      the latter case, only strip conversions that don't change the
8488      signedness.
8489
8490      Note that this is done as an internal manipulation within the
8491      constant folder, in order to find the simplest representation
8492      of the arguments so that their form can be studied.  In any
8493      cases, the appropriate type conversions should be put back in
8494      the tree that will get out of the constant folder.  */
8495
8496   if (kind == tcc_comparison)
8497     {
8498       STRIP_SIGN_NOPS (arg0);
8499       STRIP_SIGN_NOPS (arg1);
8500     }
8501   else
8502     {
8503       STRIP_NOPS (arg0);
8504       STRIP_NOPS (arg1);
8505     }
8506
8507   /* Note that TREE_CONSTANT isn't enough: static var addresses are
8508      constant but we can't do arithmetic on them.  */
8509   if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
8510       || (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
8511       || (TREE_CODE (arg0) == COMPLEX_CST && TREE_CODE (arg1) == COMPLEX_CST)
8512       || (TREE_CODE (arg0) == VECTOR_CST && TREE_CODE (arg1) == VECTOR_CST))
8513     {
8514       if (kind == tcc_binary)
8515         tem = const_binop (code, arg0, arg1, 0);
8516       else if (kind == tcc_comparison)
8517         tem = fold_relational_const (code, type, arg0, arg1);
8518       else
8519         tem = NULL_TREE;
8520
8521       if (tem != NULL_TREE)
8522         {
8523           if (TREE_TYPE (tem) != type)
8524             tem = fold_convert (type, tem);
8525           return tem;
8526         }
8527     }
8528
8529   /* If this is a commutative operation, and ARG0 is a constant, move it
8530      to ARG1 to reduce the number of tests below.  */
8531   if (commutative_tree_code (code)
8532       && tree_swap_operands_p (arg0, arg1, true))
8533     return fold_build2 (code, type, op1, op0);
8534
8535   /* ARG0 is the first operand of EXPR, and ARG1 is the second operand.
8536
8537      First check for cases where an arithmetic operation is applied to a
8538      compound, conditional, or comparison operation.  Push the arithmetic
8539      operation inside the compound or conditional to see if any folding
8540      can then be done.  Convert comparison to conditional for this purpose.
8541      The also optimizes non-constant cases that used to be done in
8542      expand_expr.
8543
8544      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
8545      one of the operands is a comparison and the other is a comparison, a
8546      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
8547      code below would make the expression more complex.  Change it to a
8548      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
8549      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
8550
8551   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
8552        || code == EQ_EXPR || code == NE_EXPR)
8553       && ((truth_value_p (TREE_CODE (arg0))
8554            && (truth_value_p (TREE_CODE (arg1))
8555                || (TREE_CODE (arg1) == BIT_AND_EXPR
8556                    && integer_onep (TREE_OPERAND (arg1, 1)))))
8557           || (truth_value_p (TREE_CODE (arg1))
8558               && (truth_value_p (TREE_CODE (arg0))
8559                   || (TREE_CODE (arg0) == BIT_AND_EXPR
8560                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
8561     {
8562       tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
8563                          : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
8564                          : TRUTH_XOR_EXPR,
8565                          boolean_type_node,
8566                          fold_convert (boolean_type_node, arg0),
8567                          fold_convert (boolean_type_node, arg1));
8568
8569       if (code == EQ_EXPR)
8570         tem = invert_truthvalue (tem);
8571
8572       return fold_convert (type, tem);
8573     }
8574
8575   if (TREE_CODE_CLASS (code) == tcc_binary
8576       || TREE_CODE_CLASS (code) == tcc_comparison)
8577     {
8578       if (TREE_CODE (arg0) == COMPOUND_EXPR)
8579         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
8580                        fold_build2 (code, type,
8581                                     TREE_OPERAND (arg0, 1), op1));
8582       if (TREE_CODE (arg1) == COMPOUND_EXPR
8583           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
8584         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
8585                        fold_build2 (code, type,
8586                                     op0, TREE_OPERAND (arg1, 1)));
8587
8588       if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
8589         {
8590           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
8591                                                      arg0, arg1, 
8592                                                      /*cond_first_p=*/1);
8593           if (tem != NULL_TREE)
8594             return tem;
8595         }
8596
8597       if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
8598         {
8599           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
8600                                                      arg1, arg0, 
8601                                                      /*cond_first_p=*/0);
8602           if (tem != NULL_TREE)
8603             return tem;
8604         }
8605     }
8606
8607   switch (code)
8608     {
8609     case PLUS_EXPR:
8610       /* A + (-B) -> A - B */
8611       if (TREE_CODE (arg1) == NEGATE_EXPR)
8612         return fold_build2 (MINUS_EXPR, type,
8613                             fold_convert (type, arg0),
8614                             fold_convert (type, TREE_OPERAND (arg1, 0)));
8615       /* (-A) + B -> B - A */
8616       if (TREE_CODE (arg0) == NEGATE_EXPR
8617           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
8618         return fold_build2 (MINUS_EXPR, type,
8619                             fold_convert (type, arg1),
8620                             fold_convert (type, TREE_OPERAND (arg0, 0)));
8621       /* Convert ~A + 1 to -A.  */
8622       if (INTEGRAL_TYPE_P (type)
8623           && TREE_CODE (arg0) == BIT_NOT_EXPR
8624           && integer_onep (arg1))
8625         return fold_build1 (NEGATE_EXPR, type, TREE_OPERAND (arg0, 0));
8626
8627       /* Handle (A1 * C1) + (A2 * C2) with A1, A2 or C1, C2 being the
8628          same or one.  */
8629       if ((TREE_CODE (arg0) == MULT_EXPR
8630            || TREE_CODE (arg1) == MULT_EXPR)
8631           && (!FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
8632         {
8633           tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
8634           if (tem)
8635             return tem;
8636         }
8637
8638       if (! FLOAT_TYPE_P (type))
8639         {
8640           if (integer_zerop (arg1))
8641             return non_lvalue (fold_convert (type, arg0));
8642
8643           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
8644              with a constant, and the two constants have no bits in common,
8645              we should treat this as a BIT_IOR_EXPR since this may produce more
8646              simplifications.  */
8647           if (TREE_CODE (arg0) == BIT_AND_EXPR
8648               && TREE_CODE (arg1) == BIT_AND_EXPR
8649               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8650               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
8651               && integer_zerop (const_binop (BIT_AND_EXPR,
8652                                              TREE_OPERAND (arg0, 1),
8653                                              TREE_OPERAND (arg1, 1), 0)))
8654             {
8655               code = BIT_IOR_EXPR;
8656               goto bit_ior;
8657             }
8658
8659           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
8660              (plus (plus (mult) (mult)) (foo)) so that we can
8661              take advantage of the factoring cases below.  */
8662           if (((TREE_CODE (arg0) == PLUS_EXPR
8663                 || TREE_CODE (arg0) == MINUS_EXPR)
8664                && TREE_CODE (arg1) == MULT_EXPR)
8665               || ((TREE_CODE (arg1) == PLUS_EXPR
8666                    || TREE_CODE (arg1) == MINUS_EXPR)
8667                   && TREE_CODE (arg0) == MULT_EXPR))
8668             {
8669               tree parg0, parg1, parg, marg;
8670               enum tree_code pcode;
8671
8672               if (TREE_CODE (arg1) == MULT_EXPR)
8673                 parg = arg0, marg = arg1;
8674               else
8675                 parg = arg1, marg = arg0;
8676               pcode = TREE_CODE (parg);
8677               parg0 = TREE_OPERAND (parg, 0);
8678               parg1 = TREE_OPERAND (parg, 1);
8679               STRIP_NOPS (parg0);
8680               STRIP_NOPS (parg1);
8681
8682               if (TREE_CODE (parg0) == MULT_EXPR
8683                   && TREE_CODE (parg1) != MULT_EXPR)
8684                 return fold_build2 (pcode, type,
8685                                     fold_build2 (PLUS_EXPR, type,
8686                                                  fold_convert (type, parg0),
8687                                                  fold_convert (type, marg)),
8688                                     fold_convert (type, parg1));
8689               if (TREE_CODE (parg0) != MULT_EXPR
8690                   && TREE_CODE (parg1) == MULT_EXPR)
8691                 return fold_build2 (PLUS_EXPR, type,
8692                                     fold_convert (type, parg0),
8693                                     fold_build2 (pcode, type,
8694                                                  fold_convert (type, marg),
8695                                                  fold_convert (type,
8696                                                                parg1)));
8697             }
8698
8699           /* Try replacing &a[i1] + c * i2 with &a[i1 + i2], if c is step
8700              of the array.  Loop optimizer sometimes produce this type of
8701              expressions.  */
8702           if (TREE_CODE (arg0) == ADDR_EXPR)
8703             {
8704               tem = try_move_mult_to_index (PLUS_EXPR, arg0, arg1);
8705               if (tem)
8706                 return fold_convert (type, tem);
8707             }
8708           else if (TREE_CODE (arg1) == ADDR_EXPR)
8709             {
8710               tem = try_move_mult_to_index (PLUS_EXPR, arg1, arg0);
8711               if (tem)
8712                 return fold_convert (type, tem);
8713             }
8714         }
8715       else
8716         {
8717           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
8718           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
8719             return non_lvalue (fold_convert (type, arg0));
8720
8721           /* Likewise if the operands are reversed.  */
8722           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
8723             return non_lvalue (fold_convert (type, arg1));
8724
8725           /* Convert X + -C into X - C.  */
8726           if (TREE_CODE (arg1) == REAL_CST
8727               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
8728             {
8729               tem = fold_negate_const (arg1, type);
8730               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
8731                 return fold_build2 (MINUS_EXPR, type,
8732                                     fold_convert (type, arg0),
8733                                     fold_convert (type, tem));
8734             }
8735
8736           if (flag_unsafe_math_optimizations
8737               && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
8738               && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
8739               && (tem = distribute_real_division (code, type, arg0, arg1)))
8740             return tem;
8741
8742           /* Convert x+x into x*2.0.  */
8743           if (operand_equal_p (arg0, arg1, 0)
8744               && SCALAR_FLOAT_TYPE_P (type))
8745             return fold_build2 (MULT_EXPR, type, arg0,
8746                                 build_real (type, dconst2));
8747
8748           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.  */
8749           if (flag_unsafe_math_optimizations
8750               && TREE_CODE (arg1) == PLUS_EXPR
8751               && TREE_CODE (arg0) != MULT_EXPR)
8752             {
8753               tree tree10 = TREE_OPERAND (arg1, 0);
8754               tree tree11 = TREE_OPERAND (arg1, 1);
8755               if (TREE_CODE (tree11) == MULT_EXPR
8756                   && TREE_CODE (tree10) == MULT_EXPR)
8757                 {
8758                   tree tree0;
8759                   tree0 = fold_build2 (PLUS_EXPR, type, arg0, tree10);
8760                   return fold_build2 (PLUS_EXPR, type, tree0, tree11);
8761                 }
8762             }
8763           /* Convert (b*c + d*e) + a into b*c + (d*e +a).  */
8764           if (flag_unsafe_math_optimizations
8765               && TREE_CODE (arg0) == PLUS_EXPR
8766               && TREE_CODE (arg1) != MULT_EXPR)
8767             {
8768               tree tree00 = TREE_OPERAND (arg0, 0);
8769               tree tree01 = TREE_OPERAND (arg0, 1);
8770               if (TREE_CODE (tree01) == MULT_EXPR
8771                   && TREE_CODE (tree00) == MULT_EXPR)
8772                 {
8773                   tree tree0;
8774                   tree0 = fold_build2 (PLUS_EXPR, type, tree01, arg1);
8775                   return fold_build2 (PLUS_EXPR, type, tree00, tree0);
8776                 }
8777             }
8778         }
8779
8780      bit_rotate:
8781       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
8782          is a rotate of A by C1 bits.  */
8783       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
8784          is a rotate of A by B bits.  */
8785       {
8786         enum tree_code code0, code1;
8787         code0 = TREE_CODE (arg0);
8788         code1 = TREE_CODE (arg1);
8789         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
8790              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
8791             && operand_equal_p (TREE_OPERAND (arg0, 0),
8792                                 TREE_OPERAND (arg1, 0), 0)
8793             && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
8794           {
8795             tree tree01, tree11;
8796             enum tree_code code01, code11;
8797
8798             tree01 = TREE_OPERAND (arg0, 1);
8799             tree11 = TREE_OPERAND (arg1, 1);
8800             STRIP_NOPS (tree01);
8801             STRIP_NOPS (tree11);
8802             code01 = TREE_CODE (tree01);
8803             code11 = TREE_CODE (tree11);
8804             if (code01 == INTEGER_CST
8805                 && code11 == INTEGER_CST
8806                 && TREE_INT_CST_HIGH (tree01) == 0
8807                 && TREE_INT_CST_HIGH (tree11) == 0
8808                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
8809                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
8810               return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
8811                              code0 == LSHIFT_EXPR ? tree01 : tree11);
8812             else if (code11 == MINUS_EXPR)
8813               {
8814                 tree tree110, tree111;
8815                 tree110 = TREE_OPERAND (tree11, 0);
8816                 tree111 = TREE_OPERAND (tree11, 1);
8817                 STRIP_NOPS (tree110);
8818                 STRIP_NOPS (tree111);
8819                 if (TREE_CODE (tree110) == INTEGER_CST
8820                     && 0 == compare_tree_int (tree110,
8821                                               TYPE_PRECISION
8822                                               (TREE_TYPE (TREE_OPERAND
8823                                                           (arg0, 0))))
8824                     && operand_equal_p (tree01, tree111, 0))
8825                   return build2 ((code0 == LSHIFT_EXPR
8826                                   ? LROTATE_EXPR
8827                                   : RROTATE_EXPR),
8828                                  type, TREE_OPERAND (arg0, 0), tree01);
8829               }
8830             else if (code01 == MINUS_EXPR)
8831               {
8832                 tree tree010, tree011;
8833                 tree010 = TREE_OPERAND (tree01, 0);
8834                 tree011 = TREE_OPERAND (tree01, 1);
8835                 STRIP_NOPS (tree010);
8836                 STRIP_NOPS (tree011);
8837                 if (TREE_CODE (tree010) == INTEGER_CST
8838                     && 0 == compare_tree_int (tree010,
8839                                               TYPE_PRECISION
8840                                               (TREE_TYPE (TREE_OPERAND
8841                                                           (arg0, 0))))
8842                     && operand_equal_p (tree11, tree011, 0))
8843                   return build2 ((code0 != LSHIFT_EXPR
8844                                   ? LROTATE_EXPR
8845                                   : RROTATE_EXPR),
8846                                  type, TREE_OPERAND (arg0, 0), tree11);
8847               }
8848           }
8849       }
8850
8851     associate:
8852       /* In most languages, can't associate operations on floats through
8853          parentheses.  Rather than remember where the parentheses were, we
8854          don't associate floats at all, unless the user has specified
8855          -funsafe-math-optimizations.  */
8856
8857       if (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
8858         {
8859           tree var0, con0, lit0, minus_lit0;
8860           tree var1, con1, lit1, minus_lit1;
8861           bool ok = true;
8862
8863           /* Split both trees into variables, constants, and literals.  Then
8864              associate each group together, the constants with literals,
8865              then the result with variables.  This increases the chances of
8866              literals being recombined later and of generating relocatable
8867              expressions for the sum of a constant and literal.  */
8868           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
8869           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
8870                              code == MINUS_EXPR);
8871
8872           /* With undefined overflow we can only associate constants
8873              with one variable.  */
8874           if ((POINTER_TYPE_P (type)
8875                || (INTEGRAL_TYPE_P (type)
8876                    && !(TYPE_UNSIGNED (type) || flag_wrapv)))
8877               && var0 && var1)
8878             {
8879               tree tmp0 = var0;
8880               tree tmp1 = var1;
8881
8882               if (TREE_CODE (tmp0) == NEGATE_EXPR)
8883                 tmp0 = TREE_OPERAND (tmp0, 0);
8884               if (TREE_CODE (tmp1) == NEGATE_EXPR)
8885                 tmp1 = TREE_OPERAND (tmp1, 0);
8886               /* The only case we can still associate with two variables
8887                  is if they are the same, modulo negation.  */
8888               if (!operand_equal_p (tmp0, tmp1, 0))
8889                 ok = false;
8890             }
8891
8892           /* Only do something if we found more than two objects.  Otherwise,
8893              nothing has changed and we risk infinite recursion.  */
8894           if (ok
8895               && (2 < ((var0 != 0) + (var1 != 0)
8896                        + (con0 != 0) + (con1 != 0)
8897                        + (lit0 != 0) + (lit1 != 0)
8898                        + (minus_lit0 != 0) + (minus_lit1 != 0))))
8899             {
8900               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
8901               if (code == MINUS_EXPR)
8902                 code = PLUS_EXPR;
8903
8904               var0 = associate_trees (var0, var1, code, type);
8905               con0 = associate_trees (con0, con1, code, type);
8906               lit0 = associate_trees (lit0, lit1, code, type);
8907               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
8908
8909               /* Preserve the MINUS_EXPR if the negative part of the literal is
8910                  greater than the positive part.  Otherwise, the multiplicative
8911                  folding code (i.e extract_muldiv) may be fooled in case
8912                  unsigned constants are subtracted, like in the following
8913                  example: ((X*2 + 4) - 8U)/2.  */
8914               if (minus_lit0 && lit0)
8915                 {
8916                   if (TREE_CODE (lit0) == INTEGER_CST
8917                       && TREE_CODE (minus_lit0) == INTEGER_CST
8918                       && tree_int_cst_lt (lit0, minus_lit0))
8919                     {
8920                       minus_lit0 = associate_trees (minus_lit0, lit0,
8921                                                     MINUS_EXPR, type);
8922                       lit0 = 0;
8923                     }
8924                   else
8925                     {
8926                       lit0 = associate_trees (lit0, minus_lit0,
8927                                               MINUS_EXPR, type);
8928                       minus_lit0 = 0;
8929                     }
8930                 }
8931               if (minus_lit0)
8932                 {
8933                   if (con0 == 0)
8934                     return fold_convert (type,
8935                                          associate_trees (var0, minus_lit0,
8936                                                           MINUS_EXPR, type));
8937                   else
8938                     {
8939                       con0 = associate_trees (con0, minus_lit0,
8940                                               MINUS_EXPR, type);
8941                       return fold_convert (type,
8942                                            associate_trees (var0, con0,
8943                                                             PLUS_EXPR, type));
8944                     }
8945                 }
8946
8947               con0 = associate_trees (con0, lit0, code, type);
8948               return fold_convert (type, associate_trees (var0, con0,
8949                                                           code, type));
8950             }
8951         }
8952
8953       return NULL_TREE;
8954
8955     case MINUS_EXPR:
8956       /* A - (-B) -> A + B */
8957       if (TREE_CODE (arg1) == NEGATE_EXPR)
8958         return fold_build2 (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0));
8959       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
8960       if (TREE_CODE (arg0) == NEGATE_EXPR
8961           && (FLOAT_TYPE_P (type)
8962               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv))
8963           && negate_expr_p (arg1)
8964           && reorder_operands_p (arg0, arg1))
8965         return fold_build2 (MINUS_EXPR, type, negate_expr (arg1),
8966                             TREE_OPERAND (arg0, 0));
8967       /* Convert -A - 1 to ~A.  */
8968       if (INTEGRAL_TYPE_P (type)
8969           && TREE_CODE (arg0) == NEGATE_EXPR
8970           && integer_onep (arg1))
8971         return fold_build1 (BIT_NOT_EXPR, type,
8972                             fold_convert (type, TREE_OPERAND (arg0, 0)));
8973
8974       /* Convert -1 - A to ~A.  */
8975       if (INTEGRAL_TYPE_P (type)
8976           && integer_all_onesp (arg0))
8977         return fold_build1 (BIT_NOT_EXPR, type, arg1);
8978
8979       if (! FLOAT_TYPE_P (type))
8980         {
8981           if (integer_zerop (arg0))
8982             return negate_expr (fold_convert (type, arg1));
8983           if (integer_zerop (arg1))
8984             return non_lvalue (fold_convert (type, arg0));
8985
8986           /* Fold A - (A & B) into ~B & A.  */
8987           if (!TREE_SIDE_EFFECTS (arg0)
8988               && TREE_CODE (arg1) == BIT_AND_EXPR)
8989             {
8990               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
8991                 return fold_build2 (BIT_AND_EXPR, type,
8992                                     fold_build1 (BIT_NOT_EXPR, type,
8993                                                  TREE_OPERAND (arg1, 0)),
8994                                     arg0);
8995               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8996                 return fold_build2 (BIT_AND_EXPR, type,
8997                                     fold_build1 (BIT_NOT_EXPR, type,
8998                                                  TREE_OPERAND (arg1, 1)),
8999                                     arg0);
9000             }
9001
9002           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
9003              any power of 2 minus 1.  */
9004           if (TREE_CODE (arg0) == BIT_AND_EXPR
9005               && TREE_CODE (arg1) == BIT_AND_EXPR
9006               && operand_equal_p (TREE_OPERAND (arg0, 0),
9007                                   TREE_OPERAND (arg1, 0), 0))
9008             {
9009               tree mask0 = TREE_OPERAND (arg0, 1);
9010               tree mask1 = TREE_OPERAND (arg1, 1);
9011               tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
9012
9013               if (operand_equal_p (tem, mask1, 0))
9014                 {
9015                   tem = fold_build2 (BIT_XOR_EXPR, type,
9016                                      TREE_OPERAND (arg0, 0), mask1);
9017                   return fold_build2 (MINUS_EXPR, type, tem, mask1);
9018                 }
9019             }
9020         }
9021
9022       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
9023       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
9024         return non_lvalue (fold_convert (type, arg0));
9025
9026       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
9027          ARG0 is zero and X + ARG0 reduces to X, since that would mean
9028          (-ARG1 + ARG0) reduces to -ARG1.  */
9029       else if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
9030         return negate_expr (fold_convert (type, arg1));
9031
9032       /* Fold &x - &x.  This can happen from &x.foo - &x.
9033          This is unsafe for certain floats even in non-IEEE formats.
9034          In IEEE, it is unsafe because it does wrong for NaNs.
9035          Also note that operand_equal_p is always false if an operand
9036          is volatile.  */
9037
9038       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
9039           && operand_equal_p (arg0, arg1, 0))
9040         return fold_convert (type, integer_zero_node);
9041
9042       /* A - B -> A + (-B) if B is easily negatable.  */
9043       if (negate_expr_p (arg1)
9044           && ((FLOAT_TYPE_P (type)
9045                /* Avoid this transformation if B is a positive REAL_CST.  */
9046                && (TREE_CODE (arg1) != REAL_CST
9047                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
9048               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv)))
9049         return fold_build2 (PLUS_EXPR, type,
9050                             fold_convert (type, arg0),
9051                             fold_convert (type, negate_expr (arg1)));
9052
9053       /* Try folding difference of addresses.  */
9054       {
9055         HOST_WIDE_INT diff;
9056
9057         if ((TREE_CODE (arg0) == ADDR_EXPR
9058              || TREE_CODE (arg1) == ADDR_EXPR)
9059             && ptr_difference_const (arg0, arg1, &diff))
9060           return build_int_cst_type (type, diff);
9061       }
9062
9063       /* Fold &a[i] - &a[j] to i-j.  */
9064       if (TREE_CODE (arg0) == ADDR_EXPR
9065           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
9066           && TREE_CODE (arg1) == ADDR_EXPR
9067           && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
9068         {
9069           tree aref0 = TREE_OPERAND (arg0, 0);
9070           tree aref1 = TREE_OPERAND (arg1, 0);
9071           if (operand_equal_p (TREE_OPERAND (aref0, 0),
9072                                TREE_OPERAND (aref1, 0), 0))
9073             {
9074               tree op0 = fold_convert (type, TREE_OPERAND (aref0, 1));
9075               tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
9076               tree esz = array_ref_element_size (aref0);
9077               tree diff = build2 (MINUS_EXPR, type, op0, op1);
9078               return fold_build2 (MULT_EXPR, type, diff,
9079                                   fold_convert (type, esz));
9080                                   
9081             }
9082         }
9083
9084       /* Try replacing &a[i1] - c * i2 with &a[i1 - i2], if c is step
9085          of the array.  Loop optimizer sometimes produce this type of
9086          expressions.  */
9087       if (TREE_CODE (arg0) == ADDR_EXPR)
9088         {
9089           tem = try_move_mult_to_index (MINUS_EXPR, arg0, arg1);
9090           if (tem)
9091             return fold_convert (type, tem);
9092         }
9093
9094       if (flag_unsafe_math_optimizations
9095           && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
9096           && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
9097           && (tem = distribute_real_division (code, type, arg0, arg1)))
9098         return tem;
9099
9100       /* Handle (A1 * C1) - (A2 * C2) with A1, A2 or C1, C2 being the
9101          same or one.  */
9102       if ((TREE_CODE (arg0) == MULT_EXPR
9103            || TREE_CODE (arg1) == MULT_EXPR)
9104           && (!FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
9105         {
9106           tree tem = fold_plusminus_mult_expr (code, type, arg0, arg1);
9107           if (tem)
9108             return tem;
9109         }
9110
9111       goto associate;
9112
9113     case MULT_EXPR:
9114       /* (-A) * (-B) -> A * B  */
9115       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
9116         return fold_build2 (MULT_EXPR, type,
9117                             fold_convert (type, TREE_OPERAND (arg0, 0)),
9118                             fold_convert (type, negate_expr (arg1)));
9119       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
9120         return fold_build2 (MULT_EXPR, type,
9121                             fold_convert (type, negate_expr (arg0)),
9122                             fold_convert (type, TREE_OPERAND (arg1, 0)));
9123
9124       if (! FLOAT_TYPE_P (type))
9125         {
9126           if (integer_zerop (arg1))
9127             return omit_one_operand (type, arg1, arg0);
9128           if (integer_onep (arg1))
9129             return non_lvalue (fold_convert (type, arg0));
9130           /* Transform x * -1 into -x.  */
9131           if (integer_all_onesp (arg1))
9132             return fold_convert (type, negate_expr (arg0));
9133
9134           /* (a * (1 << b)) is (a << b)  */
9135           if (TREE_CODE (arg1) == LSHIFT_EXPR
9136               && integer_onep (TREE_OPERAND (arg1, 0)))
9137             return fold_build2 (LSHIFT_EXPR, type, arg0,
9138                                 TREE_OPERAND (arg1, 1));
9139           if (TREE_CODE (arg0) == LSHIFT_EXPR
9140               && integer_onep (TREE_OPERAND (arg0, 0)))
9141             return fold_build2 (LSHIFT_EXPR, type, arg1,
9142                                 TREE_OPERAND (arg0, 1));
9143
9144           strict_overflow_p = false;
9145           if (TREE_CODE (arg1) == INTEGER_CST
9146               && 0 != (tem = extract_muldiv (op0,
9147                                              fold_convert (type, arg1),
9148                                              code, NULL_TREE,
9149                                              &strict_overflow_p)))
9150             {
9151               if (strict_overflow_p)
9152                 fold_overflow_warning (("assuming signed overflow does not "
9153                                         "occur when simplifying "
9154                                         "multiplication"),
9155                                        WARN_STRICT_OVERFLOW_MISC);
9156               return fold_convert (type, tem);
9157             }
9158
9159           /* Optimize z * conj(z) for integer complex numbers.  */
9160           if (TREE_CODE (arg0) == CONJ_EXPR
9161               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9162             return fold_mult_zconjz (type, arg1);
9163           if (TREE_CODE (arg1) == CONJ_EXPR
9164               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9165             return fold_mult_zconjz (type, arg0);
9166         }
9167       else
9168         {
9169           /* Maybe fold x * 0 to 0.  The expressions aren't the same
9170              when x is NaN, since x * 0 is also NaN.  Nor are they the
9171              same in modes with signed zeros, since multiplying a
9172              negative value by 0 gives -0, not +0.  */
9173           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
9174               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
9175               && real_zerop (arg1))
9176             return omit_one_operand (type, arg1, arg0);
9177           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
9178           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9179               && real_onep (arg1))
9180             return non_lvalue (fold_convert (type, arg0));
9181
9182           /* Transform x * -1.0 into -x.  */
9183           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9184               && real_minus_onep (arg1))
9185             return fold_convert (type, negate_expr (arg0));
9186
9187           /* Convert (C1/X)*C2 into (C1*C2)/X.  */
9188           if (flag_unsafe_math_optimizations
9189               && TREE_CODE (arg0) == RDIV_EXPR
9190               && TREE_CODE (arg1) == REAL_CST
9191               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
9192             {
9193               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
9194                                       arg1, 0);
9195               if (tem)
9196                 return fold_build2 (RDIV_EXPR, type, tem,
9197                                     TREE_OPERAND (arg0, 1));
9198             }
9199
9200           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
9201           if (operand_equal_p (arg0, arg1, 0))
9202             {
9203               tree tem = fold_strip_sign_ops (arg0);
9204               if (tem != NULL_TREE)
9205                 {
9206                   tem = fold_convert (type, tem);
9207                   return fold_build2 (MULT_EXPR, type, tem, tem);
9208                 }
9209             }
9210
9211           /* Optimize z * conj(z) for floating point complex numbers.
9212              Guarded by flag_unsafe_math_optimizations as non-finite
9213              imaginary components don't produce scalar results.  */
9214           if (flag_unsafe_math_optimizations
9215               && TREE_CODE (arg0) == CONJ_EXPR
9216               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9217             return fold_mult_zconjz (type, arg1);
9218           if (flag_unsafe_math_optimizations
9219               && TREE_CODE (arg1) == CONJ_EXPR
9220               && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9221             return fold_mult_zconjz (type, arg0);
9222
9223           if (flag_unsafe_math_optimizations)
9224             {
9225               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
9226               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
9227
9228               /* Optimizations of root(...)*root(...).  */
9229               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
9230                 {
9231                   tree rootfn, arg, arglist;
9232                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9233                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9234
9235                   /* Optimize sqrt(x)*sqrt(x) as x.  */
9236                   if (BUILTIN_SQRT_P (fcode0)
9237                       && operand_equal_p (arg00, arg10, 0)
9238                       && ! HONOR_SNANS (TYPE_MODE (type)))
9239                     return arg00;
9240
9241                   /* Optimize root(x)*root(y) as root(x*y).  */
9242                   rootfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9243                   arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
9244                   arglist = build_tree_list (NULL_TREE, arg);
9245                   return build_function_call_expr (rootfn, arglist);
9246                 }
9247
9248               /* Optimize expN(x)*expN(y) as expN(x+y).  */
9249               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
9250                 {
9251                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9252                   tree arg = fold_build2 (PLUS_EXPR, type,
9253                                           TREE_VALUE (TREE_OPERAND (arg0, 1)),
9254                                           TREE_VALUE (TREE_OPERAND (arg1, 1)));
9255                   tree arglist = build_tree_list (NULL_TREE, arg);
9256                   return build_function_call_expr (expfn, arglist);
9257                 }
9258
9259               /* Optimizations of pow(...)*pow(...).  */
9260               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
9261                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
9262                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
9263                 {
9264                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9265                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
9266                                                                      1)));
9267                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9268                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
9269                                                                      1)));
9270
9271                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
9272                   if (operand_equal_p (arg01, arg11, 0))
9273                     {
9274                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9275                       tree arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
9276                       tree arglist = tree_cons (NULL_TREE, arg,
9277                                                 build_tree_list (NULL_TREE,
9278                                                                  arg01));
9279                       return build_function_call_expr (powfn, arglist);
9280                     }
9281
9282                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
9283                   if (operand_equal_p (arg00, arg10, 0))
9284                     {
9285                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9286                       tree arg = fold_build2 (PLUS_EXPR, type, arg01, arg11);
9287                       tree arglist = tree_cons (NULL_TREE, arg00,
9288                                                 build_tree_list (NULL_TREE,
9289                                                                  arg));
9290                       return build_function_call_expr (powfn, arglist);
9291                     }
9292                 }
9293
9294               /* Optimize tan(x)*cos(x) as sin(x).  */
9295               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
9296                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
9297                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
9298                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
9299                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
9300                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
9301                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9302                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9303                 {
9304                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
9305
9306                   if (sinfn != NULL_TREE)
9307                     return build_function_call_expr (sinfn,
9308                                                      TREE_OPERAND (arg0, 1));
9309                 }
9310
9311               /* Optimize x*pow(x,c) as pow(x,c+1).  */
9312               if (fcode1 == BUILT_IN_POW
9313                   || fcode1 == BUILT_IN_POWF
9314                   || fcode1 == BUILT_IN_POWL)
9315                 {
9316                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9317                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
9318                                                                      1)));
9319                   if (TREE_CODE (arg11) == REAL_CST
9320                       && ! TREE_CONSTANT_OVERFLOW (arg11)
9321                       && operand_equal_p (arg0, arg10, 0))
9322                     {
9323                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
9324                       REAL_VALUE_TYPE c;
9325                       tree arg, arglist;
9326
9327                       c = TREE_REAL_CST (arg11);
9328                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
9329                       arg = build_real (type, c);
9330                       arglist = build_tree_list (NULL_TREE, arg);
9331                       arglist = tree_cons (NULL_TREE, arg0, arglist);
9332                       return build_function_call_expr (powfn, arglist);
9333                     }
9334                 }
9335
9336               /* Optimize pow(x,c)*x as pow(x,c+1).  */
9337               if (fcode0 == BUILT_IN_POW
9338                   || fcode0 == BUILT_IN_POWF
9339                   || fcode0 == BUILT_IN_POWL)
9340                 {
9341                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9342                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
9343                                                                      1)));
9344                   if (TREE_CODE (arg01) == REAL_CST
9345                       && ! TREE_CONSTANT_OVERFLOW (arg01)
9346                       && operand_equal_p (arg1, arg00, 0))
9347                     {
9348                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9349                       REAL_VALUE_TYPE c;
9350                       tree arg, arglist;
9351
9352                       c = TREE_REAL_CST (arg01);
9353                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
9354                       arg = build_real (type, c);
9355                       arglist = build_tree_list (NULL_TREE, arg);
9356                       arglist = tree_cons (NULL_TREE, arg1, arglist);
9357                       return build_function_call_expr (powfn, arglist);
9358                     }
9359                 }
9360
9361               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
9362               if (! optimize_size
9363                   && operand_equal_p (arg0, arg1, 0))
9364                 {
9365                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
9366
9367                   if (powfn)
9368                     {
9369                       tree arg = build_real (type, dconst2);
9370                       tree arglist = build_tree_list (NULL_TREE, arg);
9371                       arglist = tree_cons (NULL_TREE, arg0, arglist);
9372                       return build_function_call_expr (powfn, arglist);
9373                     }
9374                 }
9375             }
9376         }
9377       goto associate;
9378
9379     case BIT_IOR_EXPR:
9380     bit_ior:
9381       if (integer_all_onesp (arg1))
9382         return omit_one_operand (type, arg1, arg0);
9383       if (integer_zerop (arg1))
9384         return non_lvalue (fold_convert (type, arg0));
9385       if (operand_equal_p (arg0, arg1, 0))
9386         return non_lvalue (fold_convert (type, arg0));
9387
9388       /* ~X | X is -1.  */
9389       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9390           && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9391           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9392         {
9393           t1 = build_int_cst (type, -1);
9394           t1 = force_fit_type (t1, 0, false, false);
9395           return omit_one_operand (type, t1, arg1);
9396         }
9397
9398       /* X | ~X is -1.  */
9399       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9400           && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
9401           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9402         {
9403           t1 = build_int_cst (type, -1);
9404           t1 = force_fit_type (t1, 0, false, false);
9405           return omit_one_operand (type, t1, arg0);
9406         }
9407
9408       /* Canonicalize (X & C1) | C2.  */
9409       if (TREE_CODE (arg0) == BIT_AND_EXPR
9410           && TREE_CODE (arg1) == INTEGER_CST
9411           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9412         {
9413           unsigned HOST_WIDE_INT hi1, lo1, hi2, lo2, mlo, mhi;
9414           int width = TYPE_PRECISION (type);
9415           hi1 = TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1));
9416           lo1 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
9417           hi2 = TREE_INT_CST_HIGH (arg1);
9418           lo2 = TREE_INT_CST_LOW (arg1);
9419
9420           /* If (C1&C2) == C1, then (X&C1)|C2 becomes (X,C2).  */
9421           if ((hi1 & hi2) == hi1 && (lo1 & lo2) == lo1)
9422             return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9423
9424           if (width > HOST_BITS_PER_WIDE_INT)
9425             {
9426               mhi = (unsigned HOST_WIDE_INT) -1 
9427                     >> (2 * HOST_BITS_PER_WIDE_INT - width);
9428               mlo = -1;
9429             }
9430           else
9431             {
9432               mhi = 0;
9433               mlo = (unsigned HOST_WIDE_INT) -1
9434                     >> (HOST_BITS_PER_WIDE_INT - width);
9435             }
9436
9437           /* If (C1|C2) == ~0 then (X&C1)|C2 becomes X|C2.  */
9438           if ((~(hi1 | hi2) & mhi) == 0 && (~(lo1 | lo2) & mlo) == 0)
9439             return fold_build2 (BIT_IOR_EXPR, type,
9440                                 TREE_OPERAND (arg0, 0), arg1);
9441
9442           /* Minimize the number of bits set in C1, i.e. C1 := C1 & ~C2.  */
9443           hi1 &= mhi;
9444           lo1 &= mlo;
9445           if ((hi1 & ~hi2) != hi1 || (lo1 & ~lo2) != lo1)
9446             return fold_build2 (BIT_IOR_EXPR, type,
9447                                 fold_build2 (BIT_AND_EXPR, type,
9448                                              TREE_OPERAND (arg0, 0),
9449                                              build_int_cst_wide (type,
9450                                                                  lo1 & ~lo2,
9451                                                                  hi1 & ~hi2)),
9452                                 arg1);
9453         }
9454
9455       /* (X & Y) | Y is (X, Y).  */
9456       if (TREE_CODE (arg0) == BIT_AND_EXPR
9457           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9458         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9459       /* (X & Y) | X is (Y, X).  */
9460       if (TREE_CODE (arg0) == BIT_AND_EXPR
9461           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9462           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9463         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
9464       /* X | (X & Y) is (Y, X).  */
9465       if (TREE_CODE (arg1) == BIT_AND_EXPR
9466           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
9467           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
9468         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
9469       /* X | (Y & X) is (Y, X).  */
9470       if (TREE_CODE (arg1) == BIT_AND_EXPR
9471           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9472           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9473         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
9474
9475       t1 = distribute_bit_expr (code, type, arg0, arg1);
9476       if (t1 != NULL_TREE)
9477         return t1;
9478
9479       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
9480
9481          This results in more efficient code for machines without a NAND
9482          instruction.  Combine will canonicalize to the first form
9483          which will allow use of NAND instructions provided by the
9484          backend if they exist.  */
9485       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9486           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9487         {
9488           return fold_build1 (BIT_NOT_EXPR, type,
9489                               build2 (BIT_AND_EXPR, type,
9490                                       TREE_OPERAND (arg0, 0),
9491                                       TREE_OPERAND (arg1, 0)));
9492         }
9493
9494       /* See if this can be simplified into a rotate first.  If that
9495          is unsuccessful continue in the association code.  */
9496       goto bit_rotate;
9497
9498     case BIT_XOR_EXPR:
9499       if (integer_zerop (arg1))
9500         return non_lvalue (fold_convert (type, arg0));
9501       if (integer_all_onesp (arg1))
9502         return fold_build1 (BIT_NOT_EXPR, type, arg0);
9503       if (operand_equal_p (arg0, arg1, 0))
9504         return omit_one_operand (type, integer_zero_node, arg0);
9505
9506       /* ~X ^ X is -1.  */
9507       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9508           && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9509           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9510         {
9511           t1 = build_int_cst (type, -1);
9512           t1 = force_fit_type (t1, 0, false, false);
9513           return omit_one_operand (type, t1, arg1);
9514         }
9515
9516       /* X ^ ~X is -1.  */
9517       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9518           && INTEGRAL_TYPE_P (TREE_TYPE (arg0))
9519           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9520         {
9521           t1 = build_int_cst (type, -1);
9522           t1 = force_fit_type (t1, 0, false, false);
9523           return omit_one_operand (type, t1, arg0);
9524         }
9525
9526       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
9527          with a constant, and the two constants have no bits in common,
9528          we should treat this as a BIT_IOR_EXPR since this may produce more
9529          simplifications.  */
9530       if (TREE_CODE (arg0) == BIT_AND_EXPR
9531           && TREE_CODE (arg1) == BIT_AND_EXPR
9532           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9533           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
9534           && integer_zerop (const_binop (BIT_AND_EXPR,
9535                                          TREE_OPERAND (arg0, 1),
9536                                          TREE_OPERAND (arg1, 1), 0)))
9537         {
9538           code = BIT_IOR_EXPR;
9539           goto bit_ior;
9540         }
9541
9542       /* (X | Y) ^ X -> Y & ~ X*/
9543       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9544           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9545         {
9546           tree t2 = TREE_OPERAND (arg0, 1);
9547           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
9548                             arg1);
9549           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9550                             fold_convert (type, t1));
9551           return t1;
9552         }
9553
9554       /* (Y | X) ^ X -> Y & ~ X*/
9555       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9556           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9557         {
9558           tree t2 = TREE_OPERAND (arg0, 0);
9559           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
9560                             arg1);
9561           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9562                             fold_convert (type, t1));
9563           return t1;
9564         }
9565
9566       /* X ^ (X | Y) -> Y & ~ X*/
9567       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9568           && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
9569         {
9570           tree t2 = TREE_OPERAND (arg1, 1);
9571           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
9572                             arg0);
9573           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9574                             fold_convert (type, t1));
9575           return t1;
9576         }
9577
9578       /* X ^ (Y | X) -> Y & ~ X*/
9579       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9580           && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
9581         {
9582           tree t2 = TREE_OPERAND (arg1, 0);
9583           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
9584                             arg0);
9585           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
9586                             fold_convert (type, t1));
9587           return t1;
9588         }
9589         
9590       /* Convert ~X ^ ~Y to X ^ Y.  */
9591       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9592           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9593         return fold_build2 (code, type,
9594                             fold_convert (type, TREE_OPERAND (arg0, 0)),
9595                             fold_convert (type, TREE_OPERAND (arg1, 0)));
9596
9597       /* Fold (X & 1) ^ 1 as (X & 1) == 0.  */
9598       if (TREE_CODE (arg0) == BIT_AND_EXPR
9599           && integer_onep (TREE_OPERAND (arg0, 1))
9600           && integer_onep (arg1))
9601         return fold_build2 (EQ_EXPR, type, arg0,
9602                             build_int_cst (TREE_TYPE (arg0), 0));
9603
9604       /* Fold (X & Y) ^ Y as ~X & Y.  */
9605       if (TREE_CODE (arg0) == BIT_AND_EXPR
9606           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9607         {
9608           tem = fold_convert (type, TREE_OPERAND (arg0, 0));
9609           return fold_build2 (BIT_AND_EXPR, type, 
9610                               fold_build1 (BIT_NOT_EXPR, type, tem),
9611                               fold_convert (type, arg1));
9612         }
9613       /* Fold (X & Y) ^ X as ~Y & X.  */
9614       if (TREE_CODE (arg0) == BIT_AND_EXPR
9615           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9616           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9617         {
9618           tem = fold_convert (type, TREE_OPERAND (arg0, 1));
9619           return fold_build2 (BIT_AND_EXPR, type,
9620                               fold_build1 (BIT_NOT_EXPR, type, tem),
9621                               fold_convert (type, arg1));
9622         }
9623       /* Fold X ^ (X & Y) as X & ~Y.  */
9624       if (TREE_CODE (arg1) == BIT_AND_EXPR
9625           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9626         {
9627           tem = fold_convert (type, TREE_OPERAND (arg1, 1));
9628           return fold_build2 (BIT_AND_EXPR, type,
9629                               fold_convert (type, arg0),
9630                               fold_build1 (BIT_NOT_EXPR, type, tem));
9631         }
9632       /* Fold X ^ (Y & X) as ~Y & X.  */
9633       if (TREE_CODE (arg1) == BIT_AND_EXPR
9634           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9635           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9636         {
9637           tem = fold_convert (type, TREE_OPERAND (arg1, 0));
9638           return fold_build2 (BIT_AND_EXPR, type,
9639                               fold_build1 (BIT_NOT_EXPR, type, tem),
9640                               fold_convert (type, arg0));
9641         }
9642
9643       /* See if this can be simplified into a rotate first.  If that
9644          is unsuccessful continue in the association code.  */
9645       goto bit_rotate;
9646
9647     case BIT_AND_EXPR:
9648       if (integer_all_onesp (arg1))
9649         return non_lvalue (fold_convert (type, arg0));
9650       if (integer_zerop (arg1))
9651         return omit_one_operand (type, arg1, arg0);
9652       if (operand_equal_p (arg0, arg1, 0))
9653         return non_lvalue (fold_convert (type, arg0));
9654
9655       /* ~X & X is always zero.  */
9656       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9657           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
9658         return omit_one_operand (type, integer_zero_node, arg1);
9659
9660       /* X & ~X is always zero.  */
9661       if (TREE_CODE (arg1) == BIT_NOT_EXPR
9662           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9663         return omit_one_operand (type, integer_zero_node, arg0);
9664
9665       /* Canonicalize (X | C1) & C2 as (X & C2) | (C1 & C2).  */
9666       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9667           && TREE_CODE (arg1) == INTEGER_CST
9668           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9669         return fold_build2 (BIT_IOR_EXPR, type,
9670                             fold_build2 (BIT_AND_EXPR, type,
9671                                          TREE_OPERAND (arg0, 0), arg1),
9672                             fold_build2 (BIT_AND_EXPR, type,
9673                                          TREE_OPERAND (arg0, 1), arg1));
9674
9675       /* (X | Y) & Y is (X, Y).  */
9676       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9677           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9678         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 0));
9679       /* (X | Y) & X is (Y, X).  */
9680       if (TREE_CODE (arg0) == BIT_IOR_EXPR
9681           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9682           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9683         return omit_one_operand (type, arg1, TREE_OPERAND (arg0, 1));
9684       /* X & (X | Y) is (Y, X).  */
9685       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9686           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0)
9687           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 1)))
9688         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 1));
9689       /* X & (Y | X) is (Y, X).  */
9690       if (TREE_CODE (arg1) == BIT_IOR_EXPR
9691           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9692           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9693         return omit_one_operand (type, arg0, TREE_OPERAND (arg1, 0));
9694
9695       /* Fold (X ^ 1) & 1 as (X & 1) == 0.  */
9696       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9697           && integer_onep (TREE_OPERAND (arg0, 1))
9698           && integer_onep (arg1))
9699         {
9700           tem = TREE_OPERAND (arg0, 0);
9701           return fold_build2 (EQ_EXPR, type,
9702                               fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
9703                                            build_int_cst (TREE_TYPE (tem), 1)),
9704                               build_int_cst (TREE_TYPE (tem), 0));
9705         }
9706       /* Fold ~X & 1 as (X & 1) == 0.  */
9707       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9708           && integer_onep (arg1))
9709         {
9710           tem = TREE_OPERAND (arg0, 0);
9711           return fold_build2 (EQ_EXPR, type,
9712                               fold_build2 (BIT_AND_EXPR, TREE_TYPE (tem), tem,
9713                                            build_int_cst (TREE_TYPE (tem), 1)),
9714                               build_int_cst (TREE_TYPE (tem), 0));
9715         }
9716
9717       /* Fold (X ^ Y) & Y as ~X & Y.  */
9718       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9719           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9720         {
9721           tem = fold_convert (type, TREE_OPERAND (arg0, 0));
9722           return fold_build2 (BIT_AND_EXPR, type, 
9723                               fold_build1 (BIT_NOT_EXPR, type, tem),
9724                               fold_convert (type, arg1));
9725         }
9726       /* Fold (X ^ Y) & X as ~Y & X.  */
9727       if (TREE_CODE (arg0) == BIT_XOR_EXPR
9728           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
9729           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
9730         {
9731           tem = fold_convert (type, TREE_OPERAND (arg0, 1));
9732           return fold_build2 (BIT_AND_EXPR, type,
9733                               fold_build1 (BIT_NOT_EXPR, type, tem),
9734                               fold_convert (type, arg1));
9735         }
9736       /* Fold X & (X ^ Y) as X & ~Y.  */
9737       if (TREE_CODE (arg1) == BIT_XOR_EXPR
9738           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
9739         {
9740           tem = fold_convert (type, TREE_OPERAND (arg1, 1));
9741           return fold_build2 (BIT_AND_EXPR, type,
9742                               fold_convert (type, arg0),
9743                               fold_build1 (BIT_NOT_EXPR, type, tem));
9744         }
9745       /* Fold X & (Y ^ X) as ~Y & X.  */
9746       if (TREE_CODE (arg1) == BIT_XOR_EXPR
9747           && operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0)
9748           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
9749         {
9750           tem = fold_convert (type, TREE_OPERAND (arg1, 0));
9751           return fold_build2 (BIT_AND_EXPR, type,
9752                               fold_build1 (BIT_NOT_EXPR, type, tem),
9753                               fold_convert (type, arg0));
9754         }
9755
9756       t1 = distribute_bit_expr (code, type, arg0, arg1);
9757       if (t1 != NULL_TREE)
9758         return t1;
9759       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
9760       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
9761           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
9762         {
9763           unsigned int prec
9764             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
9765
9766           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
9767               && (~TREE_INT_CST_LOW (arg1)
9768                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
9769             return fold_convert (type, TREE_OPERAND (arg0, 0));
9770         }
9771
9772       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
9773
9774          This results in more efficient code for machines without a NOR
9775          instruction.  Combine will canonicalize to the first form
9776          which will allow use of NOR instructions provided by the
9777          backend if they exist.  */
9778       if (TREE_CODE (arg0) == BIT_NOT_EXPR
9779           && TREE_CODE (arg1) == BIT_NOT_EXPR)
9780         {
9781           return fold_build1 (BIT_NOT_EXPR, type,
9782                               build2 (BIT_IOR_EXPR, type,
9783                                       TREE_OPERAND (arg0, 0),
9784                                       TREE_OPERAND (arg1, 0)));
9785         }
9786
9787       goto associate;
9788
9789     case RDIV_EXPR:
9790       /* Don't touch a floating-point divide by zero unless the mode
9791          of the constant can represent infinity.  */
9792       if (TREE_CODE (arg1) == REAL_CST
9793           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
9794           && real_zerop (arg1))
9795         return NULL_TREE;
9796
9797       /* Optimize A / A to 1.0 if we don't care about
9798          NaNs or Infinities.  Skip the transformation
9799          for non-real operands.  */
9800       if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (arg0))
9801           && ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
9802           && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg0)))
9803           && operand_equal_p (arg0, arg1, 0))
9804         {
9805           tree r = build_real (TREE_TYPE (arg0), dconst1);
9806
9807           return omit_two_operands (type, r, arg0, arg1);
9808         }
9809
9810       /* The complex version of the above A / A optimization.  */
9811       if (COMPLEX_FLOAT_TYPE_P (TREE_TYPE (arg0))
9812           && operand_equal_p (arg0, arg1, 0))
9813         {
9814           tree elem_type = TREE_TYPE (TREE_TYPE (arg0));
9815           if (! HONOR_NANS (TYPE_MODE (elem_type))
9816               && ! HONOR_INFINITIES (TYPE_MODE (elem_type)))
9817             {
9818               tree r = build_real (elem_type, dconst1);
9819               /* omit_two_operands will call fold_convert for us.  */
9820               return omit_two_operands (type, r, arg0, arg1);
9821             }
9822         }
9823
9824       /* (-A) / (-B) -> A / B  */
9825       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
9826         return fold_build2 (RDIV_EXPR, type,
9827                             TREE_OPERAND (arg0, 0),
9828                             negate_expr (arg1));
9829       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
9830         return fold_build2 (RDIV_EXPR, type,
9831                             negate_expr (arg0),
9832                             TREE_OPERAND (arg1, 0));
9833
9834       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
9835       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9836           && real_onep (arg1))
9837         return non_lvalue (fold_convert (type, arg0));
9838
9839       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
9840       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9841           && real_minus_onep (arg1))
9842         return non_lvalue (fold_convert (type, negate_expr (arg0)));
9843
9844       /* If ARG1 is a constant, we can convert this to a multiply by the
9845          reciprocal.  This does not have the same rounding properties,
9846          so only do this if -funsafe-math-optimizations.  We can actually
9847          always safely do it if ARG1 is a power of two, but it's hard to
9848          tell if it is or not in a portable manner.  */
9849       if (TREE_CODE (arg1) == REAL_CST)
9850         {
9851           if (flag_unsafe_math_optimizations
9852               && 0 != (tem = const_binop (code, build_real (type, dconst1),
9853                                           arg1, 0)))
9854             return fold_build2 (MULT_EXPR, type, arg0, tem);
9855           /* Find the reciprocal if optimizing and the result is exact.  */
9856           if (optimize)
9857             {
9858               REAL_VALUE_TYPE r;
9859               r = TREE_REAL_CST (arg1);
9860               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
9861                 {
9862                   tem = build_real (type, r);
9863                   return fold_build2 (MULT_EXPR, type,
9864                                       fold_convert (type, arg0), tem);
9865                 }
9866             }
9867         }
9868       /* Convert A/B/C to A/(B*C).  */
9869       if (flag_unsafe_math_optimizations
9870           && TREE_CODE (arg0) == RDIV_EXPR)
9871         return fold_build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
9872                             fold_build2 (MULT_EXPR, type,
9873                                          TREE_OPERAND (arg0, 1), arg1));
9874
9875       /* Convert A/(B/C) to (A/B)*C.  */
9876       if (flag_unsafe_math_optimizations
9877           && TREE_CODE (arg1) == RDIV_EXPR)
9878         return fold_build2 (MULT_EXPR, type,
9879                             fold_build2 (RDIV_EXPR, type, arg0,
9880                                          TREE_OPERAND (arg1, 0)),
9881                             TREE_OPERAND (arg1, 1));
9882
9883       /* Convert C1/(X*C2) into (C1/C2)/X.  */
9884       if (flag_unsafe_math_optimizations
9885           && TREE_CODE (arg1) == MULT_EXPR
9886           && TREE_CODE (arg0) == REAL_CST
9887           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
9888         {
9889           tree tem = const_binop (RDIV_EXPR, arg0,
9890                                   TREE_OPERAND (arg1, 1), 0);
9891           if (tem)
9892             return fold_build2 (RDIV_EXPR, type, tem,
9893                                 TREE_OPERAND (arg1, 0));
9894         }
9895
9896       if (flag_unsafe_math_optimizations)
9897         {
9898           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
9899           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
9900
9901           /* Optimize sin(x)/cos(x) as tan(x).  */
9902           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
9903                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
9904                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
9905               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9906                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9907             {
9908               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
9909
9910               if (tanfn != NULL_TREE)
9911                 return build_function_call_expr (tanfn,
9912                                                  TREE_OPERAND (arg0, 1));
9913             }
9914
9915           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
9916           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
9917                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
9918                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
9919               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
9920                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
9921             {
9922               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
9923
9924               if (tanfn != NULL_TREE)
9925                 {
9926                   tree tmp = TREE_OPERAND (arg0, 1);
9927                   tmp = build_function_call_expr (tanfn, tmp);
9928                   return fold_build2 (RDIV_EXPR, type,
9929                                       build_real (type, dconst1), tmp);
9930                 }
9931             }
9932
9933           /* Optimize sin(x)/tan(x) as cos(x) if we don't care about
9934              NaNs or Infinities.  */
9935           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_TAN)
9936                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_TANF)
9937                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_TANL)))
9938             {
9939               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9940               tree arg01 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9941
9942               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
9943                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
9944                   && operand_equal_p (arg00, arg01, 0))
9945                 {
9946                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
9947
9948                   if (cosfn != NULL_TREE)
9949                     return build_function_call_expr (cosfn,
9950                                                      TREE_OPERAND (arg0, 1));
9951                 }
9952             }
9953
9954           /* Optimize tan(x)/sin(x) as 1.0/cos(x) if we don't care about
9955              NaNs or Infinities.  */
9956           if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_SIN)
9957                || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_SINF)
9958                || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_SINL)))
9959             {
9960               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9961               tree arg01 = TREE_VALUE (TREE_OPERAND (arg1, 1));
9962
9963               if (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg00)))
9964                   && ! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg00)))
9965                   && operand_equal_p (arg00, arg01, 0))
9966                 {
9967                   tree cosfn = mathfn_built_in (type, BUILT_IN_COS);
9968
9969                   if (cosfn != NULL_TREE)
9970                     {
9971                       tree tmp = TREE_OPERAND (arg0, 1);
9972                       tmp = build_function_call_expr (cosfn, tmp);
9973                       return fold_build2 (RDIV_EXPR, type,
9974                                           build_real (type, dconst1),
9975                                           tmp);
9976                     }
9977                 }
9978             }
9979
9980           /* Optimize pow(x,c)/x as pow(x,c-1).  */
9981           if (fcode0 == BUILT_IN_POW
9982               || fcode0 == BUILT_IN_POWF
9983               || fcode0 == BUILT_IN_POWL)
9984             {
9985               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
9986               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
9987               if (TREE_CODE (arg01) == REAL_CST
9988                   && ! TREE_CONSTANT_OVERFLOW (arg01)
9989                   && operand_equal_p (arg1, arg00, 0))
9990                 {
9991                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
9992                   REAL_VALUE_TYPE c;
9993                   tree arg, arglist;
9994
9995                   c = TREE_REAL_CST (arg01);
9996                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
9997                   arg = build_real (type, c);
9998                   arglist = build_tree_list (NULL_TREE, arg);
9999                   arglist = tree_cons (NULL_TREE, arg1, arglist);
10000                   return build_function_call_expr (powfn, arglist);
10001                 }
10002             }
10003
10004           /* Optimize x/expN(y) into x*expN(-y).  */
10005           if (BUILTIN_EXPONENT_P (fcode1))
10006             {
10007               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
10008               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
10009               tree arglist = build_tree_list (NULL_TREE,
10010                                               fold_convert (type, arg));
10011               arg1 = build_function_call_expr (expfn, arglist);
10012               return fold_build2 (MULT_EXPR, type, arg0, arg1);
10013             }
10014
10015           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
10016           if (fcode1 == BUILT_IN_POW
10017               || fcode1 == BUILT_IN_POWF
10018               || fcode1 == BUILT_IN_POWL)
10019             {
10020               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
10021               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
10022               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
10023               tree neg11 = fold_convert (type, negate_expr (arg11));
10024               tree arglist = tree_cons(NULL_TREE, arg10,
10025                                        build_tree_list (NULL_TREE, neg11));
10026               arg1 = build_function_call_expr (powfn, arglist);
10027               return fold_build2 (MULT_EXPR, type, arg0, arg1);
10028             }
10029         }
10030       return NULL_TREE;
10031
10032     case TRUNC_DIV_EXPR:
10033     case FLOOR_DIV_EXPR:
10034       /* Simplify A / (B << N) where A and B are positive and B is
10035          a power of 2, to A >> (N + log2(B)).  */
10036       strict_overflow_p = false;
10037       if (TREE_CODE (arg1) == LSHIFT_EXPR
10038           && (TYPE_UNSIGNED (type)
10039               || tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p)))
10040         {
10041           tree sval = TREE_OPERAND (arg1, 0);
10042           if (integer_pow2p (sval) && tree_int_cst_sgn (sval) > 0)
10043             {
10044               tree sh_cnt = TREE_OPERAND (arg1, 1);
10045               unsigned long pow2 = exact_log2 (TREE_INT_CST_LOW (sval));
10046
10047               if (strict_overflow_p)
10048                 fold_overflow_warning (("assuming signed overflow does not "
10049                                         "occur when simplifying A / (B << N)"),
10050                                        WARN_STRICT_OVERFLOW_MISC);
10051
10052               sh_cnt = fold_build2 (PLUS_EXPR, TREE_TYPE (sh_cnt),
10053                                     sh_cnt, build_int_cst (NULL_TREE, pow2));
10054               return fold_build2 (RSHIFT_EXPR, type,
10055                                   fold_convert (type, arg0), sh_cnt);
10056             }
10057         }
10058       /* Fall thru */
10059
10060     case ROUND_DIV_EXPR:
10061     case CEIL_DIV_EXPR:
10062     case EXACT_DIV_EXPR:
10063       if (integer_onep (arg1))
10064         return non_lvalue (fold_convert (type, arg0));
10065       if (integer_zerop (arg1))
10066         return NULL_TREE;
10067       /* X / -1 is -X.  */
10068       if (!TYPE_UNSIGNED (type)
10069           && TREE_CODE (arg1) == INTEGER_CST
10070           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
10071           && TREE_INT_CST_HIGH (arg1) == -1)
10072         return fold_convert (type, negate_expr (arg0));
10073
10074       /* Convert -A / -B to A / B when the type is signed and overflow is
10075          undefined.  */
10076       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
10077           && TREE_CODE (arg0) == NEGATE_EXPR
10078           && negate_expr_p (arg1))
10079         {
10080           if (INTEGRAL_TYPE_P (type))
10081             fold_overflow_warning (("assuming signed overflow does not occur "
10082                                     "when distributing negation across "
10083                                     "division"),
10084                                    WARN_STRICT_OVERFLOW_MISC);
10085           return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10086                               negate_expr (arg1));
10087         }
10088       if ((!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
10089           && TREE_CODE (arg1) == NEGATE_EXPR
10090           && negate_expr_p (arg0))
10091         {
10092           if (INTEGRAL_TYPE_P (type))
10093             fold_overflow_warning (("assuming signed overflow does not occur "
10094                                     "when distributing negation across "
10095                                     "division"),
10096                                    WARN_STRICT_OVERFLOW_MISC);
10097           return fold_build2 (code, type, negate_expr (arg0),
10098                               TREE_OPERAND (arg1, 0));
10099         }
10100
10101       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
10102          operation, EXACT_DIV_EXPR.
10103
10104          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
10105          At one time others generated faster code, it's not clear if they do
10106          after the last round to changes to the DIV code in expmed.c.  */
10107       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
10108           && multiple_of_p (type, arg0, arg1))
10109         return fold_build2 (EXACT_DIV_EXPR, type, arg0, arg1);
10110
10111       strict_overflow_p = false;
10112       if (TREE_CODE (arg1) == INTEGER_CST
10113           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10114                                          &strict_overflow_p)))
10115         {
10116           if (strict_overflow_p)
10117             fold_overflow_warning (("assuming signed overflow does not occur "
10118                                     "when simplifying division"),
10119                                    WARN_STRICT_OVERFLOW_MISC);
10120           return fold_convert (type, tem);
10121         }
10122
10123       return NULL_TREE;
10124
10125     case CEIL_MOD_EXPR:
10126     case FLOOR_MOD_EXPR:
10127     case ROUND_MOD_EXPR:
10128     case TRUNC_MOD_EXPR:
10129       /* X % 1 is always zero, but be sure to preserve any side
10130          effects in X.  */
10131       if (integer_onep (arg1))
10132         return omit_one_operand (type, integer_zero_node, arg0);
10133
10134       /* X % 0, return X % 0 unchanged so that we can get the
10135          proper warnings and errors.  */
10136       if (integer_zerop (arg1))
10137         return NULL_TREE;
10138
10139       /* 0 % X is always zero, but be sure to preserve any side
10140          effects in X.  Place this after checking for X == 0.  */
10141       if (integer_zerop (arg0))
10142         return omit_one_operand (type, integer_zero_node, arg1);
10143
10144       /* X % -1 is zero.  */
10145       if (!TYPE_UNSIGNED (type)
10146           && TREE_CODE (arg1) == INTEGER_CST
10147           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
10148           && TREE_INT_CST_HIGH (arg1) == -1)
10149         return omit_one_operand (type, integer_zero_node, arg0);
10150
10151       /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
10152          i.e. "X % C" into "X & (C - 1)", if X and C are positive.  */
10153       strict_overflow_p = false;
10154       if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
10155           && (TYPE_UNSIGNED (type)
10156               || tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p)))
10157         {
10158           tree c = arg1;
10159           /* Also optimize A % (C << N)  where C is a power of 2,
10160              to A & ((C << N) - 1).  */
10161           if (TREE_CODE (arg1) == LSHIFT_EXPR)
10162             c = TREE_OPERAND (arg1, 0);
10163
10164           if (integer_pow2p (c) && tree_int_cst_sgn (c) > 0)
10165             {
10166               tree mask = fold_build2 (MINUS_EXPR, TREE_TYPE (arg1),
10167                                        arg1, integer_one_node);
10168               if (strict_overflow_p)
10169                 fold_overflow_warning (("assuming signed overflow does not "
10170                                         "occur when simplifying "
10171                                         "X % (power of two)"),
10172                                        WARN_STRICT_OVERFLOW_MISC);
10173               return fold_build2 (BIT_AND_EXPR, type,
10174                                   fold_convert (type, arg0),
10175                                   fold_convert (type, mask));
10176             }
10177         }
10178
10179       /* X % -C is the same as X % C.  */
10180       if (code == TRUNC_MOD_EXPR
10181           && !TYPE_UNSIGNED (type)
10182           && TREE_CODE (arg1) == INTEGER_CST
10183           && !TREE_CONSTANT_OVERFLOW (arg1)
10184           && TREE_INT_CST_HIGH (arg1) < 0
10185           && !TYPE_OVERFLOW_TRAPS (type)
10186           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
10187           && !sign_bit_p (arg1, arg1))
10188         return fold_build2 (code, type, fold_convert (type, arg0),
10189                             fold_convert (type, negate_expr (arg1)));
10190
10191       /* X % -Y is the same as X % Y.  */
10192       if (code == TRUNC_MOD_EXPR
10193           && !TYPE_UNSIGNED (type)
10194           && TREE_CODE (arg1) == NEGATE_EXPR
10195           && !TYPE_OVERFLOW_TRAPS (type))
10196         return fold_build2 (code, type, fold_convert (type, arg0),
10197                             fold_convert (type, TREE_OPERAND (arg1, 0)));
10198
10199       if (TREE_CODE (arg1) == INTEGER_CST
10200           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE,
10201                                          &strict_overflow_p)))
10202         {
10203           if (strict_overflow_p)
10204             fold_overflow_warning (("assuming signed overflow does not occur "
10205                                     "when simplifying modulos"),
10206                                    WARN_STRICT_OVERFLOW_MISC);
10207           return fold_convert (type, tem);
10208         }
10209
10210       return NULL_TREE;
10211
10212     case LROTATE_EXPR:
10213     case RROTATE_EXPR:
10214       if (integer_all_onesp (arg0))
10215         return omit_one_operand (type, arg0, arg1);
10216       goto shift;
10217
10218     case RSHIFT_EXPR:
10219       /* Optimize -1 >> x for arithmetic right shifts.  */
10220       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
10221         return omit_one_operand (type, arg0, arg1);
10222       /* ... fall through ...  */
10223
10224     case LSHIFT_EXPR:
10225     shift:
10226       if (integer_zerop (arg1))
10227         return non_lvalue (fold_convert (type, arg0));
10228       if (integer_zerop (arg0))
10229         return omit_one_operand (type, arg0, arg1);
10230
10231       /* Since negative shift count is not well-defined,
10232          don't try to compute it in the compiler.  */
10233       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
10234         return NULL_TREE;
10235
10236       /* Turn (a OP c1) OP c2 into a OP (c1+c2).  */
10237       if (TREE_CODE (op0) == code && host_integerp (arg1, false)
10238           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
10239           && host_integerp (TREE_OPERAND (arg0, 1), false)
10240           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
10241         {
10242           HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
10243                                + TREE_INT_CST_LOW (arg1));
10244
10245           /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
10246              being well defined.  */
10247           if (low >= TYPE_PRECISION (type))
10248             {
10249               if (code == LROTATE_EXPR || code == RROTATE_EXPR)
10250                 low = low % TYPE_PRECISION (type);
10251               else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
10252                 return build_int_cst (type, 0);
10253               else
10254                 low = TYPE_PRECISION (type) - 1;
10255             }
10256
10257           return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10258                               build_int_cst (type, low));
10259         }
10260
10261       /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
10262          into x & ((unsigned)-1 >> c) for unsigned types.  */
10263       if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
10264            || (TYPE_UNSIGNED (type)
10265                && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
10266           && host_integerp (arg1, false)
10267           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
10268           && host_integerp (TREE_OPERAND (arg0, 1), false)
10269           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
10270         {
10271           HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
10272           HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
10273           tree lshift;
10274           tree arg00;
10275
10276           if (low0 == low1)
10277             {
10278               arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
10279
10280               lshift = build_int_cst (type, -1);
10281               lshift = int_const_binop (code, lshift, arg1, 0);
10282
10283               return fold_build2 (BIT_AND_EXPR, type, arg00, lshift);
10284             }
10285         }
10286
10287       /* Rewrite an LROTATE_EXPR by a constant into an
10288          RROTATE_EXPR by a new constant.  */
10289       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
10290         {
10291           tree tem = build_int_cst (NULL_TREE,
10292                                     GET_MODE_BITSIZE (TYPE_MODE (type)));
10293           tem = fold_convert (TREE_TYPE (arg1), tem);
10294           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
10295           return fold_build2 (RROTATE_EXPR, type, arg0, tem);
10296         }
10297
10298       /* If we have a rotate of a bit operation with the rotate count and
10299          the second operand of the bit operation both constant,
10300          permute the two operations.  */
10301       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10302           && (TREE_CODE (arg0) == BIT_AND_EXPR
10303               || TREE_CODE (arg0) == BIT_IOR_EXPR
10304               || TREE_CODE (arg0) == BIT_XOR_EXPR)
10305           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10306         return fold_build2 (TREE_CODE (arg0), type,
10307                             fold_build2 (code, type,
10308                                          TREE_OPERAND (arg0, 0), arg1),
10309                             fold_build2 (code, type,
10310                                          TREE_OPERAND (arg0, 1), arg1));
10311
10312       /* Two consecutive rotates adding up to the width of the mode can
10313          be ignored.  */
10314       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
10315           && TREE_CODE (arg0) == RROTATE_EXPR
10316           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10317           && TREE_INT_CST_HIGH (arg1) == 0
10318           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
10319           && ((TREE_INT_CST_LOW (arg1)
10320                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
10321               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
10322         return TREE_OPERAND (arg0, 0);
10323
10324       return NULL_TREE;
10325
10326     case MIN_EXPR:
10327       if (operand_equal_p (arg0, arg1, 0))
10328         return omit_one_operand (type, arg0, arg1);
10329       if (INTEGRAL_TYPE_P (type)
10330           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
10331         return omit_one_operand (type, arg1, arg0);
10332       tem = fold_minmax (MIN_EXPR, type, arg0, arg1);
10333       if (tem)
10334         return tem;
10335       goto associate;
10336
10337     case MAX_EXPR:
10338       if (operand_equal_p (arg0, arg1, 0))
10339         return omit_one_operand (type, arg0, arg1);
10340       if (INTEGRAL_TYPE_P (type)
10341           && TYPE_MAX_VALUE (type)
10342           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
10343         return omit_one_operand (type, arg1, arg0);
10344       tem = fold_minmax (MAX_EXPR, type, arg0, arg1);
10345       if (tem)
10346         return tem;
10347       goto associate;
10348
10349     case TRUTH_ANDIF_EXPR:
10350       /* Note that the operands of this must be ints
10351          and their values must be 0 or 1.
10352          ("true" is a fixed value perhaps depending on the language.)  */
10353       /* If first arg is constant zero, return it.  */
10354       if (integer_zerop (arg0))
10355         return fold_convert (type, arg0);
10356     case TRUTH_AND_EXPR:
10357       /* If either arg is constant true, drop it.  */
10358       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10359         return non_lvalue (fold_convert (type, arg1));
10360       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
10361           /* Preserve sequence points.  */
10362           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10363         return non_lvalue (fold_convert (type, arg0));
10364       /* If second arg is constant zero, result is zero, but first arg
10365          must be evaluated.  */
10366       if (integer_zerop (arg1))
10367         return omit_one_operand (type, arg1, arg0);
10368       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
10369          case will be handled here.  */
10370       if (integer_zerop (arg0))
10371         return omit_one_operand (type, arg0, arg1);
10372
10373       /* !X && X is always false.  */
10374       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10375           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10376         return omit_one_operand (type, integer_zero_node, arg1);
10377       /* X && !X is always false.  */
10378       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10379           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10380         return omit_one_operand (type, integer_zero_node, arg0);
10381
10382       /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
10383          means A >= Y && A != MAX, but in this case we know that
10384          A < X <= MAX.  */
10385
10386       if (!TREE_SIDE_EFFECTS (arg0)
10387           && !TREE_SIDE_EFFECTS (arg1))
10388         {
10389           tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
10390           if (tem && !operand_equal_p (tem, arg0, 0))
10391             return fold_build2 (code, type, tem, arg1);
10392
10393           tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
10394           if (tem && !operand_equal_p (tem, arg1, 0))
10395             return fold_build2 (code, type, arg0, tem);
10396         }
10397
10398     truth_andor:
10399       /* We only do these simplifications if we are optimizing.  */
10400       if (!optimize)
10401         return NULL_TREE;
10402
10403       /* Check for things like (A || B) && (A || C).  We can convert this
10404          to A || (B && C).  Note that either operator can be any of the four
10405          truth and/or operations and the transformation will still be
10406          valid.   Also note that we only care about order for the
10407          ANDIF and ORIF operators.  If B contains side effects, this
10408          might change the truth-value of A.  */
10409       if (TREE_CODE (arg0) == TREE_CODE (arg1)
10410           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
10411               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
10412               || TREE_CODE (arg0) == TRUTH_AND_EXPR
10413               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
10414           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
10415         {
10416           tree a00 = TREE_OPERAND (arg0, 0);
10417           tree a01 = TREE_OPERAND (arg0, 1);
10418           tree a10 = TREE_OPERAND (arg1, 0);
10419           tree a11 = TREE_OPERAND (arg1, 1);
10420           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
10421                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
10422                              && (code == TRUTH_AND_EXPR
10423                                  || code == TRUTH_OR_EXPR));
10424
10425           if (operand_equal_p (a00, a10, 0))
10426             return fold_build2 (TREE_CODE (arg0), type, a00,
10427                                 fold_build2 (code, type, a01, a11));
10428           else if (commutative && operand_equal_p (a00, a11, 0))
10429             return fold_build2 (TREE_CODE (arg0), type, a00,
10430                                 fold_build2 (code, type, a01, a10));
10431           else if (commutative && operand_equal_p (a01, a10, 0))
10432             return fold_build2 (TREE_CODE (arg0), type, a01,
10433                                 fold_build2 (code, type, a00, a11));
10434
10435           /* This case if tricky because we must either have commutative
10436              operators or else A10 must not have side-effects.  */
10437
10438           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
10439                    && operand_equal_p (a01, a11, 0))
10440             return fold_build2 (TREE_CODE (arg0), type,
10441                                 fold_build2 (code, type, a00, a10),
10442                                 a01);
10443         }
10444
10445       /* See if we can build a range comparison.  */
10446       if (0 != (tem = fold_range_test (code, type, op0, op1)))
10447         return tem;
10448
10449       /* Check for the possibility of merging component references.  If our
10450          lhs is another similar operation, try to merge its rhs with our
10451          rhs.  Then try to merge our lhs and rhs.  */
10452       if (TREE_CODE (arg0) == code
10453           && 0 != (tem = fold_truthop (code, type,
10454                                        TREE_OPERAND (arg0, 1), arg1)))
10455         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10456
10457       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
10458         return tem;
10459
10460       return NULL_TREE;
10461
10462     case TRUTH_ORIF_EXPR:
10463       /* Note that the operands of this must be ints
10464          and their values must be 0 or true.
10465          ("true" is a fixed value perhaps depending on the language.)  */
10466       /* If first arg is constant true, return it.  */
10467       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10468         return fold_convert (type, arg0);
10469     case TRUTH_OR_EXPR:
10470       /* If either arg is constant zero, drop it.  */
10471       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
10472         return non_lvalue (fold_convert (type, arg1));
10473       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
10474           /* Preserve sequence points.  */
10475           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
10476         return non_lvalue (fold_convert (type, arg0));
10477       /* If second arg is constant true, result is true, but we must
10478          evaluate first arg.  */
10479       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
10480         return omit_one_operand (type, arg1, arg0);
10481       /* Likewise for first arg, but note this only occurs here for
10482          TRUTH_OR_EXPR.  */
10483       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
10484         return omit_one_operand (type, arg0, arg1);
10485
10486       /* !X || X is always true.  */
10487       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10488           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10489         return omit_one_operand (type, integer_one_node, arg1);
10490       /* X || !X is always true.  */
10491       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10492           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10493         return omit_one_operand (type, integer_one_node, arg0);
10494
10495       goto truth_andor;
10496
10497     case TRUTH_XOR_EXPR:
10498       /* If the second arg is constant zero, drop it.  */
10499       if (integer_zerop (arg1))
10500         return non_lvalue (fold_convert (type, arg0));
10501       /* If the second arg is constant true, this is a logical inversion.  */
10502       if (integer_onep (arg1))
10503         {
10504           /* Only call invert_truthvalue if operand is a truth value.  */
10505           if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
10506             tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
10507           else
10508             tem = invert_truthvalue (arg0);
10509           return non_lvalue (fold_convert (type, tem));
10510         }
10511       /* Identical arguments cancel to zero.  */
10512       if (operand_equal_p (arg0, arg1, 0))
10513         return omit_one_operand (type, integer_zero_node, arg0);
10514
10515       /* !X ^ X is always true.  */
10516       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
10517           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
10518         return omit_one_operand (type, integer_one_node, arg1);
10519
10520       /* X ^ !X is always true.  */
10521       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
10522           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
10523         return omit_one_operand (type, integer_one_node, arg0);
10524
10525       return NULL_TREE;
10526
10527     case EQ_EXPR:
10528     case NE_EXPR:
10529       tem = fold_comparison (code, type, op0, op1);
10530       if (tem != NULL_TREE)
10531         return tem;
10532
10533       /* bool_var != 0 becomes bool_var. */
10534       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
10535           && code == NE_EXPR)
10536         return non_lvalue (fold_convert (type, arg0));
10537
10538       /* bool_var == 1 becomes bool_var. */
10539       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
10540           && code == EQ_EXPR)
10541         return non_lvalue (fold_convert (type, arg0));
10542
10543       /* bool_var != 1 becomes !bool_var. */
10544       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
10545           && code == NE_EXPR)
10546         return fold_build1 (TRUTH_NOT_EXPR, type, arg0);
10547
10548       /* bool_var == 0 becomes !bool_var. */
10549       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
10550           && code == EQ_EXPR)
10551         return fold_build1 (TRUTH_NOT_EXPR, type, arg0);
10552
10553       /*  ~a != C becomes a != ~C where C is a constant.  Likewise for ==.  */
10554       if (TREE_CODE (arg0) == BIT_NOT_EXPR
10555           && TREE_CODE (arg1) == INTEGER_CST)
10556         {
10557           tree cmp_type = TREE_TYPE (TREE_OPERAND (arg0, 0));
10558           return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10559                               fold_build1 (BIT_NOT_EXPR, cmp_type, 
10560                                            fold_convert (cmp_type, arg1)));
10561         }
10562
10563       /* If this is an equality comparison of the address of a non-weak
10564          object against zero, then we know the result.  */
10565       if (TREE_CODE (arg0) == ADDR_EXPR
10566           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
10567           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
10568           && integer_zerop (arg1))
10569         return constant_boolean_node (code != EQ_EXPR, type);
10570
10571       /* If this is an equality comparison of the address of two non-weak,
10572          unaliased symbols neither of which are extern (since we do not
10573          have access to attributes for externs), then we know the result.  */
10574       if (TREE_CODE (arg0) == ADDR_EXPR
10575           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
10576           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
10577           && ! lookup_attribute ("alias",
10578                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
10579           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
10580           && TREE_CODE (arg1) == ADDR_EXPR
10581           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
10582           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
10583           && ! lookup_attribute ("alias",
10584                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
10585           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
10586         {
10587           /* We know that we're looking at the address of two
10588              non-weak, unaliased, static _DECL nodes.
10589
10590              It is both wasteful and incorrect to call operand_equal_p
10591              to compare the two ADDR_EXPR nodes.  It is wasteful in that
10592              all we need to do is test pointer equality for the arguments
10593              to the two ADDR_EXPR nodes.  It is incorrect to use
10594              operand_equal_p as that function is NOT equivalent to a
10595              C equality test.  It can in fact return false for two
10596              objects which would test as equal using the C equality
10597              operator.  */
10598           bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
10599           return constant_boolean_node (equal
10600                                         ? code == EQ_EXPR : code != EQ_EXPR,
10601                                         type);
10602         }
10603
10604       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
10605          a MINUS_EXPR of a constant, we can convert it into a comparison with
10606          a revised constant as long as no overflow occurs.  */
10607       if (TREE_CODE (arg1) == INTEGER_CST
10608           && (TREE_CODE (arg0) == PLUS_EXPR
10609               || TREE_CODE (arg0) == MINUS_EXPR)
10610           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10611           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
10612                                       ? MINUS_EXPR : PLUS_EXPR,
10613                                       fold_convert (TREE_TYPE (arg0), arg1),
10614                                       TREE_OPERAND (arg0, 1), 0))
10615           && ! TREE_CONSTANT_OVERFLOW (tem))
10616         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10617
10618       /* Similarly for a NEGATE_EXPR.  */
10619       if (TREE_CODE (arg0) == NEGATE_EXPR
10620           && TREE_CODE (arg1) == INTEGER_CST
10621           && 0 != (tem = negate_expr (arg1))
10622           && TREE_CODE (tem) == INTEGER_CST
10623           && ! TREE_CONSTANT_OVERFLOW (tem))
10624         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
10625
10626       /* If we have X - Y == 0, we can convert that to X == Y and similarly
10627          for !=.  Don't do this for ordered comparisons due to overflow.  */
10628       if (TREE_CODE (arg0) == MINUS_EXPR
10629           && integer_zerop (arg1))
10630         return fold_build2 (code, type,
10631                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
10632
10633       /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.  */
10634       if (TREE_CODE (arg0) == ABS_EXPR
10635           && (integer_zerop (arg1) || real_zerop (arg1)))
10636         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), arg1);
10637
10638       /* If this is an EQ or NE comparison with zero and ARG0 is
10639          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
10640          two operations, but the latter can be done in one less insn
10641          on machines that have only two-operand insns or on which a
10642          constant cannot be the first operand.  */
10643       if (TREE_CODE (arg0) == BIT_AND_EXPR
10644           && integer_zerop (arg1))
10645         {
10646           tree arg00 = TREE_OPERAND (arg0, 0);
10647           tree arg01 = TREE_OPERAND (arg0, 1);
10648           if (TREE_CODE (arg00) == LSHIFT_EXPR
10649               && integer_onep (TREE_OPERAND (arg00, 0)))
10650             return
10651               fold_build2 (code, type,
10652                            build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10653                                    build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
10654                                            arg01, TREE_OPERAND (arg00, 1)),
10655                                    fold_convert (TREE_TYPE (arg0),
10656                                                  integer_one_node)),
10657                            arg1);
10658           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
10659                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
10660             return
10661               fold_build2 (code, type,
10662                            build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10663                                    build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
10664                                            arg00, TREE_OPERAND (arg01, 1)),
10665                                    fold_convert (TREE_TYPE (arg0),
10666                                                  integer_one_node)),
10667                            arg1);
10668         }
10669
10670       /* If this is an NE or EQ comparison of zero against the result of a
10671          signed MOD operation whose second operand is a power of 2, make
10672          the MOD operation unsigned since it is simpler and equivalent.  */
10673       if (integer_zerop (arg1)
10674           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
10675           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
10676               || TREE_CODE (arg0) == CEIL_MOD_EXPR
10677               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
10678               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
10679           && integer_pow2p (TREE_OPERAND (arg0, 1)))
10680         {
10681           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
10682           tree newmod = fold_build2 (TREE_CODE (arg0), newtype,
10683                                      fold_convert (newtype,
10684                                                    TREE_OPERAND (arg0, 0)),
10685                                      fold_convert (newtype,
10686                                                    TREE_OPERAND (arg0, 1)));
10687
10688           return fold_build2 (code, type, newmod,
10689                               fold_convert (newtype, arg1));
10690         }
10691
10692       /* Fold ((X >> C1) & C2) == 0 and ((X >> C1) & C2) != 0 where
10693          C1 is a valid shift constant, and C2 is a power of two, i.e.
10694          a single bit.  */
10695       if (TREE_CODE (arg0) == BIT_AND_EXPR
10696           && TREE_CODE (TREE_OPERAND (arg0, 0)) == RSHIFT_EXPR
10697           && TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1))
10698              == INTEGER_CST
10699           && integer_pow2p (TREE_OPERAND (arg0, 1))
10700           && integer_zerop (arg1))
10701         {
10702           tree itype = TREE_TYPE (arg0);
10703           unsigned HOST_WIDE_INT prec = TYPE_PRECISION (itype);
10704           tree arg001 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 1);
10705
10706           /* Check for a valid shift count.  */
10707           if (TREE_INT_CST_HIGH (arg001) == 0
10708               && TREE_INT_CST_LOW (arg001) < prec)
10709             {
10710               tree arg01 = TREE_OPERAND (arg0, 1);
10711               tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10712               unsigned HOST_WIDE_INT log2 = tree_log2 (arg01);
10713               /* If (C2 << C1) doesn't overflow, then ((X >> C1) & C2) != 0
10714                  can be rewritten as (X & (C2 << C1)) != 0.  */
10715               if ((log2 + TREE_INT_CST_LOW (arg001)) < prec)
10716                 {
10717                   tem = fold_build2 (LSHIFT_EXPR, itype, arg01, arg001);
10718                   tem = fold_build2 (BIT_AND_EXPR, itype, arg000, tem);
10719                   return fold_build2 (code, type, tem, arg1);
10720                 }
10721               /* Otherwise, for signed (arithmetic) shifts,
10722                  ((X >> C1) & C2) != 0 is rewritten as X < 0, and
10723                  ((X >> C1) & C2) == 0 is rewritten as X >= 0.  */
10724               else if (!TYPE_UNSIGNED (itype))
10725                 return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR, type,
10726                                     arg000, build_int_cst (itype, 0));
10727               /* Otherwise, of unsigned (logical) shifts,
10728                  ((X >> C1) & C2) != 0 is rewritten as (X,false), and
10729                  ((X >> C1) & C2) == 0 is rewritten as (X,true).  */
10730               else
10731                 return omit_one_operand (type,
10732                                          code == EQ_EXPR ? integer_one_node
10733                                                          : integer_zero_node,
10734                                          arg000);
10735             }
10736         }
10737
10738       /* If this is an NE comparison of zero with an AND of one, remove the
10739          comparison since the AND will give the correct value.  */
10740       if (code == NE_EXPR
10741           && integer_zerop (arg1)
10742           && TREE_CODE (arg0) == BIT_AND_EXPR
10743           && integer_onep (TREE_OPERAND (arg0, 1)))
10744         return fold_convert (type, arg0);
10745
10746       /* If we have (A & C) == C where C is a power of 2, convert this into
10747          (A & C) != 0.  Similarly for NE_EXPR.  */
10748       if (TREE_CODE (arg0) == BIT_AND_EXPR
10749           && integer_pow2p (TREE_OPERAND (arg0, 1))
10750           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10751         return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10752                             arg0, fold_convert (TREE_TYPE (arg0),
10753                                                 integer_zero_node));
10754
10755       /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
10756          bit, then fold the expression into A < 0 or A >= 0.  */
10757       tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
10758       if (tem)
10759         return tem;
10760
10761       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
10762          Similarly for NE_EXPR.  */
10763       if (TREE_CODE (arg0) == BIT_AND_EXPR
10764           && TREE_CODE (arg1) == INTEGER_CST
10765           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10766         {
10767           tree notc = fold_build1 (BIT_NOT_EXPR,
10768                                    TREE_TYPE (TREE_OPERAND (arg0, 1)),
10769                                    TREE_OPERAND (arg0, 1));
10770           tree dandnotc = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10771                                        arg1, notc);
10772           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
10773           if (integer_nonzerop (dandnotc))
10774             return omit_one_operand (type, rslt, arg0);
10775         }
10776
10777       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
10778          Similarly for NE_EXPR.  */
10779       if (TREE_CODE (arg0) == BIT_IOR_EXPR
10780           && TREE_CODE (arg1) == INTEGER_CST
10781           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10782         {
10783           tree notd = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
10784           tree candnotd = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10785                                        TREE_OPERAND (arg0, 1), notd);
10786           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
10787           if (integer_nonzerop (candnotd))
10788             return omit_one_operand (type, rslt, arg0);
10789         }
10790
10791       /* If this is a comparison of a field, we may be able to simplify it.  */
10792       if (((TREE_CODE (arg0) == COMPONENT_REF
10793             && lang_hooks.can_use_bit_fields_p ())
10794            || TREE_CODE (arg0) == BIT_FIELD_REF)
10795           /* Handle the constant case even without -O
10796              to make sure the warnings are given.  */
10797           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
10798         {
10799           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
10800           if (t1)
10801             return t1;
10802         }
10803
10804       /* Optimize comparisons of strlen vs zero to a compare of the
10805          first character of the string vs zero.  To wit,
10806                 strlen(ptr) == 0   =>  *ptr == 0
10807                 strlen(ptr) != 0   =>  *ptr != 0
10808          Other cases should reduce to one of these two (or a constant)
10809          due to the return value of strlen being unsigned.  */
10810       if (TREE_CODE (arg0) == CALL_EXPR
10811           && integer_zerop (arg1))
10812         {
10813           tree fndecl = get_callee_fndecl (arg0);
10814           tree arglist;
10815
10816           if (fndecl
10817               && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
10818               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
10819               && (arglist = TREE_OPERAND (arg0, 1))
10820               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
10821               && ! TREE_CHAIN (arglist))
10822             {
10823               tree iref = build_fold_indirect_ref (TREE_VALUE (arglist));
10824               return fold_build2 (code, type, iref,
10825                                   build_int_cst (TREE_TYPE (iref), 0));
10826             }
10827         }
10828
10829       /* Fold (X >> C) != 0 into X < 0 if C is one less than the width
10830          of X.  Similarly fold (X >> C) == 0 into X >= 0.  */
10831       if (TREE_CODE (arg0) == RSHIFT_EXPR
10832           && integer_zerop (arg1)
10833           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10834         {
10835           tree arg00 = TREE_OPERAND (arg0, 0);
10836           tree arg01 = TREE_OPERAND (arg0, 1);
10837           tree itype = TREE_TYPE (arg00);
10838           if (TREE_INT_CST_HIGH (arg01) == 0
10839               && TREE_INT_CST_LOW (arg01)
10840                  == (unsigned HOST_WIDE_INT) (TYPE_PRECISION (itype) - 1))
10841             {
10842               if (TYPE_UNSIGNED (itype))
10843                 {
10844                   itype = lang_hooks.types.signed_type (itype);
10845                   arg00 = fold_convert (itype, arg00);
10846                 }
10847               return fold_build2 (code == EQ_EXPR ? GE_EXPR : LT_EXPR,
10848                                   type, arg00, build_int_cst (itype, 0));
10849             }
10850         }
10851
10852       /* (X ^ Y) == 0 becomes X == Y, and (X ^ Y) != 0 becomes X != Y.  */
10853       if (integer_zerop (arg1)
10854           && TREE_CODE (arg0) == BIT_XOR_EXPR)
10855         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10856                             TREE_OPERAND (arg0, 1));
10857
10858       /* (X ^ Y) == Y becomes X == 0.  We know that Y has no side-effects.  */
10859       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10860           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
10861         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10862                             build_int_cst (TREE_TYPE (arg1), 0));
10863       /* Likewise (X ^ Y) == X becomes Y == 0.  X has no side-effects.  */
10864       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10865           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10866           && reorder_operands_p (TREE_OPERAND (arg0, 1), arg1))
10867         return fold_build2 (code, type, TREE_OPERAND (arg0, 1),
10868                             build_int_cst (TREE_TYPE (arg1), 0));
10869
10870       /* (X ^ C1) op C2 can be rewritten as X op (C1 ^ C2).  */
10871       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10872           && TREE_CODE (arg1) == INTEGER_CST
10873           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
10874         return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
10875                             fold_build2 (BIT_XOR_EXPR, TREE_TYPE (arg1),
10876                                          TREE_OPERAND (arg0, 1), arg1));
10877
10878       /* Fold (~X & C) == 0 into (X & C) != 0 and (~X & C) != 0 into
10879          (X & C) == 0 when C is a single bit.  */
10880       if (TREE_CODE (arg0) == BIT_AND_EXPR
10881           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_NOT_EXPR
10882           && integer_zerop (arg1)
10883           && integer_pow2p (TREE_OPERAND (arg0, 1)))
10884         {
10885           tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
10886                              TREE_OPERAND (TREE_OPERAND (arg0, 0), 0),
10887                              TREE_OPERAND (arg0, 1));
10888           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR,
10889                               type, tem, arg1);
10890         }
10891
10892       /* Fold ((X & C) ^ C) eq/ne 0 into (X & C) ne/eq 0, when the
10893          constant C is a power of two, i.e. a single bit.  */
10894       if (TREE_CODE (arg0) == BIT_XOR_EXPR
10895           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
10896           && integer_zerop (arg1)
10897           && integer_pow2p (TREE_OPERAND (arg0, 1))
10898           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10899                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10900         {
10901           tree arg00 = TREE_OPERAND (arg0, 0);
10902           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10903                               arg00, build_int_cst (TREE_TYPE (arg00), 0));
10904         }
10905
10906       /* Likewise, fold ((X ^ C) & C) eq/ne 0 into (X & C) ne/eq 0,
10907          when is C is a power of two, i.e. a single bit.  */
10908       if (TREE_CODE (arg0) == BIT_AND_EXPR
10909           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_XOR_EXPR
10910           && integer_zerop (arg1)
10911           && integer_pow2p (TREE_OPERAND (arg0, 1))
10912           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
10913                               TREE_OPERAND (arg0, 1), OEP_ONLY_CONST))
10914         {
10915           tree arg000 = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
10916           tem = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg000),
10917                              arg000, TREE_OPERAND (arg0, 1));
10918           return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
10919                               tem, build_int_cst (TREE_TYPE (tem), 0));
10920         }
10921
10922       if (integer_zerop (arg1)
10923           && tree_expr_nonzero_p (arg0))
10924         {
10925           tree res = constant_boolean_node (code==NE_EXPR, type);
10926           return omit_one_operand (type, res, arg0);
10927         }
10928       return NULL_TREE;
10929
10930     case LT_EXPR:
10931     case GT_EXPR:
10932     case LE_EXPR:
10933     case GE_EXPR:
10934       tem = fold_comparison (code, type, op0, op1);
10935       if (tem != NULL_TREE)
10936         return tem;
10937
10938       /* Transform comparisons of the form X +- C CMP X.  */
10939       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
10940           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
10941           && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
10942                && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
10943               || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
10944                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))))
10945         {
10946           tree arg01 = TREE_OPERAND (arg0, 1);
10947           enum tree_code code0 = TREE_CODE (arg0);
10948           int is_positive;
10949
10950           if (TREE_CODE (arg01) == REAL_CST)
10951             is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
10952           else
10953             is_positive = tree_int_cst_sgn (arg01);
10954
10955           /* (X - c) > X becomes false.  */
10956           if (code == GT_EXPR
10957               && ((code0 == MINUS_EXPR && is_positive >= 0)
10958                   || (code0 == PLUS_EXPR && is_positive <= 0)))
10959             {
10960               if (TREE_CODE (arg01) == INTEGER_CST
10961                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
10962                 fold_overflow_warning (("assuming signed overflow does not "
10963                                         "occur when assuming that (X - c) > X "
10964                                         "is always false"),
10965                                        WARN_STRICT_OVERFLOW_ALL);
10966               return constant_boolean_node (0, type);
10967             }
10968
10969           /* Likewise (X + c) < X becomes false.  */
10970           if (code == LT_EXPR
10971               && ((code0 == PLUS_EXPR && is_positive >= 0)
10972                   || (code0 == MINUS_EXPR && is_positive <= 0)))
10973             {
10974               if (TREE_CODE (arg01) == INTEGER_CST
10975                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
10976                 fold_overflow_warning (("assuming signed overflow does not "
10977                                         "occur when assuming that "
10978                                         "(X + c) < X is always false"),
10979                                        WARN_STRICT_OVERFLOW_ALL);
10980               return constant_boolean_node (0, type);
10981             }
10982
10983           /* Convert (X - c) <= X to true.  */
10984           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
10985               && code == LE_EXPR
10986               && ((code0 == MINUS_EXPR && is_positive >= 0)
10987                   || (code0 == PLUS_EXPR && is_positive <= 0)))
10988             {
10989               if (TREE_CODE (arg01) == INTEGER_CST
10990                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
10991                 fold_overflow_warning (("assuming signed overflow does not "
10992                                         "occur when assuming that "
10993                                         "(X - c) <= X is always true"),
10994                                        WARN_STRICT_OVERFLOW_ALL);
10995               return constant_boolean_node (1, type);
10996             }
10997
10998           /* Convert (X + c) >= X to true.  */
10999           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
11000               && code == GE_EXPR
11001               && ((code0 == PLUS_EXPR && is_positive >= 0)
11002                   || (code0 == MINUS_EXPR && is_positive <= 0)))
11003             {
11004               if (TREE_CODE (arg01) == INTEGER_CST
11005                   && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11006                 fold_overflow_warning (("assuming signed overflow does not "
11007                                         "occur when assuming that "
11008                                         "(X + c) >= X is always true"),
11009                                        WARN_STRICT_OVERFLOW_ALL);
11010               return constant_boolean_node (1, type);
11011             }
11012
11013           if (TREE_CODE (arg01) == INTEGER_CST)
11014             {
11015               /* Convert X + c > X and X - c < X to true for integers.  */
11016               if (code == GT_EXPR
11017                   && ((code0 == PLUS_EXPR && is_positive > 0)
11018                       || (code0 == MINUS_EXPR && is_positive < 0)))
11019                 {
11020                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11021                     fold_overflow_warning (("assuming signed overflow does "
11022                                             "not occur when assuming that "
11023                                             "(X + c) > X is always true"),
11024                                            WARN_STRICT_OVERFLOW_ALL);
11025                   return constant_boolean_node (1, type);
11026                 }
11027
11028               if (code == LT_EXPR
11029                   && ((code0 == MINUS_EXPR && is_positive > 0)
11030                       || (code0 == PLUS_EXPR && is_positive < 0)))
11031                 {
11032                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11033                     fold_overflow_warning (("assuming signed overflow does "
11034                                             "not occur when assuming that "
11035                                             "(X - c) < X is always true"),
11036                                            WARN_STRICT_OVERFLOW_ALL);
11037                   return constant_boolean_node (1, type);
11038                 }
11039
11040               /* Convert X + c <= X and X - c >= X to false for integers.  */
11041               if (code == LE_EXPR
11042                   && ((code0 == PLUS_EXPR && is_positive > 0)
11043                       || (code0 == MINUS_EXPR && is_positive < 0)))
11044                 {
11045                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11046                     fold_overflow_warning (("assuming signed overflow does "
11047                                             "not occur when assuming that "
11048                                             "(X + c) <= X is always false"),
11049                                            WARN_STRICT_OVERFLOW_ALL);
11050                   return constant_boolean_node (0, type);
11051                 }
11052
11053               if (code == GE_EXPR
11054                   && ((code0 == MINUS_EXPR && is_positive > 0)
11055                       || (code0 == PLUS_EXPR && is_positive < 0)))
11056                 {
11057                   if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (arg1)))
11058                     fold_overflow_warning (("assuming signed overflow does "
11059                                             "not occur when assuming that "
11060                                             "(X - c) >= X is always true"),
11061                                            WARN_STRICT_OVERFLOW_ALL);
11062                   return constant_boolean_node (0, type);
11063                 }
11064             }
11065         }
11066
11067       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
11068          This transformation affects the cases which are handled in later
11069          optimizations involving comparisons with non-negative constants.  */
11070       if (TREE_CODE (arg1) == INTEGER_CST
11071           && TREE_CODE (arg0) != INTEGER_CST
11072           && tree_int_cst_sgn (arg1) > 0)
11073         {
11074           if (code == GE_EXPR)
11075             {
11076               arg1 = const_binop (MINUS_EXPR, arg1,
11077                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
11078               return fold_build2 (GT_EXPR, type, arg0,
11079                                   fold_convert (TREE_TYPE (arg0), arg1));
11080             }
11081           if (code == LT_EXPR)
11082             {
11083               arg1 = const_binop (MINUS_EXPR, arg1,
11084                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
11085               return fold_build2 (LE_EXPR, type, arg0,
11086                                   fold_convert (TREE_TYPE (arg0), arg1));
11087             }
11088         }
11089
11090       /* Comparisons with the highest or lowest possible integer of
11091          the specified size will have known values.  */
11092       {
11093         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
11094
11095         if (TREE_CODE (arg1) == INTEGER_CST
11096             && ! TREE_CONSTANT_OVERFLOW (arg1)
11097             && width <= 2 * HOST_BITS_PER_WIDE_INT
11098             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
11099                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
11100           {
11101             HOST_WIDE_INT signed_max_hi;
11102             unsigned HOST_WIDE_INT signed_max_lo;
11103             unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
11104
11105             if (width <= HOST_BITS_PER_WIDE_INT)
11106               {
11107                 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
11108                                 - 1;
11109                 signed_max_hi = 0;
11110                 max_hi = 0;
11111
11112                 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
11113                   {
11114                     max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
11115                     min_lo = 0;
11116                     min_hi = 0;
11117                   }
11118                 else
11119                   {
11120                     max_lo = signed_max_lo;
11121                     min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
11122                     min_hi = -1;
11123                   }
11124               }
11125             else
11126               {
11127                 width -= HOST_BITS_PER_WIDE_INT;
11128                 signed_max_lo = -1;
11129                 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
11130                                 - 1;
11131                 max_lo = -1;
11132                 min_lo = 0;
11133
11134                 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
11135                   {
11136                     max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
11137                     min_hi = 0;
11138                   }
11139                 else
11140                   {
11141                     max_hi = signed_max_hi;
11142                     min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
11143                   }
11144               }
11145
11146             if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
11147                 && TREE_INT_CST_LOW (arg1) == max_lo)
11148               switch (code)
11149                 {
11150                 case GT_EXPR:
11151                   return omit_one_operand (type, integer_zero_node, arg0);
11152
11153                 case GE_EXPR:
11154                   return fold_build2 (EQ_EXPR, type, op0, op1);
11155
11156                 case LE_EXPR:
11157                   return omit_one_operand (type, integer_one_node, arg0);
11158
11159                 case LT_EXPR:
11160                   return fold_build2 (NE_EXPR, type, op0, op1);
11161
11162                 /* The GE_EXPR and LT_EXPR cases above are not normally
11163                    reached because of previous transformations.  */
11164
11165                 default:
11166                   break;
11167                 }
11168             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
11169                      == max_hi
11170                      && TREE_INT_CST_LOW (arg1) == max_lo - 1)
11171               switch (code)
11172                 {
11173                 case GT_EXPR:
11174                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
11175                   return fold_build2 (EQ_EXPR, type,
11176                                       fold_convert (TREE_TYPE (arg1), arg0),
11177                                       arg1);
11178                 case LE_EXPR:
11179                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
11180                   return fold_build2 (NE_EXPR, type,
11181                                       fold_convert (TREE_TYPE (arg1), arg0),
11182                                       arg1);
11183                 default:
11184                   break;
11185                 }
11186             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
11187                      == min_hi
11188                      && TREE_INT_CST_LOW (arg1) == min_lo)
11189               switch (code)
11190                 {
11191                 case LT_EXPR:
11192                   return omit_one_operand (type, integer_zero_node, arg0);
11193
11194                 case LE_EXPR:
11195                   return fold_build2 (EQ_EXPR, type, op0, op1);
11196
11197                 case GE_EXPR:
11198                   return omit_one_operand (type, integer_one_node, arg0);
11199
11200                 case GT_EXPR:
11201                   return fold_build2 (NE_EXPR, type, op0, op1);
11202
11203                 default:
11204                   break;
11205                 }
11206             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
11207                      == min_hi
11208                      && TREE_INT_CST_LOW (arg1) == min_lo + 1)
11209               switch (code)
11210                 {
11211                 case GE_EXPR:
11212                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
11213                   return fold_build2 (NE_EXPR, type,
11214                                       fold_convert (TREE_TYPE (arg1), arg0),
11215                                       arg1);
11216                 case LT_EXPR:
11217                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
11218                   return fold_build2 (EQ_EXPR, type,
11219                                       fold_convert (TREE_TYPE (arg1), arg0),
11220                                       arg1);
11221                 default:
11222                   break;
11223                 }
11224
11225             else if (!in_gimple_form
11226                      && TREE_INT_CST_HIGH (arg1) == signed_max_hi
11227                      && TREE_INT_CST_LOW (arg1) == signed_max_lo
11228                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
11229                      /* signed_type does not work on pointer types.  */
11230                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
11231               {
11232                 /* The following case also applies to X < signed_max+1
11233                    and X >= signed_max+1 because previous transformations.  */
11234                 if (code == LE_EXPR || code == GT_EXPR)
11235                   {
11236                     tree st;
11237                     st = lang_hooks.types.signed_type (TREE_TYPE (arg1));
11238                     return fold_build2 (code == LE_EXPR ? GE_EXPR : LT_EXPR,
11239                                         type, fold_convert (st, arg0),
11240                                         build_int_cst (st, 0));
11241                   }
11242               }
11243           }
11244       }
11245
11246       /* If we are comparing an ABS_EXPR with a constant, we can
11247          convert all the cases into explicit comparisons, but they may
11248          well not be faster than doing the ABS and one comparison.
11249          But ABS (X) <= C is a range comparison, which becomes a subtraction
11250          and a comparison, and is probably faster.  */
11251       if (code == LE_EXPR
11252           && TREE_CODE (arg1) == INTEGER_CST
11253           && TREE_CODE (arg0) == ABS_EXPR
11254           && ! TREE_SIDE_EFFECTS (arg0)
11255           && (0 != (tem = negate_expr (arg1)))
11256           && TREE_CODE (tem) == INTEGER_CST
11257           && ! TREE_CONSTANT_OVERFLOW (tem))
11258         return fold_build2 (TRUTH_ANDIF_EXPR, type,
11259                             build2 (GE_EXPR, type,
11260                                     TREE_OPERAND (arg0, 0), tem),
11261                             build2 (LE_EXPR, type,
11262                                     TREE_OPERAND (arg0, 0), arg1));
11263
11264       /* Convert ABS_EXPR<x> >= 0 to true.  */
11265       strict_overflow_p = false;
11266       if (code == GE_EXPR
11267           && (integer_zerop (arg1)
11268               || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
11269                   && real_zerop (arg1)))
11270           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
11271         {
11272           if (strict_overflow_p)
11273             fold_overflow_warning (("assuming signed overflow does not occur "
11274                                     "when simplifying comparison of "
11275                                     "absolute value and zero"),
11276                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
11277           return omit_one_operand (type, integer_one_node, arg0);
11278         }
11279
11280       /* Convert ABS_EXPR<x> < 0 to false.  */
11281       strict_overflow_p = false;
11282       if (code == LT_EXPR
11283           && (integer_zerop (arg1) || real_zerop (arg1))
11284           && tree_expr_nonnegative_warnv_p (arg0, &strict_overflow_p))
11285         {
11286           if (strict_overflow_p)
11287             fold_overflow_warning (("assuming signed overflow does not occur "
11288                                     "when simplifying comparison of "
11289                                     "absolute value and zero"),
11290                                    WARN_STRICT_OVERFLOW_CONDITIONAL);
11291           return omit_one_operand (type, integer_zero_node, arg0);
11292         }
11293
11294       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
11295          and similarly for >= into !=.  */
11296       if ((code == LT_EXPR || code == GE_EXPR)
11297           && TYPE_UNSIGNED (TREE_TYPE (arg0))
11298           && TREE_CODE (arg1) == LSHIFT_EXPR
11299           && integer_onep (TREE_OPERAND (arg1, 0)))
11300         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
11301                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
11302                                TREE_OPERAND (arg1, 1)),
11303                        build_int_cst (TREE_TYPE (arg0), 0));
11304
11305       if ((code == LT_EXPR || code == GE_EXPR)
11306           && TYPE_UNSIGNED (TREE_TYPE (arg0))
11307           && (TREE_CODE (arg1) == NOP_EXPR
11308               || TREE_CODE (arg1) == CONVERT_EXPR)
11309           && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
11310           && integer_onep (TREE_OPERAND (TREE_OPERAND (arg1, 0), 0)))
11311         return
11312           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
11313                   fold_convert (TREE_TYPE (arg0),
11314                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
11315                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
11316                                                       1))),
11317                   build_int_cst (TREE_TYPE (arg0), 0));
11318
11319       return NULL_TREE;
11320
11321     case UNORDERED_EXPR:
11322     case ORDERED_EXPR:
11323     case UNLT_EXPR:
11324     case UNLE_EXPR:
11325     case UNGT_EXPR:
11326     case UNGE_EXPR:
11327     case UNEQ_EXPR:
11328     case LTGT_EXPR:
11329       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
11330         {
11331           t1 = fold_relational_const (code, type, arg0, arg1);
11332           if (t1 != NULL_TREE)
11333             return t1;
11334         }
11335
11336       /* If the first operand is NaN, the result is constant.  */
11337       if (TREE_CODE (arg0) == REAL_CST
11338           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
11339           && (code != LTGT_EXPR || ! flag_trapping_math))
11340         {
11341           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
11342                ? integer_zero_node
11343                : integer_one_node;
11344           return omit_one_operand (type, t1, arg1);
11345         }
11346
11347       /* If the second operand is NaN, the result is constant.  */
11348       if (TREE_CODE (arg1) == REAL_CST
11349           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
11350           && (code != LTGT_EXPR || ! flag_trapping_math))
11351         {
11352           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
11353                ? integer_zero_node
11354                : integer_one_node;
11355           return omit_one_operand (type, t1, arg0);
11356         }
11357
11358       /* Simplify unordered comparison of something with itself.  */
11359       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
11360           && operand_equal_p (arg0, arg1, 0))
11361         return constant_boolean_node (1, type);
11362
11363       if (code == LTGT_EXPR
11364           && !flag_trapping_math
11365           && operand_equal_p (arg0, arg1, 0))
11366         return constant_boolean_node (0, type);
11367
11368       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
11369       {
11370         tree targ0 = strip_float_extensions (arg0);
11371         tree targ1 = strip_float_extensions (arg1);
11372         tree newtype = TREE_TYPE (targ0);
11373
11374         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
11375           newtype = TREE_TYPE (targ1);
11376
11377         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
11378           return fold_build2 (code, type, fold_convert (newtype, targ0),
11379                               fold_convert (newtype, targ1));
11380       }
11381
11382       return NULL_TREE;
11383
11384     case COMPOUND_EXPR:
11385       /* When pedantic, a compound expression can be neither an lvalue
11386          nor an integer constant expression.  */
11387       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
11388         return NULL_TREE;
11389       /* Don't let (0, 0) be null pointer constant.  */
11390       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
11391                                  : fold_convert (type, arg1);
11392       return pedantic_non_lvalue (tem);
11393
11394     case COMPLEX_EXPR:
11395       if ((TREE_CODE (arg0) == REAL_CST
11396            && TREE_CODE (arg1) == REAL_CST)
11397           || (TREE_CODE (arg0) == INTEGER_CST
11398               && TREE_CODE (arg1) == INTEGER_CST))
11399         return build_complex (type, arg0, arg1);
11400       return NULL_TREE;
11401
11402     case ASSERT_EXPR:
11403       /* An ASSERT_EXPR should never be passed to fold_binary.  */
11404       gcc_unreachable ();
11405
11406     default:
11407       return NULL_TREE;
11408     } /* switch (code) */
11409 }
11410
11411 /* Callback for walk_tree, looking for LABEL_EXPR.
11412    Returns tree TP if it is LABEL_EXPR. Otherwise it returns NULL_TREE.
11413    Do not check the sub-tree of GOTO_EXPR.  */
11414
11415 static tree
11416 contains_label_1 (tree *tp,
11417                   int *walk_subtrees,
11418                   void *data ATTRIBUTE_UNUSED)
11419 {
11420   switch (TREE_CODE (*tp))
11421     {
11422     case LABEL_EXPR:
11423       return *tp;
11424     case GOTO_EXPR:
11425       *walk_subtrees = 0;
11426     /* no break */
11427     default:
11428       return NULL_TREE;
11429     }
11430 }
11431
11432 /* Checks whether the sub-tree ST contains a label LABEL_EXPR which is
11433    accessible from outside the sub-tree. Returns NULL_TREE if no
11434    addressable label is found.  */
11435
11436 static bool
11437 contains_label_p (tree st)
11438 {
11439   return (walk_tree (&st, contains_label_1 , NULL, NULL) != NULL_TREE);
11440 }
11441
11442 /* Fold a ternary expression of code CODE and type TYPE with operands
11443    OP0, OP1, and OP2.  Return the folded expression if folding is
11444    successful.  Otherwise, return NULL_TREE.  */
11445
11446 tree
11447 fold_ternary (enum tree_code code, tree type, tree op0, tree op1, tree op2)
11448 {
11449   tree tem;
11450   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
11451   enum tree_code_class kind = TREE_CODE_CLASS (code);
11452
11453   gcc_assert (IS_EXPR_CODE_CLASS (kind)
11454               && TREE_CODE_LENGTH (code) == 3);
11455
11456   /* Strip any conversions that don't change the mode.  This is safe
11457      for every expression, except for a comparison expression because
11458      its signedness is derived from its operands.  So, in the latter
11459      case, only strip conversions that don't change the signedness.
11460
11461      Note that this is done as an internal manipulation within the
11462      constant folder, in order to find the simplest representation of
11463      the arguments so that their form can be studied.  In any cases,
11464      the appropriate type conversions should be put back in the tree
11465      that will get out of the constant folder.  */
11466   if (op0)
11467     {
11468       arg0 = op0;
11469       STRIP_NOPS (arg0);
11470     }
11471
11472   if (op1)
11473     {
11474       arg1 = op1;
11475       STRIP_NOPS (arg1);
11476     }
11477
11478   switch (code)
11479     {
11480     case COMPONENT_REF:
11481       if (TREE_CODE (arg0) == CONSTRUCTOR
11482           && ! type_contains_placeholder_p (TREE_TYPE (arg0)))
11483         {
11484           unsigned HOST_WIDE_INT idx;
11485           tree field, value;
11486           FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (arg0), idx, field, value)
11487             if (field == arg1)
11488               return value;
11489         }
11490       return NULL_TREE;
11491
11492     case COND_EXPR:
11493       /* Pedantic ANSI C says that a conditional expression is never an lvalue,
11494          so all simple results must be passed through pedantic_non_lvalue.  */
11495       if (TREE_CODE (arg0) == INTEGER_CST)
11496         {
11497           tree unused_op = integer_zerop (arg0) ? op1 : op2;
11498           tem = integer_zerop (arg0) ? op2 : op1;
11499           /* Only optimize constant conditions when the selected branch
11500              has the same type as the COND_EXPR.  This avoids optimizing
11501              away "c ? x : throw", where the throw has a void type.
11502              Avoid throwing away that operand which contains label.  */
11503           if ((!TREE_SIDE_EFFECTS (unused_op)
11504                || !contains_label_p (unused_op))
11505               && (! VOID_TYPE_P (TREE_TYPE (tem))
11506                   || VOID_TYPE_P (type)))
11507             return pedantic_non_lvalue (tem);
11508           return NULL_TREE;
11509         }
11510       if (operand_equal_p (arg1, op2, 0))
11511         return pedantic_omit_one_operand (type, arg1, arg0);
11512
11513       /* If we have A op B ? A : C, we may be able to convert this to a
11514          simpler expression, depending on the operation and the values
11515          of B and C.  Signed zeros prevent all of these transformations,
11516          for reasons given above each one.
11517
11518          Also try swapping the arguments and inverting the conditional.  */
11519       if (COMPARISON_CLASS_P (arg0)
11520           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11521                                              arg1, TREE_OPERAND (arg0, 1))
11522           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
11523         {
11524           tem = fold_cond_expr_with_comparison (type, arg0, op1, op2);
11525           if (tem)
11526             return tem;
11527         }
11528
11529       if (COMPARISON_CLASS_P (arg0)
11530           && operand_equal_for_comparison_p (TREE_OPERAND (arg0, 0),
11531                                              op2,
11532                                              TREE_OPERAND (arg0, 1))
11533           && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (op2))))
11534         {
11535           tem = fold_truth_not_expr (arg0);
11536           if (tem && COMPARISON_CLASS_P (tem))
11537             {
11538               tem = fold_cond_expr_with_comparison (type, tem, op2, op1);
11539               if (tem)
11540                 return tem;
11541             }
11542         }
11543
11544       /* If the second operand is simpler than the third, swap them
11545          since that produces better jump optimization results.  */
11546       if (truth_value_p (TREE_CODE (arg0))
11547           && tree_swap_operands_p (op1, op2, false))
11548         {
11549           /* See if this can be inverted.  If it can't, possibly because
11550              it was a floating-point inequality comparison, don't do
11551              anything.  */
11552           tem = fold_truth_not_expr (arg0);
11553           if (tem)
11554             return fold_build3 (code, type, tem, op2, op1);
11555         }
11556
11557       /* Convert A ? 1 : 0 to simply A.  */
11558       if (integer_onep (op1)
11559           && integer_zerop (op2)
11560           /* If we try to convert OP0 to our type, the
11561              call to fold will try to move the conversion inside
11562              a COND, which will recurse.  In that case, the COND_EXPR
11563              is probably the best choice, so leave it alone.  */
11564           && type == TREE_TYPE (arg0))
11565         return pedantic_non_lvalue (arg0);
11566
11567       /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
11568          over COND_EXPR in cases such as floating point comparisons.  */
11569       if (integer_zerop (op1)
11570           && integer_onep (op2)
11571           && truth_value_p (TREE_CODE (arg0)))
11572         return pedantic_non_lvalue (fold_convert (type,
11573                                                   invert_truthvalue (arg0)));
11574
11575       /* A < 0 ? <sign bit of A> : 0 is simply (A & <sign bit of A>).  */
11576       if (TREE_CODE (arg0) == LT_EXPR
11577           && integer_zerop (TREE_OPERAND (arg0, 1))
11578           && integer_zerop (op2)
11579           && (tem = sign_bit_p (TREE_OPERAND (arg0, 0), arg1)))
11580         {
11581           /* sign_bit_p only checks ARG1 bits within A's precision.
11582              If <sign bit of A> has wider type than A, bits outside
11583              of A's precision in <sign bit of A> need to be checked.
11584              If they are all 0, this optimization needs to be done
11585              in unsigned A's type, if they are all 1 in signed A's type,
11586              otherwise this can't be done.  */
11587           if (TYPE_PRECISION (TREE_TYPE (tem))
11588               < TYPE_PRECISION (TREE_TYPE (arg1))
11589               && TYPE_PRECISION (TREE_TYPE (tem))
11590                  < TYPE_PRECISION (type))
11591             {
11592               unsigned HOST_WIDE_INT mask_lo;
11593               HOST_WIDE_INT mask_hi;
11594               int inner_width, outer_width;
11595               tree tem_type;
11596
11597               inner_width = TYPE_PRECISION (TREE_TYPE (tem));
11598               outer_width = TYPE_PRECISION (TREE_TYPE (arg1));
11599               if (outer_width > TYPE_PRECISION (type))
11600                 outer_width = TYPE_PRECISION (type);
11601
11602               if (outer_width > HOST_BITS_PER_WIDE_INT)
11603                 {
11604                   mask_hi = ((unsigned HOST_WIDE_INT) -1
11605                              >> (2 * HOST_BITS_PER_WIDE_INT - outer_width));
11606                   mask_lo = -1;
11607                 }
11608               else
11609                 {
11610                   mask_hi = 0;
11611                   mask_lo = ((unsigned HOST_WIDE_INT) -1
11612                              >> (HOST_BITS_PER_WIDE_INT - outer_width));
11613                 }
11614               if (inner_width > HOST_BITS_PER_WIDE_INT)
11615                 {
11616                   mask_hi &= ~((unsigned HOST_WIDE_INT) -1
11617                                >> (HOST_BITS_PER_WIDE_INT - inner_width));
11618                   mask_lo = 0;
11619                 }
11620               else
11621                 mask_lo &= ~((unsigned HOST_WIDE_INT) -1
11622                              >> (HOST_BITS_PER_WIDE_INT - inner_width));
11623
11624               if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == mask_hi
11625                   && (TREE_INT_CST_LOW (arg1) & mask_lo) == mask_lo)
11626                 {
11627                   tem_type = lang_hooks.types.signed_type (TREE_TYPE (tem));
11628                   tem = fold_convert (tem_type, tem);
11629                 }
11630               else if ((TREE_INT_CST_HIGH (arg1) & mask_hi) == 0
11631                        && (TREE_INT_CST_LOW (arg1) & mask_lo) == 0)
11632                 {
11633                   tem_type = lang_hooks.types.unsigned_type (TREE_TYPE (tem));
11634                   tem = fold_convert (tem_type, tem);
11635                 }
11636               else
11637                 tem = NULL;
11638             }
11639
11640           if (tem)
11641             return fold_convert (type,
11642                                  fold_build2 (BIT_AND_EXPR,
11643                                               TREE_TYPE (tem), tem,
11644                                               fold_convert (TREE_TYPE (tem),
11645                                                             arg1)));
11646         }
11647
11648       /* (A >> N) & 1 ? (1 << N) : 0 is simply A & (1 << N).  A & 1 was
11649          already handled above.  */
11650       if (TREE_CODE (arg0) == BIT_AND_EXPR
11651           && integer_onep (TREE_OPERAND (arg0, 1))
11652           && integer_zerop (op2)
11653           && integer_pow2p (arg1))
11654         {
11655           tree tem = TREE_OPERAND (arg0, 0);
11656           STRIP_NOPS (tem);
11657           if (TREE_CODE (tem) == RSHIFT_EXPR
11658               && TREE_CODE (TREE_OPERAND (tem, 1)) == INTEGER_CST
11659               && (unsigned HOST_WIDE_INT) tree_log2 (arg1) ==
11660                  TREE_INT_CST_LOW (TREE_OPERAND (tem, 1)))
11661             return fold_build2 (BIT_AND_EXPR, type,
11662                                 TREE_OPERAND (tem, 0), arg1);
11663         }
11664
11665       /* A & N ? N : 0 is simply A & N if N is a power of two.  This
11666          is probably obsolete because the first operand should be a
11667          truth value (that's why we have the two cases above), but let's
11668          leave it in until we can confirm this for all front-ends.  */
11669       if (integer_zerop (op2)
11670           && TREE_CODE (arg0) == NE_EXPR
11671           && integer_zerop (TREE_OPERAND (arg0, 1))
11672           && integer_pow2p (arg1)
11673           && TREE_CODE (TREE_OPERAND (arg0, 0)) == BIT_AND_EXPR
11674           && operand_equal_p (TREE_OPERAND (TREE_OPERAND (arg0, 0), 1),
11675                               arg1, OEP_ONLY_CONST))
11676         return pedantic_non_lvalue (fold_convert (type,
11677                                                   TREE_OPERAND (arg0, 0)));
11678
11679       /* Convert A ? B : 0 into A && B if A and B are truth values.  */
11680       if (integer_zerop (op2)
11681           && truth_value_p (TREE_CODE (arg0))
11682           && truth_value_p (TREE_CODE (arg1)))
11683         return fold_build2 (TRUTH_ANDIF_EXPR, type,
11684                             fold_convert (type, arg0),
11685                             arg1);
11686
11687       /* Convert A ? B : 1 into !A || B if A and B are truth values.  */
11688       if (integer_onep (op2)
11689           && truth_value_p (TREE_CODE (arg0))
11690           && truth_value_p (TREE_CODE (arg1)))
11691         {
11692           /* Only perform transformation if ARG0 is easily inverted.  */
11693           tem = fold_truth_not_expr (arg0);
11694           if (tem)
11695             return fold_build2 (TRUTH_ORIF_EXPR, type,
11696                                 fold_convert (type, tem),
11697                                 arg1);
11698         }
11699
11700       /* Convert A ? 0 : B into !A && B if A and B are truth values.  */
11701       if (integer_zerop (arg1)
11702           && truth_value_p (TREE_CODE (arg0))
11703           && truth_value_p (TREE_CODE (op2)))
11704         {
11705           /* Only perform transformation if ARG0 is easily inverted.  */
11706           tem = fold_truth_not_expr (arg0);
11707           if (tem)
11708             return fold_build2 (TRUTH_ANDIF_EXPR, type,
11709                                 fold_convert (type, tem),
11710                                 op2);
11711         }
11712
11713       /* Convert A ? 1 : B into A || B if A and B are truth values.  */
11714       if (integer_onep (arg1)
11715           && truth_value_p (TREE_CODE (arg0))
11716           && truth_value_p (TREE_CODE (op2)))
11717         return fold_build2 (TRUTH_ORIF_EXPR, type,
11718                             fold_convert (type, arg0),
11719                             op2);
11720
11721       return NULL_TREE;
11722
11723     case CALL_EXPR:
11724       /* Check for a built-in function.  */
11725       if (TREE_CODE (op0) == ADDR_EXPR
11726           && TREE_CODE (TREE_OPERAND (op0, 0)) == FUNCTION_DECL
11727           && DECL_BUILT_IN (TREE_OPERAND (op0, 0)))
11728         return fold_builtin (TREE_OPERAND (op0, 0), op1, false);
11729       return NULL_TREE;
11730
11731     case BIT_FIELD_REF:
11732       if (TREE_CODE (arg0) == VECTOR_CST
11733           && type == TREE_TYPE (TREE_TYPE (arg0))
11734           && host_integerp (arg1, 1)
11735           && host_integerp (op2, 1))
11736         {
11737           unsigned HOST_WIDE_INT width = tree_low_cst (arg1, 1);
11738           unsigned HOST_WIDE_INT idx = tree_low_cst (op2, 1);
11739
11740           if (width != 0
11741               && simple_cst_equal (arg1, TYPE_SIZE (type)) == 1
11742               && (idx % width) == 0
11743               && (idx = idx / width)
11744                  < TYPE_VECTOR_SUBPARTS (TREE_TYPE (arg0)))
11745             {
11746               tree elements = TREE_VECTOR_CST_ELTS (arg0);
11747               while (idx-- > 0 && elements)
11748                 elements = TREE_CHAIN (elements);
11749               if (elements)
11750                 return TREE_VALUE (elements);
11751               else
11752                 return fold_convert (type, integer_zero_node);
11753             }
11754         }
11755       return NULL_TREE;
11756
11757     default:
11758       return NULL_TREE;
11759     } /* switch (code) */
11760 }
11761
11762 /* Perform constant folding and related simplification of EXPR.
11763    The related simplifications include x*1 => x, x*0 => 0, etc.,
11764    and application of the associative law.
11765    NOP_EXPR conversions may be removed freely (as long as we
11766    are careful not to change the type of the overall expression).
11767    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
11768    but we can constant-fold them if they have constant operands.  */
11769
11770 #ifdef ENABLE_FOLD_CHECKING
11771 # define fold(x) fold_1 (x)
11772 static tree fold_1 (tree);
11773 static
11774 #endif
11775 tree
11776 fold (tree expr)
11777 {
11778   const tree t = expr;
11779   enum tree_code code = TREE_CODE (t);
11780   enum tree_code_class kind = TREE_CODE_CLASS (code);
11781   tree tem;
11782
11783   /* Return right away if a constant.  */
11784   if (kind == tcc_constant)
11785     return t;
11786
11787   if (IS_EXPR_CODE_CLASS (kind))
11788     {
11789       tree type = TREE_TYPE (t);
11790       tree op0, op1, op2;
11791
11792       switch (TREE_CODE_LENGTH (code))
11793         {
11794         case 1:
11795           op0 = TREE_OPERAND (t, 0);
11796           tem = fold_unary (code, type, op0);
11797           return tem ? tem : expr;
11798         case 2:
11799           op0 = TREE_OPERAND (t, 0);
11800           op1 = TREE_OPERAND (t, 1);
11801           tem = fold_binary (code, type, op0, op1);
11802           return tem ? tem : expr;
11803         case 3:
11804           op0 = TREE_OPERAND (t, 0);
11805           op1 = TREE_OPERAND (t, 1);
11806           op2 = TREE_OPERAND (t, 2);
11807           tem = fold_ternary (code, type, op0, op1, op2);
11808           return tem ? tem : expr;
11809         default:
11810           break;
11811         }
11812     }
11813
11814   switch (code)
11815     {
11816     case CONST_DECL:
11817       return fold (DECL_INITIAL (t));
11818
11819     default:
11820       return t;
11821     } /* switch (code) */
11822 }
11823
11824 #ifdef ENABLE_FOLD_CHECKING
11825 #undef fold
11826
11827 static void fold_checksum_tree (tree, struct md5_ctx *, htab_t);
11828 static void fold_check_failed (tree, tree);
11829 void print_fold_checksum (tree);
11830
11831 /* When --enable-checking=fold, compute a digest of expr before
11832    and after actual fold call to see if fold did not accidentally
11833    change original expr.  */
11834
11835 tree
11836 fold (tree expr)
11837 {
11838   tree ret;
11839   struct md5_ctx ctx;
11840   unsigned char checksum_before[16], checksum_after[16];
11841   htab_t ht;
11842
11843   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11844   md5_init_ctx (&ctx);
11845   fold_checksum_tree (expr, &ctx, ht);
11846   md5_finish_ctx (&ctx, checksum_before);
11847   htab_empty (ht);
11848
11849   ret = fold_1 (expr);
11850
11851   md5_init_ctx (&ctx);
11852   fold_checksum_tree (expr, &ctx, ht);
11853   md5_finish_ctx (&ctx, checksum_after);
11854   htab_delete (ht);
11855
11856   if (memcmp (checksum_before, checksum_after, 16))
11857     fold_check_failed (expr, ret);
11858
11859   return ret;
11860 }
11861
11862 void
11863 print_fold_checksum (tree expr)
11864 {
11865   struct md5_ctx ctx;
11866   unsigned char checksum[16], cnt;
11867   htab_t ht;
11868
11869   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
11870   md5_init_ctx (&ctx);
11871   fold_checksum_tree (expr, &ctx, ht);
11872   md5_finish_ctx (&ctx, checksum);
11873   htab_delete (ht);
11874   for (cnt = 0; cnt < 16; ++cnt)
11875     fprintf (stderr, "%02x", checksum[cnt]);
11876   putc ('\n', stderr);
11877 }
11878
11879 static void
11880 fold_check_failed (tree expr ATTRIBUTE_UNUSED, tree ret ATTRIBUTE_UNUSED)
11881 {
11882   internal_error ("fold check: original tree changed by fold");
11883 }
11884
11885 static void
11886 fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht)
11887 {
11888   void **slot;
11889   enum tree_code code;
11890   struct tree_function_decl buf;
11891   int i, len;
11892   
11893 recursive_label:
11894
11895   gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree)
11896                <= sizeof (struct tree_function_decl))
11897               && sizeof (struct tree_type) <= sizeof (struct tree_function_decl));
11898   if (expr == NULL)
11899     return;
11900   slot = htab_find_slot (ht, expr, INSERT);
11901   if (*slot != NULL)
11902     return;
11903   *slot = expr;
11904   code = TREE_CODE (expr);
11905   if (TREE_CODE_CLASS (code) == tcc_declaration
11906       && DECL_ASSEMBLER_NAME_SET_P (expr))
11907     {
11908       /* Allow DECL_ASSEMBLER_NAME to be modified.  */
11909       memcpy ((char *) &buf, expr, tree_size (expr));
11910       expr = (tree) &buf;
11911       SET_DECL_ASSEMBLER_NAME (expr, NULL);
11912     }
11913   else if (TREE_CODE_CLASS (code) == tcc_type
11914            && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr)
11915                || TYPE_CACHED_VALUES_P (expr)
11916                || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)))
11917     {
11918       /* Allow these fields to be modified.  */
11919       memcpy ((char *) &buf, expr, tree_size (expr));
11920       expr = (tree) &buf;
11921       TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr) = 0;
11922       TYPE_POINTER_TO (expr) = NULL;
11923       TYPE_REFERENCE_TO (expr) = NULL;
11924       if (TYPE_CACHED_VALUES_P (expr))
11925         {
11926           TYPE_CACHED_VALUES_P (expr) = 0;
11927           TYPE_CACHED_VALUES (expr) = NULL;
11928         }
11929     }
11930   md5_process_bytes (expr, tree_size (expr), ctx);
11931   fold_checksum_tree (TREE_TYPE (expr), ctx, ht);
11932   if (TREE_CODE_CLASS (code) != tcc_type
11933       && TREE_CODE_CLASS (code) != tcc_declaration
11934       && code != TREE_LIST)
11935     fold_checksum_tree (TREE_CHAIN (expr), ctx, ht);
11936   switch (TREE_CODE_CLASS (code))
11937     {
11938     case tcc_constant:
11939       switch (code)
11940         {
11941         case STRING_CST:
11942           md5_process_bytes (TREE_STRING_POINTER (expr),
11943                              TREE_STRING_LENGTH (expr), ctx);
11944           break;
11945         case COMPLEX_CST:
11946           fold_checksum_tree (TREE_REALPART (expr), ctx, ht);
11947           fold_checksum_tree (TREE_IMAGPART (expr), ctx, ht);
11948           break;
11949         case VECTOR_CST:
11950           fold_checksum_tree (TREE_VECTOR_CST_ELTS (expr), ctx, ht);
11951           break;
11952         default:
11953           break;
11954         }
11955       break;
11956     case tcc_exceptional:
11957       switch (code)
11958         {
11959         case TREE_LIST:
11960           fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht);
11961           fold_checksum_tree (TREE_VALUE (expr), ctx, ht);
11962           expr = TREE_CHAIN (expr);
11963           goto recursive_label;
11964           break;
11965         case TREE_VEC:
11966           for (i = 0; i < TREE_VEC_LENGTH (expr); ++i)
11967             fold_checksum_tree (TREE_VEC_ELT (expr, i), ctx, ht);
11968           break;
11969         default:
11970           break;
11971         }
11972       break;
11973     case tcc_expression:
11974     case tcc_reference:
11975     case tcc_comparison:
11976     case tcc_unary:
11977     case tcc_binary:
11978     case tcc_statement:
11979       len = TREE_CODE_LENGTH (code);
11980       for (i = 0; i < len; ++i)
11981         fold_checksum_tree (TREE_OPERAND (expr, i), ctx, ht);
11982       break;
11983     case tcc_declaration:
11984       fold_checksum_tree (DECL_NAME (expr), ctx, ht);
11985       fold_checksum_tree (DECL_CONTEXT (expr), ctx, ht);
11986       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_COMMON))
11987         {
11988           fold_checksum_tree (DECL_SIZE (expr), ctx, ht);
11989           fold_checksum_tree (DECL_SIZE_UNIT (expr), ctx, ht);
11990           fold_checksum_tree (DECL_INITIAL (expr), ctx, ht);
11991           fold_checksum_tree (DECL_ABSTRACT_ORIGIN (expr), ctx, ht);
11992           fold_checksum_tree (DECL_ATTRIBUTES (expr), ctx, ht);
11993         }
11994       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_WITH_VIS))
11995         fold_checksum_tree (DECL_SECTION_NAME (expr), ctx, ht);
11996           
11997       if (CODE_CONTAINS_STRUCT (TREE_CODE (expr), TS_DECL_NON_COMMON))
11998         {
11999           fold_checksum_tree (DECL_VINDEX (expr), ctx, ht);
12000           fold_checksum_tree (DECL_RESULT_FLD (expr), ctx, ht);
12001           fold_checksum_tree (DECL_ARGUMENT_FLD (expr), ctx, ht);
12002         }
12003       break;
12004     case tcc_type:
12005       if (TREE_CODE (expr) == ENUMERAL_TYPE)
12006         fold_checksum_tree (TYPE_VALUES (expr), ctx, ht);
12007       fold_checksum_tree (TYPE_SIZE (expr), ctx, ht);
12008       fold_checksum_tree (TYPE_SIZE_UNIT (expr), ctx, ht);
12009       fold_checksum_tree (TYPE_ATTRIBUTES (expr), ctx, ht);
12010       fold_checksum_tree (TYPE_NAME (expr), ctx, ht);
12011       if (INTEGRAL_TYPE_P (expr)
12012           || SCALAR_FLOAT_TYPE_P (expr))
12013         {
12014           fold_checksum_tree (TYPE_MIN_VALUE (expr), ctx, ht);
12015           fold_checksum_tree (TYPE_MAX_VALUE (expr), ctx, ht);
12016         }
12017       fold_checksum_tree (TYPE_MAIN_VARIANT (expr), ctx, ht);
12018       if (TREE_CODE (expr) == RECORD_TYPE
12019           || TREE_CODE (expr) == UNION_TYPE
12020           || TREE_CODE (expr) == QUAL_UNION_TYPE)
12021         fold_checksum_tree (TYPE_BINFO (expr), ctx, ht);
12022       fold_checksum_tree (TYPE_CONTEXT (expr), ctx, ht);
12023       break;
12024     default:
12025       break;
12026     }
12027 }
12028
12029 #endif
12030
12031 /* Fold a unary tree expression with code CODE of type TYPE with an
12032    operand OP0.  Return a folded expression if successful.  Otherwise,
12033    return a tree expression with code CODE of type TYPE with an
12034    operand OP0.  */
12035
12036 tree
12037 fold_build1_stat (enum tree_code code, tree type, tree op0 MEM_STAT_DECL)
12038 {
12039   tree tem;
12040 #ifdef ENABLE_FOLD_CHECKING
12041   unsigned char checksum_before[16], checksum_after[16];
12042   struct md5_ctx ctx;
12043   htab_t ht;
12044
12045   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
12046   md5_init_ctx (&ctx);
12047   fold_checksum_tree (op0, &ctx, ht);
12048   md5_finish_ctx (&ctx, checksum_before);
12049   htab_empty (ht);
12050 #endif
12051   
12052   tem = fold_unary (code, type, op0);
12053   if (!tem)
12054     tem = build1_stat (code, type, op0 PASS_MEM_STAT);
12055   
12056 #ifdef ENABLE_FOLD_CHECKING
12057   md5_init_ctx (&ctx);
12058   fold_checksum_tree (op0, &ctx, ht);
12059   md5_finish_ctx (&ctx, checksum_after);
12060   htab_delete (ht);
12061
12062   if (memcmp (checksum_before, checksum_after, 16))
12063     fold_check_failed (op0, tem);
12064 #endif
12065   return tem;
12066 }
12067
12068 /* Fold a binary tree expression with code CODE of type TYPE with
12069    operands OP0 and OP1.  Return a folded expression if successful.
12070    Otherwise, return a tree expression with code CODE of type TYPE
12071    with operands OP0 and OP1.  */
12072
12073 tree
12074 fold_build2_stat (enum tree_code code, tree type, tree op0, tree op1
12075                   MEM_STAT_DECL)
12076 {
12077   tree tem;
12078 #ifdef ENABLE_FOLD_CHECKING
12079   unsigned char checksum_before_op0[16],
12080                 checksum_before_op1[16],
12081                 checksum_after_op0[16],
12082                 checksum_after_op1[16];
12083   struct md5_ctx ctx;
12084   htab_t ht;
12085
12086   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
12087   md5_init_ctx (&ctx);
12088   fold_checksum_tree (op0, &ctx, ht);
12089   md5_finish_ctx (&ctx, checksum_before_op0);
12090   htab_empty (ht);
12091
12092   md5_init_ctx (&ctx);
12093   fold_checksum_tree (op1, &ctx, ht);
12094   md5_finish_ctx (&ctx, checksum_before_op1);
12095   htab_empty (ht);
12096 #endif
12097
12098   tem = fold_binary (code, type, op0, op1);
12099   if (!tem)
12100     tem = build2_stat (code, type, op0, op1 PASS_MEM_STAT);
12101   
12102 #ifdef ENABLE_FOLD_CHECKING
12103   md5_init_ctx (&ctx);
12104   fold_checksum_tree (op0, &ctx, ht);
12105   md5_finish_ctx (&ctx, checksum_after_op0);
12106   htab_empty (ht);
12107
12108   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
12109     fold_check_failed (op0, tem);
12110   
12111   md5_init_ctx (&ctx);
12112   fold_checksum_tree (op1, &ctx, ht);
12113   md5_finish_ctx (&ctx, checksum_after_op1);
12114   htab_delete (ht);
12115
12116   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
12117     fold_check_failed (op1, tem);
12118 #endif
12119   return tem;
12120 }
12121
12122 /* Fold a ternary tree expression with code CODE of type TYPE with
12123    operands OP0, OP1, and OP2.  Return a folded expression if
12124    successful.  Otherwise, return a tree expression with code CODE of
12125    type TYPE with operands OP0, OP1, and OP2.  */
12126
12127 tree
12128 fold_build3_stat (enum tree_code code, tree type, tree op0, tree op1, tree op2
12129              MEM_STAT_DECL)
12130 {
12131   tree tem;
12132 #ifdef ENABLE_FOLD_CHECKING
12133   unsigned char checksum_before_op0[16],
12134                 checksum_before_op1[16],
12135                 checksum_before_op2[16],
12136                 checksum_after_op0[16],
12137                 checksum_after_op1[16],
12138                 checksum_after_op2[16];
12139   struct md5_ctx ctx;
12140   htab_t ht;
12141
12142   ht = htab_create (32, htab_hash_pointer, htab_eq_pointer, NULL);
12143   md5_init_ctx (&ctx);
12144   fold_checksum_tree (op0, &ctx, ht);
12145   md5_finish_ctx (&ctx, checksum_before_op0);
12146   htab_empty (ht);
12147
12148   md5_init_ctx (&ctx);
12149   fold_checksum_tree (op1, &ctx, ht);
12150   md5_finish_ctx (&ctx, checksum_before_op1);
12151   htab_empty (ht);
12152
12153   md5_init_ctx (&ctx);
12154   fold_checksum_tree (op2, &ctx, ht);
12155   md5_finish_ctx (&ctx, checksum_before_op2);
12156   htab_empty (ht);
12157 #endif
12158   
12159   tem = fold_ternary (code, type, op0, op1, op2);
12160   if (!tem)
12161     tem =  build3_stat (code, type, op0, op1, op2 PASS_MEM_STAT);
12162       
12163 #ifdef ENABLE_FOLD_CHECKING
12164   md5_init_ctx (&ctx);
12165   fold_checksum_tree (op0, &ctx, ht);
12166   md5_finish_ctx (&ctx, checksum_after_op0);
12167   htab_empty (ht);
12168
12169   if (memcmp (checksum_before_op0, checksum_after_op0, 16))
12170     fold_check_failed (op0, tem);
12171   
12172   md5_init_ctx (&ctx);
12173   fold_checksum_tree (op1, &ctx, ht);
12174   md5_finish_ctx (&ctx, checksum_after_op1);
12175   htab_empty (ht);
12176
12177   if (memcmp (checksum_before_op1, checksum_after_op1, 16))
12178     fold_check_failed (op1, tem);
12179   
12180   md5_init_ctx (&ctx);
12181   fold_checksum_tree (op2, &ctx, ht);
12182   md5_finish_ctx (&ctx, checksum_after_op2);
12183   htab_delete (ht);
12184
12185   if (memcmp (checksum_before_op2, checksum_after_op2, 16))
12186     fold_check_failed (op2, tem);
12187 #endif
12188   return tem;
12189 }
12190
12191 /* Perform constant folding and related simplification of initializer
12192    expression EXPR.  These behave identically to "fold_buildN" but ignore
12193    potential run-time traps and exceptions that fold must preserve.  */
12194
12195 #define START_FOLD_INIT \
12196   int saved_signaling_nans = flag_signaling_nans;\
12197   int saved_trapping_math = flag_trapping_math;\
12198   int saved_rounding_math = flag_rounding_math;\
12199   int saved_trapv = flag_trapv;\
12200   int saved_folding_initializer = folding_initializer;\
12201   flag_signaling_nans = 0;\
12202   flag_trapping_math = 0;\
12203   flag_rounding_math = 0;\
12204   flag_trapv = 0;\
12205   folding_initializer = 1;
12206
12207 #define END_FOLD_INIT \
12208   flag_signaling_nans = saved_signaling_nans;\
12209   flag_trapping_math = saved_trapping_math;\
12210   flag_rounding_math = saved_rounding_math;\
12211   flag_trapv = saved_trapv;\
12212   folding_initializer = saved_folding_initializer;
12213
12214 tree
12215 fold_build1_initializer (enum tree_code code, tree type, tree op)
12216 {
12217   tree result;
12218   START_FOLD_INIT;
12219
12220   result = fold_build1 (code, type, op);
12221
12222   END_FOLD_INIT;
12223   return result;
12224 }
12225
12226 tree
12227 fold_build2_initializer (enum tree_code code, tree type, tree op0, tree op1)
12228 {
12229   tree result;
12230   START_FOLD_INIT;
12231
12232   result = fold_build2 (code, type, op0, op1);
12233
12234   END_FOLD_INIT;
12235   return result;
12236 }
12237
12238 tree
12239 fold_build3_initializer (enum tree_code code, tree type, tree op0, tree op1,
12240                          tree op2)
12241 {
12242   tree result;
12243   START_FOLD_INIT;
12244
12245   result = fold_build3 (code, type, op0, op1, op2);
12246
12247   END_FOLD_INIT;
12248   return result;
12249 }
12250
12251 #undef START_FOLD_INIT
12252 #undef END_FOLD_INIT
12253
12254 /* Determine if first argument is a multiple of second argument.  Return 0 if
12255    it is not, or we cannot easily determined it to be.
12256
12257    An example of the sort of thing we care about (at this point; this routine
12258    could surely be made more general, and expanded to do what the *_DIV_EXPR's
12259    fold cases do now) is discovering that
12260
12261      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12262
12263    is a multiple of
12264
12265      SAVE_EXPR (J * 8)
12266
12267    when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
12268
12269    This code also handles discovering that
12270
12271      SAVE_EXPR (I) * SAVE_EXPR (J * 8)
12272
12273    is a multiple of 8 so we don't have to worry about dealing with a
12274    possible remainder.
12275
12276    Note that we *look* inside a SAVE_EXPR only to determine how it was
12277    calculated; it is not safe for fold to do much of anything else with the
12278    internals of a SAVE_EXPR, since it cannot know when it will be evaluated
12279    at run time.  For example, the latter example above *cannot* be implemented
12280    as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
12281    evaluation time of the original SAVE_EXPR is not necessarily the same at
12282    the time the new expression is evaluated.  The only optimization of this
12283    sort that would be valid is changing
12284
12285      SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
12286
12287    divided by 8 to
12288
12289      SAVE_EXPR (I) * SAVE_EXPR (J)
12290
12291    (where the same SAVE_EXPR (J) is used in the original and the
12292    transformed version).  */
12293
12294 static int
12295 multiple_of_p (tree type, tree top, tree bottom)
12296 {
12297   if (operand_equal_p (top, bottom, 0))
12298     return 1;
12299
12300   if (TREE_CODE (type) != INTEGER_TYPE)
12301     return 0;
12302
12303   switch (TREE_CODE (top))
12304     {
12305     case BIT_AND_EXPR:
12306       /* Bitwise and provides a power of two multiple.  If the mask is
12307          a multiple of BOTTOM then TOP is a multiple of BOTTOM.  */
12308       if (!integer_pow2p (bottom))
12309         return 0;
12310       /* FALLTHRU */
12311
12312     case MULT_EXPR:
12313       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
12314               || multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
12315
12316     case PLUS_EXPR:
12317     case MINUS_EXPR:
12318       return (multiple_of_p (type, TREE_OPERAND (top, 0), bottom)
12319               && multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
12320
12321     case LSHIFT_EXPR:
12322       if (TREE_CODE (TREE_OPERAND (top, 1)) == INTEGER_CST)
12323         {
12324           tree op1, t1;
12325
12326           op1 = TREE_OPERAND (top, 1);
12327           /* const_binop may not detect overflow correctly,
12328              so check for it explicitly here.  */
12329           if (TYPE_PRECISION (TREE_TYPE (size_one_node))
12330               > TREE_INT_CST_LOW (op1)
12331               && TREE_INT_CST_HIGH (op1) == 0
12332               && 0 != (t1 = fold_convert (type,
12333                                           const_binop (LSHIFT_EXPR,
12334                                                        size_one_node,
12335                                                        op1, 0)))
12336               && ! TREE_OVERFLOW (t1))
12337             return multiple_of_p (type, t1, bottom);
12338         }
12339       return 0;
12340
12341     case NOP_EXPR:
12342       /* Can't handle conversions from non-integral or wider integral type.  */
12343       if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
12344           || (TYPE_PRECISION (type)
12345               < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
12346         return 0;
12347
12348       /* .. fall through ...  */
12349
12350     case SAVE_EXPR:
12351       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
12352
12353     case INTEGER_CST:
12354       if (TREE_CODE (bottom) != INTEGER_CST
12355           || (TYPE_UNSIGNED (type)
12356               && (tree_int_cst_sgn (top) < 0
12357                   || tree_int_cst_sgn (bottom) < 0)))
12358         return 0;
12359       return integer_zerop (const_binop (TRUNC_MOD_EXPR,
12360                                          top, bottom, 0));
12361
12362     default:
12363       return 0;
12364     }
12365 }
12366
12367 /* Return true if `t' is known to be non-negative.  If the return
12368    value is based on the assumption that signed overflow is undefined,
12369    set *STRICT_OVERFLOW_P to true; otherwise, don't change
12370    *STRICT_OVERFLOW_P.  */
12371
12372 int
12373 tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
12374 {
12375   if (t == error_mark_node)
12376     return 0;
12377
12378   if (TYPE_UNSIGNED (TREE_TYPE (t)))
12379     return 1;
12380
12381   switch (TREE_CODE (t))
12382     {
12383     case SSA_NAME:
12384       /* Query VRP to see if it has recorded any information about
12385          the range of this object.  */
12386       return ssa_name_nonnegative_p (t);
12387
12388     case ABS_EXPR:
12389       /* We can't return 1 if flag_wrapv is set because
12390          ABS_EXPR<INT_MIN> = INT_MIN.  */
12391       if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
12392         return 1;
12393       if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
12394         {
12395           *strict_overflow_p = true;
12396           return 1;
12397         }
12398       break;
12399
12400     case INTEGER_CST:
12401       return tree_int_cst_sgn (t) >= 0;
12402
12403     case REAL_CST:
12404       return ! REAL_VALUE_NEGATIVE (TREE_REAL_CST (t));
12405
12406     case PLUS_EXPR:
12407       if (FLOAT_TYPE_P (TREE_TYPE (t)))
12408         return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12409                                                strict_overflow_p)
12410                 && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12411                                                   strict_overflow_p));
12412
12413       /* zero_extend(x) + zero_extend(y) is non-negative if x and y are
12414          both unsigned and at least 2 bits shorter than the result.  */
12415       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
12416           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
12417           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
12418         {
12419           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
12420           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
12421           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
12422               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
12423             {
12424               unsigned int prec = MAX (TYPE_PRECISION (inner1),
12425                                        TYPE_PRECISION (inner2)) + 1;
12426               return prec < TYPE_PRECISION (TREE_TYPE (t));
12427             }
12428         }
12429       break;
12430
12431     case MULT_EXPR:
12432       if (FLOAT_TYPE_P (TREE_TYPE (t)))
12433         {
12434           /* x * x for floating point x is always non-negative.  */
12435           if (operand_equal_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1), 0))
12436             return 1;
12437           return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12438                                                  strict_overflow_p)
12439                   && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12440                                                     strict_overflow_p));
12441         }
12442
12443       /* zero_extend(x) * zero_extend(y) is non-negative if x and y are
12444          both unsigned and their total bits is shorter than the result.  */
12445       if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
12446           && TREE_CODE (TREE_OPERAND (t, 0)) == NOP_EXPR
12447           && TREE_CODE (TREE_OPERAND (t, 1)) == NOP_EXPR)
12448         {
12449           tree inner1 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 0), 0));
12450           tree inner2 = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (t, 1), 0));
12451           if (TREE_CODE (inner1) == INTEGER_TYPE && TYPE_UNSIGNED (inner1)
12452               && TREE_CODE (inner2) == INTEGER_TYPE && TYPE_UNSIGNED (inner2))
12453             return TYPE_PRECISION (inner1) + TYPE_PRECISION (inner2)
12454                    < TYPE_PRECISION (TREE_TYPE (t));
12455         }
12456       return 0;
12457
12458     case BIT_AND_EXPR:
12459     case MAX_EXPR:
12460       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12461                                              strict_overflow_p)
12462               || tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12463                                                 strict_overflow_p));
12464
12465     case BIT_IOR_EXPR:
12466     case BIT_XOR_EXPR:
12467     case MIN_EXPR:
12468     case RDIV_EXPR:
12469     case TRUNC_DIV_EXPR:
12470     case CEIL_DIV_EXPR:
12471     case FLOOR_DIV_EXPR:
12472     case ROUND_DIV_EXPR:
12473       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12474                                              strict_overflow_p)
12475               && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12476                                                 strict_overflow_p));
12477
12478     case TRUNC_MOD_EXPR:
12479     case CEIL_MOD_EXPR:
12480     case FLOOR_MOD_EXPR:
12481     case ROUND_MOD_EXPR:
12482     case SAVE_EXPR:
12483     case NON_LVALUE_EXPR:
12484     case FLOAT_EXPR:
12485     case FIX_TRUNC_EXPR:
12486       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12487                                             strict_overflow_p);
12488
12489     case COMPOUND_EXPR:
12490     case MODIFY_EXPR:
12491       return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12492                                             strict_overflow_p);
12493
12494     case BIND_EXPR:
12495       return tree_expr_nonnegative_warnv_p (expr_last (TREE_OPERAND (t, 1)),
12496                                             strict_overflow_p);
12497
12498     case COND_EXPR:
12499       return (tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12500                                              strict_overflow_p)
12501               && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 2),
12502                                                 strict_overflow_p));
12503
12504     case NOP_EXPR:
12505       {
12506         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
12507         tree outer_type = TREE_TYPE (t);
12508
12509         if (TREE_CODE (outer_type) == REAL_TYPE)
12510           {
12511             if (TREE_CODE (inner_type) == REAL_TYPE)
12512               return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12513                                                     strict_overflow_p);
12514             if (TREE_CODE (inner_type) == INTEGER_TYPE)
12515               {
12516                 if (TYPE_UNSIGNED (inner_type))
12517                   return 1;
12518                 return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12519                                                       strict_overflow_p);
12520               }
12521           }
12522         else if (TREE_CODE (outer_type) == INTEGER_TYPE)
12523           {
12524             if (TREE_CODE (inner_type) == REAL_TYPE)
12525               return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t,0),
12526                                                     strict_overflow_p);
12527             if (TREE_CODE (inner_type) == INTEGER_TYPE)
12528               return TYPE_PRECISION (inner_type) < TYPE_PRECISION (outer_type)
12529                       && TYPE_UNSIGNED (inner_type);
12530           }
12531       }
12532       break;
12533
12534     case TARGET_EXPR:
12535       {
12536         tree temp = TARGET_EXPR_SLOT (t);
12537         t = TARGET_EXPR_INITIAL (t);
12538
12539         /* If the initializer is non-void, then it's a normal expression
12540            that will be assigned to the slot.  */
12541         if (!VOID_TYPE_P (t))
12542           return tree_expr_nonnegative_warnv_p (t, strict_overflow_p);
12543
12544         /* Otherwise, the initializer sets the slot in some way.  One common
12545            way is an assignment statement at the end of the initializer.  */
12546         while (1)
12547           {
12548             if (TREE_CODE (t) == BIND_EXPR)
12549               t = expr_last (BIND_EXPR_BODY (t));
12550             else if (TREE_CODE (t) == TRY_FINALLY_EXPR
12551                      || TREE_CODE (t) == TRY_CATCH_EXPR)
12552               t = expr_last (TREE_OPERAND (t, 0));
12553             else if (TREE_CODE (t) == STATEMENT_LIST)
12554               t = expr_last (t);
12555             else
12556               break;
12557           }
12558         if (TREE_CODE (t) == MODIFY_EXPR
12559             && TREE_OPERAND (t, 0) == temp)
12560           return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12561                                                 strict_overflow_p);
12562
12563         return 0;
12564       }
12565
12566     case CALL_EXPR:
12567       {
12568         tree fndecl = get_callee_fndecl (t);
12569         tree arglist = TREE_OPERAND (t, 1);
12570         if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
12571           switch (DECL_FUNCTION_CODE (fndecl))
12572             {
12573             CASE_FLT_FN (BUILT_IN_ACOS):
12574             CASE_FLT_FN (BUILT_IN_ACOSH):
12575             CASE_FLT_FN (BUILT_IN_CABS):
12576             CASE_FLT_FN (BUILT_IN_COSH):
12577             CASE_FLT_FN (BUILT_IN_ERFC):
12578             CASE_FLT_FN (BUILT_IN_EXP):
12579             CASE_FLT_FN (BUILT_IN_EXP10):
12580             CASE_FLT_FN (BUILT_IN_EXP2):
12581             CASE_FLT_FN (BUILT_IN_FABS):
12582             CASE_FLT_FN (BUILT_IN_FDIM):
12583             CASE_FLT_FN (BUILT_IN_HYPOT):
12584             CASE_FLT_FN (BUILT_IN_POW10):
12585             CASE_INT_FN (BUILT_IN_FFS):
12586             CASE_INT_FN (BUILT_IN_PARITY):
12587             CASE_INT_FN (BUILT_IN_POPCOUNT):
12588               /* Always true.  */
12589               return 1;
12590
12591             CASE_FLT_FN (BUILT_IN_SQRT):
12592               /* sqrt(-0.0) is -0.0.  */
12593               if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (t))))
12594                 return 1;
12595               return tree_expr_nonnegative_warnv_p (TREE_VALUE (arglist),
12596                                                     strict_overflow_p);
12597
12598             CASE_FLT_FN (BUILT_IN_ASINH):
12599             CASE_FLT_FN (BUILT_IN_ATAN):
12600             CASE_FLT_FN (BUILT_IN_ATANH):
12601             CASE_FLT_FN (BUILT_IN_CBRT):
12602             CASE_FLT_FN (BUILT_IN_CEIL):
12603             CASE_FLT_FN (BUILT_IN_ERF):
12604             CASE_FLT_FN (BUILT_IN_EXPM1):
12605             CASE_FLT_FN (BUILT_IN_FLOOR):
12606             CASE_FLT_FN (BUILT_IN_FMOD):
12607             CASE_FLT_FN (BUILT_IN_FREXP):
12608             CASE_FLT_FN (BUILT_IN_LCEIL):
12609             CASE_FLT_FN (BUILT_IN_LDEXP):
12610             CASE_FLT_FN (BUILT_IN_LFLOOR):
12611             CASE_FLT_FN (BUILT_IN_LLCEIL):
12612             CASE_FLT_FN (BUILT_IN_LLFLOOR):
12613             CASE_FLT_FN (BUILT_IN_LLRINT):
12614             CASE_FLT_FN (BUILT_IN_LLROUND):
12615             CASE_FLT_FN (BUILT_IN_LRINT):
12616             CASE_FLT_FN (BUILT_IN_LROUND):
12617             CASE_FLT_FN (BUILT_IN_MODF):
12618             CASE_FLT_FN (BUILT_IN_NEARBYINT):
12619             CASE_FLT_FN (BUILT_IN_POW):
12620             CASE_FLT_FN (BUILT_IN_RINT):
12621             CASE_FLT_FN (BUILT_IN_ROUND):
12622             CASE_FLT_FN (BUILT_IN_SIGNBIT):
12623             CASE_FLT_FN (BUILT_IN_SINH):
12624             CASE_FLT_FN (BUILT_IN_TANH):
12625             CASE_FLT_FN (BUILT_IN_TRUNC):
12626               /* True if the 1st argument is nonnegative.  */
12627               return tree_expr_nonnegative_warnv_p (TREE_VALUE (arglist),
12628                                                     strict_overflow_p);
12629
12630             CASE_FLT_FN (BUILT_IN_FMAX):
12631               /* True if the 1st OR 2nd arguments are nonnegative.  */
12632               return (tree_expr_nonnegative_warnv_p (TREE_VALUE (arglist),
12633                                                      strict_overflow_p)
12634                       || (tree_expr_nonnegative_warnv_p
12635                           (TREE_VALUE (TREE_CHAIN (arglist)),
12636                            strict_overflow_p)));
12637
12638             CASE_FLT_FN (BUILT_IN_FMIN):
12639               /* True if the 1st AND 2nd arguments are nonnegative.  */
12640               return (tree_expr_nonnegative_warnv_p (TREE_VALUE (arglist),
12641                                                      strict_overflow_p)
12642                       && (tree_expr_nonnegative_warnv_p
12643                           (TREE_VALUE (TREE_CHAIN (arglist)),
12644                            strict_overflow_p)));
12645
12646             CASE_FLT_FN (BUILT_IN_COPYSIGN):
12647               /* True if the 2nd argument is nonnegative.  */
12648               return (tree_expr_nonnegative_warnv_p
12649                       (TREE_VALUE (TREE_CHAIN (arglist)),
12650                        strict_overflow_p));
12651
12652             default:
12653               break;
12654             }
12655       }
12656
12657       /* ... fall through ...  */
12658
12659     default:
12660       {
12661         tree type = TREE_TYPE (t);
12662         if ((TYPE_PRECISION (type) != 1 || TYPE_UNSIGNED (type))
12663             && truth_value_p (TREE_CODE (t)))
12664           /* Truth values evaluate to 0 or 1, which is nonnegative unless we
12665              have a signed:1 type (where the value is -1 and 0).  */
12666           return true;
12667       }
12668     }
12669
12670   /* We don't know sign of `t', so be conservative and return false.  */
12671   return 0;
12672 }
12673
12674 /* Return true if `t' is known to be non-negative.  Handle warnings
12675    about undefined signed overflow.  */
12676
12677 int
12678 tree_expr_nonnegative_p (tree t)
12679 {
12680   int ret;
12681   bool strict_overflow_p;
12682
12683   strict_overflow_p = false;
12684   ret = tree_expr_nonnegative_warnv_p (t, &strict_overflow_p);
12685   if (strict_overflow_p)
12686     fold_overflow_warning (("assuming signed overflow does not occur when "
12687                             "determining that expression is always "
12688                             "non-negative"),
12689                            WARN_STRICT_OVERFLOW_MISC);
12690   return ret;
12691 }
12692
12693 /* Return true when T is an address and is known to be nonzero.
12694    For floating point we further ensure that T is not denormal.
12695    Similar logic is present in nonzero_address in rtlanal.h.
12696
12697    If the return value is based on the assumption that signed overflow
12698    is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't
12699    change *STRICT_OVERFLOW_P.  */
12700
12701 bool
12702 tree_expr_nonzero_warnv_p (tree t, bool *strict_overflow_p)
12703 {
12704   tree type = TREE_TYPE (t);
12705   bool sub_strict_overflow_p;
12706
12707   /* Doing something useful for floating point would need more work.  */
12708   if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
12709     return false;
12710
12711   switch (TREE_CODE (t))
12712     {
12713     case SSA_NAME:
12714       /* Query VRP to see if it has recorded any information about
12715          the range of this object.  */
12716       return ssa_name_nonzero_p (t);
12717
12718     case ABS_EXPR:
12719       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
12720                                         strict_overflow_p);
12721
12722     case INTEGER_CST:
12723       /* We used to test for !integer_zerop here.  This does not work correctly
12724          if TREE_CONSTANT_OVERFLOW (t).  */
12725       return (TREE_INT_CST_LOW (t) != 0
12726               || TREE_INT_CST_HIGH (t) != 0);
12727
12728     case PLUS_EXPR:
12729       if (TYPE_OVERFLOW_UNDEFINED (type))
12730         {
12731           /* With the presence of negative values it is hard
12732              to say something.  */
12733           sub_strict_overflow_p = false;
12734           if (!tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12735                                               &sub_strict_overflow_p)
12736               || !tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12737                                                  &sub_strict_overflow_p))
12738             return false;
12739           /* One of operands must be positive and the other non-negative.  */
12740           /* We don't set *STRICT_OVERFLOW_P here: even if this value
12741              overflows, on a twos-complement machine the sum of two
12742              nonnegative numbers can never be zero.  */
12743           return (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
12744                                              strict_overflow_p)
12745                   || tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
12746                                                 strict_overflow_p));
12747         }
12748       break;
12749
12750     case MULT_EXPR:
12751       if (TYPE_OVERFLOW_UNDEFINED (type))
12752         {
12753           if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
12754                                          strict_overflow_p)
12755               && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
12756                                             strict_overflow_p))
12757             {
12758               *strict_overflow_p = true;
12759               return true;
12760             }
12761         }
12762       break;
12763
12764     case NOP_EXPR:
12765       {
12766         tree inner_type = TREE_TYPE (TREE_OPERAND (t, 0));
12767         tree outer_type = TREE_TYPE (t);
12768
12769         return (TYPE_PRECISION (outer_type) >= TYPE_PRECISION (inner_type)
12770                 && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
12771                                               strict_overflow_p));
12772       }
12773       break;
12774
12775    case ADDR_EXPR:
12776       {
12777         tree base = get_base_address (TREE_OPERAND (t, 0));
12778
12779         if (!base)
12780           return false;
12781
12782         /* Weak declarations may link to NULL.  */
12783         if (VAR_OR_FUNCTION_DECL_P (base))
12784           return !DECL_WEAK (base);
12785
12786         /* Constants are never weak.  */
12787         if (CONSTANT_CLASS_P (base))
12788           return true;
12789
12790         return false;
12791       }
12792
12793     case COND_EXPR:
12794       sub_strict_overflow_p = false;
12795       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
12796                                      &sub_strict_overflow_p)
12797           && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 2),
12798                                         &sub_strict_overflow_p))
12799         {
12800           if (sub_strict_overflow_p)
12801             *strict_overflow_p = true;
12802           return true;
12803         }
12804       break;
12805
12806     case MIN_EXPR:
12807       sub_strict_overflow_p = false;
12808       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
12809                                      &sub_strict_overflow_p)
12810           && tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
12811                                         &sub_strict_overflow_p))
12812         {
12813           if (sub_strict_overflow_p)
12814             *strict_overflow_p = true;
12815         }
12816       break;
12817
12818     case MAX_EXPR:
12819       sub_strict_overflow_p = false;
12820       if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
12821                                      &sub_strict_overflow_p))
12822         {
12823           if (sub_strict_overflow_p)
12824             *strict_overflow_p = true;
12825
12826           /* When both operands are nonzero, then MAX must be too.  */
12827           if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
12828                                          strict_overflow_p))
12829             return true;
12830
12831           /* MAX where operand 0 is positive is positive.  */
12832           return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
12833                                                strict_overflow_p);
12834         }
12835       /* MAX where operand 1 is positive is positive.  */
12836       else if (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
12837                                           &sub_strict_overflow_p)
12838                && tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 1),
12839                                                  &sub_strict_overflow_p))
12840         {
12841           if (sub_strict_overflow_p)
12842             *strict_overflow_p = true;
12843           return true;
12844         }
12845       break;
12846
12847     case COMPOUND_EXPR:
12848     case MODIFY_EXPR:
12849     case BIND_EXPR:
12850       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
12851                                         strict_overflow_p);
12852
12853     case SAVE_EXPR:
12854     case NON_LVALUE_EXPR:
12855       return tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
12856                                         strict_overflow_p);
12857
12858     case BIT_IOR_EXPR:
12859       return (tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 1),
12860                                         strict_overflow_p)
12861               || tree_expr_nonzero_warnv_p (TREE_OPERAND (t, 0),
12862                                             strict_overflow_p));
12863
12864     case CALL_EXPR:
12865       return alloca_call_p (t);
12866
12867     default:
12868       break;
12869     }
12870   return false;
12871 }
12872
12873 /* Return true when T is an address and is known to be nonzero.
12874    Handle warnings about undefined signed overflow.  */
12875
12876 bool
12877 tree_expr_nonzero_p (tree t)
12878 {
12879   bool ret, strict_overflow_p;
12880
12881   strict_overflow_p = false;
12882   ret = tree_expr_nonzero_warnv_p (t, &strict_overflow_p);
12883   if (strict_overflow_p)
12884     fold_overflow_warning (("assuming signed overflow does not occur when "
12885                             "determining that expression is always "
12886                             "non-zero"),
12887                            WARN_STRICT_OVERFLOW_MISC);
12888   return ret;
12889 }
12890
12891 /* Given the components of a binary expression CODE, TYPE, OP0 and OP1,
12892    attempt to fold the expression to a constant without modifying TYPE,
12893    OP0 or OP1.
12894
12895    If the expression could be simplified to a constant, then return
12896    the constant.  If the expression would not be simplified to a
12897    constant, then return NULL_TREE.  */
12898
12899 tree
12900 fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
12901 {
12902   tree tem = fold_binary (code, type, op0, op1);
12903   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
12904 }
12905
12906 /* Given the components of a unary expression CODE, TYPE and OP0,
12907    attempt to fold the expression to a constant without modifying
12908    TYPE or OP0.
12909
12910    If the expression could be simplified to a constant, then return
12911    the constant.  If the expression would not be simplified to a
12912    constant, then return NULL_TREE.  */
12913
12914 tree
12915 fold_unary_to_constant (enum tree_code code, tree type, tree op0)
12916 {
12917   tree tem = fold_unary (code, type, op0);
12918   return (tem && TREE_CONSTANT (tem)) ? tem : NULL_TREE;
12919 }
12920
12921 /* If EXP represents referencing an element in a constant string
12922    (either via pointer arithmetic or array indexing), return the
12923    tree representing the value accessed, otherwise return NULL.  */
12924
12925 tree
12926 fold_read_from_constant_string (tree exp)
12927 {
12928   if ((TREE_CODE (exp) == INDIRECT_REF
12929        || TREE_CODE (exp) == ARRAY_REF)
12930       && TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE)
12931     {
12932       tree exp1 = TREE_OPERAND (exp, 0);
12933       tree index;
12934       tree string;
12935
12936       if (TREE_CODE (exp) == INDIRECT_REF)
12937         string = string_constant (exp1, &index);
12938       else
12939         {
12940           tree low_bound = array_ref_low_bound (exp);
12941           index = fold_convert (sizetype, TREE_OPERAND (exp, 1));
12942
12943           /* Optimize the special-case of a zero lower bound.
12944
12945              We convert the low_bound to sizetype to avoid some problems
12946              with constant folding.  (E.g. suppose the lower bound is 1,
12947              and its mode is QI.  Without the conversion,l (ARRAY
12948              +(INDEX-(unsigned char)1)) becomes ((ARRAY+(-(unsigned char)1))
12949              +INDEX), which becomes (ARRAY+255+INDEX).  Opps!)  */
12950           if (! integer_zerop (low_bound))
12951             index = size_diffop (index, fold_convert (sizetype, low_bound));
12952
12953           string = exp1;
12954         }
12955
12956       if (string
12957           && TYPE_MODE (TREE_TYPE (exp)) == TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))
12958           && TREE_CODE (string) == STRING_CST
12959           && TREE_CODE (index) == INTEGER_CST
12960           && compare_tree_int (index, TREE_STRING_LENGTH (string)) < 0
12961           && (GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (TREE_TYPE (string))))
12962               == MODE_INT)
12963           && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (string)))) == 1))
12964         return fold_convert (TREE_TYPE (exp),
12965                              build_int_cst (NULL_TREE,
12966                                             (TREE_STRING_POINTER (string)
12967                                              [TREE_INT_CST_LOW (index)])));
12968     }
12969   return NULL;
12970 }
12971
12972 /* Return the tree for neg (ARG0) when ARG0 is known to be either
12973    an integer constant or real constant.
12974
12975    TYPE is the type of the result.  */
12976
12977 static tree
12978 fold_negate_const (tree arg0, tree type)
12979 {
12980   tree t = NULL_TREE;
12981
12982   switch (TREE_CODE (arg0))
12983     {
12984     case INTEGER_CST:
12985       {
12986         unsigned HOST_WIDE_INT low;
12987         HOST_WIDE_INT high;
12988         int overflow = neg_double (TREE_INT_CST_LOW (arg0),
12989                                    TREE_INT_CST_HIGH (arg0),
12990                                    &low, &high);
12991         t = build_int_cst_wide (type, low, high);
12992         t = force_fit_type (t, 1,
12993                             (overflow | TREE_OVERFLOW (arg0))
12994                             && !TYPE_UNSIGNED (type),
12995                             TREE_CONSTANT_OVERFLOW (arg0));
12996         break;
12997       }
12998
12999     case REAL_CST:
13000       t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
13001       break;
13002
13003     default:
13004       gcc_unreachable ();
13005     }
13006
13007   return t;
13008 }
13009
13010 /* Return the tree for abs (ARG0) when ARG0 is known to be either
13011    an integer constant or real constant.
13012
13013    TYPE is the type of the result.  */
13014
13015 tree
13016 fold_abs_const (tree arg0, tree type)
13017 {
13018   tree t = NULL_TREE;
13019
13020   switch (TREE_CODE (arg0))
13021     {
13022     case INTEGER_CST:
13023       /* If the value is unsigned, then the absolute value is
13024          the same as the ordinary value.  */
13025       if (TYPE_UNSIGNED (type))
13026         t = arg0;
13027       /* Similarly, if the value is non-negative.  */
13028       else if (INT_CST_LT (integer_minus_one_node, arg0))
13029         t = arg0;
13030       /* If the value is negative, then the absolute value is
13031          its negation.  */
13032       else
13033         {
13034           unsigned HOST_WIDE_INT low;
13035           HOST_WIDE_INT high;
13036           int overflow = neg_double (TREE_INT_CST_LOW (arg0),
13037                                      TREE_INT_CST_HIGH (arg0),
13038                                      &low, &high);
13039           t = build_int_cst_wide (type, low, high);
13040           t = force_fit_type (t, -1, overflow | TREE_OVERFLOW (arg0),
13041                               TREE_CONSTANT_OVERFLOW (arg0));
13042         }
13043       break;
13044
13045     case REAL_CST:
13046       if (REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg0)))
13047         t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
13048       else
13049         t =  arg0;
13050       break;
13051
13052     default:
13053       gcc_unreachable ();
13054     }
13055
13056   return t;
13057 }
13058
13059 /* Return the tree for not (ARG0) when ARG0 is known to be an integer
13060    constant.  TYPE is the type of the result.  */
13061
13062 static tree
13063 fold_not_const (tree arg0, tree type)
13064 {
13065   tree t = NULL_TREE;
13066
13067   gcc_assert (TREE_CODE (arg0) == INTEGER_CST);
13068
13069   t = build_int_cst_wide (type,
13070                           ~ TREE_INT_CST_LOW (arg0),
13071                           ~ TREE_INT_CST_HIGH (arg0));
13072   t = force_fit_type (t, 0, TREE_OVERFLOW (arg0),
13073                       TREE_CONSTANT_OVERFLOW (arg0));
13074
13075   return t;
13076 }
13077
13078 /* Given CODE, a relational operator, the target type, TYPE and two
13079    constant operands OP0 and OP1, return the result of the
13080    relational operation.  If the result is not a compile time
13081    constant, then return NULL_TREE.  */
13082
13083 static tree
13084 fold_relational_const (enum tree_code code, tree type, tree op0, tree op1)
13085 {
13086   int result, invert;
13087
13088   /* From here on, the only cases we handle are when the result is
13089      known to be a constant.  */
13090
13091   if (TREE_CODE (op0) == REAL_CST && TREE_CODE (op1) == REAL_CST)
13092     {
13093       const REAL_VALUE_TYPE *c0 = TREE_REAL_CST_PTR (op0);
13094       const REAL_VALUE_TYPE *c1 = TREE_REAL_CST_PTR (op1);
13095
13096       /* Handle the cases where either operand is a NaN.  */
13097       if (real_isnan (c0) || real_isnan (c1))
13098         {
13099           switch (code)
13100             {
13101             case EQ_EXPR:
13102             case ORDERED_EXPR:
13103               result = 0;
13104               break;
13105
13106             case NE_EXPR:
13107             case UNORDERED_EXPR:
13108             case UNLT_EXPR:
13109             case UNLE_EXPR:
13110             case UNGT_EXPR:
13111             case UNGE_EXPR:
13112             case UNEQ_EXPR:
13113               result = 1;
13114               break;
13115
13116             case LT_EXPR:
13117             case LE_EXPR:
13118             case GT_EXPR:
13119             case GE_EXPR:
13120             case LTGT_EXPR:
13121               if (flag_trapping_math)
13122                 return NULL_TREE;
13123               result = 0;
13124               break;
13125
13126             default:
13127               gcc_unreachable ();
13128             }
13129
13130           return constant_boolean_node (result, type);
13131         }
13132
13133       return constant_boolean_node (real_compare (code, c0, c1), type);
13134     }
13135
13136   /* Handle equality/inequality of complex constants.  */
13137   if (TREE_CODE (op0) == COMPLEX_CST && TREE_CODE (op1) == COMPLEX_CST)
13138     {
13139       tree rcond = fold_relational_const (code, type,
13140                                           TREE_REALPART (op0),
13141                                           TREE_REALPART (op1));
13142       tree icond = fold_relational_const (code, type,
13143                                           TREE_IMAGPART (op0),
13144                                           TREE_IMAGPART (op1));
13145       if (code == EQ_EXPR)
13146         return fold_build2 (TRUTH_ANDIF_EXPR, type, rcond, icond);
13147       else if (code == NE_EXPR)
13148         return fold_build2 (TRUTH_ORIF_EXPR, type, rcond, icond);
13149       else
13150         return NULL_TREE;
13151     }
13152
13153   /* From here on we only handle LT, LE, GT, GE, EQ and NE.
13154
13155      To compute GT, swap the arguments and do LT.
13156      To compute GE, do LT and invert the result.
13157      To compute LE, swap the arguments, do LT and invert the result.
13158      To compute NE, do EQ and invert the result.
13159
13160      Therefore, the code below must handle only EQ and LT.  */
13161
13162   if (code == LE_EXPR || code == GT_EXPR)
13163     {
13164       tree tem = op0;
13165       op0 = op1;
13166       op1 = tem;
13167       code = swap_tree_comparison (code);
13168     }
13169
13170   /* Note that it is safe to invert for real values here because we
13171      have already handled the one case that it matters.  */
13172
13173   invert = 0;
13174   if (code == NE_EXPR || code == GE_EXPR)
13175     {
13176       invert = 1;
13177       code = invert_tree_comparison (code, false);
13178     }
13179
13180   /* Compute a result for LT or EQ if args permit;
13181      Otherwise return T.  */
13182   if (TREE_CODE (op0) == INTEGER_CST && TREE_CODE (op1) == INTEGER_CST)
13183     {
13184       if (code == EQ_EXPR)
13185         result = tree_int_cst_equal (op0, op1);
13186       else if (TYPE_UNSIGNED (TREE_TYPE (op0)))
13187         result = INT_CST_LT_UNSIGNED (op0, op1);
13188       else
13189         result = INT_CST_LT (op0, op1);
13190     }
13191   else
13192     return NULL_TREE;
13193
13194   if (invert)
13195     result ^= 1;
13196   return constant_boolean_node (result, type);
13197 }
13198
13199 /* Build an expression for the a clean point containing EXPR with type TYPE.
13200    Don't build a cleanup point expression for EXPR which don't have side
13201    effects.  */
13202
13203 tree
13204 fold_build_cleanup_point_expr (tree type, tree expr)
13205 {
13206   /* If the expression does not have side effects then we don't have to wrap
13207      it with a cleanup point expression.  */
13208   if (!TREE_SIDE_EFFECTS (expr))
13209     return expr;
13210
13211   /* If the expression is a return, check to see if the expression inside the
13212      return has no side effects or the right hand side of the modify expression
13213      inside the return. If either don't have side effects set we don't need to
13214      wrap the expression in a cleanup point expression.  Note we don't check the
13215      left hand side of the modify because it should always be a return decl.  */
13216   if (TREE_CODE (expr) == RETURN_EXPR)
13217     {
13218       tree op = TREE_OPERAND (expr, 0);
13219       if (!op || !TREE_SIDE_EFFECTS (op))
13220         return expr;
13221       op = TREE_OPERAND (op, 1);
13222       if (!TREE_SIDE_EFFECTS (op))
13223         return expr;
13224     }
13225   
13226   return build1 (CLEANUP_POINT_EXPR, type, expr);
13227 }
13228
13229 /* Build an expression for the address of T.  Folds away INDIRECT_REF to
13230    avoid confusing the gimplify process.  */
13231
13232 tree
13233 build_fold_addr_expr_with_type (tree t, tree ptrtype)
13234 {
13235   /* The size of the object is not relevant when talking about its address.  */
13236   if (TREE_CODE (t) == WITH_SIZE_EXPR)
13237     t = TREE_OPERAND (t, 0);
13238
13239   /* Note: doesn't apply to ALIGN_INDIRECT_REF */
13240   if (TREE_CODE (t) == INDIRECT_REF
13241       || TREE_CODE (t) == MISALIGNED_INDIRECT_REF)
13242     {
13243       t = TREE_OPERAND (t, 0);
13244       if (TREE_TYPE (t) != ptrtype)
13245         t = build1 (NOP_EXPR, ptrtype, t);
13246     }
13247   else
13248     {
13249       tree base = t;
13250
13251       while (handled_component_p (base))
13252         base = TREE_OPERAND (base, 0);
13253       if (DECL_P (base))
13254         TREE_ADDRESSABLE (base) = 1;
13255
13256       t = build1 (ADDR_EXPR, ptrtype, t);
13257     }
13258
13259   return t;
13260 }
13261
13262 tree
13263 build_fold_addr_expr (tree t)
13264 {
13265   return build_fold_addr_expr_with_type (t, build_pointer_type (TREE_TYPE (t)));
13266 }
13267
13268 /* Given a pointer value OP0 and a type TYPE, return a simplified version
13269    of an indirection through OP0, or NULL_TREE if no simplification is
13270    possible.  */
13271
13272 tree
13273 fold_indirect_ref_1 (tree type, tree op0)
13274 {
13275   tree sub = op0;
13276   tree subtype;
13277
13278   STRIP_NOPS (sub);
13279   subtype = TREE_TYPE (sub);
13280   if (!POINTER_TYPE_P (subtype))
13281     return NULL_TREE;
13282
13283   if (TREE_CODE (sub) == ADDR_EXPR)
13284     {
13285       tree op = TREE_OPERAND (sub, 0);
13286       tree optype = TREE_TYPE (op);
13287       /* *&CONST_DECL -> to the value of the const decl.  */
13288       if (TREE_CODE (op) == CONST_DECL)
13289         return DECL_INITIAL (op);
13290       /* *&p => p;  make sure to handle *&"str"[cst] here.  */
13291       if (type == optype)
13292         {
13293           tree fop = fold_read_from_constant_string (op);
13294           if (fop)
13295             return fop;
13296           else
13297             return op;
13298         }
13299       /* *(foo *)&fooarray => fooarray[0] */
13300       else if (TREE_CODE (optype) == ARRAY_TYPE
13301                && type == TREE_TYPE (optype))
13302         {
13303           tree type_domain = TYPE_DOMAIN (optype);
13304           tree min_val = size_zero_node;
13305           if (type_domain && TYPE_MIN_VALUE (type_domain))
13306             min_val = TYPE_MIN_VALUE (type_domain);
13307           return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
13308         }
13309       /* *(foo *)&complexfoo => __real__ complexfoo */
13310       else if (TREE_CODE (optype) == COMPLEX_TYPE
13311                && type == TREE_TYPE (optype))
13312         return fold_build1 (REALPART_EXPR, type, op);
13313     }
13314
13315   /* ((foo*)&complexfoo)[1] => __imag__ complexfoo */
13316   if (TREE_CODE (sub) == PLUS_EXPR
13317       && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
13318     {
13319       tree op00 = TREE_OPERAND (sub, 0);
13320       tree op01 = TREE_OPERAND (sub, 1);
13321       tree op00type;
13322
13323       STRIP_NOPS (op00);
13324       op00type = TREE_TYPE (op00);
13325       if (TREE_CODE (op00) == ADDR_EXPR
13326           && TREE_CODE (TREE_TYPE (op00type)) == COMPLEX_TYPE
13327           && type == TREE_TYPE (TREE_TYPE (op00type)))
13328         {
13329           tree size = TYPE_SIZE_UNIT (type);
13330           if (tree_int_cst_equal (size, op01))
13331             return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (op00, 0));
13332         }
13333     }
13334   
13335   /* *(foo *)fooarrptr => (*fooarrptr)[0] */
13336   if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
13337       && type == TREE_TYPE (TREE_TYPE (subtype)))
13338     {
13339       tree type_domain;
13340       tree min_val = size_zero_node;
13341       sub = build_fold_indirect_ref (sub);
13342       type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
13343       if (type_domain && TYPE_MIN_VALUE (type_domain))
13344         min_val = TYPE_MIN_VALUE (type_domain);
13345       return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
13346     }
13347
13348   return NULL_TREE;
13349 }
13350
13351 /* Builds an expression for an indirection through T, simplifying some
13352    cases.  */
13353
13354 tree
13355 build_fold_indirect_ref (tree t)
13356 {
13357   tree type = TREE_TYPE (TREE_TYPE (t));
13358   tree sub = fold_indirect_ref_1 (type, t);
13359
13360   if (sub)
13361     return sub;
13362   else
13363     return build1 (INDIRECT_REF, type, t);
13364 }
13365
13366 /* Given an INDIRECT_REF T, return either T or a simplified version.  */
13367
13368 tree
13369 fold_indirect_ref (tree t)
13370 {
13371   tree sub = fold_indirect_ref_1 (TREE_TYPE (t), TREE_OPERAND (t, 0));
13372
13373   if (sub)
13374     return sub;
13375   else
13376     return t;
13377 }
13378
13379 /* Strip non-trapping, non-side-effecting tree nodes from an expression
13380    whose result is ignored.  The type of the returned tree need not be
13381    the same as the original expression.  */
13382
13383 tree
13384 fold_ignored_result (tree t)
13385 {
13386   if (!TREE_SIDE_EFFECTS (t))
13387     return integer_zero_node;
13388
13389   for (;;)
13390     switch (TREE_CODE_CLASS (TREE_CODE (t)))
13391       {
13392       case tcc_unary:
13393         t = TREE_OPERAND (t, 0);
13394         break;
13395
13396       case tcc_binary:
13397       case tcc_comparison:
13398         if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
13399           t = TREE_OPERAND (t, 0);
13400         else if (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)))
13401           t = TREE_OPERAND (t, 1);
13402         else
13403           return t;
13404         break;
13405
13406       case tcc_expression:
13407         switch (TREE_CODE (t))
13408           {
13409           case COMPOUND_EXPR:
13410             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1)))
13411               return t;
13412             t = TREE_OPERAND (t, 0);
13413             break;
13414
13415           case COND_EXPR:
13416             if (TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))
13417                 || TREE_SIDE_EFFECTS (TREE_OPERAND (t, 2)))
13418               return t;
13419             t = TREE_OPERAND (t, 0);
13420             break;
13421
13422           default:
13423             return t;
13424           }
13425         break;
13426
13427       default:
13428         return t;
13429       }
13430 }
13431
13432 /* Return the value of VALUE, rounded up to a multiple of DIVISOR.
13433    This can only be applied to objects of a sizetype.  */
13434
13435 tree
13436 round_up (tree value, int divisor)
13437 {
13438   tree div = NULL_TREE;
13439
13440   gcc_assert (divisor > 0);
13441   if (divisor == 1)
13442     return value;
13443
13444   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
13445      have to do anything.  Only do this when we are not given a const,
13446      because in that case, this check is more expensive than just
13447      doing it.  */
13448   if (TREE_CODE (value) != INTEGER_CST)
13449     {
13450       div = build_int_cst (TREE_TYPE (value), divisor);
13451
13452       if (multiple_of_p (TREE_TYPE (value), value, div))
13453         return value;
13454     }
13455
13456   /* If divisor is a power of two, simplify this to bit manipulation.  */
13457   if (divisor == (divisor & -divisor))
13458     {
13459       tree t;
13460
13461       t = build_int_cst (TREE_TYPE (value), divisor - 1);
13462       value = size_binop (PLUS_EXPR, value, t);
13463       t = build_int_cst (TREE_TYPE (value), -divisor);
13464       value = size_binop (BIT_AND_EXPR, value, t);
13465     }
13466   else
13467     {
13468       if (!div)
13469         div = build_int_cst (TREE_TYPE (value), divisor);
13470       value = size_binop (CEIL_DIV_EXPR, value, div);
13471       value = size_binop (MULT_EXPR, value, div);
13472     }
13473
13474   return value;
13475 }
13476
13477 /* Likewise, but round down.  */
13478
13479 tree
13480 round_down (tree value, int divisor)
13481 {
13482   tree div = NULL_TREE;
13483
13484   gcc_assert (divisor > 0);
13485   if (divisor == 1)
13486     return value;
13487
13488   /* See if VALUE is already a multiple of DIVISOR.  If so, we don't
13489      have to do anything.  Only do this when we are not given a const,
13490      because in that case, this check is more expensive than just
13491      doing it.  */
13492   if (TREE_CODE (value) != INTEGER_CST)
13493     {
13494       div = build_int_cst (TREE_TYPE (value), divisor);
13495
13496       if (multiple_of_p (TREE_TYPE (value), value, div))
13497         return value;
13498     }
13499
13500   /* If divisor is a power of two, simplify this to bit manipulation.  */
13501   if (divisor == (divisor & -divisor))
13502     {
13503       tree t;
13504
13505       t = build_int_cst (TREE_TYPE (value), -divisor);
13506       value = size_binop (BIT_AND_EXPR, value, t);
13507     }
13508   else
13509     {
13510       if (!div)
13511         div = build_int_cst (TREE_TYPE (value), divisor);
13512       value = size_binop (FLOOR_DIV_EXPR, value, div);
13513       value = size_binop (MULT_EXPR, value, div);
13514     }
13515
13516   return value;
13517 }
13518
13519 /* Returns the pointer to the base of the object addressed by EXP and
13520    extracts the information about the offset of the access, storing it
13521    to PBITPOS and POFFSET.  */
13522
13523 static tree
13524 split_address_to_core_and_offset (tree exp,
13525                                   HOST_WIDE_INT *pbitpos, tree *poffset)
13526 {
13527   tree core;
13528   enum machine_mode mode;
13529   int unsignedp, volatilep;
13530   HOST_WIDE_INT bitsize;
13531
13532   if (TREE_CODE (exp) == ADDR_EXPR)
13533     {
13534       core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos,
13535                                   poffset, &mode, &unsignedp, &volatilep,
13536                                   false);
13537       core = build_fold_addr_expr (core);
13538     }
13539   else
13540     {
13541       core = exp;
13542       *pbitpos = 0;
13543       *poffset = NULL_TREE;
13544     }
13545
13546   return core;
13547 }
13548
13549 /* Returns true if addresses of E1 and E2 differ by a constant, false
13550    otherwise.  If they do, E1 - E2 is stored in *DIFF.  */
13551
13552 bool
13553 ptr_difference_const (tree e1, tree e2, HOST_WIDE_INT *diff)
13554 {
13555   tree core1, core2;
13556   HOST_WIDE_INT bitpos1, bitpos2;
13557   tree toffset1, toffset2, tdiff, type;
13558
13559   core1 = split_address_to_core_and_offset (e1, &bitpos1, &toffset1);
13560   core2 = split_address_to_core_and_offset (e2, &bitpos2, &toffset2);
13561
13562   if (bitpos1 % BITS_PER_UNIT != 0
13563       || bitpos2 % BITS_PER_UNIT != 0
13564       || !operand_equal_p (core1, core2, 0))
13565     return false;
13566
13567   if (toffset1 && toffset2)
13568     {
13569       type = TREE_TYPE (toffset1);
13570       if (type != TREE_TYPE (toffset2))
13571         toffset2 = fold_convert (type, toffset2);
13572
13573       tdiff = fold_build2 (MINUS_EXPR, type, toffset1, toffset2);
13574       if (!cst_and_fits_in_hwi (tdiff))
13575         return false;
13576
13577       *diff = int_cst_value (tdiff);
13578     }
13579   else if (toffset1 || toffset2)
13580     {
13581       /* If only one of the offsets is non-constant, the difference cannot
13582          be a constant.  */
13583       return false;
13584     }
13585   else
13586     *diff = 0;
13587
13588   *diff += (bitpos1 - bitpos2) / BITS_PER_UNIT;
13589   return true;
13590 }
13591
13592 /* Simplify the floating point expression EXP when the sign of the
13593    result is not significant.  Return NULL_TREE if no simplification
13594    is possible.  */
13595
13596 tree
13597 fold_strip_sign_ops (tree exp)
13598 {
13599   tree arg0, arg1;
13600
13601   switch (TREE_CODE (exp))
13602     {
13603     case ABS_EXPR:
13604     case NEGATE_EXPR:
13605       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
13606       return arg0 ? arg0 : TREE_OPERAND (exp, 0);
13607
13608     case MULT_EXPR:
13609     case RDIV_EXPR:
13610       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (exp))))
13611         return NULL_TREE;
13612       arg0 = fold_strip_sign_ops (TREE_OPERAND (exp, 0));
13613       arg1 = fold_strip_sign_ops (TREE_OPERAND (exp, 1));
13614       if (arg0 != NULL_TREE || arg1 != NULL_TREE)
13615         return fold_build2 (TREE_CODE (exp), TREE_TYPE (exp),
13616                             arg0 ? arg0 : TREE_OPERAND (exp, 0),
13617                             arg1 ? arg1 : TREE_OPERAND (exp, 1));
13618       break;
13619
13620     default:
13621       break;
13622     }
13623   return NULL_TREE;
13624 }
13625