?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Patch to fix -mcpu=G5 interface to EH runtime library.
[official-gcc.git] / gcc / simplify-rtx.c
bloba0f17696cea5e005cf97f3a8b02679cb392daa2b
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_RTX in X with NEW_RTX 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, rtx new_rtx)
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_RTX, return NEW_RTX. 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_rtx)
259 return new_rtx;
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_rtx, new_rtx);
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_rtx, new_rtx);
274 op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
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_rtx, new_rtx);
285 op1 = simplify_replace_rtx (op1, old_rtx, new_rtx);
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_rtx, new_rtx);
295 op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
296 op2 = simplify_replace_rtx (XEXP (x, 2), old_rtx, new_rtx);
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_rtx, new_rtx);
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_rtx, new_rtx);
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_rtx, new_rtx);
328 op1 = simplify_replace_rtx (XEXP (x, 1), old_rtx, new_rtx);
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_rtx) && REGNO (x) == REGNO (old_rtx))
341 return new_rtx;
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 && REG_P (SUBREG_REG (op))
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 && REG_P (SUBREG_REG (op))
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 if (MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
1281 && flag_trapping_math
1282 && REAL_VALUE_ISINF (f0) && REAL_VALUE_ISINF (f1))
1283 {
1284 int s0 = REAL_VALUE_NEGATIVE (f0);
1285 int s1 = REAL_VALUE_NEGATIVE (f1);
1286
1287 switch (code)
1288 {
1289 case PLUS:
1290 /* Inf + -Inf = NaN plus exception. */
1291 if (s0 != s1)
1292 return 0;
1293 break;
1294 case MINUS:
1295 /* Inf - Inf = NaN plus exception. */
1296 if (s0 == s1)
1297 return 0;
1298 break;
1299 case DIV:
1300 /* Inf / Inf = NaN plus exception. */
1301 return 0;
1302 default:
1303 break;
1304 }
1305 }
1306
1307 if (code == MULT && MODE_HAS_INFINITIES (mode) && HONOR_NANS (mode)
1308 && flag_trapping_math
1309 && ((REAL_VALUE_ISINF (f0) && REAL_VALUES_EQUAL (f1, dconst0))
1310 || (REAL_VALUE_ISINF (f1)
1311 && REAL_VALUES_EQUAL (f0, dconst0))))
1312 /* Inf * 0 = NaN plus exception. */
1313 return 0;
1314
1315 REAL_ARITHMETIC (value, rtx_to_tree_code (code), f0, f1);
1316
1317 value = real_value_truncate (mode, value);
1318 return CONST_DOUBLE_FROM_REAL_VALUE (value, mode);
1319 }
1320 }
1321
1322 /* We can fold some multi-word operations. */
1323 if (GET_MODE_CLASS (mode) == MODE_INT
1324 && width == HOST_BITS_PER_WIDE_INT * 2
1325 && (GET_CODE (trueop0) == CONST_DOUBLE
1326 || GET_CODE (trueop0) == CONST_INT)
1327 && (GET_CODE (trueop1) == CONST_DOUBLE
1328 || GET_CODE (trueop1) == CONST_INT))
1329 {
1330 unsigned HOST_WIDE_INT l1, l2, lv, lt;
1331 HOST_WIDE_INT h1, h2, hv, ht;
1332
1333 if (GET_CODE (trueop0) == CONST_DOUBLE)
1334 l1 = CONST_DOUBLE_LOW (trueop0), h1 = CONST_DOUBLE_HIGH (trueop0);
1335 else
1336 l1 = INTVAL (trueop0), h1 = HWI_SIGN_EXTEND (l1);
1337
1338 if (GET_CODE (trueop1) == CONST_DOUBLE)
1339 l2 = CONST_DOUBLE_LOW (trueop1), h2 = CONST_DOUBLE_HIGH (trueop1);
1340 else
1341 l2 = INTVAL (trueop1), h2 = HWI_SIGN_EXTEND (l2);
1342
1343 switch (code)
1344 {
1345 case MINUS:
1346 /* A - B == A + (-B). */
1347 neg_double (l2, h2, &lv, &hv);
1348 l2 = lv, h2 = hv;
1349
1350 /* Fall through.... */
1351
1352 case PLUS:
1353 add_double (l1, h1, l2, h2, &lv, &hv);
1354 break;
1355
1356 case MULT:
1357 mul_double (l1, h1, l2, h2, &lv, &hv);
1358 break;
1359
1360 case DIV:
1361 if (div_and_round_double (TRUNC_DIV_EXPR, 0, l1, h1, l2, h2,
1362 &lv, &hv, &lt, &ht))
1363 return 0;
1364 break;
1365
1366 case MOD:
1367 if (div_and_round_double (TRUNC_DIV_EXPR, 0, l1, h1, l2, h2,
1368 &lt, &ht, &lv, &hv))
1369 return 0;
1370 break;
1371
1372 case UDIV:
1373 if (div_and_round_double (TRUNC_DIV_EXPR, 1, l1, h1, l2, h2,
1374 &lv, &hv, &lt, &ht))
1375 return 0;
1376 break;
1377
1378 case UMOD:
1379 if (div_and_round_double (TRUNC_DIV_EXPR, 1, l1, h1, l2, h2,
1380 &lt, &ht, &lv, &hv))
1381 return 0;
1382 break;
1383
1384 case AND:
1385 lv = l1 & l2, hv = h1 & h2;
1386 break;
1387
1388 case IOR:
1389 lv = l1 | l2, hv = h1 | h2;
1390 break;
1391
1392 case XOR:
1393 lv = l1 ^ l2, hv = h1 ^ h2;
1394 break;
1395
1396 case SMIN:
1397 if (h1 < h2
1398 || (h1 == h2
1399 && ((unsigned HOST_WIDE_INT) l1
1400 < (unsigned HOST_WIDE_INT) l2)))
1401 lv = l1, hv = h1;
1402 else
1403 lv = l2, hv = h2;
1404 break;
1405
1406 case SMAX:
1407 if (h1 > h2
1408 || (h1 == h2
1409 && ((unsigned HOST_WIDE_INT) l1
1410 > (unsigned HOST_WIDE_INT) l2)))
1411 lv = l1, hv = h1;
1412 else
1413 lv = l2, hv = h2;
1414 break;
1415
1416 case UMIN:
1417 if ((unsigned HOST_WIDE_INT) h1 < (unsigned HOST_WIDE_INT) h2
1418 || (h1 == h2
1419 && ((unsigned HOST_WIDE_INT) l1
1420 < (unsigned HOST_WIDE_INT) l2)))
1421 lv = l1, hv = h1;
1422 else
1423 lv = l2, hv = h2;
1424 break;
1425
1426 case UMAX:
1427 if ((unsigned HOST_WIDE_INT) h1 > (unsigned HOST_WIDE_INT) h2
1428 || (h1 == h2
1429 && ((unsigned HOST_WIDE_INT) l1
1430 > (unsigned HOST_WIDE_INT) l2)))
1431 lv = l1, hv = h1;
1432 else
1433 lv = l2, hv = h2;
1434 break;
1435
1436 case LSHIFTRT: case ASHIFTRT:
1437 case ASHIFT:
1438 case ROTATE: case ROTATERT:
1439 if (SHIFT_COUNT_TRUNCATED)
1440 l2 &= (GET_MODE_BITSIZE (mode) - 1), h2 = 0;
1441
1442 if (h2 != 0 || l2 >= GET_MODE_BITSIZE (mode))
1443 return 0;
1444
1445 if (code == LSHIFTRT || code == ASHIFTRT)
1446 rshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv,
1447 code == ASHIFTRT);
1448 else if (code == ASHIFT)
1449 lshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv, 1);
1450 else if (code == ROTATE)
1451 lrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
1452 else /* code == ROTATERT */
1453 rrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv);
1454 break;
1455
1456 default:
1457 return 0;
1458 }
1459
1460 return immed_double_const (lv, hv, mode);
1461 }
1462
1463 if (GET_CODE (op0) != CONST_INT || GET_CODE (op1) != CONST_INT
1464 || width > HOST_BITS_PER_WIDE_INT || width == 0)
1465 {
1466 /* Even if we can't compute a constant result,
1467 there are some cases worth simplifying. */
1468
1469 switch (code)
1470 {
1471 case PLUS:
1472 /* Maybe simplify x + 0 to x. The two expressions are equivalent
1473 when x is NaN, infinite, or finite and nonzero. They aren't
1474 when x is -0 and the rounding mode is not towards -infinity,
1475 since (-0) + 0 is then 0. */
1476 if (!HONOR_SIGNED_ZEROS (mode) && trueop1 == CONST0_RTX (mode))
1477 return op0;
1478
1479 /* ((-a) + b) -> (b - a) and similarly for (a + (-b)). These
1480 transformations are safe even for IEEE. */
1481 if (GET_CODE (op0) == NEG)
1482 return simplify_gen_binary (MINUS, mode, op1, XEXP (op0, 0));
1483 else if (GET_CODE (op1) == NEG)
1484 return simplify_gen_binary (MINUS, mode, op0, XEXP (op1, 0));
1485
1486 /* (~a) + 1 -> -a */
1487 if (INTEGRAL_MODE_P (mode)
1488 && GET_CODE (op0) == NOT
1489 && trueop1 == const1_rtx)
1490 return simplify_gen_unary (NEG, mode, XEXP (op0, 0), mode);
1491
1492 /* Handle both-operands-constant cases. We can only add
1493 CONST_INTs to constants since the sum of relocatable symbols
1494 can't be handled by most assemblers. Don't add CONST_INT
1495 to CONST_INT since overflow won't be computed properly if wider
1496 than HOST_BITS_PER_WIDE_INT. */
1497
1498 if (CONSTANT_P (op0) && GET_MODE (op0) != VOIDmode
1499 && GET_CODE (op1) == CONST_INT)
1500 return plus_constant (op0, INTVAL (op1));
1501 else if (CONSTANT_P (op1) && GET_MODE (op1) != VOIDmode
1502 && GET_CODE (op0) == CONST_INT)
1503 return plus_constant (op1, INTVAL (op0));
1504
1505 /* See if this is something like X * C - X or vice versa or
1506 if the multiplication is written as a shift. If so, we can
1507 distribute and make a new multiply, shift, or maybe just
1508 have X (if C is 2 in the example above). But don't make
1509 something more expensive than we had before. */
1510
1511 if (! FLOAT_MODE_P (mode))
1512 {
1513 HOST_WIDE_INT coeff0 = 1, coeff1 = 1;
1514 rtx lhs = op0, rhs = op1;
1515
1516 if (GET_CODE (lhs) == NEG)
1517 coeff0 = -1, lhs = XEXP (lhs, 0);
1518 else if (GET_CODE (lhs) == MULT
1519 && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
1520 {
1521 coeff0 = INTVAL (XEXP (lhs, 1)), lhs = XEXP (lhs, 0);
1522 }
1523 else if (GET_CODE (lhs) == ASHIFT
1524 && GET_CODE (XEXP (lhs, 1)) == CONST_INT
1525 && INTVAL (XEXP (lhs, 1)) >= 0
1526 && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
1527 {
1528 coeff0 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
1529 lhs = XEXP (lhs, 0);
1530 }
1531
1532 if (GET_CODE (rhs) == NEG)
1533 coeff1 = -1, rhs = XEXP (rhs, 0);
1534 else if (GET_CODE (rhs) == MULT
1535 && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
1536 {
1537 coeff1 = INTVAL (XEXP (rhs, 1)), rhs = XEXP (rhs, 0);
1538 }
1539 else if (GET_CODE (rhs) == ASHIFT
1540 && GET_CODE (XEXP (rhs, 1)) == CONST_INT
1541 && INTVAL (XEXP (rhs, 1)) >= 0
1542 && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
1543 {
1544 coeff1 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1));
1545 rhs = XEXP (rhs, 0);
1546 }
1547
1548 if (rtx_equal_p (lhs, rhs))
1549 {
1550 rtx orig = gen_rtx_PLUS (mode, op0, op1);
1551 tem = simplify_gen_binary (MULT, mode, lhs,
1552 GEN_INT (coeff0 + coeff1));
1553 return rtx_cost (tem, SET) <= rtx_cost (orig, SET)
1554 ? tem : 0;
1555 }
1556 }
1557
1558 /* (plus (xor X C1) C2) is (xor X (C1^C2)) if C2 is signbit. */
1559 if ((GET_CODE (op1) == CONST_INT
1560 || GET_CODE (op1) == CONST_DOUBLE)
1561 && GET_CODE (op0) == XOR
1562 && (GET_CODE (XEXP (op0, 1)) == CONST_INT
1563 || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
1564 && mode_signbit_p (mode, op1))
1565 return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
1566 simplify_gen_binary (XOR, mode, op1,
1567 XEXP (op0, 1)));
1568
1569 /* If one of the operands is a PLUS or a MINUS, see if we can
1570 simplify this by the associative law.
1571 Don't use the associative law for floating point.
1572 The inaccuracy makes it nonassociative,
1573 and subtle programs can break if operations are associated. */
1574
1575 if (INTEGRAL_MODE_P (mode)
1576 && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS
1577 || GET_CODE (op1) == PLUS || GET_CODE (op1) == MINUS
1578 || (GET_CODE (op0) == CONST
1579 && GET_CODE (XEXP (op0, 0)) == PLUS)
1580 || (GET_CODE (op1) == CONST
1581 && GET_CODE (XEXP (op1, 0)) == PLUS))
1582 && (tem = simplify_plus_minus (code, mode, op0, op1, 0)) != 0)
1583 return tem;
1584
1585 /* Reassociate floating point addition only when the user
1586 specifies unsafe math optimizations. */
1587 if (FLOAT_MODE_P (mode)
1588 && flag_unsafe_math_optimizations)
1589 {
1590 tem = simplify_associative_operation (code, mode, op0, op1);
1591 if (tem)
1592 return tem;
1593 }
1594 break;
1595
1596 case COMPARE:
1597 #ifdef HAVE_cc0
1598 /* Convert (compare FOO (const_int 0)) to FOO unless we aren't
1599 using cc0, in which case we want to leave it as a COMPARE
1600 so we can distinguish it from a register-register-copy.
1601
1602 In IEEE floating point, x-0 is not the same as x. */
1603
1604 if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT
1605 || ! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations)
1606 && trueop1 == CONST0_RTX (mode))
1607 return op0;
1608 #endif
1609
1610 /* Convert (compare (gt (flags) 0) (lt (flags) 0)) to (flags). */
1611 if (((GET_CODE (op0) == GT && GET_CODE (op1) == LT)
1612 || (GET_CODE (op0) == GTU && GET_CODE (op1) == LTU))
1613 && XEXP (op0, 1) == const0_rtx && XEXP (op1, 1) == const0_rtx)
1614 {
1615 rtx xop00 = XEXP (op0, 0);
1616 rtx xop10 = XEXP (op1, 0);
1617
1618 #ifdef HAVE_cc0
1619 if (GET_CODE (xop00) == CC0 && GET_CODE (xop10) == CC0)
1620 #else
1621 if (REG_P (xop00) && REG_P (xop10)
1622 && GET_MODE (xop00) == GET_MODE (xop10)
1623 && REGNO (xop00) == REGNO (xop10)
1624 && GET_MODE_CLASS (GET_MODE (xop00)) == MODE_CC
1625 && GET_MODE_CLASS (GET_MODE (xop10)) == MODE_CC)
1626 #endif
1627 return xop00;
1628 }
1629 break;
1630
1631 case MINUS:
1632 /* We can't assume x-x is 0 even with non-IEEE floating point,
1633 but since it is zero except in very strange circumstances, we
1634 will treat it as zero with -funsafe-math-optimizations. */
1635 if (rtx_equal_p (trueop0, trueop1)
1636 && ! side_effects_p (op0)
1637 && (! FLOAT_MODE_P (mode) || flag_unsafe_math_optimizations))
1638 return CONST0_RTX (mode);
1639
1640 /* Change subtraction from zero into negation. (0 - x) is the
1641 same as -x when x is NaN, infinite, or finite and nonzero.
1642 But if the mode has signed zeros, and does not round towards
1643 -infinity, then 0 - 0 is 0, not -0. */
1644 if (!HONOR_SIGNED_ZEROS (mode) && trueop0 == CONST0_RTX (mode))
1645 return simplify_gen_unary (NEG, mode, op1, mode);
1646
1647 /* (-1 - a) is ~a. */
1648 if (trueop0 == constm1_rtx)
1649 return simplify_gen_unary (NOT, mode, op1, mode);
1650
1651 /* Subtracting 0 has no effect unless the mode has signed zeros
1652 and supports rounding towards -infinity. In such a case,
1653 0 - 0 is -0. */
1654 if (!(HONOR_SIGNED_ZEROS (mode)
1655 && HONOR_SIGN_DEPENDENT_ROUNDING (mode))
1656 && trueop1 == CONST0_RTX (mode))
1657 return op0;
1658
1659 /* See if this is something like X * C - X or vice versa or
1660 if the multiplication is written as a shift. If so, we can
1661 distribute and make a new multiply, shift, or maybe just
1662 have X (if C is 2 in the example above). But don't make
1663 something more expensive than we had before. */
1664
1665 if (! FLOAT_MODE_P (mode))
1666 {
1667 HOST_WIDE_INT coeff0 = 1, coeff1 = 1;
1668 rtx lhs = op0, rhs = op1;
1669
1670 if (GET_CODE (lhs) == NEG)
1671 coeff0 = -1, lhs = XEXP (lhs, 0);
1672 else if (GET_CODE (lhs) == MULT
1673 && GET_CODE (XEXP (lhs, 1)) == CONST_INT)
1674 {
1675 coeff0 = INTVAL (XEXP (lhs, 1)), lhs = XEXP (lhs, 0);
1676 }
1677 else if (GET_CODE (lhs) == ASHIFT
1678 && GET_CODE (XEXP (lhs, 1)) == CONST_INT
1679 && INTVAL (XEXP (lhs, 1)) >= 0
1680 && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT)
1681 {
1682 coeff0 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1));
1683 lhs = XEXP (lhs, 0);
1684 }
1685
1686 if (GET_CODE (rhs) == NEG)
1687 coeff1 = - 1, rhs = XEXP (rhs, 0);
1688 else if (GET_CODE (rhs) == MULT
1689 && GET_CODE (XEXP (rhs, 1)) == CONST_INT)
1690 {
1691 coeff1 = INTVAL (XEXP (rhs, 1)), rhs = XEXP (rhs, 0);
1692 }
1693 else if (GET_CODE (rhs) == ASHIFT
1694 && GET_CODE (XEXP (rhs, 1)) == CONST_INT
1695 && INTVAL (XEXP (rhs, 1)) >= 0
1696 && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT)
1697 {
1698 coeff1 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1));
1699 rhs = XEXP (rhs, 0);
1700 }
1701
1702 if (rtx_equal_p (lhs, rhs))
1703 {
1704 rtx orig = gen_rtx_MINUS (mode, op0, op1);
1705 tem = simplify_gen_binary (MULT, mode, lhs,
1706 GEN_INT (coeff0 - coeff1));
1707 return rtx_cost (tem, SET) <= rtx_cost (orig, SET)
1708 ? tem : 0;
1709 }
1710 }
1711
1712 /* (a - (-b)) -> (a + b). True even for IEEE. */
1713 if (GET_CODE (op1) == NEG)
1714 return simplify_gen_binary (PLUS, mode, op0, XEXP (op1, 0));
1715
1716 /* (-x - c) may be simplified as (-c - x). */
1717 if (GET_CODE (op0) == NEG
1718 && (GET_CODE (op1) == CONST_INT
1719 || GET_CODE (op1) == CONST_DOUBLE))
1720 {
1721 tem = simplify_unary_operation (NEG, mode, op1, mode);
1722 if (tem)
1723 return simplify_gen_binary (MINUS, mode, tem, XEXP (op0, 0));
1724 }
1725
1726 /* If one of the operands is a PLUS or a MINUS, see if we can
1727 simplify this by the associative law.
1728 Don't use the associative law for floating point.
1729 The inaccuracy makes it nonassociative,
1730 and subtle programs can break if operations are associated. */
1731
1732 if (INTEGRAL_MODE_P (mode)
1733 && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS
1734 || GET_CODE (op1) == PLUS || GET_CODE (op1) == MINUS
1735 || (GET_CODE (op0) == CONST
1736 && GET_CODE (XEXP (op0, 0)) == PLUS)
1737 || (GET_CODE (op1) == CONST
1738 && GET_CODE (XEXP (op1, 0)) == PLUS))
1739 && (tem = simplify_plus_minus (code, mode, op0, op1, 0)) != 0)
1740 return tem;
1741
1742 /* Don't let a relocatable value get a negative coeff. */
1743 if (GET_CODE (op1) == CONST_INT && GET_MODE (op0) != VOIDmode)
1744 return simplify_gen_binary (PLUS, mode,
1745 op0,
1746 neg_const_int (mode, op1));
1747
1748 /* (x - (x & y)) -> (x & ~y) */
1749 if (GET_CODE (op1) == AND)
1750 {
1751 if (rtx_equal_p (op0, XEXP (op1, 0)))
1752 {
1753 tem = simplify_gen_unary (NOT, mode, XEXP (op1, 1),
1754 GET_MODE (XEXP (op1, 1)));
1755 return simplify_gen_binary (AND, mode, op0, tem);
1756 }
1757 if (rtx_equal_p (op0, XEXP (op1, 1)))
1758 {
1759 tem = simplify_gen_unary (NOT, mode, XEXP (op1, 0),
1760 GET_MODE (XEXP (op1, 0)));
1761 return simplify_gen_binary (AND, mode, op0, tem);
1762 }
1763 }
1764 break;
1765
1766 case MULT:
1767 if (trueop1 == constm1_rtx)
1768 return simplify_gen_unary (NEG, mode, op0, mode);
1769
1770 /* Maybe simplify x * 0 to 0. The reduction is not valid if
1771 x is NaN, since x * 0 is then also NaN. Nor is it valid
1772 when the mode has signed zeros, since multiplying a negative
1773 number by 0 will give -0, not 0. */
1774 if (!HONOR_NANS (mode)
1775 && !HONOR_SIGNED_ZEROS (mode)
1776 && trueop1 == CONST0_RTX (mode)
1777 && ! side_effects_p (op0))
1778 return op1;
1779
1780 /* In IEEE floating point, x*1 is not equivalent to x for
1781 signalling NaNs. */
1782 if (!HONOR_SNANS (mode)
1783 && trueop1 == CONST1_RTX (mode))
1784 return op0;
1785
1786 /* Convert multiply by constant power of two into shift unless
1787 we are still generating RTL. This test is a kludge. */
1788 if (GET_CODE (trueop1) == CONST_INT
1789 && (val = exact_log2 (INTVAL (trueop1))) >= 0
1790 /* If the mode is larger than the host word size, and the
1791 uppermost bit is set, then this isn't a power of two due
1792 to implicit sign extension. */
1793 && (width <= HOST_BITS_PER_WIDE_INT
1794 || val != HOST_BITS_PER_WIDE_INT - 1))
1795 return simplify_gen_binary (ASHIFT, mode, op0, GEN_INT (val));
1796
1797 /* x*2 is x+x and x*(-1) is -x */
1798 if (GET_CODE (trueop1) == CONST_DOUBLE
1799 && GET_MODE_CLASS (GET_MODE (trueop1)) == MODE_FLOAT
1800 && GET_MODE (op0) == mode)
1801 {
1802 REAL_VALUE_TYPE d;
1803 REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
1804
1805 if (REAL_VALUES_EQUAL (d, dconst2))
1806 return simplify_gen_binary (PLUS, mode, op0, copy_rtx (op0));
1807
1808 if (REAL_VALUES_EQUAL (d, dconstm1))
1809 return simplify_gen_unary (NEG, mode, op0, mode);
1810 }
1811
1812 /* Reassociate multiplication, but for floating point MULTs
1813 only when the user specifies unsafe math optimizations. */
1814 if (! FLOAT_MODE_P (mode)
1815 || flag_unsafe_math_optimizations)
1816 {
1817 tem = simplify_associative_operation (code, mode, op0, op1);
1818 if (tem)
1819 return tem;
1820 }
1821 break;
1822
1823 case IOR:
1824 if (trueop1 == const0_rtx)
1825 return op0;
1826 if (GET_CODE (trueop1) == CONST_INT
1827 && ((INTVAL (trueop1) & GET_MODE_MASK (mode))
1828 == GET_MODE_MASK (mode)))
1829 return op1;
1830 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
1831 return op0;
1832 /* A | (~A) -> -1 */
1833 if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
1834 || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
1835 && ! side_effects_p (op0)
1836 && GET_MODE_CLASS (mode) != MODE_CC)
1837 return constm1_rtx;
1838 tem = simplify_associative_operation (code, mode, op0, op1);
1839 if (tem)
1840 return tem;
1841 break;
1842
1843 case XOR:
1844 if (trueop1 == const0_rtx)
1845 return op0;
1846 if (GET_CODE (trueop1) == CONST_INT
1847 && ((INTVAL (trueop1) & GET_MODE_MASK (mode))
1848 == GET_MODE_MASK (mode)))
1849 return simplify_gen_unary (NOT, mode, op0, mode);
1850 if (trueop0 == trueop1
1851 && ! side_effects_p (op0)
1852 && GET_MODE_CLASS (mode) != MODE_CC)
1853 return const0_rtx;
1854
1855 /* Canonicalize XOR of the most significant bit to PLUS. */
1856 if ((GET_CODE (op1) == CONST_INT
1857 || GET_CODE (op1) == CONST_DOUBLE)
1858 && mode_signbit_p (mode, op1))
1859 return simplify_gen_binary (PLUS, mode, op0, op1);
1860 /* (xor (plus X C1) C2) is (xor X (C1^C2)) if C1 is signbit. */
1861 if ((GET_CODE (op1) == CONST_INT
1862 || GET_CODE (op1) == CONST_DOUBLE)
1863 && GET_CODE (op0) == PLUS
1864 && (GET_CODE (XEXP (op0, 1)) == CONST_INT
1865 || GET_CODE (XEXP (op0, 1)) == CONST_DOUBLE)
1866 && mode_signbit_p (mode, XEXP (op0, 1)))
1867 return simplify_gen_binary (XOR, mode, XEXP (op0, 0),
1868 simplify_gen_binary (XOR, mode, op1,
1869 XEXP (op0, 1)));
1870
1871 tem = simplify_associative_operation (code, mode, op0, op1);
1872 if (tem)
1873 return tem;
1874 break;
1875
1876 case AND:
1877 if (trueop1 == const0_rtx && ! side_effects_p (op0))
1878 return const0_rtx;
1879 /* If we are turning off bits already known off in OP0, we need
1880 not do an AND. */
1881 if (GET_CODE (trueop1) == CONST_INT
1882 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1883 && (nonzero_bits (trueop0, mode) & ~INTVAL (trueop1)) == 0)
1884 return op0;
1885 if (trueop0 == trueop1 && ! side_effects_p (op0)
1886 && GET_MODE_CLASS (mode) != MODE_CC)
1887 return op0;
1888 /* A & (~A) -> 0 */
1889 if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1))
1890 || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0)))
1891 && ! side_effects_p (op0)
1892 && GET_MODE_CLASS (mode) != MODE_CC)
1893 return const0_rtx;
1894 /* For constants M and N, if M == (1LL << cst) - 1 && (N & M) == M,
1895 ((A & N) + B) & M -> (A + B) & M
1896 Similarly if (N & M) == 0,
1897 ((A | N) + B) & M -> (A + B) & M
1898 and for - instead of + and/or ^ instead of |. */
1899 if (GET_CODE (trueop1) == CONST_INT
1900 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1901 && ~INTVAL (trueop1)
1902 && (INTVAL (trueop1) & (INTVAL (trueop1) + 1)) == 0
1903 && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS))
1904 {
1905 rtx pmop[2];
1906 int which;
1907
1908 pmop[0] = XEXP (op0, 0);
1909 pmop[1] = XEXP (op0, 1);
1910
1911 for (which = 0; which < 2; which++)
1912 {
1913 tem = pmop[which];
1914 switch (GET_CODE (tem))
1915 {
1916 case AND:
1917 if (GET_CODE (XEXP (tem, 1)) == CONST_INT
1918 && (INTVAL (XEXP (tem, 1)) & INTVAL (trueop1))
1919 == INTVAL (trueop1))
1920 pmop[which] = XEXP (tem, 0);
1921 break;
1922 case IOR:
1923 case XOR:
1924 if (GET_CODE (XEXP (tem, 1)) == CONST_INT
1925 && (INTVAL (XEXP (tem, 1)) & INTVAL (trueop1)) == 0)
1926 pmop[which] = XEXP (tem, 0);
1927 break;
1928 default:
1929 break;
1930 }
1931 }
1932
1933 if (pmop[0] != XEXP (op0, 0) || pmop[1] != XEXP (op0, 1))
1934 {
1935 tem = simplify_gen_binary (GET_CODE (op0), mode,
1936 pmop[0], pmop[1]);
1937 return simplify_gen_binary (code, mode, tem, op1);
1938 }
1939 }
1940 tem = simplify_associative_operation (code, mode, op0, op1);
1941 if (tem)
1942 return tem;
1943 break;
1944
1945 case UDIV:
1946 /* 0/x is 0 (or x&0 if x has side-effects). */
1947 if (trueop0 == const0_rtx)
1948 return side_effects_p (op1)
1949 ? simplify_gen_binary (AND, mode, op1, const0_rtx)
1950 : const0_rtx;
1951 /* x/1 is x. */
1952 if (trueop1 == const1_rtx)
1953 {
1954 /* Handle narrowing UDIV. */
1955 rtx x = gen_lowpart_common (mode, op0);
1956 if (x)
1957 return x;
1958 if (mode != GET_MODE (op0) && GET_MODE (op0) != VOIDmode)
1959 return gen_lowpart_SUBREG (mode, op0);
1960 return op0;
1961 }
1962 /* Convert divide by power of two into shift. */
1963 if (GET_CODE (trueop1) == CONST_INT
1964 && (arg1 = exact_log2 (INTVAL (trueop1))) > 0)
1965 return simplify_gen_binary (LSHIFTRT, mode, op0, GEN_INT (arg1));
1966 break;
1967
1968 case DIV:
1969 /* Handle floating point and integers separately. */
1970 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
1971 {
1972 /* Maybe change 0.0 / x to 0.0. This transformation isn't
1973 safe for modes with NaNs, since 0.0 / 0.0 will then be
1974 NaN rather than 0.0. Nor is it safe for modes with signed
1975 zeros, since dividing 0 by a negative number gives -0.0 */
1976 if (trueop0 == CONST0_RTX (mode)
1977 && !HONOR_NANS (mode)
1978 && !HONOR_SIGNED_ZEROS (mode)
1979 && ! side_effects_p (op1))
1980 return op0;
1981 /* x/1.0 is x. */
1982 if (trueop1 == CONST1_RTX (mode)
1983 && !HONOR_SNANS (mode))
1984 return op0;
1985
1986 if (GET_CODE (trueop1) == CONST_DOUBLE
1987 && trueop1 != CONST0_RTX (mode))
1988 {
1989 REAL_VALUE_TYPE d;
1990 REAL_VALUE_FROM_CONST_DOUBLE (d, trueop1);
1991
1992 /* x/-1.0 is -x. */
1993 if (REAL_VALUES_EQUAL (d, dconstm1)
1994 && !HONOR_SNANS (mode))
1995 return simplify_gen_unary (NEG, mode, op0, mode);
1996
1997 /* Change FP division by a constant into multiplication.
1998 Only do this with -funsafe-math-optimizations. */
1999 if (flag_unsafe_math_optimizations
2000 && !REAL_VALUES_EQUAL (d, dconst0))
2001 {
2002 REAL_ARITHMETIC (d, RDIV_EXPR, dconst1, d);
2003 tem = CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
2004 return simplify_gen_binary (MULT, mode, op0, tem);
2005 }
2006 }
2007 }
2008 else
2009 {
2010 /* 0/x is 0 (or x&0 if x has side-effects). */
2011 if (trueop0 == const0_rtx)
2012 return side_effects_p (op1)
2013 ? simplify_gen_binary (AND, mode, op1, const0_rtx)
2014 : const0_rtx;
2015 /* x/1 is x. */
2016 if (trueop1 == const1_rtx)
2017 {
2018 /* Handle narrowing DIV. */
2019 rtx x = gen_lowpart_common (mode, op0);
2020 if (x)
2021 return x;
2022 if (mode != GET_MODE (op0) && GET_MODE (op0) != VOIDmode)
2023 return gen_lowpart_SUBREG (mode, op0);
2024 return op0;
2025 }
2026 /* x/-1 is -x. */
2027 if (trueop1 == constm1_rtx)
2028 {
2029 rtx x = gen_lowpart_common (mode, op0);
2030 if (!x)
2031 x = (mode != GET_MODE (op0) && GET_MODE (op0) != VOIDmode)
2032 ? gen_lowpart_SUBREG (mode, op0) : op0;
2033 return simplify_gen_unary (NEG, mode, x, mode);
2034 }
2035 }
2036 break;
2037
2038 case UMOD:
2039 /* 0%x is 0 (or x&0 if x has side-effects). */
2040 if (trueop0 == const0_rtx)
2041 return side_effects_p (op1)
2042 ? simplify_gen_binary (AND, mode, op1, const0_rtx)
2043 : const0_rtx;
2044 /* x%1 is 0 (of x&0 if x has side-effects). */
2045 if (trueop1 == const1_rtx)
2046 return side_effects_p (op0)
2047 ? simplify_gen_binary (AND, mode, op0, const0_rtx)
2048 : const0_rtx;
2049 /* Implement modulus by power of two as AND. */
2050 if (GET_CODE (trueop1) == CONST_INT
2051 && exact_log2 (INTVAL (trueop1)) > 0)
2052 return simplify_gen_binary (AND, mode, op0,
2053 GEN_INT (INTVAL (op1) - 1));
2054 break;
2055
2056 case MOD:
2057 /* 0%x is 0 (or x&0 if x has side-effects). */
2058 if (trueop0 == const0_rtx)
2059 return side_effects_p (op1)
2060 ? simplify_gen_binary (AND, mode, op1, const0_rtx)
2061 : const0_rtx;
2062 /* x%1 and x%-1 is 0 (or x&0 if x has side-effects). */
2063 if (trueop1 == const1_rtx || trueop1 == constm1_rtx)
2064 return side_effects_p (op0)
2065 ? simplify_gen_binary (AND, mode, op0, const0_rtx)
2066 : const0_rtx;
2067 break;
2068
2069 case ROTATERT:
2070 case ROTATE:
2071 case ASHIFTRT:
2072 /* Rotating ~0 always results in ~0. */
2073 if (GET_CODE (trueop0) == CONST_INT && width <= HOST_BITS_PER_WIDE_INT
2074 && (unsigned HOST_WIDE_INT) INTVAL (trueop0) == GET_MODE_MASK (mode)
2075 && ! side_effects_p (op1))
2076 return op0;
2077
2078 /* Fall through.... */
2079
2080 case ASHIFT:
2081 case LSHIFTRT:
2082 if (trueop1 == const0_rtx)
2083 return op0;
2084 if (trueop0 == const0_rtx && ! side_effects_p (op1))
2085 return op0;
2086 break;
2087
2088 case SMIN:
2089 if (width <= HOST_BITS_PER_WIDE_INT
2090 && GET_CODE (trueop1) == CONST_INT
2091 && INTVAL (trueop1) == (HOST_WIDE_INT) 1 << (width -1)
2092 && ! side_effects_p (op0))
2093 return op1;
2094 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2095 return op0;
2096 tem = simplify_associative_operation (code, mode, op0, op1);
2097 if (tem)
2098 return tem;
2099 break;
2100
2101 case SMAX:
2102 if (width <= HOST_BITS_PER_WIDE_INT
2103 && GET_CODE (trueop1) == CONST_INT
2104 && ((unsigned HOST_WIDE_INT) INTVAL (trueop1)
2105 == (unsigned HOST_WIDE_INT) GET_MODE_MASK (mode) >> 1)
2106 && ! side_effects_p (op0))
2107 return op1;
2108 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2109 return op0;
2110 tem = simplify_associative_operation (code, mode, op0, op1);
2111 if (tem)
2112 return tem;
2113 break;
2114
2115 case UMIN:
2116 if (trueop1 == const0_rtx && ! side_effects_p (op0))
2117 return op1;
2118 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2119 return op0;
2120 tem = simplify_associative_operation (code, mode, op0, op1);
2121 if (tem)
2122 return tem;
2123 break;
2124
2125 case UMAX:
2126 if (trueop1 == constm1_rtx && ! side_effects_p (op0))
2127 return op1;
2128 if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0))
2129 return op0;
2130 tem = simplify_associative_operation (code, mode, op0, op1);
2131 if (tem)
2132 return tem;
2133 break;
2134
2135 case SS_PLUS:
2136 case US_PLUS:
2137 case SS_MINUS:
2138 case US_MINUS:
2139 /* ??? There are simplifications that can be done. */
2140 return 0;
2141
2142 case VEC_SELECT:
2143 if (!VECTOR_MODE_P (mode))
2144 {
2145 if (!VECTOR_MODE_P (GET_MODE (trueop0))
2146 || (mode
2147 != GET_MODE_INNER (GET_MODE (trueop0)))
2148 || GET_CODE (trueop1) != PARALLEL
2149 || XVECLEN (trueop1, 0) != 1
2150 || GET_CODE (XVECEXP (trueop1, 0, 0)) != CONST_INT)
2151 abort ();
2152
2153 if (GET_CODE (trueop0) == CONST_VECTOR)
2154 return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP (trueop1, 0, 0)));
2155 }
2156 else
2157 {
2158 if (!VECTOR_MODE_P (GET_MODE (trueop0))
2159 || (GET_MODE_INNER (mode)
2160 != GET_MODE_INNER (GET_MODE (trueop0)))
2161 || GET_CODE (trueop1) != PARALLEL)
2162 abort ();
2163
2164 if (GET_CODE (trueop0) == CONST_VECTOR)
2165 {
2166 int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
2167 unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
2168 rtvec v = rtvec_alloc (n_elts);
2169 unsigned int i;
2170
2171 if (XVECLEN (trueop1, 0) != (int) n_elts)
2172 abort ();
2173 for (i = 0; i < n_elts; i++)
2174 {
2175 rtx x = XVECEXP (trueop1, 0, i);
2176
2177 if (GET_CODE (x) != CONST_INT)
2178 abort ();
2179 RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0, INTVAL (x));
2180 }
2181
2182 return gen_rtx_CONST_VECTOR (mode, v);
2183 }
2184 }
2185 return 0;
2186 case VEC_CONCAT:
2187 {
2188 enum machine_mode op0_mode = (GET_MODE (trueop0) != VOIDmode
2189 ? GET_MODE (trueop0)
2190 : GET_MODE_INNER (mode));
2191 enum machine_mode op1_mode = (GET_MODE (trueop1) != VOIDmode
2192 ? GET_MODE (trueop1)
2193 : GET_MODE_INNER (mode));
2194
2195 if (!VECTOR_MODE_P (mode)
2196 || (GET_MODE_SIZE (op0_mode) + GET_MODE_SIZE (op1_mode)
2197 != GET_MODE_SIZE (mode)))
2198 abort ();
2199
2200 if ((VECTOR_MODE_P (op0_mode)
2201 && (GET_MODE_INNER (mode)
2202 != GET_MODE_INNER (op0_mode)))
2203 || (!VECTOR_MODE_P (op0_mode)
2204 && GET_MODE_INNER (mode) != op0_mode))
2205 abort ();
2206
2207 if ((VECTOR_MODE_P (op1_mode)
2208 && (GET_MODE_INNER (mode)
2209 != GET_MODE_INNER (op1_mode)))
2210 || (!VECTOR_MODE_P (op1_mode)
2211 && GET_MODE_INNER (mode) != op1_mode))
2212 abort ();
2213
2214 if ((GET_CODE (trueop0) == CONST_VECTOR
2215 || GET_CODE (trueop0) == CONST_INT
2216 || GET_CODE (trueop0) == CONST_DOUBLE)
2217 && (GET_CODE (trueop1) == CONST_VECTOR
2218 || GET_CODE (trueop1) == CONST_INT
2219 || GET_CODE (trueop1) == CONST_DOUBLE))
2220 {
2221 int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
2222 unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
2223 rtvec v = rtvec_alloc (n_elts);
2224 unsigned int i;
2225 unsigned in_n_elts = 1;
2226
2227 if (VECTOR_MODE_P (op0_mode))
2228 in_n_elts = (GET_MODE_SIZE (op0_mode) / elt_size);
2229 for (i = 0; i < n_elts; i++)
2230 {
2231 if (i < in_n_elts)
2232 {
2233 if (!VECTOR_MODE_P (op0_mode))
2234 RTVEC_ELT (v, i) = trueop0;
2235 else
2236 RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0, i);
2237 }
2238 else
2239 {
2240 if (!VECTOR_MODE_P (op1_mode))
2241 RTVEC_ELT (v, i) = trueop1;
2242 else
2243 RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop1,
2244 i - in_n_elts);
2245 }
2246 }
2247
2248 return gen_rtx_CONST_VECTOR (mode, v);
2249 }
2250 }
2251 return 0;
2252
2253 default:
2254 abort ();
2255 }
2256
2257 return 0;
2258 }
2259
2260 /* Get the integer argument values in two forms:
2261 zero-extended in ARG0, ARG1 and sign-extended in ARG0S, ARG1S. */
2262
2263 arg0 = INTVAL (trueop0);
2264 arg1 = INTVAL (trueop1);
2265
2266 if (width < HOST_BITS_PER_WIDE_INT)
2267 {
2268 arg0 &= ((HOST_WIDE_INT) 1 << width) - 1;
2269 arg1 &= ((HOST_WIDE_INT) 1 << width) - 1;
2270
2271 arg0s = arg0;
2272 if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1)))
2273 arg0s |= ((HOST_WIDE_INT) (-1) << width);
2274
2275 arg1s = arg1;
2276 if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1)))
2277 arg1s |= ((HOST_WIDE_INT) (-1) << width);
2278 }
2279 else
2280 {
2281 arg0s = arg0;
2282 arg1s = arg1;
2283 }
2284
2285 /* Compute the value of the arithmetic. */
2286
2287 switch (code)
2288 {
2289 case PLUS:
2290 val = arg0s + arg1s;
2291 break;
2292
2293 case MINUS:
2294 val = arg0s - arg1s;
2295 break;
2296
2297 case MULT:
2298 val = arg0s * arg1s;
2299 break;
2300
2301 case DIV:
2302 if (arg1s == 0
2303 || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2304 && arg1s == -1))
2305 return 0;
2306 val = arg0s / arg1s;
2307 break;
2308
2309 case MOD:
2310 if (arg1s == 0
2311 || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2312 && arg1s == -1))
2313 return 0;
2314 val = arg0s % arg1s;
2315 break;
2316
2317 case UDIV:
2318 if (arg1 == 0
2319 || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2320 && arg1s == -1))
2321 return 0;
2322 val = (unsigned HOST_WIDE_INT) arg0 / arg1;
2323 break;
2324
2325 case UMOD:
2326 if (arg1 == 0
2327 || (arg0s == (HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1)
2328 && arg1s == -1))
2329 return 0;
2330 val = (unsigned HOST_WIDE_INT) arg0 % arg1;
2331 break;
2332
2333 case AND:
2334 val = arg0 & arg1;
2335 break;
2336
2337 case IOR:
2338 val = arg0 | arg1;
2339 break;
2340
2341 case XOR:
2342 val = arg0 ^ arg1;
2343 break;
2344
2345 case LSHIFTRT:
2346 /* If shift count is undefined, don't fold it; let the machine do
2347 what it wants. But truncate it if the machine will do that. */
2348 if (arg1 < 0)
2349 return 0;
2350
2351 if (SHIFT_COUNT_TRUNCATED)
2352 arg1 %= width;
2353
2354 val = ((unsigned HOST_WIDE_INT) arg0) >> arg1;
2355 break;
2356
2357 case ASHIFT:
2358 if (arg1 < 0)
2359 return 0;
2360
2361 if (SHIFT_COUNT_TRUNCATED)
2362 arg1 %= width;
2363
2364 val = ((unsigned HOST_WIDE_INT) arg0) << arg1;
2365 break;
2366
2367 case ASHIFTRT:
2368 if (arg1 < 0)
2369 return 0;
2370
2371 if (SHIFT_COUNT_TRUNCATED)
2372 arg1 %= width;
2373
2374 val = arg0s >> arg1;
2375
2376 /* Bootstrap compiler may not have sign extended the right shift.
2377 Manually extend the sign to insure bootstrap cc matches gcc. */
2378 if (arg0s < 0 && arg1 > 0)
2379 val |= ((HOST_WIDE_INT) -1) << (HOST_BITS_PER_WIDE_INT - arg1);
2380
2381 break;
2382
2383 case ROTATERT:
2384 if (arg1 < 0)
2385 return 0;
2386
2387 arg1 %= width;
2388 val = ((((unsigned HOST_WIDE_INT) arg0) << (width - arg1))
2389 | (((unsigned HOST_WIDE_INT) arg0) >> arg1));
2390 break;
2391
2392 case ROTATE:
2393 if (arg1 < 0)
2394 return 0;
2395
2396 arg1 %= width;
2397 val = ((((unsigned HOST_WIDE_INT) arg0) << arg1)
2398 | (((unsigned HOST_WIDE_INT) arg0) >> (width - arg1)));
2399 break;
2400
2401 case COMPARE:
2402 /* Do nothing here. */
2403 return 0;
2404
2405 case SMIN:
2406 val = arg0s <= arg1s ? arg0s : arg1s;
2407 break;
2408
2409 case UMIN:
2410 val = ((unsigned HOST_WIDE_INT) arg0
2411 <= (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
2412 break;
2413
2414 case SMAX:
2415 val = arg0s > arg1s ? arg0s : arg1s;
2416 break;
2417
2418 case UMAX:
2419 val = ((unsigned HOST_WIDE_INT) arg0
2420 > (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1);
2421 break;
2422
2423 case SS_PLUS:
2424 case US_PLUS:
2425 case SS_MINUS:
2426 case US_MINUS:
2427 /* ??? There are simplifications that can be done. */
2428 return 0;
2429
2430 default:
2431 abort ();
2432 }
2433
2434 val = trunc_int_for_mode (val, mode);
2435
2436 return GEN_INT (val);
2437 }
2438 \f
2439 /* Simplify a PLUS or MINUS, at least one of whose operands may be another
2440 PLUS or MINUS.
2441
2442 Rather than test for specific case, we do this by a brute-force method
2443 and do all possible simplifications until no more changes occur. Then
2444 we rebuild the operation.
2445
2446 If FORCE is true, then always generate the rtx. This is used to
2447 canonicalize stuff emitted from simplify_gen_binary. Note that this
2448 can still fail if the rtx is too complex. It won't fail just because
2449 the result is not 'simpler' than the input, however. */
2450
2451 struct simplify_plus_minus_op_data
2452 {
2453 rtx op;
2454 int neg;
2455 };
2456
2457 static int
2458 simplify_plus_minus_op_data_cmp (const void *p1, const void *p2)
2459 {
2460 const struct simplify_plus_minus_op_data *d1 = p1;
2461 const struct simplify_plus_minus_op_data *d2 = p2;
2462
2463 return (commutative_operand_precedence (d2->op)
2464 - commutative_operand_precedence (d1->op));
2465 }
2466
2467 static rtx
2468 simplify_plus_minus (enum rtx_code code, enum machine_mode mode, rtx op0,
2469 rtx op1, int force)
2470 {
2471 struct simplify_plus_minus_op_data ops[8];
2472 rtx result, tem;
2473 int n_ops = 2, input_ops = 2, input_consts = 0, n_consts;
2474 int first, changed;
2475 int i, j;
2476
2477 memset (ops, 0, sizeof ops);
2478
2479 /* Set up the two operands and then expand them until nothing has been
2480 changed. If we run out of room in our array, give up; this should
2481 almost never happen. */
2482
2483 ops[0].op = op0;
2484 ops[0].neg = 0;
2485 ops[1].op = op1;
2486 ops[1].neg = (code == MINUS);
2487
2488 do
2489 {
2490 changed = 0;
2491
2492 for (i = 0; i < n_ops; i++)
2493 {
2494 rtx this_op = ops[i].op;
2495 int this_neg = ops[i].neg;
2496 enum rtx_code this_code = GET_CODE (this_op);
2497
2498 switch (this_code)
2499 {
2500 case PLUS:
2501 case MINUS:
2502 if (n_ops == 7)
2503 return NULL_RTX;
2504
2505 ops[n_ops].op = XEXP (this_op, 1);
2506 ops[n_ops].neg = (this_code == MINUS) ^ this_neg;
2507 n_ops++;
2508
2509 ops[i].op = XEXP (this_op, 0);
2510 input_ops++;
2511 changed = 1;
2512 break;
2513
2514 case NEG:
2515 ops[i].op = XEXP (this_op, 0);
2516 ops[i].neg = ! this_neg;
2517 changed = 1;
2518 break;
2519
2520 case CONST:
2521 if (n_ops < 7
2522 && GET_CODE (XEXP (this_op, 0)) == PLUS
2523 && CONSTANT_P (XEXP (XEXP (this_op, 0), 0))
2524 && CONSTANT_P (XEXP (XEXP (this_op, 0), 1)))
2525 {
2526 ops[i].op = XEXP (XEXP (this_op, 0), 0);
2527 ops[n_ops].op = XEXP (XEXP (this_op, 0), 1);
2528 ops[n_ops].neg = this_neg;
2529 n_ops++;
2530 input_consts++;
2531 changed = 1;
2532 }
2533 break;
2534
2535 case NOT:
2536 /* ~a -> (-a - 1) */
2537 if (n_ops != 7)
2538 {
2539 ops[n_ops].op = constm1_rtx;
2540 ops[n_ops++].neg = this_neg;
2541 ops[i].op = XEXP (this_op, 0);
2542 ops[i].neg = !this_neg;
2543 changed = 1;
2544 }
2545 break;
2546
2547 case CONST_INT:
2548 if (this_neg)
2549 {
2550 ops[i].op = neg_const_int (mode, this_op);
2551 ops[i].neg = 0;
2552 changed = 1;
2553 }
2554 break;
2555
2556 default:
2557 break;
2558 }
2559 }
2560 }
2561 while (changed);
2562
2563 /* If we only have two operands, we can't do anything. */
2564 if (n_ops <= 2 && !force)
2565 return NULL_RTX;
2566
2567 /* Count the number of CONSTs we didn't split above. */
2568 for (i = 0; i < n_ops; i++)
2569 if (GET_CODE (ops[i].op) == CONST)
2570 input_consts++;
2571
2572 /* Now simplify each pair of operands until nothing changes. The first
2573 time through just simplify constants against each other. */
2574
2575 first = 1;
2576 do
2577 {
2578 changed = first;
2579
2580 for (i = 0; i < n_ops - 1; i++)
2581 for (j = i + 1; j < n_ops; j++)
2582 {
2583 rtx lhs = ops[i].op, rhs = ops[j].op;
2584 int lneg = ops[i].neg, rneg = ops[j].neg;
2585
2586 if (lhs != 0 && rhs != 0
2587 && (! first || (CONSTANT_P (lhs) && CONSTANT_P (rhs))))
2588 {
2589 enum rtx_code ncode = PLUS;
2590
2591 if (lneg != rneg)
2592 {
2593 ncode = MINUS;
2594 if (lneg)
2595 tem = lhs, lhs = rhs, rhs = tem;
2596 }
2597 else if (swap_commutative_operands_p (lhs, rhs))
2598 tem = lhs, lhs = rhs, rhs = tem;
2599
2600 tem = simplify_binary_operation (ncode, mode, lhs, rhs);
2601
2602 /* Reject "simplifications" that just wrap the two
2603 arguments in a CONST. Failure to do so can result
2604 in infinite recursion with simplify_binary_operation
2605 when it calls us to simplify CONST operations. */
2606 if (tem
2607 && ! (GET_CODE (tem) == CONST
2608 && GET_CODE (XEXP (tem, 0)) == ncode
2609 && XEXP (XEXP (tem, 0), 0) == lhs
2610 && XEXP (XEXP (tem, 0), 1) == rhs)
2611 /* Don't allow -x + -1 -> ~x simplifications in the
2612 first pass. This allows us the chance to combine
2613 the -1 with other constants. */
2614 && ! (first
2615 && GET_CODE (tem) == NOT
2616 && XEXP (tem, 0) == rhs))
2617 {
2618 lneg &= rneg;
2619 if (GET_CODE (tem) == NEG)
2620 tem = XEXP (tem, 0), lneg = !lneg;
2621 if (GET_CODE (tem) == CONST_INT && lneg)
2622 tem = neg_const_int (mode, tem), lneg = 0;
2623
2624 ops[i].op = tem;
2625 ops[i].neg = lneg;
2626 ops[j].op = NULL_RTX;
2627 changed = 1;
2628 }
2629 }
2630 }
2631
2632 first = 0;
2633 }
2634 while (changed);
2635
2636 /* Pack all the operands to the lower-numbered entries. */
2637 for (i = 0, j = 0; j < n_ops; j++)
2638 if (ops[j].op)
2639 ops[i++] = ops[j];
2640 n_ops = i;
2641
2642 /* Sort the operations based on swap_commutative_operands_p. */
2643 qsort (ops, n_ops, sizeof (*ops), simplify_plus_minus_op_data_cmp);
2644
2645 /* Create (minus -C X) instead of (neg (const (plus X C))). */
2646 if (n_ops == 2
2647 && GET_CODE (ops[1].op) == CONST_INT
2648 && CONSTANT_P (ops[0].op)
2649 && ops[0].neg)
2650 return gen_rtx_fmt_ee (MINUS, mode, ops[1].op, ops[0].op);
2651
2652 /* We suppressed creation of trivial CONST expressions in the
2653 combination loop to avoid recursion. Create one manually now.
2654 The combination loop should have ensured that there is exactly
2655 one CONST_INT, and the sort will have ensured that it is last
2656 in the array and that any other constant will be next-to-last. */
2657
2658 if (n_ops > 1
2659 && GET_CODE (ops[n_ops - 1].op) == CONST_INT
2660 && CONSTANT_P (ops[n_ops - 2].op))
2661 {
2662 rtx value = ops[n_ops - 1].op;
2663 if (ops[n_ops - 1].neg ^ ops[n_ops - 2].neg)
2664 value = neg_const_int (mode, value);
2665 ops[n_ops - 2].op = plus_constant (ops[n_ops - 2].op, INTVAL (value));
2666 n_ops--;
2667 }
2668
2669 /* Count the number of CONSTs that we generated. */
2670 n_consts = 0;
2671 for (i = 0; i < n_ops; i++)
2672 if (GET_CODE (ops[i].op) == CONST)
2673 n_consts++;
2674
2675 /* Give up if we didn't reduce the number of operands we had. Make
2676 sure we count a CONST as two operands. If we have the same
2677 number of operands, but have made more CONSTs than before, this
2678 is also an improvement, so accept it. */
2679 if (!force
2680 && (n_ops + n_consts > input_ops
2681 || (n_ops + n_consts == input_ops && n_consts <= input_consts)))
2682 return NULL_RTX;
2683
2684 /* Put a non-negated operand first, if possible. */
2685
2686 for (i = 0; i < n_ops && ops[i].neg; i++)
2687 continue;
2688 if (i == n_ops)
2689 ops[0].op = gen_rtx_NEG (mode, ops[0].op);
2690 else if (i != 0)
2691 {
2692 tem = ops[0].op;
2693 ops[0] = ops[i];
2694 ops[i].op = tem;
2695 ops[i].neg = 1;
2696 }
2697
2698 /* Now make the result by performing the requested operations. */
2699 result = ops[0].op;
2700 for (i = 1; i < n_ops; i++)
2701 result = gen_rtx_fmt_ee (ops[i].neg ? MINUS : PLUS,
2702 mode, result, ops[i].op);
2703
2704 return result;
2705 }
2706
2707 /* Like simplify_binary_operation except used for relational operators.
2708 MODE is the mode of the result. If MODE is VOIDmode, both operands must
2709 also be VOIDmode.
2710
2711 CMP_MODE specifies in which mode the comparison is done in, so it is
2712 the mode of the operands. If CMP_MODE is VOIDmode, it is taken from
2713 the operands or, if both are VOIDmode, the operands are compared in
2714 "infinite precision". */
2715 rtx
2716 simplify_relational_operation (enum rtx_code code, enum machine_mode mode,
2717 enum machine_mode cmp_mode, rtx op0, rtx op1)
2718 {
2719 rtx tem, trueop0, trueop1;
2720
2721 if (cmp_mode == VOIDmode)
2722 cmp_mode = GET_MODE (op0);
2723 if (cmp_mode == VOIDmode)
2724 cmp_mode = GET_MODE (op1);
2725
2726 tem = simplify_const_relational_operation (code, cmp_mode, op0, op1);
2727 if (tem)
2728 {
2729 #ifdef FLOAT_STORE_FLAG_VALUE
2730 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
2731 {
2732 if (tem == const0_rtx)
2733 return CONST0_RTX (mode);
2734 else if (GET_MODE_CLASS (mode) == MODE_FLOAT)
2735 {
2736 REAL_VALUE_TYPE val;
2737 val = FLOAT_STORE_FLAG_VALUE (mode);
2738 return CONST_DOUBLE_FROM_REAL_VALUE (val, mode);
2739 }
2740 }
2741 #endif
2742
2743 return tem;
2744 }
2745
2746 /* For the following tests, ensure const0_rtx is op1. */
2747 if (swap_commutative_operands_p (op0, op1)
2748 || (op0 == const0_rtx && op1 != const0_rtx))
2749 tem = op0, op0 = op1, op1 = tem, code = swap_condition (code);
2750
2751 /* If op0 is a compare, extract the comparison arguments from it. */
2752 if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
2753 return simplify_relational_operation (code, mode, VOIDmode,
2754 XEXP (op0, 0), XEXP (op0, 1));
2755
2756 if (mode == VOIDmode
2757 || GET_MODE_CLASS (cmp_mode) == MODE_CC
2758 || CC0_P (op0))
2759 return NULL_RTX;
2760
2761 trueop0 = avoid_constant_pool_reference (op0);
2762 trueop1 = avoid_constant_pool_reference (op1);
2763 return simplify_relational_operation_1 (code, mode, cmp_mode,
2764 trueop0, trueop1);
2765 }
2766
2767 /* This part of simplify_relational_operation is only used when CMP_MODE
2768 is not in class MODE_CC (i.e. it is a real comparison).
2769
2770 MODE is the mode of the result, while CMP_MODE specifies in which
2771 mode the comparison is done in, so it is the mode of the operands. */
2772 rtx
2773 simplify_relational_operation_1 (enum rtx_code code, enum machine_mode mode,
2774 enum machine_mode cmp_mode, rtx op0, rtx op1)
2775 {
2776 if (GET_CODE (op1) == CONST_INT)
2777 {
2778 if (INTVAL (op1) == 0 && COMPARISON_P (op0))
2779 {
2780 /* If op0 is a comparison, extract the comparison arguments form it. */
2781 if (code == NE)
2782 {
2783 if (GET_MODE (op0) == cmp_mode)
2784 return simplify_rtx (op0);
2785 else
2786 return simplify_gen_relational (GET_CODE (op0), mode, VOIDmode,
2787 XEXP (op0, 0), XEXP (op0, 1));
2788 }
2789 else if (code == EQ)
2790 {
2791 enum rtx_code new_code = reversed_comparison_code (op0, NULL_RTX);
2792 if (new_code != UNKNOWN)
2793 return simplify_gen_relational (new_code, mode, VOIDmode,
2794 XEXP (op0, 0), XEXP (op0, 1));
2795 }
2796 }
2797 }
2798
2799 return NULL_RTX;
2800 }
2801
2802 /* Check if the given comparison (done in the given MODE) is actually a
2803 tautology or a contradiction.
2804 If no simplification is possible, this function returns zero.
2805 Otherwise, it returns either const_true_rtx or const0_rtx. */
2806
2807 rtx
2808 simplify_const_relational_operation (enum rtx_code code,
2809 enum machine_mode mode,
2810 rtx op0, rtx op1)
2811 {
2812 int equal, op0lt, op0ltu, op1lt, op1ltu;
2813 rtx tem;
2814 rtx trueop0;
2815 rtx trueop1;
2816
2817 if (mode == VOIDmode
2818 && (GET_MODE (op0) != VOIDmode
2819 || GET_MODE (op1) != VOIDmode))
2820 abort ();
2821
2822 /* If op0 is a compare, extract the comparison arguments from it. */
2823 if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
2824 op1 = XEXP (op0, 1), op0 = XEXP (op0, 0);
2825
2826 /* We can't simplify MODE_CC values since we don't know what the
2827 actual comparison is. */
2828 if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC || CC0_P (op0))
2829 return 0;
2830
2831 /* Make sure the constant is second. */
2832 if (swap_commutative_operands_p (op0, op1))
2833 {
2834 tem = op0, op0 = op1, op1 = tem;
2835 code = swap_condition (code);
2836 }
2837
2838 trueop0 = avoid_constant_pool_reference (op0);
2839 trueop1 = avoid_constant_pool_reference (op1);
2840
2841 /* For integer comparisons of A and B maybe we can simplify A - B and can
2842 then simplify a comparison of that with zero. If A and B are both either
2843 a register or a CONST_INT, this can't help; testing for these cases will
2844 prevent infinite recursion here and speed things up.
2845
2846 If CODE is an unsigned comparison, then we can never do this optimization,
2847 because it gives an incorrect result if the subtraction wraps around zero.
2848 ANSI C defines unsigned operations such that they never overflow, and
2849 thus such cases can not be ignored; but we cannot do it even for
2850 signed comparisons for languages such as Java, so test flag_wrapv. */
2851
2852 if (!flag_wrapv && INTEGRAL_MODE_P (mode) && trueop1 != const0_rtx
2853 && ! ((REG_P (op0) || GET_CODE (trueop0) == CONST_INT)
2854 && (REG_P (op1) || GET_CODE (trueop1) == CONST_INT))
2855 && 0 != (tem = simplify_binary_operation (MINUS, mode, op0, op1))
2856 /* We cannot do this for == or != if tem is a nonzero address. */
2857 && ((code != EQ && code != NE) || ! nonzero_address_p (tem))
2858 && code != GTU && code != GEU && code != LTU && code != LEU)
2859 return simplify_const_relational_operation (signed_condition (code),
2860 mode, tem, const0_rtx);
2861
2862 if (flag_unsafe_math_optimizations && code == ORDERED)
2863 return const_true_rtx;
2864
2865 if (flag_unsafe_math_optimizations && code == UNORDERED)
2866 return const0_rtx;
2867
2868 /* For modes without NaNs, if the two operands are equal, we know the
2869 result except if they have side-effects. */
2870 if (! HONOR_NANS (GET_MODE (trueop0))
2871 && rtx_equal_p (trueop0, trueop1)
2872 && ! side_effects_p (trueop0))
2873 equal = 1, op0lt = 0, op0ltu = 0, op1lt = 0, op1ltu = 0;
2874
2875 /* If the operands are floating-point constants, see if we can fold
2876 the result. */
2877 else if (GET_CODE (trueop0) == CONST_DOUBLE
2878 && GET_CODE (trueop1) == CONST_DOUBLE
2879 && GET_MODE_CLASS (GET_MODE (trueop0)) == MODE_FLOAT)
2880 {
2881 REAL_VALUE_TYPE d0, d1;
2882
2883 REAL_VALUE_FROM_CONST_DOUBLE (d0, trueop0);
2884 REAL_VALUE_FROM_CONST_DOUBLE (d1, trueop1);
2885
2886 /* Comparisons are unordered iff at least one of the values is NaN. */
2887 if (REAL_VALUE_ISNAN (d0) || REAL_VALUE_ISNAN (d1))
2888 switch (code)
2889 {
2890 case UNEQ:
2891 case UNLT:
2892 case UNGT:
2893 case UNLE:
2894 case UNGE:
2895 case NE:
2896 case UNORDERED:
2897 return const_true_rtx;
2898 case EQ:
2899 case LT:
2900 case GT:
2901 case LE:
2902 case GE:
2903 case LTGT:
2904 case ORDERED:
2905 return const0_rtx;
2906 default:
2907 return 0;
2908 }
2909
2910 equal = REAL_VALUES_EQUAL (d0, d1);
2911 op0lt = op0ltu = REAL_VALUES_LESS (d0, d1);
2912 op1lt = op1ltu = REAL_VALUES_LESS (d1, d0);
2913 }
2914
2915 /* Otherwise, see if the operands are both integers. */
2916 else if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode)
2917 && (GET_CODE (trueop0) == CONST_DOUBLE
2918 || GET_CODE (trueop0) == CONST_INT)
2919 && (GET_CODE (trueop1) == CONST_DOUBLE
2920 || GET_CODE (trueop1) == CONST_INT))
2921 {
2922 int width = GET_MODE_BITSIZE (mode);
2923 HOST_WIDE_INT l0s, h0s, l1s, h1s;
2924 unsigned HOST_WIDE_INT l0u, h0u, l1u, h1u;
2925
2926 /* Get the two words comprising each integer constant. */
2927 if (GET_CODE (trueop0) == CONST_DOUBLE)
2928 {
2929 l0u = l0s = CONST_DOUBLE_LOW (trueop0);
2930 h0u = h0s = CONST_DOUBLE_HIGH (trueop0);
2931 }
2932 else
2933 {
2934 l0u = l0s = INTVAL (trueop0);
2935 h0u = h0s = HWI_SIGN_EXTEND (l0s);
2936 }
2937
2938 if (GET_CODE (trueop1) == CONST_DOUBLE)
2939 {
2940 l1u = l1s = CONST_DOUBLE_LOW (trueop1);
2941 h1u = h1s = CONST_DOUBLE_HIGH (trueop1);
2942 }
2943 else
2944 {
2945 l1u = l1s = INTVAL (trueop1);
2946 h1u = h1s = HWI_SIGN_EXTEND (l1s);
2947 }
2948
2949 /* If WIDTH is nonzero and smaller than HOST_BITS_PER_WIDE_INT,
2950 we have to sign or zero-extend the values. */
2951 if (width != 0 && width < HOST_BITS_PER_WIDE_INT)
2952 {
2953 l0u &= ((HOST_WIDE_INT) 1 << width) - 1;
2954 l1u &= ((HOST_WIDE_INT) 1 << width) - 1;
2955
2956 if (l0s & ((HOST_WIDE_INT) 1 << (width - 1)))
2957 l0s |= ((HOST_WIDE_INT) (-1) << width);
2958
2959 if (l1s & ((HOST_WIDE_INT) 1 << (width - 1)))
2960 l1s |= ((HOST_WIDE_INT) (-1) << width);
2961 }
2962 if (width != 0 && width <= HOST_BITS_PER_WIDE_INT)
2963 h0u = h1u = 0, h0s = HWI_SIGN_EXTEND (l0s), h1s = HWI_SIGN_EXTEND (l1s);
2964
2965 equal = (h0u == h1u && l0u == l1u);
2966 op0lt = (h0s < h1s || (h0s == h1s && l0u < l1u));
2967 op1lt = (h1s < h0s || (h1s == h0s && l1u < l0u));
2968 op0ltu = (h0u < h1u || (h0u == h1u && l0u < l1u));
2969 op1ltu = (h1u < h0u || (h1u == h0u && l1u < l0u));
2970 }
2971
2972 /* Otherwise, there are some code-specific tests we can make. */
2973 else
2974 {
2975 /* Optimize comparisons with upper and lower bounds. */
2976 if (SCALAR_INT_MODE_P (mode)
2977 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
2978 {
2979 rtx mmin, mmax;
2980 int sign;
2981
2982 if (code == GEU
2983 || code == LEU
2984 || code == GTU
2985 || code == LTU)
2986 sign = 0;
2987 else
2988 sign = 1;
2989
2990 get_mode_bounds (mode, sign, mode, &mmin, &mmax);
2991
2992 tem = NULL_RTX;
2993 switch (code)
2994 {
2995 case GEU:
2996 case GE:
2997 /* x >= min is always true. */
2998 if (rtx_equal_p (trueop1, mmin))
2999 tem = const_true_rtx;
3000 else
3001 break;
3002
3003 case LEU:
3004 case LE:
3005 /* x <= max is always true. */
3006 if (rtx_equal_p (trueop1, mmax))
3007 tem = const_true_rtx;
3008 break;
3009
3010 case GTU:
3011 case GT:
3012 /* x > max is always false. */
3013 if (rtx_equal_p (trueop1, mmax))
3014 tem = const0_rtx;
3015 break;
3016
3017 case LTU:
3018 case LT:
3019 /* x < min is always false. */
3020 if (rtx_equal_p (trueop1, mmin))
3021 tem = const0_rtx;
3022 break;
3023
3024 default:
3025 break;
3026 }
3027 if (tem == const0_rtx
3028 || tem == const_true_rtx)
3029 return tem;
3030 }
3031
3032 switch (code)
3033 {
3034 case EQ:
3035 if (trueop1 == const0_rtx && nonzero_address_p (op0))
3036 return const0_rtx;
3037 break;
3038
3039 case NE:
3040 if (trueop1 == const0_rtx && nonzero_address_p (op0))
3041 return const_true_rtx;
3042 break;
3043
3044 case LT:
3045 /* Optimize abs(x) < 0.0. */
3046 if (trueop1 == CONST0_RTX (mode) && !HONOR_SNANS (mode))
3047 {
3048 tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3049 : trueop0;
3050 if (GET_CODE (tem) == ABS)
3051 return const0_rtx;
3052 }
3053 break;
3054
3055 case GE:
3056 /* Optimize abs(x) >= 0.0. */
3057 if (trueop1 == CONST0_RTX (mode) && !HONOR_NANS (mode))
3058 {
3059 tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3060 : trueop0;
3061 if (GET_CODE (tem) == ABS)
3062 return const_true_rtx;
3063 }
3064 break;
3065
3066 case UNGE:
3067 /* Optimize ! (abs(x) < 0.0). */
3068 if (trueop1 == CONST0_RTX (mode))
3069 {
3070 tem = GET_CODE (trueop0) == FLOAT_EXTEND ? XEXP (trueop0, 0)
3071 : trueop0;
3072 if (GET_CODE (tem) == ABS)
3073 return const_true_rtx;
3074 }
3075 break;
3076
3077 default:
3078 break;
3079 }
3080
3081 return 0;
3082 }
3083
3084 /* If we reach here, EQUAL, OP0LT, OP0LTU, OP1LT, and OP1LTU are set
3085 as appropriate. */
3086 switch (code)
3087 {
3088 case EQ:
3089 case UNEQ:
3090 return equal ? const_true_rtx : const0_rtx;
3091 case NE:
3092 case LTGT:
3093 return ! equal ? const_true_rtx : const0_rtx;
3094 case LT:
3095 case UNLT:
3096 return op0lt ? const_true_rtx : const0_rtx;
3097 case GT:
3098 case UNGT:
3099 return op1lt ? const_true_rtx : const0_rtx;
3100 case LTU:
3101 return op0ltu ? const_true_rtx : const0_rtx;
3102 case GTU:
3103 return op1ltu ? const_true_rtx : const0_rtx;
3104 case LE:
3105 case UNLE:
3106 return equal || op0lt ? const_true_rtx : const0_rtx;
3107 case GE:
3108 case UNGE:
3109 return equal || op1lt ? const_true_rtx : const0_rtx;
3110 case LEU:
3111 return equal || op0ltu ? const_true_rtx : const0_rtx;
3112 case GEU:
3113 return equal || op1ltu ? const_true_rtx : const0_rtx;
3114 case ORDERED:
3115 return const_true_rtx;
3116 case UNORDERED:
3117 return const0_rtx;
3118 default:
3119 abort ();
3120 }
3121 }
3122 \f
3123 /* Simplify CODE, an operation with result mode MODE and three operands,
3124 OP0, OP1, and OP2. OP0_MODE was the mode of OP0 before it became
3125 a constant. Return 0 if no simplifications is possible. */
3126
3127 rtx
3128 simplify_ternary_operation (enum rtx_code code, enum machine_mode mode,
3129 enum machine_mode op0_mode, rtx op0, rtx op1,
3130 rtx op2)
3131 {
3132 unsigned int width = GET_MODE_BITSIZE (mode);
3133
3134 /* VOIDmode means "infinite" precision. */
3135 if (width == 0)
3136 width = HOST_BITS_PER_WIDE_INT;
3137
3138 switch (code)
3139 {
3140 case SIGN_EXTRACT:
3141 case ZERO_EXTRACT:
3142 if (GET_CODE (op0) == CONST_INT
3143 && GET_CODE (op1) == CONST_INT
3144 && GET_CODE (op2) == CONST_INT
3145 && ((unsigned) INTVAL (op1) + (unsigned) INTVAL (op2) <= width)
3146 && width <= (unsigned) HOST_BITS_PER_WIDE_INT)
3147 {
3148 /* Extracting a bit-field from a constant */
3149 HOST_WIDE_INT val = INTVAL (op0);
3150
3151 if (BITS_BIG_ENDIAN)
3152 val >>= (GET_MODE_BITSIZE (op0_mode)
3153 - INTVAL (op2) - INTVAL (op1));
3154 else
3155 val >>= INTVAL (op2);
3156
3157 if (HOST_BITS_PER_WIDE_INT != INTVAL (op1))
3158 {
3159 /* First zero-extend. */
3160 val &= ((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1;
3161 /* If desired, propagate sign bit. */
3162 if (code == SIGN_EXTRACT
3163 && (val & ((HOST_WIDE_INT) 1 << (INTVAL (op1) - 1))))
3164 val |= ~ (((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1);
3165 }
3166
3167 /* Clear the bits that don't belong in our mode,
3168 unless they and our sign bit are all one.
3169 So we get either a reasonable negative value or a reasonable
3170 unsigned value for this mode. */
3171 if (width < HOST_BITS_PER_WIDE_INT
3172 && ((val & ((HOST_WIDE_INT) (-1) << (width - 1)))
3173 != ((HOST_WIDE_INT) (-1) << (width - 1))))
3174 val &= ((HOST_WIDE_INT) 1 << width) - 1;
3175
3176 return GEN_INT (val);
3177 }
3178 break;
3179
3180 case IF_THEN_ELSE:
3181 if (GET_CODE (op0) == CONST_INT)
3182 return op0 != const0_rtx ? op1 : op2;
3183
3184 /* Convert c ? a : a into "a". */
3185 if (rtx_equal_p (op1, op2) && ! side_effects_p (op0))
3186 return op1;
3187
3188 /* Convert a != b ? a : b into "a". */
3189 if (GET_CODE (op0) == NE
3190 && ! side_effects_p (op0)
3191 && ! HONOR_NANS (mode)
3192 && ! HONOR_SIGNED_ZEROS (mode)
3193 && ((rtx_equal_p (XEXP (op0, 0), op1)
3194 && rtx_equal_p (XEXP (op0, 1), op2))
3195 || (rtx_equal_p (XEXP (op0, 0), op2)
3196 && rtx_equal_p (XEXP (op0, 1), op1))))
3197 return op1;
3198
3199 /* Convert a == b ? a : b into "b". */
3200 if (GET_CODE (op0) == EQ
3201 && ! side_effects_p (op0)
3202 && ! HONOR_NANS (mode)
3203 && ! HONOR_SIGNED_ZEROS (mode)
3204 && ((rtx_equal_p (XEXP (op0, 0), op1)
3205 && rtx_equal_p (XEXP (op0, 1), op2))
3206 || (rtx_equal_p (XEXP (op0, 0), op2)
3207 && rtx_equal_p (XEXP (op0, 1), op1))))
3208 return op2;
3209
3210 if (COMPARISON_P (op0) && ! side_effects_p (op0))
3211 {
3212 enum machine_mode cmp_mode = (GET_MODE (XEXP (op0, 0)) == VOIDmode
3213 ? GET_MODE (XEXP (op0, 1))
3214 : GET_MODE (XEXP (op0, 0)));
3215 rtx temp;
3216
3217 /* Look for happy constants in op1 and op2. */
3218 if (GET_CODE (op1) == CONST_INT && GET_CODE (op2) == CONST_INT)
3219 {
3220 HOST_WIDE_INT t = INTVAL (op1);
3221 HOST_WIDE_INT f = INTVAL (op2);
3222
3223 if (t == STORE_FLAG_VALUE && f == 0)
3224 code = GET_CODE (op0);
3225 else if (t == 0 && f == STORE_FLAG_VALUE)
3226 {
3227 enum rtx_code tmp;
3228 tmp = reversed_comparison_code (op0, NULL_RTX);
3229 if (tmp == UNKNOWN)
3230 break;
3231 code = tmp;
3232 }
3233 else
3234 break;
3235
3236 return simplify_gen_relational (code, mode, cmp_mode,
3237 XEXP (op0, 0), XEXP (op0, 1));
3238 }
3239
3240 if (cmp_mode == VOIDmode)
3241 cmp_mode = op0_mode;
3242 temp = simplify_relational_operation (GET_CODE (op0), op0_mode,
3243 cmp_mode, XEXP (op0, 0),
3244 XEXP (op0, 1));
3245
3246 /* See if any simplifications were possible. */
3247 if (temp)
3248 {
3249 if (GET_CODE (temp) == CONST_INT)
3250 return temp == const0_rtx ? op2 : op1;
3251 else if (temp)
3252 return gen_rtx_IF_THEN_ELSE (mode, temp, op1, op2);
3253 }
3254 }
3255 break;
3256
3257 case VEC_MERGE:
3258 if (GET_MODE (op0) != mode
3259 || GET_MODE (op1) != mode
3260 || !VECTOR_MODE_P (mode))
3261 abort ();
3262 op2 = avoid_constant_pool_reference (op2);
3263 if (GET_CODE (op2) == CONST_INT)
3264 {
3265 int elt_size = GET_MODE_SIZE (GET_MODE_INNER (mode));
3266 unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
3267 int mask = (1 << n_elts) - 1;
3268
3269 if (!(INTVAL (op2) & mask))
3270 return op1;
3271 if ((INTVAL (op2) & mask) == mask)
3272 return op0;
3273
3274 op0 = avoid_constant_pool_reference (op0);
3275 op1 = avoid_constant_pool_reference (op1);
3276 if (GET_CODE (op0) == CONST_VECTOR
3277 && GET_CODE (op1) == CONST_VECTOR)
3278 {
3279 rtvec v = rtvec_alloc (n_elts);
3280 unsigned int i;
3281
3282 for (i = 0; i < n_elts; i++)
3283 RTVEC_ELT (v, i) = (INTVAL (op2) & (1 << i)
3284 ? CONST_VECTOR_ELT (op0, i)
3285 : CONST_VECTOR_ELT (op1, i));
3286 return gen_rtx_CONST_VECTOR (mode, v);
3287 }
3288 }
3289 break;
3290
3291 default:
3292 abort ();
3293 }
3294
3295 return 0;
3296 }
3297
3298 /* Evaluate a SUBREG of a CONST_INT or CONST_DOUBLE or CONST_VECTOR,
3299 returning another CONST_INT or CONST_DOUBLE or CONST_VECTOR.
3300
3301 Works by unpacking OP into a collection of 8-bit values
3302 represented as a little-endian array of 'unsigned char', selecting by BYTE,
3303 and then repacking them again for OUTERMODE. */
3304
3305 static rtx
3306 simplify_immed_subreg (enum machine_mode outermode, rtx op,
3307 enum machine_mode innermode, unsigned int byte)
3308 {
3309 /* We support up to 512-bit values (for V8DFmode). */
3310 enum {
3311 max_bitsize = 512,
3312 value_bit = 8,
3313 value_mask = (1 << value_bit) - 1
3314 };
3315 unsigned char value[max_bitsize / value_bit];
3316 int value_start;
3317 int i;
3318 int elem;
3319
3320 int num_elem;
3321 rtx * elems;
3322 int elem_bitsize;
3323 rtx result_s;
3324 rtvec result_v = NULL;
3325 enum mode_class outer_class;
3326 enum machine_mode outer_submode;
3327
3328 /* Some ports misuse CCmode. */
3329 if (GET_MODE_CLASS (outermode) == MODE_CC && GET_CODE (op) == CONST_INT)
3330 return op;
3331
3332 /* Unpack the value. */
3333
3334 if (GET_CODE (op) == CONST_VECTOR)
3335 {
3336 num_elem = CONST_VECTOR_NUNITS (op);
3337 elems = &CONST_VECTOR_ELT (op, 0);
3338 elem_bitsize = GET_MODE_BITSIZE (GET_MODE_INNER (innermode));
3339 }
3340 else
3341 {
3342 num_elem = 1;
3343 elems = &op;
3344 elem_bitsize = max_bitsize;
3345 }
3346
3347 if (BITS_PER_UNIT % value_bit != 0)
3348 abort (); /* Too complicated; reducing value_bit may help. */
3349 if (elem_bitsize % BITS_PER_UNIT != 0)
3350 abort (); /* I don't know how to handle endianness of sub-units. */
3351
3352 for (elem = 0; elem < num_elem; elem++)
3353 {
3354 unsigned char * vp;
3355 rtx el = elems[elem];
3356
3357 /* Vectors are kept in target memory order. (This is probably
3358 a mistake.) */
3359 {
3360 unsigned byte = (elem * elem_bitsize) / BITS_PER_UNIT;
3361 unsigned ibyte = (((num_elem - 1 - elem) * elem_bitsize)
3362 / BITS_PER_UNIT);
3363 unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
3364 unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
3365 unsigned bytele = (subword_byte % UNITS_PER_WORD
3366 + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
3367 vp = value + (bytele * BITS_PER_UNIT) / value_bit;
3368 }
3369
3370 switch (GET_CODE (el))
3371 {
3372 case CONST_INT:
3373 for (i = 0;
3374 i < HOST_BITS_PER_WIDE_INT && i < elem_bitsize;
3375 i += value_bit)
3376 *vp++ = INTVAL (el) >> i;
3377 /* CONST_INTs are always logically sign-extended. */
3378 for (; i < elem_bitsize; i += value_bit)
3379 *vp++ = INTVAL (el) < 0 ? -1 : 0;
3380 break;
3381
3382 case CONST_DOUBLE:
3383 if (GET_MODE (el) == VOIDmode)
3384 {
3385 /* If this triggers, someone should have generated a
3386 CONST_INT instead. */
3387 if (elem_bitsize <= HOST_BITS_PER_WIDE_INT)
3388 abort ();
3389
3390 for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
3391 *vp++ = CONST_DOUBLE_LOW (el) >> i;
3392 while (i < HOST_BITS_PER_WIDE_INT * 2 && i < elem_bitsize)
3393 {
3394 *vp++
3395 = CONST_DOUBLE_HIGH (el) >> (i - HOST_BITS_PER_WIDE_INT);
3396 i += value_bit;
3397 }
3398 /* It shouldn't matter what's done here, so fill it with
3399 zero. */
3400 for (; i < max_bitsize; i += value_bit)
3401 *vp++ = 0;
3402 }
3403 else if (GET_MODE_CLASS (GET_MODE (el)) == MODE_FLOAT)
3404 {
3405 long tmp[max_bitsize / 32];
3406 int bitsize = GET_MODE_BITSIZE (GET_MODE (el));
3407
3408 if (bitsize > elem_bitsize)
3409 abort ();
3410 if (bitsize % value_bit != 0)
3411 abort ();
3412
3413 real_to_target (tmp, CONST_DOUBLE_REAL_VALUE (el),
3414 GET_MODE (el));
3415
3416 /* real_to_target produces its result in words affected by
3417 FLOAT_WORDS_BIG_ENDIAN. However, we ignore this,
3418 and use WORDS_BIG_ENDIAN instead; see the documentation
3419 of SUBREG in rtl.texi. */
3420 for (i = 0; i < bitsize; i += value_bit)
3421 {
3422 int ibase;
3423 if (WORDS_BIG_ENDIAN)
3424 ibase = bitsize - 1 - i;
3425 else
3426 ibase = i;
3427 *vp++ = tmp[ibase / 32] >> i % 32;
3428 }
3429
3430 /* It shouldn't matter what's done here, so fill it with
3431 zero. */
3432 for (; i < elem_bitsize; i += value_bit)
3433 *vp++ = 0;
3434 }
3435 else
3436 abort ();
3437 break;
3438
3439 default:
3440 abort ();
3441 }
3442 }
3443
3444 /* Now, pick the right byte to start with. */
3445 /* Renumber BYTE so that the least-significant byte is byte 0. A special
3446 case is paradoxical SUBREGs, which shouldn't be adjusted since they
3447 will already have offset 0. */
3448 if (GET_MODE_SIZE (innermode) >= GET_MODE_SIZE (outermode))
3449 {
3450 unsigned ibyte = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode)
3451 - byte);
3452 unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
3453 unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
3454 byte = (subword_byte % UNITS_PER_WORD
3455 + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
3456 }
3457
3458 /* BYTE should still be inside OP. (Note that BYTE is unsigned,
3459 so if it's become negative it will instead be very large.) */
3460 if (byte >= GET_MODE_SIZE (innermode))
3461 abort ();
3462
3463 /* Convert from bytes to chunks of size value_bit. */
3464 value_start = byte * (BITS_PER_UNIT / value_bit);
3465
3466 /* Re-pack the value. */
3467
3468 if (VECTOR_MODE_P (outermode))
3469 {
3470 num_elem = GET_MODE_NUNITS (outermode);
3471 result_v = rtvec_alloc (num_elem);
3472 elems = &RTVEC_ELT (result_v, 0);
3473 outer_submode = GET_MODE_INNER (outermode);
3474 }
3475 else
3476 {
3477 num_elem = 1;
3478 elems = &result_s;
3479 outer_submode = outermode;
3480 }
3481
3482 outer_class = GET_MODE_CLASS (outer_submode);
3483 elem_bitsize = GET_MODE_BITSIZE (outer_submode);
3484
3485 if (elem_bitsize % value_bit != 0)
3486 abort ();
3487 if (elem_bitsize + value_start * value_bit > max_bitsize)
3488 abort ();
3489
3490 for (elem = 0; elem < num_elem; elem++)
3491 {
3492 unsigned char *vp;
3493
3494 /* Vectors are stored in target memory order. (This is probably
3495 a mistake.) */
3496 {
3497 unsigned byte = (elem * elem_bitsize) / BITS_PER_UNIT;
3498 unsigned ibyte = (((num_elem - 1 - elem) * elem_bitsize)
3499 / BITS_PER_UNIT);
3500 unsigned word_byte = WORDS_BIG_ENDIAN ? ibyte : byte;
3501 unsigned subword_byte = BYTES_BIG_ENDIAN ? ibyte : byte;
3502 unsigned bytele = (subword_byte % UNITS_PER_WORD
3503 + (word_byte / UNITS_PER_WORD) * UNITS_PER_WORD);
3504 vp = value + value_start + (bytele * BITS_PER_UNIT) / value_bit;
3505 }
3506
3507 switch (outer_class)
3508 {
3509 case MODE_INT:
3510 case MODE_PARTIAL_INT:
3511 {
3512 unsigned HOST_WIDE_INT hi = 0, lo = 0;
3513
3514 for (i = 0;
3515 i < HOST_BITS_PER_WIDE_INT && i < elem_bitsize;
3516 i += value_bit)
3517 lo |= (HOST_WIDE_INT)(*vp++ & value_mask) << i;
3518 for (; i < elem_bitsize; i += value_bit)
3519 hi |= ((HOST_WIDE_INT)(*vp++ & value_mask)
3520 << (i - HOST_BITS_PER_WIDE_INT));
3521
3522 /* immed_double_const doesn't call trunc_int_for_mode. I don't
3523 know why. */
3524 if (elem_bitsize <= HOST_BITS_PER_WIDE_INT)
3525 elems[elem] = gen_int_mode (lo, outer_submode);
3526 else
3527 elems[elem] = immed_double_const (lo, hi, outer_submode);
3528 }
3529 break;
3530
3531 case MODE_FLOAT:
3532 {
3533 REAL_VALUE_TYPE r;
3534 long tmp[max_bitsize / 32];
3535
3536 /* real_from_target wants its input in words affected by
3537 FLOAT_WORDS_BIG_ENDIAN. However, we ignore this,
3538 and use WORDS_BIG_ENDIAN instead; see the documentation
3539 of SUBREG in rtl.texi. */
3540 for (i = 0; i < max_bitsize / 32; i++)
3541 tmp[i] = 0;
3542 for (i = 0; i < elem_bitsize; i += value_bit)
3543 {
3544 int ibase;
3545 if (WORDS_BIG_ENDIAN)
3546 ibase = elem_bitsize - 1 - i;
3547 else
3548 ibase = i;
3549 tmp[ibase / 32] |= (*vp++ & value_mask) << i % 32;
3550 }
3551
3552 real_from_target (&r, tmp, outer_submode);
3553 elems[elem] = CONST_DOUBLE_FROM_REAL_VALUE (r, outer_submode);
3554 }
3555 break;
3556
3557 default:
3558 abort ();
3559 }
3560 }
3561 if (VECTOR_MODE_P (outermode))
3562 return gen_rtx_CONST_VECTOR (outermode, result_v);
3563 else
3564 return result_s;
3565 }
3566
3567 /* Simplify SUBREG:OUTERMODE(OP:INNERMODE, BYTE)
3568 Return 0 if no simplifications are possible. */
3569 rtx
3570 simplify_subreg (enum machine_mode outermode, rtx op,
3571 enum machine_mode innermode, unsigned int byte)
3572 {
3573 /* Little bit of sanity checking. */
3574 if (innermode == VOIDmode || outermode == VOIDmode
3575 || innermode == BLKmode || outermode == BLKmode)
3576 abort ();
3577
3578 if (GET_MODE (op) != innermode
3579 && GET_MODE (op) != VOIDmode)
3580 abort ();
3581
3582 if (byte % GET_MODE_SIZE (outermode)
3583 || byte >= GET_MODE_SIZE (innermode))
3584 abort ();
3585
3586 if (outermode == innermode && !byte)
3587 return op;
3588
3589 if (GET_CODE (op) == CONST_INT
3590 || GET_CODE (op) == CONST_DOUBLE
3591 || GET_CODE (op) == CONST_VECTOR)
3592 return simplify_immed_subreg (outermode, op, innermode, byte);
3593
3594 /* Changing mode twice with SUBREG => just change it once,
3595 or not at all if changing back op starting mode. */
3596 if (GET_CODE (op) == SUBREG)
3597 {
3598 enum machine_mode innermostmode = GET_MODE (SUBREG_REG (op));
3599 int final_offset = byte + SUBREG_BYTE (op);
3600 rtx newx;
3601
3602 if (outermode == innermostmode
3603 && byte == 0 && SUBREG_BYTE (op) == 0)
3604 return SUBREG_REG (op);
3605
3606 /* The SUBREG_BYTE represents offset, as if the value were stored
3607 in memory. Irritating exception is paradoxical subreg, where
3608 we define SUBREG_BYTE to be 0. On big endian machines, this
3609 value should be negative. For a moment, undo this exception. */
3610 if (byte == 0 && GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
3611 {
3612 int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
3613 if (WORDS_BIG_ENDIAN)
3614 final_offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3615 if (BYTES_BIG_ENDIAN)
3616 final_offset += difference % UNITS_PER_WORD;
3617 }
3618 if (SUBREG_BYTE (op) == 0
3619 && GET_MODE_SIZE (innermostmode) < GET_MODE_SIZE (innermode))
3620 {
3621 int difference = (GET_MODE_SIZE (innermostmode) - GET_MODE_SIZE (innermode));
3622 if (WORDS_BIG_ENDIAN)
3623 final_offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3624 if (BYTES_BIG_ENDIAN)
3625 final_offset += difference % UNITS_PER_WORD;
3626 }
3627
3628 /* See whether resulting subreg will be paradoxical. */
3629 if (GET_MODE_SIZE (innermostmode) > GET_MODE_SIZE (outermode))
3630 {
3631 /* In nonparadoxical subregs we can't handle negative offsets. */
3632 if (final_offset < 0)
3633 return NULL_RTX;
3634 /* Bail out in case resulting subreg would be incorrect. */
3635 if (final_offset % GET_MODE_SIZE (outermode)
3636 || (unsigned) final_offset >= GET_MODE_SIZE (innermostmode))
3637 return NULL_RTX;
3638 }
3639 else
3640 {
3641 int offset = 0;
3642 int difference = (GET_MODE_SIZE (innermostmode) - GET_MODE_SIZE (outermode));
3643
3644 /* In paradoxical subreg, see if we are still looking on lower part.
3645 If so, our SUBREG_BYTE will be 0. */
3646 if (WORDS_BIG_ENDIAN)
3647 offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3648 if (BYTES_BIG_ENDIAN)
3649 offset += difference % UNITS_PER_WORD;
3650 if (offset == final_offset)
3651 final_offset = 0;
3652 else
3653 return NULL_RTX;
3654 }
3655
3656 /* Recurse for further possible simplifications. */
3657 newx = simplify_subreg (outermode, SUBREG_REG (op),
3658 GET_MODE (SUBREG_REG (op)),
3659 final_offset);
3660 if (newx)
3661 return newx;
3662 return gen_rtx_SUBREG (outermode, SUBREG_REG (op), final_offset);
3663 }
3664
3665 /* SUBREG of a hard register => just change the register number
3666 and/or mode. If the hard register is not valid in that mode,
3667 suppress this simplification. If the hard register is the stack,
3668 frame, or argument pointer, leave this as a SUBREG. */
3669
3670 if (REG_P (op)
3671 && REGNO (op) < FIRST_PSEUDO_REGISTER
3672 #ifdef CANNOT_CHANGE_MODE_CLASS
3673 && ! (REG_CANNOT_CHANGE_MODE_P (REGNO (op), innermode, outermode)
3674 && GET_MODE_CLASS (innermode) != MODE_COMPLEX_INT
3675 && GET_MODE_CLASS (innermode) != MODE_COMPLEX_FLOAT)
3676 #endif
3677 && ((reload_completed && !frame_pointer_needed)
3678 || (REGNO (op) != FRAME_POINTER_REGNUM
3679 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
3680 && REGNO (op) != HARD_FRAME_POINTER_REGNUM
3681 #endif
3682 ))
3683 #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
3684 && REGNO (op) != ARG_POINTER_REGNUM
3685 #endif
3686 && REGNO (op) != STACK_POINTER_REGNUM
3687 && subreg_offset_representable_p (REGNO (op), innermode,
3688 byte, outermode))
3689 {
3690 rtx tem = gen_rtx_SUBREG (outermode, op, byte);
3691 int final_regno = subreg_hard_regno (tem, 0);
3692
3693 /* ??? We do allow it if the current REG is not valid for
3694 its mode. This is a kludge to work around how float/complex
3695 arguments are passed on 32-bit SPARC and should be fixed. */
3696 if (HARD_REGNO_MODE_OK (final_regno, outermode)
3697 || ! HARD_REGNO_MODE_OK (REGNO (op), innermode))
3698 {
3699 rtx x = gen_rtx_REG_offset (op, outermode, final_regno, byte);
3700
3701 /* Propagate original regno. We don't have any way to specify
3702 the offset inside original regno, so do so only for lowpart.
3703 The information is used only by alias analysis that can not
3704 grog partial register anyway. */
3705
3706 if (subreg_lowpart_offset (outermode, innermode) == byte)
3707 ORIGINAL_REGNO (x) = ORIGINAL_REGNO (op);
3708 return x;
3709 }
3710 }
3711
3712 /* If we have a SUBREG of a register that we are replacing and we are
3713 replacing it with a MEM, make a new MEM and try replacing the
3714 SUBREG with it. Don't do this if the MEM has a mode-dependent address
3715 or if we would be widening it. */
3716
3717 if (MEM_P (op)
3718 && ! mode_dependent_address_p (XEXP (op, 0))
3719 /* Allow splitting of volatile memory references in case we don't
3720 have instruction to move the whole thing. */
3721 && (! MEM_VOLATILE_P (op)
3722 || ! have_insn_for (SET, innermode))
3723 && GET_MODE_SIZE (outermode) <= GET_MODE_SIZE (GET_MODE (op)))
3724 return adjust_address_nv (op, outermode, byte);
3725
3726 /* Handle complex values represented as CONCAT
3727 of real and imaginary part. */
3728 if (GET_CODE (op) == CONCAT)
3729 {
3730 int is_realpart = byte < (unsigned int) GET_MODE_UNIT_SIZE (innermode);
3731 rtx part = is_realpart ? XEXP (op, 0) : XEXP (op, 1);
3732 unsigned int final_offset;
3733 rtx res;
3734
3735 final_offset = byte % (GET_MODE_UNIT_SIZE (innermode));
3736 res = simplify_subreg (outermode, part, GET_MODE (part), final_offset);
3737 if (res)
3738 return res;
3739 /* We can at least simplify it by referring directly to the
3740 relevant part. */
3741 return gen_rtx_SUBREG (outermode, part, final_offset);
3742 }
3743
3744 /* Optimize SUBREG truncations of zero and sign extended values. */
3745 if ((GET_CODE (op) == ZERO_EXTEND
3746 || GET_CODE (op) == SIGN_EXTEND)
3747 && GET_MODE_BITSIZE (outermode) < GET_MODE_BITSIZE (innermode))
3748 {
3749 unsigned int bitpos = subreg_lsb_1 (outermode, innermode, byte);
3750
3751 /* If we're requesting the lowpart of a zero or sign extension,
3752 there are three possibilities. If the outermode is the same
3753 as the origmode, we can omit both the extension and the subreg.
3754 If the outermode is not larger than the origmode, we can apply
3755 the truncation without the extension. Finally, if the outermode
3756 is larger than the origmode, but both are integer modes, we
3757 can just extend to the appropriate mode. */
3758 if (bitpos == 0)
3759 {
3760 enum machine_mode origmode = GET_MODE (XEXP (op, 0));
3761 if (outermode == origmode)
3762 return XEXP (op, 0);
3763 if (GET_MODE_BITSIZE (outermode) <= GET_MODE_BITSIZE (origmode))
3764 return simplify_gen_subreg (outermode, XEXP (op, 0), origmode,
3765 subreg_lowpart_offset (outermode,
3766 origmode));
3767 if (SCALAR_INT_MODE_P (outermode))
3768 return simplify_gen_unary (GET_CODE (op), outermode,
3769 XEXP (op, 0), origmode);
3770 }
3771
3772 /* A SUBREG resulting from a zero extension may fold to zero if
3773 it extracts higher bits that the ZERO_EXTEND's source bits. */
3774 if (GET_CODE (op) == ZERO_EXTEND
3775 && bitpos >= GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0))))
3776 return CONST0_RTX (outermode);
3777 }
3778
3779 return NULL_RTX;
3780 }
3781
3782 /* Make a SUBREG operation or equivalent if it folds. */
3783
3784 rtx
3785 simplify_gen_subreg (enum machine_mode outermode, rtx op,
3786 enum machine_mode innermode, unsigned int byte)
3787 {
3788 rtx newx;
3789 /* Little bit of sanity checking. */
3790 if (innermode == VOIDmode || outermode == VOIDmode
3791 || innermode == BLKmode || outermode == BLKmode)
3792 abort ();
3793
3794 if (GET_MODE (op) != innermode
3795 && GET_MODE (op) != VOIDmode)
3796 abort ();
3797
3798 if (byte % GET_MODE_SIZE (outermode)
3799 || byte >= GET_MODE_SIZE (innermode))
3800 abort ();
3801
3802 newx = simplify_subreg (outermode, op, innermode, byte);
3803 if (newx)
3804 return newx;
3805
3806 if (GET_CODE (op) == SUBREG || GET_MODE (op) == VOIDmode)
3807 return NULL_RTX;
3808
3809 return gen_rtx_SUBREG (outermode, op, byte);
3810 }
3811 /* Simplify X, an rtx expression.
3812
3813 Return the simplified expression or NULL if no simplifications
3814 were possible.
3815
3816 This is the preferred entry point into the simplification routines;
3817 however, we still allow passes to call the more specific routines.
3818
3819 Right now GCC has three (yes, three) major bodies of RTL simplification
3820 code that need to be unified.
3821
3822 1. fold_rtx in cse.c. This code uses various CSE specific
3823 information to aid in RTL simplification.
3824
3825 2. simplify_rtx in combine.c. Similar to fold_rtx, except that
3826 it uses combine specific information to aid in RTL
3827 simplification.
3828
3829 3. The routines in this file.
3830
3831
3832 Long term we want to only have one body of simplification code; to
3833 get to that state I recommend the following steps:
3834
3835 1. Pour over fold_rtx & simplify_rtx and move any simplifications
3836 which are not pass dependent state into these routines.
3837
3838 2. As code is moved by #1, change fold_rtx & simplify_rtx to
3839 use this routine whenever possible.
3840
3841 3. Allow for pass dependent state to be provided to these
3842 routines and add simplifications based on the pass dependent
3843 state. Remove code from cse.c & combine.c that becomes
3844 redundant/dead.
3845
3846 It will take time, but ultimately the compiler will be easier to
3847 maintain and improve. It's totally silly that when we add a
3848 simplification that it needs to be added to 4 places (3 for RTL
3849 simplification and 1 for tree simplification. */
3850
3851 rtx
3852 simplify_rtx (rtx x)
3853 {
3854 enum rtx_code code = GET_CODE (x);
3855 enum machine_mode mode = GET_MODE (x);
3856
3857 switch (GET_RTX_CLASS (code))
3858 {
3859 case RTX_UNARY:
3860 return simplify_unary_operation (code, mode,
3861 XEXP (x, 0), GET_MODE (XEXP (x, 0)));
3862 case RTX_COMM_ARITH:
3863 if (swap_commutative_operands_p (XEXP (x, 0), XEXP (x, 1)))
3864 return simplify_gen_binary (code, mode, XEXP (x, 1), XEXP (x, 0));
3865
3866 /* Fall through.... */
3867
3868 case RTX_BIN_ARITH:
3869 return simplify_binary_operation (code, mode, XEXP (x, 0), XEXP (x, 1));
3870
3871 case RTX_TERNARY:
3872 case RTX_BITFIELD_OPS:
3873 return simplify_ternary_operation (code, mode, GET_MODE (XEXP (x, 0)),
3874 XEXP (x, 0), XEXP (x, 1),
3875 XEXP (x, 2));
3876
3877 case RTX_COMPARE:
3878 case RTX_COMM_COMPARE:
3879 return simplify_relational_operation (code, mode,
3880 ((GET_MODE (XEXP (x, 0))
3881 != VOIDmode)
3882 ? GET_MODE (XEXP (x, 0))
3883 : GET_MODE (XEXP (x, 1))),
3884 XEXP (x, 0),
3885 XEXP (x, 1));
3886
3887 case RTX_EXTRA:
3888 if (code == SUBREG)
3889 return simplify_gen_subreg (mode, SUBREG_REG (x),
3890 GET_MODE (SUBREG_REG (x)),
3891 SUBREG_BYTE (x));
3892 break;
3893
3894 case RTX_OBJ:
3895 if (code == LO_SUM)
3896 {
3897 /* Convert (lo_sum (high FOO) FOO) to FOO. */
3898 if (GET_CODE (XEXP (x, 0)) == HIGH
3899 && rtx_equal_p (XEXP (XEXP (x, 0), 0), XEXP (x, 1)))
3900 return XEXP (x, 1);
3901 }
3902 break;
3903
3904 default:
3905 break;
3906 }
3907 return NULL;
3908 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org