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