OSDN Git Service

e6769a650a8836b3af76c343cca3b5a0a2241de4
[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, 2008
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 #include "gimple.h"
69
70 /* Nonzero if we are folding constants inside an initializer; zero
71    otherwise.  */
72 int folding_initializer = 0;
73
74 /* The following constants represent a bit based encoding of GCC's
75    comparison operators.  This encoding simplifies transformations
76    on relational comparison operators, such as AND and OR.  */
77 enum comparison_code {
78   COMPCODE_FALSE = 0,
79   COMPCODE_LT = 1,
80   COMPCODE_EQ = 2,
81   COMPCODE_LE = 3,
82   COMPCODE_GT = 4,
83   COMPCODE_LTGT = 5,
84   COMPCODE_GE = 6,
85   COMPCODE_ORD = 7,
86   COMPCODE_UNORD = 8,
87   COMPCODE_UNLT = 9,
88   COMPCODE_UNEQ = 10,
89   COMPCODE_UNLE = 11,
90   COMPCODE_UNGT = 12,
91   COMPCODE_NE = 13,
92   COMPCODE_UNGE = 14,
93   COMPCODE_TRUE = 15
94 };
95
96 static void encode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
97 static void decode (HOST_WIDE_INT *, unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
98 static bool negate_mathfn_p (enum built_in_function);
99 static bool negate_expr_p (tree);
100 static tree negate_expr (tree);
101 static tree split_tree (tree, enum tree_code, tree *, tree *, tree *, int);
102 static tree associate_trees (tree, tree, enum tree_code, tree);
103 static tree const_binop (enum tree_code, tree, tree, int);
104 static enum comparison_code comparison_to_compcode (enum tree_code);
105 static enum tree_code compcode_to_comparison (enum comparison_code);
106 static tree combine_comparisons (enum tree_code, enum tree_code,
107                                  enum tree_code, tree, tree, tree);
108 static int truth_value_p (enum tree_code);
109 static int operand_equal_for_comparison_p (tree, tree, tree);
110 static int twoval_comparison_p (tree, tree *, tree *, int *);
111 static tree eval_subst (tree, tree, tree, tree, tree);
112 static tree pedantic_omit_one_operand (tree, tree, tree);
113 static tree distribute_bit_expr (enum tree_code, tree, tree, tree);
114 static tree decode_field_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
115                                     enum machine_mode *, int *, int *,
116                                     tree *, tree *);
117 static tree sign_bit_p (tree, const_tree);
118 static int simple_operand_p (const_tree);
119 static tree range_binop (enum tree_code, tree, tree, int, tree, int);
120 static tree range_predecessor (tree);
121 static tree range_successor (tree);
122 static tree make_range (tree, int *, tree *, tree *, bool *);
123 static tree build_range_check (tree, tree, int, tree, tree);
124 static int merge_ranges (int *, tree *, tree *, int, tree, tree, int, tree,
125                          tree);
126 static tree fold_range_test (enum tree_code, tree, tree, tree);
127 static tree fold_cond_expr_with_comparison (tree, tree, tree, tree);
128 static tree unextend (tree, int, int, tree);
129 static tree fold_truthop (enum tree_code, tree, tree, tree);
130 static tree optimize_minmax_comparison (enum tree_code, tree, tree, tree);
131 static tree extract_muldiv (tree, tree, enum tree_code, tree, bool *);
132 static tree extract_muldiv_1 (tree, tree, enum tree_code, tree, bool *);
133 static tree fold_binary_op_with_conditional_arg (enum tree_code, tree,
134                                                  tree, tree,
135                                                  tree, tree, int);
136 static tree fold_mathfn_compare (enum built_in_function, enum tree_code,
137                                  tree, tree, tree);
138 static tree fold_inf_compare (enum tree_code, tree, tree, tree);
139 static tree fold_div_compare (enum tree_code, tree, tree, tree);
140 static bool reorder_operands_p (const_tree, const_tree);
141 static tree fold_negate_const (tree, tree);
142 static tree fold_not_const (tree, tree);
143 static tree fold_relational_const (enum tree_code, tree, tree, tree);
144
145
146 /* We know that A1 + B1 = SUM1, using 2's complement arithmetic and ignoring
147    overflow.  Suppose A, B and SUM have the same respective signs as A1, B1,
148    and SUM1.  Then this yields nonzero if overflow occurred during the
149    addition.
150
151    Overflow occurs if A and B have the same sign, but A and SUM differ in
152    sign.  Use `^' to test whether signs differ, and `< 0' to isolate the
153    sign.  */
154 #define OVERFLOW_SUM_SIGN(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
155 \f
156 /* To do constant folding on INTEGER_CST nodes requires two-word arithmetic.
157    We do that by representing the two-word integer in 4 words, with only
158    HOST_BITS_PER_WIDE_INT / 2 bits stored in each word, as a positive
159    number.  The value of the word is LOWPART + HIGHPART * BASE.  */
160
161 #define LOWPART(x) \
162   ((x) & (((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) - 1))
163 #define HIGHPART(x) \
164   ((unsigned HOST_WIDE_INT) (x) >> HOST_BITS_PER_WIDE_INT / 2)
165 #define BASE ((unsigned HOST_WIDE_INT) 1 << HOST_BITS_PER_WIDE_INT / 2)
166
167 /* Unpack a two-word integer into 4 words.
168    LOW and HI are the integer, as two `HOST_WIDE_INT' pieces.
169    WORDS points to the array of HOST_WIDE_INTs.  */
170
171 static void
172 encode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
173 {
174   words[0] = LOWPART (low);
175   words[1] = HIGHPART (low);
176   words[2] = LOWPART (hi);
177   words[3] = HIGHPART (hi);
178 }
179
180 /* Pack an array of 4 words into a two-word integer.
181    WORDS points to the array of words.
182    The integer is stored into *LOW and *HI as two `HOST_WIDE_INT' pieces.  */
183
184 static void
185 decode (HOST_WIDE_INT *words, unsigned HOST_WIDE_INT *low,
186         HOST_WIDE_INT *hi)
187 {
188   *low = words[0] + words[1] * BASE;
189   *hi = words[2] + words[3] * BASE;
190 }
191 \f
192 /* Force the double-word integer L1, H1 to be within the range of the
193    integer type TYPE.  Stores the properly truncated and sign-extended
194    double-word integer in *LV, *HV.  Returns true if the operation
195    overflows, that is, argument and result are different.  */
196
197 int
198 fit_double_type (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
199                  unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, const_tree type)
200 {
201   unsigned HOST_WIDE_INT low0 = l1;
202   HOST_WIDE_INT high0 = h1;
203   unsigned int prec;
204   int sign_extended_type;
205
206   if (POINTER_TYPE_P (type)
207       || TREE_CODE (type) == OFFSET_TYPE)
208     prec = POINTER_SIZE;
209   else
210     prec = TYPE_PRECISION (type);
211
212   /* Size types *are* sign extended.  */
213   sign_extended_type = (!TYPE_UNSIGNED (type)
214                         || (TREE_CODE (type) == INTEGER_TYPE
215                             && TYPE_IS_SIZETYPE (type)));
216
217   /* First clear all bits that are beyond the type's precision.  */
218   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
219     ;
220   else if (prec > HOST_BITS_PER_WIDE_INT)
221     h1 &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
222   else
223     {
224       h1 = 0;
225       if (prec < HOST_BITS_PER_WIDE_INT)
226         l1 &= ~((HOST_WIDE_INT) (-1) << prec);
227     }
228
229   /* Then do sign extension if necessary.  */
230   if (!sign_extended_type)
231     /* No sign extension */;
232   else if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
233     /* Correct width already.  */;
234   else if (prec > HOST_BITS_PER_WIDE_INT)
235     {
236       /* Sign extend top half? */
237       if (h1 & ((unsigned HOST_WIDE_INT)1
238                 << (prec - HOST_BITS_PER_WIDE_INT - 1)))
239         h1 |= (HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT);
240     }
241   else if (prec == HOST_BITS_PER_WIDE_INT)
242     {
243       if ((HOST_WIDE_INT)l1 < 0)
244         h1 = -1;
245     }
246   else
247     {
248       /* Sign extend bottom half? */
249       if (l1 & ((unsigned HOST_WIDE_INT)1 << (prec - 1)))
250         {
251           h1 = -1;
252           l1 |= (HOST_WIDE_INT)(-1) << prec;
253         }
254     }
255
256   *lv = l1;
257   *hv = h1;
258
259   /* If the value didn't fit, signal overflow.  */
260   return l1 != low0 || h1 != high0;
261 }
262
263 /* We force the double-int HIGH:LOW to the range of the type TYPE by
264    sign or zero extending it.
265    OVERFLOWABLE indicates if we are interested
266    in overflow of the value, when >0 we are only interested in signed
267    overflow, for <0 we are interested in any overflow.  OVERFLOWED
268    indicates whether overflow has already occurred.  CONST_OVERFLOWED
269    indicates whether constant overflow has already occurred.  We force
270    T's value to be within range of T's type (by setting to 0 or 1 all
271    the bits outside the type's range).  We set TREE_OVERFLOWED if,
272         OVERFLOWED is nonzero,
273         or OVERFLOWABLE is >0 and signed overflow occurs
274         or OVERFLOWABLE is <0 and any overflow occurs
275    We return a new tree node for the extended double-int.  The node
276    is shared if no overflow flags are set.  */
277
278 tree
279 force_fit_type_double (tree type, unsigned HOST_WIDE_INT low,
280                        HOST_WIDE_INT high, int overflowable,
281                        bool overflowed)
282 {
283   int sign_extended_type;
284   bool overflow;
285
286   /* Size types *are* sign extended.  */
287   sign_extended_type = (!TYPE_UNSIGNED (type)
288                         || (TREE_CODE (type) == INTEGER_TYPE
289                             && TYPE_IS_SIZETYPE (type)));
290
291   overflow = fit_double_type (low, high, &low, &high, type);
292
293   /* If we need to set overflow flags, return a new unshared node.  */
294   if (overflowed || overflow)
295     {
296       if (overflowed
297           || overflowable < 0
298           || (overflowable > 0 && sign_extended_type))
299         {
300           tree t = make_node (INTEGER_CST);
301           TREE_INT_CST_LOW (t) = low;
302           TREE_INT_CST_HIGH (t) = high;
303           TREE_TYPE (t) = type;
304           TREE_OVERFLOW (t) = 1;
305           return t;
306         }
307     }
308
309   /* Else build a shared node.  */
310   return build_int_cst_wide (type, low, high);
311 }
312 \f
313 /* Add two doubleword integers with doubleword result.
314    Return nonzero if the operation overflows according to UNSIGNED_P.
315    Each argument is given as two `HOST_WIDE_INT' pieces.
316    One argument is L1 and H1; the other, L2 and H2.
317    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
318
319 int
320 add_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
321                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
322                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
323                       bool unsigned_p)
324 {
325   unsigned HOST_WIDE_INT l;
326   HOST_WIDE_INT h;
327
328   l = l1 + l2;
329   h = h1 + h2 + (l < l1);
330
331   *lv = l;
332   *hv = h;
333
334   if (unsigned_p)
335     return (unsigned HOST_WIDE_INT) h < (unsigned HOST_WIDE_INT) h1;
336   else
337     return OVERFLOW_SUM_SIGN (h1, h2, h);
338 }
339
340 /* Negate a doubleword integer with doubleword result.
341    Return nonzero if the operation overflows, assuming it's signed.
342    The argument is given as two `HOST_WIDE_INT' pieces in L1 and H1.
343    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
344
345 int
346 neg_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
347             unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
348 {
349   if (l1 == 0)
350     {
351       *lv = 0;
352       *hv = - h1;
353       return (*hv & h1) < 0;
354     }
355   else
356     {
357       *lv = -l1;
358       *hv = ~h1;
359       return 0;
360     }
361 }
362 \f
363 /* Multiply two doubleword integers with doubleword result.
364    Return nonzero if the operation overflows according to UNSIGNED_P.
365    Each argument is given as two `HOST_WIDE_INT' pieces.
366    One argument is L1 and H1; the other, L2 and H2.
367    The value is stored as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
368
369 int
370 mul_double_with_sign (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
371                       unsigned HOST_WIDE_INT l2, HOST_WIDE_INT h2,
372                       unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
373                       bool unsigned_p)
374 {
375   HOST_WIDE_INT arg1[4];
376   HOST_WIDE_INT arg2[4];
377   HOST_WIDE_INT prod[4 * 2];
378   unsigned HOST_WIDE_INT carry;
379   int i, j, k;
380   unsigned HOST_WIDE_INT toplow, neglow;
381   HOST_WIDE_INT tophigh, neghigh;
382
383   encode (arg1, l1, h1);
384   encode (arg2, l2, h2);
385
386   memset (prod, 0, sizeof prod);
387
388   for (i = 0; i < 4; i++)
389     {
390       carry = 0;
391       for (j = 0; j < 4; j++)
392         {
393           k = i + j;
394           /* This product is <= 0xFFFE0001, the sum <= 0xFFFF0000.  */
395           carry += arg1[i] * arg2[j];
396           /* Since prod[p] < 0xFFFF, this sum <= 0xFFFFFFFF.  */
397           carry += prod[k];
398           prod[k] = LOWPART (carry);
399           carry = HIGHPART (carry);
400         }
401       prod[i + 4] = carry;
402     }
403
404   decode (prod, lv, hv);
405   decode (prod + 4, &toplow, &tophigh);
406
407   /* Unsigned overflow is immediate.  */
408   if (unsigned_p)
409     return (toplow | tophigh) != 0;
410
411   /* Check for signed overflow by calculating the signed representation of the
412      top half of the result; it should agree with the low half's sign bit.  */
413   if (h1 < 0)
414     {
415       neg_double (l2, h2, &neglow, &neghigh);
416       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
417     }
418   if (h2 < 0)
419     {
420       neg_double (l1, h1, &neglow, &neghigh);
421       add_double (neglow, neghigh, toplow, tophigh, &toplow, &tophigh);
422     }
423   return (*hv < 0 ? ~(toplow & tophigh) : toplow | tophigh) != 0;
424 }
425 \f
426 /* Shift the doubleword integer in L1, H1 left by COUNT places
427    keeping only PREC bits of result.
428    Shift right if COUNT is negative.
429    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
430    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
431
432 void
433 lshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
434                HOST_WIDE_INT count, unsigned int prec,
435                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv, int arith)
436 {
437   unsigned HOST_WIDE_INT signmask;
438
439   if (count < 0)
440     {
441       rshift_double (l1, h1, -count, prec, lv, hv, arith);
442       return;
443     }
444
445   if (SHIFT_COUNT_TRUNCATED)
446     count %= prec;
447
448   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
449     {
450       /* Shifting by the host word size is undefined according to the
451          ANSI standard, so we must handle this as a special case.  */
452       *hv = 0;
453       *lv = 0;
454     }
455   else if (count >= HOST_BITS_PER_WIDE_INT)
456     {
457       *hv = l1 << (count - HOST_BITS_PER_WIDE_INT);
458       *lv = 0;
459     }
460   else
461     {
462       *hv = (((unsigned HOST_WIDE_INT) h1 << count)
463              | (l1 >> (HOST_BITS_PER_WIDE_INT - count - 1) >> 1));
464       *lv = l1 << count;
465     }
466
467   /* Sign extend all bits that are beyond the precision.  */
468
469   signmask = -((prec > HOST_BITS_PER_WIDE_INT
470                 ? ((unsigned HOST_WIDE_INT) *hv
471                    >> (prec - HOST_BITS_PER_WIDE_INT - 1))
472                 : (*lv >> (prec - 1))) & 1);
473
474   if (prec >= 2 * HOST_BITS_PER_WIDE_INT)
475     ;
476   else if (prec >= HOST_BITS_PER_WIDE_INT)
477     {
478       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
479       *hv |= signmask << (prec - HOST_BITS_PER_WIDE_INT);
480     }
481   else
482     {
483       *hv = signmask;
484       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << prec);
485       *lv |= signmask << prec;
486     }
487 }
488
489 /* Shift the doubleword integer in L1, H1 right by COUNT places
490    keeping only PREC bits of result.  COUNT must be positive.
491    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
492    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
493
494 void
495 rshift_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
496                HOST_WIDE_INT count, unsigned int prec,
497                unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv,
498                int arith)
499 {
500   unsigned HOST_WIDE_INT signmask;
501
502   signmask = (arith
503               ? -((unsigned HOST_WIDE_INT) h1 >> (HOST_BITS_PER_WIDE_INT - 1))
504               : 0);
505
506   if (SHIFT_COUNT_TRUNCATED)
507     count %= prec;
508
509   if (count >= 2 * HOST_BITS_PER_WIDE_INT)
510     {
511       /* Shifting by the host word size is undefined according to the
512          ANSI standard, so we must handle this as a special case.  */
513       *hv = 0;
514       *lv = 0;
515     }
516   else if (count >= HOST_BITS_PER_WIDE_INT)
517     {
518       *hv = 0;
519       *lv = (unsigned HOST_WIDE_INT) h1 >> (count - HOST_BITS_PER_WIDE_INT);
520     }
521   else
522     {
523       *hv = (unsigned HOST_WIDE_INT) h1 >> count;
524       *lv = ((l1 >> count)
525              | ((unsigned HOST_WIDE_INT) h1 << (HOST_BITS_PER_WIDE_INT - count - 1) << 1));
526     }
527
528   /* Zero / sign extend all bits that are beyond the precision.  */
529
530   if (count >= (HOST_WIDE_INT)prec)
531     {
532       *hv = signmask;
533       *lv = signmask;
534     }
535   else if ((prec - count) >= 2 * HOST_BITS_PER_WIDE_INT)
536     ;
537   else if ((prec - count) >= HOST_BITS_PER_WIDE_INT)
538     {
539       *hv &= ~((HOST_WIDE_INT) (-1) << (prec - count - HOST_BITS_PER_WIDE_INT));
540       *hv |= signmask << (prec - count - HOST_BITS_PER_WIDE_INT);
541     }
542   else
543     {
544       *hv = signmask;
545       *lv &= ~((unsigned HOST_WIDE_INT) (-1) << (prec - count));
546       *lv |= signmask << (prec - count);
547     }
548 }
549 \f
550 /* Rotate the doubleword integer in L1, H1 left by COUNT places
551    keeping only PREC bits of result.
552    Rotate right if COUNT is negative.
553    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
554
555 void
556 lrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
557                 HOST_WIDE_INT count, unsigned int prec,
558                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
559 {
560   unsigned HOST_WIDE_INT s1l, s2l;
561   HOST_WIDE_INT s1h, s2h;
562
563   count %= prec;
564   if (count < 0)
565     count += prec;
566
567   lshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
568   rshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
569   *lv = s1l | s2l;
570   *hv = s1h | s2h;
571 }
572
573 /* Rotate the doubleword integer in L1, H1 left by COUNT places
574    keeping only PREC bits of result.  COUNT must be positive.
575    Store the value as two `HOST_WIDE_INT' pieces in *LV and *HV.  */
576
577 void
578 rrotate_double (unsigned HOST_WIDE_INT l1, HOST_WIDE_INT h1,
579                 HOST_WIDE_INT count, unsigned int prec,
580                 unsigned HOST_WIDE_INT *lv, HOST_WIDE_INT *hv)
581 {
582   unsigned HOST_WIDE_INT s1l, s2l;
583   HOST_WIDE_INT s1h, s2h;
584
585   count %= prec;
586   if (count < 0)
587     count += prec;
588
589   rshift_double (l1, h1, count, prec, &s1l, &s1h, 0);
590   lshift_double (l1, h1, prec - count, prec, &s2l, &s2h, 0);
591   *lv = s1l | s2l;
592   *hv = s1h | s2h;
593 }
594 \f
595 /* Divide doubleword integer LNUM, HNUM by doubleword integer LDEN, HDEN
596    for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
597    CODE is a tree code for a kind of division, one of
598    TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
599    or EXACT_DIV_EXPR
600    It controls how the quotient is rounded to an integer.
601    Return nonzero if the operation overflows.
602    UNS nonzero says do unsigned division.  */
603
604 int
605 div_and_round_double (enum tree_code code, int uns,
606                       unsigned HOST_WIDE_INT lnum_orig, /* num == numerator == dividend */
607                       HOST_WIDE_INT hnum_orig,
608                       unsigned HOST_WIDE_INT lden_orig, /* den == denominator == divisor */
609                       HOST_WIDE_INT hden_orig,
610                       unsigned HOST_WIDE_INT *lquo,
611                       HOST_WIDE_INT *hquo, unsigned HOST_WIDE_INT *lrem,
612                       HOST_WIDE_INT *hrem)
613 {
614   int quo_neg = 0;
615   HOST_WIDE_INT num[4 + 1];     /* extra element for scaling.  */
616   HOST_WIDE_INT den[4], quo[4];
617   int i, j;
618   unsigned HOST_WIDE_INT work;
619   unsigned HOST_WIDE_INT carry = 0;
620   unsigned HOST_WIDE_INT lnum = lnum_orig;
621   HOST_WIDE_INT hnum = hnum_orig;
622   unsigned HOST_WIDE_INT lden = lden_orig;
623   HOST_WIDE_INT hden = hden_orig;
624   int overflow = 0;
625
626   if (hden == 0 && lden == 0)
627     overflow = 1, lden = 1;
628
629   /* Calculate quotient sign and convert operands to unsigned.  */
630   if (!uns)
631     {
632       if (hnum < 0)
633         {
634           quo_neg = ~ quo_neg;
635           /* (minimum integer) / (-1) is the only overflow case.  */
636           if (neg_double (lnum, hnum, &lnum, &hnum)
637               && ((HOST_WIDE_INT) lden & hden) == -1)
638             overflow = 1;
639         }
640       if (hden < 0)
641         {
642           quo_neg = ~ quo_neg;
643           neg_double (lden, hden, &lden, &hden);
644         }
645     }
646
647   if (hnum == 0 && hden == 0)
648     {                           /* single precision */
649       *hquo = *hrem = 0;
650       /* This unsigned division rounds toward zero.  */
651       *lquo = lnum / lden;
652       goto finish_up;
653     }
654
655   if (hnum == 0)
656     {                           /* trivial case: dividend < divisor */
657       /* hden != 0 already checked.  */
658       *hquo = *lquo = 0;
659       *hrem = hnum;
660       *lrem = lnum;
661       goto finish_up;
662     }
663
664   memset (quo, 0, sizeof quo);
665
666   memset (num, 0, sizeof num);  /* to zero 9th element */
667   memset (den, 0, sizeof den);
668
669   encode (num, lnum, hnum);
670   encode (den, lden, hden);
671
672   /* Special code for when the divisor < BASE.  */
673   if (hden == 0 && lden < (unsigned HOST_WIDE_INT) BASE)
674     {
675       /* hnum != 0 already checked.  */
676       for (i = 4 - 1; i >= 0; i--)
677         {
678           work = num[i] + carry * BASE;
679           quo[i] = work / lden;
680           carry = work % lden;
681         }
682     }
683   else
684     {
685       /* Full double precision division,
686          with thanks to Don Knuth's "Seminumerical Algorithms".  */
687       int num_hi_sig, den_hi_sig;
688       unsigned HOST_WIDE_INT quo_est, scale;
689
690       /* Find the highest nonzero divisor digit.  */
691       for (i = 4 - 1;; i--)
692         if (den[i] != 0)
693           {
694             den_hi_sig = i;
695             break;
696           }
697
698       /* Insure that the first digit of the divisor is at least BASE/2.
699          This is required by the quotient digit estimation algorithm.  */
700
701       scale = BASE / (den[den_hi_sig] + 1);
702       if (scale > 1)
703         {               /* scale divisor and dividend */
704           carry = 0;
705           for (i = 0; i <= 4 - 1; i++)
706             {
707               work = (num[i] * scale) + carry;
708               num[i] = LOWPART (work);
709               carry = HIGHPART (work);
710             }
711
712           num[4] = carry;
713           carry = 0;
714           for (i = 0; i <= 4 - 1; i++)
715             {
716               work = (den[i] * scale) + carry;
717               den[i] = LOWPART (work);
718               carry = HIGHPART (work);
719               if (den[i] != 0) den_hi_sig = i;
720             }
721         }
722
723       num_hi_sig = 4;
724
725       /* Main loop */
726       for (i = num_hi_sig - den_hi_sig - 1; i >= 0; i--)
727         {
728           /* Guess the next quotient digit, quo_est, by dividing the first
729              two remaining dividend digits by the high order quotient digit.
730              quo_est is never low and is at most 2 high.  */
731           unsigned HOST_WIDE_INT tmp;
732
733           num_hi_sig = i + den_hi_sig + 1;
734           work = num[num_hi_sig] * BASE + num[num_hi_sig - 1];
735           if (num[num_hi_sig] != den[den_hi_sig])
736             quo_est = work / den[den_hi_sig];
737           else
738             quo_est = BASE - 1;
739
740           /* Refine quo_est so it's usually correct, and at most one high.  */
741           tmp = work - quo_est * den[den_hi_sig];
742           if (tmp < BASE
743               && (den[den_hi_sig - 1] * quo_est
744                   > (tmp * BASE + num[num_hi_sig - 2])))
745             quo_est--;
746
747           /* Try QUO_EST as the quotient digit, by multiplying the
748              divisor by QUO_EST and subtracting from the remaining dividend.
749              Keep in mind that QUO_EST is the I - 1st digit.  */
750
751           carry = 0;
752           for (j = 0; j <= den_hi_sig; j++)
753             {
754               work = quo_est * den[j] + carry;
755               carry = HIGHPART (work);
756               work = num[i + j] - LOWPART (work);
757               num[i + j] = LOWPART (work);
758               carry += HIGHPART (work) != 0;
759             }
760
761           /* If quo_est was high by one, then num[i] went negative and
762              we need to correct things.  */
763           if (num[num_hi_sig] < (HOST_WIDE_INT) carry)
764             {
765               quo_est--;
766               carry = 0;                /* add divisor back in */
767               for (j = 0; j <= den_hi_sig; j++)
768                 {
769                   work = num[i + j] + den[j] + carry;
770                   carry = HIGHPART (work);
771                   num[i + j] = LOWPART (work);
772                 }
773
774               num [num_hi_sig] += carry;
775             }
776
777           /* Store the quotient digit.  */
778           quo[i] = quo_est;
779         }
780     }
781
782   decode (quo, lquo, hquo);
783
784  finish_up:
785   /* If result is negative, make it so.  */
786   if (quo_neg)
787     neg_double (*lquo, *hquo, lquo, hquo);
788
789   /* Compute trial remainder:  rem = num - (quo * den)  */
790   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
791   neg_double (*lrem, *hrem, lrem, hrem);
792   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
793
794   switch (code)
795     {
796     case TRUNC_DIV_EXPR:
797     case TRUNC_MOD_EXPR:        /* round toward zero */
798     case EXACT_DIV_EXPR:        /* for this one, it shouldn't matter */
799       return overflow;
800
801     case FLOOR_DIV_EXPR:
802     case FLOOR_MOD_EXPR:        /* round toward negative infinity */
803       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
804         {
805           /* quo = quo - 1;  */
806           add_double (*lquo, *hquo, (HOST_WIDE_INT) -1, (HOST_WIDE_INT)  -1,
807                       lquo, hquo);
808         }
809       else
810         return overflow;
811       break;
812
813     case CEIL_DIV_EXPR:
814     case CEIL_MOD_EXPR:         /* round toward positive infinity */
815       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
816         {
817           add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
818                       lquo, hquo);
819         }
820       else
821         return overflow;
822       break;
823
824     case ROUND_DIV_EXPR:
825     case ROUND_MOD_EXPR:        /* round to closest integer */
826       {
827         unsigned HOST_WIDE_INT labs_rem = *lrem;
828         HOST_WIDE_INT habs_rem = *hrem;
829         unsigned HOST_WIDE_INT labs_den = lden, ltwice;
830         HOST_WIDE_INT habs_den = hden, htwice;
831
832         /* Get absolute values.  */
833         if (*hrem < 0)
834           neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
835         if (hden < 0)
836           neg_double (lden, hden, &labs_den, &habs_den);
837
838         /* If (2 * abs (lrem) >= abs (lden)) */
839         mul_double ((HOST_WIDE_INT) 2, (HOST_WIDE_INT) 0,
840                     labs_rem, habs_rem, &ltwice, &htwice);
841
842         if (((unsigned HOST_WIDE_INT) habs_den
843              < (unsigned HOST_WIDE_INT) htwice)
844             || (((unsigned HOST_WIDE_INT) habs_den
845                  == (unsigned HOST_WIDE_INT) htwice)
846                 && (labs_den < ltwice)))
847           {
848             if (*hquo < 0)
849               /* quo = quo - 1;  */
850               add_double (*lquo, *hquo,
851                           (HOST_WIDE_INT) -1, (HOST_WIDE_INT) -1, lquo, hquo);
852             else
853               /* quo = quo + 1; */
854               add_double (*lquo, *hquo, (HOST_WIDE_INT) 1, (HOST_WIDE_INT) 0,
855                           lquo, hquo);
856           }
857         else
858           return overflow;
859       }
860       break;
861
862     default:
863       gcc_unreachable ();
864     }
865
866   /* Compute true remainder:  rem = num - (quo * den)  */
867   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
868   neg_double (*lrem, *hrem, lrem, hrem);
869   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
870   return overflow;
871 }
872
873 /* If ARG2 divides ARG1 with zero remainder, carries out the division
874    of type CODE and returns the quotient.
875    Otherwise returns NULL_TREE.  */
876
877 static tree
878 div_if_zero_remainder (enum tree_code code, const_tree arg1, const_tree arg2)
879 {
880   unsigned HOST_WIDE_INT int1l, int2l;
881   HOST_WIDE_INT int1h, int2h;
882   unsigned HOST_WIDE_INT quol, reml;
883   HOST_WIDE_INT quoh, remh;
884   tree type = TREE_TYPE (arg1);
885   int uns = TYPE_UNSIGNED (type);
886
887   int1l = TREE_INT_CST_LOW (arg1);
888   int1h = TREE_INT_CST_HIGH (arg1);
889   /* &obj[0] + -128 really should be compiled as &obj[-8] rather than
890      &obj[some_exotic_number].  */
891   if (POINTER_TYPE_P (type))
892     {
893       uns = false;
894       type = signed_type_for (type);
895       fit_double_type (int1l, int1h, &int1l, &int1h,
896                        type);
897     }
898   else
899     fit_double_type (int1l, int1h, &int1l, &int1h, type);
900   int2l = TREE_INT_CST_LOW (arg2);
901   int2h = TREE_INT_CST_HIGH (arg2);
902
903   div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
904                         &quol, &quoh, &reml, &remh);
905   if (remh != 0 || reml != 0)
906     return NULL_TREE;
907
908   return build_int_cst_wide (type, quol, quoh);
909 }
910 \f
911 /* This is nonzero if we should defer warnings about undefined
912    overflow.  This facility exists because these warnings are a
913    special case.  The code to estimate loop iterations does not want
914    to issue any warnings, since it works with expressions which do not
915    occur in user code.  Various bits of cleanup code call fold(), but
916    only use the result if it has certain characteristics (e.g., is a
917    constant); that code only wants to issue a warning if the result is
918    used.  */
919
920 static int fold_deferring_overflow_warnings;
921
922 /* If a warning about undefined overflow is deferred, this is the
923    warning.  Note that this may cause us to turn two warnings into
924    one, but that is fine since it is sufficient to only give one
925    warning per expression.  */
926
927 static const char* fold_deferred_overflow_warning;
928
929 /* If a warning about undefined overflow is deferred, this is the
930    level at which the warning should be emitted.  */
931
932 static enum warn_strict_overflow_code fold_deferred_overflow_code;
933
934 /* Start deferring overflow warnings.  We could use a stack here to
935    permit nested calls, but at present it is not necessary.  */
936
937 void
938 fold_defer_overflow_warnings (void)
939 {
940   ++fold_deferring_overflow_warnings;
941 }
942
943 /* Stop deferring overflow warnings.  If there is a pending warning,
944    and ISSUE is true, then issue the warning if appropriate.  STMT is
945    the statement with which the warning should be associated (used for
946    location information); STMT may be NULL.  CODE is the level of the
947    warning--a warn_strict_overflow_code value.  This function will use
948    the smaller of CODE and the deferred code when deciding whether to
949    issue the warning.  CODE may be zero to mean to always use the
950    deferred code.  */
951
952 void
953 fold_undefer_overflow_warnings (bool issue, const_gimple stmt, int code)
954 {
955   const char *warnmsg;
956   location_t locus;
957
958   gcc_assert (fold_deferring_overflow_warnings > 0);
959   --fold_deferring_overflow_warnings;
960   if (fold_deferring_overflow_warnings > 0)
961     {
962       if (fold_deferred_overflow_warning != NULL
963           && code != 0
964           && code < (int) fold_deferred_overflow_code)
965         fold_deferred_overflow_code = code;
966       return;
967     }
968
969   warnmsg = fold_deferred_overflow_warning;
970   fold_deferred_overflow_warning = NULL;
971
972   if (!issue || warnmsg == NULL)
973     return;
974
975   if (gimple_no_warning_p (stmt))
976     return;
977
978   /* Use the smallest code level when deciding to issue the
979      warning.  */
980   if (code == 0 || code > (int) fold_deferred_overflow_code)
981     code = fold_deferred_overflow_code;
982
983   if (!issue_strict_overflow_warning (code))
984     return;
985
986   if (stmt == NULL)
987     locus = input_location;
988   else
989     locus = gimple_location (stmt);
990   warning (OPT_Wstrict_overflow, "%H%s", &locus, warnmsg);
991 }
992
993 /* Stop deferring overflow warnings, ignoring any deferred
994    warnings.  */
995
996 void
997 fold_undefer_and_ignore_overflow_warnings (void)
998 {
999   fold_undefer_overflow_warnings (false, NULL, 0);
1000 }
1001
1002 /* Whether we are deferring overflow warnings.  */
1003
1004 bool
1005 fold_deferring_overflow_warnings_p (void)
1006 {
1007   return fold_deferring_overflow_warnings > 0;
1008 }
1009
1010 /* This is called when we fold something based on the fact that signed
1011    overflow is undefined.  */
1012
1013 static void
1014 fold_overflow_warning (const char* gmsgid, enum warn_strict_overflow_code wc)
1015 {
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            || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations))
1889           && (inexact || !real_identical (&result, &value)))
1890         return NULL_TREE;
1891
1892       t = build_real (type, result);
1893
1894       TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2);
1895       return t;
1896     }
1897
1898   if (TREE_CODE (arg1) == FIXED_CST)
1899     {
1900       FIXED_VALUE_TYPE f1;
1901       FIXED_VALUE_TYPE f2;
1902       FIXED_VALUE_TYPE result;
1903       tree t, type;
1904       int sat_p;
1905       bool overflow_p;
1906
1907       /* The following codes are handled by fixed_arithmetic.  */
1908       switch (code)
1909         {
1910         case PLUS_EXPR:
1911         case MINUS_EXPR:
1912         case MULT_EXPR:
1913         case TRUNC_DIV_EXPR:
1914           f2 = TREE_FIXED_CST (arg2);
1915           break;
1916
1917         case LSHIFT_EXPR:
1918         case RSHIFT_EXPR:
1919           f2.data.high = TREE_INT_CST_HIGH (arg2);
1920           f2.data.low = TREE_INT_CST_LOW (arg2);
1921           f2.mode = SImode;
1922           break;
1923
1924         default:
1925           return NULL_TREE;
1926         }
1927
1928       f1 = TREE_FIXED_CST (arg1);
1929       type = TREE_TYPE (arg1);
1930       sat_p = TYPE_SATURATING (type);
1931       overflow_p = fixed_arithmetic (&result, code, &f1, &f2, sat_p);
1932       t = build_fixed (type, result);
1933       /* Propagate overflow flags.  */
1934       if (overflow_p | TREE_OVERFLOW (arg1) | TREE_OVERFLOW (arg2))
1935         {
1936           TREE_OVERFLOW (t) = 1;
1937           TREE_CONSTANT_OVERFLOW (t) = 1;
1938         }
1939       else if (TREE_CONSTANT_OVERFLOW (arg1) | TREE_CONSTANT_OVERFLOW (arg2))
1940         TREE_CONSTANT_OVERFLOW (t) = 1;
1941       return t;
1942     }
1943
1944   if (TREE_CODE (arg1) == COMPLEX_CST)
1945     {
1946       tree type = TREE_TYPE (arg1);
1947       tree r1 = TREE_REALPART (arg1);
1948       tree i1 = TREE_IMAGPART (arg1);
1949       tree r2 = TREE_REALPART (arg2);
1950       tree i2 = TREE_IMAGPART (arg2);
1951       tree real, imag;
1952
1953       switch (code)
1954         {
1955         case PLUS_EXPR:
1956         case MINUS_EXPR:
1957           real = const_binop (code, r1, r2, notrunc);
1958           imag = const_binop (code, i1, i2, notrunc);
1959           break;
1960
1961         case MULT_EXPR:
1962           real = const_binop (MINUS_EXPR,
1963                               const_binop (MULT_EXPR, r1, r2, notrunc),
1964                               const_binop (MULT_EXPR, i1, i2, notrunc),
1965                               notrunc);
1966           imag = const_binop (PLUS_EXPR,
1967                               const_binop (MULT_EXPR, r1, i2, notrunc),
1968                               const_binop (MULT_EXPR, i1, r2, notrunc),
1969                               notrunc);
1970           break;
1971
1972         case RDIV_EXPR:
1973           {
1974             tree magsquared
1975               = const_binop (PLUS_EXPR,
1976                              const_binop (MULT_EXPR, r2, r2, notrunc),
1977                              const_binop (MULT_EXPR, i2, i2, notrunc),
1978                              notrunc);
1979             tree t1
1980               = const_binop (PLUS_EXPR,
1981                              const_binop (MULT_EXPR, r1, r2, notrunc),
1982                              const_binop (MULT_EXPR, i1, i2, notrunc),
1983                              notrunc);
1984             tree t2
1985               = const_binop (MINUS_EXPR,
1986                              const_binop (MULT_EXPR, i1, r2, notrunc),
1987                              const_binop (MULT_EXPR, r1, i2, notrunc),
1988                              notrunc);
1989
1990             if (INTEGRAL_TYPE_P (TREE_TYPE (r1)))
1991               code = TRUNC_DIV_EXPR;
1992
1993             real = const_binop (code, t1, magsquared, notrunc);
1994             imag = const_binop (code, t2, magsquared, notrunc);
1995           }
1996           break;
1997
1998         default:
1999           return NULL_TREE;
2000         }
2001
2002       if (real && imag)
2003         return build_complex (type, real, imag);
2004     }
2005
2006   return NULL_TREE;
2007 }
2008
2009 /* Create a size type INT_CST node with NUMBER sign extended.  KIND
2010    indicates which particular sizetype to create.  */
2011
2012 tree
2013 size_int_kind (HOST_WIDE_INT number, enum size_type_kind kind)
2014 {
2015   return build_int_cst (sizetype_tab[(int) kind], number);
2016 }
2017 \f
2018 /* Combine operands OP1 and OP2 with arithmetic operation CODE.  CODE
2019    is a tree code.  The type of the result is taken from the operands.
2020    Both must be equivalent integer types, ala int_binop_types_match_p.
2021    If the operands are constant, so is the result.  */
2022
2023 tree
2024 size_binop (enum tree_code code, tree arg0, tree arg1)
2025 {
2026   tree type = TREE_TYPE (arg0);
2027
2028   if (arg0 == error_mark_node || arg1 == error_mark_node)
2029     return error_mark_node;
2030
2031   gcc_assert (int_binop_types_match_p (code, TREE_TYPE (arg0),
2032                                        TREE_TYPE (arg1)));
2033
2034   /* Handle the special case of two integer constants faster.  */
2035   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
2036     {
2037       /* And some specific cases even faster than that.  */
2038       if (code == PLUS_EXPR)
2039         {
2040           if (integer_zerop (arg0) && !TREE_OVERFLOW (arg0))
2041             return arg1;
2042           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
2043             return arg0;
2044         }
2045       else if (code == MINUS_EXPR)
2046         {
2047           if (integer_zerop (arg1) && !TREE_OVERFLOW (arg1))
2048             return arg0;
2049         }
2050       else if (code == MULT_EXPR)
2051         {
2052           if (integer_onep (arg0) && !TREE_OVERFLOW (arg0))
2053             return arg1;
2054         }
2055
2056       /* Handle general case of two integer constants.  */
2057       return int_const_binop (code, arg0, arg1, 0);
2058     }
2059
2060   return fold_build2 (code, type, arg0, arg1);
2061 }
2062
2063 /* Given two values, either both of sizetype or both of bitsizetype,
2064    compute the difference between the two values.  Return the value
2065    in signed type corresponding to the type of the operands.  */
2066
2067 tree
2068 size_diffop (tree arg0, tree arg1)
2069 {
2070   tree type = TREE_TYPE (arg0);
2071   tree ctype;
2072
2073   gcc_assert (int_binop_types_match_p (MINUS_EXPR, TREE_TYPE (arg0),
2074                                        TREE_TYPE (arg1)));
2075
2076   /* If the type is already signed, just do the simple thing.  */
2077   if (!TYPE_UNSIGNED (type))
2078     return size_binop (MINUS_EXPR, arg0, arg1);
2079
2080   if (type == sizetype)
2081     ctype = ssizetype;
2082   else if (type == bitsizetype)
2083     ctype = sbitsizetype;
2084   else
2085     ctype = signed_type_for (type);
2086
2087   /* If either operand is not a constant, do the conversions to the signed
2088      type and subtract.  The hardware will do the right thing with any
2089      overflow in the subtraction.  */
2090   if (TREE_CODE (arg0) != INTEGER_CST || TREE_CODE (arg1) != INTEGER_CST)
2091     return size_binop (MINUS_EXPR, fold_convert (ctype, arg0),
2092                        fold_convert (ctype, arg1));
2093
2094   /* If ARG0 is larger than ARG1, subtract and return the result in CTYPE.
2095      Otherwise, subtract the other way, convert to CTYPE (we know that can't
2096      overflow) and negate (which can't either).  Special-case a result
2097      of zero while we're here.  */
2098   if (tree_int_cst_equal (arg0, arg1))
2099     return build_int_cst (ctype, 0);
2100   else if (tree_int_cst_lt (arg1, arg0))
2101     return fold_convert (ctype, size_binop (MINUS_EXPR, arg0, arg1));
2102   else
2103     return size_binop (MINUS_EXPR, build_int_cst (ctype, 0),
2104                        fold_convert (ctype, size_binop (MINUS_EXPR,
2105                                                         arg1, arg0)));
2106 }
2107 \f
2108 /* A subroutine of fold_convert_const handling conversions of an
2109    INTEGER_CST to another integer type.  */
2110
2111 static tree
2112 fold_convert_const_int_from_int (tree type, const_tree arg1)
2113 {
2114   tree t;
2115
2116   /* Given an integer constant, make new constant with new type,
2117      appropriately sign-extended or truncated.  */
2118   t = force_fit_type_double (type, TREE_INT_CST_LOW (arg1),
2119                              TREE_INT_CST_HIGH (arg1),
2120                              /* Don't set the overflow when
2121                                 converting from a pointer,  */
2122                              !POINTER_TYPE_P (TREE_TYPE (arg1))
2123                              /* or to a sizetype with same signedness
2124                                 and the precision is unchanged.
2125                                 ???  sizetype is always sign-extended,
2126                                 but its signedness depends on the
2127                                 frontend.  Thus we see spurious overflows
2128                                 here if we do not check this.  */
2129                              && !((TYPE_PRECISION (TREE_TYPE (arg1))
2130                                    == TYPE_PRECISION (type))
2131                                   && (TYPE_UNSIGNED (TREE_TYPE (arg1))
2132                                       == TYPE_UNSIGNED (type))
2133                                   && ((TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
2134                                        && TYPE_IS_SIZETYPE (TREE_TYPE (arg1)))
2135                                       || (TREE_CODE (type) == INTEGER_TYPE
2136                                           && TYPE_IS_SIZETYPE (type)))),
2137                              (TREE_INT_CST_HIGH (arg1) < 0
2138                               && (TYPE_UNSIGNED (type)
2139                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
2140                              | TREE_OVERFLOW (arg1));
2141
2142   return t;
2143 }
2144
2145 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2146    to an integer type.  */
2147
2148 static tree
2149 fold_convert_const_int_from_real (enum tree_code code, tree type, const_tree arg1)
2150 {
2151   int overflow = 0;
2152   tree t;
2153
2154   /* The following code implements the floating point to integer
2155      conversion rules required by the Java Language Specification,
2156      that IEEE NaNs are mapped to zero and values that overflow
2157      the target precision saturate, i.e. values greater than
2158      INT_MAX are mapped to INT_MAX, and values less than INT_MIN
2159      are mapped to INT_MIN.  These semantics are allowed by the
2160      C and C++ standards that simply state that the behavior of
2161      FP-to-integer conversion is unspecified upon overflow.  */
2162
2163   HOST_WIDE_INT high, low;
2164   REAL_VALUE_TYPE r;
2165   REAL_VALUE_TYPE x = TREE_REAL_CST (arg1);
2166
2167   switch (code)
2168     {
2169     case FIX_TRUNC_EXPR:
2170       real_trunc (&r, VOIDmode, &x);
2171       break;
2172
2173     default:
2174       gcc_unreachable ();
2175     }
2176
2177   /* If R is NaN, return zero and show we have an overflow.  */
2178   if (REAL_VALUE_ISNAN (r))
2179     {
2180       overflow = 1;
2181       high = 0;
2182       low = 0;
2183     }
2184
2185   /* See if R is less than the lower bound or greater than the
2186      upper bound.  */
2187
2188   if (! overflow)
2189     {
2190       tree lt = TYPE_MIN_VALUE (type);
2191       REAL_VALUE_TYPE l = real_value_from_int_cst (NULL_TREE, lt);
2192       if (REAL_VALUES_LESS (r, l))
2193         {
2194           overflow = 1;
2195           high = TREE_INT_CST_HIGH (lt);
2196           low = TREE_INT_CST_LOW (lt);
2197         }
2198     }
2199
2200   if (! overflow)
2201     {
2202       tree ut = TYPE_MAX_VALUE (type);
2203       if (ut)
2204         {
2205           REAL_VALUE_TYPE u = real_value_from_int_cst (NULL_TREE, ut);
2206           if (REAL_VALUES_LESS (u, r))
2207             {
2208               overflow = 1;
2209               high = TREE_INT_CST_HIGH (ut);
2210               low = TREE_INT_CST_LOW (ut);
2211             }
2212         }
2213     }
2214
2215   if (! overflow)
2216     REAL_VALUE_TO_INT (&low, &high, r);
2217
2218   t = force_fit_type_double (type, low, high, -1,
2219                              overflow | TREE_OVERFLOW (arg1));
2220   return t;
2221 }
2222
2223 /* A subroutine of fold_convert_const handling conversions of a
2224    FIXED_CST to an integer type.  */
2225
2226 static tree
2227 fold_convert_const_int_from_fixed (tree type, const_tree arg1)
2228 {
2229   tree t;
2230   double_int temp, temp_trunc;
2231   unsigned int mode;
2232
2233   /* Right shift FIXED_CST to temp by fbit.  */
2234   temp = TREE_FIXED_CST (arg1).data;
2235   mode = TREE_FIXED_CST (arg1).mode;
2236   if (GET_MODE_FBIT (mode) < 2 * HOST_BITS_PER_WIDE_INT)
2237     {
2238       lshift_double (temp.low, temp.high,
2239                      - GET_MODE_FBIT (mode), 2 * HOST_BITS_PER_WIDE_INT,
2240                      &temp.low, &temp.high, SIGNED_FIXED_POINT_MODE_P (mode));
2241
2242       /* Left shift temp to temp_trunc by fbit.  */
2243       lshift_double (temp.low, temp.high,
2244                      GET_MODE_FBIT (mode), 2 * HOST_BITS_PER_WIDE_INT,
2245                      &temp_trunc.low, &temp_trunc.high,
2246                      SIGNED_FIXED_POINT_MODE_P (mode));
2247     }
2248   else
2249     {
2250       temp.low = 0;
2251       temp.high = 0;
2252       temp_trunc.low = 0;
2253       temp_trunc.high = 0;
2254     }
2255
2256   /* If FIXED_CST is negative, we need to round the value toward 0.
2257      By checking if the fractional bits are not zero to add 1 to temp.  */
2258   if (SIGNED_FIXED_POINT_MODE_P (mode) && temp_trunc.high < 0
2259       && !double_int_equal_p (TREE_FIXED_CST (arg1).data, temp_trunc))
2260     {
2261       double_int one;
2262       one.low = 1;
2263       one.high = 0;
2264       temp = double_int_add (temp, one);
2265     }
2266
2267   /* Given a fixed-point constant, make new constant with new type,
2268      appropriately sign-extended or truncated.  */
2269   t = force_fit_type_double (type, temp.low, temp.high, -1,
2270                              (temp.high < 0
2271                               && (TYPE_UNSIGNED (type)
2272                                   < TYPE_UNSIGNED (TREE_TYPE (arg1))))
2273                              | TREE_OVERFLOW (arg1));
2274
2275   return t;
2276 }
2277
2278 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2279    to another floating point type.  */
2280
2281 static tree
2282 fold_convert_const_real_from_real (tree type, const_tree arg1)
2283 {
2284   REAL_VALUE_TYPE value;
2285   tree t;
2286
2287   real_convert (&value, TYPE_MODE (type), &TREE_REAL_CST (arg1));
2288   t = build_real (type, value);
2289
2290   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2291   return t;
2292 }
2293
2294 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2295    to a floating point type.  */
2296
2297 static tree
2298 fold_convert_const_real_from_fixed (tree type, const_tree arg1)
2299 {
2300   REAL_VALUE_TYPE value;
2301   tree t;
2302
2303   real_convert_from_fixed (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1));
2304   t = build_real (type, value);
2305
2306   TREE_OVERFLOW (t) = TREE_OVERFLOW (arg1);
2307   TREE_CONSTANT_OVERFLOW (t)
2308     = TREE_OVERFLOW (t) | TREE_CONSTANT_OVERFLOW (arg1);
2309   return t;
2310 }
2311
2312 /* A subroutine of fold_convert_const handling conversions a FIXED_CST
2313    to another fixed-point type.  */
2314
2315 static tree
2316 fold_convert_const_fixed_from_fixed (tree type, const_tree arg1)
2317 {
2318   FIXED_VALUE_TYPE value;
2319   tree t;
2320   bool overflow_p;
2321
2322   overflow_p = fixed_convert (&value, TYPE_MODE (type), &TREE_FIXED_CST (arg1),
2323                               TYPE_SATURATING (type));
2324   t = build_fixed (type, value);
2325
2326   /* Propagate overflow flags.  */
2327   if (overflow_p | TREE_OVERFLOW (arg1))
2328     {
2329       TREE_OVERFLOW (t) = 1;
2330       TREE_CONSTANT_OVERFLOW (t) = 1;
2331     }
2332   else if (TREE_CONSTANT_OVERFLOW (arg1))
2333     TREE_CONSTANT_OVERFLOW (t) = 1;
2334   return t;
2335 }
2336
2337 /* A subroutine of fold_convert_const handling conversions an INTEGER_CST
2338    to a fixed-point type.  */
2339
2340 static tree
2341 fold_convert_const_fixed_from_int (tree type, const_tree arg1)
2342 {
2343   FIXED_VALUE_TYPE value;
2344   tree t;
2345   bool overflow_p;
2346
2347   overflow_p = fixed_convert_from_int (&value, TYPE_MODE (type),
2348                                        TREE_INT_CST (arg1),
2349                                        TYPE_UNSIGNED (TREE_TYPE (arg1)),
2350                                        TYPE_SATURATING (type));
2351   t = build_fixed (type, value);
2352
2353   /* Propagate overflow flags.  */
2354   if (overflow_p | TREE_OVERFLOW (arg1))
2355     {
2356       TREE_OVERFLOW (t) = 1;
2357       TREE_CONSTANT_OVERFLOW (t) = 1;
2358     }
2359   else if (TREE_CONSTANT_OVERFLOW (arg1))
2360     TREE_CONSTANT_OVERFLOW (t) = 1;
2361   return t;
2362 }
2363
2364 /* A subroutine of fold_convert_const handling conversions a REAL_CST
2365    to a fixed-point type.  */
2366
2367 static tree
2368 fold_convert_const_fixed_from_real (tree type, const_tree arg1)
2369 {
2370   FIXED_VALUE_TYPE value;
2371   tree t;
2372   bool overflow_p;
2373
2374   overflow_p = fixed_convert_from_real (&value, TYPE_MODE (type),
2375                                         &TREE_REAL_CST (arg1),
2376                                         TYPE_SATURATING (type));
2377   t = build_fixed (type, value);
2378
2379   /* Propagate overflow flags.  */
2380   if (overflow_p | TREE_OVERFLOW (arg1))
2381     {
2382       TREE_OVERFLOW (t) = 1;
2383       TREE_CONSTANT_OVERFLOW (t) = 1;
2384     }
2385   else if (TREE_CONSTANT_OVERFLOW (arg1))
2386     TREE_CONSTANT_OVERFLOW (t) = 1;
2387   return t;
2388 }
2389
2390 /* Attempt to fold type conversion operation CODE of expression ARG1 to
2391    type TYPE.  If no simplification can be done return NULL_TREE.  */
2392
2393 static tree
2394 fold_convert_const (enum tree_code code, tree type, tree arg1)
2395 {
2396   if (TREE_TYPE (arg1) == type)
2397     return arg1;
2398
2399   if (POINTER_TYPE_P (type) || INTEGRAL_TYPE_P (type)
2400       || TREE_CODE (type) == OFFSET_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) == MODIFY_EXPR)
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 TARGET_EXPR:
2686   case COND_EXPR:
2687   case BIND_EXPR:
2688   case MIN_EXPR:
2689   case MAX_EXPR:
2690     break;
2691
2692   default:
2693     /* Assume the worst for front-end tree codes.  */
2694     if ((int)TREE_CODE (x) >= NUM_TREE_CODES)
2695       break;
2696     return false;
2697   }
2698
2699   return true;
2700 }
2701
2702 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2703
2704 tree
2705 non_lvalue (tree x)
2706 {
2707   /* While we are in GIMPLE, NON_LVALUE_EXPR doesn't mean anything to
2708      us.  */
2709   if (in_gimple_form)
2710     return x;
2711
2712   if (! maybe_lvalue_p (x))
2713     return x;
2714   return build1 (NON_LVALUE_EXPR, TREE_TYPE (x), x);
2715 }
2716
2717 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2718    Zero means allow extended lvalues.  */
2719
2720 int pedantic_lvalues;
2721
2722 /* When pedantic, return an expr equal to X but certainly not valid as a
2723    pedantic lvalue.  Otherwise, return X.  */
2724
2725 static tree
2726 pedantic_non_lvalue (tree x)
2727 {
2728   if (pedantic_lvalues)
2729     return non_lvalue (x);
2730   else
2731     return x;
2732 }
2733 \f
2734 /* Given a tree comparison code, return the code that is the logical inverse
2735    of the given code.  It is not safe to do this for floating-point
2736    comparisons, except for NE_EXPR and EQ_EXPR, so we receive a machine mode
2737    as well: if reversing the comparison is unsafe, return ERROR_MARK.  */
2738
2739 enum tree_code
2740 invert_tree_comparison (enum tree_code code, bool honor_nans)
2741 {
2742   if (honor_nans && flag_trapping_math)
2743     return ERROR_MARK;
2744
2745   switch (code)
2746     {
2747     case EQ_EXPR:
2748       return NE_EXPR;
2749     case NE_EXPR:
2750       return EQ_EXPR;
2751     case GT_EXPR:
2752       return honor_nans ? UNLE_EXPR : LE_EXPR;
2753     case GE_EXPR:
2754       return honor_nans ? UNLT_EXPR : LT_EXPR;
2755     case LT_EXPR:
2756       return honor_nans ? UNGE_EXPR : GE_EXPR;
2757     case LE_EXPR:
2758       return honor_nans ? UNGT_EXPR : GT_EXPR;
2759     case LTGT_EXPR:
2760       return UNEQ_EXPR;
2761     case UNEQ_EXPR:
2762       return LTGT_EXPR;
2763     case UNGT_EXPR:
2764       return LE_EXPR;
2765     case UNGE_EXPR:
2766       return LT_EXPR;
2767     case UNLT_EXPR:
2768       return GE_EXPR;
2769     case UNLE_EXPR:
2770       return GT_EXPR;
2771     case ORDERED_EXPR:
2772       return UNORDERED_EXPR;
2773     case UNORDERED_EXPR:
2774       return ORDERED_EXPR;
2775     default:
2776       gcc_unreachable ();
2777     }
2778 }
2779
2780 /* Similar, but return the comparison that results if the operands are
2781    swapped.  This is safe for floating-point.  */
2782
2783 enum tree_code
2784 swap_tree_comparison (enum tree_code code)
2785 {
2786   switch (code)
2787     {
2788     case EQ_EXPR:
2789     case NE_EXPR:
2790     case ORDERED_EXPR:
2791     case UNORDERED_EXPR:
2792     case LTGT_EXPR:
2793     case UNEQ_EXPR:
2794       return code;
2795     case GT_EXPR:
2796       return LT_EXPR;
2797     case GE_EXPR:
2798       return LE_EXPR;
2799     case LT_EXPR:
2800       return GT_EXPR;
2801     case LE_EXPR:
2802       return GE_EXPR;
2803     case UNGT_EXPR:
2804       return UNLT_EXPR;
2805     case UNGE_EXPR:
2806       return UNLE_EXPR;
2807     case UNLT_EXPR:
2808       return UNGT_EXPR;
2809     case UNLE_EXPR:
2810       return UNGE_EXPR;
2811     default:
2812       gcc_unreachable ();
2813     }
2814 }
2815
2816
2817 /* Convert a comparison tree code from an enum tree_code representation
2818    into a compcode bit-based encoding.  This function is the inverse of
2819    compcode_to_comparison.  */
2820
2821 static enum comparison_code
2822 comparison_to_compcode (enum tree_code code)
2823 {
2824   switch (code)
2825     {
2826     case LT_EXPR:
2827       return COMPCODE_LT;
2828     case EQ_EXPR:
2829       return COMPCODE_EQ;
2830     case LE_EXPR:
2831       return COMPCODE_LE;
2832     case GT_EXPR:
2833       return COMPCODE_GT;
2834     case NE_EXPR:
2835       return COMPCODE_NE;
2836     case GE_EXPR:
2837       return COMPCODE_GE;
2838     case ORDERED_EXPR:
2839       return COMPCODE_ORD;
2840     case UNORDERED_EXPR:
2841       return COMPCODE_UNORD;
2842     case UNLT_EXPR:
2843       return COMPCODE_UNLT;
2844     case UNEQ_EXPR:
2845       return COMPCODE_UNEQ;
2846     case UNLE_EXPR:
2847       return COMPCODE_UNLE;
2848     case UNGT_EXPR:
2849       return COMPCODE_UNGT;
2850     case LTGT_EXPR:
2851       return COMPCODE_LTGT;
2852     case UNGE_EXPR:
2853       return COMPCODE_UNGE;
2854     default:
2855       gcc_unreachable ();
2856     }
2857 }
2858
2859 /* Convert a compcode bit-based encoding of a comparison operator back
2860    to GCC's enum tree_code representation.  This function is the
2861    inverse of comparison_to_compcode.  */
2862
2863 static enum tree_code
2864 compcode_to_comparison (enum comparison_code code)
2865 {
2866   switch (code)
2867     {
2868     case COMPCODE_LT:
2869       return LT_EXPR;
2870     case COMPCODE_EQ:
2871       return EQ_EXPR;
2872     case COMPCODE_LE:
2873       return LE_EXPR;
2874     case COMPCODE_GT:
2875       return GT_EXPR;
2876     case COMPCODE_NE:
2877       return NE_EXPR;
2878     case COMPCODE_GE:
2879       return GE_EXPR;
2880     case COMPCODE_ORD:
2881       return ORDERED_EXPR;
2882     case COMPCODE_UNORD:
2883       return UNORDERED_EXPR;
2884     case COMPCODE_UNLT:
2885       return UNLT_EXPR;
2886     case COMPCODE_UNEQ:
2887       return UNEQ_EXPR;
2888     case COMPCODE_UNLE:
2889       return UNLE_EXPR;
2890     case COMPCODE_UNGT:
2891       return UNGT_EXPR;
2892     case COMPCODE_LTGT:
2893       return LTGT_EXPR;
2894     case COMPCODE_UNGE:
2895       return UNGE_EXPR;
2896     default:
2897       gcc_unreachable ();
2898     }
2899 }
2900
2901 /* Return a tree for the comparison which is the combination of
2902    doing the AND or OR (depending on CODE) of the two operations LCODE
2903    and RCODE on the identical operands LL_ARG and LR_ARG.  Take into account
2904    the possibility of trapping if the mode has NaNs, and return NULL_TREE
2905    if this makes the transformation invalid.  */
2906
2907 tree
2908 combine_comparisons (enum tree_code code, enum tree_code lcode,
2909                      enum tree_code rcode, tree truth_type,
2910                      tree ll_arg, tree lr_arg)
2911 {
2912   bool honor_nans = HONOR_NANS (TYPE_MODE (TREE_TYPE (ll_arg)));
2913   enum comparison_code lcompcode = comparison_to_compcode (lcode);
2914   enum comparison_code rcompcode = comparison_to_compcode (rcode);
2915   enum comparison_code compcode;
2916
2917   switch (code)
2918     {
2919     case TRUTH_AND_EXPR: case TRUTH_ANDIF_EXPR:
2920       compcode = lcompcode & rcompcode;
2921       break;
2922
2923     case TRUTH_OR_EXPR: case TRUTH_ORIF_EXPR:
2924       compcode = lcompcode | rcompcode;
2925       break;
2926
2927     default:
2928       return NULL_TREE;
2929     }
2930
2931   if (!honor_nans)
2932     {
2933       /* Eliminate unordered comparisons, as well as LTGT and ORD
2934          which are not used unless the mode has NaNs.  */
2935       compcode &= ~COMPCODE_UNORD;
2936       if (compcode == COMPCODE_LTGT)
2937         compcode = COMPCODE_NE;
2938       else if (compcode == COMPCODE_ORD)
2939         compcode = COMPCODE_TRUE;
2940     }
2941    else if (flag_trapping_math)
2942      {
2943         /* Check that the original operation and the optimized ones will trap
2944            under the same condition.  */
2945         bool ltrap = (lcompcode & COMPCODE_UNORD) == 0
2946                      && (lcompcode != COMPCODE_EQ)
2947                      && (lcompcode != COMPCODE_ORD);
2948         bool rtrap = (rcompcode & COMPCODE_UNORD) == 0
2949                      && (rcompcode != COMPCODE_EQ)
2950                      && (rcompcode != COMPCODE_ORD);
2951         bool trap = (compcode & COMPCODE_UNORD) == 0
2952                     && (compcode != COMPCODE_EQ)
2953                     && (compcode != COMPCODE_ORD);
2954
2955         /* In a short-circuited boolean expression the LHS might be
2956            such that the RHS, if evaluated, will never trap.  For
2957            example, in ORD (x, y) && (x < y), we evaluate the RHS only
2958            if neither x nor y is NaN.  (This is a mixed blessing: for
2959            example, the expression above will never trap, hence
2960            optimizing it to x < y would be invalid).  */
2961         if ((code == TRUTH_ORIF_EXPR && (lcompcode & COMPCODE_UNORD))
2962             || (code == TRUTH_ANDIF_EXPR && !(lcompcode & COMPCODE_UNORD)))
2963           rtrap = false;
2964
2965         /* If the comparison was short-circuited, and only the RHS
2966            trapped, we may now generate a spurious trap.  */
2967         if (rtrap && !ltrap
2968             && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
2969           return NULL_TREE;
2970
2971         /* If we changed the conditions that cause a trap, we lose.  */
2972         if ((ltrap || rtrap) != trap)
2973           return NULL_TREE;
2974       }
2975
2976   if (compcode == COMPCODE_TRUE)
2977     return constant_boolean_node (true, truth_type);
2978   else if (compcode == COMPCODE_FALSE)
2979     return constant_boolean_node (false, truth_type);
2980   else
2981     return fold_build2 (compcode_to_comparison (compcode),
2982                         truth_type, ll_arg, lr_arg);
2983 }
2984
2985 /* Return nonzero if CODE is a tree code that represents a truth value.  */
2986
2987 static int
2988 truth_value_p (enum tree_code code)
2989 {
2990   return (TREE_CODE_CLASS (code) == tcc_comparison
2991           || code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
2992           || code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
2993           || code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
2994 }
2995 \f
2996 /* Return nonzero if two operands (typically of the same tree node)
2997    are necessarily equal.  If either argument has side-effects this
2998    function returns zero.  FLAGS modifies behavior as follows:
2999
3000    If OEP_ONLY_CONST is set, only return nonzero for constants.
3001    This function tests whether the operands are indistinguishable;
3002    it does not test whether they are equal using C's == operation.
3003    The distinction is important for IEEE floating point, because
3004    (1) -0.0 and 0.0 are distinguishable, but -0.0==0.0, and
3005    (2) two NaNs may be indistinguishable, but NaN!=NaN.
3006
3007    If OEP_ONLY_CONST is unset, a VAR_DECL is considered equal to itself
3008    even though it may hold multiple values during a function.
3009    This is because a GCC tree node guarantees that nothing else is
3010    executed between the evaluation of its "operands" (which may often
3011    be evaluated in arbitrary order).  Hence if the operands themselves
3012    don't side-effect, the VAR_DECLs, PARM_DECLs etc... must hold the
3013    same value in each operand/subexpression.  Hence leaving OEP_ONLY_CONST
3014    unset means assuming isochronic (or instantaneous) tree equivalence.
3015    Unless comparing arbitrary expression trees, such as from different
3016    statements, this flag can usually be left unset.
3017
3018    If OEP_PURE_SAME is set, then pure functions with identical arguments
3019    are considered the same.  It is used when the caller has other ways
3020    to ensure that global memory is unchanged in between.  */
3021
3022 int
3023 operand_equal_p (const_tree arg0, const_tree arg1, unsigned int flags)
3024 {
3025   /* If either is ERROR_MARK, they aren't equal.  */
3026   if (TREE_CODE (arg0) == ERROR_MARK || TREE_CODE (arg1) == ERROR_MARK)
3027     return 0;
3028
3029   /* Check equality of integer constants before bailing out due to
3030      precision differences.  */
3031   if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
3032     return tree_int_cst_equal (arg0, arg1);
3033
3034   /* If both types don't have the same signedness, then we can't consider
3035      them equal.  We must check this before the STRIP_NOPS calls
3036      because they may change the signedness of the arguments.  As pointers
3037      strictly don't have a signedness, require either two pointers or
3038      two non-pointers as well.  */
3039   if (TYPE_UNSIGNED (TREE_TYPE (arg0)) != TYPE_UNSIGNED (TREE_TYPE (arg1))
3040       || POINTER_TYPE_P (TREE_TYPE (arg0)) != POINTER_TYPE_P (TREE_TYPE (arg1)))
3041     return 0;
3042
3043   /* If both types don't have the same precision, then it is not safe
3044      to strip NOPs.  */
3045   if (TYPE_PRECISION (TREE_TYPE (arg0)) != TYPE_PRECISION (TREE_TYPE (arg1)))
3046     return 0;
3047
3048   STRIP_NOPS (arg0);
3049   STRIP_NOPS (arg1);
3050
3051   /* In case both args are comparisons but with different comparison
3052      code, try to swap the comparison operands of one arg to produce
3053      a match and compare that variant.  */
3054   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3055       && COMPARISON_CLASS_P (arg0)
3056       && COMPARISON_CLASS_P (arg1))
3057     {
3058       enum tree_code swap_code = swap_tree_comparison (TREE_CODE (arg1));
3059
3060       if (TREE_CODE (arg0) == swap_code)
3061         return operand_equal_p (TREE_OPERAND (arg0, 0),
3062                                 TREE_OPERAND (arg1, 1), flags)
3063                && operand_equal_p (TREE_OPERAND (arg0, 1),
3064                                    TREE_OPERAND (arg1, 0), flags);
3065     }
3066
3067   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3068       /* This is needed for conversions and for COMPONENT_REF.
3069          Might as well play it safe and always test this.  */
3070       || TREE_CODE (TREE_TYPE (arg0)) == ERROR_MARK
3071       || TREE_CODE (TREE_TYPE (arg1)) == ERROR_MARK
3072       || TYPE_MODE (TREE_TYPE (arg0)) != TYPE_MODE (TREE_TYPE (arg1)))
3073     return 0;
3074
3075   /* If ARG0 and ARG1 are the same SAVE_EXPR, they are necessarily equal.
3076      We don't care about side effects in that case because the SAVE_EXPR
3077      takes care of that for us. In all other cases, two expressions are
3078      equal if they have no side effects.  If we have two identical
3079      expressions with side effects that should be treated the same due
3080      to the only side effects being identical SAVE_EXPR's, that will
3081      be detected in the recursive calls below.  */
3082   if (arg0 == arg1 && ! (flags & OEP_ONLY_CONST)
3083       && (TREE_CODE (arg0) == SAVE_EXPR
3084           || (! TREE_SIDE_EFFECTS (arg0) && ! TREE_SIDE_EFFECTS (arg1))))
3085     return 1;
3086
3087   /* Next handle constant cases, those for which we can return 1 even
3088      if ONLY_CONST is set.  */
3089   if (TREE_CONSTANT (arg0) && TREE_CONSTANT (arg1))
3090     switch (TREE_CODE (arg0))
3091       {
3092       case INTEGER_CST:
3093         return tree_int_cst_equal (arg0, arg1);
3094
3095       case FIXED_CST:
3096         return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (arg0),
3097                                        TREE_FIXED_CST (arg1));
3098
3099       case REAL_CST:
3100         if (REAL_VALUES_IDENTICAL (TREE_REAL_CST (arg0),
3101                                    TREE_REAL_CST (arg1)))
3102           return 1;
3103
3104         
3105         if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0))))
3106           {
3107             /* If we do not distinguish between signed and unsigned zero,
3108                consider them equal.  */
3109             if (real_zerop (arg0) && real_zerop (arg1))
3110               return 1;
3111           }
3112         return 0;
3113
3114       case VECTOR_CST:
3115         {
3116           tree v1, v2;
3117
3118           v1 = TREE_VECTOR_CST_ELTS (arg0);
3119           v2 = TREE_VECTOR_CST_ELTS (arg1);
3120           while (v1 && v2)
3121             {
3122               if (!operand_equal_p (TREE_VALUE (v1), TREE_VALUE (v2),
3123                                     flags))
3124                 return 0;
3125               v1 = TREE_CHAIN (v1);
3126               v2 = TREE_CHAIN (v2);
3127             }
3128
3129           return v1 == v2;
3130         }
3131
3132       case COMPLEX_CST:
3133         return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1),
3134                                  flags)
3135                 && operand_equal_p (TREE_IMAGPART (arg0), TREE_IMAGPART (arg1),
3136                                     flags));
3137
3138       case STRING_CST:
3139         return (TREE_STRING_LENGTH (arg0) == TREE_STRING_LENGTH (arg1)
3140                 && ! memcmp (TREE_STRING_POINTER (arg0),
3141                               TREE_STRING_POINTER (arg1),
3142                               TREE_STRING_LENGTH (arg0)));
3143
3144       case ADDR_EXPR:
3145         return operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0),
3146                                 0);
3147       default:
3148         break;
3149       }
3150
3151   if (flags & OEP_ONLY_CONST)
3152     return 0;
3153
3154 /* Define macros to test an operand from arg0 and arg1 for equality and a
3155    variant that allows null and views null as being different from any
3156    non-null value.  In the latter case, if either is null, the both
3157    must be; otherwise, do the normal comparison.  */
3158 #define OP_SAME(N) operand_equal_p (TREE_OPERAND (arg0, N),     \
3159                                     TREE_OPERAND (arg1, N), flags)
3160
3161 #define OP_SAME_WITH_NULL(N)                            \
3162   ((!TREE_OPERAND (arg0, N) || !TREE_OPERAND (arg1, N)) \
3163    ? TREE_OPERAND (arg0, N) == TREE_OPERAND (arg1, N) : OP_SAME (N))
3164
3165   switch (TREE_CODE_CLASS (TREE_CODE (arg0)))
3166     {
3167     case tcc_unary:
3168       /* Two conversions are equal only if signedness and modes match.  */
3169       switch (TREE_CODE (arg0))
3170         {
3171         CASE_CONVERT:
3172         case FIX_TRUNC_EXPR:
3173           if (TYPE_UNSIGNED (TREE_TYPE (arg0))
3174               != TYPE_UNSIGNED (TREE_TYPE (arg1)))
3175             return 0;
3176           break;
3177         default:
3178           break;
3179         }
3180
3181       return OP_SAME (0);
3182
3183
3184     case tcc_comparison:
3185     case tcc_binary:
3186       if (OP_SAME (0) && OP_SAME (1))
3187         return 1;
3188
3189       /* For commutative ops, allow the other order.  */
3190       return (commutative_tree_code (TREE_CODE (arg0))
3191               && operand_equal_p (TREE_OPERAND (arg0, 0),
3192                                   TREE_OPERAND (arg1, 1), flags)
3193               && operand_equal_p (TREE_OPERAND (arg0, 1),
3194                                   TREE_OPERAND (arg1, 0), flags));
3195
3196     case tcc_reference:
3197       /* If either of the pointer (or reference) expressions we are
3198          dereferencing contain a side effect, these cannot be equal.  */
3199       if (TREE_SIDE_EFFECTS (arg0)
3200           || TREE_SIDE_EFFECTS (arg1))
3201         return 0;
3202
3203       switch (TREE_CODE (arg0))
3204         {
3205         case INDIRECT_REF:
3206         case ALIGN_INDIRECT_REF:
3207         case MISALIGNED_INDIRECT_REF:
3208         case REALPART_EXPR:
3209         case IMAGPART_EXPR:
3210           return OP_SAME (0);
3211
3212         case ARRAY_REF:
3213         case ARRAY_RANGE_REF:
3214           /* Operands 2 and 3 may be null.
3215              Compare the array index by value if it is constant first as we
3216              may have different types but same value here.  */
3217           return (OP_SAME (0)
3218                   && (tree_int_cst_equal (TREE_OPERAND (arg0, 1),
3219                                           TREE_OPERAND (arg1, 1))
3220                       || OP_SAME (1))
3221                   && OP_SAME_WITH_NULL (2)
3222                   && OP_SAME_WITH_NULL (3));
3223
3224         case COMPONENT_REF:
3225           /* Handle operand 2 the same as for ARRAY_REF.  Operand 0
3226              may be NULL when we're called to compare MEM_EXPRs.  */
3227           return OP_SAME_WITH_NULL (0)
3228                  && OP_SAME (1)
3229                  && OP_SAME_WITH_NULL (2);
3230
3231         case BIT_FIELD_REF:
3232           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3233
3234         default:
3235           return 0;
3236         }
3237
3238     case tcc_expression:
3239       switch (TREE_CODE (arg0))
3240         {
3241         case ADDR_EXPR:
3242         case TRUTH_NOT_EXPR:
3243           return OP_SAME (0);
3244
3245         case TRUTH_ANDIF_EXPR:
3246         case TRUTH_ORIF_EXPR:
3247           return OP_SAME (0) && OP_SAME (1);
3248
3249         case TRUTH_AND_EXPR:
3250         case TRUTH_OR_EXPR:
3251         case TRUTH_XOR_EXPR:
3252           if (OP_SAME (0) && OP_SAME (1))
3253             return 1;
3254
3255           /* Otherwise take into account this is a commutative operation.  */
3256           return (operand_equal_p (TREE_OPERAND (arg0, 0),
3257                                    TREE_OPERAND (arg1, 1), flags)
3258                   && operand_equal_p (TREE_OPERAND (arg0, 1),
3259                                       TREE_OPERAND (arg1, 0), flags));
3260
3261         case COND_EXPR:
3262           return OP_SAME (0) && OP_SAME (1) && OP_SAME (2);
3263           
3264         default:
3265           return 0;
3266         }
3267
3268     case tcc_vl_exp:
3269       switch (TREE_CODE (arg0))
3270         {
3271         case CALL_EXPR:
3272           /* If the CALL_EXPRs call different functions, then they
3273              clearly can not be equal.  */
3274           if (! operand_equal_p (CALL_EXPR_FN (arg0), CALL_EXPR_FN (arg1),
3275                                  flags))
3276             return 0;
3277
3278           {
3279             unsigned int cef = call_expr_flags (arg0);
3280             if (flags & OEP_PURE_SAME)
3281               cef &= ECF_CONST | ECF_PURE;
3282             else
3283               cef &= ECF_CONST;
3284             if (!cef)
3285               return 0;
3286           }
3287
3288           /* Now see if all the arguments are the same.  */
3289           {
3290             const_call_expr_arg_iterator iter0, iter1;
3291             const_tree a0, a1;
3292             for (a0 = first_const_call_expr_arg (arg0, &iter0),
3293                    a1 = first_const_call_expr_arg (arg1, &iter1);
3294                  a0 && a1;
3295                  a0 = next_const_call_expr_arg (&iter0),
3296                    a1 = next_const_call_expr_arg (&iter1))
3297               if (! operand_equal_p (a0, a1, flags))
3298                 return 0;
3299
3300             /* If we get here and both argument lists are exhausted
3301                then the CALL_EXPRs are equal.  */
3302             return ! (a0 || a1);
3303           }
3304         default:
3305           return 0;
3306         }
3307
3308     case tcc_declaration:
3309       /* Consider __builtin_sqrt equal to sqrt.  */
3310       return (TREE_CODE (arg0) == FUNCTION_DECL
3311               && DECL_BUILT_IN (arg0) && DECL_BUILT_IN (arg1)
3312               && DECL_BUILT_IN_CLASS (arg0) == DECL_BUILT_IN_CLASS (arg1)
3313               && DECL_FUNCTION_CODE (arg0) == DECL_FUNCTION_CODE (arg1));
3314
3315     default:
3316       return 0;
3317     }
3318
3319 #undef OP_SAME
3320 #undef OP_SAME_WITH_NULL
3321 }
3322 \f
3323 /* Similar to operand_equal_p, but see if ARG0 might have been made by
3324    shorten_compare from ARG1 when ARG1 was being compared with OTHER.
3325
3326    When in doubt, return 0.  */
3327
3328 static int
3329 operand_equal_for_comparison_p (tree arg0, tree arg1, tree other)
3330 {
3331   int unsignedp1, unsignedpo;
3332   tree primarg0, primarg1, primother;
3333   unsigned int correct_width;
3334
3335   if (operand_equal_p (arg0, arg1, 0))
3336     return 1;
3337
3338   if (! INTEGRAL_TYPE_P (TREE_TYPE (arg0))
3339       || ! INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
3340     return 0;
3341
3342   /* Discard any conversions that don't change the modes of ARG0 and ARG1
3343      and see if the inner values are the same.  This removes any
3344      signedness comparison, which doesn't matter here.  */
3345   primarg0 = arg0, primarg1 = arg1;
3346   STRIP_NOPS (primarg0);
3347   STRIP_NOPS (primarg1);
3348   if (operand_equal_p (primarg0, primarg1, 0))
3349     return 1;
3350
3351   /* Duplicate what shorten_compare does to ARG1 and see if that gives the
3352      actual comparison operand, ARG0.
3353
3354      First throw away any conversions to wider types
3355      already present in the operands.  */
3356
3357   primarg1 = get_narrower (arg1, &unsignedp1);
3358   primother = get_narrower (other, &unsignedpo);
3359
3360   correct_width = TYPE_PRECISION (TREE_TYPE (arg1));
3361   if (unsignedp1 == unsignedpo
3362       && TYPE_PRECISION (TREE_TYPE (primarg1)) < correct_width
3363       && TYPE_PRECISION (TREE_TYPE (primother)) < correct_width)
3364     {
3365       tree type = TREE_TYPE (arg0);
3366
3367       /* Make sure shorter operand is extended the right way
3368          to match the longer operand.  */
3369       primarg1 = fold_convert (signed_or_unsigned_type_for
3370                                (unsignedp1, TREE_TYPE (primarg1)), primarg1);
3371
3372       if (operand_equal_p (arg0, fold_convert (type, primarg1), 0))
3373         return 1;
3374     }
3375
3376   return 0;
3377 }
3378 \f
3379 /* See if ARG is an expression that is either a comparison or is performing
3380    arithmetic on comparisons.  The comparisons must only be comparing
3381    two different values, which will be stored in *CVAL1 and *CVAL2; if
3382    they are nonzero it means that some operands have already been found.
3383    No variables may be used anywhere else in the expression except in the
3384    comparisons.  If SAVE_P is true it means we removed a SAVE_EXPR around
3385    the expression and save_expr needs to be called with CVAL1 and CVAL2.
3386
3387    If this is true, return 1.  Otherwise, return zero.  */
3388
3389 static int
3390 twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
3391 {
3392   enum tree_code code = TREE_CODE (arg);
3393   enum tree_code_class tclass = TREE_CODE_CLASS (code);
3394
3395   /* We can handle some of the tcc_expression cases here.  */
3396   if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3397     tclass = tcc_unary;
3398   else if (tclass == tcc_expression
3399            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
3400                || code == COMPOUND_EXPR))
3401     tclass = tcc_binary;
3402
3403   else if (tclass == tcc_expression && code == SAVE_EXPR
3404            && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
3405     {
3406       /* If we've already found a CVAL1 or CVAL2, this expression is
3407          two complex to handle.  */
3408       if (*cval1 || *cval2)
3409         return 0;
3410
3411       tclass = tcc_unary;
3412       *save_p = 1;
3413     }
3414
3415   switch (tclass)
3416     {
3417     case tcc_unary:
3418       return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
3419
3420     case tcc_binary:
3421       return (twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p)
3422               && twoval_comparison_p (TREE_OPERAND (arg, 1),
3423                                       cval1, cval2, save_p));
3424
3425     case tcc_constant:
3426       return 1;
3427
3428     case tcc_expression:
3429       if (code == COND_EXPR)
3430         return (twoval_comparison_p (TREE_OPERAND (arg, 0),
3431                                      cval1, cval2, save_p)
3432                 && twoval_comparison_p (TREE_OPERAND (arg, 1),
3433                                         cval1, cval2, save_p)
3434                 && twoval_comparison_p (TREE_OPERAND (arg, 2),
3435                                         cval1, cval2, save_p));
3436       return 0;
3437
3438     case tcc_comparison:
3439       /* First see if we can handle the first operand, then the second.  For
3440          the second operand, we know *CVAL1 can't be zero.  It must be that
3441          one side of the comparison is each of the values; test for the
3442          case where this isn't true by failing if the two operands
3443          are the same.  */
3444
3445       if (operand_equal_p (TREE_OPERAND (arg, 0),
3446                            TREE_OPERAND (arg, 1), 0))
3447         return 0;
3448
3449       if (*cval1 == 0)
3450         *cval1 = TREE_OPERAND (arg, 0);
3451       else if (operand_equal_p (*cval1, TREE_OPERAND (arg, 0), 0))
3452         ;
3453       else if (*cval2 == 0)
3454         *cval2 = TREE_OPERAND (arg, 0);
3455       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 0), 0))
3456         ;
3457       else
3458         return 0;
3459
3460       if (operand_equal_p (*cval1, TREE_OPERAND (arg, 1), 0))
3461         ;
3462       else if (*cval2 == 0)
3463         *cval2 = TREE_OPERAND (arg, 1);
3464       else if (operand_equal_p (*cval2, TREE_OPERAND (arg, 1), 0))
3465         ;
3466       else
3467         return 0;
3468
3469       return 1;
3470
3471     default:
3472       return 0;
3473     }
3474 }
3475 \f
3476 /* ARG is a tree that is known to contain just arithmetic operations and
3477    comparisons.  Evaluate the operations in the tree substituting NEW0 for
3478    any occurrence of OLD0 as an operand of a comparison and likewise for
3479    NEW1 and OLD1.  */
3480
3481 static tree
3482 eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
3483 {
3484   tree type = TREE_TYPE (arg);
3485   enum tree_code code = TREE_CODE (arg);
3486   enum tree_code_class tclass = TREE_CODE_CLASS (code);
3487
3488   /* We can handle some of the tcc_expression cases here.  */
3489   if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
3490     tclass = tcc_unary;
3491   else if (tclass == tcc_expression
3492            && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
3493     tclass = tcc_binary;
3494
3495   switch (tclass)
3496     {
3497     case tcc_unary:
3498       return fold_build1 (code, type,
3499                           eval_subst (TREE_OPERAND (arg, 0),
3500                                       old0, new0, old1, new1));
3501
3502     case tcc_binary:
3503       return fold_build2 (code, type,
3504                           eval_subst (TREE_OPERAND (arg, 0),
3505                                       old0, new0, old1, new1),
3506                           eval_subst (TREE_OPERAND (arg, 1),
3507                                       old0, new0, old1, new1));
3508
3509     case tcc_expression:
3510       switch (code)
3511         {
3512         case SAVE_EXPR:
3513           return eval_subst (TREE_OPERAND (arg, 0), old0, new0, old1, new1);
3514
3515         case COMPOUND_EXPR:
3516           return eval_subst (TREE_OPERAND (arg, 1), old0, new0, old1, new1);
3517
3518         case COND_EXPR:
3519           return fold_build3 (code, type,
3520                               eval_subst (TREE_OPERAND (arg, 0),
3521                                           old0, new0, old1, new1),
3522                               eval_subst (TREE_OPERAND (arg, 1),
3523                                           old0, new0, old1, new1),
3524                               eval_subst (TREE_OPERAND (arg, 2),
3525                                           old0, new0, old1, new1));
3526         default:
3527           break;
3528         }
3529       /* Fall through - ???  */
3530
3531     case tcc_comparison:
3532       {
3533         tree arg0 = TREE_OPERAND (arg, 0);
3534         tree arg1 = TREE_OPERAND (arg, 1);
3535
3536         /* We need to check both for exact equality and tree equality.  The
3537            former will be true if the operand has a side-effect.  In that
3538            case, we know the operand occurred exactly once.  */
3539
3540         if (arg0 == old0 || operand_equal_p (arg0, old0, 0))
3541           arg0 = new0;
3542         else if (arg0 == old1 || operand_equal_p (arg0, old1, 0))
3543           arg0 = new1;
3544
3545         if (arg1 == old0 || operand_equal_p (arg1, old0, 0))
3546           arg1 = new0;
3547         else if (arg1 == old1 || operand_equal_p (arg1, old1, 0))
3548           arg1 = new1;
3549
3550         return fold_build2 (code, type, arg0, arg1);
3551       }
3552
3553     default:
3554       return arg;
3555     }
3556 }
3557 \f
3558 /* Return a tree for the case when the result of an expression is RESULT
3559    converted to TYPE and OMITTED was previously an operand of the expression
3560    but is now not needed (e.g., we folded OMITTED * 0).
3561
3562    If OMITTED has side effects, we must evaluate it.  Otherwise, just do
3563    the conversion of RESULT to TYPE.  */
3564
3565 tree
3566 omit_one_operand (tree type, tree result, tree omitted)
3567 {
3568   tree t = fold_convert (type, result);
3569
3570   /* If the resulting operand is an empty statement, just return the omitted
3571      statement casted to void. */
3572   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3573     return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
3574
3575   if (TREE_SIDE_EFFECTS (omitted))
3576     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3577
3578   return non_lvalue (t);
3579 }
3580
3581 /* Similar, but call pedantic_non_lvalue instead of non_lvalue.  */
3582
3583 static tree
3584 pedantic_omit_one_operand (tree type, tree result, tree omitted)
3585 {
3586   tree t = fold_convert (type, result);
3587
3588   /* If the resulting operand is an empty statement, just return the omitted
3589      statement casted to void. */
3590   if (IS_EMPTY_STMT (t) && TREE_SIDE_EFFECTS (omitted))
3591     return build1 (NOP_EXPR, void_type_node, fold_ignored_result (omitted));
3592
3593   if (TREE_SIDE_EFFECTS (omitted))
3594     return build2 (COMPOUND_EXPR, type, fold_ignored_result (omitted), t);
3595
3596   return pedantic_non_lvalue (t);
3597 }
3598
3599 /* Return a tree for the case when the result of an expression is RESULT
3600    converted to TYPE and OMITTED1 and OMITTED2 were previously operands
3601    of the expression but are now not needed.
3602
3603    If OMITTED1 or OMITTED2 has side effects, they must be evaluated.
3604    If both OMITTED1 and OMITTED2 have side effects, OMITTED1 is
3605    evaluated before OMITTED2.  Otherwise, if neither has side effects,
3606    just do the conversion of RESULT to TYPE.  */
3607
3608 tree
3609 omit_two_operands (tree type, tree result, tree omitted1, tree omitted2)
3610 {
3611   tree t = fold_convert (type, result);
3612
3613   if (TREE_SIDE_EFFECTS (omitted2))
3614     t = build2 (COMPOUND_EXPR, type, omitted2, t);
3615   if (TREE_SIDE_EFFECTS (omitted1))
3616     t = build2 (COMPOUND_EXPR, type, omitted1, t);
3617
3618   return TREE_CODE (t) != COMPOUND_EXPR ? non_lvalue (t) : t;
3619 }
3620
3621 \f
3622 /* Return a simplified tree node for the truth-negation of ARG.  This
3623    never alters ARG itself.  We assume that ARG is an operation that
3624    returns a truth value (0 or 1).
3625
3626    FIXME: one would think we would fold the result, but it causes
3627    problems with the dominator optimizer.  */
3628
3629 tree
3630 fold_truth_not_expr (tree arg)
3631 {
3632   tree type = TREE_TYPE (arg);
3633   enum tree_code code = TREE_CODE (arg);
3634
3635   /* If this is a comparison, we can simply invert it, except for
3636      floating-point non-equality comparisons, in which case we just
3637      enclose a TRUTH_NOT_EXPR around what we have.  */
3638
3639   if (TREE_CODE_CLASS (code) == tcc_comparison)
3640     {
3641       tree op_type = TREE_TYPE (TREE_OPERAND (arg, 0));
3642       if (FLOAT_TYPE_P (op_type)
3643           && flag_trapping_math
3644           && code != ORDERED_EXPR && code != UNORDERED_EXPR
3645           && code != NE_EXPR && code != EQ_EXPR)
3646         return NULL_TREE;
3647       else
3648         {
3649           code = invert_tree_comparison (code,
3650                                          HONOR_NANS (TYPE_MODE (op_type)));
3651           if (code == ERROR_MARK)
3652             return NULL_TREE;
3653           else
3654             return build2 (code, type,
3655                            TREE_OPERAND (arg, 0), TREE_OPERAND (arg, 1));
3656         }
3657     }
3658
3659   switch (code)
3660     {
3661     case INTEGER_CST:
3662       return constant_boolean_node (integer_zerop (arg), type);
3663
3664     case TRUTH_AND_EXPR:
3665       return build2 (TRUTH_OR_EXPR, type,
3666                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3667                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3668
3669     case TRUTH_OR_EXPR:
3670       return build2 (TRUTH_AND_EXPR, type,
3671                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3672                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3673
3674     case TRUTH_XOR_EXPR:
3675       /* Here we can invert either operand.  We invert the first operand
3676          unless the second operand is a TRUTH_NOT_EXPR in which case our
3677          result is the XOR of the first operand with the inside of the
3678          negation of the second operand.  */
3679
3680       if (TREE_CODE (TREE_OPERAND (arg, 1)) == TRUTH_NOT_EXPR)
3681         return build2 (TRUTH_XOR_EXPR, type, TREE_OPERAND (arg, 0),
3682                        TREE_OPERAND (TREE_OPERAND (arg, 1), 0));
3683       else
3684         return build2 (TRUTH_XOR_EXPR, type,
3685                        invert_truthvalue (TREE_OPERAND (arg, 0)),
3686                        TREE_OPERAND (arg, 1));
3687
3688     case TRUTH_ANDIF_EXPR:
3689       return build2 (TRUTH_ORIF_EXPR, type,
3690                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3691                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3692
3693     case TRUTH_ORIF_EXPR:
3694       return build2 (TRUTH_ANDIF_EXPR, type,
3695                      invert_truthvalue (TREE_OPERAND (arg, 0)),
3696                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3697
3698     case TRUTH_NOT_EXPR:
3699       return TREE_OPERAND (arg, 0);
3700
3701     case COND_EXPR:
3702       {
3703         tree arg1 = TREE_OPERAND (arg, 1);
3704         tree arg2 = TREE_OPERAND (arg, 2);
3705         /* A COND_EXPR may have a throw as one operand, which
3706            then has void type.  Just leave void operands
3707            as they are.  */
3708         return build3 (COND_EXPR, type, TREE_OPERAND (arg, 0),
3709                        VOID_TYPE_P (TREE_TYPE (arg1))
3710                        ? arg1 : invert_truthvalue (arg1),
3711                        VOID_TYPE_P (TREE_TYPE (arg2))
3712                        ? arg2 : invert_truthvalue (arg2));
3713       }
3714
3715     case COMPOUND_EXPR:
3716       return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg, 0),
3717                      invert_truthvalue (TREE_OPERAND (arg, 1)));
3718
3719     case NON_LVALUE_EXPR:
3720       return invert_truthvalue (TREE_OPERAND (arg, 0));
3721
3722     case NOP_EXPR:
3723       if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3724         return build1 (TRUTH_NOT_EXPR, type, arg);
3725
3726     case CONVERT_EXPR:
3727     case FLOAT_EXPR:
3728       return build1 (TREE_CODE (arg), type,
3729                      invert_truthvalue (TREE_OPERAND (arg, 0)));
3730
3731     case BIT_AND_EXPR:
3732       if (!integer_onep (TREE_OPERAND (arg, 1)))
3733         break;
3734       return build2 (EQ_EXPR, type, arg,
3735                      build_int_cst (type, 0));
3736
3737     case SAVE_EXPR:
3738       return build1 (TRUTH_NOT_EXPR, type, arg);
3739
3740     case CLEANUP_POINT_EXPR:
3741       return build1 (CLEANUP_POINT_EXPR, type,
3742                      invert_truthvalue (TREE_OPERAND (arg, 0)));
3743
3744     default:
3745       break;
3746     }
3747
3748   return NULL_TREE;
3749 }
3750
3751 /* Return a simplified tree node for the truth-negation of ARG.  This
3752    never alters ARG itself.  We assume that ARG is an operation that
3753    returns a truth value (0 or 1).
3754
3755    FIXME: one would think we would fold the result, but it causes
3756    problems with the dominator optimizer.  */
3757
3758 tree
3759 invert_truthvalue (tree arg)
3760 {
3761   tree tem;
3762
3763   if (TREE_CODE (arg) == ERROR_MARK)
3764     return arg;
3765
3766   tem = fold_truth_not_expr (arg);
3767   if (!tem)
3768     tem = build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg), arg);
3769
3770   return tem;
3771 }
3772
3773 /* Given a bit-wise operation CODE applied to ARG0 and ARG1, see if both
3774    operands are another bit-wise operation with a common input.  If so,
3775    distribute the bit operations to save an operation and possibly two if
3776    constants are involved.  For example, convert
3777         (A | B) & (A | C) into A | (B & C)
3778    Further simplification will occur if B and C are constants.
3779
3780    If this optimization cannot be done, 0 will be returned.  */
3781
3782 static tree
3783 distribute_bit_expr (enum tree_code code, tree type, tree arg0, tree arg1)
3784 {
3785   tree common;
3786   tree left, right;
3787
3788   if (TREE_CODE (arg0) != TREE_CODE (arg1)
3789       || TREE_CODE (arg0) == code
3790       || (TREE_CODE (arg0) != BIT_AND_EXPR
3791           && TREE_CODE (arg0) != BIT_IOR_EXPR))
3792     return 0;
3793
3794   if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 0), 0))
3795     {
3796       common = TREE_OPERAND (arg0, 0);
3797       left = TREE_OPERAND (arg0, 1);
3798       right = TREE_OPERAND (arg1, 1);
3799     }
3800   else if (operand_equal_p (TREE_OPERAND (arg0, 0), TREE_OPERAND (arg1, 1), 0))
3801     {
3802       common = TREE_OPERAND (arg0, 0);
3803       left = TREE_OPERAND (arg0, 1);
3804       right = TREE_OPERAND (arg1, 0);
3805     }
3806   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 0), 0))
3807     {
3808       common = TREE_OPERAND (arg0, 1);
3809       left = TREE_OPERAND (arg0, 0);
3810       right = TREE_OPERAND (arg1, 1);
3811     }
3812   else if (operand_equal_p (TREE_OPERAND (arg0, 1), TREE_OPERAND (arg1, 1), 0))
3813     {
3814       common = TREE_OPERAND (arg0, 1);
3815       left = TREE_OPERAND (arg0, 0);
3816       right = TREE_OPERAND (arg1, 0);
3817     }
3818   else
3819     return 0;
3820
3821   return fold_build2 (TREE_CODE (arg0), type, common,
3822                       fold_build2 (code, type, left, right));
3823 }
3824
3825 /* Knowing that ARG0 and ARG1 are both RDIV_EXPRs, simplify a binary operation
3826    with code CODE.  This optimization is unsafe.  */
3827 static tree
3828 distribute_real_division (enum tree_code code, tree type, tree arg0, tree arg1)
3829 {
3830   bool mul0 = TREE_CODE (arg0) == MULT_EXPR;
3831   bool mul1 = TREE_CODE (arg1) == MULT_EXPR;
3832
3833   /* (A / C) +- (B / C) -> (A +- B) / C.  */
3834   if (mul0 == mul1
3835       && operand_equal_p (TREE_OPERAND (arg0, 1),
3836                        TREE_OPERAND (arg1, 1), 0))
3837     return fold_build2 (mul0 ? MULT_EXPR : RDIV_EXPR, type,
3838                         fold_build2 (code, type,
3839                                      TREE_OPERAND (arg0, 0),
3840                                      TREE_OPERAND (arg1, 0)),
3841                         TREE_OPERAND (arg0, 1));
3842
3843   /* (A / C1) +- (A / C2) -> A * (1 / C1 +- 1 / C2).  */
3844   if (operand_equal_p (TREE_OPERAND (arg0, 0),
3845                        TREE_OPERAND (arg1, 0), 0)
3846       && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
3847       && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
3848     {
3849       REAL_VALUE_TYPE r0, r1;
3850       r0 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
3851       r1 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
3852       if (!mul0)
3853         real_arithmetic (&r0, RDIV_EXPR, &dconst1, &r0);
3854       if (!mul1)
3855         real_arithmetic (&r1, RDIV_EXPR, &dconst1, &r1);
3856       real_arithmetic (&r0, code, &r0, &r1);
3857       return fold_build2 (MULT_EXPR, type,
3858                           TREE_OPERAND (arg0, 0),
3859                           build_real (type, r0));
3860     }
3861
3862   return NULL_TREE;
3863 }
3864 \f
3865 /* Subroutine for fold_truthop: decode a field reference.
3866
3867    If EXP is a comparison reference, we return the innermost reference.
3868
3869    *PBITSIZE is set to the number of bits in the reference, *PBITPOS is
3870    set to the starting bit number.
3871
3872    If the innermost field can be completely contained in a mode-sized
3873    unit, *PMODE is set to that mode.  Otherwise, it is set to VOIDmode.
3874
3875    *PVOLATILEP is set to 1 if the any expression encountered is volatile;
3876    otherwise it is not changed.
3877
3878    *PUNSIGNEDP is set to the signedness of the field.
3879
3880    *PMASK is set to the mask used.  This is either contained in a
3881    BIT_AND_EXPR or derived from the width of the field.
3882
3883    *PAND_MASK is set to the mask found in a BIT_AND_EXPR, if any.
3884
3885    Return 0 if this is not a component reference or is one that we can't
3886    do anything with.  */
3887
3888 static tree
3889 decode_field_reference (tree exp, HOST_WIDE_INT *pbitsize,
3890                         HOST_WIDE_INT *pbitpos, enum machine_mode *pmode,
3891                         int *punsignedp, int *pvolatilep,
3892                         tree *pmask, tree *pand_mask)
3893 {
3894   tree outer_type = 0;
3895   tree and_mask = 0;
3896   tree mask, inner, offset;
3897   tree unsigned_type;
3898   unsigned int precision;
3899
3900   /* All the optimizations using this function assume integer fields.
3901      There are problems with FP fields since the type_for_size call
3902      below can fail for, e.g., XFmode.  */
3903   if (! INTEGRAL_TYPE_P (TREE_TYPE (exp)))
3904     return 0;
3905
3906   /* We are interested in the bare arrangement of bits, so strip everything
3907      that doesn't affect the machine mode.  However, record the type of the
3908      outermost expression if it may matter below.  */
3909   if (CONVERT_EXPR_P (exp)
3910       || TREE_CODE (exp) == NON_LVALUE_EXPR)
3911     outer_type = TREE_TYPE (exp);
3912   STRIP_NOPS (exp);
3913
3914   if (TREE_CODE (exp) == BIT_AND_EXPR)
3915     {
3916       and_mask = TREE_OPERAND (exp, 1);
3917       exp = TREE_OPERAND (exp, 0);
3918       STRIP_NOPS (exp); STRIP_NOPS (and_mask);
3919       if (TREE_CODE (and_mask) != INTEGER_CST)
3920         return 0;
3921     }
3922
3923   inner = get_inner_reference (exp, pbitsize, pbitpos, &offset, pmode,
3924                                punsignedp, pvolatilep, false);
3925   if ((inner == exp && and_mask == 0)
3926       || *pbitsize < 0 || offset != 0
3927       || TREE_CODE (inner) == PLACEHOLDER_EXPR)
3928     return 0;
3929
3930   /* If the number of bits in the reference is the same as the bitsize of
3931      the outer type, then the outer type gives the signedness. Otherwise
3932      (in case of a small bitfield) the signedness is unchanged.  */
3933   if (outer_type && *pbitsize == TYPE_PRECISION (outer_type))
3934     *punsignedp = TYPE_UNSIGNED (outer_type);
3935
3936   /* Compute the mask to access the bitfield.  */
3937   unsigned_type = lang_hooks.types.type_for_size (*pbitsize, 1);
3938   precision = TYPE_PRECISION (unsigned_type);
3939
3940   mask = build_int_cst_type (unsigned_type, -1);
3941
3942   mask = const_binop (LSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3943   mask = const_binop (RSHIFT_EXPR, mask, size_int (precision - *pbitsize), 0);
3944
3945   /* Merge it with the mask we found in the BIT_AND_EXPR, if any.  */
3946   if (and_mask != 0)
3947     mask = fold_build2 (BIT_AND_EXPR, unsigned_type,
3948                         fold_convert (unsigned_type, and_mask), mask);
3949
3950   *pmask = mask;
3951   *pand_mask = and_mask;
3952   return inner;
3953 }
3954
3955 /* Subroutine for fold: determine if VAL is the INTEGER_CONST that
3956    represents the sign bit of EXP's type.  If EXP represents a sign
3957    or zero extension, also test VAL against the unextended type.
3958    The return value is the (sub)expression whose sign bit is VAL,
3959    or NULL_TREE otherwise.  */
3960
3961 static tree
3962 sign_bit_p (tree exp, const_tree val)
3963 {
3964   unsigned HOST_WIDE_INT mask_lo, lo;
3965   HOST_WIDE_INT mask_hi, hi;
3966   int width;
3967   tree t;
3968
3969   /* Tree EXP must have an integral type.  */
3970   t = TREE_TYPE (exp);
3971   if (! INTEGRAL_TYPE_P (t))
3972     return NULL_TREE;
3973
3974   /* Tree VAL must be an integer constant.  */
3975   if (TREE_CODE (val) != INTEGER_CST
3976       || TREE_OVERFLOW (val))
3977     return NULL_TREE;
3978
3979   width = TYPE_PRECISION (t);
3980   if (width > HOST_BITS_PER_WIDE_INT)
3981     {
3982       hi = (unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1);
3983       lo = 0;
3984
3985       mask_hi = ((unsigned HOST_WIDE_INT) -1
3986                  >> (2 * HOST_BITS_PER_WIDE_INT - width));
3987       mask_lo = -1;
3988     }
3989   else
3990     {
3991       hi = 0;
3992       lo = (unsigned HOST_WIDE_INT) 1 << (width - 1);
3993
3994       mask_hi = 0;
3995       mask_lo = ((unsigned HOST_WIDE_INT) -1
3996                  >> (HOST_BITS_PER_WIDE_INT - width));
3997     }
3998
3999   /* We mask off those bits beyond TREE_TYPE (exp) so that we can
4000      treat VAL as if it were unsigned.  */
4001   if ((TREE_INT_CST_HIGH (val) & mask_hi) == hi
4002       && (TREE_INT_CST_LOW (val) & mask_lo) == lo)
4003     return exp;
4004
4005   /* Handle extension from a narrower type.  */
4006   if (TREE_CODE (exp) == NOP_EXPR
4007       && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (exp, 0))) < width)
4008     return sign_bit_p (TREE_OPERAND (exp, 0), val);
4009
4010   return NULL_TREE;
4011 }
4012
4013 /* Subroutine for fold_truthop: determine if an operand is simple enough
4014    to be evaluated unconditionally.  */
4015
4016 static int
4017 simple_operand_p (const_tree exp)
4018 {
4019   /* Strip any conversions that don't change the machine mode.  */
4020   STRIP_NOPS (exp);
4021
4022   return (CONSTANT_CLASS_P (exp)
4023           || TREE_CODE (exp) == SSA_NAME
4024           || (DECL_P (exp)
4025               && ! TREE_ADDRESSABLE (exp)
4026               && ! TREE_THIS_VOLATILE (exp)
4027               && ! DECL_NONLOCAL (exp)
4028               /* Don't regard global variables as simple.  They may be
4029                  allocated in ways unknown to the compiler (shared memory,
4030                  #pragma weak, etc).  */
4031               && ! TREE_PUBLIC (exp)
4032               && ! DECL_EXTERNAL (exp)
4033               /* Loading a static variable is unduly expensive, but global
4034                  registers aren't expensive.  */
4035               && (! TREE_STATIC (exp) || DECL_REGISTER (exp))));
4036 }
4037 \f
4038 /* The following functions are subroutines to fold_range_test and allow it to
4039    try to change a logical combination of comparisons into a range test.
4040
4041    For example, both
4042         X == 2 || X == 3 || X == 4 || X == 5
4043    and
4044         X >= 2 && X <= 5
4045    are converted to
4046         (unsigned) (X - 2) <= 3
4047
4048    We describe each set of comparisons as being either inside or outside
4049    a range, using a variable named like IN_P, and then describe the
4050    range with a lower and upper bound.  If one of the bounds is omitted,
4051    it represents either the highest or lowest value of the type.
4052
4053    In the comments below, we represent a range by two numbers in brackets
4054    preceded by a "+" to designate being inside that range, or a "-" to
4055    designate being outside that range, so the condition can be inverted by
4056    flipping the prefix.  An omitted bound is represented by a "-".  For
4057    example, "- [-, 10]" means being outside the range starting at the lowest
4058    possible value and ending at 10, in other words, being greater than 10.
4059    The range "+ [-, -]" is always true and hence the range "- [-, -]" is
4060    always false.
4061
4062    We set up things so that the missing bounds are handled in a consistent
4063    manner so neither a missing bound nor "true" and "false" need to be
4064    handled using a special case.  */
4065
4066 /* Return the result of applying CODE to ARG0 and ARG1, but handle the case
4067    of ARG0 and/or ARG1 being omitted, meaning an unlimited range. UPPER0_P
4068    and UPPER1_P are nonzero if the respective argument is an upper bound
4069    and zero for a lower.  TYPE, if nonzero, is the type of the result; it
4070    must be specified for a comparison.  ARG1 will be converted to ARG0's
4071    type if both are specified.  */
4072
4073 static tree
4074 range_binop (enum tree_code code, tree type, tree arg0, int upper0_p,
4075              tree arg1, int upper1_p)
4076 {
4077   tree tem;
4078   int result;
4079   int sgn0, sgn1;
4080
4081   /* If neither arg represents infinity, do the normal operation.
4082      Else, if not a comparison, return infinity.  Else handle the special
4083      comparison rules. Note that most of the cases below won't occur, but
4084      are handled for consistency.  */
4085
4086   if (arg0 != 0 && arg1 != 0)
4087     {
4088       tem = fold_build2 (code, type != 0 ? type : TREE_TYPE (arg0),
4089                          arg0, fold_convert (TREE_TYPE (arg0), arg1));
4090       STRIP_NOPS (tem);
4091       return TREE_CODE (tem) == INTEGER_CST ? tem : 0;
4092     }
4093
4094   if (TREE_CODE_CLASS (code) != tcc_comparison)
4095     return 0;
4096
4097   /* Set SGN[01] to -1 if ARG[01] is a lower bound, 1 for upper, and 0
4098      for neither.  In real maths, we cannot assume open ended ranges are
4099      the same. But, this is computer arithmetic, where numbers are finite.
4100      We can therefore make the transformation of any unbounded range with
4101      the value Z, Z being greater than any representable number. This permits
4102      us to treat unbounded ranges as equal.  */
4103   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
4104   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
4105   switch (code)
4106     {
4107     case EQ_EXPR:
4108       result = sgn0 == sgn1;
4109       break;
4110     case NE_EXPR:
4111       result = sgn0 != sgn1;
4112       break;
4113     case LT_EXPR:
4114       result = sgn0 < sgn1;
4115       break;
4116     case LE_EXPR:
4117       result = sgn0 <= sgn1;
4118       break;
4119     case GT_EXPR:
4120       result = sgn0 > sgn1;
4121       break;
4122     case GE_EXPR:
4123       result = sgn0 >= sgn1;
4124       break;
4125     default:
4126       gcc_unreachable ();
4127     }