OSDN Git Service

9b39f0d97225cba63a26922916c2019da1bf4312
[pf3gnuchains/gcc-fork.git] / gcc / simplify-rtx.c
1 /* RTL simplification functions for GNU compiler.
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA.  */
21
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "tree.h"
29 #include "tm_p.h"
30 #include "regs.h"
31 #include "hard-reg-set.h"
32 #include "flags.h"
33 #include "real.h"
34 #include "insn-config.h"
35 #include "recog.h"
36 #include "function.h"
37 #include "expr.h"
38 #include "toplev.h"
39 #include "output.h"
40 #include "ggc.h"
41 #include "target.h"
42
43 /* Simplification and canonicalization of RTL.  */
44
45 /* Much code operates on (low, high) pairs; the low value is an
46    unsigned wide int, the high value a signed wide int.  We
47    occasionally need to sign extend from low to high as if low were a
48    signed wide int.  */
49 #define HWI_SIGN_EXTEND(low) \
50  ((((HOST_WIDE_INT) low) < 0) ? ((HOST_WIDE_INT) -1) : ((HOST_WIDE_INT) 0))
51
52 static rtx neg_const_int (enum machine_mode, rtx);
53 static bool plus_minus_operand_p (rtx);
54 static int simplify_plus_minus_op_data_cmp (const void *, const void *);
55 static rtx simplify_plus_minus (enum rtx_code, enum machine_mode, rtx, rtx);
56 static rtx simplify_immed_subreg (enum machine_mode, rtx, enum machine_mode,
57                                   unsigned int);
58 static rtx simplify_associative_operation (enum rtx_code, enum machine_mode,
59                                            rtx, rtx);
60 static rtx simplify_relational_operation_1 (enum rtx_code, enum machine_mode,
61                                             enum machine_mode, rtx, rtx);
62 static rtx simplify_unary_operation_1 (enum rtx_code, enum machine_mode, rtx);
63 static rtx simplify_binary_operation_1 (enum rtx_code, enum machine_mode,
64                                         rtx, rtx, rtx, rtx);
65 \f
66 /* Negate a CONST_INT rtx, truncating (because a conversion from a
67    maximally negative number can overflow).  */
68 static rtx
69 neg_const_int (enum machine_mode mode, rtx i)
70 {
71   return gen_int_mode (- INTVAL (i), mode);
72 }
73
74 /* Test whether expression, X, is an immediate constant that represents
75    the most significant bit of machine mode MODE.  */
76
77 bool
78 mode_signbit_p (enum machine_mode mode, rtx x)
79 {
80   unsigned HOST_WIDE_INT val;
81   unsigned int width;
82
83   if (GET_MODE_CLASS (mode) != MODE_INT)
84     return false;
85
86   width = GET_MODE_BITSIZE (mode);
87   if (width == 0)
88     return false;
89   
90   if (width <= HOST_BITS_PER_WIDE_INT
91       && GET_CODE (x) == CONST_INT)
92     val = INTVAL (x);
93   else if (width <= 2 * HOST_BITS_PER_WIDE_INT
94            && GET_CODE (x) == CONST_DOUBLE
95            && CONST_DOUBLE_LOW (x) == 0)
96     {
97       val = CONST_DOUBLE_HIGH (x);
98       width -= HOST_BITS_PER_WIDE_INT;
99     }
100   else
101     return false;
102
103   if (width < HOST_BITS_PER_WIDE_INT)
104     val &= ((unsigned HOST_WIDE_INT) 1 << width) - 1;
105   return val == ((unsigned HOST_WIDE_INT) 1 << (width - 1));
106 }
107 \f
108 /* Make a binary operation by properly ordering the operands and
109    seeing if the expression folds.  */
110
111 rtx
112 simplify_gen_binary (enum rtx_code code, enum machine_mode mode, rtx op0,
113                      rtx op1)
114 {
115   rtx tem;
116
117   /* Put complex operands first and constants second if commutative.  */
118   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
119       && swap_commutative_operands_p (op0, op1))
120     tem = op0, op0 = op1, op1 = tem;
121
122   /* If this simplifies, do it.  */
123   tem = simplify_binary_operation (code, mode, op0, op1);
124   if (tem)
125     return tem;
126
127   return gen_rtx_fmt_ee (code, mode, op0, op1);
128 }
129 \f
130 /* If X is a MEM referencing the constant pool, return the real value.
131    Otherwise return X.  */
132 rtx
133 avoid_constant_pool_reference (rtx x)
134 {
135   rtx c, tmp, addr;
136   enum machine_mode cmode;
137   HOST_WIDE_INT offset = 0;
138
139   switch (GET_CODE (x))
140     {
141     case MEM:
142       break;
143
144     case FLOAT_EXTEND:
145       /* Handle float extensions of constant pool references.  */
146       tmp = XEXP (x, 0);
147       c = avoid_constant_pool_reference (tmp);
148       if (c != tmp && GET_CODE (c) == CONST_DOUBLE)
149         {
150           REAL_VALUE_TYPE d;
151
152           REAL_VALUE_FROM_CONST_DOUBLE (d, c);
153           return CONST_DOUBLE_FROM_REAL_VALUE (d, GET_MODE (x));
154         }
155       return x;
156
157     default:
158       return x;
159     }
160
161   addr = XEXP (x, 0);
162
163   /* Call target hook to avoid the effects of -fpic etc....  */
164   addr = targetm.delegitimize_address (addr);
165
166   /* Split the address into a base and integer offset.  */
167   if (GET_CODE (addr) == CONST
168       && GET_CODE (XEXP (addr, 0)) == PLUS
169       && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
170     {
171       offset = INTVAL (XEXP (XEXP (addr, 0), 1));
172       addr = XEXP (XEXP (addr, 0), 0);
173     }
174
175   if (GET_CODE (addr) == LO_SUM)
176     addr = XEXP (addr, 1);
177
178   /* If this is a constant pool reference, we can turn it into its
179      constant and hope that simplifications happen.  */
180   if (GET_CODE (addr) == SYMBOL_REF
181       && CONSTANT_POOL_ADDRESS_P (addr))
182     {
183       c = get_pool_constant (addr);
184       cmode = get_pool_mode (addr);
185
186       /* If we're accessing the constant in a different mode than it was
187          originally stored, attempt to fix that up via subreg simplifications.
188          If that fails we have no choice but to return the original memory.  */
189       if (offset != 0 || cmode != GET_MODE (x))
190         {
191           rtx tem = simplify_subreg (GET_MODE (x), c, cmode, offset);
192           if (tem && CONSTANT_P (tem))
193             return tem;
194         }
195       else
196         return c;
197     }
198
199   return x;
200 }
201
202 /* Return true if X is a MEM referencing the constant pool.  */
203
204 bool
205 constant_pool_reference_p (rtx x)
206 {
207   return avoid_constant_pool_reference (x) != x;
208 }
209 \f
210 /* Make a unary operation by first seeing if it folds and otherwise making
211    the specified operation.  */
212
213 rtx
214 simplify_gen_unary (enum rtx_code code, enum machine_mode mode, rtx op,
215                     enum machine_mode op_mode)
216 {
217   rtx tem;
218
219   /* If this simplifies, use it.  */
220   if ((tem = simplify_unary_operation (code, mode, op, op_mode)) != 0)
221     return tem;
222
223   return gen_rtx_fmt_e (code, mode, op);
224 }
225
226 /* Likewise for ternary operations.  */
227
228 rtx
229 simplify_gen_ternary (enum rtx_code code, enum machine_mode mode,
230                       enum machine_mode op0_mode, rtx op0, rtx op1, rtx op2)
231 {
232   rtx tem;
233
234   /* If this simplifies, use it.  */
235   if (0 != (tem = simplify_ternary_operation (code, mode, op0_mode,
236                                               op0, op1, op2)))
237     return tem;
238
239   return gen_rtx_fmt_eee (code, mode, op0, op1, op2);
240 }
241
242 /* Likewise, for relational operations.
243    CMP_MODE specifies mode comparison is done in.  */
244
245 rtx
246 simplify_gen_relational (enum rtx_code code, enum machine_mode mode,
247                          enum machine_mode cmp_mode, rtx op0, rtx op1)
248 {
249   rtx tem;
250
251   if (0 != (tem = simplify_relational_operation (code, mode, cmp_mode,
252                                                  op0, op1)))
253     return tem;
254
255   return gen_rtx_fmt_ee (code, mode, op0, op1);
256 }
257 \f
258 /* Replace all occurrences of OLD_RTX in X with NEW_RTX and try to simplify the
259    resulting RTX.  Return a new RTX which is as simplified as possible.  */
260
261 rtx
262 simplify_replace_rtx (rtx x, rtx old_rtx, rtx new_rtx)
263 {
264   enum rtx_code code = GET_CODE (x);
265   enum machine_mode mode = GET_MODE (x);
266   enum machine_mode op_mode;
267   rtx op0, op1, op2;
268
269   /* If X is OLD_RTX, return NEW_RTX.  Otherwise, if this is an expression, try
270      to build a new expression substituting recursively.  If we can't do
271      anything, return our input.  */
272
273   if (x == old_rtx)
274     return new_rtx;
275
276   switch (GET_RTX_CLASS (code))
277     {
278     case RTX_UNARY:
279       op0 = XEXP (x, 0);
280       op_mode = GET_MODE (op0);
281       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
282       if (op0 == XEXP (x, 0))
283         return x;
284       return simplify_gen_unary (code, mode, op0, op_mode);
285
286     case RTX_BIN_ARITH:
287     case RTX_COMM_ARITH:
288       op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
289       op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
290       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
291         return x;
292       return simplify_gen_binary (code, mode, op0, op1);
293
294     case RTX_COMPARE:
295     case RTX_COMM_COMPARE:
296       op0 = XEXP (x, 0);
297       op1 = XEXP (x, 1);
298       op_mode = GET_MODE (op0) != VOIDmode ? GET_MODE (op0) : GET_MODE (op1);
299       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
300       op1 = simplify_replace_rtx (op1, old_rtx, new_rtx);
301       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
302         return x;
303       return simplify_gen_relational (code, mode, op_mode, op0, op1);
304
305     case RTX_TERNARY:
306     case RTX_BITFIELD_OPS:
307       op0 = XEXP (x, 0);
308       op_mode = GET_MODE (op0);
309       op0 = simplify_replace_rtx (op0, old_rtx, new_rtx);
310       op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
311       op2 = simplify_replace_rtx (XEXP (x, 2), old_rtx, new_rtx);
312       if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1) && op2 == XEXP (x, 2))
313         return x;
314       if (op_mode == VOIDmode)
315         op_mode = GET_MODE (op0);
316       return simplify_gen_ternary (code, mode, op_mode, op0, op1, op2);
317
318     case RTX_EXTRA:
319       /* The only case we try to handle is a SUBREG.  */
320       if (code == SUBREG)
321         {
322           op0 = simplify_replace_rtx (SUBREG_REG (x), old_rtx, new_rtx);
323           if (op0 == SUBREG_REG (x))
324             return x;
325           op0 = simplify_gen_subreg (GET_MODE (x), op0,
326                                      GET_MODE (SUBREG_REG (x)),
327                                      SUBREG_BYTE (x));
328           return op0 ? op0 : x;
329         }
330       break;
331
332     case RTX_OBJ:
333       if (code == MEM)
334         {
335           op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
336           if (op0 == XEXP (x, 0))
337             return x;
338           return replace_equiv_address_nv (x, op0);
339         }
340       else if (code == LO_SUM)
341         {
342           op0 = simplify_replace_rtx (XEXP (x, 0), old_rtx, new_rtx);
343           op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
344
345           /* (lo_sum (high x) x) -> x  */
346           if (GET_CODE (op0) == HIGH && rtx_equal_p (XEXP (op0, 0), op1))
347             return op1;
348
349           if (op0 == XEXP (x, 0) && op1 == XEXP (x, 1))
350             return x;
351           return gen_rtx_LO_SUM (mode, op0, op1);
352         }
353       else if (code == REG)
354         {
355           if (rtx_equal_p (x, old_rtx))
356             return new_rtx;
357         }
358       break;
359
360     default:
361       break;
362     }
363   return x;
364 }
365 \f
366 /* Try to simplify a unary operation CODE whose output mode is to be
367    MODE with input operand OP whose mode was originally OP_MODE.
368    Return zero if no simplification can be made.  */
369 rtx
370 simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
371                           rtx op, enum machine_mode op_mode)
372 {
373   rtx trueop, tem;
374
375   if (GET_CODE (op) == CONST)
376     op = XEXP (op, 0);
377
378   trueop = avoid_constant_pool_reference (op);
379
380   tem = simplify_const_unary_operation (code, mode, trueop, op_mode);
381   if (tem)
382     return tem;
383
384   return simplify_unary_operation_1 (code, mode, op);
385 }
386
387 /* Perform some simplifications we can do even if the operands
388    aren't constant.  */
389 static rtx
390 simplify_unary_operation_1 (enum rtx_code code, enum machine_mode mode, rtx op)
391 {
392   enum rtx_code reversed;
393   rtx temp;
394
395   switch (code)
396     {
397     case NOT:
398       /* (not (not X)) == X.  */
399       if (GET_CODE (op) == NOT)
400         return XEXP (op, 0);
401
402       /* (not (eq X Y)) == (ne X Y), etc.  */
403       if (COMPARISON_P (op)
404           && (mode == BImode || STORE_FLAG_VALUE == -1)
405           && ((reversed = reversed_comparison_code (op, NULL_RTX)) != UNKNOWN))
406         return simplify_gen_relational (reversed, mode, VOIDmode,
407                                         XEXP (op, 0), XEXP (op, 1));
408
409       /* (not (plus X -1)) can become (neg X).  */
410       if (GET_CODE (op) == PLUS
411           && XEXP (op, 1) == constm1_rtx)
412         return simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
413
414       /* Similarly, (not (neg X)) is (plus X -1).  */
415       if (GET_CODE (op) == NEG)
416         return plus_constant (XEXP (op, 0), -1);
417
418       /* (not (xor X C)) for C constant is (xor X D) with D = ~C.  */
419       if (GET_CODE (op) == XOR
420           && GET_CODE (XEXP (op, 1)) == CONST_INT
421           && (temp = simplify_unary_operation (NOT, mode,
422                                                XEXP (op, 1), mode)) != 0)
423         return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
424
425       /* (not (plus X C)) for signbit C is (xor X D) with D = ~C.  */
426       if (GET_CODE (op) == PLUS
427           && GET_CODE (XEXP (op, 1)) == CONST_INT
428           && mode_signbit_p (mode, XEXP (op, 1))
429           && (temp = simplify_unary_operation (NOT, mode,
430                                                XEXP (op, 1), mode)) != 0)
431         return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
432
433
434       /* (not (ashift 1 X)) is (rotate ~1 X).  We used to do this for
435          operands other than 1, but that is not valid.  We could do a
436          similar simplification for (not (lshiftrt C X)) where C is
437          just the sign bit, but this doesn't seem common enough to
438          bother with.  */
439       if (GET_CODE (op) == ASHIFT
440           && XEXP (op, 0) == const1_rtx)
441         {
442           temp = simplify_gen_unary (NOT, mode, const1_rtx, mode);
443           return simplify_gen_binary (ROTATE, mode, temp, XEXP (op, 1));
444         }
445
446       /* If STORE_FLAG_VALUE is -1, (not (comparison X Y)) can be done
447          by reversing the comparison code if valid.  */
448       if (STORE_FLAG_VALUE == -1
449           && COMPARISON_P (op)
450           && (reversed = reversed_comparison_code (op, NULL_RTX)) != UNKNOWN)
451         return simplify_gen_relational (reversed, mode, VOIDmode,
452                                         XEXP (op, 0), XEXP (op, 1));
453
454       /* (not (ashiftrt foo C)) where C is the number of bits in FOO
455          minus 1 is (ge foo (const_int 0)) if STORE_FLAG_VALUE is -1,
456          so we can perform the above simplification.  */
457       
458       if (STORE_FLAG_VALUE == -1
459           && GET_CODE (op) == ASHIFTRT
460           && GET_CODE (XEXP (op, 1)) == CONST_INT
461           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
462         return simplify_gen_relational (GE, mode, VOIDmode,
463                                         XEXP (op, 0), const0_rtx);
464
465       break;
466
467     case NEG:
468       /* (neg (neg X)) == X.  */
469       if (GET_CODE (op) == NEG)
470         return XEXP (op, 0);
471
472       /* (neg (plus X 1)) can become (not X).  */
473       if (GET_CODE (op) == PLUS
474           && XEXP (op, 1) == const1_rtx)
475         return simplify_gen_unary (NOT, mode, XEXP (op, 0), mode);
476       
477       /* Similarly, (neg (not X)) is (plus X 1).  */
478       if (GET_CODE (op) == NOT)
479         return plus_constant (XEXP (op, 0), 1);
480       
481       /* (neg (minus X Y)) can become (minus Y X).  This transformation
482          isn't safe for modes with signed zeros, since if X and Y are
483          both +0, (minus Y X) is the same as (minus X Y).  If the
484          rounding mode is towards +infinity (or -infinity) then the two
485          expressions will be rounded differently.  */
486       if (GET_CODE (op) == MINUS
487           && !HONOR_SIGNED_ZEROS (mode)
488           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
489         return simplify_gen_binary (MINUS, mode, XEXP (op, 1), XEXP (op, 0));
490       
491       if (GET_CODE (op) == PLUS
492           && !HONOR_SIGNED_ZEROS (mode)
493           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
494         {
495           /* (neg (plus A C)) is simplified to (minus -C A).  */
496           if (GET_CODE (XEXP (op, 1)) == CONST_INT
497               || GET_CODE (XEXP (op, 1)) == CONST_DOUBLE)
498             {
499               temp = simplify_unary_operation (NEG, mode, XEXP (op, 1), mode);
500               if (temp)
501                 return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 0));
502             }
503
504           /* (neg (plus A B)) is canonicalized to (minus (neg A) B).  */
505           temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
506           return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 1));
507         }
508
509       /* (neg (mult A B)) becomes (mult (neg A) B).
510          This works even for floating-point values.  */
511       if (GET_CODE (op) == MULT
512           && !HONOR_SIGN_DEPENDENT_ROUNDING (mode))
513         {
514           temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
515           return simplify_gen_binary (MULT, mode, temp, XEXP (op, 1));
516         }
517
518       /* NEG commutes with ASHIFT since it is multiplication.  Only do
519          this if we can then eliminate the NEG (e.g., if the operand
520          is a constant).  */
521       if (GET_CODE (op) == ASHIFT)
522         {
523           temp = simplify_unary_operation (NEG, mode, XEXP (op, 0), mode);
524           if (temp)
525             return simplify_gen_binary (ASHIFT, mode, temp, XEXP (op, 1));
526         }
527
528       /* (neg (ashiftrt X C)) can be replaced by (lshiftrt X C) when
529          C is equal to the width of MODE minus 1.  */
530       if (GET_CODE (op) == ASHIFTRT
531           && GET_CODE (XEXP (op, 1)) == CONST_INT
532           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
533         return simplify_gen_binary (LSHIFTRT, mode,
534                                     XEXP (op, 0), XEXP (op, 1));
535
536       /* (neg (lshiftrt X C)) can be replaced by (ashiftrt X C) when
537          C is equal to the width of MODE minus 1.  */
538       if (GET_CODE (op) == LSHIFTRT
539           && GET_CODE (XEXP (op, 1)) == CONST_INT
540           && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
541         return simplify_gen_binary (ASHIFTRT, mode,
542                                     XEXP (op, 0), XEXP (op, 1));
543       
544       break;
545
546     case SIGN_EXTEND:
547       /* (sign_extend (truncate (minus (label_ref L1) (label_ref L2))))
548          becomes just the MINUS if its mode is MODE.  This allows
549          folding switch statements on machines using casesi (such as
550          the VAX).  */
551       if (GET_CODE (op) == TRUNCATE
552           && GET_MODE (XEXP (op, 0)) == mode
553           && GET_CODE (XEXP (op, 0)) == MINUS
554           && GET_CODE (XEXP (XEXP (op, 0), 0)) == LABEL_REF
555           && GET_CODE (XEXP (XEXP (op, 0), 1)) == LABEL_REF)
556         return XEXP (op, 0);
557
558       /* Check for a sign extension of a subreg of a promoted
559          variable, where the promotion is sign-extended, and the
560          target mode is the same as the variable's promotion.  */
561       if (GET_CODE (op) == SUBREG
562           && SUBREG_PROMOTED_VAR_P (op)
563           && ! SUBREG_PROMOTED_UNSIGNED_P (op)
564           && GET_MODE (XEXP (op, 0)) == mode)
565         return XEXP (op, 0);
566
567 #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
568       if (! POINTERS_EXTEND_UNSIGNED
569           && mode == Pmode && GET_MODE (op) == ptr_mode
570           && (CONSTANT_P (op)
571               || (GET_CODE (op) == SUBREG
572                   && REG_P (SUBREG_REG (op))
573                   && REG_POINTER (SUBREG_REG (op))
574                   && GET_MODE (SUBREG_REG (op)) == Pmode)))
575         return convert_memory_address (Pmode, op);
576 #endif
577       break;
578
579     case ZERO_EXTEND:
580       /* Check for a zero extension of a subreg of a promoted
581          variable, where the promotion is zero-extended, and the
582          target mode is the same as the variable's promotion.  */
583       if (GET_CODE (op) == SUBREG
584           && SUBREG_PROMOTED_VAR_P (op)
585           && SUBREG_PROMOTED_UNSIGNED_P (op) > 0
586           && GET_MODE (XEXP (op, 0)) == mode)
587         return XEXP (op, 0);
588
589 #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend)
590       if (POINTERS_EXTEND_UNSIGNED > 0
591           && mode == Pmode && GET_MODE (op) == ptr_mode
592           && (CONSTANT_P (op)
593               || (GET_CODE (op) == SUBREG
594                   && REG_P (SUBREG_REG (op))
595                   && REG_POINTER (SUBREG_REG (op))
596                   && GET_MODE (SUBREG_REG (op)) == Pmode)))
597         return convert_memory_address (Pmode, op);
598 #endif
599       break;
600
601     default:
602       break;
603     }
604   
605   return 0;
606 }
607
608 /* Try to compute the value of a unary operation CODE whose output mode is to
609    be MODE with input operand OP whose mode was originally OP_MODE.
610    Return zero if the value cannot be computed.  */
611 rtx
612 simplify_const_unary_operation (enum rtx_code code, enum machine_mode mode,
613                                 rtx op, enum machine_mode op_mode)
614 {
615   unsigned int width = GET_MODE_BITSIZE (mode);
616
617   if (code == VEC_DUPLICATE)
618     {
619       gcc_assert (VECTOR_MODE_P (mode));
620       if (GET_MODE (op) != VOIDmode)
621       {
622         if (!VECTOR_MODE_P (GET_MODE (op)))
623           gcc_assert (GET_MODE_INNER (mode) == GET_MODE (op));
624         else
625           gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER
626                                                 (GET_MODE (op)));
627       }
628       if (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE
629           || GET_CODE (op) == CONST_VECTOR)
630         {
631           int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
632           unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
633           rtvec v = rtvec_alloc (n_elts);
634           unsigned int i;
635
636           if (GET_CODE (op) != CONST_VECTOR)
637             for (i = 0; i < n_elts; i++)
638               RTVEC_ELT (v, i) = op;
639           else
640             {
641               enum machine_mode inmode = GET_MODE (op);
642               int in_elt_size = GET_MODE_SIZE (GET_MODE_INNER (inmode));
643               unsigned in_n_elts = (GET_MODE_SIZE (inmode) / in_elt_size);
644
645               gcc_assert (in_n_elts < n_elts);
646               gcc_assert ((n_elts % in_n_elts) == 0);
647               for (i = 0; i < n_elts; i++)
648                 RTVEC_ELT (v, i) = CONST_VECTOR_ELT (op, i % in_n_elts);
649             }
650           return gen_rtx_CONST_VECTOR (mode, v);
651         }
652     }
653
654   if (VECTOR_MODE_P (mode) && GET_CODE (op) == CONST_VECTOR)
655     {
656       int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
657       unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
658       enum machine_mode opmode = GET_MODE (op);
659       int op_elt_size = GET_MODE_SIZE (GET_MODE_INNER (opmode));
660       unsigned op_n_elts = (GET_MODE_SIZE (opmode) / op_elt_size);
661       rtvec v = rtvec_alloc (n_elts);
662       unsigned int i;
663
664       gcc_assert (op_n_elts == n_elts);
665       for (i = 0; i < n_elts; i++)
666         {
667           rtx x = simplify_unary_operation (code, GET_MODE_INNER (mode),
668                                             CONST_VECTOR_ELT (op, i),
669                                             GET_MODE_INNER (opmode));
670           if (!x)
671             return 0;
672           RTVEC_ELT (v, i) = x;
673         }
674       return gen_rtx_CONST_VECTOR (mode, v);
675     }
676
677   /* The order of these tests is critical so that, for example, we don't
678      check the wrong mode (input vs. output) for a conversion operation,
679      such as FIX.  At some point, this should be simplified.  */
680
681   if (code == FLOAT && GET_MODE (op) == VOIDmode
682       && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
683     {
684       HOST_WIDE_INT hv, lv;
685       REAL_VALUE_TYPE d;
686
687       if (GET_CODE (op) == CONST_INT)
688         lv = INTVAL (op), hv = HWI_SIGN_EXTEND (lv);
689       else
690         lv = CONST_DOUBLE_LOW (op),  hv = CONST_DOUBLE_HIGH (op);
691
692       REAL_VALUE_FROM_INT (d, lv, hv, mode);
693       d = real_value_truncate (mode, d);
694       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
695     }
696   else if (code == UNSIGNED_FLOAT && GET_MODE (op) == VOIDmode
697            && (GET_CODE (op) == CONST_DOUBLE
698                || GET_CODE (op) == CONST_INT))
699     {
700       HOST_WIDE_INT hv, lv;
701       REAL_VALUE_TYPE d;
702
703       if (GET_CODE (op) == CONST_INT)
704         lv = INTVAL (op), hv = HWI_SIGN_EXTEND (lv);
705       else
706         lv = CONST_DOUBLE_LOW (op),  hv = CONST_DOUBLE_HIGH (op);
707
708       if (op_mode == VOIDmode)
709         {
710           /* We don't know how to interpret negative-looking numbers in
711              this case, so don't try to fold those.  */
712           if (hv < 0)
713             return 0;
714         }
715       else if (GET_MODE_BITSIZE (op_mode) >= HOST_BITS_PER_WIDE_INT * 2)
716         ;
717       else
718         hv = 0, lv &= GET_MODE_MASK (op_mode);
719
720       REAL_VALUE_FROM_UNSIGNED_INT (d, lv, hv, mode);
721       d = real_value_truncate (mode, d);
722       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
723     }
724
725   if (GET_CODE (op) == CONST_INT
726       && width <= HOST_BITS_PER_WIDE_INT && width > 0)
727     {
728       HOST_WIDE_INT arg0 = INTVAL (op);
729       HOST_WIDE_INT val;
730
731       switch (code)
732         {
733         case NOT:
734           val = ~ arg0;
735           break;
736
737         case NEG:
738           val = - arg0;
739           break;
740
741         case ABS:
742           val = (arg0 >= 0 ? arg0 : - arg0);
743           break;
744
745         case FFS:
746           /* Don't use ffs here.  Instead, get low order bit and then its
747              number.  If arg0 is zero, this will return 0, as desired.  */
748           arg0 &= GET_MODE_MASK (mode);
749           val = exact_log2 (arg0 & (- arg0)) + 1;
750           break;
751
752         case CLZ:
753           arg0 &= GET_MODE_MASK (mode);
754           if (arg0 == 0 && CLZ_DEFINED_VALUE_AT_ZERO (mode, val))
755             ;
756           else
757             val = GET_MODE_BITSIZE (mode) - floor_log2 (arg0) - 1;
758           break;
759
760         case CTZ:
761           arg0 &= GET_MODE_MASK (mode);
762           if (arg0 == 0)
763             {
764               /* Even if the value at zero is undefined, we have to come
765                  up with some replacement.  Seems good enough.  */
766               if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, val))
767                 val = GET_MODE_BITSIZE (mode);
768             }
769           else
770             val = exact_log2 (arg0 & -arg0);
771           break;
772
773         case POPCOUNT:
774           arg0 &= GET_MODE_MASK (mode);
775           val = 0;
776           while (arg0)
777             val++, arg0 &= arg0 - 1;
778           break;
779
780         case PARITY:
781           arg0 &= GET_MODE_MASK (mode);
782           val = 0;
783           while (arg0)
784             val++, arg0 &= arg0 - 1;
785           val &= 1;
786           break;
787
788         case TRUNCATE:
789           val = arg0;
790           break;
791
792         case ZERO_EXTEND:
793           /* When zero-extending a CONST_INT, we need to know its
794              original mode.  */
795           gcc_assert (op_mode != VOIDmode);
796           if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
797             {
798               /* If we were really extending the mode,
799                  we would have to distinguish between zero-extension
800                  and sign-extension.  */
801               gcc_assert (width == GET_MODE_BITSIZE (op_mode));
802               val = arg0;
803             }
804           else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
805             val = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
806           else
807             return 0;
808           break;
809
810         case SIGN_EXTEND:
811           if (op_mode == VOIDmode)
812             op_mode = mode;
813           if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
814             {
815               /* If we were really extending the mode,
816                  we would have to distinguish between zero-extension
817                  and sign-extension.  */
818               gcc_assert (width == GET_MODE_BITSIZE (op_mode));
819               val = arg0;
820             }
821           else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
822             {
823               val
824                 = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode));
825               if (val
826                   & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (op_mode) - 1)))
827                 val -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
828             }
829           else
830             return 0;
831           break;
832
833         case SQRT:
834         case FLOAT_EXTEND:
835         case FLOAT_TRUNCATE:
836         case SS_TRUNCATE:
837         case US_TRUNCATE:
838           return 0;
839
840         default:
841           gcc_unreachable ();
842         }
843
844       return gen_int_mode (val, mode);
845     }
846
847   /* We can do some operations on integer CONST_DOUBLEs.  Also allow
848      for a DImode operation on a CONST_INT.  */
849   else if (GET_MODE (op) == VOIDmode
850            && width <= HOST_BITS_PER_WIDE_INT * 2
851            && (GET_CODE (op) == CONST_DOUBLE
852                || GET_CODE (op) == CONST_INT))
853     {
854       unsigned HOST_WIDE_INT l1, lv;
855       HOST_WIDE_INT h1, hv;
856
857       if (GET_CODE (op) == CONST_DOUBLE)
858         l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
859       else
860         l1 = INTVAL (op), h1 = HWI_SIGN_EXTEND (l1);
861
862       switch (code)
863         {
864         case NOT:
865           lv = ~ l1;
866           hv = ~ h1;
867           break;
868
869         case NEG:
870           neg_double (l1, h1, &lv, &hv);
871           break;
872
873         case ABS:
874           if (h1 < 0)
875             neg_double (l1, h1, &lv, &hv);
876           else
877             lv = l1, hv = h1;
878           break;
879
880         case FFS:
881           hv = 0;
882           if (l1 == 0)
883             {
884               if (h1 == 0)
885                 lv = 0;
886               else
887                 lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & -h1) + 1;
888             }
889           else
890             lv = exact_log2 (l1 & -l1) + 1;
891           break;
892
893         case CLZ:
894           hv = 0;
895           if (h1 != 0)
896             lv = GET_MODE_BITSIZE (mode) - floor_log2 (h1) - 1
897               - HOST_BITS_PER_WIDE_INT;
898           else if (l1 != 0)
899             lv = GET_MODE_BITSIZE (mode) - floor_log2 (l1) - 1;
900           else if (! CLZ_DEFINED_VALUE_AT_ZERO (mode, lv))
901             lv = GET_MODE_BITSIZE (mode);
902           break;
903
904         case CTZ:
905           hv = 0;
906           if (l1 != 0)
907             lv = exact_log2 (l1 & -l1);
908           else if (h1 != 0)
909             lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & -h1);
910           else if (! CTZ_DEFINED_VALUE_AT_ZERO (mode, lv))
911             lv = GET_MODE_BITSIZE (mode);
912           break;
913
914         case POPCOUNT:
915           hv = 0;
916           lv = 0;
917           while (l1)
918             lv++, l1 &= l1 - 1;
919           while (h1)
920             lv++, h1 &= h1 - 1;
921           break;
922
923         case PARITY:
924           hv = 0;
925           lv = 0;
926           while (l1)
927             lv++, l1 &= l1 - 1;
928           while (h1)
929             lv++, h1 &= h1 - 1;
930           lv &= 1;
931           break;
932
933         case TRUNCATE:
934           /* This is just a change-of-mode, so do nothing.  */
935           lv = l1, hv = h1;
936           break;
937
938         case ZERO_EXTEND:
939           gcc_assert (op_mode != VOIDmode);
940
941           if (GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
942             return 0;
943
944           hv = 0;
945           lv = l1 & GET_MODE_MASK (op_mode);
946           break;
947
948         case SIGN_EXTEND:
949           if (op_mode == VOIDmode
950               || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
951             return 0;
952           else
953             {
954               lv = l1 & GET_MODE_MASK (op_mode);
955               if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
956                   && (lv & ((HOST_WIDE_INT) 1
957                             << (GET_MODE_BITSIZE (op_mode) - 1))) != 0)
958                 lv -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode);
959
960               hv = HWI_SIGN_EXTEND (lv);
961             }
962           break;
963
964         case SQRT:
965           return 0;
966
967         default:
968           return 0;
969         }
970
971       return immed_double_const (lv, hv, mode);
972     }
973
974   else if (GET_CODE (op) == CONST_DOUBLE
975            && SCALAR_FLOAT_MODE_P (mode))
976     {
977       REAL_VALUE_TYPE d, t;
978       REAL_VALUE_FROM_CONST_DOUBLE (d, op);
979
980       switch (code)
981         {
982         case SQRT:
983           if (HONOR_SNANS (mode) && real_isnan (&d))
984             return 0;
985           real_sqrt (&t, mode, &d);
986           d = t;
987           break;
988         case ABS:
989           d = REAL_VALUE_ABS (d);
990           break;
991         case NEG:
992           d = REAL_VALUE_NEGATE (d);
993           break;
994         case FLOAT_TRUNCATE:
995           d = real_value_truncate (mode, d);
996           break;
997         case FLOAT_EXTEND:
998           /* All this does is change the mode.  */
999           break;
1000         case FIX:
1001           real_arithmetic (&d, FIX_TRUNC_EXPR, &d, NULL);
1002           break;
1003         case NOT:
1004           {
1005             long tmp[4];
1006             int i;
1007
1008             real_to_target (tmp, &d, GET_MODE (op));
1009             for (i = 0; i < 4; i++)
1010               tmp[i] = ~tmp[i];
1011             real_from_target (&d, tmp, mode);
1012             break;
1013           }
1014         default:
1015           gcc_unreachable ();
1016         }
1017       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
1018     }
1019
1020   else if (GET_CODE (op) == CONST_DOUBLE
1021            && SCALAR_FLOAT_MODE_P (GET_MODE (op))
1022            && GET_MODE_CLASS (mode) == MODE_INT
1023            && width <= 2*HOST_BITS_PER_WIDE_INT && width > 0)
1024     {
1025       /* Although the overflow semantics of RTL's FIX and UNSIGNED_FIX
1026          operators are intentionally left unspecified (to ease implementation
1027          by target backends), for consistency, this routine implements the
1028          same semantics for constant folding as used by the middle-end.  */
1029
1030       /* This was formerly used only for non-IEEE float.
1031          eggert@twinsun.com says it is safe for IEEE also.  */
1032       HOST_WIDE_INT xh, xl, th, tl;
1033       REAL_VALUE_TYPE x, t;
1034       REAL_VALUE_FROM_CONST_DOUBLE (x, op);
1035       switch (code)
1036         {
1037         case FIX:
1038           if (REAL_VALUE_ISNAN (x))
1039             return const0_rtx;
1040
1041           /* Test against the signed upper bound.  */
1042           if (width > HOST_BITS_PER_WIDE_INT)
1043             {
1044               th = ((unsigned HOST_WIDE_INT) 1
1045                     << (width - HOST_BITS_PER_WIDE_INT - 1)) - 1;
1046               tl = -1;
1047             }
1048           else
1049             {
1050               th = 0;
1051               tl = ((unsigned HOST_WIDE_INT) 1 << (width - 1)) - 1;
1052             }
1053           real_from_integer (&t, VOIDmode, tl, th, 0);
1054           if (REAL_VALUES_LESS (t, x))
1055             {
1056               xh = th;
1057               xl = tl;
1058               break;
1059             }
1060
1061           /* Test against the signed lower bound.  */
1062           if (width > HOST_BITS_PER_WIDE_INT)
1063             {
1064               th = (HOST_WIDE_INT) -1 << (width - HOST_BITS_PER_WIDE_INT - 1);
1065               tl = 0;
1066             }
1067           else
1068             {
1069               th = -1;
1070               tl = (HOST_WIDE_INT) -1 << (width - 1);
1071             }
1072           real_from_integer (&t, VOIDmode, tl, th, 0);
1073           if (REAL_VALUES_LESS (x, t))
1074             {
1075               xh = th;
1076               xl = tl;
1077               break;
1078             }
1079           REAL_VALUE_TO_INT (&xl, &xh, x);
1080           break;
1081
1082         case UNSIGNED_FIX:
1083           if (REAL_VALUE_ISNAN (x) || REAL_VALUE_NEGATIVE (x))
1084             return const0_rtx;
1085
1086           /* Test against the unsigned upper bound.  */
1087           if (width == 2*HOST_BITS_PER_WIDE_INT)
1088             {
1089               th = -1;
1090               tl = -1;
1091             }
1092           else if (width >= HOST_BITS_PER_WIDE_INT)
1093             {
1094               th = ((unsigned HOST_WIDE_INT) 1
1095                     << (width - HOST_BITS_PER_WIDE_INT)) - 1;
1096               tl = -1;
1097             }
1098           else
1099             {
1100               th = 0;
1101               tl = ((unsigned HOST_WIDE_INT) 1 << width) - 1;
1102             }
1103           real_from_integer (&t, VOIDmode, tl, th, 1);
1104           if (REAL_VALUES_LESS (t, x))
1105             {
1106               xh = th;
1107               xl = tl;
1108               break;
1109             }
1110
1111           REAL_VALUE_TO_INT (&xl, &xh, x);
1112           break;
1113
1114         default:
1115           gcc_unreachable ();
1116         }
1117       return immed_double_const (xl, xh, mode);
1118     }
1119
1120   return NULL_RTX;
1121 }
1122 \f
1123 /* Subroutine of simplify_binary_operation to simplify a commutative,
1124    associative binary operation CODE with result mode MODE, operating
1125    on OP0 and OP1.  CODE is currently one of PLUS, MULT, AND, IOR, XOR,
1126    SMIN, SMAX, UMIN or UMAX.  Return zero if no simplification or
1127    canonicalization is possible.  */
1128
1129 static rtx
1130 simplify_associative_operation (enum rtx_code code, enum machine_mode mode,
1131                                 rtx op0, rtx op1)
1132 {
1133   rtx tem;
1134
1135   /* Linearize the operator to the left.  */
1136   if (GET_CODE (op1) == code)
1137     {
1138       /* "(a op b) op (c op d)" becomes "((a op b) op c) op d)".  */
1139       if (GET_CODE (op0) == code)
1140         {
1141           tem = simplify_gen_binary (code, mode, op0, XEXP (op1, 0));
1142           return simplify_gen_binary (code, mode, tem, XEXP (op1, 1));
1143         }
1144
1145       /* "a op (b op c)" becomes "(b op c) op a".  */
1146       if (! swap_commutative_operands_p (op1, op0))
1147         return simplify_gen_binary (code, mode, op1, op0);
1148
1149       tem = op0;
1150       op0 = op1;
1151       op1 = tem;
1152     }
1153
1154   if (GET_CODE (op0) == code)
1155     {
1156       /* Canonicalize "(x op c) op y" as "(x op y) op c".  */
1157       if (swap_commutative_operands_p (XEXP (op0, 1), op1))
1158         {
1159           tem = simplify_gen_binary (code, mode, XEXP (op0, 0), op1);
1160           return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
1161         }
1162
1163       /* Attempt to simplify "(a op b) op c" as "a op (b op c)".  */
1164       tem = swap_commutative_operands_p (XEXP (op0, 1), op1)
1165             ? simplify_binary_operation (code, mode, op1, XEXP (op0, 1))
1166             : simplify_binary_operation (code, mode, XEXP (op0, 1), op1);
1167       if (tem != 0)
1168         return simplify_gen_binary (code, mode, XEXP (op0, 0), tem);
1169
1170       /* Attempt to simplify "(a op b) op c" as "(a op c) op b".  */
1171       tem = swap_commutative_operands_p (XEXP (op0, 0), op1)
1172             ? simplify_binary_operation (code, mode, op1, XEXP (op0, 0))
1173             : simplify_binary_operation (code, mode, XEXP (op0, 0), op1);
1174       if (tem != 0)
1175         return simplify_gen_binary (code, mode, tem, XEXP (op0, 1));
1176     }
1177
1178   return 0;
1179 }
1180
1181
1182 /* Simplify a binary operation CODE with result mode MODE, operating on OP0
1183    and OP1.  Return 0 if no simplification is possible.
1184
1185    Don't use this for relational operations such as EQ or LT.
1186    Use simplify_relational_operation instead.  */
1187 rtx
1188 simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
1189                            rtx op0, rtx op1)
1190 {
1191   rtx trueop0, trueop1;
1192   rtx tem;
1193
1194   /* Relational operations don't work here.  We must know the mode
1195      of the operands in order to do the comparison correctly.
1196      Assuming a full word can give incorrect results.
1197      Consider comparing 128 with -128 in QImode.  */
1198   gcc_assert (GET_RTX_CLASS (code) != RTX_COMPARE);
1199   gcc_assert (GET_RTX_CLASS (code) != RTX_COMM_COMPARE);
1200
1201   /* Make sure the constant is second.  */
1202   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
1203       && swap_commutative_operands_p (op0, op1))
1204     {
1205       tem = op0, op0 = op1, op1 = tem;
1206     }
1207
1208   trueop0 = avoid_constant_pool_reference (op0);
1209   trueop1 = avoid_constant_pool_reference (op1);
1210
1211   tem = simplify_const_binary_operation (code, mode, trueop0, trueop1);
1212   if (tem)
1213     return tem;
1214   return simplify_binary_operation_1 (code, mode, op0, op1, trueop0, trueop1);
1215 }
1216
1217 static rtx
1218 simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode,
1219                              rtx op0, rtx op1, rtx trueop0, rtx trueop1)
1220 {
1221   rtx tem;
1222   HOST_WIDE_INT val;
1223   unsigned int width = GET_MODE_BITSIZE (mode);
1224
1225   /* Even if we can't compute a constant result,
1226      there are some cases worth simplifying.  */
1227
1228   switch (code)
1229     {
1230     case PLUS:
1231       /* Maybe simplify x + 0 to x.  The two expressions are equivalent
1232          when x is NaN, infinite, or finite and nonzero.  They aren't
1233          when x is -0 and the rounding mode is not towards -infinity,
1234          since (-0) + 0 is then 0.  */
1235       if (!HONOR_SIGNED_ZEROS (mode) && trueop1 == CONST0_RTX (mode))
1236         return op0;
1237
1238       /* ((-a) + b) -> (b - a) and similarly for (a + (-b)).  These
1239          transformations are safe even for IEEE.  */
1240       if (GET_CODE (op0) == NEG)
1241         return simplify_gen_binary (MINUS, mode, op1, XEXP (op0, 0));
1242       else if (GET_CODE (op1) == NEG)
1243         return simplify_gen_binary (MINUS, mode, op0, XEXP (op1, 0));
1244
1245       /* (~a) + 1 -> -a */
1246       if (INTEGRAL_MODE_P (mode)
1247           && GET_CODE (op0) == NOT
1248           && trueop1 == const1_rtx)
1249         return simplify_gen_unary (NEG, mode, XEXP (op0, 0), mode);
1250
1251       /* Handle both-operands-constant cases.  We can only add
1252          CONST_INTs to constants since the sum of relocatable symbols
1253          can't be handled by most assemblers.  Don't add CONST_INT
1254          to CONST_INT since overflow won't be computed properly if wider
1255          than HOST_BITS_PER_WIDE_INT.  */
1256
1257       if (CONSTANT_P (op0) && GET_MODE (op0) != VOIDmode
1258           && GET_CODE (op1) == CONST_INT)
1259         return plus_constant (op0, INTVAL (op1));
1260       else if (CONSTANT_P (op1) && GET_MODE (op1) != VOIDmode
1261                && GET_CODE (op0) == CONST_INT)
1262         return plus_constant (op1, INTVAL (op0));
1263
1264       /* See if this is something like X * C - X or vice versa or
1265          if the multiplication is written as a shift.  If so, we can
1266          distribute and make a new multiply, shift, or maybe just
1267          have X (if C is 2 in the example above).  But don't make
1268          something more expensive than we had before.  */
1269
1270       if (SCALAR_INT_MODE_P (mode))
1271         {
1272           HOST_WIDE_INT coeff0h = 0, coeff1h = 0;
1273           unsigned HOST_WIDE_INT coeff0l = 1, coeff1l = 1;
1274           rtx lhs = op0, rhs = op1;
1275
1276           if (GET_CODE (lhs) == NEG)
1277             {
1278               coeff0l = -1;
1279               coeff0h = -1;
1280               lhs = XEXP (lhs, 0);
1281             }
1282           else if (GET_CODE (lhs) == MULT
1283                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
1284             {
1285               coeff0l = INTVAL (XEXP (lhs, 1));
1286               coeff0h = INTVAL (XEXP (lhs, 1)) < 0 ? -1 : 0;
1287               lhs = XEXP (lhs, 0);
1288             }
1289           else if (GET_CODE (lhs) == ASHIFT
1290                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT
1291                    && INTVAL (XEXP (lhs, 1)) >= 0
1292                    && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
1293             {
1294               coeff0l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
1295               coeff0h = 0;
1296               lhs = XEXP (lhs, 0);
1297             }
1298
1299           if (GET_CODE (rhs) == NEG)
1300             {
1301               coeff1l = -1;
1302               coeff1h = -1;
1303               rhs = XEXP (rhs, 0);
1304             }
1305           else if (GET_CODE (rhs) == MULT
1306                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
1307             {
1308               coeff1l = INTVAL (XEXP (rhs, 1));
1309               coeff1h = INTVAL (XEXP (rhs, 1)) < 0 ? -1 : 0;
1310               rhs = XEXP (rhs, 0);
1311             }
1312           else if (GET_CODE (rhs) == ASHIFT
1313                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT
1314                    && INTVAL (XEXP (rhs, 1)) >= 0
1315                    && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
1316             {
1317               coeff1l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1));
1318               coeff1h = 0;
1319               rhs = XEXP (rhs, 0);
1320             }
1321
1322           if (rtx_equal_p (lhs, rhs))
1323             {
1324               rtx orig = gen_rtx_PLUS (mode, op0, op1);
1325               rtx coeff;
1326               unsigned HOST_WIDE_INT l;
1327               HOST_WIDE_INT h;
1328
1329               add_double (coeff0l, coeff0h, coeff1l, coeff1h, &l, &h);
1330               coeff = immed_double_const (l, h, mode);
1331
1332               tem = simplify_gen_binary (MULT, mode, lhs, coeff);
1333               return rtx_cost (tem, SET) <= rtx_cost (orig, SET)
1334                 ? tem : 0;
1335             }
1336         }
1337
1338       /* (plus (xor X C1) C2) is (xor X (C1^C2)) if C2 is signbit.  */
1339       if ((GET_CODE (op1) == CONST_INT
1340            || GET_CODE (op1) == CONST_DOUBLE)
1341           && GET_CODE (op0) == XOR
1342           && (GET_CODE (XEXP (op0, 1)) == CONST_INT
1343               || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
1344           && mode_signbit_p (mode, op1))
1345         return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
1346                                     simplify_gen_binary (XOR, mode, op1,
1347                                                          XEXP (op0, 1)));
1348
1349       /* If one of the operands is a PLUS or a MINUS, see if we can
1350          simplify this by the associative law.
1351          Don't use the associative law for floating point.
1352          The inaccuracy makes it nonassociative,
1353          and subtle programs can break if operations are associated.  */
1354
1355       if (INTEGRAL_MODE_P (mode)
1356           && (plus_minus_operand_p (op0)
1357               || plus_minus_operand_p (op1))
1358           && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
1359         return tem;
1360
1361       /* Reassociate floating point addition only when the user
1362          specifies unsafe math optimizations.  */
1363       if (FLOAT_MODE_P (mode)
1364           && flag_unsafe_math_optimizations)
1365         {
1366           tem = simplify_associative_operation (code, mode, op0, op1);
1367           if (tem)
1368             return tem;
1369         }
1370       break;
1371
1372     case COMPARE:
1373 #ifdef HAVE_cc0
1374       /* Convert (compare FOO (const_int 0)) to FOO unless we aren't
1375          using cc0, in which case we want to leave it as a COMPARE
1376          so we can distinguish it from a register-register-copy.
1377
1378          In IEEE floating point, x-0 is not the same as x.  */
1379
1380       if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
1381            || ! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations)
1382           && trueop1 == CONST0_RTX (mode))
1383         return op0;
1384 #endif
1385
1386       /* Convert (compare (gt (flags) 0) (lt (flags) 0)) to (flags).  */
1387       if (((GET_CODE (op0) == GT && GET_CODE (op1) == LT)
1388            || (GET_CODE (op0) == GTU && GET_CODE (op1) == LTU))
1389           && XEXP (op0, 1) == const0_rtx && XEXP (op1, 1) == const0_rtx)
1390         {
1391           rtx xop00 = XEXP (op0, 0);
1392           rtx xop10 = XEXP (op1, 0);
1393
1394 #ifdef HAVE_cc0
1395           if (GET_CODE (xop00) == CC0 && GET_CODE (xop10) == CC0)
1396 #else
1397             if (REG_P (xop00) && REG_P (xop10)
1398                 && GET_MODE (xop00) == GET_MODE (xop10)
1399                 && REGNO (xop00) == REGNO (xop10)
1400                 && GET_MODE_CLASS (GET_MODE (xop00)) == MODE_CC
1401                 && GET_MODE_CLASS (GET_MODE (xop10)) == MODE_CC)
1402 #endif
1403               return xop00;
1404         }
1405       break;
1406
1407     case MINUS:
1408       /* We can't assume x-x is 0 even with non-IEEE floating point,
1409          but since it is zero except in very strange circumstances, we
1410          will treat it as zero with -funsafe-math-optimizations.  */
1411       if (rtx_equal_p (trueop0, trueop1)
1412           && ! side_effects_p (op0)
1413           && (! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations))
1414         return CONST0_RTX (mode);
1415
1416       /* Change subtraction from zero into negation.  (0 - x) is the
1417          same as -x when x is NaN, infinite, or finite and nonzero.
1418          But if the mode has signed zeros, and does not round towards
1419          -infinity, then 0 - 0 is 0, not -0.  */
1420       if (!HONOR_SIGNED_ZEROS (mode) && trueop0 == CONST0_RTX (mode))
1421         return simplify_gen_unary (NEG, mode, op1, mode);
1422
1423       /* (-1 - a) is ~a.  */
1424       if (trueop0 == constm1_rtx)
1425         return simplify_gen_unary (NOT, mode, op1, mode);
1426
1427       /* Subtracting 0 has no effect unless the mode has signed zeros
1428          and supports rounding towards -infinity.  In such a case,
1429          0 - 0 is -0.  */
1430       if (!(HONOR_SIGNED_ZEROS (mode)
1431             && HONOR_SIGN_DEPENDENT_ROUNDING (mode))
1432           && trueop1 == CONST0_RTX (mode))
1433         return op0;
1434
1435       /* See if this is something like X * C - X or vice versa or
1436          if the multiplication is written as a shift.  If so, we can
1437          distribute and make a new multiply, shift, or maybe just
1438          have X (if C is 2 in the example above).  But don't make
1439          something more expensive than we had before.  */
1440
1441       if (SCALAR_INT_MODE_P (mode))
1442         {
1443           HOST_WIDE_INT coeff0h = 0, negcoeff1h = -1;
1444           unsigned HOST_WIDE_INT coeff0l = 1, negcoeff1l = -1;
1445           rtx lhs = op0, rhs = op1;
1446
1447           if (GET_CODE (lhs) == NEG)
1448             {
1449               coeff0l = -1;
1450               coeff0h = -1;
1451               lhs = XEXP (lhs, 0);
1452             }
1453           else if (GET_CODE (lhs) == MULT
1454                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
1455             {
1456               coeff0l = INTVAL (XEXP (lhs, 1));
1457               coeff0h = INTVAL (XEXP (lhs, 1)) < 0 ? -1 : 0;
1458               lhs = XEXP (lhs, 0);
1459             }
1460           else if (GET_CODE (lhs) == ASHIFT
1461                    && GET_CODE (XEXP (lhs, 1)) == CONST_INT
1462                    && INTVAL (XEXP (lhs, 1)) >= 0
1463                    && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
1464             {
1465               coeff0l = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
1466               coeff0h = 0;
1467               lhs = XEXP (lhs, 0);
1468             }
1469
1470           if (GET_CODE (rhs) == NEG)
1471             {
1472               negcoeff1l = 1;
1473               negcoeff1h = 0;
1474               rhs = XEXP (rhs, 0);
1475             }
1476           else if (GET_CODE (rhs) == MULT
1477                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
1478             {
1479               negcoeff1l = -INTVAL (XEXP (rhs, 1));
1480               negcoeff1h = INTVAL (XEXP (rhs, 1)) <= 0 ? 0 : -1;
1481               rhs = XEXP (rhs, 0);
1482             }
1483           else if (GET_CODE (rhs) == ASHIFT
1484                    && GET_CODE (XEXP (rhs, 1)) == CONST_INT
1485                    && INTVAL (XEXP (rhs, 1)) >= 0
1486                    && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
1487             {
1488               negcoeff1l = -(((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1)));
1489               negcoeff1h = -1;
1490               rhs = XEXP (rhs, 0);
1491             }
1492
1493           if (rtx_equal_p (lhs, rhs))
1494             {
1495               rtx orig = gen_rtx_MINUS (mode, op0, op1);
1496               rtx coeff;
1497               unsigned HOST_WIDE_INT l;
1498               HOST_WIDE_INT h;
1499
1500               add_double (coeff0l, coeff0h, negcoeff1l, negcoeff1h, &l, &h);
1501               coeff = immed_double_const (l, h, mode);
1502
1503               tem = simplify_gen_binary (MULT, mode, lhs, coeff);
1504               return rtx_cost (tem, SET) <= rtx_cost (orig, SET)
1505                 ? tem : 0;
1506             }
1507         }
1508
1509       /* (a - (-b)) -> (a + b).  True even for IEEE.  */
1510       if (GET_CODE (op1) == NEG)
1511         return simplify_gen_binary (PLUS, mode, op0, XEXP (op1, 0));
1512
1513       /* (-x - c) may be simplified as (-c - x).  */
1514       if (GET_CODE (op0) == NEG
1515           && (GET_CODE (op1) == CONST_INT
1516               || GET_CODE (op1) == CONST_DOUBLE))
1517         {
1518           tem = simplify_unary_operation (NEG, mode, op1, mode);
1519           if (tem)
1520             return simplify_gen_binary (MINUS, mode, tem, XEXP (op0, 0));
1521         }
1522
1523       /* Don't let a relocatable value get a negative coeff.  */
1524       if (GET_CODE (op1) == CONST_INT && GET_MODE (op0) != VOIDmode)
1525         return simplify_gen_binary (PLUS, mode,
1526                                     op0,
1527                                     neg_const_int (mode, op1));
1528
1529       /* (x - (x & y)) -> (x & ~y) */
1530       if (GET_CODE (op1) == AND)
1531         {
1532           if (rtx_equal_p (op0, XEXP (op1, 0)))
1533             {
1534               tem = simplify_gen_unary (NOT, mode, XEXP (op1, 1),
1535                                         GET_MODE (XEXP (op1, 1)));
1536               return simplify_gen_binary (AND, mode, op0, tem);
1537             }
1538           if (rtx_equal_p (op0, XEXP (op1, 1)))
1539             {
1540               tem = simplify_gen_unary (NOT, mode, XEXP (op1, 0),
1541                                         GET_MODE (XEXP (op1, 0)));
1542               return simplify_gen_binary (AND, mode, op0, tem);
1543             }
1544         }
1545
1546       /* If one of the operands is a PLUS or a MINUS, see if we can
1547          simplify this by the associative law.  This will, for example,
1548          canonicalize (minus A (plus B C)) to (minus (minus A B) C).
1549          Don't use the associative law for floating point.
1550          The inaccuracy makes it nonassociative,
1551          and subtle programs can break if operations are associated.  */
1552
1553       if (INTEGRAL_MODE_P (mode)
1554           && (plus_minus_operand_p (op0)
1555               || plus_minus_operand_p (op1))
1556           && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0)
1557         return tem;
1558       break;
1559
1560     case MULT:
1561       if (trueop1 == constm1_rtx)
1562         return simplify_gen_unary (NEG, mode, op0, mode);
1563
1564       /* Maybe simplify x * 0 to 0.  The reduction is not valid if
1565          x is NaN, since x * 0 is then also NaN.  Nor is it valid
1566          when the mode has signed zeros, since multiplying a negative
1567          number by 0 will give -0, not 0.  */
1568       if (!HONOR_NANS (mode)
1569           && !HONOR_SIGNED_ZEROS (mode)
1570           && trueop1 == CONST0_RTX (mode)
1571           && ! side_effects_p (op0))
1572         return op1;
1573
1574       /* In IEEE floating point, x*1 is not equivalent to x for
1575          signalling NaNs.  */
1576       if (!HONOR_SNANS (mode)
1577           && trueop1 == CONST1_RTX (mode))
1578         return op0;
1579
1580       /* Convert multiply by constant power of two into shift unless
1581          we are still generating RTL.  This test is a kludge.  */
1582       if (GET_CODE (trueop1) == CONST_INT
1583           && (val = exact_log2 (INTVAL (trueop1))) >= 0
1584           /* If the mode is larger than the host word size, and the
1585              uppermost bit is set, then this isn't a power of two due
1586              to implicit sign extension.  */
1587           && (width <= HOST_BITS_PER_WIDE_INT
1588               || val != HOST_BITS_PER_WIDE_INT - 1))
1589         return simplify_gen_binary (ASHIFT, mode, op0, GEN_INT (val));
1590
1591       /* Likewise for multipliers wider than a word.  */
1592       else if (GET_CODE (trueop1) == CONST_DOUBLE
1593                && (GET_MODE (trueop1) == VOIDmode
1594                    || GET_MODE_CLASS (GET_MODE (trueop1)) == MODE_INT)
1595                && GET_MODE (op0) == mode
1596                && CONST_DOUBLE_LOW (trueop1) == 0
1597                && (val = exact_log2 (CONST_DOUBLE_HIGH (trueop1))) >= 0)
1598         return simplify_gen_binary (ASHIFT, mode, op0,
1599                                     GEN_INT (val + HOST_BITS_PER_WIDE_INT));
1600
1601       /* x*2 is x+x and x*(-1) is -x */
1602       if (GET_CODE (trueop1) == CONST_DOUBLE
1603           && SCALAR_FLOAT_MODE_P (GET_MODE (trueop1))
1604           && GET_MODE (op0) == mode)
1605         {
1606           REAL_VALUE_TYPE d;
1607           REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
1608
1609           if (REAL_VALUES_EQUAL (d, dconst2))
1610             return simplify_gen_binary (PLUS, mode, op0, copy_rtx (op0));
1611
1612           if (REAL_VALUES_EQUAL (d, dconstm1))
1613             return simplify_gen_unary (NEG, mode, op0, mode);
1614         }
1615
1616       /* Reassociate multiplication, but for floating point MULTs
1617          only when the user specifies unsafe math optimizations.  */
1618       if (! FLOAT_MODE_P (mode)
1619           || flag_unsafe_math_optimizations)
1620         {
1621           tem = simplify_associative_operation (code, mode, op0, op1);
1622           if (tem)
1623             return tem;
1624         }
1625       break;
1626
1627     case IOR:
1628       if (trueop1 == const0_rtx)
1629         return op0;
1630       if (GET_CODE (trueop1) == CONST_INT
1631           && ((INTVAL (trueop1) & GET_MODE_MASK (mode))
1632               == GET_MODE_MASK (mode)))
1633         return op1;
1634       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1635         return op0;
1636       /* A | (~A) -> -1 */
1637       if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
1638            || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
1639           && ! side_effects_p (op0)
1640           && SCALAR_INT_MODE_P (mode))
1641         return constm1_rtx;
1642       tem = simplify_associative_operation (code, mode, op0, op1);
1643       if (tem)
1644         return tem;
1645       break;
1646
1647     case XOR:
1648       if (trueop1 == const0_rtx)
1649         return op0;
1650       if (GET_CODE (trueop1) == CONST_INT
1651           && ((INTVAL (trueop1) & GET_MODE_MASK (mode))
1652               == GET_MODE_MASK (mode)))
1653         return simplify_gen_unary (NOT, mode, op0, mode);
1654       if (rtx_equal_p (trueop0, trueop1)
1655           && ! side_effects_p (op0)
1656           && GET_MODE_CLASS (mode) != MODE_CC)
1657          return CONST0_RTX (mode);
1658
1659       /* Canonicalize XOR of the most significant bit to PLUS.  */
1660       if ((GET_CODE (op1) == CONST_INT
1661            || GET_CODE (op1) == CONST_DOUBLE)
1662           && mode_signbit_p (mode, op1))
1663         return simplify_gen_binary (PLUS, mode, op0, op1);
1664       /* (xor (plus X C1) C2) is (xor X (C1^C2)) if C1 is signbit.  */
1665       if ((GET_CODE (op1) == CONST_INT
1666            || GET_CODE (op1) == CONST_DOUBLE)
1667           && GET_CODE (op0) == PLUS
1668           && (GET_CODE (XEXP (op0, 1)) == CONST_INT
1669               || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
1670           && mode_signbit_p (mode, XEXP (op0, 1)))
1671         return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
1672                                     simplify_gen_binary (XOR, mode, op1,
1673                                                          XEXP (op0, 1)));
1674               
1675       tem = simplify_associative_operation (code, mode, op0, op1);
1676       if (tem)
1677         return tem;
1678       break;
1679
1680     case AND:
1681       if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
1682         return trueop1;
1683       /* If we are turning off bits already known off in OP0, we need
1684          not do an AND.  */
1685       if (GET_CODE (trueop1) == CONST_INT
1686           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1687           && (nonzero_bits (trueop0, mode) & ~INTVAL (trueop1)) == 0)
1688         return op0;
1689       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0)
1690           && GET_MODE_CLASS (mode) != MODE_CC)
1691         return op0;
1692       /* A & (~A) -> 0 */
1693       if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
1694            || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
1695           && ! side_effects_p (op0)
1696           && GET_MODE_CLASS (mode) != MODE_CC)
1697         return CONST0_RTX (mode);
1698
1699       /* Transform (and (extend X) C) into (zero_extend (and X C)) if
1700          there are no nonzero bits of C outside of X's mode.  */
1701       if ((GET_CODE (op0) == SIGN_EXTEND
1702            || GET_CODE (op0) == ZERO_EXTEND)
1703           && GET_CODE (trueop1) == CONST_INT
1704           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1705           && (~GET_MODE_MASK (GET_MODE (XEXP (op0, 0)))
1706               & INTVAL (trueop1)) == 0)
1707         {
1708           enum machine_mode imode = GET_MODE (XEXP (op0, 0));
1709           tem = simplify_gen_binary (AND, imode, XEXP (op0, 0),
1710                                      gen_int_mode (INTVAL (trueop1),
1711                                                    imode));
1712           return simplify_gen_unary (ZERO_EXTEND, mode, tem, imode);
1713         }
1714
1715       /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
1716          ((A & N) + B) & M -> (A + B) & M
1717          Similarly if (N & M) == 0,
1718          ((A | N) + B) & M -> (A + B) & M
1719          and for - instead of + and/or ^ instead of |.  */
1720       if (GET_CODE (trueop1) == CONST_INT
1721           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1722           && ~INTVAL (trueop1)
1723           && (INTVAL (trueop1) & (INTVAL (trueop1) + 1)) == 0
1724           && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS))
1725         {
1726           rtx pmop[2];
1727           int which;
1728
1729           pmop[0] = XEXP (op0, 0);
1730           pmop[1] = XEXP (op0, 1);
1731
1732           for (which = 0; which < 2; which++)
1733             {
1734               tem = pmop[which];
1735               switch (GET_CODE (tem))
1736                 {
1737                 case AND:
1738                   if (GET_CODE (XEXP (tem, 1)) == CONST_INT
1739                       && (INTVAL (XEXP (tem, 1)) & INTVAL (trueop1))
1740                       == INTVAL (trueop1))
1741                     pmop[which] = XEXP (tem, 0);
1742                   break;
1743                 case IOR:
1744                 case XOR:
1745                   if (GET_CODE (XEXP (tem, 1)) == CONST_INT
1746                       && (INTVAL (XEXP (tem, 1)) & INTVAL (trueop1)) == 0)
1747                     pmop[which] = XEXP (tem, 0);
1748                   break;
1749                 default:
1750                   break;
1751                 }
1752             }
1753
1754           if (pmop[0] != XEXP (op0, 0) || pmop[1] != XEXP (op0, 1))
1755             {
1756               tem = simplify_gen_binary (GET_CODE (op0), mode,
1757                                          pmop[0], pmop[1]);
1758               return simplify_gen_binary (code, mode, tem, op1);
1759             }
1760         }
1761       tem = simplify_associative_operation (code, mode, op0, op1);
1762       if (tem)
1763         return tem;
1764       break;
1765
1766     case UDIV:
1767       /* 0/x is 0 (or x&0 if x has side-effects).  */
1768       if (trueop0 == CONST0_RTX (mode))
1769         {
1770           if (side_effects_p (op1))
1771             return simplify_gen_binary (AND, mode, op1, trueop0);
1772           return trueop0;
1773         }
1774       /* x/1 is x.  */
1775       if (trueop1 == CONST1_RTX (mode))
1776         return rtl_hooks.gen_lowpart_no_emit (mode, op0);
1777       /* Convert divide by power of two into shift.  */
1778       if (GET_CODE (trueop1) == CONST_INT
1779           && (val = exact_log2 (INTVAL (trueop1))) > 0)
1780         return simplify_gen_binary (LSHIFTRT, mode, op0, GEN_INT (val));
1781       break;
1782
1783     case DIV:
1784       /* Handle floating point and integers separately.  */
1785       if (SCALAR_FLOAT_MODE_P (mode))
1786         {
1787           /* Maybe change 0.0 / x to 0.0.  This transformation isn't
1788              safe for modes with NaNs, since 0.0 / 0.0 will then be
1789              NaN rather than 0.0.  Nor is it safe for modes with signed
1790              zeros, since dividing 0 by a negative number gives -0.0  */
1791           if (trueop0 == CONST0_RTX (mode)
1792               && !HONOR_NANS (mode)
1793               && !HONOR_SIGNED_ZEROS (mode)
1794               && ! side_effects_p (op1))
1795             return op0;
1796           /* x/1.0 is x.  */
1797           if (trueop1 == CONST1_RTX (mode)
1798               && !HONOR_SNANS (mode))
1799             return op0;
1800
1801           if (GET_CODE (trueop1) == CONST_DOUBLE
1802               && trueop1 != CONST0_RTX (mode))
1803             {
1804               REAL_VALUE_TYPE d;
1805               REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
1806
1807               /* x/-1.0 is -x.  */
1808               if (REAL_VALUES_EQUAL (d, dconstm1)
1809                   && !HONOR_SNANS (mode))
1810                 return simplify_gen_unary (NEG, mode, op0, mode);
1811
1812               /* Change FP division by a constant into multiplication.
1813                  Only do this with -funsafe-math-optimizations.  */
1814               if (flag_unsafe_math_optimizations
1815                   && !REAL_VALUES_EQUAL (d, dconst0))
1816                 {
1817                   REAL_ARITHMETIC (d, RDIV_EXPR, dconst1, d);
1818                   tem = CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
1819                   return simplify_gen_binary (MULT, mode, op0, tem);
1820                 }
1821             }
1822         }
1823       else
1824         {
1825           /* 0/x is 0 (or x&0 if x has side-effects).  */
1826           if (trueop0 == CONST0_RTX (mode))
1827             {
1828               if (side_effects_p (op1))
1829                 return simplify_gen_binary (AND, mode, op1, trueop0);
1830               return trueop0;
1831             }
1832           /* x/1 is x.  */
1833           if (trueop1 == CONST1_RTX (mode))
1834             return rtl_hooks.gen_lowpart_no_emit (mode, op0);
1835           /* x/-1 is -x.  */
1836           if (trueop1 == constm1_rtx)
1837             {
1838               rtx x = rtl_hooks.gen_lowpart_no_emit (mode, op0);
1839               return simplify_gen_unary (NEG, mode, x, mode);
1840             }
1841         }
1842       break;
1843
1844     case UMOD:
1845       /* 0%x is 0 (or x&0 if x has side-effects).  */
1846       if (trueop0 == CONST0_RTX (mode))
1847         {
1848           if (side_effects_p (op1))
1849             return simplify_gen_binary (AND, mode, op1, trueop0);
1850           return trueop0;
1851         }
1852       /* x%1 is 0 (of x&0 if x has side-effects).  */
1853       if (trueop1 == CONST1_RTX (mode))
1854         {
1855           if (side_effects_p (op0))
1856             return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
1857           return CONST0_RTX (mode);
1858         }
1859       /* Implement modulus by power of two as AND.  */
1860       if (GET_CODE (trueop1) == CONST_INT
1861           && exact_log2 (INTVAL (trueop1)) > 0)
1862         return simplify_gen_binary (AND, mode, op0,
1863                                     GEN_INT (INTVAL (op1) - 1));
1864       break;
1865
1866     case MOD:
1867       /* 0%x is 0 (or x&0 if x has side-effects).  */
1868       if (trueop0 == CONST0_RTX (mode))
1869         {
1870           if (side_effects_p (op1))
1871             return simplify_gen_binary (AND, mode, op1, trueop0);
1872           return trueop0;
1873         }
1874       /* x%1 and x%-1 is 0 (or x&0 if x has side-effects).  */
1875       if (trueop1 == CONST1_RTX (mode) || trueop1 == constm1_rtx)
1876         {
1877           if (side_effects_p (op0))
1878             return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode));
1879           return CONST0_RTX (mode);
1880         }
1881       break;
1882
1883     case ROTATERT:
1884     case ROTATE:
1885     case ASHIFTRT:
1886       /* Rotating ~0 always results in ~0.  */
1887       if (GET_CODE (trueop0) == CONST_INT && width <= HOST_BITS_PER_WIDE_INT
1888           && (unsigned HOST_WIDE_INT) INTVAL (trueop0) == GET_MODE_MASK (mode)
1889           && ! side_effects_p (op1))
1890         return op0;
1891
1892       /* Fall through....  */
1893
1894     case ASHIFT:
1895     case LSHIFTRT:
1896       if (trueop1 == CONST0_RTX (mode))
1897         return op0;
1898       if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1))
1899         return op0;
1900       break;
1901
1902     case SMIN:
1903       if (width <= HOST_BITS_PER_WIDE_INT
1904           && GET_CODE (trueop1) == CONST_INT
1905           && INTVAL (trueop1) == (HOST_WIDE_INT) 1 << (width -1)
1906           && ! side_effects_p (op0))
1907         return op1;
1908       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1909         return op0;
1910       tem = simplify_associative_operation (code, mode, op0, op1);
1911       if (tem)
1912         return tem;
1913       break;
1914
1915     case SMAX:
1916       if (width <= HOST_BITS_PER_WIDE_INT
1917           && GET_CODE (trueop1) == CONST_INT
1918           && ((unsigned HOST_WIDE_INT) INTVAL (trueop1)
1919               == (unsigned HOST_WIDE_INT) GET_MODE_MASK (mode) >> 1)
1920           && ! side_effects_p (op0))
1921         return op1;
1922       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1923         return op0;
1924       tem = simplify_associative_operation (code, mode, op0, op1);
1925       if (tem)
1926         return tem;
1927       break;
1928
1929     case UMIN:
1930       if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0))
1931         return op1;
1932       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1933         return op0;
1934       tem = simplify_associative_operation (code, mode, op0, op1);
1935       if (tem)
1936         return tem;
1937       break;
1938
1939     case UMAX:
1940       if (trueop1 == constm1_rtx && ! side_effects_p (op0))
1941         return op1;
1942       if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1943         return op0;
1944       tem = simplify_associative_operation (code, mode, op0, op1);
1945       if (tem)
1946         return tem;
1947       break;
1948
1949     case SS_PLUS:
1950     case US_PLUS:
1951     case SS_MINUS:
1952     case US_MINUS:
1953       /* ??? There are simplifications that can be done.  */
1954       return 0;
1955
1956     case VEC_SELECT:
1957       if (!VECTOR_MODE_P (mode))
1958         {
1959           gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
1960           gcc_assert (mode == GET_MODE_INNER (GET_MODE (trueop0)));
1961           gcc_assert (GET_CODE (trueop1) == PARALLEL);
1962           gcc_assert (XVECLEN (trueop1, 0) == 1);
1963           gcc_assert (GET_CODE (XVECEXP (trueop1, 0, 0)) == CONST_INT);
1964
1965           if (GET_CODE (trueop0) == CONST_VECTOR)
1966             return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP
1967                                                       (trueop1, 0, 0)));
1968         }
1969       else
1970         {
1971           gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
1972           gcc_assert (GET_MODE_INNER (mode)
1973                       == GET_MODE_INNER (GET_MODE (trueop0)));
1974           gcc_assert (GET_CODE (trueop1) == PARALLEL);
1975
1976           if (GET_CODE (trueop0) == CONST_VECTOR)
1977             {
1978               int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
1979               unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
1980               rtvec v = rtvec_alloc (n_elts);
1981               unsigned int i;
1982
1983               gcc_assert (XVECLEN (trueop1, 0) == (int) n_elts);
1984               for (i = 0; i < n_elts; i++)
1985                 {
1986                   rtx x = XVECEXP (trueop1, 0, i);
1987
1988                   gcc_assert (GET_CODE (x) == CONST_INT);
1989                   RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0,
1990                                                        INTVAL (x));
1991                 }
1992
1993               return gen_rtx_CONST_VECTOR (mode, v);
1994             }
1995         }
1996       return 0;
1997     case VEC_CONCAT:
1998       {
1999         enum machine_mode op0_mode = (GET_MODE (trueop0) != VOIDmode
2000                                       ? GET_MODE (trueop0)
2001                                       : GET_MODE_INNER (mode));
2002         enum machine_mode op1_mode = (GET_MODE (trueop1) != VOIDmode
2003                                       ? GET_MODE (trueop1)
2004                                       : GET_MODE_INNER (mode));
2005
2006         gcc_assert (VECTOR_MODE_P (mode));
2007         gcc_assert (GET_MODE_SIZE (op0_mode) + GET_MODE_SIZE (op1_mode)
2008                     == GET_MODE_SIZE (mode));
2009
2010         if (VECTOR_MODE_P (op0_mode))
2011           gcc_assert (GET_MODE_INNER (mode)
2012                       == GET_MODE_INNER (op0_mode));
2013         else
2014           gcc_assert (GET_MODE_INNER (mode) == op0_mode);
2015
2016         if (VECTOR_MODE_P (op1_mode))
2017           gcc_assert (GET_MODE_INNER (mode)
2018                       == GET_MODE_INNER (op1_mode));
2019         else
2020           gcc_assert (GET_MODE_INNER (mode) == op1_mode);
2021
2022         if ((GET_CODE (trueop0) == CONST_VECTOR
2023              || GET_CODE (trueop0) == CONST_INT
2024              || GET_CODE (trueop0) == CONST_DOUBLE)
2025             && (GET_CODE (trueop1) == CONST_VECTOR
2026                 || GET_CODE (trueop1) == CONST_INT
2027                 || GET_CODE (trueop1) == CONST_DOUBLE))
2028           {
2029             int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
2030             unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
2031             rtvec v = rtvec_alloc (n_elts);
2032             unsigned int i;
2033             unsigned in_n_elts = 1;
2034
2035             if (VECTOR_MODE_P (op0_mode))
2036               in_n_elts = (GET_MODE_SIZE (op0_mode) / elt_size);
2037             for (i = 0; i < n_elts; i++)
2038               {
2039                 if (i < in_n_elts)
2040                   {
2041                     if (!VECTOR_MODE_P (op0_mode))
2042                       RTVEC_ELT (v, i) = trueop0;
2043                     else
2044                       RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0, i);
2045                   }
2046                 else
2047                   {
2048                     if (!VECTOR_MODE_P (op1_mode))
2049                       RTVEC_ELT (v, i) = trueop1;
2050                     else
2051                       RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop1,
2052                                                            i - in_n_elts);
2053                   }
2054               }
2055
2056             return gen_rtx_CONST_VECTOR (mode, v);
2057           }
2058       }
2059       return 0;
2060
2061     default:
2062       gcc_unreachable ();
2063     }
2064
2065   return 0;
2066 }
2067
2068 rtx
2069 simplify_const_binary_operation (enum rtx_code code, enum machine_mode mode,
2070                                  rtx op0, rtx op1)
2071 {
2072   HOST_WIDE_INT arg0, arg1, arg0s, arg1s;
2073   HOST_WIDE_INT val;
2074   unsigned int width = GET_MODE_BITSIZE (mode);
2075
2076   if (VECTOR_MODE_P (mode)
2077       && code != VEC_CONCAT
2078       && GET_CODE (op0) == CONST_VECTOR
2079       && GET_CODE (op1) == CONST_VECTOR)
2080     {
2081       unsigned n_elts = GET_MODE_NUNITS (mode);
2082       enum machine_mode op0mode = GET_MODE (op0);
2083       unsigned op0_n_elts = GET_MODE_NUNITS (op0mode);
2084       enum machine_mode op1mode = GET_MODE (op1);
2085       unsigned op1_n_elts = GET_MODE_NUNITS (op1mode);
2086       rtvec v = rtvec_alloc (n_elts);
2087       unsigned int i;
2088
2089       gcc_assert (op0_n_elts == n_elts);
2090       gcc_assert (op1_n_elts == n_elts);
2091       for (i = 0; i < n_elts; i++)
2092         {
2093           rtx x = simplify_binary_operation (code, GET_MODE_INNER (mode),
2094                                              CONST_VECTOR_ELT (op0, i),
2095                                              CONST_VECTOR_ELT (op1, i));
2096           if (!x)
2097             return 0;
2098           RTVEC_ELT (v, i) = x;
2099         }
2100
2101       return gen_rtx_CONST_VECTOR (mode, v);
2102     }
2103
2104   if (VECTOR_MODE_P (mode)
2105       && code == VEC_CONCAT
2106       && CONSTANT_P (op0) && CONSTANT_P (op1))
2107     {
2108       unsigned n_elts = GET_MODE_NUNITS (mode);
2109       rtvec v = rtvec_alloc (n_elts);
2110
2111       gcc_assert (n_elts >= 2);
2112       if (n_elts == 2)
2113         {
2114           gcc_assert (GET_CODE (op0) != CONST_VECTOR);
2115           gcc_assert (GET_CODE (op1) != CONST_VECTOR);
2116
2117           RTVEC_ELT (v, 0) = op0;
2118           RTVEC_ELT (v, 1) = op1;
2119         }
2120       else
2121         {
2122           unsigned op0_n_elts = GET_MODE_NUNITS (GET_MODE (op0));
2123           unsigned op1_n_elts = GET_MODE_NUNITS (GET_MODE (op1));
2124           unsigned i;
2125
2126           gcc_assert (GET_CODE (op0) == CONST_VECTOR);
2127           gcc_assert (GET_CODE (op1) == CONST_VECTOR);
2128           gcc_assert (op0_n_elts + op1_n_elts == n_elts);
2129
2130           for (i = 0; i < op0_n_elts; ++i)
2131             RTVEC_ELT (v, i) = XVECEXP (op0, 0, i);
2132           for (i = 0; i < op1_n_elts; ++i)
2133             RTVEC_ELT (v, op0_n_elts+i) = XVECEXP (op1, 0, i);
2134         }
2135
2136       return gen_rtx_CONST_VECTOR (mode, v);
2137     }
2138
2139   if (SCALAR_FLOAT_MODE_P (mode)
2140       && GET_CODE (op0) == CONST_DOUBLE
2141       && GET_CODE (op1) == CONST_DOUBLE
2142       && mode == GET_MODE (op0) && mode == GET_MODE (op1))
2143     {
2144       if (code == AND
2145           || code == IOR
2146           || code == XOR)
2147         {
2148           long tmp0[4];
2149           long tmp1[4];
2150           REAL_VALUE_TYPE r;
2151           int i;
2152
2153           real_to_target (tmp0, CONST_DOUBLE_REAL_VALUE (op0),
2154                           GET_MODE (op0));
2155           real_to_target (tmp1, CONST_DOUBLE_REAL_VALUE (op1),
2156                           GET_MODE (op1));
2157           for (i = 0; i < 4; i++)
2158             {
2159               switch (code)
2160               {
2161               case AND:
2162                 tmp0[i] &= tmp1[i];
2163                 break;
2164               case IOR:
2165                 tmp0[i] |= tmp1[i];
2166                 break;
2167               case XOR:
2168                 tmp0[i] ^= tmp1[i];
2169                 break;
2170               default:
2171                 gcc_unreachable ();
2172               }
2173             }
2174            real_from_target (&r, tmp0, mode);
2175            return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
2176         }
2177       else
2178         {
2179           REAL_VALUE_TYPE f0, f1, value, result;
2180           bool inexact;
2181
2182           REAL_VALUE_FROM_CONST_DOUBLE (f0, op0);
2183           REAL_VALUE_FROM_CONST_DOUBLE (f1, op1);
2184           real_convert (&f0, mode, &f0);
2185           real_convert (&f1, mode, &f1);
2186
2187           if (HONOR_SNANS (mode)
2188               && (REAL_VALUE_ISNAN (f0) || REAL_VALUE_ISNAN (f1)))
2189             return 0;
2190
2191           if (code == DIV
2192               && REAL_VALUES_EQUAL (f1, dconst0)
2193               && (flag_trapping_math || ! MODE_HAS_INFINITIES (mode)))
2194             return 0;
2195
2196           if (MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
2197               && flag_trapping_math
2198               && REAL_VALUE_ISINF (f0) && REAL_VALUE_ISINF (f1))
2199             {
2200               int s0 = REAL_VALUE_NEGATIVE (f0);
2201               int s1 = REAL_VALUE_NEGATIVE (f1);
2202
2203               switch (code)
2204                 {
2205                 case PLUS:
2206                   /* Inf + -Inf = NaN plus exception.  */
2207                   if (s0 != s1)
2208                     return 0;
2209                   break;
2210                 case MINUS:
2211                   /* Inf - Inf = NaN plus exception.  */
2212                   if (s0 == s1)
2213                     return 0;
2214                   break;
2215                 case DIV:
2216                   /* Inf / Inf = NaN plus exception.  */
2217                   return 0;
2218                 default:
2219                   break;
2220                 }
2221             }
2222
2223           if (code == MULT && MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
2224               && flag_trapping_math
2225               && ((REAL_VALUE_ISINF (f0) && REAL_VALUES_EQUAL (f1, dconst0))
2226                   || (REAL_VALUE_ISINF (f1)
2227                       && REAL_VALUES_EQUAL (f0, dconst0))))
2228             /* Inf * 0 = NaN plus exception.  */
2229             return 0;
2230
2231           inexact = real_arithmetic (&value, rtx_to_tree_code (code),
2232                                      &f0, &f1);
2233           real_convert (&result, mode, &value);
2234
2235           /* Don't constant fold this floating point operation if
2236              the result has overflowed and flag_trapping_math.  */
2237
2238           if (flag_trapping_math
2239               && MODE_HAS_INFINITIES (mode)
2240               && REAL_VALUE_ISINF (result)
2241               && !REAL_VALUE_ISINF (f0)
2242               && !REAL_VALUE_ISINF (f1))
2243             /* Overflow plus exception.  */
2244             return 0;
2245
2246           /* Don't constant fold this floating point operation if the
2247              result may dependent upon the run-time rounding mode and
2248              flag_rounding_math is set, or if GCC's software emulation
2249              is unable to accurately represent the result.  */
2250
2251           if ((flag_rounding_math
2252                || (REAL_MODE_FORMAT_COMPOSITE_P (mode)
2253                    && !flag_unsafe_math_optimizations))
2254               && (inexact || !real_identical (&result, &value)))
2255             return NULL_RTX;
2256
2257           return CONST_DOUBLE_FROM_REAL_VALUE (result, mode);
2258         }
2259     }
2260
2261   /* We can fold some multi-word operations.  */
2262   if (GET_MODE_CLASS (mode) == MODE_INT
2263       && width == HOST_BITS_PER_WIDE_INT * 2
2264       && (GET_CODE (op0) == CONST_DOUBLE || GET_CODE (op0) == CONST_INT)
2265       && (GET_CODE (op1) == CONST_DOUBLE || GET_CODE (op1) == CONST_INT))
2266     {
2267       unsigned HOST_WIDE_INT l1, l2, lv, lt;
2268       HOST_WIDE_INT h1, h2, hv, ht;
2269
2270       if (GET_CODE (op0) == CONST_DOUBLE)
2271         l1 = CONST_DOUBLE_LOW (op0), h1 = CONST_DOUBLE_HIGH (op0);
2272       else
2273         l1 = INTVAL (op0), h1 = HWI_SIGN_EXTEND (l1);
2274
2275       if (GET_CODE (op1) == CONST_DOUBLE)
2276         l2 = CONST_DOUBLE_LOW (op1), h2 = CONST_DOUBLE_HIGH (op1);
2277       else
2278         l2 = INTVAL (op1), h2 = HWI_SIGN_EXTEND (l2);
2279
2280       switch (code)
2281         {
2282         case MINUS:
2283           /* A - B == A + (-B).  */
2284           neg_double (l2, h2, &lv, &hv);
2285           l2 = lv, h2 = hv;
2286
2287           /* Fall through....  */
2288
2289         case PLUS:
2290           add_double (l1, h1, l2, h2, &lv, &hv);
2291           break;
2292
2293         case MULT:
2294           mul_double (l1, h1, l2, h2, &lv, &hv);
2295           break;
2296
2297         case DIV:
2298           if (div_and_round_double (TRUNC_DIV_EXPR, 0, l1, h1, l2, h2,
2299                                     &lv, &hv, &lt, &ht))
2300             return 0;
2301           break;
2302
2303         case MOD:
2304           if (div_and_round_double (TRUNC_DIV_EXPR, 0, l1, h1, l2, h2,
2305                                     &lt, &ht, &lv, &hv))
2306             return 0;
2307           break;
2308
2309         case UDIV:
2310           if (div_and_round_double (TRUNC_DIV_EXPR, 1, l1, h1, l2, h2,
2311                                     &lv, &hv, &lt, &ht))
2312             return 0;
2313           break;
2314
2315         case UMOD:
2316           if (div_and_round_double (TRUNC_DIV_EXPR, 1, l1, h1, l2, h2,
2317                                     &lt, &ht, &lv, &hv))
2318             return 0;
2319           break;
2320
2321         case AND:
2322           lv = l1 & l2, hv = h1 & h2;
2323           break;
2324
2325         case IOR:
2326           lv = l1 | l2, hv = h1 | h2;
2327           break;
2328
2329         case XOR:
2330           lv = l1 ^ l2, hv = h1 ^ h2;
2331           break;
2332
2333         case SMIN:
2334           if (h1 < h2
2335               || (h1 == h2
2336                   && ((unsigned HOST_WIDE_INT) l1
2337                       < (unsigned HOST_WIDE_INT) l2)))
2338             lv = l1, hv = h1;
2339           else
2340             lv = l2, hv = h2;
2341           break;
2342
2343         case SMAX:
2344           if (h1 > h2
2345               || (h1 == h2
2346                   && ((unsigned HOST_WIDE_INT) l1
2347                       > (unsigned HOST_WIDE_INT) l2)))
2348             lv = l1, hv = h1;
2349           else
2350             lv = l2, hv = h2;
2351           break;
2352
2353         case UMIN:
2354           if ((unsigned HOST_WIDE_INT) h1 < (unsigned HOST_WIDE_INT) h2
2355               || (h1 == h2
2356                   && ((unsigned HOST_WIDE_INT) l1
2357                       < (unsigned HOST_WIDE_INT) l2)))
2358             lv = l1, hv = h1;
2359           else
2360             lv = l2, hv = h2;
2361           break;
2362
2363         case UMAX:
2364           if ((unsigned HOST_WIDE_INT) h1 > (unsigned HOST_WIDE_INT) h2
2365               || (h1 == h2
2366                   && ((unsigned HOST_WIDE_INT) l1
2367                       > (unsigned HOST_WIDE_INT) l2)))
2368             lv = l1, hv = h1;
2369           else
2370             lv = l2, hv = h2;
2371           break;
2372
2373         case LSHIFTRT:   case ASHIFTRT:
2374         case ASHIFT:
2375         case ROTATE:     case ROTATERT:
2376           if (SHIFT_COUNT_TRUNCATED)
2377             l2 &= (GET_MODE_BITSIZE (mode) - 1), h2 = 0;
2378
2379           if (h2 != 0 || l2 >= GET_MODE_BITSIZE (mode))
2380             return 0;
2381
2382           if (code == LSHIFTRT || code == ASHIFTRT)
2383             rshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv,
2384                            code == ASHIFTRT);
2385           else if (code == ASHIFT)
2386             lshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv, 1);
2387           else if (code == ROTATE)
2388             lrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
2389           else /* code == ROTATERT */
2390             rrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
2391           break;
2392
2393         default:
2394           return 0;
2395         }
2396
2397       return immed_double_const (lv, hv, mode);
2398     }
2399
2400   if (GET_CODE (op0) == CONST_INT && GET_CODE (op1) == CONST_INT
2401       && width <= HOST_BITS_PER_WIDE_INT && width != 0)
2402     {
2403       /* Get the integer argument values in two forms:
2404          zero-extended in ARG0, ARG1 and sign-extended in ARG0S, ARG1S.  */
2405
2406       arg0 = INTVAL (op0);
2407       arg1 = INTVAL (op1);
2408
2409       if (width < HOST_BITS_PER_WIDE_INT)
2410         {
2411           arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
2412           arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
2413
2414           arg0s = arg0;
2415           if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
2416             arg0s |= ((HOST_WIDE_INT) (-1) << width);
2417
2418           arg1s = arg1;
2419           if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1)))
2420             arg1s |= ((HOST_WIDE_INT) (-1) << width);
2421         }
2422       else
2423         {
2424           arg0s = arg0;
2425           arg1s = arg1;
2426         }
2427       
2428       /* Compute the value of the arithmetic.  */
2429       
2430       switch (code)
2431         {
2432         case PLUS:
2433           val = arg0s + arg1s;
2434           break;
2435           
2436         case MINUS:
2437           val = arg0s - arg1s;
2438           break;
2439           
2440         case MULT:
2441           val = arg0s * arg1s;
2442           break;
2443           
2444         case DIV:
2445           if (arg1s == 0
2446               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2447                   && arg1s == -1))
2448             return 0;
2449           val = arg0s / arg1s;
2450           break;
2451           
2452         case MOD:
2453           if (arg1s == 0
2454               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2455                   && arg1s == -1))
2456             return 0;
2457           val = arg0s % arg1s;
2458           break;
2459           
2460         case UDIV:
2461           if (arg1 == 0
2462               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2463                   && arg1s == -1))
2464             return 0;
2465           val = (unsigned HOST_WIDE_INT) arg0 / arg1;
2466           break;
2467           
2468         case UMOD:
2469           if (arg1 == 0
2470               || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2471                   && arg1s == -1))
2472             return 0;
2473           val = (unsigned HOST_WIDE_INT) arg0 % arg1;
2474           break;
2475           
2476         case AND:
2477           val = arg0 & arg1;
2478           break;
2479           
2480         case IOR:
2481           val = arg0 | arg1;
2482           break;
2483           
2484         case XOR:
2485           val = arg0 ^ arg1;
2486           break;
2487           
2488         case LSHIFTRT:
2489         case ASHIFT:
2490         case ASHIFTRT:
2491           /* Truncate the shift if SHIFT_COUNT_TRUNCATED, otherwise make sure
2492              the value is in range.  We can't return any old value for
2493              out-of-range arguments because either the middle-end (via
2494              shift_truncation_mask) or the back-end might be relying on
2495              target-specific knowledge.  Nor can we rely on
2496              shift_truncation_mask, since the shift might not be part of an
2497              ashlM3, lshrM3 or ashrM3 instruction.  */
2498           if (SHIFT_COUNT_TRUNCATED)
2499             arg1 = (unsigned HOST_WIDE_INT) arg1 % width;
2500           else if (arg1 < 0 || arg1 >= GET_MODE_BITSIZE (mode))
2501             return 0;
2502           
2503           val = (code == ASHIFT
2504                  ? ((unsigned HOST_WIDE_INT) arg0) << arg1
2505                  : ((unsigned HOST_WIDE_INT) arg0) >> arg1);
2506           
2507           /* Sign-extend the result for arithmetic right shifts.  */
2508           if (code == ASHIFTRT && arg0s < 0 && arg1 > 0)
2509             val |= ((HOST_WIDE_INT) -1) << (width - arg1);
2510           break;
2511           
2512         case ROTATERT:
2513           if (arg1 < 0)
2514             return 0;
2515           
2516           arg1 %= width;
2517           val = ((((unsigned HOST_WIDE_INT) arg0) << (width - arg1))
2518                  | (((unsigned HOST_WIDE_INT) arg0) >> arg1));
2519           break;
2520           
2521         case ROTATE:
2522           if (arg1 < 0)
2523             return 0;
2524           
2525           arg1 %= width;
2526           val = ((((unsigned HOST_WIDE_INT) arg0) << arg1)
2527                  | (((unsigned HOST_WIDE_INT) arg0) >> (width - arg1)));
2528           break;
2529           
2530         case COMPARE:
2531           /* Do nothing here.  */
2532           return 0;
2533           
2534         case SMIN:
2535           val = arg0s <= arg1s ? arg0s : arg1s;
2536           break;
2537           
2538         case UMIN:
2539           val = ((unsigned HOST_WIDE_INT) arg0
2540                  <= (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
2541           break;
2542           
2543         case SMAX:
2544           val = arg0s > arg1s ? arg0s : arg1s;
2545           break;
2546           
2547         case UMAX:
2548           val = ((unsigned HOST_WIDE_INT) arg0
2549                  > (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
2550           break;
2551           
2552         case SS_PLUS:
2553         case US_PLUS:
2554         case SS_MINUS:
2555         case US_MINUS:
2556           /* ??? There are simplifications that can be done.  */
2557           return 0;
2558           
2559         default:
2560           gcc_unreachable ();
2561         }
2562
2563       return gen_int_mode (val, mode);
2564     }
2565
2566   return NULL_RTX;
2567 }
2568
2569
2570 \f
2571 /* Simplify a PLUS or MINUS, at least one of whose operands may be another
2572    PLUS or MINUS.
2573
2574    Rather than test for specific case, we do this by a brute-force method
2575    and do all possible simplifications until no more changes occur.  Then
2576    we rebuild the operation.  */
2577
2578 struct simplify_plus_minus_op_data
2579 {
2580   rtx op;
2581   short neg;
2582   short ix;
2583 };
2584
2585 static int
2586 simplify_plus_minus_op_data_cmp (const void *p1, const void *p2)
2587 {
2588   const struct simplify_plus_minus_op_data *d1 = p1;
2589   const struct simplify_plus_minus_op_data *d2 = p2;
2590   int result;
2591
2592   result = (commutative_operand_precedence (d2->op)
2593             - commutative_operand_precedence (d1->op));
2594   if (result)
2595     return result;
2596   return d1->ix - d2->ix;
2597 }
2598
2599 static rtx
2600 simplify_plus_minus (enum rtx_code code, enum machine_mode mode, rtx op0,
2601                      rtx op1)
2602 {
2603   struct simplify_plus_minus_op_data ops[8];
2604   rtx result, tem;
2605   int n_ops = 2, input_ops = 2;
2606   int first, changed, canonicalized = 0;
2607   int i, j;
2608
2609   memset (ops, 0, sizeof ops);
2610
2611   /* Set up the two operands and then expand them until nothing has been
2612      changed.  If we run out of room in our array, give up; this should
2613      almost never happen.  */
2614
2615   ops[0].op = op0;
2616   ops[0].neg = 0;
2617   ops[1].op = op1;
2618   ops[1].neg = (code == MINUS);
2619
2620   do
2621     {
2622       changed = 0;
2623
2624       for (i = 0; i < n_ops; i++)
2625         {
2626           rtx this_op = ops[i].op;
2627           int this_neg = ops[i].neg;
2628           enum rtx_code this_code = GET_CODE (this_op);
2629
2630           switch (this_code)
2631             {
2632             case PLUS:
2633             case MINUS:
2634               if (n_ops == 7)
2635                 return NULL_RTX;
2636
2637               ops[n_ops].op = XEXP (this_op, 1);
2638               ops[n_ops].neg = (this_code == MINUS) ^ this_neg;
2639               n_ops++;
2640
2641               ops[i].op = XEXP (this_op, 0);
2642               input_ops++;
2643               changed = 1;
2644               canonicalized |= this_neg;
2645               break;
2646
2647             case NEG:
2648               ops[i].op = XEXP (this_op, 0);
2649               ops[i].neg = ! this_neg;
2650               changed = 1;
2651               canonicalized = 1;
2652               break;
2653
2654             case CONST:
2655               if (n_ops < 7
2656                   && GET_CODE (XEXP (this_op, 0)) == PLUS
2657                   && CONSTANT_P (XEXP (XEXP (this_op, 0), 0))
2658                   && CONSTANT_P (XEXP (XEXP (this_op, 0), 1)))
2659                 {
2660                   ops[i].op = XEXP (XEXP (this_op, 0), 0);
2661                   ops[n_ops].op = XEXP (XEXP (this_op, 0), 1);
2662                   ops[n_ops].neg = this_neg;
2663                   n_ops++;
2664                   changed = 1;
2665                   canonicalized = 1;
2666                 }
2667               break;
2668
2669             case NOT:
2670               /* ~a -> (-a - 1) */
2671               if (n_ops != 7)
2672                 {
2673                   ops[n_ops].op = constm1_rtx;
2674                   ops[n_ops++].neg = this_neg;
2675                   ops[i].op = XEXP (this_op, 0);
2676                   ops[i].neg = !this_neg;
2677                   changed = 1;
2678                   canonicalized = 1;
2679                 }
2680               break;
2681
2682             case CONST_INT:
2683               if (this_neg)
2684                 {
2685                   ops[i].op = neg_const_int (mode, this_op);
2686                   ops[i].neg = 0;
2687                   changed = 1;
2688                   canonicalized = 1;
2689                 }
2690               break;
2691
2692             default:
2693               break;
2694             }
2695         }
2696     }
2697   while (changed);
2698
2699   gcc_assert (n_ops >= 2);
2700   if (!canonicalized)
2701     {
2702       int n_constants = 0;
2703
2704       for (i = 0; i < n_ops; i++)
2705         if (GET_CODE (ops[i].op) == CONST_INT)
2706           n_constants++;
2707
2708       if (n_constants <= 1)
2709         return NULL_RTX;
2710     }
2711
2712   /* If we only have two operands, we can avoid the loops.  */
2713   if (n_ops == 2)
2714     {
2715       enum rtx_code code = ops[0].neg || ops[1].neg ? MINUS : PLUS;
2716       rtx lhs, rhs;
2717
2718       /* Get the two operands.  Be careful with the order, especially for
2719          the cases where code == MINUS.  */
2720       if (ops[0].neg && ops[1].neg)
2721         {
2722           lhs = gen_rtx_NEG (mode, ops[0].op);
2723           rhs = ops[1].op;
2724         }
2725       else if (ops[0].neg)
2726         {
2727           lhs = ops[1].op;
2728           rhs = ops[0].op;
2729         }
2730       else
2731         {
2732           lhs = ops[0].op;
2733           rhs = ops[1].op;
2734         }
2735
2736       return simplify_const_binary_operation (code, mode, lhs, rhs);
2737     }
2738
2739   /* Now simplify each pair of operands until nothing changes.  The first
2740      time through just simplify constants against each other.  */
2741
2742   first = 1;
2743   do
2744     {
2745       changed = first;
2746
2747       for (i = 0; i < n_ops - 1; i++)
2748         for (j = i + 1; j < n_ops; j++)
2749           {
2750             rtx lhs = ops[i].op, rhs = ops[j].op;
2751             int lneg = ops[i].neg, rneg = ops[j].neg;
2752
2753             if (lhs != 0 && rhs != 0
2754                 && (! first || (CONSTANT_P (lhs) && CONSTANT_P (rhs))))
2755               {
2756                 enum rtx_code ncode = PLUS;
2757
2758                 if (lneg != rneg)
2759                   {
2760                     ncode = MINUS;
2761                     if (lneg)
2762                       tem = lhs, lhs = rhs, rhs = tem;
2763                   }
2764                 else if (swap_commutative_operands_p (lhs, rhs))
2765                   tem = lhs, lhs = rhs, rhs = tem;
2766
2767                 tem = simplify_binary_operation (ncode, mode, lhs, rhs);
2768
2769                 /* Reject "simplifications" that just wrap the two
2770                    arguments in a CONST.  Failure to do so can result
2771                    in infinite recursion with simplify_binary_operation
2772                    when it calls us to simplify CONST operations.  */
2773                 if (tem
2774                     && ! (GET_CODE (tem) == CONST
2775                           && GET_CODE (XEXP (tem, 0)) == ncode
2776                           && XEXP (XEXP (tem, 0), 0) == lhs
2777                           && XEXP (XEXP (tem, 0), 1) == rhs)
2778                     /* Don't allow -x + -1 -> ~x simplifications in the
2779                        first pass.  This allows us the chance to combine
2780                        the -1 with other constants.  */
2781                     && ! (first
2782                           && GET_CODE (tem) == NOT
2783                           && XEXP (tem, 0) == rhs))
2784                   {
2785                     lneg &= rneg;
2786                     if (GET_CODE (tem) == NEG)
2787                       tem = XEXP (tem, 0), lneg = !lneg;
2788                     if (GET_CODE (tem) == CONST_INT && lneg)
2789                       tem = neg_const_int (mode, tem), lneg = 0;
2790
2791                     ops[i].op = tem;
2792                     ops[i].neg = lneg;
2793                     ops[j].op = NULL_RTX;
2794                     changed = 1;
2795                   }
2796               }
2797           }
2798
2799       first = 0;
2800     }
2801   while (changed);
2802
2803   /* Pack all the operands to the lower-numbered entries.  */
2804   for (i = 0, j = 0; j < n_ops; j++)
2805     if (ops[j].op)
2806       {
2807         ops[i] = ops[j];
2808         /* Stabilize sort.  */
2809         ops[i].ix = i;
2810         i++;
2811       }
2812   n_ops = i;
2813
2814   /* Sort the operations based on swap_commutative_operands_p.  */
2815   qsort (ops, n_ops, sizeof (*ops), simplify_plus_minus_op_data_cmp);
2816
2817   /* Create (minus -C X) instead of (neg (const (plus X C))).  */
2818   if (n_ops == 2
2819       && GET_CODE (ops[1].op) == CONST_INT
2820       && CONSTANT_P (ops[0].op)
2821       && ops[0].neg)
2822     return gen_rtx_fmt_ee (MINUS, mode, ops[1].op, ops[0].op);
2823   
2824   /* We suppressed creation of trivial CONST expressions in the
2825      combination loop to avoid recursion.  Create one manually now.
2826      The combination loop should have ensured that there is exactly
2827      one CONST_INT, and the sort will have ensured that it is last
2828      in the array and that any other constant will be next-to-last.  */
2829
2830   if (n_ops > 1
2831       && GET_CODE (ops[n_ops - 1].op) == CONST_INT
2832       && CONSTANT_P (ops[n_ops - 2].op))
2833     {
2834       rtx value = ops[n_ops - 1].op;
2835       if (ops[n_ops - 1].neg ^ ops[n_ops - 2].neg)
2836         value = neg_const_int (mode, value);
2837       ops[n_ops - 2].op = plus_constant (ops[n_ops - 2].op, INTVAL (value));
2838       n_ops--;
2839     }
2840
2841   /* Put a non-negated operand first, if possible.  */
2842
2843   for (i = 0; i < n_ops && ops[i].neg; i++)
2844     continue;
2845   if (i == n_ops)
2846     ops[0].op = gen_rtx_NEG (mode, ops[0].op);
2847   else if (i != 0)
2848     {
2849       tem = ops[0].op;
2850       ops[0] = ops[i];
2851       ops[i].op = tem;
2852       ops[i].neg = 1;
2853     }
2854
2855   /* Now make the result by performing the requested operations.  */
2856   result = ops[0].op;
2857   for (i = 1; i < n_ops; i++)
2858     result = gen_rtx_fmt_ee (ops[i].neg ? MINUS : PLUS,
2859                              mode, result, ops[i].op);
2860
2861   return result;
2862 }
2863
2864 /* Check whether an operand is suitable for calling simplify_plus_minus.  */
2865 static bool
2866 plus_minus_operand_p (rtx x)
2867 {
2868   return GET_CODE (x) == PLUS
2869          || GET_CODE (x) == MINUS
2870          || (GET_CODE (x) == CONST
2871              && GET_CODE (XEXP (x, 0)) == PLUS
2872              && CONSTANT_P (XEXP (XEXP (x, 0), 0))
2873              && CONSTANT_P (XEXP (XEXP (x, 0), 1)));
2874 }
2875
2876 /* Like simplify_binary_operation except used for relational operators.
2877    MODE is the mode of the result. If MODE is VOIDmode, both operands must
2878    not also be VOIDmode.
2879
2880    CMP_MODE specifies in which mode the comparison is done in, so it is
2881    the mode of the operands.  If CMP_MODE is VOIDmode, it is taken from
2882    the operands or, if both are VOIDmode, the operands are compared in
2883    "infinite precision".  */
2884 rtx
2885 simplify_relational_operation (enum rtx_code code, enum machine_mode mode,
2886                                enum machine_mode cmp_mode, rtx op0, rtx op1)
2887 {
2888   rtx tem, trueop0, trueop1;
2889
2890   if (cmp_mode == VOIDmode)
2891     cmp_mode = GET_MODE (op0);
2892   if (cmp_mode == VOIDmode)
2893     cmp_mode = GET_MODE (op1);
2894
2895   tem = simplify_const_relational_operation (code, cmp_mode, op0, op1);
2896   if (tem)
2897     {
2898       if (SCALAR_FLOAT_MODE_P (mode))
2899         {
2900           if (tem == const0_rtx)
2901             return CONST0_RTX (mode);
2902 #ifdef FLOAT_STORE_FLAG_VALUE
2903           {
2904             REAL_VALUE_TYPE val;
2905             val = FLOAT_STORE_FLAG_VALUE (mode);
2906             return CONST_DOUBLE_FROM_REAL_VALUE (val, mode);
2907           }
2908 #else
2909           return NULL_RTX;
2910 #endif 
2911         }
2912       if (VECTOR_MODE_P (mode))
2913         {
2914           if (tem == const0_rtx)
2915             return CONST0_RTX (mode);
2916 #ifdef VECTOR_STORE_FLAG_VALUE
2917           {
2918             int i, units;
2919             rtvec v;
2920
2921             rtx val = VECTOR_STORE_FLAG_VALUE (mode);
2922             if (val == NULL_RTX)
2923               return NULL_RTX;
2924             if (val == const1_rtx)
2925               return CONST1_RTX (mode);
2926
2927             units = GET_MODE_NUNITS (mode);
2928             v = rtvec_alloc (units);
2929             for (i = 0; i < units; i++)
2930               RTVEC_ELT (v, i) = val;
2931             return gen_rtx_raw_CONST_VECTOR (mode, v);
2932           }
2933 #else
2934           return NULL_RTX;
2935 #endif
2936         }
2937
2938       return tem;
2939     }
2940
2941   /* For the following tests, ensure const0_rtx is op1.  */
2942   if (swap_commutative_operands_p (op0, op1)
2943       || (op0 == const0_rtx && op1 != const0_rtx))
2944     tem = op0, op0 = op1, op1 = tem, code = swap_condition (code);
2945
2946   /* If op0 is a compare, extract the comparison arguments from it.  */
2947   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
2948     return simplify_relational_operation (code, mode, VOIDmode,
2949                                           XEXP (op0, 0), XEXP (op0, 1));
2950
2951   if (mode == VOIDmode
2952       || GET_MODE_CLASS (cmp_mode) == MODE_CC
2953       || CC0_P (op0))
2954     return NULL_RTX;
2955
2956   trueop0 = avoid_constant_pool_reference (op0);
2957   trueop1 = avoid_constant_pool_reference (op1);
2958   return simplify_relational_operation_1 (code, mode, cmp_mode,
2959                                           trueop0, trueop1);
2960 }
2961
2962 /* This part of simplify_relational_operation is only used when CMP_MODE
2963    is not in class MODE_CC (i.e. it is a real comparison).
2964
2965    MODE is the mode of the result, while CMP_MODE specifies in which
2966    mode the comparison is done in, so it is the mode of the operands.  */
2967
2968 static rtx
2969 simplify_relational_operation_1 (enum rtx_code code, enum machine_mode mode,
2970                                  enum machine_mode cmp_mode, rtx op0, rtx op1)
2971 {
2972   enum rtx_code op0code = GET_CODE (op0);
2973
2974   if (GET_CODE (op1) == CONST_INT)
2975     {
2976       if (INTVAL (op1) == 0 && COMPARISON_P (op0))
2977         {
2978           /* If op0 is a comparison, extract the comparison arguments form it.  */
2979           if (code == NE)
2980             {
2981               if (GET_MODE (op0) == mode)
2982                 return simplify_rtx (op0);
2983               else
2984                 return simplify_gen_relational (GET_CODE (op0), mode, VOIDmode,
2985                                                 XEXP (op0, 0), XEXP (op0, 1));
2986             }
2987           else if (code == EQ)
2988             {
2989               enum rtx_code new_code = reversed_comparison_code (op0, NULL_RTX);
2990               if (new_code != UNKNOWN)
2991                 return simplify_gen_relational (new_code, mode, VOIDmode,
2992                                                 XEXP (op0, 0), XEXP (op0, 1));
2993             }
2994         }
2995     }
2996
2997   /* (eq/ne (plus x cst1) cst2) simplifies to (eq/ne x (cst2 - cst1))  */
2998   if ((code == EQ || code == NE)
2999       && (op0code == PLUS || op0code == MINUS)
3000       && CONSTANT_P (op1)
3001       && CONSTANT_P (XEXP (op0, 1))
3002       && (INTEGRAL_MODE_P (cmp_mode) || flag_unsafe_math_optimizations))
3003     {
3004       rtx x = XEXP (op0, 0);
3005       rtx c = XEXP (op0, 1);
3006
3007       c = simplify_gen_binary (op0code == PLUS ? MINUS : PLUS,
3008                                cmp_mode, op1, c);
3009       return simplify_gen_relational (code, mode, cmp_mode, x, c);
3010     }
3011
3012   /* (ne:SI (zero_extract:SI FOO (const_int 1) BAR) (const_int 0))) is
3013      the same as (zero_extract:SI FOO (const_int 1) BAR).  */
3014   if (code == NE
3015       && op1 == const0_rtx
3016       && GET_MODE_CLASS (mode) == MODE_INT
3017       && cmp_mode != VOIDmode
3018       /* ??? Work-around BImode bugs in the ia64 backend.  */
3019       && mode != BImode
3020       && cmp_mode != BImode
3021       && nonzero_bits (op0, cmp_mode) == 1
3022       && STORE_FLAG_VALUE == 1)
3023     return GET_MODE_SIZE (mode) > GET_MODE_SIZE (cmp_mode)
3024            ? simplify_gen_unary (ZERO_EXTEND, mode, op0, cmp_mode)
3025            : lowpart_subreg (mode, op0, cmp_mode);
3026
3027   return NULL_RTX;
3028 }
3029
3030 /* Check if the given comparison (done in the given MODE) is actually a
3031    tautology or a contradiction.
3032    If no simplification is possible, this function returns zero.
3033    Otherwise, it returns either const_true_rtx or const0_rtx.  */
3034
3035 rtx
3036 simplify_const_relational_operation (enum rtx_code code,
3037                                      enum machine_mode mode,
3038                                      rtx op0, rtx op1)
3039 {
3040   int equal, op0lt, op0ltu, op1lt, op1ltu;
3041   rtx tem;
3042   rtx trueop0;
3043   rtx trueop1;
3044
3045   gcc_assert (mode != VOIDmode
3046               || (GET_MODE (op0) == VOIDmode
3047                   && GET_MODE (op1) == VOIDmode));
3048
3049   /* If op0 is a compare, extract the comparison arguments from it.  */
3050   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
3051     {
3052       op1 = XEXP (op0, 1);
3053       op0 = XEXP (op0, 0);
3054
3055       if (GET_MODE (op0) != VOIDmode)
3056         mode = GET_MODE (op0);
3057       else if (GET_MODE (op1) != VOIDmode)
3058         mode = GET_MODE (op1);
3059       else
3060         return 0;
3061     }
3062
3063   /* We can't simplify MODE_CC values since we don't know what the
3064      actual comparison is.  */
3065   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC || CC0_P (op0))
3066     return 0;
3067
3068   /* Make sure the constant is second.  */
3069   if (swap_commutative_operands_p (op0, op1))
3070     {
3071       tem = op0, op0 = op1, op1 = tem;
3072       code = swap_condition (code);
3073     }
3074
3075   trueop0 = avoid_constant_pool_reference (op0);
3076   trueop1 = avoid_constant_pool_reference (op1);
3077
3078   /* For integer comparisons of A and B maybe we can simplify A - B and can
3079      then simplify a comparison of that with zero.  If A and B are both either
3080      a register or a CONST_INT, this can't help; testing for these cases will
3081      prevent infinite recursion here and speed things up.
3082
3083      If CODE is an unsigned comparison, then we can never do this optimization,
3084      because it gives an incorrect result if the subtraction wraps around zero.
3085      ANSI C defines unsigned operations such that they never overflow, and
3086      thus such cases can not be ignored; but we cannot do it even for
3087      signed comparisons for languages such as Java, so test flag_wrapv.  */
3088
3089   if (!flag_wrapv && INTEGRAL_MODE_P (mode) && trueop1 != const0_rtx
3090       && ! ((REG_P (op0) || GET_CODE (trueop0) == CONST_INT)
3091             && (REG_P (op1) || GET_CODE (trueop1) == CONST_INT))
3092       && 0 != (tem = simplify_binary_operation (MINUS, mode, op0, op1))
3093       /* We cannot do this for == or != if tem is a nonzero address.  */
3094       && ((code != EQ && code != NE) || ! nonzero_address_p (tem))
3095       && code != GTU && code != GEU && code != LTU && code != LEU)
3096     return simplify_const_relational_operation (signed_condition (code),
3097                                                 mode, tem, const0_rtx);
3098
3099   if (flag_unsafe_math_optimizations && code == ORDERED)
3100     return const_true_rtx;
3101
3102   if (flag_unsafe_math_optimizations && code == UNORDERED)
3103     return const0_rtx;
3104
3105   /* For modes without NaNs, if the two operands are equal, we know the
3106      result except if they have side-effects.  */
3107   if (! HONOR_NANS (GET_MODE (trueop0))
3108       && rtx_equal_p (trueop0, trueop1)
3109       && ! side_effects_p (trueop0))
3110     equal = 1, op0lt = 0, op0ltu = 0, op1lt = 0, op1ltu = 0;
3111
3112   /* If the operands are floating-point constants, see if we can fold
3113      the result.  */
3114   else if (GET_CODE (trueop0) == CONST_DOUBLE
3115            && GET_CODE (trueop1) == CONST_DOUBLE
3116            && SCALAR_FLOAT_MODE_P (GET_MODE (trueop0)))
3117     {
3118       REAL_VALUE_TYPE d0, d1;
3119
3120       REAL_VALUE_FROM_CONST_DOUBLE (d0, trueop0);
3121       REAL_VALUE_FROM_CONST_DOUBLE (d1, trueop1);
3122
3123       /* Comparisons are unordered iff at least one of the values is NaN.  */
3124       if (REAL_VALUE_ISNAN (d0) || REAL_VALUE_ISNAN (d1))
3125         switch (code)
3126           {
3127           case UNEQ:
3128           case UNLT:
3129           case UNGT:
3130           case UNLE:
3131           case UNGE:
3132           case NE:
3133           case UNORDERED:
3134             return const_true_rtx;
3135           case EQ:
3136           case LT:
3137           case GT:
3138           case LE:
3139           case GE:
3140           case LTGT:
3141           case ORDERED:
3142             return const0_rtx;
3143           default:
3144             return 0;
3145           }
3146
3147       equal = REAL_VALUES_EQUAL (d0, d1);
3148       op0lt = op0ltu = REAL_VALUES_LESS (d0, d1);
3149       op1lt = op1ltu = REAL_VALUES_LESS (d1, d0);
3150     }
3151
3152   /* Otherwise, see if the operands are both integers.  */
3153   else if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode)
3154            && (GET_CODE (trueop0) == CONST_DOUBLE
3155                || GET_CODE (trueop0) == CONST_INT)
3156            && (GET_CODE (trueop1) == CONST_DOUBLE
3157                || GET_CODE (trueop1) == CONST_INT))
3158     {
3159       int width = GET_MODE_BITSIZE (mode);
3160       HOST_WIDE_INT l0s, h0s, l1s, h1s;
3161       unsigned HOST_WIDE_INT l0u, h0u, l1u, h1u;
3162
3163       /* Get the two words comprising each integer constant.  */
3164       if (GET_CODE (trueop0) == CONST_DOUBLE)
3165         {
3166           l0u = l0s = CONST_DOUBLE_LOW (trueop0);
3167           h0u = h0s = CONST_DOUBLE_HIGH (trueop0);
3168         }
3169       else
3170         {
3171           l0u = l0s = INTVAL (trueop0);
3172           h0u = h0s = HWI_SIGN_EXTEND (l0s);
3173         }
3174
3175       if (GET_CODE (trueop1) == CONST_DOUBLE)
3176         {
3177           l1u = l1s = CONST_DOUBLE_LOW (trueop1);
3178           h1u = h1s = CONST_DOUBLE_HIGH (trueop1);
3179         }
3180       else
3181         {
3182           l1u = l1s = INTVAL (trueop1);
3183           h1u = h1s = HWI_SIGN_EXTEND (l1s);
3184         }
3185
3186       /* If WIDTH is nonzero and smaller than HOST_BITS_PER_WIDE_INT,
3187          we have to sign or zero-extend the values.  */
3188       if (width != 0 && width < HOST_BITS_PER_WIDE_INT)
3189         {
3190           l0u &= ((HOST_WIDE_INT) 1 << width) - 1;
3191           l1u &= ((HOST_WIDE_INT) 1 << width) - 1;
3192
3193           if (l0s & ((HOST_WIDE_INT) 1 << (width - 1)))
3194             l0s |= ((HOST_WIDE_INT) (-1) << width);
3195
3196           if (l1s & ((HOST_WIDE_INT) 1 << (width - 1)))
3197             l1s |= ((HOST_WIDE_INT) (-1) << width);
3198         }
3199       if (width != 0 && width <= HOST_BITS_PER_WIDE_INT)
3200         h0u = h1u = 0, h0s = HWI_SIGN_EXTEND (l0s), h1s = HWI_SIGN_EXTEND (l1s);
3201
3202       equal = (h0u == h1u && l0u == l1u);
3203       op0lt = (h0s < h1s || (h0s == h1s && l0u < l1u));
3204       op1lt = (h1s < h0s || (h1s == h0s && l1u < l0u));
3205       op0ltu = (h0u < h1u || (h0u == h1u && l0u < l1u));
3206       op1ltu = (h1u < h0u || (h1u == h0u && l1u < l0u));
3207     }
3208
3209   /* Otherwise, there are some code-specific tests we can make.  */
3210   else
3211     {
3212       /* Optimize comparisons with upper and lower bounds.  */
3213       if (SCALAR_INT_MODE_P (mode)
3214           && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3215         {
3216           rtx mmin, mmax;
3217           int sign;
3218
3219           if (code == GEU
3220               || code == LEU
3221               || code == GTU
3222               || code == LTU)
3223             sign = 0;
3224           else
3225             sign = 1;
3226
3227           get_mode_bounds (mode, sign, mode, &mmin, &mmax);
3228
3229           tem = NULL_RTX;
3230           switch (code)
3231             {
3232             case GEU:
3233             case GE:
3234               /* x >= min is always true.  */
3235               if (rtx_equal_p (trueop1, mmin))
3236                 tem = const_true_rtx;
3237               else 
3238               break;
3239
3240             case LEU:
3241             case LE:
3242               /* x <= max is always true.  */
3243               if (rtx_equal_p (trueop1, mmax))
3244                 tem = const_true_rtx;
3245               break;
3246
3247             case GTU:
3248             case GT:
3249               /* x > max is always false.  */
3250               if (rtx_equal_p (trueop1, mmax))
3251                 tem = const0_rtx;
3252               break;
3253
3254             case LTU:
3255             case LT:
3256               /* x < min is always false.  */
3257               if (rtx_equal_p (trueop1, mmin))
3258                 tem = const0_rtx;
3259               break;
3260
3261             default:
3262               break;
3263             }
3264           if (tem == const0_rtx
3265               || tem == const_true_rtx)
3266             return tem;
3267         }
3268
3269       switch (code)
3270         {
3271         case EQ:
3272           if (trueop1 == const0_rtx && nonzero_address_p (op0))
3273             return const0_rtx;
3274           break;
3275
3276         case NE:
3277           if (trueop1 == const0_rtx && nonzero_address_p (op0))
3278             return const_true_rtx;
3279           break;
3280
3281         case LT:
3282           /* Optimize abs(x) < 0.0.  */
3283           if (trueop1 == CONST0_RTX (mode)
3284               && !HONOR_SNANS (mode)
3285               && !(flag_wrapv && INTEGRAL_MODE_P (mode)))
3286             {
3287               tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3288                                                        : trueop0;
3289               if (GET_CODE (tem) == ABS)
3290                 return const0_rtx;
3291             }
3292           break;
3293
3294         case GE:
3295           /* Optimize abs(x) >= 0.0.  */
3296           if (trueop1 == CONST0_RTX (mode)
3297               && !HONOR_NANS (mode)
3298               && !(flag_wrapv && INTEGRAL_MODE_P (mode)))
3299             {
3300               tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3301                                                        : trueop0;
3302               if (GET_CODE (tem) == ABS)
3303                 return const_true_rtx;
3304             }
3305           break;
3306
3307         case UNGE:
3308           /* Optimize ! (abs(x) < 0.0).  */
3309           if (trueop1 == CONST0_RTX (mode))
3310             {
3311               tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3312                                                        : trueop0;
3313               if (GET_CODE (tem) == ABS)
3314                 return const_true_rtx;
3315             }
3316           break;
3317
3318         default:
3319           break;
3320         }
3321
3322       return 0;
3323     }
3324
3325   /* If we reach here, EQUAL, OP0LT, OP0LTU, OP1LT, and OP1LTU are set
3326      as appropriate.  */