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