OSDN Git Service

2008-03-27 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / fold-const.c
1 /* Fold a constant sub-tree into a single node for C-compiler
2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 /*@@ This file should be rewritten to use an arbitrary precision
23   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
24   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
25   @@ The routines that translate from the ap rep should
26   @@ warn if precision et. al. is lost.
27   @@ This would also make life easier when this technology is used
28   @@ for cross-compilers.  */
29
30 /* The entry points in this file are fold, size_int_wide, size_binop
31    and force_fit_type_double.
32
33    fold takes a tree as argument and returns a simplified tree.
34
35    size_binop takes a tree code for an arithmetic operation
36    and two operands that are trees, and produces a tree for the
37    result, assuming the type comes from `sizetype'.
38
39    size_int takes an integer value, and creates a tree constant
40    with type from `sizetype'.
41
42    force_fit_type_double takes a constant, an overflowable flag and a
43    prior overflow indicator.  It forces the value to fit the type and
44    sets TREE_OVERFLOW.
45
46    Note: Since the folders get called on non-gimple code as well as
47    gimple code, we need to handle GIMPLE tuples as well as their
48    corresponding tree equivalents.  */
49
50 #include "config.h"
51 #include "system.h"
52 #include "coretypes.h"
53 #include "tm.h"
54 #include "flags.h"
55 #include "tree.h"
56 #include "real.h"
57 #include "fixed-value.h"
58 #include "rtl.h"
59 #include "expr.h"
60 #include "tm_p.h"
61 #include "target.h"
62 #include "toplev.h"
63 #include "intl.h"
64 #include "ggc.h"
65 #include "hashtab.h"
66 #include "langhooks.h"
67 #include "md5.h"
68
69 /* Nonzero if we are folding constants inside an initializer; zero
70    otherwise.  */
71 int folding_initializer = 0;
72
73 /* The following constants represent a bit based encoding of GCC's
74    comparison operators.  This encoding simplifies transformations
75    on relational comparison operators, such as AND and OR.  */
76 enum comparison_code {
77   COMPCODE_FALSE = 0,
78   COMPCODE_LT = 1,
79   COMPCODE_EQ = 2,
80   COMPCODE_LE = 3,
81   COMPCODE_GT = 4,
82   COMPCODE_LTGT = 5,
83   COMPCODE_GE = 6,
84   COMPCODE_ORD = 7,
85   COMPCODE_UNORD = 8,
86   COMPCODE_UNLT = 9,
87   COMPCODE_UNEQ = 10,
88   COMPCODE_UNLE = 11,
89   COMPCODE_UNGT = 12,
90   COMPCODE_NE = 13,
91   COMPCODE_UNGE = 14,
92   COMPCODE_TRUE = 15
93 };
94
95 static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
96 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
97 static bool negate_mathfn_p (enum built_in_function);
98 static bool negate_expr_p (tree);
99 static tree negate_expr (tree);
100 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
101 static tree associate_trees (tree, tree, enum tree_code, tree);
102 static tree const_binop (enum tree_code, tree, tree, int);
103 static enum comparison_code comparison_to_compcode (enum tree_code);
104 static enum tree_code compcode_to_comparison (enum comparison_code);
105 static tree combine_comparisons (enum tree_code, enum tree_code,
106                                  enum tree_code, tree, tree, tree);
107 static int truth_value_p (enum tree_code);
108 static int operand_equal_for_comparison_p (tree, tree, tree);
109 static int twoval_comparison_p (tree, tree *, tree *, int *);
110 static tree eval_subst (tree, tree, tree, tree, tree);
111 static tree pedantic_omit_one_operand (tree, tree, tree);
112 static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
113 static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
114                                     enum machine_mode *, int *, int *,
115                                     tree *, tree *);
116 static tree sign_bit_p (tree, const_tree);
117 static int simple_operand_p (const_tree);
118 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
119 static tree range_predecessor (tree);
120 static tree range_successor (tree);
121 static tree make_range (tree, int *, tree *, tree *, bool *);
122 static tree build_range_check (tree, tree, int, tree, tree);
123 static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
124                          tree);
125 static tree fold_range_test (enum tree_code, tree, tree, tree);
126 static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
127 static tree unextend (tree, int, int, tree);
128 static tree fold_truthop (enum tree_code, tree, tree, tree);
129 static tree optimize_minmax_comparison (enum tree_code, tree, tree, tree);
130 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
131 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
132 static tree fold_binary_op_with_conditional_arg (enum tree_code, tree,
133                                                  tree, tree,
134                                                  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 (const_tree, const_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
144
145 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
146    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
147    and SUM1.  Then this yields nonzero if overflow occurred during the
148    addition.
149
150    Overflow occurs if A and B have the same sign, but A and SUM differ in
151    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
152    sign.  */
153 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
154 \f
155 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
156    We do that by representing the two-word integer in 4 words, with only
157    HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
158    number.  The value of the word is LOWPART + HIGHPART * BASE.  */
159
160 #define LOWPART(x) \
161   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
162 #define HIGHPART(x) \
163   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
164 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
165
166 /* Unpack a two-word integer into 4 words.
167    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
168    WORDS points to the array of HOST_WIDE_INTs.  */
169
170 static void
171 encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
172 {
173   words[0] = LOWPART (low);
174   words[1] = HIGHPART (low);
175   words[2] = LOWPART (hi);
176   words[3] = HIGHPART (hi);
177 }
178
179 /* Pack an array of 4 words into a two-word integer.
180    WORDS points to the array of words.
181    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
182
183 static void
184 decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
185         HOST_WIDE_INT *hi)
186 {
187   *low = words[0] + words[1] * BASE;
188   *hi = words[2] + words[3] * BASE;
189 }
190 \f
191 /* Force the double-word integer L1, H1 to be within the range of the
192    integer type TYPE.  Stores the properly truncated and sign-extended
193    double-word integer in *LV, *HV.  Returns true if the operation
194    overflows, that is, argument and result are different.  */
195
196 int
197 fit_double_type (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
198                  unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, const_tree type)
199 {
200   unsigned HOST_WIDE_INT low0 = l1;
201   HOST_WIDE_INT high0 = h1;
202   unsigned int prec;
203   int sign_extended_type;
204
205   if (POINTER_TYPE_P (type)
206       || TREE_CODE (type) == OFFSET_TYPE)
207     prec = POINTER_SIZE;
208   else
209     prec = TYPE_PRECISION (type);
210
211   /* Size types *are* sign extended.  */
212   sign_extended_type = (!TYPE_UNSIGNED (type)
213                         || (TREE_CODE (type) == INTEGER_TYPE
214                             && TYPE_IS_SIZETYPE (type)));
215
216   /* First clear all bits that are beyond the type's precision.  */
217   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
218     ;
219   else if (prec > HOST_BITS_PER_WIDE_INT)
220     h1 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
221   else
222     {
223       h1 = 0;
224       if (prec < HOST_BITS_PER_WIDE_INT)
225         l1 &= ~((HOST_WIDE_INT) (-1) << prec);
226     }
227
228   /* Then do sign extension if necessary.  */
229   if (!sign_extended_type)
230     /* No sign extension */;
231   else if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
232     /* Correct width already.  */;
233   else if (prec > HOST_BITS_PER_WIDE_INT)
234     {
235       /* Sign extend top half? */
236       if (h1 & ((unsigned HOST_WIDE_INT)1
237                 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
238         h1 |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
239     }
240   else if (prec == HOST_BITS_PER_WIDE_INT)
241     {
242       if ((HOST_WIDE_INT)l1 < 0)
243         h1 = -1;
244     }
245   else
246     {
247       /* Sign extend bottom half? */
248       if (l1 & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
249         {
250           h1 = -1;
251           l1 |= (HOST_WIDE_INT)(-1) << prec;
252         }
253     }
254
255   *lv = l1;
256   *hv = h1;
257
258   /* If the value didn't fit, signal overflow.  */
259   return l1 != low0 || h1 != high0;
260 }
261
262 /* We force the double-int HIGH:LOW to the range of the type TYPE by
263    sign or zero extending it.
264    OVERFLOWABLE indicates if we are interested
265    in overflow of the value, when >0 we are only interested in signed
266    overflow, for <0 we are interested in any overflow.  OVERFLOWED
267    indicates whether overflow has already occurred.  CONST_OVERFLOWED
268    indicates whether constant overflow has already occurred.  We force
269    T's value to be within range of T's type (by setting to 0 or 1 all
270    the bits outside the type's range).  We set TREE_OVERFLOWED if,
271         OVERFLOWED is nonzero,
272         or OVERFLOWABLE is >0 and signed overflow occurs
273         or OVERFLOWABLE is <0 and any overflow occurs
274    We return a new tree node for the extended double-int.  The node
275    is shared if no overflow flags are set.  */
276
277 tree
278 force_fit_type_double (tree type, unsigned HOST_WIDE_INT low,
279                        HOST_WIDE_INT high, int overflowable,
280                        bool overflowed)
281 {
282   int sign_extended_type;
283   bool overflow;
284
285   /* Size types *are* sign extended.  */
286   sign_extended_type = (!TYPE_UNSIGNED (type)
287                         || (TREE_CODE (type) == INTEGER_TYPE
288                             && TYPE_IS_SIZETYPE (type)));
289
290   overflow = fit_double_type (low, high, &low, &high, type);
291
292   /* If we need to set overflow flags, return a new unshared node.  */
293   if (overflowed || overflow)
294     {
295       if (overflowed
296           || overflowable < 0
297           || (overflowable > 0 && sign_extended_type))
298         {
299           tree t = make_node (INTEGER_CST);
300           TREE_INT_CST_LOW (t) = low;
301           TREE_INT_CST_HIGH (t) = high;
302           TREE_TYPE (t) = type;
303           TREE_OVERFLOW (t) = 1;
304           return t;
305         }
306     }
307
308   /* Else build a shared node.  */
309   return build_int_cst_wide (type, low, high);
310 }
311 \f
312 /* Add two doubleword integers with doubleword result.
313    Return nonzero if the operation overflows according to UNSIGNED_P.
314    Each argument is given as two `HOST_WIDE_INT' pieces.
315    One argument is L1 and H1; the other, L2 and H2.
316    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
317
318 int
319 add_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
320                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
321                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
322                       bool unsigned_p)
323 {
324   unsigned HOST_WIDE_INT l;
325   HOST_WIDE_INT h;
326
327   l = l1 + l2;
328   h = h1 + h2 + (l < l1);
329
330   *lv = l;
331   *hv = h;
332
333   if (unsigned_p)
334     return (unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1;
335   else
336     return OVERFLOW_SUM_SIGN (h1, h2, h);
337 }
338
339 /* Negate a doubleword integer with doubleword result.
340    Return nonzero if the operation overflows, assuming it's signed.
341    The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
342    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
343
344 int
345 neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
346             unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
347 {
348   if (l1 == 0)
349     {
350       *lv = 0;
351       *hv = - h1;
352       return (*hv & h1) < 0;
353     }
354   else
355     {
356       *lv = -l1;
357       *hv = ~h1;
358       return 0;
359     }
360 }
361 \f
362 /* Multiply two doubleword integers with doubleword result.
363    Return nonzero if the operation overflows according to UNSIGNED_P.
364    Each argument is given as two `HOST_WIDE_INT' pieces.
365    One argument is L1 and H1; the other, L2 and H2.
366    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
367
368 int
369 mul_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
370                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
371                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
372                       bool unsigned_p)
373 {
374   HOST_WIDE_INT arg1[4];
375   HOST_WIDE_INT arg2[4];
376   HOST_WIDE_INT prod[4 * 2];
377   unsigned HOST_WIDE_INT carry;
378   int i, j, k;
379   unsigned HOST_WIDE_INT toplow, neglow;
380   HOST_WIDE_INT tophigh, neghigh;
381
382   encode (arg1, l1, h1);
383   encode (arg2, l2, h2);
384
385   memset (prod, 0, sizeof prod);
386
387   for (i = 0; i < 4; i++)
388     {
389       carry = 0;
390       for (j = 0; j < 4; j++)
391         {
392           k = i + j;
393           /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000.  */
394           carry += arg1[i] * arg2[j];
395           /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF.  */
396           carry += prod[k];
397           prod[k] = LOWPART (carry);
398           carry = HIGHPART (carry);
399         }
400       prod[i + 4] = carry;
401     }
402
403   decode (prod, lv, hv);
404   decode (prod + 4, &toplow, &tophigh);
405
406   /* Unsigned overflow is immediate.  */
407   if (unsigned_p)
408     return (toplow | tophigh) != 0;
409
410   /* Check for signed overflow by calculating the signed representation of the
411      top half of the result; it should agree with the low half's sign bit.  */
412   if (h1 < 0)
413     {
414       neg_double (l2, h2, &neglow, &neghigh);
415       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
416     }
417   if (h2 < 0)
418     {
419       neg_double (l1, h1, &neglow, &neghigh);
420       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
421     }
422   return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
423 }
424 \f
425 /* Shift the doubleword integer in L1, H1 left by COUNT places
426    keeping only PREC bits of result.
427    Shift right if COUNT is negative.
428    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
429    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
430
431 void
432 lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
433                HOST_WIDE_INT count, unsigned int prec,
434                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, int arith)
435 {
436   unsigned HOST_WIDE_INT signmask;
437
438   if (count < 0)
439     {
440       rshift_double (l1, h1, -count, prec, lv, hv, arith);
441       return;
442     }
443
444   if (SHIFT_COUNT_TRUNCATED)
445     count %= prec;
446
447   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
448     {
449       /* Shifting by the host word size is undefined according to the
450          ANSI standard, so we must handle this as a special case.  */
451       *hv = 0;
452       *lv = 0;
453     }
454   else if (count >= HOST_BITS_PER_WIDE_INT)
455     {
456       *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
457       *lv = 0;
458     }
459   else
460     {
461       *hv = (((unsigned HOST_WIDE_INT) h1 << count)
462              | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
463       *lv = l1 << count;
464     }
465
466   /* Sign extend all bits that are beyond the precision.  */
467
468   signmask = -((prec > HOST_BITS_PER_WIDE_INT
469                 ? ((unsigned HOST_WIDE_INT) *hv
470                    >> (prec - HOST_BITS_PER_WIDE_INT - 1))
471                 : (*lv >> (prec - 1))) & 1);
472
473   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
474     ;
475   else if (prec >= HOST_BITS_PER_WIDE_INT)
476     {
477       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
478       *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
479     }
480   else
481     {
482       *hv = signmask;
483       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
484       *lv |= signmask << prec;
485     }
486 }
487
488 /* Shift the doubleword integer in L1, H1 right by COUNT places
489    keeping only PREC bits of result.  COUNT must be positive.
490    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
491    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
492
493 void
494 rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
495                HOST_WIDE_INT count, unsigned int prec,
496                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
497                int arith)
498 {
499   unsigned HOST_WIDE_INT signmask;
500
501   signmask = (arith
502               ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
503               : 0);
504
505   if (SHIFT_COUNT_TRUNCATED)
506     count %= prec;
507
508   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
509     {
510       /* Shifting by the host word size is undefined according to the
511          ANSI standard, so we must handle this as a special case.  */
512       *hv = 0;
513       *lv = 0;
514     }
515   else if (count >= HOST_BITS_PER_WIDE_INT)
516     {
517       *hv = 0;
518       *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
519     }
520   else
521     {
522       *hv = (unsigned HOST_WIDE_INT) h1 >> count;
523       *lv = ((l1 >> count)
524              | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
525     }
526
527   /* Zero / sign extend all bits that are beyond the precision.  */
528
529   if (count >= (HOST_WIDE_INT)prec)
530     {
531       *hv = signmask;
532       *lv = signmask;
533     }
534   else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT)
535     ;
536   else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
537     {
538       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
539       *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
540     }
541   else
542     {
543       *hv = signmask;
544       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
545       *lv |= signmask << (prec - count);
546     }
547 }
548 \f
549 /* Rotate the doubleword integer in L1, H1 left by COUNT places
550    keeping only PREC bits of result.
551    Rotate right if COUNT is negative.
552    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
553
554 void
555 lrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
556                 HOST_WIDE_INT count, unsigned int prec,
557                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
558 {
559   unsigned HOST_WIDE_INT s1l, s2l;
560   HOST_WIDE_INT s1h, s2h;
561
562   count %= prec;
563   if (count < 0)
564     count += prec;
565
566   lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
567   rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
568   *lv = s1l | s2l;
569   *hv = s1h | s2h;
570 }
571
572 /* Rotate the doubleword integer in L1, H1 left by COUNT places
573    keeping only PREC bits of result.  COUNT must be positive.
574    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
575
576 void
577 rrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
578                 HOST_WIDE_INT count, unsigned int prec,
579                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
580 {
581   unsigned HOST_WIDE_INT s1l, s2l;
582   HOST_WIDE_INT s1h, s2h;
583
584   count %= prec;
585   if (count < 0)
586     count += prec;
587
588   rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
589   lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
590   *lv = s1l | s2l;
591   *hv = s1h | s2h;
592 }
593 \f
594 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
595    for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
596    CODE is a tree code for a kind of division, one of
597    TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
598    or EXACT_DIV_EXPR
599    It controls how the quotient is rounded to an integer.
600    Return nonzero if the operation overflows.
601    UNS nonzero says do unsigned division.  */
602
603 int
604 div_and_round_double (enum tree_code code, int uns,
605                       unsigned HOST_WIDE_INT lnum_orig, /* num == numerator == dividend */
606                       HOST_WIDE_INT hnum_orig,
607                       unsigned HOST_WIDE_INT lden_orig, /* den == denominator == divisor */
608                       HOST_WIDE_INT hden_orig,
609                       unsigned HOST_WIDE_INT *lquo,
610                       HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
611                       HOST_WIDE_INT *hrem)
612 {
613   int quo_neg = 0;
614   HOST_WIDE_INT num[4 + 1];     /* extra element for scaling.  */
615   HOST_WIDE_INT den[4], quo[4];
616   int i, j;
617   unsigned HOST_WIDE_INT work;
618   unsigned HOST_WIDE_INT carry = 0;
619   unsigned HOST_WIDE_INT lnum = lnum_orig;
620   HOST_WIDE_INT hnum = hnum_orig;
621   unsigned HOST_WIDE_INT lden = lden_orig;
622   HOST_WIDE_INT hden = hden_orig;
623   int overflow = 0;
624
625   if (hden == 0 && lden == 0)
626     overflow = 1, lden = 1;
627
628   /* Calculate quotient sign and convert operands to unsigned.  */
629   if (!uns)
630     {
631       if (hnum < 0)
632         {
633           quo_neg = ~ quo_neg;
634           /* (minimum integer) / (-1) is the only overflow case.  */
635           if (neg_double (lnum, hnum, &lnum, &hnum)
636               && ((HOST_WIDE_INT) lden & hden) == -1)
637             overflow = 1;
638         }
639       if (hden < 0)
640         {
641           quo_neg = ~ quo_neg;
642           neg_double (lden, hden, &lden, &hden);
643         }
644     }
645
646   if (hnum == 0 && hden == 0)
647     {                           /* single precision */
648       *hquo = *hrem = 0;
649       /* This unsigned division rounds toward zero.  */
650       *lquo = lnum / lden;
651       goto finish_up;
652     }
653
654   if (hnum == 0)
655     {                           /* trivial case: dividend < divisor */
656       /* hden != 0 already checked.  */
657       *hquo = *lquo = 0;
658       *hrem = hnum;
659       *lrem = lnum;
660       goto finish_up;
661     }
662
663   memset (quo, 0, sizeof quo);
664
665   memset (num, 0, sizeof num);  /* to zero 9th element */
666   memset (den, 0, sizeof den);
667
668   encode (num, lnum, hnum);
669   encode (den, lden, hden);
670
671   /* Special code for when the divisor < BASE.  */
672   if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
673     {
674       /* hnum != 0 already checked.  */
675       for (i = 4 - 1; i >= 0; i--)
676         {
677           work = num[i] + carry * BASE;
678           quo[i] = work / lden;
679           carry = work % lden;
680         }
681     }
682   else
683     {
684       /* Full double precision division,
685          with thanks to Don Knuth's "Seminumerical Algorithms".  */
686       int num_hi_sig, den_hi_sig;
687       unsigned HOST_WIDE_INT quo_est, scale;
688
689       /* Find the highest nonzero divisor digit.  */
690       for (i = 4 - 1;; i--)
691         if (den[i] != 0)
692           {
693             den_hi_sig = i;
694             break;
695           }
696
697       /* Insure that the first digit of the divisor is at least BASE/2.
698          This is required by the quotient digit estimation algorithm.  */
699
700       scale = BASE / (den[den_hi_sig] + 1);
701       if (scale > 1)
702         {               /* scale divisor and dividend */
703           carry = 0;
704           for (i = 0; i <= 4 - 1; i++)
705             {
706               work = (num[i] * scale) + carry;
707               num[i] = LOWPART (work);
708               carry = HIGHPART (work);
709             }
710
711           num[4] = carry;
712           carry = 0;
713           for (i = 0; i <= 4 - 1; i++)
714             {
715               work = (den[i] * scale) + carry;
716               den[i] = LOWPART (work);
717               carry = HIGHPART (work);
718               if (den[i] != 0) den_hi_sig = i;
719             }
720         }
721
722       num_hi_sig = 4;
723
724       /* Main loop */
725       for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
726         {
727           /* Guess the next quotient digit, quo_est, by dividing the first
728              two remaining dividend digits by the high order quotient digit.
729              quo_est is never low and is at most 2 high.  */
730           unsigned HOST_WIDE_INT tmp;
731
732           num_hi_sig = i + den_hi_sig + 1;
733           work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
734           if (num[num_hi_sig] != den[den_hi_sig])
735             quo_est = work / den[den_hi_sig];
736           else
737             quo_est = BASE - 1;
738
739           /* Refine quo_est so it's usually correct, and at most one high.  */
740           tmp = work - quo_est * den[den_hi_sig];
741           if (tmp < BASE
742               && (den[den_hi_sig - 1] * quo_est
743                   > (tmp * BASE + num[num_hi_sig - 2])))
744             quo_est--;
745
746           /* Try QUO_EST as the quotient digit, by multiplying the
747              divisor by QUO_EST and subtracting from the remaining dividend.
748              Keep in mind that QUO_EST is the I - 1st digit.  */
749
750           carry = 0;
751           for (j = 0; j <= den_hi_sig; j++)
752             {
753               work = quo_est * den[j] + carry;
754               carry = HIGHPART (work);
755               work = num[i + j] - LOWPART (work);
756               num[i + j] = LOWPART (work);
757               carry += HIGHPART (work) != 0;
758             }
759
760           /* If quo_est was high by one, then num[i] went negative and
761              we need to correct things.  */
762           if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
763             {
764               quo_est--;
765               carry = 0;                /* add divisor back in */
766               for (j = 0; j <= den_hi_sig; j++)
767                 {
768                   work = num[i + j] + den[j] + carry;
769                   carry = HIGHPART (work);
770                   num[i + j] = LOWPART (work);
771                 }
772
773               num [num_hi_sig] += carry;
774             }
775
776           /* Store the quotient digit.  */
777           quo[i] = quo_est;
778         }
779     }
780
781   decode (quo, lquo, hquo);
782
783  finish_up:
784   /* If result is negative, make it so.  */
785   if (quo_neg)
786     neg_double (*lquo, *hquo, lquo, hquo);
787
788   /* Compute trial remainder:  rem = num - (quo * den)  */
789   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
790   neg_double (*lrem, *hrem, lrem, hrem);
791   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
792
793   switch (code)
794     {
795     case TRUNC_DIV_EXPR:
796     case TRUNC_MOD_EXPR:        /* round toward zero */
797     case EXACT_DIV_EXPR:        /* for this one, it shouldn't matter */
798       return overflow;
799
800     case FLOOR_DIV_EXPR:
801     case FLOOR_MOD_EXPR:        /* round toward negative infinity */
802       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
803         {
804           /* quo = quo - 1;  */
805           add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT)  -1,
806                       lquo, hquo);
807         }
808       else
809         return overflow;
810       break;
811
812     case CEIL_DIV_EXPR:
813     case CEIL_MOD_EXPR:         /* round toward positive infinity */
814       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
815         {
816           add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
817                       lquo, hquo);
818         }
819       else
820         return overflow;
821       break;
822
823     case ROUND_DIV_EXPR:
824     case ROUND_MOD_EXPR:        /* round to closest integer */
825       {
826         unsigned HOST_WIDE_INT labs_rem = *lrem;
827         HOST_WIDE_INT habs_rem = *hrem;
828         unsigned HOST_WIDE_INT labs_den = lden, ltwice;
829         HOST_WIDE_INT habs_den = hden, htwice;
830
831         /* Get absolute values.  */
832         if (*hrem < 0)
833           neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
834         if (hden < 0)
835           neg_double (lden, hden, &labs_den, &habs_den);
836
837         /* If (2 * abs (lrem) >= abs (lden)) */
838         mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
839                     labs_rem, habs_rem, &ltwice, &htwice);
840
841         if (((unsigned HOST_WIDE_INT) habs_den
842              < (unsigned HOST_WIDE_INT) htwice)
843             || (((unsigned HOST_WIDE_INT) habs_den
844                  == (unsigned HOST_WIDE_INT) htwice)
845                 && (labs_den < ltwice)))
846           {
847             if (*hquo < 0)
848               /* quo = quo - 1;  */
849               add_double (*lquo, *hquo,
850                           (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
851             else
852               /* quo = quo + 1; */
853               add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
854                           lquo, hquo);
855           }
856         else
857           return overflow;
858       }
859       break;
860
861     default:
862       gcc_unreachable ();
863     }
864
865   /* Compute true remainder:  rem = num - (quo * den)  */
866   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
867   neg_double (*lrem, *hrem, lrem, hrem);
868   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
869   return overflow;
870 }
871
872 /* If ARG2 divides ARG1 with zero remainder, carries out the division
873    of type CODE and returns the quotient.
874    Otherwise returns NULL_TREE.  */
875
876 static tree
877 div_if_zero_remainder (enum tree_code code, const_tree arg1, const_tree arg2)
878 {
879   unsigned HOST_WIDE_INT int1l, int2l;
880   HOST_WIDE_INT int1h, int2h;
881   unsigned HOST_WIDE_INT quol, reml;
882   HOST_WIDE_INT quoh, remh;
883   tree type = TREE_TYPE (arg1);
884   int uns = TYPE_UNSIGNED (type);
885
886   int1l = TREE_INT_CST_LOW (arg1);
887   int1h = TREE_INT_CST_HIGH (arg1);
888   /* &obj[0] + -128 really should be compiled as &obj[-8] rather than
889      &obj[some_exotic_number].  */
890   if (POINTER_TYPE_P (type))
891     {
892       uns = false;
893       type = signed_type_for (type);
894       fit_double_type (int1l, int1h, &int1l, &int1h,
895                        type);
896     }
897   else
898     fit_double_type (int1l, int1h, &int1l, &int1h, type);
899   int2l = TREE_INT_CST_LOW (arg2);
900   int2h = TREE_INT_CST_HIGH (arg2);
901
902   div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
903                         &quol, &quoh, &reml, &remh);
904   if (remh != 0 || reml != 0)
905     return NULL_TREE;
906
907   return build_int_cst_wide (type, quol, quoh);
908 }
909 \f
910 /* This is nonzero if we should defer warnings about undefined
911    overflow.  This facility exists because these warnings are a
912    special case.  The code to estimate loop iterations does not want
913    to issue any warnings, since it works with expressions which do not
914    occur in user code.  Various bits of cleanup code call fold(), but
915    only use the result if it has certain characteristics (e.g., is a
916    constant); that code only wants to issue a warning if the result is
917    used.  */
918
919 static int fold_deferring_overflow_warnings;
920
921 /* If a warning about undefined overflow is deferred, this is the
922    warning.  Note that this may cause us to turn two warnings into
923    one, but that is fine since it is sufficient to only give one
924    warning per expression.  */
925
926 static const char* fold_deferred_overflow_warning;
927
928 /* If a warning about undefined overflow is deferred, this is the
929    level at which the warning should be emitted.  */
930
931 static enum warn_strict_overflow_code fold_deferred_overflow_code;
932
933 /* Start deferring overflow warnings.  We could use a stack here to
934    permit nested calls, but at present it is not necessary.  */
935
936 void
937 fold_defer_overflow_warnings (void)
938 {
939   ++fold_deferring_overflow_warnings;
940 }
941
942 /* Stop deferring overflow warnings.  If there is a pending warning,
943    and ISSUE is true, then issue the warning if appropriate.  STMT is
944    the statement with which the warning should be associated (used for
945    location information); STMT may be NULL.  CODE is the level of the
946    warning--a warn_strict_overflow_code value.  This function will use
947    the smaller of CODE and the deferred code when deciding whether to
948    issue the warning.  CODE may be zero to mean to always use the
949    deferred code.  */
950
951 void
952 fold_undefer_overflow_warnings (bool issue, const_tree stmt, int code)
953 {
954   const char *warnmsg;
955   location_t locus;
956
957   gcc_assert (fold_deferring_overflow_warnings > 0);
958   --fold_deferring_overflow_warnings;
959   if (fold_deferring_overflow_warnings > 0)
960     {
961       if (fold_deferred_overflow_warning != NULL
962           && code != 0
963           && code < (int) fold_deferred_overflow_code)
964         fold_deferred_overflow_code = code;
965       return;
966     }
967
968   warnmsg = fold_deferred_overflow_warning;
969   fold_deferred_overflow_warning = NULL;
970
971   if (!issue || warnmsg == NULL)
972     return;
973
974   if (stmt != NULL_TREE && TREE_NO_WARNING (stmt))
975     return;
976
977   /* Use the smallest code level when deciding to issue the
978      warning.  */
979   if (code == 0 || code > (int) fold_deferred_overflow_code)
980     code = fold_deferred_overflow_code;
981
982   if (!issue_strict_overflow_warning (code))
983     return;
984
985   if (stmt == NULL_TREE || !expr_has_location (stmt))
986     locus = input_location;
987   else
988     locus = expr_location (stmt);
989   warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg);
990 }
991
992 /* Stop deferring overflow warnings, ignoring any deferred
993    warnings.  */
994
995 void
996 fold_undefer_and_ignore_overflow_warnings (void)
997 {
998   fold_undefer_overflow_warnings (false, NULL_TREE, 0);
999 }
1000
1001 /* Whether we are deferring overflow warnings.  */
1002
1003 bool
1004 fold_deferring_overflow_warnings_p (void)
1005 {
1006   return fold_deferring_overflow_warnings > 0;
1007 }
1008
1009 /* This is called when we fold something based on the fact that signed
1010    overflow is undefined.  */
1011
1012 static void
1013 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
1014 {
1015   gcc_assert (!flag_wrapv && !flag_trapv);
1016   if (fold_deferring_overflow_warnings > 0)
1017     {
1018       if (fold_deferred_overflow_warning == NULL
1019           || wc < fold_deferred_overflow_code)
1020         {
1021           fold_deferred_overflow_warning = gmsgid;
1022           fold_deferred_overflow_code = wc;
1023         }
1024     }
1025   else if (issue_strict_overflow_warning (wc))
1026     warning (OPT_Wstrict_overflow, gmsgid);
1027 }
1028 \f
1029 /* Return true if the built-in mathematical function specified by CODE
1030    is odd, i.e. -f(x) == f(-x).  */
1031
1032 static bool
1033 negate_mathfn_p (enum built_in_function code)
1034 {
1035   switch (code)
1036     {
1037     CASE_FLT_FN (BUILT_IN_ASIN):
1038     CASE_FLT_FN (BUILT_IN_ASINH):
1039     CASE_FLT_FN (BUILT_IN_ATAN):
1040     CASE_FLT_FN (BUILT_IN_ATANH):
1041     CASE_FLT_FN (BUILT_IN_CASIN):
1042     CASE_FLT_FN (BUILT_IN_CASINH):
1043     CASE_FLT_FN (BUILT_IN_CATAN):
1044     CASE_FLT_FN (BUILT_IN_CATANH):
1045     CASE_FLT_FN (BUILT_IN_CBRT):
1046     CASE_FLT_FN (BUILT_IN_CPROJ):
1047     CASE_FLT_FN (BUILT_IN_CSIN):
1048     CASE_FLT_FN (BUILT_IN_CSINH):
1049     CASE_FLT_FN (BUILT_IN_CTAN):
1050     CASE_FLT_FN (BUILT_IN_CTANH):
1051     CASE_FLT_FN (BUILT_IN_ERF):
1052     CASE_FLT_FN (BUILT_IN_LLROUND):
1053     CASE_FLT_FN (BUILT_IN_LROUND):
1054     CASE_FLT_FN (BUILT_IN_ROUND):
1055     CASE_FLT_FN (BUILT_IN_SIN):
1056     CASE_FLT_FN (BUILT_IN_SINH):
1057     CASE_FLT_FN (BUILT_IN_TAN):
1058     CASE_FLT_FN (BUILT_IN_TANH):
1059     CASE_FLT_FN (BUILT_IN_TRUNC):
1060       return true;
1061
1062     CASE_FLT_FN (BUILT_IN_LLRINT):
1063     CASE_FLT_FN (BUILT_IN_LRINT):
1064     CASE_FLT_FN (BUILT_IN_NEARBYINT):
1065     CASE_FLT_FN (BUILT_IN_RINT):
1066       return !flag_rounding_math;
1067     
1068     default:
1069       break;
1070     }
1071   return false;
1072 }
1073
1074 /* Check whether we may negate an integer constant T without causing
1075    overflow.  */
1076
1077 bool
1078 may_negate_without_overflow_p (const_tree t)
1079 {
1080   unsigned HOST_WIDE_INT val;
1081   unsigned int prec;
1082   tree type;
1083
1084   gcc_assert (TREE_CODE (t) == INTEGER_CST);
1085
1086   type = TREE_TYPE (t);
1087   if (TYPE_UNSIGNED (type))
1088     return false;
1089
1090   prec = TYPE_PRECISION (type);
1091   if (prec > HOST_BITS_PER_WIDE_INT)
1092     {
1093       if (TREE_INT_CST_LOW (t) != 0)
1094         return true;
1095       prec -= HOST_BITS_PER_WIDE_INT;
1096       val = TREE_INT_CST_HIGH (t);
1097     }
1098   else
1099     val = TREE_INT_CST_LOW (t);
1100   if (prec < HOST_BITS_PER_WIDE_INT)
1101     val &= ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1102   return val != ((unsigned HOST_WIDE_INT) 1 << (prec - 1));
1103 }
1104
1105 /* Determine whether an expression T can be cheaply negated using
1106    the function negate_expr without introducing undefined overflow.  */
1107
1108 static bool
1109 negate_expr_p (tree t)
1110 {
1111   tree type;
1112
1113   if (t == 0)
1114     return false;
1115
1116   type = TREE_TYPE (t);
1117
1118   STRIP_SIGN_NOPS (t);
1119   switch (TREE_CODE (t))
1120     {
1121     case INTEGER_CST:
1122       if (TYPE_OVERFLOW_WRAPS (type))
1123         return true;
1124
1125       /* Check that -CST will not overflow type.  */
1126       return may_negate_without_overflow_p (t);
1127     case BIT_NOT_EXPR:
1128       return (INTEGRAL_TYPE_P (type)
1129               && TYPE_OVERFLOW_WRAPS (type));
1130
1131     case FIXED_CST:
1132     case REAL_CST:
1133     case NEGATE_EXPR:
1134       return true;
1135
1136     case COMPLEX_CST:
1137       return negate_expr_p (TREE_REALPART (t))
1138              && negate_expr_p (TREE_IMAGPART (t));
1139
1140     case COMPLEX_EXPR:
1141       return negate_expr_p (TREE_OPERAND (t, 0))
1142              && negate_expr_p (TREE_OPERAND (t, 1));
1143
1144     case CONJ_EXPR:
1145       return negate_expr_p (TREE_OPERAND (t, 0));
1146
1147     case PLUS_EXPR:
1148       if (HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1149           || HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
1150         return false;
1151       /* -(A + B) -> (-B) - A.  */
1152       if (negate_expr_p (TREE_OPERAND (t, 1))
1153           && reorder_operands_p (TREE_OPERAND (t, 0),
1154                                  TREE_OPERAND (t, 1)))
1155         return true;
1156       /* -(A + B) -> (-A) - B.  */
1157       return negate_expr_p (TREE_OPERAND (t, 0));
1158
1159     case MINUS_EXPR:
1160       /* We can't turn -(A-B) into B-A when we honor signed zeros.  */
1161       return !HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1162              && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
1163              && reorder_operands_p (TREE_OPERAND (t, 0),
1164                                     TREE_OPERAND (t, 1));
1165
1166     case MULT_EXPR:
1167       if (TYPE_UNSIGNED (TREE_TYPE (t)))
1168         break;
1169
1170       /* Fall through.  */
1171
1172     case RDIV_EXPR:
1173       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
1174         return negate_expr_p (TREE_OPERAND (t, 1))
1175                || negate_expr_p (TREE_OPERAND (t, 0));
1176       break;
1177
1178     case TRUNC_DIV_EXPR:
1179     case ROUND_DIV_EXPR:
1180     case FLOOR_DIV_EXPR:
1181     case CEIL_DIV_EXPR:
1182     case EXACT_DIV_EXPR:
1183       /* In general we can't negate A / B, because if A is INT_MIN and
1184          B is 1, we may turn this into INT_MIN / -1 which is undefined
1185          and actually traps on some architectures.  But if overflow is
1186          undefined, we can negate, because - (INT_MIN / 1) is an
1187          overflow.  */
1188       if (INTEGRAL_TYPE_P (TREE_TYPE (t))
1189           && !TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (t)))
1190         break;
1191       return negate_expr_p (TREE_OPERAND (t, 1))
1192              || negate_expr_p (TREE_OPERAND (t, 0));
1193
1194     case NOP_EXPR:
1195       /* Negate -((double)float) as (double)(-float).  */
1196       if (TREE_CODE (type) == REAL_TYPE)
1197         {
1198           tree tem = strip_float_extensions (t);
1199           if (tem != t)
1200             return negate_expr_p (tem);
1201         }
1202       break;
1203
1204     case CALL_EXPR:
1205       /* Negate -f(x) as f(-x).  */
1206       if (negate_mathfn_p (builtin_mathfn_code (t)))
1207         return negate_expr_p (CALL_EXPR_ARG (t, 0));
1208       break;
1209
1210     case RSHIFT_EXPR:
1211       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1212       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1213         {
1214           tree op1 = TREE_OPERAND (t, 1);
1215           if (TREE_INT_CST_HIGH (op1) == 0
1216               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1217                  == TREE_INT_CST_LOW (op1))
1218             return true;
1219         }
1220       break;
1221
1222     default:
1223       break;
1224     }
1225   return false;
1226 }
1227
1228 /* Given T, an expression, return a folded tree for -T or NULL_TREE, if no
1229    simplification is possible.
1230    If negate_expr_p would return true for T, NULL_TREE will never be
1231    returned.  */
1232
1233 static tree
1234 fold_negate_expr (tree t)
1235 {
1236   tree type = TREE_TYPE (t);
1237   tree tem;
1238
1239   switch (TREE_CODE (t))
1240     {
1241     /* Convert - (~A) to A + 1.  */
1242     case BIT_NOT_EXPR:
1243       if (INTEGRAL_TYPE_P (type))
1244         return fold_build2 (PLUS_EXPR, type, TREE_OPERAND (t, 0),
1245                             build_int_cst (type, 1));
1246       break;
1247       
1248     case INTEGER_CST:
1249       tem = fold_negate_const (t, type);
1250       if (TREE_OVERFLOW (tem) == TREE_OVERFLOW (t)
1251           || !TYPE_OVERFLOW_TRAPS (type))
1252         return tem;
1253       break;
1254
1255     case REAL_CST:
1256       tem = fold_negate_const (t, type);
1257       /* Two's complement FP formats, such as c4x, may overflow.  */
1258       if (!TREE_OVERFLOW (tem) || !flag_trapping_math)
1259         return tem;
1260       break;
1261
1262     case FIXED_CST:
1263       tem = fold_negate_const (t, type);
1264       return tem;
1265
1266     case COMPLEX_CST:
1267       {
1268         tree rpart = negate_expr (TREE_REALPART (t));
1269         tree ipart = negate_expr (TREE_IMAGPART (t));
1270
1271         if ((TREE_CODE (rpart) == REAL_CST
1272              && TREE_CODE (ipart) == REAL_CST)
1273             || (TREE_CODE (rpart) == INTEGER_CST
1274                 && TREE_CODE (ipart) == INTEGER_CST))
1275           return build_complex (type, rpart, ipart);
1276       }
1277       break;
1278
1279     case COMPLEX_EXPR:
1280       if (negate_expr_p (t))
1281         return fold_build2 (COMPLEX_EXPR, type,
1282                             fold_negate_expr (TREE_OPERAND (t, 0)),
1283                             fold_negate_expr (TREE_OPERAND (t, 1)));
1284       break;
1285       
1286     case CONJ_EXPR:
1287       if (negate_expr_p (t))
1288         return fold_build1 (CONJ_EXPR, type,
1289                             fold_negate_expr (TREE_OPERAND (t, 0)));
1290       break;
1291
1292     case NEGATE_EXPR:
1293       return TREE_OPERAND (t, 0);
1294
1295     case PLUS_EXPR:
1296       if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1297           && !HONOR_SIGNED_ZEROS (TYPE_MODE (type)))
1298         {
1299           /* -(A + B) -> (-B) - A.  */
1300           if (negate_expr_p (TREE_OPERAND (t, 1))
1301               && reorder_operands_p (TREE_OPERAND (t, 0),
1302                                      TREE_OPERAND (t, 1)))
1303             {
1304               tem = negate_expr (TREE_OPERAND (t, 1));
1305               return fold_build2 (MINUS_EXPR, type,
1306                                   tem, TREE_OPERAND (t, 0));
1307             }
1308
1309           /* -(A + B) -> (-A) - B.  */
1310           if (negate_expr_p (TREE_OPERAND (t, 0)))
1311             {
1312               tem = negate_expr (TREE_OPERAND (t, 0));
1313               return fold_build2 (MINUS_EXPR, type,
1314                                   tem, TREE_OPERAND (t, 1));
1315             }
1316         }
1317       break;
1318
1319     case MINUS_EXPR:
1320       /* - (A - B) -> B - A  */
1321       if (!HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type))
1322           && !HONOR_SIGNED_ZEROS (TYPE_MODE (type))
1323           && reorder_operands_p (TREE_OPERAND (t, 0), TREE_OPERAND (t, 1)))
1324         return fold_build2 (MINUS_EXPR, type,
1325                             TREE_OPERAND (t, 1), TREE_OPERAND (t, 0));
1326       break;
1327
1328     case MULT_EXPR:
1329       if (TYPE_UNSIGNED (type))
1330         break;
1331
1332       /* Fall through.  */
1333
1334     case RDIV_EXPR:
1335       if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (type)))
1336         {
1337           tem = TREE_OPERAND (t, 1);
1338           if (negate_expr_p (tem))
1339             return fold_build2 (TREE_CODE (t), type,
1340                                 TREE_OPERAND (t, 0), negate_expr (tem));
1341           tem = TREE_OPERAND (t, 0);
1342           if (negate_expr_p (tem))
1343             return fold_build2 (TREE_CODE (t), type,
1344                                 negate_expr (tem), TREE_OPERAND (t, 1));
1345         }
1346       break;
1347
1348     case TRUNC_DIV_EXPR:
1349     case ROUND_DIV_EXPR:
1350     case FLOOR_DIV_EXPR:
1351     case CEIL_DIV_EXPR:
1352     case EXACT_DIV_EXPR:
1353       /* In general we can't negate A / B, because if A is INT_MIN and
1354          B is 1, we may turn this into INT_MIN / -1 which is undefined
1355          and actually traps on some architectures.  But if overflow is
1356          undefined, we can negate, because - (INT_MIN / 1) is an
1357          overflow.  */
1358       if (!INTEGRAL_TYPE_P (type) || TYPE_OVERFLOW_UNDEFINED (type))
1359         {
1360           const char * const warnmsg = G_("assuming signed overflow does not "
1361                                           "occur when negating a division");
1362           tem = TREE_OPERAND (t, 1);
1363           if (negate_expr_p (tem))
1364             {
1365               if (INTEGRAL_TYPE_P (type)
1366                   && (TREE_CODE (tem) != INTEGER_CST
1367                       || integer_onep (tem)))
1368                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
1369               return fold_build2 (TREE_CODE (t), type,
1370                                   TREE_OPERAND (t, 0), negate_expr (tem));
1371             }
1372           tem = TREE_OPERAND (t, 0);
1373           if (negate_expr_p (tem))
1374             {
1375               if (INTEGRAL_TYPE_P (type)
1376                   && (TREE_CODE (tem) != INTEGER_CST
1377                       || tree_int_cst_equal (tem, TYPE_MIN_VALUE (type))))
1378                 fold_overflow_warning (warnmsg, WARN_STRICT_OVERFLOW_MISC);
1379               return fold_build2 (TREE_CODE (t), type,
1380                                   negate_expr (tem), TREE_OPERAND (t, 1));
1381             }
1382         }
1383       break;
1384
1385     case NOP_EXPR:
1386       /* Convert -((double)float) into (double)(-float).  */
1387       if (TREE_CODE (type) == REAL_TYPE)
1388         {
1389           tem = strip_float_extensions (t);
1390           if (tem != t && negate_expr_p (tem))
1391             return fold_convert (type, negate_expr (tem));
1392         }
1393       break;
1394
1395     case CALL_EXPR:
1396       /* Negate -f(x) as f(-x).  */
1397       if (negate_mathfn_p (builtin_mathfn_code (t))
1398           && negate_expr_p (CALL_EXPR_ARG (t, 0)))
1399         {
1400           tree fndecl, arg;
1401
1402           fndecl = get_callee_fndecl (t);
1403           arg = negate_expr (CALL_EXPR_ARG (t, 0));
1404           return build_call_expr (fndecl, 1, arg);
1405         }
1406       break;
1407
1408     case RSHIFT_EXPR:
1409       /* Optimize -((int)x >> 31) into (unsigned)x >> 31.  */
1410       if (TREE_CODE (TREE_OPERAND (t, 1)) == INTEGER_CST)
1411         {
1412           tree op1 = TREE_OPERAND (t, 1);
1413           if (TREE_INT_CST_HIGH (op1) == 0
1414               && (unsigned HOST_WIDE_INT) (TYPE_PRECISION (type) - 1)
1415                  == TREE_INT_CST_LOW (op1))
1416             {
1417               tree ntype = TYPE_UNSIGNED (type)
1418                            ? signed_type_for (type)
1419                            : unsigned_type_for (type);
1420               tree temp = fold_convert (ntype, TREE_OPERAND (t, 0));
1421               temp = fold_build2 (RSHIFT_EXPR, ntype, temp, op1);
1422               return fold_convert (type, temp);
1423             }
1424         }
1425       break;
1426
1427     default:
1428       break;
1429     }
1430
1431   return NULL_TREE;
1432 }
1433
1434 /* Like fold_negate_expr, but return a NEGATE_EXPR tree, if T can not be
1435    negated in a simpler way.  Also allow for T to be NULL_TREE, in which case
1436    return NULL_TREE. */
1437
1438 static tree
1439 negate_expr (tree t)
1440 {
1441   tree type, tem;
1442
1443   if (t == NULL_TREE)
1444     return NULL_TREE;
1445
1446   type = TREE_TYPE (t);
1447   STRIP_SIGN_NOPS (t);
1448
1449   tem = fold_negate_expr (t);
1450   if (!tem)
1451     tem = build1 (NEGATE_EXPR, TREE_TYPE (t), t);
1452   return fold_convert (type, tem);
1453 }
1454 \f
1455 /* Split a tree IN into a constant, literal and variable parts that could be
1456    combined with CODE to make IN.  "constant" means an expression with
1457    TREE_CONSTANT but that isn't an actual constant.  CODE must be a
1458    commutative arithmetic operation.  Store the constant part into *CONP,
1459    the literal in *LITP and return the variable part.  If a part isn't
1460    present, set it to null.  If the tree does not decompose in this way,
1461    return the entire tree as the variable part and the other parts as null.
1462
1463    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.  In that
1464    case, we negate an operand that was subtracted.  Except if it is a
1465    literal for which we use *MINUS_LITP instead.
1466
1467    If NEGATE_P is true, we are negating all of IN, again except a literal
1468    for which we use *MINUS_LITP instead.
1469
1470    If IN is itself a literal or constant, return it as appropriate.
1471
1472    Note that we do not guarantee that any of the three values will be the
1473    same type as IN, but they will have the same signedness and mode.  */
1474
1475 static tree
1476 split_tree (tree in, enum tree_code code, tree *conp, tree *litp,
1477             tree *minus_litp, int negate_p)
1478 {
1479   tree var = 0;
1480
1481   *conp = 0;
1482   *litp = 0;
1483   *minus_litp = 0;
1484
1485   /* Strip any conversions that don't change the machine mode or signedness.  */
1486   STRIP_SIGN_NOPS (in);
1487
1488   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST
1489       || TREE_CODE (in) == FIXED_CST)
1490     *litp = in;
1491   else if (TREE_CODE (in) == code
1492            || ((! FLOAT_TYPE_P (TREE_TYPE (in)) || flag_associative_math)
1493                && ! SAT_FIXED_POINT_TYPE_P (TREE_TYPE (in))
1494                /* We can associate addition and subtraction together (even
1495                   though the C standard doesn't say so) for integers because
1496                   the value is not affected.  For reals, the value might be
1497                   affected, so we can't.  */
1498                && ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
1499                    || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
1500     {
1501       tree op0 = TREE_OPERAND (in, 0);
1502       tree op1 = TREE_OPERAND (in, 1);
1503       int neg1_p = TREE_CODE (in) == MINUS_EXPR;
1504       int neg_litp_p = 0, neg_conp_p = 0, neg_var_p = 0;
1505
1506       /* First see if either of the operands is a literal, then a constant.  */
1507       if (TREE_CODE (op0) == INTEGER_CST || TREE_CODE (op0) == REAL_CST
1508           || TREE_CODE (op0) == FIXED_CST)
1509         *litp = op0, op0 = 0;
1510       else if (TREE_CODE (op1) == INTEGER_CST || TREE_CODE (op1) == REAL_CST
1511                || TREE_CODE (op1) == FIXED_CST)
1512         *litp = op1, neg_litp_p = neg1_p, op1 = 0;
1513
1514       if (op0 != 0 && TREE_CONSTANT (op0))
1515         *conp = op0, op0 = 0;
1516       else if (op1 != 0 && TREE_CONSTANT (op1))
1517         *conp = op1, neg_conp_p = neg1_p, op1 = 0;
1518
1519       /* If we haven't dealt with either operand, this is not a case we can
1520          decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
1521       if (op0 != 0 && op1 != 0)
1522         var = in;
1523       else if (op0 != 0)
1524         var = op0;
1525       else
1526         var = op1, neg_var_p = neg1_p;
1527
1528       /* Now do any needed negations.  */
1529       if (neg_litp_p)
1530         *minus_litp = *litp, *litp = 0;
1531       if (neg_conp_p)
1532         *conp = negate_expr (*conp);
1533       if (neg_var_p)
1534         var = negate_expr (var);
1535     }
1536   else if (TREE_CONSTANT (in))
1537     *conp = in;
1538   else
1539     var = in;
1540
1541   if (negate_p)
1542     {
1543       if (*litp)
1544         *minus_litp = *litp, *litp = 0;
1545       else if (*minus_litp)
1546         *litp = *minus_litp, *minus_litp = 0;
1547       *conp = negate_expr (*conp);
1548       var = negate_expr (var);
1549     }
1550
1551   return var;
1552 }
1553
1554 /* Re-associate trees split by the above function.  T1 and T2 are either
1555    expressions to associate or null.  Return the new expression, if any.  If
1556    we build an operation, do it in TYPE and with CODE.  */
1557
1558 static tree
1559 associate_trees (tree t1, tree t2, enum tree_code code, tree type)
1560 {
1561   if (t1 == 0)
1562     return t2;
1563   else if (t2 == 0)
1564     return t1;
1565
1566   /* If either input is CODE, a PLUS_EXPR, or a MINUS_EXPR, don't
1567      try to fold this since we will have infinite recursion.  But do
1568      deal with any NEGATE_EXPRs.  */
1569   if (TREE_CODE (t1) == code || TREE_CODE (t2) == code
1570       || TREE_CODE (t1) == MINUS_EXPR || TREE_CODE (t2) == MINUS_EXPR)
1571     {
1572       if (code == PLUS_EXPR)
1573         {
1574           if (TREE_CODE (t1) == NEGATE_EXPR)
1575             return build2 (MINUS_EXPR, type, fold_convert (type, t2),
1576                            fold_convert (type, TREE_OPERAND (t1, 0)));
1577           else if (TREE_CODE (t2) == NEGATE_EXPR)
1578             return build2 (MINUS_EXPR, type, fold_convert (type, t1),
1579                            fold_convert (type, TREE_OPERAND (t2, 0)));
1580           else if (integer_zerop (t2))
1581             return fold_convert (type, t1);
1582         }
1583       else if (code == MINUS_EXPR)
1584         {
1585           if (integer_zerop (t2))
1586             return fold_convert (type, t1);
1587         }
1588
1589       return build2 (code, type, fold_convert (type, t1),
1590                      fold_convert (type, t2));
1591     }
1592
1593   return fold_build2 (code, type, fold_convert (type, t1),
1594                       fold_convert (type, t2));
1595 }
1596 \f
1597 /* Check whether TYPE1 and TYPE2 are equivalent integer types, suitable
1598    for use in int_const_binop, size_binop and size_diffop.  */
1599
1600 static bool
1601 int_binop_types_match_p (enum tree_code code, const_tree type1, const_tree type2)
1602 {
1603   if (TREE_CODE (type1) != INTEGER_TYPE && !POINTER_TYPE_P (type1))
1604     return false;
1605   if (TREE_CODE (type2) != INTEGER_TYPE && !POINTER_TYPE_P (type2))
1606     return false;
1607
1608   switch (code)
1609     {
1610     case LSHIFT_EXPR:
1611     case RSHIFT_EXPR:
1612     case LROTATE_EXPR:
1613     case RROTATE_EXPR:
1614       return true;
1615
1616     default:
1617       break;
1618     }
1619
1620   return TYPE_UNSIGNED (type1) == TYPE_UNSIGNED (type2)
1621          && TYPE_PRECISION (type1) == TYPE_PRECISION (type2)
1622          && TYPE_MODE (type1) == TYPE_MODE (type2);
1623 }
1624
1625
1626 /* Combine two integer constants ARG1 and ARG2 under operation CODE
1627    to produce a new constant.  Return NULL_TREE if we don't know how
1628    to evaluate CODE at compile-time.
1629
1630    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1631
1632 tree
1633 int_const_binop (enum tree_code code, const_tree arg1, const_tree arg2, int notrunc)
1634 {
1635   unsigned HOST_WIDE_INT int1l, int2l;
1636   HOST_WIDE_INT int1h, int2h;
1637   unsigned HOST_WIDE_INT low;
1638   HOST_WIDE_INT hi;
1639   unsigned HOST_WIDE_INT garbagel;
1640   HOST_WIDE_INT garbageh;
1641   tree t;
1642   tree type = TREE_TYPE (arg1);
1643   int uns = TYPE_UNSIGNED (type);
1644   int is_sizetype
1645     = (TREE_CODE (type) == INTEGER_TYPE && TYPE_IS_SIZETYPE (type));
1646   int overflow = 0;
1647
1648   int1l = TREE_INT_CST_LOW (arg1);
1649   int1h = TREE_INT_CST_HIGH (arg1);
1650   int2l = TREE_INT_CST_LOW (arg2);
1651   int2h = TREE_INT_CST_HIGH (arg2);
1652
1653   switch (code)
1654     {
1655     case BIT_IOR_EXPR:
1656       low = int1l | int2l, hi = int1h | int2h;
1657       break;
1658
1659     case BIT_XOR_EXPR:
1660       low = int1l ^ int2l, hi = int1h ^ int2h;
1661       break;
1662
1663     case BIT_AND_EXPR:
1664       low = int1l & int2l, hi = int1h & int2h;
1665       break;
1666
1667     case RSHIFT_EXPR:
1668       int2l = -int2l;
1669     case LSHIFT_EXPR:
1670       /* It's unclear from the C standard whether shifts can overflow.
1671          The following code ignores overflow; perhaps a C standard
1672          interpretation ruling is needed.  */
1673       lshift_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1674                      &low, &hi, !uns);
1675       break;
1676
1677     case RROTATE_EXPR:
1678       int2l = - int2l;
1679     case LROTATE_EXPR:
1680       lrotate_double (int1l, int1h, int2l, TYPE_PRECISION (type),
1681                       &low, &hi);
1682       break;
1683
1684     case PLUS_EXPR:
1685       overflow = add_double (int1l, int1h, int2l, int2h, &low, &hi);
1686       break;
1687
1688     case MINUS_EXPR:
1689       neg_double (int2l, int2h, &low, &hi);
1690       add_double (int1l, int1h, low, hi, &low, &hi);
1691       overflow = OVERFLOW_SUM_SIGN (hi, int2h, int1h);
1692       break;
1693
1694     case MULT_EXPR:
1695       overflow = mul_double (int1l, int1h, int2l, int2h, &low, &hi);
1696       break;
1697
1698     case TRUNC_DIV_EXPR:
1699     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
1700     case EXACT_DIV_EXPR:
1701       /* This is a shortcut for a common special case.  */
1702       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1703           && !TREE_OVERFLOW (arg1)
1704           && !TREE_OVERFLOW (arg2)
1705           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1706         {
1707           if (code == CEIL_DIV_EXPR)
1708             int1l += int2l - 1;
1709
1710           low = int1l / int2l, hi = 0;
1711           break;
1712         }
1713
1714       /* ... fall through ...  */
1715
1716     case ROUND_DIV_EXPR:
1717       if (int2h == 0 && int2l == 0)
1718         return NULL_TREE;
1719       if (int2h == 0 && int2l == 1)
1720         {
1721           low = int1l, hi = int1h;
1722           break;
1723         }
1724       if (int1l == int2l && int1h == int2h
1725           && ! (int1l == 0 && int1h == 0))
1726         {
1727           low = 1, hi = 0;
1728           break;
1729         }
1730       overflow = div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
1731                                        &low, &hi, &garbagel, &garbageh);
1732       break;
1733
1734     case TRUNC_MOD_EXPR:
1735     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
1736       /* This is a shortcut for a common special case.  */
1737       if (int2h == 0 && (HOST_WIDE_INT) int2l > 0
1738           && !TREE_OVERFLOW (arg1)
1739           && !TREE_OVERFLOW (arg2)
1740           && int1h == 0 && (HOST_WIDE_INT) int1l >= 0)
1741         {
1742           if (code == CEIL_MOD_EXPR)
1743             int1l += int2l - 1;
1744           low = int1l % int2l, hi = 0;
1745           break;
1746         }
1747
1748       /* ... fall through ...  */
1749
1750     case ROUND_MOD_EXPR:
1751       if (int2h == 0 && int2l == 0)
1752         return NULL_TREE;
1753       overflow = div_and_round_double (code, uns,
1754                                        int1l, int1h, int2l, int2h,
1755                                        &garbagel, &garbageh, &low, &hi);
1756       break;
1757
1758     case MIN_EXPR:
1759     case MAX_EXPR:
1760       if (uns)
1761         low = (((unsigned HOST_WIDE_INT) int1h
1762                 < (unsigned HOST_WIDE_INT) int2h)
1763                || (((unsigned HOST_WIDE_INT) int1h
1764                     == (unsigned HOST_WIDE_INT) int2h)
1765                    && int1l < int2l));
1766       else
1767         low = (int1h < int2h
1768                || (int1h == int2h && int1l < int2l));
1769
1770       if (low == (code == MIN_EXPR))
1771         low = int1l, hi = int1h;
1772       else
1773         low = int2l, hi = int2h;
1774       break;
1775
1776     default:
1777       return NULL_TREE;
1778     }
1779
1780   if (notrunc)
1781     {
1782       t = build_int_cst_wide (TREE_TYPE (arg1), low, hi);
1783
1784       /* Propagate overflow flags ourselves.  */
1785       if (((!uns || is_sizetype) && overflow)
1786           | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1787         {
1788           t = copy_node (t);
1789           TREE_OVERFLOW (t) = 1;
1790         }
1791     }
1792   else
1793     t = force_fit_type_double (TREE_TYPE (arg1), low, hi, 1,
1794                                ((!uns || is_sizetype) && overflow)
1795                                | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2));
1796
1797   return t;
1798 }
1799
1800 /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new
1801    constant.  We assume ARG1 and ARG2 have the same data type, or at least
1802    are the same kind of constant and the same machine mode.  Return zero if
1803    combining the constants is not allowed in the current operating mode.
1804
1805    If NOTRUNC is nonzero, do not truncate the result to fit the data type.  */
1806
1807 static tree
1808 const_binop (enum tree_code code, tree arg1, tree arg2, int notrunc)
1809 {
1810   /* Sanity check for the recursive cases.  */
1811   if (!arg1 || !arg2)
1812     return NULL_TREE;
1813
1814   STRIP_NOPS (arg1);
1815   STRIP_NOPS (arg2);
1816
1817   if (TREE_CODE (arg1) == INTEGER_CST)
1818     return int_const_binop (code, arg1, arg2, notrunc);
1819
1820   if (TREE_CODE (arg1) == REAL_CST)
1821     {
1822       enum machine_mode mode;
1823       REAL_VALUE_TYPE d1;
1824       REAL_VALUE_TYPE d2;
1825       REAL_VALUE_TYPE value;
1826       REAL_VALUE_TYPE result;
1827       bool inexact;
1828       tree t, type;
1829
1830       /* The following codes are handled by real_arithmetic.  */
1831       switch (code)
1832         {
1833         case PLUS_EXPR:
1834         case MINUS_EXPR:
1835         case MULT_EXPR:
1836         case RDIV_EXPR:
1837         case MIN_EXPR:
1838         case MAX_EXPR:
1839           break;
1840
1841         default:
1842           return NULL_TREE;
1843         }
1844
1845       d1 = TREE_REAL_CST (arg1);
1846       d2 = TREE_REAL_CST (arg2);
1847
1848       type = TREE_TYPE (arg1);
1849       mode = TYPE_MODE (type);
1850
1851       /* Don't perform operation if we honor signaling NaNs and
1852          either operand is a NaN.  */
1853       if (HONOR_SNANS (mode)
1854           && (REAL_VALUE_ISNAN (d1) || REAL_VALUE_ISNAN (d2)))
1855         return NULL_TREE;
1856
1857       /* Don't perform operation if it would raise a division
1858          by zero exception.  */
1859       if (code == RDIV_EXPR
1860           && REAL_VALUES_EQUAL (d2, dconst0)
1861           && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
1862         return NULL_TREE;
1863
1864       /* If either operand is a NaN, just return it.  Otherwise, set up
1865          for floating-point trap; we return an overflow.  */
1866       if (REAL_VALUE_ISNAN (d1))
1867         return arg1;
1868       else if (REAL_VALUE_ISNAN (d2))
1869         return arg2;
1870
1871       inexact = real_arithmetic (&value, code, &d1, &d2);
1872       real_convert (&result, mode, &value);
1873
1874       /* Don't constant fold this floating point operation if
1875          the result has overflowed and flag_trapping_math.  */
1876       if (flag_trapping_math
1877           && MODE_HAS_INFINITIES (mode)
1878           && REAL_VALUE_ISINF (result)
1879           && !REAL_VALUE_ISINF (d1)
1880           && !REAL_VALUE_ISINF (d2))
1881         return NULL_TREE;
1882
1883       /* Don't constant fold this floating point operation if the
1884          result may dependent upon the run-time rounding mode and
1885          flag_rounding_math is set, or if GCC's software emulation
1886          is unable to accurately represent the result.  */
1887       if ((flag_rounding_math
1888            || (REAL_MODE_FORMAT_COMPOSITE_P (mode)
1889                && !flag_unsafe_math_optimizations))
1890           && (inexact || !real_identical (&result, &value)))
1891         return NULL_TREE;
1892
1893       t = build_real (type, result);
1894
1895       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1896       return t;
1897     }
1898
1899   if (TREE_CODE (arg1) == FIXED_CST)
1900     {
1901       FIXED_VALUE_TYPE f1;
1902       FIXED_VALUE_TYPE f2;
1903       FIXED_VALUE_TYPE result;
1904       tree t, type;
1905       int sat_p;
1906       bool overflow_p;
1907
1908       /* The following codes are handled by fixed_arithmetic.  */
1909       switch (code)
1910         {
1911         case PLUS_EXPR:
1912         case MINUS_EXPR:
1913         case MULT_EXPR:
1914         case TRUNC_DIV_EXPR:
1915           f2 = TREE_FIXED_CST (arg2);
1916           break;
1917
1918         case LSHIFT_EXPR:
1919         case RSHIFT_EXPR:
1920           f2.data.high = TREE_INT_CST_HIGH (arg2);
1921           f2.data.low = TREE_INT_CST_LOW (arg2);
1922           f2.mode = SImode;
1923           break;
1924
1925         default:
1926           return NULL_TREE;
1927         }
1928
1929       f1 = TREE_FIXED_CST (arg1);
1930       type = TREE_TYPE (arg1);
1931       sat_p = TYPE_SATURATING (type);
1932       overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1933       t = build_fixed (type, result);
1934       /* Propagate overflow flags.  */
1935       if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1936         {
1937           TREE_OVERFLOW (t) = 1;
1938           TREE_CONSTANT_OVERFLOW (t) = 1;
1939         }
1940       else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
1941         TREE_CONSTANT_OVERFLOW (t) = 1;
1942       return t;
1943     }
1944
1945   if (TREE_CODE (arg1) == COMPLEX_CST)
1946     {
1947       tree type = TREE_TYPE (arg1);
1948       tree r1 = TREE_REALPART (arg1);
1949       tree i1 = TREE_IMAGPART (arg1);
1950       tree r2 = TREE_REALPART (arg2);
1951       tree i2 = TREE_IMAGPART (arg2);
1952       tree real, imag;
1953
1954       switch (code)
1955         {
1956         case PLUS_EXPR:
1957         case MINUS_EXPR:
1958           real = const_binop (code, r1, r2, notrunc);
1959           imag = const_binop (code, i1, i2, notrunc);
1960           break;
1961
1962         case MULT_EXPR:
1963           real = const_binop (MINUS_EXPR,
1964                               const_binop (MULT_EXPR, r1, r2, notrunc),
1965                               const_binop (MULT_EXPR, i1, i2, notrunc),
1966                               notrunc);
1967           imag = const_binop (PLUS_EXPR,
1968                               const_binop (MULT_EXPR, r1, i2, notrunc),
1969                               const_binop (MULT_EXPR, i1, r2, notrunc),
1970                               notrunc);
1971           break;
1972
1973         case RDIV_EXPR:
1974           {
1975             tree magsquared
1976               = const_binop (PLUS_EXPR,
1977                              const_binop (MULT_EXPR, r2, r2, notrunc),
1978                              const_binop (MULT_EXPR, i2, i2, notrunc),
1979                              notrunc);
1980             tree t1
1981               = const_binop (PLUS_EXPR,
1982                              const_binop (MULT_EXPR, r1, r2, notrunc),
1983                              const_binop (MULT_EXPR, i1, i2, notrunc),
1984                              notrunc);
1985             tree t2
1986               = const_binop (MINUS_EXPR,
1987                              const_binop (MULT_EXPR, i1, r2, notrunc),
1988                              const_binop (MULT_EXPR, r1, i2, notrunc),
1989                              notrunc);
1990
1991             if (INTEGRAL_TYPE_P (TREE_TYPE (r1)))
1992               code = TRUNC_DIV_EXPR;
1993
1994             real = const_binop (code, t1, magsquared, notrunc);
1995             imag = const_binop (code, t2, magsquared, notrunc);
1996           }
1997           break;
1998
1999         default:
2000           return NULL_TREE;
2001         }
2002
2003       if (real && imag)
2004         return build_complex (type, real, imag);
2005     }
2006
2007   return NULL_TREE;
2008 }
2009
2010 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
2011    indicates which particular sizetype to create.  */
2012
2013 tree
2014 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
2015 {
2016   return build_int_cst (sizetype_tab[(int) kind], number);
2017 }
2018 \f
2019 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
2020    is a tree code.  The type of the result is taken from the operands.
2021    Both must be equivalent integer types, ala int_binop_types_match_p.
2022    If the operands are constant, so is the result.  */
2023
2024 tree
2025 size_binop (enum tree_code code, tree arg0, tree arg1)
2026 {
2027   tree type = TREE_TYPE (arg0);
2028
2029   if (arg0 == error_mark_node || arg1 == error_mark_node)
2030     return error_mark_node;
2031
2032   gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
2033                                        TREE_TYPE (arg1)));
2034
2035   /* Handle the special case of two integer constants faster.  */
2036   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2037     {
2038       /* And some specific cases even faster than that.  */
2039       if (code == PLUS_EXPR)
2040         {
2041           if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
2042             return arg1;
2043           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
2044             return arg0;
2045         }
2046       else if (code == MINUS_EXPR)
2047         {
2048           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
2049             return arg0;
2050         }
2051       else if (code == MULT_EXPR)
2052         {
2053           if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
2054             return arg1;
2055         }
2056
2057       /* Handle general case of two integer constants.  */
2058       return int_const_binop (code, arg0, arg1, 0);
2059     }
2060
2061   return fold_build2 (code, type, arg0, arg1);
2062 }
2063
2064 /* Given two values, either both of sizetype or both of bitsizetype,
2065    compute the difference between the two values.  Return the value
2066    in signed type corresponding to the type of the operands.  */
2067
2068 tree
2069 size_diffop (tree arg0, tree arg1)
2070 {
2071   tree type = TREE_TYPE (arg0);
2072   tree ctype;
2073
2074   gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
2075                                        TREE_TYPE (arg1)));
2076
2077   /* If the type is already signed, just do the simple thing.  */
2078   if (!TYPE_UNSIGNED (type))
2079     return size_binop (MINUS_EXPR, arg0, arg1);
2080
2081   if (type == sizetype)
2082     ctype = ssizetype;
2083   else if (type == bitsizetype)
2084     ctype = sbitsizetype;
2085   else
2086     ctype = signed_type_for (type);
2087
2088   /* If either operand is not a constant, do the conversions to the signed
2089      type and subtract.  The hardware will do the right thing with any
2090      overflow in the subtraction.  */
2091   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
2092     return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
2093                        fold_convert (ctype, arg1));
2094
2095   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
2096      Otherwise, subtract the other way, convert to CTYPE (we know that can't
2097      overflow) and negate (which can't either).  Special-case a result
2098      of zero while we're here.  */
2099   if (tree_int_cst_equal (arg0, arg1))
2100     return build_int_cst (ctype, 0);
2101   else if (tree_int_cst_lt (arg1, arg0))
2102     return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
2103   else
2104     return size_binop (MINUS_EXPR, build_int_cst (ctype, 0),
2105                        fold_convert (ctype, size_binop (MINUS_EXPR,
2106                                                         arg1, arg0)));
2107 }
2108 \f
2109 /* A subroutine of fold_convert_const handling conversions of an
2110    INTEGER_CST to another integer type.  */
2111
2112 static tree
2113 fold_convert_const_int_from_int (tree type, const_tree arg1)
2114 {
2115   tree t;
2116
2117   /* Given an integer constant, make new constant with new type,
2118      appropriately sign-extended or truncated.  */
2119   t = force_fit_type_double (type, TREE_INT_CST_LOW (arg1),
2120                              TREE_INT_CST_HIGH (arg1),
2121                              /* Don't set the overflow when
2122                                 converting from a pointer,  */
2123                              !POINTER_TYPE_P (TREE_TYPE (arg1))
2124                              /* or to a sizetype with same signedness
2125                                 and the precision is unchanged.
2126                                 ???  sizetype is always sign-extended,
2127                                 but its signedness depends on the
2128                                 frontend.  Thus we see spurious overflows
2129                                 here if we do not check this.  */
2130                              && !((TYPE_PRECISION (TREE_TYPE (arg1))
2131                                    == TYPE_PRECISION (type))
2132                                   && (TYPE_UNSIGNED (TREE_TYPE (arg1))
2133                                       == TYPE_UNSIGNED (type))
2134                                   && ((TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
2135                                        && TYPE_IS_SIZETYPE (TREE_TYPE (arg1)))
2136                                       || (TREE_CODE (type) == INTEGER_TYPE
2137                                           && TYPE_IS_SIZETYPE (type)))),
2138                              (TREE_INT_CST_HIGH (arg1) < 0
2139                               && (TYPE_UNSIGNED (type)
2140                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
2141                              | TREE_OVERFLOW (arg1));
2142
2143   return t;
2144 }
2145
2146 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2147    to an integer type.  */
2148
2149 static tree
2150 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
2151 {
2152   int overflow = 0;
2153   tree t;
2154
2155   /* The following code implements the floating point to integer
2156      conversion rules required by the Java Language Specification,
2157      that IEEE NaNs are mapped to zero and values that overflow
2158      the target precision saturate, i.e. values greater than
2159      INT_MAX are mapped to INT_MAX, and values less than INT_MIN
2160      are mapped to INT_MIN.  These semantics are allowed by the
2161      C and C++ standards that simply state that the behavior of
2162      FP-to-integer conversion is unspecified upon overflow.  */
2163
2164   HOST_WIDE_INT high, low;
2165   REAL_VALUE_TYPE r;
2166   REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
2167
2168   switch (code)
2169     {
2170     case FIX_TRUNC_EXPR:
2171       real_trunc (&r, VOIDmode, &x);
2172       break;
2173
2174     default:
2175       gcc_unreachable ();
2176     }
2177
2178   /* If R is NaN, return zero and show we have an overflow.  */
2179   if (REAL_VALUE_ISNAN (r))
2180     {
2181       overflow = 1;
2182       high = 0;
2183       low = 0;
2184     }
2185
2186   /* See if R is less than the lower bound or greater than the
2187      upper bound.  */
2188
2189   if (! overflow)
2190     {
2191       tree lt = TYPE_MIN_VALUE (type);
2192       REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
2193       if (REAL_VALUES_LESS (r, l))
2194         {
2195           overflow = 1;
2196           high = TREE_INT_CST_HIGH (lt);
2197           low = TREE_INT_CST_LOW (lt);
2198         }
2199     }
2200
2201   if (! overflow)
2202     {
2203       tree ut = TYPE_MAX_VALUE (type);
2204       if (ut)
2205         {
2206           REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
2207           if (REAL_VALUES_LESS (u, r))
2208             {
2209               overflow = 1;
2210               high = TREE_INT_CST_HIGH (ut);
2211               low = TREE_INT_CST_LOW (ut);
2212             }
2213         }
2214     }
2215
2216   if (! overflow)
2217     REAL_VALUE_TO_INT (&low, &high, r);
2218
2219   t = force_fit_type_double (type, low, high, -1,
2220                              overflow | TREE_OVERFLOW (arg1));
2221   return t;
2222 }
2223
2224 /* A subroutine of fold_convert_const handling conversions of a
2225    FIXED_CST to an integer type.  */
2226
2227 static tree
2228 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
2229 {
2230   tree t;
2231   double_int temp, temp_trunc;
2232   unsigned int mode;
2233
2234   /* Right shift FIXED_CST to temp by fbit.  */
2235   temp = TREE_FIXED_CST (arg1).data;
2236   mode = TREE_FIXED_CST (arg1).mode;
2237   if (GET_MODE_FBIT (mode) < 2 * HOST_BITS_PER_WIDE_INT)
2238     {
2239       lshift_double (temp.low, temp.high,
2240                      - GET_MODE_FBIT (mode), 2 * HOST_BITS_PER_WIDE_INT,
2241                      &temp.low, &temp.high, SIGNED_FIXED_POINT_MODE_P (mode));
2242
2243       /* Left shift temp to temp_trunc by fbit.  */
2244       lshift_double (temp.low, temp.high,
2245                      GET_MODE_FBIT (mode), 2 * HOST_BITS_PER_WIDE_INT,
2246                      &temp_trunc.low, &temp_trunc.high,
2247                      SIGNED_FIXED_POINT_MODE_P (mode));
2248     }
2249   else
2250     {
2251       temp.low = 0;
2252       temp.high = 0;
2253       temp_trunc.low = 0;
2254       temp_trunc.high = 0;
2255     }
2256
2257   /* If FIXED_CST is negative, we need to round the value toward 0.
2258      By checking if the fractional bits are not zero to add 1 to temp.  */
2259   if (SIGNED_FIXED_POINT_MODE_P (mode) && temp_trunc.high < 0
2260       && !double_int_equal_p (TREE_FIXED_CST (arg1).data, temp_trunc))
2261     {
2262       double_int one;
2263       one.low = 1;
2264       one.high = 0;
2265       temp = double_int_add (temp, one);
2266     }
2267
2268   /* Given a fixed-point constant, make new constant with new type,
2269      appropriately sign-extended or truncated.  */
2270   t = force_fit_type_double (type, temp.low, temp.high, -1,
2271                              (temp.high < 0
2272                               && (TYPE_UNSIGNED (type)
2273                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
2274                              | TREE_OVERFLOW (arg1));
2275
2276   return t;
2277 }
2278
2279 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2280    to another floating point type.  */
2281
2282 static tree
2283 fold_convert_const_real_from_real (tree type, const_tree arg1)
2284 {
2285   REAL_VALUE_TYPE value;
2286   tree t;
2287
2288   real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
2289   t = build_real (type, value);
2290
2291   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2292   return t;
2293 }
2294
2295 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2296    to a floating point type.  */
2297
2298 static tree
2299 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
2300 {
2301   REAL_VALUE_TYPE value;
2302   tree t;
2303
2304   real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
2305   t = build_real (type, value);
2306
2307   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2308   TREE_CONSTANT_OVERFLOW (t)
2309     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2310   return t;
2311 }
2312
2313 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2314    to another fixed-point type.  */
2315
2316 static tree
2317 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
2318 {
2319   FIXED_VALUE_TYPE value;
2320   tree t;
2321   bool overflow_p;
2322
2323   overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
2324                               TYPE_SATURATING (type));
2325   t = build_fixed (type, value);
2326
2327   /* Propagate overflow flags.  */
2328   if (overflow_p | TREE_OVERFLOW (arg1))
2329     {
2330       TREE_OVERFLOW (t) = 1;
2331       TREE_CONSTANT_OVERFLOW (t) = 1;
2332     }
2333   else if (TREE_CONSTANT_OVERFLOW (arg1))
2334     TREE_CONSTANT_OVERFLOW (t) = 1;
2335   return t;
2336 }
2337
2338 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2339    to a fixed-point type.  */
2340
2341 static tree
2342 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
2343 {
2344   FIXED_VALUE_TYPE value;
2345   tree t;
2346   bool overflow_p;
2347
2348   overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
2349                                        TREE_INT_CST (arg1),
2350                                        TYPE_UNSIGNED (TREE_TYPE (arg1)),
2351                                        TYPE_SATURATING (type));
2352   t = build_fixed (type, value);
2353
2354   /* Propagate overflow flags.  */
2355   if (overflow_p | TREE_OVERFLOW (arg1))
2356     {
2357       TREE_OVERFLOW (t) = 1;
2358       TREE_CONSTANT_OVERFLOW (t) = 1;
2359     }
2360   else if (TREE_CONSTANT_OVERFLOW (arg1))
2361     TREE_CONSTANT_OVERFLOW (t) = 1;
2362   return t;
2363 }
2364
2365 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2366    to a fixed-point type.  */
2367
2368 static tree
2369 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
2370 {
2371   FIXED_VALUE_TYPE value;
2372   tree t;
2373   bool overflow_p;
2374
2375   overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
2376                                         &TREE_REAL_CST (arg1),
2377                                         TYPE_SATURATING (type));
2378   t = build_fixed (type, value);
2379
2380   /* Propagate overflow flags.  */
2381   if (overflow_p | TREE_OVERFLOW (arg1))
2382     {
2383       TREE_OVERFLOW (t) = 1;
2384       TREE_CONSTANT_OVERFLOW (t) = 1;
2385     }
2386   else if (TREE_CONSTANT_OVERFLOW (arg1))
2387     TREE_CONSTANT_OVERFLOW (t) = 1;
2388   return t;
2389 }
2390
2391 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2392    type TYPE.  If no simplification can be done return NULL_TREE.  */
2393
2394 static tree
2395 fold_convert_const (enum tree_code code, tree type, tree arg1)
2396 {
2397   if (TREE_TYPE (arg1) == type)
2398     return arg1;
2399
2400   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type))
2401     {
2402       if (TREE_CODE (arg1) == INTEGER_CST)
2403         return fold_convert_const_int_from_int (type, arg1);
2404       else if (TREE_CODE (arg1) == REAL_CST)
2405         return fold_convert_const_int_from_real (code, type, arg1);
2406       else if (TREE_CODE (arg1) == FIXED_CST)
2407         return fold_convert_const_int_from_fixed (type, arg1);
2408     }
2409   else if (TREE_CODE (type) == REAL_TYPE)
2410     {
2411       if (TREE_CODE (arg1) == INTEGER_CST)
2412         return build_real_from_int_cst (type, arg1);
2413       else if (TREE_CODE (arg1) == REAL_CST)
2414         return fold_convert_const_real_from_real (type, arg1);
2415       else if (TREE_CODE (arg1) == FIXED_CST)
2416         return fold_convert_const_real_from_fixed (type, arg1);
2417     }
2418   else if (TREE_CODE (type) == FIXED_POINT_TYPE)
2419     {
2420       if (TREE_CODE (arg1) == FIXED_CST)
2421         return fold_convert_const_fixed_from_fixed (type, arg1);
2422       else if (TREE_CODE (arg1) == INTEGER_CST)
2423         return fold_convert_const_fixed_from_int (type, arg1);
2424       else if (TREE_CODE (arg1) == REAL_CST)
2425         return fold_convert_const_fixed_from_real (type, arg1);
2426     }
2427   return NULL_TREE;
2428 }
2429
2430 /* Construct a vector of zero elements of vector type TYPE.  */
2431
2432 static tree
2433 build_zero_vector (tree type)
2434 {
2435   tree elem, list;
2436   int i, units;
2437
2438   elem = fold_convert_const (NOP_EXPR, TREE_TYPE (type), integer_zero_node);
2439   units = TYPE_VECTOR_SUBPARTS (type);
2440   
2441   list = NULL_TREE;
2442   for (i = 0; i < units; i++)
2443     list = tree_cons (NULL_TREE, elem, list);
2444   return build_vector (type, list);
2445 }
2446
2447 /* Returns true, if ARG is convertible to TYPE using a NOP_EXPR.  */
2448
2449 bool
2450 fold_convertible_p (const_tree type, const_tree arg)
2451 {
2452   tree orig = TREE_TYPE (arg);
2453
2454   if (type == orig)
2455     return true;
2456
2457   if (TREE_CODE (arg) == ERROR_MARK
2458       || TREE_CODE (type) == ERROR_MARK
2459       || TREE_CODE (orig) == ERROR_MARK)
2460     return false;
2461
2462   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2463     return true;
2464
2465   switch (TREE_CODE (type))
2466     {
2467     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2468     case POINTER_TYPE: case REFERENCE_TYPE:
2469     case OFFSET_TYPE:
2470       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2471           || TREE_CODE (orig) == OFFSET_TYPE)
2472         return true;
2473       return (TREE_CODE (orig) == VECTOR_TYPE
2474               && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2475
2476     case REAL_TYPE:
2477     case FIXED_POINT_TYPE:
2478     case COMPLEX_TYPE:
2479     case VECTOR_TYPE:
2480     case VOID_TYPE:
2481       return TREE_CODE (type) == TREE_CODE (orig);
2482
2483     default:
2484       return false;
2485     }
2486 }
2487
2488 /* Convert expression ARG to type TYPE.  Used by the middle-end for
2489    simple conversions in preference to calling the front-end's convert.  */
2490
2491 tree
2492 fold_convert (tree type, tree arg)
2493 {
2494   tree orig = TREE_TYPE (arg);
2495   tree tem;
2496
2497   if (type == orig)
2498     return arg;
2499
2500   if (TREE_CODE (arg) == ERROR_MARK
2501       || TREE_CODE (type) == ERROR_MARK
2502       || TREE_CODE (orig) == ERROR_MARK)
2503     return error_mark_node;
2504
2505   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (orig))
2506     return fold_build1 (NOP_EXPR, type, arg);
2507
2508   switch (TREE_CODE (type))
2509     {
2510     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
2511     case POINTER_TYPE: case REFERENCE_TYPE:
2512     case OFFSET_TYPE:
2513       if (TREE_CODE (arg) == INTEGER_CST)
2514         {
2515           tem = fold_convert_const (NOP_EXPR, type, arg);
2516           if (tem != NULL_TREE)
2517             return tem;
2518         }
2519       if (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2520           || TREE_CODE (orig) == OFFSET_TYPE)
2521         return fold_build1 (NOP_EXPR, type, arg);
2522       if (TREE_CODE (orig) == COMPLEX_TYPE)
2523         {
2524           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2525           return fold_convert (type, tem);
2526         }
2527       gcc_assert (TREE_CODE (orig) == VECTOR_TYPE
2528                   && tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2529       return fold_build1 (NOP_EXPR, type, arg);
2530
2531     case REAL_TYPE:
2532       if (TREE_CODE (arg) == INTEGER_CST)
2533         {
2534           tem = fold_convert_const (FLOAT_EXPR, type, arg);
2535           if (tem != NULL_TREE)
2536             return tem;
2537         }
2538       else if (TREE_CODE (arg) == REAL_CST)
2539         {
2540           tem = fold_convert_const (NOP_EXPR, type, arg);
2541           if (tem != NULL_TREE)
2542             return tem;
2543         }
2544       else if (TREE_CODE (arg) == FIXED_CST)
2545         {
2546           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2547           if (tem != NULL_TREE)
2548             return tem;
2549         }
2550
2551       switch (TREE_CODE (orig))
2552         {
2553         case INTEGER_TYPE:
2554         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2555         case POINTER_TYPE: case REFERENCE_TYPE:
2556           return fold_build1 (FLOAT_EXPR, type, arg);
2557
2558         case REAL_TYPE:
2559           return fold_build1 (NOP_EXPR, type, arg);
2560
2561         case FIXED_POINT_TYPE:
2562           return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
2563
2564         case COMPLEX_TYPE:
2565           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2566           return fold_convert (type, tem);
2567
2568         default:
2569           gcc_unreachable ();
2570         }
2571
2572     case FIXED_POINT_TYPE:
2573       if (TREE_CODE (arg) == FIXED_CST || TREE_CODE (arg) == INTEGER_CST
2574           || TREE_CODE (arg) == REAL_CST)
2575         {
2576           tem = fold_convert_const (FIXED_CONVERT_EXPR, type, arg);
2577           if (tem != NULL_TREE)
2578             return tem;
2579         }
2580
2581       switch (TREE_CODE (orig))
2582         {
2583         case FIXED_POINT_TYPE:
2584         case INTEGER_TYPE:
2585         case ENUMERAL_TYPE:
2586         case BOOLEAN_TYPE:
2587         case REAL_TYPE:
2588           return fold_build1 (FIXED_CONVERT_EXPR, type, arg);
2589
2590         case COMPLEX_TYPE:
2591           tem = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2592           return fold_convert (type, tem);
2593
2594         default:
2595           gcc_unreachable ();
2596         }
2597
2598     case COMPLEX_TYPE:
2599       switch (TREE_CODE (orig))
2600         {
2601         case INTEGER_TYPE:
2602         case BOOLEAN_TYPE: case ENUMERAL_TYPE:
2603         case POINTER_TYPE: case REFERENCE_TYPE:
2604         case REAL_TYPE:
2605         case FIXED_POINT_TYPE:
2606           return build2 (COMPLEX_EXPR, type,
2607                          fold_convert (TREE_TYPE (type), arg),
2608                          fold_convert (TREE_TYPE (type), integer_zero_node));
2609         case COMPLEX_TYPE:
2610           {
2611             tree rpart, ipart;
2612
2613             if (TREE_CODE (arg) == COMPLEX_EXPR)
2614               {
2615                 rpart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 0));
2616                 ipart = fold_convert (TREE_TYPE (type), TREE_OPERAND (arg, 1));
2617                 return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2618               }
2619
2620             arg = save_expr (arg);
2621             rpart = fold_build1 (REALPART_EXPR, TREE_TYPE (orig), arg);
2622             ipart = fold_build1 (IMAGPART_EXPR, TREE_TYPE (orig), arg);
2623             rpart = fold_convert (TREE_TYPE (type), rpart);
2624             ipart = fold_convert (TREE_TYPE (type), ipart);
2625             return fold_build2 (COMPLEX_EXPR, type, rpart, ipart);
2626           }
2627
2628         default:
2629           gcc_unreachable ();
2630         }
2631
2632     case VECTOR_TYPE:
2633       if (integer_zerop (arg))
2634         return build_zero_vector (type);
2635       gcc_assert (tree_int_cst_equal (TYPE_SIZE (type), TYPE_SIZE (orig)));
2636       gcc_assert (INTEGRAL_TYPE_P (orig) || POINTER_TYPE_P (orig)
2637                   || TREE_CODE (orig) == VECTOR_TYPE);
2638       return fold_build1 (VIEW_CONVERT_EXPR, type, arg);
2639
2640     case VOID_TYPE:
2641       tem = fold_ignored_result (arg);
2642       if (TREE_CODE (tem) == GIMPLE_MODIFY_STMT)
2643         return tem;
2644       return fold_build1 (NOP_EXPR, type, tem);
2645
2646     default:
2647       gcc_unreachable ();
2648     }
2649 }
2650 \f
2651 /* Return false if expr can be assumed not to be an lvalue, true
2652    otherwise.  */
2653
2654 static bool
2655 maybe_lvalue_p (const_tree x)
2656 {
2657   /* We only need to wrap lvalue tree codes.  */
2658   switch (TREE_CODE (x))
2659   {
2660   case VAR_DECL:
2661   case PARM_DECL:
2662   case RESULT_DECL:
2663   case LABEL_DECL:
2664   case FUNCTION_DECL:
2665   case SSA_NAME:
2666
2667   case COMPONENT_REF:
2668   case INDIRECT_REF:
2669   case ALIGN_INDIRECT_REF:
2670   case MISALIGNED_INDIRECT_REF:
2671   case ARRAY_REF:
2672   case ARRAY_RANGE_REF:
2673   case BIT_FIELD_REF:
2674   case OBJ_TYPE_REF:
2675
2676   case REALPART_EXPR:
2677   case IMAGPART_EXPR:
2678   case PREINCREMENT_EXPR:
2679   case PREDECREMENT_EXPR:
2680   case SAVE_EXPR:
2681   case TRY_CATCH_EXPR:
2682   case WITH_CLEANUP_EXPR:
2683   case COMPOUND_EXPR:
2684   case MODIFY_EXPR:
2685   case GIMPLE_MODIFY_STMT:
2686   case TARGET_EXPR:
2687   case COND_EXPR:
2688   case BIND_EXPR:
2689   case MIN_EXPR:
2690   case MAX_EXPR:
2691     break;
2692
2693   default:
2694     /* Assume the worst for front-end tree codes.  */
2695     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2696       break;
2697     return false;
2698   }
2699
2700   return true;
2701 }
2702
2703 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2704
2705 tree
2706 non_lvalue (tree x)
2707 {
2708   /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2709      us.  */
2710   if (in_gimple_form)
2711     return x;
2712
2713   if (! maybe_lvalue_p (x))
2714     return x;
2715   return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2716 }
2717
2718 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2719    Zero means allow extended lvalues.  */
2720
2721 int pedantic_lvalues;
2722
2723 /* When pedantic, return an expr equal to X but certainly not valid as a
2724    pedantic lvalue.  Otherwise, return X.  */
2725
2726 static tree
2727 pedantic_non_lvalue (tree x)
2728 {
2729   if (pedantic_lvalues)
2730     return non_lvalue (x);
2731   else
2732     return x;
2733 }
2734 \f
2735 /* Given a tree comparison code, return the code that is the logical inverse
2736    of the given code.  It is not safe to do this for floating-point
2737    comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2738    as well: if reversing the comparison is unsafe, return ERROR_MARK.  */
2739
2740 enum tree_code
2741 invert_tree_comparison (enum tree_code code, bool honor_nans)
2742 {
2743   if (honor_nans && flag_trapping_math)
2744     return ERROR_MARK;
2745
2746   switch (code)
2747     {
2748     case EQ_EXPR:
2749       return NE_EXPR;
2750     case NE_EXPR:
2751       return EQ_EXPR;
2752     case GT_EXPR:
2753       return honor_nans ? UNLE_EXPR : LE_EXPR;
2754     case GE_EXPR:
2755       return honor_nans ? UNLT_EXPR : LT_EXPR;
2756     case LT_EXPR:
2757       return honor_nans ? UNGE_EXPR : GE_EXPR;
2758     case LE_EXPR:
2759       return honor_nans ? UNGT_EXPR : GT_EXPR;
2760     case LTGT_EXPR:
2761       return UNEQ_EXPR;
2762     case UNEQ_EXPR:
2763       return LTGT_EXPR;
2764     case UNGT_EXPR:
2765       return LE_EXPR;
2766     case UNGE_EXPR:
2767       return LT_EXPR;
2768     case UNLT_EXPR:
2769       return GE_EXPR;
2770     case UNLE_EXPR:
2771       return GT_EXPR;
2772     case ORDERED_EXPR:
2773       return UNORDERED_EXPR;
2774     case UNORDERED_EXPR:
2775       return ORDERED_EXPR;
2776     default:
2777       gcc_unreachable ();
2778     }
2779 }
2780
2781 /* Similar, but return the comparison that results if the operands are
2782    swapped.  This is safe for floating-point.  */
2783
2784 enum tree_code
2785 swap_tree_comparison (enum tree_code code)
2786 {
2787   switch (code)
2788     {
2789     case EQ_EXPR:
2790     case NE_EXPR:
2791     case ORDERED_EXPR:
2792     case UNORDERED_EXPR:
2793     case LTGT_EXPR:
2794     case UNEQ_EXPR:
2795       return code;
2796     case GT_EXPR:
2797       return LT_EXPR;
2798     case GE_EXPR:
2799       return LE_EXPR;
2800     case LT_EXPR:
2801       return GT_EXPR;
2802     case LE_EXPR:
2803       return GE_EXPR;
2804     case UNGT_EXPR:
2805       return UNLT_EXPR;
2806     case UNGE_EXPR:
2807       return UNLE_EXPR;
2808     case UNLT_EXPR:
2809       return UNGT_EXPR;
2810     case UNLE_EXPR:
2811       return UNGE_EXPR;
2812     default:
2813       gcc_unreachable ();
2814     }
2815 }
2816
2817
2818 /* Convert a comparison tree code from an enum tree_code representation
2819    into a compcode bit-based encoding.  This function is the inverse of
2820    compcode_to_comparison.  */
2821
2822 static enum comparison_code
2823 comparison_to_compcode (enum tree_code code)
2824 {
2825   switch (code)
2826     {
2827     case LT_EXPR:
2828       return COMPCODE_LT;
2829     case EQ_EXPR:
2830       return COMPCODE_EQ;
2831     case LE_EXPR:
2832       return COMPCODE_LE;
2833     case GT_EXPR:
2834       return COMPCODE_GT;
2835     case NE_EXPR:
2836       return COMPCODE_NE;
2837     case GE_EXPR:
2838       return COMPCODE_GE;
2839     case ORDERED_EXPR:
2840       return COMPCODE_ORD;
2841     case UNORDERED_EXPR:
2842       return COMPCODE_UNORD;
2843     case UNLT_EXPR:
2844       return COMPCODE_UNLT;
2845     case UNEQ_EXPR:
2846       return COMPCODE_UNEQ;
2847     case UNLE_EXPR:
2848       return COMPCODE_UNLE;
2849     case UNGT_EXPR:
2850       return COMPCODE_UNGT;
2851     case LTGT_EXPR:
2852       return COMPCODE_LTGT;
2853     case UNGE_EXPR:
2854       return COMPCODE_UNGE;
2855     default:
2856       gcc_unreachable ();
2857     }
2858 }
2859
2860 /* Convert a compcode bit-based encoding of a comparison operator back
2861    to GCC's enum tree_code representation.  This function is the
2862    inverse of comparison_to_compcode.  */
2863
2864 static enum tree_code
2865 compcode_to_comparison (enum comparison_code code)
2866 {
2867   switch (code)
2868     {
2869     case COMPCODE_LT:
2870       return LT_EXPR;
2871     case COMPCODE_EQ:
2872       return EQ_EXPR;
2873     case COMPCODE_LE:
2874       return LE_EXPR;
2875     case COMPCODE_GT:
2876       return GT_EXPR;
2877     case COMPCODE_NE:
2878       return NE_EXPR;
2879     case COMPCODE_GE:
2880       return GE_EXPR;
2881     case COMPCODE_ORD:
2882       return ORDERED_EXPR;
2883     case COMPCODE_UNORD:
2884       return UNORDERED_EXPR;
2885     case COMPCODE_UNLT:
2886       return UNLT_EXPR;
2887     case COMPCODE_UNEQ:
2888       return UNEQ_EXPR;
2889     case COMPCODE_UNLE:
2890       return UNLE_EXPR;
2891     case COMPCODE_UNGT:
2892       return UNGT_EXPR;
2893     case COMPCODE_LTGT:
2894       return LTGT_EXPR;
2895     case COMPCODE_UNGE:
2896       return UNGE_EXPR;
2897     default:
2898       gcc_unreachable ();
2899     }
2900 }
2901
2902 /* Return a tree for the comparison which is the combination of
2903    doing the AND or OR (depending on CODE) of the two operations LCODE
2904    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2905    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2906    if this makes the transformation invalid.  */
2907
2908 tree
2909 combine_comparisons (enum tree_code code, enum tree_code lcode,
2910                      enum tree_code rcode, tree truth_type,
2911                      tree ll_arg, tree lr_arg)
2912 {
2913   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2914   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2915   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2916   enum comparison_code compcode;
2917
2918   switch (code)
2919     {
2920     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2921       compcode = lcompcode & rcompcode;
2922       break;
2923
2924     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2925       compcode = lcompcode | rcompcode;
2926       break;
2927
2928     default:
2929       return NULL_TREE;
2930     }
2931
2932   if (!honor_nans)
2933     {
2934       /* Eliminate unordered comparisons, as well as LTGT and ORD
2935          which are not used unless the mode has NaNs.  */
2936       compcode &= ~COMPCODE_UNORD;
2937       if (compcode == COMPCODE_LTGT)
2938         compcode = COMPCODE_NE;
2939       else if (compcode == COMPCODE_ORD)
2940         compcode = COMPCODE_TRUE;
2941     }
2942    else if (flag_trapping_math)
2943      {
2944         /* Check that the original operation and the optimized ones will trap
2945            under the same condition.  */
2946         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2947                      && (lcompcode != COMPCODE_EQ)
2948                      && (lcompcode != COMPCODE_ORD);
2949         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2950                      && (rcompcode != COMPCODE_EQ)
2951                      && (rcompcode != COMPCODE_ORD);
2952         bool trap = (compcode & COMPCODE_UNORD) == 0
2953                     && (compcode != COMPCODE_EQ)
2954                     && (compcode != COMPCODE_ORD);
2955
2956         /* In a short-circuited boolean expression the LHS might be
2957            such that the RHS, if evaluated, will never trap.  For
2958            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2959            if neither x nor y is NaN.  (This is a mixed blessing: for
2960            example, the expression above will never trap, hence
2961            optimizing it to x < y would be invalid).  */
2962         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2963             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2964           rtrap = false;
2965
2966         /* If the comparison was short-circuited, and only the RHS
2967            trapped, we may now generate a spurious trap.  */
2968         if (rtrap && !ltrap
2969             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2970           return NULL_TREE;
2971
2972         /* If we changed the conditions that cause a trap, we lose.  */
2973         if ((ltrap || rtrap) != trap)
2974           return NULL_TREE;
2975       }
2976
2977   if (compcode == COMPCODE_TRUE)
2978     return constant_boolean_node (true, truth_type);
2979   else if (compcode == COMPCODE_FALSE)
2980     return constant_boolean_node (false, truth_type);
2981   else
2982     return fold_build2 (compcode_to_comparison (compcode),
2983                         truth_type, ll_arg, lr_arg);
2984 }
2985
2986 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2987
2988 static int
2989 truth_value_p (enum tree_code code)
2990 {
2991   return (TREE_CODE_CLASS (code) == tcc_comparison
2992           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2993           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2994           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2995 }
2996 \f
2997 /* Return nonzero if two operands (typically of the same tree node)
2998    are necessarily equal.  If either argument has side-effects this
2999    function returns zero.  FLAGS modifies behavior as follows:
3000
3001    If OEP_ONLY_CONST is set, only return nonzero for constants.
3002    This function tests whether the operands are indistinguishable;
3003    it does not test whether they are equal using C's == operation.
3004    The distinction is important for IEEE floating point, because
3005    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
3006    (2) two NaNs may be indistinguishable, but NaN!=NaN.
3007
3008    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
3009    even though it may hold multiple values during a function.
3010    This is because a GCC tree node guarantees that nothing else is
3011    executed between the evaluation of its "operands" (which may often
3012    be evaluated in arbitrary order).  Hence if the operands themselves
3013    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
3014    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
3015    unset means assuming isochronic (or instantaneous) tree equivalence.
3016    Unless comparing arbitrary expression trees, such as from different
3017    statements, this flag can usually be left unset.
3018
3019    If OEP_PURE_SAME is set, then pure functions with identical arguments
3020    are considered the same.  It is used when the caller has other ways
3021    to ensure that global memory is unchanged in between.  */
3022
3023 int
3024 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
3025 {
3026   /* If either is ERROR_MARK, they aren't equal.  */
3027   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
3028     return 0;
3029
3030   /* If both types don't have the same signedness, then we can't consider
3031      them equal.  We must check this before the STRIP_NOPS calls
3032      because they may change the signedness of the arguments.  */
3033   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1)))
3034     return 0;
3035
3036   /* If both types don't have the same precision, then it is not safe
3037      to strip NOPs.  */
3038   if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
3039     return 0;
3040
3041   STRIP_NOPS (arg0);
3042   STRIP_NOPS (arg1);
3043
3044   /* In case both args are comparisons but with different comparison
3045      code, try to swap the comparison operands of one arg to produce
3046      a match and compare that variant.  */
3047   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3048       && COMPARISON_CLASS_P (arg0)
3049       && COMPARISON_CLASS_P (arg1))
3050     {
3051       enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
3052
3053       if (TREE_CODE (arg0) == swap_code)
3054         return operand_equal_p (TREE_OPERAND (arg0, 0),
3055                                 TREE_OPERAND (arg1, 1), flags)
3056                && operand_equal_p (TREE_OPERAND (arg0, 1),
3057                                    TREE_OPERAND (arg1, 0), flags);
3058     }
3059
3060   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3061       /* This is needed for conversions and for COMPONENT_REF.
3062          Might as well play it safe and always test this.  */
3063       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
3064       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
3065       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
3066     return 0;
3067
3068   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
3069      We don't care about side effects in that case because the SAVE_EXPR
3070      takes care of that for us. In all other cases, two expressions are
3071      equal if they have no side effects.  If we have two identical
3072      expressions with side effects that should be treated the same due
3073      to the only side effects being identical SAVE_EXPR's, that will
3074      be detected in the recursive calls below.  */
3075   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
3076       && (TREE_CODE (arg0) == SAVE_EXPR
3077           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
3078     return 1;
3079
3080   /* Next handle constant cases, those for which we can return 1 even
3081      if ONLY_CONST is set.  */
3082   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
3083     switch (TREE_CODE (arg0))
3084       {
3085       case INTEGER_CST:
3086         return tree_int_cst_equal (arg0, arg1);
3087
3088       case FIXED_CST:
3089         return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
3090                                        TREE_FIXED_CST (arg1));
3091
3092       case REAL_CST:
3093         if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
3094                                    TREE_REAL_CST (arg1)))
3095           return 1;
3096
3097         
3098         if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
3099           {
3100             /* If we do not distinguish between signed and unsigned zero,
3101                consider them equal.  */
3102             if (real_zerop (arg0) && real_zerop (arg1))
3103               return 1;
3104           }
3105         return 0;
3106
3107       case VECTOR_CST:
3108         {
3109           tree v1, v2;
3110
3111           v1 = TREE_VECTOR_CST_ELTS (arg0);
3112           v2 = TREE_VECTOR_CST_ELTS (arg1);
3113           while (v1 && v2)
3114             {
3115               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
3116                                     flags))
3117                 return 0;
3118               v1 = TREE_CHAIN (v1);
3119               v2 = TREE_CHAIN (v2);
3120             }
3121
3122           return v1 == v2;
3123         }
3124
3125       case COMPLEX_CST:
3126         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
3127                                  flags)
3128                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
3129                                     flags));
3130
3131       case STRING_CST:
3132         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
3133                 && ! memcmp (TREE_STRING_POINTER (arg0),
3134                               TREE_STRING_POINTER (arg1),
3135                               TREE_STRING_LENGTH (arg0)));
3136
3137       case ADDR_EXPR:
3138         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
3139                                 0);
3140       default:
3141         break;
3142       }
3143
3144   if (flags & OEP_ONLY_CONST)
3145     return 0;
3146
3147 /* Define macros to test an operand from arg0 and arg1 for equality and a
3148    variant that allows null and views null as being different from any
3149    non-null value.  In the latter case, if either is null, the both
3150    must be; otherwise, do the normal comparison.  */
3151 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),     \
3152                                     TREE_OPERAND (arg1, N), flags)
3153
3154 #define OP_SAME_WITH_NULL(N)                            \
3155   ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3156    ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3157
3158   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
3159     {
3160     case tcc_unary:
3161       /* Two conversions are equal only if signedness and modes match.  */
3162       switch (TREE_CODE (arg0))
3163         {
3164         case NOP_EXPR:
3165         case CONVERT_EXPR:
3166         case FIX_TRUNC_EXPR:
3167           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
3168               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
3169             return 0;
3170           break;
3171         default:
3172           break;
3173         }
3174
3175       return OP_SAME (0);
3176
3177
3178     case tcc_comparison:
3179     case tcc_binary:
3180       if (OP_SAME (0) && OP_SAME (1))
3181         return 1;
3182
3183       /* For commutative ops, allow the other order.  */
3184       return (commutative_tree_code (TREE_CODE (arg0))
3185               && operand_equal_p (TREE_OPERAND (arg0, 0),
3186                                   TREE_OPERAND (arg1, 1), flags)
3187               && operand_equal_p (TREE_OPERAND (arg0, 1),
3188                                   TREE_OPERAND (arg1, 0), flags));
3189
3190     case tcc_reference:
3191       /* If either of the pointer (or reference) expressions we are
3192          dereferencing contain a side effect, these cannot be equal.  */
3193       if (TREE_SIDE_EFFECTS (arg0)
3194           || TREE_SIDE_EFFECTS (arg1))
3195         return 0;
3196
3197       switch (TREE_CODE (arg0))
3198         {
3199         case INDIRECT_REF:
3200         case ALIGN_INDIRECT_REF:
3201         case MISALIGNED_INDIRECT_REF:
3202         case REALPART_EXPR:
3203         case IMAGPART_EXPR:
3204           return OP_SAME (0);
3205
3206         case ARRAY_REF:
3207         case ARRAY_RANGE_REF:
3208           /* Operands 2 and 3 may be null.
3209              Compare the array index by value if it is constant first as we
3210              may have different types but same value here.  */
3211           return (OP_SAME (0)
3212                   && (tree_int_cst_equal (TREE_OPERAND (arg0, 1),
3213                                           TREE_OPERAND (arg1, 1))
3214                       || OP_SAME (1))
3215                   && OP_SAME_WITH_NULL (2)
3216                   && OP_SAME_WITH_NULL (3));
3217
3218         case COMPONENT_REF:
3219           /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
3220              may be NULL when we're called to compare MEM_EXPRs.  */
3221           return OP_SAME_WITH_NULL (0)
3222                  && OP_SAME (1)
3223                  && OP_SAME_WITH_NULL (2);
3224
3225         case BIT_FIELD_REF:
3226           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3227
3228         default:
3229           return 0;
3230         }
3231
3232     case tcc_expression:
3233       switch (TREE_CODE (arg0))
3234         {
3235         case ADDR_EXPR:
3236         case TRUTH_NOT_EXPR:
3237           return OP_SAME (0);
3238
3239         case TRUTH_ANDIF_EXPR:
3240         case TRUTH_ORIF_EXPR:
3241           return OP_SAME (0) && OP_SAME (1);
3242
3243         case TRUTH_AND_EXPR:
3244         case TRUTH_OR_EXPR:
3245         case TRUTH_XOR_EXPR:
3246           if (OP_SAME (0) && OP_SAME (1))
3247             return 1;
3248
3249           /* Otherwise take into account this is a commutative operation.  */
3250           return (operand_equal_p (TREE_OPERAND (arg0, 0),
3251                                    TREE_OPERAND (arg1, 1), flags)
3252                   && operand_equal_p (TREE_OPERAND (arg0, 1),
3253                                       TREE_OPERAND (arg1, 0), flags));
3254
3255         default:
3256           return 0;
3257         }
3258
3259     case tcc_vl_exp:
3260       switch (TREE_CODE (arg0))
3261         {
3262         case CALL_EXPR:
3263           /* If the CALL_EXPRs call different functions, then they
3264              clearly can not be equal.  */
3265           if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
3266                                  flags))
3267             return 0;
3268
3269           {
3270             unsigned int cef = call_expr_flags (arg0);
3271             if (flags & OEP_PURE_SAME)
3272               cef &= ECF_CONST | ECF_PURE;
3273             else
3274               cef &= ECF_CONST;
3275             if (!cef)
3276               return 0;
3277           }
3278
3279           /* Now see if all the arguments are the same.  */
3280           {
3281             const_call_expr_arg_iterator iter0, iter1;
3282             const_tree a0, a1;
3283             for (a0 = first_const_call_expr_arg (arg0, &iter0),
3284                    a1 = first_const_call_expr_arg (arg1, &iter1);
3285                  a0 && a1;
3286                  a0 = next_const_call_expr_arg (&iter0),
3287                    a1 = next_const_call_expr_arg (&iter1))
3288               if (! operand_equal_p (a0, a1, flags))
3289                 return 0;
3290
3291             /* If we get here and both argument lists are exhausted
3292                then the CALL_EXPRs are equal.  */
3293             return ! (a0 || a1);
3294           }
3295         default:
3296           return 0;
3297         }
3298
3299     case tcc_declaration:
3300       /* Consider __builtin_sqrt equal to sqrt.  */
3301       return (TREE_CODE (arg0) == FUNCTION_DECL
3302               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
3303               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
3304               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
3305
3306     default:
3307       return 0;
3308     }
3309
3310 #undef OP_SAME
3311 #undef OP_SAME_WITH_NULL
3312 }
3313 \f
3314 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3315    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3316
3317    When in doubt, return 0.  */
3318
3319 static int
3320 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
3321 {
3322   int unsignedp1, unsignedpo;
3323   tree primarg0, primarg1, primother;
3324   unsigned int correct_width;
3325
3326   if (operand_equal_p (arg0, arg1, 0))
3327     return 1;
3328
3329   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
3330       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
3331     return 0;
3332
3333   /* Discard any conversions that don't change the modes of ARG0 and ARG1
3334      and see if the inner values are the same.  This removes any
3335      signedness comparison, which doesn't matter here.  */
3336   primarg0 = arg0, primarg1 = arg1;
3337   STRIP_NOPS (primarg0);
3338   STRIP_NOPS (primarg1);
3339   if (operand_equal_p (primarg0, primarg1, 0))
3340     return 1;
3341
3342   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3343      actual comparison operand, ARG0.
3344
3345      First throw away any conversions to wider types
3346      already present in the operands.  */
3347
3348   primarg1 = get_narrower (arg1, &unsignedp1);
3349   primother = get_narrower (other, &unsignedpo);
3350
3351   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
3352   if (unsignedp1 == unsignedpo
3353       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
3354       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
3355     {
3356       tree type = TREE_TYPE (arg0);
3357
3358       /* Make sure shorter operand is extended the right way
3359          to match the longer operand.  */
3360       primarg1 = fold_convert (signed_or_unsigned_type_for
3361                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
3362
3363       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
3364         return 1;
3365     }
3366
3367   return 0;
3368 }
3369 \f
3370 /* See if ARG is an expression that is either a comparison or is performing
3371    arithmetic on comparisons.  The comparisons must only be comparing
3372    two different values, which will be stored in *CVAL1 and *CVAL2; if
3373    they are nonzero it means that some operands have already been found.
3374    No variables may be used anywhere else in the expression except in the
3375    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
3376    the expression and save_expr needs to be called with CVAL1 and CVAL2.
3377
3378    If this is true, return 1.  Otherwise, return zero.  */
3379
3380 static int
3381 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
3382 {
3383   enum tree_code code = TREE_CODE (arg);
3384   enum tree_code_class class = TREE_CODE_CLASS (code);
3385
3386   /* We can handle some of the tcc_expression cases here.  */
3387   if (class == tcc_expression && code == TRUTH_NOT_EXPR)
3388     class = tcc_unary;
3389   else if (class == tcc_expression
3390            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
3391                || code == COMPOUND_EXPR))
3392     class = tcc_binary;
3393
3394   else if (class == tcc_expression && code == SAVE_EXPR
3395            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
3396     {
3397       /* If we've already found a CVAL1 or CVAL2, this expression is
3398          two complex to handle.  */
3399       if (*cval1 || *cval2)
3400         return 0;
3401
3402       class = tcc_unary;
3403       *save_p = 1;
3404     }
3405
3406   switch (class)
3407     {
3408     case tcc_unary:
3409       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
3410
3411     case tcc_binary:
3412       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
3413               && twoval_comparison_p (TREE_OPERAND (arg, 1),
3414                                       cval1, cval2, save_p));
3415
3416     case tcc_constant:
3417       return 1;
3418
3419     case tcc_expression:
3420       if (code == COND_EXPR)
3421         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
3422                                      cval1, cval2, save_p)
3423                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3424                                         cval1, cval2, save_p)
3425                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
3426                                         cval1, cval2, save_p));
3427       return 0;
3428
3429     case tcc_comparison:
3430       /* First see if we can handle the first operand, then the second.  For
3431          the second operand, we know *CVAL1 can't be zero.  It must be that
3432          one side of the comparison is each of the values; test for the
3433          case where this isn't true by failing if the two operands
3434          are the same.  */
3435
3436       if (operand_equal_p (TREE_OPERAND (arg, 0),
3437                            TREE_OPERAND (arg, 1), 0))
3438         return 0;
3439
3440       if (*cval1 == 0)
3441         *cval1 = TREE_OPERAND (arg, 0);
3442       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
3443         ;
3444       else if (*cval2 == 0)
3445         *cval2 = TREE_OPERAND (arg, 0);
3446       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
3447         ;
3448       else
3449         return 0;
3450
3451       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
3452         ;
3453       else if (*cval2 == 0)
3454         *cval2 = TREE_OPERAND (arg, 1);
3455       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
3456         ;
3457       else
3458         return 0;
3459
3460       return 1;
3461
3462     default:
3463       return 0;
3464     }
3465 }
3466 \f
3467 /* ARG is a tree that is known to contain just arithmetic operations and
3468    comparisons.  Evaluate the operations in the tree substituting NEW0 for
3469    any occurrence of OLD0 as an operand of a comparison and likewise for
3470    NEW1 and OLD1.  */
3471
3472 static tree
3473 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
3474 {
3475   tree type = TREE_TYPE (arg);
3476   enum tree_code code = TREE_CODE (arg);
3477   enum tree_code_class class = TREE_CODE_CLASS (code);
3478
3479   /* We can handle some of the tcc_expression cases here.  */
3480   if (class == tcc_expression && code == TRUTH_NOT_EXPR)
3481     class = tcc_unary;
3482   else if (class == tcc_expression
3483            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3484     class = tcc_binary;
3485
3486   switch (class)
3487     {
3488     case tcc_unary:
3489       return fold_build1 (code, type,
3490                           eval_subst (TREE_OPERAND (arg, 0),
3491                                       old0, new0, old1, new1));
3492
3493     case tcc_binary:
3494       return fold_build2 (code, type,
3495                           eval_subst (TREE_OPERAND (arg, 0),
3496                                       old0, new0, old1, new1),
3497                           eval_subst (TREE_OPERAND (arg, 1),
3498                                       old0, new0, old1, new1));
3499
3500     case tcc_expression:
3501       switch (code)
3502         {
3503         case SAVE_EXPR:
3504           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
3505
3506         case COMPOUND_EXPR:
3507           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
3508
3509         case COND_EXPR:
3510           return fold_build3 (code, type,
3511                               eval_subst (TREE_OPERAND (arg, 0),
3512                                           old0, new0, old1, new1),
3513                               eval_subst (TREE_OPERAND (arg, 1),
3514                                           old0, new0, old1, new1),
3515                               eval_subst (TREE_OPERAND (arg, 2),
3516      &n